src/lib/implementations/CECCommandHandler.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 "env.h"
  34 #include "CECCommandHandler.h"
  35
  36 #include "lib/devices/CECBusDevice.h"
  37 #include "lib/devices/CECAudioSystem.h"
  38 #include "lib/devices/CECPlaybackDevice.h"
  39 #include "lib/CECClient.h"
  40 #include "lib/CECProcessor.h"
  41 #include "lib/LibCEC.h"
  42 #include "lib/CECTypeUtils.h"
  43 #include "lib/platform/util/util.h"
  44
  45 using namespace CEC;
  46 using namespace std;
  47 using namespace PLATFORM;
  48
  49 #define LIB_CEC     m_busDevice->GetProcessor()->GetLib()
  50 #define ToString(p) CCECTypeUtils::ToString(p)
  51 #define REQUEST_POWER_STATUS_TIMEOUT 5000
  52
  53 CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice,
  54                                        int32_t iTransmitTimeout /* = CEC_DEFAULT_TRANSMIT_TIMEOUT */,
  55                                        int32_t iTransmitWait /* = CEC_DEFAULT_TRANSMIT_WAIT */,
  56                                        int8_t iTransmitRetries /* = CEC_DEFAULT_TRANSMIT_RETRIES */,
  57                                        int64_t iActiveSourcePending /* = 0 */) :
  58     m_busDevice(busDevice),
  59     m_processor(m_busDevice->GetProcessor()),
  60     m_iTransmitTimeout(iTransmitTimeout),
  61     m_iTransmitWait(iTransmitWait),
  62     m_iTransmitRetries(iTransmitRetries),
  63     m_bHandlerInited(false),
  64     m_bOPTSendDeckStatusUpdateOnActiveSource(false),
  65     m_vendorId(CEC_VENDOR_UNKNOWN),
  66     m_iActiveSourcePending(iActiveSourcePending),
  67     m_iPowerStatusRequested(0)
  68 {
  69 }
  70
  71 bool CCECCommandHandler::HandleCommand(const cec_command &command)
  72 {
  73   if (command.opcode_set == 0)
  74     return HandlePoll(command);
  75
  76   int iHandled(CEC_ABORT_REASON_UNRECOGNIZED_OPCODE);
  77
  78   LIB_CEC->AddCommand(command);
  79
  80   switch(command.opcode)
  81   {
  82   case CEC_OPCODE_REPORT_POWER_STATUS:
  83     iHandled = HandleReportPowerStatus(command);
  84     break;
  85   case CEC_OPCODE_CEC_VERSION:
  86     iHandled = HandleDeviceCecVersion(command);
  87     break;
  88   case CEC_OPCODE_SET_MENU_LANGUAGE:
  89     iHandled = HandleSetMenuLanguage(command);
  90     break;
  91   case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
  92     iHandled = HandleGivePhysicalAddress(command);
  93     break;
  94   case CEC_OPCODE_GET_MENU_LANGUAGE:
  95     iHandled = HandleGiveMenuLanguage(command);
  96     break;
  97   case CEC_OPCODE_GIVE_OSD_NAME:
  98     iHandled = HandleGiveOSDName(command);
  99     break;
 100   case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
 101     iHandled = HandleGiveDeviceVendorId(command);
 102     break;
 103   case CEC_OPCODE_DEVICE_VENDOR_ID:
 104     iHandled = HandleDeviceVendorId(command);
 105     break;
 106   case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
 107     iHandled = HandleDeviceVendorCommandWithId(command);
 108     break;
 109   case CEC_OPCODE_GIVE_DECK_STATUS:
 110     iHandled = HandleGiveDeckStatus(command);
 111     break;
 112   case CEC_OPCODE_DECK_CONTROL:
 113     iHandled = HandleDeckControl(command);
 114     break;
 115   case CEC_OPCODE_MENU_REQUEST:
 116     iHandled = HandleMenuRequest(command);
 117     break;
 118   case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
 119     iHandled = HandleGiveDevicePowerStatus(command);
 120     break;
 121   case CEC_OPCODE_GET_CEC_VERSION:
 122     iHandled = HandleGetCecVersion(command);
 123     break;
 124   case CEC_OPCODE_USER_CONTROL_PRESSED:
 125     iHandled = HandleUserControlPressed(command);
 126     break;
 127   case CEC_OPCODE_USER_CONTROL_RELEASE:
 128     iHandled = HandleUserControlRelease(command);
 129     break;
 130   case CEC_OPCODE_GIVE_AUDIO_STATUS:
 131     iHandled = HandleGiveAudioStatus(command);
 132     break;
 133   case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
 134     iHandled = HandleGiveSystemAudioModeStatus(command);
 135     break;
 136   case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
 137     iHandled = HandleSystemAudioModeRequest(command);
 138     break;
 139   case CEC_OPCODE_REPORT_AUDIO_STATUS:
 140     iHandled = HandleReportAudioStatus(command);
 141     break;
 142   case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
 143     iHandled = HandleSystemAudioModeStatus(command);
 144     break;
 145   case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
 146     iHandled = HandleSetSystemAudioMode(command);
 147     break;
 148   case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 149     iHandled = HandleRequestActiveSource(command);
 150     break;
 151   case CEC_OPCODE_SET_STREAM_PATH:
 152     iHandled = HandleSetStreamPath(command);
 153     break;
 154   case CEC_OPCODE_ROUTING_CHANGE:
 155     iHandled = HandleRoutingChange(command);
 156     break;
 157   case CEC_OPCODE_ROUTING_INFORMATION:
 158     iHandled = HandleRoutingInformation(command);
 159     break;
 160   case CEC_OPCODE_STANDBY:
 161     iHandled = HandleStandby(command);
 162     break;
 163   case CEC_OPCODE_ACTIVE_SOURCE:
 164     iHandled = HandleActiveSource(command);
 165     break;
 166   case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
 167     iHandled = HandleReportPhysicalAddress(command);
 168     break;
 169   case CEC_OPCODE_SET_OSD_NAME:
 170     iHandled = HandleSetOSDName(command);
 171     break;
 172   case CEC_OPCODE_IMAGE_VIEW_ON:
 173     iHandled = HandleImageViewOn(command);
 174     break;
 175   case CEC_OPCODE_TEXT_VIEW_ON:
 176     iHandled = HandleTextViewOn(command);
 177     break;
 178   case CEC_OPCODE_FEATURE_ABORT:
 179     iHandled = HandleFeatureAbort(command);
 180     break;
 181   case CEC_OPCODE_VENDOR_COMMAND:
 182     iHandled = HandleVendorCommand(command);
 183     break;
 184   case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN:
 185     iHandled = HandleVendorRemoteButtonDown(command);
 186     break;
 187   case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP:
 188     iHandled = HandleVendorRemoteButtonUp(command);
 189     break;
 190   case CEC_OPCODE_PLAY:
 191     // libCEC (currently) doesn't need to do anything with this, since player applications handle it
 192     // but it should not respond with a feature abort
 193     iHandled = COMMAND_HANDLED;
 194     break;
 195   default:
 196     break;
 197   }
 198
 199   if (iHandled == COMMAND_HANDLED)
 200     m_busDevice->SignalOpcode((command.opcode == CEC_OPCODE_FEATURE_ABORT && command.parameters.size > 0) ? (cec_opcode)command.parameters[0] : command.opcode);
 201   else
 202     UnhandledCommand(command, (cec_abort_reason)iHandled);
 203
 204   return iHandled == COMMAND_HANDLED;
 205 }
 206
 207 int CCECCommandHandler::HandleActiveSource(const cec_command &command)
 208 {
 209   if (command.parameters.size == 2)
 210   {
 211     uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 212     m_processor->GetDevices()->SetActiveSource(iAddress);
 213     CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iAddress);
 214     if (device)
 215       device->MarkAsActiveSource();
 216
 217     m_processor->GetDevices()->SignalAll(command.opcode);
 218     return COMMAND_HANDLED;
 219   }
 220
 221   return CEC_ABORT_REASON_INVALID_OPERAND;
 222 }
 223
 224 int CCECCommandHandler::HandleDeckControl(const cec_command &command)
 225 {
 226   CCECPlaybackDevice *device = CCECBusDevice::AsPlaybackDevice(GetDevice(command.destination));
 227   if (device && command.parameters.size > 0)
 228   {
 229     device->SetDeckControlMode((cec_deck_control_mode) command.parameters[0]);
 230     return COMMAND_HANDLED;
 231   }
 232
 233   return CEC_ABORT_REASON_INVALID_OPERAND;
 234 }
 235
 236 int CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
 237 {
 238   if (command.parameters.size == 1)
 239   {
 240     CCECBusDevice *device = GetDevice(command.initiator);
 241     if (device)
 242       device->SetCecVersion((cec_version) command.parameters[0]);
 243
 244     return COMMAND_HANDLED;
 245   }
 246
 247   return CEC_ABORT_REASON_INVALID_OPERAND;
 248 }
 249
 250 int CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command & UNUSED(command))
 251 {
 252   return CEC_ABORT_REASON_INVALID_OPERAND;
 253 }
 254
 255 int CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
 256 {
 257   SetVendorId(command);
 258   return COMMAND_HANDLED;
 259 }
 260
 261 int CCECCommandHandler::HandleFeatureAbort(const cec_command &command)
 262 {
 263   if (command.parameters.size == 2 &&
 264         (command.parameters[1] == CEC_ABORT_REASON_UNRECOGNIZED_OPCODE ||
 265          command.parameters[1] == CEC_ABORT_REASON_REFUSED))
 266     m_processor->GetDevice(command.initiator)->SetUnsupportedFeature((cec_opcode)command.parameters[0]);
 267   return COMMAND_HANDLED;
 268 }
 269
 270 int CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
 271 {
 272   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 273   {
 274     CCECBusDevice *device = GetDevice(command.destination);
 275     if (device && device->TransmitCECVersion(command.initiator, true))
 276       return COMMAND_HANDLED;
 277     return CEC_ABORT_REASON_INVALID_OPERAND;
 278   }
 279
 280   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 281 }
 282
 283 int CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
 284 {
 285   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 286   {
 287     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.destination));
 288     if (device && device->TransmitAudioStatus(command.initiator, true))
 289       return COMMAND_HANDLED;
 290     return CEC_ABORT_REASON_INVALID_OPERAND;
 291   }
 292
 293   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 294 }
 295
 296 int CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
 297 {
 298   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 299   {
 300     CCECPlaybackDevice *device = CCECBusDevice::AsPlaybackDevice(GetDevice(command.destination));
 301     if (device && device->TransmitDeckStatus(command.initiator, true))
 302       return COMMAND_HANDLED;
 303     return CEC_ABORT_REASON_INVALID_OPERAND;
 304   }
 305
 306   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 307 }
 308
 309 int CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
 310 {
 311   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 312   {
 313     CCECBusDevice *device = GetDevice(command.destination);
 314     if (device && device->TransmitPowerState(command.initiator, true))
 315       return COMMAND_HANDLED;
 316     return CEC_ABORT_REASON_INVALID_OPERAND;
 317   }
 318
 319   return CEC_ABORT_REASON_INVALID_OPERAND;
 320 }
 321
 322 int CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
 323 {
 324   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 325   {
 326     CCECBusDevice *device = GetDevice(command.destination);
 327     if (device && device->TransmitVendorID(command.initiator, true, true))
 328       return COMMAND_HANDLED;
 329   }
 330
 331   return CEC_ABORT_REASON_INVALID_OPERAND;
 332 }
 333
 334 int CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
 335 {
 336   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 337   {
 338     CCECBusDevice *device = GetDevice(command.destination);
 339     if (device && device->TransmitOSDName(command.initiator, true))
 340       return COMMAND_HANDLED;
 341   }
 342
 343   return CEC_ABORT_REASON_INVALID_OPERAND;
 344 }
 345
 346 int CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
 347 {
 348   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 349   {
 350     CCECBusDevice *device = GetDevice(command.destination);
 351     if (device && device->TransmitPhysicalAddress(true))
 352       return COMMAND_HANDLED;
 353     return CEC_ABORT_REASON_INVALID_OPERAND;
 354   }
 355
 356   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 357 }
 358
 359 int CCECCommandHandler::HandleGiveMenuLanguage(const cec_command &command)
 360 {
 361   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 362   {
 363     CCECBusDevice *device = GetDevice(command.destination);
 364     if (device && device->TransmitSetMenuLanguage(command.initiator, true))
 365       return COMMAND_HANDLED;
 366     return CEC_ABORT_REASON_INVALID_OPERAND;
 367   }
 368
 369   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 370 }
 371
 372 int CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
 373 {
 374   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 375   {
 376     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.destination));
 377     if (device && device->TransmitSystemAudioModeStatus(command.initiator, true))
 378       return COMMAND_HANDLED;
 379     return CEC_ABORT_REASON_INVALID_OPERAND;
 380   }
 381
 382   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 383 }
 384
 385 int CCECCommandHandler::HandleImageViewOn(const cec_command &command)
 386 {
 387   CCECBusDevice *device = GetDevice(command.destination);
 388   if (device && (device->GetCurrentStatus() == CEC_DEVICE_STATUS_PRESENT ||
 389       device->GetCurrentStatus() == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC))
 390   {
 391     if (device->GetCurrentPowerStatus() == CEC_POWER_STATUS_STANDBY ||
 392         device->GetCurrentPowerStatus() == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY)
 393       device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
 394   }
 395   return COMMAND_HANDLED;
 396 }
 397
 398 int CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 399 {
 400   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 401   {
 402     CCECBusDevice *device = GetDevice(command.destination);
 403     if (device)
 404     {
 405       CCECClient *client = device->GetClient();
 406       if (client)
 407       {
 408         if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_ACTIVATE)
 409         {
 410           if (client->MenuStateChanged(CEC_MENU_STATE_ACTIVATED) == 1)
 411             device->SetMenuState(CEC_MENU_STATE_ACTIVATED);
 412         }
 413         else if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_DEACTIVATE)
 414         {
 415           if (client->MenuStateChanged(CEC_MENU_STATE_DEACTIVATED) == 1)
 416             device->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
 417         }
 418       }
 419       if (device->TransmitMenuState(command.initiator, true))
 420         return COMMAND_HANDLED;
 421     }
 422     return CEC_ABORT_REASON_INVALID_OPERAND;
 423   }
 424
 425   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 426 }
 427
 428 bool CCECCommandHandler::HandlePoll(const cec_command &command)
 429 {
 430   m_busDevice->HandlePoll(command.destination);
 431   return true;
 432 }
 433
 434 int CCECCommandHandler::HandleReportAudioStatus(const cec_command &command)
 435 {
 436   if (command.parameters.size == 1)
 437   {
 438     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.initiator));
 439     if (device)
 440     {
 441       device->SetAudioStatus(command.parameters[0]);
 442       return COMMAND_HANDLED;
 443     }
 444   }
 445   return CEC_ABORT_REASON_INVALID_OPERAND;
 446 }
 447
 448 int CCECCommandHandler::HandleReportPhysicalAddress(const cec_command &command)
 449 {
 450   if (command.parameters.size == 3)
 451   {
 452     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 453     SetPhysicalAddress(command.initiator, iNewAddress);
 454     return COMMAND_HANDLED;
 455   }
 456   return CEC_ABORT_REASON_INVALID_OPERAND;
 457 }
 458
 459 int CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 460 {
 461   if (command.parameters.size == 1)
 462   {
 463     CCECBusDevice *device = GetDevice(command.initiator);
 464     if (device)
 465     {
 466       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 467       return COMMAND_HANDLED;
 468     }
 469   }
 470   return CEC_ABORT_REASON_INVALID_OPERAND;
 471 }
 472
 473 int CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 474 {
 475   if (m_processor->CECInitialised())
 476   {
 477     LIB_CEC->AddLog(CEC_LOG_DEBUG, ">> %i requests active source", (uint8_t) command.initiator);
 478     m_processor->GetDevice(command.initiator)->SetPowerStatus(CEC_POWER_STATUS_ON);
 479
 480     vector<CCECBusDevice *> devices;
 481     for (size_t iDevicePtr = 0; iDevicePtr < GetMyDevices(devices); iDevicePtr++)
 482       devices[iDevicePtr]->TransmitActiveSource(true);
 483   }
 484
 485   return COMMAND_HANDLED;
 486 }
 487
 488 int CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 489 {
 490   if (command.parameters.size == 4)
 491   {
 492     CCECBusDevice *device = GetDevice(command.initiator);
 493     if (device)
 494     {
 495       uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 496       device->SetActiveRoute(iNewAddress);
 497       return COMMAND_HANDLED;
 498     }
 499   }
 500
 501   return CEC_ABORT_REASON_INVALID_OPERAND;
 502 }
 503
 504 int CCECCommandHandler::HandleRoutingInformation(const cec_command &command)
 505 {
 506   if (command.parameters.size == 2)
 507   {
 508     CCECBusDevice *device = GetDevice(command.initiator);
 509     if (device)
 510     {
 511       uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 512       device->SetActiveRoute(iNewAddress);
 513       return COMMAND_HANDLED;
 514     }
 515   }
 516
 517   return CEC_ABORT_REASON_INVALID_OPERAND;
 518 }
 519
 520 int CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 521 {
 522   if (command.parameters.size == 3)
 523   {
 524     CCECBusDevice *device = GetDevice(command.initiator);
 525     if (device)
 526     {
 527       cec_menu_language language;
 528       language.device = command.initiator;
 529       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 530         language.language[iPtr] = command.parameters[iPtr];
 531       language.language[3] = 0;
 532       device->SetMenuLanguage(language);
 533       return COMMAND_HANDLED;
 534     }
 535   }
 536
 537   return CEC_ABORT_REASON_INVALID_OPERAND;
 538 }
 539
 540 int CCECCommandHandler::HandleSetOSDName(const cec_command &command)
 541 {
 542   if (command.parameters.size > 0)
 543   {
 544     CCECBusDevice *device = GetDevice(command.initiator);
 545     if (device)
 546     {
 547       char buf[1024];
 548       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 549         buf[iPtr] = (char)command.parameters[iPtr];
 550       buf[command.parameters.size] = 0;
 551
 552       CStdString strName(buf);
 553       device->SetOSDName(strName);
 554
 555       return COMMAND_HANDLED;
 556     }
 557   }
 558
 559   return CEC_ABORT_REASON_INVALID_OPERAND;
 560 }
 561
 562 int CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 563 {
 564   if (!m_processor->CECInitialised())
 565     return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 566
 567   if (command.parameters.size >= 2)
 568   {
 569     uint16_t iStreamAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 570     LIB_CEC->AddLog(CEC_LOG_DEBUG, ">> %s (%x) sets stream path to physical address %04x", ToString(command.initiator), command.initiator, iStreamAddress);
 571
 572     /* one of the device handled by libCEC has been made active */
 573     CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamAddress);
 574     if (device && device->IsHandledByLibCEC())
 575     {
 576       device->ActivateSource();
 577       return COMMAND_HANDLED;
 578     }
 579   }
 580
 581   return CEC_ABORT_REASON_INVALID_OPERAND;
 582 }
 583
 584 int CCECCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
 585 {
 586   if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination))
 587   {
 588     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.destination));
 589     if (device)
 590     {
 591       if (command.parameters.size >= 2)
 592       {
 593         device->SetPowerStatus(CEC_POWER_STATUS_ON);
 594         device->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_ON);
 595         uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 596         CCECBusDevice *newActiveDevice = GetDeviceByPhysicalAddress(iNewAddress);
 597         if (newActiveDevice)
 598           newActiveDevice->MarkAsActiveSource();
 599         if (device->TransmitSetSystemAudioMode(command.initiator, true))
 600           return COMMAND_HANDLED;
 601       }
 602       else
 603       {
 604         device->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_OFF);
 605         if (device->TransmitSetSystemAudioMode(command.initiator, true))
 606           return COMMAND_HANDLED;
 607       }
 608     }
 609   }
 610
 611   return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 612 }
 613
 614 int CCECCommandHandler::HandleStandby(const cec_command &command)
 615 {
 616   CCECBusDevice *device = GetDevice(command.initiator);
 617   if (device)
 618     device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 619
 620   return COMMAND_HANDLED;
 621 }
 622
 623 int CCECCommandHandler::HandleSystemAudioModeStatus(const cec_command &command)
 624 {
 625   if (command.parameters.size == 1)
 626   {
 627     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.initiator));
 628     if (device)
 629     {
 630       device->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 631       return COMMAND_HANDLED;
 632     }
 633   }
 634
 635   return CEC_ABORT_REASON_INVALID_OPERAND;
 636 }
 637
 638 int CCECCommandHandler::HandleSetSystemAudioMode(const cec_command &command)
 639 {
 640   if (command.parameters.size == 1)
 641   {
 642     CCECAudioSystem *device = CCECBusDevice::AsAudioSystem(GetDevice(command.initiator));
 643     if (device)
 644     {
 645       device->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 646       return COMMAND_HANDLED;
 647     }
 648   }
 649
 650   return CEC_ABORT_REASON_INVALID_OPERAND;
 651 }
 652
 653 int CCECCommandHandler::HandleTextViewOn(const cec_command &command)
 654 {
 655   m_processor->GetDevice(command.initiator)->MarkAsActiveSource();
 656   return COMMAND_HANDLED;
 657 }
 658
 659 int CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 660 {
 661   if (!m_processor->CECInitialised() ||
 662       !m_processor->IsHandledByLibCEC(command.destination))
 663     return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 664
 665   if (command.parameters.size == 0)
 666     return CEC_ABORT_REASON_INVALID_OPERAND;
 667
 668   CCECBusDevice *device = GetDevice(command.destination);
 669   if (!device)
 670     return CEC_ABORT_REASON_INVALID_OPERAND;
 671
 672   CCECClient *client = device->GetClient();
 673   if (client)
 674     client->SetCurrentButton((cec_user_control_code) command.parameters[0]);
 675
 676   if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
 677       command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION||
 678       command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION)
 679   {
 680     bool bPowerOn(true);
 681
 682     // CEC_USER_CONTROL_CODE_POWER and CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION operate as a toggle
 683     // assume CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION does not
 684     if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
 685         command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION)
 686     {
 687       cec_power_status status = device->GetCurrentPowerStatus();
 688       bPowerOn = !(status == CEC_POWER_STATUS_ON || status == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
 689     }
 690
 691     if (bPowerOn)
 692     {
 693       device->ActivateSource();
 694     }
 695     else
 696     {
 697       device->MarkAsInactiveSource();
 698       device->TransmitInactiveSource();
 699       device->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
 700     }
 701   }
 702   else if (command.parameters[0] != CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION)
 703   {
 704     // we're not marked as active source, but the tv sends keypresses to us, so assume it forgot to activate us
 705     if (!device->IsActiveSource() && command.initiator == CECDEVICE_TV)
 706       device->ActivateSource();
 707   }
 708
 709   return COMMAND_HANDLED;
 710 }
 711
 712 int CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 713 {
 714   if (!m_processor->CECInitialised() ||
 715       !m_processor->IsHandledByLibCEC(command.destination))
 716     return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
 717
 718   CCECClient *client = m_processor->GetClient(command.destination);
 719   if (client)
 720     client->AddKey();
 721
 722   return COMMAND_HANDLED;
 723 }
 724
 725 int CCECCommandHandler::HandleVendorCommand(const cec_command & UNUSED(command))
 726 {
 727   return CEC_ABORT_REASON_INVALID_OPERAND;
 728 }
 729
 730 int CCECCommandHandler::HandleVendorRemoteButtonDown(const cec_command& command)
 731 {
 732   if (command.parameters.size == 0)
 733     return CEC_ABORT_REASON_INVALID_OPERAND;
 734
 735   LIB_CEC->AddLog(CEC_LOG_NOTICE, "unhandled vendor remote button received with keycode %x", command.parameters[0]);
 736   return COMMAND_HANDLED;
 737 }
 738
 739 void CCECCommandHandler::UnhandledCommand(const cec_command &command, const cec_abort_reason reason)
 740 {
 741   if (m_processor->IsHandledByLibCEC(command.destination))
 742   {
 743     LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending abort with opcode %02x and reason '%s' to %s", command.opcode, ToString(reason), ToString(command.initiator));
 744     m_processor->TransmitAbort(command.destination, command.initiator, command.opcode, reason);
 745   }
 746 }
 747
 748 size_t CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
 749 {
 750   size_t iReturn(0);
 751
 752   cec_logical_addresses addresses = m_processor->GetLogicalAddresses();
 753   for (uint8_t iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
 754   {
 755     if (addresses[iPtr])
 756     {
 757       devices.push_back(GetDevice((cec_logical_address) iPtr));
 758       ++iReturn;
 759     }
 760   }
 761
 762   return iReturn;
 763 }
 764
 765 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 766 {
 767   return m_processor->GetDevice(iLogicalAddress);
 768 }
 769
 770 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 771 {
 772   return m_processor->GetDeviceByPhysicalAddress(iPhysicalAddress);
 773 }
 774
 775 bool CCECCommandHandler::SetVendorId(const cec_command &command)
 776 {
 777   bool bChanged(false);
 778   if (command.parameters.size < 3)
 779   {
 780     LIB_CEC->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 781     return bChanged;
 782   }
 783
 784   uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
 785                        ((uint64_t)command.parameters[1] << 8) +
 786                         (uint64_t)command.parameters[2];
 787
 788   CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
 789   if (device)
 790     bChanged = device->SetVendorId(iVendorId);
 791   return bChanged;
 792 }
 793
 794 void CCECCommandHandler::SetPhysicalAddress(cec_logical_address iAddress, uint16_t iNewAddress)
 795 {
 796   if (!m_processor->IsHandledByLibCEC(iAddress))
 797   {
 798     CCECBusDevice *otherDevice = m_processor->GetDeviceByPhysicalAddress(iNewAddress);
 799     CCECClient *client = otherDevice ? otherDevice->GetClient() : NULL;
 800
 801     CCECBusDevice *device = m_processor->GetDevice(iAddress);
 802     if (device)
 803       device->SetPhysicalAddress(iNewAddress);
 804     else
 805     {
 806       LIB_CEC->AddLog(CEC_LOG_DEBUG, "device with logical address %X not found", iAddress);
 807     }
 808
 809     /* another device reported the same physical address as ours */
 810     if (client)
 811       client->ResetPhysicalAddress();
 812   }
 813   else
 814   {
 815     LIB_CEC->AddLog(CEC_LOG_DEBUG, "ignore physical address report for device %s (%X) because it's marked as handled by libCEC", ToString(iAddress), iAddress);
 816   }
 817 }
 818
 819 bool CCECCommandHandler::PowerOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 820 {
 821   if (iDestination == CECDEVICE_TV)
 822     return TransmitImageViewOn(iInitiator, iDestination);
 823
 824   return TransmitKeypress(iInitiator, iDestination, CEC_USER_CONTROL_CODE_POWER) &&
 825     TransmitKeyRelease(iInitiator, iDestination);
 826 }
 827
 828 bool CCECCommandHandler::TransmitImageViewOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 829 {
 830   cec_command command;
 831   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_IMAGE_VIEW_ON);
 832
 833   if (Transmit(command, false, false))
 834   {
 835     CCECBusDevice* dest = m_processor->GetDevice(iDestination);
 836     if (dest && dest->GetCurrentPowerStatus() != CEC_POWER_STATUS_ON)
 837       dest->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
 838     return true;
 839   }
 840   return false;
 841 }
 842
 843 bool CCECCommandHandler::TransmitStandby(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 844 {
 845   cec_command command;
 846   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_STANDBY);
 847
 848   return Transmit(command, false, false);
 849 }
 850
 851 bool CCECCommandHandler::TransmitRequestActiveSource(const cec_logical_address iInitiator, bool bWaitForResponse /* = true */)
 852 {
 853   cec_command command;
 854   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_REQUEST_ACTIVE_SOURCE);
 855
 856   return Transmit(command, !bWaitForResponse, false);
 857 }
 858
 859 bool CCECCommandHandler::TransmitRequestCecVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 860 {
 861   cec_command command;
 862   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_CEC_VERSION);
 863
 864   return Transmit(command, !bWaitForResponse, false);
 865 }
 866
 867 bool CCECCommandHandler::TransmitRequestMenuLanguage(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 868 {
 869   cec_command command;
 870   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_MENU_LANGUAGE);
 871
 872   return Transmit(command, !bWaitForResponse, false);
 873 }
 874
 875 bool CCECCommandHandler::TransmitRequestOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 876 {
 877   cec_command command;
 878   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_OSD_NAME);
 879
 880   return Transmit(command, !bWaitForResponse, false);
 881 }
 882
 883 bool CCECCommandHandler::TransmitRequestPhysicalAddress(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 884 {
 885   cec_command command;
 886   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_PHYSICAL_ADDRESS);
 887
 888   return Transmit(command, !bWaitForResponse, false);
 889 }
 890
 891 bool CCECCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 892 {
 893   if (iDestination == CECDEVICE_TV)
 894   {
 895     int64_t now(GetTimeMs());
 896     if (now - m_iPowerStatusRequested < REQUEST_POWER_STATUS_TIMEOUT)
 897       return true;
 898     m_iPowerStatusRequested = now;
 899   }
 900
 901   LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting power status of '%s' (%X)", m_busDevice->GetLogicalAddressName(), iDestination);
 902
 903   cec_command command;
 904   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
 905
 906   return Transmit(command, !bWaitForResponse, false);
 907 }
 908
 909 bool CCECCommandHandler::TransmitRequestVendorId(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 910 {
 911   cec_command command;
 912   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 913
 914   return Transmit(command, !bWaitForResponse, false);
 915 }
 916
 917 bool CCECCommandHandler::TransmitActiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress, bool bIsReply)
 918 {
 919   cec_command command;
 920   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
 921   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 922   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 923
 924   return Transmit(command, false, bIsReply);
 925 }
 926
 927 bool CCECCommandHandler::TransmitCECVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_version cecVersion, bool bIsReply)
 928 {
 929   cec_command command;
 930   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_CEC_VERSION);
 931   command.parameters.PushBack((uint8_t)cecVersion);
 932
 933   return Transmit(command, false, bIsReply);
 934 }
 935
 936 bool CCECCommandHandler::TransmitInactiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
 937 {
 938   cec_command command;
 939   cec_command::Format(command, iInitiator, CECDEVICE_TV, CEC_OPCODE_INACTIVE_SOURCE);
 940   command.parameters.PushBack((iPhysicalAddress >> 8) & 0xFF);
 941   command.parameters.PushBack(iPhysicalAddress & 0xFF);
 942
 943   return Transmit(command, false, false);
 944 }
 945
 946 bool CCECCommandHandler::TransmitMenuState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_menu_state menuState, bool bIsReply)
 947 {
 948   cec_command command;
 949   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_MENU_STATUS);
 950   command.parameters.PushBack((uint8_t)menuState);
 951
 952   return Transmit(command, false, bIsReply);
 953 }
 954
 955 bool CCECCommandHandler::TransmitOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, std::string strDeviceName, bool bIsReply)
 956 {
 957   cec_command command;
 958   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_NAME);
 959   for (size_t iPtr = 0; iPtr < strDeviceName.length(); iPtr++)
 960     command.parameters.PushBack(strDeviceName.at(iPtr));
 961
 962   return Transmit(command, false, bIsReply);
 963 }
 964
 965 bool CCECCommandHandler::TransmitOSDString(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_display_control duration, const char *strMessage, bool bIsReply)
 966 {
 967   cec_command command;
 968   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_STRING);
 969   command.parameters.PushBack((uint8_t)duration);
 970
 971   size_t iLen = strlen(strMessage);
 972   if (iLen > 13) iLen = 13;
 973
 974   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 975     command.parameters.PushBack(strMessage[iPtr]);
 976
 977   return Transmit(command, false, bIsReply);
 978 }
 979
 980 bool CCECCommandHandler::TransmitPhysicalAddress(const cec_logical_address iInitiator, uint16_t iPhysicalAddress, cec_device_type type, bool bIsReply)
 981 {
 982   cec_command command;
 983   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
 984   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 985   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 986   command.parameters.PushBack((uint8_t) (type));
 987
 988   return Transmit(command, false, bIsReply);
 989 }
 990
 991 bool CCECCommandHandler::TransmitSetMenuLanguage(const cec_logical_address iInitiator, const char lang[3], bool bIsReply)
 992 {
 993   cec_command command;
 994   command.Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_SET_MENU_LANGUAGE);
 995   command.parameters.PushBack((uint8_t) lang[0]);
 996   command.parameters.PushBack((uint8_t) lang[1]);
 997   command.parameters.PushBack((uint8_t) lang[2]);
 998
 999   return Transmit(command, false, bIsReply);
