fixed - request the active source before requesting device information in cec-client...
[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 "env.h"
34 #include "CECBusDevice.h"
35
36 #include "lib/CECProcessor.h"
37 #include "lib/CECClient.h"
38 #include "lib/implementations/ANCommandHandler.h"
39 #include "lib/implementations/CECCommandHandler.h"
40 #include "lib/implementations/SLCommandHandler.h"
41 #include "lib/implementations/VLCommandHandler.h"
42 #include "lib/LibCEC.h"
43 #include "lib/CECTypeUtils.h"
44 #include "lib/platform/util/timeutils.h"
45 #include "lib/platform/util/util.h"
46
47 #include "CECAudioSystem.h"
48 #include "CECPlaybackDevice.h"
49 #include "CECRecordingDevice.h"
50 #include "CECTuner.h"
51 #include "CECTV.h"
52
53 using namespace std;
54 using namespace CEC;
55 using namespace PLATFORM;
56
57 #define LIB_CEC m_processor->GetLib()
58 #define ToString(p) CCECTypeUtils::ToString(p)
59
60 CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */) :
61 m_type (CEC_DEVICE_TYPE_RESERVED),
62 m_iPhysicalAddress (iPhysicalAddress),
63 m_iStreamPath (CEC_INVALID_PHYSICAL_ADDRESS),
64 m_iLogicalAddress (iLogicalAddress),
65 m_powerStatus (CEC_POWER_STATUS_UNKNOWN),
66 m_processor (processor),
67 m_vendor (CEC_VENDOR_UNKNOWN),
68 m_bReplaceHandler (false),
69 m_menuState (CEC_MENU_STATE_ACTIVATED),
70 m_bActiveSource (false),
71 m_iLastActive (0),
72 m_iLastPowerStateUpdate (0),
73 m_cecVersion (CEC_VERSION_UNKNOWN),
74 m_deviceStatus (CEC_DEVICE_STATUS_UNKNOWN),
75 m_iHandlerUseCount (0),
76 m_bAwaitingReceiveFailed(false),
77 m_bVendorIdRequested (false),
78 m_waitForResponse (new CWaitForResponse)
79 {
80 m_handler = new CCECCommandHandler(this);
81
82 for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
83 m_menuLanguage.language[iPtr] = '?';
84 m_menuLanguage.language[3] = 0;
85 m_menuLanguage.device = iLogicalAddress;
86
87 m_strDeviceName = ToString(m_iLogicalAddress);
88 }
89
90 CCECBusDevice::~CCECBusDevice(void)
91 {
92 DELETE_AND_NULL(m_handler);
93 DELETE_AND_NULL(m_waitForResponse);
94 }
95
96 bool CCECBusDevice::ReplaceHandler(bool bActivateSource /* = true */)
97 {
98 if (m_iLogicalAddress == CECDEVICE_BROADCAST)
99 return false;
100
101 bool bInitHandler(false);
102 {
103 CLockObject lock(m_mutex);
104 CLockObject handlerLock(m_handlerMutex);
105 if (m_iHandlerUseCount > 0)
106 return false;
107
108 MarkBusy();
109
110 if (m_vendor != m_handler->GetVendorId())
111 {
112 if (CCECCommandHandler::HasSpecificHandler(m_vendor))
113 {
114 LIB_CEC->AddLog(CEC_LOG_DEBUG, "replacing the command handler for device '%s' (%x)", GetLogicalAddressName(), GetLogicalAddress());
115
116 int32_t iTransmitTimeout = m_handler->m_iTransmitTimeout;
117 int32_t iTransmitWait = m_handler->m_iTransmitWait;
118 int8_t iTransmitRetries = m_handler->m_iTransmitRetries;
119 int64_t iActiveSourcePending = m_handler->m_iActiveSourcePending;
120
121 DELETE_AND_NULL(m_handler);
122
123 switch (m_vendor)
124 {
125 case CEC_VENDOR_SAMSUNG:
126 m_handler = new CANCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
127 break;
128 case CEC_VENDOR_LG:
129 m_handler = new CSLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
130 break;
131 case CEC_VENDOR_PANASONIC:
132 m_handler = new CVLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
133 break;
134 default:
135 m_handler = new CCECCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
136 break;
137 }
138
139 m_handler->SetVendorId(m_vendor);
140 bInitHandler = true;
141 }
142 }
143 }
144
145 if (bInitHandler)
146 {
147 CCECBusDevice *primary = GetProcessor()->GetPrimaryDevice();
148 if (primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
149 {
150 m_handler->InitHandler();
151
152 if (bActivateSource && IsHandledByLibCEC() && IsActiveSource())
153 m_handler->ActivateSource();
154 }
155 }
156
157 MarkReady();
158
159 return true;
160 }
161
162 CCECCommandHandler *CCECBusDevice::GetHandler(void)
163 {
164 ReplaceHandler(false);
165 MarkBusy();
166 return m_handler;
167 }
168
169 bool CCECBusDevice::HandleCommand(const cec_command &command)
170 {
171 bool bHandled(false);
172
173 /* update "last active" */
174 {
175 CLockObject lock(m_mutex);
176 m_iLastActive = GetTimeMs();
177 MarkBusy();
178 }
179
180 /* handle the command */
181 bHandled = m_handler->HandleCommand(command);
182
183 /* change status to present */
184 if (bHandled && GetLogicalAddress() != CECDEVICE_BROADCAST)
185 {
186 CLockObject lock(m_mutex);
187 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
188 {
189 if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT)
190 LIB_CEC->AddLog(CEC_LOG_DEBUG, "device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode));
191 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
192 }
193 }
194
195 MarkReady();
196 return bHandled;
197 }
198
199 const char* CCECBusDevice::GetLogicalAddressName(void) const
200 {
201 return ToString(m_iLogicalAddress);
202 }
203
204 bool CCECBusDevice::IsPresent(void)
205 {
206 CLockObject lock(m_mutex);
207 return m_deviceStatus == CEC_DEVICE_STATUS_PRESENT;
208 }
209
210 bool CCECBusDevice::IsHandledByLibCEC(void)
211 {
212 CLockObject lock(m_mutex);
213 return m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC;
214 }
215
216 void CCECBusDevice::SetUnsupportedFeature(cec_opcode opcode)
217 {
218 // some commands should never be marked as unsupported
219 if (opcode == CEC_OPCODE_VENDOR_COMMAND ||
220 opcode == CEC_OPCODE_VENDOR_COMMAND_WITH_ID ||
221 opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN ||
222 opcode == CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP ||
223 opcode == CEC_OPCODE_ABORT ||
224 opcode == CEC_OPCODE_FEATURE_ABORT ||
225 opcode == CEC_OPCODE_NONE)
226 return;
227
228 {
229 CLockObject lock(m_mutex);
230 if (m_unsupportedFeatures.find(opcode) == m_unsupportedFeatures.end())
231 {
232 LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking opcode '%s' as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
233 m_unsupportedFeatures.insert(opcode);
234 }
235 }
236
237 // signal threads that are waiting for a reponse
238 MarkBusy();
239 SignalOpcode(cec_command::GetResponseOpcode(opcode));
240 MarkReady();
241 }
242
243 bool CCECBusDevice::IsUnsupportedFeature(cec_opcode opcode)
244 {
245 CLockObject lock(m_mutex);
246 bool bUnsupported = (m_unsupportedFeatures.find(opcode) != m_unsupportedFeatures.end());
247 if (bUnsupported)
248 LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' is marked as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
249 return bUnsupported;
250 }
251
252 bool CCECBusDevice::TransmitKeypress(const cec_logical_address initiator, cec_user_control_code key, bool bWait /* = true */)
253 {
254 MarkBusy();
255 bool bReturn = m_handler->TransmitKeypress(initiator, m_iLogicalAddress, key, bWait);
256 MarkReady();
257 return bReturn;
258 }
259
260 bool CCECBusDevice::TransmitKeyRelease(const cec_logical_address initiator, bool bWait /* = true */)
261 {
262 MarkBusy();
263 bool bReturn = m_handler->TransmitKeyRelease(initiator, m_iLogicalAddress, bWait);
264 MarkReady();
265 return bReturn;
266 }
267
268 cec_version CCECBusDevice::GetCecVersion(const cec_logical_address initiator, bool bUpdate /* = false */)
269 {
270 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
271 bool bRequestUpdate(false);
272 {
273 CLockObject lock(m_mutex);
274 bRequestUpdate = bIsPresent &&
275 (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN);
276 }
277
278 if (bRequestUpdate)
279 {
280 CheckVendorIdRequested(initiator);
281 RequestCecVersion(initiator);
282 }
283
284 CLockObject lock(m_mutex);
285 return m_cecVersion;
286 }
287
288 void CCECBusDevice::SetCecVersion(const cec_version newVersion)
289 {
290 CLockObject lock(m_mutex);
291 if (m_cecVersion != newVersion)
292 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): CEC version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(newVersion));
293 m_cecVersion = newVersion;
294 }
295
296 bool CCECBusDevice::RequestCecVersion(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
297 {
298 bool bReturn(false);
299
300 if (!IsHandledByLibCEC() &&
301 !IsUnsupportedFeature(CEC_OPCODE_GET_CEC_VERSION))
302 {
303 MarkBusy();
304 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
305 bReturn = m_handler->TransmitRequestCecVersion(initiator, m_iLogicalAddress, bWaitForResponse);
306 MarkReady();
307 }
308 return bReturn;
309 }
310
311 bool CCECBusDevice::TransmitCECVersion(const cec_logical_address destination, bool bIsReply)
312 {
313 cec_version version;
314 {
315 CLockObject lock(m_mutex);
316 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_cecVersion));
317 version = m_cecVersion;
318 }
319
320 MarkBusy();
321 bool bReturn = m_handler->TransmitCECVersion(m_iLogicalAddress, destination, version, bIsReply);
322 MarkReady();
323 return bReturn;
324 }
325
326 cec_menu_language &CCECBusDevice::GetMenuLanguage(const cec_logical_address initiator, 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 || !strcmp(m_menuLanguage.language, "???")));
334 }
335
336 if (bRequestUpdate)
337 {
338 CheckVendorIdRequested(initiator);
339 RequestMenuLanguage(initiator);
340 }
341
342 CLockObject lock(m_mutex);
343 return m_menuLanguage;
344 }
345
346 void CCECBusDevice::SetMenuLanguage(const char *strLanguage)
347 {
348 if (!strLanguage)
349 return;
350
351 CLockObject lock(m_mutex);
352 if (strcmp(strLanguage, m_menuLanguage.language))
353 {
354 memcpy(m_menuLanguage.language, strLanguage, 3);
355 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, m_menuLanguage.language);
356 }
357 }
358
359 void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
360 {
361 if (language.device == m_iLogicalAddress)
362 SetMenuLanguage(language.language);
363 }
364
365 bool CCECBusDevice::RequestMenuLanguage(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
366 {
367 bool bReturn(false);
368
369 if (!IsHandledByLibCEC() &&
370 !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE))
371 {
372 MarkBusy();
373 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
374 bReturn = m_handler->TransmitRequestMenuLanguage(initiator, m_iLogicalAddress, bWaitForResponse);
375 MarkReady();
376 }
377 return bReturn;
378 }
379
380 bool CCECBusDevice::TransmitSetMenuLanguage(const cec_logical_address destination, bool bIsReply)
381 {
382 bool bReturn(false);
383 cec_menu_language language;
384 {
385 CLockObject lock(m_mutex);
386 language = m_menuLanguage;
387 }
388
389 char lang[3];
390 {
391 CLockObject lock(m_mutex);
392 lang[0] = language.language[0];
393 lang[1] = language.language[1];
394 lang[2] = language.language[2];
395 }
396
397 MarkBusy();
398 if (lang[0] == '?' && lang[1] == '?' && lang[2] == '?')
399 {
400 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu language feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
401 m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
402 bReturn = true;
403 }
404 else
405 {
406 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): menu language '%s'", GetLogicalAddressName(), m_iLogicalAddress, lang);
407 bReturn = m_handler->TransmitSetMenuLanguage(m_iLogicalAddress, lang, bIsReply);
408 }
409 MarkReady();
410 return bReturn;
411 }
412
413 bool CCECBusDevice::TransmitOSDString(const cec_logical_address destination, cec_display_control duration, const char *strMessage, bool bIsReply)
414 {
415 bool bReturn(false);
416 if (!m_processor->GetDevice(destination)->IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING))
417 {
418 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, strMessage);
419 MarkBusy();
420 bReturn = m_handler->TransmitOSDString(m_iLogicalAddress, destination, duration, strMessage, bIsReply);
421 MarkReady();
422 }
423 return bReturn;
424 }
425
426 CStdString CCECBusDevice::GetCurrentOSDName(void)
427 {
428 CLockObject lock(m_mutex);
429 return m_strDeviceName;
430 }
431
432 CStdString CCECBusDevice::GetOSDName(const cec_logical_address initiator, bool bUpdate /* = false */)
433 {
434 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
435 bool bRequestUpdate(false);
436 {
437 CLockObject lock(m_mutex);
438 bRequestUpdate = bIsPresent &&
439 (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) &&
440 m_type != CEC_DEVICE_TYPE_TV;
441 }
442
443 if (bRequestUpdate)
444 {
445 CheckVendorIdRequested(initiator);
446 RequestOSDName(initiator);
447 }
448
449 CLockObject lock(m_mutex);
450 return m_strDeviceName;
451 }
452
453 void CCECBusDevice::SetOSDName(CStdString strName)
454 {
455 CLockObject lock(m_mutex);
456 if (m_strDeviceName != strName)
457 {
458 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName.c_str());
459 m_strDeviceName = strName;
460 }
461 }
462
463 bool CCECBusDevice::RequestOSDName(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
464 {
465 bool bReturn(false);
466
467 if (!IsHandledByLibCEC() &&
468 !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME))
469 {
470 MarkBusy();
471 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
472 bReturn = m_handler->TransmitRequestOSDName(initiator, m_iLogicalAddress, bWaitForResponse);
473 MarkReady();
474 }
475 return bReturn;
476 }
477
478 bool CCECBusDevice::TransmitOSDName(const cec_logical_address destination, bool bIsReply)
479 {
480 CStdString strDeviceName;
481 {
482 CLockObject lock(m_mutex);
483 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, m_strDeviceName.c_str());
484 strDeviceName = m_strDeviceName;
485 }
486
487 MarkBusy();
488 bool bReturn = m_handler->TransmitOSDName(m_iLogicalAddress, destination, strDeviceName, bIsReply);
489 MarkReady();
490 return bReturn;
491 }
492
493 bool CCECBusDevice::HasValidPhysicalAddress(void)
494 {
495 CLockObject lock(m_mutex);
496 return CLibCEC::IsValidPhysicalAddress(m_iPhysicalAddress);
497 }
498
499 uint16_t CCECBusDevice::GetCurrentPhysicalAddress(void)
500 {
501 CLockObject lock(m_mutex);
502 return m_iPhysicalAddress;
503 }
504
505 uint16_t CCECBusDevice::GetPhysicalAddress(const cec_logical_address initiator, bool bSuppressUpdate /* = false */)
506 {
507 if (!bSuppressUpdate)
508 {
509 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
510 bool bRequestUpdate(false);
511 {
512 CLockObject lock(m_mutex);
513 bRequestUpdate = bIsPresent && m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS;
514 }
515
516 if (bRequestUpdate)
517 {
518 CheckVendorIdRequested(initiator);
519 if (!RequestPhysicalAddress(initiator))
520 LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to request the physical address");
521 }
522 }
523
524 CLockObject lock(m_mutex);
525 return m_iPhysicalAddress;
526 }
527
528 bool CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
529 {
530 CLockObject lock(m_mutex);
531 if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress)
532 {
533 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
534 m_iPhysicalAddress = iNewAddress;
535 }
536 return true;
537 }
538
539 bool CCECBusDevice::RequestPhysicalAddress(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
540 {
541 bool bReturn(false);
542
543 if (!IsHandledByLibCEC())
544 {
545 MarkBusy();
546 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
547 bReturn = m_handler->TransmitRequestPhysicalAddress(initiator, m_iLogicalAddress, bWaitForResponse);
548 MarkReady();
549 }
550 return bReturn;
551 }
552
553 bool CCECBusDevice::TransmitPhysicalAddress(bool bIsReply)
554 {
555 uint16_t iPhysicalAddress;
556 cec_device_type type;
557 {
558 CLockObject lock(m_mutex);
559 if (m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS)
560 return false;
561
562 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
563 iPhysicalAddress = m_iPhysicalAddress;
564 type = m_type;
565 }
566
567 MarkBusy();
568 bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type, bIsReply);
569 MarkReady();
570 return bReturn;
571 }
572
573 cec_power_status CCECBusDevice::GetCurrentPowerStatus(void)
574 {
575 CLockObject lock(m_mutex);
576 return m_powerStatus;
577 }
578
579 cec_power_status CCECBusDevice::GetPowerStatus(const cec_logical_address initiator, bool bUpdate /* = false */)
580 {
581 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
582 bool bRequestUpdate(false);
583 {
584 CLockObject lock(m_mutex);
585 bRequestUpdate = (bIsPresent &&
586 (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
587 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON ||
588 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY ||
589 GetTimeMs() - m_iLastPowerStateUpdate >= CEC_POWER_STATE_REFRESH_TIME));
590 }
591
592 if (bRequestUpdate)
593 {
594 CheckVendorIdRequested(initiator);
595 RequestPowerStatus(initiator);
596 }
597
598 CLockObject lock(m_mutex);
599 return m_powerStatus;
600 }
601
602 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
603 {
604 CLockObject lock(m_mutex);
605 if (m_powerStatus != powerStatus)
606 {
607 m_iLastPowerStateUpdate = GetTimeMs();
608 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
609 m_powerStatus = powerStatus;
610 }
611 }
612
613 bool CCECBusDevice::RequestPowerStatus(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
614 {
615 bool bReturn(false);
616
617 if (!IsHandledByLibCEC() &&
618 !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
619 {
620 MarkBusy();
621 bReturn = m_handler->TransmitRequestPowerStatus(initiator, m_iLogicalAddress, bWaitForResponse);
622 MarkReady();
623 }
624 return bReturn;
625 }
626
627 bool CCECBusDevice::TransmitPowerState(const cec_logical_address destination, bool bIsReply)
628 {
629 cec_power_status state;
630 {
631 CLockObject lock(m_mutex);
632 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_powerStatus));
633 state = m_powerStatus;
634 }
635
636 MarkBusy();
637 bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, destination, state, bIsReply);
638 MarkReady();
639 return bReturn;
640 }
641
642 cec_vendor_id CCECBusDevice::GetCurrentVendorId(void)
643 {
644 CLockObject lock(m_mutex);
645 return m_vendor;
646 }
647
648 cec_vendor_id CCECBusDevice::GetVendorId(const cec_logical_address initiator, bool bUpdate /* = false */)
649 {
650 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
651 bool bRequestUpdate(false);
652 {
653 CLockObject lock(m_mutex);
654 bRequestUpdate = (bIsPresent &&
655 (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN));
656 }
657
658 if (bRequestUpdate)
659 RequestVendorId(initiator);
660
661 CLockObject lock(m_mutex);
662 return m_vendor;
663 }
664
665 const char *CCECBusDevice::GetVendorName(const cec_logical_address initiator, bool bUpdate /* = false */)
666 {
667 return ToString(GetVendorId(initiator, bUpdate));
668 }
669
670 bool CCECBusDevice::SetVendorId(uint64_t iVendorId)
671 {
672 bool bVendorChanged(false);
673
674 {
675 CLockObject lock(m_mutex);
676 bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId);
677 m_vendor = (cec_vendor_id)iVendorId;
678 }
679
680 if (bVendorChanged)
681 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor);
682
683 return bVendorChanged;
684 }
685
686 bool CCECBusDevice::RequestVendorId(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
687 {
688 bool bReturn(false);
689
690 if (!IsHandledByLibCEC() && initiator != CECDEVICE_UNKNOWN)
691 {
692 MarkBusy();
693 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
694 bReturn = m_handler->TransmitRequestVendorId(initiator, m_iLogicalAddress, bWaitForResponse);
695 MarkReady();
696
697 if (bWaitForResponse)
698 ReplaceHandler(true);
699 }
700 return bReturn;
701 }
702
703 bool CCECBusDevice::TransmitVendorID(const cec_logical_address destination, bool bSendAbort, bool bIsReply)
704 {
705 bool bReturn(false);
706 uint64_t iVendorId;
707 {
708 CLockObject lock(m_mutex);
709 iVendorId = (uint64_t)m_vendor;
710 }
711
712 MarkBusy();
713 if (iVendorId == CEC_VENDOR_UNKNOWN)
714 {
715 if (bSendAbort)
716 {
717 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
718 m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
719 bReturn = true;
720 }
721 }
722 else
723 {
724 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id %s (%x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString((cec_vendor_id)iVendorId), iVendorId);
725 bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId, bIsReply);
726 }
727 MarkReady();
728 return bReturn;
729 }
730
731 cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */, bool bSuppressPoll /* = false */)
732 {
733 if (m_iLogicalAddress == CECDEVICE_BROADCAST)
734 return CEC_DEVICE_STATUS_NOT_PRESENT;
735
736 cec_bus_device_status status(CEC_DEVICE_STATUS_UNKNOWN);
737 bool bNeedsPoll(false);
738
739 {
740 CLockObject lock(m_mutex);
741 status = m_deviceStatus;
742 bNeedsPoll = !bSuppressPoll &&
743 m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC &&
744 // poll forced
745 (bForcePoll ||
746 // don't know the status
747 m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN ||
748 // always poll the TV if it's marked as not present
749 (m_deviceStatus == CEC_DEVICE_STATUS_NOT_PRESENT && m_iLogicalAddress == CECDEVICE_TV));
750 }
751
752 if (bNeedsPoll)
753 {
754 bool bPollAcked(false);
755 if (bNeedsPoll && NeedsPoll())
756 bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
757
758 status = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
759 SetDeviceStatus(status);
760 }
761
762 return status;
763 }
764
765 void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
766 {
767 if (m_iLogicalAddress == CECDEVICE_UNREGISTERED)
768 return;
769
770 {
771 CLockObject lock(m_mutex);
772 switch (newStatus)
773 {
774 case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
775 if (m_deviceStatus != newStatus)
776 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'handled by libCEC'", GetLogicalAddressName(), m_iLogicalAddress);
777 SetPowerStatus (CEC_POWER_STATUS_ON);
778 SetVendorId (CEC_VENDOR_UNKNOWN);
779 SetMenuState (CEC_MENU_STATE_ACTIVATED);
780 SetCecVersion (libCECSpecVersion);
781 SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS);
782 MarkAsInactiveSource();
783 m_iLastActive = 0;
784 m_deviceStatus = newStatus;
785 break;
786 case CEC_DEVICE_STATUS_PRESENT:
787 if (m_deviceStatus != newStatus)
788 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'present'", GetLogicalAddressName(), m_iLogicalAddress);
789 m_deviceStatus = newStatus;
790 m_iLastActive = GetTimeMs();
791 break;
792 case CEC_DEVICE_STATUS_NOT_PRESENT:
793 if (m_deviceStatus != newStatus)
794 {
795 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'not present'", GetLogicalAddressName(), m_iLogicalAddress);
796 ResetDeviceStatus(true);
797 m_deviceStatus = newStatus;
798 }
799 break;
800 default:
801 ResetDeviceStatus();
802 break;
803 }
804 }
805 }
806
807 void CCECBusDevice::ResetDeviceStatus(bool bClientUnregistered /* = false */)
808 {
809 CLockObject lock(m_mutex);
810 SetPowerStatus (CEC_POWER_STATUS_UNKNOWN);
811 SetVendorId (CEC_VENDOR_UNKNOWN);
812 SetMenuState (CEC_MENU_STATE_ACTIVATED);
813 SetCecVersion (CEC_VERSION_UNKNOWN);
814 SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS);
815 SetOSDName (ToString(m_iLogicalAddress));
816 MarkAsInactiveSource(bClientUnregistered);
817
818 m_iLastActive = 0;
819 m_bVendorIdRequested = false;
820 m_unsupportedFeatures.clear();
821 m_waitForResponse->Clear();
822
823 if (m_deviceStatus != CEC_DEVICE_STATUS_UNKNOWN)
824 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'unknown'", GetLogicalAddressName(), m_iLogicalAddress);
825 m_deviceStatus = CEC_DEVICE_STATUS_UNKNOWN;
826 }
827
828 bool CCECBusDevice::TransmitPoll(const cec_logical_address dest, bool bUpdateDeviceStatus)
829 {
830 bool bReturn(false);
831 cec_logical_address destination(dest);
832 if (destination == CECDEVICE_UNKNOWN)
833 destination = m_iLogicalAddress;
834
835 CCECBusDevice *destDevice = m_processor->GetDevice(destination);
836 if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
837 return bReturn;
838
839 MarkBusy();
840 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
841 bReturn = m_handler->TransmitPoll(m_iLogicalAddress, destination, false);
842 LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
843
844 if (bUpdateDeviceStatus)
845 destDevice->SetDeviceStatus(bReturn ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT);
846
847 MarkReady();
848 return bReturn;
849 }
850
851 void CCECBusDevice::HandlePoll(const cec_logical_address destination)
852 {
853 if (destination >= 0 && destination < CECDEVICE_BROADCAST)
854 {
855 CCECBusDevice *device = m_processor->GetDevice(destination);
856 if (device)
857 device->HandlePollFrom(m_iLogicalAddress);
858 }
859 }
860
861 void CCECBusDevice::HandlePollFrom(const cec_logical_address initiator)
862 {
863 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(initiator), initiator, ToString(m_iLogicalAddress), m_iLogicalAddress);
864 m_bAwaitingReceiveFailed = true;
865 }
866
867 bool CCECBusDevice::HandleReceiveFailed(void)
868 {
869 bool bReturn = m_bAwaitingReceiveFailed;
870 m_bAwaitingReceiveFailed = false;
871 return bReturn;
872 }
873
874 cec_menu_state CCECBusDevice::GetMenuState(const cec_logical_address UNUSED(initiator))
875 {
876 CLockObject lock(m_mutex);
877 return m_menuState;
878 }
879
880 void CCECBusDevice::SetMenuState(const cec_menu_state state)
881 {
882 CLockObject lock(m_mutex);
883 if (m_menuState != state)
884 {
885 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
886 m_menuState = state;
887 }
888 }
889
890 bool CCECBusDevice::TransmitMenuState(const cec_logical_address dest, bool bIsReply)
891 {
892 cec_menu_state menuState;
893 {
894 CLockObject lock(m_mutex);
895 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
896 menuState = m_menuState;
897 }
898
899 MarkBusy();
900 bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState, bIsReply);
901 MarkReady();
902 return bReturn;
903 }
904
905 bool CCECBusDevice::ActivateSource(uint64_t iDelay /* = 0 */)
906 {
907 MarkAsActiveSource();
908 MarkBusy();
909 bool bReturn(true);
910 if (iDelay == 0)
911 {
912 LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending active source message for '%s'", ToString(m_iLogicalAddress));
913 bReturn = m_handler->ActivateSource();
914 }
915 else
916 {
917 LIB_CEC->AddLog(CEC_LOG_DEBUG, "scheduling active source message for '%s'", ToString(m_iLogicalAddress));
918 m_handler->ScheduleActivateSource(iDelay);
919 }
920 MarkReady();
921 return bReturn;
922 }
923
924 bool CCECBusDevice::RequestActiveSource(bool bWaitForResponse /* = true */)
925 {
926 bool bReturn(false);
927
928 if (IsHandledByLibCEC())
929 {
930 MarkBusy();
931 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting active source");
932
933 bReturn = m_handler->TransmitRequestActiveSource(m_iLogicalAddress, bWaitForResponse);
934 MarkReady();
935 }
936 return bReturn;
937 }
938
939 void CCECBusDevice::MarkAsActiveSource(void)
940 {
941 bool bWasActivated(false);
942
943 // set the power status to powered on
944 SetPowerStatus(CEC_POWER_STATUS_ON);
945
946 // mark this device as active source
947 {
948 CLockObject lock(m_mutex);
949 if (!m_bActiveSource)
950 {
951 LIB_CEC->AddLog(CEC_LOG_DEBUG, "making %s (%x) the active source", GetLogicalAddressName(), m_iLogicalAddress);
952 bWasActivated = true;
953 }
954 else
955 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%x) was already marked as active source", GetLogicalAddressName(), m_iLogicalAddress);
956
957 m_bActiveSource = true;
958 }
959
960 // mark other devices as inactive sources
961 CECDEVICEVEC devices;
962 m_processor->GetDevices()->Get(devices);
963 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
964 if ((*it)->GetLogicalAddress() != m_iLogicalAddress)
965 (*it)->MarkAsInactiveSource();
966
967 if (bWasActivated)
968 {
969 m_processor->SetActiveSource(true, false);
970 CCECClient *client = GetClient();
971 if (client)
972 client->SourceActivated(m_iLogicalAddress);
973 }
974 }
975
976 void CCECBusDevice::MarkAsInactiveSource(bool bClientUnregistered /* = false */)
977 {
978 bool bWasDeactivated(false);
979 {
980 CLockObject lock(m_mutex);
981 if (m_bActiveSource)
982 {
983 LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking %s (%X) as inactive source", GetLogicalAddressName(), m_iLogicalAddress);
984 bWasDeactivated = true;
985 }
986 m_bActiveSource = false;
987 }
988
989 if (bWasDeactivated)
990 {
991 m_processor->SetActiveSource(false, bClientUnregistered);
992 CCECClient *client = GetClient();
993 if (client)
994 client->SourceDeactivated(m_iLogicalAddress);
995 }
996 }
997
998 bool CCECBusDevice::TransmitActiveSource(bool bIsReply)
999 {
1000 bool bSendActiveSource(false);
1001 uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
1002
1003 {
1004 CLockObject lock(m_mutex);
1005 if (!HasValidPhysicalAddress())
1006 {
1007 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X) has an invalid physical address (%04x), not sending active source commands", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1008 return false;
1009 }
1010
1011 iPhysicalAddress = m_iPhysicalAddress;
1012
1013 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1014 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1015 else if (m_bActiveSource)
1016 {
1017 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1018 bSendActiveSource = true;
1019 }
1020 else
1021 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
1022 }
1023
1024 bool bActiveSourceSent(false);
1025 if (bSendActiveSource)
1026 {
1027 MarkBusy();
1028 bActiveSourceSent = m_handler->TransmitActiveSource(m_iLogicalAddress, iPhysicalAddress, bIsReply);
1029 MarkReady();
1030 }
1031
1032 return bActiveSourceSent;
1033 }
1034
1035 bool CCECBusDevice::TransmitImageViewOn(void)
1036 {
1037 {
1038 CLockObject lock(m_mutex);
1039 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1040 {
1041 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1042 return false;
1043 }
1044 }
1045
1046 bool bImageViewOnSent(false);
1047 MarkBusy();
1048 bImageViewOnSent = m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
1049 MarkReady();
1050 return bImageViewOnSent;
1051 }
1052
1053 bool CCECBusDevice::TransmitInactiveSource(void)
1054 {
1055 uint16_t iPhysicalAddress;
1056 {
1057 CLockObject lock(m_mutex);
1058 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
1059 iPhysicalAddress = m_iPhysicalAddress;
1060 }
1061
1062 MarkBusy();
1063 bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
1064 MarkReady();
1065 return bReturn;
1066 }
1067
1068 bool CCECBusDevice::TransmitPendingActiveSourceCommands(void)
1069 {
1070 MarkBusy();
1071 bool bReturn = m_handler->ActivateSource(true);
1072 MarkReady();
1073 return bReturn;
1074 }
1075
1076 void CCECBusDevice::SetActiveRoute(uint16_t iRoute)
1077 {
1078 CCECDeviceMap* map = m_processor->GetDevices();
1079 if (!map)
1080 return;
1081
1082 CCECBusDevice* previouslyActive = map->GetActiveSource();
1083 if (!previouslyActive)
1084 return;
1085
1086 CECDEVICEVEC devices;
1087 m_processor->GetDevices()->GetChildrenOf(devices, this);
1088
1089 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1090 {
1091 if (!CCECTypeUtils::PhysicalAddressIsIncluded(iRoute, (*it)->GetCurrentPhysicalAddress()))
1092 (*it)->MarkAsInactiveSource();
1093 }
1094 }
1095
1096 void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */)
1097 {
1098 CLockObject lock(m_mutex);
1099 if (iNewAddress != m_iStreamPath)
1100 {
1101 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress);
1102 m_iStreamPath = iNewAddress;
1103 }
1104
1105 if (!LIB_CEC->IsValidPhysicalAddress(iNewAddress))
1106 return;
1107
1108 CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iNewAddress);
1109 if (device)
1110 {
1111 // if a device is found with the new physical address, mark it as active, which will automatically mark all other devices as inactive
1112 device->MarkAsActiveSource();
1113
1114 // respond with an active source message if this device is handled by libCEC
1115 if (device->IsHandledByLibCEC())
1116 device->TransmitActiveSource(true);
1117 }
1118 else
1119 {
1120 // try to find the device with the old address, and mark it as inactive when found
1121 device = m_processor->GetDeviceByPhysicalAddress(iOldAddress);
1122 if (device)
1123 device->MarkAsInactiveSource();
1124 }
1125 }
1126
1127 bool CCECBusDevice::PowerOn(const cec_logical_address initiator)
1128 {
1129 bool bReturn(false);
1130 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1131
1132 MarkBusy();
1133 cec_power_status currentStatus;
1134 if (m_iLogicalAddress == CECDEVICE_TV ||
1135 ((currentStatus = GetPowerStatus(initiator, false)) != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON &&
1136 currentStatus != CEC_POWER_STATUS_ON))
1137 {
1138 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
1139 bReturn = m_handler->PowerOn(initiator, m_iLogicalAddress);
1140 }
1141 else
1142 {
1143 LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus));
1144 }
1145
1146 MarkReady();
1147 return bReturn;
1148 }
1149
1150 bool CCECBusDevice::Standby(const cec_logical_address initiator)
1151 {
1152 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1153
1154 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
1155 MarkBusy();
1156 bool bReturn = m_handler->TransmitStandby(initiator, m_iLogicalAddress);
1157 MarkReady();
1158 return bReturn;
1159 }
1160
1161 bool CCECBusDevice::NeedsPoll(void)
1162 {
1163 bool bSendPoll(false);
1164 cec_logical_address pollAddress(CECDEVICE_UNKNOWN);
1165 switch (m_iLogicalAddress)
1166 {
1167 case CECDEVICE_PLAYBACKDEVICE3:
1168 pollAddress = CECDEVICE_PLAYBACKDEVICE2;
1169 break;
1170 case CECDEVICE_PLAYBACKDEVICE2:
1171 pollAddress = CECDEVICE_PLAYBACKDEVICE1;
1172 break;
1173 case CECDEVICE_RECORDINGDEVICE3:
1174 pollAddress = CECDEVICE_RECORDINGDEVICE2;
1175 break;
1176 case CECDEVICE_RECORDINGDEVICE2:
1177 pollAddress = CECDEVICE_RECORDINGDEVICE1;
1178 break;
1179 case CECDEVICE_TUNER4:
1180 pollAddress = CECDEVICE_TUNER3;
1181 break;
1182 case CECDEVICE_TUNER3:
1183 pollAddress = CECDEVICE_TUNER2;
1184 break;
1185 case CECDEVICE_TUNER2:
1186 pollAddress = CECDEVICE_TUNER1;
1187 break;
1188 case CECDEVICE_AUDIOSYSTEM:
1189 case CECDEVICE_PLAYBACKDEVICE1:
1190 case CECDEVICE_RECORDINGDEVICE1:
1191 case CECDEVICE_TUNER1:
1192 case CECDEVICE_TV:
1193 bSendPoll = true;
1194 break;
1195 default:
1196 break;
1197 }
1198
1199 if (!bSendPoll && pollAddress != CECDEVICE_UNKNOWN)
1200 {
1201 CCECBusDevice *device = m_processor->GetDevice(pollAddress);
1202 if (device)
1203 {
1204 cec_bus_device_status status = device->GetStatus();
1205 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
1206 }
1207 else
1208 {
1209 bSendPoll = true;
1210 }
1211 }
1212
1213 return bSendPoll;
1214 }
1215
1216 void CCECBusDevice::CheckVendorIdRequested(const cec_logical_address initiator)
1217 {
1218 bool bRequestVendorId(false);
1219 {
1220 CLockObject lock(m_mutex);
1221 bRequestVendorId = !m_bVendorIdRequested;
1222 m_bVendorIdRequested = true;
1223 }
1224
1225 if (bRequestVendorId)
1226 {
1227 ReplaceHandler(false);
1228 GetVendorId(initiator);
1229 }
1230 }
1231 //@}
1232
1233 CCECAudioSystem *CCECBusDevice::AsAudioSystem(void)
1234 {
1235 return AsAudioSystem(this);
1236 }
1237
1238 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(void)
1239 {
1240 return AsPlaybackDevice(this);
1241 }
1242
1243 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(void)
1244 {
1245 return AsRecordingDevice(this);
1246 }
1247
1248 CCECTuner *CCECBusDevice::AsTuner(void)
1249 {
1250 return AsTuner(this);
1251 }
1252
1253 CCECTV *CCECBusDevice::AsTV(void)
1254 {
1255 return AsTV(this);
1256 }
1257
1258 CCECAudioSystem *CCECBusDevice::AsAudioSystem(CCECBusDevice *device)
1259 {
1260 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
1261 return static_cast<CCECAudioSystem *>(device);
1262 return NULL;
1263 }
1264
1265 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(CCECBusDevice *device)
1266 {
1267 if (device &&
1268 (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
1269 device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
1270 return static_cast<CCECPlaybackDevice *>(device);
1271 return NULL;
1272 }
1273
1274 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(CCECBusDevice *device)
1275 {
1276 if (device && device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
1277 return static_cast<CCECRecordingDevice *>(device);
1278 return NULL;
1279 }
1280
1281 CCECTuner *CCECBusDevice::AsTuner(CCECBusDevice *device)
1282 {
1283 if (device && device->GetType() == CEC_DEVICE_TYPE_TUNER)
1284 return static_cast<CCECTuner *>(device);
1285 return NULL;
1286 }
1287
1288 CCECTV *CCECBusDevice::AsTV(CCECBusDevice *device)
1289 {
1290 if (device && device->GetType() == CEC_DEVICE_TYPE_TV)
1291 return static_cast<CCECTV *>(device);
1292 return NULL;
1293 }
1294
1295 void CCECBusDevice::MarkBusy(void)
1296 {
1297 CLockObject handlerLock(m_handlerMutex);
1298 ++m_iHandlerUseCount;
1299 }
1300
1301 void CCECBusDevice::MarkReady(void)
1302 {
1303 CLockObject handlerLock(m_handlerMutex);
1304 if (m_iHandlerUseCount > 0)
1305 --m_iHandlerUseCount;
1306 }
1307
1308 bool CCECBusDevice::TryLogicalAddress(cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
1309 {
1310 LIB_CEC->AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName());
1311
1312 if (!TransmitPoll(m_iLogicalAddress, false))
1313 {
1314 LIB_CEC->AddLog(CEC_LOG_DEBUG, "using logical address '%s'", GetLogicalAddressName());
1315 SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC, libCECSpecVersion);
1316
1317 return true;
1318 }
1319
1320 LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName());
1321 SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
1322 return false;
1323 }
1324
1325 CCECClient *CCECBusDevice::GetClient(void)
1326 {
1327 return m_processor->GetClient(m_iLogicalAddress);
1328 }
1329
1330 void CCECBusDevice::SignalOpcode(cec_opcode opcode)
1331 {
1332 m_waitForResponse->Received(opcode);
1333 }
1334
1335 bool CCECBusDevice::WaitForOpcode(cec_opcode opcode)
1336 {
1337 return m_waitForResponse->Wait(opcode);
1338 }