using namespace std;
using namespace PLATFORM;
+#define CEC_PROCESSOR_SIGNAL_WAIT_TIME 1000
+
CCECProcessor::CCECProcessor(CLibCEC *controller, libcec_configuration *configuration) :
m_bConnectionOpened(false),
m_bInitialised(false),
{
CreateBusDevices();
m_configuration.Clear();
- m_configuration.serverVersion = CEC_SERVER_VERSION_1_6_1;
+ m_configuration.serverVersion = LIBCEC_VERSION_CURRENT;
SetConfiguration(configuration);
if (m_configuration.tvVendor != CEC_VENDOR_UNKNOWN)
m_iLastTransmission(0)
{
m_configuration.Clear();
- m_configuration.serverVersion = CEC_SERVER_VERSION_1_6_1;
+ m_configuration.serverVersion = LIBCEC_VERSION_CURRENT;
// client version < 1.5.0
m_configuration.clientVersion = (uint32_t)CEC_CLIENT_VERSION_PRE_1_5;
void CCECProcessor::CreateBusDevices(void)
{
- for (int iPtr = 0; iPtr < 16; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_BROADCAST; iPtr++)
{
switch(iPtr)
{
case CECDEVICE_AUDIOSYSTEM:
- m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF);
+ m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr);
break;
case CECDEVICE_PLAYBACKDEVICE1:
case CECDEVICE_PLAYBACKDEVICE2:
case CECDEVICE_PLAYBACKDEVICE3:
- m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF);
+ m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr);
break;
case CECDEVICE_RECORDINGDEVICE1:
case CECDEVICE_RECORDINGDEVICE2:
case CECDEVICE_RECORDINGDEVICE3:
- m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF);
+ m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr);
break;
case CECDEVICE_TUNER1:
case CECDEVICE_TUNER2:
case CECDEVICE_TUNER3:
case CECDEVICE_TUNER4:
- m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF);
+ m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr);
break;
case CECDEVICE_TV:
- m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0);
+ m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr);
break;
default:
- m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF);
+ m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr);
break;
}
}
{
Close();
- for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_BROADCAST; iPtr++)
{
delete m_busDevices[iPtr];
m_busDevices[iPtr] = NULL;
{
CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
m_communication->Close();
- CEvent::Sleep(1000);
+ CEvent::Sleep(CEC_DEFAULT_CONNECT_RETRY_WAIT);
}
if (bReturn)
{
m_configuration.iFirmwareVersion = m_communication->GetFirmwareVersion();
- uint32_t iBuildDate = m_communication->GetFirmwareBuildDate();
- CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d, client version = %s", m_configuration.iFirmwareVersion, ToString((cec_client_version)m_configuration.clientVersion));
- if (iBuildDate > 0)
+ m_configuration.iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
+ CStdString strLog;
+ strLog.Format("connected to the CEC adapter. libCEC version = %s, client version = %s, firmware version = %d", ToString((cec_server_version)m_configuration.serverVersion), ToString((cec_client_version)m_configuration.clientVersion), m_configuration.iFirmwareVersion);
+ if (m_configuration.iFirmwareBuildDate != CEC_FW_BUILD_UNKNOWN)
{
- time_t buildTime = (time_t)iBuildDate;
- CLibCEC::AddLog(CEC_LOG_NOTICE, "Firmware build date: %s", asctime(localtime(&buildTime)));
+ time_t buildTime = (time_t)m_configuration.iFirmwareBuildDate;
+ strLog.AppendFormat(", firmware build date: %s", asctime(gmtime(&buildTime)));
+ strLog = strLog.Left((int)strLog.length() - 1); // strip \n added by asctime
+ strLog.append(" +0000");
}
+ CLibCEC::AddLog(CEC_LOG_NOTICE, strLog);
+ }
+ if (!m_communication->IsRunningLatestFirmware())
+ {
+ const char *strUpgradeMessage = "The firmware of this adapter can be upgraded. Please visit http://blog.pulse-eight.com/ for more information.";
+ CLibCEC::AddLog(CEC_LOG_WARNING, strUpgradeMessage);
+ CLibCEC::Alert(CEC_ALERT_SERVICE_DEVICE, libcec_parameter(strUpgradeMessage));
+ }
+ else
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "the adapter is using the latest (known) firmware version");
}
if (m_configuration.bGetSettingsFromROM == 1)
CLockObject lock(m_mutex);
if (!config.deviceTypes.IsEmpty())
m_configuration.deviceTypes = config.deviceTypes;
- if (config.iPhysicalAddress > 0)
+ if (IsValidPhysicalAddress(config.iPhysicalAddress))
m_configuration.iPhysicalAddress = config.iPhysicalAddress;
snprintf(m_configuration.strDeviceName, 13, "%s", config.strDeviceName);
}
memcpy(language.language, m_configuration.strDeviceLanguage, 3);
language.language[3] = 0;
- for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
if (m_configuration.logicalAddresses[iPtr])
{
/* get the vendor id from the TV, so we are using the correct handler */
m_busDevices[CECDEVICE_TV]->GetVendorId();
- if (m_configuration.iPhysicalAddress != 0)
+ if (IsValidPhysicalAddress(m_configuration.iPhysicalAddress))
{
- CLibCEC::AddLog(CEC_LOG_NOTICE, "setting the physical address to %4x", m_configuration.iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_NOTICE, "setting the physical address to %04X", m_configuration.iPhysicalAddress);
m_busDevices[m_configuration.logicalAddresses.primary]->m_iPhysicalAddress = m_configuration.iPhysicalAddress;
if ((bReturn = m_busDevices[m_configuration.logicalAddresses.primary]->TransmitPhysicalAddress()) == false)
- CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set the physical address to %4x", m_configuration.iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set the physical address to %04X", m_configuration.iPhysicalAddress);
+ }
+ else
+ {
+ if (!SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort, true))
+ 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);
+ bReturn = true;
}
- 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);
if (bReturn && m_configuration.bActivateSource == 1)
m_busDevices[m_configuration.logicalAddresses.primary]->ActivateSource();
return bReturn;
}
-bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
+bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
{
bool bReturn(false);
CCECBusDevice *previousDevice = GetDeviceByType(from);
m_configuration.logicalAddresses.primary = CECDEVICE_UNKNOWN;
- for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
+ for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
{
if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
continue;
newDevice->SetOSDName(previousDevice->GetOSDName(false));
previousDevice->SetOSDName(ToString(previousDevice->GetLogicalAddress()));
- newDevice->SetPhysicalAddress(previousDevice->GetPhysicalAddress(false));
- previousDevice->SetPhysicalAddress(0xFFFF);
+ newDevice->SetPhysicalAddress(previousDevice->GetPhysicalAddress());
+ previousDevice->SetPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
newDevice->SetPowerStatus(previousDevice->GetPowerStatus(false));
previousDevice->SetPowerStatus(CEC_POWER_STATUS_UNKNOWN);
return false;
}
- for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
+ for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
{
if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
continue;
{
if (!IsInitialised())
return;
- for (uint8_t iPtr = 0; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
m_busDevices[iPtr]->ReplaceHandler(m_bInitialised);
}
while (!IsStopped() && m_communication->IsOpen())
{
- if (m_inBuffer.Pop(command, 500))
+ if (m_inBuffer.Pop(command, CEC_PROCESSOR_SIGNAL_WAIT_TIME))
ParseCommand(command);
if (IsInitialised())
if (type != CEC_DEVICE_TYPE_RESERVED)
{
- for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
{
if (m_configuration.logicalAddresses[iPtr] && m_busDevices[iPtr]->m_type == type)
{
}
m_busDevices[addr]->SetActiveSource();
- if (m_busDevices[addr]->GetPhysicalAddress(false) != 0xFFFF)
+ if (IsValidPhysicalAddress(m_busDevices[addr]->GetPhysicalAddress()))
bReturn = m_busDevices[addr]->ActivateSource();
return bReturn;
bool bReturn(false);
// suppress polls when searching for a device
- CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath, false, true);
+ CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
if (device)
{
device->SetActiveSource();
bReturn = true;
}
+ else
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "device with PA '%04x' not found", iStreamPath);
+ }
return bReturn;
}
bool bReturn(false);
// limit the HDMI port range to 1-15
- if (iPort < 1)
- iPort = 1;
- if (iPort > 15)
- iPort = 15;
+ if (iPort < CEC_MIN_HDMI_PORTNUMBER ||
+ iPort > CEC_MAX_HDMI_PORTNUMBER)
+ return bReturn;
{
CLockObject lock(m_mutex);
m_configuration.baseDevice = iBaseDevice;
- m_configuration.iHDMIPort = iPort;
+ m_configuration.iHDMIPort = iPort;
}
if (!IsRunning() && !bForce)
uint16_t iPhysicalAddress(0);
if (iBaseDevice > CECDEVICE_TV)
- {
- iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress();
- }
+ iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress(false);
- if (iPhysicalAddress < 0xffff)
+ if (iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS)
{
if (iPhysicalAddress == 0)
iPhysicalAddress += 0x1000 * iPort;
}
if (!bReturn)
- CLibCEC::AddLog(CEC_LOG_ERROR, "failed to set the physical address");
- else
- SetPhysicalAddress(iPhysicalAddress);
+ {
+ CLibCEC::AddLog(CEC_LOG_WARNING, "failed to set the physical address to %04X, setting it to the default value %04X", iPhysicalAddress, CEC_DEFAULT_PHYSICAL_ADDRESS);
+ iPhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
+ }
+
+ SetPhysicalAddress(iPhysicalAddress);
return bReturn;
}
bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
{
- for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
- if (m_busDevices[iPtr]->GetPhysicalAddress(false) == iPhysicalAddress)
+ if (m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
return true;
}
return false;
bool CCECProcessor::SetMenuState(cec_menu_state state, bool bSendUpdate /* = true */)
{
- for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
if (m_configuration.logicalAddresses[iPtr])
m_busDevices[iPtr]->SetMenuState(state);
{
CLockObject lock(m_mutex);
m_configuration.iPhysicalAddress = iPhysicalAddress;
- CLibCEC::AddLog(CEC_LOG_DEBUG, "setting physical address to '%4x'", iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "setting physical address to '%04X'", iPhysicalAddress);
if (!m_configuration.logicalAddresses.IsEmpty())
{
bool bWasActiveSource(false);
- for (uint8_t iPtr = 0; iPtr < 15; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
if (m_configuration.logicalAddresses[iPtr])
{
bWasActiveSource |= m_busDevices[iPtr]->IsActiveSource();
}
}
- for (uint8_t iPtr = 0; iPtr < 15; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
if (sendUpdatesTo[iPtr])
m_busDevices[iPtr]->TransmitPhysicalAddress();
uint8_t CCECProcessor::VolumeUp(bool bSendRelease /* = true */)
{
- uint8_t status = 0;
+ uint8_t status(CEC_AUDIO_VOLUME_STATUS_UNKNOWN);
if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeUp(bSendRelease);
uint8_t CCECProcessor::VolumeDown(bool bSendRelease /* = true */)
{
- uint8_t status = 0;
+ uint8_t status(CEC_AUDIO_VOLUME_STATUS_UNKNOWN);
if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeDown(bSendRelease);
uint8_t CCECProcessor::MuteAudio(bool bSendRelease /* = true */)
{
- uint8_t status = 0;
+ uint8_t status(CEC_AUDIO_VOLUME_STATUS_UNKNOWN);
if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->MuteAudio(bSendRelease);
return status;
}
-CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bRefresh /* = false */, bool bSuppressPoll /* = false */) const
+CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bSuppressUpdate /* = true */)
{
- if (m_busDevices[m_configuration.logicalAddresses.primary]->GetPhysicalAddress(false) == iPhysicalAddress)
- return m_busDevices[m_configuration.logicalAddresses.primary];
+ CCECBusDevice *device(NULL);
- CCECBusDevice *device = NULL;
- for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
+ // check each device until we found a match
+ for (uint8_t iPtr = CECDEVICE_TV; !device && iPtr < CECDEVICE_BROADCAST; iPtr++)
{
- if (m_busDevices[iPtr]->GetPhysicalAddress(bRefresh, bSuppressPoll) == iPhysicalAddress)
- {
+ if (m_busDevices[iPtr]->GetPhysicalAddress(bSuppressUpdate) == iPhysicalAddress)
device = m_busDevices[iPtr];
- break;
- }
}
return device;
{
CCECBusDevice *device = NULL;
- for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
if (m_busDevices[iPtr]->m_type == type && m_configuration.logicalAddresses[iPtr])
{
return false;
}
+CStdString CCECProcessor::GetDeviceName(void) const
+{
+ CStdString strName;
+ strName = m_configuration.strDeviceName;
+ return strName;
+}
+
uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
{
if (m_busDevices[iAddress])
return CEC_POWER_STATUS_UNKNOWN;
}
-cec_logical_address CCECProcessor::GetActiveSource(void)
+cec_logical_address CCECProcessor::GetActiveSource(bool bRequestActiveSource /* = true */)
{
- for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
{
if (m_busDevices[iPtr]->IsActiveSource())
return (cec_logical_address)iPtr;
}
+ if (bRequestActiveSource && m_configuration.logicalAddresses.primary != CECDEVICE_UNKNOWN)
+ {
+ CCECBusDevice *primary = m_busDevices[m_configuration.logicalAddresses.primary];
+ if (primary)
+ primary->RequestActiveSource();
+
+ return GetActiveSource(false);
+ }
+
return CECDEVICE_UNKNOWN;
}
bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
{
- return iAddress > CECDEVICE_TV && iAddress < CECDEVICE_BROADCAST ?
+ return iAddress >= CECDEVICE_TV && iAddress < CECDEVICE_BROADCAST ?
m_busDevices[iAddress]->IsActiveSource() :
false;
}
{
cec_logical_addresses addresses;
addresses.Clear();
- for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
if (m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
addresses.Set((cec_logical_address) iPtr);
bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
{
- for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
{
if (m_busDevices[iPtr]->GetType() == type && m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
return true;
uint16_t CCECProcessor::GetPhysicalAddress(void) const
{
if (!m_configuration.logicalAddresses.IsEmpty() && m_busDevices[m_configuration.logicalAddresses.primary])
- return m_busDevices[m_configuration.logicalAddresses.primary]->GetPhysicalAddress(false);
+ return m_busDevices[m_configuration.logicalAddresses.primary]->GetPhysicalAddress();
return false;
}
{
CLibCEC::AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__);
uint16_t iPhysicalAddress = m_communication->GetPhysicalAddress();
- if (iPhysicalAddress != 0)
+ if (IsValidPhysicalAddress(iPhysicalAddress))
{
m_configuration.bAutodetectAddress = 1;
- m_configuration.iPhysicalAddress = iPhysicalAddress;
- m_configuration.baseDevice = CECDEVICE_UNKNOWN;
- m_configuration.iHDMIPort = 0;
+ m_configuration.iPhysicalAddress = iPhysicalAddress;
+ m_configuration.baseDevice = CECDEVICE_UNKNOWN;
+ m_configuration.iHDMIPort = CEC_HDMI_PORTNUMBER_NONE;
return SetPhysicalAddress(iPhysicalAddress);
}
return false;
if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
{
bool bReturn(true);
- for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_BROADCAST; iPtr++)
{
if (m_configuration.powerOffDevices[iPtr])
{
if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
{
bool bReturn(true);
- for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_BROADCAST; iPtr++)
{
if (m_configuration.wakeDevices[iPtr])
{
return "info index search reverse";
case CEC_DECK_INFO_OTHER_STATUS:
return "other";
+ case CEC_DECK_INFO_OTHER_STATUS_LG:
+ return "LG other";
default:
return "unknown";
}
return "system audio mode status";
case CEC_OPCODE_SET_AUDIO_RATE:
return "set audio rate";
+ case CEC_OPCODE_START_ARC:
+ return "start ARC";
+ case CEC_OPCODE_REPORT_ARC_STARTED:
+ return "report ARC started";
+ case CEC_OPCODE_REPORT_ARC_ENDED:
+ return "report ARC ended";
+ case CEC_OPCODE_REQUEST_ARC_START:
+ return "request ARC start";
+ case CEC_OPCODE_REQUEST_ARC_END:
+ return "request ARC end";
+ case CEC_OPCODE_END_ARC:
+ return "end ARC";
+ case CEC_OPCODE_CDC:
+ return "CDC";
case CEC_OPCODE_NONE:
return "poll";
default:
bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */)
{
+ bool bReturn(false);
if (!m_communication && strPort)
{
- bool bReturn(false);
IAdapterCommunication *comm = new CUSBCECAdapterCommunication(this, strPort);
- CTimeout timeout(10000);
+ CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT);
int iConnectTry(0);
while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false)
{
CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
comm->Close();
- Sleep(500);
+ Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
}
if (comm->IsOpen())
{
}
else
{
- return m_communication->StartBootloader();
+ m_communication->StartBootloader();
+ Close();
+ bReturn = true;
}
+
+ return bReturn;
}
bool CCECProcessor::PingAdapter(void)
if (IsRunning() && configuration->bAutodetectAddress == 1)
{
uint16_t iPhysicalAddress = m_communication->GetPhysicalAddress();
- if (iPhysicalAddress != 0)
+ if (IsValidPhysicalAddress(iPhysicalAddress))
{
if (IsRunning())
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%4x'", __FUNCTION__, iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%04X'", __FUNCTION__, iPhysicalAddress);
else
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using physical address '%x'", __FUNCTION__, iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using physical address '%04X'", __FUNCTION__, iPhysicalAddress);
bPhysicalAddressChanged = (m_configuration.iPhysicalAddress != iPhysicalAddress);
m_configuration.iPhysicalAddress = iPhysicalAddress;
- m_configuration.iHDMIPort = 0;
- m_configuration.baseDevice = CECDEVICE_UNKNOWN;
- bPhysicalAutodetected = true;
+ m_configuration.iHDMIPort = CEC_HDMI_PORTNUMBER_NONE;
+ m_configuration.baseDevice = CECDEVICE_UNKNOWN;
+ bPhysicalAutodetected = true;
}
}
// physical address
if (!bPhysicalAutodetected)
{
- if (configuration->iPhysicalAddress != 0)
- bPhysicalAddressChanged = IsRunning() && m_configuration.iPhysicalAddress != configuration->iPhysicalAddress;
+ uint16_t iPhysicalAddress(IsValidPhysicalAddress(configuration->iPhysicalAddress) ? configuration->iPhysicalAddress : CEC_PHYSICAL_ADDRESS_TV);
+ bPhysicalAddressChanged = IsRunning() && m_configuration.iPhysicalAddress != iPhysicalAddress;
if (bPhysicalAddressChanged)
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - physical address '%x'", __FUNCTION__, configuration->iPhysicalAddress);
- m_configuration.iPhysicalAddress = configuration->iPhysicalAddress;
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - physical address '%04X'", __FUNCTION__, iPhysicalAddress);
+ m_configuration.iPhysicalAddress = iPhysicalAddress;
}
}
bool bHdmiPortChanged(false);
- if (!bPhysicalAutodetected && !bPhysicalAddressChanged)
+ if (!bPhysicalAutodetected && !IsValidPhysicalAddress(configuration->iPhysicalAddress))
{
// base device
bHdmiPortChanged = IsRunning() && m_configuration.baseDevice != configuration->baseDevice;
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
m_configuration.baseDevice = CECDEVICE_UNKNOWN;
- m_configuration.iHDMIPort = 0;
+ m_configuration.iHDMIPort = CEC_HDMI_PORTNUMBER_NONE;
}
bReinit = bPhysicalAddressChanged || bHdmiPortChanged || bDeviceTypeChanged;
// client version 1.6.2
if (configuration->clientVersion >= CEC_CLIENT_VERSION_1_6_2)
{
- snprintf(m_configuration.strDeviceLanguage, 3, "%s", configuration->strDeviceLanguage);
+ memcpy(m_configuration.strDeviceLanguage, configuration->strDeviceLanguage, 3);
}
// ensure that there is at least 1 device type set
if (m_configuration.deviceTypes.IsEmpty())
m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
- // persist the configuration
- if (IsRunning())
- m_communication->PersistConfiguration(&m_configuration);
-
+ bool bReturn(true);
if (bReinit || m_configuration.logicalAddresses.IsEmpty())
{
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);
+ bReturn = ChangeDeviceType(oldPrimaryType, m_configuration.deviceTypes[0]);
+ else if (IsValidPhysicalAddress(m_configuration.iPhysicalAddress))
+ bReturn = SetPhysicalAddress(m_configuration.iPhysicalAddress);
+ else if (m_configuration.baseDevice != CECDEVICE_UNKNOWN && m_configuration.iHDMIPort != CEC_HDMI_PORTNUMBER_NONE)
+ bReturn = SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort);
}
else if (m_configuration.bActivateSource == 1 && IsRunning() && !IsActiveSource(m_configuration.logicalAddresses.primary))
{
SetActiveSource(m_configuration.deviceTypes.types[0]);
}
- return true;
+ // persist the configuration
+ if (IsRunning())
+ m_communication->PersistConfiguration(&m_configuration);
+
+ return bReturn;
}
bool CCECProcessor::GetCurrentConfiguration(libcec_configuration *configuration)
configuration->bShutdownOnStandby = m_configuration.bShutdownOnStandby;
}
+ // client version 1.6.2
+ if (configuration->clientVersion >= CEC_CLIENT_VERSION_1_6_2)
+ {
+ memcpy(configuration->strDeviceLanguage, m_configuration.strDeviceLanguage, 3);
+ configuration->iFirmwareBuildDate = m_configuration.iFirmwareBuildDate;
+ }
return true;
}
void CCECProcessor::RescanActiveDevices(void)
{
- for (unsigned int iPtr = 0; iPtr < CECDEVICE_BROADCAST; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
m_busDevices[iPtr]->GetStatus(true);
}
-bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = 10000 */)
+bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
{
- if (!OpenConnection(strPort, 38400, iTimeoutMs, false))
+ if (!OpenConnection(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs, false))
return false;
- config->iFirmwareVersion = m_communication->GetFirmwareVersion();
- config->iPhysicalAddress = m_communication->GetPhysicalAddress();
+ config->iFirmwareVersion = m_communication->GetFirmwareVersion();
+ config->iPhysicalAddress = m_communication->GetPhysicalAddress();
+ config->iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
- delete m_communication;
- m_communication = NULL;
return true;
}
bool CCECProcessor::TransmitPendingActiveSourceCommands(void)
{
bool bReturn(true);
- for (unsigned int iPtr = 0; iPtr < CECDEVICE_BROADCAST; iPtr++)
+ for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
bReturn &= m_busDevices[iPtr]->TransmitPendingActiveSourceCommands();
return bReturn;
}
+
+bool CCECProcessor::IsValidPhysicalAddress(uint16_t iPhysicalAddress)
+{
+ return iPhysicalAddress >= CEC_MIN_PHYSICAL_ADDRESS &&
+ iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS;
+}
repositories / deb_libcec.git / blobdiff