signal all waiting threads when receiving an active source message, cache the current...
[deb_libcec.git] / src / lib / devices / CECBusDevice.cpp
CommitLineData
e9de9629
LOK
1/*
2 * This file is part of the libCEC(R) library.
3 *
b492c10e 4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
e9de9629
LOK
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
2b44051c 33#include "env.h"
e9de9629 34#include "CECBusDevice.h"
2b44051c
LOK
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"
e9de9629 46
004b8382
LOK
47#include "CECAudioSystem.h"
48#include "CECPlaybackDevice.h"
49#include "CECRecordingDevice.h"
50#include "CECTuner.h"
51#include "CECTV.h"
52
53using namespace std;
e9de9629 54using namespace CEC;
f00ff009 55using namespace PLATFORM;
e9de9629 56
004b8382 57#define LIB_CEC m_processor->GetLib()
0d800fe5 58#define ToString(p) CCECTypeUtils::ToString(p)
c4098482 59
d2d1660c 60CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */) :
ecc676ca
LOK
61 m_type (CEC_DEVICE_TYPE_RESERVED),
62 m_iPhysicalAddress (iPhysicalAddress),
b32ffd87 63 m_iStreamPath (CEC_INVALID_PHYSICAL_ADDRESS),
ecc676ca
LOK
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),
ebb6ddb3 76 m_bAwaitingReceiveFailed(false),
060a7b5e
LOK
77 m_bVendorIdRequested (false),
78 m_waitForResponse (new CWaitForResponse)
e9de9629
LOK
79{
80 m_handler = new CCECCommandHandler(this);
51b2a094 81
a3269a0a
LOK
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;
1fcf5a3f 86
c4098482 87 m_strDeviceName = ToString(m_iLogicalAddress);
e9de9629
LOK
88}
89
90CCECBusDevice::~CCECBusDevice(void)
91{
c9d15485 92 DELETE_AND_NULL(m_handler);
060a7b5e 93 DELETE_AND_NULL(m_waitForResponse);
e9de9629
LOK
94}
95
004b8382
LOK
96bool CCECBusDevice::ReplaceHandler(bool bActivateSource /* = true */)
97{
880f082e
LOK
98 if (m_iLogicalAddress == CECDEVICE_BROADCAST)
99 return false;
100
004b8382
LOK
101 bool bInitHandler(false);
102 {
2b44051c 103 CLockObject lock(m_mutex);
004b8382
LOK
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());
060a7b5e
LOK
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
c9d15485 121 DELETE_AND_NULL(m_handler);
004b8382
LOK
122
123 switch (m_vendor)
124 {
125 case CEC_VENDOR_SAMSUNG:
060a7b5e 126 m_handler = new CANCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
004b8382
LOK
127 break;
128 case CEC_VENDOR_LG:
060a7b5e 129 m_handler = new CSLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
004b8382
LOK
130 break;
131 case CEC_VENDOR_PANASONIC:
060a7b5e 132 m_handler = new CVLCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
004b8382
LOK
133 break;
134 default:
060a7b5e 135 m_handler = new CCECCommandHandler(this, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending);
004b8382
LOK
136 break;
137 }
138
139 m_handler->SetVendorId(m_vendor);
140 bInitHandler = true;
141 }
142 }
143 }
144
145 if (bInitHandler)
146 {
42d28d15
LOK
147 CCECBusDevice *primary = GetProcessor()->GetPrimaryDevice();
148 if (primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
149 {
150 m_handler->InitHandler();
004b8382 151
42d28d15
LOK
152 if (bActivateSource && IsHandledByLibCEC() && IsActiveSource())
153 m_handler->ActivateSource();
154 }
004b8382
LOK
155 }
156
157 MarkReady();
158
159 return true;
160}
161
91ef4e2d
LOK
162CCECCommandHandler *CCECBusDevice::GetHandler(void)
163{
164 ReplaceHandler(false);
165 MarkBusy();
166 return m_handler;
167}
168
93729720 169bool CCECBusDevice::HandleCommand(const cec_command &command)
f8513317 170{
7f919115
LOK
171 bool bHandled(false);
172
173 /* update "last active" */
8fa35473 174 {
f00ff009 175 CLockObject lock(m_mutex);
8fa35473 176 m_iLastActive = GetTimeMs();
1344fd1a 177 MarkBusy();
8fa35473
LOK
178 }
179
7f919115
LOK
180 /* handle the command */
181 bHandled = m_handler->HandleCommand(command);
8fa35473 182
7f919115 183 /* change status to present */
004b8382 184 if (bHandled && GetLogicalAddress() != CECDEVICE_BROADCAST)
8d915412 185 {
f00ff009 186 CLockObject lock(m_mutex);
8fa35473 187 if (m_deviceStatus != CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
8d915412 188 {
8fa35473 189 if (m_deviceStatus != CEC_DEVICE_STATUS_PRESENT)
004b8382 190 LIB_CEC->AddLog(CEC_LOG_DEBUG, "device %s (%x) status changed to present after command %s", GetLogicalAddressName(), (uint8_t)GetLogicalAddress(), ToString(command.opcode));
8fa35473 191 m_deviceStatus = CEC_DEVICE_STATUS_PRESENT;
8d915412 192 }
8d915412 193 }
7f919115 194
1344fd1a 195 MarkReady();
7f919115 196 return bHandled;
93729720
LOK
197}
198
004b8382 199const char* CCECBusDevice::GetLogicalAddressName(void) const
93729720 200{
004b8382
LOK
201 return ToString(m_iLogicalAddress);
202}
203
204bool CCECBusDevice::IsPresent(void)
205{
206 CLockObject lock(m_mutex);
207 return m_deviceStatus == CEC_DEVICE_STATUS_PRESENT;
208}
209
210bool CCECBusDevice::IsHandledByLibCEC(void)
211{
212 CLockObject lock(m_mutex);
213 return m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC;
214}
215
216void 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;
c6d7f0e1 227
5e5637c6 228 {
004b8382
LOK
229 CLockObject lock(m_mutex);
230 if (m_unsupportedFeatures.find(opcode) == m_unsupportedFeatures.end())
8670c970 231 {
004b8382
LOK
232 LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking opcode '%s' as unsupported feature for device '%s'", ToString(opcode), GetLogicalAddressName());
233 m_unsupportedFeatures.insert(opcode);
8670c970
LOK
234 }
235 }
f437e4be 236
004b8382
LOK
237 // signal threads that are waiting for a reponse
238 MarkBusy();
060a7b5e 239 SignalOpcode(cec_command::GetResponseOpcode(opcode));
004b8382
LOK
240 MarkReady();
241}
242
243bool 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
252bool 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);
1344fd1a
LOK
256 MarkReady();
257 return bReturn;
93729720
LOK
258}
259
004b8382 260bool CCECBusDevice::TransmitKeyRelease(const cec_logical_address initiator, bool bWait /* = true */)
93729720 261{
1344fd1a 262 MarkBusy();
004b8382 263 bool bReturn = m_handler->TransmitKeyRelease(initiator, m_iLogicalAddress, bWait);
1344fd1a
LOK
264 MarkReady();
265 return bReturn;
93729720
LOK
266}
267
004b8382 268cec_version CCECBusDevice::GetCecVersion(const cec_logical_address initiator, bool bUpdate /* = false */)
93729720 269{
6bbfc3f7 270 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
97fc4ffb
LOK
271 bool bRequestUpdate(false);
272 {
f00ff009 273 CLockObject lock(m_mutex);
ddb6ac5b 274 bRequestUpdate = bIsPresent &&
6bbfc3f7 275 (bUpdate || m_cecVersion == CEC_VERSION_UNKNOWN);
97fc4ffb
LOK
276 }
277
278 if (bRequestUpdate)
ebb6ddb3 279 {
004b8382
LOK
280 CheckVendorIdRequested(initiator);
281 RequestCecVersion(initiator);
ebb6ddb3 282 }
f294b22f 283
f00ff009 284 CLockObject lock(m_mutex);
f294b22f
LOK
285 return m_cecVersion;
286}
287
004b8382 288void CCECBusDevice::SetCecVersion(const cec_version newVersion)
5734016c 289{
004b8382
LOK
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;
5734016c
LOK
294}
295
004b8382 296bool CCECBusDevice::RequestCecVersion(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
f294b22f
LOK
297{
298 bool bReturn(false);
b64db02e 299
004b8382 300 if (!IsHandledByLibCEC() &&
66c3ef5a 301 !IsUnsupportedFeature(CEC_OPCODE_GET_CEC_VERSION))
93729720 302 {
1344fd1a 303 MarkBusy();
ff07d530 304 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting CEC version of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
004b8382 305 bReturn = m_handler->TransmitRequestCecVersion(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 306 MarkReady();
93729720 307 }
f294b22f 308 return bReturn;
93729720
LOK
309}
310
2b44051c 311bool CCECBusDevice::TransmitCECVersion(const cec_logical_address destination, bool bIsReply)
62f5527d 312{
004b8382
LOK
313 cec_version version;
314 {
315 CLockObject lock(m_mutex);
ff07d530 316 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): cec version %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_cecVersion));
004b8382
LOK
317 version = m_cecVersion;
318 }
319
320 MarkBusy();
2b44051c 321 bool bReturn = m_handler->TransmitCECVersion(m_iLogicalAddress, destination, version, bIsReply);
004b8382
LOK
322 MarkReady();
323 return bReturn;
62f5527d
LOK
324}
325
004b8382 326cec_menu_language &CCECBusDevice::GetMenuLanguage(const cec_logical_address initiator, bool bUpdate /* = false */)
93729720 327{
6bbfc3f7 328 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
97fc4ffb
LOK
329 bool bRequestUpdate(false);
330 {
f00ff009 331 CLockObject lock(m_mutex);
ddb6ac5b 332 bRequestUpdate = (bIsPresent &&
97fc4ffb
LOK
333 (bUpdate || !strcmp(m_menuLanguage.language, "???")));
334 }
335
336 if (bRequestUpdate)
ebb6ddb3 337 {
004b8382
LOK
338 CheckVendorIdRequested(initiator);
339 RequestMenuLanguage(initiator);
ebb6ddb3 340 }
5e5637c6 341
f00ff009 342 CLockObject lock(m_mutex);
f294b22f
LOK
343 return m_menuLanguage;
344}
345
004b8382
LOK
346void 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);
60c28d82 355 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu language set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, m_menuLanguage.language);
004b8382
LOK
356 }
357}
358
359void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
360{
361 if (language.device == m_iLogicalAddress)
362 SetMenuLanguage(language.language);
363}
364
365bool CCECBusDevice::RequestMenuLanguage(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
f294b22f
LOK
366{
367 bool bReturn(false);
b64db02e 368
004b8382 369 if (!IsHandledByLibCEC() &&
4d738fe3 370 !IsUnsupportedFeature(CEC_OPCODE_GET_MENU_LANGUAGE))
93729720 371 {
1344fd1a 372 MarkBusy();
ff07d530 373 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting menu language of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
004b8382 374 bReturn = m_handler->TransmitRequestMenuLanguage(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 375 MarkReady();
93729720 376 }
f294b22f 377 return bReturn;
93729720
LOK
378}
379
2b44051c 380bool CCECBusDevice::TransmitSetMenuLanguage(const cec_logical_address destination, bool bIsReply)
3e61b350 381{
004b8382
LOK
382 bool bReturn(false);
383 cec_menu_language language;
384 {
385 CLockObject lock(m_mutex);
386 language = m_menuLanguage;
387 }
3e61b350 388
004b8382
LOK
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 {
ff07d530 400 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu language feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
004b8382
LOK
401 m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
402 bReturn = true;
403 }
404 else
405 {
ff07d530 406 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): menu language '%s'", GetLogicalAddressName(), m_iLogicalAddress, lang);
2b44051c 407 bReturn = m_handler->TransmitSetMenuLanguage(m_iLogicalAddress, lang, bIsReply);
004b8382
LOK
408 }
409 MarkReady();
410 return bReturn;
f8513317
LOK
411}
412
2b44051c 413bool CCECBusDevice::TransmitOSDString(const cec_logical_address destination, cec_display_control duration, const char *strMessage, bool bIsReply)
e9de9629 414{
004b8382
LOK
415 bool bReturn(false);
416 if (!m_processor->GetDevice(destination)->IsUnsupportedFeature(CEC_OPCODE_SET_OSD_STRING))
417 {
ff07d530 418 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): display OSD message '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, strMessage);
004b8382 419 MarkBusy();
2b44051c 420 bReturn = m_handler->TransmitOSDString(m_iLogicalAddress, destination, duration, strMessage, bIsReply);
004b8382
LOK
421 MarkReady();
422 }
423 return bReturn;
e9de9629
LOK
424}
425
c0152c09
LOK
426CStdString CCECBusDevice::GetCurrentOSDName(void)
427{
428 CLockObject lock(m_mutex);
429 return m_strDeviceName;
430}
431
004b8382 432CStdString CCECBusDevice::GetOSDName(const cec_logical_address initiator, bool bUpdate /* = false */)
ed21be2a 433{
6bbfc3f7 434 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
97fc4ffb
LOK
435 bool bRequestUpdate(false);
436 {
f00ff009 437 CLockObject lock(m_mutex);
ddb6ac5b 438 bRequestUpdate = bIsPresent &&
97fc4ffb 439 (bUpdate || m_strDeviceName.Equals(ToString(m_iLogicalAddress))) &&
ddb6ac5b 440 m_type != CEC_DEVICE_TYPE_TV;
97fc4ffb
LOK
441 }
442
443 if (bRequestUpdate)
ebb6ddb3 444 {
004b8382
LOK
445 CheckVendorIdRequested(initiator);
446 RequestOSDName(initiator);
ebb6ddb3 447 }
5e5637c6 448
f00ff009 449 CLockObject lock(m_mutex);
ed21be2a
LOK
450 return m_strDeviceName;
451}
452
004b8382
LOK
453void CCECBusDevice::SetOSDName(CStdString strName)
454{
455 CLockObject lock(m_mutex);
456 if (m_strDeviceName != strName)
457 {
60c28d82 458 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): osd name set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, strName.c_str());
004b8382
LOK
459 m_strDeviceName = strName;
460 }
461}
462
463bool CCECBusDevice::RequestOSDName(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
ed21be2a
LOK
464{
465 bool bReturn(false);
b64db02e 466
004b8382 467 if (!IsHandledByLibCEC() &&
4d738fe3 468 !IsUnsupportedFeature(CEC_OPCODE_GIVE_OSD_NAME))
ed21be2a 469 {
1344fd1a 470 MarkBusy();
ff07d530 471 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting OSD name of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
004b8382 472 bReturn = m_handler->TransmitRequestOSDName(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 473 MarkReady();
ed21be2a
LOK
474 }
475 return bReturn;
476}
477
2b44051c 478bool CCECBusDevice::TransmitOSDName(const cec_logical_address destination, bool bIsReply)
004b8382
LOK
479{
480 CStdString strDeviceName;
481 {
482 CLockObject lock(m_mutex);
ff07d530 483 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): OSD name '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, m_strDeviceName.c_str());
004b8382
LOK
484 strDeviceName = m_strDeviceName;
485 }
486
487 MarkBusy();
2b44051c 488 bool bReturn = m_handler->TransmitOSDName(m_iLogicalAddress, destination, strDeviceName, bIsReply);
004b8382
LOK
489 MarkReady();
490 return bReturn;
491}
492
493bool CCECBusDevice::HasValidPhysicalAddress(void)
494{
495 CLockObject lock(m_mutex);
496 return CLibCEC::IsValidPhysicalAddress(m_iPhysicalAddress);
497}
498
499uint16_t CCECBusDevice::GetCurrentPhysicalAddress(void)
500{
501 CLockObject lock(m_mutex);
502 return m_iPhysicalAddress;
503}
504
505uint16_t CCECBusDevice::GetPhysicalAddress(const cec_logical_address initiator, bool bSuppressUpdate /* = false */)
16b1e052 506{
0680dab3 507 if (!bSuppressUpdate)
16b1e052 508 {
0680dab3
LOK
509 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
510 bool bRequestUpdate(false);
511 {
512 CLockObject lock(m_mutex);
b32ffd87 513 bRequestUpdate = bIsPresent && m_iPhysicalAddress == CEC_INVALID_PHYSICAL_ADDRESS;
0680dab3 514 }
16b1e052 515
0680dab3
LOK
516 if (bRequestUpdate)
517 {
004b8382
LOK
518 CheckVendorIdRequested(initiator);
519 if (!RequestPhysicalAddress(initiator))
520 LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to request the physical address");
0680dab3 521 }
ebb6ddb3 522 }
97fc4ffb 523
f00ff009 524 CLockObject lock(m_mutex);
16b1e052
LOK
525 return m_iPhysicalAddress;
526}
527
004b8382
LOK
528bool CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress)
529{
530 CLockObject lock(m_mutex);
531 if (iNewAddress > 0 && m_iPhysicalAddress != iNewAddress)
532 {
60c28d82 533 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): physical address changed from %04x to %04x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
004b8382 534 m_iPhysicalAddress = iNewAddress;
d3caa81b
LOK
535
536 if (m_processor->GetDevices()->GetActiveSourceAddress() == iNewAddress)
537 MarkAsActiveSource();
004b8382
LOK
538 }
539 return true;
540}
541
542bool CCECBusDevice::RequestPhysicalAddress(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
16b1e052
LOK
543{
544 bool bReturn(false);
b64db02e 545
004b8382 546 if (!IsHandledByLibCEC())
16b1e052 547 {
1344fd1a 548 MarkBusy();
ff07d530 549 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting physical address of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
004b8382 550 bReturn = m_handler->TransmitRequestPhysicalAddress(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 551 MarkReady();
16b1e052
LOK
552 }
553 return bReturn;
554}
555
2b44051c 556bool CCECBusDevice::TransmitPhysicalAddress(bool bIsReply)
004b8382
LOK
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
ff07d530 565 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> broadcast (F): physical adddress %4x", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
004b8382
LOK
566 iPhysicalAddress = m_iPhysicalAddress;
567 type = m_type;
568 }
569
570 MarkBusy();
2b44051c 571 bool bReturn = m_handler->TransmitPhysicalAddress(m_iLogicalAddress, iPhysicalAddress, type, bIsReply);
004b8382
LOK
572 MarkReady();
573 return bReturn;
574}
575
576cec_power_status CCECBusDevice::GetCurrentPowerStatus(void)
577{
578 CLockObject lock(m_mutex);
579 return m_powerStatus;
580}
581
582cec_power_status CCECBusDevice::GetPowerStatus(const cec_logical_address initiator, bool bUpdate /* = false */)
e9de9629 583{
6bbfc3f7 584 bool bIsPresent(GetStatus() == CEC_DEVICE_STATUS_PRESENT);
97fc4ffb
LOK
585 bool bRequestUpdate(false);
586 {
f00ff009 587 CLockObject lock(m_mutex);
ddb6ac5b 588 bRequestUpdate = (bIsPresent &&
c8f0eef0 589 (bUpdate || m_powerStatus == CEC_POWER_STATUS_UNKNOWN ||
2efa39b7
LOK
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));
97fc4ffb
LOK
593 }
594
595 if (bRequestUpdate)
ebb6ddb3 596 {
004b8382
LOK
597 CheckVendorIdRequested(initiator);
598 RequestPowerStatus(initiator);
ebb6ddb3 599 }
5e5637c6 600
f00ff009 601 CLockObject lock(m_mutex);
f294b22f
LOK
602 return m_powerStatus;
603}
604
004b8382
LOK
605void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
606{
607 CLockObject lock(m_mutex);
608 if (m_powerStatus != powerStatus)
609 {
610 m_iLastPowerStateUpdate = GetTimeMs();
60c28d82 611 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): power status changed from '%s' to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_powerStatus), ToString(powerStatus));
004b8382
LOK
612 m_powerStatus = powerStatus;
613 }
614}
615
616bool CCECBusDevice::RequestPowerStatus(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
f294b22f
LOK
617{
618 bool bReturn(false);
b64db02e 619
004b8382 620 if (!IsHandledByLibCEC() &&
4d738fe3 621 !IsUnsupportedFeature(CEC_OPCODE_GIVE_DEVICE_POWER_STATUS))
93729720 622 {
1344fd1a 623 MarkBusy();
004b8382 624 bReturn = m_handler->TransmitRequestPowerStatus(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 625 MarkReady();
93729720 626 }
f294b22f
LOK
627 return bReturn;
628}
93729720 629
2b44051c 630bool CCECBusDevice::TransmitPowerState(const cec_logical_address destination, bool bIsReply)
f294b22f 631{
004b8382 632 cec_power_status state;
97fc4ffb 633 {
f00ff009 634 CLockObject lock(m_mutex);
ff07d530 635 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): %s", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination, ToString(m_powerStatus));
004b8382 636 state = m_powerStatus;
97fc4ffb
LOK
637 }
638
004b8382 639 MarkBusy();
2b44051c 640 bool bReturn = m_handler->TransmitPowerState(m_iLogicalAddress, destination, state, bIsReply);
004b8382
LOK
641 MarkReady();
642 return bReturn;
643}
644
645cec_vendor_id CCECBusDevice::GetCurrentVendorId(void)
646{
647 CLockObject lock(m_mutex);
f294b22f 648 return m_vendor;
e9de9629
LOK
649}
650
004b8382
LOK
651cec_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
668const char *CCECBusDevice::GetVendorName(const cec_logical_address initiator, bool bUpdate /* = false */)
669{
670 return ToString(GetVendorId(initiator, bUpdate));
671}
672
673bool 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
689bool CCECBusDevice::RequestVendorId(const cec_logical_address initiator, bool bWaitForResponse /* = true */)
a3269a0a 690{
f294b22f 691 bool bReturn(false);
b64db02e 692
004b8382 693 if (!IsHandledByLibCEC() && initiator != CECDEVICE_UNKNOWN)
a3269a0a 694 {
1344fd1a 695 MarkBusy();
ff07d530 696 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting vendor ID of '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
004b8382 697 bReturn = m_handler->TransmitRequestVendorId(initiator, m_iLogicalAddress, bWaitForResponse);
1344fd1a 698 MarkReady();
3e61b350 699
a75e3a5a
LOK
700 if (bWaitForResponse)
701 ReplaceHandler(true);
a3269a0a 702 }
f294b22f 703 return bReturn;
93729720
LOK
704}
705
2b44051c 706bool CCECBusDevice::TransmitVendorID(const cec_logical_address destination, bool bSendAbort, bool bIsReply)
93729720 707{
004b8382
LOK
708 bool bReturn(false);
709 uint64_t iVendorId;
710 {
711 CLockObject lock(m_mutex);
712 iVendorId = (uint64_t)m_vendor;
713 }
a3269a0a 714
004b8382
LOK
715 MarkBusy();
716 if (iVendorId == CEC_VENDOR_UNKNOWN)
9fd73dd4 717 {
004b8382 718 if (bSendAbort)
c6d7f0e1 719 {
ff07d530 720 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): vendor id feature abort", GetLogicalAddressName(), m_iLogicalAddress, ToString(destination), destination);
004b8382
LOK
721 m_processor->TransmitAbort(m_iLogicalAddress, destination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
722 bReturn = true;
c6d7f0e1 723 }
9fd73dd4 724 }
004b8382
LOK
725 else
726 {
ff07d530 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);
2b44051c 728 bReturn = m_handler->TransmitVendorID(m_iLogicalAddress, iVendorId, bIsReply);
004b8382
LOK
729 }
730 MarkReady();
731 return bReturn;
9fd73dd4
LOK
732}
733
a75e3a5a 734cec_bus_device_status CCECBusDevice::GetStatus(bool bForcePoll /* = false */, bool bSuppressPoll /* = false */)
f8ae3295 735{
a2facc35
LOK
736 if (m_iLogicalAddress == CECDEVICE_BROADCAST)
737 return CEC_DEVICE_STATUS_NOT_PRESENT;
738
ba427965
LOK
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;
a75e3a5a 745 bNeedsPoll = !bSuppressPoll &&
79efa271
LOK
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));
ba427965
LOK
753 }
754
755 if (bNeedsPoll)
f8ae3295 756 {
9fd73dd4 757 bool bPollAcked(false);
7b62b76e 758 if (bNeedsPoll && NeedsPoll())
9fd73dd4 759 bPollAcked = m_processor->PollDevice(m_iLogicalAddress);
95a73fa7 760
ba427965
LOK
761 status = bPollAcked ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT;
762 SetDeviceStatus(status);
f8ae3295
LOK
763 }
764
ba427965 765 return status;
f8ae3295
LOK
766}
767
2b44051c 768void CCECBusDevice::SetDeviceStatus(const cec_bus_device_status newStatus, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
93fff5c1 769{
f3b448b7
LOK
770 if (m_iLogicalAddress == CECDEVICE_UNREGISTERED)
771 return;
772
93fff5c1 773 {
ee17ad58
LOK
774 CLockObject lock(m_mutex);
775 switch (newStatus)
776 {
ee17ad58
LOK
777 case CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC:
778 if (m_deviceStatus != newStatus)
f5aa7e4c 779 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'handled by libCEC'", GetLogicalAddressName(), m_iLogicalAddress);
a20d808d
LOK
780 SetPowerStatus (CEC_POWER_STATUS_ON);
781 SetVendorId (CEC_VENDOR_UNKNOWN);
782 SetMenuState (CEC_MENU_STATE_ACTIVATED);
2b44051c 783 SetCecVersion (libCECSpecVersion);
b32ffd87 784 SetStreamPath (CEC_INVALID_PHYSICAL_ADDRESS);
004b8382 785 MarkAsInactiveSource();
a20d808d
LOK
786 m_iLastActive = 0;
787 m_deviceStatus = newStatus;
ee17ad58
LOK
788 break;
789 case CEC_DEVICE_STATUS_PRESENT:
790 if (m_deviceStatus != newStatus)
f5aa7e4c 791 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'present'", GetLogicalAddressName(), m_iLogicalAddress);
ee17ad58 792 m_deviceStatus = newStatus;
be3b6983 793 m_iLastActive = GetTimeMs();
ee17ad58
LOK
794 break;
795 case CEC_DEVICE_STATUS_NOT_PRESENT:
796 if (m_deviceStatus != newStatus)
a20d808d 797 {
f5aa7e4c 798 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): device status changed into 'not present'", GetLogicalAddressName(), m_iLogicalAddress);
a582c2bb 799 ResetDeviceStatus(true);
a20d808d
LOK
800 m_deviceStatus = newStatus;
801 }
ee17ad58 802 break;
f5aa7e4c
LOK
803 default:
804 ResetDeviceStatus();
805 break;
ee17ad58 806 }
93fff5c1
LOK
807 }
808}
809
a582c2bb 810void CCECBusDevice::ResetDeviceStatus(bool bClientUnregistered /* = false */)
93729720 811{
f00ff009 812 CLockObject lock(m_mutex);
004b8382
LOK
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));
a582c2bb 819 MarkAsInactiveSource(bClientUnregistered);
f5aa7e4c 820
004b8382
LOK
821 m_iLastActive = 0;
822 m_bVendorIdRequested = false;
823 m_unsupportedFeatures.clear();
060a7b5e 824 m_waitForResponse->Clear();
f5aa7e4c
LOK
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;
93729720
LOK
829}
830
be3b6983 831bool CCECBusDevice::TransmitPoll(const cec_logical_address dest, bool bUpdateDeviceStatus)
9dc04b07 832{
004b8382
LOK
833 bool bReturn(false);
834 cec_logical_address destination(dest);
835 if (destination == CECDEVICE_UNKNOWN)
836 destination = m_iLogicalAddress;
96274140 837
004b8382
LOK
838 CCECBusDevice *destDevice = m_processor->GetDevice(destination);
839 if (destDevice->m_deviceStatus == CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC)
840 return bReturn;
841
842 MarkBusy();
ff07d530 843 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): POLL", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest);
be3b6983 844 bReturn = m_handler->TransmitPoll(m_iLogicalAddress, destination, false);
004b8382
LOK
845 LIB_CEC->AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
846
be3b6983
LOK
847 if (bUpdateDeviceStatus)
848 destDevice->SetDeviceStatus(bReturn ? CEC_DEVICE_STATUS_PRESENT : CEC_DEVICE_STATUS_NOT_PRESENT);
004b8382
LOK
849
850 MarkReady();
851 return bReturn;
852}
853
854void CCECBusDevice::HandlePoll(const cec_logical_address destination)
855{
856 if (destination >= 0 && destination < CECDEVICE_BROADCAST)
5f2068fe 857 {
004b8382 858 CCECBusDevice *device = m_processor->GetDevice(destination);
0cb55c43 859 if (device)
004b8382 860 device->HandlePollFrom(m_iLogicalAddress);
9dc04b07
LOK
861 }
862}
863
004b8382 864void CCECBusDevice::HandlePollFrom(const cec_logical_address initiator)
e55f3f70 865{
004b8382
LOK
866 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< POLL: %s (%x) -> %s (%x)", ToString(initiator), initiator, ToString(m_iLogicalAddress), m_iLogicalAddress);
867 m_bAwaitingReceiveFailed = true;
e55f3f70
LOK
868}
869
004b8382 870bool CCECBusDevice::HandleReceiveFailed(void)
1344fd1a 871{
004b8382
LOK
872 bool bReturn = m_bAwaitingReceiveFailed;
873 m_bAwaitingReceiveFailed = false;
874 return bReturn;
1344fd1a
LOK
875}
876
004b8382 877cec_menu_state CCECBusDevice::GetMenuState(const cec_logical_address UNUSED(initiator))
1344fd1a 878{
004b8382
LOK
879 CLockObject lock(m_mutex);
880 return m_menuState;
1344fd1a
LOK
881}
882
004b8382 883void CCECBusDevice::SetMenuState(const cec_menu_state state)
e9de9629 884{
004b8382
LOK
885 CLockObject lock(m_mutex);
886 if (m_menuState != state)
94e9a2af 887 {
60c28d82 888 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s (%X): menu state set to '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(m_menuState));
004b8382
LOK
889 m_menuState = state;
890 }
891}
d211708b 892
2b44051c 893bool CCECBusDevice::TransmitMenuState(const cec_logical_address dest, bool bIsReply)
004b8382
LOK
894{
895 cec_menu_state menuState;
896 {
897 CLockObject lock(m_mutex);
ff07d530 898 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) -> %s (%X): menu state '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(dest), dest, ToString(m_menuState));
004b8382
LOK
899 menuState = m_menuState;
900 }
104125dc 901
004b8382 902 MarkBusy();
2b44051c 903 bool bReturn = m_handler->TransmitMenuState(m_iLogicalAddress, dest, menuState, bIsReply);
004b8382
LOK
904 MarkReady();
905 return bReturn;
906}
94e9a2af 907
060a7b5e 908bool CCECBusDevice::ActivateSource(uint64_t iDelay /* = 0 */)
004b8382
LOK
909{
910 MarkAsActiveSource();
004b8382 911 MarkBusy();
060a7b5e
LOK
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 }
004b8382
LOK
923 MarkReady();
924 return bReturn;
925}
94e9a2af 926
004b8382
LOK
927bool CCECBusDevice::RequestActiveSource(bool bWaitForResponse /* = true */)
928{
929 bool bReturn(false);
e9de9629 930
004b8382 931 if (IsHandledByLibCEC())
104125dc 932 {
004b8382 933 MarkBusy();
ff07d530 934 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< requesting active source");
104125dc 935
004b8382
LOK
936 bReturn = m_handler->TransmitRequestActiveSource(m_iLogicalAddress, bWaitForResponse);
937 MarkReady();
104125dc 938 }
004b8382
LOK
939 return bReturn;
940}
104125dc 941
004b8382
LOK
942void CCECBusDevice::MarkAsActiveSource(void)
943{
29d5198c
LOK
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);
104125dc 959
29d5198c
LOK
960 m_bActiveSource = true;
961 }
962
963 // mark other devices as inactive sources
004b8382
LOK
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
29d5198c
LOK
970 if (bWasActivated)
971 {
d3caa81b
LOK
972 if (IsHandledByLibCEC())
973 m_processor->SetActiveSource(true, false);
29d5198c
LOK
974 CCECClient *client = GetClient();
975 if (client)
976 client->SourceActivated(m_iLogicalAddress);
977 }
b64db02e
LOK
978}
979
a582c2bb 980void CCECBusDevice::MarkAsInactiveSource(bool bClientUnregistered /* = false */)
b64db02e 981{
29d5198c 982 bool bWasDeactivated(false);
b64db02e 983 {
f00ff009 984 CLockObject lock(m_mutex);
004b8382 985 if (m_bActiveSource)
29d5198c 986 {
004b8382 987 LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking %s (%X) as inactive source", GetLogicalAddressName(), m_iLogicalAddress);
29d5198c
LOK
988 bWasDeactivated = true;
989 }
004b8382 990 m_bActiveSource = false;
b64db02e 991 }
29d5198c
LOK
992
993 if (bWasDeactivated)
994 {
d3caa81b
LOK
995 if (IsHandledByLibCEC())
996 m_processor->SetActiveSource(false, bClientUnregistered);
29d5198c
LOK
997 CCECClient *client = GetClient();
998 if (client)
999 client->SourceDeactivated(m_iLogicalAddress);
1000 }
e9de9629
LOK
1001}
1002
2b44051c 1003bool CCECBusDevice::TransmitActiveSource(bool bIsReply)
0f23c85c 1004{
8fa35473 1005 bool bSendActiveSource(false);
3a48aeae 1006 uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
0f23c85c 1007
8747dd4f 1008 {
f00ff009 1009 CLockObject lock(m_mutex);
3a48aeae
LOK
1010 if (!HasValidPhysicalAddress())
1011 {
b1d821c6 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);
3a48aeae
LOK
1013 return false;
1014 }
1015
1016 iPhysicalAddress = m_iPhysicalAddress;
1017
49c8f2e4 1018 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
004b8382 1019 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
8fa35473
LOK
1020 else if (m_bActiveSource)
1021 {
004b8382 1022 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): active source (%4x)", GetLogicalAddressName(), m_iLogicalAddress, m_iPhysicalAddress);
8fa35473
LOK
1023 bSendActiveSource = true;
1024 }
1025 else
004b8382 1026 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not the active source", GetLogicalAddressName(), m_iLogicalAddress);
8747dd4f
LOK
1027 }
1028
dbad810a 1029 bool bActiveSourceSent(false);
b64db02e
LOK
1030 if (bSendActiveSource)
1031 {
1344fd1a 1032 MarkBusy();
2b44051c 1033 bActiveSourceSent = m_handler->TransmitActiveSource(m_iLogicalAddress, iPhysicalAddress, bIsReply);
1344fd1a 1034 MarkReady();
b64db02e
LOK
1035 }
1036
dbad810a 1037 return bActiveSourceSent;
0f23c85c
LOK
1038}
1039
49c8f2e4
LOK
1040bool CCECBusDevice::TransmitImageViewOn(void)
1041{
49c8f2e4 1042 {
9a2f12df
LOK
1043 CLockObject lock(m_mutex);
1044 if (m_powerStatus != CEC_POWER_STATUS_ON && m_powerStatus != CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON)
1045 {
004b8382 1046 LIB_CEC->AddLog(CEC_LOG_DEBUG, "<< %s (%X) is not powered on", GetLogicalAddressName(), m_iLogicalAddress);
9a2f12df
LOK
1047 return false;
1048 }
49c8f2e4 1049 }
9a2f12df 1050
dbad810a 1051 bool bImageViewOnSent(false);
9a2f12df 1052 MarkBusy();
dbad810a 1053 bImageViewOnSent = m_handler->TransmitImageViewOn(m_iLogicalAddress, CECDEVICE_TV);
9a2f12df 1054 MarkReady();
dbad810a 1055 return bImageViewOnSent;
49c8f2e4
LOK
1056}
1057
ab27363d 1058bool CCECBusDevice::TransmitInactiveSource(void)
93729720 1059{
8fa35473
LOK
1060 uint16_t iPhysicalAddress;
1061 {
f00ff009 1062 CLockObject lock(m_mutex);
004b8382 1063 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< %s (%X) -> broadcast (F): inactive source", GetLogicalAddressName(), m_iLogicalAddress);
8fa35473
LOK
1064 iPhysicalAddress = m_iPhysicalAddress;
1065 }
93729720 1066
1344fd1a
LOK
1067 MarkBusy();
1068 bool bReturn = m_handler->TransmitInactiveSource(m_iLogicalAddress, iPhysicalAddress);
1069 MarkReady();
1070 return bReturn;
93729720
LOK
1071}
1072
004b8382 1073bool CCECBusDevice::TransmitPendingActiveSourceCommands(void)
0f23c85c 1074{
1344fd1a 1075 MarkBusy();
aa4c0d34 1076 bool bReturn = m_handler->ActivateSource(true);
1344fd1a
LOK
1077 MarkReady();
1078 return bReturn;
0f23c85c
LOK
1079}
1080
844eab4e
LOK
1081void 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
004b8382 1101void CCECBusDevice::SetStreamPath(uint16_t iNewAddress, uint16_t iOldAddress /* = CEC_INVALID_PHYSICAL_ADDRESS */)
0f23c85c 1102{
004b8382
LOK
1103 CLockObject lock(m_mutex);
1104 if (iNewAddress != m_iStreamPath)
8fa35473 1105 {
60c28d82 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);
004b8382 1107 m_iStreamPath = iNewAddress;
8fa35473 1108 }
0f23c85c 1109
99aeafb9
LOK
1110 if (!LIB_CEC->IsValidPhysicalAddress(iNewAddress))
1111 return;
1112
004b8382
LOK
1113 CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iNewAddress);
1114 if (device)
4d738fe3 1115 {
004b8382
LOK
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();
e681f8a5
LOK
1118
1119 // respond with an active source message if this device is handled by libCEC
1120 if (device->IsHandledByLibCEC())
1121 device->TransmitActiveSource(true);
4d738fe3 1122 }
004b8382 1123 else
8fa35473 1124 {
004b8382
LOK
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();
8fa35473 1129 }
0f23c85c
LOK
1130}
1131
004b8382 1132bool CCECBusDevice::PowerOn(const cec_logical_address initiator)
fbdea54c
MK
1133{
1134 bool bReturn(false);
004b8382 1135 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
fbdea54c
MK
1136
1137 MarkBusy();
f81fdbfa
LOK
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))
fbdea54c 1142 {
004b8382 1143 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< powering on '%s' (%X)", GetLogicalAddressName(), m_iLogicalAddress);
f81fdbfa 1144 bReturn = m_handler->PowerOn(initiator, m_iLogicalAddress);
fbdea54c
MK
1145 }
1146 else
1147 {
ff07d530 1148 LIB_CEC->AddLog(CEC_LOG_DEBUG, "'%s' (%X) is already '%s'", GetLogicalAddressName(), m_iLogicalAddress, ToString(currentStatus));
fbdea54c 1149 }
004b8382 1150
fbdea54c
MK
1151 MarkReady();
1152 return bReturn;
1153}
1154
004b8382 1155bool CCECBusDevice::Standby(const cec_logical_address initiator)
57f45e6c 1156{
004b8382 1157 GetVendorId(initiator); // ensure that we got the vendor id, because the implementations vary per vendor
b750a5c3 1158
ff07d530 1159 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< putting '%s' (%X) in standby mode", GetLogicalAddressName(), m_iLogicalAddress);
1344fd1a 1160 MarkBusy();
004b8382 1161 bool bReturn = m_handler->TransmitStandby(initiator, m_iLogicalAddress);
1344fd1a 1162 MarkReady();
57f45e6c
LOK
1163 return bReturn;
1164}
93729720 1165
004b8382 1166bool CCECBusDevice::NeedsPoll(void)
93729720 1167{
004b8382
LOK
1168 bool bSendPoll(false);
1169 cec_logical_address pollAddress(CECDEVICE_UNKNOWN);
1170 switch (m_iLogicalAddress)
8fa35473 1171 {
004b8382
LOK
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;
8fa35473 1202 }
93729720 1203
004b8382
LOK
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;
93729720
LOK
1219}
1220
004b8382 1221void CCECBusDevice::CheckVendorIdRequested(const cec_logical_address initiator)
93729720 1222{
004b8382 1223 bool bRequestVendorId(false);
8fa35473 1224 {
f00ff009 1225 CLockObject lock(m_mutex);
004b8382
LOK
1226 bRequestVendorId = !m_bVendorIdRequested;
1227 m_bVendorIdRequested = true;
8fa35473
LOK
1228 }
1229
004b8382 1230 if (bRequestVendorId)
c4098482 1231 {
004b8382
LOK
1232 ReplaceHandler(false);
1233 GetVendorId(initiator);
c4098482 1234 }
93729720 1235}
004b8382 1236//@}
a33794d8 1237
004b8382 1238CCECAudioSystem *CCECBusDevice::AsAudioSystem(void)
a33794d8 1239{
004b8382 1240 return AsAudioSystem(this);
a33794d8
LOK
1241}
1242
004b8382 1243CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(void)
a33794d8 1244{
004b8382 1245 return AsPlaybackDevice(this);
a33794d8 1246}
4d738fe3 1247
004b8382 1248CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(void)
4d738fe3 1249{
004b8382 1250 return AsRecordingDevice(this);
4d738fe3
LOK
1251}
1252
004b8382 1253CCECTuner *CCECBusDevice::AsTuner(void)
4d738fe3 1254{
004b8382
LOK
1255 return AsTuner(this);
1256}
ad7e0696 1257
004b8382
LOK
1258CCECTV *CCECBusDevice::AsTV(void)
1259{
1260 return AsTV(this);
1261}
b499cf16 1262
004b8382
LOK
1263CCECAudioSystem *CCECBusDevice::AsAudioSystem(CCECBusDevice *device)
1264{
1265 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
1266 return static_cast<CCECAudioSystem *>(device);
1267 return NULL;
4d738fe3 1268}
b64db02e 1269
004b8382 1270CCECPlaybackDevice *CCECBusDevice::AsPlaybackDevice(CCECBusDevice *device)
b64db02e 1271{
004b8382
LOK
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;
b64db02e
LOK
1277}
1278
004b8382 1279CCECRecordingDevice *CCECBusDevice::AsRecordingDevice(CCECBusDevice *device)
a75e3a5a 1280{
004b8382
LOK
1281 if (device && device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
1282 return static_cast<CCECRecordingDevice *>(device);
1283 return NULL;
a75e3a5a
LOK
1284}
1285
004b8382 1286CCECTuner *CCECBusDevice::AsTuner(CCECBusDevice *device)
0cfdeb5a 1287{
004b8382
LOK
1288 if (device && device->GetType() == CEC_DEVICE_TYPE_TUNER)
1289 return static_cast<CCECTuner *>(device);
1290 return NULL;
0cfdeb5a
LOK
1291}
1292
004b8382 1293CCECTV *CCECBusDevice::AsTV(CCECBusDevice *device)
0cfdeb5a 1294{
004b8382
LOK
1295 if (device && device->GetType() == CEC_DEVICE_TYPE_TV)
1296 return static_cast<CCECTV *>(device);
1297 return NULL;
0cfdeb5a
LOK
1298}
1299
004b8382 1300void CCECBusDevice::MarkBusy(void)
ebb6ddb3 1301{
004b8382
LOK
1302 CLockObject handlerLock(m_handlerMutex);
1303 ++m_iHandlerUseCount;
1304}
ebb6ddb3 1305
004b8382
LOK
1306void CCECBusDevice::MarkReady(void)
1307{
1308 CLockObject handlerLock(m_handlerMutex);
1309 if (m_iHandlerUseCount > 0)
1310 --m_iHandlerUseCount;
1311}
1312
2b44051c 1313bool CCECBusDevice::TryLogicalAddress(cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
004b8382
LOK
1314{
1315 LIB_CEC->AddLog(CEC_LOG_DEBUG, "trying logical address '%s'", GetLogicalAddressName());
1316
2b44051c 1317 if (!TransmitPoll(m_iLogicalAddress, false))
ebb6ddb3 1318 {
ff07d530 1319 LIB_CEC->AddLog(CEC_LOG_DEBUG, "using logical address '%s'", GetLogicalAddressName());
2b44051c 1320 SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC, libCECSpecVersion);
004b8382
LOK
1321
1322 return true;
ebb6ddb3 1323 }
004b8382
LOK
1324
1325 LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address '%s' already taken", GetLogicalAddressName());
1326 SetDeviceStatus(CEC_DEVICE_STATUS_PRESENT);
1327 return false;
ebb6ddb3
LOK
1328}
1329
004b8382 1330CCECClient *CCECBusDevice::GetClient(void)
b78b4e33 1331{
004b8382 1332 return m_processor->GetClient(m_iLogicalAddress);
b78b4e33 1333}
060a7b5e
LOK
1334
1335void CCECBusDevice::SignalOpcode(cec_opcode opcode)
1336{
1337 m_waitForResponse->Received(opcode);
1338}
1339
1340bool CCECBusDevice::WaitForOpcode(cec_opcode opcode)
1341{
1342 return m_waitForResponse->Wait(opcode);
1343}