src/lib/devices/CECBusDevice.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 "CECBusDevice.h"
  34 #include "../CECProcessor.h"
  35 #include "../CECClient.h"
  36 #include "../implementations/ANCommandHandler.h"
  37 #include "../implementations/CECCommandHandler.h"
  38 #include "../implementations/SLCommandHandler.h"
  39 #include "../implementations/VLCommandHandler.h"
  40 #include "../LibCEC.h"
  41 #include "../CECTypeUtils.h"
  42 #include "../platform/util/timeutils.h"
  43 #include "../platform/util/util.h"
  44
  45 #include "CECAudioSystem.h"
  46 #include "CECPlaybackDevice.h"
  47 #include "CECRecordingDevice.h"
  48 #include "CECTuner.h"
  49 #include "CECTV.h"
  50
  51 using namespace std;
  52 using namespace CEC;
  53 using namespace PLATFORM;
  54
  55 #define LIB_CEC     m_processor->GetLib()
  56 #define ToString(p) CCECTypeUtils::ToString(p)
  57
  58 CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */) :
  59   m_type                  (CEC_DEVICE_TYPE_RESERVED),
  60   m_iPhysicalAddress      (iPhysicalAddress),
  61   m_iStreamPath           (CEC_INVALID_PHYSICAL_ADDRESS),
  62   m_iLogicalAddress       (iLogicalAddress),
  63   m_powerStatus           (CEC_POWER_STATUS_UNKNOWN),
  64   m_processor             (processor),
  65   m_vendor                (CEC_VENDOR_UNKNOWN),
  66   m_bReplaceHandler       (false),
  67   m_menuState             (CEC_MENU_STATE_ACTIVATED),
  68   m_bActiveSource         (false),
  69   m_iLastActive           (0),
  70   m_iLastPowerStateUpdate (0),
  71   m_cecVersion            (CEC_VERSION_UNKNOWN),
  72   m_deviceStatus          (CEC_DEVICE_STATUS_UNKNOWN),
  73   m_iHandlerUseCount      (0),
  74   m_bAwaitingReceiveFailed(false),
  75   m_bVendorIdRequested    (false),
  76   m_waitForResponse       (new CWaitForResponse)
  77 {
  78   m_handler = new CCECCommandHandler(this);
  79
  80   for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
  81     m_menuLanguage.language[iPtr] = '?';
  82   m_menuLanguage.language[3] = 0;
  83   m_menuLanguage.device = iLogicalAddress;
  84
  85   m_strDeviceName = ToString(m_iLogicalAddress);
  86 }
  87
  88 CCECBusDevice::~CCECBusDevice(void)
  89 {
  90   DELETE_AND_NULL(m_handler);
  91   DELETE_AND_NULL(m_waitForResponse);
  92 }
  93
  94 bool CCECBusDevice::ReplaceHandler(bool bActivateSource /* = true */)
  95 {
  96   bool bInitHandler(false);
  97   {
  98     CTryLockObject lock(m_mutex);
  99     if (!lock.IsLocked())
 100       return false;
 101
 102     CLockObject handlerLock(m_handlerMutex);
 103     if (m_iHandlerUseCount > 0)
 104       return false;
 105
 106     MarkBusy();
 107
 108     if (m_vendor != m_handler->GetVendorId())
 109     {
 110       if (CCECCommandHandler::HasSpecificHandler(m_vendor))
 111       {
 112         LIB_CEC->AddLog(CEC_LOG_DEBUG, "replacing the command handler for device '%s' (%x)", GetLogicalAddressName(), GetLogicalAddress());
 113
 114         int32_t iTransmitTimeout     = m_handler->m_iTransmitTimeout;
 115         int32_t iTransmitWait        = m_handler->m_iTransmitWait;
 116         int8_t  iTransmitRetries     = m_handler->m_iTransmitRetries;
 117         int64_t iActiveSourcePending = m_handler->m_iActiveSourcePending;
 118
 119         DELETE_AND_NULL(m_handler);
 120
 121         switch (m_vendor)
 122         {
 123         case CEC_VENDOR_SAMSUNG:
 124           m_handler = new CANCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
 125           break;
 126         case CEC_VENDOR_LG:
 127           m_handler = new CSLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
 128           break;
 129         case CEC_VENDOR_PANASONIC:
 130           m_handler = new CVLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
 131           break;
 132         default:
 133           m_handler = new CCECCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
 134           break;
 135         }
 136
 137         m_handler->SetVendorId(m_vendor);
 138         bInitHandler = true;
 139       }
 140     }
 141   }
 142
 143   if (bInitHandler)
 144   {
 145     CCECBusDevice *primary = GetProcessor()->GetPrimaryDevice();
 146     if (primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
 147     {
 148       m_handler->InitHandler();
 149
 150       if (bActivateSource && IsHandledByLibCEC() && IsActiveSource())
 151         m_handler->ActivateSource();
 152     }
 153   }
 154
 155   MarkReady();
 156
 157   return true;
 158 }
 159
 160 CCECCommandHandler *CCECBusDevice::GetHandler(void)
 161 {
 162   ReplaceHandler(false);
 163   MarkBusy();
 164   return m_handler;
 165 }
 166
 167 bool CCECBusDevice::HandleCommand(const cec_command &command)
 168 {
 169   bool bHandled(false);
 170
 171   /* update "last active" */
 172   {
 173     CLockObject lock(m_mutex);
 174     m_iLastActive = GetTimeMs();
 175
 176     /* don't call GetStatus() here, just read the value with the mutex locked */
 177     if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC && command.opcode_set == 1)
 178       m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
 179
 180     MarkBusy();
 181   }
 182
 183   /* handle the command */
 184   bHandled = m_handler->HandleCommand(command);
 185
 186   /* change status to present */
 187   if (bHandled && GetLogicalAddress() != CECDEVICE_BROADCAST)
 188   {
 189     CLockObject lock(m_mutex);
 190     if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
 191     {
 192       if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT)
 193         LIB_CEC->AddLog(CEC_LOG_DEBUG, "device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode));
 194       m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
 195     }
 196   }
 197
 198   MarkReady();
 199   return bHandled;
 200 }
 201
 202 const char* CCECBusDevice::GetLogicalAddressName(void) const
 203 {
 204   return ToString(m_iLogicalAddress);
 205 }
 206
 207 bool CCECBusDevice::IsPresent(void)
 208 {
 209   CLockObject lock(m_mutex);
 210   return m_deviceStatus == CEC_DEVICE_STATUS_PRESENT;
 211 }
 212
 213 bool CCECBusDevice::IsHandledByLibCEC(void)
 214 {
 215   CLockObject lock(m_mutex);
 216   return m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC;
 217 }
 218
 219 void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode)
 220 {
 221   // some commands should never be marked as unsupported
 222   if (opcode == CEC_OPCODE_VENDOR_COMMAND ||
 223       opcode == CEC_OPCODE_VENDOR_COMMAND_WITH_ID ||
 224       opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN ||
 225       opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP ||
 226       opcode == CEC_OPCODE_ABORT ||
 227       opcode == CEC_OPCODE_FEATURE_ABORT ||
 228       opcode == CEC_OPCODE_NONE)
 229     return;
 230
 231   {
 232     CLockObject lock(m_mutex);
 233     if (m_unsupportedFeatures.find(opcode) == m_unsupportedFeatures.end())
 234     {
 235       LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking opcode '%s' as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
 236       m_unsupportedFeatures.insert(opcode);
 237     }
 238   }
 239
 240   // signal threads that are waiting for a reponse
 241   MarkBusy();
 242   SignalOpcode(cec_command::GetResponseOpcode(opcode));
 243   MarkReady();
 244 }
 245
 246 bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode)
 247 {
 248   CLockObject lock(m_mutex);
 249   bool bUnsupported = (m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end());
 250   if (bUnsupported)
 251     LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' is marked as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
 252   return bUnsupported;
 253 }
 254
 255 bool CCECBusDevice::TransmitKeypress(const cec_logical_address initiator, cec_user_control_code key, bool bWait /* = true */)
 256 {
 257   MarkBusy();
 258   bool bReturn = m_handler->TransmitKeypress(initiator, m_iLogicalAddress, key, bWait);
 259   MarkReady();
 260   return bReturn;
 261 }
 262
 263 bool CCECBusDevice::TransmitKeyRelease(const cec_logical_address initiator, bool bWait /* = true */)
 264 {
 265   MarkBusy();
 266   bool bReturn = m_handler->TransmitKeyRelease(initiator, m_iLogicalAddress, bWait);
 267   MarkReady();
 268   return bReturn;
 269 }
 270
 271 cec_version CCECBusDevice::GetCecVersion(const cec_logical_address initiator, bool bUpdate /* = false */)
 272 {
 273   bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 274   bool bRequestUpdate(false);
 275   {
 276     CLockObject lock(m_mutex);
 277     bRequestUpdate = bIsPresent &&
 278         (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN);
 279   }
 280
 281   if (bRequestUpdate)
 282   {
 283     CheckVendorIdRequested(initiator);
 284     RequestCecVersion(initiator);
 285   }
 286
 287   CLockObject lock(m_mutex);
 288   return m_cecVersion;
 289 }
 290
 291 void CCECBusDevice::SetCecVersion(const cec_version newVersion)
 292 {
 293   CLockObject lock(m_mutex);
 294   if (m_cecVersion != newVersion)
 295     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion));
 296   m_cecVersion = newVersion;
 297 }
 298
 299 bool CCECBusDevice::RequestCecVersion(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 300 {
 301   bool bReturn(false);
 302
 303   if (!IsHandledByLibCEC() &&
 304       !IsUnsupportedFeature(CEC_OPCODE_GET_CEC_VERSION))
 305   {
 306     MarkBusy();
 307     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 308     bReturn = m_handler->TransmitRequestCecVersion(initiator, m_iLogicalAddress, bWaitForResponse);
 309     MarkReady();
 310   }
 311   return bReturn;
 312 }
 313
 314 bool CCECBusDevice::TransmitCECVersion(const cec_logical_address destination)
 315 {
 316   cec_version version;
 317   {
 318     CLockObject lock(m_mutex);
 319     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_cecVersion));
 320     version = m_cecVersion;
 321   }
 322
 323   MarkBusy();
 324   bool bReturn = m_handler->TransmitCECVersion(m_iLogicalAddress, destination, version);
 325   MarkReady();
 326   return bReturn;
 327 }
 328
 329 cec_menu_language &CCECBusDevice::GetMenuLanguage(const cec_logical_address initiator, bool bUpdate /* = false */)
 330 {
 331   bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 332   bool bRequestUpdate(false);
 333   {
 334     CLockObject lock(m_mutex);
 335     bRequestUpdate = (bIsPresent &&
 336         (bUpdate || !strcmp(m_menuLanguage.language, "???")));
 337   }
 338
 339   if (bRequestUpdate)
 340   {
 341     CheckVendorIdRequested(initiator);
 342     RequestMenuLanguage(initiator);
 343   }
 344
 345   CLockObject lock(m_mutex);
 346   return m_menuLanguage;
 347 }
 348
 349 void CCECBusDevice::SetMenuLanguage(const char *strLanguage)
 350 {
 351   if (!strLanguage)
 352     return;
 353
 354   CLockObject lock(m_mutex);
 355   if (strcmp(strLanguage, m_menuLanguage.language))
 356   {
 357     memcpy(m_menuLanguage.language, strLanguage, 3);
 358     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, m_menuLanguage.language);
 359   }
 360 }
 361
 362 void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
 363 {
 364   if (language.device == m_iLogicalAddress)
 365     SetMenuLanguage(language.language);
 366 }
 367
 368 bool CCECBusDevice::RequestMenuLanguage(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 369 {
 370   bool bReturn(false);
 371
 372   if (!IsHandledByLibCEC() &&
 373       !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE))
 374   {
 375     MarkBusy();
 376     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 377     bReturn = m_handler->TransmitRequestMenuLanguage(initiator, m_iLogicalAddress, bWaitForResponse);
 378     MarkReady();
 379   }
 380   return bReturn;
 381 }
 382
 383 bool CCECBusDevice::TransmitSetMenuLanguage(const cec_logical_address destination)
 384 {
 385   bool bReturn(false);
 386   cec_menu_language language;
 387   {
 388     CLockObject lock(m_mutex);
 389     language = m_menuLanguage;
 390   }
 391
 392   char lang[3];
 393   {
 394     CLockObject lock(m_mutex);
 395     lang[0] = language.language[0];
 396     lang[1] = language.language[1];
 397     lang[2] = language.language[2];
 398   }
 399
 400   MarkBusy();
 401   if (lang[0] == '?' && lang[1] == '?' && lang[2] == '?')
 402   {
 403     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): Menu language feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
 404     m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 405     bReturn = true;
 406   }
 407   else
 408   {
 409     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): Menu language '%s'", GetLogicalAddressName(), m_iLogicalAddress, lang);
 410     bReturn = m_handler->TransmitSetMenuLanguage(m_iLogicalAddress, lang);
 411   }
 412   MarkReady();
 413   return bReturn;
 414 }
 415
 416 bool CCECBusDevice::TransmitOSDString(const cec_logical_address destination, cec_display_control duration, const char *strMessage)
 417 {
 418   bool bReturn(false);
 419   if (!m_processor->GetDevice(destination)->IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING))
 420   {
 421     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, strMessage);
 422     MarkBusy();
 423     bReturn = m_handler->TransmitOSDString(m_iLogicalAddress, destination, duration, strMessage);
 424     MarkReady();
 425   }
 426   return bReturn;
 427 }
 428
 429 CStdString CCECBusDevice::GetCurrentOSDName(void)
 430 {
 431   CLockObject lock(m_mutex);
 432   return m_strDeviceName;
 433 }
 434
 435 CStdString CCECBusDevice::GetOSDName(const cec_logical_address initiator, bool bUpdate /* = false */)
 436 {
 437   bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 438   bool bRequestUpdate(false);
 439   {
 440     CLockObject lock(m_mutex);
 441     bRequestUpdate = bIsPresent &&
 442         (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) &&
 443         m_type != CEC_DEVICE_TYPE_TV;
 444   }
 445
 446   if (bRequestUpdate)
 447   {
 448     CheckVendorIdRequested(initiator);
 449     RequestOSDName(initiator);
 450   }
 451
 452   CLockObject lock(m_mutex);
 453   return m_strDeviceName;
 454 }
 455
 456 void CCECBusDevice::SetOSDName(CStdString strName)
 457 {
 458   CLockObject lock(m_mutex);
 459   if (m_strDeviceName != strName)
 460   {
 461     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName.c_str());
 462     m_strDeviceName = strName;
 463   }
 464 }
 465
 466 bool CCECBusDevice::RequestOSDName(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 467 {
 468   bool bReturn(false);
 469
 470   if (!IsHandledByLibCEC() &&
 471       !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME))
 472   {
 473     MarkBusy();
 474     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 475     bReturn = m_handler->TransmitRequestOSDName(initiator, m_iLogicalAddress, bWaitForResponse);
 476     MarkReady();
 477   }
 478   return bReturn;
 479 }
 480
 481 bool CCECBusDevice::TransmitOSDName(const cec_logical_address destination)
 482 {
 483   CStdString strDeviceName;
 484   {
 485     CLockObject lock(m_mutex);
 486     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, m_strDeviceName.c_str());
 487     strDeviceName = m_strDeviceName;
 488   }
 489
 490   MarkBusy();
 491   bool bReturn = m_handler->TransmitOSDName(m_iLogicalAddress, destination, strDeviceName);
 492   MarkReady();
 493   return bReturn;
 494 }
 495
 496 bool CCECBusDevice::HasValidPhysicalAddress(void)
 497 {
 498   CLockObject lock(m_mutex);
 499   return CLibCEC::IsValidPhysicalAddress(m_iPhysicalAddress);
 500 }
 501
 502 uint16_t CCECBusDevice::GetCurrentPhysicalAddress(void)
 503 {
 504   CLockObject lock(m_mutex);
 505   return m_iPhysicalAddress;
 506 }
 507
 508 uint16_t CCECBusDevice::GetPhysicalAddress(const cec_logical_address initiator, bool bSuppressUpdate /* = false */)
 509 {
 510   if (!bSuppressUpdate)
 511   {
 512     bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 513     bool bRequestUpdate(false);
 514     {
 515       CLockObject lock(m_mutex);
 516       bRequestUpdate = bIsPresent && m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS;
 517     }
 518
 519     if (bRequestUpdate)
 520     {
 521       CheckVendorIdRequested(initiator);
 522       if (!RequestPhysicalAddress(initiator))
 523         LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to request the physical address");
 524     }
 525   }
 526
 527   CLockObject lock(m_mutex);
 528   return m_iPhysicalAddress;
 529 }
 530
 531 bool CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
 532 {
 533   CLockObject lock(m_mutex);
 534   if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress)
 535   {
 536     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
 537     m_iPhysicalAddress = iNewAddress;
 538   }
 539   return true;
 540 }
 541
 542 bool CCECBusDevice::RequestPhysicalAddress(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 543 {
 544   bool bReturn(false);
 545
 546   if (!IsHandledByLibCEC())
 547   {
 548     MarkBusy();
 549     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 550     bReturn = m_handler->TransmitRequestPhysicalAddress(initiator, m_iLogicalAddress, bWaitForResponse);
 551     MarkReady();
 552   }
 553   return bReturn;
 554 }
 555
 556 bool CCECBusDevice::TransmitPhysicalAddress(void)
 557 {
 558   uint16_t iPhysicalAddress;
 559   cec_device_type type;
 560   {
 561     CLockObject lock(m_mutex);
 562     if (m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS)
 563       return false;
 564
 565     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
 566     iPhysicalAddress = m_iPhysicalAddress;
 567     type = m_type;
 568   }
 569
 570   MarkBusy();
 571   bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type);
 572   MarkReady();
 573   return bReturn;
 574 }
 575
 576 cec_power_status CCECBusDevice::GetCurrentPowerStatus(void)
 577 {
 578   CLockObject lock(m_mutex);
 579   return m_powerStatus;
 580 }
 581
 582 cec_power_status CCECBusDevice::GetPowerStatus(const cec_logical_address initiator, bool bUpdate /* = false */)
 583 {
 584   bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 585   bool bRequestUpdate(false);
 586   {
 587     CLockObject lock(m_mutex);
 588     bRequestUpdate = (bIsPresent &&
 589         (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
 590             m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON ||
 591             m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY ||
 592             GetTimeMs() - m_iLastPowerStateUpdate >= CEC_POWER_STATE_REFRESH_TIME));
 593   }
 594
 595   if (bRequestUpdate)
 596   {
 597     CheckVendorIdRequested(initiator);
 598     RequestPowerStatus(initiator);
 599   }
 600
 601   CLockObject lock(m_mutex);
 602   return m_powerStatus;
 603 }
 604
 605 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
 606 {
 607   CLockObject lock(m_mutex);
 608   if (m_powerStatus != powerStatus)
 609   {
 610     m_iLastPowerStateUpdate = GetTimeMs();
 611     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
 612     m_powerStatus = powerStatus;
 613   }
 614 }
 615
 616 bool CCECBusDevice::RequestPowerStatus(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 617 {
 618   bool bReturn(false);
 619
 620   if (!IsHandledByLibCEC() &&
 621       !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
 622   {
 623     MarkBusy();
 624     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting power status of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 625     bReturn = m_handler->TransmitRequestPowerStatus(initiator, m_iLogicalAddress, bWaitForResponse);
 626     MarkReady();
 627   }
 628   return bReturn;
 629 }
 630
 631 bool CCECBusDevice::TransmitPowerState(const cec_logical_address destination)
 632 {
 633   cec_power_status state;
 634   {
 635     CLockObject lock(m_mutex);
 636     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_powerStatus));
 637     state = m_powerStatus;
 638   }
 639
 640   MarkBusy();
 641   bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, destination, state);
 642   MarkReady();
 643   return bReturn;
 644 }
 645
 646 cec_vendor_id CCECBusDevice::GetCurrentVendorId(void)
 647 {
 648   CLockObject lock(m_mutex);
 649   return m_vendor;
 650 }
 651
 652 cec_vendor_id CCECBusDevice::GetVendorId(const cec_logical_address initiator, bool bUpdate /* = false */)
 653 {
 654   bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
 655   bool bRequestUpdate(false);
 656   {
 657     CLockObject lock(m_mutex);
 658     bRequestUpdate = (bIsPresent &&
 659         (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN));
 660   }
 661
 662   if (bRequestUpdate)
 663     RequestVendorId(initiator);
 664
 665   CLockObject lock(m_mutex);
 666   return m_vendor;
 667 }
 668
 669 const char *CCECBusDevice::GetVendorName(const cec_logical_address initiator, bool bUpdate /* = false */)
 670 {
 671   return ToString(GetVendorId(initiator, bUpdate));
 672 }
 673
 674 bool CCECBusDevice::SetVendorId(uint64_t iVendorId)
 675 {
 676   bool bVendorChanged(false);
 677
 678   {
 679     CLockObject lock(m_mutex);
 680     bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId);
 681     m_vendor = (cec_vendor_id)iVendorId;
 682   }
 683
 684   if (bVendorChanged)
 685     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor);
 686
 687   return bVendorChanged;
 688 }
 689
 690 bool CCECBusDevice::RequestVendorId(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
 691 {
 692   bool bReturn(false);
 693
 694   if (!IsHandledByLibCEC() && initiator != CECDEVICE_UNKNOWN)
 695   {
 696     MarkBusy();
 697     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
 698     bReturn = m_handler->TransmitRequestVendorId(initiator, m_iLogicalAddress, bWaitForResponse);
 699     MarkReady();
 700
 701     if (bWaitForResponse)
 702       ReplaceHandler(true);
 703   }
 704   return bReturn;
 705 }
 706
 707 bool CCECBusDevice::TransmitVendorID(const cec_logical_address destination, bool bSendAbort /* = true */)
 708 {
 709   bool bReturn(false);
 710   uint64_t iVendorId;
 711   {
 712     CLockObject lock(m_mutex);
 713     iVendorId = (uint64_t)m_vendor;
 714   }
 715
 716   MarkBusy();
 717   if (iVendorId == CEC_VENDOR_UNKNOWN)
 718   {
 719     if (bSendAbort)
 720     {
 721       LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
 722       m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 723       bReturn = true;
 724     }
 725   }
 726   else
 727   {
 728     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString((cec_vendor_id)iVendorId), iVendorId);
 729     bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId);
 730   }
 731   MarkReady();
 732   return bReturn;
 733 }
 734
 735 cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */, bool bSuppressPoll /* = false */)
 736 {
 737   cec_bus_device_status status(CEC_DEVICE_STATUS_UNKNOWN);
 738   bool bNeedsPoll(false);
 739
 740   {
 741     CLockObject lock(m_mutex);
 742     status = m_deviceStatus;
 743     bNeedsPoll = !bSuppressPoll &&
 744         (bForcePoll || m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN);
 745   }
 746
 747   if (bNeedsPoll)
 748   {
 749     bool bPollAcked(false);
 750     if (bNeedsPoll && NeedsPoll())
 751       bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
 752
 753     status = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
 754     SetDeviceStatus(status);
 755   }
 756
 757   return status;
 758 }
 759
 760 void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus)
 761 {
 762   {
 763     CLockObject lock(m_mutex);
 764     switch (newStatus)
 765     {
 766     case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
 767       if (m_deviceStatus != newStatus)
 768         LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'handled by libCEC'", GetLogicalAddressName(), m_iLogicalAddress);
 769       SetPowerStatus   (CEC_POWER_STATUS_ON);
 770       SetVendorId      (CEC_VENDOR_UNKNOWN);
 771       SetMenuState     (CEC_MENU_STATE_ACTIVATED);
 772       SetCecVersion    (CEC_VERSION_1_3A);
 773       SetStreamPath    (CEC_INVALID_PHYSICAL_ADDRESS);
 774       MarkAsInactiveSource();
 775       m_iLastActive   = 0;
 776       m_deviceStatus  = newStatus;
 777       break;
 778     case CEC_DEVICE_STATUS_PRESENT:
 779       if (m_deviceStatus != newStatus)
 780         LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'present'", GetLogicalAddressName(), m_iLogicalAddress);
 781       m_deviceStatus = newStatus;
 782       break;
 783     case CEC_DEVICE_STATUS_NOT_PRESENT:
 784       if (m_deviceStatus != newStatus)
 785       {
 786         LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'not present'", GetLogicalAddressName(), m_iLogicalAddress);
 787         ResetDeviceStatus();
 788         m_deviceStatus = newStatus;
 789       }
 790       break;
 791     default:
 792       ResetDeviceStatus();
 793       break;
 794     }
 795   }
 796 }
 797
 798 void CCECBusDevice::ResetDeviceStatus(void)
 799 {
 800   CLockObject lock(m_mutex);
 801   SetPowerStatus   (CEC_POWER_STATUS_UNKNOWN);
 802   SetVendorId      (CEC_VENDOR_UNKNOWN);
 803   SetMenuState     (CEC_MENU_STATE_ACTIVATED);
 804   SetCecVersion    (CEC_VERSION_UNKNOWN);
 805   SetStreamPath    (CEC_INVALID_PHYSICAL_ADDRESS);
 806   SetOSDName       (ToString(m_iLogicalAddress));
 807   MarkAsInactiveSource();
 808
 809   m_iLastActive = 0;
 810   m_bVendorIdRequested = false;
 811   m_unsupportedFeatures.clear();
 812   m_waitForResponse->Clear();
 813
 814   if (m_deviceStatus != CEC_DEVICE_STATUS_UNKNOWN)
 815     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'unknown'", GetLogicalAddressName(), m_iLogicalAddress);
 816   m_deviceStatus = CEC_DEVICE_STATUS_UNKNOWN;
 817 }
 818
 819 bool CCECBusDevice::TransmitPoll(const cec_logical_address dest)
 820 {
 821   bool bReturn(false);
 822   cec_logical_address destination(dest);
 823   if (destination == CECDEVICE_UNKNOWN)
 824     destination = m_iLogicalAddress;
 825
 826   CCECBusDevice *destDevice = m_processor->GetDevice(destination);
 827   if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
 828     return bReturn;
 829
 830   MarkBusy();
 831   LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
 832   bReturn = m_handler->TransmitPoll(m_iLogicalAddress, destination);
 833   LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
 834
 835   CLockObject lock(m_mutex);
 836   if (bReturn)
 837   {
 838     m_iLastActive = GetTimeMs();
 839     destDevice->m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
 840   }
 841   else
 842     destDevice->m_deviceStatus = CEC_DEVICE_STATUS_NOT_PRESENT;
 843
 844   MarkReady();
 845   return bReturn;
 846 }
 847
 848 void CCECBusDevice::HandlePoll(const cec_logical_address destination)
 849 {
 850   if (destination >= 0 && destination < CECDEVICE_BROADCAST)
 851   {
 852     CCECBusDevice *device = m_processor->GetDevice(destination);
 853     if (device)
 854       device->HandlePollFrom(m_iLogicalAddress);
 855   }
 856 }
 857
 858 void CCECBusDevice::HandlePollFrom(const cec_logical_address initiator)
 859 {
 860   LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(initiator), initiator, ToString(m_iLogicalAddress), m_iLogicalAddress);
 861   m_bAwaitingReceiveFailed = true;
 862 }
 863
 864 bool CCECBusDevice::HandleReceiveFailed(void)
 865 {
 866   bool bReturn = m_bAwaitingReceiveFailed;
 867   m_bAwaitingReceiveFailed = false;
 868   return bReturn;
 869 }
 870
 871 cec_menu_state CCECBusDevice::GetMenuState(const cec_logical_address UNUSED(initiator))
 872 {
 873   CLockObject lock(m_mutex);
 874   return m_menuState;
 875 }
 876
 877 void CCECBusDevice::SetMenuState(const cec_menu_state state)
 878 {
 879   CLockObject lock(m_mutex);
 880   if (m_menuState != state)
 881   {
 882     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
 883     m_menuState = state;
 884   }
 885 }
 886
 887 bool CCECBusDevice::TransmitMenuState(const cec_logical_address dest)
 888 {
 889   cec_menu_state menuState;
 890   {
 891     CLockObject lock(m_mutex);
 892     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
 893     menuState = m_menuState;
 894   }
 895
 896   MarkBusy();
 897   bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState);
 898   MarkReady();
 899   return bReturn;
 900 }
 901
 902 bool CCECBusDevice::ActivateSource(uint64_t iDelay /* = 0 */)
 903 {
 904   MarkAsActiveSource();
 905   MarkBusy();
 906   bool bReturn(true);
 907   if (iDelay == 0)
 908   {
 909     LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending active source message for '%s'", ToString(m_iLogicalAddress));
 910     bReturn = m_handler->ActivateSource();
 911   }
 912   else
 913   {
 914     LIB_CEC->AddLog(CEC_LOG_DEBUG, "scheduling active source message for '%s'", ToString(m_iLogicalAddress));
 915     m_handler->ScheduleActivateSource(iDelay);
 916   }
 917   MarkReady();
 918   return bReturn;
 919 }
 920
 921 bool CCECBusDevice::RequestActiveSource(bool bWaitForResponse /* = true */)
 922 {
 923   bool bReturn(false);
 924
 925   if (IsHandledByLibCEC())
 926   {
 927     MarkBusy();
 928     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< requesting active source");
 929
 930     bReturn = m_handler->TransmitRequestActiveSource(m_iLogicalAddress, bWaitForResponse);
 931     MarkReady();
 932   }
 933   return bReturn;
 934 }
 935
 936 void CCECBusDevice::MarkAsActiveSource(void)
 937 {
 938   bool bWasActivated(false);
 939
 940   // set the power status to powered on
 941   SetPowerStatus(CEC_POWER_STATUS_ON);
 942
 943   // mark this device as active source
 944   {
 945     CLockObject lock(m_mutex);
 946     if (!m_bActiveSource)
 947     {
 948       LIB_CEC->AddLog(CEC_LOG_DEBUG, "making %s (%x) the active source", GetLogicalAddressName(), m_iLogicalAddress);
 949       bWasActivated = true;
 950     }
 951     else
 952       LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%x) was already marked as active source", GetLogicalAddressName(), m_iLogicalAddress);
 953
 954     m_bActiveSource = true;
 955   }
 956
 957   // mark other devices as inactive sources
 958   CECDEVICEVEC devices;
 959   m_processor->GetDevices()->Get(devices);
 960   for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
 961     if ((*it)->GetLogicalAddress() != m_iLogicalAddress)
 962       (*it)->MarkAsInactiveSource();
 963
 964   if (bWasActivated)
 965   {
 966     CCECClient *client = GetClient();
 967     if (client)
 968       client->SourceActivated(m_iLogicalAddress);
 969   }
 970 }
 971
 972 void CCECBusDevice::MarkAsInactiveSource(void)
 973 {
 974   bool bWasDeactivated(false);
 975   {
 976     CLockObject lock(m_mutex);
 977     if (m_bActiveSource)
 978     {
 979       LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking %s (%X) as inactive source", GetLogicalAddressName(), m_iLogicalAddress);
 980       bWasDeactivated = true;
 981     }
 982     m_bActiveSource = false;
 983   }
 984
 985   if (bWasDeactivated)
 986   {
 987     CCECClient *client = GetClient();
 988     if (client)
 989       client->SourceDeactivated(m_iLogicalAddress);
 990   }
 991 }
 992
 993 bool CCECBusDevice::TransmitActiveSource(void)
 994 {
 995   bool bSendActiveSource(false);
 996   uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
 997
 998   {
 999     CLockObject lock(m_mutex);
1000     if (!HasValidPhysicalAddress())
1001     {
1002       LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X) has an invalid physical address (%04x), not sending active source commands", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1003       return false;
1004     }
1005
1006     iPhysicalAddress = m_iPhysicalAddress;
1007
1008     if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1009       LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1010     else if (m_bActiveSource)
1011     {
1012       LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1013       bSendActiveSource = true;
1014     }
1015     else
1016       LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
1017   }
1018
1019   bool bActiveSourceSent(false);
1020   if (bSendActiveSource)
1021   {
1022     MarkBusy();
1023     bActiveSourceSent = m_handler->TransmitActiveSource(m_iLogicalAddress, iPhysicalAddress);
1024     MarkReady();
1025   }
1026
1027   return bActiveSourceSent;
1028 }
1029
1030 bool CCECBusDevice::TransmitImageViewOn(void)
1031 {
1032   {
1033     CLockObject lock(m_mutex);
1034     if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1035     {
1036       LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1037       return false;
1038     }
1039   }
1040
1041   bool bImageViewOnSent(false);
1042   MarkBusy();
1043   bImageViewOnSent = m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
1044   MarkReady();
1045   return bImageViewOnSent;
1046 }
1047
1048 bool CCECBusDevice::TransmitInactiveSource(void)
1049 {
1050   uint16_t iPhysicalAddress;
1051   {
1052     CLockObject lock(m_mutex);
1053     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
1054     iPhysicalAddress = m_iPhysicalAddress;
1055   }
1056
1057   MarkBusy();
1058   bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
1059   MarkReady();
1060   return bReturn;
1061 }
1062
1063 bool CCECBusDevice::TransmitPendingActiveSourceCommands(void)
1064 {
1065   MarkBusy();
1066   bool bReturn = m_handler->ActivateSource(true);
1067   MarkReady();
1068   return bReturn;
1069 }
1070
1071 void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */)
1072 {
1073   CLockObject lock(m_mutex);
1074   if (iNewAddress != m_iStreamPath)
1075   {
1076     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress);
1077     m_iStreamPath = iNewAddress;
1078   }
1079
1080   if (!LIB_CEC->IsValidPhysicalAddress(iNewAddress))
1081     return;
1082
1083   CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iNewAddress);
1084   if (device)
1085   {
1086     // if a device is found with the new physical address, mark it as active, which will automatically mark all other devices as inactive
1087     device->MarkAsActiveSource();
1088   }
1089   else
1090   {
1091     // try to find the device with the old address, and mark it as inactive when found
1092     device = m_processor->GetDeviceByPhysicalAddress(iOldAddress);
1093     if (device)
1094       device->MarkAsInactiveSource();
1095   }
1096 }
1097
1098 bool CCECBusDevice::PowerOn(const cec_logical_address initiator)
1099 {
1100   bool bReturn(false);
1101   GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1102
1103   MarkBusy();
1104   cec_power_status currentStatus = GetPowerStatus(initiator, false);
1105   if (currentStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON &&
1106     currentStatus != CEC_POWER_STATUS_ON)
1107   {
1108     LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
1109     if (m_handler->PowerOn(initiator, m_iLogicalAddress))
1110     {
1111       SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
1112       bReturn = true;
1113     }
1114   }
1115   else
1116   {
1117     LIB_CEC->AddLog(CEC_LOG_NOTICE, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus));
1118   }
1119
1120   MarkReady();
1121   return bReturn;
1122 }
1123
1124 bool CCECBusDevice::Standby(const cec_logical_address initiator)
1125 {
1126   GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1127
1128   LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
1129   MarkBusy();
1130   bool bReturn = m_handler->TransmitStandby(initiator, m_iLogicalAddress);
1131   MarkReady();
1132   return bReturn;
1133 }
1134
1135 bool CCECBusDevice::NeedsPoll(void)
1136 {
1137   bool bSendPoll(false);
1138   cec_logical_address pollAddress(CECDEVICE_UNKNOWN);
1139   switch (m_iLogicalAddress)
1140   {
1141   case CECDEVICE_PLAYBACKDEVICE3:
1142     pollAddress = CECDEVICE_PLAYBACKDEVICE2;
1143     break;
1144   case CECDEVICE_PLAYBACKDEVICE2:
1145     pollAddress = CECDEVICE_PLAYBACKDEVICE1;
1146     break;
1147   case CECDEVICE_RECORDINGDEVICE3:
1148     pollAddress = CECDEVICE_RECORDINGDEVICE2;
1149     break;
1150   case CECDEVICE_RECORDINGDEVICE2:
1151     pollAddress = CECDEVICE_RECORDINGDEVICE1;
1152     break;
1153   case CECDEVICE_TUNER4:
1154     pollAddress = CECDEVICE_TUNER3;
1155     break;
1156   case CECDEVICE_TUNER3:
1157     pollAddress = CECDEVICE_TUNER2;
1158     break;
1159   case CECDEVICE_TUNER2:
1160     pollAddress = CECDEVICE_TUNER1;
1161     break;
1162   case CECDEVICE_AUDIOSYSTEM:
1163   case CECDEVICE_PLAYBACKDEVICE1:
1164   case CECDEVICE_RECORDINGDEVICE1:
1165   case CECDEVICE_TUNER1:
1166   case CECDEVICE_TV:
1167     bSendPoll = true;
1168     break;
1169   default:
1170     break;
1171   }
1172
1173   if (!bSendPoll && pollAddress != CECDEVICE_UNKNOWN)
1174   {
1175     CCECBusDevice *device = m_processor->GetDevice(pollAddress);
1176     if (device)
1177     {
1178       cec_bus_device_status status = device->GetStatus();
1179       bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
1180     }
1181     else
1182     {
1183       bSendPoll = true;
1184     }
1185   }
1186
1187   return bSendPoll;
1188 }
1189
1190 void CCECBusDevice::CheckVendorIdRequested(const cec_logical_address initiator)
1191 {
1192   bool bRequestVendorId(false);
1193   {
1194     CLockObject lock(m_mutex);
1195     bRequestVendorId = !m_bVendorIdRequested;
1196     m_bVendorIdRequested = true;
1197   }
1198
1199   if (bRequestVendorId)
1200   {
1201     ReplaceHandler(false);
1202     GetVendorId(initiator);
1203   }
1204 }
1205 //@}
1206
1207 CCECAudioSystem *CCECBusDevice::AsAudioSystem(void)
1208 {
1209   return AsAudioSystem(this);
1210 }
1211
1212 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(void)
1213 {
1214   return AsPlaybackDevice(this);
1215 }
1216
1217 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(void)
1218 {
1219   return AsRecordingDevice(this);
1220 }
1221
1222 CCECTuner *CCECBusDevice::AsTuner(void)
1223 {
1224   return AsTuner(this);
1225 }
1226
1227 CCECTV *CCECBusDevice::AsTV(void)
1228 {
1229   return AsTV(this);
1230 }
1231
1232 CCECAudioSystem *CCECBusDevice::AsAudioSystem(CCECBusDevice *device)
1233 {
1234   if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
1235     return static_cast<CCECAudioSystem *>(device);
1236   return NULL;
1237 }
1238
1239 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(CCECBusDevice *device)
1240 {
1241   if (device &&
1242       (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
1243        device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
1244     return static_cast<CCECPlaybackDevice *>(device);
1245   return NULL;
1246 }
1247
1248 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(CCECBusDevice *device)
1249 {
1250   if (device && device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
1251     return static_cast<CCECRecordingDevice *>(device);
1252   return NULL;
1253 }
1254
1255 CCECTuner *CCECBusDevice::AsTuner(CCECBusDevice *device)
1256 {
1257   if (device && device->GetType() == CEC_DEVICE_TYPE_TUNER)
1258     return static_cast<CCECTuner *>(device);
1259   return NULL;
1260 }
1261
1262 CCECTV *CCECBusDevice::AsTV(CCECBusDevice *device)
1263 {
1264   if (device && device->GetType() == CEC_DEVICE_TYPE_TV)
1265     return static_cast<CCECTV *>(device);
1266   return NULL;
1267 }
1268
1269 void CCECBusDevice::MarkBusy(void)
1270 {
1271   CLockObject handlerLock(m_handlerMutex);
1272   ++m_iHandlerUseCount;
1273 }
1274
1275 void CCECBusDevice::MarkReady(void)
1276 {
1277   CLockObject handlerLock(m_handlerMutex);
1278   if (m_iHandlerUseCount > 0)
1279     --m_iHandlerUseCount;
1280 }
1281
1282 bool CCECBusDevice::TryLogicalAddress(void)
1283 {
1284   LIB_CEC->AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName());
1285
1286   if (!TransmitPoll(m_iLogicalAddress))
1287   {
1288     LIB_CEC->AddLog(CEC_LOG_NOTICE, "using logical address '%s'", GetLogicalAddressName());
1289     SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
1290
1291     return true;
1292   }
1293
1294   LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName());
1295   SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
1296   return false;
1297 }
1298
1299 CCECClient *CCECBusDevice::GetClient(void)
1300 {
1301   return m_processor->GetClient(m_iLogicalAddress);
1302 }
1303
1304 void CCECBusDevice::SignalOpcode(cec_opcode opcode)
1305 {
1306   m_waitForResponse->Received(opcode);
1307 }
1308
1309 bool CCECBusDevice::WaitForOpcode(cec_opcode opcode)
1310 {
1311   return m_waitForResponse->Wait(opcode);
1312 }