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