X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2FLibCEC.cpp;h=c0931c3e963d3fb724c5da88ba7d74e9b2cd1502;hb=ebefc26c10d68ba9ced2a30c896dccc81c6c2eeb;hp=b64cdc709ad6ab22f7a7eb17dac3c2d264e24896;hpb=5f2f3609d7ee857ac7e5d03600fbd735e99c892f;p=deb_libcec.git

diff --git a/src/lib/LibCEC.cpp b/src/lib/LibCEC.cpp
index b64cdc7..c0931c3 100644
--- a/src/lib/LibCEC.cpp
+++ b/src/lib/LibCEC.cpp
@@ -35,12 +35,14 @@
 #include "adapter/USBCECAdapterDetection.h"
 #include "adapter/USBCECAdapterCommunication.h"
 #include "CECProcessor.h"
+#include "CECTypeUtils.h"
 #include "devices/CECAudioSystem.h"
 #include "devices/CECBusDevice.h"
 #include "devices/CECPlaybackDevice.h"
 #include "devices/CECTV.h"
 #include "platform/util/timeutils.h"
 #include "platform/util/StdString.h"
+#include "platform/util/util.h"
 
 #include "CECClient.h"
 
@@ -48,6 +50,7 @@ using namespace std;
 using namespace CEC;
 using namespace PLATFORM;
 
+//TODO replace deprecated constructor in 2.0
 CLibCEC::CLibCEC(const char *UNUSED(strDeviceName), cec_device_type_list UNUSED(types), uint16_t UNUSED(iPhysicalAddress) /* = 0 */) :
     m_iStartTime(GetTimeMs()),
     m_client(NULL)
