src/lib/implementations/VLCommandHandler.cpp

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