src/lib/devices/CECBusDevice.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 "CECBusDevice.h"
  34 #include "../CECProcessor.h"
  35 #include "../implementations/ANCommandHandler.h"
  36 #include "../implementations/CECCommandHandler.h"
  37 #include "../implementations/SLCommandHandler.h"
  38 #include "../implementations/VLCommandHandler.h"
  39 #include "../platform/timeutils.h"
  40
  41 using namespace CEC;
  42
  43 CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress) :
  44   m_iPhysicalAddress(iPhysicalAddress),
  45   m_iStreamPath(0),
  46   m_iLogicalAddress(iLogicalAddress),
  47   m_powerStatus(CEC_POWER_STATUS_UNKNOWN),
  48   m_processor(processor),
  49   m_bMenuActive(true),
  50   m_iVendorClass(CEC_VENDOR_UNKNOWN),
  51   m_iLastActive(0),
  52   m_cecVersion(CEC_VERSION_1_3A)
  53 {
  54   m_handler = new CCECCommandHandler(this);
  55
  56   for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
  57     m_menuLanguage.language[iPtr] = '?';
  58   m_menuLanguage.language[3] = 0;
  59   m_menuLanguage.device = iLogicalAddress;
  60
  61   m_vendor.vendor = CEC_VENDOR_UNKNOWN;
  62   m_type          = CEC_DEVICE_TYPE_RESERVED;
  63   m_strDeviceName = "Unknown";
  64 }
  65
  66 CCECBusDevice::~CCECBusDevice(void)
  67 {
  68   m_condition.Broadcast();
  69   delete m_handler;
  70 }
  71
  72 void CCECBusDevice::AddLog(cec_log_level level, const CStdString &strMessage)
  73 {
  74   m_processor->AddLog(level, strMessage);
  75 }
  76
  77 bool CCECBusDevice::HandleCommand(const cec_command &command)
  78 {
  79   CLockObject lock(&m_mutex);
  80   m_iLastActive = GetTimeMs();
  81   m_handler->HandleCommand(command);
  82   m_condition.Signal();
  83   return true;
  84 }
  85
  86 void CCECBusDevice::PollVendorId(void)
  87 {
  88   CLockObject lock(&m_mutex);
  89   if (m_iLastActive > 0 && m_iLogicalAddress != CECDEVICE_BROADCAST &&
  90       m_vendor.vendor == CEC_VENDOR_UNKNOWN &&
  91       GetTimeMs() - m_iLastActive > 5000)
  92   {
  93     m_iLastActive = GetTimeMs();
  94
  95     cec_command command;
  96     cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
  97     if (m_processor->Transmit(command))
  98       m_condition.Wait(&m_mutex, 1000);
  99   }
 100 }
 101
 102 bool CCECBusDevice::PowerOn(void)
 103 {
 104   CStdString strLog;
 105   strLog.Format("<< powering on device with logical address %d", (int8_t)m_iLogicalAddress);
 106   AddLog(CEC_LOG_DEBUG, strLog.c_str());
 107
 108   cec_command command;
 109   cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_IMAGE_VIEW_ON);
 110
 111   return m_processor->Transmit(command);
 112 }
 113
 114 bool CCECBusDevice::Standby(void)
 115 {
 116   CStdString strLog;
 117   strLog.Format("<< putting device with logical address %d in standby mode", (int8_t)m_iLogicalAddress);
 118   AddLog(CEC_LOG_DEBUG, strLog.c_str());
 119
 120   cec_command command;
 121   cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_STANDBY);
 122
 123   return m_processor->Transmit(command);
 124 }
 125
 126 /** @name Getters */
 127 //@{
 128 cec_version CCECBusDevice::GetCecVersion(void)
 129 {
 130   if (m_cecVersion == CEC_VERSION_UNKNOWN)
 131   {
 132     if (!MyLogicalAddressContains(m_iLogicalAddress))
 133     {
 134       AddLog(CEC_LOG_NOTICE, "<< requesting CEC version");
 135       cec_command command;
 136       cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GET_CEC_VERSION);
 137       CLockObject lock(&m_mutex);
 138       if (m_processor->Transmit(command))
 139         m_condition.Wait(&m_mutex, 1000);
 140     }
 141   }
 142
 143   return m_cecVersion;
 144 }
 145
 146 cec_menu_language &CCECBusDevice::GetMenuLanguage(void)
 147 {
 148   if (!strcmp(m_menuLanguage.language, "???"))
 149   {
 150     if (!MyLogicalAddressContains(m_iLogicalAddress))
 151     {
 152       AddLog(CEC_LOG_NOTICE, "<< requesting menu language");
 153       cec_command command;
 154       cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GET_MENU_LANGUAGE);
 155       CLockObject lock(&m_mutex);
 156       if (m_processor->Transmit(command))
 157         m_condition.Wait(&m_mutex, 1000);
 158     }
 159   }
 160
 161   return m_menuLanguage;
 162 }
 163
 164 cec_logical_address CCECBusDevice::GetMyLogicalAddress(void) const
 165 {
 166   return m_processor->GetLogicalAddress();
 167 }
 168
 169 uint16_t CCECBusDevice::GetMyPhysicalAddress(void) const
 170 {
 171   return m_processor->GetPhysicalAddress();
 172 }
 173
 174 cec_power_status CCECBusDevice::GetPowerStatus(void)
 175 {
 176   if (m_powerStatus == CEC_POWER_STATUS_UNKNOWN)
 177   {
 178     if (!MyLogicalAddressContains(m_iLogicalAddress))
 179     {
 180       AddLog(CEC_LOG_NOTICE, "<< requesting power status");
 181       cec_command command;
 182       cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
 183       CLockObject lock(&m_mutex);
 184       if (m_processor->Transmit(command))
 185         m_condition.Wait(&m_mutex, 1000);
 186     }
 187   }
 188
 189   return m_powerStatus;
 190 }
 191
 192 const cec_vendor &CCECBusDevice::GetVendor(void)
 193 {
 194   if (m_vendor.vendor == CEC_VENDOR_UNKNOWN)
 195   {
 196     if (!MyLogicalAddressContains(m_iLogicalAddress))
 197     {
 198       AddLog(CEC_LOG_NOTICE, "<< requesting vendor ID");
 199       cec_command command;
 200       cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 201       CLockObject lock(&m_mutex);
 202
 203       if (m_processor->Transmit(command))
 204         m_condition.Wait(&m_mutex, 1000);
 205     }
 206   }
 207
 208   return m_vendor;
 209 }
 210
 211 bool CCECBusDevice::MyLogicalAddressContains(cec_logical_address address) const
 212 {
 213   return m_processor->HasLogicalAddress(address);
 214 }
 215
 216 //@}
 217
 218 /** @name Setters */
 219 //@{
 220 void CCECBusDevice::SetCecVersion(const cec_version newVersion)
 221 {
 222   CStdString strLog;
 223   m_cecVersion = newVersion;
 224
 225   switch (newVersion)
 226   {
 227   case CEC_VERSION_1_2:
 228     strLog.Format("device %d reports CEC version 1.2", m_iLogicalAddress);
 229     break;
 230   case CEC_VERSION_1_2A:
 231     strLog.Format("device %d reports CEC version 1.2a", m_iLogicalAddress);
 232     break;
 233   case CEC_VERSION_1_3:
 234     strLog.Format("device %d reports CEC version 1.3", m_iLogicalAddress);
 235     break;
 236   case CEC_VERSION_1_3A:
 237     strLog.Format("device %d reports CEC version 1.3a", m_iLogicalAddress);
 238     break;
 239   default:
 240     strLog.Format("device %d reports an unknown CEC version", m_iLogicalAddress);
 241     m_cecVersion = CEC_VERSION_UNKNOWN;
 242     break;
 243   }
 244   AddLog(CEC_LOG_DEBUG, strLog);
 245 }
 246
 247 void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
 248 {
 249   if (language.device == m_iLogicalAddress)
 250   {
 251     CStdString strLog;
 252     strLog.Format("device %d menu language set to '%s'", m_iLogicalAddress, language.language);
 253     m_processor->AddLog(CEC_LOG_DEBUG, strLog);
 254     m_menuLanguage = language;
 255   }
 256 }
 257
 258 void CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
 259 {
 260   if (iNewAddress > 0)
 261   {
 262     CStdString strLog;
 263     strLog.Format(">> %i changed physical address from %04x to %04x", m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
 264     AddLog(CEC_LOG_DEBUG, strLog.c_str());
 265
 266     m_iPhysicalAddress = iNewAddress;
 267   }
 268 }
 269
 270 void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = 0 */)
 271 {
 272   if (iNewAddress > 0)
 273   {
 274     CStdString strLog;
 275     strLog.Format(">> %i stream path from %04x to %04x", m_iLogicalAddress, iOldAddress, iNewAddress);
 276     AddLog(CEC_LOG_DEBUG, strLog.c_str());
 277
 278     m_iStreamPath = iNewAddress;
 279   }
 280 }
 281
 282 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
 283 {
 284   if (m_powerStatus != powerStatus)
 285   {
 286     CStdString strLog;
 287     strLog.Format("device %d power status changed from %2x to %2x", m_iLogicalAddress, m_powerStatus, powerStatus);
 288     m_processor->AddLog(CEC_LOG_DEBUG, strLog);
 289     m_powerStatus = powerStatus;
 290   }
 291 }
 292
 293 void CCECBusDevice::SetVendorId(const cec_datapacket &data)
 294 {
 295   if (data.size < 3)
 296   {
 297     AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 298     return;
 299   }
 300
 301   uint64_t iVendorId = ((uint64_t)data[0] << 3) +
 302                        ((uint64_t)data[1] << 2) +
 303                         (uint64_t)data[2];
 304
 305   SetVendorId(iVendorId, data.size >= 4 ? data[3] : 0);
 306 }
 307
 308 void CCECBusDevice::SetVendorId(uint64_t iVendorId, uint8_t iVendorClass /* = 0 */)
 309 {
 310   m_vendor.vendor = (cec_vendor_id)iVendorId;
 311   m_iVendorClass = iVendorClass;
 312
 313   switch (iVendorId)
 314   {
 315   case CEC_VENDOR_SAMSUNG:
 316     if (m_handler->GetVendorId() != CEC_VENDOR_SAMSUNG)
 317     {
 318       delete m_handler;
 319       m_handler = new CANCommandHandler(this);
 320     }
 321     break;
 322   case CEC_VENDOR_LG:
 323     if (m_handler->GetVendorId() != CEC_VENDOR_LG)
 324     {
 325       delete m_handler;
 326       m_handler = new CSLCommandHandler(this);
 327     }
 328     break;
 329   case CEC_VENDOR_PANASONIC:
 330     if (m_handler->GetVendorId() != CEC_VENDOR_PANASONIC)
 331     {
 332       delete m_handler;
 333       m_handler = new CVLCommandHandler(this);
 334     }
 335     break;
 336   default:
 337     if (m_handler->GetVendorId() != CEC_VENDOR_UNKNOWN)
 338     {
 339       delete m_handler;
 340       m_handler = new CCECCommandHandler(this);
 341     }
 342     break;
 343   }
 344
 345   CStdString strLog;
 346   strLog.Format("device %d: vendor = %s (%06x) class = %2x", m_iLogicalAddress, GetVendorName(), GetVendorId(), GetVendorClass());
 347   m_processor->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 348 }
 349 //@}
 350
 351 /** @name Transmit methods */
 352 //@{
 353 bool CCECBusDevice::TransmitActiveSource(void)
 354 {
 355   CStdString strLog;
 356   strLog.Format("<< %x -> broadcast: active source (%4x)", m_iLogicalAddress, m_iPhysicalAddress);
 357   AddLog(CEC_LOG_NOTICE, strLog);
 358
 359   cec_command command;
 360   cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
 361   command.parameters.push_back((uint8_t) ((m_iPhysicalAddress >> 8) & 0xFF));
 362   command.parameters.push_back((uint8_t) (m_iPhysicalAddress & 0xFF));
 363
 364   return m_processor->Transmit(command);
 365 }
 366
 367 bool CCECBusDevice::TransmitActiveView(void)
 368 {
 369   CStdString strLog;
 370   strLog.Format("<< %x -> broadcast: active view (%4x)", m_iLogicalAddress, m_iPhysicalAddress);
 371   AddLog(CEC_LOG_NOTICE, strLog);
 372
 373   cec_command command;
 374   cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
 375   command.parameters.push_back((m_iPhysicalAddress >> 8) & 0xFF);
 376   command.parameters.push_back(m_iPhysicalAddress & 0xFF);
 377
 378   return m_processor->Transmit(command);
 379 }
 380
 381 bool CCECBusDevice::TransmitCECVersion(cec_logical_address dest)
 382 {
 383   CStdString strLog;
 384   strLog.Format("<< %x -> %x: cec version ", m_iLogicalAddress, dest);
 385   switch (m_cecVersion)
 386   {
 387   case CEC_VERSION_1_2:
 388     strLog.append("1.2");
 389     break;
 390   case CEC_VERSION_1_2A:
 391     strLog.append("1.2a");
 392     break;
 393   case CEC_VERSION_1_3:
 394     strLog.append("1.3");
 395     break;
 396   case CEC_VERSION_1_3A:
 397     strLog.append("1.3a");
 398     break;
 399   default:
 400     strLog.append("unknown");
 401     break;
 402   }
 403   AddLog(CEC_LOG_NOTICE, strLog);
 404
 405   cec_command command;
 406   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_CEC_VERSION);
 407   command.parameters.push_back(m_cecVersion);
 408
 409   return m_processor->Transmit(command);
 410 }
 411
 412 bool CCECBusDevice::TransmitDeckStatus(cec_logical_address dest)
 413 {
 414   // need to support opcodes play and deck control before doing anything with this
 415   CStdString strLog;
 416   strLog.Format("<< %x -> %x: deck status feature abort", m_iLogicalAddress, dest);
 417   AddLog(CEC_LOG_NOTICE, strLog);
 418
 419   m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DECK_STATUS);
 420   return false;
 421 }
 422
 423 bool CCECBusDevice::TransmitInactiveView(void)
 424 {
 425   CStdString strLog;
 426   strLog.Format("<< %x -> broadcast: inactive view", m_iLogicalAddress);
 427   AddLog(CEC_LOG_NOTICE, strLog);
 428
 429   cec_command command;
 430   cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_INACTIVE_SOURCE);
 431   command.parameters.push_back((m_iPhysicalAddress >> 8) & 0xFF);
 432   command.parameters.push_back(m_iPhysicalAddress & 0xFF);
 433
 434   return m_processor->Transmit(command);
 435 }
 436
 437 bool CCECBusDevice::TransmitMenuState(cec_logical_address dest)
 438 {
 439   CStdString strLog;
 440   strLog.Format("<< %x -> %x: ", m_iLogicalAddress, dest);
 441   if (m_bMenuActive)
 442     strLog.append("menu active");
 443   else
 444     strLog.append("menu inactive");
 445   AddLog(CEC_LOG_NOTICE, strLog);
 446
 447   cec_command command;
 448   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_MENU_STATUS);
 449   command.parameters.push_back(m_bMenuActive ? (uint8_t) CEC_MENU_STATE_ACTIVATED : (uint8_t) CEC_MENU_STATE_DEACTIVATED);
 450
 451   return m_processor->Transmit(command);
 452 }
 453
 454 bool CCECBusDevice::TransmitOSDName(cec_logical_address dest)
 455 {
 456   CStdString strLog;
 457   strLog.Format("<< %x -> %x: OSD name '%s'", m_iLogicalAddress, dest, m_strDeviceName.c_str());
 458   AddLog(CEC_LOG_NOTICE, strLog.c_str());
 459
 460   cec_command command;
 461   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_SET_OSD_NAME);
 462   for (unsigned int iPtr = 0; iPtr < m_strDeviceName.length(); iPtr++)
 463     command.parameters.push_back(m_strDeviceName.at(iPtr));
 464
 465   return m_processor->Transmit(command);
 466 }
 467
 468 bool CCECBusDevice::TransmitOSDString(cec_logical_address dest, cec_display_control duration, const char *strMessage)
 469 {
 470   CStdString strLog;
 471   strLog.Format("<< %x -> %x: display OSD message '%s'", m_iLogicalAddress, dest, strMessage);
 472   AddLog(CEC_LOG_NOTICE, strLog.c_str());
 473
 474   cec_command command;
 475   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_SET_OSD_STRING);
 476   command.parameters.push_back((uint8_t)duration);
 477
 478   unsigned int iLen = strlen(strMessage);
 479   if (iLen > 13) iLen = 13;
 480
 481   for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
 482     command.parameters.push_back(strMessage[iPtr]);
 483
 484   return m_processor->Transmit(command);
 485 }
 486
 487 bool CCECBusDevice::TransmitPhysicalAddress(void)
 488 {
 489   CStdString strLog;
 490   strLog.Format("<< %x -> broadcast: physical adddress %4x", m_iLogicalAddress, m_iPhysicalAddress);
 491   AddLog(CEC_LOG_NOTICE, strLog.c_str());
 492
 493   cec_command command;
 494   cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
 495   command.parameters.push_back((uint8_t) ((m_iPhysicalAddress >> 8) & 0xFF));
 496   command.parameters.push_back((uint8_t) (m_iPhysicalAddress & 0xFF));
 497   command.parameters.push_back((uint8_t) (m_type));
 498
 499   return m_processor->Transmit(command);
 500 }
 501
 502 bool CCECBusDevice::TransmitPoll(cec_logical_address dest)
 503 {
 504   bool bReturn(false);
 505
 506   if (dest == CECDEVICE_UNKNOWN)
 507     dest = m_iLogicalAddress;
 508
 509   CStdString strLog;
 510   strLog.Format("<< %x -> %x: POLL", m_iLogicalAddress, dest);
 511   AddLog(CEC_LOG_NOTICE, strLog.c_str());
 512
 513   cec_command command;
 514   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_NONE);
 515   CLockObject lock(&m_mutex);
 516
 517   bReturn = m_processor->Transmit(command);
 518   AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
 519   return bReturn;
 520 }
 521
 522 bool CCECBusDevice::TransmitPowerState(cec_logical_address dest)
 523 {
 524   CStdString strLog;
 525   strLog.Format("<< %x -> %x: ", m_iLogicalAddress, dest);
 526
 527   switch (m_powerStatus)
 528   {
 529   case CEC_POWER_STATUS_ON:
 530     strLog.append("powered on");
 531     break;
 532   case CEC_POWER_STATUS_STANDBY:
 533     strLog.append("in standby mode");
 534     break;
 535   case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
 536     strLog.append("in transition from on to standby");
 537     break;
 538   case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
 539     strLog.append("in transition from standby to on");
 540     break;
 541   default:
 542     strLog.append("power state unknown");
 543     break;
 544   }
 545   AddLog(CEC_LOG_NOTICE, strLog.c_str());
 546
 547   strLog.Format("<< reporting power status '%d'", m_powerStatus);
 548   AddLog(CEC_LOG_NOTICE, strLog);
 549
 550   cec_command command;
 551   cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_REPORT_POWER_STATUS);
 552   command.parameters.push_back((uint8_t) m_powerStatus);
 553
 554   return m_processor->Transmit(command);
 555 }
 556
 557 bool CCECBusDevice::TransmitVendorID(cec_logical_address dest)
 558 {
 559   CStdString strLog;
 560   strLog.Format("<< %x -> %x: vendor id feature abort", m_iLogicalAddress, dest);
 561   AddLog(CEC_LOG_NOTICE, strLog);
 562
 563   m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 564   return false;
 565 }
 566 //@}