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