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 "../CECProcessor.h"
  37
  38 using namespace CEC;
  39
  40 CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice)
  41 {
  42   m_busDevice = busDevice;
  43 }
  44
  45 bool CCECCommandHandler::HandleCommand(const cec_command &command)
  46 {
  47   bool bHandled(true);
  48
  49   if (m_busDevice->MyLogicalAddressContains(command.destination))
  50   {
  51     switch(command.opcode)
  52     {
  53     case CEC_OPCODE_REPORT_POWER_STATUS:
  54       HandleReportPowerStatus(command);
  55       break;
  56     case CEC_OPCODE_CEC_VERSION:
  57       HandleDeviceCecVersion(command);
  58       break;
  59     case CEC_OPCODE_SET_MENU_LANGUAGE:
  60       HandleSetMenuLanguage(command);
  61       m_busDevice->GetProcessor()->AddCommand(command);
  62       break;
  63     case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
  64       HandleGivePhysicalAddress(command);
  65       break;
  66     case CEC_OPCODE_GIVE_OSD_NAME:
  67       HandleGiveOSDName(command);
  68       break;
  69     case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
  70       HandleGiveDeviceVendorId(command);
  71       break;
  72     case CEC_OPCODE_DEVICE_VENDOR_ID:
  73       HandleDeviceVendorId(command);
  74       break;
  75     case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
  76       HandleDeviceVendorCommandWithId(command);
  77       break;
  78     case CEC_OPCODE_GIVE_DECK_STATUS:
  79       HandleGiveDeckStatus(command);
  80       break;
  81     case CEC_OPCODE_MENU_REQUEST:
  82       HandleMenuRequest(command);
  83       break;
  84     case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
  85       HandleGiveDevicePowerStatus(command);
  86       break;
  87     case CEC_OPCODE_GET_CEC_VERSION:
  88       HandleGetCecVersion(command);
  89       break;
  90     case CEC_OPCODE_USER_CONTROL_PRESSED:
  91       HandleUserControlPressed(command);
  92       break;
  93     case CEC_OPCODE_USER_CONTROL_RELEASE:
  94       HandleUserControlRelease(command);
  95       break;
  96     case CEC_OPCODE_GIVE_AUDIO_STATUS:
  97       HandleGiveAudioStatus(command);
  98       break;
  99     default:
 100       UnhandledCommand(command);
 101       m_busDevice->GetProcessor()->AddCommand(command);
 102       bHandled = false;
 103       break;
 104     }
 105   }
 106   else if (command.destination == CECDEVICE_BROADCAST)
 107   {
 108     CStdString strLog;
 109     switch (command.opcode)
 110     {
 111     case CEC_OPCODE_SET_MENU_LANGUAGE:
 112       HandleSetMenuLanguage(command);
 113       m_busDevice->GetProcessor()->AddCommand(command);
 114       break;
 115     case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
 116       HandleRequestActiveSource(command);
 117       break;
 118     case CEC_OPCODE_SET_STREAM_PATH:
 119       HandleSetStreamPath(command);
 120       m_busDevice->GetProcessor()->AddCommand(command);
 121       break;
 122     case CEC_OPCODE_ROUTING_CHANGE:
 123       HandleRoutingChange(command);
 124       m_busDevice->GetProcessor()->AddCommand(command);
 125       break;
 126     case CEC_OPCODE_DEVICE_VENDOR_ID:
 127       HandleDeviceVendorId(command);
 128       break;
 129     case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
 130       HandleDeviceVendorCommandWithId(command);
 131      break;
 132     default:
 133       UnhandledCommand(command);
 134       m_busDevice->GetProcessor()->AddCommand(command);
 135       bHandled = false;
 136       break;
 137     }
 138   }
 139   else
 140   {
 141     CStdString strLog;
 142     strLog.Format("ignoring frame: we're not at destination %x", command.destination);
 143     m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 144     bHandled = false;
 145   }
 146
 147   return bHandled;
 148 }
 149
 150 bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
 151 {
 152   if (command.parameters.size == 1)
 153   {
 154     CCECBusDevice *device = GetDevice(command.initiator);
 155     if (device)
 156       device->SetCecVersion((cec_version) command.parameters[0]);
 157   }
 158
 159   return true;
 160 }
 161
 162 bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
 163 {
 164   CCECBusDevice *device = GetDevice(command.initiator);
 165   if (device)
 166     device->SetVendorId(command.parameters);
 167
 168   return true;
 169 }
 170
 171 bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
 172 {
 173   CCECBusDevice *device = GetDevice(command.initiator);
 174   if (device)
 175     device->SetVendorId(command.parameters);
 176
 177   return true;
 178 }
 179
 180 bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
 181 {
 182   CCECBusDevice *device = GetDevice(command.destination);
 183   if (device)
 184     return device->TransmitCECVersion(command.initiator);
 185
 186   return false;
 187 }
 188
 189 bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
 190 {
 191   CCECBusDevice *device = GetDevice(command.destination);
 192   if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
 193     return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
 194
 195   return false;
 196 }
 197
 198 bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
 199 {
 200   CCECBusDevice *device = GetDevice(command.destination);
 201   if (device)
 202     return device->TransmitDeckStatus(command.initiator);
 203
 204   return false;
 205 }
 206
 207 bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
 208 {
 209   CCECBusDevice *device = GetDevice(command.destination);
 210   if (device)
 211     return device->TransmitPowerState(command.initiator);
 212
 213   return false;
 214 }
 215
 216 bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
 217 {
 218   CCECBusDevice *device = GetDevice(command.destination);
 219   if (device)
 220     return device->TransmitVendorID(command.initiator);
 221
 222   return false;
 223 }
 224
 225 bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
 226 {
 227   CCECBusDevice *device = GetDevice(command.destination);
 228   if (device)
 229     return device->TransmitOSDName(command.initiator);
 230
 231   return false;
 232 }
 233
 234 bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
 235 {
 236   CCECBusDevice *device = GetDevice(command.destination);
 237   if (device)
 238     return device->TransmitPhysicalAddress();
 239
 240   return false;
 241 }
 242
 243 bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
 244 {
 245   if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
 246   {
 247     CCECBusDevice *device = GetDevice(command.destination);
 248     if (device)
 249       return device->TransmitMenuState(command.initiator);
 250   }
 251   return false;
 252 }
 253
 254 bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
 255 {
 256   if (command.parameters.size == 1)
 257   {
 258     CCECBusDevice *device = GetDevice(command.initiator);
 259     if (device)
 260       device->SetPowerStatus((cec_power_status) command.parameters[0]);
 261   }
 262   return true;
 263 }
 264
 265 bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
 266 {
 267   CStdString strLog;
 268   strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
 269   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 270   CCECBusDevice *device = m_busDevice->GetProcessor()->m_busDevices[m_busDevice->GetMyLogicalAddress()];
 271   if (device)
 272     return device->TransmitActiveSource();
 273   return false;
 274 }
 275
 276 bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
 277 {
 278   if (command.parameters.size == 4)
 279   {
 280     uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 281     uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
 282
 283     CCECBusDevice *device = GetDevice(command.initiator);
 284     if (device)
 285       device->SetPhysicalAddress(iNewAddress, iOldAddress);
 286   }
 287   return true;
 288 }
 289
 290 bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
 291 {
 292   if (command.parameters.size == 3)
 293   {
 294     CCECBusDevice *device = GetDevice(command.initiator);
 295     if (device)
 296     {
 297       cec_menu_language language;
 298       language.device = command.initiator;
 299       for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
 300         language.language[iPtr] = command.parameters[iPtr];
 301       language.language[3] = 0;
 302       device->SetMenuLanguage(language);
 303     }
 304   }
 305   return true;
 306 }
 307
 308 bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
 309 {
 310   if (command.parameters.size >= 2)
 311   {
 312     int streamaddr = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
 313     CStdString strLog;
 314     strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
 315     m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 316     CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
 317     if (device)
 318       return device->TransmitActiveSource();
 319   }
 320   return true;
 321 }
 322
 323 bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
 324 {
 325   if (command.parameters.size > 0)
 326   {
 327     m_busDevice->GetProcessor()->AddKey();
 328
 329     if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
 330     {
 331       CStdString strLog;
 332       strLog.Format("key pressed: %1x", command.parameters[0]);
 333       m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
 334
 335       m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
 336     }
 337   }
 338   return true;
 339 }
 340
 341 bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
 342 {
 343   m_busDevice->GetProcessor()->AddKey();
 344   return true;
 345 }
 346
 347 void CCECCommandHandler::UnhandledCommand(const cec_command &command)
 348 {
 349   CStdString strLog;
 350   strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
 351   m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
 352 }
 353
 354 CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
 355 {
 356   CCECBusDevice *device = NULL;
 357
 358   if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
 359     device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
 360
 361   return device;
 362 }
 363
 364 CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
 365 {
 366   CCECBusDevice *device = NULL;
 367
 368   for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 369   {
 370     if (m_busDevice->GetProcessor()->m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
 371     {
 372       device = m_busDevice->GetProcessor()->m_busDevices[iPtr];
 373       break;
 374     }
 375   }
 376
 377   return device;
 378 }