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