C++ CCECBusDevice::GetLogicalAddress方法代码示例

bool CSLCommandHandler::InitHandler(void)
{
  if (m_bHandlerInited)
    return true;
  m_bHandlerInited = true;

  if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
    return true;

  CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
  {
    /* imitate LG devices */
    if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
    {
      primary->SetVendorId(CEC_VENDOR_LG);
      primary->ReplaceHandler(false);
    }

    if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
    {
      /* start as 'in transition standby->on' */
      primary->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
      primary->TransmitPowerState(CECDEVICE_TV, false);

      /* send the vendor id */
      primary->TransmitVendorID(CECDEVICE_BROADCAST, false, false);
    }
  }

  return true;
}

bool CRLCommandHandler::InitHandler(void)
{
  if (m_bHandlerInited)
    return true;
  m_bHandlerInited = true;

  if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
    return true;

  CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
  {
    /* imitate Toshiba devices */
    if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
    {
      primary->SetVendorId(CEC_VENDOR_TOSHIBA);
      primary->ReplaceHandler(false);
    }

    if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
    {
      /* send the vendor id */
      primary->TransmitVendorID(CECDEVICE_BROADCAST, false, false);
    }
  }

  return true;
}

bool CVLCommandHandler::InitHandler(void)
{
  CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
  {
    /* use the VL commandhandler for the primary device that is handled by libCEC */
    if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
    {
      if (primary && m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
      {
        libcec_configuration config;
        m_processor->GetPrimaryClient()->GetCurrentConfiguration(config);
        if (config.iDoubleTapTimeoutMs == 0)
        {
          config.iDoubleTapTimeoutMs = CEC_DOUBLE_TAP_TIMEOUT_MS;
          m_processor->GetPrimaryClient()->SetConfiguration(config);
        }

        primary->SetVendorId(CEC_VENDOR_PANASONIC);
        primary->ReplaceHandler(false);
      }

      if (primary->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
        return m_processor->GetPrimaryClient()->ChangeDeviceType(CEC_DEVICE_TYPE_RECORDING_DEVICE, CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
    }
  }

  return CCECCommandHandler::InitHandler();
}

void CSLCommandHandler::HandleVendorCommandSLConnect(const cec_command &command)
{
  m_bSLEnabled = true;
  SetLGDeckStatus();

  CCECBusDevice *primary = m_processor->GetPrimaryDevice();

  primary->SetActiveSource();
  TransmitImageViewOn(primary->GetLogicalAddress(), command.initiator);
  TransmitVendorCommand05(primary->GetLogicalAddress(), command.initiator);
}

bool CPHCommandHandler::InitHandler(void)
{
  CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
  {
    //XXX hack to use this handler for the primary device
    if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV &&
        primary && m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
    {
      primary->SetVendorId(CEC_VENDOR_PHILIPS);
      primary->ReplaceHandler(false);
    }
  }

  return CCECCommandHandler::InitHandler();
}

uint8_t CCECClient::SendMuteAudio(void)
{
  CCECBusDevice *device = GetPrimaryDevice();
  CCECAudioSystem *audio = m_processor->GetAudioSystem();

  return device && audio && audio->IsPresent() ?
      audio->MuteAudio(device->GetLogicalAddress()) :
      (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
}

uint8_t CCECClient::SendVolumeDown(bool bSendRelease /* = true */)
{
  CCECBusDevice *device = GetPrimaryDevice();
  CCECAudioSystem *audio = m_processor->GetAudioSystem();

  return device && audio && audio->IsPresent() ?
      audio->VolumeDown(device->GetLogicalAddress(), bSendRelease) :
      (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
}

int CSLCommandHandler::HandleDeviceVendorId(const cec_command &command)
{
  SetVendorId(command);

  if (!SLInitialised() && command.initiator == CECDEVICE_TV)
  {
    CCECBusDevice *destination = m_processor->GetDevice(command.destination);
    if (destination && (destination->GetLogicalAddress() == CECDEVICE_BROADCAST || destination->IsHandledByLibCEC()))
    {
      cec_logical_address initiator = destination->GetLogicalAddress();
      if (initiator == CECDEVICE_BROADCAST)
        initiator = m_processor->GetPrimaryDevice()->GetLogicalAddress();

      cec_command response;
      cec_command::Format(response, initiator, command.initiator, CEC_OPCODE_FEATURE_ABORT);
      Transmit(response, false, true);
      return COMMAND_HANDLED;
    }
  }

  return CCECCommandHandler::HandleDeviceVendorId(command);
}

bool CSLCommandHandler::InitHandler(void)
{
  if (m_bHandlerInited)
    return true;
  m_bHandlerInited = true;

  /* reply with LGs vendor id */
  CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
    primary->TransmitVendorID(CECDEVICE_TV, false);

  primary->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
  return true;
}

void CSLCommandHandler::HandleVendorCommandPowerOn(const cec_command &command)
{
  CCECBusDevice *device = m_processor->GetPrimaryDevice();
  if (device)
  {
    m_bSLEnabled = true;

    device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON); //XXX
    device->TransmitPowerState(command.initiator);
    device->SetPowerStatus(CEC_POWER_STATUS_ON);

    SetLGDeckStatus();
    device->SetActiveSource();
    TransmitImageViewOn(device->GetLogicalAddress(), command.initiator);
  }
}

cec_logical_address CCECProcessor::GetActiveSource(bool bRequestActiveSource /* = true */)
{
  // get the device that is marked as active source from the device map
  CCECBusDevice *activeSource = m_busDevices->GetActiveSource();
  if (activeSource)
    return activeSource->GetLogicalAddress();

  if (bRequestActiveSource)
  {
    // request the active source from the bus
    CCECBusDevice *primary = GetPrimaryDevice();
    if (primary)
    {
      primary->RequestActiveSource();
      return GetActiveSource(false);
    }
  }

  // unknown or none
  return CECDEVICE_UNKNOWN;
}

CSLCommandHandler::CSLCommandHandler(CCECBusDevice *busDevice) :
    CCECCommandHandler(busDevice),
    m_bAwaitingReceiveFailed(false),
    m_bSLEnabled(false),
    m_bPowerStateReset(false)
{
  CCECBusDevice *primary = m_processor->GetPrimaryDevice();

  /* imitate LG devices */
  if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
    primary->SetVendorId(CEC_VENDOR_LG, false);
  SetLGDeckStatus();

  /* LG TVs don't always reply to CEC version requests, so just set it to 1.3a */
  if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
    m_busDevice->SetCecVersion(CEC_VERSION_1_3A);

  /* LG devices always return "korean" as language */
  cec_menu_language lang;
  lang.device = m_busDevice->GetLogicalAddress();
  snprintf(lang.language, 4, "eng");
  m_busDevice->SetMenuLanguage(lang);
}

bool CCECBusDevice::ReplaceHandler(bool bActivateSource /* = true */)
{
  if (m_iLogicalAddress == CECDEVICE_BROADCAST)
    return false;

  bool bInitHandler(false);
  {
    CLockObject lock(m_mutex);
    CLockObject handlerLock(m_handlerMutex);
    if (m_iHandlerUseCount > 0)
      return false;

    MarkBusy();

    if (m_vendor != m_handler->GetVendorId())
    {
      if (CCECCommandHandler::HasSpecificHandler(m_vendor))
      {
        LIB_CEC->AddLog(CEC_LOG_DEBUG, "replacing the command handler for device '%s' (%x)", GetLogicalAddressName(), GetLogicalAddress());

        int32_t iTransmitTimeout     = m_handler->m_iTransmitTimeout;
        int32_t iTransmitWait        = m_handler->m_iTransmitWait;
        int8_t  iTransmitRetries     = m_handler->m_iTransmitRetries;
        int64_t iActiveSourcePending = m_handler->m_iActiveSourcePending;

        SAFE_DELETE(m_handler);

        switch (m_vendor)
        {
        case CEC_VENDOR_SAMSUNG:
          m_handler = new CANCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_LG:
          m_handler = new CSLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_PANASONIC:
          m_handler = new CVLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_PHILIPS:
          m_handler = new CPHCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_TOSHIBA:
        case CEC_VENDOR_TOSHIBA2:
          m_handler = new CRLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_ONKYO:
          m_handler = new CRHCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        case CEC_VENDOR_SHARP:
        case CEC_VENDOR_SHARP2:
          m_handler = new CAQCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        default:
          m_handler = new CCECCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
          break;
        }

        /** override the vendor ID set in the handler, as a single vendor may have multiple IDs */
        m_handler->SetVendorId(m_vendor);
        bInitHandler = true;
      }
    }
  }

  if (bInitHandler)
  {
    CCECBusDevice *primary = GetProcessor()->GetPrimaryDevice();
    if (primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
    {
      m_handler->InitHandler();

      if (bActivateSource && IsHandledByLibCEC() && IsActiveSource())
        m_handler->ActivateSource();
    }
  }

  MarkReady();

  return true;
}