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