cec: stop replying to power status requests from LG when the power state is 'on'
[deb_libcec.git] / src / lib / CECProcessor.cpp
CommitLineData
abbca718
LOK
1/*
2 * This file is part of the libCEC(R) library.
3 *
b492c10e 4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
abbca718
LOK
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
2abe74eb 33#include "CECProcessor.h"
abbca718 34
7bb4ed43 35#include "adapter/USBCECAdapterCommunication.h"
eafa9d46 36#include "devices/CECBusDevice.h"
51b2a094
LOK
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"
62f5527d 42#include "implementations/CECCommandHandler.h"
2abe74eb 43#include "LibCEC.h"
ba65909d 44#include "platform/util/timeutils.h"
abbca718
LOK
45
46using namespace CEC;
47using namespace std;
f00ff009 48using namespace PLATFORM;
abbca718 49
caca2d81
LOK
50CCECProcessor::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
69CCECProcessor::CCECProcessor(CLibCEC *controller, const char *strDeviceName, const cec_device_type_list &types, uint16_t iPhysicalAddress, cec_client_version clientVersion) :
b64db02e 70 m_bInitialised(false),
4f362964 71 m_iPhysicalAddress(iPhysicalAddress),
16b1e052 72 m_iHDMIPort(CEC_DEFAULT_HDMI_PORT),
d2f1c157 73 m_iBaseDevice((cec_logical_address)CEC_DEFAULT_BASE_DEVICE),
f8513317
LOK
74 m_strDeviceName(strDeviceName),
75 m_types(types),
99666519 76 m_communication(NULL),
f8513317 77 m_controller(controller),
dcd240b2
LOK
78 m_bMonitor(false),
79 m_iStandardLineTimeout(3),
5f316715 80 m_iRetryLineTimeout(3),
caca2d81
LOK
81 m_iLastTransmission(0),
82 m_clientVersion(clientVersion)
f8513317 83{
ab1469a0 84 m_logicalAddresses.Clear();
caca2d81
LOK
85 CreateBusDevices();
86}
87
88void CCECProcessor::CreateBusDevices(void)
89{
f8513317 90 for (int iPtr = 0; iPtr < 16; iPtr++)
51b2a094
LOK
91 {
92 switch(iPtr)
93 {
94 case CECDEVICE_AUDIOSYSTEM:
5d5a2dc2 95 m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF);
51b2a094
LOK
96 break;
97 case CECDEVICE_PLAYBACKDEVICE1:
98 case CECDEVICE_PLAYBACKDEVICE2:
99 case CECDEVICE_PLAYBACKDEVICE3:
5d5a2dc2 100 m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF);
51b2a094
LOK
101 break;
102 case CECDEVICE_RECORDINGDEVICE1:
103 case CECDEVICE_RECORDINGDEVICE2:
104 case CECDEVICE_RECORDINGDEVICE3:
5d5a2dc2 105 m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF);
51b2a094
LOK
106 break;
107 case CECDEVICE_TUNER1:
108 case CECDEVICE_TUNER2:
109 case CECDEVICE_TUNER3:
110 case CECDEVICE_TUNER4:
5d5a2dc2 111 m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF);
51b2a094
LOK
112 break;
113 case CECDEVICE_TV:
114 m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0);
115 break;
116 default:
5d5a2dc2 117 m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF);
51b2a094
LOK
118 break;
119 }
120 }
f8513317
LOK
121}
122
2abe74eb 123CCECProcessor::~CCECProcessor(void)
abbca718 124{
eca71746 125 Close();
7c63a480 126
d1998c7b
LOK
127 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
128 delete m_busDevices[iPtr];
abbca718
LOK
129}
130
eca71746
LOK
131void 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
578c3905 144bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs)
abbca718 145{
a674fd68 146 bool bReturn(false);
578c3905 147 CLockObject lock(m_mutex);
99666519 148 if (m_communication)
578c3905 149 {
9f9c8c82
LOK
150 CLibCEC::AddLog(CEC_LOG_WARNING, "existing connection handler found, deleting it");
151 m_communication->Close();
152 delete m_communication;
578c3905 153 }
1113cb7d 154
7bb4ed43 155 m_communication = new CUSBCECAdapterCommunication(this, strPort, iBaudRate);
99666519 156
578c3905
LOK
157 /* check for an already opened connection */
158 if (m_communication->IsOpen())
1113cb7d 159 {
5477a250 160 CLibCEC::AddLog(CEC_LOG_ERROR, "connection already opened");
578c3905
LOK
161 return bReturn;
162 }
abbca718 163
c520af4f
LOK
164 uint64_t iNow = GetTimeMs();
165 uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT;
166
578c3905 167 /* open a new connection */
efed01e1
LOK
168 unsigned iConnectTry(0);
169 while (iNow < iTarget && (bReturn = m_communication->Open(this, iTimeoutMs)) == false)
3d78df91
LOK
170 {
171 CLibCEC::AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
172 Sleep(500);
173 iNow = GetTimeMs();
174 }
56035c86 175
efed01e1 176 if (bReturn)
caca2d81 177 CLibCEC::AddLog(CEC_LOG_NOTICE, "connected to the CEC adapter. firmware version = %d, client version = %s", m_communication->GetFirmwareVersion(), ToString(m_clientVersion));
3d78df91 178
578c3905
LOK
179 return bReturn;
180}
181
0cfdeb5a
LOK
182bool CCECProcessor::IsInitialised(void)
183{
184 CLockObject lock(m_mutex);
185 return m_bInitialised;
186}
187
2db8981f 188void CCECProcessor::SetInitialised(bool bSetTo /* = true */)
578c3905 189{
578c3905 190 CLockObject lock(m_mutex);
2db8981f
LOK
191 m_bInitialised = bSetTo;
192}
578c3905 193
2db8981f
LOK
194bool CCECProcessor::Initialise(void)
195{
196 bool bReturn(false);
578c3905 197 {
2db8981f
LOK
198 CLockObject lock(m_mutex);
199 if (!m_logicalAddresses.IsEmpty())
200 m_logicalAddresses.Clear();
578c3905 201
2db8981f
LOK
202 if (!FindLogicalAddresses())
203 {
5477a250 204 CLibCEC::AddLog(CEC_LOG_ERROR, "could not detect our logical addresses");
2db8981f
LOK
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 }
578c3905
LOK
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
4f362964
LOK
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)
5477a250 223 CLibCEC::AddLog(CEC_LOG_ERROR, "unable to set HDMI port %d on %s (%x)", m_iHDMIPort, ToString(m_iBaseDevice), (uint8_t)m_iBaseDevice);
2db8981f
LOK
224
225 SetInitialised(bReturn);
578c3905
LOK
226
227 return bReturn;
228}
229
230bool 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))
a674fd68 237 return bReturn;
994dbaaa 238
a674fd68 239 /* create the processor thread */
8e57f83c 240 if (!CreateThread())
a674fd68 241 {
5477a250 242 CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread");
a674fd68 243 return bReturn;
994dbaaa 244 }
a674fd68
LOK
245 }
246
578c3905 247 if ((bReturn = Initialise()) == false)
a674fd68 248 {
5477a250 249 CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a processor thread");
578c3905 250 StopThread(true);
a674fd68
LOK
251 }
252 else
253 {
5477a250 254 CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started");
a674fd68
LOK
255 }
256
257 return bReturn;
abbca718
LOK
258}
259
b58d9277 260bool CCECProcessor::TryLogicalAddress(cec_logical_address address)
f8513317 261{
93fff5c1 262 if (m_busDevices[address]->TryLogicalAddress())
f8513317 263 {
ab1469a0 264 m_logicalAddresses.Set(address);
f8513317
LOK
265 return true;
266 }
267
f8513317
LOK
268 return false;
269}
270
b58d9277 271bool CCECProcessor::FindLogicalAddressRecordingDevice(void)
f8513317 272{
5477a250 273 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
b58d9277
LOK
274 return TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1) ||
275 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2) ||
276 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3);
f8513317
LOK
277}
278
b58d9277 279bool CCECProcessor::FindLogicalAddressTuner(void)
f8513317 280{
5477a250 281 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
b58d9277
LOK
282 return TryLogicalAddress(CECDEVICE_TUNER1) ||
283 TryLogicalAddress(CECDEVICE_TUNER2) ||
284 TryLogicalAddress(CECDEVICE_TUNER3) ||
285 TryLogicalAddress(CECDEVICE_TUNER4);
f8513317
LOK
286}
287
b58d9277 288bool CCECProcessor::FindLogicalAddressPlaybackDevice(void)
f8513317 289{
5477a250 290 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
b58d9277
LOK
291 return TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1) ||
292 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2) ||
293 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3);
f8513317
LOK
294}
295
b58d9277 296bool CCECProcessor::FindLogicalAddressAudioSystem(void)
f8513317 297{
5477a250 298 CLibCEC::AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audio'");
b58d9277 299 return TryLogicalAddress(CECDEVICE_AUDIOSYSTEM);
f8513317
LOK
300}
301
3e61b350
LOK
302bool CCECProcessor::ChangeDeviceType(cec_device_type from, cec_device_type to)
303{
304 bool bChanged(false);
305
5477a250 306 CLibCEC::AddLog(CEC_LOG_NOTICE, "changing device type '%s' into '%s'", ToString(from), ToString(to));
3e61b350 307
f00ff009 308 CLockObject lock(m_mutex);
3e61b350
LOK
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);
4478bc79 336 previousDevice->SetDeviceStatus(CEC_DEVICE_STATUS_NOT_PRESENT);
3e61b350
LOK
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
f8513317
LOK
379bool CCECProcessor::FindLogicalAddresses(void)
380{
381 bool bReturn(true);
ab1469a0 382 m_logicalAddresses.Clear();
f8513317
LOK
383
384 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
385 {
386 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
387 continue;
388
5477a250 389 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - device %d: type %d", __FUNCTION__, iPtr, m_types.types[iPtr]);
f8513317
LOK
390
391 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
b58d9277 392 bReturn &= FindLogicalAddressRecordingDevice();
f8513317 393 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
b58d9277 394 bReturn &= FindLogicalAddressTuner();
f8513317 395 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
b58d9277 396 bReturn &= FindLogicalAddressPlaybackDevice();
f8513317 397 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
b58d9277 398 bReturn &= FindLogicalAddressAudioSystem();
f8513317
LOK
399 }
400
a674fd68
LOK
401 if (bReturn)
402 SetAckMask(m_logicalAddresses.AckMask());
403
f8513317
LOK
404 return bReturn;
405}
406
a3ffc068
LOK
407void CCECProcessor::ReplaceHandlers(void)
408{
ded7e7ce 409 CLockObject lock(m_mutex);
0cfdeb5a
LOK
410 if (!IsInitialised())
411 return;
a3ffc068 412 for (uint8_t iPtr = 0; iPtr <= CECDEVICE_PLAYBACKDEVICE3; iPtr++)
591170fd 413 m_busDevices[iPtr]->ReplaceHandler(m_bInitialised);
a3ffc068
LOK
414}
415
b1f94db1
LOK
416bool CCECProcessor::OnCommandReceived(const cec_command &command)
417{
418 m_commandBuffer.Push(command);
419 return true;
420}
421
2abe74eb 422void *CCECProcessor::Process(void)
f99bc831 423{
8e57f83c
LOK
424 cec_command command;
425 CLibCEC::AddLog(CEC_LOG_DEBUG, "processor thread started");
abbca718 426
b1f94db1 427 while (!IsStopped() && m_communication->IsOpen())
abbca718 428 {
591170fd 429 ReplaceHandlers();
b1f94db1 430 if (m_commandBuffer.Pop(command))
9dee1670 431 ParseCommand(command);
b5f34cf9 432
13fd6a66 433 m_controller->CheckKeypressTimeout();
b1f94db1 434 Sleep(5);
abbca718
LOK
435 }
436
60fa4578 437 return NULL;
abbca718
LOK
438}
439
18203d17 440bool CCECProcessor::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
abbca718 441{
8ac9c610
LOK
442 bool bReturn(false);
443
60fa4578 444 if (!IsRunning())
8ac9c610 445 return bReturn;
f99bc831 446
18203d17 447 cec_logical_address addr = m_logicalAddresses.primary;
04437dcf 448
18203d17
LOK
449 if (type != CEC_DEVICE_TYPE_RESERVED)
450 {
90ea9066 451 for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
18203d17
LOK
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
37b0c572 461 m_busDevices[addr]->SetActiveSource();
d383d6d0 462 if (m_busDevices[addr]->GetPhysicalAddress(false) != 0xFFFF)
e046c7bf 463 {
49c8f2e4
LOK
464 bReturn = m_busDevices[addr]->TransmitImageViewOn() &&
465 m_busDevices[addr]->TransmitActiveSource();
e046c7bf 466
4478bc79
LOK
467 if (bReturn)
468 {
469 m_busDevices[addr]->SetMenuState(CEC_MENU_STATE_ACTIVATED);
470 m_busDevices[addr]->TransmitMenuState(CECDEVICE_TV);
471 }
472
e046c7bf
LOK
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 }
8d915412
LOK
480
481 return bReturn;
18203d17
LOK
482}
483
37b0c572
LOK
484bool 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
dcd240b2
LOK
498void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
499{
f00ff009 500 CLockObject lock(m_mutex);
dcd240b2
LOK
501 m_iStandardLineTimeout = iTimeout;
502}
503
504void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
505{
f00ff009 506 CLockObject lock(m_mutex);
dcd240b2
LOK
507 m_iRetryLineTimeout = iTimeout;
508}
509
18203d17
LOK
510bool CCECProcessor::SetActiveView(void)
511{
4a870dc8 512 return SetActiveSource(m_types.IsEmpty() ? CEC_DEVICE_TYPE_RESERVED : m_types[0]);
8ac9c610
LOK
513}
514
28fa6c97 515bool CCECProcessor::SetDeckControlMode(cec_deck_control_mode mode, bool bSendUpdate /* = true */)
a9232a79
LOK
516{
517 bool bReturn(false);
518
519 CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
520 if (device)
521 {
522 ((CCECPlaybackDevice *) device)->SetDeckControlMode(mode);
28fa6c97
LOK
523 if (bSendUpdate)
524 ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV);
a9232a79
LOK
525 bReturn = true;
526 }
527
528 return bReturn;
529}
530
28fa6c97 531bool CCECProcessor::SetDeckInfo(cec_deck_info info, bool bSendUpdate /* = true */)
a9232a79
LOK
532{
533 bool bReturn(false);
534
535 CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
536 if (device)
537 {
538 ((CCECPlaybackDevice *) device)->SetDeckStatus(info);
28fa6c97
LOK
539 if (bSendUpdate)
540 ((CCECPlaybackDevice *) device)->TransmitDeckStatus(CECDEVICE_TV);
a9232a79
LOK
541 bReturn = true;
542 }
543
544 return bReturn;
545}
546
d2f1c157 547bool CCECProcessor::SetHDMIPort(cec_logical_address iBaseDevice, uint8_t iPort, bool bForce /* = false */)
16b1e052
LOK
548{
549 bool bReturn(false);
f00ff009 550 CLockObject lock(m_mutex);
16b1e052 551
89b3c9df
LOK
552 m_iBaseDevice = iBaseDevice;
553 m_iHDMIPort = iPort;
8e57f83c 554 if (!IsRunning() && !bForce)
89b3c9df 555 return true;
16b1e052 556
5477a250 557 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting HDMI port to %d on device %s (%d)", iPort, ToString(iBaseDevice), (int)iBaseDevice);
56035c86 558
16b1e052 559 uint16_t iPhysicalAddress(0);
1e7afacd 560 if (iBaseDevice > CECDEVICE_TV)
5d0c1164 561 {
f00ff009 562 lock.Unlock();
1e7afacd 563 iPhysicalAddress = m_busDevices[iBaseDevice]->GetPhysicalAddress();
5d0c1164
LOK
564 lock.Lock();
565 }
1e7afacd 566
a674fd68 567 if (iPhysicalAddress < 0xffff)
1e7afacd 568 {
1e7afacd 569 if (iPhysicalAddress == 0)
5d355340 570 iPhysicalAddress += 0x1000 * iPort;
1e7afacd 571 else if (iPhysicalAddress % 0x1000 == 0)
5d355340 572 iPhysicalAddress += 0x100 * iPort;
1e7afacd 573 else if (iPhysicalAddress % 0x100 == 0)
5d355340 574 iPhysicalAddress += 0x10 * iPort;
1e7afacd 575 else if (iPhysicalAddress % 0x10 == 0)
5d355340 576 iPhysicalAddress += iPort;
1e7afacd 577
5d355340 578 bReturn = true;
16b1e052
LOK
579 }
580
a674fd68 581 if (!bReturn)
5477a250 582 CLibCEC::AddLog(CEC_LOG_ERROR, "failed to set the physical address");
f070564b
LOK
583 else
584 {
f00ff009 585 lock.Unlock();
f070564b
LOK
586 SetPhysicalAddress(iPhysicalAddress);
587 }
a674fd68 588
16b1e052
LOK
589 return bReturn;
590}
591
45b97de7 592bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
16b1e052 593{
9fd73dd4 594 for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
16b1e052
LOK
595 {
596 if (m_busDevices[iPtr]->GetPhysicalAddress(false) == iPhysicalAddress)
597 return true;
598 }
599 return false;
600}
601
ab27363d 602bool CCECProcessor::TransmitInactiveSource(void)
abbca718 603{
60fa4578 604 if (!IsRunning())
f99bc831
LOK
605 return false;
606
ab1469a0 607 if (!m_logicalAddresses.IsEmpty() && m_busDevices[m_logicalAddresses.primary])
ab27363d 608 return m_busDevices[m_logicalAddresses.primary]->TransmitInactiveSource();
cc60ab1c 609 return false;
abbca718
LOK
610}
611
9dee1670 612void CCECProcessor::LogOutput(const cec_command &data)
abbca718 613{
1d3ca3de 614 CStdString strTx;
57f45e6c
LOK
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);
9dee1670 618
06a1f7ce 619 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
1d3ca3de 620 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
5477a250 621 CLibCEC::AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
9dee1670 622}
2abe74eb 623
06bfd4d7 624bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
abbca718 625{
f00ff009 626 CLockObject lock(m_mutex);
f8513317 627 if (m_logicalAddresses.primary != iLogicalAddress)
06775107 628 {
5477a250 629 CLibCEC::AddLog(CEC_LOG_NOTICE, "<< setting primary logical address to %1x", iLogicalAddress);
f8513317 630 m_logicalAddresses.primary = iLogicalAddress;
ab1469a0
LOK
631 m_logicalAddresses.Set(iLogicalAddress);
632 return SetAckMask(m_logicalAddresses.AckMask());
06775107 633 }
2abe74eb 634
06bfd4d7 635 return true;
abbca718 636}
825ddb96 637
28fa6c97
LOK
638bool 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
bebb19dc 652bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress, bool bSendUpdate /* = true */)
2492216a 653{
f070564b
LOK
654 bool bSendActiveView(false);
655 bool bReturn(false);
4d6f5ac7 656 cec_logical_addresses sendUpdatesTo;
ded7e7ce 657 sendUpdatesTo.Clear();
ff684fef 658
f070564b 659 {
f00ff009 660 CLockObject lock(m_mutex);
4f362964
LOK
661 m_iPhysicalAddress = iPhysicalAddress;
662
f070564b
LOK
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)
4d6f5ac7 673 sendUpdatesTo.Set((cec_logical_address)iPtr);
f070564b
LOK
674 }
675
676 bSendActiveView = bWasActiveSource && bSendUpdate;
677 bReturn = true;
678 }
cc60ab1c 679 }
f070564b 680
4d6f5ac7
LOK
681 for (uint8_t iPtr = 0; iPtr < 15; iPtr++)
682 if (sendUpdatesTo[iPtr])
683 m_busDevices[iPtr]->TransmitPhysicalAddress();
684
f070564b
LOK
685 if (bSendActiveView)
686 SetActiveView();
687
688 return bReturn;
1969b140
LOK
689}
690
8b7e5ff6
LOK
691bool CCECProcessor::SwitchMonitoring(bool bEnable)
692{
5477a250 693 CLibCEC::AddLog(CEC_LOG_NOTICE, "== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
8b7e5ff6 694
855a3a98 695 {
f00ff009 696 CLockObject lock(m_mutex);
855a3a98 697 m_bMonitor = bEnable;
855a3a98
LOK
698 }
699
8b7e5ff6 700 if (bEnable)
06bfd4d7 701 return SetAckMask(0);
8b7e5ff6 702 else
ab1469a0 703 return SetAckMask(m_logicalAddresses.AckMask());
8b7e5ff6
LOK
704}
705
57f45e6c
LOK
706bool CCECProcessor::PollDevice(cec_logical_address iAddress)
707{
708 if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress])
95a73fa7
LOK
709 {
710 return m_logicalAddresses.primary == CECDEVICE_UNKNOWN ?
711 m_busDevices[iAddress]->TransmitPoll(iAddress) :
712 m_busDevices[m_logicalAddresses.primary]->TransmitPoll(iAddress);
713 }
57f45e6c
LOK
714 return false;
715}
716
5c73f7f7 717uint8_t CCECProcessor::VolumeUp(bool bSendRelease /* = true */)
04e637f9
LOK
718{
719 uint8_t status = 0;
37b0c572 720 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
5c73f7f7 721 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeUp(bSendRelease);
04e637f9
LOK
722
723 return status;
724}
725
5c73f7f7 726uint8_t CCECProcessor::VolumeDown(bool bSendRelease /* = true */)
04e637f9
LOK
727{
728 uint8_t status = 0;
37b0c572 729 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
5c73f7f7 730 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->VolumeDown(bSendRelease);
04e637f9
LOK
731
732 return status;
733}
734
5c73f7f7 735uint8_t CCECProcessor::MuteAudio(bool bSendRelease /* = true */)
04e637f9
LOK
736{
737 uint8_t status = 0;
37b0c572 738 if (IsPresentDevice(CECDEVICE_AUDIOSYSTEM))
5c73f7f7 739 status = ((CCECAudioSystem *)m_busDevices[CECDEVICE_AUDIOSYSTEM])->MuteAudio(bSendRelease);
04e637f9
LOK
740
741 return status;
742}
743
16b1e052 744CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bRefresh /* = false */) const
8ac9c610 745{
16b1e052 746 if (m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress(false) == iPhysicalAddress)
b58d9277 747 return m_busDevices[m_logicalAddresses.primary];
8ac9c610 748
b58d9277 749 CCECBusDevice *device = NULL;
8ac9c610
LOK
750 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
751 {
16b1e052 752 if (m_busDevices[iPtr]->GetPhysicalAddress(bRefresh) == iPhysicalAddress)
8ac9c610
LOK
753 {
754 device = m_busDevices[iPtr];
755 break;
756 }
757 }
758
759 return device;
760}
761
a9232a79
LOK
762CCECBusDevice *CCECProcessor::GetDeviceByType(cec_device_type type) const
763{
764 CCECBusDevice *device = NULL;
765
7619faad 766 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
a9232a79 767 {
b64db02e 768 if (m_busDevices[iPtr]->m_type == type && m_logicalAddresses[iPtr])
a9232a79
LOK
769 {
770 device = m_busDevices[iPtr];
771 break;
772 }
773 }
774
775 return device;
776}
777
842262d8
LOK
778CCECBusDevice *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
6a1c0009
LOK
787cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress)
788{
789 return m_busDevices[iAddress]->GetCecVersion();
790}
791
ed21be2a
LOK
792cec_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
a3269a0a
LOK
803bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
804{
cc60ab1c
LOK
805 if (m_busDevices[iAddress])
806 {
807 *language = m_busDevices[iAddress]->GetMenuLanguage();
5744fbba 808 return (strcmp(language->language, "???") != 0);
cc60ab1c
LOK
809 }
810 return false;
a3269a0a
LOK
811}
812
44c74256
LOK
813uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
814{
cc60ab1c
LOK
815 if (m_busDevices[iAddress])
816 return m_busDevices[iAddress]->GetVendorId();
817 return false;
44c74256
LOK
818}
819
eab72c40
LOK
820uint16_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
e55f3f70
LOK
827cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress)
828{
cc60ab1c
LOK
829 if (m_busDevices[iAddress])
830 return m_busDevices[iAddress]->GetPowerStatus();
831 return CEC_POWER_STATUS_UNKNOWN;
e55f3f70
LOK
832}
833
b4b1b49b
LOK
834cec_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
845bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
846{
847 return m_busDevices[iAddress]->IsActiveSource();
848}
849
8d84e2c0 850bool CCECProcessor::Transmit(const cec_command &data)
825ddb96 851{
7bb4ed43 852 cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
eb35e4ca 853 {
7bb4ed43
LOK
854 CLockObject lock(m_mutex);
855 LogOutput(data);
5f316715 856 m_iLastTransmission = GetTimeMs();
7bb4ed43
LOK
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);
2abe74eb
LOK
861 }
862
7bb4ed43
LOK
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);
9902f4e8 867
7bb4ed43 868 return retVal == ADAPTER_MESSAGE_STATE_SENT_ACKED;
825ddb96 869}
abbca718 870
22b4e74a 871void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
abbca718 872{
5477a250 873 CLibCEC::AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
9dee1670 874
06a1f7ce 875 cec_command command;
f8513317 876 // TODO
ab1469a0
LOK
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);
9dee1670
LOK
880
881 Transmit(command);
abbca718
LOK
882}
883
b1f94db1 884void CCECProcessor::ParseCommand(const cec_command &command)
abbca718 885{
e9de9629 886 CStdString dataStr;
1d3ca3de 887 dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode);
e9de9629
LOK
888 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
889 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
5477a250 890 CLibCEC::AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
dc113aca 891
7871d66e 892 if (!m_bMonitor && command.initiator >= CECDEVICE_TV && command.initiator <= CECDEVICE_BROADCAST)
e9de9629 893 m_busDevices[(uint8_t)command.initiator]->HandleCommand(command);
dc113aca
LOK
894}
895
6d858ba4
LOK
896cec_logical_addresses CCECProcessor::GetActiveDevices(void)
897{
898 cec_logical_addresses addresses;
988de7b9 899 addresses.Clear();
6d858ba4
LOK
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
37b0c572 908bool CCECProcessor::IsPresentDevice(cec_logical_address address)
6d858ba4
LOK
909{
910 return m_busDevices[address]->GetStatus() == CEC_DEVICE_STATUS_PRESENT;
911}
912
37b0c572 913bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
6d858ba4 914{
6d858ba4 915 for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
2813bd07
LOK
916 {
917 if (m_busDevices[iPtr]->GetType() == type && m_busDevices[iPtr]->GetStatus() == CEC_DEVICE_STATUS_PRESENT)
6d858ba4 918 return true;
2813bd07
LOK
919 }
920
6d858ba4
LOK
921 return false;
922}
923
0f23c85c
LOK
924uint16_t CCECProcessor::GetPhysicalAddress(void) const
925{
ab1469a0 926 if (!m_logicalAddresses.IsEmpty() && m_busDevices[m_logicalAddresses.primary])
16b1e052 927 return m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress(false);
cc60ab1c 928 return false;
0f23c85c
LOK
929}
930
06bfd4d7
LOK
931bool CCECProcessor::SetAckMask(uint16_t iMask)
932{
5dcf9f25 933 return m_communication->SetAckMask(iMask);
06bfd4d7 934}
a33794d8 935
4bec9d79 936bool CCECProcessor::TransmitKeypress(cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
a33794d8 937{
86869f8f 938 return m_busDevices[iDestination]->TransmitKeypress(key, bWait);
a33794d8
LOK
939}
940
4bec9d79 941bool CCECProcessor::TransmitKeyRelease(cec_logical_address iDestination, bool bWait /* = true */)
a33794d8 942{
86869f8f 943 return m_busDevices[iDestination]->TransmitKeyRelease(bWait);
a33794d8 944}
7c63a480 945
3e61b350
LOK
946const 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
03ae897d
LOK
967const 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
980const 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
999const 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
1016const 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
1057const 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
1074const 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
1113const 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
1246const 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
1de6617c 1259const char *CCECProcessor::ToString(const cec_audio_status UNUSED(status))
03ae897d
LOK
1260{
1261 // TODO this is a mask
1262 return "TODO";
1263}
1264
1265const 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";
ec0deac1
LOK
1281 case CEC_VENDOR_PHILIPS:
1282 return "Philips";
1a87cacc
LOK
1283 case CEC_VENDOR_SONY:
1284 return "Sony";
03ae897d
LOK
1285 default:
1286 return "Unknown";
1287 }
1288}
1289
caca2d81
LOK
1290const 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
7c63a480
LOK
1303void *CCECBusScan::Process(void)
1304{
1305 CCECBusDevice *device(NULL);
fe6f8e37 1306 uint8_t iCounter(0);
5f316715 1307
5e5637c6 1308 while (!IsStopped())
7c63a480 1309 {
bdb0f7f4 1310 if (++iCounter < 10)
fe6f8e37
LOK
1311 {
1312 Sleep(1000);
1313 continue;
1314 }
5f316715 1315 for (unsigned int iPtr = 0; iPtr <= 11 && !IsStopped(); iPtr++)
7c63a480 1316 {
5f316715
LOK
1317 device = m_processor->m_busDevices[iPtr];
1318 WaitUntilIdle();
1319 if (device && device->GetStatus(true) == CEC_DEVICE_STATUS_PRESENT)
5e5637c6 1320 {
5f316715
LOK
1321 WaitUntilIdle();
1322 if (!IsStopped())
1323 device->GetVendorId();
1324
1325 WaitUntilIdle();
1326 if (!IsStopped())
1327 device->GetPowerStatus(true);
5e5637c6 1328 }
7c63a480
LOK
1329 }
1330 }
5f316715 1331
7c63a480
LOK
1332 return NULL;
1333}
1113cb7d 1334
5f316715
LOK
1335void CCECBusScan::WaitUntilIdle(void)
1336{
1337 if (IsStopped())
1338 return;
1339
701f753b 1340 int32_t iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission());
5f316715
LOK
1341 while (iWaitTime > 0)
1342 {
1343 Sleep(iWaitTime);
701f753b 1344 iWaitTime = 3000 - (int32_t)(GetTimeMs() - m_processor->GetLastTransmission());
5f316715
LOK
1345 }
1346}
1347
1113cb7d
LOK
1348bool CCECProcessor::StartBootloader(void)
1349{
1350 return m_communication->StartBootloader();
1351}
1352
1353bool CCECProcessor::PingAdapter(void)
1354{
1355 return m_communication->PingAdapter();
1356}
6729ac71
LOK
1357
1358void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
1359{
0cfdeb5a 1360 m_busDevices[initiator]->HandlePoll(destination);
6729ac71
LOK
1361}
1362
7bb4ed43 1363bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator)
6729ac71 1364{
0cfdeb5a 1365 return !m_busDevices[initiator]->HandleReceiveFailed();
6729ac71 1366}
f42d3e0f
LOK
1367
1368bool 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}
d40928b5
LOK
1373
1374bool CCECProcessor::GetCurrentConfiguration(libcec_configuration *configuration)
1375{
1376 configuration->iPhysicalAddress = m_iPhysicalAddress;
1377 configuration->iHDMIPort = m_iHDMIPort;
1378 configuration->baseDevice = m_iBaseDevice;
39b1216c 1379 snprintf(configuration->strDeviceName, 13, "%s", m_strDeviceName.c_str());
d40928b5
LOK
1380 configuration->deviceTypes = m_types;
1381 return true;
1382}
224ea877
LOK
1383
1384bool CCECProcessor::CanPersistConfiguration(void)
1385{
1386 return m_communication->GetFirmwareVersion() >= 2;
1387}
1388
1389bool CCECProcessor::PersistConfiguration(libcec_configuration *configuration)
1390{
1391 return m_communication->PersistConfiguration(configuration);
1392}