src/lib/CECProcessor.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 "CECProcessor.h"
  34
  35 #include "adapter/USBCECAdapterCommunication.h"
  36 #include "devices/CECBusDevice.h"
  37 #include "devices/CECAudioSystem.h"
  38 #include "devices/CECPlaybackDevice.h"
  39 #include "devices/CECRecordingDevice.h"
  40 #include "devices/CECTuner.h"
  41 #include "devices/CECTV.h"
  42 #include "implementations/CECCommandHandler.h"
  43 #include "LibCEC.h"
  44 #include "CECClient.h"
  45 #include "CECTypeUtils.h"
  46 #include "platform/util/timeutils.h"
  47 #include "platform/util/util.h"
  48
  49 using namespace CEC;
  50 using namespace std;
  51 using namespace PLATFORM;
  52
  53 #define CEC_PROCESSOR_SIGNAL_WAIT_TIME 1000
  54 #define ACTIVE_SOURCE_CHECK_INTERVAL   500
  55
  56 #define ToString(x) CCECTypeUtils::ToString(x)
  57
  58 CCECProcessor::CCECProcessor(CLibCEC *libcec) :
  59     m_bInitialised(false),
  60     m_communication(NULL),
  61     m_libcec(libcec),
  62     m_iStandardLineTimeout(3),
  63     m_iRetryLineTimeout(3),
  64     m_iLastTransmission(0)
  65 {
  66   m_busDevices = new CCECDeviceMap(this);
  67 }
  68
  69 CCECProcessor::~CCECProcessor(void)
  70 {
  71   Close();
  72   DELETE_AND_NULL(m_busDevices);
  73 }
  74
  75 bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
  76 {
  77   CLockObject lock(m_mutex);
  78   // open a connection
  79   if (!OpenConnection(strPort, iBaudRate, iTimeoutMs))
  80     return false;
  81
  82   // create the processor thread
  83   if (!IsRunning())
  84   {
  85     if (!CreateThread())
  86     {
  87       m_libcec->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
  88       return false;
  89     }
  90   }
  91
  92   return true;
  93 }
  94
  95 void CCECProcessor::Close(void)
  96 {
  97   // mark as uninitialised
  98   SetCECInitialised(false);
  99
 100   // stop the processor
 101   StopThread();
 102
 103   // close the connection
 104   DELETE_AND_NULL(m_communication);
 105 }
 106
 107 void CCECProcessor::ResetMembers(void)
 108 {
 109   // close the connection
 110   DELETE_AND_NULL(m_communication);
 111
 112   // reset the other members to the initial state
 113   m_iStandardLineTimeout = 3;
 114   m_iRetryLineTimeout = 3;
 115   m_iLastTransmission = 0;
 116   m_busDevices->ResetDeviceStatus();
 117 }
 118
 119 bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs, bool bStartListening /* = true */)
 120 {
 121   bool bReturn(false);
 122   CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
 123
 124   // ensure that a previous connection is closed
 125   Close();
 126
 127   // reset all member to the initial state
 128   ResetMembers();
 129
 130   // check whether the Close() method deleted any previous connection
 131   if (m_communication)
 132   {
 133     m_libcec->AddLog(CEC_LOG_ERROR, "previous connection could not be closed");
 134     return bReturn;
 135   }
 136
 137   // create a new connection
 138   m_communication = new CUSBCECAdapterCommunication(this, strPort, iBaudRate);
 139
 140   // open a new connection
 141   unsigned iConnectTry(0);
 142   while (timeout.TimeLeft() > 0 && (bReturn = m_communication->Open((timeout.TimeLeft() / CEC_CONNECT_TRIES), false, bStartListening)) == false)
 143   {
 144     m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
 145     m_communication->Close();
 146     CEvent::Sleep(CEC_DEFAULT_CONNECT_RETRY_WAIT);
 147   }
 148
 149   m_libcec->AddLog(CEC_LOG_NOTICE, "connection opened");
 150
 151   // mark as initialised
 152   SetCECInitialised(true);
 153
 154   return bReturn;
 155 }
 156
 157 bool CCECProcessor::CECInitialised(void)
 158 {
 159   CLockObject lock(m_threadMutex);
 160   return m_bInitialised;
 161 }
 162
 163 void CCECProcessor::SetCECInitialised(bool bSetTo /* = true */)
 164 {
 165   {
 166     CLockObject lock(m_mutex);
 167     m_bInitialised = bSetTo;
 168   }
 169   if (!bSetTo)
 170     UnregisterClients();
 171 }
 172
 173 bool CCECProcessor::TryLogicalAddress(cec_logical_address address)
 174 {
 175   // find the device
 176   CCECBusDevice *device = m_busDevices->At(address);
 177   if (device)
 178   {
 179     // check if it's already marked as present or used
 180     if (device->IsPresent() || device->IsHandledByLibCEC())
 181       return false;
 182
 183     // poll the LA if not
 184     SetAckMask(0);
 185     return device->TryLogicalAddress();
 186   }
 187
 188   return false;
 189 }
 190
 191 void CCECProcessor::ReplaceHandlers(void)
 192 {
 193   if (!CECInitialised())
 194     return;
 195
 196   // check each device
 197   for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
 198     it->second->ReplaceHandler(true);
 199 }
 200
 201 bool CCECProcessor::OnCommandReceived(const cec_command &command)
 202 {
 203   return m_inBuffer.Push(command);
 204 }
 205
 206 void *CCECProcessor::Process(void)
 207 {
 208   m_libcec->AddLog(CEC_LOG_DEBUG, "processor thread started");
 209
 210   cec_command command; command.Clear();
 211   CTimeout activeSourceCheck(ACTIVE_SOURCE_CHECK_INTERVAL);
 212
 213   // as long as we're not being stopped and the connection is open
 214   while (!IsStopped() && m_communication->IsOpen())
 215   {
 216     // wait for a new incoming command, and process it
 217     if (m_inBuffer.Pop(command, CEC_PROCESSOR_SIGNAL_WAIT_TIME))
 218       ProcessCommand(command);
 219
 220     if (CECInitialised())
 221     {
 222       // check clients for keypress timeouts
 223       m_libcec->CheckKeypressTimeout();
 224
 225       // check if we need to replace handlers
 226       ReplaceHandlers();
 227
 228       // check whether we need to activate a source, if it failed before
 229       if (activeSourceCheck.TimeLeft() == 0)
 230       {
 231         if (CECInitialised())
 232           TransmitPendingActiveSourceCommands();
 233         activeSourceCheck.Init(ACTIVE_SOURCE_CHECK_INTERVAL);
 234       }
 235     }
 236   }
 237
 238   return NULL;
 239 }
 240
 241 bool CCECProcessor::ActivateSource(uint16_t iStreamPath)
 242 {
 243   bool bReturn(false);
 244
 245   // find the device with the given PA
 246   CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
 247   // and make it the active source when found
 248   if (device)
 249     bReturn = device->ActivateSource();
 250   else
 251     m_libcec->AddLog(CEC_LOG_DEBUG, "device with PA '%04x' not found", iStreamPath);
 252
 253   return bReturn;
 254 }
 255
 256 void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
 257 {
 258   CLockObject lock(m_mutex);
 259   m_iStandardLineTimeout = iTimeout;
 260 }
 261
 262 uint8_t CCECProcessor::GetStandardLineTimeout(void)
 263 {
 264   CLockObject lock(m_mutex);
 265   return m_iStandardLineTimeout;
 266 }
 267
 268 void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
 269 {
 270   CLockObject lock(m_mutex);
 271   m_iRetryLineTimeout = iTimeout;
 272 }
 273
 274 uint8_t CCECProcessor::GetRetryLineTimeout(void)
 275 {
 276   CLockObject lock(m_mutex);
 277   return m_iRetryLineTimeout;
 278 }
 279
 280 bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
 281 {
 282   CCECBusDevice *device = GetDeviceByPhysicalAddress(iPhysicalAddress);
 283   return device != NULL;
 284 }
 285
 286 void CCECProcessor::LogOutput(const cec_command &data)
 287 {
 288   CStdString strTx;
 289
 290   // initiator and destination
 291   strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
 292
 293   // append the opcode
 294   if (data.opcode_set)
 295       strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
 296
 297   // append the parameters
 298   for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
 299     strTx.AppendFormat(":%02x", data.parameters[iPtr]);
 300
 301   // and log it
 302   m_libcec->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
 303 }
 304
 305 bool CCECProcessor::PollDevice(cec_logical_address iAddress)
 306 {
 307   // try to find the primary device
 308   CCECBusDevice *primary = GetPrimaryDevice();
 309   // poll the destination, with the primary as source
 310   if (primary)
 311     return primary->TransmitPoll(iAddress);
 312
 313   // try to find the destination
 314   CCECBusDevice *device = m_busDevices->At(iAddress);
 315   // and poll the destination, with the same LA as source
 316   if (device)
 317     return device->TransmitPoll(iAddress);
 318
 319   return false;
 320 }
 321
 322 CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bSuppressUpdate /* = true */)
 323 {
 324   return m_busDevices ?
 325       m_busDevices->GetDeviceByPhysicalAddress(iPhysicalAddress, bSuppressUpdate) :
 326       NULL;
 327 }
 328
 329 CCECBusDevice *CCECProcessor::GetDevice(cec_logical_address address) const
 330 {
 331   return m_busDevices ?
 332       m_busDevices->At(address) :
 333       NULL;
 334 }
 335
 336 cec_logical_address CCECProcessor::GetActiveSource(bool bRequestActiveSource /* = true */)
 337 {
 338   // get the device that is marked as active source from the device map
 339   CCECBusDevice *activeSource = m_busDevices->GetActiveSource();
 340   if (activeSource)
 341     return activeSource->GetLogicalAddress();
 342
 343   if (bRequestActiveSource)
 344   {
 345     // request the active source from the bus
 346     CCECBusDevice *primary = GetPrimaryDevice();
 347     if (primary)
 348     {
 349       primary->RequestActiveSource();
 350       return GetActiveSource(false);
 351     }
 352   }
 353
 354   // unknown or none
 355   return CECDEVICE_UNKNOWN;
 356 }
 357
 358 bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
 359 {
 360   CCECBusDevice *device = m_busDevices->At(iAddress);
 361   return device && device->IsActiveSource();
 362 }
 363
 364 bool CCECProcessor::Transmit(const cec_command &data)
 365 {
 366   uint8_t iMaxTries(0);
 367   bool bRetry(true);
 368   uint8_t iTries(0);
 369
 370   // get the current timeout setting
 371   uint8_t iLineTimeout(GetStandardLineTimeout());
 372
 373   // reset the state of this message to 'unknown'
 374   cec_adapter_message_state adapterState = ADAPTER_MESSAGE_STATE_UNKNOWN;
 375
 376   LogOutput(data);
 377
 378   // find the initiator device
 379   CCECBusDevice *initiator = m_busDevices->At(data.initiator);
 380   if (!initiator)
 381   {
 382     m_libcec->AddLog(CEC_LOG_WARNING, "invalid initiator");
 383     return false;
 384   }
 385
 386   // find the destination device, if it's not the broadcast address
 387   if (data.destination != CECDEVICE_BROADCAST)
 388   {
 389     // check if the device is marked as handled by libCEC
 390     CCECBusDevice *destination = m_busDevices->At(data.destination);
 391     if (destination && destination->IsHandledByLibCEC())
 392     {
 393       // and reject the command if it's trying to send data to a device that is handled by libCEC
 394       m_libcec->AddLog(CEC_LOG_WARNING, "not sending data to myself!");
 395       return false;
 396     }
 397   }
 398
 399   {
 400     CLockObject lock(m_mutex);
 401     m_iLastTransmission = GetTimeMs();
 402     // set the number of tries
 403     iMaxTries = initiator->GetHandler()->GetTransmitRetries() + 1;
 404     initiator->MarkHandlerReady();
 405   }
 406
 407   // and try to send the command
 408   while (bRetry && ++iTries < iMaxTries)
 409   {
 410     if (initiator->IsUnsupportedFeature(data.opcode))
 411       return false;
 412
 413     adapterState = !IsStopped() && m_communication && m_communication->IsOpen() ?
 414         m_communication->Write(data, bRetry, iLineTimeout) :
 415         ADAPTER_MESSAGE_STATE_ERROR;
 416     iLineTimeout = m_iRetryLineTimeout;
 417   }
 418
 419   return adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 420 }
 421
 422 void CCECProcessor::TransmitAbort(cec_logical_address source, cec_logical_address destination, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
 423 {
 424   m_libcec->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
 425
 426   cec_command command;
 427   cec_command::Format(command, source, destination, CEC_OPCODE_FEATURE_ABORT);
 428   command.parameters.PushBack((uint8_t)opcode);
 429   command.parameters.PushBack((uint8_t)reason);
 430
 431   Transmit(command);
 432 }
 433
 434 void CCECProcessor::ProcessCommand(const cec_command &command)
 435 {
 436   // log the command
 437   CStdString dataStr;
 438   dataStr.Format(">> %1x%1x", command.initiator, command.destination);
 439   if (command.opcode_set == 1)
 440     dataStr.AppendFormat(":%02x", command.opcode);
 441   for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 442     dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
 443   m_libcec->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
 444
 445   // find the initiator
 446   CCECBusDevice *device = m_busDevices->At(command.initiator);
 447
 448   if (device)
 449     device->HandleCommand(command);
 450 }
 451
 452 bool CCECProcessor::IsPresentDevice(cec_logical_address address)
 453 {
 454   CCECBusDevice *device = m_busDevices->At(address);
 455   return device && device->GetStatus() == CEC_DEVICE_STATUS_PRESENT;
 456 }
 457
 458 bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
 459 {
 460   CECDEVICEVEC devices;
 461   m_busDevices->GetByType(type, devices);
 462   CCECDeviceMap::FilterActive(devices);
 463   return !devices.empty();
 464 }
 465
 466 uint16_t CCECProcessor::GetDetectedPhysicalAddress(void) const
 467 {
 468   return m_communication ? m_communication->GetPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
 469 }
 470
 471 bool CCECProcessor::SetAckMask(uint16_t iMask)
 472 {
 473   return m_communication ? m_communication->SetAckMask(iMask) : false;
 474 }
 475
 476 bool CCECProcessor::StandbyDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
 477 {
 478   bool bReturn(true);
 479   for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
 480     bReturn &= (*it)->Standby(initiator);
 481   return bReturn;
 482 }
 483
 484 bool CCECProcessor::StandbyDevice(const cec_logical_address initiator, cec_logical_address address)
 485 {
 486   CCECBusDevice *device = m_busDevices->At(address);
 487   return device ? device->Standby(initiator) : false;
 488 }
 489
 490 bool CCECProcessor::PowerOnDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
 491 {
 492   bool bReturn(true);
 493   for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
 494     bReturn &= (*it)->PowerOn(initiator);
 495   return bReturn;
 496 }
 497
 498 bool CCECProcessor::PowerOnDevice(const cec_logical_address initiator, cec_logical_address address)
 499 {
 500   CCECBusDevice *device = m_busDevices->At(address);
 501   return device ? device->PowerOn(initiator) : false;
 502 }
 503
 504 bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */)
 505 {
 506   bool bReturn(false);
 507   // open a connection if no connection has been opened
 508   if (!m_communication && strPort)
 509   {
 510     IAdapterCommunication *comm = new CUSBCECAdapterCommunication(this, strPort);
 511     CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT);
 512     int iConnectTry(0);
 513     while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false)
 514     {
 515       m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
 516       comm->Close();
 517       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 518     }
 519     if (comm->IsOpen())
 520     {
 521       bReturn = comm->StartBootloader();
 522       DELETE_AND_NULL(comm);
 523     }
 524     return bReturn;
 525   }
 526   else
 527   {
 528     m_communication->StartBootloader();
 529     Close();
 530     bReturn = true;
 531   }
 532
 533   return bReturn;
 534 }
 535
 536 bool CCECProcessor::PingAdapter(void)
 537 {
 538   return m_communication->PingAdapter();
 539 }
 540
 541 void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
 542 {
 543   CCECBusDevice *device = m_busDevices->At(destination);
 544   if (device)
 545     device->HandlePollFrom(initiator);
 546 }
 547
 548 bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator)
 549 {
 550   CCECBusDevice *device = m_busDevices->At(initiator);
 551   return !device || !device->HandleReceiveFailed();
 552 }
 553
 554 bool CCECProcessor::SetStreamPath(uint16_t iPhysicalAddress)
 555 {
 556   // stream path changes are sent by the TV
 557   bool bReturn = GetTV()->GetHandler()->TransmitSetStreamPath(iPhysicalAddress);
 558   GetTV()->MarkHandlerReady();
 559   return bReturn;
 560 }
 561
 562 bool CCECProcessor::CanPersistConfiguration(void)
 563 {
 564   return m_communication ? m_communication->GetFirmwareVersion() >= 2 : false;
 565 }
 566
 567 bool CCECProcessor::PersistConfiguration(const libcec_configuration &configuration)
 568 {
 569   return m_communication ? m_communication->PersistConfiguration(configuration) : false;
 570 }
 571
 572 void CCECProcessor::RescanActiveDevices(void)
 573 {
 574   for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
 575     it->second->GetStatus(true);
 576 }
 577
 578 bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
 579 {
 580   if (!OpenConnection(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs, false))
 581     return false;
 582
 583   config->iFirmwareVersion   = m_communication->GetFirmwareVersion();
 584   config->iPhysicalAddress   = m_communication->GetPhysicalAddress();
 585   config->iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
 586
 587   return true;
 588 }
 589
 590 bool CCECProcessor::TransmitPendingActiveSourceCommands(void)
 591 {
 592   bool bReturn(true);
 593   for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
 594     bReturn &= it->second->TransmitPendingActiveSourceCommands();
 595   return bReturn;
 596 }
 597
 598 CCECTV *CCECProcessor::GetTV(void) const
 599 {
 600   return CCECBusDevice::AsTV(m_busDevices->At(CECDEVICE_TV));
 601 }
 602
 603 CCECAudioSystem *CCECProcessor::GetAudioSystem(void) const
 604 {
 605   return CCECBusDevice::AsAudioSystem(m_busDevices->At(CECDEVICE_AUDIOSYSTEM));
 606 }
 607
 608 CCECPlaybackDevice *CCECProcessor::GetPlaybackDevice(cec_logical_address address) const
 609 {
 610   return CCECBusDevice::AsPlaybackDevice(m_busDevices->At(address));
 611 }
 612
 613 CCECRecordingDevice *CCECProcessor::GetRecordingDevice(cec_logical_address address) const
 614 {
 615   return CCECBusDevice::AsRecordingDevice(m_busDevices->At(address));
 616 }
 617
 618 CCECTuner *CCECProcessor::GetTuner(cec_logical_address address) const
 619 {
 620   return CCECBusDevice::AsTuner(m_busDevices->At(address));
 621 }
 622
 623 bool CCECProcessor::RegisterClient(CCECClient *client)
 624 {
 625   if (!client)
 626     return false;
 627
 628   libcec_configuration &configuration = *client->GetConfiguration();
 629
 630   if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_3 && configuration.bMonitorOnly == 1)
 631     return true;
 632
 633   if (!CECInitialised())
 634   {
 635     m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: CEC processor is not initialised");
 636     return false;
 637   }
 638
 639   // ensure that we know the vendor id of the TV
 640   CCECBusDevice *tv = GetTV();
 641   tv->GetVendorId(CECDEVICE_UNREGISTERED);
 642   tv->ReplaceHandler(false);
 643
 644   // unregister the client first if it's already been marked as registered
 645   if (client->IsRegistered())
 646     UnregisterClient(client);
 647
 648   // get the configuration from the client
 649   m_libcec->AddLog(CEC_LOG_NOTICE, "registering new CEC client - v%s", ToString((cec_client_version)configuration.clientVersion));
 650
 651   // mark as uninitialised and unregistered
 652   client->SetRegistered(false);
 653   client->SetInitialised(false);
 654
 655   // get the current ackmask, so we can restore it if polling fails
 656   uint16_t iPreviousMask(m_communication->GetAckMask());
 657
 658   // find logical addresses for this client
 659   if (!client->AllocateLogicalAddresses())
 660   {
 661     m_libcec->AddLog(CEC_LOG_ERROR, "failed to register the new CEC client - cannot allocate the requested device types");
 662     SetAckMask(iPreviousMask);
 663     return false;
 664   }
 665
 666   // register this client on the new addresses
 667   CECDEVICEVEC devices;
 668   m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses);
 669   for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
 670   {
 671                 // set the physical address of the device at this LA
 672     if (CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
 673       (*it)->SetPhysicalAddress(configuration.iPhysicalAddress);
 674
 675     // replace a previous client
 676     CLockObject lock(m_mutex);
 677     m_clients.erase((*it)->GetLogicalAddress());
 678     m_clients.insert(make_pair<cec_logical_address, CCECClient *>((*it)->GetLogicalAddress(), client));
 679   }
 680
 681   // get the settings from the rom
 682   if (configuration.bGetSettingsFromROM == 1)
 683   {
 684     libcec_configuration config; config.Clear();
 685     m_communication->GetConfiguration(config);
 686
 687     CLockObject lock(m_mutex);
 688     if (!config.deviceTypes.IsEmpty())
 689       configuration.deviceTypes = config.deviceTypes;
 690     if (CLibCEC::IsValidPhysicalAddress(config.iPhysicalAddress))
 691       configuration.iPhysicalAddress = config.iPhysicalAddress;
 692     snprintf(configuration.strDeviceName, 13, "%s", config.strDeviceName);
 693   }
 694
 695   // set the firmware version and build date
 696   configuration.serverVersion      = LIBCEC_VERSION_CURRENT;
 697   configuration.iFirmwareVersion   = m_communication->GetFirmwareVersion();
 698   configuration.iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
 699
 700   // mark the client as registered
 701   client->SetRegistered(true);
 702
 703   // set the new ack mask
 704   bool bReturn = SetAckMask(GetLogicalAddresses().AckMask()) &&
 705       // and initialise the client
 706       client->OnRegister();
 707
 708   // log the new registration
 709   CStdString strLog;
 710   strLog.Format("%s: %s", bReturn ? "CEC client registered" : "failed to register the CEC client", client->GetConnectionInfo().c_str());
 711   m_libcec->AddLog(bReturn ? CEC_LOG_NOTICE : CEC_LOG_ERROR, strLog);
 712
 713   // display a warning if the firmware can be upgraded
 714   if (bReturn && !IsRunningLatestFirmware())
 715   {
 716     const char *strUpgradeMessage = "The firmware of this adapter can be upgraded. Please visit http://blog.pulse-eight.com/ for more information.";
 717     m_libcec->AddLog(CEC_LOG_WARNING, strUpgradeMessage);
 718     libcec_parameter param;
 719     param.paramData = (void*)strUpgradeMessage; param.paramType = CEC_PARAMETER_TYPE_STRING;
 720     client->Alert(CEC_ALERT_SERVICE_DEVICE, param);
 721   }
 722
 723   // ensure that the command handler for the TV is initialised
 724   if (bReturn)
 725   {
 726     CCECCommandHandler *handler = GetTV()->GetHandler();
 727     if (handler)
 728       handler->InitHandler();
 729     GetTV()->MarkHandlerReady();
 730   }
 731
 732   return bReturn;
 733 }
 734
 735 bool CCECProcessor::UnregisterClient(CCECClient *client)
 736 {
 737   if (!client)
 738     return false;
 739
 740   if (client->IsRegistered())
 741     m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering client: %s", client->GetConnectionInfo().c_str());
 742
 743   // notify the client that it will be unregistered
 744   client->OnUnregister();
 745
 746   {
 747     CLockObject lock(m_mutex);
 748     // find all devices that match the LA's of this client
 749     CECDEVICEVEC devices;
 750     m_busDevices->GetByLogicalAddresses(devices, client->GetConfiguration()->logicalAddresses);
 751     for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
 752     {
 753       // find the client
 754       map<cec_logical_address, CCECClient *>::iterator entry = m_clients.find((*it)->GetLogicalAddress());
 755       // unregister the client
 756       if (entry != m_clients.end())
 757         m_clients.erase(entry);
 758
 759       // reset the device status
 760       (*it)->ResetDeviceStatus();
 761     }
 762   }
 763
 764   // set the new ackmask
 765   return SetAckMask(GetLogicalAddresses().AckMask());
 766 }
 767
 768 void CCECProcessor::UnregisterClients(void)
 769 {
 770   m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering all CEC clients");
 771
 772   vector<CCECClient *> clients = m_libcec->GetClients();
 773   for (vector<CCECClient *>::iterator client = clients.begin(); client != clients.end(); client++)
 774     UnregisterClient(*client);
 775
 776   CLockObject lock(m_mutex);
 777   m_clients.clear();
 778 }
 779
 780 CCECClient *CCECProcessor::GetClient(const cec_logical_address address)
 781 {
 782   CLockObject lock(m_mutex);
 783   map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.find(address);
 784   if (client != m_clients.end())
 785     return client->second;
 786   return NULL;
 787 }
 788
 789 CCECClient *CCECProcessor::GetPrimaryClient(void)
 790 {
 791   CLockObject lock(m_mutex);
 792   map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin();
 793   if (client != m_clients.end())
 794     return client->second;
 795   return NULL;
 796 }
 797
 798 CCECBusDevice *CCECProcessor::GetPrimaryDevice(void)
 799 {
 800   return m_busDevices->At(GetLogicalAddress());
 801 }
 802
 803 cec_logical_address CCECProcessor::GetLogicalAddress(void)
 804 {
 805   cec_logical_addresses addresses = GetLogicalAddresses();
 806   return addresses.primary;
 807 }
 808
 809 cec_logical_addresses CCECProcessor::GetLogicalAddresses(void)
 810 {
 811   CLockObject lock(m_mutex);
 812   cec_logical_addresses addresses;
 813   addresses.Clear();
 814   for (map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin(); client != m_clients.end(); client++)
 815     addresses.Set(client->first);
 816
 817   return addresses;
 818 }
 819
 820 bool CCECProcessor::IsHandledByLibCEC(const cec_logical_address address) const
 821 {
 822   CCECBusDevice *device = GetDevice(address);
 823   return device && device->IsHandledByLibCEC();
 824 }
 825
 826 bool CCECProcessor::IsRunningLatestFirmware(void)
 827 {
 828   return m_communication && m_communication->IsOpen() ?
 829       m_communication->IsRunningLatestFirmware() :
 830       true;
 831 }