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