@@ -55,6 +58,7 @@ CLibCEC::CLibCEC(const char *UNUSED(strDeviceName), cec_device_type_list UNUSED(
   m_cec = new CCECProcessor(this);
 }
 
+//TODO replace deprecated constructor in 2.0
 CLibCEC::CLibCEC(libcec_configuration *UNUSED(configuration)) :
     m_iStartTime(GetTimeMs()),
     m_client(NULL)
@@ -68,8 +72,7 @@ CLibCEC::~CLibCEC(void)
   UnregisterClients();
 
   // delete the adapter connection
-  delete m_cec;
-  m_cec = NULL;
+  DELETE_AND_NULL(m_cec);
 }
 
 bool CLibCEC::Open(const char *strPort, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
@@ -99,16 +102,24 @@ bool CLibCEC::Open(const char *strPort, uint32_t iTimeoutMs /* = CEC_DEFAULT_CON
 
 void CLibCEC::Close(void)
 {
+  if (!m_cec)
+    return;
+
   // unregister all clients
-  UnregisterClients();
+  m_cec->UnregisterClients();
 
   // close the connection
-  if (m_cec)
-    m_cec->Close();
+  m_cec->Close();
 }
 
 int8_t CLibCEC::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
 {
+  if (!CUSBCECAdapterDetection::CanAutodetect())
+  {
+    AddLog(CEC_LOG_WARNING, "libCEC has not been compiled with adapter detection code for this target, so the path to the COM port has to be provided to libCEC");
+    return 0;
+  }
+
   return CUSBCECAdapterDetection::FindAdapters(deviceList, iBufSize, strDevicePath);
 }
 
@@ -353,84 +364,17 @@ bool CLibCEC::GetNextCommand(cec_command *command)
 
 cec_device_type CLibCEC::GetType(cec_logical_address address)
 {
-  switch (address)
-  {
-    case CECDEVICE_AUDIOSYSTEM:
-      return CEC_DEVICE_TYPE_AUDIO_SYSTEM;
-    case CECDEVICE_PLAYBACKDEVICE1:
-    case CECDEVICE_PLAYBACKDEVICE2:
-    case CECDEVICE_PLAYBACKDEVICE3:
-      return CEC_DEVICE_TYPE_PLAYBACK_DEVICE;
-    case CECDEVICE_RECORDINGDEVICE1:
-    case CECDEVICE_RECORDINGDEVICE2:
-    case CECDEVICE_RECORDINGDEVICE3:
-      return CEC_DEVICE_TYPE_RECORDING_DEVICE;
-    case CECDEVICE_TUNER1:
-    case CECDEVICE_TUNER2:
-    case CECDEVICE_TUNER3:
-    case CECDEVICE_TUNER4:
-      return CEC_DEVICE_TYPE_TUNER;
-    case CECDEVICE_TV:
-      return CEC_DEVICE_TYPE_TV;
-    default:
-      return CEC_DEVICE_TYPE_RESERVED;
-  }
+  return CCECTypeUtils::GetType(address);
 }
 
 uint16_t CLibCEC::GetMaskForType(cec_logical_address address)
 {
-  return GetMaskForType(GetType(address));
+  return CCECTypeUtils::GetMaskForType(address);
 }
 
 uint16_t CLibCEC::GetMaskForType(cec_device_type type)
 {
-  switch (type)
-  {
-    case CEC_DEVICE_TYPE_AUDIO_SYSTEM:
-    {
-      cec_logical_addresses addr;
-      addr.Clear();
-      addr.Set(CECDEVICE_AUDIOSYSTEM);
-      return addr.AckMask();
-    }
-    case CEC_DEVICE_TYPE_PLAYBACK_DEVICE:
-    {
-      cec_logical_addresses addr;
-      addr.Clear();
-      addr.Set(CECDEVICE_PLAYBACKDEVICE1);
-      addr.Set(CECDEVICE_PLAYBACKDEVICE2);
-      addr.Set(CECDEVICE_PLAYBACKDEVICE3);
-      return addr.AckMask();
-    }
-    case CEC_DEVICE_TYPE_RECORDING_DEVICE:
-    {
-      cec_logical_addresses addr;
-      addr.Clear();
-      addr.Set(CECDEVICE_RECORDINGDEVICE1);
-      addr.Set(CECDEVICE_RECORDINGDEVICE2);
-      addr.Set(CECDEVICE_RECORDINGDEVICE3);
-      return addr.AckMask();
-    }
-    case CEC_DEVICE_TYPE_TUNER:
-    {
-      cec_logical_addresses addr;
-      addr.Clear();
-      addr.Set(CECDEVICE_TUNER1);
-      addr.Set(CECDEVICE_TUNER2);
-      addr.Set(CECDEVICE_TUNER3);
-      addr.Set(CECDEVICE_TUNER4);
-      return addr.AckMask();
-    }
-    case CEC_DEVICE_TYPE_TV:
-    {
-      cec_logical_addresses addr;
-      addr.Clear();
-      addr.Set(CECDEVICE_TV);
-      return addr.AckMask();
-    }
-    default:
-      return 0;
-  }
+  return CCECTypeUtils::GetMaskForType(type);
 }
 
 bool CLibCEC::IsValidPhysicalAddress(uint16_t iPhysicalAddress)
@@ -441,420 +385,67 @@ bool CLibCEC::IsValidPhysicalAddress(uint16_t iPhysicalAddress)
 
 const char *CLibCEC::ToString(const cec_device_type type)
 {
-  switch (type)
-  {
-  case CEC_DEVICE_TYPE_AUDIO_SYSTEM:
-    return "audio system";
-  case CEC_DEVICE_TYPE_PLAYBACK_DEVICE:
-    return "playback device";
-  case CEC_DEVICE_TYPE_RECORDING_DEVICE:
-      return "recording device";
-  case CEC_DEVICE_TYPE_RESERVED:
-      return "reserved";
-  case CEC_DEVICE_TYPE_TUNER:
-      return "tuner";
-  case CEC_DEVICE_TYPE_TV:
-      return "TV";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(type);
 }
 
 const char *CLibCEC::ToString(const cec_menu_state state)
 {
-  switch (state)
-  {
-  case CEC_MENU_STATE_ACTIVATED:
-    return "activated";
-  case CEC_MENU_STATE_DEACTIVATED:
-    return "deactivated";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(state);
 }
 
 const char *CLibCEC::ToString(const cec_version version)
 {
-  switch (version)
-  {
-  case CEC_VERSION_1_2:
-    return "1.2";
-  case CEC_VERSION_1_2A:
-    return "1.2a";
-  case CEC_VERSION_1_3:
-    return "1.3";
-  case CEC_VERSION_1_3A:
-    return "1.3a";
-  case CEC_VERSION_1_4:
-    return "1.4";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(version);
 }
 
 const char *CLibCEC::ToString(const cec_power_status status)
 {
-  switch (status)
-  {
-  case CEC_POWER_STATUS_ON:
-    return "on";
-  case CEC_POWER_STATUS_STANDBY:
-    return "standby";
-  case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
-    return "in transition from on to standby";
-  case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
-    return "in transition from standby to on";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(status);
 }
 
 const char *CLibCEC::ToString(const cec_logical_address address)
 {
-  switch(address)
-  {
-  case CECDEVICE_AUDIOSYSTEM:
-    return "Audio";
-  case CECDEVICE_BROADCAST:
-    return "Broadcast";
-  case CECDEVICE_FREEUSE:
-    return "Free use";
-  case CECDEVICE_PLAYBACKDEVICE1:
-    return "Playback 1";
-  case CECDEVICE_PLAYBACKDEVICE2:
-    return "Playback 2";
-  case CECDEVICE_PLAYBACKDEVICE3:
-    return "Playback 3";
-  case CECDEVICE_RECORDINGDEVICE1:
-    return "Recorder 1";
-  case CECDEVICE_RECORDINGDEVICE2:
-    return "Recorder 2";
-  case CECDEVICE_RECORDINGDEVICE3:
-    return "Recorder 3";
-  case CECDEVICE_RESERVED1:
-    return "Reserved 1";
-  case CECDEVICE_RESERVED2:
-    return "Reserved 2";
-  case CECDEVICE_TUNER1:
-    return "Tuner 1";
-  case CECDEVICE_TUNER2:
-    return "Tuner 2";
-  case CECDEVICE_TUNER3:
-    return "Tuner 3";
-  case CECDEVICE_TUNER4:
-    return "Tuner 4";
-  case CECDEVICE_TV:
-    return "TV";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(address);
 }
 
 const char *CLibCEC::ToString(const cec_deck_control_mode mode)
 {
-  switch (mode)
-  {
-  case CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND:
-    return "skip forward wind";
-  case CEC_DECK_CONTROL_MODE_EJECT:
-    return "eject";
-  case CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND:
-    return "reverse rewind";
-  case CEC_DECK_CONTROL_MODE_STOP:
-    return "stop";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(mode);
 }
 
 const char *CLibCEC::ToString(const cec_deck_info status)
 {
-  switch (status)
-  {
-  case CEC_DECK_INFO_PLAY:
-    return "play";
-  case CEC_DECK_INFO_RECORD:
-    return "record";
-  case CEC_DECK_INFO_PLAY_REVERSE:
-    return "play reverse";
-  case CEC_DECK_INFO_STILL:
-    return "still";
-  case CEC_DECK_INFO_SLOW:
-    return "slow";
-  case CEC_DECK_INFO_SLOW_REVERSE:
-    return "slow reverse";
-  case CEC_DECK_INFO_FAST_FORWARD:
-    return "fast forward";
-  case CEC_DECK_INFO_FAST_REVERSE:
-    return "fast reverse";
-  case CEC_DECK_INFO_NO_MEDIA:
-    return "no media";
-  case CEC_DECK_INFO_STOP:
-    return "stop";
-  case CEC_DECK_INFO_SKIP_FORWARD_WIND:
-    return "info skip forward wind";
-  case CEC_DECK_INFO_SKIP_REVERSE_REWIND:
-    return "info skip reverse rewind";
-  case CEC_DECK_INFO_INDEX_SEARCH_FORWARD:
-    return "info index search forward";
-  case CEC_DECK_INFO_INDEX_SEARCH_REVERSE:
-    return "info index search reverse";
-  case CEC_DECK_INFO_OTHER_STATUS:
-    return "other";
-  case CEC_DECK_INFO_OTHER_STATUS_LG:
-    return "LG other";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(status);
 }
 
 const char *CLibCEC::ToString(const cec_opcode opcode)
 {
-  switch (opcode)
-  {
-  case CEC_OPCODE_ACTIVE_SOURCE:
-    return "active source";
-  case CEC_OPCODE_IMAGE_VIEW_ON:
-    return "image view on";
-  case CEC_OPCODE_TEXT_VIEW_ON:
-    return "text view on";
-  case CEC_OPCODE_INACTIVE_SOURCE:
-    return "inactive source";
-  case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
-    return "request active source";
-  case CEC_OPCODE_ROUTING_CHANGE:
-    return "routing change";
-  case CEC_OPCODE_ROUTING_INFORMATION:
-    return "routing information";
-  case CEC_OPCODE_SET_STREAM_PATH:
-    return "set stream path";
-  case CEC_OPCODE_STANDBY:
-    return "standby";
-  case CEC_OPCODE_RECORD_OFF:
-    return "record off";
-  case CEC_OPCODE_RECORD_ON:
-    return "record on";
-  case CEC_OPCODE_RECORD_STATUS:
-    return "record status";
-  case CEC_OPCODE_RECORD_TV_SCREEN:
-    return "record tv screen";
-  case CEC_OPCODE_CLEAR_ANALOGUE_TIMER:
-    return "clear analogue timer";
-  case CEC_OPCODE_CLEAR_DIGITAL_TIMER:
-    return "clear digital timer";
-  case CEC_OPCODE_CLEAR_EXTERNAL_TIMER:
-    return "clear external timer";
-  case CEC_OPCODE_SET_ANALOGUE_TIMER:
-    return "set analogue timer";
-  case CEC_OPCODE_SET_DIGITAL_TIMER:
-    return "set digital timer";
-  case CEC_OPCODE_SET_EXTERNAL_TIMER:
-    return "set external timer";
-  case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE:
-    return "set timer program title";
-  case CEC_OPCODE_TIMER_CLEARED_STATUS:
-    return "timer cleared status";
-  case CEC_OPCODE_TIMER_STATUS:
-    return "timer status";
-  case CEC_OPCODE_CEC_VERSION:
-    return "cec version";
-  case CEC_OPCODE_GET_CEC_VERSION:
-    return "get cec version";
-  case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
-    return "give physical address";
-  case CEC_OPCODE_GET_MENU_LANGUAGE:
-    return "get menu language";
-  case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
-    return "report physical address";
-  case CEC_OPCODE_SET_MENU_LANGUAGE:
-    return "set menu language";
-  case CEC_OPCODE_DECK_CONTROL:
-    return "deck control";
-  case CEC_OPCODE_DECK_STATUS:
-    return "deck status";
-  case CEC_OPCODE_GIVE_DECK_STATUS:
-    return "give deck status";
-  case CEC_OPCODE_PLAY:
-    return "play";
-  case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS:
-    return "give tuner status";
-  case CEC_OPCODE_SELECT_ANALOGUE_SERVICE:
-    return "select analogue service";
-  case CEC_OPCODE_SELECT_DIGITAL_SERVICE:
-    return "set digital service";
-  case CEC_OPCODE_TUNER_DEVICE_STATUS:
-    return "tuner device status";
-  case CEC_OPCODE_TUNER_STEP_DECREMENT:
-    return "tuner step decrement";
-  case CEC_OPCODE_TUNER_STEP_INCREMENT:
-    return "tuner step increment";
-  case CEC_OPCODE_DEVICE_VENDOR_ID:
-    return "device vendor id";
-  case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
-    return "give device vendor id";
-  case CEC_OPCODE_VENDOR_COMMAND:
-    return "vendor command";
-  case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
-    return "vendor command with id";
-  case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN:
-    return "vendor remote button down";
-  case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP:
-    return "vendor remote button up";
-  case CEC_OPCODE_SET_OSD_STRING:
-    return "set osd string";
-  case CEC_OPCODE_GIVE_OSD_NAME:
-    return "give osd name";
-  case CEC_OPCODE_SET_OSD_NAME:
-    return "set osd name";
-  case CEC_OPCODE_MENU_REQUEST:
-    return "menu request";
-  case CEC_OPCODE_MENU_STATUS:
-    return "menu status";
-  case CEC_OPCODE_USER_CONTROL_PRESSED:
-    return "user control pressed";
-  case CEC_OPCODE_USER_CONTROL_RELEASE:
-    return "user control release";
-  case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
-    return "give device power status";
-  case CEC_OPCODE_REPORT_POWER_STATUS:
-    return "report power status";
-  case CEC_OPCODE_FEATURE_ABORT:
-    return "feature abort";
-  case CEC_OPCODE_ABORT:
-    return "abort";
-  case CEC_OPCODE_GIVE_AUDIO_STATUS:
-    return "give audio status";
-  case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
-    return "give audio mode status";
-  case CEC_OPCODE_REPORT_AUDIO_STATUS:
-    return "report audio status";
-  case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
-    return "set system audio mode";
-  case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
-    return "system audio mode request";
-  case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
-    return "system audio mode status";
-  case CEC_OPCODE_SET_AUDIO_RATE:
-    return "set audio rate";
-  case CEC_OPCODE_START_ARC:
-    return "start ARC";
-  case CEC_OPCODE_REPORT_ARC_STARTED:
-    return "report ARC started";
-  case CEC_OPCODE_REPORT_ARC_ENDED:
-    return "report ARC ended";
-  case CEC_OPCODE_REQUEST_ARC_START:
-    return "request ARC start";
-  case CEC_OPCODE_REQUEST_ARC_END:
-    return "request ARC end";
-  case CEC_OPCODE_END_ARC:
-    return "end ARC";
-  case CEC_OPCODE_CDC:
-    return "CDC";
-  case CEC_OPCODE_NONE:
-    return "poll";
-  default:
-    return "UNKNOWN";
-  }
+  return CCECTypeUtils::ToString(opcode);
 }
 
 const char *CLibCEC::ToString(const cec_system_audio_status mode)
 {
-  switch(mode)
-  {
-  case CEC_SYSTEM_AUDIO_STATUS_ON:
-    return "on";
-  case CEC_SYSTEM_AUDIO_STATUS_OFF:
-    return "off";
-  default:
-    return "unknown";
-  }
+  return CCECTypeUtils::ToString(mode);
 }
 
-const char *CLibCEC::ToString(const cec_audio_status UNUSED(status))
+const char *CLibCEC::ToString(const cec_audio_status status)
 {
-  // TODO this is a mask
-  return "TODO";
+  return CCECTypeUtils::ToString(status);
 }
 
 const char *CLibCEC::ToString(const cec_vendor_id vendor)
 {
-  switch (vendor)
-  {
-  case CEC_VENDOR_SAMSUNG:
-    return "Samsung";
-  case CEC_VENDOR_LG:
-    return "LG";
-  case CEC_VENDOR_PANASONIC:
-    return "Panasonic";
-  case CEC_VENDOR_PIONEER:
-    return "Pioneer";
-  case CEC_VENDOR_ONKYO:
-    return "Onkyo";
-  case CEC_VENDOR_YAMAHA:
-    return "Yamaha";
-  case CEC_VENDOR_PHILIPS:
-    return "Philips";
-  case CEC_VENDOR_SONY:
-    return "Sony";
-  case CEC_VENDOR_TOSHIBA:
-    return "Toshiba";
-  default:
-    return "Unknown";
-  }
+  return CCECTypeUtils::ToString(vendor);
 }
 
 const char *CLibCEC::ToString(const cec_client_version version)
 {
-  switch (version)
-  {
-  case CEC_CLIENT_VERSION_PRE_1_5:
-    return "pre-1.5";
-  case CEC_CLIENT_VERSION_1_5_0:
-    return "1.5.0";
-  case CEC_CLIENT_VERSION_1_5_1:
-    return "1.5.1";
-  case CEC_CLIENT_VERSION_1_5_2:
-    return "1.5.2";
-  case CEC_CLIENT_VERSION_1_5_3:
-    return "1.5.3";
-  case CEC_CLIENT_VERSION_1_6_0:
-    return "1.6.0";
-  case CEC_CLIENT_VERSION_1_6_1:
-    return "1.6.1";
-  case CEC_CLIENT_VERSION_1_6_2:
-    return "1.6.2";
-  case CEC_CLIENT_VERSION_1_6_3:
-    return "1.6.3";
-  default:
-    return "Unknown";
-  }
+  return CCECTypeUtils::ToString(version);
 }
 
 const char *CLibCEC::ToString(const cec_server_version version)
 {
-  switch (version)
-  {
-  case CEC_SERVER_VERSION_PRE_1_5:
-    return "pre-1.5";
-  case CEC_SERVER_VERSION_1_5_0:
-    return "1.5.0";
-  case CEC_SERVER_VERSION_1_5_1:
-    return "1.5.1";
-  case CEC_SERVER_VERSION_1_5_2:
-    return "1.5.2";
-  case CEC_SERVER_VERSION_1_5_3:
-    return "1.5.3";
-  case CEC_SERVER_VERSION_1_6_0:
-    return "1.6.0";
-  case CEC_SERVER_VERSION_1_6_1:
-    return "1.6.1";
-  case CEC_SERVER_VERSION_1_6_2:
-    return "1.6.2";
-  case CEC_SERVER_VERSION_1_6_3:
-    return "1.6.3";
-  default:
-    return "Unknown";
-  }
+  return CCECTypeUtils::ToString(version);
 }
 
 void CLibCEC::CheckKeypressTimeout(void)
@@ -884,6 +475,13 @@ void CLibCEC::AddLog(const cec_log_level level, const char *strFormat, ...)
     (*it)->AddLog(message);
 }
 
+void CLibCEC::AddCommand(const cec_command &command)
+{
+  // send the command to all clients
+  for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++)
+    (*it)->AddCommand(command);
+}
+
 void CLibCEC::Alert(const libcec_alert type, const libcec_parameter &param)
 {
   // send the alert to all clients
@@ -932,8 +530,7 @@ void CLibCEC::UnregisterClients(void)
 
   m_clients.clear();
 
-  delete m_client;
-  m_client = NULL;
+  DELETE_AND_NULL(m_client);
 }
 
 void * CECInitialise(libcec_configuration *configuration)
@@ -959,14 +556,14 @@ void * CECInitialise(libcec_configuration *configuration)
   return static_cast< void* > (lib);
 }
 
-void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types, uint16_t iPhysicalAddress /* = 0 */)
+void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types)
 {
-  libcec_configuration configuration;
+  libcec_configuration configuration; configuration.Clear();
 
   // client version < 1.5.0
   snprintf(configuration.strDeviceName, 13, "%s", strDeviceName);
   configuration.deviceTypes      = types;
-  configuration.iPhysicalAddress = iPhysicalAddress;
+  configuration.iPhysicalAddress = CEC_INVALID_PHYSICAL_ADDRESS;
 
   if (configuration.deviceTypes.IsEmpty())
     configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
@@ -974,6 +571,18 @@ void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types, uint1
   return CECInitialise(&configuration);
 }
 
