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 LOK |
340 | cec_osd_name retVal; |
341 | if (m_client) | |
342 | retVal = m_client->GetDeviceOSDName(iAddress); | |
343 | return retVal; | |
f42d3e0f LOK |
344 | } |
345 | ||
004b8382 | 346 | cec_logical_addresses CLibCEC::GetLogicalAddresses(void) |
f42d3e0f | 347 | { |
004b8382 | 348 | cec_logical_addresses addresses; |
c30acafa | 349 | addresses.Clear(); |
004b8382 LOK |
350 | if (m_cec) |
351 | addresses = m_cec->GetLogicalAddresses(); | |
352 | return addresses; | |
f42d3e0f LOK |
353 | } |
354 | ||
004b8382 | 355 | bool CLibCEC::GetNextLogMessage(cec_log_message *message) |
80b72250 | 356 | { |
004b8382 | 357 | return m_client ? m_client->GetNextLogMessage(message) : false; |
80b72250 LOK |
358 | } |
359 | ||
004b8382 | 360 | bool CLibCEC::GetNextKeypress(cec_keypress *key) |
5477a250 | 361 | { |
004b8382 | 362 | return m_client ? m_client->GetNextKeypress(key) : false; |
5477a250 LOK |
363 | } |
364 | ||
004b8382 | 365 | bool CLibCEC::GetNextCommand(cec_command *command) |
5477a250 | 366 | { |
004b8382 | 367 | return m_client ? m_client->GetNextCommand(command) : false; |
5477a250 LOK |
368 | } |
369 | ||
004b8382 | 370 | cec_device_type CLibCEC::GetType(cec_logical_address address) |
f8513317 | 371 | { |
004b8382 LOK |
372 | switch (address) |
373 | { | |
374 | case CECDEVICE_AUDIOSYSTEM: | |
375 | return CEC_DEVICE_TYPE_AUDIO_SYSTEM; | |
376 | case CECDEVICE_PLAYBACKDEVICE1: | |
377 | case CECDEVICE_PLAYBACKDEVICE2: | |
378 | case CECDEVICE_PLAYBACKDEVICE3: | |
379 | return CEC_DEVICE_TYPE_PLAYBACK_DEVICE; | |
380 | case CECDEVICE_RECORDINGDEVICE1: | |
381 | case CECDEVICE_RECORDINGDEVICE2: | |
382 | case CECDEVICE_RECORDINGDEVICE3: | |
383 | return CEC_DEVICE_TYPE_RECORDING_DEVICE; | |
384 | case CECDEVICE_TUNER1: | |
385 | case CECDEVICE_TUNER2: | |
386 | case CECDEVICE_TUNER3: | |
387 | case CECDEVICE_TUNER4: | |
388 | return CEC_DEVICE_TYPE_TUNER; | |
389 | case CECDEVICE_TV: | |
390 | return CEC_DEVICE_TYPE_TV; | |
391 | default: | |
392 | return CEC_DEVICE_TYPE_RESERVED; | |
393 | } | |
f8513317 LOK |
394 | } |
395 | ||
004b8382 | 396 | uint16_t CLibCEC::GetMaskForType(cec_logical_address address) |
caca2d81 | 397 | { |
004b8382 | 398 | return GetMaskForType(GetType(address)); |
caca2d81 LOK |
399 | } |
400 | ||
004b8382 | 401 | uint16_t CLibCEC::GetMaskForType(cec_device_type type) |
a2198e5e | 402 | { |
004b8382 | 403 | switch (type) |
a2198e5e | 404 | { |
004b8382 | 405 | case CEC_DEVICE_TYPE_AUDIO_SYSTEM: |
08d80226 | 406 | { |
004b8382 LOK |
407 | cec_logical_addresses addr; |
408 | addr.Clear(); | |
409 | addr.Set(CECDEVICE_AUDIOSYSTEM); | |
410 | return addr.AckMask(); | |
08d80226 | 411 | } |
004b8382 LOK |
412 | case CEC_DEVICE_TYPE_PLAYBACK_DEVICE: |
413 | { | |
414 | cec_logical_addresses addr; | |
415 | addr.Clear(); | |
416 | addr.Set(CECDEVICE_PLAYBACKDEVICE1); | |
417 | addr.Set(CECDEVICE_PLAYBACKDEVICE2); | |
418 | addr.Set(CECDEVICE_PLAYBACKDEVICE3); | |
419 | return addr.AckMask(); | |
420 | } | |
421 | case CEC_DEVICE_TYPE_RECORDING_DEVICE: | |
422 | { | |
423 | cec_logical_addresses addr; | |
424 | addr.Clear(); | |
425 | addr.Set(CECDEVICE_RECORDINGDEVICE1); | |
426 | addr.Set(CECDEVICE_RECORDINGDEVICE2); | |
427 | addr.Set(CECDEVICE_RECORDINGDEVICE3); | |
428 | return addr.AckMask(); | |
429 | } | |
430 | case CEC_DEVICE_TYPE_TUNER: | |
431 | { | |
432 | cec_logical_addresses addr; | |
433 | addr.Clear(); | |
434 | addr.Set(CECDEVICE_TUNER1); | |
435 | addr.Set(CECDEVICE_TUNER2); | |
436 | addr.Set(CECDEVICE_TUNER3); | |
437 | addr.Set(CECDEVICE_TUNER4); | |
438 | return addr.AckMask(); | |
439 | } | |
440 | case CEC_DEVICE_TYPE_TV: | |
441 | { | |
442 | cec_logical_addresses addr; | |
443 | addr.Clear(); | |
444 | addr.Set(CECDEVICE_TV); | |
445 | return addr.AckMask(); | |
446 | } | |
447 | default: | |
448 | return 0; | |
a2198e5e | 449 | } |
004b8382 | 450 | } |
08d80226 | 451 | |
004b8382 LOK |
452 | bool CLibCEC::IsValidPhysicalAddress(uint16_t iPhysicalAddress) |
453 | { | |
454 | return iPhysicalAddress >= CEC_MIN_PHYSICAL_ADDRESS && | |
455 | iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS; | |
a2198e5e LOK |
456 | } |
457 | ||
004b8382 | 458 | const char *CLibCEC::ToString(const cec_device_type type) |
25701fa6 | 459 | { |
004b8382 LOK |
460 | switch (type) |
461 | { | |
462 | case CEC_DEVICE_TYPE_AUDIO_SYSTEM: | |
463 | return "audio system"; | |
464 | case CEC_DEVICE_TYPE_PLAYBACK_DEVICE: | |
465 | return "playback device"; | |
466 | case CEC_DEVICE_TYPE_RECORDING_DEVICE: | |
467 | return "recording device"; | |
468 | case CEC_DEVICE_TYPE_RESERVED: | |
469 | return "reserved"; | |
470 | case CEC_DEVICE_TYPE_TUNER: | |
471 | return "tuner"; | |
472 | case CEC_DEVICE_TYPE_TV: | |
473 | return "TV"; | |
474 | default: | |
475 | return "unknown"; | |
476 | } | |
25701fa6 | 477 | } |
03ae897d LOK |
478 | |
479 | const char *CLibCEC::ToString(const cec_menu_state state) | |
480 | { | |
004b8382 LOK |
481 | switch (state) |
482 | { | |
483 | case CEC_MENU_STATE_ACTIVATED: | |
484 | return "activated"; | |
485 | case CEC_MENU_STATE_DEACTIVATED: | |
486 | return "deactivated"; | |
487 | default: | |
488 | return "unknown"; | |
489 | } | |
03ae897d LOK |
490 | } |
491 | ||
492 | const char *CLibCEC::ToString(const cec_version version) | |
493 | { | |
004b8382 LOK |
494 | switch (version) |
495 | { | |
496 | case CEC_VERSION_1_2: | |
497 | return "1.2"; | |
498 | case CEC_VERSION_1_2A: | |
499 | return "1.2a"; | |
500 | case CEC_VERSION_1_3: | |
501 | return "1.3"; | |
502 | case CEC_VERSION_1_3A: | |
503 | return "1.3a"; | |
504 | case CEC_VERSION_1_4: | |
505 | return "1.4"; | |
506 | default: | |
507 | return "unknown"; | |
508 | } | |
03ae897d LOK |
509 | } |
510 | ||
511 | const char *CLibCEC::ToString(const cec_power_status status) | |
512 | { | |
004b8382 LOK |
513 | switch (status) |
514 | { | |
515 | case CEC_POWER_STATUS_ON: | |
516 | return "on"; | |
517 | case CEC_POWER_STATUS_STANDBY: | |
518 | return "standby"; | |
519 | case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY: | |
520 | return "in transition from on to standby"; | |
521 | case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON: | |
522 | return "in transition from standby to on"; | |
523 | default: | |
524 | return "unknown"; | |
525 | } | |
03ae897d LOK |
526 | } |
527 | ||
528 | const char *CLibCEC::ToString(const cec_logical_address address) | |
529 | { | |
004b8382 LOK |
530 | switch(address) |
531 | { | |
532 | case CECDEVICE_AUDIOSYSTEM: | |
533 | return "Audio"; | |
534 | case CECDEVICE_BROADCAST: | |
535 | return "Broadcast"; | |
536 | case CECDEVICE_FREEUSE: | |
537 | return "Free use"; | |
538 | case CECDEVICE_PLAYBACKDEVICE1: | |
539 | return "Playback 1"; | |
540 | case CECDEVICE_PLAYBACKDEVICE2: | |
541 | return "Playback 2"; | |
542 | case CECDEVICE_PLAYBACKDEVICE3: | |
543 | return "Playback 3"; | |
544 | case CECDEVICE_RECORDINGDEVICE1: | |
545 | return "Recorder 1"; | |
546 | case CECDEVICE_RECORDINGDEVICE2: | |
547 | return "Recorder 2"; | |
548 | case CECDEVICE_RECORDINGDEVICE3: | |
549 | return "Recorder 3"; | |
550 | case CECDEVICE_RESERVED1: | |
551 | return "Reserved 1"; | |
552 | case CECDEVICE_RESERVED2: | |
553 | return "Reserved 2"; | |
554 | case CECDEVICE_TUNER1: | |
555 | return "Tuner 1"; | |
556 | case CECDEVICE_TUNER2: | |
557 | return "Tuner 2"; | |
558 | case CECDEVICE_TUNER3: | |
559 | return "Tuner 3"; | |
560 | case CECDEVICE_TUNER4: | |
561 | return "Tuner 4"; | |
562 | case CECDEVICE_TV: | |
563 | return "TV"; | |
564 | default: | |
565 | return "unknown"; | |
566 | } | |
03ae897d LOK |
567 | } |
568 | ||
569 | const char *CLibCEC::ToString(const cec_deck_control_mode mode) | |
570 | { | |
004b8382 LOK |
571 | switch (mode) |
572 | { | |
573 | case CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND: | |
574 | return "skip forward wind"; | |
575 | case CEC_DECK_CONTROL_MODE_EJECT: | |
576 | return "eject"; | |
577 | case CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND: | |
578 | return "reverse rewind"; | |
579 | case CEC_DECK_CONTROL_MODE_STOP: | |
580 | return "stop"; | |
581 | default: | |
582 | return "unknown"; | |
583 | } | |
03ae897d LOK |
584 | } |
585 | ||
586 | const char *CLibCEC::ToString(const cec_deck_info status) | |
587 | { | |
004b8382 LOK |
588 | switch (status) |
589 | { | |
590 | case CEC_DECK_INFO_PLAY: | |
591 | return "play"; | |
592 | case CEC_DECK_INFO_RECORD: | |
593 | return "record"; | |
594 | case CEC_DECK_INFO_PLAY_REVERSE: | |
595 | return "play reverse"; | |
596 | case CEC_DECK_INFO_STILL: | |
597 | return "still"; | |
598 | case CEC_DECK_INFO_SLOW: | |
599 | return "slow"; | |
600 | case CEC_DECK_INFO_SLOW_REVERSE: | |
601 | return "slow reverse"; | |
602 | case CEC_DECK_INFO_FAST_FORWARD: | |
603 | return "fast forward"; | |
604 | case CEC_DECK_INFO_FAST_REVERSE: | |
605 | return "fast reverse"; | |
606 | case CEC_DECK_INFO_NO_MEDIA: | |
607 | return "no media"; | |
608 | case CEC_DECK_INFO_STOP: | |
609 | return "stop"; | |
610 | case CEC_DECK_INFO_SKIP_FORWARD_WIND: | |
611 | return "info skip forward wind"; | |
612 | case CEC_DECK_INFO_SKIP_REVERSE_REWIND: | |
613 | return "info skip reverse rewind"; | |
614 | case CEC_DECK_INFO_INDEX_SEARCH_FORWARD: | |
615 | return "info index search forward"; | |
616 | case CEC_DECK_INFO_INDEX_SEARCH_REVERSE: | |
617 | return "info index search reverse"; | |
618 | case CEC_DECK_INFO_OTHER_STATUS: | |
619 | return "other"; | |
620 | case CEC_DECK_INFO_OTHER_STATUS_LG: | |
621 | return "LG other"; | |
622 | default: | |
623 | return "unknown"; | |
624 | } | |
03ae897d LOK |
625 | } |
626 | ||
627 | const char *CLibCEC::ToString(const cec_opcode opcode) | |
628 | { | |
004b8382 LOK |
629 | switch (opcode) |
630 | { | |
631 | case CEC_OPCODE_ACTIVE_SOURCE: | |
632 | return "active source"; | |
633 | case CEC_OPCODE_IMAGE_VIEW_ON: | |
634 | return "image view on"; | |
635 | case CEC_OPCODE_TEXT_VIEW_ON: | |
636 | return "text view on"; | |
637 | case CEC_OPCODE_INACTIVE_SOURCE: | |
638 | return "inactive source"; | |
639 | case CEC_OPCODE_REQUEST_ACTIVE_SOURCE: | |
640 | return "request active source"; | |
641 | case CEC_OPCODE_ROUTING_CHANGE: | |
642 | return "routing change"; | |
643 | case CEC_OPCODE_ROUTING_INFORMATION: | |
644 | return "routing information"; | |
645 | case CEC_OPCODE_SET_STREAM_PATH: | |
646 | return "set stream path"; | |
647 | case CEC_OPCODE_STANDBY: | |
648 | return "standby"; | |
649 | case CEC_OPCODE_RECORD_OFF: | |
650 | return "record off"; | |
651 | case CEC_OPCODE_RECORD_ON: | |
652 | return "record on"; | |
653 | case CEC_OPCODE_RECORD_STATUS: | |
654 | return "record status"; | |
655 | case CEC_OPCODE_RECORD_TV_SCREEN: | |
656 | return "record tv screen"; | |
657 | case CEC_OPCODE_CLEAR_ANALOGUE_TIMER: | |
658 | return "clear analogue timer"; | |
659 | case CEC_OPCODE_CLEAR_DIGITAL_TIMER: | |
660 | return "clear digital timer"; | |
661 | case CEC_OPCODE_CLEAR_EXTERNAL_TIMER: | |
662 | return "clear external timer"; | |
663 | case CEC_OPCODE_SET_ANALOGUE_TIMER: | |
664 | return "set analogue timer"; | |
665 | case CEC_OPCODE_SET_DIGITAL_TIMER: | |
666 | return "set digital timer"; | |
667 | case CEC_OPCODE_SET_EXTERNAL_TIMER: | |
668 | return "set external timer"; | |
669 | case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE: | |
670 | return "set timer program title"; | |
671 | case CEC_OPCODE_TIMER_CLEARED_STATUS: | |
672 | return "timer cleared status"; | |
673 | case CEC_OPCODE_TIMER_STATUS: | |
674 | return "timer status"; | |
675 | case CEC_OPCODE_CEC_VERSION: | |
676 | return "cec version"; | |
677 | case CEC_OPCODE_GET_CEC_VERSION: | |
678 | return "get cec version"; | |
679 | case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: | |
680 | return "give physical address"; | |
681 | case CEC_OPCODE_GET_MENU_LANGUAGE: | |
682 | return "get menu language"; | |
683 | case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS: | |
684 | return "report physical address"; | |
685 | case CEC_OPCODE_SET_MENU_LANGUAGE: | |
686 | return "set menu language"; | |
687 | case CEC_OPCODE_DECK_CONTROL: | |
688 | return "deck control"; | |
689 | case CEC_OPCODE_DECK_STATUS: | |
690 | return "deck status"; | |
691 | case CEC_OPCODE_GIVE_DECK_STATUS: | |
692 | return "give deck status"; | |
693 | case CEC_OPCODE_PLAY: | |
694 | return "play"; | |
695 | case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS: | |
696 | return "give tuner status"; | |
697 | case CEC_OPCODE_SELECT_ANALOGUE_SERVICE: | |
698 | return "select analogue service"; | |
699 | case CEC_OPCODE_SELECT_DIGITAL_SERVICE: | |
700 | return "set digital service"; | |
701 | case CEC_OPCODE_TUNER_DEVICE_STATUS: | |
702 | return "tuner device status"; | |
703 | case CEC_OPCODE_TUNER_STEP_DECREMENT: | |
704 | return "tuner step decrement"; | |
705 | case CEC_OPCODE_TUNER_STEP_INCREMENT: | |
706 | return "tuner step increment"; | |
707 | case CEC_OPCODE_DEVICE_VENDOR_ID: | |
708 | return "device vendor id"; | |
709 | case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID: | |
710 | return "give device vendor id"; | |
711 | case CEC_OPCODE_VENDOR_COMMAND: | |
712 | return "vendor command"; | |
713 | case CEC_OPCODE_VENDOR_COMMAND_WITH_ID: | |
714 | return "vendor command with id"; | |
715 | case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN: | |
716 | return "vendor remote button down"; | |
717 | case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP: | |
718 | return "vendor remote button up"; | |
719 | case CEC_OPCODE_SET_OSD_STRING: | |
720 | return "set osd string"; | |
721 | case CEC_OPCODE_GIVE_OSD_NAME: | |
722 | return "give osd name"; | |
723 | case CEC_OPCODE_SET_OSD_NAME: | |
724 | return "set osd name"; | |
725 | case CEC_OPCODE_MENU_REQUEST: | |
726 | return "menu request"; | |
727 | case CEC_OPCODE_MENU_STATUS: | |
728 | return "menu status"; | |
729 | case CEC_OPCODE_USER_CONTROL_PRESSED: | |
730 | return "user control pressed"; | |
731 | case CEC_OPCODE_USER_CONTROL_RELEASE: | |
732 | return "user control release"; | |
733 | case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS: | |
734 | return "give device power status"; | |
735 | case CEC_OPCODE_REPORT_POWER_STATUS: | |
736 | return "report power status"; | |
737 | case CEC_OPCODE_FEATURE_ABORT: | |
738 | return "feature abort"; | |
739 | case CEC_OPCODE_ABORT: | |
740 | return "abort"; | |
741 | case CEC_OPCODE_GIVE_AUDIO_STATUS: | |
742 | return "give audio status"; | |
743 | case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS: | |
744 | return "give audio mode status"; | |
745 | case CEC_OPCODE_REPORT_AUDIO_STATUS: | |
746 | return "report audio status"; | |
747 | case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE: | |
748 | return "set system audio mode"; | |
749 | case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST: | |
750 | return "system audio mode request"; | |
751 | case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS: | |
752 | return "system audio mode status"; | |
753 | case CEC_OPCODE_SET_AUDIO_RATE: | |
754 | return "set audio rate"; | |
755 | case CEC_OPCODE_START_ARC: | |
756 | return "start ARC"; | |
757 | case CEC_OPCODE_REPORT_ARC_STARTED: | |
758 | return "report ARC started"; | |
759 | case CEC_OPCODE_REPORT_ARC_ENDED: | |
760 | return "report ARC ended"; | |
761 | case CEC_OPCODE_REQUEST_ARC_START: | |
762 | return "request ARC start"; | |
763 | case CEC_OPCODE_REQUEST_ARC_END: | |
764 | return "request ARC end"; | |
765 | case CEC_OPCODE_END_ARC: | |
766 | return "end ARC"; | |
767 | case CEC_OPCODE_CDC: | |
768 | return "CDC"; | |
769 | case CEC_OPCODE_NONE: | |
770 | return "poll"; | |
771 | default: | |
772 | return "UNKNOWN"; | |
773 | } | |
03ae897d LOK |
774 | } |
775 | ||
776 | const char *CLibCEC::ToString(const cec_system_audio_status mode) | |
777 | { | |
004b8382 LOK |
778 | switch(mode) |
779 | { | |
780 | case CEC_SYSTEM_AUDIO_STATUS_ON: | |
781 | return "on"; | |
782 | case CEC_SYSTEM_AUDIO_STATUS_OFF: | |
783 | return "off"; | |
784 | default: | |
785 | return "unknown"; | |
786 | } | |
03ae897d LOK |
787 | } |
788 | ||
004b8382 | 789 | const char *CLibCEC::ToString(const cec_audio_status UNUSED(status)) |
03ae897d | 790 | { |
004b8382 LOK |
791 | // TODO this is a mask |
792 | return "TODO"; | |
03ae897d LOK |
793 | } |
794 | ||
795 | const char *CLibCEC::ToString(const cec_vendor_id vendor) | |
796 | { | |
004b8382 LOK |
797 | switch (vendor) |
798 | { | |
799 | case CEC_VENDOR_SAMSUNG: | |
800 | return "Samsung"; | |
801 | case CEC_VENDOR_LG: | |
802 | return "LG"; | |
803 | case CEC_VENDOR_PANASONIC: | |
804 | return "Panasonic"; | |
805 | case CEC_VENDOR_PIONEER: | |
806 | return "Pioneer"; | |
807 | case CEC_VENDOR_ONKYO: | |
808 | return "Onkyo"; | |
809 | case CEC_VENDOR_YAMAHA: | |
810 | return "Yamaha"; | |
811 | case CEC_VENDOR_PHILIPS: | |
812 | return "Philips"; | |
813 | case CEC_VENDOR_SONY: | |
814 | return "Sony"; | |
815 | case CEC_VENDOR_TOSHIBA: | |
816 | return "Toshiba"; | |
817 | default: | |
818 | return "Unknown"; | |
819 | } | |
03ae897d | 820 | } |
caca2d81 LOK |
821 | |
822 | const char *CLibCEC::ToString(const cec_client_version version) | |
823 | { | |
004b8382 LOK |
824 | switch (version) |
825 | { | |
826 | case CEC_CLIENT_VERSION_PRE_1_5: | |
827 | return "pre-1.5"; | |
828 | case CEC_CLIENT_VERSION_1_5_0: | |
829 | return "1.5.0"; | |
830 | case CEC_CLIENT_VERSION_1_5_1: | |
831 | return "1.5.1"; | |
832 | case CEC_CLIENT_VERSION_1_5_2: | |
833 | return "1.5.2"; | |
834 | case CEC_CLIENT_VERSION_1_5_3: | |
835 | return "1.5.3"; | |
836 | case CEC_CLIENT_VERSION_1_6_0: | |
837 | return "1.6.0"; | |
838 | case CEC_CLIENT_VERSION_1_6_1: | |
839 | return "1.6.1"; | |
840 | case CEC_CLIENT_VERSION_1_6_2: | |
841 | return "1.6.2"; | |
842 | default: | |
843 | return "Unknown"; | |
844 | } | |
caca2d81 | 845 | } |
d40928b5 | 846 | |
3efda01a LOK |
847 | const char *CLibCEC::ToString(const cec_server_version version) |
848 | { | |
004b8382 LOK |
849 | switch (version) |
850 | { | |
851 | case CEC_SERVER_VERSION_PRE_1_5: | |
852 | return "pre-1.5"; | |
853 | case CEC_SERVER_VERSION_1_5_0: | |
854 | return "1.5.0"; | |
855 | case CEC_SERVER_VERSION_1_5_1: | |
856 | return "1.5.1"; | |
857 | case CEC_SERVER_VERSION_1_5_2: | |
858 | return "1.5.2"; | |
859 | case CEC_SERVER_VERSION_1_5_3: | |
860 | return "1.5.3"; | |
861 | case CEC_SERVER_VERSION_1_6_0: | |
862 | return "1.6.0"; | |
863 | case CEC_SERVER_VERSION_1_6_1: | |
864 | return "1.6.1"; | |
865 | case CEC_SERVER_VERSION_1_6_2: | |
866 | return "1.6.2"; | |
867 | default: | |
868 | return "Unknown"; | |
869 | } | |
3efda01a LOK |
870 | } |
871 | ||
004b8382 | 872 | void CLibCEC::CheckKeypressTimeout(void) |
a75e3a5a | 873 | { |
004b8382 LOK |
874 | // check all clients |
875 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
876 | (*it)->CheckKeypressTimeout(); | |
a75e3a5a LOK |
877 | } |
878 | ||
004b8382 | 879 | void CLibCEC::AddLog(const cec_log_level level, const char *strFormat, ...) |
d40928b5 | 880 | { |
004b8382 LOK |
881 | CStdString strLog; |
882 | ||
883 | va_list argList; | |
884 | va_start(argList, strFormat); | |
885 | strLog.FormatV(strFormat, argList); | |
886 | va_end(argList); | |
887 | ||
888 | cec_log_message message; | |
889 | message.level = level; | |
890 | message.time = GetTimeMs() - m_iStartTime; | |
891 | snprintf(message.message, sizeof(message.message), "%s", strLog.c_str()); | |
892 | ||
893 | // send the message to all clients | |
894 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
895 | (*it)->AddLog(message); | |
224ea877 LOK |
896 | } |
897 | ||
004b8382 | 898 | void CLibCEC::Alert(const libcec_alert type, const libcec_parameter ¶m) |
30b4aac0 | 899 | { |
004b8382 LOK |
900 | // send the alert to all clients |
901 | for (vector<CCECClient *>::iterator it = m_clients.begin(); it != m_clients.end(); it++) | |
902 | (*it)->Alert(type, param); | |
30b4aac0 LOK |
903 | } |
904 | ||
004b8382 | 905 | bool CLibCEC::SetActiveView(void) |
224ea877 | 906 | { |
004b8382 LOK |
907 | AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); |
908 | return SetActiveSource(); | |
224ea877 LOK |
909 | } |
910 | ||
004b8382 | 911 | bool CLibCEC::EnablePhysicalAddressDetection(void) |
224ea877 | 912 | { |
004b8382 LOK |
913 | AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__); |
914 | return true; | |
224ea877 | 915 | } |
3efda01a | 916 | |
004b8382 | 917 | CCECClient *CLibCEC::RegisterClient(libcec_configuration *configuration) |
3efda01a | 918 | { |
004b8382 LOK |
919 | if (!m_cec) |
920 | return NULL; | |
921 | ||
922 | CCECClient *newClient = new CCECClient(m_cec, configuration); | |
923 | if (!newClient) | |
924 | return NULL; | |
925 | ||
926 | m_clients.push_back(newClient); | |
927 | if (!m_client) | |
928 | m_client = newClient; | |
929 | ||
930 | if (m_cec->IsRunning()) | |
931 | m_cec->RegisterClient(newClient); | |
932 | ||
99aeafb9 | 933 | return newClient; |
3efda01a | 934 | } |
c9549d35 | 935 | |
004b8382 | 936 | void CLibCEC::UnregisterClients(void) |
c9549d35 | 937 | { |
004b8382 LOK |
938 | m_clients.clear(); |
939 | delete m_client; | |
940 | m_client = NULL; | |
c9549d35 | 941 | } |
9878069e | 942 | |
004b8382 | 943 | void * CECInitialise(libcec_configuration *configuration) |
9878069e | 944 | { |
004b8382 LOK |
945 | if (!configuration) |
946 | return NULL; | |
947 | ||
c30acafa | 948 | CLibCEC *lib = new CLibCEC(NULL); |
99aeafb9 | 949 | CCECClient *client(NULL); |
004b8382 | 950 | if (lib) |
99aeafb9 LOK |
951 | client = lib->RegisterClient(configuration); |
952 | ||
953 | if (client) | |
954 | client->GetCurrentConfiguration(configuration); | |
955 | ||
956 | // ensure that the correct server version is set | |
957 | configuration->serverVersion = LIBCEC_VERSION_CURRENT; | |
004b8382 LOK |
958 | |
959 | return static_cast< void* > (lib); | |
9878069e | 960 | } |
209b7a5c | 961 | |
004b8382 | 962 | void * CECInit(const char *strDeviceName, CEC::cec_device_type_list types, uint16_t iPhysicalAddress /* = 0 */) |
209b7a5c | 963 | { |
004b8382 | 964 | libcec_configuration configuration; |
004b8382 LOK |
965 | |
966 | // client version < 1.5.0 | |
967 | snprintf(configuration.strDeviceName, 13, "%s", strDeviceName); | |
968 | configuration.deviceTypes = types; | |
969 | configuration.iPhysicalAddress = iPhysicalAddress; | |
970 | ||
971 | if (configuration.deviceTypes.IsEmpty()) | |
972 | configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE); | |
973 | ||
974 | return CECInitialise(&configuration); | |
209b7a5c LOK |
975 | } |
976 | ||
004b8382 | 977 | bool CECStartBootloader(void) |
209b7a5c | 978 | { |
004b8382 LOK |
979 | bool bReturn(false); |
980 | cec_adapter deviceList[1]; | |
981 | if (CUSBCECAdapterDetection::FindAdapters(deviceList, 1) > 0) | |
209b7a5c | 982 | { |
004b8382 LOK |
983 | CUSBCECAdapterCommunication comm(NULL, deviceList[0].comm); |
984 | CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT); | |
985 | while (timeout.TimeLeft() > 0 && (bReturn = comm.Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false) | |
209b7a5c | 986 | { |
004b8382 LOK |
987 | comm.Close(); |
988 | CEvent::Sleep(500); | |
209b7a5c | 989 | } |
004b8382 LOK |
990 | if (comm.IsOpen()) |
991 | bReturn = comm.StartBootloader(); | |
209b7a5c | 992 | } |
004b8382 LOK |
993 | |
994 | return bReturn; | |
995 | } | |
996 | ||
997 | void CECDestroy(CEC::ICECAdapter *instance) | |
998 | { | |
999 | delete instance; | |
209b7a5c | 1000 | } |
f80cd208 | 1001 | |
b32ffd87 | 1002 | bool CLibCEC::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */) |
f80cd208 LOK |
1003 | { |
1004 | if (m_cec->IsRunning()) | |
1005 | return false; | |
004b8382 | 1006 | |
f80cd208 | 1007 | return m_cec->GetDeviceInformation(strPort, config, iTimeoutMs); |
a75e3a5a | 1008 | } |
c30acafa LOK |
1009 | |
1010 | void CLibCEC::AddKey(const cec_keypress &UNUSED(key)) {} | |
1011 | void CLibCEC::AddCommand(const cec_command &UNUSED(command)) {} | |
1012 | void CLibCEC::ConfigurationChanged(const libcec_configuration &UNUSED(config)) {} | |
1013 | void CLibCEC::SetCurrentButton(cec_user_control_code UNUSED(iButtonCode)) {} | |
1014 | CLibCEC *CLibCEC::GetInstance(void) { return NULL; } | |
1015 | void CLibCEC::SetInstance(CLibCEC *UNUSED(instance)) {} |