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       return device->TransmitPhysicalAddress();
 338   }
 339
 340   return false;
 341 }
 342
 343 bool CCECCommandHandler::HandleGiveMenuLanguage(const cec_command &command)
 344 {
 345   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 346   {
 347     CCECBusDevice *device = GetDevice(command.destination);
 348     if (device)
 349       return device->TransmitSetMenuLanguage(command.initiator);
 350   }
 351
 352   return false;
 353 }
 354
 355 bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
 356 {
 357   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 358   {
 359     CCECBusDevice *device = GetDevice(command.destination);
 360     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 361       return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
 362   }
 363
 364   return false;
 365 }
 366
 367 bool CCECCommandHandler::HandleImageViewOn(const cec_command &command)
 368 {
 369   m_processor->m_busDevices[command.initiator]->SetActiveSource();
 370   return true;
 371 }
 372
 373 bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 374 {
 375   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 376   {
 377     CCECBusDevice *device = GetDevice(command.destination);
 378     if (device)
 379     {
 380       if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_ACTIVATE)
 381       {
 382         if (CLibCEC::MenuStateChanged(CEC_MENU_STATE_ACTIVATED) == 1)
 383           device->SetMenuState(CEC_MENU_STATE_ACTIVATED);
 384       }
 385       else if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_DEACTIVATE)
 386       {
 387         if (CLibCEC::MenuStateChanged(CEC_MENU_STATE_DEACTIVATED) == 1)
 388           device->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
 389       }
 390       return device->TransmitMenuState(command.initiator);
 391     }
 392   }
 393
 394   return false;
 395 }
 396
 397 bool CCECCommandHandler::HandlePoll(const cec_command &command)
 398 {
 399   m_busDevice->HandlePoll(command.destination);
 400   return true;
 401 }
 402
 403 bool CCECCommandHandler::HandleReportAudioStatus(const cec_command &command)
 404 {
 405   if (command.parameters.size == 1)
 406   {
 407     CCECBusDevice *device = GetDevice(command.initiator);
 408     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 409     {
 410       ((CCECAudioSystem *)device)->SetAudioStatus(command.parameters[0]);
 411       return true;
 412     }
 413   }
 414   return false;
 415 }
 416
 417 bool CCECCommandHandler::HandleReportPhysicalAddress(const cec_command &command)
 418 {
 419   if (command.parameters.size == 3)
 420   {
 421     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 422     SetPhysicalAddress(command.initiator, iNewAddress);
 423   }
 424   return true;
 425 }
 426
 427 bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 428 {
 429   if (command.parameters.size == 1)
 430   {
 431     CCECBusDevice *device = GetDevice(command.initiator);
 432     if (device)
 433       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 434   }
 435   return true;
 436 }
 437
 438 bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 439 {
 440   if (m_processor->IsRunning())
 441   {
 442     CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %i requests active source", (uint8_t) command.initiator);
 443
 444     vector<CCECBusDevice *> devices;
 445     for (size_t iDevicePtr = 0; iDevicePtr < GetMyDevices(devices); iDevicePtr++)
 446       devices[iDevicePtr]->TransmitActiveSource();
 447
 448     return true;
 449   }
 450   return false;
 451 }
 452
 453 bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 454 {
 455   if (command.parameters.size == 4)
 456   {
 457     uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 458     uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 459
 460     CCECBusDevice *device = GetDevice(command.initiator);
 461     if (device)
 462       device->SetStreamPath(iNewAddress, iOldAddress);
 463     else
 464       CLibCEC::AddLog(CEC_LOG_DEBUG, "initiator device not found");
 465   }
 466   return true;
 467 }
 468
 469 bool CCECCommandHandler::HandleRoutingInformation(const cec_command &command)
 470 {
 471   if (command.parameters.size == 2)
 472   {
 473     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 474     m_processor->SetActiveSource(iNewAddress);
 475   }
 476
 477   return false;
 478 }
 479
 480 bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 481 {
 482   if (command.parameters.size == 3)
 483   {
 484     CCECBusDevice *device = GetDevice(command.initiator);
 485     if (device)
 486     {
 487       cec_menu_language language;
 488       language.device = command.initiator;
 489       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 490         language.language[iPtr] = command.parameters[iPtr];
 491       language.language[3] = 0;
 492       device->SetMenuLanguage(language);
 493       return true;
 494     }
 495   }
 496   return false;
 497 }
 498
 499 bool CCECCommandHandler::HandleSetOSDName(const cec_command &command)
 500 {
 501   if (command.parameters.size > 0)
 502   {
 503     CCECBusDevice *device = GetDevice(command.initiator);
 504     if (device)
 505     {
 506       char buf[1024];
 507       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 508         buf[iPtr] = (char)command.parameters[iPtr];
 509       buf[command.parameters.size] = 0;
 510
 511       CStdString strName(buf);
 512       device->SetOSDName(strName);
 513
 514       return true;
 515     }
 516   }
 517   return false;
 518 }
 519
 520 bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 521 {
 522   if (m_processor->IsRunning() && command.parameters.size >= 2)
 523   {
 524     uint16_t iStreamAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 525     CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %i sets stream path to physical address %04x", command.initiator, iStreamAddress);
 526
 527     /* one of the device handled by libCEC has been made active */
 528     CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamAddress);
 529     if (device && m_busDevice->MyLogicalAddressContains(device->GetLogicalAddress()))
 530     {
 531       device->SetActiveSource();
 532       device->TransmitImageViewOn();
 533       device->TransmitActiveSource();
 534
 535       device->SetMenuState(CEC_MENU_STATE_ACTIVATED);
 536       device->TransmitMenuState(command.initiator);
 537     }
 538   }
 539   return false;
 540 }
 541
 542 bool CCECCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
 543 {
 544   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 545   {
 546     CCECBusDevice *device = GetDevice(command.destination);
 547     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 548     {
 549       if (command.parameters.size >= 2)
 550       {
 551         device->SetPowerStatus(CEC_POWER_STATUS_ON);
 552         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_ON);
 553         uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 554         CCECBusDevice *newActiveDevice = GetDeviceByPhysicalAddress(iNewAddress);
 555         if (newActiveDevice)
 556           newActiveDevice->SetActiveSource();
 557         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 558       }
 559       else
 560       {
 561         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_OFF);
 562         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 563       }
 564     }
 565   }
 566   return false;
 567 }
 568
 569 bool CCECCommandHandler::HandleStandby(const cec_command &command)
 570 {
 571   CCECBusDevice *device = GetDevice(command.initiator);
 572   if (device)
 573     device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 574
 575   return true;
 576 }
 577
 578 bool CCECCommandHandler::HandleSystemAudioModeStatus(const cec_command &command)
 579 {
 580   if (command.parameters.size == 1)
 581   {
 582     CCECBusDevice *device = GetDevice(command.initiator);
 583     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 584     {
 585       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 586       return true;
 587     }
 588   }
 589
 590   return false;
 591 }
 592
 593 bool CCECCommandHandler::HandleSetSystemAudioMode(const cec_command &command)
 594 {
 595   if (command.parameters.size == 1)
 596   {
 597     CCECBusDevice *device = GetDevice(command.initiator);
 598     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 599     {
 600       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 601       return true;
 602     }
 603   }
 604
 605   return false;
 606 }
 607
 608 bool CCECCommandHandler::HandleTextViewOn(const cec_command &command)
 609 {
 610   m_processor->m_busDevices[command.initiator]->SetActiveSource();
 611   return true;
 612 }
 613
 614 bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 615 {
 616   if (m_processor->IsRunning() &&
 617       m_busDevice->MyLogicalAddressContains(command.destination) &&
 618       command.parameters.size > 0)
 619   {
 620     CLibCEC::AddKey();
 621     if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
 622       CLibCEC::SetCurrentButton((cec_user_control_code) command.parameters[0]);
 623
 624     if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
 625         command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION)
 626     {
 627       bool bPowerOn(true);
 628       CCECBusDevice *device = GetDevice(command.destination);
 629       if (!device)
 630         return true;
 631
 632       // CEC_USER_CONTROL_CODE_POWER operates as a toggle
 633       // assume CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION does not
 634       if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER)
 635       {
 636         cec_power_status status = device->GetPowerStatus();
 637         bPowerOn = !(status == CEC_POWER_STATUS_ON || status == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
 638       }
 639
 640       if (bPowerOn)
 641       {
 642         device->SetActiveSource();
 643         device->TransmitImageViewOn();
 644         device->TransmitActiveSource();
 645
 646         if (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
 647             device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
 648           ((CCECPlaybackDevice *)device)->TransmitDeckStatus(command.initiator);
 649       }
 650       else
 651       {
 652         device->SetInactiveSource();
 653         device->TransmitInactiveSource();
 654         device->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
 655       }
 656     }
 657
 658     return true;
 659   }
 660   return false;
 661 }
 662
 663 bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 664 {
 665   if (m_processor->IsRunning() && m_busDevice->MyLogicalAddressContains(command.destination))
 666     CLibCEC::AddKey();
 667
 668   return true;
 669 }
 670
 671 bool CCECCommandHandler::HandleVendorCommand(const cec_command & UNUSED(command))
 672 {
 673   return true;
 674 }
 675
 676 void CCECCommandHandler::UnhandledCommand(const cec_command &command)
 677 {
 678   CLibCEC::AddLog(CEC_LOG_DEBUG, "unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
 679 }
 680
 681 size_t CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
 682 {
 683   size_t iReturn(0);
 684
 685   cec_logical_addresses addresses = m_processor->GetLogicalAddresses();
 686   for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
 687   {
 688     if (addresses[iPtr])
 689     {
 690       devices.push_back(GetDevice((cec_logical_address) iPtr));
 691       ++iReturn;
 692     }
 693   }
 694
 695   return iReturn;
 696 }
 697
 698 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 699 {
 700   CCECBusDevice *device = NULL;
 701
 702   if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
 703     device = m_processor->m_busDevices[iLogicalAddress];
 704
 705   return device;
 706 }
 707
 708 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 709 {
 710   return m_processor->GetDeviceByPhysicalAddress(iPhysicalAddress);
 711 }
 712
 713 CCECBusDevice *CCECCommandHandler::GetDeviceByType(cec_device_type type) const
 714 {
 715   return m_processor->GetDeviceByType(type);
 716 }
 717
 718 bool CCECCommandHandler::SetVendorId(const cec_command &command)
 719 {
 720   bool bChanged(false);
 721   if (command.parameters.size < 3)
 722   {
 723     CLibCEC::AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 724     return bChanged;
 725   }
 726
 727   uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
 728                        ((uint64_t)command.parameters[1] << 8) +
 729                         (uint64_t)command.parameters[2];
 730
 731   CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
 732   if (device)
 733     bChanged = device->SetVendorId(iVendorId);
 734   return bChanged;
 735 }
 736
 737 void CCECCommandHandler::SetPhysicalAddress(cec_logical_address iAddress, uint16_t iNewAddress)
 738 {
 739   if (!m_busDevice->MyLogicalAddressContains(iAddress))
 740   {
 741     bool bOurAddress(m_processor->GetPhysicalAddress() == iNewAddress);
 742     GetDevice(iAddress)->SetPhysicalAddress(iNewAddress);
 743     if (bOurAddress)
 744     {
 745       /* another device reported the same physical address as ours
 746        * since we don't have physical address detection yet, we'll just use the
 747        * given address, increased by 0x100 for now */
 748       m_processor->SetPhysicalAddress(iNewAddress + 0x100);
 749     }
 750   }
 751 }
 752
 753 bool CCECCommandHandler::PowerOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 754 {
 755   if (iDestination == CECDEVICE_TV)
 756     return TransmitImageViewOn(iInitiator, iDestination);
 757
 758   return TransmitKeypress(iInitiator, iDestination, CEC_USER_CONTROL_CODE_POWER) &&
 759     TransmitKeyRelease(iInitiator, iDestination);
 760 }
 761
 762 bool CCECCommandHandler::TransmitImageViewOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 763 {
 764   cec_command command;
 765   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_IMAGE_VIEW_ON);
 766
 767   return Transmit(command);
 768 }
 769
 770 bool CCECCommandHandler::TransmitStandby(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 771 {
 772   cec_command command;
 773   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_STANDBY);
 774
 775   return Transmit(command);
 776 }
 777
 778 bool CCECCommandHandler::TransmitRequestCecVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 779 {
 780   cec_command command;
 781   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_CEC_VERSION);
 782
 783   return Transmit(command, !bWaitForResponse);
 784 }
 785
 786 bool CCECCommandHandler::TransmitRequestMenuLanguage(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 787 {
 788   cec_command command;
 789   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_MENU_LANGUAGE);
 790
 791   return Transmit(command, !bWaitForResponse);
 792 }
 793
 794 bool CCECCommandHandler::TransmitRequestOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 795 {
 796   cec_command command;
 797   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_OSD_NAME);
 798
 799   return Transmit(command, !bWaitForResponse);
 800 }
 801
 802 bool CCECCommandHandler::TransmitRequestPhysicalAddress(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 803 {
 804   cec_command command;
 805   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_PHYSICAL_ADDRESS);
 806
 807   return Transmit(command, !bWaitForResponse);
 808 }
 809
 810 bool CCECCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 811 {
 812   cec_command command;
 813   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
 814
 815   return Transmit(command, !bWaitForResponse);
 816 }
 817
 818 bool CCECCommandHandler::TransmitRequestVendorId(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
 819 {
 820   cec_command command;
 821   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
 822
 823   return Transmit(command, !bWaitForResponse);
 824 }
 825
 826 bool CCECCommandHandler::TransmitActiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
 827 {
 828   cec_command command;
 829   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
 830   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 831   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 832
 833   return Transmit(command);
 834 }
 835
 836 bool CCECCommandHandler::TransmitCECVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_version cecVersion)
 837 {
 838   cec_command command;
 839   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_CEC_VERSION);
 840   command.parameters.PushBack((uint8_t)cecVersion);
 841
 842   return Transmit(command);
 843 }
 844
 845 bool CCECCommandHandler::TransmitInactiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
 846 {
 847   cec_command command;
 848   cec_command::Format(command, iInitiator, CECDEVICE_TV, CEC_OPCODE_INACTIVE_SOURCE);
 849   command.parameters.PushBack((iPhysicalAddress >> 8) & 0xFF);
 850   command.parameters.PushBack(iPhysicalAddress & 0xFF);
 851
 852   return Transmit(command);
 853 }
 854
 855 bool CCECCommandHandler::TransmitMenuState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_menu_state menuState)
 856 {
 857   cec_command command;
 858   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_MENU_STATUS);
 859   command.parameters.PushBack((uint8_t)menuState);
 860
 861   return Transmit(command);
 862 }
 863
 864 bool CCECCommandHandler::TransmitOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, CStdString strDeviceName)
 865 {
 866   cec_command command;
 867   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_NAME);
 868   for (size_t iPtr = 0; iPtr < strDeviceName.length(); iPtr++)
 869     command.parameters.PushBack(strDeviceName.at(iPtr));
 870
 871   return Transmit(command);
 872 }
 873
 874 bool CCECCommandHandler::TransmitOSDString(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_display_control duration, const char *strMessage)
 875 {
 876   cec_command command;
 877   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_STRING);
 878   command.parameters.PushBack((uint8_t)duration);
 879
 880   size_t iLen = strlen(strMessage);
 881   if (iLen > 13) iLen = 13;
 882
 883   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 884     command.parameters.PushBack(strMessage[iPtr]);
 885
 886   return Transmit(command);
 887 }
 888
 889 bool CCECCommandHandler::TransmitPhysicalAddress(const cec_logical_address iInitiator, uint16_t iPhysicalAddress, cec_device_type type)
 890 {
 891   cec_command command;
 892   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
 893   command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
 894   command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
 895   command.parameters.PushBack((uint8_t) (type));
 896
 897   return Transmit(command);
 898 }
 899
 900 bool CCECCommandHandler::TransmitSetMenuLanguage(const cec_logical_address iInitiator, const char lang[3])
 901 {
 902   cec_command command;
 903   command.Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_SET_MENU_LANGUAGE);
 904   command.parameters.PushBack((uint8_t) lang[0]);
 905   command.parameters.PushBack((uint8_t) lang[1]);
 906   command.parameters.PushBack((uint8_t) lang[2]);
 907
 908   return Transmit(command);
 909 }
 910
 911 bool CCECCommandHandler::TransmitPoll(const cec_logical_address iInitiator, const cec_logical_address iDestination)
 912 {
 913   cec_command command;
 914   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_NONE);
 915
 916   return Transmit(command);
 917 }
 918
 919 bool CCECCommandHandler::TransmitPowerState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_power_status state)
 920 {
 921   cec_command command;
 922   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_POWER_STATUS);
 923   command.parameters.PushBack((uint8_t) state);
 924
 925   return Transmit(command);
 926 }
 927
 928 bool CCECCommandHandler::TransmitVendorID(const cec_logical_address iInitiator, uint64_t iVendorId)
 929 {
 930   cec_command command;
 931   cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_DEVICE_VENDOR_ID);
 932
 933   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 16) & 0xFF));
 934   command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 8) & 0xFF));
 935   command.parameters.PushBack((uint8_t) ((uint64_t)iVendorId & 0xFF));
 936
 937   return Transmit(command);
 938 }
 939
 940 bool CCECCommandHandler::TransmitAudioStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, uint8_t state)
 941 {
 942   cec_command command;
 943   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_AUDIO_STATUS);
 944   command.parameters.PushBack(state);
 945
 946   return Transmit(command);
 947 }
 948
 949 bool CCECCommandHandler::TransmitSetSystemAudioMode(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state)
 950 {
 951   cec_command command;
 952   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_SYSTEM_AUDIO_MODE);
 953   command.parameters.PushBack((uint8_t)state);
 954
 955   return Transmit(command);
 956 }
 957
 958 bool CCECCommandHandler::TransmitSetStreamPath(uint16_t iStreamPath)
 959 {
 960   cec_command command;
 961   cec_command::Format(command, m_busDevice->GetLogicalAddress(), CECDEVICE_BROADCAST, CEC_OPCODE_SET_STREAM_PATH);
 962   command.parameters.PushBack((uint8_t) ((iStreamPath >> 8) & 0xFF));
 963   command.parameters.PushBack((uint8_t) (iStreamPath        & 0xFF));
 964
 965   return Transmit(command);
 966 }
 967
 968 bool CCECCommandHandler::TransmitSystemAudioModeStatus(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_SYSTEM_AUDIO_MODE_STATUS);
 972   command.parameters.PushBack((uint8_t)state);
 973
 974   return Transmit(command);
 975 }
 976
 977 bool CCECCommandHandler::TransmitDeckStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_deck_info state)
 978 {
 979   cec_command command;
 980   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_DECK_STATUS);
 981   command.PushBack((uint8_t)state);
 982
 983   return Transmit(command);
 984 }
 985
 986 bool CCECCommandHandler::TransmitKeypress(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
 987 {
 988   cec_command command;
 989   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_PRESSED);
 990   command.parameters.PushBack((uint8_t)key);
 991
 992   return Transmit(command, !bWait);
 993 }
 994
 995 bool CCECCommandHandler::TransmitKeyRelease(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWait /* = true */)
 996 {
 997   cec_command command;
 998   cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_RELEASE);
 999
