signal all waiting threads when receiving an active source message, cache the current...
[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 if (m_processor->GetDevices()->GetActiveSourceAddress() == iNewAddress)
537 MarkAsActiveSource();
538 }
539 return true;
540 }
541
542 bool CCECBusDevice::RequestPhysicalAddress(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
543 {
544 bool bReturn(false);
545
546 if (!IsHandledByLibCEC())
547 {
548 MarkBusy();
549 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
550 bReturn = m_handler->TransmitRequestPhysicalAddress(initiator, m_iLogicalAddress, bWaitForResponse);
551 MarkReady();
552 }
553 return bReturn;
554 }
555
556 bool CCECBusDevice::TransmitPhysicalAddress(bool bIsReply)
557 {
558 uint16_t iPhysicalAddress;
559 cec_device_type type;
560 {
561 CLockObject lock(m_mutex);
562 if (m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS)
563 return false;
564
565 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
566 iPhysicalAddress = m_iPhysicalAddress;
567 type = m_type;
568 }
569
570 MarkBusy();
571 bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type, bIsReply);
572 MarkReady();
573 return bReturn;
574 }
575
576 cec_power_status CCECBusDevice::GetCurrentPowerStatus(void)
577 {
578 CLockObject lock(m_mutex);
579 return m_powerStatus;
580 }
581
582 cec_power_status CCECBusDevice::GetPowerStatus(const cec_logical_address initiator, bool bUpdate /* = false */)
583 {
584 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
585 bool bRequestUpdate(false);
586 {
587 CLockObject lock(m_mutex);
588 bRequestUpdate = (bIsPresent &&
589 (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
590 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON ||
591 m_powerStatus == CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY ||
592 GetTimeMs() - m_iLastPowerStateUpdate >= CEC_POWER_STATE_REFRESH_TIME));
593 }
594
595 if (bRequestUpdate)
596 {
597 CheckVendorIdRequested(initiator);
598 RequestPowerStatus(initiator);
599 }
600
601 CLockObject lock(m_mutex);
602 return m_powerStatus;
603 }
604
605 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
606 {
607 CLockObject lock(m_mutex);
608 if (m_powerStatus != powerStatus)
609 {
610 m_iLastPowerStateUpdate = GetTimeMs();
611 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
612 m_powerStatus = powerStatus;
613 }
614 }
615
616 bool CCECBusDevice::RequestPowerStatus(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
617 {
618 bool bReturn(false);
619
620 if (!IsHandledByLibCEC() &&
621 !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
622 {
623 MarkBusy();
624 bReturn = m_handler->TransmitRequestPowerStatus(initiator, m_iLogicalAddress, bWaitForResponse);
625 MarkReady();
626 }
627 return bReturn;
628 }
629
630 bool CCECBusDevice::TransmitPowerState(const cec_logical_address destination, bool bIsReply)
631 {
632 cec_power_status state;
633 {
634 CLockObject lock(m_mutex);
635 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_powerStatus));
636 state = m_powerStatus;
637 }
638
639 MarkBusy();
640 bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, destination, state, bIsReply);
641 MarkReady();
642 return bReturn;
643 }
644
645 cec_vendor_id CCECBusDevice::GetCurrentVendorId(void)
646 {
647 CLockObject lock(m_mutex);
648 return m_vendor;
649 }
650
651 cec_vendor_id CCECBusDevice::GetVendorId(const cec_logical_address initiator, bool bUpdate /* = false */)
652 {
653 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
654 bool bRequestUpdate(false);
655 {
656 CLockObject lock(m_mutex);
657 bRequestUpdate = (bIsPresent &&
658 (bUpdate || m_vendor == CEC_VENDOR_UNKNOWN));
659 }
660
661 if (bRequestUpdate)
662 RequestVendorId(initiator);
663
664 CLockObject lock(m_mutex);
665 return m_vendor;
666 }
667
668 const char *CCECBusDevice::GetVendorName(const cec_logical_address initiator, bool bUpdate /* = false */)
669 {
670 return ToString(GetVendorId(initiator, bUpdate));
671 }
672
673 bool CCECBusDevice::SetVendorId(uint64_t iVendorId)
674 {
675 bool bVendorChanged(false);
676
677 {
678 CLockObject lock(m_mutex);
679 bVendorChanged = (m_vendor != (cec_vendor_id)iVendorId);
680 m_vendor = (cec_vendor_id)iVendorId;
681 }
682
683 if (bVendorChanged)
684 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): vendor = %s (%06x)", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_vendor), m_vendor);
685
686 return bVendorChanged;
687 }
688
689 bool CCECBusDevice::RequestVendorId(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
690 {
691 bool bReturn(false);
692
693 if (!IsHandledByLibCEC() && initiator != CECDEVICE_UNKNOWN)
694 {
695 MarkBusy();
696 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
697 bReturn = m_handler->TransmitRequestVendorId(initiator, m_iLogicalAddress, bWaitForResponse);
698 MarkReady();
699
700 if (bWaitForResponse)
701 ReplaceHandler(true);
702 }
703 return bReturn;
704 }
705
706 bool CCECBusDevice::TransmitVendorID(const cec_logical_address destination, bool bSendAbort, bool bIsReply)
707 {
708 bool bReturn(false);
709 uint64_t iVendorId;
710 {
711 CLockObject lock(m_mutex);
712 iVendorId = (uint64_t)m_vendor;
713 }
714
715 MarkBusy();
716 if (iVendorId == CEC_VENDOR_UNKNOWN)
717 {
718 if (bSendAbort)
719 {
720 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
721 m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
722 bReturn = true;
723 }
724 }
725 else
726 {
727 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);
728 bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId, bIsReply);
729 }
730 MarkReady();
731 return bReturn;
732 }
733
734 cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */, bool bSuppressPoll /* = false */)
735 {
736 if (m_iLogicalAddress == CECDEVICE_BROADCAST)
737 return CEC_DEVICE_STATUS_NOT_PRESENT;
738
739 cec_bus_device_status status(CEC_DEVICE_STATUS_UNKNOWN);
740 bool bNeedsPoll(false);
741
742 {
743 CLockObject lock(m_mutex);
744 status = m_deviceStatus;
745 bNeedsPoll = !bSuppressPoll &&
746 m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC &&
747 // poll forced
748 (bForcePoll ||
749 // don't know the status
750 m_deviceStatus == CEC_DEVICE_STATUS_UNKNOWN ||
751 // always poll the TV if it's marked as not present
752 (m_deviceStatus == CEC_DEVICE_STATUS_NOT_PRESENT && m_iLogicalAddress == CECDEVICE_TV));
753 }
754
755 if (bNeedsPoll)
756 {
757 bool bPollAcked(false);
758 if (bNeedsPoll && NeedsPoll())
759 bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
760
761 status = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
762 SetDeviceStatus(status);
763 }
764
765 return status;
766 }
767
768 void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
769 {
770 if (m_iLogicalAddress == CECDEVICE_UNREGISTERED)
771 return;
772
773 {
774 CLockObject lock(m_mutex);
775 switch (newStatus)
776 {
777 case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
778 if (m_deviceStatus != newStatus)
779 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'handled by libCEC'", GetLogicalAddressName(), m_iLogicalAddress);
780 SetPowerStatus (CEC_POWER_STATUS_ON);
781 SetVendorId (CEC_VENDOR_UNKNOWN);
782 SetMenuState (CEC_MENU_STATE_ACTIVATED);
783 SetCecVersion (libCECSpecVersion);
784 SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS);
785 MarkAsInactiveSource();
786 m_iLastActive = 0;
787 m_deviceStatus = newStatus;
788 break;
789 case CEC_DEVICE_STATUS_PRESENT:
790 if (m_deviceStatus != newStatus)
791 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'present'", GetLogicalAddressName(), m_iLogicalAddress);
792 m_deviceStatus = newStatus;
793 m_iLastActive = GetTimeMs();
794 break;
795 case CEC_DEVICE_STATUS_NOT_PRESENT:
796 if (m_deviceStatus != newStatus)
797 {
798 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'not present'", GetLogicalAddressName(), m_iLogicalAddress);
799 ResetDeviceStatus(true);
800 m_deviceStatus = newStatus;
801 }
802 break;
803 default:
804 ResetDeviceStatus();
805 break;
806 }
807 }
808 }
809
810 void CCECBusDevice::ResetDeviceStatus(bool bClientUnregistered /* = false */)
811 {
812 CLockObject lock(m_mutex);
813 SetPowerStatus (CEC_POWER_STATUS_UNKNOWN);
814 SetVendorId (CEC_VENDOR_UNKNOWN);
815 SetMenuState (CEC_MENU_STATE_ACTIVATED);
816 SetCecVersion (CEC_VERSION_UNKNOWN);
817 SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS);
818 SetOSDName (ToString(m_iLogicalAddress));
819 MarkAsInactiveSource(bClientUnregistered);
820
821 m_iLastActive = 0;
822 m_bVendorIdRequested = false;
823 m_unsupportedFeatures.clear();
824 m_waitForResponse->Clear();
825
826 if (m_deviceStatus != CEC_DEVICE_STATUS_UNKNOWN)
827 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'unknown'", GetLogicalAddressName(), m_iLogicalAddress);
828 m_deviceStatus = CEC_DEVICE_STATUS_UNKNOWN;
829 }
830
831 bool CCECBusDevice::TransmitPoll(const cec_logical_address dest, bool bUpdateDeviceStatus)
832 {
833 bool bReturn(false);
834 cec_logical_address destination(dest);
835 if (destination == CECDEVICE_UNKNOWN)
836 destination = m_iLogicalAddress;
837
838 CCECBusDevice *destDevice = m_processor->GetDevice(destination);
839 if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
840 return bReturn;
841
842 MarkBusy();
843 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
844 bReturn = m_handler->TransmitPoll(m_iLogicalAddress, destination, false);
845 LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
846
847 if (bUpdateDeviceStatus)
848 destDevice->SetDeviceStatus(bReturn ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT);
849
850 MarkReady();
851 return bReturn;
852 }
853
854 void CCECBusDevice::HandlePoll(const cec_logical_address destination)
855 {
856 if (destination >= 0 && destination < CECDEVICE_BROADCAST)
857 {
858 CCECBusDevice *device = m_processor->GetDevice(destination);
859 if (device)
860 device->HandlePollFrom(m_iLogicalAddress);
861 }
862 }
863
864 void CCECBusDevice::HandlePollFrom(const cec_logical_address initiator)
865 {
866 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(initiator), initiator, ToString(m_iLogicalAddress), m_iLogicalAddress);
867 m_bAwaitingReceiveFailed = true;
868 }
869
870 bool CCECBusDevice::HandleReceiveFailed(void)
871 {
872 bool bReturn = m_bAwaitingReceiveFailed;
873 m_bAwaitingReceiveFailed = false;
874 return bReturn;
875 }
876
877 cec_menu_state CCECBusDevice::GetMenuState(const cec_logical_address UNUSED(initiator))
878 {
879 CLockObject lock(m_mutex);
880 return m_menuState;
881 }
882
883 void CCECBusDevice::SetMenuState(const cec_menu_state state)
884 {
885 CLockObject lock(m_mutex);
886 if (m_menuState != state)
887 {
888 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
889 m_menuState = state;
890 }
891 }
892
893 bool CCECBusDevice::TransmitMenuState(const cec_logical_address dest, bool bIsReply)
894 {
895 cec_menu_state menuState;
896 {
897 CLockObject lock(m_mutex);
898 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
899 menuState = m_menuState;
900 }
901
902 MarkBusy();
903 bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState, bIsReply);
904 MarkReady();
905 return bReturn;
906 }
907
908 bool CCECBusDevice::ActivateSource(uint64_t iDelay /* = 0 */)
909 {
910 MarkAsActiveSource();
911 MarkBusy();
912 bool bReturn(true);
913 if (iDelay == 0)
914 {
915 LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending active source message for '%s'", ToString(m_iLogicalAddress));
916 bReturn = m_handler->ActivateSource();
917 }
918 else
919 {
920 LIB_CEC->AddLog(CEC_LOG_DEBUG, "scheduling active source message for '%s'", ToString(m_iLogicalAddress));
921 m_handler->ScheduleActivateSource(iDelay);
922 }
923 MarkReady();
924 return bReturn;
925 }
926
927 bool CCECBusDevice::RequestActiveSource(bool bWaitForResponse /* = true */)
928 {
929 bool bReturn(false);
930
931 if (IsHandledByLibCEC())
932 {
933 MarkBusy();
934 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting active source");
935
936 bReturn = m_handler->TransmitRequestActiveSource(m_iLogicalAddress, bWaitForResponse);
937 MarkReady();
938 }
939 return bReturn;
940 }
941
942 void CCECBusDevice::MarkAsActiveSource(void)
943 {
944 bool bWasActivated(false);
945
946 // set the power status to powered on
947 SetPowerStatus(CEC_POWER_STATUS_ON);
948
949 // mark this device as active source
950 {
951 CLockObject lock(m_mutex);
952 if (!m_bActiveSource)
953 {
954 LIB_CEC->AddLog(CEC_LOG_DEBUG, "making %s (%x) the active source", GetLogicalAddressName(), m_iLogicalAddress);
955 bWasActivated = true;
956 }
957 else
958 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%x) was already marked as active source", GetLogicalAddressName(), m_iLogicalAddress);
959
960 m_bActiveSource = true;
961 }
962
963 // mark other devices as inactive sources
964 CECDEVICEVEC devices;
965 m_processor->GetDevices()->Get(devices);
966 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
967 if ((*it)->GetLogicalAddress() != m_iLogicalAddress)
968 (*it)->MarkAsInactiveSource();
969
970 if (bWasActivated)
971 {
972 if (IsHandledByLibCEC())
973 m_processor->SetActiveSource(true, false);
974 CCECClient *client = GetClient();
975 if (client)
976 client->SourceActivated(m_iLogicalAddress);
977 }
978 }
979
980 void CCECBusDevice::MarkAsInactiveSource(bool bClientUnregistered /* = false */)
981 {
982 bool bWasDeactivated(false);
983 {
984 CLockObject lock(m_mutex);
985 if (m_bActiveSource)
986 {
987 LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking %s (%X) as inactive source", GetLogicalAddressName(), m_iLogicalAddress);
988 bWasDeactivated = true;
989 }
990 m_bActiveSource = false;
991 }
992
993 if (bWasDeactivated)
994 {
995 if (IsHandledByLibCEC())
996 m_processor->SetActiveSource(false, bClientUnregistered);
997 CCECClient *client = GetClient();
998 if (client)
999 client->SourceDeactivated(m_iLogicalAddress);
1000 }
1001 }
1002
1003 bool CCECBusDevice::TransmitActiveSource(bool bIsReply)
1004 {
1005 bool bSendActiveSource(false);
1006 uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
1007
1008 {
1009 CLockObject lock(m_mutex);
1010 if (!HasValidPhysicalAddress())
1011 {
1012 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X) has an invalid physical address (%04x), not sending active source commands", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1013 return false;
1014 }
1015
1016 iPhysicalAddress = m_iPhysicalAddress;
1017
1018 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1019 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1020 else if (m_bActiveSource)
1021 {
1022 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
1023 bSendActiveSource = true;
1024 }
1025 else
1026 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
1027 }
1028
1029 bool bActiveSourceSent(false);
1030 if (bSendActiveSource)
1031 {
1032 MarkBusy();
1033 bActiveSourceSent = m_handler->TransmitActiveSource(m_iLogicalAddress, iPhysicalAddress, bIsReply);
1034 MarkReady();
1035 }
1036
1037 return bActiveSourceSent;
1038 }
1039
1040 bool CCECBusDevice::TransmitImageViewOn(void)
1041 {
1042 {
1043 CLockObject lock(m_mutex);
1044 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1045 {
1046 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
1047 return false;
1048 }
1049 }
1050
1051 bool bImageViewOnSent(false);
1052 MarkBusy();
1053 bImageViewOnSent = m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
1054 MarkReady();
1055 return bImageViewOnSent;
1056 }
1057
1058 bool CCECBusDevice::TransmitInactiveSource(void)
1059 {
1060 uint16_t iPhysicalAddress;
1061 {
1062 CLockObject lock(m_mutex);
1063 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
1064 iPhysicalAddress = m_iPhysicalAddress;
1065 }
1066
1067 MarkBusy();
1068 bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
1069 MarkReady();
1070 return bReturn;
1071 }
1072
1073 bool CCECBusDevice::TransmitPendingActiveSourceCommands(void)
1074 {
1075 MarkBusy();
1076 bool bReturn = m_handler->ActivateSource(true);
1077 MarkReady();
1078 return bReturn;
1079 }
1080
1081 void CCECBusDevice::SetActiveRoute(uint16_t iRoute)
1082 {
1083 CCECDeviceMap* map = m_processor->GetDevices();
1084 if (!map)
1085 return;
1086
1087 CCECBusDevice* previouslyActive = map->GetActiveSource();
1088 if (!previouslyActive)
1089 return;
1090
1091 CECDEVICEVEC devices;
1092 m_processor->GetDevices()->GetChildrenOf(devices, this);
1093
1094 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1095 {
1096 if (!CCECTypeUtils::PhysicalAddressIsIncluded(iRoute, (*it)->GetCurrentPhysicalAddress()))
1097 (*it)->MarkAsInactiveSource();
1098 }
1099 }
1100
1101 void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */)
1102 {
1103 CLockObject lock(m_mutex);
1104 if (iNewAddress != m_iStreamPath)
1105 {
1106 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): stream path changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, iOldAddress == 0 ? m_iStreamPath : iOldAddress, iNewAddress);
1107 m_iStreamPath = iNewAddress;
1108 }
1109
1110 if (!LIB_CEC->IsValidPhysicalAddress(iNewAddress))
1111 return;
1112
1113 CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iNewAddress);
1114 if (device)
1115 {
1116 // if a device is found with the new physical address, mark it as active, which will automatically mark all other devices as inactive
1117 device->MarkAsActiveSource();
1118
1119 // respond with an active source message if this device is handled by libCEC
1120 if (device->IsHandledByLibCEC())
1121 device->TransmitActiveSource(true);
1122 }
1123 else
1124 {
1125 // try to find the device with the old address, and mark it as inactive when found
1126 device = m_processor->GetDeviceByPhysicalAddress(iOldAddress);
1127 if (device)
1128 device->MarkAsInactiveSource();
1129 }
1130 }
1131
1132 bool CCECBusDevice::PowerOn(const cec_logical_address initiator)
1133 {
1134 bool bReturn(false);
1135 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1136
1137 MarkBusy();
1138 cec_power_status currentStatus;
1139 if (m_iLogicalAddress == CECDEVICE_TV ||
1140 ((currentStatus = GetPowerStatus(initiator, false)) != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON &&
1141 currentStatus != CEC_POWER_STATUS_ON))
1142 {
1143 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
1144 bReturn = m_handler->PowerOn(initiator, m_iLogicalAddress);
1145 }
1146 else
1147 {
1148 LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus));
1149 }
1150
1151 MarkReady();
1152 return bReturn;
1153 }
1154
1155 bool CCECBusDevice::Standby(const cec_logical_address initiator)
1156 {
1157 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
1158
1159 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
1160 MarkBusy();
1161 bool bReturn = m_handler->TransmitStandby(initiator, m_iLogicalAddress);
1162 MarkReady();
1163 return bReturn;
1164 }
1165
1166 bool CCECBusDevice::NeedsPoll(void)
1167 {
1168 bool bSendPoll(false);
1169 cec_logical_address pollAddress(CECDEVICE_UNKNOWN);
1170 switch (m_iLogicalAddress)
1171 {
1172 case CECDEVICE_PLAYBACKDEVICE3:
1173 pollAddress = CECDEVICE_PLAYBACKDEVICE2;
1174 break;
1175 case CECDEVICE_PLAYBACKDEVICE2:
1176 pollAddress = CECDEVICE_PLAYBACKDEVICE1;
1177 break;
1178 case CECDEVICE_RECORDINGDEVICE3:
1179 pollAddress = CECDEVICE_RECORDINGDEVICE2;
1180 break;
1181 case CECDEVICE_RECORDINGDEVICE2:
1182 pollAddress = CECDEVICE_RECORDINGDEVICE1;
1183 break;
1184 case CECDEVICE_TUNER4:
1185 pollAddress = CECDEVICE_TUNER3;
1186 break;
1187 case CECDEVICE_TUNER3:
1188 pollAddress = CECDEVICE_TUNER2;
1189 break;
1190 case CECDEVICE_TUNER2:
1191 pollAddress = CECDEVICE_TUNER1;
1192 break;
1193 case CECDEVICE_AUDIOSYSTEM:
1194 case CECDEVICE_PLAYBACKDEVICE1:
1195 case CECDEVICE_RECORDINGDEVICE1:
1196 case CECDEVICE_TUNER1:
1197 case CECDEVICE_TV:
1198 bSendPoll = true;
1199 break;
1200 default:
1201 break;
1202 }
1203
1204 if (!bSendPoll && pollAddress != CECDEVICE_UNKNOWN)
1205 {
1206 CCECBusDevice *device = m_processor->GetDevice(pollAddress);
1207 if (device)
1208 {
1209 cec_bus_device_status status = device->GetStatus();
1210 bSendPoll = (status == CEC_DEVICE_STATUS_PRESENT || status == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
1211 }
1212 else
1213 {
1214 bSendPoll = true;
1215 }
1216 }
1217
1218 return bSendPoll;
1219 }
1220
1221 void CCECBusDevice::CheckVendorIdRequested(const cec_logical_address initiator)
1222 {
1223 bool bRequestVendorId(false);
1224 {
1225 CLockObject lock(m_mutex);
1226 bRequestVendorId = !m_bVendorIdRequested;
1227 m_bVendorIdRequested = true;
1228 }
1229
1230 if (bRequestVendorId)
1231 {
1232 ReplaceHandler(false);
1233 GetVendorId(initiator);
1234 }
1235 }
1236 //@}
1237
1238 CCECAudioSystem *CCECBusDevice::AsAudioSystem(void)
1239 {
1240 return AsAudioSystem(this);
1241 }
1242
1243 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(void)
1244 {
1245 return AsPlaybackDevice(this);
1246 }
1247
1248 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(void)
1249 {
1250 return AsRecordingDevice(this);
1251 }
1252
1253 CCECTuner *CCECBusDevice::AsTuner(void)
1254 {
1255 return AsTuner(this);
1256 }
1257
1258 CCECTV *CCECBusDevice::AsTV(void)
1259 {
1260 return AsTV(this);
1261 }
1262
1263 CCECAudioSystem *CCECBusDevice::AsAudioSystem(CCECBusDevice *device)
1264 {
1265 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
1266 return static_cast<CCECAudioSystem *>(device);
1267 return NULL;
1268 }
1269
1270 CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(CCECBusDevice *device)
1271 {
1272 if (device &&
1273 (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
1274 device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
1275 return static_cast<CCECPlaybackDevice *>(device);
1276 return NULL;
1277 }
1278
1279 CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(CCECBusDevice *device)
1280 {
1281 if (device && device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
1282 return static_cast<CCECRecordingDevice *>(device);
1283 return NULL;
1284 }
1285
1286 CCECTuner *CCECBusDevice::AsTuner(CCECBusDevice *device)
1287 {
1288 if (device && device->GetType() == CEC_DEVICE_TYPE_TUNER)
1289 return static_cast<CCECTuner *>(device);
1290 return NULL;
1291 }
1292
1293 CCECTV *CCECBusDevice::AsTV(CCECBusDevice *device)
1294 {
1295 if (device && device->GetType() == CEC_DEVICE_TYPE_TV)
1296 return static_cast<CCECTV *>(device);
1297 return NULL;
1298 }
1299
1300 void CCECBusDevice::MarkBusy(void)
1301 {
1302 CLockObject handlerLock(m_handlerMutex);
1303 ++m_iHandlerUseCount;
1304 }
1305
1306 void CCECBusDevice::MarkReady(void)
1307 {
1308 CLockObject handlerLock(m_handlerMutex);
1309 if (m_iHandlerUseCount > 0)
1310 --m_iHandlerUseCount;
1311 }
1312
1313 bool CCECBusDevice::TryLogicalAddress(cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
1314 {
1315 LIB_CEC->AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName());
1316
1317 if (!TransmitPoll(m_iLogicalAddress, false))
1318 {
1319 LIB_CEC->AddLog(CEC_LOG_DEBUG, "using logical address '%s'", GetLogicalAddressName());
1320 SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC, libCECSpecVersion);
1321
1322 return true;
1323 }
1324
1325 LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName());
1326 SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
1327 return false;
1328 }
1329
1330 CCECClient *CCECBusDevice::GetClient(void)
1331 {
1332 return m_processor->GetClient(m_iLogicalAddress);
1333 }
1334
1335 void CCECBusDevice::SignalOpcode(cec_opcode opcode)
1336 {
1337 m_waitForResponse->Received(opcode);
1338 }
1339
1340 bool CCECBusDevice::WaitForOpcode(cec_opcode opcode)
1341 {
1342 return m_waitForResponse->Wait(opcode);
1343 }