cec: added PollDevice()/cec_poll_device()
[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 "LibCEC.h"
38 #include "util/StdString.h"
39 #include "platform/timeutils.h"
40
41 using namespace CEC;
42 using namespace std;
43
44 CCECProcessor::CCECProcessor(CLibCEC *controller, CAdapterCommunication *serComm, const char *strDeviceName, cec_logical_address iLogicalAddress /* = CECDEVICE_PLAYBACKDEVICE1 */, uint16_t iPhysicalAddress /* = CEC_DEFAULT_PHYSICAL_ADDRESS*/) :
45 m_iLogicalAddress(iLogicalAddress),
46 m_strDeviceName(strDeviceName),
47 m_communication(serComm),
48 m_controller(controller),
49 m_bMonitor(false)
50 {
51 for (int iPtr = 0; iPtr < 16; iPtr++)
52 m_busDevices[iPtr] = new CCECBusDevice(this, (cec_logical_address) iPtr, iPtr == iLogicalAddress ? iPhysicalAddress : 0);
53 }
54
55 CCECProcessor::~CCECProcessor(void)
56 {
57 m_startCondition.Broadcast();
58 StopThread();
59 m_communication = NULL;
60 m_controller = NULL;
61 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
62 delete m_busDevices[iPtr];
63 }
64
65 bool CCECProcessor::Start(void)
66 {
67 CLockObject lock(&m_mutex);
68 if (!m_communication || !m_communication->IsOpen())
69 {
70 m_controller->AddLog(CEC_LOG_ERROR, "connection is closed");
71 return false;
72 }
73
74 if (CreateThread())
75 {
76 if (!m_startCondition.Wait(&m_mutex))
77 {
78 m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
79 return false;
80 }
81 return true;
82 }
83 else
84 m_controller->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
85
86 return false;
87 }
88
89 void *CCECProcessor::Process(void)
90 {
91 cec_command command;
92 CCECAdapterMessage msg;
93
94 SetAckMask(0x1 << (uint8_t)m_iLogicalAddress);
95
96 {
97 CLockObject lock(&m_mutex);
98 m_controller->AddLog(CEC_LOG_DEBUG, "processor thread started");
99 m_startCondition.Signal();
100 }
101
102 while (!IsStopped())
103 {
104 bool bParseFrame(false);
105 command.clear();
106 msg.clear();
107
108 {
109 CLockObject lock(&m_mutex);
110 if (m_communication->IsOpen() && m_communication->Read(msg, 50))
111 {
112 m_controller->AddLog(msg.is_error() ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
113 bParseFrame = ParseMessage(msg) && !IsStopped();
114 }
115
116 if (bParseFrame)
117 command = m_currentframe;
118 }
119
120 if (bParseFrame)
121 ParseCommand(command);
122
123 Sleep(5);
124
125 m_controller->CheckKeypressTimeout();
126
127 for (unsigned int iDevicePtr = 0; iDevicePtr < 16; iDevicePtr++)
128 m_busDevices[iDevicePtr]->PollVendorId();
129
130 Sleep(5);
131 }
132
133 return NULL;
134 }
135
136 bool CCECProcessor::SetActiveView(void)
137 {
138 if (!IsRunning())
139 return false;
140
141 if (m_iLogicalAddress != CECDEVICE_UNKNOWN && m_busDevices[m_iLogicalAddress])
142 return m_busDevices[m_iLogicalAddress]->BroadcastActiveView();
143 return false;
144 }
145
146 bool CCECProcessor::SetInactiveView(void)
147 {
148 if (!IsRunning())
149 return false;
150
151 if (m_iLogicalAddress != CECDEVICE_UNKNOWN && m_busDevices[m_iLogicalAddress])
152 return m_busDevices[m_iLogicalAddress]->BroadcastInactiveView();
153 return false;
154 }
155
156 void CCECProcessor::LogOutput(const cec_command &data)
157 {
158 CStdString strTx;
159 strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
160 if (data.opcode_set)
161 strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
162
163 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
164 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
165 m_controller->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
166 }
167
168 bool CCECProcessor::SetLogicalAddress(cec_logical_address iLogicalAddress)
169 {
170 if (m_iLogicalAddress != iLogicalAddress)
171 {
172 CStdString strLog;
173 strLog.Format("<< setting logical address to %1x", iLogicalAddress);
174 m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
175 m_iLogicalAddress = iLogicalAddress;
176 return SetAckMask(0x1 << (uint8_t)m_iLogicalAddress);
177 }
178
179 return true;
180 }
181
182 bool CCECProcessor::SetPhysicalAddress(uint16_t iPhysicalAddress)
183 {
184 if (m_iLogicalAddress != CECDEVICE_UNKNOWN && m_busDevices[m_iLogicalAddress])
185 {
186 m_busDevices[m_iLogicalAddress]->SetPhysicalAddress(iPhysicalAddress);
187 return m_busDevices[m_iLogicalAddress]->BroadcastActiveView();
188 }
189 return false;
190 }
191
192 bool CCECProcessor::SwitchMonitoring(bool bEnable)
193 {
194 CStdString strLog;
195 strLog.Format("== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
196 m_controller->AddLog(CEC_LOG_NOTICE, strLog.c_str());
197
198 m_bMonitor = bEnable;
199 if (bEnable)
200 return SetAckMask(0);
201 else
202 return SetAckMask(0x1 << (uint8_t)m_iLogicalAddress);
203 }
204
205 bool CCECProcessor::PollDevice(cec_logical_address iAddress)
206 {
207 if (iAddress != CECDEVICE_UNKNOWN && m_busDevices[iAddress])
208 return m_busDevices[iAddress]->PollDevice();
209 return false;
210 }
211
212 cec_version CCECProcessor::GetDeviceCecVersion(cec_logical_address iAddress)
213 {
214 return m_busDevices[iAddress]->GetCecVersion();
215 }
216
217 bool CCECProcessor::GetDeviceMenuLanguage(cec_logical_address iAddress, cec_menu_language *language)
218 {
219 if (m_busDevices[iAddress])
220 {
221 *language = m_busDevices[iAddress]->GetMenuLanguage();
222 return (strcmp(language->language, "???") != 0);
223 }
224 return false;
225 }
226
227 uint64_t CCECProcessor::GetDeviceVendorId(cec_logical_address iAddress)
228 {
229 if (m_busDevices[iAddress])
230 return m_busDevices[iAddress]->GetVendorId();
231 return false;
232 }
233
234 cec_power_status CCECProcessor::GetDevicePowerStatus(cec_logical_address iAddress)
235 {
236 if (m_busDevices[iAddress])
237 return m_busDevices[iAddress]->GetPowerStatus();
238 return CEC_POWER_STATUS_UNKNOWN;
239 }
240
241 bool CCECProcessor::Transmit(const cec_command &data)
242 {
243 bool bReturn(false);
244 LogOutput(data);
245
246 CCECAdapterMessage *output = new CCECAdapterMessage(data);
247 bReturn = Transmit(output);
248 delete output;
249
250 return bReturn;
251 }
252
253 bool CCECProcessor::Transmit(CCECAdapterMessage *output)
254 {
255 bool bReturn(false);
256 CLockObject lock(&m_mutex);
257 {
258 CLockObject msgLock(&output->mutex);
259 if (!m_communication || !m_communication->Write(output))
260 return bReturn;
261 else
262 {
263 output->condition.Wait(&output->mutex);
264 if (output->state != ADAPTER_MESSAGE_STATE_SENT)
265 {
266 m_controller->AddLog(CEC_LOG_ERROR, "command was not sent");
267 return bReturn;
268 }
269 }
270
271 if (output->transmit_timeout > 0)
272 {
273 if ((bReturn = WaitForTransmitSucceeded(output->size(), output->transmit_timeout)) == false)
274 m_controller->AddLog(CEC_LOG_ERROR, "did not receive ack");
275 }
276 else
277 bReturn = true;
278 }
279
280 return bReturn;
281 }
282
283 void CCECProcessor::TransmitAbort(cec_logical_address address, cec_opcode opcode, ECecAbortReason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
284 {
285 m_controller->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
286
287 cec_command command;
288 cec_command::format(command, m_iLogicalAddress, address, CEC_OPCODE_FEATURE_ABORT);
289 command.parameters.push_back((uint8_t)opcode);
290 command.parameters.push_back((uint8_t)reason);
291
292 Transmit(command);
293 }
294
295 bool CCECProcessor::WaitForTransmitSucceeded(uint8_t iLength, uint32_t iTimeout /* = 1000 */)
296 {
297 bool bError(false);
298 bool bTransmitSucceeded(false);
299 uint8_t iPacketsLeft(iLength / 4);
300
301 int64_t iNow = GetTimeMs();
302 int64_t iTargetTime = iNow + (uint64_t) iTimeout;
303
304 while (!bTransmitSucceeded && !bError && (iTimeout == 0 || iNow < iTargetTime))
305 {
306 CCECAdapterMessage msg;
307
308 if (!m_communication->Read(msg, iTimeout > 0 ? (int32_t)(iTargetTime - iNow) : 1000))
309 {
310 iNow = GetTimeMs();
311 continue;
312 }
313
314 if ((bError = msg.is_error()) == false)
315 {
316 m_controller->AddLog(bError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
317
318 switch(msg.message())
319 {
320 case MSGCODE_COMMAND_ACCEPTED:
321 if (iPacketsLeft > 0)
322 iPacketsLeft--;
323 break;
324 case MSGCODE_TRANSMIT_SUCCEEDED:
325 bTransmitSucceeded = (iPacketsLeft == 0);
326 bError = !bTransmitSucceeded;
327 break;
328 default:
329 ParseMessage(msg);
330 }
331
332 iNow = GetTimeMs();
333 }
334 }
335
336 return bTransmitSucceeded && !bError;
337 }
338
339 bool CCECProcessor::ParseMessage(const CCECAdapterMessage &msg)
340 {
341 bool bEom = false;
342
343 if (msg.empty())
344 return bEom;
345
346 switch(msg.message())
347 {
348 case MSGCODE_FRAME_START:
349 {
350 m_currentframe.clear();
351 if (msg.size() >= 2)
352 {
353 m_currentframe.initiator = msg.initiator();
354 m_currentframe.destination = msg.destination();
355 m_currentframe.ack = msg.ack();
356 m_currentframe.eom = msg.eom();
357 }
358 }
359 break;
360 case MSGCODE_FRAME_DATA:
361 {
362 if (msg.size() >= 2)
363 {
364 m_currentframe.push_back(msg[1]);
365 m_currentframe.eom = msg.eom();
366 }
367 bEom = msg.eom();
368 }
369 break;
370 default:
371 break;
372 }
373
374 return bEom;
375 }
376
377 void CCECProcessor::ParseCommand(cec_command &command)
378 {
379 CStdString dataStr;
380 dataStr.Format(">> %1x%1x:%02x", command.initiator, command.destination, command.opcode);
381 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
382 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
383 m_controller->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
384
385 if (!m_bMonitor)
386 m_busDevices[(uint8_t)command.initiator]->HandleCommand(command);
387 }
388
389 uint16_t CCECProcessor::GetPhysicalAddress(void) const
390 {
391 if (m_iLogicalAddress != CECDEVICE_UNKNOWN && m_busDevices[m_iLogicalAddress])
392 return m_busDevices[m_iLogicalAddress]->GetPhysicalAddress();
393 return false;
394 }
395
396 void CCECProcessor::SetCurrentButton(cec_user_control_code iButtonCode)
397 {
398 m_controller->SetCurrentButton(iButtonCode);
399 }
400
401 void CCECProcessor::AddCommand(const cec_command &command)
402 {
403 m_controller->AddCommand(command);
404 }
405
406 void CCECProcessor::AddKey(cec_keypress &key)
407 {
408 m_controller->AddKey(key);
409 }
410
411 void CCECProcessor::AddKey(void)
412 {
413 m_controller->AddKey();
414 }
415
416 void CCECProcessor::AddLog(cec_log_level level, const CStdString &strMessage)
417 {
418 m_controller->AddLog(level, strMessage);
419 }
420
421 bool CCECProcessor::SetAckMask(uint16_t iMask)
422 {
423 bool bReturn(false);
424 CStdString strLog;
425 strLog.Format("setting ackmask to %2x", iMask);
426 m_controller->AddLog(CEC_LOG_DEBUG, strLog.c_str());
427
428 CCECAdapterMessage *output = new CCECAdapterMessage;
429
430 output->push_back(MSGSTART);
431 output->push_escaped(MSGCODE_SET_ACK_MASK);
432 output->push_escaped(iMask >> 8);
433 output->push_escaped((uint8_t)iMask);
434 output->push_back(MSGEND);
435
436 if ((bReturn = Transmit(output)) == false)
437 m_controller->AddLog(CEC_LOG_ERROR, "could not set the ackmask");
438
439 delete output;
440
441 return bReturn;
442 }