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