1000   return Transmit(command, !bWait);
1001 }
1002
1003 bool CCECCommandHandler::Transmit(cec_command &command, bool bSuppressWait /* = false */)
1004 {
1005   bool bReturn(false);
1006   cec_opcode expectedResponse(cec_command::GetResponseOpcode(command.opcode));
1007   bool bExpectResponse(expectedResponse != CEC_OPCODE_NONE && !bSuppressWait);
1008   command.transmit_timeout = m_iTransmitTimeout;
1009
1010   if (command.initiator == CECDEVICE_UNKNOWN)
1011   {
1012     CLibCEC::AddLog(CEC_LOG_ERROR, "not transmitting a command without a valid initiator");
1013     return bReturn;
1014   }
1015
1016   {
1017     uint8_t iTries(0), iMaxTries(!command.opcode_set ? 1 : m_iTransmitRetries + 1);
1018     while (!bReturn && ++iTries <= iMaxTries && !m_busDevice->IsUnsupportedFeature(command.opcode))
1019     {
1020       if ((bReturn = m_processor->Transmit(command)) == true)
1021       {
1022         CLibCEC::AddLog(CEC_LOG_DEBUG, "command transmitted");
1023         if (bExpectResponse)
1024         {
1025           bReturn = m_waitForResponse->Wait(expectedResponse);
1026           CLibCEC::AddLog(CEC_LOG_DEBUG, bReturn ? "expected response received (%X: %s)" : "expected response not received (%X: %s)", (int)expectedResponse, m_processor->ToString(expectedResponse));
1027         }
1028       }
1029     }
1030   }
1031
1032   return bReturn;
1033 }
1034
1035 bool CCECCommandHandler::ActivateSource(void)
1036 {
1037   if (m_busDevice->IsActiveSource() &&
1038     m_busDevice->GetStatus(false) == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
1039   {
1040     m_busDevice->SetPowerStatus(CEC_POWER_STATUS_ON);
1041     m_busDevice->SetMenuState(CEC_MENU_STATE_ACTIVATED);
1042
1043     m_busDevice->TransmitImageViewOn();
1044     m_busDevice->TransmitActiveSource();
1045     m_busDevice->TransmitMenuState(CECDEVICE_TV);
1046     if ((m_busDevice->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
1047       m_busDevice->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) &&
1048       SendDeckStatusUpdateOnActiveSource())
1049       ((CCECPlaybackDevice *)m_busDevice)->TransmitDeckStatus(CECDEVICE_TV);
1050     m_bHandlerInited = true;
1051   }
1052   return true;
1053 }
1054
1055 void CCECCommandHandler::SignalOpcode(cec_opcode opcode)
1056 {
1057   m_waitForResponse->Received(opcode);
1058 }