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