aef61b2b924f0652129de7b7688f6a62f404d393
[deb_libcec.git] / USBCECAdapterMessage.cpp
1 /*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33 #include "USBCECAdapterMessage.h"
34 #include "../LibCEC.h"
35
36 using namespace CEC;
37 using namespace PLATFORM;
38
39 CCECAdapterMessage::CCECAdapterMessage(void)
40 {
41 Clear();
42 }
43
44 CCECAdapterMessage::CCECAdapterMessage(const cec_command &command, uint8_t iLineTimeout /* = 3 */)
45 {
46 Clear();
47
48 //set ack polarity to high when transmitting to the broadcast address
49 //set ack polarity low when transmitting to any other address
50 PushBack(MSGSTART);
51 PushEscaped(MSGCODE_TRANSMIT_ACK_POLARITY);
52 if (command.destination == CECDEVICE_BROADCAST)
53 PushEscaped(CEC_TRUE);
54 else
55 PushEscaped(CEC_FALSE);
56 PushBack(MSGEND);
57
58 // add source and destination
59 PushBack(MSGSTART);
60 PushEscaped(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
61 PushBack(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
62 PushBack(MSGEND);
63
64 // add opcode
65 if (command.opcode_set == 1)
66 {
67 PushBack(MSGSTART);
68 PushEscaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
69 PushBack((uint8_t) command.opcode);
70 PushBack(MSGEND);
71
72 // add parameters
73 for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
74 {
75 PushBack(MSGSTART);
76
77 if (iPtr == command.parameters.size - 1)
78 PushEscaped( MSGCODE_TRANSMIT_EOM);
79 else
80 PushEscaped(MSGCODE_TRANSMIT);
81
82 PushEscaped(command.parameters[iPtr]);
83
84 PushBack(MSGEND);
85 }
86 }
87
88 // set timeout
89 transmit_timeout = command.transmit_timeout;
90
91 lineTimeout = iLineTimeout;
92 }
93
94 CStdString CCECAdapterMessage::ToString(void) const
95 {
96 CStdString strMsg;
97 if (Size() == 0)
98 {
99 strMsg = "empty message";
100 }
101 else
102 {
103 strMsg = ToString(Message());
104
105 switch (Message())
106 {
107 case MSGCODE_TIMEOUT_ERROR:
108 case MSGCODE_HIGH_ERROR:
109 case MSGCODE_LOW_ERROR:
110 {
111 uint32_t iLine = (Size() >= 4) ? (At(2) << 8) | At(3) : 0;
112 uint32_t iTime = (Size() >= 8) ? (At(4) << 24) | (At(5) << 16) | (At(6) << 8) | At(7) : 0;
113 strMsg.AppendFormat(" line:%u", iLine);
114 strMsg.AppendFormat(" time:%u", iTime);
115 }
116 break;
117 case MSGCODE_FRAME_START:
118 if (Size() >= 3)
119 strMsg.AppendFormat(" initiator:%1x destination:%1x ack:%s %s", Initiator(), Destination(), IsACK() ? "high" : "low", IsEOM() ? "eom" : "");
120 break;
121 case MSGCODE_FRAME_DATA:
122 if (Size() >= 3)
123 strMsg.AppendFormat(" %02x %s", At(2), IsEOM() ? "eom" : "");
124 break;
125 default:
126 for (uint8_t iPtr = 2; iPtr < Size(); iPtr++)
127 if (At(iPtr) != MSGEND)
128 strMsg.AppendFormat(" %02x", At(iPtr));
129 break;
130 }
131 }
132
133 return strMsg;
134 }
135
136 const char *CCECAdapterMessage::ToString(cec_adapter_messagecode msgCode)
137 {
138 switch (msgCode)
139 {
140 case MSGCODE_NOTHING:
141 return "NOTHING";
142 case MSGCODE_PING:
143 return "PING";
144 case MSGCODE_TIMEOUT_ERROR:
145 return "TIMEOUT";
146 case MSGCODE_HIGH_ERROR:
147 return "HIGH_ERROR";
148 case MSGCODE_LOW_ERROR:
149 return "LOW_ERROR";
150 case MSGCODE_FRAME_START:
151 return "FRAME_START";
152 case MSGCODE_FRAME_DATA:
153 return "FRAME_DATA";
154 case MSGCODE_RECEIVE_FAILED:
155 return "RECEIVE_FAILED";
156 case MSGCODE_COMMAND_ACCEPTED:
157 return "COMMAND_ACCEPTED";
158 case MSGCODE_COMMAND_REJECTED:
159 return "COMMAND_REJECTED";
160 case MSGCODE_SET_ACK_MASK:
161 return "SET_ACK_MASK";
162 case MSGCODE_TRANSMIT:
163 return "TRANSMIT";
164 case MSGCODE_TRANSMIT_EOM:
165 return "TRANSMIT_EOM";
166 case MSGCODE_TRANSMIT_IDLETIME:
167 return "TRANSMIT_IDLETIME";
168 case MSGCODE_TRANSMIT_ACK_POLARITY:
169 return "TRANSMIT_ACK_POLARITY";
170 case MSGCODE_TRANSMIT_LINE_TIMEOUT:
171 return "TRANSMIT_LINE_TIMEOUT";
172 case MSGCODE_TRANSMIT_SUCCEEDED:
173 return "TRANSMIT_SUCCEEDED";
174 case MSGCODE_TRANSMIT_FAILED_LINE:
175 return "TRANSMIT_FAILED_LINE";
176 case MSGCODE_TRANSMIT_FAILED_ACK:
177 return "TRANSMIT_FAILED_ACK";
178 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
179 return "TRANSMIT_FAILED_TIMEOUT_DATA";
180 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
181 return "TRANSMIT_FAILED_TIMEOUT_LINE";
182 case MSGCODE_FIRMWARE_VERSION:
183 return "FIRMWARE_VERSION";
184 case MSGCODE_START_BOOTLOADER:
185 return "START_BOOTLOADER";
186 case MSGCODE_FRAME_EOM:
187 return "FRAME_EOM";
188 case MSGCODE_FRAME_ACK:
189 return "FRAME_ACK";
190 case MSGCODE_GET_BUILDDATE:
191 return "GET_BUILDDATE";
192 case MSGCODE_SET_CONTROLLED:
193 return "SET_CONTROLLED";
194 case MSGCODE_GET_AUTO_ENABLED:
195 return "GET_AUTO_ENABLED";
196 case MSGCODE_SET_AUTO_ENABLED:
197 return "SET_AUTO_ENABLED";
198 case MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS:
199 return "GET_DEFAULT_LOGICAL_ADDRESS";
200 case MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS:
201 return "SET_DEFAULT_LOGICAL_ADDRESS";
202 case MSGCODE_GET_LOGICAL_ADDRESS_MASK:
203 return "GET_LOGICAL_ADDRESS_MASK";
204 case MSGCODE_SET_LOGICAL_ADDRESS_MASK:
205 return "SET_LOGICAL_ADDRESS_MASK";
206 case MSGCODE_GET_PHYSICAL_ADDRESS:
207 return "GET_PHYSICAL_ADDRESS";
208 case MSGCODE_SET_PHYSICAL_ADDRESS:
209 return "SET_PHYSICAL_ADDRESS";
210 case MSGCODE_GET_DEVICE_TYPE:
211 return "GET_DEVICE_TYPE";
212 case MSGCODE_SET_DEVICE_TYPE:
213 return "SET_DEVICE_TYPE";
214 case MSGCODE_GET_HDMI_VERSION:
215 return "GET_HDMI_VERSION";
216 case MSGCODE_SET_HDMI_VERSION:
217 return "SET_HDMI_VERSION";
218 case MSGCODE_GET_OSD_NAME:
219 return "GET_OSD_NAME";
220 case MSGCODE_SET_OSD_NAME:
221 return "SET_OSD_NAME";
222 case MSGCODE_WRITE_EEPROM:
223 return "WRITE_EEPROM";
224 default:
225 break;
226 }
227
228 return "unknown";
229 }
230
231 uint8_t CCECAdapterMessage::operator[](uint8_t pos) const
232 {
233 return pos < packet.size ? packet[pos] : 0;
234 }
235
236 uint8_t CCECAdapterMessage::At(uint8_t pos) const
237 {
238 return pos < packet.size ? packet[pos] : 0;
239 }
240
241 uint8_t CCECAdapterMessage::Size(void) const
242 {
243 return packet.size;
244 }
245
246 bool CCECAdapterMessage::IsEmpty(void) const
247 {
248 return packet.IsEmpty();
249 }
250
251 void CCECAdapterMessage::Clear(void)
252 {
253 state = ADAPTER_MESSAGE_STATE_UNKNOWN;
254 transmit_timeout = CEC_DEFAULT_TRANSMIT_TIMEOUT;
255 response.Clear();
256 packet.Clear();
257 lineTimeout = 3;
258 bNextByteIsEscaped = false;
259 }
260
261 void CCECAdapterMessage::Shift(uint8_t iShiftBy)
262 {
263 packet.Shift(iShiftBy);
264 }
265
266 void CCECAdapterMessage::Append(CCECAdapterMessage &data)
267 {
268 Append(data.packet);
269 }
270
271 void CCECAdapterMessage::Append(cec_datapacket &data)
272 {
273 for (uint8_t iPtr = 0; iPtr < data.size; iPtr++)
274 PushBack(data[iPtr]);
275 }
276
277 void CCECAdapterMessage::PushBack(uint8_t byte)
278 {
279 packet.PushBack(byte);
280 }
281
282 void CCECAdapterMessage::PushEscaped(uint8_t byte)
283 {
284 if (byte >= MSGESC)
285 {
286 PushBack(MSGESC);
287 PushBack(byte - ESCOFFSET);
288 }
289 else
290 {
291 PushBack(byte);
292 }
293 }
294
295 bool CCECAdapterMessage::PushReceivedByte(uint8_t byte)
296 {
297 if (byte == MSGSTART)
298 {
299 if (HasStartMessage())
300 {
301 CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
302 Clear();
303 }
304 PushBack(byte);
305 }
306 else
307 {
308 if (bNextByteIsEscaped)
309 {
310 PushBack(byte + (uint8_t)ESCOFFSET);
311 bNextByteIsEscaped = false;
312 }
313 else if (byte == MSGESC)
314 bNextByteIsEscaped = true;
315 else
316 PushBack(byte);
317 }
318
319 return byte == MSGEND;
320 }
321
322 cec_adapter_messagecode CCECAdapterMessage::Message(void) const
323 {
324 return packet.size >= 2 ?
325 (cec_adapter_messagecode) (packet.At(1) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
326 MSGCODE_NOTHING;
327 }
328
329 bool CCECAdapterMessage::IsTranmission(void) const
330 {
331 cec_adapter_messagecode msgCode = Message();
332 return msgCode == MSGCODE_FRAME_ACK ||
333 msgCode == MSGCODE_FRAME_DATA ||
334 msgCode == MSGCODE_FRAME_EOM ||
335 msgCode == MSGCODE_FRAME_START ||
336 msgCode == MSGCODE_HIGH_ERROR ||
337 msgCode == MSGCODE_LOW_ERROR ||
338 msgCode == MSGCODE_RECEIVE_FAILED ||
339 msgCode == MSGCODE_TRANSMIT_ACK_POLARITY ||
340 msgCode == MSGCODE_TRANSMIT_EOM ||
341 msgCode == MSGCODE_TRANSMIT_FAILED_ACK ||
342 msgCode == MSGCODE_TRANSMIT_FAILED_LINE ||
343 msgCode == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
344 msgCode == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE ||
345 msgCode == MSGCODE_TRANSMIT_LINE_TIMEOUT ||
346 msgCode == MSGCODE_TRANSMIT_SUCCEEDED;
347 }
348
349 bool CCECAdapterMessage::IsEOM(void) const
350 {
351 return packet.size >= 2 ?
352 (packet.At(1) & MSGCODE_FRAME_EOM) != 0 :
353 false;
354 }
355
356 bool CCECAdapterMessage::IsACK(void) const
357 {
358 return packet.size >= 2 ?
359 (packet.At(1) & MSGCODE_FRAME_ACK) != 0 :
360 false;
361 }
362
363 bool CCECAdapterMessage::IsError(void) const
364 {
365 cec_adapter_messagecode code = Message();
366 return (code == MSGCODE_HIGH_ERROR ||
367 code == MSGCODE_LOW_ERROR ||
368 code == MSGCODE_RECEIVE_FAILED ||
369 code == MSGCODE_COMMAND_REJECTED ||
370 code == MSGCODE_TRANSMIT_LINE_TIMEOUT ||
371 code == MSGCODE_TRANSMIT_FAILED_LINE ||
372 code == MSGCODE_TRANSMIT_FAILED_ACK ||
373 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
374 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE);
375 }
376
377 bool CCECAdapterMessage::NeedsRetry(void) const
378 {
379 return Reply() == MSGCODE_NOTHING ||
380 Reply() == MSGCODE_RECEIVE_FAILED ||
381 Reply() == MSGCODE_TIMEOUT_ERROR ||
382 Reply() == MSGCODE_TRANSMIT_FAILED_LINE ||
383 Reply() == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
384 Reply() == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE ||
385 Reply() == MSGCODE_TRANSMIT_LINE_TIMEOUT;
386 }
387
388 cec_logical_address CCECAdapterMessage::Initiator(void) const
389 {
390 return packet.size >= 3 ?
391 (cec_logical_address) (packet.At(2) >> 4) :
392 CECDEVICE_UNKNOWN;
393 }
394
395 cec_logical_address CCECAdapterMessage::Destination(void) const
396 {
397 return packet.size >= 3 ?
398 (cec_logical_address) (packet.At(2) & 0xF) :
399 CECDEVICE_UNKNOWN;
400 }
401
402 bool CCECAdapterMessage::HasStartMessage(void) const
403 {
404 return packet.size >= 1 && packet.At(0) == MSGSTART;
405 }
406
407 bool CCECAdapterMessage::PushToCecCommand(cec_command &command) const
408 {
409 // empty message
410 if (IsEmpty())
411 return false;
412
413 cec_adapter_messagecode msgCode = Message();
414 if (msgCode == MSGCODE_FRAME_START)
415 {
416 command.Clear();
417 if (Size() >= 3)
418 {
419 command.initiator = Initiator();
420 command.destination = Destination();
421 command.ack = IsACK();
422 command.eom = IsEOM();
423 }
424 return IsEOM() && !IsError();
425 }
426 else if (msgCode == MSGCODE_FRAME_DATA)
427 {
428 if (Size() >= 3)
429 {
430 command.PushBack(At(2));
431 command.eom = IsEOM();
432 }
433 return IsEOM() && !IsError();
434 }
435
436 return false;
437 }
438
439 cec_adapter_messagecode CCECAdapterMessage::Reply(void) const
440 {
441 return response.size >= 2 ?
442 (cec_adapter_messagecode) (response.At(1) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
443 MSGCODE_NOTHING;
444 }