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 {
  44   m_busDevice = busDevice;
  45 }
  46
  47 bool CCECCommandHandler::HandleCommand(const cec_command &command)
  48 {
  49   bool bHandled(true);
  50
  51   CStdString strLog;
  52   strLog.Format(">> %s (%X) -> %s (%X): %s (%2X)", m_busDevice->GetProcessor()->ToString(command.initiator), command.initiator, m_busDevice->GetProcessor()->ToString(command.destination), command.destination, m_busDevice->GetProcessor()->ToString(command.opcode), command.opcode);
  53   m_busDevice->AddLog(CEC_LOG_NOTICE, strLog);
  54
  55   switch(command.opcode)
  56   {
  57   case CEC_OPCODE_REPORT_POWER_STATUS:
  58     HandleReportPowerStatus(command);
  59     break;
  60   case CEC_OPCODE_CEC_VERSION:
  61     HandleDeviceCecVersion(command);
  62     break;
  63   case CEC_OPCODE_SET_MENU_LANGUAGE:
  64     HandleSetMenuLanguage(command);
  65     break;
  66   case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
  67     HandleGivePhysicalAddress(command);
  68     break;
  69   case CEC_OPCODE_GIVE_OSD_NAME:
  70      HandleGiveOSDName(command);
  71     break;
  72   case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
  73     HandleGiveDeviceVendorId(command);
  74     break;
  75   case CEC_OPCODE_DEVICE_VENDOR_ID:
  76     HandleDeviceVendorId(command);
  77     break;
  78   case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
  79     HandleDeviceVendorCommandWithId(command);
  80     break;
  81   case CEC_OPCODE_GIVE_DECK_STATUS:
  82     HandleGiveDeckStatus(command);
  83     break;
  84   case CEC_OPCODE_DECK_CONTROL:
  85     HandleDeckControl(command);
  86     break;
  87   case CEC_OPCODE_MENU_REQUEST:
  88     HandleMenuRequest(command);
  89     break;
  90   case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
  91     HandleGiveDevicePowerStatus(command);
  92     break;
  93   case CEC_OPCODE_GET_CEC_VERSION:
  94     HandleGetCecVersion(command);
  95     break;
  96   case CEC_OPCODE_USER_CONTROL_PRESSED:
  97     HandleUserControlPressed(command);
  98     break;
  99   case CEC_OPCODE_USER_CONTROL_RELEASE:
 100     HandleUserControlRelease(command);
 101     break;
 102   case CEC_OPCODE_GIVE_AUDIO_STATUS:
 103     HandleGiveAudioStatus(command);
 104     break;
 105   case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
 106     HandleGiveSystemAudioModeStatus(command);
 107     break;
 108   case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
 109     HandleSystemAudioModeRequest(command);
 110     break;
 111   case CEC_OPCODE_REPORT_AUDIO_STATUS:
 112     HandleReportAudioStatus(command);//YYY
 113     break;
 114   case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
 115     HandleSystemAudioModeStatus(command);//YYY
 116     break;
 117   case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
 118     HandleSetSystemAudioMode(command);//YYY
 119     break;
 120   case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 121     HandleRequestActiveSource(command);
 122     break;
 123   case CEC_OPCODE_SET_STREAM_PATH:
 124     HandleSetStreamPath(command);
 125     break;
 126   case CEC_OPCODE_ROUTING_CHANGE:
 127     HandleRoutingChange(command);
 128     break;
 129   case CEC_OPCODE_ROUTING_INFORMATION:
 130     HandleRoutingInformation(command);
 131     break;
 132   case CEC_OPCODE_STANDBY:
 133     HandleStandby(command);
 134     break;
 135   case CEC_OPCODE_ACTIVE_SOURCE:
 136     HandleActiveSource(command);
 137     break;
 138   case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
 139     HandleReportPhysicalAddress(command);
 140     break;
 141   case CEC_OPCODE_SET_OSD_NAME:
 142     HandleSetOSDName(command);
 143     break;
 144   case CEC_OPCODE_IMAGE_VIEW_ON:
 145     HandleImageViewOn(command);
 146     break;
 147   case CEC_OPCODE_TEXT_VIEW_ON:
 148     HandleTextViewOn(command);
 149     break;
 150   default:
 151     UnhandledCommand(command);
 152     bHandled = false;
 153     break;
 154   }
 155
 156   m_busDevice->GetProcessor()->AddCommand(command);
 157   return bHandled;
 158 }
 159
 160 bool CCECCommandHandler::HandleActiveSource(const cec_command &command)
 161 {
 162   if (command.parameters.size == 2)
 163   {
 164     uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 165     return m_busDevice->GetProcessor()->SetStreamPath(iAddress);
 166   }
 167
 168   return true;
 169 }
 170
 171 bool CCECCommandHandler::HandleDeckControl(const cec_command &command)
 172 {
 173   CCECBusDevice *device = GetDevice(command.destination);
 174   if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) && command.parameters.size > 0)
 175   {
 176     ((CCECPlaybackDevice *) device)->SetDeckControlMode((cec_deck_control_mode) command.parameters[0]);
 177     return true;
 178   }
 179
 180   return false;
 181 }
 182
 183 bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
 184 {
 185   if (command.parameters.size == 1)
 186   {
 187     CCECBusDevice *device = GetDevice(command.initiator);
 188     if (device)
 189       device->SetCecVersion((cec_version) command.parameters[0]);
 190   }
 191
 192   return true;
 193 }
 194
 195 bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
 196 {
 197   if (m_busDevice->MyLogicalAddressContains(command.destination))
 198     m_busDevice->GetProcessor()->TransmitAbort(command.initiator, command.opcode, CEC_ABORT_REASON_REFUSED);
 199
 200   return true;
 201 }
 202
 203 bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
 204 {
 205   SetVendorId(command);
 206   return true;
 207 }
 208
 209 bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
 210 {
 211   if (m_busDevice->MyLogicalAddressContains(command.destination))
 212   {
 213     CCECBusDevice *device = GetDevice(command.destination);
 214     if (device)
 215       return device->TransmitCECVersion(command.initiator);
 216   }
 217
 218   return false;
 219 }
 220
 221 bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
 222 {
 223   if (m_busDevice->MyLogicalAddressContains(command.destination))
 224   {
 225     CCECBusDevice *device = GetDevice(command.destination);
 226     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 227       return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
 228   }
 229
 230   return false;
 231 }
 232
 233 bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
 234 {
 235   if (m_busDevice->MyLogicalAddressContains(command.destination))
 236   {
 237     CCECBusDevice *device = GetDevice(command.destination);
 238     if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
 239       return ((CCECPlaybackDevice *) device)->TransmitDeckStatus(command.initiator);
 240   }
 241
 242   return false;
 243 }
 244
 245 bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
 246 {
 247   if (m_busDevice->MyLogicalAddressContains(command.destination))
 248   {
 249     CCECBusDevice *device = GetDevice(command.destination);
 250     if (device)
 251       return device->TransmitPowerState(command.initiator);
 252   }
 253
 254   return false;
 255 }
 256
 257 bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
 258 {
 259   if (m_busDevice->MyLogicalAddressContains(command.destination))
 260   {
 261     CCECBusDevice *device = GetDevice(command.destination);
 262     if (device)
 263       return device->TransmitVendorID(command.initiator);
 264   }
 265
 266   return false;
 267 }
 268
 269 bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
 270 {
 271   if (m_busDevice->MyLogicalAddressContains(command.destination))
 272   {
 273     CCECBusDevice *device = GetDevice(command.destination);
 274     if (device)
 275       return device->TransmitOSDName(command.initiator);
 276   }
 277
 278   return false;
 279 }
 280
 281 bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
 282 {
 283   if (m_busDevice->MyLogicalAddressContains(command.destination))
 284   {
 285     CCECBusDevice *device = GetDevice(command.destination);
 286     if (device)
 287       return device->TransmitPhysicalAddress();
 288   }
 289
 290   return false;
 291 }
 292
 293 bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
 294 {
 295   if (m_busDevice->MyLogicalAddressContains(command.destination))
 296   {
 297     CCECBusDevice *device = GetDevice(command.destination);
 298     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 299       return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
 300   }
 301
 302   return false;
 303 }
 304
 305 bool CCECCommandHandler::HandleImageViewOn(const cec_command &command)
 306 {
 307   m_busDevice->GetProcessor()->SetActiveSource(command.initiator);
 308   return true;
 309 }
 310
 311 bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 312 {
 313   if (m_busDevice->MyLogicalAddressContains(command.destination))
 314   {
 315     if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
 316     {
 317       CCECBusDevice *device = GetDevice(command.destination);
 318       if (device)
 319         return device->TransmitMenuState(command.initiator);
 320     }
 321   }
 322
 323   return false;
 324 }
 325
 326 bool CCECCommandHandler::HandleReportAudioStatus(const cec_command &command)
 327 {
 328   if (command.parameters.size == 1)
 329   {
 330     CCECBusDevice *device = GetDevice(command.initiator);
 331     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 332     {
 333       ((CCECAudioSystem *)device)->SetAudioStatus(command.parameters[0]);
 334       return true;
 335     }
 336   }
 337   return false;
 338 }
 339
 340 bool CCECCommandHandler::HandleReportPhysicalAddress(const cec_command &command)
 341 {
 342   if (command.parameters.size == 3)
 343   {
 344     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 345     SetPhysicalAddress(command.initiator, iNewAddress);
 346   }
 347   return true;
 348 }
 349
 350 bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 351 {
 352   if (command.parameters.size == 1)
 353   {
 354     CCECBusDevice *device = GetDevice(command.initiator);
 355     if (device)
 356       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 357   }
 358   return true;
 359 }
 360
 361 bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 362 {
 363   CStdString strLog;
 364   strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
 365   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 366
 367   vector<CCECBusDevice *> devices;
 368   for (int iDevicePtr = (int)GetMyDevices(devices)-1; iDevicePtr >=0; iDevicePtr--)
 369     devices[iDevicePtr]->TransmitActiveSource();
 370
 371   return true;
 372 }
 373
 374 bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 375 {
 376   if (command.parameters.size == 4)
 377   {
 378     uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 379     uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 380
 381     CCECBusDevice *device = GetDevice(command.initiator);
 382     if (device)
 383       device->SetStreamPath(iNewAddress, iOldAddress);
 384   }
 385   return true;
 386 }
 387
 388 bool CCECCommandHandler::HandleRoutingInformation(const cec_command &command)
 389 {
 390   if (command.parameters.size == 2)
 391   {
 392     uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 393     m_busDevice->GetProcessor()->SetStreamPath(iNewAddress);
 394   }
 395
 396   return false;
 397 }
 398
 399 bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 400 {
 401   if (command.parameters.size == 3)
 402   {
 403     CCECBusDevice *device = GetDevice(command.initiator);
 404     if (device)
 405     {
 406       cec_menu_language language;
 407       language.device = command.initiator;
 408       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 409         language.language[iPtr] = command.parameters[iPtr];
 410       language.language[3] = 0;
 411       device->SetMenuLanguage(language);
 412       return true;
 413     }
 414   }
 415   return false;
 416 }
 417
 418 bool CCECCommandHandler::HandleSetOSDName(const cec_command &command)
 419 {
 420   if (command.parameters.size > 0)
 421   {
 422     CCECBusDevice *device = GetDevice(command.initiator);
 423     if (device)
 424     {
 425       char buf[1024];
 426       for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 427         buf[iPtr] = (char)command.parameters[iPtr];
 428       buf[command.parameters.size] = 0;
 429
 430       CStdString strName(buf);
 431       device->SetOSDName(strName);
 432
 433       return true;
 434     }
 435   }
 436   return false;
 437 }
 438
 439 bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 440 {
 441   if (command.parameters.size >= 2)
 442   {
 443     uint16_t iStreamAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 444     CStdString strLog;
 445     strLog.Format(">> %i sets stream path to physical address %04x", command.initiator, iStreamAddress);
 446     m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 447
 448     if (m_busDevice->GetProcessor()->SetStreamPath(iStreamAddress))
 449     {
 450       CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamAddress);
 451       if (device)
 452       {
 453         return device->TransmitActiveSource() &&
 454             device->TransmitMenuState(command.initiator);
 455       }
 456     }
 457   }
 458   return false;
 459 }
 460
 461 bool CCECCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
 462 {
 463   if (m_busDevice->MyLogicalAddressContains(command.destination))
 464   {
 465     CCECBusDevice *device = GetDevice(command.destination);
 466     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 467     {
 468       if (command.parameters.size >= 2)
 469       {
 470         device->SetPowerStatus(CEC_POWER_STATUS_ON);
 471         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_ON);
 472         uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 473         CCECBusDevice *newActiveDevice = GetDeviceByPhysicalAddress(iNewAddress);
 474         if (newActiveDevice)
 475           m_busDevice->GetProcessor()->SetActiveSource(newActiveDevice->GetLogicalAddress());
 476         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 477       }
 478       else
 479       {
 480         ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_OFF);
 481         return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
 482       }
 483     }
 484   }
 485   return false;
 486 }
 487
 488 bool CCECCommandHandler::HandleStandby(const cec_command &command)
 489 {
 490   CCECBusDevice *device = GetDevice(command.initiator);
 491   if (device)
 492     device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 493
 494   return true;
 495 }
 496
 497 bool CCECCommandHandler::HandleSystemAudioModeStatus(const cec_command &command)
 498 {
 499   if (command.parameters.size == 1)
 500   {
 501     CCECBusDevice *device = GetDevice(command.initiator);
 502     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 503     {
 504       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 505       return true;
 506     }
 507   }
 508
 509   return false;
 510 }
 511
 512 bool CCECCommandHandler::HandleSetSystemAudioMode(const cec_command &command)
 513 {
 514   if (command.parameters.size == 1)
 515   {
 516     CCECBusDevice *device = GetDevice(command.initiator);
 517     if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 518     {
 519       ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
 520       return true;
 521     }
 522   }
 523
 524   return false;
 525 }
 526
 527 bool CCECCommandHandler::HandleTextViewOn(const cec_command &command)
 528 {
 529   m_busDevice->GetProcessor()->SetActiveSource(command.initiator);
 530   return true;
 531 }
 532
 533 bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 534 {
 535   if (m_busDevice->MyLogicalAddressContains(command.destination) && command.parameters.size > 0)
 536   {
 537     m_busDevice->GetProcessor()->AddKey();
 538
 539     if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
 540     {
 541       CStdString strLog;
 542       strLog.Format("key pressed: %x", command.parameters[0]);
 543       m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 544
 545       if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
 546           command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION)
 547       {
 548         CCECBusDevice *device = GetDevice(command.destination);
 549         if (device)
 550           device->SetPowerStatus(CEC_POWER_STATUS_ON);
 551       }
 552
 553       m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
 554       return true;
 555     }
 556   }
 557   return false;
 558 }
 559
 560 bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 561 {
 562   if (m_busDevice->MyLogicalAddressContains(command.destination))
 563     m_busDevice->GetProcessor()->AddKey();
 564
 565   return true;
 566 }
 567
 568 void CCECCommandHandler::UnhandledCommand(const cec_command &command)
 569 {
 570   CStdString strLog;
 571   strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
 572   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
 573 }
 574
 575 unsigned int CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
 576 {
 577   unsigned int iReturn(0);
 578
 579   cec_logical_addresses addresses = m_busDevice->GetProcessor()->GetLogicalAddresses();
 580   for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
 581   {
 582     if (addresses[iPtr])
 583     {
 584       devices.push_back(GetDevice((cec_logical_address) iPtr));
 585       ++iReturn;
 586     }
 587   }
 588
 589   return iReturn;
 590 }
 591
 592 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 593 {
 594   CCECBusDevice *device = NULL;
 595
 596   if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
 597     device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
 598
 599   return device;
 600 }
 601
 602 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 603 {
 604   return m_busDevice->GetProcessor()->GetDeviceByPhysicalAddress(iPhysicalAddress);
 605 }
 606
 607 CCECBusDevice *CCECCommandHandler::GetDeviceByType(cec_device_type type) const
 608 {
 609   return m_busDevice->GetProcessor()->GetDeviceByType(type);
 610 }
 611
 612 void CCECCommandHandler::SetVendorId(const cec_command &command)
 613 {
 614   if (command.parameters.size < 3)
 615   {
 616     m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 617     return;
 618   }
 619
 620   uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
 621                        ((uint64_t)command.parameters[1] << 8) +
 622                         (uint64_t)command.parameters[2];
 623
 624   CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
 625   if (device)
 626     device->SetVendorId(iVendorId);
 627 }
 628
 629 void CCECCommandHandler::SetPhysicalAddress(cec_logical_address iAddress, uint16_t iNewAddress)
 630 {
 631   if (!m_busDevice->MyLogicalAddressContains(iAddress))
 632   {
 633     bool bOurAddress(m_busDevice->GetProcessor()->GetPhysicalAddress() == iNewAddress);
 634     GetDevice(iAddress)->SetPhysicalAddress(iNewAddress);
 635     if (bOurAddress)
 636     {
 637       /* another device reported the same physical address as ours
 638        * since we don't have physical address detection yet, we'll just use the
 639        * given address, increased by 0x100 for now */
 640       m_busDevice->GetProcessor()->SetPhysicalAddress(iNewAddress + 0x100);
 641     }
 642   }
 643 }