Commit | Line | Data |
---|---|---|
2abe74eb LOK |
1 | /* |
2 | * This file is part of the libCEC(R) library. | |
3 | * | |
b492c10e | 4 | * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved. |
2abe74eb LOK |
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 | ||
7bb4ed43 | 35 | #include "adapter/USBCECAdapterDetection.h" |
08d80226 | 36 | #include "adapter/USBCECAdapterCommunication.h" |
2abe74eb | 37 | #include "CECProcessor.h" |
004b8382 | 38 | #include "devices/CECAudioSystem.h" |
0f23c85c | 39 | #include "devices/CECBusDevice.h" |
004b8382 LOK |
40 | #include "devices/CECPlaybackDevice.h" |
41 | #include "devices/CECTV.h" | |
ba65909d LOK |
42 | #include "platform/util/timeutils.h" |
43 | #include "platform/util/StdString.h" | |
2abe74eb | 44 | |
004b8382 LOK |
45 | #include "CECClient.h" |
46 | ||
2abe74eb LOK |
47 | using namespace std; |
48 | using namespace CEC; | |
f00ff009 | 49 | using namespace PLATFORM; |
2abe74eb | 50 | |
c30acafa LOK |
51 | CLibCEC::CLibCEC(const char *UNUSED(strDeviceName), cec_device_type_list UNUSED(types), uint16_t UNUSED(iPhysicalAddress) /* = 0 */) : |
52 | m_iStartTime(GetTimeMs()), | |
53 | m_client(NULL) | |
54 | { | |
55 | m_cec = new CCECProcessor(this); | |
56 | } | |
57 | ||
58 | CLibCEC::CLibCEC(libcec_configuration *UNUSED(configuration)) : | |
59 | m_iStartTime(GetTimeMs()), | |
60 | m_client(NULL) | |
caca2d81 | 61 | { |
004b8382 | 62 | m_cec = new CCECProcessor(this); |
f8513317 LOK |
63 | } |
64 | ||
2abe74eb LOK |
65 | CLibCEC::~CLibCEC(void) |
66 | { | |
004b8382 LOK |
67 | delete m_client; |
68 | m_client = NULL; | |
2abe74eb | 69 | delete m_cec; |
004b8382 | 70 | m_cec = NULL; |
2abe74eb LOK |
71 | } |
72 | ||
b32ffd87 | 73 | bool CLibCEC::Open(const char *strPort, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */) |
2abe74eb | 74 | { |
99aeafb9 LOK |
75 | if (!m_cec) |
76 | return false; | |
77 | ||
1113cb7d | 78 | if (m_cec->IsRunning()) |
2abe74eb LOK |
79 | { |
80 | AddLog(CEC_LOG_ERROR, "connection already open"); | |
81 | return false; | |
82 | } | |
83 | ||
b32ffd87 | 84 | if (!m_cec->Start(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs)) |
2abe74eb LOK |
85 | { |
86 | AddLog(CEC_LOG_ERROR, "could not start CEC communications"); | |
87 | return false; | |
88 | } | |
89 | ||
004b8382 LOK |
90 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) |
91 | { | |
92 | if (!m_cec->RegisterClient(*it)) | |
93 | { | |
94 | AddLog(CEC_LOG_ERROR, "failed to register a CEC client"); | |
95 | return false; | |
96 | } | |
97 | } | |
98 | ||
2abe74eb LOK |
99 | return true; |
100 | } | |
101 | ||
102 | void CLibCEC::Close(void) | |
103 | { | |
fa4798bd | 104 | if (m_cec) |
99aeafb9 LOK |
105 | m_cec->Close(); |
106 | ||
107 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
547b390d | 108 | { |
99aeafb9 LOK |
109 | (*it)->SetRegistered(false); |
110 | (*it)->SetInitialised(false); | |
547b390d | 111 | } |
fa4798bd LOK |
112 | } |
113 | ||
25701fa6 | 114 | int8_t CLibCEC::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */) |
2abe74eb | 115 | { |
7bb4ed43 | 116 | return CUSBCECAdapterDetection::FindAdapters(deviceList, iBufSize, strDevicePath); |
2abe74eb LOK |
117 | } |
118 | ||
119 | bool CLibCEC::PingAdapter(void) | |
120 | { | |
1113cb7d | 121 | return m_cec ? m_cec->PingAdapter() : false; |
2abe74eb LOK |
122 | } |
123 | ||
124 | bool CLibCEC::StartBootloader(void) | |
125 | { | |
1113cb7d | 126 | return m_cec ? m_cec->StartBootloader() : false; |
2abe74eb LOK |
127 | } |
128 | ||
004b8382 | 129 | bool CLibCEC::SwitchMonitoring(bool bEnable) |
16b1e052 | 130 | { |
004b8382 | 131 | return m_cec ? m_cec->SwitchMonitoring(bEnable) : false; |
16b1e052 LOK |
132 | } |
133 | ||
004b8382 | 134 | cec_logical_address CLibCEC::GetActiveSource(void) |
2dbd78f8 | 135 | { |
004b8382 | 136 | return m_cec ? m_cec->GetActiveSource() : CECDEVICE_UNKNOWN; |
2dbd78f8 LOK |
137 | } |
138 | ||
004b8382 | 139 | bool CLibCEC::IsActiveSource(cec_logical_address iAddress) |
2abe74eb | 140 | { |
004b8382 | 141 | return m_cec ? m_cec->IsActiveSource(iAddress) : false; |
2abe74eb LOK |
142 | } |
143 | ||
004b8382 | 144 | bool CLibCEC::PollDevice(cec_logical_address iAddress) |
2abe74eb | 145 | { |
004b8382 | 146 | return m_cec ? m_cec->PollDevice(iAddress) : false; |
2abe74eb LOK |
147 | } |
148 | ||
004b8382 | 149 | cec_logical_addresses CLibCEC::GetActiveDevices(void) |
18203d17 | 150 | { |
004b8382 LOK |
151 | CECDEVICEVEC activeDevices; |
152 | if (m_cec) | |
153 | m_cec->GetDevices()->GetActive(activeDevices); | |
154 | return CCECDeviceMap::ToLogicalAddresses(activeDevices); | |
18203d17 LOK |
155 | } |
156 | ||
004b8382 | 157 | bool CLibCEC::IsActiveDevice(cec_logical_address iAddress) |
2abe74eb | 158 | { |
004b8382 LOK |
159 | cec_logical_addresses activeDevices = GetActiveDevices(); |
160 | return activeDevices.IsSet(iAddress); | |
2abe74eb LOK |
161 | } |
162 | ||
004b8382 | 163 | bool CLibCEC::IsActiveDeviceType(cec_device_type type) |
a9232a79 | 164 | { |
004b8382 LOK |
165 | CECDEVICEVEC activeDevices; |
166 | if (m_cec) | |
167 | m_cec->GetDevices()->GetActive(activeDevices); | |
168 | CCECDeviceMap::FilterType(type, activeDevices); | |
169 | return !activeDevices.empty(); | |
a9232a79 LOK |
170 | } |
171 | ||
004b8382 | 172 | bool CLibCEC::SetStreamPath(cec_logical_address iAddress) |
a9232a79 | 173 | { |
004b8382 LOK |
174 | uint16_t iPhysicalAddress = GetDevicePhysicalAddress(iAddress); |
175 | if (iPhysicalAddress != CEC_INVALID_PHYSICAL_ADDRESS) | |
176 | return SetStreamPath(iPhysicalAddress); | |
177 | return false; | |
a9232a79 LOK |
178 | } |
179 | ||
004b8382 | 180 | bool CLibCEC::SetStreamPath(uint16_t iPhysicalAddress) |
2abe74eb | 181 | { |
004b8382 | 182 | return m_cec->SetStreamPath(iPhysicalAddress); |
2abe74eb LOK |
183 | } |
184 | ||
004b8382 | 185 | bool CLibCEC::IsLibCECActiveSource(void) |
28fa6c97 | 186 | { |
004b8382 LOK |
187 | bool bReturn(false); |
188 | if (m_cec) | |
189 | { | |
190 | cec_logical_address activeSource = m_cec->GetActiveSource(); | |
191 | CCECBusDevice *device = m_cec->GetDevice(activeSource); | |
192 | if (device) | |
193 | bReturn = device->IsHandledByLibCEC(); | |
194 | } | |
195 | return bReturn; | |
28fa6c97 LOK |
196 | } |
197 | ||
004b8382 | 198 | bool CLibCEC::CanPersistConfiguration(void) |
1969b140 | 199 | { |
004b8382 | 200 | return m_cec->CanPersistConfiguration(); |
1969b140 LOK |
201 | } |
202 | ||
004b8382 | 203 | bool CLibCEC::PersistConfiguration(libcec_configuration *configuration) |
8b7e5ff6 | 204 | { |
004b8382 | 205 | return m_cec->PersistConfiguration(configuration); |
8b7e5ff6 LOK |
206 | } |
207 | ||
004b8382 | 208 | void CLibCEC::RescanActiveDevices(void) |
6a1c0009 | 209 | { |
004b8382 | 210 | return m_cec->RescanActiveDevices(); |
6a1c0009 LOK |
211 | } |
212 | ||
004b8382 | 213 | bool CLibCEC::EnableCallbacks(void *cbParam, ICECCallbacks *callbacks) |
a3269a0a | 214 | { |
004b8382 | 215 | return m_client ? m_client->EnableCallbacks(cbParam, callbacks) : false; |
a3269a0a LOK |
216 | } |
217 | ||
004b8382 | 218 | bool CLibCEC::GetCurrentConfiguration(libcec_configuration *configuration) |
44c74256 | 219 | { |
004b8382 | 220 | return m_client ? m_client->GetCurrentConfiguration(configuration) : false; |
44c74256 LOK |
221 | } |
222 | ||
004b8382 | 223 | bool CLibCEC::SetConfiguration(const libcec_configuration *configuration) |
eab72c40 | 224 | { |
004b8382 | 225 | return m_client ? m_client->SetConfiguration(configuration) : false; |
eab72c40 LOK |
226 | } |
227 | ||
004b8382 | 228 | bool CLibCEC::Transmit(const cec_command &data) |
b4b1b49b | 229 | { |
004b8382 | 230 | return m_client ? m_client->Transmit(data) : false; |
b4b1b49b LOK |
231 | } |
232 | ||
004b8382 | 233 | bool CLibCEC::SetLogicalAddress(cec_logical_address iLogicalAddress) |
b4b1b49b | 234 | { |
004b8382 | 235 | return m_client ? m_client->SetLogicalAddress(iLogicalAddress) : false; |
b4b1b49b LOK |
236 | } |
237 | ||
004b8382 | 238 | bool CLibCEC::SetPhysicalAddress(uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS */) |
e55f3f70 | 239 | { |
004b8382 | 240 | return m_client ? m_client->SetPhysicalAddress(iPhysicalAddress) : false; |
e55f3f70 | 241 | } |
44c74256 | 242 | |
004b8382 | 243 | bool CLibCEC::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort /* = CEC_DEFAULT_HDMI_PORT */) |
57f45e6c | 244 | { |
004b8382 | 245 | return m_client ? m_client->SetHDMIPort(iBaseDevice, iPort) : false; |
57f45e6c LOK |
246 | } |
247 | ||
004b8382 | 248 | bool CLibCEC::PowerOnDevices(cec_logical_address address /* = CECDEVICE_TV */) |
6d858ba4 | 249 | { |
004b8382 | 250 | return m_client ? m_client->SendPowerOnDevices(address) : false; |
6d858ba4 LOK |
251 | } |
252 | ||
004b8382 | 253 | bool CLibCEC::StandbyDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */) |
6d858ba4 | 254 | { |
004b8382 | 255 | return m_client ? m_client->SendStandbyDevices(address) : false; |
6d858ba4 LOK |
256 | } |
257 | ||
004b8382 | 258 | bool CLibCEC::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */) |
6d858ba4 | 259 | { |
004b8382 | 260 | return m_client ? m_client->SendSetActiveSource(type) : false; |
6d858ba4 LOK |
261 | } |
262 | ||
004b8382 | 263 | bool CLibCEC::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */) |
04e637f9 | 264 | { |
004b8382 | 265 | return m_client ? m_client->SendSetDeckControlMode(mode, bSendUpdate) : false; |
04e637f9 LOK |
266 | } |
267 | ||
004b8382 | 268 | bool CLibCEC::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true */) |
04e637f9 | 269 | { |
004b8382 | 270 | return m_client ? m_client->SendSetDeckInfo(info, bSendUpdate) : false; |
04e637f9 LOK |
271 | } |
272 | ||
004b8382 | 273 | bool CLibCEC::SetInactiveView(void) |
04e637f9 | 274 | { |
004b8382 | 275 | return m_client ? m_client->SendSetInactiveView() : false; |
04e637f9 LOK |
276 | } |
277 | ||
004b8382 | 278 | bool CLibCEC::SetMenuState(cec_menu_state state, bool bSendUpdate /* = true */) |
a33794d8 | 279 | { |
004b8382 | 280 | return m_client ? m_client->SendSetMenuState(state, bSendUpdate) : false; |
a33794d8 LOK |
281 | } |
282 | ||
004b8382 | 283 | bool CLibCEC::SetOSDString(cec_logical_address iLogicalAddress, cec_display_control duration, const char *strMessage) |
a33794d8 | 284 | { |
004b8382 | 285 | return m_client ? m_client->SendSetOSDString(iLogicalAddress, duration, strMessage) : false; |
a33794d8 LOK |
286 | } |
287 | ||
004b8382 | 288 | cec_version CLibCEC::GetDeviceCecVersion(cec_logical_address iAddress) |
ed21be2a | 289 | { |
004b8382 | 290 | return m_client ? m_client->GetDeviceCecVersion(iAddress) : CEC_VERSION_UNKNOWN; |
ed21be2a LOK |
291 | } |
292 | ||
004b8382 | 293 | bool CLibCEC::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language) |
2abe74eb | 294 | { |
004b8382 | 295 | return m_client ? m_client->GetDeviceMenuLanguage(iAddress, language) : false; |
2abe74eb LOK |
296 | } |
297 | ||
004b8382 | 298 | uint64_t CLibCEC::GetDeviceVendorId(cec_logical_address iAddress) |
95ba7a09 | 299 | { |
004b8382 | 300 | return m_client ? m_client->GetDeviceVendorId(iAddress) : (uint64_t)CEC_VENDOR_UNKNOWN; |
02e7043e LOK |
301 | } |
302 | ||
004b8382 | 303 | uint16_t CLibCEC::GetDevicePhysicalAddress(cec_logical_address iAddress) |
32403cc3 | 304 | { |
004b8382 | 305 | return m_client ? m_client->GetDevicePhysicalAddress(iAddress) : CEC_INVALID_PHYSICAL_ADDRESS; |
32403cc3 LOK |
306 | } |
307 | ||
004b8382 | 308 | cec_power_status CLibCEC::GetDevicePowerStatus(cec_logical_address iAddress) |
02e7043e | 309 | { |
004b8382 | 310 | return m_client ? m_client->GetDevicePowerStatus(iAddress) : CEC_POWER_STATUS_UNKNOWN; |
95ba7a09 LOK |
311 | } |
312 | ||
004b8382 | 313 | uint8_t CLibCEC::VolumeUp(bool bSendRelease /* = true */) |
2abe74eb | 314 | { |
004b8382 | 315 | return m_client ? m_client->SendVolumeUp(bSendRelease) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN; |
2abe74eb LOK |
316 | } |
317 | ||
004b8382 | 318 | uint8_t CLibCEC::VolumeDown(bool bSendRelease /* = true */) |
2abe74eb | 319 | { |
004b8382 | 320 | return m_client ? m_client->SendVolumeDown(bSendRelease) : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN; |
2abe74eb LOK |
321 | } |
322 | ||
004b8382 | 323 | uint8_t CLibCEC::MuteAudio(bool UNUSED(bSendRelease) /* = true */) |
b1c47f9d | 324 | { |
004b8382 | 325 | return m_client ? m_client->SendMuteAudio() : (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN; |
b1c47f9d LOK |
326 | } |
327 | ||
004b8382 | 328 | bool CLibCEC::SendKeypress(cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */) |
2abe74eb | 329 | { |
004b8382 | 330 | return m_client ? m_client->SendKeypress(iDestination, key, bWait) : false; |
2abe74eb LOK |
331 | } |
332 | ||
004b8382 | 333 | bool CLibCEC::SendKeyRelease(cec_logical_address iDestination, bool bWait /* = true */) |
e1804a4e | 334 | { |
004b8382 | 335 | return m_client ? m_client->SendKeyRelease(iDestination, bWait) : false; |
e1804a4e LOK |
336 | } |
337 | ||
004b8382 | 338 | cec_osd_name CLibCEC::GetDeviceOSDName(cec_logical_address iAddress) |
f42d3e0f | 339 | { |
004b8382 | 340 | cec_osd_name retVal; |
20505741 LOK |
341 | retVal.device = CECDEVICE_UNKNOWN; |
342 | memset(retVal.name, 0, 14); | |
343 | ||
004b8382 LOK |
344 | if (m_client) |
345 | retVal = m_client->GetDeviceOSDName(iAddress); | |
346 | return retVal; | |
f42d3e0f LOK |
347 | } |
348 | ||
004b8382 | 349 | cec_logical_addresses CLibCEC::GetLogicalAddresses(void) |
f42d3e0f | 350 | { |
004b8382 | 351 | cec_logical_addresses addresses; |
c30acafa | 352 | addresses.Clear(); |
004b8382 LOK |
353 | if (m_cec) |
354 | addresses = m_cec->GetLogicalAddresses(); | |
355 | return addresses; | |
f42d3e0f LOK |
356 | } |
357 | ||
004b8382 | 358 | bool CLibCEC::GetNextLogMessage(cec_log_message *message) |
80b72250 | 359 | { |
004b8382 | 360 | return m_client ? m_client->GetNextLogMessage(message) : false; |
80b72250 LOK |
361 | } |
362 | ||
004b8382 | 363 | bool CLibCEC::GetNextKeypress(cec_keypress *key) |
5477a250 | 364 | { |
004b8382 | 365 | return m_client ? m_client->GetNextKeypress(key) : false; |
5477a250 LOK |
366 | } |
367 | ||
004b8382 | 368 | bool CLibCEC::GetNextCommand(cec_command *command) |
5477a250 | 369 | { |
004b8382 | 370 | return m_client ? m_client->GetNextCommand(command) : false; |
5477a250 LOK |
371 | } |
372 | ||
004b8382 | 373 | cec_device_type CLibCEC::GetType(cec_logical_address address) |
f8513317 | 374 | { |
004b8382 LOK |
375 | switch (address) |
376 | { | |
377 | case CECDEVICE_AUDIOSYSTEM: | |
378 | return CEC_DEVICE_TYPE_AUDIO_SYSTEM; | |
379 | case CECDEVICE_PLAYBACKDEVICE1: | |
380 | case CECDEVICE_PLAYBACKDEVICE2: | |
381 | case CECDEVICE_PLAYBACKDEVICE3: | |
382 | return CEC_DEVICE_TYPE_PLAYBACK_DEVICE; | |
383 | case CECDEVICE_RECORDINGDEVICE1: | |
384 | case CECDEVICE_RECORDINGDEVICE2: | |
385 | case CECDEVICE_RECORDINGDEVICE3: | |
386 | return CEC_DEVICE_TYPE_RECORDING_DEVICE; | |
387 | case CECDEVICE_TUNER1: | |
388 | case CECDEVICE_TUNER2: | |
389 | case CECDEVICE_TUNER3: | |
390 | case CECDEVICE_TUNER4: | |
391 | return CEC_DEVICE_TYPE_TUNER; | |
392 | case CECDEVICE_TV: | |
393 | return CEC_DEVICE_TYPE_TV; | |
394 | default: | |
395 | return CEC_DEVICE_TYPE_RESERVED; | |
396 | } | |
f8513317 LOK |
397 | } |
398 | ||
004b8382 | 399 | uint16_t CLibCEC::GetMaskForType(cec_logical_address address) |
caca2d81 | 400 | { |
004b8382 | 401 | return GetMaskForType(GetType(address)); |
caca2d81 LOK |
402 | } |
403 | ||
004b8382 | 404 | uint16_t CLibCEC::GetMaskForType(cec_device_type type) |
a2198e5e | 405 | { |
004b8382 | 406 | switch (type) |
a2198e5e | 407 | { |
004b8382 | 408 | case CEC_DEVICE_TYPE_AUDIO_SYSTEM: |
08d80226 | 409 | { |
004b8382 LOK |
410 | cec_logical_addresses addr; |
411 | addr.Clear(); | |
412 | addr.Set(CECDEVICE_AUDIOSYSTEM); | |
413 | return addr.AckMask(); | |
08d80226 | 414 | } |
004b8382 LOK |
415 | case CEC_DEVICE_TYPE_PLAYBACK_DEVICE: |
416 | { | |
417 | cec_logical_addresses addr; | |
418 | addr.Clear(); | |
419 | addr.Set(CECDEVICE_PLAYBACKDEVICE1); | |
420 | addr.Set(CECDEVICE_PLAYBACKDEVICE2); | |
421 | addr.Set(CECDEVICE_PLAYBACKDEVICE3); | |
422 | return addr.AckMask(); | |
423 | } | |
424 | case CEC_DEVICE_TYPE_RECORDING_DEVICE: | |
425 | { | |
426 | cec_logical_addresses addr; | |
427 | addr.Clear(); | |
428 | addr.Set(CECDEVICE_RECORDINGDEVICE1); | |
429 | addr.Set(CECDEVICE_RECORDINGDEVICE2); | |
430 | addr.Set(CECDEVICE_RECORDINGDEVICE3); | |
431 | return addr.AckMask(); | |
432 | } | |
433 | case CEC_DEVICE_TYPE_TUNER: | |
434 | { | |
435 | cec_logical_addresses addr; | |
436 | addr.Clear(); | |
437 | addr.Set(CECDEVICE_TUNER1); | |
438 | addr.Set(CECDEVICE_TUNER2); | |
439 | addr.Set(CECDEVICE_TUNER3); | |
440 | addr.Set(CECDEVICE_TUNER4); | |
441 | return addr.AckMask(); | |
442 | } | |
443 | case CEC_DEVICE_TYPE_TV: | |
444 | { | |
445 | cec_logical_addresses addr; | |
446 | addr.Clear(); | |
447 | addr.Set(CECDEVICE_TV); | |
448 | return addr.AckMask(); | |
449 | } | |
450 | default: | |
451 | return 0; | |
a2198e5e | 452 | } |
004b8382 | 453 | } |
08d80226 | 454 | |
004b8382 LOK |
455 | bool CLibCEC::IsValidPhysicalAddress(uint16_t iPhysicalAddress) |
456 | { | |
457 | return iPhysicalAddress >= CEC_MIN_PHYSICAL_ADDRESS && | |
458 | iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS; | |
a2198e5e LOK |
459 | } |
460 | ||
004b8382 | 461 | const char *CLibCEC::ToString(const cec_device_type type) |
25701fa6 | 462 | { |
004b8382 LOK |
463 | switch (type) |
464 | { | |
465 | case CEC_DEVICE_TYPE_AUDIO_SYSTEM: | |
466 | return "audio system"; | |
467 | case CEC_DEVICE_TYPE_PLAYBACK_DEVICE: | |
468 | return "playback device"; | |
469 | case CEC_DEVICE_TYPE_RECORDING_DEVICE: | |
470 | return "recording device"; | |
471 | case CEC_DEVICE_TYPE_RESERVED: | |
472 | return "reserved"; | |
473 | case CEC_DEVICE_TYPE_TUNER: | |
474 | return "tuner"; | |
475 | case CEC_DEVICE_TYPE_TV: | |
476 | return "TV"; | |
477 | default: | |
478 | return "unknown"; | |
479 | } | |
25701fa6 | 480 | } |
03ae897d LOK |
481 | |
482 | const char *CLibCEC::ToString(const cec_menu_state state) | |
483 | { | |
004b8382 LOK |
484 | switch (state) |
485 | { | |
486 | case CEC_MENU_STATE_ACTIVATED: | |
487 | return "activated"; | |
488 | case CEC_MENU_STATE_DEACTIVATED: | |
489 | return "deactivated"; | |
490 | default: | |
491 | return "unknown"; | |
492 | } | |
03ae897d LOK |
493 | } |
494 | ||
495 | const char *CLibCEC::ToString(const cec_version version) | |
496 | { | |
004b8382 LOK |
497 | switch (version) |
498 | { | |
499 | case CEC_VERSION_1_2: | |
500 | return "1.2"; | |
501 | case CEC_VERSION_1_2A: | |
502 | return "1.2a"; | |
503 | case CEC_VERSION_1_3: | |
504 | return "1.3"; | |
505 | case CEC_VERSION_1_3A: | |
506 | return "1.3a"; | |
507 | case CEC_VERSION_1_4: | |
508 | return "1.4"; | |
509 | default: | |
510 | return "unknown"; | |
511 | } | |
03ae897d LOK |
512 | } |
513 | ||
514 | const char *CLibCEC::ToString(const cec_power_status status) | |
515 | { | |
004b8382 LOK |
516 | switch (status) |
517 | { | |
518 | case CEC_POWER_STATUS_ON: | |
519 | return "on"; | |
520 | case CEC_POWER_STATUS_STANDBY: | |
521 | return "standby"; | |
522 | case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY: | |
523 | return "in transition from on to standby"; | |
524 | case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON: | |
525 | return "in transition from standby to on"; | |
526 | default: | |
527 | return "unknown"; | |
528 | } | |
03ae897d LOK |
529 | } |
530 | ||
531 | const char *CLibCEC::ToString(const cec_logical_address address) | |
532 | { | |
004b8382 LOK |
533 | switch(address) |
534 | { | |
535 | case CECDEVICE_AUDIOSYSTEM: | |
536 | return "Audio"; | |
537 | case CECDEVICE_BROADCAST: | |
538 | return "Broadcast"; | |
539 | case CECDEVICE_FREEUSE: | |
540 | return "Free use"; | |
541 | case CECDEVICE_PLAYBACKDEVICE1: | |
542 | return "Playback 1"; | |
543 | case CECDEVICE_PLAYBACKDEVICE2: | |
544 | return "Playback 2"; | |
545 | case CECDEVICE_PLAYBACKDEVICE3: | |
546 | return "Playback 3"; | |
547 | case CECDEVICE_RECORDINGDEVICE1: | |
548 | return "Recorder 1"; | |
549 | case CECDEVICE_RECORDINGDEVICE2: | |
550 | return "Recorder 2"; | |
551 | case CECDEVICE_RECORDINGDEVICE3: | |
552 | return "Recorder 3"; | |
553 | case CECDEVICE_RESERVED1: | |
554 | return "Reserved 1"; | |
555 | case CECDEVICE_RESERVED2: | |
556 | return "Reserved 2"; | |
557 | case CECDEVICE_TUNER1: | |
558 | return "Tuner 1"; | |
559 | case CECDEVICE_TUNER2: | |
560 | return "Tuner 2"; | |
561 | case CECDEVICE_TUNER3: | |
562 | return "Tuner 3"; | |
563 | case CECDEVICE_TUNER4: | |
564 | return "Tuner 4"; | |
565 | case CECDEVICE_TV: | |
566 | return "TV"; | |
567 | default: | |
568 | return "unknown"; | |
569 | } | |
03ae897d LOK |
570 | } |
571 | ||
572 | const char *CLibCEC::ToString(const cec_deck_control_mode mode) | |
573 | { | |
004b8382 LOK |
574 | switch (mode) |
575 | { | |
576 | case CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND: | |
577 | return "skip forward wind"; | |
578 | case CEC_DECK_CONTROL_MODE_EJECT: | |
579 | return "eject"; | |
580 | case CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND: | |
581 | return "reverse rewind"; | |
582 | case CEC_DECK_CONTROL_MODE_STOP: | |
583 | return "stop"; | |
584 | default: | |
585 | return "unknown"; | |
586 | } | |
03ae897d LOK |
587 | } |
588 | ||
589 | const char *CLibCEC::ToString(const cec_deck_info status) | |
590 | { | |
004b8382 LOK |
591 | switch (status) |
592 | { | |
593 | case CEC_DECK_INFO_PLAY: | |
594 | return "play"; | |
595 | case CEC_DECK_INFO_RECORD: | |
596 | return "record"; | |
597 | case CEC_DECK_INFO_PLAY_REVERSE: | |
598 | return "play reverse"; | |
599 | case CEC_DECK_INFO_STILL: | |
600 | return "still"; | |
601 | case CEC_DECK_INFO_SLOW: | |
602 | return "slow"; | |
603 | case CEC_DECK_INFO_SLOW_REVERSE: | |
604 | return "slow reverse"; | |
605 | case CEC_DECK_INFO_FAST_FORWARD: | |
606 | return "fast forward"; | |
607 | case CEC_DECK_INFO_FAST_REVERSE: | |
608 | return "fast reverse"; | |
609 | case CEC_DECK_INFO_NO_MEDIA: | |
610 | return "no media"; | |
611 | case CEC_DECK_INFO_STOP: | |
612 | return "stop"; | |
613 | case CEC_DECK_INFO_SKIP_FORWARD_WIND: | |
614 | return "info skip forward wind"; | |
615 | case CEC_DECK_INFO_SKIP_REVERSE_REWIND: | |
616 | return "info skip reverse rewind"; | |
617 | case CEC_DECK_INFO_INDEX_SEARCH_FORWARD: | |
618 | return "info index search forward"; | |
619 | case CEC_DECK_INFO_INDEX_SEARCH_REVERSE: | |
620 | return "info index search reverse"; | |
621 | case CEC_DECK_INFO_OTHER_STATUS: | |
622 | return "other"; | |
623 | case CEC_DECK_INFO_OTHER_STATUS_LG: | |
624 | return "LG other"; | |
625 | default: | |
626 | return "unknown"; | |
627 | } | |
03ae897d LOK |
628 | } |
629 | ||
630 | const char *CLibCEC::ToString(const cec_opcode opcode) | |
631 | { | |
004b8382 LOK |
632 | switch (opcode) |
633 | { | |
634 | case CEC_OPCODE_ACTIVE_SOURCE: | |
635 | return "active source"; | |
636 | case CEC_OPCODE_IMAGE_VIEW_ON: | |
637 | return "image view on"; | |
638 | case CEC_OPCODE_TEXT_VIEW_ON: | |
639 | return "text view on"; | |
640 | case CEC_OPCODE_INACTIVE_SOURCE: | |
641 | return "inactive source"; | |
642 | case CEC_OPCODE_REQUEST_ACTIVE_SOURCE: | |
643 | return "request active source"; | |
644 | case CEC_OPCODE_ROUTING_CHANGE: | |
645 | return "routing change"; | |
646 | case CEC_OPCODE_ROUTING_INFORMATION: | |
647 | return "routing information"; | |
648 | case CEC_OPCODE_SET_STREAM_PATH: | |
649 | return "set stream path"; | |
650 | case CEC_OPCODE_STANDBY: | |
651 | return "standby"; | |
652 | case CEC_OPCODE_RECORD_OFF: | |
653 | return "record off"; | |
654 | case CEC_OPCODE_RECORD_ON: | |
655 | return "record on"; | |
656 | case CEC_OPCODE_RECORD_STATUS: | |
657 | return "record status"; | |
658 | case CEC_OPCODE_RECORD_TV_SCREEN: | |
659 | return "record tv screen"; | |
660 | case CEC_OPCODE_CLEAR_ANALOGUE_TIMER: | |
661 | return "clear analogue timer"; | |
662 | case CEC_OPCODE_CLEAR_DIGITAL_TIMER: | |
663 | return "clear digital timer"; | |
664 | case CEC_OPCODE_CLEAR_EXTERNAL_TIMER: | |
665 | return "clear external timer"; | |
666 | case CEC_OPCODE_SET_ANALOGUE_TIMER: | |
667 | return "set analogue timer"; | |
668 | case CEC_OPCODE_SET_DIGITAL_TIMER: | |
669 | return "set digital timer"; | |
670 | case CEC_OPCODE_SET_EXTERNAL_TIMER: | |
671 | return "set external timer"; | |
672 | case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE: | |
673 | return "set timer program title"; | |
674 | case CEC_OPCODE_TIMER_CLEARED_STATUS: | |
675 | return "timer cleared status"; | |
676 | case CEC_OPCODE_TIMER_STATUS: | |
677 | return "timer status"; | |
678 | case CEC_OPCODE_CEC_VERSION: | |
679 | return "cec version"; | |
680 | case CEC_OPCODE_GET_CEC_VERSION: | |
681 | return "get cec version"; | |
682 | case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: | |
683 | return "give physical address"; | |
684 | case CEC_OPCODE_GET_MENU_LANGUAGE: | |
685 | return "get menu language"; | |
686 | case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS: | |
687 | return "report physical address"; | |
688 | case CEC_OPCODE_SET_MENU_LANGUAGE: | |
689 | return "set menu language"; | |
690 | case CEC_OPCODE_DECK_CONTROL: | |
691 | return "deck control"; | |
692 | case CEC_OPCODE_DECK_STATUS: | |
693 | return "deck status"; | |
694 | case CEC_OPCODE_GIVE_DECK_STATUS: | |
695 | return "give deck status"; | |
696 | case CEC_OPCODE_PLAY: | |
697 | return "play"; | |
698 | case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS: | |
699 | return "give tuner status"; | |
700 | case CEC_OPCODE_SELECT_ANALOGUE_SERVICE: | |
701 | return "select analogue service"; | |
702 | case CEC_OPCODE_SELECT_DIGITAL_SERVICE: | |
703 | return "set digital service"; | |
704 | case CEC_OPCODE_TUNER_DEVICE_STATUS: | |
705 | return "tuner device status"; | |
706 | case CEC_OPCODE_TUNER_STEP_DECREMENT: | |
707 | return "tuner step decrement"; | |
708 | case CEC_OPCODE_TUNER_STEP_INCREMENT: | |
709 | return "tuner step increment"; | |
710 | case CEC_OPCODE_DEVICE_VENDOR_ID: | |
711 | return "device vendor id"; | |
712 | case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID: | |
713 | return "give device vendor id"; | |
714 | case CEC_OPCODE_VENDOR_COMMAND: | |
715 | return "vendor command"; | |
716 | case CEC_OPCODE_VENDOR_COMMAND_WITH_ID: | |
717 | return "vendor command with id"; | |
718 | case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN: | |
719 | return "vendor remote button down"; | |
720 | case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP: | |
721 | return "vendor remote button up"; | |
722 | case CEC_OPCODE_SET_OSD_STRING: | |
723 | return "set osd string"; | |
724 | case CEC_OPCODE_GIVE_OSD_NAME: | |
725 | return "give osd name"; | |
726 | case CEC_OPCODE_SET_OSD_NAME: | |
727 | return "set osd name"; | |
728 | case CEC_OPCODE_MENU_REQUEST: | |
729 | return "menu request"; | |
730 | case CEC_OPCODE_MENU_STATUS: | |
731 | return "menu status"; | |
732 | case CEC_OPCODE_USER_CONTROL_PRESSED: | |
733 | return "user control pressed"; | |
734 | case CEC_OPCODE_USER_CONTROL_RELEASE: | |
735 | return "user control release"; | |
736 | case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS: | |
737 | return "give device power status"; | |
738 | case CEC_OPCODE_REPORT_POWER_STATUS: | |
739 | return "report power status"; | |
740 | case CEC_OPCODE_FEATURE_ABORT: | |
741 | return "feature abort"; | |
742 | case CEC_OPCODE_ABORT: | |
743 | return "abort"; | |
744 | case CEC_OPCODE_GIVE_AUDIO_STATUS: | |
745 | return "give audio status"; | |
746 | case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS: | |
747 | return "give audio mode status"; | |
748 | case CEC_OPCODE_REPORT_AUDIO_STATUS: | |
749 | return "report audio status"; | |
750 | case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE: | |
751 | return "set system audio mode"; | |
752 | case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST: | |
753 | return "system audio mode request"; | |
754 | case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS: | |
755 | return "system audio mode status"; | |
756 | case CEC_OPCODE_SET_AUDIO_RATE: | |
757 | return "set audio rate"; | |
758 | case CEC_OPCODE_START_ARC: | |
759 | return "start ARC"; | |
760 | case CEC_OPCODE_REPORT_ARC_STARTED: | |
761 | return "report ARC started"; | |
762 | case CEC_OPCODE_REPORT_ARC_ENDED: | |
763 | return "report ARC ended"; | |
764 | case CEC_OPCODE_REQUEST_ARC_START: | |
765 | return "request ARC start"; | |
766 | case CEC_OPCODE_REQUEST_ARC_END: | |
767 | return "request ARC end"; | |
768 | case CEC_OPCODE_END_ARC: | |
769 | return "end ARC"; | |
770 | case CEC_OPCODE_CDC: | |
771 | return "CDC"; | |
772 | case CEC_OPCODE_NONE: | |
773 | return "poll"; | |
774 | default: | |
775 | return "UNKNOWN"; | |
776 | } | |
03ae897d LOK |
777 | } |
778 | ||
779 | const char *CLibCEC::ToString(const cec_system_audio_status mode) | |
780 | { | |
004b8382 LOK |
781 | switch(mode) |
782 | { | |
783 | case CEC_SYSTEM_AUDIO_STATUS_ON: | |
784 | return "on"; | |
785 | case CEC_SYSTEM_AUDIO_STATUS_OFF: | |
786 | return "off"; | |
787 | default: | |
788 | return "unknown"; | |
789 | } | |
03ae897d LOK |
790 | } |
791 | ||
004b8382 | 792 | const char *CLibCEC::ToString(const cec_audio_status UNUSED(status)) |
03ae897d | 793 | { |
004b8382 LOK |
794 | // TODO this is a mask |
795 | return "TODO"; | |
03ae897d LOK |
796 | } |
797 | ||
798 | const char *CLibCEC::ToString(const cec_vendor_id vendor) | |
799 | { | |
004b8382 LOK |
800 | switch (vendor) |
801 | { | |
802 | case CEC_VENDOR_SAMSUNG: | |
803 | return "Samsung"; | |
804 | case CEC_VENDOR_LG: | |
805 | return "LG"; | |
806 | case CEC_VENDOR_PANASONIC: | |
807 | return "Panasonic"; | |
808 | case CEC_VENDOR_PIONEER: | |
809 | return "Pioneer"; | |
810 | case CEC_VENDOR_ONKYO: | |
811 | return "Onkyo"; | |
812 | case CEC_VENDOR_YAMAHA: | |
813 | return "Yamaha"; | |
814 | case CEC_VENDOR_PHILIPS: | |
815 | return "Philips"; | |
816 | case CEC_VENDOR_SONY: | |
817 | return "Sony"; | |
818 | case CEC_VENDOR_TOSHIBA: | |
819 | return "Toshiba"; | |
820 | default: | |
821 | return "Unknown"; | |
822 | } | |
03ae897d | 823 | } |
caca2d81 LOK |
824 | |
825 | const char *CLibCEC::ToString(const cec_client_version version) | |
826 | { | |
004b8382 LOK |
827 | switch (version) |
828 | { | |
829 | case CEC_CLIENT_VERSION_PRE_1_5: | |
830 | return "pre-1.5"; | |
831 | case CEC_CLIENT_VERSION_1_5_0: | |
832 | return "1.5.0"; | |
833 | case CEC_CLIENT_VERSION_1_5_1: | |
834 | return "1.5.1"; | |
835 | case CEC_CLIENT_VERSION_1_5_2: | |
836 | return "1.5.2"; | |
837 | case CEC_CLIENT_VERSION_1_5_3: | |
838 | return "1.5.3"; | |
839 | case CEC_CLIENT_VERSION_1_6_0: | |
840 | return "1.6.0"; | |
841 | case CEC_CLIENT_VERSION_1_6_1: | |
842 | return "1.6.1"; | |
843 | case CEC_CLIENT_VERSION_1_6_2: | |
844 | return "1.6.2"; | |
845 | default: | |
846 | return "Unknown"; | |
847 | } | |
caca2d81 | 848 | } |
d40928b5 | 849 | |
3efda01a LOK |
850 | const char *CLibCEC::ToString(const cec_server_version version) |
851 | { | |
004b8382 LOK |
852 | switch (version) |
853 | { | |
854 | case CEC_SERVER_VERSION_PRE_1_5: | |
855 | return "pre-1.5"; | |
856 | case CEC_SERVER_VERSION_1_5_0: | |
857 | return "1.5.0"; | |
858 | case CEC_SERVER_VERSION_1_5_1: | |
859 | return "1.5.1"; | |
860 | case CEC_SERVER_VERSION_1_5_2: | |
861 | return "1.5.2"; | |
862 | case CEC_SERVER_VERSION_1_5_3: | |
863 | return "1.5.3"; | |
864 | case CEC_SERVER_VERSION_1_6_0: | |
865 | return "1.6.0"; | |
866 | case CEC_SERVER_VERSION_1_6_1: | |
867 | return "1.6.1"; | |
868 | case CEC_SERVER_VERSION_1_6_2: | |
869 | return "1.6.2"; | |
870 | default: | |
871 | return "Unknown"; | |
872 | } | |
3efda01a LOK |
873 | } |
874 | ||
004b8382 | 875 | void CLibCEC::CheckKeypressTimeout(void) |
a75e3a5a | 876 | { |
004b8382 LOK |
877 | // check all clients |
878 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
879 | (*it)->CheckKeypressTimeout(); | |
a75e3a5a LOK |
880 | } |
881 | ||
004b8382 | 882 | void CLibCEC::AddLog(const cec_log_level level, const char *strFormat, ...) |
d40928b5 | 883 | { |
004b8382 LOK |
884 | CStdString strLog; |
885 | ||
886 | va_list argList; | |
887 | va_start(argList, strFormat); | |
888 | strLog.FormatV(strFormat, argList); | |
889 | va_end(argList); | |
890 | ||
891 | cec_log_message message; | |
892 | message.level = level; | |
893 | message.time = GetTimeMs() - m_iStartTime; | |
894 | snprintf(message.message, sizeof(message.message), "%s", strLog.c_str()); | |
895 | ||
896 | // send the message to all clients | |
897 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
898 | (*it)->AddLog(message); | |
224ea877 LOK |
899 | } |
900 | ||
004b8382 | 901 | void CLibCEC::Alert(const libcec_alert type, const libcec_parameter ¶m) |
30b4aac0 | 902 | { |
004b8382 LOK |
903 | // send the alert to all clients |
904 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
905 | (*it)->Alert(type, param); | |
30b4aac0 LOK |
906 | } |
907 | ||
004b8382 | 908 | bool CLibCEC::SetActiveView(void) |
224ea877 | 909 | { |
004b8382 LOK |
910 | AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); |
911 | return SetActiveSource(); | |
224ea877 LOK |
912 | } |
913 | ||
004b8382 | 914 | bool CLibCEC::EnablePhysicalAddressDetection(void) |
224ea877 | 915 | { |
004b8382 LOK |
916 | AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); |
917 | return true; | |
224ea877 | 918 | } |
3efda01a | 919 | |
004b8382 | 920 | CCECClient *CLibCEC::RegisterClient(libcec_configuration *configuration) |
3efda01a | 921 | { |
004b8382 LOK |
922 | if (!m_cec) |
923 | return NULL; | |
924 | ||
925 | CCECClient *newClient = new CCECClient(m_cec, configuration); | |
926 | if (!newClient) | |
927 | return NULL; | |
928 | ||
929 | m_clients.push_back(newClient); | |
930 | if (!m_client) | |
931 | m_client = newClient; | |
932 | ||
933 | if (m_cec->IsRunning()) | |
934 | m_cec->RegisterClient(newClient); | |
935 | ||
99aeafb9 | 936 | return newClient; |
3efda01a | 937 | } |
c9549d35 | 938 | |
004b8382 | 939 | void CLibCEC::UnregisterClients(void) |
c9549d35 | 940 | { |
004b8382 LOK |
941 | m_clients.clear(); |
942 | delete m_client; | |
943 | m_client = NULL; | |
c9549d35 | 944 | } |
9878069e | 945 | |
004b8382 | 946 | void * CECInitialise(libcec_configuration *configuration) |
9878069e | 947 | { |
004b8382 LOK |
948 | if (!configuration) |
949 | return NULL; | |
950 | ||
c30acafa | 951 | CLibCEC *lib = new CLibCEC(NULL); |
99aeafb9 | 952 | CCECClient *client(NULL); |
004b8382 | 953 | if (lib) |
99aeafb9 LOK |
954 | client = lib->RegisterClient(configuration); |
955 | ||
956 | if (client) | |
957 | client->GetCurrentConfiguration(configuration); | |
958 | ||
959 | // ensure that the correct server version is set | |
960 | configuration->serverVersion = LIBCEC_VERSION_CURRENT; | |
004b8382 LOK |
961 | |
962 | return static_cast< void* > (lib); | |
9878069e | 963 | } |
209b7a5c | 964 | |
004b8382 | 965 | void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types, uint16_t iPhysicalAddress /* = 0 */) |
209b7a5c | 966 | { |
004b8382 | 967 | libcec_configuration configuration; |
004b8382 LOK |
968 | |
969 | // client version < 1.5.0 | |
970 | snprintf(configuration.strDeviceName, 13, "%s", strDeviceName); | |
971 | configuration.deviceTypes = types; | |
972 | configuration.iPhysicalAddress = iPhysicalAddress; | |
973 | ||
974 | if (configuration.deviceTypes.IsEmpty()) | |
975 | configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE); | |
976 | ||
977 | return CECInitialise(&configuration); | |
209b7a5c LOK |
978 | } |
979 | ||
004b8382 | 980 | bool CECStartBootloader(void) |
209b7a5c | 981 | { |
004b8382 LOK |
982 | bool bReturn(false); |
983 | cec_adapter deviceList[1]; | |
984 | if (CUSBCECAdapterDetection::FindAdapters(deviceList, 1) > 0) | |
209b7a5c | 985 | { |
004b8382 LOK |
986 | CUSBCECAdapterCommunication comm(NULL, deviceList[0].comm); |
987 | CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT); | |
988 | while (timeout.TimeLeft() > 0 && (bReturn = comm.Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false) | |
209b7a5c | 989 | { |
004b8382 LOK |
990 | comm.Close(); |
991 | CEvent::Sleep(500); | |
209b7a5c | 992 | } |
004b8382 LOK |
993 | if (comm.IsOpen()) |
994 | bReturn = comm.StartBootloader(); | |
209b7a5c | 995 | } |
004b8382 LOK |
996 | |
997 | return bReturn; | |
998 | } | |
999 | ||
1000 | void CECDestroy(CEC::ICECAdapter *instance) | |
1001 | { | |
1002 | delete instance; | |
209b7a5c | 1003 | } |
f80cd208 | 1004 | |
b32ffd87 | 1005 | bool CLibCEC::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */) |
f80cd208 LOK |
1006 | { |
1007 | if (m_cec->IsRunning()) | |
1008 | return false; | |
004b8382 | 1009 | |
f80cd208 | 1010 | return m_cec->GetDeviceInformation(strPort, config, iTimeoutMs); |
a75e3a5a | 1011 | } |
c30acafa LOK |
1012 | |
1013 | void CLibCEC::AddKey(const cec_keypress &UNUSED(key)) {} | |
1014 | void CLibCEC::AddCommand(const cec_command &UNUSED(command)) {} | |
1015 | void CLibCEC::ConfigurationChanged(const libcec_configuration &UNUSED(config)) {} | |
1016 | void CLibCEC::SetCurrentButton(cec_user_control_code UNUSED(iButtonCode)) {} | |
1017 | CLibCEC *CLibCEC::GetInstance(void) { return NULL; } | |
1018 | void CLibCEC::SetInstance(CLibCEC *UNUSED(instance)) {} |