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