X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2Fdevices%2FCECBusDevice.cpp;h=5b9d421bd25c2dea260092887eb04c624d405658;hb=2ee922ad2f1812c74f2aa6e61305fdcc5c27de53;hp=1ea78d72fdf0d6418b9cd3d22f1903b479d770a1;hpb=b64db02edf638da604a1b7042ff3af6347f228d4;p=deb_libcec.git diff --git a/src/lib/devices/CECBusDevice.cpp b/src/lib/devices/CECBusDevice.cpp index 1ea78d7..c9699d8 100644 --- a/src/lib/devices/CECBusDevice.cpp +++ b/src/lib/devices/CECBusDevice.cpp @@ -1,7 +1,7 @@ /* * This file is part of the libCEC(R) library. * - * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved. + * libCEC(R) is Copyright (C) 2011-2013 Pulse-Eight Limited. All rights reserved. * libCEC(R) is an original work, containing original code. * * libCEC(R) is a trademark of Pulse-Eight Limited. @@ -30,33 +30,126 @@ * http://www.pulse-eight.net/ */ +#include "env.h" #include "CECBusDevice.h" -#include "../CECProcessor.h" -#include "../implementations/ANCommandHandler.h" -#include "../implementations/CECCommandHandler.h" -#include "../implementations/SLCommandHandler.h" -#include "../implementations/VLCommandHandler.h" -#include "../platform/timeutils.h" +#include "lib/CECProcessor.h" +#include "lib/CECClient.h" +#include "lib/implementations/ANCommandHandler.h" +#include "lib/implementations/CECCommandHandler.h" +#include "lib/implementations/SLCommandHandler.h" +#include "lib/implementations/VLCommandHandler.h" +#include "lib/implementations/PHCommandHandler.h" +#include "lib/implementations/RLCommandHandler.h" +#include "lib/implementations/RHCommandHandler.h" +#include "lib/implementations/AQCommandHandler.h" +#include "lib/LibCEC.h" +#include "lib/CECTypeUtils.h" +#include "lib/platform/util/timeutils.h" +#include "lib/platform/util/util.h" + +#include "CECAudioSystem.h" +#include "CECPlaybackDevice.h" +#include "CECRecordingDevice.h" +#include "CECTuner.h" +#include "CECTV.h" + +using namespace std; using namespace CEC; +using namespace PLATFORM; -#define ToString(p) m_processor->ToString(p) - -CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress) : - m_type(CEC_DEVICE_TYPE_RESERVED), - m_iPhysicalAddress(iPhysicalAddress), - m_iStreamPath(0), - m_iLogicalAddress(iLogicalAddress), - m_powerStatus(CEC_POWER_STATUS_UNKNOWN), - m_processor(processor), - m_vendor(CEC_VENDOR_UNKNOWN), - m_bReplaceHandler(false), - m_menuState(CEC_MENU_STATE_ACTIVATED), - m_bActiveSource(false), - m_iLastActive(0), - m_cecVersion(CEC_VERSION_UNKNOWN), - m_deviceStatus(CEC_DEVICE_STATUS_UNKNOWN), - m_handlerMutex(false) +#define LIB_CEC m_processor->GetLib() +#define ToString(p) CCECTypeUtils::ToString(p) + +CResponse::CResponse(cec_opcode opcode) : + m_opcode(opcode) +{ +} + +CResponse::~CResponse(void) +{ + Broadcast(); +} + +bool CResponse::Wait(uint32_t iTimeout) +{ + return m_event.Wait(iTimeout); +} + +void CResponse::Broadcast(void) +{ + m_event.Broadcast(); +} + +CWaitForResponse::CWaitForResponse(void) +{ +} + +CWaitForResponse::~CWaitForResponse(void) +{ + Clear(); +} + +void CWaitForResponse::Clear() +{ + PLATFORM::CLockObject lock(m_mutex); + for (std::map::iterator it = m_waitingFor.begin(); it != m_waitingFor.end(); it++) + it->second->Broadcast(); + m_waitingFor.clear(); +} + +bool CWaitForResponse::Wait(cec_opcode opcode, uint32_t iTimeout) +{ + CResponse *response = GetEvent(opcode); + return response ? response->Wait(iTimeout) : false; +} + +void CWaitForResponse::Received(cec_opcode opcode) +{ + CResponse *response = GetEvent(opcode); + if (response) + response->Broadcast(); +} + +CResponse* CWaitForResponse::GetEvent(cec_opcode opcode) +{ + CResponse *retVal(NULL); + { + PLATFORM::CLockObject lock(m_mutex); + std::map::iterator it = m_waitingFor.find(opcode); + if (it != m_waitingFor.end()) + { + retVal = it->second; + } + else + { + retVal = new CResponse(opcode); + m_waitingFor[opcode] = retVal; + } + return retVal; + } +} + +CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */) : + m_type (CEC_DEVICE_TYPE_RESERVED), + m_iPhysicalAddress (iPhysicalAddress), + m_iStreamPath (CEC_INVALID_PHYSICAL_ADDRESS), + m_iLogicalAddress (iLogicalAddress), + m_powerStatus (CEC_POWER_STATUS_UNKNOWN), + m_processor (processor), + m_vendor (CEC_VENDOR_UNKNOWN), + m_bReplaceHandler (false), + m_menuState (CEC_MENU_STATE_ACTIVATED), + m_bActiveSource (false), + m_iLastActive (0), + m_iLastPowerStateUpdate (0), + m_cecVersion (CEC_VERSION_UNKNOWN), + m_deviceStatus (CEC_DEVICE_STATUS_UNKNOWN), + m_iHandlerUseCount (0), + m_bAwaitingReceiveFailed(false), + m_bVendorIdRequested (false), + m_waitForResponse (new CWaitForResponse), + m_bImageViewOnSent (false) { m_handler = new CCECCommandHandler(this); @@ -70,12 +163,94 @@ CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogi CCECBusDevice::~CCECBusDevice(void) { - delete m_handler; + DELETE_AND_NULL(m_handler); + DELETE_AND_NULL(m_waitForResponse); +} + +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; + + DELETE_AND_NULL(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: + m_handler = new CAQCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending); + break; + default: + m_handler = new CCECCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending); + break; + } + + 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; } -void CCECBusDevice::AddLog(cec_log_level level, const CStdString &strMessage) +CCECCommandHandler *CCECBusDevice::GetHandler(void) { - m_processor->AddLog(level, strMessage); + ReplaceHandler(false); + MarkBusy(); + return m_handler; } bool CCECBusDevice::HandleCommand(const cec_command &command) @@ -84,768 +259,1213 @@ bool CCECBusDevice::HandleCommand(const cec_command &command) /* update "last active" */ { - CLockObject lock(&m_mutex); + CLockObject lock(m_mutex); m_iLastActive = GetTimeMs(); - - if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC) - m_deviceStatus = CEC_DEVICE_STATUS_PRESENT; + MarkBusy(); } /* handle the command */ - ReplaceHandler(true); bHandled = m_handler->HandleCommand(command); /* change status to present */ - if (bHandled) + if (bHandled && GetLogicalAddress() != CECDEVICE_BROADCAST && command.opcode_set == 1) { - CLockObject lock(&m_mutex); + CLockObject lock(m_mutex); if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC) { if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT) - { - CStdString strLog; - strLog.Format("device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode)); - AddLog(CEC_LOG_DEBUG, strLog); - } + LIB_CEC->AddLog(CEC_LOG_DEBUG, "device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode)); m_deviceStatus = CEC_DEVICE_STATUS_PRESENT; } } + MarkReady(); return bHandled; } -bool CCECBusDevice::PowerOn(void) +const char* CCECBusDevice::GetLogicalAddressName(void) const { - CStdString strLog; - strLog.Format("<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_DEBUG, strLog.c_str()); - - if (m_handler->TransmitImageViewOn(GetMyLogicalAddress(), m_iLogicalAddress)) - { - { - CLockObject lock(&m_mutex); -// m_powerStatus = CEC_POWER_STATUS_UNKNOWN; - m_powerStatus = CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON; - } -// cec_power_status status = GetPowerStatus(); -// if (status == CEC_POWER_STATUS_STANDBY || status == CEC_POWER_STATUS_UNKNOWN) -// { -// /* sending the normal power on command appears to have failed */ -// CStdString strLog; -// strLog.Format("<< sending power on keypress to '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); -// AddLog(CEC_LOG_DEBUG, strLog.c_str()); -// -// TransmitKeypress(CEC_USER_CONTROL_CODE_POWER); -// return TransmitKeyRelease(); -// } - return true; - } - - return false; + return ToString(m_iLogicalAddress); } -bool CCECBusDevice::Standby(void) +bool CCECBusDevice::IsPresent(void) { - CStdString strLog; - strLog.Format("<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_DEBUG, strLog.c_str()); - - return m_handler->TransmitStandby(GetMyLogicalAddress(), m_iLogicalAddress); + CLockObject lock(m_mutex); + return m_deviceStatus == CEC_DEVICE_STATUS_PRESENT; } -/** @name Getters */ -//@{ -cec_version CCECBusDevice::GetCecVersion(bool bUpdate /* = false */) +bool CCECBusDevice::IsHandledByLibCEC(void) { - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN)) - RequestCecVersion(); - - return m_cecVersion; + CLockObject lock(m_mutex); + return m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC; } -bool CCECBusDevice::RequestCecVersion(void) +void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode) { - bool bReturn(false); + // some commands should never be marked as unsupported + if (opcode == CEC_OPCODE_VENDOR_COMMAND || + opcode == CEC_OPCODE_VENDOR_COMMAND_WITH_ID || + opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN || + opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP || + opcode == CEC_OPCODE_ABORT || + opcode == CEC_OPCODE_FEATURE_ABORT || + opcode == CEC_OPCODE_NONE || + opcode == CEC_OPCODE_USER_CONTROL_PRESSED || + opcode == CEC_OPCODE_USER_CONTROL_RELEASE) + return; - if (!MyLogicalAddressContains(m_iLogicalAddress)) { - CStdString strLog; - strLog.Format("<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - - bReturn = m_handler->TransmitRequestCecVersion(GetMyLogicalAddress(), m_iLogicalAddress); + CLockObject lock(m_mutex); + if (m_unsupportedFeatures.find(opcode) == m_unsupportedFeatures.end()) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking opcode '%s' as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName()); + m_unsupportedFeatures.insert(opcode); + } } - return bReturn; -} -const char* CCECBusDevice::GetLogicalAddressName(void) const -{ - return ToString(m_iLogicalAddress); + // signal threads that are waiting for a reponse + MarkBusy(); + SignalOpcode(cec_command::GetResponseOpcode(opcode)); + MarkReady(); } -cec_menu_language &CCECBusDevice::GetMenuLanguage(bool bUpdate /* = false */) +bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode) { - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (bUpdate || !strcmp(m_menuLanguage.language, "???"))) - RequestMenuLanguage(); - - return m_menuLanguage; + CLockObject lock(m_mutex); + bool bUnsupported = (m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end()); + if (bUnsupported) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' is marked as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName()); + return bUnsupported; } -bool CCECBusDevice::RequestMenuLanguage(void) +bool CCECBusDevice::TransmitKeypress(const cec_logical_address initiator, cec_user_control_code key, bool bWait /* = true */) { - bool bReturn(false); - - if (!MyLogicalAddressContains(m_iLogicalAddress) && - !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE)) - { - CStdString strLog; - strLog.Format("<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bReturn = m_handler->TransmitRequestMenuLanguage(GetMyLogicalAddress(), m_iLogicalAddress); - } + MarkBusy(); + bool bReturn = m_handler->TransmitKeypress(initiator, m_iLogicalAddress, key, bWait); + MarkReady(); return bReturn; } -cec_logical_address CCECBusDevice::GetMyLogicalAddress(void) const +bool CCECBusDevice::TransmitKeyRelease(const cec_logical_address initiator, bool bWait /* = true */) { - return m_processor->GetLogicalAddress(); + MarkBusy(); + bool bReturn = m_handler->TransmitKeyRelease(initiator, m_iLogicalAddress, bWait); + MarkReady(); + return bReturn; } -uint16_t CCECBusDevice::GetMyPhysicalAddress(void) const +cec_version CCECBusDevice::GetCecVersion(const cec_logical_address initiator, bool bUpdate /* = false */) { - return m_processor->GetPhysicalAddress(); + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); + { + CLockObject lock(m_mutex); + bRequestUpdate = bIsPresent && + (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN); + } + + if (bRequestUpdate) + { + CheckVendorIdRequested(initiator); + RequestCecVersion(initiator); + } + + CLockObject lock(m_mutex); + return m_cecVersion; } -CStdString CCECBusDevice::GetOSDName(bool bUpdate /* = false */) +void CCECBusDevice::SetCecVersion(const cec_version newVersion) { - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) && - m_type != CEC_DEVICE_TYPE_TV) - RequestOSDName(); - - return m_strDeviceName; + CLockObject lock(m_mutex); + if (m_cecVersion != newVersion) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion)); + m_cecVersion = newVersion; } -bool CCECBusDevice::RequestOSDName(void) +bool CCECBusDevice::RequestCecVersion(const cec_logical_address initiator, bool bWaitForResponse /* = true */) { bool bReturn(false); - if (!MyLogicalAddressContains(m_iLogicalAddress) && - !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME)) + if (!IsHandledByLibCEC() && + !IsUnsupportedFeature(CEC_OPCODE_GET_CEC_VERSION)) { - CStdString strLog; - strLog.Format("<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bReturn = m_handler->TransmitRequestOSDName(GetMyLogicalAddress(), m_iLogicalAddress); + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->TransmitRequestCecVersion(initiator, m_iLogicalAddress, bWaitForResponse); + MarkReady(); } return bReturn; } -uint16_t CCECBusDevice::GetPhysicalAddress(bool bUpdate /* = false */) +bool CCECBusDevice::TransmitCECVersion(const cec_logical_address destination, bool bIsReply) { - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (m_iPhysicalAddress == 0xFFFF || bUpdate)) + cec_version version; { - if (!RequestPhysicalAddress()) - AddLog(CEC_LOG_ERROR, "failed to request the physical address"); + CLockObject lock(m_mutex); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_cecVersion)); + version = m_cecVersion; } - return m_iPhysicalAddress; + MarkBusy(); + bool bReturn = m_handler->TransmitCECVersion(m_iLogicalAddress, destination, version, bIsReply); + MarkReady(); + return bReturn; } -bool CCECBusDevice::RequestPhysicalAddress(void) +cec_menu_language &CCECBusDevice::GetMenuLanguage(const cec_logical_address initiator, bool bUpdate /* = false */) { - bool bReturn(false); - - if (!MyLogicalAddressContains(m_iLogicalAddress)) + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); { - CStdString strLog; - strLog.Format("<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bReturn = m_handler->TransmitRequestPhysicalAddress(GetMyLogicalAddress(), m_iLogicalAddress); + CLockObject lock(m_mutex); + bRequestUpdate = (bIsPresent && + (bUpdate || !strcmp(m_menuLanguage.language, "???"))); } - return bReturn; -} -cec_power_status CCECBusDevice::GetPowerStatus(bool bUpdate /* = false */) -{ - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN)) - RequestPowerStatus(); + if (bRequestUpdate) + { + CheckVendorIdRequested(initiator); + RequestMenuLanguage(initiator); + } - return m_powerStatus; + CLockObject lock(m_mutex); + return m_menuLanguage; } -bool CCECBusDevice::RequestPowerStatus(void) +void CCECBusDevice::SetMenuLanguage(const char *strLanguage) { - bool bReturn(false); + if (!strLanguage) + return; - if (!MyLogicalAddressContains(m_iLogicalAddress) && - !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS)) + CLockObject lock(m_mutex); + if (strcmp(strLanguage, m_menuLanguage.language)) { - CStdString strLog; - strLog.Format("<< requesting power status of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bReturn = m_handler->TransmitRequestPowerStatus(GetMyLogicalAddress(), m_iLogicalAddress); + memcpy(m_menuLanguage.language, strLanguage, 3); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, m_menuLanguage.language); } - return bReturn; } -cec_vendor_id CCECBusDevice::GetVendorId(bool bUpdate /* = false */) +void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language) { - CLockObject lock(&m_mutex); - if (GetStatus() == CEC_DEVICE_STATUS_PRESENT && - (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN)) - RequestVendorId(); - - return m_vendor; + if (language.device == m_iLogicalAddress) + SetMenuLanguage(language.language); } -bool CCECBusDevice::RequestVendorId(void) +bool CCECBusDevice::RequestMenuLanguage(const cec_logical_address initiator, bool bWaitForResponse /* = true */) { bool bReturn(false); - if (!MyLogicalAddressContains(m_iLogicalAddress)) + if (!IsHandledByLibCEC() && + !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE)) { - CStdString strLog; - strLog.Format("<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bReturn = m_handler->TransmitRequestVendorId(GetMyLogicalAddress(), m_iLogicalAddress); + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->TransmitRequestMenuLanguage(initiator, m_iLogicalAddress, bWaitForResponse); + MarkReady(); } return bReturn; } -const char *CCECBusDevice::GetVendorName(bool bUpdate /* = false */) +bool CCECBusDevice::TransmitSetMenuLanguage(const cec_logical_address destination, bool bIsReply) { - return ToString(GetVendorId(bUpdate)); -} - -bool CCECBusDevice::MyLogicalAddressContains(cec_logical_address address) const -{ - return m_processor->HasLogicalAddress(address); -} + bool bReturn(false); + cec_menu_language language; + { + CLockObject lock(m_mutex); + language = m_menuLanguage; + } -bool CCECBusDevice::NeedsPoll(void) -{ - bool bSendPoll(false); - switch (m_iLogicalAddress) + char lang[4]; { - case CECDEVICE_PLAYBACKDEVICE3: - if (m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_PLAYBACKDEVICE2: - if (m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_RECORDINGDEVICE3: - if (m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_RECORDINGDEVICE2: - if (m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_TUNER4: - if (m_processor->m_busDevices[CECDEVICE_TUNER3]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_TUNER3: - if (m_processor->m_busDevices[CECDEVICE_TUNER2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_TUNER2: - if (m_processor->m_busDevices[CECDEVICE_TUNER1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - bSendPoll = true; - break; - case CECDEVICE_AUDIOSYSTEM: - case CECDEVICE_PLAYBACKDEVICE1: - case CECDEVICE_RECORDINGDEVICE1: - case CECDEVICE_TUNER1: - case CECDEVICE_TV: - bSendPoll = true; - break; - default: - break; + CLockObject lock(m_mutex); + lang[0] = language.language[0]; + lang[1] = language.language[1]; + lang[2] = language.language[2]; + lang[3] = (char)0; } - return bSendPoll; + MarkBusy(); + if (lang[0] == '?' && lang[1] == '?' && lang[2] == '?') + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu language feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination); + m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID); + bReturn = true; + } + else + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): menu language '%s'", GetLogicalAddressName(), m_iLogicalAddress, lang); + bReturn = m_handler->TransmitSetMenuLanguage(m_iLogicalAddress, lang, bIsReply); + } + MarkReady(); + return bReturn; } -cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */) +bool CCECBusDevice::TransmitOSDString(const cec_logical_address destination, cec_display_control duration, const char *strMessage, bool bIsReply) { - CLockObject lock(&m_mutex); - if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC && - (m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN || bForcePoll)) + bool bReturn(false); + if (!m_processor->GetDevice(destination)->IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING)) { - lock.Leave(); - bool bPollAcked(false); - if (bForcePoll || NeedsPoll()) - bPollAcked = m_processor->PollDevice(m_iLogicalAddress); - - lock.Lock(); - m_deviceStatus = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT; + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, strMessage); + MarkBusy(); + bReturn = m_handler->TransmitOSDString(m_iLogicalAddress, destination, duration, strMessage, bIsReply); + MarkReady(); } - - return m_deviceStatus; + return bReturn; } -//@} - -/** @name Setters */ -//@{ -void CCECBusDevice::SetCecVersion(const cec_version newVersion) +CStdString CCECBusDevice::GetCurrentOSDName(void) { - m_cecVersion = newVersion; - - CStdString strLog; - strLog.Format("%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion)); - AddLog(CEC_LOG_DEBUG, strLog); + CLockObject lock(m_mutex); + return m_strDeviceName; } -void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language) +CStdString CCECBusDevice::GetOSDName(const cec_logical_address initiator, bool bUpdate /* = false */) { - CLockObject lock(&m_mutex); - if (language.device == m_iLogicalAddress) + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); + { + CLockObject lock(m_mutex); + bRequestUpdate = bIsPresent && + (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) && + m_type != CEC_DEVICE_TYPE_TV; + } + + if (bRequestUpdate) { - CStdString strLog; - strLog.Format(">> %s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, language.language); - m_processor->AddLog(CEC_LOG_DEBUG, strLog); - m_menuLanguage = language; + CheckVendorIdRequested(initiator); + RequestOSDName(initiator); } + + CLockObject lock(m_mutex); + return m_strDeviceName; } void CCECBusDevice::SetOSDName(CStdString strName) { - CLockObject lock(&m_mutex); + CLockObject lock(m_mutex); if (m_strDeviceName != strName) { - CStdString strLog; - strLog.Format(">> %s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName); - m_processor->AddLog(CEC_LOG_DEBUG, strLog); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName.c_str()); m_strDeviceName = strName; } } -void CCECBusDevice::SetMenuState(const cec_menu_state state) +bool CCECBusDevice::RequestOSDName(const cec_logical_address initiator, bool bWaitForResponse /* = true */) { - CLockObject lock(&m_mutex); - if (m_menuState != state) + bool bReturn(false); + + if (!IsHandledByLibCEC() && + !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME)) { - CStdString strLog; - strLog.Format(">> %s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState)); - m_processor->AddLog(CEC_LOG_DEBUG, strLog); - m_menuState = state; + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->TransmitRequestOSDName(initiator, m_iLogicalAddress, bWaitForResponse); + MarkReady(); } + return bReturn; } -void CCECBusDevice::SetInactiveSource(void) +bool CCECBusDevice::TransmitOSDName(const cec_logical_address destination, bool bIsReply) { + CStdString strDeviceName; { - CLockObject lock(&m_mutex); - m_bActiveSource = false; + CLockObject lock(m_mutex); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, m_strDeviceName.c_str()); + strDeviceName = m_strDeviceName; } - if (MyLogicalAddressContains(m_iLogicalAddress)) - SetPowerStatus(CEC_POWER_STATUS_STANDBY); + MarkBusy(); + bool bReturn = m_handler->TransmitOSDName(m_iLogicalAddress, destination, strDeviceName, bIsReply); + MarkReady(); + return bReturn; } -void CCECBusDevice::SetActiveSource(void) +bool CCECBusDevice::HasValidPhysicalAddress(void) { - CLockObject lock(&m_mutex); - - for (int iPtr = 0; iPtr < 16; iPtr++) - if (iPtr != m_iLogicalAddress) - m_processor->m_busDevices[iPtr]->SetInactiveSource(); - - m_bActiveSource = true; - m_powerStatus = CEC_POWER_STATUS_ON; + CLockObject lock(m_mutex); + return CLibCEC::IsValidPhysicalAddress(m_iPhysicalAddress); } -bool CCECBusDevice::TryLogicalAddress(void) +uint16_t CCECBusDevice::GetCurrentPhysicalAddress(void) { - CStdString strLog; - strLog.Format("trying logical address '%s'", GetLogicalAddressName()); - AddLog(CEC_LOG_DEBUG, strLog); + CLockObject lock(m_mutex); + return m_iPhysicalAddress; +} - m_processor->SetAckMask(0x1 << m_iLogicalAddress); - if (!TransmitPoll(m_iLogicalAddress)) +uint16_t CCECBusDevice::GetPhysicalAddress(const cec_logical_address initiator, bool bSuppressUpdate /* = false */) +{ + if (!bSuppressUpdate) { - strLog.Format("using logical address '%s'", GetLogicalAddressName()); - AddLog(CEC_LOG_NOTICE, strLog); - SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC); + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); + { + CLockObject lock(m_mutex); + bRequestUpdate = bIsPresent && m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS; + } - return true; + if (bRequestUpdate) + { + CheckVendorIdRequested(initiator); + if (!RequestPhysicalAddress(initiator)) + LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to request the physical address"); + } } - strLog.Format("logical address '%s' already taken", GetLogicalAddressName()); - AddLog(CEC_LOG_DEBUG, strLog); - SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT); - return false; + CLockObject lock(m_mutex); + return m_iPhysicalAddress; } -void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus) +bool CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress) { - CLockObject lock(&m_mutex); - switch (newStatus) + CLockObject lock(m_mutex); + if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress) { - case CEC_DEVICE_STATUS_UNKNOWN: - m_iStreamPath = 0; - m_powerStatus = CEC_POWER_STATUS_UNKNOWN; - m_vendor = CEC_VENDOR_UNKNOWN; - m_menuState = CEC_MENU_STATE_ACTIVATED; - m_bActiveSource = false; - m_iLastActive = 0; - m_cecVersion = CEC_VERSION_UNKNOWN; - m_deviceStatus = newStatus; - break; - case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC: - m_iStreamPath = 0; - m_powerStatus = CEC_POWER_STATUS_ON; - m_vendor = CEC_VENDOR_UNKNOWN; - m_menuState = CEC_MENU_STATE_ACTIVATED; - m_bActiveSource = false; - m_iLastActive = 0; - m_cecVersion = CEC_VERSION_1_3A; - m_deviceStatus = newStatus; - break; - case CEC_DEVICE_STATUS_PRESENT: - case CEC_DEVICE_STATUS_NOT_PRESENT: - m_deviceStatus = newStatus; - break; + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress); + m_iPhysicalAddress = iNewAddress; } + return true; } -void CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress) +bool CCECBusDevice::RequestPhysicalAddress(const cec_logical_address initiator, bool bWaitForResponse /* = true */) { - CLockObject lock(&m_mutex); - if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress) - { - CStdString strLog; - strLog.Format(">> %s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress); - AddLog(CEC_LOG_DEBUG, strLog.c_str()); + bool bReturn(false); - m_iPhysicalAddress = iNewAddress; + if (!IsHandledByLibCEC()) + { + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->TransmitRequestPhysicalAddress(initiator, m_iLogicalAddress, bWaitForResponse); + MarkReady(); } + return bReturn; } -void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = 0 */) +bool CCECBusDevice::TransmitPhysicalAddress(bool bIsReply) { - CLockObject lock(&m_mutex); - if (iNewAddress > 0) + uint16_t iPhysicalAddress; + cec_device_type type; { - CStdString strLog; - strLog.Format(">> %s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress); - AddLog(CEC_LOG_DEBUG, strLog.c_str()); - - m_iStreamPath = iNewAddress; + CLockObject lock(m_mutex); + if (m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS) + return false; - if (iNewAddress > 0) - { - lock.Leave(); - SetPowerStatus(CEC_POWER_STATUS_ON); - } + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress); + iPhysicalAddress = m_iPhysicalAddress; + type = m_type; } + + MarkBusy(); + bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type, bIsReply); + MarkReady(); + return bReturn; } -void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus) +cec_power_status CCECBusDevice::GetCurrentPowerStatus(void) { - CLockObject lock(&m_mutex); - if (m_powerStatus != powerStatus) - { - CStdString strLog; - strLog.Format(">> %s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus)); - m_processor->AddLog(CEC_LOG_DEBUG, strLog); - m_powerStatus = powerStatus; - } + CLockObject lock(m_mutex); + return m_powerStatus; } -bool CCECBusDevice::ReplaceHandler(bool bInitHandler /* = true */) +cec_power_status CCECBusDevice::GetPowerStatus(const cec_logical_address initiator, bool bUpdate /* = false */) { - CLockObject lock(&m_mutex); - CLockObject handlerLock(&m_handlerMutex); + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); + { + CLockObject lock(m_mutex); + bRequestUpdate = (bIsPresent && + (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN || + m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON || + m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY || + GetTimeMs() - m_iLastPowerStateUpdate >= CEC_POWER_STATE_REFRESH_TIME)); + } - if (m_vendor != m_handler->GetVendorId()) + if (bRequestUpdate) { - if (m_handler->InUse()) - return false; + CheckVendorIdRequested(initiator); + RequestPowerStatus(initiator, bUpdate); + } - delete m_handler; + CLockObject lock(m_mutex); + return m_powerStatus; +} - switch (m_vendor) - { - case CEC_VENDOR_SAMSUNG: - m_handler = new CANCommandHandler(this); - break; - case CEC_VENDOR_LG: - m_handler = new CSLCommandHandler(this); - break; - case CEC_VENDOR_PANASONIC: - m_handler = new CVLCommandHandler(this); - break; - default: - m_handler = new CCECCommandHandler(this); - break; - } +void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus) +{ + CLockObject lock(m_mutex); + if (m_powerStatus != powerStatus) + { + m_iLastPowerStateUpdate = GetTimeMs(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus)); + m_powerStatus = powerStatus; + } +} - if (bInitHandler && m_processor->GetLogicalAddresses().IsSet(m_iLogicalAddress) && m_processor->IsInitialised()) - m_handler->InitHandler(); +void CCECBusDevice::OnImageViewOnSent(bool bSentByLibCEC) +{ + CLockObject lock(m_mutex); + m_bImageViewOnSent = bSentByLibCEC; + + if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON) + { + m_iLastPowerStateUpdate = GetTimeMs(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)); + m_powerStatus = CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON; } +} - return true; +bool CCECBusDevice::ImageViewOnSent(void) +{ + CLockObject lock(m_mutex); + return m_bImageViewOnSent; +} + +bool CCECBusDevice::RequestPowerStatus(const cec_logical_address initiator, bool bUpdate, bool bWaitForResponse /* = true */) +{ + bool bReturn(false); + + if (!IsHandledByLibCEC() && + !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS)) + { + MarkBusy(); + bReturn = m_handler->TransmitRequestPowerStatus(initiator, m_iLogicalAddress, bUpdate, bWaitForResponse); + if (!bReturn) + SetPowerStatus(CEC_POWER_STATUS_UNKNOWN); + MarkReady(); + } + return bReturn; +} + +bool CCECBusDevice::TransmitPowerState(const cec_logical_address destination, bool bIsReply) +{ + cec_power_status state; + { + CLockObject lock(m_mutex); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_powerStatus)); + state = m_powerStatus; + } + + MarkBusy(); + bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, destination, state, bIsReply); + MarkReady(); + return bReturn; +} + +cec_vendor_id CCECBusDevice::GetCurrentVendorId(void) +{ + CLockObject lock(m_mutex); + return m_vendor; +} + +cec_vendor_id CCECBusDevice::GetVendorId(const cec_logical_address initiator, bool bUpdate /* = false */) +{ + bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT); + bool bRequestUpdate(false); + { + CLockObject lock(m_mutex); + bRequestUpdate = (bIsPresent && + (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN)); + } + + if (bRequestUpdate) + RequestVendorId(initiator); + + CLockObject lock(m_mutex); + return m_vendor; +} + +const char *CCECBusDevice::GetVendorName(const cec_logical_address initiator, bool bUpdate /* = false */) +{ + return ToString(GetVendorId(initiator, bUpdate)); } -bool CCECBusDevice::SetVendorId(uint64_t iVendorId, bool bInitHandler /* = true */) +bool CCECBusDevice::SetVendorId(uint64_t iVendorId) { bool bVendorChanged(false); { - CLockObject lock(&m_mutex); + CLockObject lock(m_mutex); bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId); m_vendor = (cec_vendor_id)iVendorId; - ReplaceHandler(bInitHandler); } - CStdString strLog; - strLog.Format("%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor); - m_processor->AddLog(CEC_LOG_DEBUG, strLog.c_str()); + if (bVendorChanged) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor); return bVendorChanged; } -//@} -/** @name Transmit methods */ -//@{ -bool CCECBusDevice::TransmitActiveSource(void) +bool CCECBusDevice::RequestVendorId(const cec_logical_address initiator, bool bWaitForResponse /* = true */) { - bool bSendActiveSource(false); + bool bReturn(false); + if (!IsHandledByLibCEC() && initiator != CECDEVICE_UNKNOWN) { - CLockObject lock(&m_mutex); - if (m_powerStatus != CEC_POWER_STATUS_ON) - { - CStdString strLog; - strLog.Format("<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_DEBUG, strLog); - } - else if (m_bActiveSource) - { - CStdString strLog; - strLog.Format("<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - bSendActiveSource = true; - } - else + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->TransmitRequestVendorId(initiator, m_iLogicalAddress, bWaitForResponse); + MarkReady(); + + if (bWaitForResponse) + ReplaceHandler(true); + } + return bReturn; +} + +bool CCECBusDevice::TransmitVendorID(const cec_logical_address destination, bool bSendAbort, bool bIsReply) +{ + bool bReturn(false); + uint64_t iVendorId; + { + CLockObject lock(m_mutex); + iVendorId = (uint64_t)m_vendor; + } + + MarkBusy(); + if (iVendorId == CEC_VENDOR_UNKNOWN) + { + if (bSendAbort) { - CStdString strLog; - strLog.Format("<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_DEBUG, strLog); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination); + m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID); + bReturn = true; } } + else + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString((cec_vendor_id)iVendorId), iVendorId); + bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, destination, iVendorId, bIsReply); + } + MarkReady(); + return bReturn; +} + +cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */, bool bSuppressPoll /* = false */) +{ + if (m_iLogicalAddress == CECDEVICE_BROADCAST) + return CEC_DEVICE_STATUS_NOT_PRESENT; + + cec_bus_device_status status(CEC_DEVICE_STATUS_UNKNOWN); + bool bNeedsPoll(false); - if (bSendActiveSource) { - m_handler->TransmitActiveSource(m_iLogicalAddress, m_iPhysicalAddress); - m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV); - return true; + CLockObject lock(m_mutex); + status = m_deviceStatus; + bNeedsPoll = !bSuppressPoll && + m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC && + // poll forced + (bForcePoll || + // don't know the status + m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN || + // always poll the TV if it's marked as not present + (m_deviceStatus == CEC_DEVICE_STATUS_NOT_PRESENT && m_iLogicalAddress == CECDEVICE_TV)); } - return false; + if (bNeedsPoll) + { + bool bPollAcked(false); + if (bNeedsPoll) + bPollAcked = m_processor->PollDevice(m_iLogicalAddress); + + status = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT; + SetDeviceStatus(status); + } + + return status; } -bool CCECBusDevice::TransmitCECVersion(cec_logical_address dest) +void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */) { - cec_version version; + if (m_iLogicalAddress == CECDEVICE_UNREGISTERED) + return; + { - CLockObject lock(&m_mutex); - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_cecVersion)); - AddLog(CEC_LOG_NOTICE, strLog); - version = m_cecVersion; + CLockObject lock(m_mutex); + switch (newStatus) + { + case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC: + if (m_deviceStatus != newStatus) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'handled by libCEC'", GetLogicalAddressName(), m_iLogicalAddress); + SetPowerStatus (CEC_POWER_STATUS_ON); + SetVendorId (CEC_VENDOR_UNKNOWN); + SetMenuState (CEC_MENU_STATE_ACTIVATED); + SetCecVersion (libCECSpecVersion); + SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS); + MarkAsInactiveSource(); + m_iLastActive = 0; + m_deviceStatus = newStatus; + break; + case CEC_DEVICE_STATUS_PRESENT: + if (m_deviceStatus != newStatus) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'present'", GetLogicalAddressName(), m_iLogicalAddress); + m_deviceStatus = newStatus; + m_iLastActive = GetTimeMs(); + break; + case CEC_DEVICE_STATUS_NOT_PRESENT: + if (m_deviceStatus != newStatus) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'not present'", GetLogicalAddressName(), m_iLogicalAddress); + ResetDeviceStatus(true); + m_deviceStatus = newStatus; + } + break; + default: + ResetDeviceStatus(); + break; + } } +} - return m_handler->TransmitCECVersion(m_iLogicalAddress, dest, version); +void CCECBusDevice::ResetDeviceStatus(bool bClientUnregistered /* = false */) +{ + CLockObject lock(m_mutex); + SetPowerStatus (CEC_POWER_STATUS_UNKNOWN); + SetVendorId (CEC_VENDOR_UNKNOWN); + SetMenuState (CEC_MENU_STATE_ACTIVATED); + SetCecVersion (CEC_VERSION_UNKNOWN); + SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS); + SetOSDName (ToString(m_iLogicalAddress)); + MarkAsInactiveSource(bClientUnregistered); + + m_iLastActive = 0; + m_bVendorIdRequested = false; + m_unsupportedFeatures.clear(); + m_waitForResponse->Clear(); + + if (m_deviceStatus != CEC_DEVICE_STATUS_UNKNOWN) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'unknown'", GetLogicalAddressName(), m_iLogicalAddress); + m_deviceStatus = CEC_DEVICE_STATUS_UNKNOWN; } -bool CCECBusDevice::TransmitInactiveSource(void) +bool CCECBusDevice::TransmitPoll(const cec_logical_address dest, bool bUpdateDeviceStatus) { - uint16_t iPhysicalAddress; + bool bReturn(false); + cec_logical_address destination(dest); + if (destination == CECDEVICE_UNKNOWN) + destination = m_iLogicalAddress; + + CCECBusDevice *destDevice = m_processor->GetDevice(destination); + if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC) + return bReturn; + + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest); + bReturn = m_handler->TransmitPoll(m_iLogicalAddress, destination, false); + LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent"); + + if (bUpdateDeviceStatus) + destDevice->SetDeviceStatus(bReturn ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT); + + MarkReady(); + return bReturn; +} + +void CCECBusDevice::HandlePoll(const cec_logical_address destination) +{ + if (destination >= 0 && destination < CECDEVICE_BROADCAST) { - CLockObject lock(&m_mutex); - CStdString strLog; - strLog.Format("<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress); - AddLog(CEC_LOG_NOTICE, strLog); - iPhysicalAddress = m_iPhysicalAddress; + CCECBusDevice *device = m_processor->GetDevice(destination); + if (device) + device->HandlePollFrom(m_iLogicalAddress); } +} - return m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress); +void CCECBusDevice::HandlePollFrom(const cec_logical_address initiator) +{ + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(initiator), initiator, ToString(m_iLogicalAddress), m_iLogicalAddress); + m_bAwaitingReceiveFailed = true; +} + +bool CCECBusDevice::HandleReceiveFailed(void) +{ + bool bReturn = m_bAwaitingReceiveFailed; + m_bAwaitingReceiveFailed = false; + return bReturn; } -bool CCECBusDevice::TransmitMenuState(cec_logical_address dest) +cec_menu_state CCECBusDevice::GetMenuState(const cec_logical_address UNUSED(initiator)) +{ + CLockObject lock(m_mutex); + return m_menuState; +} + +void CCECBusDevice::SetMenuState(const cec_menu_state state) +{ + CLockObject lock(m_mutex); + if (m_menuState != state) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState)); + m_menuState = state; + } +} + +bool CCECBusDevice::TransmitMenuState(const cec_logical_address dest, bool bIsReply) { cec_menu_state menuState; { - CLockObject lock(&m_mutex); - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState)); - AddLog(CEC_LOG_NOTICE, strLog); + CLockObject lock(m_mutex); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState)); menuState = m_menuState; } - return m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState); + MarkBusy(); + bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState, bIsReply); + MarkReady(); + return bReturn; } -bool CCECBusDevice::TransmitOSDName(cec_logical_address dest) +bool CCECBusDevice::ActivateSource(uint64_t iDelay /* = 0 */) { - CStdString strDeviceName; + MarkAsActiveSource(); + MarkBusy(); + bool bReturn(true); + if (iDelay == 0) { - CLockObject lock(&m_mutex); - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, m_strDeviceName.c_str()); - AddLog(CEC_LOG_NOTICE, strLog.c_str()); - strDeviceName = m_strDeviceName; + LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending active source message for '%s'", ToString(m_iLogicalAddress)); + bReturn = m_handler->ActivateSource(); + } + else + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "scheduling active source message for '%s'", ToString(m_iLogicalAddress)); + m_handler->ScheduleActivateSource(iDelay); } + MarkReady(); + return bReturn; +} + +bool CCECBusDevice::RequestActiveSource(bool bWaitForResponse /* = true */) +{ + bool bReturn(false); - return m_handler->TransmitOSDName(m_iLogicalAddress, dest, strDeviceName); + if (IsHandledByLibCEC()) + { + MarkBusy(); + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting active source"); + + bReturn = m_handler->TransmitRequestActiveSource(m_iLogicalAddress, bWaitForResponse); + MarkReady(); + } + return bReturn; } -bool CCECBusDevice::TransmitOSDString(cec_logical_address dest, cec_display_control duration, const char *strMessage) +void CCECBusDevice::MarkAsActiveSource(void) { - if (!IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING)) + bool bWasActivated(false); + + // set the power status to powered on + SetPowerStatus(CEC_POWER_STATUS_ON); + + // mark this device as active source { - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, strMessage); - AddLog(CEC_LOG_NOTICE, strLog.c_str()); + CLockObject lock(m_mutex); + if (!m_bActiveSource) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "making %s (%x) the active source", GetLogicalAddressName(), m_iLogicalAddress); + bWasActivated = true; + } + else + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%x) was already marked as active source", GetLogicalAddressName(), m_iLogicalAddress); - return m_handler->TransmitOSDString(m_iLogicalAddress, dest, duration, strMessage); + m_bActiveSource = true; + } + + CCECBusDevice* tv = m_processor->GetDevice(CECDEVICE_TV); + if (tv) + tv->OnImageViewOnSent(false); + + // mark other devices as inactive sources + CECDEVICEVEC devices; + m_processor->GetDevices()->Get(devices); + for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++) + if ((*it)->GetLogicalAddress() != m_iLogicalAddress) + (*it)->MarkAsInactiveSource(); + + if (bWasActivated) + { + if (IsHandledByLibCEC()) + m_processor->SetActiveSource(true, false); + CCECClient *client = GetClient(); + if (client) + client->SourceActivated(m_iLogicalAddress); } - return false; } -bool CCECBusDevice::TransmitPhysicalAddress(void) +void CCECBusDevice::MarkAsInactiveSource(bool bClientUnregistered /* = false */) { - uint16_t iPhysicalAddress; - cec_device_type type; + bool bWasDeactivated(false); { - CLockObject lock(&m_mutex); - if (m_iPhysicalAddress == 0xffff) - return false; + CLockObject lock(m_mutex); + if (m_bActiveSource) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking %s (%X) as inactive source", GetLogicalAddressName(), m_iLogicalAddress); + bWasDeactivated = true; + } + m_bActiveSource = false; + } + + if (bWasDeactivated) + { + if (IsHandledByLibCEC()) + m_processor->SetActiveSource(false, bClientUnregistered); + CCECClient *client = GetClient(); + if (client) + client->SourceDeactivated(m_iLogicalAddress); + } +} - CStdString strLog; - strLog.Format("<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress); - AddLog(CEC_LOG_NOTICE, strLog.c_str()); +bool CCECBusDevice::TransmitActiveSource(bool bIsReply) +{ + bool bSendActiveSource(false); + uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS); + + { + CLockObject lock(m_mutex); + if (!HasValidPhysicalAddress()) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X) has an invalid physical address (%04x), not sending active source commands", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress); + return false; + } iPhysicalAddress = m_iPhysicalAddress; - type = m_type; + + if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON) + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress); + else if (m_bActiveSource) + { + LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress); + bSendActiveSource = true; + } + else + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress); + } + + bool bActiveSourceSent(false); + if (bSendActiveSource) + { + MarkBusy(); + bActiveSourceSent = m_handler->TransmitActiveSource(m_iLogicalAddress, iPhysicalAddress, bIsReply); + MarkReady(); } - return m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type); + return bActiveSourceSent; } -bool CCECBusDevice::TransmitPoll(cec_logical_address dest) +bool CCECBusDevice::TransmitImageViewOn(void) { - bool bReturn(false); - if (dest == CECDEVICE_UNKNOWN) - dest = m_iLogicalAddress; + { + CLockObject lock(m_mutex); + if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress); + return false; + } + } - CCECBusDevice *destDevice = m_processor->m_busDevices[dest]; - if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC) - return bReturn; + CCECBusDevice* tv = m_processor->GetDevice(CECDEVICE_TV); + if (!tv) + { + LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - couldn't get TV instance", __FUNCTION__); + return false; + } + + if (tv->ImageViewOnSent()) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - 'image view on' already sent", __FUNCTION__); + return true; + } + + bool bImageViewOnSent(false); + MarkBusy(); + bImageViewOnSent = m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV); + MarkReady(); - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest); - AddLog(CEC_LOG_NOTICE, strLog.c_str()); - bReturn = m_handler->TransmitPoll(m_iLogicalAddress, dest); - AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent"); + if (bImageViewOnSent) + tv->OnImageViewOnSent(true); - CLockObject lock(&m_mutex); - if (bReturn) + return bImageViewOnSent; +} + +bool CCECBusDevice::TransmitInactiveSource(void) +{ + uint16_t iPhysicalAddress; { - m_iLastActive = GetTimeMs(); - destDevice->m_deviceStatus = CEC_DEVICE_STATUS_PRESENT; + CLockObject lock(m_mutex); + LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress); + iPhysicalAddress = m_iPhysicalAddress; } - else - destDevice->m_deviceStatus = CEC_DEVICE_STATUS_NOT_PRESENT; + MarkBusy(); + bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress); + MarkReady(); return bReturn; } -bool CCECBusDevice::TransmitPowerState(cec_logical_address dest) +bool CCECBusDevice::TransmitPendingActiveSourceCommands(void) { - cec_power_status state; + MarkBusy(); + bool bReturn = m_handler->ActivateSource(true); + MarkReady(); + return bReturn; +} + +void CCECBusDevice::SetActiveRoute(uint16_t iRoute) +{ + SetPowerStatus(CEC_POWER_STATUS_ON); + + CCECDeviceMap* map = m_processor->GetDevices(); + if (!map) + return; + + CCECBusDevice* newRoute = m_processor->GetDeviceByPhysicalAddress(iRoute, true); + if (newRoute && newRoute->IsHandledByLibCEC()) { - CLockObject lock(&m_mutex); - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_powerStatus)); - AddLog(CEC_LOG_NOTICE, strLog.c_str()); - state = m_powerStatus; + // we were made the active source, send notification + newRoute->ActivateSource(); } +} + +void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */) +{ + if (iNewAddress != CEC_INVALID_PHYSICAL_ADDRESS) + SetPowerStatus(CEC_POWER_STATUS_ON); - return m_handler->TransmitPowerState(m_iLogicalAddress, dest, state); + CLockObject lock(m_mutex); + if (iNewAddress != m_iStreamPath) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress); + m_iStreamPath = iNewAddress; + } + + if (!LIB_CEC->IsValidPhysicalAddress(iNewAddress)) + return; + + CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iNewAddress); + if (device) + { + // if a device is found with the new physical address, mark it as active, which will automatically mark all other devices as inactive + device->MarkAsActiveSource(); + + // respond with an active source message if this device is handled by libCEC + if (device->IsHandledByLibCEC()) + device->TransmitActiveSource(true); + } + else + { + // try to find the device with the old address, and mark it as inactive when found + device = m_processor->GetDeviceByPhysicalAddress(iOldAddress); + if (device) + device->MarkAsInactiveSource(); + } } -bool CCECBusDevice::TransmitVendorID(cec_logical_address dest, bool bSendAbort /* = true */) +bool CCECBusDevice::PowerOn(const cec_logical_address initiator) { - uint64_t iVendorId; + bool bReturn(false); + GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor + + MarkBusy(); + cec_power_status currentStatus; + if (m_iLogicalAddress == CECDEVICE_TV || + ((currentStatus = GetPowerStatus(initiator, false)) != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON && + currentStatus != CEC_POWER_STATUS_ON)) { - CLockObject lock(&m_mutex); - iVendorId = (uint64_t)m_vendor; + LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress); + bReturn = m_handler->PowerOn(initiator, m_iLogicalAddress); + } + else + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus)); } - if (iVendorId == CEC_VENDOR_UNKNOWN) + MarkReady(); + return bReturn; +} + +bool CCECBusDevice::Standby(const cec_logical_address initiator) +{ + GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor + + LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress); + MarkBusy(); + bool bReturn = m_handler->TransmitStandby(initiator, m_iLogicalAddress); + MarkReady(); + return bReturn; +} + +bool CCECBusDevice::NeedsPoll(void) +{ + bool bSendPoll(false); + cec_logical_address pollAddress(CECDEVICE_UNKNOWN); + switch (m_iLogicalAddress) { - if (bSendAbort) - { - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest); - AddLog(CEC_LOG_NOTICE, strLog); + case CECDEVICE_PLAYBACKDEVICE3: + pollAddress = CECDEVICE_PLAYBACKDEVICE2; + break; + case CECDEVICE_PLAYBACKDEVICE2: + pollAddress = CECDEVICE_PLAYBACKDEVICE1; + break; + case CECDEVICE_RECORDINGDEVICE3: + pollAddress = CECDEVICE_RECORDINGDEVICE2; + break; + case CECDEVICE_RECORDINGDEVICE2: + pollAddress = CECDEVICE_RECORDINGDEVICE1; + break; + case CECDEVICE_TUNER4: + pollAddress = CECDEVICE_TUNER3; + break; + case CECDEVICE_TUNER3: + pollAddress = CECDEVICE_TUNER2; + break; + case CECDEVICE_TUNER2: + pollAddress = CECDEVICE_TUNER1; + break; + case CECDEVICE_AUDIOSYSTEM: + case CECDEVICE_PLAYBACKDEVICE1: + case CECDEVICE_RECORDINGDEVICE1: + case CECDEVICE_TUNER1: + case CECDEVICE_TV: + bSendPoll = true; + break; + default: + break; + } - m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID); + if (!bSendPoll && pollAddress != CECDEVICE_UNKNOWN) + { + CCECBusDevice *device = m_processor->GetDevice(pollAddress); + if (device) + { + cec_bus_device_status status = device->GetStatus(); + bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC); + } + else + { + bSendPoll = true; } - return false; } - else + + return bSendPoll; +} + +void CCECBusDevice::CheckVendorIdRequested(const cec_logical_address initiator) +{ + bool bRequestVendorId(false); { - CStdString strLog; - strLog.Format("<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString((cec_vendor_id)iVendorId), iVendorId); - AddLog(CEC_LOG_NOTICE, strLog); + CLockObject lock(m_mutex); + bRequestVendorId = !m_bVendorIdRequested; + m_bVendorIdRequested = true; + } - return m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId); + if (bRequestVendorId) + { + ReplaceHandler(false); + GetVendorId(initiator); } } +//@} -bool CCECBusDevice::TransmitKeypress(cec_user_control_code key, bool bWait /* = true */) +CCECAudioSystem *CCECBusDevice::AsAudioSystem(void) { - return m_handler->TransmitKeypress(m_processor->GetLogicalAddress(), m_iLogicalAddress, key, bWait); + return AsAudioSystem(this); } -bool CCECBusDevice::TransmitKeyRelease(bool bWait /* = true */) +CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(void) { - return m_handler->TransmitKeyRelease(m_processor->GetLogicalAddress(), m_iLogicalAddress, bWait); + return AsPlaybackDevice(this); } -bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode) const +CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(void) { - return m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end(); + return AsRecordingDevice(this); } -void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode) +CCECTuner *CCECBusDevice::AsTuner(void) { - m_unsupportedFeatures.insert(opcode); + return AsTuner(this); } -bool CCECBusDevice::InitHandler(void) +CCECTV *CCECBusDevice::AsTV(void) { - CLockObject lock(&m_mutex); - ReplaceHandler(false); - return m_handler->InitHandler(); + return AsTV(this); } -//@} +CCECAudioSystem *CCECBusDevice::AsAudioSystem(CCECBusDevice *device) +{ + if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM) + return static_cast(device); + return NULL; +} + +CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(CCECBusDevice *device) +{ + if (device && + (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || + device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)) + return static_cast(device); + return NULL; +} + +CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(CCECBusDevice *device) +{ + if (device && device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) + return static_cast(device); + return NULL; +} + +CCECTuner *CCECBusDevice::AsTuner(CCECBusDevice *device) +{ + if (device && device->GetType() == CEC_DEVICE_TYPE_TUNER) + return static_cast(device); + return NULL; +} + +CCECTV *CCECBusDevice::AsTV(CCECBusDevice *device) +{ + if (device && device->GetType() == CEC_DEVICE_TYPE_TV) + return static_cast(device); + return NULL; +} + +void CCECBusDevice::MarkBusy(void) +{ + CLockObject handlerLock(m_handlerMutex); + ++m_iHandlerUseCount; +} + +void CCECBusDevice::MarkReady(void) +{ + CLockObject handlerLock(m_handlerMutex); + if (m_iHandlerUseCount > 0) + --m_iHandlerUseCount; +} + +bool CCECBusDevice::TryLogicalAddress(cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */) +{ + LIB_CEC->AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName()); + + if (!TransmitPoll(m_iLogicalAddress, false)) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "using logical address '%s'", GetLogicalAddressName()); + SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC, libCECSpecVersion); + + return true; + } + + LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName()); + SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT); + return false; +} + +CCECClient *CCECBusDevice::GetClient(void) +{ + return m_processor->GetClient(m_iLogicalAddress); +} + +void CCECBusDevice::SignalOpcode(cec_opcode opcode) +{ + m_waitForResponse->Received(opcode); +} + +bool CCECBusDevice::WaitForOpcode(cec_opcode opcode) +{ + return m_waitForResponse->Wait(opcode); +}