src/lib/CECProcessor.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited.  All rights reserved.
   5  * libCEC(R) is an original work, containing original code.
   6  *
   7  * libCEC(R) is a trademark of Pulse-Eight Limited.
   8  *
   9  * This program is dual-licensed; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  *
  23  *
  24  * Alternatively, you can license this library under a commercial license,
  25  * please contact Pulse-Eight Licensing for more information.
  26  *
  27  * For more information contact:
  28  * Pulse-Eight Licensing       <license@pulse-eight.com>
  29  *     http://www.pulse-eight.com/
  30  *     http://www.pulse-eight.net/
  31  */
  32
  33 #include "CECProcessor.h"
  34
  35 #include "AdapterCommunication.h"
  36 #include "devices/CECBusDevice.h"
  37 #include "devices/CECAudioSystem.h"
  38 #include "devices/CECPlaybackDevice.h"
  39 #include "devices/CECRecordingDevice.h"
  40 #include "devices/CECTuner.h"
  41 #include "devices/CECTV.h"
  42 #include "LibCEC.h"
  43 #include "util/StdString.h"
  44 #include "platform/timeutils.h"
  45
  46 using namespace CEC;
  47 using namespace std;
  48
  49 CCECProcessor::CCECProcessor(CLibCEC *controller, CAdapterCommunication *serComm, const char *strDeviceName, cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS*/) :
  50     m_bStarted(false),
  51     m_strDeviceName(strDeviceName),
  52     m_communication(serComm),
  53     m_controller(controller),
  54     m_bMonitor(false)
  55 {
  56   m_logicalAddresses.clear();
  57   m_logicalAddresses.set(iLogicalAddress);
  58   m_types.clear();
  59   for (int iPtr = 0; iPtr < 16; iPtr++)
  60     m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, iPtr == iLogicalAddress ? iPhysicalAddress : 0);
  61 }
  62
  63 CCECProcessor::CCECProcessor(CLibCEC *controller, CAdapterCommunication *serComm, const char *strDeviceName, const cec_device_type_list &types) :
  64     m_bStarted(false),
  65     m_strDeviceName(strDeviceName),
  66     m_types(types),
  67     m_communication(serComm),
  68     m_controller(controller),
  69     m_bMonitor(false)
  70 {
  71   m_logicalAddresses.clear();
  72   for (int iPtr = 0; iPtr < 16; iPtr++)
  73   {
  74     switch(iPtr)
  75     {
  76     case CECDEVICE_AUDIOSYSTEM:
  77       m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF);
  78       break;
  79     case CECDEVICE_PLAYBACKDEVICE1:
  80     case CECDEVICE_PLAYBACKDEVICE2:
  81     case CECDEVICE_PLAYBACKDEVICE3:
  82       m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF);
  83       break;
  84     case CECDEVICE_RECORDINGDEVICE1:
  85     case CECDEVICE_RECORDINGDEVICE2:
  86     case CECDEVICE_RECORDINGDEVICE3:
  87       m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF);
  88       break;
  89     case CECDEVICE_TUNER1:
  90     case CECDEVICE_TUNER2:
  91     case CECDEVICE_TUNER3:
  92     case CECDEVICE_TUNER4:
  93       m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF);
  94       break;
  95     case CECDEVICE_TV:
  96       m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0);
  97       break;
  98     default:
  99       m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF);
 100       break;
 101     }
 102   }
 103 }
 104
 105 CCECProcessor::~CCECProcessor(void)
 106 {
 107   m_startCondition.Broadcast();
 108   StopThread();
 109   m_communication = NULL;
 110   m_controller = NULL;
 111   for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 112     delete m_busDevices[iPtr];
 113 }
 114
 115 bool CCECProcessor::Start(void)
 116 {
 117   CLockObject lock(&m_mutex);
 118   if (!m_communication || !m_communication->IsOpen())
 119   {
 120     m_controller->AddLog(CEC_LOG_ERROR, "connection is closed");
 121     return false;
 122   }
 123
 124   if (CreateThread())
 125   {
 126     if (!m_startCondition.Wait(&m_mutex) || !m_bStarted)
 127     {
 128       m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
 129       return false;
 130     }
 131     return true;
 132   }
 133   else
 134     m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
 135
 136   return false;
 137 }
 138
 139 bool CCECProcessor::TryLogicalAddress(cec_logical_address address, const char *strLabel, unsigned int iIndex)
 140 {
 141   CStdString strLog;
 142   strLog.Format("trying logical address '%s'", strLabel);
 143   AddLog(CEC_LOG_DEBUG, strLog);
 144
 145   SetAckMask(0x1 << address);
 146   if (!m_busDevices[address]->TransmitPoll(address))
 147   {
 148     strLog.Format("using logical address '%s'", strLabel);
 149     AddLog(CEC_LOG_NOTICE, strLog);
 150
 151     /* only set our OSD name and active source for the primary device */
 152     if (m_logicalAddresses.empty())
 153     {
 154       m_busDevices[address]->m_strDeviceName = m_strDeviceName;
 155       m_busDevices[address]->m_bActiveSource = true;
 156     }
 157     m_busDevices[address]->m_powerStatus = (m_types[0] == m_busDevices[address]->m_type) ? CEC_POWER_STATUS_ON : CEC_POWER_STATUS_STANDBY;
 158     m_busDevices[address]->m_cecVersion = CEC_VERSION_1_3A;
 159     m_logicalAddresses.set(address);
 160
 161     // TODO
 162     m_busDevices[address]->SetPhysicalAddress(CEC_DEFAULT_PHYSICAL_ADDRESS + (iIndex * 0x100));
 163
 164     return true;
 165   }
 166
 167   strLog.Format("logical address '%s' already taken", strLabel);
 168   AddLog(CEC_LOG_DEBUG, strLog);
 169   return false;
 170 }
 171
 172 bool CCECProcessor::FindLogicalAddressRecordingDevice(unsigned int iIndex)
 173 {
 174   AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
 175   return TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1, "recording 1", iIndex) ||
 176       TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2, "recording 2", iIndex) ||
 177       TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3, "recording 3", iIndex);
 178 }
 179
 180 bool CCECProcessor::FindLogicalAddressTuner(unsigned int iIndex)
 181 {
 182   AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
 183   return TryLogicalAddress(CECDEVICE_TUNER1, "tuner 1", iIndex) ||
 184       TryLogicalAddress(CECDEVICE_TUNER2, "tuner 2", iIndex) ||
 185       TryLogicalAddress(CECDEVICE_TUNER3, "tuner 3", iIndex) ||
 186       TryLogicalAddress(CECDEVICE_TUNER4, "tuner 4", iIndex);
 187 }
 188
 189 bool CCECProcessor::FindLogicalAddressPlaybackDevice(unsigned int iIndex)
 190 {
 191   AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
 192   return TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1, "playback 1", iIndex) ||
 193       TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2, "playback 2", iIndex) ||
 194       TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3, "playback 3", iIndex);
 195 }
 196
 197 bool CCECProcessor::FindLogicalAddressAudioSystem(unsigned int iIndex)
 198 {
 199   AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audio'");
 200   return TryLogicalAddress(CECDEVICE_AUDIOSYSTEM, "audio", iIndex);
 201 }
 202
 203 bool CCECProcessor::FindLogicalAddresses(void)
 204 {
 205   bool bReturn(true);
 206   m_logicalAddresses.clear();
 207   CStdString strLog;
 208
 209   for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 210   {
 211     if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
 212       continue;
 213
 214     strLog.Format("%s - device %d: type %d", __FUNCTION__, iPtr, m_types.types[iPtr]);
 215     AddLog(CEC_LOG_DEBUG, strLog);
 216
 217     if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
 218       bReturn &= FindLogicalAddressRecordingDevice(iPtr);
 219     if (m_types.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
 220       bReturn &= FindLogicalAddressTuner(iPtr);
 221     if (m_types.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
 222       bReturn &= FindLogicalAddressPlaybackDevice(iPtr);
 223     if (m_types.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 224       bReturn &= FindLogicalAddressAudioSystem(iPtr);
 225   }
 226
 227   return bReturn;
 228 }
 229
 230 void *CCECProcessor::Process(void)
 231 {
 232   bool                  bParseFrame(false);
 233   cec_command           command;
 234   CCECAdapterMessage    msg;
 235
 236   {
 237     if (m_logicalAddresses.empty() && !FindLogicalAddresses())
 238     {
 239       CLockObject lock(&m_mutex);
 240       m_controller->AddLog(CEC_LOG_ERROR, "could not detect our logical addressed");
 241       m_startCondition.Signal();
 242       return NULL;
 243     }
 244
 245     SetAckMask(m_logicalAddresses.ackmask());
 246
 247     {
 248       CLockObject lock(&m_mutex);
 249       m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
 250       m_bStarted = true;
 251       m_startCondition.Signal();
 252     }
 253   }
 254
 255   while (!IsStopped())
 256   {
 257     command.clear();
 258     msg.clear();
 259
 260     {
 261       CLockObject lock(&m_mutex);
 262       if (m_commandBuffer.Pop(command))
 263       {
 264         bParseFrame = true;
 265       }
 266       else if (m_communication->IsOpen() && m_communication->Read(msg, 50))
 267       {
 268         m_controller->AddLog(msg.is_error() ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
 269         if ((bParseFrame = (ParseMessage(msg) && !IsStopped())))
 270           command = m_currentframe;
 271       }
 272     }
 273
 274     if (bParseFrame)
 275       ParseCommand(command);
 276     bParseFrame = false;
 277
 278     Sleep(5);
 279
 280     m_controller->CheckKeypressTimeout();
 281
 282     for (unsigned int iDevicePtr = 0; iDevicePtr < 16; iDevicePtr++)
 283       m_busDevices[iDevicePtr]->PollVendorId();
 284
 285     Sleep(5);
 286   }
 287
 288   return NULL;
 289 }
 290
 291 bool CCECProcessor::SetActiveView(void)
 292 {
 293   if (!IsRunning())
 294     return false;
 295
 296   if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
 297     return m_busDevices[m_logicalAddresses.primary]->TransmitActiveView();
 298   return false;
 299 }
 300
 301 bool CCECProcessor::SetInactiveView(void)
 302 {
 303   if (!IsRunning())
 304     return false;
 305
 306   if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
 307     return m_busDevices[m_logicalAddresses.primary]->TransmitInactiveView();
 308   return false;
 309 }
 310
 311 void CCECProcessor::LogOutput(const cec_command &data)
 312 {
 313   CStdString strTx;
 314   strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
 315   if (data.opcode_set)
 316       strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
 317
 318   for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
 319     strTx.AppendFormat(":%02x", data.parameters[iPtr]);
 320   m_controller->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
 321 }
 322
 323 bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
 324 {
 325   if (m_logicalAddresses.primary != iLogicalAddress)
 326   {
 327     CStdString strLog;
 328     strLog.Format("<< setting primary logical address to %1x", iLogicalAddress);
 329     m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
 330     m_logicalAddresses.primary = iLogicalAddress;
 331     m_logicalAddresses.set(iLogicalAddress);
 332     return SetAckMask(m_logicalAddresses.ackmask());
 333   }
 334
 335   return true;
 336 }
 337
 338 bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress)
 339 {
 340   if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
 341   {
 342     m_busDevices[m_logicalAddresses.primary]->SetPhysicalAddress(iPhysicalAddress);
 343     return m_busDevices[m_logicalAddresses.primary]->TransmitActiveView();
 344   }
 345   return false;
 346 }
 347
 348 bool CCECProcessor::SwitchMonitoring(bool bEnable)
 349 {
 350   CStdString strLog;
 351   strLog.Format("== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
 352   m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
 353
 354   m_bMonitor = bEnable;
 355   if (bEnable)
 356     return SetAckMask(0);
 357   else
 358     return SetAckMask(m_logicalAddresses.ackmask());
 359 }
 360
 361 bool CCECProcessor::PollDevice(cec_logical_address iAddress)
 362 {
 363   if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress])
 364     return m_busDevices[m_logicalAddresses.primary]->TransmitPoll(iAddress);
 365   return false;
 366 }
 367
 368 cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress)
 369 {
 370   return m_busDevices[iAddress]->GetCecVersion();
 371 }
 372
 373 bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
 374 {
 375   if (m_busDevices[iAddress])
 376   {
 377     *language = m_busDevices[iAddress]->GetMenuLanguage();
 378     return (strcmp(language->language, "???") != 0);
 379   }
 380   return false;
 381 }
 382
 383 uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
 384 {
 385   if (m_busDevices[iAddress])
 386     return m_busDevices[iAddress]->GetVendorId();
 387   return false;
 388 }
 389
 390 cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress)
 391 {
 392   if (m_busDevices[iAddress])
 393     return m_busDevices[iAddress]->GetPowerStatus();
 394   return CEC_POWER_STATUS_UNKNOWN;
 395 }
 396
 397 bool CCECProcessor::Transmit(const cec_command &data)
 398 {
 399   bool bReturn(false);
 400   LogOutput(data);
 401
 402   CCECAdapterMessage *output = new CCECAdapterMessage(data);
 403   bReturn = Transmit(output);
 404   delete output;
 405
 406   return bReturn;
 407 }
 408
 409 bool CCECProcessor::Transmit(CCECAdapterMessage *output)
 410 {
 411   bool bReturn(false);
 412   CLockObject lock(&m_mutex);
 413   {
 414     CLockObject msgLock(&output->mutex);
 415     if (!m_communication || !m_communication->Write(output))
 416       return bReturn;
 417     else
 418     {
 419       output->condition.Wait(&output->mutex);
 420       if (output->state != ADAPTER_MESSAGE_STATE_SENT)
 421       {
 422         m_controller->AddLog(CEC_LOG_ERROR, "command was not sent");
 423         return bReturn;
 424       }
 425     }
 426
 427     if (output->transmit_timeout > 0)
 428     {
 429       if ((bReturn = WaitForTransmitSucceeded(output->size(), output->transmit_timeout)) == false)
 430         m_controller->AddLog(CEC_LOG_DEBUG, "did not receive ack");
 431     }
 432     else
 433       bReturn = true;
 434   }
 435
 436   return bReturn;
 437 }
 438
 439 void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, ECecAbortReason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
 440 {
 441   m_controller->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
 442
 443   cec_command command;
 444   // TODO
 445   cec_command::format(command, m_logicalAddresses.primary, address, CEC_OPCODE_FEATURE_ABORT);
 446   command.parameters.push_back((uint8_t)opcode);
 447   command.parameters.push_back((uint8_t)reason);
 448
 449   Transmit(command);
 450 }
 451
 452 bool CCECProcessor::WaitForTransmitSucceeded(uint8_t iLength, uint32_t iTimeout /* = 1000 */)
 453 {
 454   bool bError(false);
 455   bool bTransmitSucceeded(false);
 456   uint8_t iPacketsLeft(iLength / 4);
 457
 458   int64_t iNow = GetTimeMs();
 459   int64_t iTargetTime = iNow + (uint64_t) iTimeout;
 460
 461   while (!bTransmitSucceeded && !bError && (iTimeout == 0 || iNow < iTargetTime))
 462   {
 463     CCECAdapterMessage msg;
 464
 465     if (!m_communication->Read(msg, iTimeout > 0 ? (int32_t)(iTargetTime - iNow) : 1000))
 466     {
 467       iNow = GetTimeMs();
 468       continue;
 469     }
 470
 471     if ((bError = msg.is_error()) == false)
 472     {
 473       m_controller->AddLog(bError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
 474
 475       switch(msg.message())
 476       {
 477       case MSGCODE_COMMAND_ACCEPTED:
 478         if (iPacketsLeft > 0)
 479           iPacketsLeft--;
 480         break;
 481       case MSGCODE_TRANSMIT_SUCCEEDED:
 482         bTransmitSucceeded = (iPacketsLeft == 0);
 483         bError = !bTransmitSucceeded;
 484         break;
 485       default:
 486         if (ParseMessage(msg))
 487           m_commandBuffer.Push(m_currentframe);
 488       }
 489
 490       iNow = GetTimeMs();
 491     }
 492   }
 493
 494   return bTransmitSucceeded && !bError;
 495 }
 496
 497 bool CCECProcessor::ParseMessage(const CCECAdapterMessage &msg)
 498 {
 499   bool bEom = false;
 500
 501   if (msg.empty())
 502     return bEom;
 503
 504   switch(msg.message())
 505   {
 506   case MSGCODE_FRAME_START:
 507     {
 508       m_currentframe.clear();
 509       if (msg.size() >= 2)
 510       {
 511         m_currentframe.initiator   = msg.initiator();
 512         m_currentframe.destination = msg.destination();
 513         m_currentframe.ack         = msg.ack();
 514         m_currentframe.eom         = msg.eom();
 515       }
 516     }
 517     break;
 518   case MSGCODE_FRAME_DATA:
 519     {
 520       if (msg.size() >= 2)
 521       {
 522         m_currentframe.push_back(msg[1]);
 523         m_currentframe.eom = msg.eom();
 524       }
 525       bEom = msg.eom();
 526     }
 527     break;
 528   default:
 529     break;
 530   }
 531
 532   return bEom;
 533 }
 534
 535 void CCECProcessor::ParseCommand(cec_command &command)
 536 {
 537   CStdString dataStr;
 538   dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode);
 539   for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 540     dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
 541   m_controller->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
 542
 543   if (!m_bMonitor)
 544     m_busDevices[(uint8_t)command.initiator]->HandleCommand(command);
 545 }
 546
 547 uint16_t CCECProcessor::GetPhysicalAddress(void) const
 548 {
 549   if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
 550     return m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress();
 551   return false;
 552 }
 553
 554 void CCECProcessor::SetCurrentButton(cec_user_control_code iButtonCode)
 555 {
 556   m_controller->SetCurrentButton(iButtonCode);
 557 }
 558
 559 void CCECProcessor::AddCommand(const cec_command &command)
 560 {
 561   m_controller->AddCommand(command);
 562 }
 563
 564 void CCECProcessor::AddKey(cec_keypress &key)
 565 {
 566   m_controller->AddKey(key);
 567 }
 568
 569 void CCECProcessor::AddKey(void)
 570 {
 571   m_controller->AddKey();
 572 }
 573
 574 void CCECProcessor::AddLog(cec_log_level level, const CStdString &strMessage)
 575 {
 576   m_controller->AddLog(level, strMessage);
 577 }
 578
 579 bool CCECProcessor::SetAckMask(uint16_t iMask)
 580 {
 581   bool bReturn(false);
 582   CStdString strLog;
 583   strLog.Format("setting ackmask to %2x", iMask);
 584   m_controller->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 585
 586   CCECAdapterMessage *output = new CCECAdapterMessage;
 587
 588   output->push_back(MSGSTART);
 589   output->push_escaped(MSGCODE_SET_ACK_MASK);
 590   output->push_escaped(iMask >> 8);
 591   output->push_escaped((uint8_t)iMask);
 592   output->push_back(MSGEND);
 593
 594   if ((bReturn = Transmit(output)) == false)
 595     m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
 596
 597   delete output;
 598
 599   return bReturn;
 600 }