#include "CECProcessor.h"
-#include "AdapterCommunication.h"
+#include "adapter/AdapterMessage.h"
#include "devices/CECBusDevice.h"
#include "devices/CECAudioSystem.h"
#include "devices/CECPlaybackDevice.h"
#include "devices/CECTV.h"
#include "implementations/CECCommandHandler.h"
#include "LibCEC.h"
-#include "util/StdString.h"
-#include "platform/timeutils.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),
delete m_busDevices[iPtr];
}
-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 bReturn(false);
+ CLockObject lock(m_mutex);
+ if (!m_communication)
+ {
+ m_controller->AddLog(CEC_LOG_ERROR, "no connection handler found");
+ return bReturn;
+ }
+ /* check for an already opened connection */
+ if (m_communication->IsOpen())
{
- CLockObject lock(&m_mutex);
+ m_controller->AddLog(CEC_LOG_ERROR, "connection already opened");
+ return bReturn;
+ }
- /* check for an already opened connection */
- if (!m_communication || m_communication->IsOpen())
- {
- m_controller->AddLog(CEC_LOG_ERROR, "connection already opened");
- return bReturn;
- }
+ /* open a new connection */
+ if ((bReturn = m_communication->Open(strPort, iBaudRate, iTimeoutMs)) == false)
+ m_controller->AddLog(CEC_LOG_ERROR, "could not open a connection");
- /* open a new connection */
- if (!m_communication->Open(strPort, iBaudRate, iTimeoutMs))
- {
- m_controller->AddLog(CEC_LOG_ERROR, "could not open a connection");
- return bReturn;
- }
+ return bReturn;
+}
- /* create the processor thread */
- if (!CreateThread() || !m_startCondition.Wait(&m_mutex) || !m_bStarted)
+void CCECProcessor::SetInitialised(bool bSetTo /* = true */)
+{
+ CLockObject lock(m_mutex);
+ m_bInitialised = bSetTo;
+}
+
+bool CCECProcessor::Initialise(void)
+{
+ bool bReturn(false);
+ {
+ CLockObject lock(m_mutex);
+ if (!m_logicalAddresses.IsEmpty())
+ m_logicalAddresses.Clear();
+
+ if (!FindLogicalAddresses())
{
- m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
+ m_controller->AddLog(CEC_LOG_ERROR, "could not detect our logical addresses");
return bReturn;
}
- }
-
- /* find the logical address for the adapter */
- bReturn = m_logicalAddresses.IsEmpty() ? FindLogicalAddresses() : true;
- if (!bReturn)
- m_controller->AddLog(CEC_LOG_ERROR, "could not detect our logical addresses");
- /* set the physical address for the adapter */
- if (bReturn)
- {
/* 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();
+ /* get the vendor id from the TV, so we are using the correct handler */
+ m_busDevices[CECDEVICE_TV]->RequestVendorId();
+ ReplaceHandlers();
- bReturn = SetHDMIPort(m_iBaseDevice, m_iHDMIPort, true);
+ if ((bReturn = SetHDMIPort(m_iBaseDevice, m_iHDMIPort, true)) == false)
+ {
+ CStdString strLog;
+ strLog.Format("unable to set HDMI port %d on %s (%x)", m_iHDMIPort, ToString(m_iBaseDevice), (uint8_t)m_iBaseDevice);
+ m_controller->AddLog(CEC_LOG_ERROR, strLog);
}
- if (bReturn)
+ SetInitialised(bReturn);
+
+ return bReturn;
+}
+
+bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
+{
+ bool bReturn(false);
+
{
- m_bInitialised = true;
- m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
+ CLockObject lock(m_mutex);
+ if (!OpenConnection(strPort, iBaudRate, iTimeoutMs))
+ return bReturn;
+
+ /* create the processor thread */
+ if (!CreateThread() || !m_startCondition.Wait(m_mutex) || !m_bStarted)
+ {
+ m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
+ return bReturn;
+ }
}
- else
+
+ if ((bReturn = Initialise()) == false)
{
m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
StopThread(true);
}
+ else
+ {
+ m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
+ }
return bReturn;
}
strLog.Format("changing device type '%s' into '%s'", ToString(from), ToString(to));
AddLog(CEC_LOG_NOTICE, strLog);
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
CCECBusDevice *previousDevice = GetDeviceByType(from);
m_logicalAddresses.primary = CECDEVICE_UNKNOWN;
CCECAdapterMessage msg;
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
m_bStarted = true;
m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
m_startCondition.Signal();
{
ReplaceHandlers();
command.Clear();
- msg.clear();
+ msg.Clear();
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
if (m_commandBuffer.Pop(command))
{
bParseFrame = true;
void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
m_iStandardLineTimeout = iTimeout;
}
void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
m_iRetryLineTimeout = iTimeout;
}
bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, bool bForce /* = false */)
{
bool bReturn(false);
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
m_iBaseDevice = iBaseDevice;
m_iHDMIPort = iPort;
uint16_t iPhysicalAddress(0);
if (iBaseDevice > CECDEVICE_TV)
{
- lock.Leave();
+ lock.Unlock();
iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress();
lock.Lock();
}
m_controller->AddLog(CEC_LOG_ERROR, "failed to set the physical address");
else
{
- lock.Leave();
+ lock.Unlock();
SetPhysicalAddress(iPhysicalAddress);
}
bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
if (m_logicalAddresses.primary != iLogicalAddress)
{
CStdString strLog;
cec_logical_addresses sendUpdatesTo;
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
if (!m_logicalAddresses.IsEmpty())
{
bool bWasActiveSource(false);
m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
{
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
m_bMonitor = bEnable;
}
bReturn = Transmit(output);
/* set to "not present" on failed ack */
- if (output->is_error() && output->reply == MSGCODE_TRANSMIT_FAILED_ACK &&
- output->destination() != CECDEVICE_BROADCAST)
- m_busDevices[output->destination()]->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT);
+ if (output->IsError() && output->reply == MSGCODE_TRANSMIT_FAILED_ACK &&
+ output->Destination() != CECDEVICE_BROADCAST)
+ m_busDevices[output->Destination()]->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT);
delete output;
return bReturn;
bool CCECProcessor::Transmit(CCECAdapterMessage *output)
{
bool bReturn(false);
- CLockObject lock(&m_mutex);
+ CLockObject lock(m_mutex);
{
m_iLastTransmission = GetTimeMs();
m_communication->SetLineTimeout(m_iStandardLineTimeout);
if (output->tries > 0)
m_communication->SetLineTimeout(m_iRetryLineTimeout);
- CLockObject msgLock(&output->mutex);
+ CLockObject msgLock(output->mutex);
if (!m_communication || !m_communication->Write(output))
return bReturn;
else
{
- output->condition.Wait(&output->mutex);
+ output->condition.Wait(output->mutex);
if (output->state != ADAPTER_MESSAGE_STATE_SENT)
{
m_controller->AddLog(CEC_LOG_ERROR, "command was not sent");
if (output->transmit_timeout > 0)
{
- if ((bReturn = WaitForTransmitSucceeded(output)) == false)
+ if ((bReturn = m_communication->WaitForTransmitSucceeded(output)) == false)
m_controller->AddLog(CEC_LOG_DEBUG, "did not receive ack");
}
else
bReturn = true;
- }while (output->transmit_timeout > 0 && output->needs_retry() && ++output->tries < output->maxTries);
+ }while (output->transmit_timeout > 0 && output->NeedsRetry() && ++output->tries < output->maxTries);
}
m_communication->SetLineTimeout(m_iStandardLineTimeout);
Transmit(command);
}
-bool CCECProcessor::WaitForTransmitSucceeded(CCECAdapterMessage *message)
-{
- bool bError(false);
- bool bTransmitSucceeded(false);
- uint8_t iPacketsLeft(message->size() / 4);
-
- int64_t iNow = GetTimeMs();
- int64_t iTargetTime = iNow + message->transmit_timeout;
-
- while (!bTransmitSucceeded && !bError && (message->transmit_timeout == 0 || iNow < iTargetTime))
- {
- CCECAdapterMessage msg;
-
- if (!m_communication->Read(msg, message->transmit_timeout > 0 ? (int32_t)(iTargetTime - iNow) : 1000))
- {
- iNow = GetTimeMs();
- continue;
- }
-
- if (msg.message() == MSGCODE_FRAME_START && msg.ack())
- {
- m_busDevices[msg.initiator()]->GetHandler()->HandlePoll(msg.initiator(), msg.destination());
- m_lastInitiator = msg.initiator();
- iNow = GetTimeMs();
- continue;
- }
-
- bError = msg.is_error();
- if (msg.message() == MSGCODE_RECEIVE_FAILED &&
- m_lastInitiator != CECDEVICE_UNKNOWN &&
- !m_busDevices[m_lastInitiator]->GetHandler()->HandleReceiveFailed())
- {
- iNow = GetTimeMs();
- continue;
- }
-
- if (bError)
- {
- message->reply = msg.message();
- m_controller->AddLog(CEC_LOG_DEBUG, msg.ToString());
- }
- else
- {
- switch(msg.message())
- {
- case MSGCODE_COMMAND_ACCEPTED:
- m_controller->AddLog(CEC_LOG_DEBUG, msg.ToString());
- if (iPacketsLeft > 0)
- iPacketsLeft--;
- break;
- case MSGCODE_TRANSMIT_SUCCEEDED:
- m_controller->AddLog(CEC_LOG_DEBUG, msg.ToString());
- bTransmitSucceeded = (iPacketsLeft == 0);
- bError = !bTransmitSucceeded;
- message->reply = MSGCODE_TRANSMIT_SUCCEEDED;
- break;
- default:
- // ignore other data while waiting
- break;
- }
-
- iNow = GetTimeMs();
- }
- }
-
- return bTransmitSucceeded && !bError;
-}
-
bool CCECProcessor::ParseMessage(const CCECAdapterMessage &msg)
{
bool bEom(false);
- bool bIsError(msg.is_error());
+ bool bIsError(msg.IsError());
- if (msg.empty())
+ if (msg.IsEmpty())
return bEom;
- switch(msg.message())
+ switch(msg.Message())
{
case MSGCODE_FRAME_START:
{
m_currentframe.Clear();
- if (msg.size() >= 2)
+ if (msg.Size() >= 2)
{
- m_currentframe.initiator = msg.initiator();
- m_currentframe.destination = msg.destination();
- m_currentframe.ack = msg.ack();
- m_currentframe.eom = msg.eom();
+ 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)
{
break;
case MSGCODE_FRAME_DATA:
{
- if (msg.size() >= 2)
+ if (msg.Size() >= 2)
{
m_currentframe.PushBack(msg[1]);
- m_currentframe.eom = msg.eom();
+ m_currentframe.eom = msg.IsEOM();
}
- bEom = msg.eom();
+ bEom = msg.IsEOM();
}
break;
default:
CCECAdapterMessage *output = new CCECAdapterMessage;
- output->push_back(MSGSTART);
- output->push_escaped(MSGCODE_SET_ACK_MASK);
- output->push_escaped(iMask >> 8);
- output->push_escaped((uint8_t)iMask);
- output->push_back(MSGEND);
+ output->PushBack(MSGSTART);
+ output->PushEscaped(MSGCODE_SET_ACK_MASK);
+ output->PushEscaped(iMask >> 8);
+ output->PushEscaped((uint8_t)iMask);
+ output->PushBack(MSGEND);
if ((bReturn = Transmit(output)) == false)
m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
{
return m_communication->PingAdapter();
}
+
+void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
+{
+ m_busDevices[initiator]->GetHandler()->HandlePoll(initiator, destination);
+ m_lastInitiator = initiator;
+}
+
+bool CCECProcessor::HandleReceiveFailed(void)
+{
+ return m_lastInitiator != CECDEVICE_UNKNOWN &&
+ !m_busDevices[m_lastInitiator]->GetHandler()->HandleReceiveFailed();
+}