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