X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2FCECProcessor.cpp;h=efe038f1498eb17f433fa0c7f8191673411dc031;hb=bb6138eabba9a42f85c3167c0a8aefbd77ff95b8;hp=6faf72c5e5b8ae3e8890024184da2115e9bf8d32;hpb=996665192725398172263999b88c63663d11db04;p=deb_libcec.git diff --git a/src/lib/CECProcessor.cpp b/src/lib/CECProcessor.cpp index 6faf72c..557b76d 100644 --- a/src/lib/CECProcessor.cpp +++ b/src/lib/CECProcessor.cpp @@ -1,7 +1,7 @@ /* * This file is part of the libCEC(R) library. * - * libCEC(R) is Copyright (C) 2011-2012 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,9 +30,10 @@ * http://www.pulse-eight.net/ */ +#include "env.h" #include "CECProcessor.h" -#include "adapter/AdapterMessage.h" +#include "adapter/AdapterFactory.h" #include "devices/CECBusDevice.h" #include "devices/CECAudioSystem.h" #include "devices/CECPlaybackDevice.h" @@ -41,1403 +42,1028 @@ #include "devices/CECTV.h" #include "implementations/CECCommandHandler.h" #include "LibCEC.h" +#include "CECClient.h" +#include "CECTypeUtils.h" #include "platform/util/timeutils.h" +#include "platform/util/util.h" using namespace CEC; using namespace std; using namespace PLATFORM; -CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS*/) : - m_bStarted(false), - m_bInitialised(false), - m_iHDMIPort(CEC_DEFAULT_HDMI_PORT), - m_iBaseDevice((cec_logical_address)CEC_DEFAULT_BASE_DEVICE), - m_lastInitiator(CECDEVICE_UNKNOWN), - m_strDeviceName(strDeviceName), - m_communication(NULL), - m_controller(controller), - m_bMonitor(false), - m_iStandardLineTimeout(3), - m_iRetryLineTimeout(3), - m_iLastTransmission(0) +#define CEC_PROCESSOR_SIGNAL_WAIT_TIME 1000 +#define ACTIVE_SOURCE_CHECK_INTERVAL 500 +#define TV_PRESENT_CHECK_INTERVAL 30000 + +#define ToString(x) CCECTypeUtils::ToString(x) + +CCECStandbyProtection::CCECStandbyProtection(CCECProcessor* processor) : + m_processor(processor) {} +CCECStandbyProtection::~CCECStandbyProtection(void) {} + +void* CCECStandbyProtection::Process(void) { - m_logicalAddresses.Clear(); - m_logicalAddresses.Set(iLogicalAddress); - m_types.clear(); - for (int iPtr = 0; iPtr <= 16; iPtr++) - m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, iPtr == iLogicalAddress ? iPhysicalAddress : 0); + int64_t last = GetTimeMs(); + int64_t next; + while (!IsStopped()) + { + PLATFORM::CEvent::Sleep(1000); + + next = GetTimeMs(); + + // reset the connection if the clock changed + if (next < last || next - last > 10000) + { + libcec_parameter param; + param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN; + m_processor->GetLib()->Alert(CEC_ALERT_CONNECTION_LOST, param); + break; + } + + last = next; + } + return NULL; } -CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, const cec_device_type_list &types) : - m_bStarted(false), +CCECProcessor::CCECProcessor(CLibCEC *libcec) : m_bInitialised(false), - m_iHDMIPort(CEC_DEFAULT_HDMI_PORT), - m_iBaseDevice((cec_logical_address)CEC_DEFAULT_BASE_DEVICE), - m_strDeviceName(strDeviceName), - m_types(types), m_communication(NULL), - m_controller(controller), - m_bMonitor(false), + m_libcec(libcec), m_iStandardLineTimeout(3), m_iRetryLineTimeout(3), - m_iLastTransmission(0) + m_iLastTransmission(0), + m_bMonitor(true), + m_addrAllocator(NULL), + m_bStallCommunication(false), + m_connCheck(NULL) { - m_logicalAddresses.Clear(); - for (int iPtr = 0; iPtr < 16; iPtr++) - { - switch(iPtr) - { - case CECDEVICE_AUDIOSYSTEM: - m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF); - break; - case CECDEVICE_PLAYBACKDEVICE1: - case CECDEVICE_PLAYBACKDEVICE2: - case CECDEVICE_PLAYBACKDEVICE3: - m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF); - break; - case CECDEVICE_RECORDINGDEVICE1: - case CECDEVICE_RECORDINGDEVICE2: - case CECDEVICE_RECORDINGDEVICE3: - m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF); - break; - case CECDEVICE_TUNER1: - case CECDEVICE_TUNER2: - case CECDEVICE_TUNER3: - case CECDEVICE_TUNER4: - m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF); - break; - case CECDEVICE_TV: - m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0); - break; - default: - m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF); - break; - } - } + m_busDevices = new CCECDeviceMap(this); } CCECProcessor::~CCECProcessor(void) { - m_bStarted = false; - m_startCondition.Broadcast(); - StopThread(); - - delete m_communication; - m_communication = NULL; - m_controller = NULL; - for (unsigned int iPtr = 0; iPtr < 16; iPtr++) - delete m_busDevices[iPtr]; + m_bStallCommunication = false; + DELETE_AND_NULL(m_addrAllocator); + Close(); + DELETE_AND_NULL(m_busDevices); } -bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs) +bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */) { - bool bReturn(false); CLockObject lock(m_mutex); - if (m_communication) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "existing connection handler found"); - return bReturn; - } - - m_communication = new CAdapterCommunication(this, strPort, iBaudRate); - - /* check for an already opened connection */ - if (m_communication->IsOpen()) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "connection already opened"); - return bReturn; - } - - uint64_t iNow = GetTimeMs(); - uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT; - unsigned iConnectTry(0), iPingTry(0), iFwVersionTry(0); - bool bConnected(false), bPinged(false); - - /* open a new connection */ - while (iNow < iTarget && (bConnected = m_communication->Open(iTimeoutMs)) == false) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry); - Sleep(500); - iNow = GetTimeMs(); - } - - /* try to ping the adapter */ - while (bConnected && iNow < iTarget && (bPinged = m_communication->PingAdapter()) == false) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry); - Sleep(500); - iNow = GetTimeMs(); - } + // open a connection + if (!OpenConnection(strPort, iBaudRate, iTimeoutMs)) + return false; - /* try to read the firmware version */ - uint16_t iFirmwareVersion(CEC_FW_VERSION_UNKNOWN); - while (bPinged && iNow < iTarget && (iFirmwareVersion = m_communication->GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN) + // create the processor thread + if (!IsRunning()) { - CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry); - Sleep(500); - iNow = GetTimeMs(); + if (!CreateThread()) + { + m_libcec->AddLog(CEC_LOG_ERROR, "could not create a processor thread"); + return false; + } } - if ((bReturn = iFirmwareVersion != CEC_FW_VERSION_UNKNOWN) == true) - CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d", iFirmwareVersion); - - return bReturn; + return true; } -void CCECProcessor::SetInitialised(bool bSetTo /* = true */) +void CCECProcessor::Close(void) { + // mark as uninitialised + SetCECInitialised(false); + + // stop the processor + DELETE_AND_NULL(m_connCheck); + StopThread(-1); + m_inBuffer.Broadcast(); + StopThread(); + + // close the connection CLockObject lock(m_mutex); - m_bInitialised = bSetTo; + DELETE_AND_NULL(m_communication); } -bool CCECProcessor::Initialise(void) +void CCECProcessor::ResetMembers(void) { - bool bReturn(false); - { - CLockObject lock(m_mutex); - if (!m_logicalAddresses.IsEmpty()) - m_logicalAddresses.Clear(); - - if (!FindLogicalAddresses()) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "could not detect our logical addresses"); - return bReturn; - } + // close the connection + DELETE_AND_NULL(m_communication); - /* only set our OSD name for the primary device */ - m_busDevices[m_logicalAddresses.primary]->m_strDeviceName = m_strDeviceName; - } - - /* get the vendor id from the TV, so we are using the correct handler */ - m_busDevices[CECDEVICE_TV]->RequestVendorId(); - ReplaceHandlers(); - - if ((bReturn = SetHDMIPort(m_iBaseDevice, m_iHDMIPort, true)) == false) - CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set HDMI port %d on %s (%x)", m_iHDMIPort, ToString(m_iBaseDevice), (uint8_t)m_iBaseDevice); - - SetInitialised(bReturn); - - return bReturn; + // reset the other members to the initial state + m_iStandardLineTimeout = 3; + m_iRetryLineTimeout = 3; + m_iLastTransmission = 0; + m_busDevices->ResetDeviceStatus(); } -bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */) +bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs, bool bStartListening /* = true */) { bool bReturn(false); + CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT); - { - CLockObject lock(m_mutex); - if (!OpenConnection(strPort, iBaudRate, iTimeoutMs)) - return bReturn; + // ensure that a previous connection is closed + Close(); - /* create the processor thread */ - if (!CreateThread() || !m_startCondition.Wait(m_mutex) || !m_bStarted) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread"); - return bReturn; - } - } + // reset all member to the initial state + ResetMembers(); - if ((bReturn = Initialise()) == false) - { - CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread"); - StopThread(true); - } - else + // check whether the Close() method deleted any previous connection + if (m_communication) { - CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started"); + m_libcec->AddLog(CEC_LOG_ERROR, "previous connection could not be closed"); + return bReturn; } - return bReturn; -} + // create a new connection + m_communication = CAdapterFactory(this->m_libcec).GetInstance(strPort, iBaudRate); -bool CCECProcessor::TryLogicalAddress(cec_logical_address address) -{ - if (m_busDevices[address]->TryLogicalAddress()) + // open a new connection + unsigned iConnectTry(0); + while (timeout.TimeLeft() > 0 && (bReturn = m_communication->Open((timeout.TimeLeft() / CEC_CONNECT_TRIES), false, bStartListening)) == false) { - m_logicalAddresses.Set(address); - return true; + m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry); + m_communication->Close(); + CEvent::Sleep(CEC_DEFAULT_CONNECT_RETRY_WAIT); } - return false; -} + m_libcec->AddLog(CEC_LOG_NOTICE, "connection opened"); -bool CCECProcessor::FindLogicalAddressRecordingDevice(void) -{ - CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'"); - return TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1) || - TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2) || - TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3); -} - -bool CCECProcessor::FindLogicalAddressTuner(void) -{ - CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'"); - return TryLogicalAddress(CECDEVICE_TUNER1) || - TryLogicalAddress(CECDEVICE_TUNER2) || - TryLogicalAddress(CECDEVICE_TUNER3) || - TryLogicalAddress(CECDEVICE_TUNER4); -} + // mark as initialised + SetCECInitialised(true); -bool CCECProcessor::FindLogicalAddressPlaybackDevice(void) -{ - CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'"); - return TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1) || - TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2) || - TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3); + return bReturn; } -bool CCECProcessor::FindLogicalAddressAudioSystem(void) +bool CCECProcessor::CECInitialised(void) { - CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audio'"); - return TryLogicalAddress(CECDEVICE_AUDIOSYSTEM); + CLockObject lock(m_threadMutex); + return m_bInitialised; } -bool CCECProcessor::ChangeDeviceType(cec_device_type from, cec_device_type to) +void CCECProcessor::SetCECInitialised(bool bSetTo /* = true */) { - bool bChanged(false); - - CLibCEC::AddLog(CEC_LOG_NOTICE, "changing device type '%s' into '%s'", ToString(from), ToString(to)); - - CLockObject lock(m_mutex); - CCECBusDevice *previousDevice = GetDeviceByType(from); - m_logicalAddresses.primary = CECDEVICE_UNKNOWN; - - for (unsigned int iPtr = 0; iPtr < 5; iPtr++) { - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) - continue; - - if (m_types.types[iPtr] == from) - { - bChanged = true; - m_types.types[iPtr] = to; - } - else if (m_types.types[iPtr] == to && bChanged) - { - m_types.types[iPtr] = CEC_DEVICE_TYPE_RESERVED; - } + CLockObject lock(m_mutex); + m_bInitialised = bSetTo; } + if (!bSetTo) + UnregisterClients(); +} - if (bChanged) +bool CCECProcessor::TryLogicalAddress(cec_logical_address address, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */) +{ + // find the device + CCECBusDevice *device = m_busDevices->At(address); + if (device) { - FindLogicalAddresses(); - - CCECBusDevice *newDevice = GetDeviceByType(to); - if (previousDevice && newDevice) - { - newDevice->SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC); - previousDevice->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT); - - newDevice->SetCecVersion(previousDevice->GetCecVersion(false)); - previousDevice->SetCecVersion(CEC_VERSION_UNKNOWN); + // check if it's already marked as present or used + if (device->IsPresent() || device->IsHandledByLibCEC()) + return false; - newDevice->SetMenuLanguage(previousDevice->GetMenuLanguage(false)); - cec_menu_language lang; - lang.device = previousDevice->GetLogicalAddress(); - for (unsigned int iPtr = 0; iPtr < 4; iPtr++) - lang.language[iPtr] = '?'; - lang.language[3] = 0; - previousDevice->SetMenuLanguage(lang); - - newDevice->SetMenuState(previousDevice->GetMenuState()); - previousDevice->SetMenuState(CEC_MENU_STATE_DEACTIVATED); - - newDevice->SetOSDName(previousDevice->GetOSDName(false)); - previousDevice->SetOSDName(ToString(previousDevice->GetLogicalAddress())); - - newDevice->SetPhysicalAddress(previousDevice->GetPhysicalAddress(false)); - previousDevice->SetPhysicalAddress(0xFFFF); - - newDevice->SetPowerStatus(previousDevice->GetPowerStatus(false)); - previousDevice->SetPowerStatus(CEC_POWER_STATUS_UNKNOWN); - - newDevice->SetVendorId(previousDevice->GetVendorId(false)); - previousDevice->SetVendorId(CEC_VENDOR_UNKNOWN); - - if ((from == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || from == CEC_DEVICE_TYPE_RECORDING_DEVICE) && - (to == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || to == CEC_DEVICE_TYPE_RECORDING_DEVICE)) - { - ((CCECPlaybackDevice *) newDevice)->SetDeckControlMode(((CCECPlaybackDevice *) previousDevice)->GetDeckControlMode()); - ((CCECPlaybackDevice *) previousDevice)->SetDeckControlMode(CEC_DECK_CONTROL_MODE_STOP); - - ((CCECPlaybackDevice *) newDevice)->SetDeckStatus(((CCECPlaybackDevice *) previousDevice)->GetDeckStatus()); - ((CCECPlaybackDevice *) previousDevice)->SetDeckStatus(CEC_DECK_INFO_STOP); - } - } + // poll the LA if not + return device->TryLogicalAddress(libCECSpecVersion); } - return true; + return false; } -bool CCECProcessor::FindLogicalAddresses(void) +void CCECProcessor::ReplaceHandlers(void) { - bool bReturn(true); - m_logicalAddresses.Clear(); - - for (unsigned int iPtr = 0; iPtr < 5; iPtr++) - { - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) - continue; - - CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - device %d: type %d", __FUNCTION__, iPtr, m_types.types[iPtr]); - - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE) - bReturn &= FindLogicalAddressRecordingDevice(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_TUNER) - bReturn &= FindLogicalAddressTuner(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE) - bReturn &= FindLogicalAddressPlaybackDevice(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM) - bReturn &= FindLogicalAddressAudioSystem(); - } - - if (bReturn) - SetAckMask(m_logicalAddresses.AckMask()); + if (!CECInitialised()) + return; - return bReturn; + // check each device + for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++) + it->second->ReplaceHandler(true); } -void CCECProcessor::ReplaceHandlers(void) +bool CCECProcessor::OnCommandReceived(const cec_command &command) { - for (uint8_t iPtr = 0; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++) - m_busDevices[iPtr]->ReplaceHandler(m_bInitialised); + return m_inBuffer.Push(command); } void *CCECProcessor::Process(void) { - bool bParseFrame(false); - cec_command command; - CCECAdapterMessage msg; + m_libcec->AddLog(CEC_LOG_DEBUG, "processor thread started"); - { - CLockObject lock(m_mutex); - m_bStarted = true; - CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started"); - m_startCondition.Signal(); - } + if (!m_connCheck) + m_connCheck = new CCECStandbyProtection(this); + m_connCheck->CreateThread(); - while (!IsStopped()) + cec_command command; command.Clear(); + CTimeout activeSourceCheck(ACTIVE_SOURCE_CHECK_INTERVAL); + CTimeout tvPresentCheck(TV_PRESENT_CHECK_INTERVAL); + + // as long as we're not being stopped and the connection is open + while (!IsStopped() && m_communication->IsOpen()) { - ReplaceHandlers(); - command.Clear(); - msg.Clear(); + // wait for a new incoming command, and process it + if (m_inBuffer.Pop(command, CEC_PROCESSOR_SIGNAL_WAIT_TIME)) + ProcessCommand(command); + if (CECInitialised() && !IsStopped()) { - CLockObject lock(m_mutex); - if (m_commandBuffer.Pop(command)) - bParseFrame = true; - else if (m_communication->IsOpen() && m_communication->Read(msg, 50)) - { - if ((bParseFrame = (ParseMessage(msg) && !IsStopped())) == true) - command = m_currentframe; - } - } - - if (bParseFrame) - ParseCommand(command); - bParseFrame = false; - - Sleep(5); - - m_controller->CheckKeypressTimeout(); - } - - if (m_communication) - m_communication->Close(); - - return NULL; -} - -bool CCECProcessor::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */) -{ - bool bReturn(false); - - if (!IsRunning()) - return bReturn; + // check clients for keypress timeouts + m_libcec->CheckKeypressTimeout(); - cec_logical_address addr = m_logicalAddresses.primary; + // check if we need to replace handlers + ReplaceHandlers(); - if (type != CEC_DEVICE_TYPE_RESERVED) - { - for (uint8_t iPtr = 0; iPtr <= 11; iPtr++) - { - if (m_logicalAddresses[iPtr] && m_busDevices[iPtr]->m_type == type) + // check whether we need to activate a source, if it failed before + if (activeSourceCheck.TimeLeft() == 0) { - addr = (cec_logical_address) iPtr; - break; + if (CECInitialised()) + TransmitPendingActiveSourceCommands(); + activeSourceCheck.Init(ACTIVE_SOURCE_CHECK_INTERVAL); } - } - } - - m_busDevices[addr]->SetActiveSource(); - if (m_busDevices[addr]->GetPhysicalAddress(false) != 0xFFFF) - { - bReturn = m_busDevices[addr]->TransmitActiveSource(); - - if (bReturn) - { - m_busDevices[addr]->SetMenuState(CEC_MENU_STATE_ACTIVATED); - m_busDevices[addr]->TransmitMenuState(CECDEVICE_TV); - } - if (bReturn && (m_busDevices[addr]->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || - m_busDevices[addr]->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) && - m_busDevices[addr]->GetHandler()->SendDeckStatusUpdateOnActiveSource()) - { - bReturn = ((CCECPlaybackDevice *)m_busDevices[addr])->TransmitDeckStatus(CECDEVICE_TV); + // check whether the TV is present and responding + if (tvPresentCheck.TimeLeft() == 0) + { + CCECClient *primary = GetPrimaryClient(); + // only check whether the tv responds to polls when a client is connected and not in monitoring mode + if (primary && primary->GetConfiguration()->bMonitorOnly != 1) + { + if (!m_busDevices->At(CECDEVICE_TV)->IsPresent()) + { + libcec_parameter param; + param.paramType = CEC_PARAMETER_TYPE_STRING; + param.paramData = (void*)"TV does not respond to CEC polls"; + primary->Alert(CEC_ALERT_TV_POLL_FAILED, param); + } + } + tvPresentCheck.Init(TV_PRESENT_CHECK_INTERVAL); + } } } - return bReturn; + return NULL; } -bool CCECProcessor::SetActiveSource(uint16_t iStreamPath) +bool CCECProcessor::ActivateSource(uint16_t iStreamPath) { bool bReturn(false); + // find the device with the given PA CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath); + // and make it the active source when found if (device) - { - device->SetActiveSource(); - bReturn = true; - } + bReturn = device->ActivateSource(); + else + m_libcec->AddLog(CEC_LOG_DEBUG, "device with PA '%04x' not found", iStreamPath); return bReturn; } +void CCECProcessor::SetActiveSource(bool bSetTo, bool bClientUnregistered) +{ + if (m_communication) + m_communication->SetActiveSource(bSetTo, bClientUnregistered); +} + void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout) { CLockObject lock(m_mutex); m_iStandardLineTimeout = iTimeout; } +uint8_t CCECProcessor::GetStandardLineTimeout(void) +{ + CLockObject lock(m_mutex); + return m_iStandardLineTimeout; +} + void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout) { CLockObject lock(m_mutex); m_iRetryLineTimeout = iTimeout; } -bool CCECProcessor::SetActiveView(void) +uint8_t CCECProcessor::GetRetryLineTimeout(void) { - return SetActiveSource(m_types.IsEmpty() ? CEC_DEVICE_TYPE_RESERVED : m_types[0]); + CLockObject lock(m_mutex); + return m_iRetryLineTimeout; } -bool CCECProcessor::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */) +bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress) { - bool bReturn(false); - - CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE); - if (device) - { - ((CCECPlaybackDevice *) device)->SetDeckControlMode(mode); - if (bSendUpdate) - ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV); - bReturn = true; - } - - return bReturn; + CCECBusDevice *device = GetDeviceByPhysicalAddress(iPhysicalAddress); + return device != NULL; } -bool CCECProcessor::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true */) +void CCECProcessor::LogOutput(const cec_command &data) { - bool bReturn(false); + CStdString strTx; - CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE); - if (device) - { - ((CCECPlaybackDevice *) device)->SetDeckStatus(info); - if (bSendUpdate) - ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV); - bReturn = true; - } + // initiator and destination + strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination); - return bReturn; + // append the opcode + if (data.opcode_set) + strTx.AppendFormat(":%02x", (uint8_t)data.opcode); + + // append the parameters + for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++) + strTx.AppendFormat(":%02x", data.parameters[iPtr]); + + // and log it + m_libcec->AddLog(CEC_LOG_TRAFFIC, strTx.c_str()); } -bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, bool bForce /* = false */) +bool CCECProcessor::PollDevice(cec_logical_address iAddress) { - bool bReturn(false); - CLockObject lock(m_mutex); + // try to find the primary device + CCECBusDevice *primary = GetPrimaryDevice(); + // poll the destination, with the primary as source + if (primary) + return primary->TransmitPoll(iAddress, true); - m_iBaseDevice = iBaseDevice; - m_iHDMIPort = iPort; - if (!m_bStarted && !bForce) - return true; + CCECBusDevice *device = m_busDevices->At(CECDEVICE_UNREGISTERED); + if (device) + return device->TransmitPoll(iAddress, true); - CLibCEC::AddLog(CEC_LOG_DEBUG, "setting HDMI port to %d on device %s (%d)", iPort, ToString(iBaseDevice), (int)iBaseDevice); + return false; +} - uint16_t iPhysicalAddress(0); - if (iBaseDevice > CECDEVICE_TV) - { - lock.Unlock(); - iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress(); - lock.Lock(); - } +CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bSuppressUpdate /* = true */) +{ + return m_busDevices ? + m_busDevices->GetDeviceByPhysicalAddress(iPhysicalAddress, bSuppressUpdate) : + NULL; +} - if (iPhysicalAddress < 0xffff) - { - if (iPhysicalAddress == 0) - iPhysicalAddress += 0x1000 * iPort; - else if (iPhysicalAddress % 0x1000 == 0) - iPhysicalAddress += 0x100 * iPort; - else if (iPhysicalAddress % 0x100 == 0) - iPhysicalAddress += 0x10 * iPort; - else if (iPhysicalAddress % 0x10 == 0) - iPhysicalAddress += iPort; +CCECBusDevice *CCECProcessor::GetDevice(cec_logical_address address) const +{ + return m_busDevices ? + m_busDevices->At(address) : + NULL; +} - bReturn = true; - } +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 (!bReturn) - CLibCEC::AddLog(CEC_LOG_ERROR, "failed to set the physical address"); - else + if (bRequestActiveSource) { - lock.Unlock(); - SetPhysicalAddress(iPhysicalAddress); + // request the active source from the bus + CCECBusDevice *primary = GetPrimaryDevice(); + if (primary) + { + primary->RequestActiveSource(); + return GetActiveSource(false); + } } - return bReturn; + // unknown or none + return CECDEVICE_UNKNOWN; } -bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress) +bool CCECProcessor::IsActiveSource(cec_logical_address iAddress) { - for (unsigned int iPtr = 0; iPtr < 15; iPtr++) - { - if (m_busDevices[iPtr]->GetPhysicalAddress(false) == iPhysicalAddress) - return true; - } - return false; + CCECBusDevice *device = m_busDevices->At(iAddress); + return device && device->IsActiveSource(); } -bool CCECProcessor::TransmitInactiveSource(void) +bool CCECProcessor::Transmit(const cec_command &data, bool bIsReply) { - if (!IsRunning()) - return false; + cec_command transmitData(data); + uint8_t iMaxTries(0); + bool bRetry(true); + uint8_t iTries(0); - if (!m_logicalAddresses.IsEmpty() && m_busDevices[m_logicalAddresses.primary]) - return m_busDevices[m_logicalAddresses.primary]->TransmitInactiveSource(); - return false; -} + // get the current timeout setting + uint8_t iLineTimeout(GetStandardLineTimeout()); -void CCECProcessor::LogOutput(const cec_command &data) -{ - CStdString strTx; - strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination); - if (data.opcode_set) - strTx.AppendFormat(":%02x", (uint8_t)data.opcode); + // reset the state of this message to 'unknown' + cec_adapter_message_state adapterState = ADAPTER_MESSAGE_STATE_UNKNOWN; - for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++) - strTx.AppendFormat(":%02x", data.parameters[iPtr]); - CLibCEC::AddLog(CEC_LOG_TRAFFIC, strTx.c_str()); -} - -bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress) -{ CLockObject lock(m_mutex); - if (m_logicalAddresses.primary != iLogicalAddress) + if (!m_communication) + return false; + + if (!m_communication->SupportsSourceLogicalAddress(transmitData.initiator)) { - CLibCEC::AddLog(CEC_LOG_NOTICE, "<< setting primary logical address to %1x", iLogicalAddress); - m_logicalAddresses.primary = iLogicalAddress; - m_logicalAddresses.Set(iLogicalAddress); - return SetAckMask(m_logicalAddresses.AckMask()); + if (transmitData.initiator == CECDEVICE_UNREGISTERED && m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE)) + { + m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter. using '%s' instead", ToString(transmitData.initiator), ToString(CECDEVICE_FREEUSE)); + transmitData.initiator = CECDEVICE_FREEUSE; + } + else + { + m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter", ToString(transmitData.initiator)); + return false; + } } - return true; -} + LogOutput(transmitData); -bool CCECProcessor::SetMenuState(cec_menu_state state, bool bSendUpdate /* = true */) -{ - for (uint8_t iPtr = 0; iPtr < 16; iPtr++) + // find the initiator device + CCECBusDevice *initiator = m_busDevices->At(transmitData.initiator); + if (!initiator) { - if (m_logicalAddresses[iPtr]) - m_busDevices[iPtr]->SetMenuState(state); + m_libcec->AddLog(CEC_LOG_WARNING, "invalid initiator"); + return false; } - if (bSendUpdate) - m_busDevices[m_logicalAddresses.primary]->TransmitMenuState(CECDEVICE_TV); + // find the destination device, if it's not the broadcast address + if (transmitData.destination != CECDEVICE_BROADCAST) + { + // check if the device is marked as handled by libCEC + CCECBusDevice *destination = m_busDevices->At(transmitData.destination); + if (destination && destination->IsHandledByLibCEC()) + { + // and reject the command if it's trying to send data to a device that is handled by libCEC + m_libcec->AddLog(CEC_LOG_WARNING, "not sending data to myself!"); + return false; + } + } - return true; -} + // wait until we finished allocating a new LA if it got lost + lock.Unlock(); + while (m_bStallCommunication) Sleep(5); + lock.Lock(); -bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress, bool bSendUpdate /* = true */) -{ - bool bSendActiveView(false); - bool bReturn(false); - cec_logical_addresses sendUpdatesTo; + m_iLastTransmission = GetTimeMs(); + // set the number of tries + iMaxTries = initiator->GetHandler()->GetTransmitRetries() + 1; + initiator->MarkHandlerReady(); + // and try to send the command + while (bRetry && ++iTries < iMaxTries) { - CLockObject lock(m_mutex); - if (!m_logicalAddresses.IsEmpty()) - { - bool bWasActiveSource(false); - for (uint8_t iPtr = 0; iPtr < 15; iPtr++) - if (m_logicalAddresses[iPtr]) - { - bWasActiveSource |= m_busDevices[iPtr]->IsActiveSource(); - m_busDevices[iPtr]->SetInactiveSource(); - m_busDevices[iPtr]->SetPhysicalAddress(iPhysicalAddress); - if (bSendUpdate) - sendUpdatesTo.Set((cec_logical_address)iPtr); - } + if (initiator->IsUnsupportedFeature(transmitData.opcode)) + return false; - bSendActiveView = bWasActiveSource && bSendUpdate; - bReturn = true; - } + adapterState = !IsStopped() && m_communication && m_communication->IsOpen() ? + m_communication->Write(transmitData, bRetry, iLineTimeout, bIsReply) : + ADAPTER_MESSAGE_STATE_ERROR; + iLineTimeout = m_iRetryLineTimeout; } - for (uint8_t iPtr = 0; iPtr < 15; iPtr++) - if (sendUpdatesTo[iPtr]) - m_busDevices[iPtr]->TransmitPhysicalAddress(); + return bIsReply ? + adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED || adapterState == ADAPTER_MESSAGE_STATE_SENT || adapterState == ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT : + adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED; +} - if (bSendActiveView) - SetActiveView(); +void CCECProcessor::TransmitAbort(cec_logical_address source, cec_logical_address destination, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */) +{ + m_libcec->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message"); - return bReturn; + cec_command command; + cec_command::Format(command, source, destination, CEC_OPCODE_FEATURE_ABORT); + command.parameters.PushBack((uint8_t)opcode); + command.parameters.PushBack((uint8_t)reason); + + Transmit(command, true); } -bool CCECProcessor::SwitchMonitoring(bool bEnable) +void CCECProcessor::ProcessCommand(const cec_command &command) { - CLibCEC::AddLog(CEC_LOG_NOTICE, "== %s monitoring mode ==", bEnable ? "enabling" : "disabling"); + // log the command + m_libcec->AddLog(CEC_LOG_TRAFFIC, ToString(command).c_str()); - { - CLockObject lock(m_mutex); - m_bMonitor = bEnable; - } + // find the initiator + CCECBusDevice *device = m_busDevices->At(command.initiator); - if (bEnable) - return SetAckMask(0); - else - return SetAckMask(m_logicalAddresses.AckMask()); + if (device) + device->HandleCommand(command); } -bool CCECProcessor::PollDevice(cec_logical_address iAddress) +bool CCECProcessor::IsPresentDevice(cec_logical_address address) { - if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress]) - { - return m_logicalAddresses.primary == CECDEVICE_UNKNOWN ? - m_busDevices[iAddress]->TransmitPoll(iAddress) : - m_busDevices[m_logicalAddresses.primary]->TransmitPoll(iAddress); - } - return false; + CCECBusDevice *device = m_busDevices->At(address); + return device && device->GetStatus() == CEC_DEVICE_STATUS_PRESENT; } -uint8_t CCECProcessor::VolumeUp(bool bSendRelease /* = true */) +bool CCECProcessor::IsPresentDeviceType(cec_device_type type) { - uint8_t status = 0; - if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM)) - status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeUp(bSendRelease); - - return status; + CECDEVICEVEC devices; + m_busDevices->GetByType(type, devices); + CCECDeviceMap::FilterActive(devices); + return !devices.empty(); } -uint8_t CCECProcessor::VolumeDown(bool bSendRelease /* = true */) +uint16_t CCECProcessor::GetDetectedPhysicalAddress(void) const { - uint8_t status = 0; - if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM)) - status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeDown(bSendRelease); - - return status; + return m_communication ? m_communication->GetPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS; } -uint8_t CCECProcessor::MuteAudio(bool bSendRelease /* = true */) +bool CCECProcessor::ClearLogicalAddresses(void) { - uint8_t status = 0; - if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM)) - status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->MuteAudio(bSendRelease); + cec_logical_addresses addresses; addresses.Clear(); + return SetLogicalAddresses(addresses); +} - return status; +bool CCECProcessor::SetLogicalAddresses(const cec_logical_addresses &addresses) +{ + return m_communication ? m_communication->SetLogicalAddresses(addresses) : false; } -CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bRefresh /* = false */) const +bool CCECProcessor::StandbyDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices) { - if (m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress(false) == iPhysicalAddress) - return m_busDevices[m_logicalAddresses.primary]; + bool bReturn(true); + for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++) + bReturn &= (*it)->Standby(initiator); + return bReturn; +} - CCECBusDevice *device = NULL; - for (unsigned int iPtr = 0; iPtr < 16; iPtr++) - { - if (m_busDevices[iPtr]->GetPhysicalAddress(bRefresh) == iPhysicalAddress) - { - device = m_busDevices[iPtr]; - break; - } - } +bool CCECProcessor::StandbyDevice(const cec_logical_address initiator, cec_logical_address address) +{ + CCECBusDevice *device = m_busDevices->At(address); + return device ? device->Standby(initiator) : false; +} - return device; +bool CCECProcessor::PowerOnDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices) +{ + bool bReturn(true); + for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++) + bReturn &= (*it)->PowerOn(initiator); + return bReturn; } -CCECBusDevice *CCECProcessor::GetDeviceByType(cec_device_type type) const +bool CCECProcessor::PowerOnDevice(const cec_logical_address initiator, cec_logical_address address) { - CCECBusDevice *device = NULL; + CCECBusDevice *device = m_busDevices->At(address); + return device ? device->PowerOn(initiator) : false; +} - for (uint8_t iPtr = 0; iPtr < 16; iPtr++) +bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */) +{ + bool bReturn(false); + // open a connection if no connection has been opened + if (!m_communication && strPort) { - if (m_busDevices[iPtr]->m_type == type && m_logicalAddresses[iPtr]) + CAdapterFactory factory(this->m_libcec); + IAdapterCommunication *comm = factory.GetInstance(strPort); + CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT); + int iConnectTry(0); + while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false) { - device = m_busDevices[iPtr]; - break; + m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry); + comm->Close(); + Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT); + } + if (comm->IsOpen()) + { + bReturn = comm->StartBootloader(); + DELETE_AND_NULL(comm); } + return bReturn; + } + else + { + m_communication->StartBootloader(); + Close(); + bReturn = true; } - return device; + return bReturn; } -CCECBusDevice *CCECProcessor::GetPrimaryDevice(void) const +bool CCECProcessor::PingAdapter(void) { - CCECBusDevice *device(NULL); - cec_logical_address primary = m_logicalAddresses.primary; - if (primary != CECDEVICE_UNKNOWN) - device = m_busDevices[primary]; - return device; + return m_communication->PingAdapter(); } -cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress) +void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination) { - return m_busDevices[iAddress]->GetCecVersion(); + CCECBusDevice *device = m_busDevices->At(destination); + if (device) + device->HandlePollFrom(initiator); } -cec_osd_name CCECProcessor::GetDeviceOSDName(cec_logical_address iAddress) +bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator) { - CStdString strOSDName = m_busDevices[iAddress]->GetOSDName(); - cec_osd_name retVal; - - snprintf(retVal.name, sizeof(retVal.name), "%s", strOSDName.c_str()); - retVal.device = iAddress; + CCECBusDevice *device = m_busDevices->At(initiator); + return !device || !device->HandleReceiveFailed(); +} - return retVal; +bool CCECProcessor::CanPersistConfiguration(void) +{ + return m_communication ? m_communication->GetFirmwareVersion() >= 2 : false; } -bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language) +bool CCECProcessor::PersistConfiguration(const libcec_configuration &configuration) { - if (m_busDevices[iAddress]) + libcec_configuration persistConfiguration = configuration; + if (!CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress)) { - *language = m_busDevices[iAddress]->GetMenuLanguage(); - return (strcmp(language->language, "???") != 0); + CCECBusDevice *device = GetPrimaryDevice(); + if (device) + persistConfiguration.iPhysicalAddress = device->GetCurrentPhysicalAddress(); } - return false; + + return m_communication ? m_communication->PersistConfiguration(persistConfiguration) : false; } -uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress) +void CCECProcessor::RescanActiveDevices(void) { - if (m_busDevices[iAddress]) - return m_busDevices[iAddress]->GetVendorId(); - return false; + for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++) + it->second->GetStatus(true); } -uint16_t CCECProcessor::GetDevicePhysicalAddress(cec_logical_address iAddress) +bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */) { - if (m_busDevices[iAddress]) - return m_busDevices[iAddress]->GetPhysicalAddress(false); - return false; + if (!OpenConnection(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs, false)) + return false; + + config->iFirmwareVersion = m_communication->GetFirmwareVersion(); + config->iPhysicalAddress = m_communication->GetPhysicalAddress(); + config->iFirmwareBuildDate = m_communication->GetFirmwareBuildDate(); + config->adapterType = m_communication->GetAdapterType(); + + Close(); + + return true; } -cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress) +bool CCECProcessor::TransmitPendingActiveSourceCommands(void) { - if (m_busDevices[iAddress]) - return m_busDevices[iAddress]->GetPowerStatus(); - return CEC_POWER_STATUS_UNKNOWN; + bool bReturn(true); + for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++) + bReturn &= it->second->TransmitPendingActiveSourceCommands(); + return bReturn; } -cec_logical_address CCECProcessor::GetActiveSource(void) +CCECTV *CCECProcessor::GetTV(void) const { - for (uint8_t iPtr = 0; iPtr <= 11; iPtr++) - { - if (m_busDevices[iPtr]->IsActiveSource()) - return (cec_logical_address)iPtr; - } - - return CECDEVICE_UNKNOWN; + return CCECBusDevice::AsTV(m_busDevices->At(CECDEVICE_TV)); } -bool CCECProcessor::IsActiveSource(cec_logical_address iAddress) +CCECAudioSystem *CCECProcessor::GetAudioSystem(void) const { - return m_busDevices[iAddress]->IsActiveSource(); + return CCECBusDevice::AsAudioSystem(m_busDevices->At(CECDEVICE_AUDIOSYSTEM)); } -bool CCECProcessor::Transmit(const cec_command &data) +CCECPlaybackDevice *CCECProcessor::GetPlaybackDevice(cec_logical_address address) const { - bool bReturn(false); - LogOutput(data); + return CCECBusDevice::AsPlaybackDevice(m_busDevices->At(address)); +} - CCECAdapterMessage *output = new CCECAdapterMessage(data); +CCECRecordingDevice *CCECProcessor::GetRecordingDevice(cec_logical_address address) const +{ + return CCECBusDevice::AsRecordingDevice(m_busDevices->At(address)); +} - /* set the number of retries */ - if (data.opcode == CEC_OPCODE_NONE) - output->maxTries = 1; - else if (data.initiator != CECDEVICE_BROADCAST) - output->maxTries = m_busDevices[data.initiator]->GetHandler()->GetTransmitRetries() + 1; +CCECTuner *CCECProcessor::GetTuner(cec_logical_address address) const +{ + return CCECBusDevice::AsTuner(m_busDevices->At(address)); +} - bReturn = Transmit(output); +bool CCECProcessor::AllocateLogicalAddresses(CCECClient* client) +{ + libcec_configuration &configuration = *client->GetConfiguration(); - /* set to "not present" on failed ack */ - if (output->state == ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED && - output->Destination() != CECDEVICE_BROADCAST) - m_busDevices[output->Destination()]->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT); + // mark as unregistered + client->SetRegistered(false); - delete output; - return bReturn; -} + // unregister this client from the old addresses + CECDEVICEVEC devices; + m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses); + for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++) + { + // remove client entry + CLockObject lock(m_mutex); + m_clients.erase((*it)->GetLogicalAddress()); + } -bool CCECProcessor::Transmit(CCECAdapterMessage *output) -{ - bool bReturn(false); - CLockObject lock(m_mutex); + // find logical addresses for this client + if (!client->AllocateLogicalAddresses()) { - if (!m_communication) - return bReturn; + m_libcec->AddLog(CEC_LOG_ERROR, "failed to find a free logical address for the client"); + return false; + } - m_iLastTransmission = GetTimeMs(); - m_communication->SetLineTimeout(m_iStandardLineTimeout); - output->tries = 0; + // register this client on the new addresses + devices.clear(); + m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses); + for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++) + { + // set the physical address of the device at this LA + if (CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress)) + (*it)->SetPhysicalAddress(configuration.iPhysicalAddress); - do - { - if (output->tries > 0) - m_communication->SetLineTimeout(m_iRetryLineTimeout); - bReturn = m_communication->Write(output); - if (!bReturn) - Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT); - }while (!bReturn && output->transmit_timeout > 0 && output->NeedsRetry() && ++output->tries < output->maxTries); + // replace a previous client + CLockObject lock(m_mutex); + m_clients.erase((*it)->GetLogicalAddress()); + m_clients.insert(make_pair((*it)->GetLogicalAddress(), client)); } - m_communication->SetLineTimeout(m_iStandardLineTimeout); + // set the new ackmask + SetLogicalAddresses(GetLogicalAddresses()); - return bReturn; + // resume outgoing communication + m_bStallCommunication = false; + + return true; } -void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */) +uint16_t CCECProcessor::GetPhysicalAddressFromEeprom(void) { - CLibCEC::AddLog(CEC_LOG_DEBUG, "<< transmitting abort message"); - - cec_command command; - // TODO - cec_command::Format(command, m_logicalAddresses.primary, address, CEC_OPCODE_FEATURE_ABORT); - command.parameters.PushBack((uint8_t)opcode); - command.parameters.PushBack((uint8_t)reason); - - Transmit(command); + libcec_configuration config; config.Clear(); + if (m_communication) + m_communication->GetConfiguration(config); + return config.iPhysicalAddress; } -bool CCECProcessor::ParseMessage(const CCECAdapterMessage &msg) +bool CCECProcessor::RegisterClient(CCECClient *client) { - bool bEom(false); - bool bIsError(msg.IsError()); + if (!client) + return false; - if (msg.IsEmpty()) - return bEom; + libcec_configuration &configuration = *client->GetConfiguration(); - switch(msg.Message()) + if (configuration.clientVersion < CEC_CLIENT_VERSION_2_0_0) { - case MSGCODE_FRAME_START: - { - m_currentframe.Clear(); - if (msg.Size() >= 2) - { - m_currentframe.initiator = msg.Initiator(); - m_currentframe.destination = msg.Destination(); - m_currentframe.ack = msg.IsACK(); - m_currentframe.eom = msg.IsEOM(); - } - if (m_currentframe.ack == 0x1) - { - m_lastInitiator = m_currentframe.initiator; - m_busDevices[m_lastInitiator]->GetHandler()->HandlePoll(m_currentframe.initiator, m_currentframe.destination); - } - } - break; - case MSGCODE_RECEIVE_FAILED: - { - if (m_lastInitiator != CECDEVICE_UNKNOWN) - bIsError = m_busDevices[m_lastInitiator]->GetHandler()->HandleReceiveFailed(); - } - break; - case MSGCODE_FRAME_DATA: + m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: client version %s is no longer supported", ToString((cec_client_version)configuration.clientVersion)); + return false; + } + + if (configuration.bMonitorOnly == 1) + return true; + + if (!CECInitialised()) + { + m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: CEC processor is not initialised"); + return false; + } + + // unregister the client first if it's already been marked as registered + if (client->IsRegistered()) + UnregisterClient(client); + + // ensure that controlled mode is enabled + m_communication->SetControlledMode(true); + m_bMonitor = false; + + // source logical address for requests + cec_logical_address sourceAddress(CECDEVICE_UNREGISTERED); + if (!m_communication->SupportsSourceLogicalAddress(CECDEVICE_UNREGISTERED)) + { + if (m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE)) + sourceAddress = CECDEVICE_FREEUSE; + else { - if (msg.Size() >= 2) - { - m_currentframe.PushBack(msg[1]); - m_currentframe.eom = msg.IsEOM(); - } - bEom = msg.IsEOM(); + m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: both unregistered and free use are not supported by the device"); + return false; } - break; - default: - break; } - CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString()); - return bEom; -} + // ensure that we know the vendor id of the TV + CCECBusDevice *tv = GetTV(); + cec_vendor_id tvVendor(tv->GetVendorId(sourceAddress)); -void CCECProcessor::ParseCommand(cec_command &command) -{ - CStdString dataStr; - dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode); - for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++) - dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]); - CLibCEC::AddLog(CEC_LOG_TRAFFIC, dataStr.c_str()); + // wait until the handler is replaced, to avoid double registrations + if (tvVendor != CEC_VENDOR_UNKNOWN && + CCECCommandHandler::HasSpecificHandler(tvVendor)) + { + while (!tv->ReplaceHandler(false)) + CEvent::Sleep(5); + } - if (!m_bMonitor && command.initiator >= CECDEVICE_TV && command.initiator <= CECDEVICE_BROADCAST) - m_busDevices[(uint8_t)command.initiator]->HandleCommand(command); -} + // get the configuration from the client + m_libcec->AddLog(CEC_LOG_NOTICE, "registering new CEC client - v%s", ToString((cec_client_version)configuration.clientVersion)); -cec_logical_addresses CCECProcessor::GetActiveDevices(void) -{ - cec_logical_addresses addresses; - addresses.Clear(); - for (unsigned int iPtr = 0; iPtr < 15; iPtr++) + // get the current ackmask, so we can restore it if polling fails + cec_logical_addresses previousMask = GetLogicalAddresses(); + + // mark as uninitialised + client->SetInitialised(false); + + // find logical addresses for this client + if (!AllocateLogicalAddresses(client)) { - if (m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - addresses.Set((cec_logical_address) iPtr); + m_libcec->AddLog(CEC_LOG_ERROR, "failed to register the new CEC client - cannot allocate the requested device types"); + SetLogicalAddresses(previousMask); + return false; } - return addresses; -} -bool CCECProcessor::IsPresentDevice(cec_logical_address address) -{ - return m_busDevices[address]->GetStatus() == CEC_DEVICE_STATUS_PRESENT; -} - -bool CCECProcessor::IsPresentDeviceType(cec_device_type type) -{ - for (unsigned int iPtr = 0; iPtr < 15; iPtr++) + // get the settings from the rom + if (configuration.bGetSettingsFromROM == 1) { - if (m_busDevices[iPtr]->GetType() == type && m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT) - return true; + libcec_configuration config; config.Clear(); + m_communication->GetConfiguration(config); + + CLockObject lock(m_mutex); + if (!config.deviceTypes.IsEmpty()) + configuration.deviceTypes = config.deviceTypes; + if (CLibCEC::IsValidPhysicalAddress(config.iPhysicalAddress)) + configuration.iPhysicalAddress = config.iPhysicalAddress; + snprintf(configuration.strDeviceName, 13, "%s", config.strDeviceName); } - return false; -} + // set the firmware version and build date + configuration.serverVersion = LIBCEC_VERSION_CURRENT; + configuration.iFirmwareVersion = m_communication->GetFirmwareVersion(); + configuration.iFirmwareBuildDate = m_communication->GetFirmwareBuildDate(); + configuration.adapterType = m_communication->GetAdapterType(); -uint16_t CCECProcessor::GetPhysicalAddress(void) const -{ - if (!m_logicalAddresses.IsEmpty() && m_busDevices[m_logicalAddresses.primary]) - return m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress(false); - return false; -} + // mark the client as registered + client->SetRegistered(true); -bool CCECProcessor::SetAckMask(uint16_t iMask) -{ - return m_communication->SetAckMask(iMask); -} + sourceAddress = client->GetPrimaryLogicalAdddress(); -bool CCECProcessor::TransmitKeypress(cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */) -{ - return m_busDevices[iDestination]->TransmitKeypress(key, bWait); -} + // initialise the client + bool bReturn = client->OnRegister(); -bool CCECProcessor::TransmitKeyRelease(cec_logical_address iDestination, bool bWait /* = true */) -{ - return m_busDevices[iDestination]->TransmitKeyRelease(bWait); -} + // log the new registration + CStdString strLog; + strLog.Format("%s: %s", bReturn ? "CEC client registered" : "failed to register the CEC client", client->GetConnectionInfo().c_str()); + m_libcec->AddLog(bReturn ? CEC_LOG_NOTICE : CEC_LOG_ERROR, strLog); -const char *CCECProcessor::ToString(const cec_device_type type) -{ - switch (type) + // display a warning if the firmware can be upgraded + if (bReturn && !IsRunningLatestFirmware()) { - case CEC_DEVICE_TYPE_AUDIO_SYSTEM: - return "audio system"; - case CEC_DEVICE_TYPE_PLAYBACK_DEVICE: - return "playback device"; - case CEC_DEVICE_TYPE_RECORDING_DEVICE: - return "recording device"; - case CEC_DEVICE_TYPE_RESERVED: - return "reserved"; - case CEC_DEVICE_TYPE_TUNER: - return "tuner"; - case CEC_DEVICE_TYPE_TV: - return "TV"; - default: - return "unknown"; + const char *strUpgradeMessage = "The firmware of this adapter can be upgraded. Please visit http://blog.pulse-eight.com/ for more information."; + m_libcec->AddLog(CEC_LOG_WARNING, strUpgradeMessage); + libcec_parameter param; + param.paramData = (void*)strUpgradeMessage; param.paramType = CEC_PARAMETER_TYPE_STRING; + client->Alert(CEC_ALERT_SERVICE_DEVICE, param); } -} -const char *CCECProcessor::ToString(const cec_menu_state state) -{ - switch (state) + // ensure that the command handler for the TV is initialised + if (bReturn) { - case CEC_MENU_STATE_ACTIVATED: - return "activated"; - case CEC_MENU_STATE_DEACTIVATED: - return "deactivated"; - default: - return "unknown"; + CCECCommandHandler *handler = GetTV()->GetHandler(); + if (handler) + handler->InitHandler(); + GetTV()->MarkHandlerReady(); } + + // report our OSD name to the TV, since some TVs don't request it + client->GetPrimaryDevice()->TransmitOSDName(CECDEVICE_TV, false); + + // request the power status of the TV + tv->RequestPowerStatus(sourceAddress, true, true); + + return bReturn; } -const char *CCECProcessor::ToString(const cec_version version) +bool CCECProcessor::UnregisterClient(CCECClient *client) { - switch (version) + if (!client) + return false; + + if (client->IsRegistered()) + m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering client: %s", client->GetConnectionInfo().c_str()); + + // notify the client that it will be unregistered + client->OnUnregister(); + { - case CEC_VERSION_1_2: - return "1.2"; - case CEC_VERSION_1_2A: - return "1.2a"; - case CEC_VERSION_1_3: - return "1.3"; - case CEC_VERSION_1_3A: - return "1.3a"; - case CEC_VERSION_1_4: - return "1.4"; - default: - return "unknown"; + CLockObject lock(m_mutex); + // find all devices that match the LA's of this client + CECDEVICEVEC devices; + m_busDevices->GetByLogicalAddresses(devices, client->GetConfiguration()->logicalAddresses); + for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++) + { + // find the client + map::iterator entry = m_clients.find((*it)->GetLogicalAddress()); + // unregister the client + if (entry != m_clients.end()) + m_clients.erase(entry); + + // reset the device status + (*it)->ResetDeviceStatus(true); + } } -} -const char *CCECProcessor::ToString(const cec_power_status status) -{ - switch (status) + // set the new ackmask + cec_logical_addresses addresses = GetLogicalAddresses(); + if (SetLogicalAddresses(addresses)) { - case CEC_POWER_STATUS_ON: - return "on"; - case CEC_POWER_STATUS_STANDBY: - return "standby"; - case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY: - return "in transition from on to standby"; - case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON: - return "in transition from standby to on"; - default: - return "unknown"; + // no more clients left, disable controlled mode + if (addresses.IsEmpty() && !m_bMonitor) + m_communication->SetControlledMode(false); + + return true; } + + return false; } -const char *CCECProcessor::ToString(const cec_logical_address address) +void CCECProcessor::UnregisterClients(void) { - switch(address) - { - case CECDEVICE_AUDIOSYSTEM: - return "Audio"; - case CECDEVICE_BROADCAST: - return "Broadcast"; - case CECDEVICE_FREEUSE: - return "Free use"; - case CECDEVICE_PLAYBACKDEVICE1: - return "Playback 1"; - case CECDEVICE_PLAYBACKDEVICE2: - return "Playback 2"; - case CECDEVICE_PLAYBACKDEVICE3: - return "Playback 3"; - case CECDEVICE_RECORDINGDEVICE1: - return "Recorder 1"; - case CECDEVICE_RECORDINGDEVICE2: - return "Recorder 2"; - case CECDEVICE_RECORDINGDEVICE3: - return "Recorder 3"; - case CECDEVICE_RESERVED1: - return "Reserved 1"; - case CECDEVICE_RESERVED2: - return "Reserved 2"; - case CECDEVICE_TUNER1: - return "Tuner 1"; - case CECDEVICE_TUNER2: - return "Tuner 2"; - case CECDEVICE_TUNER3: - return "Tuner 3"; - case CECDEVICE_TUNER4: - return "Tuner 4"; - case CECDEVICE_TV: - return "TV"; - default: - return "unknown"; - } + m_libcec->AddLog(CEC_LOG_DEBUG, "unregistering all CEC clients"); + + vector clients = m_libcec->GetClients(); + for (vector::iterator client = clients.begin(); client != clients.end(); client++) + UnregisterClient(*client); + + CLockObject lock(m_mutex); + m_clients.clear(); } -const char *CCECProcessor::ToString(const cec_deck_control_mode mode) +CCECClient *CCECProcessor::GetClient(const cec_logical_address address) { - switch (mode) - { - case CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND: - return "skip forward wind"; - case CEC_DECK_CONTROL_MODE_EJECT: - return "eject"; - case CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND: - return "reverse rewind"; - case CEC_DECK_CONTROL_MODE_STOP: - return "stop"; - default: - return "unknown"; - } + CLockObject lock(m_mutex); + map::const_iterator client = m_clients.find(address); + if (client != m_clients.end()) + return client->second; + return NULL; } -const char *CCECProcessor::ToString(const cec_deck_info status) +CCECClient *CCECProcessor::GetPrimaryClient(void) { - switch (status) - { - case CEC_DECK_INFO_PLAY: - return "play"; - case CEC_DECK_INFO_RECORD: - return "record"; - case CEC_DECK_INFO_PLAY_REVERSE: - return "play reverse"; - case CEC_DECK_INFO_STILL: - return "still"; - case CEC_DECK_INFO_SLOW: - return "slow"; - case CEC_DECK_INFO_SLOW_REVERSE: - return "slow reverse"; - case CEC_DECK_INFO_FAST_FORWARD: - return "fast forward"; - case CEC_DECK_INFO_FAST_REVERSE: - return "fast reverse"; - case CEC_DECK_INFO_NO_MEDIA: - return "no media"; - case CEC_DECK_INFO_STOP: - return "stop"; - case CEC_DECK_INFO_SKIP_FORWARD_WIND: - return "info skip forward wind"; - case CEC_DECK_INFO_SKIP_REVERSE_REWIND: - return "info skip reverse rewind"; - case CEC_DECK_INFO_INDEX_SEARCH_FORWARD: - return "info index search forward"; - case CEC_DECK_INFO_INDEX_SEARCH_REVERSE: - return "info index search reverse"; - case CEC_DECK_INFO_OTHER_STATUS: - return "other"; - default: - return "unknown"; - } + CLockObject lock(m_mutex); + map::const_iterator client = m_clients.begin(); + if (client != m_clients.end()) + return client->second; + return NULL; } -const char *CCECProcessor::ToString(const cec_opcode opcode) +CCECBusDevice *CCECProcessor::GetPrimaryDevice(void) { - switch (opcode) - { - case CEC_OPCODE_ACTIVE_SOURCE: - return "active source"; - case CEC_OPCODE_IMAGE_VIEW_ON: - return "image view on"; - case CEC_OPCODE_TEXT_VIEW_ON: - return "text view on"; - case CEC_OPCODE_INACTIVE_SOURCE: - return "inactive source"; - case CEC_OPCODE_REQUEST_ACTIVE_SOURCE: - return "request active source"; - case CEC_OPCODE_ROUTING_CHANGE: - return "routing change"; - case CEC_OPCODE_ROUTING_INFORMATION: - return "routing information"; - case CEC_OPCODE_SET_STREAM_PATH: - return "set stream path"; - case CEC_OPCODE_STANDBY: - return "standby"; - case CEC_OPCODE_RECORD_OFF: - return "record off"; - case CEC_OPCODE_RECORD_ON: - return "record on"; - case CEC_OPCODE_RECORD_STATUS: - return "record status"; - case CEC_OPCODE_RECORD_TV_SCREEN: - return "record tv screen"; - case CEC_OPCODE_CLEAR_ANALOGUE_TIMER: - return "clear analogue timer"; - case CEC_OPCODE_CLEAR_DIGITAL_TIMER: - return "clear digital timer"; - case CEC_OPCODE_CLEAR_EXTERNAL_TIMER: - return "clear external timer"; - case CEC_OPCODE_SET_ANALOGUE_TIMER: - return "set analogue timer"; - case CEC_OPCODE_SET_DIGITAL_TIMER: - return "set digital timer"; - case CEC_OPCODE_SET_EXTERNAL_TIMER: - return "set external timer"; - case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE: - return "set timer program title"; - case CEC_OPCODE_TIMER_CLEARED_STATUS: - return "timer cleared status"; - case CEC_OPCODE_TIMER_STATUS: - return "timer status"; - case CEC_OPCODE_CEC_VERSION: - return "cec version"; - case CEC_OPCODE_GET_CEC_VERSION: - return "get cec version"; - case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: - return "give physical address"; - case CEC_OPCODE_GET_MENU_LANGUAGE: - return "get menu language"; - case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS: - return "report physical address"; - case CEC_OPCODE_SET_MENU_LANGUAGE: - return "set menu language"; - case CEC_OPCODE_DECK_CONTROL: - return "deck control"; - case CEC_OPCODE_DECK_STATUS: - return "deck status"; - case CEC_OPCODE_GIVE_DECK_STATUS: - return "give deck status"; - case CEC_OPCODE_PLAY: - return "play"; - case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS: - return "give tuner status"; - case CEC_OPCODE_SELECT_ANALOGUE_SERVICE: - return "select analogue service"; - case CEC_OPCODE_SELECT_DIGITAL_SERVICE: - return "set digital service"; - case CEC_OPCODE_TUNER_DEVICE_STATUS: - return "tuner device status"; - case CEC_OPCODE_TUNER_STEP_DECREMENT: - return "tuner step decrement"; - case CEC_OPCODE_TUNER_STEP_INCREMENT: - return "tuner step increment"; - case CEC_OPCODE_DEVICE_VENDOR_ID: - return "device vendor id"; - case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID: - return "give device vendor id"; - case CEC_OPCODE_VENDOR_COMMAND: - return "vendor command"; - case CEC_OPCODE_VENDOR_COMMAND_WITH_ID: - return "vendor command with id"; - case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN: - return "vendor remote button down"; - case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP: - return "vendor remote button up"; - case CEC_OPCODE_SET_OSD_STRING: - return "set osd string"; - case CEC_OPCODE_GIVE_OSD_NAME: - return "give osd name"; - case CEC_OPCODE_SET_OSD_NAME: - return "set osd name"; - case CEC_OPCODE_MENU_REQUEST: - return "menu request"; - case CEC_OPCODE_MENU_STATUS: - return "menu status"; - case CEC_OPCODE_USER_CONTROL_PRESSED: - return "user control pressed"; - case CEC_OPCODE_USER_CONTROL_RELEASE: - return "user control release"; - case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS: - return "give device power status"; - case CEC_OPCODE_REPORT_POWER_STATUS: - return "report power status"; - case CEC_OPCODE_FEATURE_ABORT: - return "feature abort"; - case CEC_OPCODE_ABORT: - return "abort"; - case CEC_OPCODE_GIVE_AUDIO_STATUS: - return "give audio status"; - case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS: - return "give audio mode status"; - case CEC_OPCODE_REPORT_AUDIO_STATUS: - return "report audio status"; - case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE: - return "set system audio mode"; - case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST: - return "system audio mode request"; - case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS: - return "system audio mode status"; - case CEC_OPCODE_SET_AUDIO_RATE: - return "set audio rate"; - default: - return "UNKNOWN"; - } + return m_busDevices->At(GetLogicalAddress()); } -const char *CCECProcessor::ToString(const cec_system_audio_status mode) +cec_logical_address CCECProcessor::GetLogicalAddress(void) { - switch(mode) - { - case CEC_SYSTEM_AUDIO_STATUS_ON: - return "on"; - case CEC_SYSTEM_AUDIO_STATUS_OFF: - return "off"; - default: - return "unknown"; - } + cec_logical_addresses addresses = GetLogicalAddresses(); + return addresses.primary; } -const char *CCECProcessor::ToString(const cec_audio_status UNUSED(status)) +cec_logical_addresses CCECProcessor::GetLogicalAddresses(void) { - // TODO this is a mask - return "TODO"; + CLockObject lock(m_mutex); + cec_logical_addresses addresses; + addresses.Clear(); + for (map::const_iterator client = m_clients.begin(); client != m_clients.end(); client++) + addresses.Set(client->first); + + return addresses; } -const char *CCECProcessor::ToString(const cec_vendor_id vendor) +bool CCECProcessor::IsHandledByLibCEC(const cec_logical_address address) const { - switch (vendor) - { - case CEC_VENDOR_SAMSUNG: - return "Samsung"; - case CEC_VENDOR_LG: - return "LG"; - case CEC_VENDOR_PANASONIC: - return "Panasonic"; - case CEC_VENDOR_PIONEER: - return "Pioneer"; - case CEC_VENDOR_ONKYO: - return "Onkyo"; - case CEC_VENDOR_YAMAHA: - return "Yamaha"; - case CEC_VENDOR_PHILIPS: - return "Philips"; - case CEC_VENDOR_SONY: - return "Sony"; - default: - return "Unknown"; - } + CCECBusDevice *device = GetDevice(address); + return device && device->IsHandledByLibCEC(); } -void *CCECBusScan::Process(void) +bool CCECProcessor::IsRunningLatestFirmware(void) { - CCECBusDevice *device(NULL); - uint8_t iCounter(0); + return m_communication && m_communication->IsOpen() ? + m_communication->IsRunningLatestFirmware() : + true; +} - while (!IsStopped()) +void CCECProcessor::SwitchMonitoring(bool bSwitchTo) +{ { - if (++iCounter < 10) - { - Sleep(1000); - continue; - } - for (unsigned int iPtr = 0; iPtr <= 11 && !IsStopped(); iPtr++) - { - device = m_processor->m_busDevices[iPtr]; - WaitUntilIdle(); - if (device && device->GetStatus(true) == CEC_DEVICE_STATUS_PRESENT) - { - WaitUntilIdle(); - if (!IsStopped()) - device->GetVendorId(); - - WaitUntilIdle(); - if (!IsStopped()) - device->GetPowerStatus(true); - } - } + CLockObject lock(m_mutex); + m_bMonitor = bSwitchTo; } - - return NULL; + if (bSwitchTo) + UnregisterClients(); } -void CCECBusScan::WaitUntilIdle(void) +void CCECProcessor::HandleLogicalAddressLost(cec_logical_address oldAddress) { - if (IsStopped()) - return; + // stall outgoing messages until we know our new LA + m_bStallCommunication = true; - int32_t iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission()); - while (iWaitTime > 0) + m_libcec->AddLog(CEC_LOG_NOTICE, "logical address %x was taken by another device, allocating a new address", oldAddress); + CCECClient* client = GetClient(oldAddress); + if (!client) + client = GetPrimaryClient(); + if (client) { - Sleep(iWaitTime); - iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission()); + if (m_addrAllocator) + while (m_addrAllocator->IsRunning()) Sleep(5); + delete m_addrAllocator; + + m_addrAllocator = new CCECAllocateLogicalAddress(this, client); + m_addrAllocator->CreateThread(); } } -bool CCECProcessor::StartBootloader(void) +void CCECProcessor::HandlePhysicalAddressChanged(uint16_t iNewAddress) { - return m_communication->StartBootloader(); + m_libcec->AddLog(CEC_LOG_NOTICE, "physical address changed to %04x", iNewAddress); + CCECClient* client = GetPrimaryClient(); + if (client) + client->SetPhysicalAddress(iNewAddress); } -bool CCECProcessor::PingAdapter(void) +uint16_t CCECProcessor::GetAdapterVendorId(void) const { - return m_communication->PingAdapter(); + return m_communication ? m_communication->GetAdapterVendorId() : 0; } -void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination) +uint16_t CCECProcessor::GetAdapterProductId(void) const { - m_busDevices[initiator]->GetHandler()->HandlePoll(initiator, destination); - m_lastInitiator = initiator; + return m_communication ? m_communication->GetAdapterProductId() : 0; } -bool CCECProcessor::HandleReceiveFailed(void) +CCECAllocateLogicalAddress::CCECAllocateLogicalAddress(CCECProcessor* processor, CCECClient* client) : + m_processor(processor), + m_client(client) { } + +void* CCECAllocateLogicalAddress::Process(void) { - return m_lastInitiator != CECDEVICE_UNKNOWN && - !m_busDevices[m_lastInitiator]->GetHandler()->HandleReceiveFailed(); + m_processor->AllocateLogicalAddresses(m_client); + return NULL; }