win32: removed unneeded afxres.h include in the resource files, which is not present...
[deb_libcec.git] / src / lib / CECProcessor.cpp
1 /*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33 #include "CECProcessor.h"
34
35 #include "AdapterCommunication.h"
36 #include "devices/CECBusDevice.h"
37 #include "devices/CECAudioSystem.h"
38 #include "devices/CECPlaybackDevice.h"
39 #include "devices/CECRecordingDevice.h"
40 #include "devices/CECTuner.h"
41 #include "devices/CECTV.h"
42 #include "implementations/CECCommandHandler.h"
43 #include "LibCEC.h"
44 #include "util/StdString.h"
45 #include "platform/timeutils.h"
46
47 using namespace CEC;
48 using namespace std;
49
50 CCECProcessor::CCECProcessor(CLibCEC *controller, CAdapterCommunication *serComm, const char *strDeviceName, cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS*/) :
51 m_bStarted(false),
52 m_strDeviceName(strDeviceName),
53 m_communication(serComm),
54 m_controller(controller),
55 m_bMonitor(false)
56 {
57 m_logicalAddresses.clear();
58 m_logicalAddresses.set(iLogicalAddress);
59 m_types.clear();
60 for (int iPtr = 0; iPtr < 16; iPtr++)
61 m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, iPtr == iLogicalAddress ? iPhysicalAddress : 0);
62 }
63
64 CCECProcessor::CCECProcessor(CLibCEC *controller, CAdapterCommunication *serComm, const char *strDeviceName, const cec_device_type_list &types) :
65 m_bStarted(false),
66 m_strDeviceName(strDeviceName),
67 m_types(types),
68 m_communication(serComm),
69 m_controller(controller),
70 m_bMonitor(false)
71 {
72 m_logicalAddresses.clear();
73 for (int iPtr = 0; iPtr < 16; iPtr++)
74 {
75 switch(iPtr)
76 {
77 case CECDEVICE_AUDIOSYSTEM:
78 m_busDevices[iPtr] = new CCECAudioSystem(this, (cec_logical_address) iPtr, 0xFFFF);
79 break;
80 case CECDEVICE_PLAYBACKDEVICE1:
81 case CECDEVICE_PLAYBACKDEVICE2:
82 case CECDEVICE_PLAYBACKDEVICE3:
83 m_busDevices[iPtr] = new CCECPlaybackDevice(this, (cec_logical_address) iPtr, 0xFFFF);
84 break;
85 case CECDEVICE_RECORDINGDEVICE1:
86 case CECDEVICE_RECORDINGDEVICE2:
87 case CECDEVICE_RECORDINGDEVICE3:
88 m_busDevices[iPtr] = new CCECRecordingDevice(this, (cec_logical_address) iPtr, 0xFFFF);
89 break;
90 case CECDEVICE_TUNER1:
91 case CECDEVICE_TUNER2:
92 case CECDEVICE_TUNER3:
93 case CECDEVICE_TUNER4:
94 m_busDevices[iPtr] = new CCECTuner(this, (cec_logical_address) iPtr, 0xFFFF);
95 break;
96 case CECDEVICE_TV:
97 m_busDevices[iPtr] = new CCECTV(this, (cec_logical_address) iPtr, 0);
98 break;
99 default:
100 m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, 0xFFFF);
101 break;
102 }
103 }
104 }
105
106 CCECProcessor::~CCECProcessor(void)
107 {
108 m_startCondition.Broadcast();
109 StopThread();
110 m_communication = NULL;
111 m_controller = NULL;
112 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
113 delete m_busDevices[iPtr];
114 }
115
116 bool CCECProcessor::Start(void)
117 {
118 CLockObject lock(&m_mutex);
119 if (!m_communication || !m_communication->IsOpen())
120 {
121 m_controller->AddLog(CEC_LOG_ERROR, "connection is closed");
122 return false;
123 }
124
125 if (CreateThread())
126 {
127 if (!m_startCondition.Wait(&m_mutex) || !m_bStarted)
128 {
129 m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
130 return false;
131 }
132 return true;
133 }
134 else
135 m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
136
137 return false;
138 }
139
140 bool CCECProcessor::TryLogicalAddress(cec_logical_address address, unsigned int iIndex)
141 {
142 const char *strLabel = CCECCommandHandler::ToString(address);
143 CStdString strLog;
144 strLog.Format("trying logical address '%s'", strLabel);
145 AddLog(CEC_LOG_DEBUG, strLog);
146
147 SetAckMask(0x1 << address);
148 if (!m_busDevices[address]->TransmitPoll(address))
149 {
150 strLog.Format("using logical address '%s'", strLabel);
151 AddLog(CEC_LOG_NOTICE, strLog);
152
153 /* only set our OSD name and active source for the primary device */
154 if (m_logicalAddresses.empty())
155 {
156 m_busDevices[address]->m_strDeviceName = m_strDeviceName;
157 m_busDevices[address]->m_bActiveSource = true;
158 }
159 m_busDevices[address]->m_powerStatus = CEC_POWER_STATUS_STANDBY;
160 m_busDevices[address]->m_cecVersion = CEC_VERSION_1_3A;
161 m_logicalAddresses.set(address);
162
163 // TODO
164 m_busDevices[address]->SetPhysicalAddress((uint16_t)CEC_DEFAULT_PHYSICAL_ADDRESS + ((uint16_t)iIndex * 0x100));
165
166 return true;
167 }
168
169 strLog.Format("logical address '%s' already taken", strLabel);
170 AddLog(CEC_LOG_DEBUG, strLog);
171 return false;
172 }
173
174 bool CCECProcessor::FindLogicalAddressRecordingDevice(unsigned int iIndex)
175 {
176 AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
177 return TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1, iIndex) ||
178 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2, iIndex) ||
179 TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3, iIndex);
180 }
181
182 bool CCECProcessor::FindLogicalAddressTuner(unsigned int iIndex)
183 {
184 AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
185 return TryLogicalAddress(CECDEVICE_TUNER1, iIndex) ||
186 TryLogicalAddress(CECDEVICE_TUNER2, iIndex) ||
187 TryLogicalAddress(CECDEVICE_TUNER3, iIndex) ||
188 TryLogicalAddress(CECDEVICE_TUNER4, iIndex);
189 }
190
191 bool CCECProcessor::FindLogicalAddressPlaybackDevice(unsigned int iIndex)
192 {
193 AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
194 return TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1, iIndex) ||
195 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2, iIndex) ||
196 TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3, iIndex);
197 }
198
199 bool CCECProcessor::FindLogicalAddressAudioSystem(unsigned int iIndex)
200 {
201 AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audio'");
202 return TryLogicalAddress(CECDEVICE_AUDIOSYSTEM, iIndex);
203 }
204
205 bool CCECProcessor::FindLogicalAddresses(void)
206 {
207 bool bReturn(true);
208 m_logicalAddresses.clear();
209 CStdString strLog;
210
211 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
212 {
213 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
214 continue;
215
216 strLog.Format("%s - device %d: type %d", __FUNCTION__, iPtr, m_types.types[iPtr]);
217 AddLog(CEC_LOG_DEBUG, strLog);
218
219 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
220 bReturn &= FindLogicalAddressRecordingDevice(iPtr);
221 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
222 bReturn &= FindLogicalAddressTuner(iPtr);
223 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
224 bReturn &= FindLogicalAddressPlaybackDevice(iPtr);
225 if (m_types.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
226 bReturn &= FindLogicalAddressAudioSystem(iPtr);
227 }
228
229 return bReturn;
230 }
231
232 void *CCECProcessor::Process(void)
233 {
234 bool bParseFrame(false);
235 cec_command command;
236 CCECAdapterMessage msg;
237
238 {
239 if (m_logicalAddresses.empty() && !FindLogicalAddresses())
240 {
241 CLockObject lock(&m_mutex);
242 m_controller->AddLog(CEC_LOG_ERROR, "could not detect our logical addressed");
243 m_startCondition.Signal();
244 return NULL;
245 }
246
247 SetAckMask(m_logicalAddresses.ackmask());
248
249 {
250 CLockObject lock(&m_mutex);
251 m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
252 m_bStarted = true;
253 m_startCondition.Signal();
254 }
255 }
256
257 while (!IsStopped())
258 {
259 command.clear();
260 msg.clear();
261
262 {
263 CLockObject lock(&m_mutex);
264 if (m_commandBuffer.Pop(command))
265 {
266 bParseFrame = true;
267 }
268 else if (m_communication->IsOpen() && m_communication->Read(msg, 50))
269 {
270 m_controller->AddLog(msg.is_error() ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
271 if ((bParseFrame = (ParseMessage(msg) && !IsStopped())) == true)
272 command = m_currentframe;
273 }
274 }
275
276 if (bParseFrame)
277 ParseCommand(command);
278 bParseFrame = false;
279
280 Sleep(5);
281
282 m_controller->CheckKeypressTimeout();
283
284 for (unsigned int iDevicePtr = 0; iDevicePtr < 16; iDevicePtr++)
285 m_busDevices[iDevicePtr]->PollVendorId();
286
287 Sleep(5);
288 }
289
290 return NULL;
291 }
292
293 bool CCECProcessor::SetActiveSource(cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
294 {
295 bool bReturn(false);
296
297 if (!IsRunning())
298 return bReturn;
299
300 cec_logical_address addr = m_logicalAddresses.primary;
301
302 if (type != CEC_DEVICE_TYPE_RESERVED)
303 {
304 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
305 {
306 if (m_logicalAddresses[iPtr] && m_busDevices[iPtr]->m_type == type)
307 {
308 addr = (cec_logical_address) iPtr;
309 break;
310 }
311 }
312 }
313
314 return SetStreamPath(m_busDevices[addr]->GetPhysicalAddress());
315 }
316
317 bool CCECProcessor::SetActiveView(void)
318 {
319 return SetActiveSource();
320 }
321
322 bool CCECProcessor::SetStreamPath(uint16_t iStreamPath)
323 {
324 bool bReturn(false);
325
326 CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
327 if (device)
328 {
329 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
330 m_busDevices[iPtr]->m_bActiveSource = false;
331
332 device->m_bActiveSource = true;
333 device->m_powerStatus = CEC_POWER_STATUS_ON;
334
335 if (m_logicalAddresses.isset(device->m_iLogicalAddress))
336 bReturn = device->TransmitActiveSource();
337 else
338 bReturn = true;
339 }
340
341 return bReturn;
342 }
343
344 bool CCECProcessor::SetInactiveView(void)
345 {
346 if (!IsRunning())
347 return false;
348
349 if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
350 return m_busDevices[m_logicalAddresses.primary]->TransmitInactiveView();
351 return false;
352 }
353
354 void CCECProcessor::LogOutput(const cec_command &data)
355 {
356 CStdString strTx;
357 strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
358 if (data.opcode_set)
359 strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
360
361 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
362 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
363 m_controller->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
364 }
365
366 bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
367 {
368 if (m_logicalAddresses.primary != iLogicalAddress)
369 {
370 CStdString strLog;
371 strLog.Format("<< setting primary logical address to %1x", iLogicalAddress);
372 m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
373 m_logicalAddresses.primary = iLogicalAddress;
374 m_logicalAddresses.set(iLogicalAddress);
375 return SetAckMask(m_logicalAddresses.ackmask());
376 }
377
378 return true;
379 }
380
381 bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress)
382 {
383 if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
384 {
385 m_busDevices[m_logicalAddresses.primary]->SetPhysicalAddress(iPhysicalAddress);
386 return SetActiveView();
387 }
388 return false;
389 }
390
391 bool CCECProcessor::SwitchMonitoring(bool bEnable)
392 {
393 CStdString strLog;
394 strLog.Format("== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
395 m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
396
397 m_bMonitor = bEnable;
398 if (bEnable)
399 return SetAckMask(0);
400 else
401 return SetAckMask(m_logicalAddresses.ackmask());
402 }
403
404 bool CCECProcessor::PollDevice(cec_logical_address iAddress)
405 {
406 if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress])
407 return m_busDevices[m_logicalAddresses.primary]->TransmitPoll(iAddress);
408 return false;
409 }
410
411
412 CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
413 {
414 CCECBusDevice *device = NULL;
415
416 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
417 {
418 if (m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
419 {
420 device = m_busDevices[iPtr];
421 break;
422 }
423 }
424
425 return device;
426 }
427
428 cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress)
429 {
430 return m_busDevices[iAddress]->GetCecVersion();
431 }
432
433 bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
434 {
435 if (m_busDevices[iAddress])
436 {
437 *language = m_busDevices[iAddress]->GetMenuLanguage();
438 return (strcmp(language->language, "???") != 0);
439 }
440 return false;
441 }
442
443 uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
444 {
445 if (m_busDevices[iAddress])
446 return m_busDevices[iAddress]->GetVendorId();
447 return false;
448 }
449
450 cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress)
451 {
452 if (m_busDevices[iAddress])
453 return m_busDevices[iAddress]->GetPowerStatus();
454 return CEC_POWER_STATUS_UNKNOWN;
455 }
456
457 bool CCECProcessor::Transmit(const cec_command &data)
458 {
459 bool bReturn(false);
460 LogOutput(data);
461
462 CCECAdapterMessage *output = new CCECAdapterMessage(data);
463 bReturn = Transmit(output);
464 delete output;
465
466 return bReturn;
467 }
468
469 bool CCECProcessor::Transmit(CCECAdapterMessage *output)
470 {
471 bool bReturn(false);
472 CLockObject lock(&m_mutex);
473 {
474 CLockObject msgLock(&output->mutex);
475 if (!m_communication || !m_communication->Write(output))
476 return bReturn;
477 else
478 {
479 output->condition.Wait(&output->mutex);
480 if (output->state != ADAPTER_MESSAGE_STATE_SENT)
481 {
482 m_controller->AddLog(CEC_LOG_ERROR, "command was not sent");
483 return bReturn;
484 }
485 }
486
487 if (output->transmit_timeout > 0)
488 {
489 if ((bReturn = WaitForTransmitSucceeded(output->size(), output->transmit_timeout)) == false)
490 m_controller->AddLog(CEC_LOG_DEBUG, "did not receive ack");
491 }
492 else
493 bReturn = true;
494 }
495
496 return bReturn;
497 }
498
499 void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, ECecAbortReason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
500 {
501 m_controller->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
502
503 cec_command command;
504 // TODO
505 cec_command::format(command, m_logicalAddresses.primary, address, CEC_OPCODE_FEATURE_ABORT);
506 command.parameters.push_back((uint8_t)opcode);
507 command.parameters.push_back((uint8_t)reason);
508
509 Transmit(command);
510 }
511
512 bool CCECProcessor::WaitForTransmitSucceeded(uint8_t iLength, uint32_t iTimeout /* = 1000 */)
513 {
514 bool bError(false);
515 bool bTransmitSucceeded(false);
516 uint8_t iPacketsLeft(iLength / 4);
517
518 int64_t iNow = GetTimeMs();
519 int64_t iTargetTime = iNow + (uint64_t) iTimeout;
520
521 while (!bTransmitSucceeded && !bError && (iTimeout == 0 || iNow < iTargetTime))
522 {
523 CCECAdapterMessage msg;
524
525 if (!m_communication->Read(msg, iTimeout > 0 ? (int32_t)(iTargetTime - iNow) : 1000))
526 {
527 iNow = GetTimeMs();
528 continue;
529 }
530
531 if ((bError = msg.is_error()) == false)
532 {
533 m_controller->AddLog(bError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
534
535 switch(msg.message())
536 {
537 case MSGCODE_COMMAND_ACCEPTED:
538 if (iPacketsLeft > 0)
539 iPacketsLeft--;
540 break;
541 case MSGCODE_TRANSMIT_SUCCEEDED:
542 bTransmitSucceeded = (iPacketsLeft == 0);
543 bError = !bTransmitSucceeded;
544 break;
545 default:
546 if (ParseMessage(msg))
547 m_commandBuffer.Push(m_currentframe);
548 }
549
550 iNow = GetTimeMs();
551 }
552 }
553
554 return bTransmitSucceeded && !bError;
555 }
556
557 bool CCECProcessor::ParseMessage(const CCECAdapterMessage &msg)
558 {
559 bool bEom = false;
560
561 if (msg.empty())
562 return bEom;
563
564 switch(msg.message())
565 {
566 case MSGCODE_FRAME_START:
567 {
568 m_currentframe.clear();
569 if (msg.size() >= 2)
570 {
571 m_currentframe.initiator = msg.initiator();
572 m_currentframe.destination = msg.destination();
573 m_currentframe.ack = msg.ack();
574 m_currentframe.eom = msg.eom();
575 }
576 }
577 break;
578 case MSGCODE_FRAME_DATA:
579 {
580 if (msg.size() >= 2)
581 {
582 m_currentframe.push_back(msg[1]);
583 m_currentframe.eom = msg.eom();
584 }
585 bEom = msg.eom();
586 }
587 break;
588 default:
589 break;
590 }
591
592 return bEom;
593 }
594
595 void CCECProcessor::ParseCommand(cec_command &command)
596 {
597 CStdString dataStr;
598 dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode);
599 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
600 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
601 m_controller->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
602
603 if (!m_bMonitor)
604 m_busDevices[(uint8_t)command.initiator]->HandleCommand(command);
605 }
606
607 uint16_t CCECProcessor::GetPhysicalAddress(void) const
608 {
609 if (!m_logicalAddresses.empty() && m_busDevices[m_logicalAddresses.primary])
610 return m_busDevices[m_logicalAddresses.primary]->GetPhysicalAddress();
611 return false;
612 }
613
614 void CCECProcessor::SetCurrentButton(cec_user_control_code iButtonCode)
615 {
616 m_controller->SetCurrentButton(iButtonCode);
617 }
618
619 void CCECProcessor::AddCommand(const cec_command &command)
620 {
621 m_controller->AddCommand(command);
622 }
623
624 void CCECProcessor::AddKey(cec_keypress &key)
625 {
626 m_controller->AddKey(key);
627 }
628
629 void CCECProcessor::AddKey(void)
630 {
631 m_controller->AddKey();
632 }
633
634 void CCECProcessor::AddLog(cec_log_level level, const CStdString &strMessage)
635 {
636 m_controller->AddLog(level, strMessage);
637 }
638
639 bool CCECProcessor::SetAckMask(uint16_t iMask)
640 {
641 bool bReturn(false);
642 CStdString strLog;
643 strLog.Format("setting ackmask to %2x", iMask);
644 m_controller->AddLog(CEC_LOG_DEBUG, strLog.c_str());
645
646 CCECAdapterMessage *output = new CCECAdapterMessage;
647
648 output->push_back(MSGSTART);
649 output->push_escaped(MSGCODE_SET_ACK_MASK);
650 output->push_escaped(iMask >> 8);
651 output->push_escaped((uint8_t)iMask);
652 output->push_back(MSGEND);
653
654 if ((bReturn = Transmit(output)) == false)
655 m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
656
657 delete output;
658
659 return bReturn;
660 }