src/lib/implementations/CECCommandHandler.cpp

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