win32: also timeout when data is received in SocketRead()
[deb_libcec.git] / src / lib / adapter / AdapterMessage.h
1 #pragma once
2 /*
3 * This file is part of the libCEC(R) library.
4 *
5 * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved.
6 * libCEC(R) is an original work, containing original code.
7 *
8 * libCEC(R) is a trademark of Pulse-Eight Limited.
9 *
10 * This program is dual-licensed; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 *
24 *
25 * Alternatively, you can license this library under a commercial license,
26 * please contact Pulse-Eight Licensing for more information.
27 *
28 * For more information contact:
29 * Pulse-Eight Licensing <license@pulse-eight.com>
30 * http://www.pulse-eight.com/
31 * http://www.pulse-eight.net/
32 */
33
34 #include "../platform/util/StdString.h"
35
36 namespace CEC
37 {
38 typedef enum cec_adapter_message_state
39 {
40 ADAPTER_MESSAGE_STATE_UNKNOWN = 0,
41 ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT,
42 ADAPTER_MESSAGE_STATE_SENT,
43 ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED,
44 ADAPTER_MESSAGE_STATE_SENT_ACKED,
45 ADAPTER_MESSAGE_STATE_INCOMING,
46 ADAPTER_MESSAGE_STATE_ERROR
47 } cec_adapter_message_state;
48
49
50 class CCECAdapterMessage
51 {
52 public:
53 CCECAdapterMessage(void)
54 {
55 Clear();
56 }
57
58 CCECAdapterMessage(const cec_command &command)
59 {
60 Clear();
61
62 //set ack polarity to high when transmitting to the broadcast address
63 //set ack polarity low when transmitting to any other address
64 PushBack(MSGSTART);
65 PushEscaped(MSGCODE_TRANSMIT_ACK_POLARITY);
66 if (command.destination == CECDEVICE_BROADCAST)
67 PushEscaped(CEC_TRUE);
68 else
69 PushEscaped(CEC_FALSE);
70 PushBack(MSGEND);
71
72 // add source and destination
73 PushBack(MSGSTART);
74 PushEscaped(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
75 PushBack(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
76 PushBack(MSGEND);
77
78 // add opcode
79 if (command.opcode_set == 1)
80 {
81 PushBack(MSGSTART);
82 PushEscaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
83 PushBack((uint8_t) command.opcode);
84 PushBack(MSGEND);
85
86 // add parameters
87 for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
88 {
89 PushBack(MSGSTART);
90
91 if (iPtr == command.parameters.size - 1)
92 PushEscaped( MSGCODE_TRANSMIT_EOM);
93 else
94 PushEscaped(MSGCODE_TRANSMIT);
95
96 PushEscaped(command.parameters[iPtr]);
97
98 PushBack(MSGEND);
99 }
100 }
101
102 // set timeout
103 transmit_timeout = command.transmit_timeout;
104 //TODO
105 }
106
107 CCECAdapterMessage &operator=(const CCECAdapterMessage &msg)
108 {
109 packet = msg.packet;
110 state = msg.state;
111 return *this;
112 }
113
114 CStdString ToString(void) const
115 {
116 CStdString strMsg;
117 if (Size() == 0)
118 {
119 strMsg = "empty message";
120 }
121 else
122 {
123 strMsg = MessageCodeAsString();
124
125 switch (Message())
126 {
127 case MSGCODE_TIMEOUT_ERROR:
128 case MSGCODE_HIGH_ERROR:
129 case MSGCODE_LOW_ERROR:
130 {
131 uint32_t iLine = (Size() >= 3) ? (At(1) << 8) | At(2) : 0;
132 uint32_t iTime = (Size() >= 7) ? (At(3) << 24) | (At(4) << 16) | (At(5) << 8) | At(6) : 0;
133 strMsg.AppendFormat(" line:%u", iLine);
134 strMsg.AppendFormat(" time:%u", iTime);
135 }
136 break;
137 case MSGCODE_FRAME_START:
138 if (Size() >= 2)
139 strMsg.AppendFormat(" initiator:%1x destination:%1x ack:%s %s", Initiator(), Destination(), IsACK() ? "high" : "low", IsEOM() ? "eom" : "");
140 break;
141 case MSGCODE_FRAME_DATA:
142 if (Size() >= 2)
143 strMsg.AppendFormat(" %02x %s", At(1), IsEOM() ? "eom" : "");
144 break;
145 default:
146 break;
147 }
148 }
149
150 return strMsg;
151 }
152
153 CStdString MessageCodeAsString(void) const
154 {
155 CStdString strMsg;
156 switch (Message())
157 {
158 case MSGCODE_NOTHING:
159 strMsg = "NOTHING";
160 break;
161 case MSGCODE_PING:
162 strMsg = "PING";
163 break;
164 case MSGCODE_TIMEOUT_ERROR:
165 strMsg = "TIMEOUT";
166 break;
167 case MSGCODE_HIGH_ERROR:
168 strMsg = "HIGH_ERROR";
169 break;
170 case MSGCODE_LOW_ERROR:
171 strMsg = "LOW_ERROR";
172 break;
173 case MSGCODE_FRAME_START:
174 strMsg = "FRAME_START";
175 break;
176 case MSGCODE_FRAME_DATA:
177 strMsg = "FRAME_DATA";
178 break;
179 case MSGCODE_RECEIVE_FAILED:
180 strMsg = "RECEIVE_FAILED";
181 break;
182 case MSGCODE_COMMAND_ACCEPTED:
183 strMsg = "COMMAND_ACCEPTED";
184 break;
185 case MSGCODE_COMMAND_REJECTED:
186 strMsg = "COMMAND_REJECTED";
187 break;
188 case MSGCODE_SET_ACK_MASK:
189 strMsg = "SET_ACK_MASK";
190 break;
191 case MSGCODE_TRANSMIT:
192 strMsg = "TRANSMIT";
193 break;
194 case MSGCODE_TRANSMIT_EOM:
195 strMsg = "TRANSMIT_EOM";
196 break;
197 case MSGCODE_TRANSMIT_IDLETIME:
198 strMsg = "TRANSMIT_IDLETIME";
199 break;
200 case MSGCODE_TRANSMIT_ACK_POLARITY:
201 strMsg = "TRANSMIT_ACK_POLARITY";
202 break;
203 case MSGCODE_TRANSMIT_LINE_TIMEOUT:
204 strMsg = "TRANSMIT_LINE_TIMEOUT";
205 break;
206 case MSGCODE_TRANSMIT_SUCCEEDED:
207 strMsg = "TRANSMIT_SUCCEEDED";
208 break;
209 case MSGCODE_TRANSMIT_FAILED_LINE:
210 strMsg = "TRANSMIT_FAILED_LINE";
211 break;
212 case MSGCODE_TRANSMIT_FAILED_ACK:
213 strMsg = "TRANSMIT_FAILED_ACK";
214 break;
215 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
216 strMsg = "TRANSMIT_FAILED_TIMEOUT_DATA";
217 break;
218 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
219 strMsg = "TRANSMIT_FAILED_TIMEOUT_LINE";
220 break;
221 case MSGCODE_FIRMWARE_VERSION:
222 strMsg = "FIRMWARE_VERSION";
223 break;
224 case MSGCODE_START_BOOTLOADER:
225 strMsg = "START_BOOTLOADER";
226 break;
227 case MSGCODE_FRAME_EOM:
228 strMsg = "FRAME_EOM";
229 break;
230 case MSGCODE_FRAME_ACK:
231 strMsg = "FRAME_ACK";
232 break;
233 }
234
235 return strMsg;
236 }
237
238 uint8_t operator[](uint8_t pos) const
239 {
240 return packet[pos];
241 }
242
243 uint8_t At(uint8_t pos) const
244 {
245 return packet[pos];
246 }
247
248 uint8_t Size(void) const
249 {
250 return packet.size;
251 }
252
253 bool IsEmpty(void) const
254 {
255 return packet.IsEmpty();
256 }
257
258 void Clear(void)
259 {
260 state = ADAPTER_MESSAGE_STATE_UNKNOWN;
261 transmit_timeout = CEC_DEFAULT_TRANSMIT_TIMEOUT;
262 packet.Clear();
263 maxTries = CEC_DEFAULT_TRANSMIT_RETRIES + 1;
264 tries = 0;
265 reply = MSGCODE_NOTHING;
266 isTransmission = true;
267 expectControllerAck = true;
268 }
269
270 void Shift(uint8_t iShiftBy)
271 {
272 packet.Shift(iShiftBy);
273 }
274
275 void PushBack(uint8_t add)
276 {
277 packet.PushBack(add);
278 }
279
280 void PushEscaped(uint8_t byte)
281 {
282 if (byte >= MSGESC)
283 {
284 PushBack(MSGESC);
285 PushBack(byte - ESCOFFSET);
286 }
287 else
288 {
289 PushBack(byte);
290 }
291 }
292
293 cec_adapter_messagecode Message(void) const
294 {
295 return packet.size >= 1 ?
296 (cec_adapter_messagecode) (packet.At(0) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
297 MSGCODE_NOTHING;
298 }
299
300 bool IsEOM(void) const
301 {
302 return packet.size >= 1 ?
303 (packet.At(0) & MSGCODE_FRAME_EOM) != 0 :
304 false;
305 }
306
307 bool IsACK(void) const
308 {
309 return packet.size >= 1 ?
310 (packet.At(0) & MSGCODE_FRAME_ACK) != 0 :
311 false;
312 }
313
314 bool IsError(void) const
315 {
316 cec_adapter_messagecode code = Message();
317 return (code == MSGCODE_HIGH_ERROR ||
318 code == MSGCODE_LOW_ERROR ||
319 code == MSGCODE_RECEIVE_FAILED ||
320 code == MSGCODE_COMMAND_REJECTED ||
321 code == MSGCODE_TRANSMIT_LINE_TIMEOUT ||
322 code == MSGCODE_TRANSMIT_FAILED_LINE ||
323 code == MSGCODE_TRANSMIT_FAILED_ACK ||
324 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
325 code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE);
326 }
327
328 bool NeedsRetry(void) const
329 {
330 return reply == MSGCODE_NOTHING ||
331 reply == MSGCODE_RECEIVE_FAILED ||
332 reply == MSGCODE_TIMEOUT_ERROR ||
333 reply == MSGCODE_TRANSMIT_FAILED_LINE ||
334 reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
335 reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE ||
336 reply == MSGCODE_TRANSMIT_LINE_TIMEOUT;
337 }
338
339 cec_logical_address Initiator(void) const
340 {
341 return packet.size >= 2 ?
342 (cec_logical_address) (packet.At(1) >> 4) :
343 CECDEVICE_UNKNOWN;
344 }
345
346 cec_logical_address Destination(void) const
347 {
348 return packet.size >= 2 ?
349 (cec_logical_address) (packet.At(1) & 0xF) :
350 CECDEVICE_UNKNOWN;
351 }
352
353 uint8_t maxTries;
354 uint8_t tries;
355 cec_adapter_messagecode reply;
356 cec_datapacket packet;
357 cec_adapter_message_state state;
358 int32_t transmit_timeout;
359 bool isTransmission;
360 bool expectControllerAck;
361 PLATFORM::CMutex mutex;
362 PLATFORM::CCondition condition;
363 };
364 }