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