+void * CECCreate(const char *strDeviceName, CEC::cec_logical_address iLogicalAddress /* = CEC::CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */)
+{
+  libcec_configuration configuration; configuration.Clear();
+
+  // client version < 1.5.0
+  snprintf(configuration.strDeviceName, 13, "%s", strDeviceName);
+  configuration.iPhysicalAddress = iPhysicalAddress;
+  configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
+
+  return CECInitialise(&configuration);
+}
+
 bool CECStartBootloader(void)
 {
   bool bReturn(false);
@@ -996,7 +605,7 @@ bool CECStartBootloader(void)
 
 void CECDestroy(CEC::ICECAdapter *instance)
 {
-  delete instance;
+  DELETE_AND_NULL(instance);
 }
 
 bool CLibCEC::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
@@ -1009,7 +618,6 @@ bool CLibCEC::GetDeviceInformation(const char *strPort, libcec_configuration *co
 
 // no longer being used
 void CLibCEC::AddKey(const cec_keypress &UNUSED(key)) {}
-void CLibCEC::AddCommand(const cec_command &UNUSED(command)) {}
 void CLibCEC::ConfigurationChanged(const libcec_configuration &UNUSED(config)) {}
 void CLibCEC::SetCurrentButton(cec_user_control_code UNUSED(iButtonCode)) {}
 CLibCEC *CLibCEC::GetInstance(void) { return NULL; }