cec: persist the configuration before closing the connection. only try to persist...
[deb_libcec.git] / src / lib / CECProcessor.cpp
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33#include "CECProcessor.h"
34
35#include "adapter/USBCECAdapterCommunication.h"
36#include "devices/CECBusDevice.h"
37#include "devices/CECAudioSystem.h"
38#include "devices/CECPlaybackDevice.h"
39#include "devices/CECRecordingDevice.h"
40#include "devices/CECTuner.h"
41#include "devices/CECTV.h"
42#include "implementations/CECCommandHandler.h"
43#include "LibCEC.h"
44#include "platform/util/timeutils.h"
45
46using namespace CEC;
47using namespace std;
48using namespace PLATFORM;
49
50CCECProcessor::CCECProcessor(CLibCEC *controller, libcec_configuration *configuration) :
51 m_bConnectionOpened(false),
52 m_bInitialised(false),
53 m_communication(NULL),
54 m_controller(controller),
55 m_bMonitor(false),
56 m_iStandardLineTimeout(3),
57 m_iRetryLineTimeout(3),
58 m_iLastTransmission(0)
59{
60 CreateBusDevices();
61 m_configuration.Clear();
62 m_configuration.serverVersion = configuration->serverVersion;
63 SetConfiguration(configuration);
64
65 if (m_configuration.tvVendor != CEC_VENDOR_UNKNOWN)
66 m_busDevices[CECDEVICE_TV]->ReplaceHandler(false);
67}
68
69CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, const cec_device_type_list &types, uint16_t iPhysicalAddress) :
70 m_bConnectionOpened(false),
71 m_bInitialised(false),
72 m_communication(NULL),
73 m_controller(controller),
74 m_bMonitor(false),
75 m_iStandardLineTimeout(3),
76 m_iRetryLineTimeout(3),
77 m_iLastTransmission(0)
78{
79 m_configuration.Clear();
80 m_configuration.serverVersion = CEC_SERVER_VERSION_1_5_2;
81
82 // client version < 1.5.0
83 m_configuration.clientVersion = (uint32_t)CEC_CLIENT_VERSION_PRE_1_5;
84 snprintf(m_configuration.strDeviceName, 13, "%s", strDeviceName);
85 m_configuration.deviceTypes = types;
86 m_configuration.iPhysicalAddress = iPhysicalAddress;
87 m_configuration.baseDevice = (cec_logical_address)CEC_DEFAULT_BASE_DEVICE;
88 m_configuration.iHDMIPort = CEC_DEFAULT_HDMI_PORT;
89
90 if (m_configuration.deviceTypes.IsEmpty())
91 m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
92 CreateBusDevices();
93}
94
95void CCECProcessor::CreateBusDevices(void)
96{
97 for (int iPtr = 0; iPtr < 16; iPtr++)
98 {
99 switch(iPtr)
100 {
101 case CECDEVICE_AUDIOSYSTEM:
102 m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF);
103 break;
104 case CECDEVICE_PLAYBACKDEVICE1:
105 case CECDEVICE_PLAYBACKDEVICE2:
106 case CECDEVICE_PLAYBACKDEVICE3:
107 m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF);
108 break;
109 case CECDEVICE_RECORDINGDEVICE1:
110 case CECDEVICE_RECORDINGDEVICE2:
111 case CECDEVICE_RECORDINGDEVICE3:
112 m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF);
113 break;
114 case CECDEVICE_TUNER1:
115 case CECDEVICE_TUNER2:
116 case CECDEVICE_TUNER3:
117 case CECDEVICE_TUNER4:
118 m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF);
119 break;
120 case CECDEVICE_TV:
121 m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0);
122 break;
123 default:
124 m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF);
125 break;
126 }
127 }
128}
129
130CCECProcessor::~CCECProcessor(void)
131{
132 Close();
133
134 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
135 delete m_busDevices[iPtr];
136}
137
138void CCECProcessor::Close(void)
139{
140 StopThread(false);
141 SetInitialised(false);
142 StopThread();
143
144 bool bClose(false);
145 {
146 CLockObject lock(m_mutex);
147 bClose = m_bConnectionOpened;
148 m_bConnectionOpened = false;
149 }
150
151 if (bClose && m_communication)
152 {
153 m_communication->PersistConfiguration(&m_configuration);
154 m_communication->Close();
155 delete m_communication;
156 m_communication = NULL;
157 }
158}
159
160bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs)
161{
162 bool bReturn(false);
163 Close();
164
165 {
166 CLockObject lock(m_mutex);
167 if (m_bConnectionOpened)
168 {
169 CLibCEC::AddLog(CEC_LOG_ERROR, "connection already opened");
170 return false;
171 }
172 m_communication = new CUSBCECAdapterCommunication(this, strPort, iBaudRate);
173 m_bConnectionOpened = (m_communication != NULL);
174 }
175
176 /* check for an already opened connection */
177 if (m_communication->IsOpen())
178 {
179 CLibCEC::AddLog(CEC_LOG_ERROR, "connection already opened");
180 return bReturn;
181 }
182
183 CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
184
185 /* open a new connection */
186 unsigned iConnectTry(0);
187 while (timeout.TimeLeft() > 0 && (bReturn = m_communication->Open(this, (timeout.TimeLeft() / CEC_CONNECT_TRIES))) == false)
188 {
189 CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
190 m_communication->Close();
191 CEvent::Sleep(1000);
192 }
193
194 if (bReturn)
195 CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d, client version = %s", m_communication->GetFirmwareVersion(), ToString((cec_client_version)m_configuration.clientVersion));
196
197 return bReturn;
198}
199
200bool CCECProcessor::IsInitialised(void)
201{
202 CLockObject lock(m_mutex);
203 return m_bInitialised;
204}
205
206void CCECProcessor::SetInitialised(bool bSetTo /* = true */)
207{
208 CLockObject lock(m_mutex);
209 m_bInitialised = bSetTo;
210}
211
212bool CCECProcessor::Initialise(void)
213{
214 bool bReturn(false);
215 {
216 CLockObject lock(m_mutex);
217 if (!m_configuration.logicalAddresses.IsEmpty())
218 m_configuration.logicalAddresses.Clear();
219
220 if (!FindLogicalAddresses())
221 {
222 CLibCEC::AddLog(CEC_LOG_ERROR, "could not detect our logical addresses");
223 return bReturn;
224 }
225
226 /* only set our OSD name for the primary device */
227 m_busDevices[m_configuration.logicalAddresses.primary]->m_strDeviceName = m_configuration.strDeviceName;
228
229 /* make the primary device the active source if the option is set */
230 if (m_configuration.bActivateSource == 1)
231 m_busDevices[m_configuration.logicalAddresses.primary]->m_bActiveSource = true;
232 }
233
234 /* get the vendor id from the TV, so we are using the correct handler */
235 m_busDevices[CECDEVICE_TV]->GetVendorId();
236
237 if (m_configuration.iPhysicalAddress != 0)
238 {
239 CLibCEC::AddLog(CEC_LOG_NOTICE, "setting the physical address to %4x", m_configuration.iPhysicalAddress);
240 m_busDevices[m_configuration.logicalAddresses.primary]->m_iPhysicalAddress = m_configuration.iPhysicalAddress;
241 if ((bReturn = m_busDevices[m_configuration.logicalAddresses.primary]->TransmitPhysicalAddress()) == false)
242 CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set the physical address to %4x", m_configuration.iPhysicalAddress);
243 }
244 else if (m_configuration.iPhysicalAddress == 0 && (bReturn = SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort, true)) == false)
245 CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set HDMI port %d on %s (%x)", m_configuration.iHDMIPort, ToString(m_configuration.baseDevice), (uint8_t)m_configuration.baseDevice);
246
247 if (m_configuration.bActivateSource == 1)
248 m_busDevices[m_configuration.logicalAddresses.primary]->ActivateSource();
249
250 SetInitialised(bReturn);
251 if (bReturn)
252 CLibCEC::ConfigurationChanged(m_configuration);
253
254 return bReturn;
255}
256
257bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = 38400 */, uint32_t iTimeoutMs /* = 10000 */)
258{
259 bool bReturn(false);
260
261 {
262 CLockObject lock(m_mutex);
263 if (!OpenConnection(strPort, iBaudRate, iTimeoutMs))
264 return bReturn;
265
266 /* create the processor thread */
267 if (!CreateThread())
268 {
269 CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread");
270 return bReturn;
271 }
272 }
273
274 if ((bReturn = Initialise()) == false)
275 {
276 CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread");
277 StopThread(true);
278 }
279 else
280 {
281 CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started");
282 }
283
284 return bReturn;
285}
286
287bool CCECProcessor::TryLogicalAddress(cec_logical_address address)
288{
289 if (m_busDevices[address]->TryLogicalAddress())
290 {
291 m_configuration.logicalAddresses.Set(address);
292 return true;
293 }
294
295 return false;
296}
297
298bool CCECProcessor::FindLogicalAddressRecordingDevice(void)
299{
300 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
301 return TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1) ||
302 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2) ||
303 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3);
304}
305
306bool CCECProcessor::FindLogicalAddressTuner(void)
307{
308 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
309 return TryLogicalAddress(CECDEVICE_TUNER1) ||
310 TryLogicalAddress(CECDEVICE_TUNER2) ||
311 TryLogicalAddress(CECDEVICE_TUNER3) ||
312 TryLogicalAddress(CECDEVICE_TUNER4);
313}
314
315bool CCECProcessor::FindLogicalAddressPlaybackDevice(void)
316{
317 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
318 return TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1) ||
319 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2) ||
320 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3);
321}
322
323bool CCECProcessor::FindLogicalAddressAudioSystem(void)
324{
325 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audio'");
326 return TryLogicalAddress(CECDEVICE_AUDIOSYSTEM);
327}
328
329bool CCECProcessor::ChangeDeviceType(cec_device_type from, cec_device_type to)
330{
331 bool bChanged(false);
332
333 CLibCEC::AddLog(CEC_LOG_NOTICE, "changing device type '%s' into '%s'", ToString(from), ToString(to));
334
335 CLockObject lock(m_mutex);
336 CCECBusDevice *previousDevice = GetDeviceByType(from);
337 m_configuration.logicalAddresses.primary = CECDEVICE_UNKNOWN;
338
339 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
340 {
341 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
342 continue;
343
344 if (m_configuration.deviceTypes.types[iPtr] == from)
345 {
346 bChanged = true;
347 m_configuration.deviceTypes.types[iPtr] = to;
348 }
349 else if (m_configuration.deviceTypes.types[iPtr] == to && bChanged)
350 {
351 m_configuration.deviceTypes.types[iPtr] = CEC_DEVICE_TYPE_RESERVED;
352 }
353 }
354
355 if (bChanged)
356 {
357 FindLogicalAddresses();
358
359 CCECBusDevice *newDevice = GetDeviceByType(to);
360 if (previousDevice && newDevice)
361 {
362 newDevice->SetDeviceStatus(CEC_DEVICE_STATUS_HANDLED_BY_LIBCEC);
363 previousDevice->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT);
364
365 newDevice->SetCecVersion(previousDevice->GetCecVersion(false));
366 previousDevice->SetCecVersion(CEC_VERSION_UNKNOWN);
367
368 newDevice->SetMenuLanguage(previousDevice->GetMenuLanguage(false));
369 cec_menu_language lang;
370 lang.device = previousDevice->GetLogicalAddress();
371 for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
372 lang.language[iPtr] = '?';
373 lang.language[3] = 0;
374 previousDevice->SetMenuLanguage(lang);
375
376 newDevice->SetMenuState(previousDevice->GetMenuState());
377 previousDevice->SetMenuState(CEC_MENU_STATE_DEACTIVATED);
378
379 newDevice->SetOSDName(previousDevice->GetOSDName(false));
380 previousDevice->SetOSDName(ToString(previousDevice->GetLogicalAddress()));
381
382 newDevice->SetPhysicalAddress(previousDevice->GetPhysicalAddress(false));
383 previousDevice->SetPhysicalAddress(0xFFFF);
384
385 newDevice->SetPowerStatus(previousDevice->GetPowerStatus(false));
386 previousDevice->SetPowerStatus(CEC_POWER_STATUS_UNKNOWN);
387
388 newDevice->SetVendorId(previousDevice->GetVendorId(false));
389 previousDevice->SetVendorId(CEC_VENDOR_UNKNOWN);
390
391 if ((from == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || from == CEC_DEVICE_TYPE_RECORDING_DEVICE) &&
392 (to == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || to == CEC_DEVICE_TYPE_RECORDING_DEVICE))
393 {
394 ((CCECPlaybackDevice *) newDevice)->SetDeckControlMode(((CCECPlaybackDevice *) previousDevice)->GetDeckControlMode());
395 ((CCECPlaybackDevice *) previousDevice)->SetDeckControlMode(CEC_DECK_CONTROL_MODE_STOP);
396
397 ((CCECPlaybackDevice *) newDevice)->SetDeckStatus(((CCECPlaybackDevice *) previousDevice)->GetDeckStatus());
398 ((CCECPlaybackDevice *) previousDevice)->SetDeckStatus(CEC_DECK_INFO_STOP);
399 }
400 }
401 }
402
403 return true;
404}
405
406bool CCECProcessor::FindLogicalAddresses(void)
407{
408 bool bReturn(true);
409 m_configuration.logicalAddresses.Clear();
410
411 if (m_configuration.deviceTypes.IsEmpty())
412 {
413 CLibCEC::AddLog(CEC_LOG_ERROR, "no device types set");
414 return false;
415 }
416
417 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
418 {
419 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
420 continue;
421
422 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - device %d: type %d", __FUNCTION__, iPtr, m_configuration.deviceTypes.types[iPtr]);
423
424 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
425 bReturn &= FindLogicalAddressRecordingDevice();
426 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
427 bReturn &= FindLogicalAddressTuner();
428 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
429 bReturn &= FindLogicalAddressPlaybackDevice();
430 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
431 bReturn &= FindLogicalAddressAudioSystem();
432 }
433
434 if (bReturn)
435 SetAckMask(m_configuration.logicalAddresses.AckMask());
436
437 return bReturn;
438}
439
440void CCECProcessor::ReplaceHandlers(void)
441{
442 if (!IsInitialised())
443 return;
444 for (uint8_t iPtr = 0; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
445 m_busDevices[iPtr]->ReplaceHandler(m_bInitialised);
446}
447
448bool CCECProcessor::OnCommandReceived(const cec_command &command)
449{
450 ParseCommand(command);
451 return true;
452}
453
454void *CCECProcessor::Process(void)
455{
456 CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started");
457
458 while (!IsStopped() && m_communication->IsOpen())
459 {
460 if (IsInitialised())
461 {
462 ReplaceHandlers();
463
464 m_controller->CheckKeypressTimeout();
465 }
466 Sleep(5);
467 }
468
469 return NULL;
470}
471
472bool CCECProcessor::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
473{
474 bool bReturn(false);
475
476 if (!IsRunning())
477 return bReturn;
478
479 cec_logical_address addr = m_configuration.logicalAddresses.primary;
480
481 if (type != CEC_DEVICE_TYPE_RESERVED)
482 {
483 for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
484 {
485 if (m_configuration.logicalAddresses[iPtr] && m_busDevices[iPtr]->m_type == type)
486 {
487 addr = (cec_logical_address) iPtr;
488 break;
489 }
490 }
491 }
492
493 m_busDevices[addr]->SetActiveSource();
494 if (m_busDevices[addr]->GetPhysicalAddress(false) != 0xFFFF)
495 bReturn = m_busDevices[addr]->ActivateSource();
496
497 return bReturn;
498}
499
500bool CCECProcessor::SetActiveSource(uint16_t iStreamPath)
501{
502 bool bReturn(false);
503
504 CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
505 if (device)
506 {
507 device->SetActiveSource();
508 bReturn = true;
509 }
510
511 return bReturn;
512}
513
514void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
515{
516 CLockObject lock(m_mutex);
517 m_iStandardLineTimeout = iTimeout;
518}
519
520void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
521{
522 CLockObject lock(m_mutex);
523 m_iRetryLineTimeout = iTimeout;
524}
525
526bool CCECProcessor::SetActiveView(void)
527{
528 CLibCEC::AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__);
529 return SetActiveSource(m_configuration.deviceTypes.IsEmpty() ? CEC_DEVICE_TYPE_RESERVED : m_configuration.deviceTypes[0]);
530}
531
532bool CCECProcessor::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */)
533{
534 bool bReturn(false);
535
536 CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
537 if (device)
538 {
539 ((CCECPlaybackDevice *) device)->SetDeckControlMode(mode);
540 if (bSendUpdate)
541 ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV);
542 bReturn = true;
543 }
544
545 return bReturn;
546}
547
548bool CCECProcessor::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true */)
549{
550 bool bReturn(false);
551
552 CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
553 if (device)
554 {
555 ((CCECPlaybackDevice *) device)->SetDeckStatus(info);
556 if (bSendUpdate)
557 ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV);
558 bReturn = true;
559 }
560
561 return bReturn;
562}
563
564bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, bool bForce /* = false */)
565{
566 bool bReturn(false);
567
568 {
569 CLockObject lock(m_mutex);
570 m_configuration.baseDevice = iBaseDevice;
571 m_configuration.iHDMIPort = iPort;
572 }
573
574 if (!IsRunning() && !bForce)
575 return true;
576
577 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting HDMI port to %d on device %s (%d)", iPort, ToString(iBaseDevice), (int)iBaseDevice);
578
579 uint16_t iPhysicalAddress(0);
580 if (iBaseDevice > CECDEVICE_TV)
581 {
582 iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress();
583 }
584
585 if (iPhysicalAddress < 0xffff)
586 {
587 if (iPhysicalAddress == 0)
588 iPhysicalAddress += 0x1000 * iPort;
589 else if (iPhysicalAddress % 0x1000 == 0)
590 iPhysicalAddress += 0x100 * iPort;
591 else if (iPhysicalAddress % 0x100 == 0)
592 iPhysicalAddress += 0x10 * iPort;
593 else if (iPhysicalAddress % 0x10 == 0)
594 iPhysicalAddress += iPort;
595
596 bReturn = true;
597 }
598
599 if (!bReturn)
600 CLibCEC::AddLog(CEC_LOG_ERROR, "failed to set the physical address");
601 else
602 SetPhysicalAddress(iPhysicalAddress);
603
604 return bReturn;
605}
606
607bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
608{
609 for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
610 {
611 if (m_busDevices[iPtr]->GetPhysicalAddress(false) == iPhysicalAddress)
612 return true;
613 }
614 return false;
615}
616
617bool CCECProcessor::TransmitInactiveSource(void)
618{
619 if (!IsRunning())
620 return false;
621
622 if (!m_configuration.logicalAddresses.IsEmpty() && m_busDevices[m_configuration.logicalAddresses.primary])
623 return m_busDevices[m_configuration.logicalAddresses.primary]->TransmitInactiveSource();
624 return false;
625}
626
627void CCECProcessor::LogOutput(const cec_command &data)
628{
629 CStdString strTx;
630 strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
631 if (data.opcode_set)
632 strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
633
634 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
635 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
636 CLibCEC::AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
637}
638
639bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
640{
641 CLockObject lock(m_mutex);
642 if (m_configuration.logicalAddresses.primary != iLogicalAddress)
643 {
644 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< setting primary logical address to %1x", iLogicalAddress);
645 m_configuration.logicalAddresses.primary = iLogicalAddress;
646 m_configuration.logicalAddresses.Set(iLogicalAddress);
647 return SetAckMask(m_configuration.logicalAddresses.AckMask());
648 }
649
650 return true;
651}
652
653bool CCECProcessor::SetMenuState(cec_menu_state state, bool bSendUpdate /* = true */)
654{
655 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
656 {
657 if (m_configuration.logicalAddresses[iPtr])
658 m_busDevices[iPtr]->SetMenuState(state);
659 }
660
661 if (bSendUpdate)
662 m_busDevices[m_configuration.logicalAddresses.primary]->TransmitMenuState(CECDEVICE_TV);
663
664 return true;
665}
666
667bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress, bool bSendUpdate /* = true */)
668{
669 bool bSendActiveView(false);
670 bool bReturn(false);
671 cec_logical_addresses sendUpdatesTo;
672 sendUpdatesTo.Clear();
673
674 {
675 CLockObject lock(m_mutex);
676 m_configuration.iPhysicalAddress = iPhysicalAddress;
677 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting physical address to '%4x'", iPhysicalAddress);
678
679 if (!m_configuration.logicalAddresses.IsEmpty())
680 {
681 bool bWasActiveSource(false);
682 for (uint8_t iPtr = 0; iPtr < 15; iPtr++)
683 if (m_configuration.logicalAddresses[iPtr])
684 {
685 bWasActiveSource |= m_busDevices[iPtr]->IsActiveSource();
686 m_busDevices[iPtr]->SetInactiveSource();
687 m_busDevices[iPtr]->SetPhysicalAddress(iPhysicalAddress);
688 if (bSendUpdate)
689 sendUpdatesTo.Set((cec_logical_address)iPtr);
690 }
691
692 bSendActiveView = bWasActiveSource && bSendUpdate;
693 bReturn = true;
694 }
695 }
696
697 for (uint8_t iPtr = 0; iPtr < 15; iPtr++)
698 if (sendUpdatesTo[iPtr])
699 m_busDevices[iPtr]->TransmitPhysicalAddress();
700
701 if (bSendActiveView)
702 SetActiveView();
703
704 if (bReturn)
705 CLibCEC::ConfigurationChanged(m_configuration);
706
707 return bReturn;
708}
709
710bool CCECProcessor::SwitchMonitoring(bool bEnable)
711{
712 CLibCEC::AddLog(CEC_LOG_NOTICE, "== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
713
714 {
715 CLockObject lock(m_mutex);
716 m_bMonitor = bEnable;
717 }
718
719 if (bEnable)
720 return SetAckMask(0);
721 else
722 return SetAckMask(m_configuration.logicalAddresses.AckMask());
723}
724
725bool CCECProcessor::PollDevice(cec_logical_address iAddress)
726{
727 if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress])
728 {
729 return m_configuration.logicalAddresses.primary == CECDEVICE_UNKNOWN ?
730 m_busDevices[iAddress]->TransmitPoll(iAddress) :
731 m_busDevices[m_configuration.logicalAddresses.primary]->TransmitPoll(iAddress);
732 }
733 return false;
734}
735
736uint8_t CCECProcessor::VolumeUp(bool bSendRelease /* = true */)
737{
738 uint8_t status = 0;
739 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
740 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeUp(bSendRelease);
741
742 return status;
743}
744
745uint8_t CCECProcessor::VolumeDown(bool bSendRelease /* = true */)
746{
747 uint8_t status = 0;
748 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
749 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeDown(bSendRelease);
750
751 return status;
752}
753
754uint8_t CCECProcessor::MuteAudio(bool bSendRelease /* = true */)
755{
756 uint8_t status = 0;
757 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
758 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->MuteAudio(bSendRelease);
759
760 return status;
761}
762
763CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bRefresh /* = false */) const
764{
765 if (m_busDevices[m_configuration.logicalAddresses.primary]->GetPhysicalAddress(false) == iPhysicalAddress)
766 return m_busDevices[m_configuration.logicalAddresses.primary];
767
768 CCECBusDevice *device = NULL;
769 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
770 {
771 if (m_busDevices[iPtr]->GetPhysicalAddress(bRefresh) == iPhysicalAddress)
772 {
773 device = m_busDevices[iPtr];
774 break;
775 }
776 }
777
778 return device;
779}
780
781CCECBusDevice *CCECProcessor::GetDeviceByType(cec_device_type type) const
782{
783 CCECBusDevice *device = NULL;
784
785 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
786 {
787 if (m_busDevices[iPtr]->m_type == type && m_configuration.logicalAddresses[iPtr])
788 {
789 device = m_busDevices[iPtr];
790 break;
791 }
792 }
793
794 return device;
795}
796
797CCECBusDevice *CCECProcessor::GetPrimaryDevice(void) const
798{
799 CCECBusDevice *device(NULL);
800 cec_logical_address primary = m_configuration.logicalAddresses.primary;
801 if (primary != CECDEVICE_UNKNOWN)
802 device = m_busDevices[primary];
803 return device;
804}
805
806cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress)
807{
808 return m_busDevices[iAddress]->GetCecVersion();
809}
810
811cec_osd_name CCECProcessor::GetDeviceOSDName(cec_logical_address iAddress)
812{
813 CStdString strOSDName = m_busDevices[iAddress]->GetOSDName();
814 cec_osd_name retVal;
815
816 snprintf(retVal.name, sizeof(retVal.name), "%s", strOSDName.c_str());
817 retVal.device = iAddress;
818
819 return retVal;
820}
821
822bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
823{
824 if (m_busDevices[iAddress])
825 {
826 *language = m_busDevices[iAddress]->GetMenuLanguage();
827 return (strcmp(language->language, "???") != 0);
828 }
829 return false;
830}
831
832uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
833{
834 if (m_busDevices[iAddress])
835 return m_busDevices[iAddress]->GetVendorId();
836 return false;
837}
838
839uint16_t CCECProcessor::GetDevicePhysicalAddress(cec_logical_address iAddress)
840{
841 if (m_busDevices[iAddress])
842 return m_busDevices[iAddress]->GetPhysicalAddress(false);
843 return false;
844}
845
846cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress)
847{
848 if (m_busDevices[iAddress])
849 return m_busDevices[iAddress]->GetPowerStatus();
850 return CEC_POWER_STATUS_UNKNOWN;
851}
852
853cec_logical_address CCECProcessor::GetActiveSource(void)
854{
855 for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
856 {
857 if (m_busDevices[iPtr]->IsActiveSource())
858 return (cec_logical_address)iPtr;
859 }
860
861 return CECDEVICE_UNKNOWN;
862}
863
864bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
865{
866 return m_busDevices[iAddress]->IsActiveSource();
867}
868
869bool CCECProcessor::Transmit(const cec_command &data)
870{
871 if (m_configuration.logicalAddresses[(uint8_t)data.destination])
872 {
873 CLibCEC::AddLog(CEC_LOG_WARNING, "not sending data to myself!");
874 return false;
875 }
876
877 uint8_t iMaxTries(0);
878 {
879 CLockObject lock(m_mutex);
880 if (IsStopped())
881 return false;
882 LogOutput(data);
883 m_iLastTransmission = GetTimeMs();
884 if (!m_communication || !m_communication->IsOpen())
885 {
886 CLibCEC::AddLog(CEC_LOG_ERROR, "cannot transmit command: connection closed");
887 return false;
888 }
889 iMaxTries = m_busDevices[data.initiator]->GetHandler()->GetTransmitRetries() + 1;
890 }
891
892 return m_communication->Write(data, iMaxTries, m_iLineTimeout, m_iRetryLineTimeout)
893 == ADAPTER_MESSAGE_STATE_SENT_ACKED;
894}
895
896void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
897{
898 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
899
900 cec_command command;
901 // TODO
902 cec_command::Format(command, m_configuration.logicalAddresses.primary, address, CEC_OPCODE_FEATURE_ABORT);
903 command.parameters.PushBack((uint8_t)opcode);
904 command.parameters.PushBack((uint8_t)reason);
905
906 Transmit(command);
907}
908
909void CCECProcessor::ParseCommand(const cec_command &command)
910{
911 CStdString dataStr;
912 dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode);
913 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
914 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
915 CLibCEC::AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
916
917 if (!m_bMonitor && command.initiator >= CECDEVICE_TV && command.initiator <= CECDEVICE_BROADCAST)
918 m_busDevices[(uint8_t)command.initiator]->HandleCommand(command);
919}
920
921cec_logical_addresses CCECProcessor::GetActiveDevices(void)
922{
923 cec_logical_addresses addresses;
924 addresses.Clear();
925 for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
926 {
927 if (m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
928 addresses.Set((cec_logical_address) iPtr);
929 }
930 return addresses;
931}
932
933bool CCECProcessor::IsPresentDevice(cec_logical_address address)
934{
935 return m_busDevices[address]->GetStatus() == CEC_DEVICE_STATUS_PRESENT;
936}
937
938bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
939{
940 for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
941 {
942 if (m_busDevices[iPtr]->GetType() == type && m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
943 return true;
944 }
945
946 return false;
947}
948
949uint16_t CCECProcessor::GetPhysicalAddress(void) const
950{
951 if (!m_configuration.logicalAddresses.IsEmpty() && m_busDevices[m_configuration.logicalAddresses.primary])
952 return m_busDevices[m_configuration.logicalAddresses.primary]->GetPhysicalAddress(false);
953 return false;
954}
955
956bool CCECProcessor::SetAckMask(uint16_t iMask)
957{
958 return m_communication->SetAckMask(iMask);
959}
960
961bool CCECProcessor::TransmitKeypress(cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
962{
963 return m_busDevices[iDestination]->TransmitKeypress(key, bWait);
964}
965
966bool CCECProcessor::TransmitKeyRelease(cec_logical_address iDestination, bool bWait /* = true */)
967{
968 return m_busDevices[iDestination]->TransmitKeyRelease(bWait);
969}
970
971bool CCECProcessor::EnablePhysicalAddressDetection(void)
972{
973 CLibCEC::AddLog(CEC_LOG_WARNING, "deprecated method %s called", __FUNCTION__);
974 uint16_t iPhysicalAddress = m_communication->GetPhysicalAddress();
975 if (iPhysicalAddress != 0)
976 {
977 m_configuration.bAutodetectAddress = 1;
978 m_configuration.iPhysicalAddress = iPhysicalAddress;
979 m_configuration.baseDevice = CECDEVICE_UNKNOWN;
980 m_configuration.iHDMIPort = 0;
981 return SetPhysicalAddress(iPhysicalAddress);
982 }
983 return false;
984}
985
986bool CCECProcessor::StandbyDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */)
987{
988 if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
989 {
990 bool bReturn(true);
991 for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++)
992 {
993 if (m_configuration.powerOffDevices[iPtr])
994 bReturn &= m_busDevices[iPtr]->Standby();
995 }
996 return bReturn;
997 }
998
999 return m_busDevices[address]->Standby();
1000}
1001
1002bool CCECProcessor::PowerOnDevices(cec_logical_address address /* = CECDEVICE_BROADCAST */)
1003{
1004 if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
1005 {
1006 bool bReturn(true);
1007 for (uint8_t iPtr = 0; iPtr <= 0xF; iPtr++)
1008 {
1009 if (m_configuration.powerOffDevices[iPtr])
1010 bReturn &= m_busDevices[iPtr]->PowerOn();
1011 }
1012 return bReturn;
1013 }
1014
1015 return m_busDevices[address]->PowerOn();
1016}
1017
1018const char *CCECProcessor::ToString(const cec_device_type type)
1019{
1020 switch (type)
1021 {
1022 case CEC_DEVICE_TYPE_AUDIO_SYSTEM:
1023 return "audio system";
1024 case CEC_DEVICE_TYPE_PLAYBACK_DEVICE:
1025 return "playback device";
1026 case CEC_DEVICE_TYPE_RECORDING_DEVICE:
1027 return "recording device";
1028 case CEC_DEVICE_TYPE_RESERVED:
1029 return "reserved";
1030 case CEC_DEVICE_TYPE_TUNER:
1031 return "tuner";
1032 case CEC_DEVICE_TYPE_TV:
1033 return "TV";
1034 default:
1035 return "unknown";
1036 }
1037}
1038
1039const char *CCECProcessor::ToString(const cec_menu_state state)
1040{
1041 switch (state)
1042 {
1043 case CEC_MENU_STATE_ACTIVATED:
1044 return "activated";
1045 case CEC_MENU_STATE_DEACTIVATED:
1046 return "deactivated";
1047 default:
1048 return "unknown";
1049 }
1050}
1051
1052const char *CCECProcessor::ToString(const cec_version version)
1053{
1054 switch (version)
1055 {
1056 case CEC_VERSION_1_2:
1057 return "1.2";
1058 case CEC_VERSION_1_2A:
1059 return "1.2a";
1060 case CEC_VERSION_1_3:
1061 return "1.3";
1062 case CEC_VERSION_1_3A:
1063 return "1.3a";
1064 case CEC_VERSION_1_4:
1065 return "1.4";
1066 default:
1067 return "unknown";
1068 }
1069}
1070
1071const char *CCECProcessor::ToString(const cec_power_status status)
1072{
1073 switch (status)
1074 {
1075 case CEC_POWER_STATUS_ON:
1076 return "on";
1077 case CEC_POWER_STATUS_STANDBY:
1078 return "standby";
1079 case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
1080 return "in transition from on to standby";
1081 case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
1082 return "in transition from standby to on";
1083 default:
1084 return "unknown";
1085 }
1086}
1087
1088const char *CCECProcessor::ToString(const cec_logical_address address)
1089{
1090 switch(address)
1091 {
1092 case CECDEVICE_AUDIOSYSTEM:
1093 return "Audio";
1094 case CECDEVICE_BROADCAST:
1095 return "Broadcast";
1096 case CECDEVICE_FREEUSE:
1097 return "Free use";
1098 case CECDEVICE_PLAYBACKDEVICE1:
1099 return "Playback 1";
1100 case CECDEVICE_PLAYBACKDEVICE2:
1101 return "Playback 2";
1102 case CECDEVICE_PLAYBACKDEVICE3:
1103 return "Playback 3";
1104 case CECDEVICE_RECORDINGDEVICE1:
1105 return "Recorder 1";
1106 case CECDEVICE_RECORDINGDEVICE2:
1107 return "Recorder 2";
1108 case CECDEVICE_RECORDINGDEVICE3:
1109 return "Recorder 3";
1110 case CECDEVICE_RESERVED1:
1111 return "Reserved 1";
1112 case CECDEVICE_RESERVED2:
1113 return "Reserved 2";
1114 case CECDEVICE_TUNER1:
1115 return "Tuner 1";
1116 case CECDEVICE_TUNER2:
1117 return "Tuner 2";
1118 case CECDEVICE_TUNER3:
1119 return "Tuner 3";
1120 case CECDEVICE_TUNER4:
1121 return "Tuner 4";
1122 case CECDEVICE_TV:
1123 return "TV";
1124 default:
1125 return "unknown";
1126 }
1127}
1128
1129const char *CCECProcessor::ToString(const cec_deck_control_mode mode)
1130{
1131 switch (mode)
1132 {
1133 case CEC_DECK_CONTROL_MODE_SKIP_FORWARD_WIND:
1134 return "skip forward wind";
1135 case CEC_DECK_CONTROL_MODE_EJECT:
1136 return "eject";
1137 case CEC_DECK_CONTROL_MODE_SKIP_REVERSE_REWIND:
1138 return "reverse rewind";
1139 case CEC_DECK_CONTROL_MODE_STOP:
1140 return "stop";
1141 default:
1142 return "unknown";
1143 }
1144}
1145
1146const char *CCECProcessor::ToString(const cec_deck_info status)
1147{
1148 switch (status)
1149 {
1150 case CEC_DECK_INFO_PLAY:
1151 return "play";
1152 case CEC_DECK_INFO_RECORD:
1153 return "record";
1154 case CEC_DECK_INFO_PLAY_REVERSE:
1155 return "play reverse";
1156 case CEC_DECK_INFO_STILL:
1157 return "still";
1158 case CEC_DECK_INFO_SLOW:
1159 return "slow";
1160 case CEC_DECK_INFO_SLOW_REVERSE:
1161 return "slow reverse";
1162 case CEC_DECK_INFO_FAST_FORWARD:
1163 return "fast forward";
1164 case CEC_DECK_INFO_FAST_REVERSE:
1165 return "fast reverse";
1166 case CEC_DECK_INFO_NO_MEDIA:
1167 return "no media";
1168 case CEC_DECK_INFO_STOP:
1169 return "stop";
1170 case CEC_DECK_INFO_SKIP_FORWARD_WIND:
1171 return "info skip forward wind";
1172 case CEC_DECK_INFO_SKIP_REVERSE_REWIND:
1173 return "info skip reverse rewind";
1174 case CEC_DECK_INFO_INDEX_SEARCH_FORWARD:
1175 return "info index search forward";
1176 case CEC_DECK_INFO_INDEX_SEARCH_REVERSE:
1177 return "info index search reverse";
1178 case CEC_DECK_INFO_OTHER_STATUS:
1179 return "other";
1180 default:
1181 return "unknown";
1182 }
1183}
1184
1185const char *CCECProcessor::ToString(const cec_opcode opcode)
1186{
1187 switch (opcode)
1188 {
1189 case CEC_OPCODE_ACTIVE_SOURCE:
1190 return "active source";
1191 case CEC_OPCODE_IMAGE_VIEW_ON:
1192 return "image view on";
1193 case CEC_OPCODE_TEXT_VIEW_ON:
1194 return "text view on";
1195 case CEC_OPCODE_INACTIVE_SOURCE:
1196 return "inactive source";
1197 case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
1198 return "request active source";
1199 case CEC_OPCODE_ROUTING_CHANGE:
1200 return "routing change";
1201 case CEC_OPCODE_ROUTING_INFORMATION:
1202 return "routing information";
1203 case CEC_OPCODE_SET_STREAM_PATH:
1204 return "set stream path";
1205 case CEC_OPCODE_STANDBY:
1206 return "standby";
1207 case CEC_OPCODE_RECORD_OFF:
1208 return "record off";
1209 case CEC_OPCODE_RECORD_ON:
1210 return "record on";
1211 case CEC_OPCODE_RECORD_STATUS:
1212 return "record status";
1213 case CEC_OPCODE_RECORD_TV_SCREEN:
1214 return "record tv screen";
1215 case CEC_OPCODE_CLEAR_ANALOGUE_TIMER:
1216 return "clear analogue timer";
1217 case CEC_OPCODE_CLEAR_DIGITAL_TIMER:
1218 return "clear digital timer";
1219 case CEC_OPCODE_CLEAR_EXTERNAL_TIMER:
1220 return "clear external timer";
1221 case CEC_OPCODE_SET_ANALOGUE_TIMER:
1222 return "set analogue timer";
1223 case CEC_OPCODE_SET_DIGITAL_TIMER:
1224 return "set digital timer";
1225 case CEC_OPCODE_SET_EXTERNAL_TIMER:
1226 return "set external timer";
1227 case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE:
1228 return "set timer program title";
1229 case CEC_OPCODE_TIMER_CLEARED_STATUS:
1230 return "timer cleared status";
1231 case CEC_OPCODE_TIMER_STATUS:
1232 return "timer status";
1233 case CEC_OPCODE_CEC_VERSION:
1234 return "cec version";
1235 case CEC_OPCODE_GET_CEC_VERSION:
1236 return "get cec version";
1237 case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
1238 return "give physical address";
1239 case CEC_OPCODE_GET_MENU_LANGUAGE:
1240 return "get menu language";
1241 case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
1242 return "report physical address";
1243 case CEC_OPCODE_SET_MENU_LANGUAGE:
1244 return "set menu language";
1245 case CEC_OPCODE_DECK_CONTROL:
1246 return "deck control";
1247 case CEC_OPCODE_DECK_STATUS:
1248 return "deck status";
1249 case CEC_OPCODE_GIVE_DECK_STATUS:
1250 return "give deck status";
1251 case CEC_OPCODE_PLAY:
1252 return "play";
1253 case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS:
1254 return "give tuner status";
1255 case CEC_OPCODE_SELECT_ANALOGUE_SERVICE:
1256 return "select analogue service";
1257 case CEC_OPCODE_SELECT_DIGITAL_SERVICE:
1258 return "set digital service";
1259 case CEC_OPCODE_TUNER_DEVICE_STATUS:
1260 return "tuner device status";
1261 case CEC_OPCODE_TUNER_STEP_DECREMENT:
1262 return "tuner step decrement";
1263 case CEC_OPCODE_TUNER_STEP_INCREMENT:
1264 return "tuner step increment";
1265 case CEC_OPCODE_DEVICE_VENDOR_ID:
1266 return "device vendor id";
1267 case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
1268 return "give device vendor id";
1269 case CEC_OPCODE_VENDOR_COMMAND:
1270 return "vendor command";
1271 case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
1272 return "vendor command with id";
1273 case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN:
1274 return "vendor remote button down";
1275 case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP:
1276 return "vendor remote button up";
1277 case CEC_OPCODE_SET_OSD_STRING:
1278 return "set osd string";
1279 case CEC_OPCODE_GIVE_OSD_NAME:
1280 return "give osd name";
1281 case CEC_OPCODE_SET_OSD_NAME:
1282 return "set osd name";
1283 case CEC_OPCODE_MENU_REQUEST:
1284 return "menu request";
1285 case CEC_OPCODE_MENU_STATUS:
1286 return "menu status";
1287 case CEC_OPCODE_USER_CONTROL_PRESSED:
1288 return "user control pressed";
1289 case CEC_OPCODE_USER_CONTROL_RELEASE:
1290 return "user control release";
1291 case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
1292 return "give device power status";
1293 case CEC_OPCODE_REPORT_POWER_STATUS:
1294 return "report power status";
1295 case CEC_OPCODE_FEATURE_ABORT:
1296 return "feature abort";
1297 case CEC_OPCODE_ABORT:
1298 return "abort";
1299 case CEC_OPCODE_GIVE_AUDIO_STATUS:
1300 return "give audio status";
1301 case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
1302 return "give audio mode status";
1303 case CEC_OPCODE_REPORT_AUDIO_STATUS:
1304 return "report audio status";
1305 case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
1306 return "set system audio mode";
1307 case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
1308 return "system audio mode request";
1309 case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
1310 return "system audio mode status";
1311 case CEC_OPCODE_SET_AUDIO_RATE:
1312 return "set audio rate";
1313 case CEC_OPCODE_NONE:
1314 return "poll";
1315 default:
1316 return "UNKNOWN";
1317 }
1318}
1319
1320const char *CCECProcessor::ToString(const cec_system_audio_status mode)
1321{
1322 switch(mode)
1323 {
1324 case CEC_SYSTEM_AUDIO_STATUS_ON:
1325 return "on";
1326 case CEC_SYSTEM_AUDIO_STATUS_OFF:
1327 return "off";
1328 default:
1329 return "unknown";
1330 }
1331}
1332
1333const char *CCECProcessor::ToString(const cec_audio_status UNUSED(status))
1334{
1335 // TODO this is a mask
1336 return "TODO";
1337}
1338
1339const char *CCECProcessor::ToString(const cec_vendor_id vendor)
1340{
1341 switch (vendor)
1342 {
1343 case CEC_VENDOR_SAMSUNG:
1344 return "Samsung";
1345 case CEC_VENDOR_LG:
1346 return "LG";
1347 case CEC_VENDOR_PANASONIC:
1348 return "Panasonic";
1349 case CEC_VENDOR_PIONEER:
1350 return "Pioneer";
1351 case CEC_VENDOR_ONKYO:
1352 return "Onkyo";
1353 case CEC_VENDOR_YAMAHA:
1354 return "Yamaha";
1355 case CEC_VENDOR_PHILIPS:
1356 return "Philips";
1357 case CEC_VENDOR_SONY:
1358 return "Sony";
1359 case CEC_VENDOR_TOSHIBA:
1360 return "Toshiba";
1361 default:
1362 return "Unknown";
1363 }
1364}
1365
1366const char *CCECProcessor::ToString(const cec_client_version version)
1367{
1368 switch (version)
1369 {
1370 case CEC_CLIENT_VERSION_PRE_1_5:
1371 return "pre-1.5";
1372 case CEC_CLIENT_VERSION_1_5_0:
1373 return "1.5.0";
1374 case CEC_CLIENT_VERSION_1_5_1:
1375 return "1.5.1";
1376 case CEC_CLIENT_VERSION_1_5_2:
1377 return "1.5.2";
1378 default:
1379 return "Unknown";
1380 }
1381}
1382
1383const char *CCECProcessor::ToString(const cec_server_version version)
1384{
1385 switch (version)
1386 {
1387 case CEC_SERVER_VERSION_PRE_1_5:
1388 return "pre-1.5";
1389 case CEC_SERVER_VERSION_1_5_0:
1390 return "1.5.0";
1391 case CEC_SERVER_VERSION_1_5_1:
1392 return "1.5.1";
1393 case CEC_SERVER_VERSION_1_5_2:
1394 return "1.5.2";
1395 default:
1396 return "Unknown";
1397 }
1398}
1399
1400void *CCECBusScan::Process(void)
1401{
1402 CCECBusDevice *device(NULL);
1403 uint8_t iCounter(0);
1404
1405 while (!IsStopped())
1406 {
1407 if (++iCounter < 10)
1408 {
1409 Sleep(1000);
1410 continue;
1411 }
1412 for (unsigned int iPtr = 0; iPtr <= 11 && !IsStopped(); iPtr++)
1413 {
1414 device = m_processor->m_busDevices[iPtr];
1415 WaitUntilIdle();
1416 if (device && device->GetStatus(true) == CEC_DEVICE_STATUS_PRESENT)
1417 {
1418 WaitUntilIdle();
1419 if (!IsStopped())
1420 device->GetVendorId();
1421
1422 WaitUntilIdle();
1423 if (!IsStopped())
1424 device->GetPowerStatus(true);
1425 }
1426 }
1427 }
1428
1429 return NULL;
1430}
1431
1432void CCECBusScan::WaitUntilIdle(void)
1433{
1434 if (IsStopped())
1435 return;
1436
1437 int32_t iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission());
1438 while (iWaitTime > 0)
1439 {
1440 Sleep(iWaitTime);
1441 iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission());
1442 }
1443}
1444
1445bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */)
1446{
1447 if (!m_communication && strPort)
1448 {
1449 bool bReturn(false);
1450 IAdapterCommunication *comm = new CUSBCECAdapterCommunication(this, strPort);
1451 CTimeout timeout(10000);
1452 int iConnectTry(0);
1453 while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(NULL, (timeout.TimeLeft() / CEC_CONNECT_TRIES)), true) == false)
1454 {
1455 CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
1456 comm->Close();
1457 Sleep(500);
1458 }
1459 if (comm->IsOpen())
1460 {
1461 bReturn = comm->StartBootloader();
1462 delete comm;
1463 }
1464 return bReturn;
1465 }
1466 else
1467 {
1468 return m_communication->StartBootloader();
1469 }
1470}
1471
1472bool CCECProcessor::PingAdapter(void)
1473{
1474 return m_communication->PingAdapter();
1475}
1476
1477void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
1478{
1479 m_busDevices[initiator]->HandlePoll(destination);
1480}
1481
1482bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator)
1483{
1484 return !m_busDevices[initiator]->HandleReceiveFailed();
1485}
1486
1487bool CCECProcessor::SetStreamPath(uint16_t iPhysicalAddress)
1488{
1489 // stream path changes are sent by the TV
1490 return m_busDevices[CECDEVICE_TV]->GetHandler()->TransmitSetStreamPath(iPhysicalAddress);
1491}
1492
1493bool CCECProcessor::SetConfiguration(const libcec_configuration *configuration)
1494{
1495 bool bReinit(false);
1496 CCECBusDevice *primary = IsRunning() ? GetPrimaryDevice() : NULL;
1497 cec_device_type oldPrimaryType = primary ? primary->GetType() : CEC_DEVICE_TYPE_RECORDING_DEVICE;
1498 m_configuration.clientVersion = configuration->clientVersion;
1499
1500 // client version 1.5.0
1501
1502 // device types
1503 bool bDeviceTypeChanged = IsRunning () && m_configuration.deviceTypes != configuration->deviceTypes;
1504 m_configuration.deviceTypes = configuration->deviceTypes;
1505
1506 bool bPhysicalAddressChanged(false);
1507
1508 // autodetect address
1509 bool bPhysicalAutodetected(false);
1510 if (IsRunning() && configuration->bAutodetectAddress == 1)
1511 {
1512 uint16_t iPhysicalAddress = m_communication->GetPhysicalAddress();
1513 if (iPhysicalAddress != 0)
1514 {
1515 if (IsRunning())
1516 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%4x'", __FUNCTION__, iPhysicalAddress);
1517 bPhysicalAddressChanged = (m_configuration.iPhysicalAddress != iPhysicalAddress);
1518 m_configuration.iPhysicalAddress = iPhysicalAddress;
1519 m_configuration.iHDMIPort = 0;
1520 m_configuration.baseDevice = CECDEVICE_UNKNOWN;
1521 bPhysicalAutodetected = true;
1522 }
1523 }
1524
1525 // physical address
1526 if (!bPhysicalAutodetected)
1527 {
1528 if (configuration->iPhysicalAddress != 0)
1529 bPhysicalAddressChanged = IsRunning() && m_configuration.iPhysicalAddress != configuration->iPhysicalAddress;
1530 if (IsRunning())
1531 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using physical address '%4x'", __FUNCTION__, configuration->iPhysicalAddress);
1532 m_configuration.iPhysicalAddress = configuration->iPhysicalAddress;
1533 }
1534
1535 bool bHdmiPortChanged(false);
1536 if (!bPhysicalAutodetected && !bPhysicalAddressChanged)
1537 {
1538 // base device
1539 bHdmiPortChanged = IsRunning() && m_configuration.baseDevice != configuration->baseDevice;
1540 if (IsRunning())
1541 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using base device '%x'", __FUNCTION__, (int)configuration->baseDevice);
1542 m_configuration.baseDevice = configuration->baseDevice;
1543
1544 // hdmi port
1545 bHdmiPortChanged |= IsRunning() && m_configuration.iHDMIPort != configuration->iHDMIPort;
1546 if (IsRunning())
1547 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using HDMI port '%d'", __FUNCTION__, configuration->iHDMIPort);
1548 m_configuration.iHDMIPort = configuration->iHDMIPort;
1549 }
1550 else
1551 {
1552 if (IsRunning())
1553 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
1554 m_configuration.baseDevice = CECDEVICE_UNKNOWN;
1555 m_configuration.iHDMIPort = 0;
1556 }
1557
1558 bReinit = bPhysicalAddressChanged || bHdmiPortChanged || bDeviceTypeChanged;
1559
1560 // device name
1561 snprintf(m_configuration.strDeviceName, 13, "%s", configuration->strDeviceName);
1562 if (primary && !primary->GetOSDName().Equals(m_configuration.strDeviceName))
1563 {
1564 primary->SetOSDName(m_configuration.strDeviceName);
1565 if (!bReinit && IsRunning())
1566 primary->TransmitOSDName(CECDEVICE_TV);
1567 }
1568
1569 // tv vendor id override
1570 if (m_configuration.tvVendor != configuration->tvVendor)
1571 {
1572 m_configuration.tvVendor= configuration->tvVendor;
1573 m_busDevices[CECDEVICE_TV]->SetVendorId((uint64_t)m_configuration.tvVendor);
1574 }
1575
1576 // wake CEC devices
1577 if (m_configuration.wakeDevices != configuration->wakeDevices)
1578 {
1579 m_configuration.wakeDevices = configuration->wakeDevices;
1580 if (!bReinit && IsRunning())
1581 PowerOnDevices();
1582 }
1583
1584 // just copy these
1585 m_configuration.clientVersion = configuration->clientVersion;
1586 m_configuration.bActivateSource = configuration->bActivateSource;
1587 m_configuration.bGetSettingsFromROM = configuration->bGetSettingsFromROM;
1588 m_configuration.powerOffDevices = configuration->powerOffDevices;
1589 m_configuration.bPowerOffScreensaver = configuration->bPowerOffScreensaver;
1590 m_configuration.bPowerOffOnStandby = configuration->bPowerOffOnStandby;
1591
1592 // client version 1.5.1
1593 if (configuration->clientVersion >= CEC_CLIENT_VERSION_1_5_1)
1594 m_configuration.bSendInactiveSource = configuration->bSendInactiveSource;
1595
1596 // ensure that there is at least 1 device type set
1597 if (m_configuration.deviceTypes.IsEmpty())
1598 m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
1599
1600 if (bReinit)
1601 {
1602 if (bDeviceTypeChanged)
1603 return ChangeDeviceType(oldPrimaryType, m_configuration.deviceTypes[0]);
1604 else if (bPhysicalAddressChanged)
1605 return SetPhysicalAddress(m_configuration.iPhysicalAddress);
1606 else
1607 return SetHDMIPort(m_configuration.baseDevice, m_configuration.iHDMIPort);
1608 }
1609 else if (m_configuration.bActivateSource == 1 && IsRunning() && !IsActiveSource(m_configuration.logicalAddresses.primary))
1610 {
1611 // activate the source if we're not already the active source
1612 SetActiveSource(m_configuration.deviceTypes.types[0]);
1613 }
1614
1615 return true;
1616}
1617
1618bool CCECProcessor::GetCurrentConfiguration(libcec_configuration *configuration)
1619{
1620 // client version 1.5.0
1621 snprintf(configuration->strDeviceName, 13, "%s", m_configuration.strDeviceName);
1622 configuration->deviceTypes = m_configuration.deviceTypes;
1623 configuration->bAutodetectAddress = m_configuration.bAutodetectAddress;
1624 configuration->iPhysicalAddress = m_configuration.iPhysicalAddress;
1625 configuration->baseDevice = m_configuration.baseDevice;
1626 configuration->iHDMIPort = m_configuration.iHDMIPort;
1627 configuration->clientVersion = m_configuration.clientVersion;
1628 configuration->serverVersion = m_configuration.serverVersion;
1629 configuration->tvVendor = m_configuration.tvVendor;
1630
1631 configuration->bGetSettingsFromROM = m_configuration.bGetSettingsFromROM;
1632 configuration->bUseTVMenuLanguage = m_configuration.bUseTVMenuLanguage;
1633 configuration->bActivateSource = m_configuration.bActivateSource;
1634 configuration->wakeDevices = m_configuration.wakeDevices;
1635 configuration->powerOffDevices = m_configuration.powerOffDevices;
1636 configuration->bPowerOffScreensaver = m_configuration.bPowerOffScreensaver;
1637 configuration->bPowerOffOnStandby = m_configuration.bPowerOffOnStandby;
1638
1639 // client version 1.5.1
1640 if (configuration->clientVersion >= CEC_CLIENT_VERSION_1_5_1)
1641 configuration->bSendInactiveSource = m_configuration.bSendInactiveSource;
1642
1643 // client version 1.5.3
1644 if (configuration->clientVersion >= CEC_CLIENT_VERSION_1_5_3)
1645 configuration->logicalAddresses = m_configuration.logicalAddresses;
1646
1647 return true;
1648}
1649
1650bool CCECProcessor::CanPersistConfiguration(void)
1651{
1652 return m_communication->GetFirmwareVersion() >= 2;
1653}
1654
1655bool CCECProcessor::PersistConfiguration(libcec_configuration *configuration)
1656{
1657 return m_communication->PersistConfiguration(configuration);
1658}
1659
1660void CCECProcessor::RescanActiveDevices(void)
1661{
1662 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
1663 m_busDevices[iPtr]->GetStatus(true);
1664}