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)", ToString(command.initiator), command.initiator, ToString(command.destination), command.destination, ToString(command.opcode), command.opcode);
  53   m_busDevice->AddLog(CEC_LOG_NOTICE, strLog);
  54
  55   if (m_busDevice->MyLogicalAddressContains(command.destination))
  56   {
  57     switch(command.opcode)
  58     {
  59     case CEC_OPCODE_REPORT_POWER_STATUS:
  60       HandleReportPowerStatus(command);
  61       break;
  62     case CEC_OPCODE_CEC_VERSION:
  63       HandleDeviceCecVersion(command);
  64       break;
  65     case CEC_OPCODE_SET_MENU_LANGUAGE:
  66       HandleSetMenuLanguage(command);
  67       /* pass to listeners */
  68       m_busDevice->GetProcessor()->AddCommand(command);
  69       break;
  70     case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
  71       HandleGivePhysicalAddress(command);
  72       break;
  73     case CEC_OPCODE_GIVE_OSD_NAME:
  74       HandleGiveOSDName(command);
  75       break;
  76     case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
  77       HandleGiveDeviceVendorId(command);
  78       break;
  79     case CEC_OPCODE_DEVICE_VENDOR_ID:
  80       HandleDeviceVendorId(command);
  81       break;
  82     case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
  83       HandleDeviceVendorCommandWithId(command);
  84       break;
  85     case CEC_OPCODE_GIVE_DECK_STATUS:
  86       HandleGiveDeckStatus(command);
  87       break;
  88     case CEC_OPCODE_MENU_REQUEST:
  89       HandleMenuRequest(command);
  90       break;
  91     case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
  92       HandleGiveDevicePowerStatus(command);
  93       break;
  94     case CEC_OPCODE_GET_CEC_VERSION:
  95       HandleGetCecVersion(command);
  96       break;
  97     case CEC_OPCODE_USER_CONTROL_PRESSED:
  98       HandleUserControlPressed(command);
  99       break;
 100     case CEC_OPCODE_USER_CONTROL_RELEASE:
 101       HandleUserControlRelease(command);
 102       break;
 103     case CEC_OPCODE_GIVE_AUDIO_STATUS:
 104       HandleGiveAudioStatus(command);
 105       break;
 106     case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
 107       HandleGiveSystemAudioModeStatus(command);
 108       break;
 109     case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
 110       HandleSetSystemAudioModeRequest(command);
 111       break;
 112     default:
 113       UnhandledCommand(command);
 114       /* pass to listeners */
 115       m_busDevice->GetProcessor()->AddCommand(command);
 116       bHandled = false;
 117       break;
 118     }
 119   }
 120   else if (command.destination == CECDEVICE_BROADCAST)
 121   {
 122     CStdString strLog;
 123     switch (command.opcode)
 124     {
 125     case CEC_OPCODE_SET_MENU_LANGUAGE:
 126       HandleSetMenuLanguage(command);
 127       /* pass to listeners */
 128       m_busDevice->GetProcessor()->AddCommand(command);
 129       break;
 130     case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 131       HandleRequestActiveSource(command);
 132       break;
 133     case CEC_OPCODE_SET_STREAM_PATH:
 134       HandleSetStreamPath(command);
 135       break;
 136     case CEC_OPCODE_ROUTING_CHANGE:
 137       HandleRoutingChange(command);
 138       break;
 139     case CEC_OPCODE_DEVICE_VENDOR_ID:
 140       HandleDeviceVendorId(command);
 141       break;
 142     case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
 143       HandleDeviceVendorCommandWithId(command);
 144      break;
 145     case CEC_OPCODE_STANDBY:
 146       HandleStandby(command);
 147       /* pass to listeners */
 148       m_busDevice->GetProcessor()->AddCommand(command);
 149      break;
 150     case CEC_OPCODE_ACTIVE_SOURCE:
 151       HandleActiveSource(command);
 152       /* pass to listeners */
 153       m_busDevice->GetProcessor()->AddCommand(command);
 154       break;
 155     default:
 156       UnhandledCommand(command);
 157       /* pass to listeners */
 158       m_busDevice->GetProcessor()->AddCommand(command);
 159       bHandled = false;
 160       break;
 161     }
 162   }
 163   else
 164   {
 165     CStdString strLog;
 166     strLog.Format("ignoring frame: we're not at destination %x", command.destination);
 167     m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 168     bHandled = false;
 169   }
 170
 171   return bHandled;
 172 }
 173
 174 bool CCECCommandHandler::HandleActiveSource(const cec_command &command)
 175 {
 176   if (command.parameters.size == 2)
 177   {
 178     uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 179     return m_busDevice->GetProcessor()->SetStreamPath(iAddress);
 180   }
 181
 182   return true;
 183 }
 184
 185 bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
 186 {
 187   if (command.parameters.size == 1)
 188   {
 189     CCECBusDevice *device = GetDevice(command.initiator);
 190     if (device)
 191       device->SetCecVersion((cec_version) command.parameters[0]);
 192   }
 193
 194   return true;
 195 }
 196
 197 bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
 198 {
 199   SetVendorId(command);
 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   CCECBusDevice *device = GetDevice(command.destination);
 212   if (device)
 213     return device->TransmitCECVersion(command.initiator);
 214
 215   return false;
 216 }
 217
 218 bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
 219 {
 220   CCECBusDevice *device = GetDevice(command.destination);
 221   if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 222     return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
 223
 224   return false;
 225 }
 226
 227 bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
 228 {
 229   CCECBusDevice *device = GetDevice(command.destination);
 230   if (device && device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
 231     return ((CCECPlaybackDevice *) device)->TransmitDeckStatus(command.initiator);
 232
 233   return false;
 234 }
 235
 236 bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
 237 {
 238   CCECBusDevice *device = GetDevice(command.destination);
 239   if (device)
 240     return device->TransmitPowerState(command.initiator);
 241
 242   return false;
 243 }
 244
 245 bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
 246 {
 247   CCECBusDevice *device = GetDevice(command.destination);
 248   if (device)
 249     return device->TransmitVendorID(command.initiator);
 250
 251   return false;
 252 }
 253
 254 bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
 255 {
 256   CCECBusDevice *device = GetDevice(command.destination);
 257   if (device)
 258     return device->TransmitOSDName(command.initiator);
 259
 260   return false;
 261 }
 262
 263 bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
 264 {
 265   CCECBusDevice *device = GetDevice(command.destination);
 266   if (device)
 267     return device->TransmitPhysicalAddress();
 268
 269   return false;
 270 }
 271
 272 bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 273 {
 274   if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
 275   {
 276     CCECBusDevice *device = GetDevice(command.destination);
 277     if (device)
 278       return device->TransmitMenuState(command.initiator);
 279   }
 280   return false;
 281 }
 282
 283 bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 284 {
 285   if (command.parameters.size == 1)
 286   {
 287     CCECBusDevice *device = GetDevice(command.initiator);
 288     if (device)
 289       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 290   }
 291   return true;
 292 }
 293
 294 bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 295 {
 296   CStdString strLog;
 297   strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
 298   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 299
 300   vector<CCECBusDevice *> devices;
 301   for (int iDevicePtr = (int)GetMyDevices(devices)-1; iDevicePtr >=0; iDevicePtr--)
 302     devices[iDevicePtr]->TransmitActiveSource();
 303   return true;
 304 }
 305
 306 bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 307 {
 308   if (command.parameters.size == 4)
 309   {
 310     uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 311     uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 312
 313     CCECBusDevice *device = GetDevice(command.initiator);
 314     if (device)
 315       device->SetStreamPath(iNewAddress, iOldAddress);
 316   }
 317   return true;
 318 }
 319
 320 bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 321 {
 322   if (command.parameters.size == 3)
 323   {
 324     CCECBusDevice *device = GetDevice(command.initiator);
 325     if (device)
 326     {
 327       cec_menu_language language;
 328       language.device = command.initiator;
 329       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 330         language.language[iPtr] = command.parameters[iPtr];
 331       language.language[3] = 0;
 332       device->SetMenuLanguage(language);
 333     }
 334   }
 335   return true;
 336 }
 337
 338 bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 339 {
 340   if (command.parameters.size >= 2)
 341   {
 342     int streamaddr = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 343     CStdString strLog;
 344     strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
 345     m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 346     CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
 347     if (device)
 348       return device->TransmitActiveSource();
 349   }
 350   return true;
 351 }
 352
 353 bool CCECCommandHandler::HandleSetSystemAudioModeRequest(const cec_command &command)
 354 {
 355   if (command.parameters.size >= 1)
 356   {
 357     CCECBusDevice *device = GetDevice(command.destination);
 358     if (device&& device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 359       return ((CCECAudioSystem *) device)->SetSystemAudioMode(command);
 360   }
 361   return true;
 362 }
 363
 364 bool CCECCommandHandler::HandleStandby(const cec_command &command)
 365 {
 366   CCECBusDevice *device = GetDevice(command.initiator);
 367   if (device)
 368     device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 369   return true;
 370 }
 371
 372 bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
 373 {
 374   CCECBusDevice *device = GetDevice(command.destination);
 375   if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 376     return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
 377
 378   return false;
 379 }
 380
 381 bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 382 {
 383   if (command.parameters.size > 0)
 384   {
 385     m_busDevice->GetProcessor()->AddKey();
 386
 387     if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
 388     {
 389       CStdString strLog;
 390       strLog.Format("key pressed: %1x", command.parameters[0]);
 391       m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 392
 393       m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
 394     }
 395   }
 396   return true;
 397 }
 398
 399 bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 400 {
 401   m_busDevice->GetProcessor()->AddKey();
 402   return true;
 403 }
 404
 405 void CCECCommandHandler::UnhandledCommand(const cec_command &command)
 406 {
 407   CStdString strLog;
 408   strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
 409   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
 410 }
 411
 412 unsigned int CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
 413 {
 414   unsigned int iReturn(0);
 415
 416   cec_logical_addresses addresses = m_busDevice->GetProcessor()->GetLogicalAddresses();
 417   for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 418   {
 419     if (addresses[iPtr])
 420     {
 421       devices.push_back(GetDevice((cec_logical_address) iPtr));
 422       ++iReturn;
 423     }
 424   }
 425
 426   return iReturn;
 427 }
 428
 429 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 430 {
 431   CCECBusDevice *device = NULL;
 432
 433   if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
 434     device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
 435
 436   return device;
 437 }
 438
 439 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 440 {
 441   return m_busDevice->GetProcessor()->GetDeviceByPhysicalAddress(iPhysicalAddress);
 442 }
 443
 444 void CCECCommandHandler::SetVendorId(const cec_command &command)
 445 {
 446   if (command.parameters.size < 3)
 447   {
 448     m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
 449     return;
 450   }
 451
 452   uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
 453                        ((uint64_t)command.parameters[1] << 8) +
 454                         (uint64_t)command.parameters[2];
 455
 456   CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
 457   if (device)
 458     device->SetVendorId(iVendorId, command.parameters.size > 3 ? command.parameters[3] : 0);
 459 }
 460
 461 const char *CCECCommandHandler::ToString(const cec_logical_address address)
 462 {
 463   switch(address)
 464   {
 465   case CECDEVICE_AUDIOSYSTEM:
 466     return "Audio";
 467   case CECDEVICE_BROADCAST:
 468     return "Broadcast";
 469   case CECDEVICE_FREEUSE:
 470     return "Free use";
 471   case CECDEVICE_PLAYBACKDEVICE1:
 472     return "Playback 1";
 473   case CECDEVICE_PLAYBACKDEVICE2:
 474     return "Playback 2";
 475   case CECDEVICE_PLAYBACKDEVICE3:
 476     return "Playback 3";
 477   case CECDEVICE_RECORDINGDEVICE1:
 478     return "Recorder 1";
 479   case CECDEVICE_RECORDINGDEVICE2:
 480     return "Recorder 2";
 481   case CECDEVICE_RECORDINGDEVICE3:
 482     return "Recorder 3";
 483   case CECDEVICE_RESERVED1:
 484     return "Reserved 1";
 485   case CECDEVICE_RESERVED2:
 486     return "Reserved 2";
 487   case CECDEVICE_TUNER1:
 488     return "Tuner 1";
 489   case CECDEVICE_TUNER2:
 490     return "Tuner 2";
 491   case CECDEVICE_TUNER3:
 492     return "Tuner 3";
 493   case CECDEVICE_TUNER4:
 494     return "Tuner 4";
 495   case CECDEVICE_TV:
 496     return "TV";
 497   default:
 498     return "unknown";
 499   }
 500 }
 501
 502 const char *CCECCommandHandler::ToString(const cec_deck_info status)
 503 {
 504   switch (status)
 505   {
 506   case CEC_DECK_INFO_PLAY:
 507     return "play";
 508   case CEC_DECK_INFO_RECORD:
 509     return "record";
 510   case CEC_DECK_INFO_PLAY_REVERSE:
 511     return "play reverse";
 512   case CEC_DECK_INFO_STILL:
 513     return "still";
 514   case CEC_DECK_INFO_SLOW:
 515     return "slow";
 516   case CEC_DECK_INFO_SLOW_REVERSE:
 517     return "slow reverse";
 518   case CEC_DECK_INFO_FAST_FORWARD:
 519     return "fast forward";
 520   case CEC_DECK_INFO_FAST_REVERSE:
 521     return "fast reverse";
 522   case CEC_DECK_INFO_NO_MEDIA:
 523     return "no media";
 524   case CEC_DECK_INFO_STOP:
 525     return "stop";
 526   case CEC_DECK_INFO_SKIP_FORWARD_WIND:
 527     return "info skip forward wind";
 528   case CEC_DECK_INFO_SKIP_REVERSE_REWIND:
 529     return "info skip reverse rewind";
 530   case CEC_DECK_INFO_INDEX_SEARCH_FORWARD:
 531     return "info index search forward";
 532   case CEC_DECK_INFO_INDEX_SEARCH_REVERSE:
 533     return "info index search reverse";
 534   case CEC_DECK_INFO_OTHER_STATUS:
 535     return "other";
 536   default:
 537     return "unknown";
 538   }
 539 }
 540
 541 const char *CCECCommandHandler::ToString(const cec_opcode opcode)
 542 {
 543   switch (opcode)
 544   {
 545   case CEC_OPCODE_ACTIVE_SOURCE:
 546     return "active source";
 547   case CEC_OPCODE_IMAGE_VIEW_ON:
 548     return "image view on";
 549   case CEC_OPCODE_TEXT_VIEW_ON:
 550     return "text view on";
 551   case CEC_OPCODE_INACTIVE_SOURCE:
 552     return "inactive source";
 553   case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 554     return "request active source";
 555   case CEC_OPCODE_ROUTING_CHANGE:
 556     return "routing change";
 557   case CEC_OPCODE_ROUTING_INFORMATION:
 558     return "routing information";
 559   case CEC_OPCODE_SET_STREAM_PATH:
 560     return "set stream path";
 561   case CEC_OPCODE_STANDBY:
 562     return "standby";
 563   case CEC_OPCODE_RECORD_OFF:
 564     return "record off";
 565   case CEC_OPCODE_RECORD_ON:
 566     return "record on";
 567   case CEC_OPCODE_RECORD_STATUS:
 568     return "record status";
 569   case CEC_OPCODE_RECORD_TV_SCREEN:
 570     return "record tv screen";
 571   case CEC_OPCODE_CLEAR_ANALOGUE_TIMER:
 572     return "clear analogue timer";
 573   case CEC_OPCODE_CLEAR_DIGITAL_TIMER:
 574     return "clear digital timer";
 575   case CEC_OPCODE_CLEAR_EXTERNAL_TIMER:
 576     return "clear external timer";
 577   case CEC_OPCODE_SET_ANALOGUE_TIMER:
 578     return "set analogue timer";
 579   case CEC_OPCODE_SET_DIGITAL_TIMER:
 580     return "set digital timer";
 581   case CEC_OPCODE_SET_EXTERNAL_TIMER:
 582     return "set external timer";
 583   case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE:
 584     return "set timer program title";
 585   case CEC_OPCODE_TIMER_CLEARED_STATUS:
 586     return "timer cleared status";
 587   case CEC_OPCODE_TIMER_STATUS:
 588     return "timer status";
 589   case CEC_OPCODE_CEC_VERSION:
 590     return "cec version";
 591   case CEC_OPCODE_GET_CEC_VERSION:
 592     return "get cec version";
 593   case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
 594     return "give physical address";
 595   case CEC_OPCODE_GET_MENU_LANGUAGE:
 596     return "get menu language";
 597   case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
 598     return "report physical address";
 599   case CEC_OPCODE_SET_MENU_LANGUAGE:
 600     return "set menu language";
 601   case CEC_OPCODE_DECK_CONTROL:
 602     return "deck control";
 603   case CEC_OPCODE_DECK_STATUS:
 604     return "deck status";
 605   case CEC_OPCODE_GIVE_DECK_STATUS:
 606     return "give deck status";
 607   case CEC_OPCODE_PLAY:
 608     return "play";
 609   case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS:
 610     return "give tuner status";
 611   case CEC_OPCODE_SELECT_ANALOGUE_SERVICE:
 612     return "select analogue service";
 613   case CEC_OPCODE_SELECT_DIGITAL_SERVICE:
 614     return "set digital service";
 615   case CEC_OPCODE_TUNER_DEVICE_STATUS:
 616     return "tuner device status";
 617   case CEC_OPCODE_TUNER_STEP_DECREMENT:
 618     return "tuner step decrement";
 619   case CEC_OPCODE_TUNER_STEP_INCREMENT:
 620     return "tuner step increment";
 621   case CEC_OPCODE_DEVICE_VENDOR_ID:
 622     return "device vendor id";
 623   case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
 624     return "give device vendor id";
 625   case CEC_OPCODE_VENDOR_COMMAND:
 626     return "vendor command";
 627   case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
 628     return "vendor command with id";
 629   case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN:
 630     return "vendor remote button down";
 631   case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP:
 632     return "vendor remote button up";
 633   case CEC_OPCODE_SET_OSD_STRING:
 634     return "set osd string";
 635   case CEC_OPCODE_GIVE_OSD_NAME:
 636     return "give osd name";
 637   case CEC_OPCODE_SET_OSD_NAME:
 638     return "set osd name";
 639   case CEC_OPCODE_MENU_REQUEST:
 640     return "menu request";
 641   case CEC_OPCODE_MENU_STATUS:
 642     return "menu status";
 643   case CEC_OPCODE_USER_CONTROL_PRESSED:
 644     return "user control pressed";
 645   case CEC_OPCODE_USER_CONTROL_RELEASE:
 646     return "user control release";
 647   case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
 648     return "give device power status";
 649   case CEC_OPCODE_REPORT_POWER_STATUS:
 650     return "report power status";
 651   case CEC_OPCODE_FEATURE_ABORT:
 652     return "feature abort";
 653   case CEC_OPCODE_ABORT:
 654     return "abort";
 655   case CEC_OPCODE_GIVE_AUDIO_STATUS:
 656     return "give audio status";
 657   case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
 658     return "give audio mode status";
 659   case CEC_OPCODE_REPORT_AUDIO_STATUS:
 660     return "report audio status";
 661   case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
 662     return "set system audio mode";
 663   case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
 664     return "system audio mode request";
 665   case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
 666     return "system audio mode status";
 667   case CEC_OPCODE_SET_AUDIO_RATE:
 668     return "set audio rate";
 669   default:
 670     return "UNKNOWN";
 671   }
 672 }