src/lib/LibCECC.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 "cec.h"
  35 #include "cecc.h"
  36
  37 using namespace CEC;
  38 using namespace std;
  39
  40 /*!
  41  * C interface implementation
  42  */
  43 //@{
  44 ICECAdapter *cec_parser;
  45
  46 int cec_initialise(libcec_configuration *configuration)
  47 {
  48   cec_parser = (ICECAdapter *) CECInitialise(configuration);
  49   return (cec_parser != NULL) ? 1 : 0;
  50 }
  51
  52 int cec_init_typed(const char *strDeviceName, cec_device_type_list deviceTypes)
  53 {
  54   cec_parser = (ICECAdapter *) CECInit(strDeviceName, deviceTypes);
  55   return (cec_parser != NULL) ? 1 : 0;
  56 }
  57
  58 void cec_destroy(void)
  59 {
  60   cec_close();
  61   CECDestroy(cec_parser);
  62   cec_parser = NULL;
  63 }
  64
  65 int cec_open(const char *strPort, uint32_t iTimeout)
  66 {
  67   if (cec_parser)
  68     return cec_parser->Open(strPort, iTimeout);
  69   return false;
  70 }
  71
  72 void cec_close(void)
  73 {
  74   if (cec_parser)
  75     cec_parser->Close();
  76 }
  77
  78 int cec_enable_callbacks(void *cbParam, ICECCallbacks *callbacks)
  79 {
  80   if (cec_parser)
  81     return cec_parser->EnableCallbacks(cbParam, callbacks) ? 1 : 0;
  82   return -1;
  83 }
  84
  85 int8_t cec_find_adapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
  86 {
  87   if (cec_parser)
  88     return cec_parser->FindAdapters(deviceList, iBufSize, strDevicePath);
  89   return -1;
  90 }
  91
  92 int cec_ping_adapters(void)
  93 {
  94   if (cec_parser)
  95     return cec_parser->PingAdapter() ? 1 : 0;
  96   return -1;
  97 }
  98
  99 int cec_start_bootloader(void)
 100 {
 101   if (cec_parser)
 102     return cec_parser->StartBootloader() ? 1 : 0;
 103   return -1;
 104 }
 105
 106 int8_t cec_get_min_lib_version(void)
 107 {
 108   if (cec_parser)
 109     return cec_parser->GetMinLibVersion();
 110   return -1;
 111 }
 112
 113 int8_t cec_get_lib_version_major(void)
 114 {
 115   if (cec_parser)
 116     return cec_parser->GetLibVersionMajor();
 117   return -1;
 118 }
 119
 120 int8_t cec_get_lib_version_minor(void)
 121 {
 122   if (cec_parser)
 123     return cec_parser->GetLibVersionMinor();
 124   return -1;
 125 }
 126
 127 int cec_get_next_log_message(cec_log_message *message)
 128 {
 129   if (cec_parser)
 130     return cec_parser->GetNextLogMessage(message) ? 1 : 0;
 131   return -1;
 132 }
 133
 134 int cec_get_next_keypress(cec_keypress *key)
 135 {
 136   if (cec_parser)
 137     return cec_parser->GetNextKeypress(key) ? 1 : 0;
 138   return -1;
 139 }
 140
 141 int cec_get_next_command(cec_command *command)
 142 {
 143   if (cec_parser)
 144     return cec_parser->GetNextCommand(command) ? 1 : 0;
 145   return -1;
 146 }
 147
 148 int cec_transmit(const CEC::cec_command *data)
 149 {
 150   if (cec_parser)
 151     return cec_parser->Transmit(*data) ? 1 : 0;
 152   return -1;
 153 }
 154
 155 int cec_set_logical_address(cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */)
 156 {
 157   if (cec_parser)
 158     return cec_parser->SetLogicalAddress(iLogicalAddress) ? 1 : 0;
 159   return -1;
 160 }
 161
 162 int cec_set_physical_address(uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */)
 163 {
 164   if (cec_parser)
 165     return cec_parser->SetPhysicalAddress(iPhysicalAddress) ? 1 : 0;
 166   return -1;
 167 }
 168
 169 int cec_power_on_devices(cec_logical_address address /* = CECDEVICE_TV */)
 170 {
 171   if (cec_parser)
 172     return cec_parser->PowerOnDevices(address) ? 1 : 0;
 173   return -1;
 174 }
 175
 176 int cec_standby_devices(cec_logical_address address /* = CECDEVICE_BROADCAST */)
 177 {
 178   if (cec_parser)
 179     return cec_parser->StandbyDevices(address) ? 1 : 0;
 180   return -1;
 181 }
 182
 183 int cec_set_active_view(void)
 184 {
 185   if (cec_parser)
 186     return cec_parser->SetActiveView() ? 1 : 0;
 187   return -1;
 188 }
 189
 190 int cec_set_active_source(cec_device_type type)
 191 {
 192   if (cec_parser)
 193     return cec_parser->SetActiveSource(type) ? 1 : 0;
 194   return -1;
 195 }
 196
 197 int cec_set_deck_control_mode(cec_deck_control_mode mode, int bSendUpdate) {
 198   if (cec_parser)
 199     return cec_parser->SetDeckControlMode(mode, bSendUpdate == 1) ? 1 : 0;
 200   return -1;
 201 }
 202
 203 int cec_set_deck_info(cec_deck_info info, int bSendUpdate) {
 204   if (cec_parser)
 205     return cec_parser->SetDeckInfo(info, bSendUpdate == 1) ? 1 : 0;
 206   return -1;
 207
 208 }
 209
 210 int cec_set_inactive_view(void)
 211 {
 212   if (cec_parser)
 213     return cec_parser->SetInactiveView() ? 1 : 0;
 214   return -1;
 215 }
 216
 217 int cec_set_menu_state(cec_menu_state state, int bSendUpdate) {
 218   if (cec_parser)
 219     return cec_parser->SetMenuState(state, bSendUpdate == 1) ? 1 : 0;
 220   return -1;
 221 }
 222
 223 int cec_set_osd_string(cec_logical_address iLogicalAddress, cec_display_control duration, const char *strMessage)
 224 {
 225   if (cec_parser)
 226     return cec_parser->SetOSDString(iLogicalAddress, duration, strMessage) ? 1 : 0;
 227   return -1;
 228 }
 229
 230 int cec_switch_monitoring(int bEnable)
 231 {
 232   if (cec_parser)
 233     return cec_parser->SwitchMonitoring(bEnable == 1) ? 1 : 0;
 234   return -1;
 235 }
 236
 237 cec_version cec_get_device_cec_version(cec_logical_address iLogicalAddress)
 238 {
 239   if (cec_parser)
 240     return cec_parser->GetDeviceCecVersion(iLogicalAddress);
 241   return CEC_VERSION_UNKNOWN;
 242 }
 243
 244 int cec_get_device_menu_language(cec_logical_address iLogicalAddress, cec_menu_language *language)
 245 {
 246   if (cec_parser)
 247     return cec_parser->GetDeviceMenuLanguage(iLogicalAddress, language) ? 1 : 0;
 248   return -1;
 249 }
 250
 251 uint64_t cec_get_device_vendor_id(cec_logical_address iLogicalAddress)
 252 {
 253   if (cec_parser)
 254     return cec_parser->GetDeviceVendorId(iLogicalAddress);
 255   return 0;
 256 }
 257
 258 uint16_t cec_get_device_physical_address(cec_logical_address iLogicalAddress)
 259 {
 260   if (cec_parser)
 261     return cec_parser->GetDevicePhysicalAddress(iLogicalAddress);
 262   return 0;
 263 }
 264
 265 cec_logical_address cec_get_active_source(void)
 266 {
 267   if (cec_parser)
 268     return cec_parser->GetActiveSource();
 269   return CECDEVICE_UNKNOWN;
 270 }
 271
 272 int cec_is_active_source(cec_logical_address iAddress)
 273 {
 274   if (cec_parser)
 275     return cec_parser->IsActiveSource(iAddress);
 276   return false;
 277 }
 278
 279 cec_power_status cec_get_device_power_status(cec_logical_address iLogicalAddress)
 280 {
 281   if (cec_parser)
 282     return cec_parser->GetDevicePowerStatus(iLogicalAddress);
 283   return CEC_POWER_STATUS_UNKNOWN;
 284 }
 285
 286 int cec_poll_device(cec_logical_address iLogicalAddress)
 287 {
 288   if (cec_parser)
 289     return cec_parser->PollDevice(iLogicalAddress) ? 1 : 0;
 290   return -1;
 291 }
 292
 293 cec_logical_addresses cec_get_active_devices(void)
 294 {
 295   cec_logical_addresses addresses;
 296   addresses.Clear();
 297   if (cec_parser)
 298     addresses = cec_parser->GetActiveDevices();
 299   return addresses;
 300 }
 301
 302 int cec_is_active_device(cec_logical_address iAddress)
 303 {
 304   if (cec_parser)
 305     return cec_parser->IsActiveDevice(iAddress) ? 1 : 0;
 306   return -1;
 307 }
 308
 309 int cec_is_active_device_type(cec_device_type type)
 310 {
 311   if (cec_parser)
 312     return cec_parser->IsActiveDeviceType(type) ? 1 : 0;
 313   return -1;
 314 }
 315
 316 int cec_set_hdmi_port(cec_logical_address iBaseDevice, uint8_t iPort)
 317 {
 318   if (cec_parser)
 319     return cec_parser->SetHDMIPort(iBaseDevice, iPort) ? 1 : 0;
 320   return -1;
 321 }
 322
 323 int cec_volume_up(int bSendRelease)
 324 {
 325   if (cec_parser)
 326     return cec_parser->VolumeUp(bSendRelease == 1);
 327   return -1;
 328 }
 329
 330 int cec_volume_down(int bSendRelease)
 331 {
 332   if (cec_parser)
 333     return cec_parser->VolumeDown(bSendRelease == 1);
 334   return -1;
 335 }
 336
 337 int cec_mute_audio(int bSendRelease)
 338 {
 339   if (cec_parser)
 340     return cec_parser->MuteAudio(bSendRelease == 1);
 341   return -1;
 342 }
 343
 344 int cec_send_keypress(cec_logical_address iDestination, cec_user_control_code key, int bWait)
 345 {
 346   if (cec_parser)
 347     return cec_parser->SendKeypress(iDestination, key, bWait == 1) ? 1 : 0;
 348   return -1;
 349 }
 350
 351 int cec_send_key_release(cec_logical_address iDestination, int bWait)
 352 {
 353   if (cec_parser)
 354     return cec_parser->SendKeyRelease(iDestination, bWait == 1) ? 1 : 0;
 355   return -1;
 356 }
 357
 358 cec_osd_name cec_get_device_osd_name(cec_logical_address iAddress)
 359 {
 360   cec_osd_name retVal;
 361   retVal.device = iAddress;
 362   retVal.name[0] = 0;
 363
 364   if (cec_parser)
 365     retVal = cec_parser->GetDeviceOSDName(iAddress);
 366
 367   return retVal;
 368 }
 369
 370 int cec_enable_physical_address_detection(void)
 371 {
 372   return cec_parser ? (cec_parser->EnablePhysicalAddressDetection() ? 1 : 0) : -1;
 373 }
 374
 375 int cec_set_stream_path_logical(CEC::cec_logical_address iAddress)
 376 {
 377   return cec_parser ? (cec_parser->SetStreamPath(iAddress) ? 1 : 0) : -1;
 378 }
 379
 380 int cec_set_stream_path_physical(uint16_t iPhysicalAddress)
 381 {
 382   return cec_parser ? (cec_parser->SetStreamPath(iPhysicalAddress) ? 1 : 0) : -1;
 383 }
 384
 385 cec_logical_addresses cec_get_logical_addresses(void)
 386 {
 387   cec_logical_addresses addr;
 388   addr.Clear();
 389   if (cec_parser)
 390     addr = cec_parser->GetLogicalAddresses();
 391   return addr;
 392 }
 393
 394 int cec_get_current_configuration(libcec_configuration *configuration)
 395 {
 396   return cec_parser ? (cec_parser->GetCurrentConfiguration(configuration) ? 1 : 0) : -1;
 397 }
 398
 399 int cec_can_persist_configuration(void)
 400 {
 401   return cec_parser ? (cec_parser->CanPersistConfiguration() ? 1 : 0) : -1;
 402 }
 403
 404 int cec_persist_configuration(libcec_configuration *configuration)
 405 {
 406   return cec_parser ? (cec_parser->PersistConfiguration(configuration) ? 1 : 0) : -1;
 407 }
 408
 409 int cec_set_configuration(libcec_configuration *configuration)
 410 {
 411   return cec_parser ? (cec_parser->SetConfiguration(configuration) ? 1 : 0) : -1;
 412 }
 413
 414 void cec_rescan_devices(void)
 415 {
 416   if (cec_parser)
 417     cec_parser->RescanActiveDevices();
 418 }
 419
 420 int cec_is_libcec_active_source(void)
 421 {
 422   return cec_parser ? (cec_parser->IsLibCECActiveSource() ? 1 : 0) : -1;
 423 }
 424
 425 int cec_get_device_information(const char *strPort, CEC::libcec_configuration *config, uint32_t iTimeoutMs)
 426 {
 427   return cec_parser ? (cec_parser->GetDeviceInformation(strPort, config, iTimeoutMs) ? 1 : 0) : -1;
 428 }
 429
 430 const char * cec_get_lib_info(void)
 431 {
 432   return cec_parser ? cec_parser->GetLibInfo() : NULL;
 433 }
 434
 435 void cec_init_video_standalone(void)
 436 {
 437   if (cec_parser)
 438     cec_parser->InitVideoStandalone();
 439 }
 440
 441 //@}