/*
* 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.
m_settingCecVersion(CEC_VERSION_UNKNOWN),
m_iSettingLAMask(0),
m_bNeedsWrite(false),
- m_iBuildDate(CEC_FW_BUILD_UNKNOWN)
+ m_iBuildDate(CEC_FW_BUILD_UNKNOWN),
+ m_bControlledMode(false),
+ m_adapterType(P8_ADAPTERTYPE_UNKNOWN)
{
m_persistedConfiguration.Clear();
}
while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION);
if (response.size == 2)
m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]);
else
{
- LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", iFwVersionTry);
+ LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d, size = %d)", iFwVersionTry, response.size);
CEvent::Sleep(500);
}
}
m_persistedConfiguration.iFirmwareVersion = 1;
}
+ // firmware versions < 2 don't have an autonomous mode
+ if (m_persistedConfiguration.iFirmwareVersion < 2)
+ m_bControlledMode = true;
+
return m_persistedConfiguration.iFirmwareVersion;
}
bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED);
if (response.size == 1)
bool CUSBCECAdapterCommands::RequestSettingCECVersion(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION);
if (response.size == 1)
return false;
}
+p8_cec_adapter_type CUSBCECAdapterCommands::RequestAdapterType(void)
+{
+ if (m_adapterType == P8_ADAPTERTYPE_UNKNOWN)
+ {
+#ifdef CEC_DEBUGGING
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting adapter type");
+#endif
+
+ cec_datapacket response = RequestSetting(MSGCODE_GET_ADAPTER_TYPE);
+ if (response.size == 1)
+ m_adapterType = (p8_cec_adapter_type)response[0];
+ }
+ return m_adapterType;
+}
+
uint32_t CUSBCECAdapterCommands::RequestBuildDate(void)
{
if (m_iBuildDate == CEC_FW_BUILD_UNKNOWN)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting firmware build date");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_BUILDDATE);
if (response.size == 4)
bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS);
if (response.size == 1)
bool CUSBCECAdapterCommands::RequestSettingDeviceType(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting device type setting");
+#endif
m_persistedConfiguration.deviceTypes.Clear();
cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE);
bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK);
if (response.size == 2)
bool CUSBCECAdapterCommands::RequestSettingOSDName(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
+#endif
memset(m_persistedConfiguration.strDeviceName, 0, 13);
cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME);
bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
+#endif
cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS);
if (response.size == 2)
bool bReturn(false);
/* check whether this value was changed */
- if (m_bSettingAutoEnabled == enabled)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_bSettingAutoEnabled == enabled)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
CCECAdapterMessage params;
delete message;
if (bReturn)
+ {
+ CLockObject lock(m_mutex);
m_bSettingAutoEnabled = enabled;
+ }
return bReturn;
}
bool bReturn(false);
/* check whether this value was changed */
- if (m_persistedConfiguration.deviceTypes.types[0] == type)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_persistedConfiguration.deviceTypes.types[0] == type)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the device type to %X (previous: %X)", (uint8_t)type, (uint8_t)m_persistedConfiguration.deviceTypes.types[0]);
CCECAdapterMessage params;
bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+ if (bReturn)
+ {
+ CLockObject lock(m_mutex);
+ m_persistedConfiguration.deviceTypes.types[0] = type;
+ }
+
return bReturn;
}
bool bReturn(false);
/* check whether this value was changed */
- if (m_persistedConfiguration.logicalAddresses.primary == address)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_persistedConfiguration.logicalAddresses.primary == address)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X (previous: %X)", (uint8_t)address, (uint8_t)m_persistedConfiguration.logicalAddresses.primary);
CCECAdapterMessage params;
delete message;
if (bReturn)
+ {
+ CLockObject lock(m_mutex);
m_persistedConfiguration.logicalAddresses.primary = address;
+ }
return bReturn;
}
bool bReturn(false);
/* check whether this value was changed */
- if (m_iSettingLAMask == iMask)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_iSettingLAMask == iMask)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X (previous: %2X)", iMask, m_iSettingLAMask);
CCECAdapterMessage params;
delete message;
if (bReturn)
+ {
+ CLockObject lock(m_mutex);
m_iSettingLAMask = iMask;
+ }
return bReturn;
}
bool bReturn(false);
/* check whether this value was changed */
- if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X (previous: %04X)", iPhysicalAddress, m_persistedConfiguration.iPhysicalAddress);
CCECAdapterMessage params;
delete message;
if (bReturn)
+ {
+ CLockObject lock(m_mutex);
m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress;
+ }
return bReturn;
}
bool bReturn(false);
/* check whether this value was changed */
- if (m_settingCecVersion == version)
- return bReturn;
+ {
+ CLockObject lock(m_mutex);
+ if (m_settingCecVersion == version)
+ return bReturn;
+ m_bNeedsWrite = true;
+ }
- m_bNeedsWrite = true;
LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s (previous: %s)", ToString(version), ToString(m_settingCecVersion));
CCECAdapterMessage params;
delete message;
if (bReturn)
+ {
+ CLockObject lock(m_mutex);
m_settingCecVersion = version;
+ }
return bReturn;
}
bool CUSBCECAdapterCommands::WriteEEPROM(void)
{
- if (!m_bNeedsWrite)
- return true;
+ {
+ CLockObject lock(m_mutex);
+ if (!m_bNeedsWrite)
+ return true;
+ }
LIB_CEC->AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
CCECAdapterMessage params;
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params);
- m_bNeedsWrite = !(message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED);
+ bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
- return m_bNeedsWrite;
+
+ if (bReturn)
+ {
+ CLockObject lock(m_mutex);
+ m_bNeedsWrite = false;
+ }
+
+ return bReturn;
}
bool CUSBCECAdapterCommands::PersistConfiguration(const libcec_configuration &configuration)
bool CUSBCECAdapterCommands::PingAdapter(void)
{
+#ifdef CEC_DEBUGGING
LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending ping");
+#endif
CCECAdapterMessage params;
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_PING, params);
return bReturn;
}
+void CUSBCECAdapterCommands::SetActiveSource(bool bSetTo, bool bClientUnregistered)
+{
+ if (bClientUnregistered) return;
+ if (m_persistedConfiguration.iFirmwareVersion >= 3)
+ {
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking the adapter as %s source", bSetTo ? "active" : "inactive");
+ CCECAdapterMessage params;
+ params.PushEscaped(bSetTo ? 1 : 0);
+ CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_ACTIVE_SOURCE, params);
+ delete message;
+ }
+}
+
bool CUSBCECAdapterCommands::StartBootloader(void)
{
LIB_CEC->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
bool CUSBCECAdapterCommands::SetControlledMode(bool controlled)
{
+ {
+ CLockObject lock(m_mutex);
+ if (m_bControlledMode == controlled)
+ return true;
+ }
+
LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
CCECAdapterMessage params;
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_CONTROLLED, params);
bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ {
+ CLockObject lock(m_mutex);
+ m_bControlledMode = controlled;
+ }
+
return bReturn;
}