src/lib/LibCEC.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 "LibCEC.h"
  34
  35 #include "AdapterCommunication.h"
  36 #include "AdapterDetection.h"
  37 #include "CECProcessor.h"
  38 #include "util/StdString.h"
  39 #include "platform/timeutils.h"
  40
  41 using namespace std;
  42 using namespace CEC;
  43
  44 CLibCEC::CLibCEC(const char *strDeviceName, cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */) :
  45     m_iStartTime(GetTimeMs()),
  46     m_iCurrentButton(CEC_USER_CONTROL_CODE_UNKNOWN),
  47     m_buttontime(0)
  48 {
  49   m_comm = new CAdapterCommunication(this);
  50   m_cec = new CCECProcessor(this, m_comm, strDeviceName, iLogicalAddress, iPhysicalAddress);
  51 }
  52
  53 CLibCEC::~CLibCEC(void)
  54 {
  55   Close();
  56   delete m_cec;
  57   m_cec = NULL;
  58
  59   delete m_comm;
  60   m_comm = NULL;
  61
  62   m_logBuffer.Clear();
  63   m_keyBuffer.Clear();
  64   m_commandBuffer.Clear();
  65 }
  66
  67 bool CLibCEC::Open(const char *strPort, uint32_t iTimeoutMs /* = 10000 */)
  68 {
  69   if (!m_comm)
  70   {
  71     AddLog(CEC_LOG_ERROR, "no comm port");
  72     return false;
  73   }
  74
  75   if (m_comm->IsOpen())
  76   {
  77     AddLog(CEC_LOG_ERROR, "connection already open");
  78     return false;
  79   }
  80
  81   int64_t iNow = GetTimeMs();
  82   int64_t iTarget = iNow + iTimeoutMs;
  83
  84   bool bOpened(false);
  85   while (!bOpened && iNow < iTarget)
  86   {
  87     bOpened = m_comm->Open(strPort, 38400, iTimeoutMs);
  88     iNow = GetTimeMs();
  89   }
  90
  91   if (!bOpened)
  92   {
  93     AddLog(CEC_LOG_ERROR, "could not open a connection");
  94     return false;
  95   }
  96
  97   if (!m_cec->Start())
  98   {
  99     AddLog(CEC_LOG_ERROR, "could not start CEC communications");
 100     return false;
 101   }
 102
 103   return true;
 104 }
 105
 106 void CLibCEC::Close(void)
 107 {
 108   if (m_cec)
 109     m_cec->StopThread();
 110   if (m_comm)
 111     m_comm->Close();
 112 }
 113
 114 int8_t CLibCEC::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
 115 {
 116   CStdString strDebug;
 117   if (strDevicePath)
 118     strDebug.Format("trying to autodetect the com port for device path '%s'", strDevicePath);
 119   else
 120     strDebug.Format("trying to autodetect all CEC adapters");
 121   AddLog(CEC_LOG_DEBUG, strDebug);
 122
 123   return CAdapterDetection::FindAdapters(deviceList, iBufSize, strDevicePath);
 124 }
 125
 126 bool CLibCEC::PingAdapter(void)
 127 {
 128   return m_comm ? m_comm->PingAdapter() : false;
 129 }
 130
 131 bool CLibCEC::StartBootloader(void)
 132 {
 133   return m_comm ? m_comm->StartBootloader() : false;
 134 }
 135
 136 int8_t CLibCEC::GetMinVersion(void)
 137 {
 138   return CEC_MIN_VERSION;
 139 }
 140
 141 int8_t CLibCEC::GetLibVersion(void)
 142 {
 143   return CEC_LIB_VERSION;
 144 }
 145
 146 bool CLibCEC::GetNextLogMessage(cec_log_message *message)
 147 {
 148   return (m_logBuffer.Pop(*message));
 149 }
 150
 151 bool CLibCEC::GetNextKeypress(cec_keypress *key)
 152 {
 153   return m_keyBuffer.Pop(*key);
 154 }
 155
 156 bool CLibCEC::GetNextCommand(cec_command *command)
 157 {
 158   return m_commandBuffer.Pop(*command);
 159 }
 160
 161 bool CLibCEC::Transmit(const cec_command &data, bool bWaitForAck /* = true */)
 162 {
 163   return m_cec ? m_cec->Transmit(data, bWaitForAck) : false;
 164 }
 165
 166 bool CLibCEC::SetLogicalAddress(cec_logical_address iLogicalAddress)
 167 {
 168   return m_cec ? m_cec->SetLogicalAddress(iLogicalAddress) : false;
 169 }
 170
 171 bool CLibCEC::SetPhysicalAddress(uint16_t iPhysicalAddress)
 172 {
 173   return m_cec ? m_cec->SetPhysicalAddress(iPhysicalAddress) : false;
 174 }
 175
 176 bool CLibCEC::PowerOnDevices(cec_logical_address address /* = CECDEVICE_TV */)
 177 {
 178   return m_cec ? m_cec->PowerOnDevices(address) : false;
 179 }
 180
 181 bool CLibCEC::StandbyDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */)
 182 {
 183   return m_cec ? m_cec->StandbyDevices(address) : false;
 184 }
 185
 186 bool CLibCEC::SetActiveView(void)
 187 {
 188   return m_cec ? m_cec->SetActiveView() : false;
 189 }
 190
 191 bool CLibCEC::SetInactiveView(void)
 192 {
 193   return m_cec ? m_cec->SetInactiveView() : false;
 194 }
 195
 196 void CLibCEC::AddLog(cec_log_level level, const string &strMessage)
 197 {
 198   if (m_cec)
 199   {
 200     cec_log_message message;
 201     message.level = level;
 202     message.time = GetTimeMs() - m_iStartTime;
 203     snprintf(message.message, sizeof(message.message), "%s", strMessage.c_str());
 204     m_logBuffer.Push(message);
 205   }
 206 }
 207
 208 void CLibCEC::AddKey(void)
 209 {
 210   if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN)
 211   {
 212     cec_keypress key;
 213
 214     key.duration = (unsigned int) (GetTimeMs() - m_buttontime);
 215     key.keycode = m_iCurrentButton;
 216     m_keyBuffer.Push(key);
 217     m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
 218     m_buttontime = 0;
 219   }
 220 }
 221
 222 void CLibCEC::AddCommand(cec_command &command)
 223 {
 224   if (m_commandBuffer.Push(command))
 225   {
 226     CStdString strDebug;
 227     strDebug.Format("stored command '%2x' in the command buffer. buffer size = %d", command.opcode, m_commandBuffer.Size());
 228     AddLog(CEC_LOG_DEBUG, strDebug);
 229   }
 230   else
 231   {
 232     AddLog(CEC_LOG_WARNING, "command buffer is full");
 233   }
 234 }
 235
 236 void CLibCEC::CheckKeypressTimeout(void)
 237 {
 238   if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN && GetTimeMs() - m_buttontime > CEC_BUTTON_TIMEOUT)
 239   {
 240     AddKey();
 241     m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
 242   }
 243 }
 244
 245 void CLibCEC::SetCurrentButton(cec_user_control_code iButtonCode)
 246 {
 247   m_iCurrentButton = iButtonCode;
 248   m_buttontime = GetTimeMs();
 249 }
 250
 251 void * CECCreate(const char *strDeviceName, CEC::cec_logical_address iLogicalAddress /*= CEC::CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */)
 252 {
 253   return static_cast< void* > (new CLibCEC(strDeviceName, iLogicalAddress, iPhysicalAddress));
 254 }
 255
 256 void CECDestroy(CEC::ICECAdapter *instance)
 257 {
 258   CLibCEC *lib = static_cast< CLibCEC* > (instance);
 259   if (lib)
 260     delete lib;
 261 }