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