repositories / deb_libcec.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge branch 'master' into release
[deb_libcec.git] / src / lib / devices / CECBusDevice.cpp
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011 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 "../platform/timeutils.h"
40
41using namespace CEC;
42
43#define ToString(p) m_processor->ToString(p)
44
45CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress) :
46 m_type(CEC_DEVICE_TYPE_RESERVED),
47 m_iPhysicalAddress(iPhysicalAddress),
48 m_iStreamPath(0),
49 m_iLogicalAddress(iLogicalAddress),
50 m_powerStatus(CEC_POWER_STATUS_UNKNOWN),
51 m_processor(processor),
52 m_vendor(CEC_VENDOR_UNKNOWN),
53 m_bReplaceHandler(false),
54 m_menuState(CEC_MENU_STATE_ACTIVATED),
55 m_bActiveSource(false),
56 m_iLastActive(0),
57 m_cecVersion(CEC_VERSION_UNKNOWN),
58 m_deviceStatus(CEC_DEVICE_STATUS_UNKNOWN),
59 m_handlerMutex(false)
60{
61 m_handler = new CCECCommandHandler(this);
62
63 for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
64 m_menuLanguage.language[iPtr] = '?';
65 m_menuLanguage.language[3] = 0;
66 m_menuLanguage.device = iLogicalAddress;
67
68 m_strDeviceName = ToString(m_iLogicalAddress);
69}
70
71CCECBusDevice::~CCECBusDevice(void)
72{
73 delete m_handler;
74}
75
76void CCECBusDevice::AddLog(cec_log_level level, const CStdString &strMessage)
77{
78 m_processor->AddLog(level, strMessage);
79}
80
81bool CCECBusDevice::HandleCommand(const cec_command &command)
82{
83 bool bHandled(false);
84
85 /* update "last active" */
86 {
87 CLockObject lock(&m_mutex);
88 m_iLastActive = GetTimeMs();
89
90 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
91 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
92 }
93
94 /* handle the command */
95 bHandled = m_handler->HandleCommand(command);
96
97 /* change status to present */
98 if (bHandled)
99 {
100 CLockObject lock(&m_mutex);
101 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
102 {
103 if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT)
104 {
105 CStdString strLog;
106 strLog.Format("device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode));
107 AddLog(CEC_LOG_DEBUG, strLog);
108 }
109 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
110 }
111 }
112
113 return bHandled;
114}
115
116bool CCECBusDevice::PowerOn(void)
117{
118 CStdString strLog;
119 strLog.Format("<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
120 AddLog(CEC_LOG_DEBUG, strLog.c_str());
121
122 if (m_handler->TransmitImageViewOn(GetMyLogicalAddress(), m_iLogicalAddress))
123 {
124 {
125 CLockObject lock(&m_mutex);
126// m_powerStatus = CEC_POWER_STATUS_UNKNOWN;
127 m_powerStatus = CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON;
128 }
129// cec_power_status status = GetPowerStatus();
130// if (status == CEC_POWER_STATUS_STANDBY || status == CEC_POWER_STATUS_UNKNOWN)
131// {
132// /* sending the normal power on command appears to have failed */
133// CStdString strLog;
134// strLog.Format("<< sending power on keypress to '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
135// AddLog(CEC_LOG_DEBUG, strLog.c_str());
136//
137// TransmitKeypress(CEC_USER_CONTROL_CODE_POWER);
138// return TransmitKeyRelease();
139// }
140 return true;
141 }
142
143 return false;
144}
145
146bool CCECBusDevice::Standby(void)
147{
148 CStdString strLog;
149 strLog.Format("<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
150 AddLog(CEC_LOG_DEBUG, strLog.c_str());
151
152 return m_handler->TransmitStandby(GetMyLogicalAddress(), m_iLogicalAddress);
153}
154
155/** @name Getters */
156//@{
157cec_version CCECBusDevice::GetCecVersion(bool bUpdate /* = false */)
158{
159 bool bRequestUpdate(false);
160 {
161 CLockObject lock(&m_mutex);
162 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
163 (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN));
164 }
165
166 if (bRequestUpdate)
167 RequestCecVersion();
168
169 CLockObject lock(&m_mutex);
170 return m_cecVersion;
171}
172
173bool CCECBusDevice::RequestCecVersion(void)
174{
175 bool bReturn(false);
176
177 if (!MyLogicalAddressContains(m_iLogicalAddress))
178 {
179 CStdString strLog;
180 strLog.Format("<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
181 AddLog(CEC_LOG_NOTICE, strLog);
182
183 bReturn = m_handler->TransmitRequestCecVersion(GetMyLogicalAddress(), m_iLogicalAddress);
184 }
185 return bReturn;
186}
187
188const char* CCECBusDevice::GetLogicalAddressName(void) const
189{
190 return ToString(m_iLogicalAddress);
191}
192
193cec_menu_language &CCECBusDevice::GetMenuLanguage(bool bUpdate /* = false */)
194{
195 bool bRequestUpdate(false);
196 {
197 CLockObject lock(&m_mutex);
198 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
199 (bUpdate || !strcmp(m_menuLanguage.language, "???")));
200 }
201
202 if (bRequestUpdate)
203 RequestMenuLanguage();
204
205 CLockObject lock(&m_mutex);
206 return m_menuLanguage;
207}
208
209bool CCECBusDevice::RequestMenuLanguage(void)
210{
211 bool bReturn(false);
212
213 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
214 !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE))
215 {
216 CStdString strLog;
217 strLog.Format("<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
218 AddLog(CEC_LOG_NOTICE, strLog);
219 bReturn = m_handler->TransmitRequestMenuLanguage(GetMyLogicalAddress(), m_iLogicalAddress);
220 }
221 return bReturn;
222}
223
224cec_logical_address CCECBusDevice::GetMyLogicalAddress(void) const
225{
226 return m_processor->GetLogicalAddress();
227}
228
229uint16_t CCECBusDevice::GetMyPhysicalAddress(void) const
230{
231 return m_processor->GetPhysicalAddress();
232}
233
234CStdString CCECBusDevice::GetOSDName(bool bUpdate /* = false */)
235{
236 bool bRequestUpdate(false);
237 {
238 CLockObject lock(&m_mutex);
239 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
240 (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) &&
241 m_type != CEC_DEVICE_TYPE_TV);
242 }
243
244 if (bRequestUpdate)
245 RequestOSDName();
246
247 CLockObject lock(&m_mutex);
248 return m_strDeviceName;
249}
250
251bool CCECBusDevice::RequestOSDName(void)
252{
253 bool bReturn(false);
254
255 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
256 !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME))
257 {
258 CStdString strLog;
259 strLog.Format("<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
260 AddLog(CEC_LOG_NOTICE, strLog);
261 bReturn = m_handler->TransmitRequestOSDName(GetMyLogicalAddress(), m_iLogicalAddress);
262 }
263 return bReturn;
264}
265
266uint16_t CCECBusDevice::GetPhysicalAddress(bool bUpdate /* = false */)
267{
268 bool bRequestUpdate(false);
269 {
270 CLockObject lock(&m_mutex);
271 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
272 (m_iPhysicalAddress == 0xFFFF || bUpdate));
273 }
274
275 if (bRequestUpdate && !RequestPhysicalAddress())
276 AddLog(CEC_LOG_ERROR, "failed to request the physical address (1)");
277
278 CLockObject lock(&m_mutex);
279 return m_iPhysicalAddress;
280}
281
282bool CCECBusDevice::RequestPhysicalAddress(void)
283{
284 bool bReturn(false);
285
286 if (!MyLogicalAddressContains(m_iLogicalAddress))
287 {
288 CStdString strLog;
289 strLog.Format("<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
290 AddLog(CEC_LOG_NOTICE, strLog);
291 bReturn = m_handler->TransmitRequestPhysicalAddress(GetMyLogicalAddress(), m_iLogicalAddress);
292 }
293 return bReturn;
294}
295
296cec_power_status CCECBusDevice::GetPowerStatus(bool bUpdate /* = false */)
297{
298 bool bRequestUpdate(false);
299 {
300 CLockObject lock(&m_mutex);
301 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
302 (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
303 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON));
304 }
305
306 if (bRequestUpdate)
307 RequestPowerStatus();
308
309 CLockObject lock(&m_mutex);
310 return m_powerStatus;
311}
312
313bool CCECBusDevice::RequestPowerStatus(void)
314{
315 bool bReturn(false);
316
317 if (!MyLogicalAddressContains(m_iLogicalAddress) &&
318 !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
319 {
320 CStdString strLog;
321 strLog.Format("<< requesting power status of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
322 AddLog(CEC_LOG_NOTICE, strLog);
323 bReturn = m_handler->TransmitRequestPowerStatus(GetMyLogicalAddress(), m_iLogicalAddress);
324 }
325 return bReturn;
326}
327
328cec_vendor_id CCECBusDevice::GetVendorId(bool bUpdate /* = false */)
329{
330 bool bRequestUpdate(false);
331 {
332 CLockObject lock(&m_mutex);
333 bRequestUpdate = (GetStatus() == CEC_DEVICE_STATUS_PRESENT &&
334 (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN));
335 }
336
337 if (bRequestUpdate)
338 RequestVendorId();
339
340 CLockObject lock(&m_mutex);
341 return m_vendor;
342}
343
344bool CCECBusDevice::RequestVendorId(void)
345{
346 bool bReturn(false);
347
348 if (!MyLogicalAddressContains(m_iLogicalAddress))
349 {
350 CStdString strLog;
351 strLog.Format("<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
352 AddLog(CEC_LOG_NOTICE, strLog);
353 bReturn = m_handler->TransmitRequestVendorId(GetMyLogicalAddress(), m_iLogicalAddress);
354 }
355 return bReturn;
356}
357
358const char *CCECBusDevice::GetVendorName(bool bUpdate /* = false */)
359{
360 return ToString(GetVendorId(bUpdate));
361}
362
363bool CCECBusDevice::MyLogicalAddressContains(cec_logical_address address) const
364{
365 return m_processor->HasLogicalAddress(address);
366}
367
368bool CCECBusDevice::NeedsPoll(void)
369{
370 bool bSendPoll(false);
371 switch (m_iLogicalAddress)
372 {
373 case CECDEVICE_PLAYBACKDEVICE3:
374 if (m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
375 bSendPoll = true;
376 break;
377 case CECDEVICE_PLAYBACKDEVICE2:
378 if (m_processor->m_busDevices[CECDEVICE_PLAYBACKDEVICE1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
379 bSendPoll = true;
380 break;
381 case CECDEVICE_RECORDINGDEVICE3:
382 if (m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
383 bSendPoll = true;
384 break;
385 case CECDEVICE_RECORDINGDEVICE2:
386 if (m_processor->m_busDevices[CECDEVICE_RECORDINGDEVICE1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
387 bSendPoll = true;
388 break;
389 case CECDEVICE_TUNER4:
390 if (m_processor->m_busDevices[CECDEVICE_TUNER3]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
391 bSendPoll = true;
392 break;
393 case CECDEVICE_TUNER3:
394 if (m_processor->m_busDevices[CECDEVICE_TUNER2]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
395 bSendPoll = true;
396 break;
397 case CECDEVICE_TUNER2:
398 if (m_processor->m_busDevices[CECDEVICE_TUNER1]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
399 bSendPoll = true;
400 break;
401 case CECDEVICE_AUDIOSYSTEM:
402 case CECDEVICE_PLAYBACKDEVICE1:
403 case CECDEVICE_RECORDINGDEVICE1:
404 case CECDEVICE_TUNER1:
405 case CECDEVICE_TV:
406 bSendPoll = true;
407 break;
408 default:
409 break;
410 }
411
412 return bSendPoll;
413}
414
415cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */)
416{
417 CLockObject lock(&m_mutex);
418 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC &&
419 (m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN || bForcePoll))
420 {
421 lock.Leave();
422 bool bPollAcked(false);
423 if (bForcePoll || NeedsPoll())
424 bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
425
426 lock.Lock();
427 m_deviceStatus = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
428 }
429
430 return m_deviceStatus;
431}
432
433//@}
434
435/** @name Setters */
436//@{
437void CCECBusDevice::SetCecVersion(const cec_version newVersion)
438{
439 m_cecVersion = newVersion;
440
441 CStdString strLog;
442 strLog.Format("%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion));
443 AddLog(CEC_LOG_DEBUG, strLog);
444}
445
446void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
447{
448 CLockObject lock(&m_mutex);
449 if (language.device == m_iLogicalAddress)
450 {
451 CStdString strLog;
452 strLog.Format(">> %s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, language.language);
453 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
454 m_menuLanguage = language;
455 }
456}
457
458void CCECBusDevice::SetOSDName(CStdString strName)
459{
460 CLockObject lock(&m_mutex);
461 if (m_strDeviceName != strName)
462 {
463 CStdString strLog;
464 strLog.Format(">> %s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName);
465 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
466 m_strDeviceName = strName;
467 }
468}
469
470void CCECBusDevice::SetMenuState(const cec_menu_state state)
471{
472 CLockObject lock(&m_mutex);
473 if (m_menuState != state)
474 {
475 CStdString strLog;
476 strLog.Format(">> %s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
477 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
478 m_menuState = state;
479 }
480}
481
482void CCECBusDevice::SetInactiveSource(void)
483{
484 {
485 CLockObject lock(&m_mutex);
486 m_bActiveSource = false;
487 }
488
489 if (MyLogicalAddressContains(m_iLogicalAddress))
490 SetPowerStatus(CEC_POWER_STATUS_STANDBY);
491}
492
493void CCECBusDevice::SetActiveSource(void)
494{
495 CLockObject lock(&m_mutex);
496
497 for (int iPtr = 0; iPtr < 16; iPtr++)
498 if (iPtr != m_iLogicalAddress)
499 m_processor->m_busDevices[iPtr]->SetInactiveSource();
500
501 m_bActiveSource = true;
502 m_powerStatus = CEC_POWER_STATUS_ON;
503}
504
505bool CCECBusDevice::TryLogicalAddress(void)
506{
507 CStdString strLog;
508 strLog.Format("trying logical address '%s'", GetLogicalAddressName());
509 AddLog(CEC_LOG_DEBUG, strLog);
510
511 m_processor->SetAckMask(0x1 << m_iLogicalAddress);
512 if (!TransmitPoll(m_iLogicalAddress))
513 {
514 strLog.Format("using logical address '%s'", GetLogicalAddressName());
515 AddLog(CEC_LOG_NOTICE, strLog);
516 SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
517
518 return true;
519 }
520
521 strLog.Format("logical address '%s' already taken", GetLogicalAddressName());
522 AddLog(CEC_LOG_DEBUG, strLog);
523 SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
524 return false;
525}
526
527void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus)
528{
529 CLockObject lock(&m_mutex);
530 switch (newStatus)
531 {
532 case CEC_DEVICE_STATUS_UNKNOWN:
533 m_iStreamPath = 0;
534 m_powerStatus = CEC_POWER_STATUS_UNKNOWN;
535 m_vendor = CEC_VENDOR_UNKNOWN;
536 m_menuState = CEC_MENU_STATE_ACTIVATED;
537 m_bActiveSource = false;
538 m_iLastActive = 0;
539 m_cecVersion = CEC_VERSION_UNKNOWN;
540 m_deviceStatus = newStatus;
541 break;
542 case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
543 m_iStreamPath = 0;
544 m_powerStatus = CEC_POWER_STATUS_ON;
545 m_vendor = CEC_VENDOR_UNKNOWN;
546 m_menuState = CEC_MENU_STATE_ACTIVATED;
547 m_bActiveSource = false;
548 m_iLastActive = 0;
549 m_cecVersion = CEC_VERSION_1_3A;
550 m_deviceStatus = newStatus;
551 break;
552 case CEC_DEVICE_STATUS_PRESENT:
553 case CEC_DEVICE_STATUS_NOT_PRESENT:
554 m_deviceStatus = newStatus;
555 break;
556 }
557}
558
559void CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
560{
561 CLockObject lock(&m_mutex);
562 if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress)
563 {
564 CStdString strLog;
565 strLog.Format(">> %s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
566 AddLog(CEC_LOG_DEBUG, strLog.c_str());
567
568 m_iPhysicalAddress = iNewAddress;
569 }
570}
571
572void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = 0 */)
573{
574 CLockObject lock(&m_mutex);
575 if (iNewAddress > 0)
576 {
577 CStdString strLog;
578 strLog.Format(">> %s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress);
579 AddLog(CEC_LOG_DEBUG, strLog.c_str());
580
581 m_iStreamPath = iNewAddress;
582
583 if (iNewAddress > 0)
584 {
585 lock.Leave();
586 SetPowerStatus(CEC_POWER_STATUS_ON);
587 }
588 }
589}
590
591void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
592{
593 CLockObject lock(&m_mutex);
594 if (m_powerStatus != powerStatus)
595 {
596 CStdString strLog;
597 strLog.Format(">> %s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
598 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
599 m_powerStatus = powerStatus;
600 }
601}
602
603bool CCECBusDevice::ReplaceHandler(bool bInitHandler /* = true */)
604{
605 CLockObject lock(&m_mutex);
606 CLockObject handlerLock(&m_handlerMutex);
607
608 if (m_vendor != m_handler->GetVendorId())
609 {
610 if (m_handler->InUse())
611 return false;
612
613 delete m_handler;
614
615 switch (m_vendor)
616 {
617 case CEC_VENDOR_SAMSUNG:
618 m_handler = new CANCommandHandler(this);
619 break;
620 case CEC_VENDOR_LG:
621 m_handler = new CSLCommandHandler(this);
622 break;
623 case CEC_VENDOR_PANASONIC:
624 m_handler = new CVLCommandHandler(this);
625 break;
626 default:
627 m_handler = new CCECCommandHandler(this);
628 break;
629 }
630
631 if (bInitHandler && m_processor->GetLogicalAddresses().IsSet(m_iLogicalAddress) && m_processor->IsInitialised())
632 m_handler->InitHandler();
633 }
634
635 return true;
636}
637
638bool CCECBusDevice::SetVendorId(uint64_t iVendorId, bool bInitHandler /* = true */)
639{
640 bool bVendorChanged(false);
641
642 {
643 CLockObject lock(&m_mutex);
644 bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId);
645 m_vendor = (cec_vendor_id)iVendorId;
646 ReplaceHandler(bInitHandler);
647 }
648
649 CStdString strLog;
650 strLog.Format("%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor);
651 m_processor->AddLog(CEC_LOG_DEBUG, strLog.c_str());
652
653 return bVendorChanged;
654}
655//@}
656
657/** @name Transmit methods */
658//@{
659bool CCECBusDevice::TransmitActiveSource(void)
660{
661 bool bSendActiveSource(false);
662
663 {
664 CLockObject lock(&m_mutex);
665 if (m_powerStatus != CEC_POWER_STATUS_ON)
666 {
667 CStdString strLog;
668 strLog.Format("<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
669 AddLog(CEC_LOG_DEBUG, strLog);
670 }
671 else if (m_bActiveSource)
672 {
673 CStdString strLog;
674 strLog.Format("<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
675 AddLog(CEC_LOG_NOTICE, strLog);
676 bSendActiveSource = true;
677 }
678 else
679 {
680 CStdString strLog;
681 strLog.Format("<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
682 AddLog(CEC_LOG_DEBUG, strLog);
683 }
684 }
685
686 if (bSendActiveSource)
687 {
688 m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
689 m_handler->TransmitActiveSource(m_iLogicalAddress, m_iPhysicalAddress);
690 return true;
691 }
692
693 return false;
694}
695
696bool CCECBusDevice::TransmitCECVersion(cec_logical_address dest)
697{
698 cec_version version;
699 {
700 CLockObject lock(&m_mutex);
701 CStdString strLog;
702 strLog.Format("<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_cecVersion));
703 AddLog(CEC_LOG_NOTICE, strLog);
704 version = m_cecVersion;
705 }
706
707 return m_handler->TransmitCECVersion(m_iLogicalAddress, dest, version);
708}
709
710bool CCECBusDevice::TransmitInactiveSource(void)
711{
712 uint16_t iPhysicalAddress;
713 {
714 CLockObject lock(&m_mutex);
715 CStdString strLog;
716 strLog.Format("<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
717 AddLog(CEC_LOG_NOTICE, strLog);
718 iPhysicalAddress = m_iPhysicalAddress;
719 }
720
721 return m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
722}
723
724bool CCECBusDevice::TransmitMenuState(cec_logical_address dest)
725{
726 cec_menu_state menuState;
727 {
728 CLockObject lock(&m_mutex);
729 CStdString strLog;
730 strLog.Format("<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
731 AddLog(CEC_LOG_NOTICE, strLog);
732 menuState = m_menuState;
733 }
734
735 return m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState);
736}
737
738bool CCECBusDevice::TransmitOSDName(cec_logical_address dest)
739{
740 CStdString strDeviceName;
741 {
742 CLockObject lock(&m_mutex);
743 CStdString strLog;
744 strLog.Format("<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, m_strDeviceName.c_str());
745 AddLog(CEC_LOG_NOTICE, strLog.c_str());
746 strDeviceName = m_strDeviceName;
747 }
748
749 return m_handler->TransmitOSDName(m_iLogicalAddress, dest, strDeviceName);
750}
751
752bool CCECBusDevice::TransmitOSDString(cec_logical_address dest, cec_display_control duration, const char *strMessage)
753{
754 if (!IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING))
755 {
756 CStdString strLog;
757 strLog.Format("<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, strMessage);
758 AddLog(CEC_LOG_NOTICE, strLog.c_str());
759
760 return m_handler->TransmitOSDString(m_iLogicalAddress, dest, duration, strMessage);
761 }
762 return false;
763}
764
765bool CCECBusDevice::TransmitPhysicalAddress(void)
766{
767 uint16_t iPhysicalAddress;
768 cec_device_type type;
769 {
770 CLockObject lock(&m_mutex);
771 if (m_iPhysicalAddress == 0xffff)
772 return false;
773
774 CStdString strLog;
775 strLog.Format("<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
776 AddLog(CEC_LOG_NOTICE, strLog.c_str());
777
778 iPhysicalAddress = m_iPhysicalAddress;
779 type = m_type;
780 }
781
782 return m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type);
783}
784
785bool CCECBusDevice::TransmitPoll(cec_logical_address dest)
786{
787 bool bReturn(false);
788 if (dest == CECDEVICE_UNKNOWN)
789 dest = m_iLogicalAddress;
790
791 CCECBusDevice *destDevice = m_processor->m_busDevices[dest];
792 if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
793 return bReturn;
794
795 CStdString strLog;
796 strLog.Format("<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
797 AddLog(CEC_LOG_NOTICE, strLog.c_str());
798 bReturn = m_handler->TransmitPoll(m_iLogicalAddress, dest);
799 AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
800
801 CLockObject lock(&m_mutex);
802 if (bReturn)
803 {
804 m_iLastActive = GetTimeMs();
805 destDevice->m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
806 }
807 else
808 destDevice->m_deviceStatus = CEC_DEVICE_STATUS_NOT_PRESENT;
809
810 return bReturn;
811}
812
813bool CCECBusDevice::TransmitPowerState(cec_logical_address dest)
814{
815 cec_power_status state;
816 {
817 CLockObject lock(&m_mutex);
818 CStdString strLog;
819 strLog.Format("<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_powerStatus));
820 AddLog(CEC_LOG_NOTICE, strLog.c_str());
821 state = m_powerStatus;
822 }
823
824 return m_handler->TransmitPowerState(m_iLogicalAddress, dest, state);
825}
826
827bool CCECBusDevice::TransmitVendorID(cec_logical_address dest, bool bSendAbort /* = true */)
828{
829 uint64_t iVendorId;
830 {
831 CLockObject lock(&m_mutex);
832 iVendorId = (uint64_t)m_vendor;
833 }
834
835 if (iVendorId == CEC_VENDOR_UNKNOWN)
836 {
837 if (bSendAbort)
838 {
839 CStdString strLog;
840 strLog.Format("<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
841 AddLog(CEC_LOG_NOTICE, strLog);
842
843 m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
844 }
845 return false;
846 }
847 else
848 {
849 CStdString strLog;
850 strLog.Format("<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString((cec_vendor_id)iVendorId), iVendorId);
851 AddLog(CEC_LOG_NOTICE, strLog);
852
853 return m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId);
854 }
855}
856
857bool CCECBusDevice::TransmitKeypress(cec_user_control_code key, bool bWait /* = true */)
858{
859 return m_handler->TransmitKeypress(m_processor->GetLogicalAddress(), m_iLogicalAddress, key, bWait);
860}
861
862bool CCECBusDevice::TransmitKeyRelease(bool bWait /* = true */)
863{
864 return m_handler->TransmitKeyRelease(m_processor->GetLogicalAddress(), m_iLogicalAddress, bWait);
865}
866
867bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode) const
868{
869 return m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end();
870}
871
872void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode)
873{
874 m_unsupportedFeatures.insert(opcode);
875}
876
877bool CCECBusDevice::InitHandler(void)
878{
879 CLockObject lock(&m_mutex);
880 return m_handler->InitHandler();
881}
882
883//@}
libcec Piment Noir Debian package repository