X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2FCECProcessor.cpp;h=98be0c49229593c515ba451718763d5c20b95c96;hb=68b94c34ec2f7de6cd5db434e50242f3ebf8f65a;hp=204f23bea8bc741b9e785076819ff684a9ed211f;hpb=4f362964f02515f4011eb5db6b4f2f989fc6d0a5;p=deb_libcec.git diff --git a/src/lib/CECProcessor.cpp b/src/lib/CECProcessor.cpp index 204f23b..98be0c4 100644 --- a/src/lib/CECProcessor.cpp +++ b/src/lib/CECProcessor.cpp @@ -47,13 +47,8 @@ using namespace CEC; using namespace std; using namespace PLATFORM; -CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, const cec_device_type_list &types, uint16_t iPhysicalAddress /* = 0 */) : +CCECProcessor::CCECProcessor(CLibCEC *controller, const libcec_configuration *configuration) : m_bInitialised(false), - m_iPhysicalAddress(iPhysicalAddress), - 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), @@ -62,6 +57,42 @@ CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, con m_iLastTransmission(0) { m_logicalAddresses.Clear(); + CreateBusDevices(); + m_configuration.Clear(); + + SetConfiguration(configuration); + + if (m_configuration.tvVendor != CEC_VENDOR_UNKNOWN) + m_busDevices[CECDEVICE_TV]->ReplaceHandler(false); +} + +CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, const cec_device_type_list &types, uint16_t iPhysicalAddress) : + m_bInitialised(false), + m_communication(NULL), + m_controller(controller), + m_bMonitor(false), + m_iStandardLineTimeout(3), + m_iRetryLineTimeout(3), + m_iLastTransmission(0) +{ + m_configuration.Clear(); + + // client version < 1.5.0 + m_configuration.clientVersion = CEC_CLIENT_VERSION_PRE_1_5; + snprintf(m_configuration.strDeviceName, 13, "%s", strDeviceName); + m_configuration.deviceTypes = types; + m_configuration.iPhysicalAddress = iPhysicalAddress; + m_configuration.baseDevice = (cec_logical_address)CEC_DEFAULT_BASE_DEVICE; + m_configuration.iHDMIPort = CEC_DEFAULT_HDMI_PORT; + + if (m_configuration.deviceTypes.IsEmpty()) + m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE); + m_logicalAddresses.Clear(); + CreateBusDevices(); +} + +void CCECProcessor::CreateBusDevices(void) +{ for (int iPtr = 0; iPtr < 16; iPtr++) { switch(iPtr) @@ -149,7 +180,7 @@ bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint } if (bReturn) - CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d", m_communication->GetFirmwareVersion()); + CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d, client version = %s", m_communication->GetFirmwareVersion(), ToString(m_configuration.clientVersion)); return bReturn; } @@ -181,23 +212,24 @@ bool CCECProcessor::Initialise(void) } /* only set our OSD name for the primary device */ - m_busDevices[m_logicalAddresses.primary]->m_strDeviceName = m_strDeviceName; + m_busDevices[m_logicalAddresses.primary]->m_strDeviceName = m_configuration.strDeviceName; } /* get the vendor id from the TV, so we are using the correct handler */ - m_busDevices[CECDEVICE_TV]->RequestVendorId(); - ReplaceHandlers(); + m_busDevices[CECDEVICE_TV]->GetVendorId(); - if (m_iPhysicalAddress != 0) + if (m_configuration.iPhysicalAddress != 0) { - m_busDevices[m_logicalAddresses.primary]->m_iPhysicalAddress = m_iPhysicalAddress; + CLibCEC::AddLog(CEC_LOG_NOTICE, "setting the physical address to %4x", m_configuration.iPhysicalAddress); + m_busDevices[m_logicalAddresses.primary]->m_iPhysicalAddress = m_configuration.iPhysicalAddress; if ((bReturn = m_busDevices[m_logicalAddresses.primary]->TransmitPhysicalAddress()) == false) - CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set the physical address to %4x", m_iPhysicalAddress); + CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set the physical address to %4x", m_configuration.iPhysicalAddress); } - else if (m_iPhysicalAddress == 0 && (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); + else if (m_configuration.iPhysicalAddress == 0 && (bReturn = SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort, true)) == false) + CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set HDMI port %d on %s (%x)", m_configuration.iHDMIPort, ToString(m_configuration.baseDevice), (uint8_t)m_configuration.baseDevice); SetInitialised(bReturn); + CLibCEC::ConfigurationChanged(m_configuration); return bReturn; } @@ -286,17 +318,17 @@ bool CCECProcessor::ChangeDeviceType(cec_device_type from, cec_device_type to) for (unsigned int iPtr = 0; iPtr < 5; iPtr++) { - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) continue; - if (m_types.types[iPtr] == from) + if (m_configuration.deviceTypes.types[iPtr] == from) { bChanged = true; - m_types.types[iPtr] = to; + m_configuration.deviceTypes.types[iPtr] = to; } - else if (m_types.types[iPtr] == to && bChanged) + else if (m_configuration.deviceTypes.types[iPtr] == to && bChanged) { - m_types.types[iPtr] = CEC_DEVICE_TYPE_RESERVED; + m_configuration.deviceTypes.types[iPtr] = CEC_DEVICE_TYPE_RESERVED; } } @@ -356,20 +388,26 @@ bool CCECProcessor::FindLogicalAddresses(void) bool bReturn(true); m_logicalAddresses.Clear(); + if (m_configuration.deviceTypes.IsEmpty()) + { + CLibCEC::AddLog(CEC_LOG_ERROR, "no device types set"); + return false; + } + for (unsigned int iPtr = 0; iPtr < 5; iPtr++) { - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED) continue; - CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - device %d: type %d", __FUNCTION__, iPtr, m_types.types[iPtr]); + CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - device %d: type %d", __FUNCTION__, iPtr, m_configuration.deviceTypes.types[iPtr]); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE) bReturn &= FindLogicalAddressRecordingDevice(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_TUNER) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_TUNER) bReturn &= FindLogicalAddressTuner(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE) bReturn &= FindLogicalAddressPlaybackDevice(); - if (m_types.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM) + if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM) bReturn &= FindLogicalAddressAudioSystem(); } @@ -381,7 +419,6 @@ bool CCECProcessor::FindLogicalAddresses(void) void CCECProcessor::ReplaceHandlers(void) { - CLockObject lock(m_mutex); if (!IsInitialised()) return; for (uint8_t iPtr = 0; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++) @@ -401,11 +438,14 @@ void *CCECProcessor::Process(void) while (!IsStopped() && m_communication->IsOpen()) { - ReplaceHandlers(); - if (m_commandBuffer.Pop(command)) - ParseCommand(command); + if (IsInitialised()) + { + ReplaceHandlers(); + if (m_commandBuffer.Pop(command)) + ParseCommand(command); - m_controller->CheckKeypressTimeout(); + m_controller->CheckKeypressTimeout(); + } Sleep(5); } @@ -435,22 +475,7 @@ bool CCECProcessor::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RE 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); - } - } + bReturn = m_busDevices[addr]->ActivateSource(); return bReturn; } @@ -483,7 +508,8 @@ void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout) bool CCECProcessor::SetActiveView(void) { - return SetActiveSource(m_types.IsEmpty() ? CEC_DEVICE_TYPE_RESERVED : m_types[0]); + CLibCEC::AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); + return SetActiveSource(m_configuration.deviceTypes.IsEmpty() ? CEC_DEVICE_TYPE_RESERVED : m_configuration.deviceTypes[0]); } bool CCECProcessor::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */) @@ -521,15 +547,14 @@ bool CCECProcessor::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true * bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, bool bForce /* = false */) { bool bReturn(false); - CLockObject lock(m_mutex); - if (m_iPhysicalAddress != 0) + { - CLibCEC::AddLog(CEC_LOG_WARNING, "ignoring SetHDMIPort() call because a physical address is set"); - return bReturn; + CLockObject lock(m_mutex); + m_configuration.baseDevice = iBaseDevice; + m_configuration.iHDMIPort = iPort; + m_configuration.bAutodetectAddress = false; } - m_iBaseDevice = iBaseDevice; - m_iHDMIPort = iPort; if (!IsRunning() && !bForce) return true; @@ -538,9 +563,7 @@ bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, uint16_t iPhysicalAddress(0); if (iBaseDevice > CECDEVICE_TV) { - lock.Unlock(); iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress(); - lock.Lock(); } if (iPhysicalAddress < 0xffff) @@ -560,10 +583,7 @@ bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, if (!bReturn) CLibCEC::AddLog(CEC_LOG_ERROR, "failed to set the physical address"); else - { - lock.Unlock(); SetPhysicalAddress(iPhysicalAddress); - } return bReturn; } @@ -637,7 +657,12 @@ bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress, bool bSendUpda { CLockObject lock(m_mutex); - m_iPhysicalAddress = iPhysicalAddress; + m_configuration.iPhysicalAddress = iPhysicalAddress; + if (m_configuration.bAutodetectAddress) + { + m_configuration.baseDevice = CECDEVICE_UNKNOWN; + m_configuration.iHDMIPort = 0; + } if (!m_logicalAddresses.IsEmpty()) { @@ -664,6 +689,9 @@ bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress, bool bSendUpda if (bSendActiveView) SetActiveView(); + if (bReturn) + CLibCEC::ConfigurationChanged(m_configuration); + return bReturn; } @@ -828,6 +856,12 @@ bool CCECProcessor::IsActiveSource(cec_logical_address iAddress) bool CCECProcessor::Transmit(const cec_command &data) { + if (m_logicalAddresses[(uint8_t)data.destination]) + { + CLibCEC::AddLog(CEC_LOG_WARNING, "not sending data to myself!"); + return false; + } + cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN); { CLockObject lock(m_mutex); @@ -922,6 +956,53 @@ bool CCECProcessor::TransmitKeyRelease(cec_logical_address iDestination, bool bW return m_busDevices[iDestination]->TransmitKeyRelease(bWait); } +bool CCECProcessor::EnablePhysicalAddressDetection(void) +{ + CLibCEC::AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); + uint16_t iPhysicalAddress = m_communication->GetPhysicalAddress(); + if (iPhysicalAddress != 0) + { + m_configuration.bAutodetectAddress = 1; + m_configuration.iPhysicalAddress = iPhysicalAddress; + m_configuration.baseDevice = CECDEVICE_UNKNOWN; + m_configuration.iHDMIPort = 0; + return SetPhysicalAddress(iPhysicalAddress); + } + return false; +} + +bool CCECProcessor::StandbyDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */) +{ + if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0) + { + bool bReturn(true); + for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++) + { + if (m_configuration.powerOffDevices[iPtr]) + bReturn &= m_busDevices[iPtr]->Standby(); + } + return bReturn; + } + + return m_busDevices[address]->Standby(); +} + +bool CCECProcessor::PowerOnDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */) +{ + if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0) + { + bool bReturn(true); + for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++) + { + if (m_configuration.powerOffDevices[iPtr]) + bReturn &= m_busDevices[iPtr]->PowerOn(); + } + return bReturn; + } + + return m_busDevices[address]->PowerOn(); +} + const char *CCECProcessor::ToString(const cec_device_type type) { switch (type) @@ -1266,6 +1347,19 @@ const char *CCECProcessor::ToString(const cec_vendor_id vendor) } } +const char *CCECProcessor::ToString(const cec_client_version version) +{ + switch (version) + { + case CEC_CLIENT_VERSION_PRE_1_5: + return "pre-1.5"; + case CEC_CLIENT_VERSION_1_5_0: + return "1.5.0"; + default: + return "Unknown"; + } +} + void *CCECBusScan::Process(void) { CCECBusDevice *device(NULL); @@ -1336,3 +1430,139 @@ bool CCECProcessor::SetStreamPath(uint16_t iPhysicalAddress) // stream path changes are sent by the TV return m_busDevices[CECDEVICE_TV]->GetHandler()->TransmitSetStreamPath(iPhysicalAddress); } + +bool CCECProcessor::SetConfiguration(const libcec_configuration *configuration) +{ + bool bReinit(false); + CCECBusDevice *primary = IsRunning() ? GetPrimaryDevice() : NULL; + cec_device_type oldPrimaryType = primary ? primary->GetType() : CEC_DEVICE_TYPE_RECORDING_DEVICE; + m_configuration.clientVersion = configuration->clientVersion; + + // client version 1.5.0 + + // device types + bool bDeviceTypeChanged = IsRunning () && m_configuration.deviceTypes != configuration->deviceTypes; + m_configuration.deviceTypes = configuration->deviceTypes; + + // autodetect address + uint16_t iPhysicalAddress = IsRunning() && configuration->bAutodetectAddress ? m_communication->GetPhysicalAddress() : 0; + bool bPhysicalAutodetected = IsRunning() && configuration->bAutodetectAddress && iPhysicalAddress != m_configuration.iPhysicalAddress && iPhysicalAddress != 0; + if (bPhysicalAutodetected) + { + m_configuration.iPhysicalAddress = iPhysicalAddress; + m_configuration.bAutodetectAddress = true; + } + else + { + m_configuration.bAutodetectAddress = false; + } + + // physical address + bool bPhysicalAddressChanged(false); + if (!bPhysicalAutodetected) + { + bPhysicalAddressChanged = IsRunning() && m_configuration.iPhysicalAddress != configuration->iPhysicalAddress; + m_configuration.iPhysicalAddress = configuration->iPhysicalAddress; + } + + // base device + bool bHdmiPortChanged(false); + if (!bPhysicalAutodetected && !bPhysicalAddressChanged) + { + bHdmiPortChanged = IsRunning() && m_configuration.baseDevice != configuration->baseDevice; + m_configuration.baseDevice = configuration->baseDevice; + } + else + { + m_configuration.baseDevice = CECDEVICE_UNKNOWN; + } + + // hdmi port + if (!bPhysicalAutodetected && !bPhysicalAddressChanged) + { + bHdmiPortChanged |= IsRunning() && m_configuration.iHDMIPort != configuration->iHDMIPort; + m_configuration.iHDMIPort = configuration->iHDMIPort; + } + else + { + m_configuration.iHDMIPort = 0; + } + + bReinit = bPhysicalAddressChanged || bHdmiPortChanged || bDeviceTypeChanged || bPhysicalAutodetected; + + // device name + snprintf(m_configuration.strDeviceName, 13, "%s", configuration->strDeviceName); + if (primary && !primary->GetOSDName().Equals(m_configuration.strDeviceName)) + { + primary->SetOSDName(m_configuration.strDeviceName); + if (!bReinit && IsRunning()) + primary->TransmitOSDName(CECDEVICE_TV); + } + + // tv vendor id override + if (m_configuration.tvVendor != configuration->tvVendor) + { + m_configuration.tvVendor= configuration->tvVendor; + m_busDevices[CECDEVICE_TV]->SetVendorId((uint64_t)m_configuration.tvVendor); + } + + // wake CEC devices + if (m_configuration.wakeDevices != configuration->wakeDevices) + { + m_configuration.wakeDevices = configuration->wakeDevices; + if (!bReinit && IsRunning()) + PowerOnDevices(); + } + + // just copy these + m_configuration.bGetSettingsFromROM = configuration->bGetSettingsFromROM; + m_configuration.powerOffDevices = configuration->powerOffDevices; + m_configuration.bPowerOffScreensaver = configuration->bPowerOffScreensaver; + m_configuration.bPowerOffOnStandby = configuration->bPowerOffOnStandby; + + // ensure that there is at least 1 device type set + if (m_configuration.deviceTypes.IsEmpty()) + m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE); + + if (bReinit) + { + if (bDeviceTypeChanged) + return ChangeDeviceType(oldPrimaryType, m_configuration.deviceTypes[0]); + else if (bPhysicalAddressChanged) + return SetPhysicalAddress(m_configuration.iPhysicalAddress); + else + return SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort); + } + + return true; +} + +bool CCECProcessor::GetCurrentConfiguration(libcec_configuration *configuration) +{ + // client version 1.5.0 + configuration->clientVersion = m_configuration.clientVersion; + snprintf(configuration->strDeviceName, 13, "%s", m_configuration.strDeviceName); + configuration->deviceTypes = m_configuration.deviceTypes; + configuration->bAutodetectAddress = m_configuration.bAutodetectAddress; + configuration->iPhysicalAddress = m_configuration.iPhysicalAddress; + configuration->baseDevice = m_configuration.baseDevice; + configuration->iHDMIPort = m_configuration.iHDMIPort; + configuration->tvVendor = m_configuration.tvVendor; + configuration->wakeDevices = m_configuration.wakeDevices; + configuration->bGetSettingsFromROM = m_configuration.bGetSettingsFromROM; + configuration->powerOffDevices = m_configuration.powerOffDevices; + configuration->bPowerOffScreensaver = m_configuration.bPowerOffScreensaver; + configuration->bPowerOffOnStandby = m_configuration.bPowerOffOnStandby; + + return true; +} + +bool CCECProcessor::CanPersistConfiguration(void) +{ + return m_communication->GetFirmwareVersion() >= 2; +} + +bool CCECProcessor::PersistConfiguration(libcec_configuration *configuration) +{ + return m_communication->PersistConfiguration(configuration); +}