src/lib/LibCEC.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2012 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 "env.h"
  34 #include "LibCEC.h"
  35
  36 #include "adapter/AdapterFactory.h"
  37 #include "adapter/AdapterCommunication.h"
  38 #include "CECProcessor.h"
  39 #include "CECTypeUtils.h"
  40 #include "devices/CECAudioSystem.h"
  41 #include "devices/CECBusDevice.h"
  42 #include "devices/CECPlaybackDevice.h"
  43 #include "devices/CECTV.h"
  44 #include "platform/util/timeutils.h"
  45 #include "platform/util/StdString.h"
  46 #include "platform/util/util.h"
  47
  48 #include "CECClient.h"
  49
  50 using namespace std;
  51 using namespace CEC;
  52 using namespace PLATFORM;
  53
  54 //TODO replace deprecated constructor in 2.0
  55 CLibCEC::CLibCEC(const char *UNUSED(strDeviceName), cec_device_type_list UNUSED(types), uint16_t UNUSED(iPhysicalAddress) /* = 0 */) :
  56     m_iStartTime(GetTimeMs()),
  57     m_client(NULL)
  58 {
  59   m_cec = new CCECProcessor(this);
  60 }
  61
  62 //TODO replace deprecated constructor in 2.0
  63 CLibCEC::CLibCEC(libcec_configuration *UNUSED(configuration)) :
  64     m_iStartTime(GetTimeMs()),
  65     m_client(NULL)
  66 {
  67   m_cec = new CCECProcessor(this);
  68 }
  69
  70 CLibCEC::~CLibCEC(void)
  71 {
  72   // unregister all clients client
  73   UnregisterClients();
  74
  75   // delete the adapter connection
  76   DELETE_AND_NULL(m_cec);
  77 }
  78
  79 bool CLibCEC::Open(const char *strPort, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
  80 {
  81   if (!m_cec || !strPort)
  82     return false;
  83
  84   // open a new connection
  85   if (!m_cec->Start(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs))
  86   {
  87     AddLog(CEC_LOG_ERROR, "could not start CEC communications");
  88     return false;
  89   }
  90
  91   // register all clients
  92   for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
  93   {
  94     if (!m_cec->RegisterClient(*it))
  95     {
  96       AddLog(CEC_LOG_ERROR, "failed to register a CEC client");
  97       return false;
  98     }
  99   }
 100
 101   return true;
 102 }
 103
 104 void CLibCEC::Close(void)
 105 {
 106   if (!m_cec)
 107     return;
 108
 109   // unregister all clients
 110   m_cec->UnregisterClients();
 111
 112   // close the connection
 113   m_cec->Close();
 114 }
 115
 116 int8_t CLibCEC::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
 117 {
 118   return CAdapterFactory(this).FindAdapters(deviceList, iBufSize, strDevicePath);
 119 }
 120
 121 bool CLibCEC::StartBootloader(void)
 122 {
 123   return m_cec ? m_cec->StartBootloader() : false;
 124 }
 125
 126 bool CLibCEC::PingAdapter(void)
 127 {
 128   return m_client ? m_client->PingAdapter() : false;
 129 }
 130
 131 bool CLibCEC::EnableCallbacks(void *cbParam, ICECCallbacks *callbacks)
 132 {
 133   return m_client ? m_client->EnableCallbacks(cbParam, callbacks) : false;
 134 }
 135
 136 bool CLibCEC::GetCurrentConfiguration(libcec_configuration *configuration)
 137 {
 138   return m_client ? m_client->GetCurrentConfiguration(*configuration) : false;
 139 }
 140
 141 bool CLibCEC::SetConfiguration(const libcec_configuration *configuration)
 142 {
 143   return m_client ? m_client->SetConfiguration(*configuration) : false;
 144 }
 145
 146 bool CLibCEC::CanPersistConfiguration(void)
 147 {
 148   return m_client ? m_client->CanPersistConfiguration() : false;
 149 }
 150
 151 bool CLibCEC::PersistConfiguration(libcec_configuration *configuration)
 152 {
 153   return m_client ? m_client->PersistConfiguration(*configuration) : false;
 154 }
 155
 156 void CLibCEC::RescanActiveDevices(void)
 157 {
 158   if (m_client)
 159     m_client->RescanActiveDevices();
 160 }
 161
 162 bool CLibCEC::IsLibCECActiveSource(void)
 163 {
 164   return m_client ? m_client->IsLibCECActiveSource() : false;
 165 }
 166
 167 bool CLibCEC::Transmit(const cec_command &data)
 168 {
 169   return m_client ? m_client->Transmit(data, false) : false;
 170 }
 171
 172 bool CLibCEC::SetLogicalAddress(cec_logical_address iLogicalAddress)
 173 {
 174   return m_client ? m_client->SetLogicalAddress(iLogicalAddress) : false;
 175 }
 176
 177 bool CLibCEC::SetPhysicalAddress(uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */)
 178 {
 179   return m_client ? m_client->SetPhysicalAddress(iPhysicalAddress) : false;
 180 }
 181
 182 bool CLibCEC::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort /* = CEC_DEFAULT_HDMI_PORT */)
 183 {
 184   return m_client ? m_client->SetHDMIPort(iBaseDevice, iPort) : false;
 185 }
 186
 187 bool CLibCEC::PowerOnDevices(cec_logical_address address /* = CECDEVICE_TV */)
 188 {
 189   return m_client ? m_client->SendPowerOnDevices(address) : false;
 190 }
 191
 192 bool CLibCEC::StandbyDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */)
 193 {
 194   return m_client ? m_client->SendStandbyDevices(address) : false;
 195 }
 196
 197 bool CLibCEC::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
 198 {
 199   return m_client ? m_client->SendSetActiveSource(type) : false;
 200 }
 201
 202 bool CLibCEC::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */)
 203 {
 204   return m_client ? m_client->SendSetDeckControlMode(mode, bSendUpdate) : false;
 205 }
 206
 207 bool CLibCEC::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true */)
 208 {
 209   return m_client ? m_client->SendSetDeckInfo(info, bSendUpdate) : false;
 210 }
 211
 212 bool CLibCEC::SetInactiveView(void)
 213 {
 214   return m_client ? m_client->SendSetInactiveView() : false;
 215 }
 216
 217 bool CLibCEC::SetMenuState(cec_menu_state state, bool bSendUpdate /* = true */)
 218 {
 219   return m_client ? m_client->SendSetMenuState(state, bSendUpdate) : false;
 220 }
 221
 222 bool CLibCEC::SetOSDString(cec_logical_address iLogicalAddress, cec_display_control duration, const char *strMessage)
 223 {
 224   return m_client ? m_client->SendSetOSDString(iLogicalAddress, duration, strMessage) : false;
 225 }
 226
 227 bool CLibCEC::SwitchMonitoring(bool bEnable)
 228 {
 229   return m_client ? m_client->SwitchMonitoring(bEnable) : false;
 230 }
 231
 232 cec_version CLibCEC::GetDeviceCecVersion(cec_logical_address iAddress)
 233 {
 234   return m_client ? m_client->GetDeviceCecVersion(iAddress) : CEC_VERSION_UNKNOWN;
 235 }
 236
 237 bool CLibCEC::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
 238 {
 239   return m_client ? m_client->GetDeviceMenuLanguage(iAddress, *language) : false;
 240 }
 241
 242 uint64_t CLibCEC::GetDeviceVendorId(cec_logical_address iAddress)
 243 {
 244   return m_client ? m_client->GetDeviceVendorId(iAddress) : (uint64_t)CEC_VENDOR_UNKNOWN;
 245 }
 246
 247 uint16_t CLibCEC::GetDevicePhysicalAddress(cec_logical_address iAddress)
 248 {
 249   return m_client ? m_client->GetDevicePhysicalAddress(iAddress) : CEC_INVALID_PHYSICAL_ADDRESS;
 250 }
 251
 252 cec_power_status CLibCEC::GetDevicePowerStatus(cec_logical_address iAddress)
 253 {
 254   return m_client ? m_client->GetDevicePowerStatus(iAddress) : CEC_POWER_STATUS_UNKNOWN;
 255 }
 256
 257 bool CLibCEC::PollDevice(cec_logical_address iAddress)
 258 {
 259   return m_client ? m_client->PollDevice(iAddress) : false;
 260 }
 261
 262 cec_logical_addresses CLibCEC::GetActiveDevices(void)
 263 {
 264   cec_logical_addresses addresses;
 265   addresses.Clear();
 266   if (m_client)
 267     addresses = m_client->GetActiveDevices();
 268   return addresses;
 269 }
 270
 271 bool CLibCEC::IsActiveDevice(cec_logical_address iAddress)
 272 {
 273   return m_client ? m_client->IsActiveDevice(iAddress) : false;
 274 }
 275
 276 bool CLibCEC::IsActiveDeviceType(cec_device_type type)
 277 {
 278   return m_client ? m_client->IsActiveDeviceType(type) : false;
 279 }
 280
 281 uint8_t CLibCEC::VolumeUp(bool bSendRelease /* = true */)
 282 {
 283   return m_client ? m_client->SendVolumeUp(bSendRelease) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 284 }
 285
 286 uint8_t CLibCEC::VolumeDown(bool bSendRelease /* = true */)
 287 {
 288   return m_client ? m_client->SendVolumeDown(bSendRelease) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 289 }
 290
 291 uint8_t CLibCEC::MuteAudio(bool UNUSED(bSendRelease) /* = true */)
 292 {
 293   return m_client ? m_client->SendMuteAudio() : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 294 }
 295
 296 bool CLibCEC::SendKeypress(cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
 297 {
 298   return m_client ? m_client->SendKeypress(iDestination, key, bWait) : false;
 299 }
 300
 301 bool CLibCEC::SendKeyRelease(cec_logical_address iDestination, bool bWait /* = true */)
 302 {
 303   return m_client ? m_client->SendKeyRelease(iDestination, bWait) : false;
 304 }
 305
 306 cec_osd_name CLibCEC::GetDeviceOSDName(cec_logical_address iAddress)
 307 {
 308   cec_osd_name retVal;
 309   retVal.device = CECDEVICE_UNKNOWN;
 310   memset(retVal.name, 0, 14);
 311
 312   if (m_client)
 313     retVal = m_client->GetDeviceOSDName(iAddress);
 314   return retVal;
 315 }
 316
 317 cec_logical_address CLibCEC::GetActiveSource(void)
 318 {
 319   return m_client ? m_client->GetActiveSource() : CECDEVICE_UNKNOWN;
 320 }
 321
 322 bool CLibCEC::IsActiveSource(cec_logical_address iAddress)
 323 {
 324   return m_client ? m_client->IsActiveSource(iAddress) : false;
 325 }
 326 bool CLibCEC::SetStreamPath(cec_logical_address iAddress)
 327 {
 328   return m_client ? m_client->SetStreamPath(iAddress) : false;
 329 }
 330
 331 bool CLibCEC::SetStreamPath(uint16_t iPhysicalAddress)
 332 {
 333   return m_client ? m_client->SetStreamPath(iPhysicalAddress) : false;
 334 }
 335
 336 cec_logical_addresses CLibCEC::GetLogicalAddresses(void)
 337 {
 338   cec_logical_addresses addresses;
 339   addresses.Clear();
 340   if (m_client)
 341     m_client->GetLogicalAddresses();
 342   return addresses;
 343 }
 344
 345 cec_device_type CLibCEC::GetType(cec_logical_address address)
 346 {
 347   return CCECTypeUtils::GetType(address);
 348 }
 349
 350 uint16_t CLibCEC::GetMaskForType(cec_logical_address address)
 351 {
 352   return CCECTypeUtils::GetMaskForType(address);
 353 }
 354
 355 uint16_t CLibCEC::GetMaskForType(cec_device_type type)
 356 {
 357   return CCECTypeUtils::GetMaskForType(type);
 358 }
 359
 360 bool CLibCEC::IsValidPhysicalAddress(uint16_t iPhysicalAddress)
 361 {
 362   return iPhysicalAddress >= CEC_MIN_PHYSICAL_ADDRESS &&
 363          iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS;
 364 }
 365
 366 const char *CLibCEC::ToString(const cec_device_type type)
 367 {
 368   return CCECTypeUtils::ToString(type);
 369 }
 370
 371 const char *CLibCEC::ToString(const cec_menu_state state)
 372 {
 373   return CCECTypeUtils::ToString(state);
 374 }
 375
 376 const char *CLibCEC::ToString(const cec_version version)
 377 {
 378   return CCECTypeUtils::ToString(version);
 379 }
 380
 381 const char *CLibCEC::ToString(const cec_power_status status)
 382 {
 383   return CCECTypeUtils::ToString(status);
 384 }
 385
 386 const char *CLibCEC::ToString(const cec_logical_address address)
 387 {
 388   return CCECTypeUtils::ToString(address);
 389 }
 390
 391 const char *CLibCEC::ToString(const cec_deck_control_mode mode)
 392 {
 393   return CCECTypeUtils::ToString(mode);
 394 }
 395
 396 const char *CLibCEC::ToString(const cec_deck_info status)
 397 {
 398   return CCECTypeUtils::ToString(status);
 399 }
 400
 401 const char *CLibCEC::ToString(const cec_opcode opcode)
 402 {
 403   return CCECTypeUtils::ToString(opcode);
 404 }
 405
 406 const char *CLibCEC::ToString(const cec_system_audio_status mode)
 407 {
 408   return CCECTypeUtils::ToString(mode);
 409 }
 410
 411 const char *CLibCEC::ToString(const cec_audio_status status)
 412 {
 413   return CCECTypeUtils::ToString(status);
 414 }
 415
 416 const char *CLibCEC::ToString(const cec_vendor_id vendor)
 417 {
 418   return CCECTypeUtils::ToString(vendor);
 419 }
 420
 421 const char *CLibCEC::ToString(const cec_client_version version)
 422 {
 423   return CCECTypeUtils::ToString(version);
 424 }
 425
 426 const char *CLibCEC::ToString(const cec_server_version version)
 427 {
 428   return CCECTypeUtils::ToString(version);
 429 }
 430
 431 void CLibCEC::CheckKeypressTimeout(void)
 432 {
 433   // check all clients
 434   for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
 435     (*it)->CheckKeypressTimeout();
 436 }
 437
 438 void CLibCEC::AddLog(const cec_log_level level, const char *strFormat, ...)
 439 {
 440   CStdString strLog;
 441
 442   // format the message
 443   va_list argList;
 444   va_start(argList, strFormat);
 445   strLog.FormatV(strFormat, argList);
 446   va_end(argList);
 447
 448   cec_log_message message;
 449   message.level = level;
 450   message.time = GetTimeMs() - m_iStartTime;
 451   snprintf(message.message, sizeof(message.message), "%s", strLog.c_str());
 452
 453   // send the message to all clients
 454   for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
 455     (*it)->AddLog(message);
 456 }
 457
 458 void CLibCEC::AddCommand(const cec_command &command)
 459 {
 460   // send the command to all clients
 461   for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
 462     (*it)->AddCommand(command);
 463 }
 464
 465 void CLibCEC::Alert(const libcec_alert type, const libcec_parameter &param)
 466 {
 467   // send the alert to all clients
 468   for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
 469     (*it)->Alert(type, param);
 470 }
 471
 472 CCECClient *CLibCEC::RegisterClient(libcec_configuration &configuration)
 473 {
 474   if (!m_cec)
 475     return NULL;
 476
 477   // create a new client instance
 478   CCECClient *newClient = new CCECClient(m_cec, configuration);
 479   if (!newClient)
 480     return NULL;
 481   m_clients.push_back(newClient);
 482
 483   // if the default client isn't set, set it
 484   if (!m_client)
 485     m_client = newClient;
 486
 487   // register the new client
 488   if (m_cec->CECInitialised())
 489     m_cec->RegisterClient(newClient);
 490
 491   return newClient;
 492 }
 493
 494 void CLibCEC::UnregisterClients(void)
 495 {
 496   if (m_cec)
 497     m_cec->UnregisterClients();
 498
 499   m_clients.clear();
 500
 501   DELETE_AND_NULL(m_client);
 502 }
 503
 504 void * CECInitialise(libcec_configuration *configuration)
 505 {
 506   if (!configuration)
 507     return NULL;
 508
 509   // create a new libCEC instance
 510   CLibCEC *lib = new CLibCEC(NULL);
 511
 512   // register a new client
 513   CCECClient *client(NULL);
 514   if (lib && configuration)
 515     client = lib->RegisterClient(*configuration);
 516
 517   // update the current configuration
 518   if (client)
 519     client->GetCurrentConfiguration(*configuration);
 520
 521   // ensure that the correct server version is set
 522   configuration->serverVersion = LIBCEC_VERSION_CURRENT;
 523
 524   return static_cast< void* > (lib);
 525 }
 526
 527 void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types)
 528 {
 529   libcec_configuration configuration; configuration.Clear();
 530
 531   // client version < 1.5.0
 532   snprintf(configuration.strDeviceName, 13, "%s", strDeviceName);
 533   configuration.deviceTypes      = types;
 534   configuration.iPhysicalAddress = CEC_INVALID_PHYSICAL_ADDRESS;
 535
 536   if (configuration.deviceTypes.IsEmpty())
 537     configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
 538
 539   return CECInitialise(&configuration);
 540 }
 541
 542 bool CECStartBootloader(void)
 543 {
 544   bool bReturn(false);
 545   cec_adapter deviceList[1];
 546   if (CAdapterFactory(NULL).FindAdapters(deviceList, 1, 0) > 0)
 547   {
 548     CAdapterFactory factory(NULL);
 549     IAdapterCommunication *comm = factory.GetInstance(deviceList[0].comm);
 550     if (comm)
 551     {
 552       CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT);
 553       while (timeout.TimeLeft() > 0 &&
 554           (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false)
 555       {
 556         comm->Close();
 557         CEvent::Sleep(500);
 558       }
 559       if (comm->IsOpen())
 560         bReturn = comm->StartBootloader();
 561
 562       delete comm;
 563     }
 564   }
 565
 566   return bReturn;
 567 }
 568
 569 void CECDestroy(CEC::ICECAdapter *instance)
 570 {
 571   DELETE_AND_NULL(instance);
 572 }
 573
 574 bool CLibCEC::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
 575 {
 576   if (m_cec->IsRunning())
 577     return false;
 578
 579   return m_cec->GetDeviceInformation(strPort, config, iTimeoutMs);
 580 }
 581
 582 const char *CLibCEC::GetLibInfo(void)
 583 {
 584 #ifndef LIB_INFO
 585 #ifdef _WIN32
 586 #define FEATURES "'P8 USB' 'P8 USB detect'"
 587 #ifdef _WIN64
 588 #define HOST_TYPE "Windows (x64)"
 589 #else
 590 #define HOST_TYPE "Windows (x86)"
 591 #endif
 592 #else
 593 #define HOST_TYPE "unknown"
 594 #define FEATURES "unknown"
 595 #endif
 596
 597   return "host: " HOST_TYPE ", features: " FEATURES ", compiled: " __DATE__;
 598 #else
 599   return LIB_INFO;
 600 #endif
 601 }
 602
 603 const char *CLibCEC::ToString(const cec_user_control_code key)
 604 {
 605   return CCECTypeUtils::ToString(key);
 606 }
 607
 608 void CLibCEC::InitVideoStandalone(void)
 609 {
 610   CAdapterFactory::InitVideoStandalone();
 611 }
 612
 613 const char *CLibCEC::ToString(const cec_adapter_type type)
 614 {
 615   return CCECTypeUtils::ToString(type);
 616 }