1000 }
1001
1002 bool CCECCommandHandler::TransmitPoll(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bIsReply)
1003 {
1004   cec_command command;
1005   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_NONE);
1006
1007   return Transmit(command, false, bIsReply);
1008 }
1009
1010 bool CCECCommandHandler::TransmitPowerState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_power_status state, bool bIsReply)
1011 {
1012   cec_command command;
1013   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_POWER_STATUS);
1014   command.parameters.PushBack((uint8_t) state);
1015
1016   return Transmit(command, false, bIsReply);
1017 }
1018
1019 bool CCECCommandHandler::TransmitVendorID(const cec_logical_address iInitiator, uint64_t iVendorId, bool bIsReply)
1020 {
1021   cec_command command;
1022   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_DEVICE_VENDOR_ID);
1023
1024   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 16) & 0xFF));
1025   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 8) & 0xFF));
1026   command.parameters.PushBack((uint8_t) ((uint64_t)iVendorId & 0xFF));
1027
1028   return Transmit(command, false, bIsReply);
1029 }
1030
1031 bool CCECCommandHandler::TransmitAudioStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, uint8_t state, bool bIsReply)
1032 {
1033   cec_command command;
1034   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_AUDIO_STATUS);
1035   command.parameters.PushBack(state);
1036
1037   return Transmit(command, false, bIsReply);
1038 }
1039
1040 bool CCECCommandHandler::TransmitSetSystemAudioMode(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state, bool bIsReply)
1041 {
1042   cec_command command;
1043   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_SYSTEM_AUDIO_MODE);
1044   command.parameters.PushBack((uint8_t)state);
1045
1046   return Transmit(command, false, bIsReply);
1047 }
1048
1049 bool CCECCommandHandler::TransmitSetStreamPath(uint16_t iStreamPath, bool bIsReply)
1050 {
1051   if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
1052   {
1053     LIB_CEC->AddLog(CEC_LOG_ERROR, "only the TV is allowed to send CEC_OPCODE_SET_STREAM_PATH");
1054     return false;
1055   }
1056   cec_command command;
1057   cec_command::Format(command, m_busDevice->GetLogicalAddress(), CECDEVICE_BROADCAST, CEC_OPCODE_SET_STREAM_PATH);
1058   command.parameters.PushBack((uint8_t) ((iStreamPath >> 8) & 0xFF));
1059   command.parameters.PushBack((uint8_t) (iStreamPath        & 0xFF));
1060
1061   return Transmit(command, false, bIsReply);
1062 }
1063
1064 bool CCECCommandHandler::TransmitSystemAudioModeStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state, bool bIsReply)
1065 {
1066   cec_command command;
1067   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS);
1068   command.parameters.PushBack((uint8_t)state);
1069
1070   return Transmit(command, false, bIsReply);
1071 }
1072
1073 bool CCECCommandHandler::TransmitDeckStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_deck_info state, bool bIsReply)
1074 {
1075   cec_command command;
1076   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_DECK_STATUS);
1077   command.PushBack((uint8_t)state);
1078
1079   return Transmit(command, false, bIsReply);
1080 }
1081
1082 bool CCECCommandHandler::TransmitKeypress(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
1083 {
1084   cec_command command;
1085   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_PRESSED);
1086   command.parameters.PushBack((uint8_t)key);
1087
1088   return Transmit(command, !bWait, false);
1089 }
1090
1091 bool CCECCommandHandler::TransmitKeyRelease(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWait /* = true */)
1092 {
1093   cec_command command;
1094   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_RELEASE);
1095
1096   return Transmit(command, !bWait, false);
1097 }
1098
1099 bool CCECCommandHandler::Transmit(cec_command &command, bool bSuppressWait, bool bIsReply)
1100 {
1101   bool bReturn(false);
1102   cec_opcode expectedResponse(cec_command::GetResponseOpcode(command.opcode));
1103   bool bExpectResponse(expectedResponse != CEC_OPCODE_NONE && !bSuppressWait);
1104   command.transmit_timeout = m_iTransmitTimeout;
1105
1106   if (command.initiator == CECDEVICE_UNKNOWN)
1107   {
1108     LIB_CEC->AddLog(CEC_LOG_ERROR, "not transmitting a command without a valid initiator");
1109     return bReturn;
1110   }
1111
1112   // check whether the destination is not marked as not present or handled by libCEC
1113   if (command.destination != CECDEVICE_BROADCAST && command.opcode_set)
1114   {
1115     CCECBusDevice* destinationDevice = m_processor->GetDevice(command.destination);
1116     cec_bus_device_status status = destinationDevice ? destinationDevice->GetStatus() : CEC_DEVICE_STATUS_NOT_PRESENT;
1117     if (status == CEC_DEVICE_STATUS_NOT_PRESENT)
1118     {
1119       LIB_CEC->AddLog(CEC_LOG_DEBUG, "not sending command '%s': destination device '%s' marked as not present", ToString(command.opcode),ToString(command.destination));
1120       return bReturn;
1121     }
1122     else if (status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
1123     {
1124       LIB_CEC->AddLog(CEC_LOG_DEBUG, "not sending command '%s': destination device '%s' marked as handled by libCEC", ToString(command.opcode),ToString(command.destination));
1125       return bReturn;
1126     }
1127   }
1128
1129   {
1130     uint8_t iTries(0), iMaxTries(!command.opcode_set ? 1 : m_iTransmitRetries + 1);
1131     while (!bReturn && ++iTries <= iMaxTries && !m_busDevice->IsUnsupportedFeature(command.opcode))
1132     {
1133       if ((bReturn = m_processor->Transmit(command, bIsReply)) == true)
1134       {
1135 #ifdef CEC_DEBUGGING
1136         LIB_CEC->AddLog(CEC_LOG_DEBUG, "command transmitted");
1137 #endif
1138         if (bExpectResponse)
1139         {
1140           bReturn = m_busDevice->WaitForOpcode(expectedResponse);
1141           LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? "expected response received (%X: %s)" : "expected response not received (%X: %s)", (int)expectedResponse, ToString(expectedResponse));
1142         }
1143       }
1144     }
1145   }
1146
1147   return bReturn;
1148 }
1149
1150 bool CCECCommandHandler::ActivateSource(bool bTransmitDelayedCommandsOnly /* = false */)
1151 {
1152   if (m_busDevice->IsActiveSource() &&
1153       m_busDevice->IsHandledByLibCEC())
1154   {
1155     {
1156       CLockObject lock(m_mutex);
1157       // check if we need to send a delayed source switch
1158       if (bTransmitDelayedCommandsOnly)
1159       {
1160         if (m_iActiveSourcePending == 0 || GetTimeMs() < m_iActiveSourcePending)
1161           return false;
1162
1163 #ifdef CEC_DEBUGGING
1164         LIB_CEC->AddLog(CEC_LOG_DEBUG, "transmitting delayed activate source command");
1165 #endif
1166       }
1167     }
1168
1169     // update the power state and menu state
1170     if (!bTransmitDelayedCommandsOnly)
1171     {
1172       m_busDevice->SetPowerStatus(CEC_POWER_STATUS_ON);
1173       m_busDevice->SetMenuState(CEC_MENU_STATE_ACTIVATED);
1174     }
1175
1176     // vendor specific hook
1177     VendorPreActivateSourceHook();
1178
1179     // power on the TV
1180     CCECBusDevice* tv = m_processor->GetDevice(CECDEVICE_TV);
1181     bool bTvPresent = (tv && tv->GetStatus() == CEC_DEVICE_STATUS_PRESENT);
1182     bool bActiveSourceFailed(false);
1183     if (bTvPresent)
1184     {
1185       if (tv->GetCurrentPowerStatus() != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1186         bActiveSourceFailed = !m_busDevice->TransmitImageViewOn();
1187     }
1188     else
1189       LIB_CEC->AddLog(CEC_LOG_DEBUG, "TV not present, not sending 'image view on'");
1190
1191     // check if we're allowed to switch sources
1192     bool bSourceSwitchAllowed = SourceSwitchAllowed();
1193     if (!bSourceSwitchAllowed)
1194       LIB_CEC->AddLog(CEC_LOG_DEBUG, "source switch is currently not allowed by command handler");
1195
1196     // switch sources (if allowed)
1197     if (!bActiveSourceFailed && bSourceSwitchAllowed)
1198     {
1199       bActiveSourceFailed = !m_busDevice->TransmitActiveSource(false);
1200       if (bTvPresent && !bActiveSourceFailed)
1201         bActiveSourceFailed = !m_busDevice->TransmitMenuState(CECDEVICE_TV, false);
1202
1203       // update the deck status for playback devices
1204       if (bTvPresent && !bActiveSourceFailed)
1205       {
1206         CCECPlaybackDevice *playbackDevice = m_busDevice->AsPlaybackDevice();
1207         if (playbackDevice && SendDeckStatusUpdateOnActiveSource())
1208           bActiveSourceFailed = !playbackDevice->TransmitDeckStatus(CECDEVICE_TV, false);
1209       }
1210     }
1211
1212     // retry later
1213     if (bActiveSourceFailed || !bSourceSwitchAllowed)
1214     {
1215       LIB_CEC->AddLog(CEC_LOG_DEBUG, "failed to make '%s' the active source. will retry later", m_busDevice->GetLogicalAddressName());
1216       int64_t now(GetTimeMs());
1217       CLockObject lock(m_mutex);
1218       if (m_iActiveSourcePending == 0 || m_iActiveSourcePending < now)
1219         m_iActiveSourcePending = now + (int64_t)CEC_ACTIVE_SOURCE_SWITCH_RETRY_TIME_MS;
1220       return false;
1221     }
1222     else
1223     {
1224       CLockObject lock(m_mutex);
1225       // clear previous pending active source command
1226       m_iActiveSourcePending = 0;
1227     }
1228
1229     // mark the handler as initialised
1230     CLockObject lock(m_mutex);
1231     m_bHandlerInited = true;
1232   }
1233   return true;
1234 }
1235
1236 void CCECCommandHandler::ScheduleActivateSource(uint64_t iDelay)
1237 {
1238   CLockObject lock(m_mutex);
1239   m_iActiveSourcePending = GetTimeMs() + iDelay;
1240 }