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 "CECCommandHandler.h"
  34 #include "../devices/CECBusDevice.h"
  35 #include "../devices/CECAudioSystem.h"
  36 #include "../devices/CECPlaybackDevice.h"
  37 #include "../CECProcessor.h"
  38 #include "../LibCEC.h"
  39
  40 using namespace CEC;
  41 using namespace std;
  42 using namespace PLATFORM;
  43
  44 CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice) :
  45     m_busDevice(busDevice),
  46     m_processor(m_busDevice->GetProcessor()),
  47     m_iTransmitTimeout(CEC_DEFAULT_TRANSMIT_TIMEOUT),
  48     m_iTransmitWait(CEC_DEFAULT_TRANSMIT_WAIT),
  49     m_iTransmitRetries(CEC_DEFAULT_TRANSMIT_RETRIES),
  50     m_bHandlerInited(false),
  51     m_bOPTSendDeckStatusUpdateOnActiveSource(false),
  52     m_vendorId(CEC_VENDOR_UNKNOWN),
  53     m_waitForResponse(new CWaitForResponse)
  54 {
  55 }
  56
  57 CCECCommandHandler::~CCECCommandHandler(void)
  58 {
  59   delete m_waitForResponse;
  60 }
  61
  62 bool CCECCommandHandler::HandleCommand(const cec_command &command)
  63 {
  64   if (command.opcode_set == 0)
  65     return HandlePoll(command);
  66
  67   bool bHandled(true);
  68
  69   CLibCEC::AddCommand(command);
  70
  71   switch(command.opcode)
  72   {
  73   case CEC_OPCODE_REPORT_POWER_STATUS:
  74     HandleReportPowerStatus(command);
  75     break;
  76   case CEC_OPCODE_CEC_VERSION:
  77     HandleDeviceCecVersion(command);
  78     break;
  79   case CEC_OPCODE_SET_MENU_LANGUAGE:
  80     HandleSetMenuLanguage(command);
  81     break;
  82   case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
  83     if (m_processor->IsInitialised())
  84       HandleGivePhysicalAddress(command);
  85     break;
  86   case CEC_OPCODE_GET_MENU_LANGUAGE:
  87     if (m_processor->IsInitialised())
  88       HandleGiveMenuLanguage(command);
  89     break;
  90   case CEC_OPCODE_GIVE_OSD_NAME:
  91     if (m_processor->IsInitialised())
  92       HandleGiveOSDName(command);
  93     break;
  94   case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
  95     if (m_processor->IsInitialised())
  96       HandleGiveDeviceVendorId(command);
  97     break;
  98   case CEC_OPCODE_DEVICE_VENDOR_ID:
  99     HandleDeviceVendorId(command);
 100     break;
 101   case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
 102     HandleDeviceVendorCommandWithId(command);
 103     break;
 104   case CEC_OPCODE_GIVE_DECK_STATUS:
 105     if (m_processor->IsInitialised())
 106       HandleGiveDeckStatus(command);
 107     break;
 108   case CEC_OPCODE_DECK_CONTROL:
 109     HandleDeckControl(command);
 110     break;
 111   case CEC_OPCODE_MENU_REQUEST:
 112     if (m_processor->IsInitialised())
 113       HandleMenuRequest(command);
 114     break;
 115   case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
 116     if (m_processor->IsInitialised())
 117       HandleGiveDevicePowerStatus(command);
 118     break;
 119   case CEC_OPCODE_GET_CEC_VERSION:
 120     if (m_processor->IsInitialised())
 121       HandleGetCecVersion(command);
 122     break;
 123   case CEC_OPCODE_USER_CONTROL_PRESSED:
 124     if (m_processor->IsInitialised())
 125       HandleUserControlPressed(command);
 126     break;
 127   case CEC_OPCODE_USER_CONTROL_RELEASE:
 128     if (m_processor->IsInitialised())
 129       HandleUserControlRelease(command);
 130     break;
 131   case CEC_OPCODE_GIVE_AUDIO_STATUS:
 132     if (m_processor->IsInitialised())
 133       HandleGiveAudioStatus(command);
 134     break;
 135   case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
 136     if (m_processor->IsInitialised())
 137       HandleGiveSystemAudioModeStatus(command);
 138     break;
 139   case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
 140     if (m_processor->IsInitialised())
 141       HandleSystemAudioModeRequest(command);
 142     break;
 143   case CEC_OPCODE_REPORT_AUDIO_STATUS:
 144     HandleReportAudioStatus(command);
 145     break;
 146   case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
 147     HandleSystemAudioModeStatus(command);
 148     break;
 149   case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
 150     HandleSetSystemAudioMode(command);
 151     break;
 152   case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 153     if (m_processor->IsInitialised())
 154       HandleRequestActiveSource(command);
 155     break;
 156   case CEC_OPCODE_SET_STREAM_PATH:
 157     HandleSetStreamPath(command);
 158     break;
 159   case CEC_OPCODE_ROUTING_CHANGE:
 160     HandleRoutingChange(command);
 161     break;
 162   case CEC_OPCODE_ROUTING_INFORMATION:
 163     HandleRoutingInformation(command);
 164     break;
 165   case CEC_OPCODE_STANDBY:
 166     if (m_processor->IsInitialised())
 167       HandleStandby(command);
 168     break;
 169   case CEC_OPCODE_ACTIVE_SOURCE:
 170     HandleActiveSource(command);
 171     break;
 172   case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
 173     HandleReportPhysicalAddress(command);
 174     break;
 175   case CEC_OPCODE_SET_OSD_NAME:
 176     HandleSetOSDName(command);
 177     break;
 178   case CEC_OPCODE_IMAGE_VIEW_ON:
 179     HandleImageViewOn(command);
 180     break;
 181   case CEC_OPCODE_TEXT_VIEW_ON:
 182     HandleTextViewOn(command);
 183     break;
 184   case CEC_OPCODE_FEATURE_ABORT:
 185     HandleFeatureAbort(command);
 186     break;
 187   case CEC_OPCODE_VENDOR_COMMAND:
 188     HandleVendorCommand(command);
 189     break;
 190   default:
 191     UnhandledCommand(command);
 192     bHandled = false;
 193     break;
 194   }
 195
 196   if (bHandled)
 197     m_waitForResponse->Received((command.opcode == CEC_OPCODE_FEATURE_ABORT && command.parameters.size > 0) ? (cec_opcode)command.parameters[0] : command.opcode);
 198
 199   return bHandled;
 200 }
 201
 202 bool CCECCommandHandler::HandleActiveSource(const cec_command &command)
 203 {
 204   if (command.parameters.size == 2)
 205   {
 206     uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 207     return m_processor->SetActiveSource(iAddress);
 208   }
 209
 210   return true;
 211 }
 212
 213 bool CCECCommandHandler::HandleDeckControl(const cec_command &command)
 214 {
 215   CCECBusDevice *device = GetDevice(command.destination);
 216   if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) && command.parameters.size > 0)
 217   {
 218     ((CCECPlaybackDevice *) device)->SetDeckControlMode((cec_deck_control_mode) command.parameters[0]);
 219     return true;
 220   }
 221
 222   return false;
 223 }
 224
 225 bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
 226 {
 227   if (command.parameters.size == 1)
 228   {
 229     CCECBusDevice *device = GetDevice(command.initiator);
 230     if (device)
 231       device->SetCecVersion((cec_version) command.parameters[0]);
 232   }
 233
 234   return true;
 235 }
 236
 237 bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
 238 {
 239   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 240     m_processor->TransmitAbort(command.initiator, command.opcode, CEC_ABORT_REASON_REFUSED);
 241
 242   return true;
 243 }
 244
 245 bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
 246 {
 247   return SetVendorId(command);
 248 }
 249
 250 bool CCECCommandHandler::HandleFeatureAbort(const cec_command &command)
 251 {
 252   if (command.parameters.size == 2 &&
 253         (command.parameters[1] == CEC_ABORT_REASON_UNRECOGNIZED_OPCODE ||
 254          command.parameters[1] == CEC_ABORT_REASON_REFUSED))
 255     m_processor->m_busDevices[command.initiator]->SetUnsupportedFeature((cec_opcode)command.parameters[0]);
 256   return true;
 257 }
 258
 259 bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
 260 {
 261   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 262   {
 263     CCECBusDevice *device = GetDevice(command.destination);
 264     if (device)
 265       return device->TransmitCECVersion(command.initiator);
 266   }
 267
 268   return false;
 269 }
 270
 271 bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
 272 {
 273   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 274   {
 275     CCECBusDevice *device = GetDevice(command.destination);
 276     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 277       return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
 278   }
 279
 280   return false;
 281 }
 282
 283 bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
 284 {
 285   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 286   {
 287     CCECBusDevice *device = GetDevice(command.destination);
 288     if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
 289       return ((CCECPlaybackDevice *) device)->TransmitDeckStatus(command.initiator);
 290   }
 291
 292   return false;
 293 }
 294
 295 bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
 296 {
 297   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 298   {
 299     CCECBusDevice *device = GetDevice(command.destination);
 300     if (device)
 301       return device->TransmitPowerState(command.initiator);
 302   }
 303
 304   return false;
 305 }
 306
 307 bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
 308 {
 309   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 310   {
 311     CCECBusDevice *device = GetDevice(command.destination);
 312     if (device)
 313       return device->TransmitVendorID(command.initiator);
 314   }
 315
 316   return false;
 317 }
 318
 319 bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
 320 {
 321   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 322   {
 323     CCECBusDevice *device = GetDevice(command.destination);
 324     if (device)
 325       return device->TransmitOSDName(command.initiator);
 326   }
 327
 328   return false;
 329 }
 330
 331 bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
 332 {
 333   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 334   {
 335     CCECBusDevice *device = GetDevice(command.destination);
 336     if (device)
 337     {
 338       device->SetActiveSource();
 339       return device->TransmitPhysicalAddress() &&
 340           device->TransmitImageViewOn() &&
 341           device->TransmitActiveSource();
 342     }
 343   }
 344
 345   return false;
 346 }
 347
 348 bool CCECCommandHandler::HandleGiveMenuLanguage(const cec_command &command)
 349 {
 350   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 351   {
 352     CCECBusDevice *device = GetDevice(command.destination);
 353     if (device)
 354       return device->TransmitSetMenuLanguage(command.initiator);
 355   }
 356
 357   return false;
 358 }
 359
 360 bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
 361 {
 362   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 363   {
 364     CCECBusDevice *device = GetDevice(command.destination);
 365     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 366       return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
 367   }
 368
 369   return false;
 370 }
 371
 372 bool CCECCommandHandler::HandleImageViewOn(const cec_command &command)
 373 {
 374   m_processor->m_busDevices[command.initiator]->SetActiveSource();
 375   return true;
 376 }
 377
 378 bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 379 {
 380   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 381   {
 382     if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
 383     {
 384       CCECBusDevice *device = GetDevice(command.destination);
 385       if (device)
 386         return device->TransmitMenuState(command.initiator);
 387     }
 388   }
 389
 390   return false;
 391 }
 392
 393 bool CCECCommandHandler::HandlePoll(const cec_command &command)
 394 {
 395   m_busDevice->HandlePoll(command.destination);
 396   return true;
 397 }
 398
 399 bool CCECCommandHandler::HandleReportAudioStatus(const cec_command &command)
 400 {
 401   if (command.parameters.size == 1)
 402   {
 403     CCECBusDevice *device = GetDevice(command.initiator);
 404     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 405     {
 406       ((CCECAudioSystem *)device)->SetAudioStatus(command.parameters[0]);
 407       return true;
 408     }
 409   }
 410   return false;
 411 }
 412
 413 bool CCECCommandHandler::HandleReportPhysicalAddress(const cec_command &command)
 414 {
 415   if (command.parameters.size == 3)
 416   {
 417     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 418     SetPhysicalAddress(command.initiator, iNewAddress);
 419   }
 420   return true;
 421 }
 422
 423 bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 424 {
 425   if (command.parameters.size == 1)
 426   {
 427     CCECBusDevice *device = GetDevice(command.initiator);
 428     if (device)
 429       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 430   }
 431   return true;
 432 }
 433
 434 bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 435 {
 436   if (m_processor->IsRunning())
 437   {
 438     CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %i requests active source", (uint8_t) command.initiator);
 439
 440     vector<CCECBusDevice *> devices;
 441     for (size_t iDevicePtr = 0; iDevicePtr < GetMyDevices(devices); iDevicePtr++)
 442       devices[iDevicePtr]->TransmitActiveSource();
 443
 444     return true;
 445   }
 446   return false;
 447 }
 448
 449 bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 450 {
 451   if (command.parameters.size == 4)
 452   {
 453     uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 454     uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 455
 456     CCECBusDevice *device = GetDevice(command.initiator);
 457     if (device)
 458       device->SetStreamPath(iNewAddress, iOldAddress);
 459   }
 460   return true;
 461 }
 462
 463 bool CCECCommandHandler::HandleRoutingInformation(const cec_command &command)
 464 {
 465   if (command.parameters.size == 2)
 466   {
 467     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 468     m_processor->SetActiveSource(iNewAddress);
 469   }
 470
 471   return false;
 472 }
 473
 474 bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 475 {
 476   if (command.parameters.size == 3)
 477   {
 478     CCECBusDevice *device = GetDevice(command.initiator);
 479     if (device)
 480     {
 481       cec_menu_language language;
 482       language.device = command.initiator;
 483       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 484         language.language[iPtr] = command.parameters[iPtr];
 485       language.language[3] = 0;
 486       device->SetMenuLanguage(language);
 487       return true;
 488     }
 489   }
 490   return false;
 491 }
 492
 493 bool CCECCommandHandler::HandleSetOSDName(const cec_command &command)
 494 {
 495   if (command.parameters.size > 0)
 496   {
 497     CCECBusDevice *device = GetDevice(command.initiator);
 498     if (device)
 499     {
 500       char buf[1024];
 501       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 502         buf[iPtr] = (char)command.parameters[iPtr];
 503       buf[command.parameters.size] = 0;
 504
 505       CStdString strName(buf);
 506       device->SetOSDName(strName);
 507
 508       return true;
 509     }
 510   }
 511   return false;
 512 }
 513
 514 bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 515 {
 516   if (m_processor->IsRunning() && command.parameters.size >= 2)
 517   {
 518     uint16_t iStreamAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 519     CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %i sets stream path to physical address %04x", command.initiator, iStreamAddress);
 520
 521     /* one of the device handled by libCEC has been made active */
 522     CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamAddress);
 523     if (device && m_busDevice->MyLogicalAddressContains(device->GetLogicalAddress()))
 524     {
 525       device->SetActiveSource();
 526       device->TransmitImageViewOn();
 527       device->TransmitActiveSource();
 528
 529       device->SetMenuState(CEC_MENU_STATE_ACTIVATED);
 530       device->TransmitMenuState(command.initiator);
 531     }
 532   }
 533   return false;
 534 }
 535
 536 bool CCECCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
 537 {
 538   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 539   {
 540     CCECBusDevice *device = GetDevice(command.destination);
 541     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 542     {
 543       if (command.parameters.size >= 2)
 544       {
 545         device->SetPowerStatus(CEC_POWER_STATUS_ON);
 546         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_ON);
 547         uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 548         CCECBusDevice *newActiveDevice = GetDeviceByPhysicalAddress(iNewAddress);
 549         if (newActiveDevice)
 550           newActiveDevice->SetActiveSource();
 551         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 552       }
 553       else
 554       {
 555         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_OFF);
 556         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 557       }
 558     }
 559   }
 560   return false;
 561 }
 562
 563 bool CCECCommandHandler::HandleStandby(const cec_command &command)
 564 {
 565   CCECBusDevice *device = GetDevice(command.initiator);
 566   if (device)
 567     device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 568
 569   return true;
 570 }
 571
 572 bool CCECCommandHandler::HandleSystemAudioModeStatus(const cec_command &command)
 573 {
 574   if (command.parameters.size == 1)
 575   {
 576     CCECBusDevice *device = GetDevice(command.initiator);
 577     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 578     {
 579       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 580       return true;
 581     }
 582   }
 583
 584   return false;
 585 }
 586
 587 bool CCECCommandHandler::HandleSetSystemAudioMode(const cec_command &command)
 588 {
 589   if (command.parameters.size == 1)
 590   {
 591     CCECBusDevice *device = GetDevice(command.initiator);
 592     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 593     {
 594       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 595       return true;
 596     }
 597   }
 598
 599   return false;
 600 }
 601
 602 bool CCECCommandHandler::HandleTextViewOn(const cec_command &command)
 603 {
 604   m_processor->m_busDevices[command.initiator]->SetActiveSource();
 605   return true;
 606 }
 607
 608 bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 609 {
 610   if (m_processor->IsRunning() &&
 611       m_busDevice->MyLogicalAddressContains(command.destination) &&
 612       command.parameters.size > 0)
 613   {
 614     CLibCEC::AddKey();
 615     if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
 616       CLibCEC::SetCurrentButton((cec_user_control_code) command.parameters[0]);
 617
 618     if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
 619         command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION)
 620     {
 621       bool bPowerOn(true);
 622       CCECBusDevice *device = GetDevice(command.destination);
 623       if (!device)
 624         return true;
 625
 626       // CEC_USER_CONTROL_CODE_POWER operates as a toggle
 627       // assume CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION does not
 628       if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER)
 629       {
 630         cec_power_status status = device->GetPowerStatus();
 631         bPowerOn = !(status == CEC_POWER_STATUS_ON || status == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
 632       }
 633
 634       if (bPowerOn)
 635       {
 636         device->SetActiveSource();
 637         device->TransmitImageViewOn();
 638         device->TransmitActiveSource();
 639
 640         if (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
 641             device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
 642           ((CCECPlaybackDevice *)device)->TransmitDeckStatus(command.initiator);
 643       }
 644       else
 645       {
 646         device->SetInactiveSource();
 647         device->TransmitInactiveSource();
 648         device->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
 649       }
 650     }
 651
 652     return true;
 653   }
 654   return false;
 655 }
 656
 657 bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 658 {
 659   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 660     CLibCEC::AddKey();
 661
 662   return true;
 663 }
 664
 665 bool CCECCommandHandler::HandleVendorCommand(const cec_command & UNUSED(command))
 666 {
 667   return true;
 668 }
 669
 670 void CCECCommandHandler::UnhandledCommand(const cec_command &command)
 671 {
 672   CLibCEC::AddLog(CEC_LOG_DEBUG, "unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
 673 }
 674
 675 size_t CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
 676 {
 677   size_t iReturn(0);
 678
 679   cec_logical_addresses addresses = m_processor->GetLogicalAddresses();
 680   for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
 681   {
 682     if (addresses[iPtr])
 683     {
 684       devices.push_back(GetDevice((cec_logical_address) iPtr));
 685       ++iReturn;
 686     }
 687   }
 688
 689   return iReturn;
 690 }
 691
 692 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 693 {
 694   CCECBusDevice *device = NULL;
 695
 696   if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
 697     device = m_processor->m_busDevices[iLogicalAddress];
 698
 699   return device;
 700 }
 701
 702 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 703 {
 704   return m_processor->GetDeviceByPhysicalAddress(iPhysicalAddress);
 705 }
 706
 707 CCECBusDevice *CCECCommandHandler::GetDeviceByType(cec_device_type type) const
 708 {
 709   return m_processor->GetDeviceByType(type);
 710 }
 711
 712 bool CCECCommandHandler::SetVendorId(const cec_command &command)
 713 {
 714   bool bChanged(false);
 715   if (command.parameters.size < 3)
 716   {
 717     CLibCEC::AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 718     return bChanged;
 719   }
 720
 721   uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
 722                        ((uint64_t)command.parameters[1] << 8) +
 723                         (uint64_t)command.parameters[2];
 724
 725   CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
 726   if (device)
 727     bChanged = device->SetVendorId(iVendorId);
 728   return bChanged;
 729 }
 730
 731 void CCECCommandHandler::SetPhysicalAddress(cec_logical_address iAddress, uint16_t iNewAddress)
 732 {
 733   if (!m_busDevice->MyLogicalAddressContains(iAddress))
 734   {
 735     bool bOurAddress(m_processor->GetPhysicalAddress() == iNewAddress);
 736     GetDevice(iAddress)->SetPhysicalAddress(iNewAddress);
 737     if (bOurAddress)
 738     {
 739       /* another device reported the same physical address as ours
 740        * since we don't have physical address detection yet, we'll just use the
 741        * given address, increased by 0x100 for now */
 742       m_processor->SetPhysicalAddress(iNewAddress + 0x100);
 743     }
 744   }
 745 }
 746
 747 bool CCECCommandHandler::PowerOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 748 {
 749   if (iDestination == CECDEVICE_TV)
 750     return TransmitImageViewOn(iInitiator, iDestination);
 751
 752   return TransmitKeypress(iInitiator, iDestination, CEC_USER_CONTROL_CODE_POWER) &&
 753     TransmitKeyRelease(iInitiator, iDestination);
 754 }
 755
 756 bool CCECCommandHandler::TransmitImageViewOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 757 {
 758   cec_command command;
 759   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_IMAGE_VIEW_ON);
 760
 761   return Transmit(command, false);
 762 }
 763
 764 bool CCECCommandHandler::TransmitStandby(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 765 {
 766   cec_command command;
 767   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_STANDBY);
 768
 769   return Transmit(command, false);
 770 }
 771
 772 bool CCECCommandHandler::TransmitRequestCecVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 773 {
 774   cec_command command;
 775   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_CEC_VERSION);
 776
 777   return Transmit(command, bWaitForResponse, CEC_OPCODE_CEC_VERSION);
 778 }
 779
 780 bool CCECCommandHandler::TransmitRequestMenuLanguage(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 781 {
 782   cec_command command;
 783   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_MENU_LANGUAGE);
 784
 785   return Transmit(command, bWaitForResponse, CEC_OPCODE_SET_MENU_LANGUAGE);
 786 }
 787
 788 bool CCECCommandHandler::TransmitRequestOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 789 {
 790   cec_command command;
 791   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_OSD_NAME);
 792
 793   return Transmit(command, bWaitForResponse, CEC_OPCODE_SET_OSD_NAME);
 794 }
 795
 796 bool CCECCommandHandler::TransmitRequestPhysicalAddress(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 797 {
 798   cec_command command;
 799   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_PHYSICAL_ADDRESS);
 800
 801   return Transmit(command, bWaitForResponse, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
 802 }
 803
 804 bool CCECCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 805 {
 806   cec_command command;
 807   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
 808
 809   return Transmit(command, bWaitForResponse, CEC_OPCODE_REPORT_POWER_STATUS);
 810 }
 811
 812 bool CCECCommandHandler::TransmitRequestVendorId(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 813 {
 814   cec_command command;
 815   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 816
 817   return Transmit(command, bWaitForResponse, CEC_OPCODE_DEVICE_VENDOR_ID);
 818 }
 819
 820 bool CCECCommandHandler::TransmitActiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
 821 {
 822   cec_command command;
 823   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
 824   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 825   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 826
 827   return Transmit(command, false);
 828 }
 829
 830 bool CCECCommandHandler::TransmitCECVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_version cecVersion)
 831 {
 832   cec_command command;
 833   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_CEC_VERSION);
 834   command.parameters.PushBack((uint8_t)cecVersion);
 835
 836   return Transmit(command, false);
 837 }
 838
 839 bool CCECCommandHandler::TransmitInactiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
 840 {
 841   cec_command command;
 842   cec_command::Format(command, iInitiator, CECDEVICE_TV, CEC_OPCODE_INACTIVE_SOURCE);
 843   command.parameters.PushBack((iPhysicalAddress >> 8) & 0xFF);
 844   command.parameters.PushBack(iPhysicalAddress & 0xFF);
 845
 846   return Transmit(command, false);
 847 }
 848
 849 bool CCECCommandHandler::TransmitMenuState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_menu_state menuState)
 850 {
 851   cec_command command;
 852   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_MENU_STATUS);
 853   command.parameters.PushBack((uint8_t)menuState);
 854
 855   return Transmit(command, false);
 856 }
 857
 858 bool CCECCommandHandler::TransmitOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, CStdString strDeviceName)
 859 {
 860   cec_command command;
 861   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_NAME);
 862   for (size_t iPtr = 0; iPtr < strDeviceName.length(); iPtr++)
 863     command.parameters.PushBack(strDeviceName.at(iPtr));
 864
 865   return Transmit(command, false);
 866 }
 867
 868 bool CCECCommandHandler::TransmitOSDString(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_display_control duration, const char *strMessage)
 869 {
 870   cec_command command;
 871   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_STRING);
 872   command.parameters.PushBack((uint8_t)duration);
 873
 874   size_t iLen = strlen(strMessage);
 875   if (iLen > 13) iLen = 13;
 876
 877   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 878     command.parameters.PushBack(strMessage[iPtr]);
 879
 880   return Transmit(command, false);
 881 }
 882
 883 bool CCECCommandHandler::TransmitPhysicalAddress(const cec_logical_address iInitiator, uint16_t iPhysicalAddress, cec_device_type type)
 884 {
 885   cec_command command;
 886   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
 887   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 888   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 889   command.parameters.PushBack((uint8_t) (type));
 890
 891   return Transmit(command, false);
 892 }
 893
 894 bool CCECCommandHandler::TransmitSetMenuLanguage(const cec_logical_address iInitiator, const char lang[3])
 895 {
 896   cec_command command;
 897   command.Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_SET_MENU_LANGUAGE);
 898   command.parameters.PushBack((uint8_t) lang[0]);
 899   command.parameters.PushBack((uint8_t) lang[1]);
 900   command.parameters.PushBack((uint8_t) lang[2]);
 901
 902   return Transmit(command, false);
 903 }
 904
 905 bool CCECCommandHandler::TransmitPoll(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 906 {
 907   cec_command command;
 908   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_NONE);
 909
 910   return Transmit(command, false);
 911 }
 912
 913 bool CCECCommandHandler::TransmitPowerState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_power_status state)
 914 {
 915   cec_command command;
 916   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_POWER_STATUS);
 917   command.parameters.PushBack((uint8_t) state);
 918
 919   return Transmit(command, false);
 920 }
 921
 922 bool CCECCommandHandler::TransmitVendorID(const cec_logical_address iInitiator, uint64_t iVendorId)
 923 {
 924   cec_command command;
 925   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_DEVICE_VENDOR_ID);
 926
 927   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 16) & 0xFF));
 928   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 8) & 0xFF));
 929   command.parameters.PushBack((uint8_t) ((uint64_t)iVendorId & 0xFF));
 930
 931   return Transmit(command, false);
 932 }
 933
 934 bool CCECCommandHandler::TransmitAudioStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, uint8_t state)
 935 {
 936   cec_command command;
 937   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_AUDIO_STATUS);
 938   command.parameters.PushBack(state);
 939
 940   return Transmit(command, false);
 941 }
 942
 943 bool CCECCommandHandler::TransmitSetSystemAudioMode(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state)
 944 {
 945   cec_command command;
 946   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_SYSTEM_AUDIO_MODE);
 947   command.parameters.PushBack((uint8_t)state);
 948
 949   return Transmit(command, false);
 950 }
 951
 952 bool CCECCommandHandler::TransmitSetStreamPath(uint16_t iStreamPath)
 953 {
 954   cec_command command;
 955   cec_command::Format(command, m_busDevice->GetLogicalAddress(), CECDEVICE_BROADCAST, CEC_OPCODE_SET_STREAM_PATH);
 956   command.parameters.PushBack((uint8_t) ((iStreamPath >> 8) & 0xFF));
 957   command.parameters.PushBack((uint8_t) (iStreamPath        & 0xFF));
 958
 959   return Transmit(command, false);
 960 }
 961
 962 bool CCECCommandHandler::TransmitSystemAudioModeStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state)
 963 {
 964   cec_command command;
 965   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS);
 966   command.parameters.PushBack((uint8_t)state);
 967
 968   return Transmit(command, false);
 969 }
 970
 971 bool CCECCommandHandler::TransmitDeckStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_deck_info state)
 972 {
 973   cec_command command;
 974   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_DECK_STATUS);
 975   command.PushBack((uint8_t)state);
 976
 977   return Transmit(command, false);
 978 }
 979
 980 bool CCECCommandHandler::TransmitKeypress(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
 981 {
 982   cec_command command;
 983   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_PRESSED);
 984   command.parameters.PushBack((uint8_t)key);
 985
 986   return Transmit(command, bWait);
 987 }
 988
 989 bool CCECCommandHandler::TransmitKeyRelease(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWait /* = true */)
 990 {
 991   cec_command command;
 992   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_RELEASE);
 993
 994   return Transmit(command, bWait);
 995 }
 996
 997 bool CCECCommandHandler::Transmit(cec_command &command, bool bExpectResponse /* = true */, cec_opcode expectedResponse /* = CEC_OPCODE_NONE */)
 998 {
 999   bool bReturn(false);
1000   command.transmit_timeout = m_iTransmitTimeout;
1001
1002   if (command.initiator == CECDEVICE_UNKNOWN)
1003   {
1004     CLibCEC::AddLog(CEC_LOG_ERROR, "not transmitting a command without a valid initiator");
1005     return bReturn;
1006   }
1007
1008   {
1009     uint8_t iTries(0), iMaxTries(command.opcode == CEC_OPCODE_NONE ? 1 : m_iTransmitRetries + 1);
1010     while (!bReturn && ++iTries <= iMaxTries)
1011     {
1012       if ((bReturn = m_processor->Transmit(command)) == true)
1013       {
1014         CLibCEC::AddLog(CEC_LOG_DEBUG, "command transmitted");
1015         if (bExpectResponse)
1016         {
1017           bReturn = m_waitForResponse->Wait(expectedResponse);
1018           CLibCEC::AddLog(CEC_LOG_DEBUG, bReturn ? "expected response received (%X: %s)" : "expected response not received (%X: %s)", (int)expectedResponse, m_processor->ToString(expectedResponse));
1019         }
1020       }
1021     }
1022   }
1023
1024   return bReturn;
1025 }
1026
1027 bool CCECCommandHandler::ActivateSource(void)
1028 {
1029   if (m_busDevice->IsActiveSource() &&
1030     m_busDevice->GetStatus(false) == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
1031   {
1032     m_busDevice->SetPowerStatus(CEC_POWER_STATUS_ON);
1033     m_busDevice->SetMenuState(CEC_MENU_STATE_ACTIVATED);
1034
1035     m_busDevice->TransmitImageViewOn();
1036     m_busDevice->TransmitActiveSource();
1037     m_busDevice->TransmitMenuState(CECDEVICE_TV);
1038     if ((m_busDevice->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
1039       m_busDevice->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) &&
1040       SendDeckStatusUpdateOnActiveSource())
1041       ((CCECPlaybackDevice *)m_busDevice)->TransmitDeckStatus(CECDEVICE_TV);
1042     m_bHandlerInited = true;
1043   }
1044   return true;
1045 }