repositories / deb_libcec.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
cec: don't send a deck status update when sending an active source message for panaso...
[deb_libcec.git] / src / lib / implementations / CECCommandHandler.cpp
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011 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 "CECCommandHandler.h"
34#include "../devices/CECBusDevice.h"
35#include "../devices/CECAudioSystem.h"
36#include "../devices/CECPlaybackDevice.h"
37#include "../CECProcessor.h"
38
39using namespace CEC;
40using namespace std;
41
42CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice) :
43 m_busDevice(busDevice),
44 m_processor(m_busDevice->GetProcessor()),
45 m_iTransmitTimeout(CEC_DEFAULT_TRANSMIT_TIMEOUT),
46 m_iTransmitWait(CEC_DEFAULT_TRANSMIT_WAIT),
47 m_iTransmitRetries(CEC_DEFAULT_TRANSMIT_RETRIES),
48 m_bHandlerInited(false),
49 m_iUseCounter(0),
50 m_expectedResponse(CEC_OPCODE_NONE),
51 m_bOPTSendDeckStatusUpdateOnActiveSource(true)
52{
53}
54
55CCECCommandHandler::~CCECCommandHandler(void)
56{
57 CLockObject lock(&m_processor->m_transmitMutex);
58 CLockObject receiveLock(&m_receiveMutex);
59 m_condition.Broadcast();
60}
61
62bool CCECCommandHandler::HandleCommand(const cec_command &command)
63{
64 bool bHandled(true);
65
66 MarkBusy();
67 CStdString strLog;
68 strLog.Format(">> %s (%X) -> %s (%X): %s (%2X)", m_processor->ToString(command.initiator), command.initiator, m_processor->ToString(command.destination), command.destination, m_processor->ToString(command.opcode), command.opcode);
69 m_busDevice->AddLog(CEC_LOG_NOTICE, strLog);
70
71 m_processor->AddCommand(command);
72
73 switch(command.opcode)
74 {
75 case CEC_OPCODE_REPORT_POWER_STATUS:
76 HandleReportPowerStatus(command);
77 break;
78 case CEC_OPCODE_CEC_VERSION:
79 HandleDeviceCecVersion(command);
80 break;
81 case CEC_OPCODE_SET_MENU_LANGUAGE:
82 HandleSetMenuLanguage(command);
83 break;
84 case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
85 if (m_processor->IsInitialised())
86 HandleGivePhysicalAddress(command);
87 break;
88 case CEC_OPCODE_GIVE_OSD_NAME:
89 if (m_processor->IsInitialised())
90 HandleGiveOSDName(command);
91 break;
92 case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
93 if (m_processor->IsInitialised())
94 HandleGiveDeviceVendorId(command);
95 break;
96 case CEC_OPCODE_DEVICE_VENDOR_ID:
97 HandleDeviceVendorId(command);
98 break;
99 case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
100 HandleDeviceVendorCommandWithId(command);
101 break;
102 case CEC_OPCODE_GIVE_DECK_STATUS:
103 if (m_processor->IsInitialised())
104 HandleGiveDeckStatus(command);
105 break;
106 case CEC_OPCODE_DECK_CONTROL:
107 HandleDeckControl(command);
108 break;
109 case CEC_OPCODE_MENU_REQUEST:
110 if (m_processor->IsInitialised())
111 HandleMenuRequest(command);
112 break;
113 case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
114 if (m_processor->IsInitialised())
115 HandleGiveDevicePowerStatus(command);
116 break;
117 case CEC_OPCODE_GET_CEC_VERSION:
118 if (m_processor->IsInitialised())
119 HandleGetCecVersion(command);
120 break;
121 case CEC_OPCODE_USER_CONTROL_PRESSED:
122 if (m_processor->IsInitialised())
123 HandleUserControlPressed(command);
124 break;
125 case CEC_OPCODE_USER_CONTROL_RELEASE:
126 if (m_processor->IsInitialised())
127 HandleUserControlRelease(command);
128 break;
129 case CEC_OPCODE_GIVE_AUDIO_STATUS:
130 if (m_processor->IsInitialised())
131 HandleGiveAudioStatus(command);
132 break;
133 case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
134 if (m_processor->IsInitialised())
135 HandleGiveSystemAudioModeStatus(command);
136 break;
137 case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
138 if (m_processor->IsInitialised())
139 HandleSystemAudioModeRequest(command);
140 break;
141 case CEC_OPCODE_REPORT_AUDIO_STATUS:
142 HandleReportAudioStatus(command);
143 break;
144 case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
145 HandleSystemAudioModeStatus(command);
146 break;
147 case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
148 HandleSetSystemAudioMode(command);
149 break;
150 case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
151 if (m_processor->IsInitialised())
152 HandleRequestActiveSource(command);
153 break;
154 case CEC_OPCODE_SET_STREAM_PATH:
155 HandleSetStreamPath(command);
156 break;
157 case CEC_OPCODE_ROUTING_CHANGE:
158 HandleRoutingChange(command);
159 break;
160 case CEC_OPCODE_ROUTING_INFORMATION:
161 HandleRoutingInformation(command);
162 break;
163 case CEC_OPCODE_STANDBY:
164 if (m_processor->IsInitialised())
165 HandleStandby(command);
166 break;
167 case CEC_OPCODE_ACTIVE_SOURCE:
168 HandleActiveSource(command);
169 break;
170 case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
171 HandleReportPhysicalAddress(command);
172 break;
173 case CEC_OPCODE_SET_OSD_NAME:
174 HandleSetOSDName(command);
175 break;
176 case CEC_OPCODE_IMAGE_VIEW_ON:
177 HandleImageViewOn(command);
178 break;
179 case CEC_OPCODE_TEXT_VIEW_ON:
180 HandleTextViewOn(command);
181 break;
182 case CEC_OPCODE_FEATURE_ABORT:
183 HandleFeatureAbort(command);
184 break;
185 case CEC_OPCODE_VENDOR_COMMAND:
186 HandleVendorCommand(command);
187 break;
188 default:
189 UnhandledCommand(command);
190 bHandled = false;
191 break;
192 }
193
194 if (bHandled)
195 {
196 CLockObject lock(&m_receiveMutex);
197 if (m_expectedResponse == CEC_OPCODE_NONE ||
198 m_expectedResponse == command.opcode)
199 m_condition.Signal();
200 }
201
202 MarkReady();
203 return bHandled;
204}
205
206bool CCECCommandHandler::HandleActiveSource(const cec_command &command)
207{
208 if (command.parameters.size == 2)
209 {
210 uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
211 return m_processor->SetActiveSource(iAddress);
212 }
213
214 return true;
215}
216
217bool CCECCommandHandler::HandleDeckControl(const cec_command &command)
218{
219 CCECBusDevice *device = GetDevice(command.destination);
220 if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE) && command.parameters.size > 0)
221 {
222 ((CCECPlaybackDevice *) device)->SetDeckControlMode((cec_deck_control_mode) command.parameters[0]);
223 return true;
224 }
225
226 return false;
227}
228
229bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
230{
231 if (command.parameters.size == 1)
232 {
233 CCECBusDevice *device = GetDevice(command.initiator);
234 if (device)
235 device->SetCecVersion((cec_version) command.parameters[0]);
236 }
237
238 return true;
239}
240
241bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
242{
243 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
244 m_processor->TransmitAbort(command.initiator, command.opcode, CEC_ABORT_REASON_REFUSED);
245
246 return true;
247}
248
249bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
250{
251 return SetVendorId(command);
252}
253
254bool CCECCommandHandler::HandleFeatureAbort(const cec_command &command)
255{
256 if (command.parameters.size == 2)
257 {
258 m_processor->m_busDevices[command.initiator]->SetUnsupportedFeature((cec_opcode)command.parameters[0]);
259 }
260 return true;
261}
262
263bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
264{
265 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
266 {
267 CCECBusDevice *device = GetDevice(command.destination);
268 if (device)
269 return device->TransmitCECVersion(command.initiator);
270 }
271
272 return false;
273}
274
275bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
276{
277 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
278 {
279 CCECBusDevice *device = GetDevice(command.destination);
280 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
281 return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
282 }
283
284 return false;
285}
286
287bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
288{
289 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
290 {
291 CCECBusDevice *device = GetDevice(command.destination);
292 if (device && (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE || device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE))
293 return ((CCECPlaybackDevice *) device)->TransmitDeckStatus(command.initiator);
294 }
295
296 return false;
297}
298
299bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
300{
301 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
302 {
303 CCECBusDevice *device = GetDevice(command.destination);
304 if (device)
305 return device->TransmitPowerState(command.initiator);
306 }
307
308 return false;
309}
310
311bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
312{
313 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
314 {
315 CCECBusDevice *device = GetDevice(command.destination);
316 if (device)
317 return device->TransmitVendorID(command.initiator);
318 }
319
320 return false;
321}
322
323bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
324{
325 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
326 {
327 CCECBusDevice *device = GetDevice(command.destination);
328 if (device)
329 return device->TransmitOSDName(command.initiator);
330 }
331
332 return false;
333}
334
335bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
336{
337 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
338 {
339 CCECBusDevice *device = GetDevice(command.destination);
340 if (device)
341 {
342 device->SetActiveSource();
343 return device->TransmitPhysicalAddress() &&
344 device->TransmitActiveSource();
345 }
346 }
347
348 return false;
349}
350
351bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
352{
353 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
354 {
355 CCECBusDevice *device = GetDevice(command.destination);
356 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
357 return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
358 }
359
360 return false;
361}
362
363bool CCECCommandHandler::HandleImageViewOn(const cec_command &command)
364{
365 m_processor->m_busDevices[command.initiator]->SetActiveSource();
366 return true;
367}
368
369bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
370{
371 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
372 {
373 if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
374 {
375 CCECBusDevice *device = GetDevice(command.destination);
376 if (device)
377 return device->TransmitMenuState(command.initiator);
378 }
379 }
380
381 return false;
382}
383
384bool CCECCommandHandler::HandleReportAudioStatus(const cec_command &command)
385{
386 if (command.parameters.size == 1)
387 {
388 CCECBusDevice *device = GetDevice(command.initiator);
389 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
390 {
391 ((CCECAudioSystem *)device)->SetAudioStatus(command.parameters[0]);
392 return true;
393 }
394 }
395 return false;
396}
397
398bool CCECCommandHandler::HandleReportPhysicalAddress(const cec_command &command)
399{
400 if (command.parameters.size == 3)
401 {
402 uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
403 SetPhysicalAddress(command.initiator, iNewAddress);
404 }
405 return true;
406}
407
408bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
409{
410 if (command.parameters.size == 1)
411 {
412 CCECBusDevice *device = GetDevice(command.initiator);
413 if (device)
414 device->SetPowerStatus((cec_power_status) command.parameters[0]);
415 }
416 return true;
417}
418
419bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
420{
421 if (m_processor->IsStarted())
422 {
423 CStdString strLog;
424 strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
425 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
426
427 vector<CCECBusDevice *> devices;
428 for (int iDevicePtr = (int)GetMyDevices(devices)-1; iDevicePtr >=0; iDevicePtr--)
429 devices[iDevicePtr]->TransmitActiveSource();
430
431 return true;
432 }
433 return false;
434}
435
436bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
437{
438 if (command.parameters.size == 4)
439 {
440 uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
441 uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
442
443 CCECBusDevice *device = GetDevice(command.initiator);
444 if (device)
445 device->SetStreamPath(iNewAddress, iOldAddress);
446 }
447 return true;
448}
449
450bool CCECCommandHandler::HandleRoutingInformation(const cec_command &command)
451{
452 if (command.parameters.size == 2)
453 {
454 uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
455 m_processor->SetActiveSource(iNewAddress);
456 }
457
458 return false;
459}
460
461bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
462{
463 if (command.parameters.size == 3)
464 {
465 CCECBusDevice *device = GetDevice(command.initiator);
466 if (device)
467 {
468 cec_menu_language language;
469 language.device = command.initiator;
470 for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
471 language.language[iPtr] = command.parameters[iPtr];
472 language.language[3] = 0;
473 device->SetMenuLanguage(language);
474 return true;
475 }
476 }
477 return false;
478}
479
480bool CCECCommandHandler::HandleSetOSDName(const cec_command &command)
481{
482 if (command.parameters.size > 0)
483 {
484 CCECBusDevice *device = GetDevice(command.initiator);
485 if (device)
486 {
487 char buf[1024];
488 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
489 buf[iPtr] = (char)command.parameters[iPtr];
490 buf[command.parameters.size] = 0;
491
492 CStdString strName(buf);
493 device->SetOSDName(strName);
494
495 return true;
496 }
497 }
498 return false;
499}
500
501bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
502{
503 if (m_processor->IsStarted() && command.parameters.size >= 2)
504 {
505 uint16_t iStreamAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
506 CStdString strLog;
507 strLog.Format(">> %i sets stream path to physical address %04x", command.initiator, iStreamAddress);
508 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
509
510 /* one of the device handled by libCEC has been made active */
511 CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamAddress);
512 if (device && m_busDevice->MyLogicalAddressContains(device->GetLogicalAddress()))
513 {
514 device->SetActiveSource();
515 device->TransmitActiveSource();
516 }
517 }
518 return false;
519}
520
521bool CCECCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
522{
523 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
524 {
525 CCECBusDevice *device = GetDevice(command.destination);
526 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
527 {
528 if (command.parameters.size >= 2)
529 {
530 device->SetPowerStatus(CEC_POWER_STATUS_ON);
531 ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_ON);
532 uint16_t iNewAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
533 CCECBusDevice *newActiveDevice = GetDeviceByPhysicalAddress(iNewAddress);
534 if (newActiveDevice)
535 newActiveDevice->SetActiveSource();
536 return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
537 }
538 else
539 {
540 ((CCECAudioSystem *) device)->SetSystemAudioModeStatus(CEC_SYSTEM_AUDIO_STATUS_OFF);
541 return ((CCECAudioSystem *) device)->TransmitSetSystemAudioMode(command.initiator);
542 }
543 }
544 }
545 return false;
546}
547
548bool CCECCommandHandler::HandleStandby(const cec_command &command)
549{
550 CCECBusDevice *device = GetDevice(command.initiator);
551 if (device)
552 device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
553
554 return true;
555}
556
557bool CCECCommandHandler::HandleSystemAudioModeStatus(const cec_command &command)
558{
559 if (command.parameters.size == 1)
560 {
561 CCECBusDevice *device = GetDevice(command.initiator);
562 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
563 {
564 ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
565 return true;
566 }
567 }
568
569 return false;
570}
571
572bool CCECCommandHandler::HandleSetSystemAudioMode(const cec_command &command)
573{
574 if (command.parameters.size == 1)
575 {
576 CCECBusDevice *device = GetDevice(command.initiator);
577 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
578 {
579 ((CCECAudioSystem *)device)->SetSystemAudioModeStatus((cec_system_audio_status)command.parameters[0]);
580 return true;
581 }
582 }
583
584 return false;
585}
586
587bool CCECCommandHandler::HandleTextViewOn(const cec_command &command)
588{
589 m_processor->m_busDevices[command.initiator]->SetActiveSource();
590 return true;
591}
592
593bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
594{
595 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination) && command.parameters.size > 0)
596 {
597 m_processor->AddKey();
598
599 if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
600 {
601 CStdString strLog;
602 strLog.Format("key pressed: %x", command.parameters[0]);
603 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
604
605 if (command.parameters[0] == CEC_USER_CONTROL_CODE_POWER ||
606 command.parameters[0] == CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION)
607 {
608 CCECBusDevice *device = GetDevice(command.destination);
609 if (device)
610 {
611 device->SetPowerStatus(CEC_POWER_STATUS_ON);
612 if (device->MyLogicalAddressContains(device->GetLogicalAddress()))
613 {
614 device->SetActiveSource();
615 device->TransmitActiveSource();
616
617 if (device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE ||
618 device->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
619 ((CCECPlaybackDevice *)device)->TransmitDeckStatus(command.initiator);
620 }
621 }
622 }
623 else
624 {
625 m_processor->SetCurrentButton((cec_user_control_code) command.parameters[0]);
626 }
627 return true;
628 }
629 }
630 return false;
631}
632
633bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
634{
635 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
636 m_processor->AddKey();
637
638 return true;
639}
640
641void CCECCommandHandler::UnhandledCommand(const cec_command &command)
642{
643 CStdString strLog;
644 strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
645 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
646}
647
648unsigned int CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
649{
650 unsigned int iReturn(0);
651
652 cec_logical_addresses addresses = m_processor->GetLogicalAddresses();
653 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
654 {
655 if (addresses[iPtr])
656 {
657 devices.push_back(GetDevice((cec_logical_address) iPtr));
658 ++iReturn;
659 }
660 }
661
662 return iReturn;
663}
664
665CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
666{
667 CCECBusDevice *device = NULL;
668
669 if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
670 device = m_processor->m_busDevices[iLogicalAddress];
671
672 return device;
673}
674
675CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
676{
677 return m_processor->GetDeviceByPhysicalAddress(iPhysicalAddress);
678}
679
680CCECBusDevice *CCECCommandHandler::GetDeviceByType(cec_device_type type) const
681{
682 return m_processor->GetDeviceByType(type);
683}
684
685bool CCECCommandHandler::SetVendorId(const cec_command &command)
686{
687 bool bChanged(false);
688 if (command.parameters.size < 3)
689 {
690 m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
691 return bChanged;
692 }
693
694 uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
695 ((uint64_t)command.parameters[1] << 8) +
696 (uint64_t)command.parameters[2];
697
698 CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
699 if (device)
700 bChanged = device->SetVendorId(iVendorId);
701 return bChanged;
702}
703
704void CCECCommandHandler::SetPhysicalAddress(cec_logical_address iAddress, uint16_t iNewAddress)
705{
706 if (!m_busDevice->MyLogicalAddressContains(iAddress))
707 {
708 bool bOurAddress(m_processor->GetPhysicalAddress() == iNewAddress);
709 GetDevice(iAddress)->SetPhysicalAddress(iNewAddress);
710 if (bOurAddress)
711 {
712 /* another device reported the same physical address as ours
713 * since we don't have physical address detection yet, we'll just use the
714 * given address, increased by 0x100 for now */
715 m_processor->SetPhysicalAddress(iNewAddress + 0x100);
716 }
717 }
718}
719
720void CCECCommandHandler::HandlePoll(const cec_logical_address iInitiator, const cec_logical_address iDestination)
721{
722 CStdString strLog;
723 strLog.Format("<< POLL: %s (%x) -> %s (%x)", m_processor->ToString(iInitiator), iInitiator, m_processor->ToString(iDestination), iDestination);
724 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
725}
726
727bool CCECCommandHandler::HandleReceiveFailed(void)
728{
729 /* default = error */
730 return true;
731}
732
733bool CCECCommandHandler::TransmitImageViewOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
734{
735 cec_command command;
736 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_IMAGE_VIEW_ON);
737
738 return Transmit(command, false);
739}
740
741bool CCECCommandHandler::TransmitStandby(const cec_logical_address iInitiator, const cec_logical_address iDestination)
742{
743 cec_command command;
744 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_STANDBY);
745
746 return Transmit(command, false);
747}
748
749bool CCECCommandHandler::TransmitRequestCecVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination)
750{
751 cec_command command;
752 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_CEC_VERSION);
753
754 return Transmit(command, true, CEC_OPCODE_CEC_VERSION);
755}
756
757bool CCECCommandHandler::TransmitRequestMenuLanguage(const cec_logical_address iInitiator, const cec_logical_address iDestination)
758{
759 cec_command command;
760 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GET_MENU_LANGUAGE);
761
762 return Transmit(command, true, CEC_OPCODE_SET_MENU_LANGUAGE);
763}
764
765bool CCECCommandHandler::TransmitRequestOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination)
766{
767 cec_command command;
768 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_OSD_NAME);
769
770 return Transmit(command, true, CEC_OPCODE_SET_OSD_NAME);
771}
772
773bool CCECCommandHandler::TransmitRequestPhysicalAddress(const cec_logical_address iInitiator, const cec_logical_address iDestination)
774{
775 cec_command command;
776 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_PHYSICAL_ADDRESS);
777
778 return Transmit(command, true, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
779}
780
781bool CCECCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination)
782{
783 cec_command command;
784 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
785
786 return Transmit(command, true, CEC_OPCODE_REPORT_POWER_STATUS);
787}
788
789bool CCECCommandHandler::TransmitRequestVendorId(const cec_logical_address iInitiator, const cec_logical_address iDestination)
790{
791 cec_command command;
792 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
793
794 return Transmit(command, true, CEC_OPCODE_DEVICE_VENDOR_ID);
795}
796
797bool CCECCommandHandler::TransmitActiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
798{
799 cec_command command;
800 cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
801 command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
802 command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
803
804 return Transmit(command, false);
805}
806
807bool CCECCommandHandler::TransmitCECVersion(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_version cecVersion)
808{
809 cec_command command;
810 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_CEC_VERSION);
811 command.parameters.PushBack((uint8_t)cecVersion);
812
813 return Transmit(command, false);
814}
815
816bool CCECCommandHandler::TransmitInactiveSource(const cec_logical_address iInitiator, uint16_t iPhysicalAddress)
817{
818 cec_command command;
819 cec_command::Format(command, iInitiator, CECDEVICE_TV, CEC_OPCODE_INACTIVE_SOURCE);
820 command.parameters.PushBack((iPhysicalAddress >> 8) & 0xFF);
821 command.parameters.PushBack(iPhysicalAddress & 0xFF);
822
823 return Transmit(command, false);
824}
825
826bool CCECCommandHandler::TransmitMenuState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_menu_state menuState)
827{
828 cec_command command;
829 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_MENU_STATUS);
830 command.parameters.PushBack((uint8_t)menuState);
831
832 return Transmit(command, false);
833}
834
835bool CCECCommandHandler::TransmitOSDName(const cec_logical_address iInitiator, const cec_logical_address iDestination, CStdString strDeviceName)
836{
837 cec_command command;
838 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_NAME);
839 for (unsigned int iPtr = 0; iPtr < strDeviceName.length(); iPtr++)
840 command.parameters.PushBack(strDeviceName.at(iPtr));
841
842 return Transmit(command, false);
843}
844
845bool CCECCommandHandler::TransmitOSDString(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_display_control duration, const char *strMessage)
846{
847 cec_command command;
848 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_OSD_STRING);
849 command.parameters.PushBack((uint8_t)duration);
850
851 unsigned int iLen = strlen(strMessage);
852 if (iLen > 13) iLen = 13;
853
854 for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
855 command.parameters.PushBack(strMessage[iPtr]);
856
857 return Transmit(command, false);
858}
859
860bool CCECCommandHandler::TransmitPhysicalAddress(const cec_logical_address iInitiator, uint16_t iPhysicalAddress, cec_device_type type)
861{
862 cec_command command;
863 cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
864 command.parameters.PushBack((uint8_t) ((iPhysicalAddress >> 8) & 0xFF));
865 command.parameters.PushBack((uint8_t) (iPhysicalAddress & 0xFF));
866 command.parameters.PushBack((uint8_t) (type));
867
868 return Transmit(command, false);
869}
870
871bool CCECCommandHandler::TransmitPoll(const cec_logical_address iInitiator, const cec_logical_address iDestination)
872{
873 cec_command command;
874 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_NONE);
875
876 return Transmit(command, false);
877}
878
879bool CCECCommandHandler::TransmitPowerState(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_power_status state)
880{
881 cec_command command;
882 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_POWER_STATUS);
883 command.parameters.PushBack((uint8_t) state);
884
885 return Transmit(command, false);
886}
887
888bool CCECCommandHandler::TransmitVendorID(const cec_logical_address iInitiator, uint64_t iVendorId)
889{
890 cec_command command;
891 cec_command::Format(command, iInitiator, CECDEVICE_BROADCAST, CEC_OPCODE_DEVICE_VENDOR_ID);
892
893 command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 16) & 0xFF));
894 command.parameters.PushBack((uint8_t) (((uint64_t)iVendorId >> 8) & 0xFF));
895 command.parameters.PushBack((uint8_t) ((uint64_t)iVendorId & 0xFF));
896
897 return Transmit(command, false);
898}
899
900bool CCECCommandHandler::TransmitAudioStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, uint8_t state)
901{
902 cec_command command;
903 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_REPORT_AUDIO_STATUS);
904 command.parameters.PushBack(state);
905
906 return Transmit(command, false);
907}
908
909bool CCECCommandHandler::TransmitSetSystemAudioMode(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state)
910{
911 cec_command command;
912 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SET_SYSTEM_AUDIO_MODE);
913 command.parameters.PushBack((uint8_t)state);
914
915 return Transmit(command, false);
916}
917
918bool CCECCommandHandler::TransmitSystemAudioModeStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_system_audio_status state)
919{
920 cec_command command;
921 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS);
922 command.parameters.PushBack((uint8_t)state);
923
924 return Transmit(command, false);
925}
926
927bool CCECCommandHandler::TransmitDeckStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_deck_info state)
928{
929 cec_command command;
930 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_DECK_STATUS);
931 command.PushBack((uint8_t)state);
932
933 return Transmit(command, false);
934}
935
936bool CCECCommandHandler::TransmitKeypress(const cec_logical_address iInitiator, const cec_logical_address iDestination, cec_user_control_code key, bool bWait /* = true */)
937{
938 cec_command command;
939 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_PRESSED);
940 command.parameters.PushBack((uint8_t)key);
941
942 return Transmit(command, bWait);
943}
944
945bool CCECCommandHandler::TransmitKeyRelease(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWait /* = true */)
946{
947 cec_command command;
948 cec_command::Format(command, iInitiator, iDestination, CEC_OPCODE_USER_CONTROL_RELEASE);
949
950 return Transmit(command, bWait);
951}
952
953bool CCECCommandHandler::Transmit(cec_command &command, bool bExpectResponse /* = true */, cec_opcode expectedResponse /* = CEC_OPCODE_NONE */)
954{
955 bool bReturn(false);
956 MarkBusy();
957 command.transmit_timeout = m_iTransmitTimeout;
958
959 {
960 uint8_t iTries(0), iMaxTries(command.opcode == CEC_OPCODE_NONE ? 1 : m_iTransmitRetries + 1);
961 CLockObject writeLock(&m_processor->m_transmitMutex);
962 CLockObject receiveLock(&m_receiveMutex);
963 ++m_iUseCounter;
964 while (!bReturn && ++iTries <= iMaxTries)
965 {
966 m_expectedResponse = expectedResponse;
967 if (m_processor->Transmit(command))
968 {
969 m_processor->AddLog(CEC_LOG_DEBUG, "command transmitted");
970 bReturn = bExpectResponse ?
971 m_condition.Wait(&m_receiveMutex, m_iTransmitWait) :
972 true;
973 }
974 }
975 --m_iUseCounter;
976 }
977
978 MarkReady();
979 return bReturn;
980}
981
982bool CCECCommandHandler::ActivateSource(void)
983{
984 if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
985 {
986 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
987 primary->SetPowerStatus(CEC_POWER_STATUS_ON);
988 primary->SetMenuState(CEC_MENU_STATE_ACTIVATED);
989
990 if (m_processor->GetPrimaryDevice()->GetPhysicalAddress(false) != 0xffff)
991 {
992 m_processor->SetActiveSource();
993 primary->TransmitMenuState(m_busDevice->GetLogicalAddress());
994 m_bHandlerInited = true;
995 }
996 }
997 return true;
998}
999
1000void CCECCommandHandler::MarkBusy(void)
1001{
1002 CLockObject receiveLock(&m_receiveMutex);
1003 ++m_iUseCounter;
1004}
1005
1006bool CCECCommandHandler::MarkReady(void)
1007{
1008 CLockObject receiveLock(&m_receiveMutex);
1009 return m_iUseCounter > 0 ? (--m_iUseCounter == 0) : true;
1010}
1011
1012bool CCECCommandHandler::InUse(void)
1013{
1014 CLockObject receiveLock(&m_receiveMutex);
1015 return m_iUseCounter > 0;
1016}
libcec Piment Noir Debian package repository