src/lib/CECClient.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2013 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 "CECClient.h"
  35
  36 #include "CECProcessor.h"
  37 #include "LibCEC.h"
  38 #include "CECTypeUtils.h"
  39 #include "devices/CECPlaybackDevice.h"
  40 #include "devices/CECAudioSystem.h"
  41 #include "devices/CECTV.h"
  42 #include "implementations/CECCommandHandler.h"
  43
  44 using namespace CEC;
  45 using namespace PLATFORM;
  46
  47 #define LIB_CEC     m_processor->GetLib()
  48 #define ToString(x) CCECTypeUtils::ToString(x)
  49
  50 CCECClient::CCECClient(CCECProcessor *processor, const libcec_configuration &configuration) :
  51     m_processor(processor),
  52     m_bInitialised(false),
  53     m_bRegistered(false),
  54     m_iCurrentButton(CEC_USER_CONTROL_CODE_UNKNOWN),
  55     m_buttontime(0),
  56     m_iPreventForwardingPowerOffCommand(0),
  57     m_iLastKeypressTime(0)
  58 {
  59   m_lastKeypress.keycode = CEC_USER_CONTROL_CODE_UNKNOWN;
  60   m_lastKeypress.duration = 0;
  61   m_configuration.Clear();
  62   // set the initial configuration
  63   SetConfiguration(configuration);
  64 }
  65
  66 CCECClient::~CCECClient(void)
  67 {
  68   // unregister the client
  69   if (m_processor && IsRegistered())
  70     m_processor->UnregisterClient(this);
  71 }
  72
  73 bool CCECClient::IsInitialised(void)
  74 {
  75   CLockObject lock(m_mutex);
  76   return m_bInitialised && m_processor;
  77 }
  78
  79 void CCECClient::SetInitialised(bool bSetTo)
  80 {
  81   CLockObject lock(m_mutex);
  82   m_bInitialised = bSetTo;
  83 }
  84
  85 bool CCECClient::IsRegistered(void)
  86 {
  87   CLockObject lock(m_mutex);
  88   return m_bRegistered && m_processor;
  89 }
  90
  91 void CCECClient::SetRegistered(bool bSetTo)
  92 {
  93   CLockObject lock(m_mutex);
  94   m_bRegistered = bSetTo;
  95 }
  96
  97 bool CCECClient::OnRegister(void)
  98 {
  99   // return false if already initialised
 100   if (IsInitialised())
 101     return true;
 102
 103   // get all device we control
 104   CECDEVICEVEC devices;
 105   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 106
 107   // return false when no devices were found
 108   if (devices.empty())
 109   {
 110     LIB_CEC->AddLog(CEC_LOG_WARNING, "cannot find the primary device (logical address %x)", GetPrimaryLogicalAdddress());
 111     return false;
 112   }
 113
 114   // mark as initialised
 115   SetInitialised(true);
 116
 117   // configure all devices
 118   for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
 119   {
 120     // only set our OSD name for the primary device
 121     if ((*it)->GetLogicalAddress() == GetPrimaryLogicalAdddress())
 122       (*it)->SetOSDName(m_configuration.strDeviceName);
 123
 124     // set the default menu language for devices we control
 125     (*it)->SetMenuLanguage(m_configuration.strDeviceLanguage);
 126   }
 127
 128   // set the physical address
 129   SetPhysicalAddress(m_configuration);
 130
 131   // make the primary device the active source if the option is set
 132   if (m_configuration.bActivateSource == 1)
 133     GetPrimaryDevice()->ActivateSource(500);
 134
 135   return true;
 136 }
 137
 138 bool CCECClient::SetHDMIPort(const cec_logical_address iBaseDevice, const uint8_t iPort, bool bForce /* = false */)
 139 {
 140   bool bReturn(false);
 141
 142   // limit the HDMI port range to 1-15
 143   if (iPort < CEC_MIN_HDMI_PORTNUMBER ||
 144       iPort > CEC_MAX_HDMI_PORTNUMBER)
 145     return bReturn;
 146
 147   LIB_CEC->AddLog(CEC_LOG_NOTICE, "setting HDMI port to %d on device %s (%d)", iPort, ToString(iBaseDevice), (int)iBaseDevice);
 148
 149   // update the configuration
 150   {
 151     CLockObject lock(m_mutex);
 152     m_configuration.baseDevice = iBaseDevice;
 153     m_configuration.iHDMIPort  = iPort;
 154   }
 155
 156   // don't continue if the connection isn't opened
 157   if (!m_processor->CECInitialised() && !bForce)
 158     return true;
 159
 160   // get the PA of the base device
 161   uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
 162   CCECBusDevice *baseDevice = m_processor->GetDevice(iBaseDevice);
 163   if (baseDevice)
 164     iPhysicalAddress = baseDevice->GetPhysicalAddress(GetPrimaryLogicalAdddress());
 165
 166   // add our port number
 167   if (iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS)
 168   {
 169     if (iPhysicalAddress == 0)
 170       iPhysicalAddress += 0x1000 * iPort;
 171     else if (iPhysicalAddress % 0x1000 == 0)
 172       iPhysicalAddress += 0x100 * iPort;
 173     else if (iPhysicalAddress % 0x100 == 0)
 174       iPhysicalAddress += 0x10 * iPort;
 175     else if (iPhysicalAddress % 0x10 == 0)
 176       iPhysicalAddress += iPort;
 177
 178     bReturn = true;
 179   }
 180
 181   // set the default address when something went wrong
 182   if (!bReturn)
 183   {
 184     uint16_t iEepromAddress = m_processor->GetPhysicalAddressFromEeprom();
 185     if (CLibCEC::IsValidPhysicalAddress(iEepromAddress))
 186     {
 187       LIB_CEC->AddLog(CEC_LOG_WARNING, "failed to set the physical address to %04X, setting it to the value that was persisted in the eeprom, %04X", iPhysicalAddress, iEepromAddress);
 188       iPhysicalAddress = iEepromAddress;
 189       bReturn = true;
 190     }
 191     else
 192     {
 193       LIB_CEC->AddLog(CEC_LOG_WARNING, "failed to set the physical address to %04X, setting it to the default value %04X", iPhysicalAddress, CEC_DEFAULT_PHYSICAL_ADDRESS);
 194       iPhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
 195     }
 196   }
 197
 198   // and set the address
 199   SetDevicePhysicalAddress(iPhysicalAddress);
 200
 201   CallbackConfigurationChanged(m_configuration);
 202
 203   return bReturn;
 204 }
 205
 206 void CCECClient::ResetPhysicalAddress(void)
 207 {
 208   SetPhysicalAddress(CEC_DEFAULT_PHYSICAL_ADDRESS);
 209 }
 210
 211 void CCECClient::SetPhysicalAddress(const libcec_configuration &configuration)
 212 {
 213   bool bPASet(false);
 214
 215   // override the physical address from configuration.iPhysicalAddress if it's set
 216   if (!bPASet && CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
 217     bPASet = SetPhysicalAddress(configuration.iPhysicalAddress);
 218
 219   // try to autodetect the address
 220   if (!bPASet && m_processor->CECInitialised())
 221   {
 222     bPASet = AutodetectPhysicalAddress();
 223     m_configuration.bAutodetectAddress = bPASet ? 1 : 0;
 224   }
 225
 226   // use the base device + hdmi port settings
 227   if (!bPASet)
 228     bPASet = SetHDMIPort(configuration.baseDevice, configuration.iHDMIPort);
 229
 230   // reset to defaults if something went wrong
 231   if (!bPASet)
 232   {
 233     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
 234     m_configuration.baseDevice = CECDEVICE_UNKNOWN;
 235     m_configuration.iHDMIPort  = CEC_HDMI_PORTNUMBER_NONE;
 236   }
 237 }
 238
 239 bool CCECClient::SetPhysicalAddress(const uint16_t iPhysicalAddress)
 240 {
 241   // update the configuration
 242   bool bChanged(true);
 243   {
 244     CLockObject lock(m_mutex);
 245     if (m_configuration.iPhysicalAddress == iPhysicalAddress)
 246       bChanged = false;
 247     else
 248       m_configuration.iPhysicalAddress = iPhysicalAddress;
 249   }
 250   if (!bChanged)
 251   {
 252     LIB_CEC->AddLog(CEC_LOG_DEBUG, "physical address unchanged (%04X)", iPhysicalAddress);
 253     return true;
 254   }
 255
 256   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting physical address to '%04X'", iPhysicalAddress);
 257
 258   // set the physical address for each device
 259   SetDevicePhysicalAddress(iPhysicalAddress);
 260
 261   // and send back the updated configuration
 262   CallbackConfigurationChanged(m_configuration);
 263
 264   return true;
 265 }
 266
 267 void CCECClient::SetSupportedDeviceTypes(void)
 268 {
 269   cec_device_type_list types;
 270   types.Clear();
 271
 272   // get the command handler for the tv
 273   CCECCommandHandler *tvHandler = m_processor->GetTV()->GetHandler();
 274   if (!tvHandler)
 275     return;
 276
 277   // check all device types
 278   for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
 279   {
 280     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
 281       continue;
 282
 283     // get the supported device type. the handler will replace types it doesn't support by one it does support
 284     cec_device_type type = tvHandler->GetReplacementDeviceType(m_configuration.deviceTypes.types[iPtr]);
 285     if (!types.IsSet(type))
 286       types.Add(type);
 287   }
 288   m_processor->GetTV()->MarkHandlerReady();
 289
 290   // set the new type list
 291   m_configuration.deviceTypes = types;
 292
 293   // persist the new configuration
 294   PersistConfiguration(m_configuration);
 295 }
 296
 297 bool CCECClient::AllocateLogicalAddresses(void)
 298 {
 299   // reset all previous LAs that were set
 300   m_configuration.logicalAddresses.Clear();
 301
 302   // get the supported device types from the command handler of the TV
 303   SetSupportedDeviceTypes();
 304
 305   // display an error if no device types are set
 306   if (m_configuration.deviceTypes.IsEmpty())
 307   {
 308     LIB_CEC->AddLog(CEC_LOG_ERROR, "no device types given");
 309     return false;
 310   }
 311
 312   // check each entry of the list
 313   for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
 314   {
 315     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
 316       continue;
 317
 318     // find an LA for this type
 319     cec_logical_address address(CECDEVICE_UNKNOWN);
 320     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
 321       address = AllocateLogicalAddressRecordingDevice();
 322     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
 323       address = AllocateLogicalAddressTuner();
 324     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
 325       address = AllocateLogicalAddressPlaybackDevice();
 326     if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 327       address = AllocateLogicalAddressAudioSystem();
 328
 329     // display an error if no LA could be allocated
 330     if (address == CECDEVICE_UNKNOWN)
 331     {
 332       LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - failed to allocate device '%d', type '%s'", __FUNCTION__, iPtr, ToString(m_configuration.deviceTypes.types[iPtr]));
 333       return false;
 334     }
 335
 336     // display the registered LA
 337     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - device '%d', type '%s', LA '%X'", __FUNCTION__, iPtr, ToString(m_configuration.deviceTypes.types[iPtr]), address);
 338     m_configuration.logicalAddresses.Set(address);
 339   }
 340
 341   // persist the new configuration
 342   PersistConfiguration(m_configuration);
 343
 344   return true;
 345 }
 346
 347 cec_logical_address CCECClient::AllocateLogicalAddressRecordingDevice(void)
 348 {
 349   cec_logical_address retVal(CECDEVICE_UNKNOWN);
 350
 351   LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
 352   if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1, m_configuration.cecVersion))
 353     retVal = CECDEVICE_RECORDINGDEVICE1;
 354   else if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2, m_configuration.cecVersion))
 355     retVal = CECDEVICE_RECORDINGDEVICE2;
 356   else if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3, m_configuration.cecVersion))
 357     retVal = CECDEVICE_RECORDINGDEVICE3;
 358
 359   return retVal;
 360 }
 361
 362 cec_logical_address CCECClient::AllocateLogicalAddressTuner(void)
 363 {
 364   cec_logical_address retVal(CECDEVICE_UNKNOWN);
 365
 366   LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
 367   if (m_processor->TryLogicalAddress(CECDEVICE_TUNER1, m_configuration.cecVersion))
 368     retVal = CECDEVICE_TUNER1;
 369   else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER2, m_configuration.cecVersion))
 370     retVal = CECDEVICE_TUNER2;
 371   else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER3, m_configuration.cecVersion))
 372     retVal = CECDEVICE_TUNER3;
 373   else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER4, m_configuration.cecVersion))
 374     retVal = CECDEVICE_TUNER4;
 375
 376   return retVal;
 377 }
 378
 379 cec_logical_address CCECClient::AllocateLogicalAddressPlaybackDevice(void)
 380 {
 381   cec_logical_address retVal(CECDEVICE_UNKNOWN);
 382
 383   LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
 384   if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1, m_configuration.cecVersion))
 385     retVal = CECDEVICE_PLAYBACKDEVICE1;
 386   else if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2, m_configuration.cecVersion))
 387     retVal = CECDEVICE_PLAYBACKDEVICE2;
 388   else if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3, m_configuration.cecVersion))
 389     retVal = CECDEVICE_PLAYBACKDEVICE3;
 390
 391   return retVal;
 392 }
 393
 394 cec_logical_address CCECClient::AllocateLogicalAddressAudioSystem(void)
 395 {
 396   cec_logical_address retVal(CECDEVICE_UNKNOWN);
 397
 398   LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audiosystem'");
 399   if (m_processor->TryLogicalAddress(CECDEVICE_AUDIOSYSTEM, m_configuration.cecVersion))
 400     retVal = CECDEVICE_AUDIOSYSTEM;
 401
 402   return retVal;
 403 }
 404
 405 CCECBusDevice *CCECClient::GetDeviceByType(const cec_device_type type) const
 406 {
 407   // get all devices that match our logical addresses
 408   CECDEVICEVEC devices;
 409   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 410
 411   // filter the type we need
 412   CCECDeviceMap::FilterType(type, devices);
 413
 414   return devices.empty() ?
 415       NULL :
 416       *devices.begin();
 417 }
 418
 419 bool CCECClient::ChangeDeviceType(const cec_device_type from, const cec_device_type to)
 420 {
 421   if (from == to)
 422     return true;
 423
 424   LIB_CEC->AddLog(CEC_LOG_NOTICE, "changing device type '%s' into '%s'", ToString(from), ToString(to));
 425
 426   {
 427     CLockObject lock(m_mutex);
 428
 429     // get the previous device that was allocated
 430     CCECBusDevice *previousDevice = GetDeviceByType(from);
 431     if (!previousDevice)
 432       return false;
 433
 434     // change the type in the device type list
 435     bool bChanged(false);
 436     for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
 437     {
 438       if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
 439         continue;
 440
 441       if (m_configuration.deviceTypes.types[iPtr] == from)
 442       {
 443         bChanged = true;
 444         m_configuration.deviceTypes.types[iPtr] = to;
 445       }
 446       else if (m_configuration.deviceTypes.types[iPtr] == to && bChanged)
 447       {
 448         // ensure that dupes are removed
 449         m_configuration.deviceTypes.types[iPtr] = CEC_DEVICE_TYPE_RESERVED;
 450       }
 451     }
 452   }
 453
 454   // re-register the client to set the new ackmask
 455   if (!m_processor->RegisterClient(this))
 456     return false;
 457
 458   // persist the new configuration
 459   PersistConfiguration(m_configuration);
 460
 461   return true;
 462 }
 463
 464 bool CCECClient::SetLogicalAddress(const cec_logical_address iLogicalAddress)
 465 {
 466   bool bReturn(true);
 467
 468   if (GetPrimaryLogicalAdddress() != iLogicalAddress)
 469   {
 470     LIB_CEC->AddLog(CEC_LOG_NOTICE, "setting primary logical address to %1x", iLogicalAddress);
 471     {
 472       CLockObject lock(m_mutex);
 473       m_configuration.logicalAddresses.primary = iLogicalAddress;
 474       m_configuration.logicalAddresses.Set(iLogicalAddress);
 475     }
 476
 477     bReturn = m_processor->RegisterClient(this);
 478
 479     // persist the new configuration
 480     if (bReturn)
 481       PersistConfiguration(m_configuration);
 482   }
 483
 484   return bReturn;
 485 }
 486
 487 bool CCECClient::Transmit(const cec_command &data, bool bIsReply)
 488 {
 489   return m_processor ? m_processor->Transmit(data, bIsReply) : false;
 490 }
 491
 492 bool CCECClient::SendPowerOnDevices(const cec_logical_address address /* = CECDEVICE_TV */)
 493 {
 494   // if the broadcast address if set as destination, read the wakeDevices setting
 495   if (address == CECDEVICE_BROADCAST)
 496   {
 497     CECDEVICEVEC devices;
 498     m_processor->GetDevices()->GetWakeDevices(m_configuration, devices);
 499     return m_processor->PowerOnDevices(GetPrimaryLogicalAdddress(), devices);
 500   }
 501
 502   return m_processor->PowerOnDevice(GetPrimaryLogicalAdddress(), address);
 503 }
 504
 505 bool CCECClient::SendStandbyDevices(const cec_logical_address address /* = CECDEVICE_BROADCAST */)
 506 {
 507   // if the broadcast address if set as destination, read the standbyDevices setting
 508   if (address == CECDEVICE_BROADCAST)
 509   {
 510     CECDEVICEVEC devices;
 511     m_processor->GetDevices()->GetPowerOffDevices(m_configuration, devices);
 512     return m_processor->StandbyDevices(GetPrimaryLogicalAdddress(), devices);
 513   }
 514
 515   return m_processor->StandbyDevice(GetPrimaryLogicalAdddress(), address);
 516 }
 517
 518 bool CCECClient::SendSetActiveSource(const cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
 519 {
 520   // get the devices that are controlled by us
 521   CECDEVICEVEC devices;
 522   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 523
 524   // filter out the device that matches the given type
 525   if (type != CEC_DEVICE_TYPE_RESERVED)
 526     CCECDeviceMap::FilterType(type, devices);
 527
 528   // no devices left, re-fetch the list of devices that are controlled by us
 529   if (devices.empty())
 530     m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 531
 532   if (!devices.empty())
 533   {
 534     // get the first device from the list
 535     CCECBusDevice *device = *devices.begin();
 536
 537     // and activate it
 538     if (!m_processor->CECInitialised())
 539       device->MarkAsActiveSource();
 540     else if (device->HasValidPhysicalAddress())
 541       return device->ActivateSource();
 542   }
 543
 544   return false;
 545 }
 546
 547 CCECPlaybackDevice *CCECClient::GetPlaybackDevice(void)
 548 {
 549   CCECPlaybackDevice *device(NULL);
 550   CECDEVICEVEC devices;
 551
 552   // get the playback devices
 553   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 554   CCECDeviceMap::FilterType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE, devices);
 555
 556   // no matches, get the recording devices
 557   if (devices.empty())
 558   {
 559     m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 560     CCECDeviceMap::FilterType(CEC_DEVICE_TYPE_RECORDING_DEVICE, devices);
 561   }
 562
 563   // get the first device that matches, and cast it to CCECPlaybackDevice
 564   if (!devices.empty())
 565     device = (*devices.begin())->AsPlaybackDevice();
 566
 567   return device;
 568 }
 569
 570 cec_logical_address CCECClient::GetPrimaryLogicalAdddress(void)
 571 {
 572   CLockObject lock(m_mutex);
 573   return m_configuration.logicalAddresses.primary;
 574 }
 575
 576 CCECBusDevice *CCECClient::GetPrimaryDevice(void)
 577 {
 578   return m_processor->GetDevice(GetPrimaryLogicalAdddress());
 579 }
 580
 581 bool CCECClient::SendSetDeckControlMode(const cec_deck_control_mode mode, bool bSendUpdate /* = true */)
 582 {
 583   // find a playback device that we control
 584   CCECPlaybackDevice *device = GetPlaybackDevice();
 585   if (device)
 586   {
 587     // and set the deck control mode if there is a match
 588     device->SetDeckControlMode(mode);
 589     if (bSendUpdate)
 590       return device->TransmitDeckStatus(CECDEVICE_TV, false);
 591     return true;
 592   }
 593
 594   // no match
 595   return false;
 596 }
 597
 598 bool CCECClient::SendSetDeckInfo(const cec_deck_info info, bool bSendUpdate /* = true */)
 599 {
 600   // find a playback device that we control
 601   CCECPlaybackDevice *device = GetPlaybackDevice();
 602   if (device)
 603   {
 604     // and set the deck status if there is a match
 605     device->SetDeckStatus(info);
 606     if (bSendUpdate)
 607       return device->AsPlaybackDevice()->TransmitDeckStatus(CECDEVICE_TV, false);
 608     return true;
 609   }
 610
 611   // no match
 612   return false;
 613 }
 614
 615 bool CCECClient::SendSetMenuState(const cec_menu_state state, bool bSendUpdate /* = true */)
 616 {
 617   CECDEVICEVEC devices;
 618
 619   // set the menu state for all devices that are controlled by us
 620   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 621   for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
 622   {
 623     (*it)->SetMenuState(state);
 624     if (bSendUpdate)
 625       (*it)->TransmitMenuState(CECDEVICE_TV, false);
 626   }
 627
 628   return true;
 629 }
 630
 631 bool CCECClient::SendSetInactiveView(void)
 632 {
 633   CECDEVICEVEC devices;
 634
 635   // mark all devices that are controlled by us as inactive source
 636   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
 637   for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
 638   {
 639     if ((*it)->IsActiveSource())
 640     {
 641       (*it)->MarkAsInactiveSource();
 642       return (*it)->TransmitInactiveSource();
 643     }
 644   }
 645
 646   return true;
 647 }
 648
 649 bool CCECClient::SendSetOSDString(const cec_logical_address iLogicalAddress, const cec_display_control duration, const char *strMessage)
 650 {
 651   CCECBusDevice *primary = GetPrimaryDevice();
 652   if (primary)
 653     return primary->TransmitOSDString(iLogicalAddress, duration, strMessage, false);
 654
 655   return false;
 656 }
 657
 658 cec_version CCECClient::GetDeviceCecVersion(const cec_logical_address iAddress)
 659 {
 660   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 661   if (device)
 662     return device->GetCecVersion(GetPrimaryLogicalAdddress());
 663   return CEC_VERSION_UNKNOWN;
 664 }
 665
 666 bool CCECClient::GetDeviceMenuLanguage(const cec_logical_address iAddress, cec_menu_language &language)
 667 {
 668   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 669   if (device)
 670   {
 671     language = device->GetMenuLanguage(GetPrimaryLogicalAdddress());
 672     return (strcmp(language.language, "???") != 0);
 673   }
 674   return false;
 675 }
 676
 677 cec_osd_name CCECClient::GetDeviceOSDName(const cec_logical_address iAddress)
 678 {
 679   cec_osd_name retVal;
 680   retVal.device = iAddress;
 681   retVal.name[0] = 0;
 682
 683   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 684   if (device)
 685   {
 686     CStdString strOSDName = device->GetOSDName(GetPrimaryLogicalAdddress());
 687     snprintf(retVal.name, sizeof(retVal.name), "%s", strOSDName.c_str());
 688     retVal.device = iAddress;
 689   }
 690
 691   return retVal;
 692 }
 693
 694 uint16_t CCECClient::GetDevicePhysicalAddress(const cec_logical_address iAddress)
 695 {
 696   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 697   if (device)
 698     return device->GetPhysicalAddress(GetPrimaryLogicalAdddress());
 699   return CEC_INVALID_PHYSICAL_ADDRESS;
 700 }
 701
 702 cec_power_status CCECClient::GetDevicePowerStatus(const cec_logical_address iAddress)
 703 {
 704   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 705   if (device)
 706     return device->GetPowerStatus(GetPrimaryLogicalAdddress());
 707   return CEC_POWER_STATUS_UNKNOWN;
 708 }
 709
 710 uint64_t CCECClient::GetDeviceVendorId(const cec_logical_address iAddress)
 711 {
 712   CCECBusDevice *device = m_processor->GetDevice(iAddress);
 713   if (device)
 714     return device->GetVendorId(GetPrimaryLogicalAdddress());
 715   return CEC_VENDOR_UNKNOWN;
 716 }
 717
 718 uint8_t CCECClient::SendVolumeUp(bool bSendRelease /* = true */)
 719 {
 720   CCECBusDevice *device = GetPrimaryDevice();
 721   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 722
 723   return device && audio && audio->IsPresent() ?
 724       audio->VolumeUp(device->GetLogicalAddress(), bSendRelease) :
 725       (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 726 }
 727
 728 uint8_t CCECClient::SendVolumeDown(bool bSendRelease /* = true */)
 729 {
 730   CCECBusDevice *device = GetPrimaryDevice();
 731   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 732
 733   return device && audio && audio->IsPresent() ?
 734       audio->VolumeDown(device->GetLogicalAddress(), bSendRelease) :
 735       (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 736 }
 737
 738 uint8_t CCECClient::SendMuteAudio(void)
 739 {
 740   CCECBusDevice *device = GetPrimaryDevice();
 741   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 742
 743   return device && audio && audio->IsPresent() ?
 744       audio->MuteAudio(device->GetLogicalAddress()) :
 745       (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 746 }
 747
 748 uint8_t CCECClient::AudioToggleMute(void)
 749 {
 750   CCECBusDevice *device = GetPrimaryDevice();
 751   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 752
 753   return device && audio && audio->IsPresent() ?
 754       audio->MuteAudio(device->GetLogicalAddress()) :
 755       (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 756 }
 757
 758 uint8_t CCECClient::AudioMute(void)
 759 {
 760   CCECBusDevice *device = GetPrimaryDevice();
 761   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 762   uint8_t iStatus = device && audio && audio->IsPresent() ? audio->GetAudioStatus(device->GetLogicalAddress()) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 763   if ((iStatus & CEC_AUDIO_MUTE_STATUS_MASK) != CEC_AUDIO_MUTE_STATUS_MASK)
 764     iStatus = audio->MuteAudio(device->GetLogicalAddress());
 765
 766   return iStatus;
 767 }
 768
 769 uint8_t CCECClient::AudioUnmute(void)
 770 {
 771   CCECBusDevice *device = GetPrimaryDevice();
 772   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 773   uint8_t iStatus = device && audio && audio->IsPresent() ? audio->GetAudioStatus(device->GetLogicalAddress()) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 774   if ((iStatus & CEC_AUDIO_MUTE_STATUS_MASK) == CEC_AUDIO_MUTE_STATUS_MASK)
 775     iStatus = audio->MuteAudio(device->GetLogicalAddress());
 776
 777   return iStatus;
 778 }
 779
 780 uint8_t CCECClient::AudioStatus(void)
 781 {
 782   CCECBusDevice *device = GetPrimaryDevice();
 783   CCECAudioSystem *audio = m_processor->GetAudioSystem();
 784   return device && audio && audio->IsPresent() ? audio->GetAudioStatus(device->GetLogicalAddress()) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
 785 }
 786
 787 bool CCECClient::SendKeypress(const cec_logical_address iDestination, const cec_user_control_code key, bool bWait /* = true */)
 788 {
 789   CCECBusDevice *dest = m_processor->GetDevice(iDestination);
 790
 791   return dest ?
 792       dest->TransmitKeypress(GetPrimaryLogicalAdddress(), key, bWait) :
 793       false;
 794 }
 795
 796 bool CCECClient::SendKeyRelease(const cec_logical_address iDestination, bool bWait /* = true */)
 797 {
 798   CCECBusDevice *dest = m_processor->GetDevice(iDestination);
 799
 800   return dest ?
 801       dest->TransmitKeyRelease(GetPrimaryLogicalAdddress(), bWait) :
 802       false;
 803 }
 804
 805 bool CCECClient::GetCurrentConfiguration(libcec_configuration &configuration)
 806 {
 807   CLockObject lock(m_mutex);
 808
 809   // client version 1.5.0
 810   snprintf(configuration.strDeviceName, 13, "%s", m_configuration.strDeviceName);
 811   configuration.deviceTypes               = m_configuration.deviceTypes;
 812   configuration.bAutodetectAddress        = m_configuration.bAutodetectAddress;
 813   configuration.iPhysicalAddress          = m_configuration.iPhysicalAddress;
 814   configuration.baseDevice                = m_configuration.baseDevice;
 815   configuration.iHDMIPort                 = m_configuration.iHDMIPort;
 816   configuration.clientVersion             = m_configuration.clientVersion;
 817   configuration.serverVersion             = m_configuration.serverVersion;
 818   configuration.tvVendor                  = m_configuration.tvVendor;
 819   configuration.bGetSettingsFromROM       = m_configuration.bGetSettingsFromROM;
 820   configuration.bUseTVMenuLanguage        = m_configuration.bUseTVMenuLanguage;
 821   configuration.bActivateSource           = m_configuration.bActivateSource;
 822   configuration.wakeDevices               = m_configuration.wakeDevices;
 823   configuration.powerOffDevices           = m_configuration.powerOffDevices;
 824   configuration.bPowerOffScreensaver      = m_configuration.bPowerOffScreensaver;
 825   configuration.bPowerOnScreensaver       = m_configuration.bPowerOnScreensaver;
 826   configuration.bPowerOffOnStandby        = m_configuration.bPowerOffOnStandby;
 827   configuration.bSendInactiveSource       = m_configuration.bSendInactiveSource;
 828   configuration.logicalAddresses          = m_configuration.logicalAddresses;
 829   configuration.iFirmwareVersion          = m_configuration.iFirmwareVersion;
 830   configuration.bPowerOffDevicesOnStandby = m_configuration.bPowerOffDevicesOnStandby;
 831   configuration.bShutdownOnStandby        = m_configuration.bShutdownOnStandby;
 832   memcpy(configuration.strDeviceLanguage,  m_configuration.strDeviceLanguage, 3);
 833   configuration.iFirmwareBuildDate        = m_configuration.iFirmwareBuildDate;
 834   configuration.bMonitorOnly              = m_configuration.bMonitorOnly;
 835   configuration.cecVersion                = m_configuration.cecVersion;
 836   configuration.adapterType               = m_configuration.adapterType;
 837
 838   return true;
 839 }
 840
 841 bool CCECClient::SetConfiguration(const libcec_configuration &configuration)
 842 {
 843   libcec_configuration defaultSettings;
 844   bool bIsRunning(m_processor && m_processor->CECInitialised());
 845   CCECBusDevice *primary = bIsRunning ? GetPrimaryDevice() : NULL;
 846   uint16_t iPA = primary ? primary->GetCurrentPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
 847
 848   // update the callbacks
 849   if (configuration.callbacks)
 850     EnableCallbacks(configuration.callbackParam, configuration.callbacks);
 851
 852   // update the client version
 853   SetClientVersion((cec_client_version)configuration.clientVersion);
 854
 855   // update the OSD name
 856   CStdString strOSDName(configuration.strDeviceName);
 857   SetOSDName(strOSDName);
 858
 859   // update the TV vendor override
 860   SetTVVendorOverride((cec_vendor_id)configuration.tvVendor);
 861
 862   // just copy these
 863   {
 864     CLockObject lock(m_mutex);
 865     m_configuration.bUseTVMenuLanguage         = configuration.bUseTVMenuLanguage;
 866     m_configuration.bActivateSource            = configuration.bActivateSource;
 867     m_configuration.bGetSettingsFromROM        = configuration.bGetSettingsFromROM;
 868     m_configuration.wakeDevices                = configuration.wakeDevices;
 869     m_configuration.powerOffDevices            = configuration.powerOffDevices;
 870     m_configuration.bPowerOffScreensaver       = configuration.bPowerOffScreensaver;
 871     m_configuration.bPowerOffOnStandby         = configuration.bPowerOffOnStandby;
 872     m_configuration.bSendInactiveSource        = configuration.bSendInactiveSource;
 873     m_configuration.bPowerOffDevicesOnStandby  = configuration.bPowerOffDevicesOnStandby;
 874     m_configuration.bShutdownOnStandby         = configuration.bShutdownOnStandby;
 875     memcpy(m_configuration.strDeviceLanguage,   configuration.strDeviceLanguage, 3);
 876     m_configuration.bMonitorOnly               = configuration.bMonitorOnly;
 877     m_configuration.cecVersion                 = configuration.cecVersion;
 878     m_configuration.adapterType                = configuration.adapterType;
 879     m_configuration.iDoubleTapTimeout50Ms      = configuration.iDoubleTapTimeout50Ms;
 880     m_configuration.deviceTypes.Add(configuration.deviceTypes[0]);
 881
 882     if (m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_0_5)
 883     {
 884       m_configuration.comboKey           = configuration.comboKey;
 885       m_configuration.iComboKeyTimeoutMs = configuration.iComboKeyTimeoutMs;
 886     }
 887     else
 888     {
 889       m_configuration.comboKey           = defaultSettings.comboKey;
 890       m_configuration.iComboKeyTimeoutMs = defaultSettings.iComboKeyTimeoutMs;
 891     }
 892
 893     if (m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_1_0)
 894       m_configuration.bPowerOnScreensaver = configuration.bPowerOnScreensaver;
 895     else
 896       m_configuration.bPowerOnScreensaver = defaultSettings.bPowerOnScreensaver;
 897   }
 898
 899   bool bNeedReinit(false);
 900
 901   // device types
 902   if (SetDeviceTypes(configuration.deviceTypes))
 903   {
 904     // the device type changed. just copy the rest, and re-register
 905     {
 906       CLockObject lock(m_mutex);
 907       m_configuration.iPhysicalAddress = configuration.iPhysicalAddress;
 908       m_configuration.baseDevice       = configuration.baseDevice;
 909       m_configuration.iHDMIPort        = configuration.iHDMIPort;
 910       bNeedReinit = true;
 911     }
 912   }
 913   else
 914   {
 915     // set the physical address
 916     SetPhysicalAddress(configuration);
 917   }
 918
 919   // persist the new configuration
 920   PersistConfiguration(m_configuration);
 921
 922   if (!primary)
 923     primary = GetPrimaryDevice();
 924
 925   if (bNeedReinit || !primary || primary->GetCurrentPhysicalAddress() != iPA)
 926   {
 927     // PA or device type changed
 928     m_processor->RegisterClient(this);
 929   }
 930   else if (primary && configuration.bActivateSource == 1 && bIsRunning && !primary->IsActiveSource())
 931   {
 932     // activate the source if we're not already the active source
 933     primary->ActivateSource();
 934   }
 935
 936   return true;
 937 }
 938
 939 void CCECClient::AddCommand(const cec_command &command)
 940 {
 941   // don't forward the standby opcode more than once every 10 seconds
 942   if (command.opcode == CEC_OPCODE_STANDBY)
 943   {
 944     CLockObject lock(m_mutex);
 945     if (m_iPreventForwardingPowerOffCommand != 0 &&
 946         m_iPreventForwardingPowerOffCommand > GetTimeMs())
 947       return;
 948     else
 949       m_iPreventForwardingPowerOffCommand = GetTimeMs() + CEC_FORWARD_STANDBY_MIN_INTERVAL;
 950   }
 951
 952   if (command.destination == CECDEVICE_BROADCAST || GetLogicalAddresses().IsSet(command.destination))
 953   {
 954     LIB_CEC->AddLog(CEC_LOG_DEBUG, ">> %s (%X) -> %s (%X): %s (%2X)", ToString(command.initiator), command.initiator, ToString(command.destination), command.destination, ToString(command.opcode), command.opcode);
 955     CallbackAddCommand(command);
 956   }
 957 }
 958
 959 int CCECClient::MenuStateChanged(const cec_menu_state newState)
 960 {
 961   LIB_CEC->AddLog(CEC_LOG_DEBUG, ">> %s: %s", ToString(CEC_OPCODE_MENU_REQUEST), ToString(newState));
 962   return CallbackMenuStateChanged(newState);
 963 }
 964
 965 void CCECClient::AddKey(bool bSendComboKey /* = false */)
 966 {
 967   cec_keypress key;
 968   key.keycode = CEC_USER_CONTROL_CODE_UNKNOWN;
 969
 970   {
 971     CLockObject lock(m_mutex);
 972     if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN)
 973     {
 974       key.duration = (unsigned int) (GetTimeMs() - m_buttontime);
 975
 976       if (key.duration > m_configuration.iComboKeyTimeoutMs ||
 977           m_configuration.iComboKeyTimeoutMs == 0 ||
 978           m_iCurrentButton != m_configuration.comboKey ||
 979           bSendComboKey)
 980       {
 981         key.keycode = m_iCurrentButton;
 982
 983         m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
 984         m_buttontime = 0;
 985       }
 986     }
 987   }
 988
 989   if (key.keycode != CEC_USER_CONTROL_CODE_UNKNOWN)
 990   {
 991     LIB_CEC->AddLog(CEC_LOG_DEBUG, "key released: %s (%1x)", ToString(key.keycode), key.keycode);
 992     CallbackAddKey(key);
 993   }
 994 }
 995
 996 void CCECClient::AddKey(const cec_keypress &key)
 997 {
 998   if (key.keycode > CEC_USER_CONTROL_CODE_MAX ||
 999       key.keycode < CEC_USER_CONTROL_CODE_SELECT)
1000   {
1001     // send back the previous key if there is one
1002     AddKey();
1003     return;
1004   }
1005
1006   cec_keypress transmitKey(key);
1007   cec_user_control_code comboKey(m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_0_5 ?
1008       m_configuration.comboKey : CEC_USER_CONTROL_CODE_STOP);
1009
1010   {
1011     CLockObject lock(m_mutex);
1012     if (m_configuration.iComboKeyTimeoutMs > 0 && m_iCurrentButton == comboKey && key.duration == 0)
1013     {
1014       // stop + ok -> exit
1015       if (key.keycode == CEC_USER_CONTROL_CODE_SELECT)
1016         transmitKey.keycode = CEC_USER_CONTROL_CODE_EXIT;
1017       // stop + pause -> root menu
1018       else if (key.keycode == CEC_USER_CONTROL_CODE_PAUSE)
1019         transmitKey.keycode = CEC_USER_CONTROL_CODE_ROOT_MENU;
1020       // stop + play -> dot (which is handled as context menu in xbmc)
1021       else if (key.keycode == CEC_USER_CONTROL_CODE_PLAY)
1022         transmitKey.keycode = CEC_USER_CONTROL_CODE_DOT;
1023       // default, send back the previous key
1024       else
1025         AddKey(true);
1026     }
1027
1028     if (m_iCurrentButton == key.keycode)
1029     {
1030       m_buttontime = GetTimeMs();
1031     }
1032     else
1033     {
1034       AddKey();
1035       if (key.duration == 0)
1036       {
1037         m_iCurrentButton = transmitKey.keycode;
1038         m_buttontime = m_iCurrentButton == CEC_USER_CONTROL_CODE_UNKNOWN || key.duration > 0 ? 0 : GetTimeMs();
1039       }
1040     }
1041   }
1042
1043   if (key.keycode != comboKey || key.duration > 0)
1044   {
1045     LIB_CEC->AddLog(CEC_LOG_DEBUG, "key pressed: %s (%1x)", ToString(transmitKey.keycode), transmitKey.keycode);
1046     CallbackAddKey(transmitKey);
1047   }
1048 }
1049
1050 void CCECClient::SetCurrentButton(const cec_user_control_code iButtonCode)
1051 {
1052   // push a keypress to the buffer with 0 duration and another with the duration set when released
1053   cec_keypress key;
1054   key.duration = 0;
1055   key.keycode = iButtonCode;
1056
1057   AddKey(key);
1058 }
1059
1060 void CCECClient::CheckKeypressTimeout(void)
1061 {
1062   cec_keypress key;
1063
1064   {
1065     CLockObject lock(m_mutex);
1066     uint64_t iNow = GetTimeMs();
1067     cec_user_control_code comboKey(m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_0_5 ?
1068         m_configuration.comboKey : CEC_USER_CONTROL_CODE_STOP);
1069     uint32_t iTimeoutMs(m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_0_5 ?
1070         m_configuration.iComboKeyTimeoutMs : CEC_DEFAULT_COMBO_TIMEOUT_MS);
1071
1072     if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN &&
1073           ((m_iCurrentButton == comboKey && iTimeoutMs > 0 && iNow - m_buttontime > iTimeoutMs) ||
1074           (m_iCurrentButton != comboKey && iNow - m_buttontime > CEC_BUTTON_TIMEOUT)))
1075     {
1076       key.duration = (unsigned int) (iNow - m_buttontime);
1077       key.keycode = m_iCurrentButton;
1078
1079       m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
1080       m_buttontime = 0;
1081     }
1082     else
1083     {
1084       return;
1085     }
1086   }
1087
1088   LIB_CEC->AddLog(CEC_LOG_DEBUG, "key auto-released: %s (%1x)", ToString(key.keycode), key.keycode);
1089   CallbackAddKey(key);
1090 }
1091
1092 bool CCECClient::EnableCallbacks(void *cbParam, ICECCallbacks *callbacks)
1093 {
1094   CLockObject lock(m_cbMutex);
1095   m_configuration.callbackParam = cbParam;
1096   m_configuration.callbacks     = callbacks;
1097   return true;
1098 }
1099
1100 bool CCECClient::PingAdapter(void)
1101 {
1102   return m_processor ? m_processor->PingAdapter() : false;
1103 }
1104
1105 std::string CCECClient::GetConnectionInfo(void)
1106 {
1107   CStdString strLog;
1108   strLog.Format("libCEC version = %s, client version = %s, firmware version = %d", ToString((cec_server_version)m_configuration.serverVersion), ToString((cec_client_version)m_configuration.clientVersion), m_configuration.iFirmwareVersion);
1109   if (m_configuration.iFirmwareBuildDate != CEC_FW_BUILD_UNKNOWN)
1110   {
1111     time_t buildTime = (time_t)m_configuration.iFirmwareBuildDate;
1112     strLog.AppendFormat(", firmware build date: %s", asctime(gmtime(&buildTime)));
1113     strLog = strLog.substr(0, strLog.length() > 0 ? (size_t)(strLog.length() - 1) : 0); // strip \n added by asctime
1114     strLog.append(" +0000");
1115   }
1116
1117   // log the addresses that are being used
1118   if (!m_configuration.logicalAddresses.IsEmpty())
1119   {
1120     strLog.append(", logical address(es) = ");
1121     CECDEVICEVEC devices;
1122     m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
1123     for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1124       strLog.AppendFormat("%s (%X) ", (*it)->GetLogicalAddressName(), (*it)->GetLogicalAddress());
1125   }
1126
1127   if (!CLibCEC::IsValidPhysicalAddress(m_configuration.iPhysicalAddress))
1128     strLog.AppendFormat(", base device: %s (%X), HDMI port number: %d", ToString(m_configuration.baseDevice), m_configuration.baseDevice, m_configuration.iHDMIPort);
1129   uint16_t iPhysicalAddress = GetPrimaryDevice()->GetPhysicalAddress(GetLogicalAddresses().primary, false);
1130   strLog.AppendFormat(", physical address: %x.%x.%x.%x", (iPhysicalAddress >> 12) & 0xF, (iPhysicalAddress >> 8) & 0xF, (iPhysicalAddress >> 4) & 0xF, iPhysicalAddress & 0xF);
1131
1132   strLog.AppendFormat(", %s", LIB_CEC->GetLibInfo());
1133
1134   std::string strReturn(strLog.c_str());
1135   return strReturn;
1136 }
1137
1138 void CCECClient::SetTVVendorOverride(const cec_vendor_id id)
1139 {
1140   {
1141     CLockObject lock(m_mutex);
1142     m_configuration.tvVendor = id;
1143   }
1144
1145   if (id != CEC_VENDOR_UNKNOWN)
1146   {
1147     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vendor id '%s'", __FUNCTION__, ToString(id));
1148
1149     CCECBusDevice *tv = m_processor ? m_processor->GetTV() : NULL;
1150     if (tv)
1151       tv->SetVendorId((uint64_t)id);
1152   }
1153
1154   // persist the new configuration
1155   PersistConfiguration(m_configuration);
1156 }
1157
1158 cec_vendor_id CCECClient::GetTVVendorOverride(void)
1159 {
1160   CLockObject lock(m_mutex);
1161   return (cec_vendor_id)m_configuration.tvVendor;
1162 }
1163
1164 void CCECClient::SetOSDName(const std::string &strDeviceName)
1165 {
1166   {
1167     CLockObject lock(m_mutex);
1168     snprintf(m_configuration.strDeviceName, 13, "%s", strDeviceName.c_str());
1169   }
1170
1171   LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using OSD name '%s'", __FUNCTION__, strDeviceName.c_str());
1172
1173   CCECBusDevice *primary = GetPrimaryDevice();
1174   if (primary && !primary->GetCurrentOSDName().Equals(strDeviceName.c_str()))
1175   {
1176     primary->SetOSDName(strDeviceName);
1177     if (m_processor && m_processor->CECInitialised())
1178       primary->TransmitOSDName(CECDEVICE_TV, false);
1179   }
1180
1181   // persist the new configuration
1182   PersistConfiguration(m_configuration);
1183 }
1184
1185 std::string CCECClient::GetOSDName(void)
1186 {
1187   CLockObject lock(m_mutex);
1188   std::string strOSDName(m_configuration.strDeviceName);
1189   return strOSDName;
1190 }
1191
1192 void CCECClient::SetWakeDevices(const cec_logical_addresses &addresses)
1193 {
1194   {
1195     CLockObject lock(m_mutex);
1196     m_configuration.wakeDevices = addresses;
1197   }
1198   // persist the new configuration
1199   PersistConfiguration(m_configuration);
1200 }
1201
1202 cec_logical_addresses CCECClient::GetWakeDevices(void)
1203 {
1204   CLockObject lock(m_mutex);
1205   return m_configuration.wakeDevices;
1206 }
1207
1208 bool CCECClient::AutodetectPhysicalAddress(void)
1209 {
1210   bool bPhysicalAutodetected(false);
1211   uint16_t iPhysicalAddress = m_processor ? m_processor->GetDetectedPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
1212
1213   if (CLibCEC::IsValidPhysicalAddress(iPhysicalAddress))
1214   {
1215     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%04X'", __FUNCTION__, iPhysicalAddress);
1216
1217     CLockObject lock(m_mutex);
1218     m_configuration.iPhysicalAddress = iPhysicalAddress;
1219     m_configuration.iHDMIPort        = CEC_HDMI_PORTNUMBER_NONE;
1220     m_configuration.baseDevice       = CECDEVICE_UNKNOWN;
1221     bPhysicalAutodetected            = true;
1222   }
1223
1224   SetDevicePhysicalAddress(iPhysicalAddress);
1225
1226   return bPhysicalAutodetected;
1227 }
1228
1229 void CCECClient::SetClientVersion(const cec_client_version version)
1230 {
1231   LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using client version '%s'", __FUNCTION__, ToString(version));
1232
1233   CLockObject lock(m_mutex);
1234   m_configuration.clientVersion = (uint32_t)version;
1235 }
1236
1237 cec_client_version CCECClient::GetClientVersion(void)
1238 {
1239   CLockObject lock(m_mutex);
1240   return (cec_client_version)m_configuration.clientVersion;
1241 }
1242
1243 bool CCECClient::SetDeviceTypes(const cec_device_type_list &deviceTypes)
1244 {
1245   bool bNeedReinit(false);
1246
1247   {
1248     CLockObject lock(m_mutex);
1249     bNeedReinit = m_processor && m_processor->CECInitialised() &&
1250         (m_configuration.deviceTypes != deviceTypes);
1251     m_configuration.deviceTypes = deviceTypes;
1252   }
1253
1254   // persist the new configuration
1255   PersistConfiguration(m_configuration);
1256
1257   if (bNeedReinit)
1258     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using primary device type '%s'", __FUNCTION__, ToString(deviceTypes[0]));
1259
1260   return bNeedReinit;
1261 }
1262
1263 cec_device_type_list CCECClient::GetDeviceTypes(void)
1264 {
1265   cec_device_type_list retVal;
1266   CLockObject lock(m_mutex);
1267   retVal = m_configuration.deviceTypes;
1268   return retVal;
1269 }
1270
1271 bool CCECClient::SetDevicePhysicalAddress(const uint16_t iPhysicalAddress)
1272 {
1273   if (!CLibCEC::IsValidPhysicalAddress(iPhysicalAddress))
1274   {
1275     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - not setting invalid physical address %04x", __FUNCTION__, iPhysicalAddress);
1276     return false;
1277   }
1278
1279   // reconfigure all devices
1280   cec_logical_address reactivateSource(CECDEVICE_UNKNOWN);
1281   CECDEVICEVEC devices;
1282   m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
1283   for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1284   {
1285     // if this device was the active source, reactivate it afterwards
1286     if ((*it)->IsActiveSource())
1287       reactivateSource = (*it)->GetLogicalAddress();
1288
1289     // mark the device as inactive source
1290     if (IsInitialised())
1291       (*it)->MarkAsInactiveSource();
1292
1293     // set the new physical address
1294     (*it)->SetPhysicalAddress(iPhysicalAddress);
1295
1296     // and transmit it
1297     if (IsInitialised())
1298       (*it)->TransmitPhysicalAddress(false);
1299   }
1300
1301   // reactivate the previous active source
1302   if (reactivateSource != CECDEVICE_UNKNOWN &&
1303       m_processor->CECInitialised() &&
1304       IsInitialised())
1305   {
1306     CCECBusDevice *device = m_processor->GetDevice(reactivateSource);
1307     if (device)
1308       device->ActivateSource();
1309   }
1310
1311   // persist the new configuration
1312   PersistConfiguration(m_configuration);
1313
1314   return true;
1315 }
1316
1317 bool CCECClient::SwitchMonitoring(bool bEnable)
1318 {
1319   LIB_CEC->AddLog(CEC_LOG_NOTICE, "== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
1320
1321   if (m_processor)
1322   {
1323     m_processor->SwitchMonitoring(bEnable);
1324     m_configuration.bMonitorOnly = bEnable;
1325     return bEnable ? true: m_processor->RegisterClient(this);
1326   }
1327
1328   return false;
1329 }
1330
1331 bool CCECClient::PollDevice(const cec_logical_address iAddress)
1332 {
1333   // try to find the primary device
1334   CCECBusDevice *primary = GetPrimaryDevice();
1335   // poll the destination, with the primary as source
1336   if (primary)
1337     return primary->TransmitPoll(iAddress, true);
1338
1339   return m_processor ? m_processor->PollDevice(iAddress) : false;
1340 }
1341
1342 cec_logical_addresses CCECClient::GetActiveDevices(void)
1343 {
1344   CECDEVICEVEC activeDevices;
1345   if (m_processor)
1346     m_processor->GetDevices()->GetActive(activeDevices);
1347   return CCECDeviceMap::ToLogicalAddresses(activeDevices);
1348 }
1349
1350 bool CCECClient::IsActiveDevice(const cec_logical_address iAddress)
1351 {
1352   cec_logical_addresses activeDevices = GetActiveDevices();
1353   return activeDevices.IsSet(iAddress);
1354 }
1355
1356 bool CCECClient::IsActiveDeviceType(const cec_device_type type)
1357 {
1358   CECDEVICEVEC activeDevices;
1359   if (m_processor)
1360     m_processor->GetDevices()->GetActive(activeDevices);
1361   CCECDeviceMap::FilterType(type, activeDevices);
1362   return !activeDevices.empty();
1363 }
1364
1365 cec_logical_address CCECClient::GetActiveSource(void)
1366 {
1367   return m_processor ? m_processor->GetActiveSource() : CECDEVICE_UNKNOWN;
1368 }
1369
1370 bool CCECClient::IsActiveSource(const cec_logical_address iAddress)
1371 {
1372   return m_processor ? m_processor->IsActiveSource(iAddress) : false;
1373 }
1374
1375 bool CCECClient::SetStreamPath(const cec_logical_address iAddress)
1376 {
1377   uint16_t iPhysicalAddress = GetDevicePhysicalAddress(iAddress);
1378   if (iPhysicalAddress != CEC_INVALID_PHYSICAL_ADDRESS)
1379     return SetStreamPath(iPhysicalAddress);
1380   return false;
1381 }
1382
1383 bool CCECClient::SetStreamPath(const uint16_t iPhysicalAddress)
1384 {
1385   bool bReturn(false);
1386
1387   CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_TV);
1388   if (device)
1389   {
1390     device->SetStreamPath(iPhysicalAddress);
1391     bReturn = device->GetHandler()->TransmitSetStreamPath(iPhysicalAddress, false);
1392     device->MarkHandlerReady();
1393   }
1394   else
1395   {
1396     LIB_CEC->AddLog(CEC_LOG_ERROR, "only the TV is allowed to send CEC_OPCODE_SET_STREAM_PATH");
1397   }
1398
1399   return bReturn;
1400 }
1401
1402 cec_logical_addresses CCECClient::GetLogicalAddresses(void)
1403 {
1404   cec_logical_addresses addresses;
1405   CLockObject lock(m_mutex);
1406   addresses = m_configuration.logicalAddresses;
1407   return addresses;
1408 }
1409
1410 bool CCECClient::CanPersistConfiguration(void)
1411 {
1412   return m_processor ? m_processor->CanPersistConfiguration() : false;
1413 }
1414
1415 bool CCECClient::PersistConfiguration(const libcec_configuration &configuration)
1416 {
1417   return m_processor && IsRegistered() ?
1418       m_processor->PersistConfiguration(configuration) :
1419       false;
1420 }
1421
1422 void CCECClient::RescanActiveDevices(void)
1423 {
1424   if (m_processor)
1425     m_processor->RescanActiveDevices();
1426 }
1427
1428 bool CCECClient::IsLibCECActiveSource(void)
1429 {
1430   bool bReturn(false);
1431   if (m_processor)
1432   {
1433     cec_logical_address activeSource = m_processor->GetActiveSource();
1434     CCECBusDevice *device = m_processor->GetDevice(activeSource);
1435     if (device)
1436       bReturn = device->IsHandledByLibCEC() && !device->GetHandler()->ActiveSourcePending();
1437   }
1438   return bReturn;
1439 }
1440
1441 void CCECClient::SourceActivated(const cec_logical_address logicalAddress)
1442 {
1443   LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> source activated: %s (%x)", ToString(logicalAddress), logicalAddress);
1444   CallbackSourceActivated(true, logicalAddress);
1445 }
1446
1447 void CCECClient::SourceDeactivated(const cec_logical_address logicalAddress)
1448 {
1449   LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> source deactivated: %s (%x)", ToString(logicalAddress), logicalAddress);
1450   CallbackSourceActivated(false, logicalAddress);
1451 }
1452
1453 void CCECClient::CallbackAddCommand(const cec_command &command)
1454 {
1455   CLockObject lock(m_cbMutex);
1456   if (m_configuration.callbacks && m_configuration.callbacks->CBCecCommand)
1457     m_configuration.callbacks->CBCecCommand(m_configuration.callbackParam, command);
1458 }
1459
1460 uint32_t CCECClient::DoubleTapTimeoutMS(void)
1461 {
1462   CLockObject lock(m_cbMutex);
1463   return m_configuration.clientVersion >= CEC_CLIENT_VERSION_2_2_0 ?
1464       m_configuration.iDoubleTapTimeout50Ms * DOUBLE_TAP_TIMEOUT_UNIT_SIZE :
1465       m_configuration.iDoubleTapTimeout50Ms;
1466 }
1467
1468 void CCECClient::CallbackAddKey(const cec_keypress &key)
1469 {
1470   CLockObject lock(m_cbMutex);
1471   if (m_configuration.callbacks && m_configuration.callbacks->CBCecKeyPress)
1472   {
1473     // prevent double taps
1474     int64_t now = GetTimeMs();
1475     if (m_lastKeypress.keycode != key.keycode ||
1476         key.duration > 0 ||
1477         now - m_iLastKeypressTime >= DoubleTapTimeoutMS())
1478     {
1479       // no double tap
1480       if (key.duration == 0)
1481         m_iLastKeypressTime = now;
1482       m_lastKeypress = key;
1483       m_configuration.callbacks->CBCecKeyPress(m_configuration.callbackParam, key);
1484     }
1485   }
1486 }
1487
1488 void CCECClient::CallbackAddLog(const cec_log_message &message)
1489 {
1490   CLockObject lock(m_cbMutex);
1491   if (m_configuration.callbacks && m_configuration.callbacks->CBCecLogMessage)
1492     m_configuration.callbacks->CBCecLogMessage(m_configuration.callbackParam, message);
1493 }
1494
1495 void CCECClient::CallbackConfigurationChanged(const libcec_configuration &config)
1496 {
1497   CLockObject lock(m_cbMutex);
1498   if (m_configuration.callbacks &&
1499       m_configuration.callbacks->CBCecConfigurationChanged &&
1500       m_processor->CECInitialised())
1501     m_configuration.callbacks->CBCecConfigurationChanged(m_configuration.callbackParam, config);
1502 }
1503
1504 void CCECClient::CallbackSourceActivated(bool bActivated, const cec_logical_address logicalAddress)
1505 {
1506   CLockObject lock(m_cbMutex);
1507   if (m_configuration.callbacks &&
1508       m_configuration.callbacks->CBCecSourceActivated)
1509     m_configuration.callbacks->CBCecSourceActivated(m_configuration.callbackParam, logicalAddress, bActivated ? 1 : 0);
1510 }
1511
1512 void CCECClient::CallbackAlert(const libcec_alert type, const libcec_parameter &param)
1513 {
1514   CLockObject lock(m_cbMutex);
1515   if (m_configuration.callbacks &&
1516       m_configuration.callbacks->CBCecAlert)
1517     m_configuration.callbacks->CBCecAlert(m_configuration.callbackParam, type, param);
1518 }
1519
1520 int CCECClient::CallbackMenuStateChanged(const cec_menu_state newState)
1521 {
1522   CLockObject lock(m_cbMutex);
1523   if (m_configuration.callbacks &&
1524       m_configuration.callbacks->CBCecMenuStateChanged)
1525     return m_configuration.callbacks->CBCecMenuStateChanged(m_configuration.callbackParam, newState);
1526   return 0;
1527 }