cec: LG devices don't respond to CEC version requests (unsupported feature). set...
[deb_libcec.git] / src / lib / devices / CECBusDevice.cpp
1 /*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33 #include "CECBusDevice.h"
34 #include "../CECProcessor.h"
35 #include "../implementations/ANCommandHandler.h"
36 #include "../implementations/CECCommandHandler.h"
37 #include "../implementations/SLCommandHandler.h"
38 #include "../implementations/VLCommandHandler.h"
39 #include "../LibCEC.h"
40 #include "../platform/util/timeutils.h"
41
42 using namespace CEC;
43 using namespace PLATFORM;
44
45 #define ToString(p) m_processor->ToString(p)
46
47 CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress) :
48 m_type(CEC_DEVICE_TYPE_RESERVED),
49 m_iPhysicalAddress(iPhysicalAddress),
50 m_iStreamPath(0),
51 m_iLogicalAddress(iLogicalAddress),
52 m_powerStatus(CEC_POWER_STATUS_UNKNOWN),
53 m_processor(processor),
54 m_vendor(CEC_VENDOR_UNKNOWN),
55 m_bReplaceHandler(false),
56 m_menuState(CEC_MENU_STATE_ACTIVATED),
57 m_bActiveSource(false),
58 m_iLastActive(0),
59 m_iLastPowerStateUpdate(0),
60 m_cecVersion(CEC_VERSION_UNKNOWN),
61 m_deviceStatus(CEC_DEVICE_STATUS_UNKNOWN),
62 m_iHandlerUseCount(0),
63 m_bAwaitingReceiveFailed(false)
64 {
65 m_handler = new CCECCommandHandler(this);
66
67 for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
68 m_menuLanguage.language[iPtr] = '?';
69 m_menuLanguage.language[3] = 0;
70 m_menuLanguage.device = iLogicalAddress;
71
72 m_strDeviceName = ToString(m_iLogicalAddress);
73 }
74
75 CCECBusDevice::~CCECBusDevice(void)
76 {
77 delete m_handler;
78 }
79
80 bool CCECBusDevice::HandleCommand(const cec_command &command)
81 {
82 bool bHandled(false);
83
84 /* update "last active" */
85 {
86 CLockObject lock(m_mutex);
87 m_iLastActive = GetTimeMs();
88
89 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
90 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
91
92 MarkBusy();
93 }
94
95 /* handle the command */
96 bHandled = m_handler->HandleCommand(command);
97
98 /* change status to present */
99 if (bHandled)
100 {
101 CLockObject lock(m_mutex);
102 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
103 {
104 if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT)
105 CLibCEC::AddLog(CEC_LOG_DEBUG, "device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode));
106 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
107 }
108 }
109
110 MarkReady();
111 return bHandled;
112 }
113
114 bool CCECBusDevice::PowerOn(void)
115 {
116 bool bReturn(false);
117 GetVendorId(); // ensure that we got the vendor id, because the implementations vary per vendor
118
119 MarkBusy();
120 cec_power_status currentStatus = GetPowerStatus(false);
121 if (currentStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON &&
122 currentStatus != CEC_POWER_STATUS_ON)
123 {
124 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
125 if (m_handler->PowerOn(GetMyLogicalAddress(), m_iLogicalAddress))
126 {
127 SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
128 bReturn = true;
129 }
130 }
131 else
132 {
133 CLibCEC::AddLog(CEC_LOG_NOTICE, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus));
134 }
135
136 MarkReady();
137 return bReturn;
138 }
139
140 bool CCECBusDevice::Standby(void)
141 {
142 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
143 MarkBusy();
144 bool bReturn = m_handler->TransmitStandby(GetMyLogicalAddress(), m_iLogicalAddress);
145 MarkReady();
146 return bReturn;
147 }
148
149 /** @name Getters */
150 //@{
151 cec_version CCECBusDevice::GetCecVersion(bool bUpdate /* = false */)
152 {
153 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
154 bool bRequestUpdate(false);
155 {
156 CLockObject lock(m_mutex);
157 bRequestUpdate = bIsPresent &&
158 (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN);
159 }
160
161 if (bRequestUpdate)
162 RequestCecVersion();
163
164 CLockObject lock(m_mutex);
165 return m_cecVersion;
166 }
167
168 bool CCECBusDevice::RequestCecVersion(void)
169 {
170 bool bReturn(false);
171
172 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
173 !IsUnsupportedFeature(CEC_OPCODE_GET_CEC_VERSION))
174 {
175 MarkBusy();
176 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
177
178 bReturn = m_handler->TransmitRequestCecVersion(GetMyLogicalAddress(), m_iLogicalAddress);
179 MarkReady();
180 }
181 return bReturn;
182 }
183
184 const char* CCECBusDevice::GetLogicalAddressName(void) const
185 {
186 return ToString(m_iLogicalAddress);
187 }
188
189 cec_menu_language &CCECBusDevice::GetMenuLanguage(bool bUpdate /* = false */)
190 {
191 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
192 bool bRequestUpdate(false);
193 {
194 CLockObject lock(m_mutex);
195 bRequestUpdate = (bIsPresent &&
196 (bUpdate || !strcmp(m_menuLanguage.language, "???")));
197 }
198
199 if (bRequestUpdate)
200 RequestMenuLanguage();
201
202 CLockObject lock(m_mutex);
203 return m_menuLanguage;
204 }
205
206 bool CCECBusDevice::RequestMenuLanguage(void)
207 {
208 bool bReturn(false);
209
210 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
211 !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE))
212 {
213 MarkBusy();
214 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
215 bReturn = m_handler->TransmitRequestMenuLanguage(GetMyLogicalAddress(), m_iLogicalAddress);
216 MarkReady();
217 }
218 return bReturn;
219 }
220
221 cec_menu_state CCECBusDevice::GetMenuState(void)
222 {
223 CLockObject lock(m_mutex);
224 return m_menuState;
225 }
226
227 cec_logical_address CCECBusDevice::GetMyLogicalAddress(void) const
228 {
229 return m_processor->GetLogicalAddress();
230 }
231
232 uint16_t CCECBusDevice::GetMyPhysicalAddress(void) const
233 {
234 return m_processor->GetPhysicalAddress();
235 }
236
237 CStdString CCECBusDevice::GetOSDName(bool bUpdate /* = false */)
238 {
239 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
240 bool bRequestUpdate(false);
241 {
242 CLockObject lock(m_mutex);
243 bRequestUpdate = bIsPresent &&
244 (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) &&
245 m_type != CEC_DEVICE_TYPE_TV;
246 }
247
248 if (bRequestUpdate)
249 RequestOSDName();
250
251 CLockObject lock(m_mutex);
252 return m_strDeviceName;
253 }
254
255 bool CCECBusDevice::RequestOSDName(void)
256 {
257 bool bReturn(false);
258
259 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
260 !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME))
261 {
262 MarkBusy();
263 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
264 bReturn = m_handler->TransmitRequestOSDName(GetMyLogicalAddress(), m_iLogicalAddress);
265 MarkReady();
266 }
267 return bReturn;
268 }
269
270 uint16_t CCECBusDevice::GetPhysicalAddress(bool bUpdate /* = false */)
271 {
272 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
273 bool bRequestUpdate(false);
274 {
275 CLockObject lock(m_mutex);
276 bRequestUpdate = bIsPresent &&
277 (m_iPhysicalAddress == 0xFFFF || bUpdate);
278 }
279
280 if (bRequestUpdate && !RequestPhysicalAddress())
281 CLibCEC::AddLog(CEC_LOG_ERROR, "failed to request the physical address");
282
283 CLockObject lock(m_mutex);
284 return m_iPhysicalAddress;
285 }
286
287 bool CCECBusDevice::RequestPhysicalAddress(void)
288 {
289 bool bReturn(false);
290
291 if (!MyLogicalAddressContains(m_iLogicalAddress))
292 {
293 MarkBusy();
294 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
295 bReturn = m_handler->TransmitRequestPhysicalAddress(GetMyLogicalAddress(), m_iLogicalAddress);
296 MarkReady();
297 }
298 return bReturn;
299 }
300
301 cec_power_status CCECBusDevice::GetPowerStatus(bool bUpdate /* = false */)
302 {
303 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
304 bool bRequestUpdate(false);
305 {
306 CLockObject lock(m_mutex);
307 bRequestUpdate = (bIsPresent &&
308 (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
309 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON ||
310 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY ||
311 GetTimeMs() - m_iLastPowerStateUpdate >= CEC_POWER_STATE_REFRESH_TIME));
312 }
313
314 if (bRequestUpdate)
315 RequestPowerStatus();
316
317 CLockObject lock(m_mutex);
318 return m_powerStatus;
319 }
320
321 bool CCECBusDevice::RequestPowerStatus(void)
322 {
323 bool bReturn(false);
324
325 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
326 !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
327 {
328 MarkBusy();
329 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting power status of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
330 bReturn = m_handler->TransmitRequestPowerStatus(GetMyLogicalAddress(), m_iLogicalAddress);
331 MarkReady();
332 }
333 return bReturn;
334 }
335
336 cec_vendor_id CCECBusDevice::GetVendorId(bool bUpdate /* = false */)
337 {
338 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
339 bool bRequestUpdate(false);
340 {
341 CLockObject lock(m_mutex);
342 bRequestUpdate = (bIsPresent &&
343 (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN));
344 }
345
346 if (bRequestUpdate)
347 RequestVendorId();
348
349 CLockObject lock(m_mutex);
350 return m_vendor;
351 }
352
353 bool CCECBusDevice::RequestVendorId(void)
354 {
355 bool bReturn(false);
356
357 if (!MyLogicalAddressContains(m_iLogicalAddress))
358 {
359 MarkBusy();
360 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
361 bReturn = m_handler->TransmitRequestVendorId(GetMyLogicalAddress(), m_iLogicalAddress);
362 MarkReady();
363
364 ReplaceHandler(true);
365 }
366 return bReturn;
367 }
368
369 const char *CCECBusDevice::GetVendorName(bool bUpdate /* = false */)
370 {
371 return ToString(GetVendorId(bUpdate));
372 }
373
374 bool CCECBusDevice::MyLogicalAddressContains(cec_logical_address address) const
375 {
376 return m_processor->HasLogicalAddress(address);
377 }
378
379 bool CCECBusDevice::NeedsPoll(void)
380 {
381 bool bSendPoll(false);
382 switch (m_iLogicalAddress)
383 {
384 case CECDEVICE_PLAYBACKDEVICE3:
385 {
386 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE2]->GetStatus();
387 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
388 }
389 break;
390 case CECDEVICE_PLAYBACKDEVICE2:
391 {
392 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE1]->GetStatus();
393 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
394 }
395 break;
396 case CECDEVICE_RECORDINGDEVICE3:
397 {
398 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE2]->GetStatus();
399 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
400 }
401 break;
402 case CECDEVICE_RECORDINGDEVICE2:
403 {
404 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE1]->GetStatus();
405 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
406 }
407 break;
408 case CECDEVICE_TUNER4:
409 {
410 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_TUNER3]->GetStatus();
411 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
412 }
413 break;
414 case CECDEVICE_TUNER3:
415 {
416 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_TUNER2]->GetStatus();
417 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
418 }
419 break;
420 case CECDEVICE_TUNER2:
421 {
422 cec_bus_device_status status = m_processor->m_busDevices[CECDEVICE_TUNER1]->GetStatus();
423 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
424 }
425 break;
426 case CECDEVICE_AUDIOSYSTEM:
427 case CECDEVICE_PLAYBACKDEVICE1:
428 case CECDEVICE_RECORDINGDEVICE1:
429 case CECDEVICE_TUNER1:
430 case CECDEVICE_TV:
431 bSendPoll = true;
432 break;
433 default:
434 break;
435 }
436
437 return bSendPoll;
438 }
439
440 cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */)
441 {
442 CLockObject lock(m_mutex);
443 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC &&
444 (m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN || bForcePoll))
445 {
446 lock.Unlock();
447 bool bPollAcked(false);
448 if (bForcePoll || NeedsPoll())
449 bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
450
451 lock.Lock();
452 m_deviceStatus = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
453 }
454
455 return m_deviceStatus;
456 }
457
458 //@}
459
460 /** @name Setters */
461 //@{
462 void CCECBusDevice::SetCecVersion(const cec_version newVersion)
463 {
464 m_cecVersion = newVersion;
465 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion));
466 }
467
468 void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
469 {
470 CLockObject lock(m_mutex);
471 if (language.device == m_iLogicalAddress)
472 {
473 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, language.language);
474 m_menuLanguage = language;
475 }
476 }
477
478 void CCECBusDevice::SetOSDName(CStdString strName)
479 {
480 CLockObject lock(m_mutex);
481 if (m_strDeviceName != strName)
482 {
483 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName.c_str());
484 m_strDeviceName = strName;
485 }
486 }
487
488 void CCECBusDevice::SetMenuState(const cec_menu_state state)
489 {
490 CLockObject lock(m_mutex);
491 if (m_menuState != state)
492 {
493 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
494 m_menuState = state;
495 }
496 }
497
498 void CCECBusDevice::SetInactiveSource(void)
499 {
500 {
501 CLockObject lock(m_mutex);
502 m_bActiveSource = false;
503 }
504
505 if (MyLogicalAddressContains(m_iLogicalAddress))
506 SetPowerStatus(CEC_POWER_STATUS_STANDBY);
507 }
508
509 void CCECBusDevice::SetActiveSource(void)
510 {
511 CLockObject lock(m_mutex);
512 if (!m_bActiveSource)
513 CLibCEC::AddLog(CEC_LOG_DEBUG, "making %s (%x) the active source", GetLogicalAddressName(), m_iLogicalAddress);
514
515 for (int iPtr = 0; iPtr < 16; iPtr++)
516 if (iPtr != m_iLogicalAddress)
517 m_processor->m_busDevices[iPtr]->SetInactiveSource();
518
519 m_bActiveSource = true;
520 SetPowerStatus(CEC_POWER_STATUS_ON);
521 }
522
523 bool CCECBusDevice::TryLogicalAddress(void)
524 {
525 CLibCEC::AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName());
526
527 m_processor->SetAckMask(0);
528 if (!TransmitPoll(m_iLogicalAddress))
529 {
530 CLibCEC::AddLog(CEC_LOG_NOTICE, "using logical address '%s'", GetLogicalAddressName());
531 SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
532
533 return true;
534 }
535
536 CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName());
537 SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
538 return false;
539 }
540
541 void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus)
542 {
543 CLockObject lock(m_mutex);
544 switch (newStatus)
545 {
546 case CEC_DEVICE_STATUS_UNKNOWN:
547 if (m_deviceStatus != newStatus)
548 CLibCEC::AddLog(CEC_LOG_DEBUG, "device status of %s changed into 'unknown'", ToString(m_iLogicalAddress));
549 m_iStreamPath = 0;
550 m_powerStatus = CEC_POWER_STATUS_UNKNOWN;
551 m_vendor = CEC_VENDOR_UNKNOWN;
552 m_menuState = CEC_MENU_STATE_ACTIVATED;
553 m_bActiveSource = false;
554 m_iLastActive = 0;
555 m_cecVersion = CEC_VERSION_UNKNOWN;
556 m_deviceStatus = newStatus;
557 break;
558 case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
559 if (m_deviceStatus != newStatus)
560 CLibCEC::AddLog(CEC_LOG_DEBUG, "device status of %s changed into 'handled by libCEC'", ToString(m_iLogicalAddress));
561 m_iStreamPath = 0;
562 m_powerStatus = CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON;
563 m_vendor = CEC_VENDOR_UNKNOWN;
564 m_menuState = CEC_MENU_STATE_ACTIVATED;
565 m_bActiveSource = false;
566 m_iLastActive = 0;
567 m_cecVersion = CEC_VERSION_1_3A;
568 m_deviceStatus = newStatus;
569 break;
570 case CEC_DEVICE_STATUS_PRESENT:
571 if (m_deviceStatus != newStatus)
572 CLibCEC::AddLog(CEC_LOG_DEBUG, "device status of %s changed into 'present'", ToString(m_iLogicalAddress));
573 m_deviceStatus = newStatus;
574 break;
575 case CEC_DEVICE_STATUS_NOT_PRESENT:
576 if (m_deviceStatus != newStatus)
577 CLibCEC::AddLog(CEC_LOG_DEBUG, "device status of %s changed into 'not present'", ToString(m_iLogicalAddress));
578 m_deviceStatus = newStatus;
579 break;
580 }
581 }
582
583 void CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
584 {
585 CLockObject lock(m_mutex);
586 if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress)
587 {
588 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
589 m_iPhysicalAddress = iNewAddress;
590 }
591 }
592
593 void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = 0 */)
594 {
595 CLockObject lock(m_mutex);
596 if (iNewAddress > 0)
597 {
598 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress);
599 m_iStreamPath = iNewAddress;
600
601 if (iNewAddress > 0)
602 {
603 lock.Unlock();
604 SetPowerStatus(CEC_POWER_STATUS_ON);
605 }
606 }
607 }
608
609 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
610 {
611 CLockObject lock(m_mutex);
612 if (m_powerStatus != powerStatus)
613 {
614 m_iLastPowerStateUpdate = GetTimeMs();
615 CLibCEC::AddLog(CEC_LOG_DEBUG, ">> %s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
616 m_powerStatus = powerStatus;
617 }
618 }
619
620 void CCECBusDevice::MarkBusy(void)
621 {
622 CLockObject handlerLock(m_handlerMutex);
623 ++m_iHandlerUseCount;
624 }
625
626 void CCECBusDevice::MarkReady(void)
627 {
628 CLockObject handlerLock(m_handlerMutex);
629 if (m_iHandlerUseCount > 0)
630 --m_iHandlerUseCount;
631 }
632
633 bool CCECBusDevice::ReplaceHandler(bool bActivateSource /* = true */)
634 {
635 bool bInitHandler(false);
636 {
637 CTryLockObject lock(m_mutex);
638 if (!lock.IsLocked())
639 return false;
640
641 CLockObject handlerLock(m_handlerMutex);
642 if (m_iHandlerUseCount > 0)
643 return false;
644
645 MarkBusy();
646
647 if (m_vendor != m_handler->GetVendorId())
648 {
649 if (CCECCommandHandler::HasSpecificHandler(m_vendor))
650 {
651 CLibCEC::AddLog(CEC_LOG_DEBUG, "replacing the command handler for device '%s' (%x)", GetLogicalAddressName(), GetLogicalAddress());
652 delete m_handler;
653
654 switch (m_vendor)
655 {
656 case CEC_VENDOR_SAMSUNG:
657 m_handler = new CANCommandHandler(this);
658 break;
659 case CEC_VENDOR_LG:
660 m_handler = new CSLCommandHandler(this);
661 break;
662 case CEC_VENDOR_PANASONIC:
663 m_handler = new CVLCommandHandler(this);
664 break;
665 default:
666 m_handler = new CCECCommandHandler(this);
667 break;
668 }
669
670 m_handler->SetVendorId(m_vendor);
671 bInitHandler = true;
672 }
673 }
674 }
675
676 if (bInitHandler)
677 {
678 m_handler->InitHandler();
679
680 if (bActivateSource && m_processor->GetLogicalAddresses().IsSet(m_iLogicalAddress) && m_processor->IsInitialised() && IsActiveSource())
681 m_handler->ActivateSource();
682 }
683
684 MarkReady();
685
686 return true;
687 }
688
689 bool CCECBusDevice::SetVendorId(uint64_t iVendorId)
690 {
691 bool bVendorChanged(false);
692
693 {
694 CLockObject lock(m_mutex);
695 bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId);
696 m_vendor = (cec_vendor_id)iVendorId;
697 }
698
699 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor);
700
701 return bVendorChanged;
702 }
703 //@}
704
705 /** @name Transmit methods */
706 //@{
707 bool CCECBusDevice::TransmitActiveSource(void)
708 {
709 bool bSendActiveSource(false);
710
711 {
712 CLockObject lock(m_mutex);
713 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
714 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
715 else if (m_bActiveSource)
716 {
717 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
718 bSendActiveSource = true;
719 }
720 else
721 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
722 }
723
724 if (bSendActiveSource)
725 {
726 MarkBusy();
727 m_handler->TransmitActiveSource(m_iLogicalAddress, m_iPhysicalAddress);
728 MarkReady();
729 return true;
730 }
731
732 return false;
733 }
734
735 bool CCECBusDevice::TransmitCECVersion(cec_logical_address dest)
736 {
737 cec_version version;
738 {
739 CLockObject lock(m_mutex);
740 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_cecVersion));
741 version = m_cecVersion;
742 }
743
744 MarkBusy();
745 bool bReturn = m_handler->TransmitCECVersion(m_iLogicalAddress, dest, version);
746 MarkReady();
747 return bReturn;
748 }
749
750 bool CCECBusDevice::TransmitImageViewOn(void)
751 {
752 {
753 CLockObject lock(m_mutex);
754 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
755 {
756 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
757 return false;
758 }
759 }
760
761 MarkBusy();
762 m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
763 MarkReady();
764 return true;
765 }
766
767 bool CCECBusDevice::TransmitInactiveSource(void)
768 {
769 uint16_t iPhysicalAddress;
770 {
771 CLockObject lock(m_mutex);
772 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
773 iPhysicalAddress = m_iPhysicalAddress;
774 }
775
776 MarkBusy();
777 bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
778 MarkReady();
779 return bReturn;
780 }
781
782 bool CCECBusDevice::TransmitMenuState(cec_logical_address dest)
783 {
784 cec_menu_state menuState;
785 {
786 CLockObject lock(m_mutex);
787 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
788 menuState = m_menuState;
789 }
790
791 MarkBusy();
792 bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState);
793 MarkReady();
794 return bReturn;
795 }
796
797 bool CCECBusDevice::TransmitOSDName(cec_logical_address dest)
798 {
799 CStdString strDeviceName;
800 {
801 CLockObject lock(m_mutex);
802 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, m_strDeviceName.c_str());
803 strDeviceName = m_strDeviceName;
804 }
805
806 MarkBusy();
807 bool bReturn = m_handler->TransmitOSDName(m_iLogicalAddress, dest, strDeviceName);
808 MarkReady();
809 return bReturn;
810 }
811
812 bool CCECBusDevice::TransmitOSDString(cec_logical_address dest, cec_display_control duration, const char *strMessage)
813 {
814 bool bReturn(false);
815 if (!m_processor->m_busDevices[dest]->IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING))
816 {
817 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, strMessage);
818 MarkBusy();
819 bReturn = m_handler->TransmitOSDString(m_iLogicalAddress, dest, duration, strMessage);
820 MarkReady();
821 }
822 return bReturn;
823 }
824
825 bool CCECBusDevice::TransmitPhysicalAddress(void)
826 {
827 uint16_t iPhysicalAddress;
828 cec_device_type type;
829 {
830 CLockObject lock(m_mutex);
831 if (m_iPhysicalAddress == 0xffff)
832 return false;
833
834 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
835 iPhysicalAddress = m_iPhysicalAddress;
836 type = m_type;
837 }
838
839 MarkBusy();
840 bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type);
841 MarkReady();
842 return bReturn;
843 }
844
845 bool CCECBusDevice::TransmitPoll(cec_logical_address dest)
846 {
847 bool bReturn(false);
848 if (dest == CECDEVICE_UNKNOWN)
849 dest = m_iLogicalAddress;
850
851 CCECBusDevice *destDevice = m_processor->m_busDevices[dest];
852 if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
853 return bReturn;
854
855 MarkBusy();
856 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
857 bReturn = m_handler->TransmitPoll(m_iLogicalAddress, dest);
858 CLibCEC::AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
859
860 CLockObject lock(m_mutex);
861 if (bReturn)
862 {
863 m_iLastActive = GetTimeMs();
864 destDevice->m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
865 }
866 else
867 destDevice->m_deviceStatus = CEC_DEVICE_STATUS_NOT_PRESENT;
868
869 MarkReady();
870 return bReturn;
871 }
872
873 bool CCECBusDevice::TransmitPowerState(cec_logical_address dest)
874 {
875 cec_power_status state;
876 {
877 CLockObject lock(m_mutex);
878 if (!IsActiveSource())
879 SetPowerStatus(CEC_POWER_STATUS_STANDBY);
880
881 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_powerStatus));
882 state = m_powerStatus;
883 }
884
885 MarkBusy();
886 bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, dest, state);
887 MarkReady();
888 return bReturn;
889 }
890
891 bool CCECBusDevice::TransmitVendorID(cec_logical_address dest, bool bSendAbort /* = true */)
892 {
893 bool bReturn(false);
894 uint64_t iVendorId;
895 {
896 CLockObject lock(m_mutex);
897 iVendorId = (uint64_t)m_vendor;
898 }
899
900 MarkBusy();
901 if (iVendorId == CEC_VENDOR_UNKNOWN)
902 {
903 if (bSendAbort)
904 {
905 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
906 m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
907 bReturn = true;
908 }
909 }
910 else
911 {
912 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString((cec_vendor_id)iVendorId), iVendorId);
913 bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId);
914 }
915 MarkReady();
916 return bReturn;
917 }
918
919 bool CCECBusDevice::TransmitKeypress(cec_user_control_code key, bool bWait /* = true */)
920 {
921 MarkBusy();
922 bool bReturn = m_handler->TransmitKeypress(m_processor->GetLogicalAddress(), m_iLogicalAddress, key, bWait);
923 MarkReady();
924 return bReturn;
925 }
926
927 bool CCECBusDevice::TransmitKeyRelease(bool bWait /* = true */)
928 {
929 MarkBusy();
930 bool bReturn = m_handler->TransmitKeyRelease(m_processor->GetLogicalAddress(), m_iLogicalAddress, bWait);
931 MarkReady();
932 return bReturn;
933 }
934
935 bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode) const
936 {
937 bool bUnsupported = (m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end());
938 if (bUnsupported)
939 CLibCEC::AddLog(CEC_LOG_NOTICE, "'%s' is marked as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
940 return bUnsupported;
941 }
942
943 void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode)
944 {
945 CLibCEC::AddLog(CEC_LOG_DEBUG, "marking opcode '%s' as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
946 m_unsupportedFeatures.insert(opcode);
947 }
948
949 bool CCECBusDevice::ActivateSource(void)
950 {
951 MarkBusy();
952 bool bReturn = m_handler->ActivateSource();
953 MarkReady();
954 return bReturn;
955 }
956
957 void CCECBusDevice::HandlePoll(cec_logical_address iDestination)
958 {
959 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(m_iLogicalAddress), m_iLogicalAddress, ToString(iDestination), iDestination);
960 m_bAwaitingReceiveFailed = true;
961 }
962
963 bool CCECBusDevice::HandleReceiveFailed(void)
964 {
965 bool bReturn = m_bAwaitingReceiveFailed;
966 m_bAwaitingReceiveFailed = false;
967 return bReturn;
968 }
969
970 //@}