src/lib/implementations/VLCommandHandler.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2013 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 "env.h"
  34 #include "VLCommandHandler.h"
  35
  36 #include "lib/devices/CECBusDevice.h"
  37 #include "lib/devices/CECPlaybackDevice.h"
  38 #include "lib/devices/CECTV.h"
  39 #include "lib/CECProcessor.h"
  40 #include "lib/LibCEC.h"
  41 #include "lib/CECClient.h"
  42
  43 #define VL_POWER_CHANGE 0x20
  44 #define VL_POWERED_UP   0x00
  45 #define VL_POWERED_DOWN 0x01
  46 #define VL_UNKNOWN1     0x06
  47
  48 using namespace CEC;
  49 using namespace PLATFORM;
  50
  51 #define LIB_CEC     m_busDevice->GetProcessor()->GetLib()
  52 #define ToString(p) LIB_CEC->ToString(p)
  53
  54 // wait this amount of ms before trying to switch sources after receiving the message from the TV that it's powered on
  55 #define SOURCE_SWITCH_DELAY_MS 3000
  56
  57 CVLCommandHandler::CVLCommandHandler(CCECBusDevice *busDevice,
  58                                      int32_t iTransmitTimeout /* = CEC_DEFAULT_TRANSMIT_TIMEOUT */,
  59                                      int32_t iTransmitWait /* = CEC_DEFAULT_TRANSMIT_WAIT */,
  60                                      int8_t iTransmitRetries /* = CEC_DEFAULT_TRANSMIT_RETRIES */,
  61                                      int64_t iActiveSourcePending /* = 0 */) :
  62     CCECCommandHandler(busDevice, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending),
  63     m_iPowerUpEventReceived(0),
  64     m_bCapabilitiesSent(false)
  65 {
  66   m_vendorId = CEC_VENDOR_PANASONIC;
  67 }
  68
  69 bool CVLCommandHandler::InitHandler(void)
  70 {
  71   CCECBusDevice *primary = m_processor->GetPrimaryDevice();
  72   if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
  73   {
  74     /* use the VL commandhandler for the primary device that is handled by libCEC */
  75     if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
  76     {
  77       if (primary && m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
  78       {
  79         libcec_configuration config;
  80         m_processor->GetPrimaryClient()->GetCurrentConfiguration(config);
  81         if (config.iDoubleTapTimeoutMs == 0)
  82         {
  83           config.iDoubleTapTimeoutMs = CEC_DOUBLE_TAP_TIMEOUT_MS;
  84           m_processor->GetPrimaryClient()->SetConfiguration(config);
  85         }
  86
  87         primary->SetVendorId(CEC_VENDOR_PANASONIC);
  88         primary->ReplaceHandler(false);
  89       }
  90
  91       if (primary->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
  92         return m_processor->GetPrimaryClient()->ChangeDeviceType(CEC_DEVICE_TYPE_RECORDING_DEVICE, CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
  93     }
  94   }
  95
  96   return CCECCommandHandler::InitHandler();
  97 }
  98
  99 int CVLCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
 100 {
 101   if (!m_processor->IsHandledByLibCEC(command.destination))
 102     return CEC_ABORT_REASON_INVALID_OPERAND;
 103
 104   if (command.parameters[0] != 0x00 ||
 105       command.parameters[1] != 0x80 ||
 106       command.parameters[2] != 0x45)
 107     return CEC_ABORT_REASON_INVALID_OPERAND;
 108
 109   // XXX this is also sent when the TV is powered off
 110 #if 0
 111   if (command.initiator == CECDEVICE_TV &&
 112       command.parameters.At(3) == VL_UNKNOWN1)
 113   {
 114     // set the power up event time
 115     {
 116       CLockObject lock(m_mutex);
 117       if (m_iPowerUpEventReceived == 0)
 118         m_iPowerUpEventReceived = GetTimeMs();
 119     }
 120     // mark the TV as powered on
 121     m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
 122   }
 123   else
 124 #endif
 125     if (command.initiator == CECDEVICE_TV &&
 126       command.destination == CECDEVICE_BROADCAST &&
 127       command.parameters.At(3) == VL_POWER_CHANGE)
 128   {
 129     if (command.parameters.At(4) == VL_POWERED_UP)
 130     {
 131       // set the power up event time
 132       {
 133         CLockObject lock(m_mutex);
 134         if (m_iPowerUpEventReceived == 0)
 135           m_iPowerUpEventReceived = GetTimeMs();
 136       }
 137       // mark the TV as powered on
 138       m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
 139
 140       // send capabilties
 141       SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
 142
 143       // reactivate the source, so the tv switches channels
 144       if (m_processor->IsActiveSource(m_processor->GetLogicalAddress()))
 145         m_processor->GetDevice(m_processor->GetLogicalAddress())->TransmitActiveSource(false);
 146     }
 147     else if (command.parameters.At(4) == VL_POWERED_DOWN)
 148     {
 149       // reset the power up event time
 150       {
 151         CLockObject lock(m_mutex);
 152         m_iPowerUpEventReceived = 0;
 153       }
 154       // mark the TV as powered off
 155       m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
 156     }
 157     else
 158       LIB_CEC->AddLog(CEC_LOG_DEBUG, "skipping unknown vendor command");
 159
 160     return COMMAND_HANDLED;
 161   }
 162
 163   return CCECCommandHandler::HandleDeviceVendorCommandWithId(command);
 164 }
 165
 166 bool CVLCommandHandler::PowerUpEventReceived(void)
 167 {
 168   bool bPowerUpEventReceived(true);
 169
 170   if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
 171   {
 172     CCECBusDevice* tv = m_processor->GetTV();
 173     if (tv && tv->GetStatus() != CEC_DEVICE_STATUS_PRESENT)
 174       return true;
 175
 176     // get the status from the TV
 177     if (tv && tv->GetCurrentVendorId() == CEC_VENDOR_PANASONIC)
 178     {
 179       CVLCommandHandler *handler = static_cast<CVLCommandHandler *>(tv->GetHandler());
 180       bPowerUpEventReceived = handler ? handler->PowerUpEventReceived() : false;
 181       tv->MarkHandlerReady();
 182     }
 183   }
 184   else
 185   {
 186     // get the current status
 187     {
 188       CLockObject lock(m_mutex);
 189       bPowerUpEventReceived = m_iPowerUpEventReceived > 0 &&
 190                               GetTimeMs() - m_iPowerUpEventReceived > SOURCE_SWITCH_DELAY_MS;
 191     }
 192
 193     // if we didn't receive the event, check if the TV is already marked as powered on
 194     if (!bPowerUpEventReceived && m_busDevice->GetCurrentPowerStatus() == CEC_POWER_STATUS_ON)
 195     {
 196       CLockObject lock(m_mutex);
 197       m_iPowerUpEventReceived = GetTimeMs();
 198       bPowerUpEventReceived = true;
 199     }
 200   }
 201
 202   return bPowerUpEventReceived;
 203 }
 204
 205 int CVLCommandHandler::HandleStandby(const cec_command &command)
 206 {
 207   // reset the power up event time
 208   {
 209     CLockObject lock(m_mutex);
 210     m_iPowerUpEventReceived = 0;
 211     m_bCapabilitiesSent = false;
 212   }
 213
 214   return CCECCommandHandler::HandleStandby(command);
 215 }
 216
 217 void CVLCommandHandler::VendorPreActivateSourceHook(void)
 218 {
 219   bool bTransmit(false);
 220   {
 221     CLockObject lock(m_mutex);
 222     bTransmit = !m_bCapabilitiesSent;
 223   }
 224   if (bTransmit)
 225     SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), CECDEVICE_TV);
 226 }
 227
 228 void CVLCommandHandler::SendVendorCommandCapabilities(const cec_logical_address initiator, const cec_logical_address destination)
 229 {
 230   if (PowerUpEventReceived())
 231   {
 232     cec_command response;
 233     cec_command::Format(response, initiator, destination, CEC_OPCODE_VENDOR_COMMAND);
 234     uint8_t iResponseData[] = {0x10, 0x02, 0xFF, 0xFF, 0x00, 0x05, 0x05, 0x45, 0x55, 0x5c, 0x58, 0x32};
 235     response.PushArray(12, iResponseData);
 236
 237     if (Transmit(response, false, true))
 238     {
 239       CLockObject lock(m_mutex);
 240       m_bCapabilitiesSent = true;
 241     }
 242   }
 243 }
 244
 245 int CVLCommandHandler::HandleVendorCommand(const cec_command &command)
 246 {
 247   // some vendor command voodoo that will enable more buttons on the remote
 248   if (command.parameters.size == 3 &&
 249       command.parameters[0] == 0x10 &&
 250       command.parameters[1] == 0x01 &&
 251       command.parameters[2] == 0x05 &&
 252       m_processor->IsHandledByLibCEC(command.destination))
 253   {
 254     SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
 255     return COMMAND_HANDLED;
 256   }
 257
 258   return CEC_ABORT_REASON_INVALID_OPERAND;
 259 }
 260
 261 bool CVLCommandHandler::SourceSwitchAllowed(void)
 262 {
 263   if (!PowerUpEventReceived())
 264     TransmitRequestPowerStatus(m_processor->GetPrimaryDevice()->GetLogicalAddress(), CECDEVICE_TV, false);
 265
 266   return PowerUpEventReceived();
 267 }
 268
 269 int CVLCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
 270 {
 271   if (command.initiator == CECDEVICE_TV)
 272   {
 273     // set the power up event time
 274     {
 275       CLockObject lock(m_mutex);
 276       if (m_iPowerUpEventReceived == 0)
 277         m_iPowerUpEventReceived = GetTimeMs();
 278     }
 279     // mark the TV as powered on
 280     m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
 281   }
 282
 283   return CCECCommandHandler::HandleSystemAudioModeRequest(command);
 284 }
 285
 286 int CVLCommandHandler::HandleReportPowerStatus(const cec_command &command)
 287 {
 288   if (command.initiator == m_busDevice->GetLogicalAddress() &&
 289       command.parameters.size == 1 &&
 290       (cec_power_status)command.parameters[0] == CEC_POWER_STATUS_ON)
 291   {
 292     CLockObject lock(m_mutex);
 293     if (m_iPowerUpEventReceived == 0)
 294       m_iPowerUpEventReceived = GetTimeMs();
 295   }
 296
 297   return CCECCommandHandler::HandleReportPowerStatus(command);
 298 }