FreeRDP
rdpei_common.c
1 
21 #include <freerdp/config.h>
22 
23 #include <winpr/crt.h>
24 #include <winpr/stream.h>
25 
26 #include "rdpei_common.h"
27 
28 #include <freerdp/log.h>
29 
30 #define TAG FREERDP_TAG("channels.rdpei.common")
31 
32 BOOL rdpei_read_2byte_unsigned(wStream* s, UINT16* value)
33 {
34  BYTE byte = 0;
35 
36  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
37  return FALSE;
38 
39  Stream_Read_UINT8(s, byte);
40 
41  if (byte & 0x80)
42  {
43  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
44  return FALSE;
45 
46  *value = (byte & 0x7F) << 8;
47  Stream_Read_UINT8(s, byte);
48  *value |= byte;
49  }
50  else
51  {
52  *value = (byte & 0x7F);
53  }
54 
55  return TRUE;
56 }
57 
58 BOOL rdpei_write_2byte_unsigned(wStream* s, UINT16 value)
59 {
60  BYTE byte = 0;
61 
62  if (!Stream_EnsureRemainingCapacity(s, 2))
63  return FALSE;
64 
65  if (value > 0x7FFF)
66  return FALSE;
67 
68  if (value >= 0x7F)
69  {
70  byte = ((value & 0x7F00) >> 8);
71  Stream_Write_UINT8(s, byte | 0x80);
72  byte = (value & 0xFF);
73  Stream_Write_UINT8(s, byte);
74  }
75  else
76  {
77  byte = (value & 0x7F);
78  Stream_Write_UINT8(s, byte);
79  }
80 
81  return TRUE;
82 }
83 
84 BOOL rdpei_read_2byte_signed(wStream* s, INT16* value)
85 {
86  BYTE byte = 0;
87  BOOL negative = 0;
88 
89  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
90  return FALSE;
91 
92  Stream_Read_UINT8(s, byte);
93 
94  negative = (byte & 0x40) ? TRUE : FALSE;
95 
96  const BYTE val = (byte & 0x3F);
97 
98  if (byte & 0x80)
99  {
100  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
101  return FALSE;
102 
103  Stream_Read_UINT8(s, byte);
104  *value = (INT16)((val << 8) | byte);
105  }
106  else
107  *value = val;
108 
109  if (negative)
110  *value *= -1;
111 
112  return TRUE;
113 }
114 
115 BOOL rdpei_write_2byte_signed(wStream* s, INT16 value)
116 {
117  BYTE byte = 0;
118  BOOL negative = FALSE;
119 
120  if (!Stream_EnsureRemainingCapacity(s, 2))
121  return FALSE;
122 
123  if (value < 0)
124  {
125  negative = TRUE;
126  value *= -1;
127  }
128 
129  if (value > 0x3FFF)
130  return FALSE;
131 
132  if (value >= 0x3F)
133  {
134  byte = ((value & 0x3F00) >> 8);
135 
136  if (negative)
137  byte |= 0x40;
138 
139  Stream_Write_UINT8(s, byte | 0x80);
140  byte = (value & 0xFF);
141  Stream_Write_UINT8(s, byte);
142  }
143  else
144  {
145  byte = (value & 0x3F);
146 
147  if (negative)
148  byte |= 0x40;
149 
150  Stream_Write_UINT8(s, byte);
151  }
152 
153  return TRUE;
154 }
155 
156 BOOL rdpei_read_4byte_unsigned(wStream* s, UINT32* value)
157 {
158  BYTE byte = 0;
159  BYTE count = 0;
160 
161  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
162  return FALSE;
163 
164  Stream_Read_UINT8(s, byte);
165 
166  count = (byte & 0xC0) >> 6;
167 
168  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
169  return FALSE;
170 
171  switch (count)
172  {
173  case 0:
174  *value = (byte & 0x3F);
175  break;
176 
177  case 1:
178  *value = (byte & 0x3F) << 8;
179  Stream_Read_UINT8(s, byte);
180  *value |= byte;
181  break;
182 
183  case 2:
184  *value = (byte & 0x3F) << 16;
185  Stream_Read_UINT8(s, byte);
186  *value |= (byte << 8);
187  Stream_Read_UINT8(s, byte);
188  *value |= byte;
189  break;
190 
191  case 3:
192  *value = (byte & 0x3F) << 24;
193  Stream_Read_UINT8(s, byte);
194  *value |= (byte << 16);
195  Stream_Read_UINT8(s, byte);
196  *value |= (byte << 8);
197  Stream_Read_UINT8(s, byte);
198  *value |= byte;
199  break;
200 
201  default:
202  break;
203  }
204 
205  return TRUE;
206 }
207 
208 BOOL rdpei_write_4byte_unsigned(wStream* s, UINT32 value)
209 {
210  BYTE byte = 0;
211 
212  if (!Stream_EnsureRemainingCapacity(s, 4))
213  return FALSE;
214 
215  if (value <= 0x3FUL)
216  {
217  Stream_Write_UINT8(s, value);
218  }
219  else if (value <= 0x3FFFUL)
220  {
221  byte = (value >> 8) & 0x3F;
222  Stream_Write_UINT8(s, byte | 0x40);
223  byte = (value & 0xFF);
224  Stream_Write_UINT8(s, byte);
225  }
226  else if (value <= 0x3FFFFFUL)
227  {
228  byte = (value >> 16) & 0x3F;
229  Stream_Write_UINT8(s, byte | 0x80);
230  byte = (value >> 8) & 0xFF;
231  Stream_Write_UINT8(s, byte);
232  byte = (value & 0xFF);
233  Stream_Write_UINT8(s, byte);
234  }
235  else if (value <= 0x3FFFFFFFUL)
236  {
237  byte = (value >> 24) & 0x3F;
238  Stream_Write_UINT8(s, byte | 0xC0);
239  byte = (value >> 16) & 0xFF;
240  Stream_Write_UINT8(s, byte);
241  byte = (value >> 8) & 0xFF;
242  Stream_Write_UINT8(s, byte);
243  byte = (value & 0xFF);
244  Stream_Write_UINT8(s, byte);
245  }
246  else
247  {
248  return FALSE;
249  }
250 
251  return TRUE;
252 }
253 
254 BOOL rdpei_read_4byte_signed(wStream* s, INT32* value)
255 {
256  BYTE byte = 0;
257  BYTE count = 0;
258  BOOL negative = 0;
259 
260  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
261  return FALSE;
262 
263  Stream_Read_UINT8(s, byte);
264 
265  count = (byte & 0xC0) >> 6;
266  negative = (byte & 0x20) ? TRUE : FALSE;
267 
268  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
269  return FALSE;
270 
271  switch (count)
272  {
273  case 0:
274  *value = (byte & 0x1F);
275  break;
276 
277  case 1:
278  *value = (byte & 0x1F) << 8;
279  Stream_Read_UINT8(s, byte);
280  *value |= byte;
281  break;
282 
283  case 2:
284  *value = (byte & 0x1F) << 16;
285  Stream_Read_UINT8(s, byte);
286  *value |= (byte << 8);
287  Stream_Read_UINT8(s, byte);
288  *value |= byte;
289  break;
290 
291  case 3:
292  *value = (byte & 0x1F) << 24;
293  Stream_Read_UINT8(s, byte);
294  *value |= (byte << 16);
295  Stream_Read_UINT8(s, byte);
296  *value |= (byte << 8);
297  Stream_Read_UINT8(s, byte);
298  *value |= byte;
299  break;
300 
301  default:
302  break;
303  }
304 
305  if (negative)
306  *value *= -1;
307 
308  return TRUE;
309 }
310 
311 BOOL rdpei_write_4byte_signed(wStream* s, INT32 value)
312 {
313  BYTE byte = 0;
314  BOOL negative = FALSE;
315 
316  if (!Stream_EnsureRemainingCapacity(s, 4))
317  return FALSE;
318 
319  if (value < 0)
320  {
321  negative = TRUE;
322  value *= -1;
323  }
324 
325  if (value <= 0x1FL)
326  {
327  byte = value & 0x1F;
328 
329  if (negative)
330  byte |= 0x20;
331 
332  Stream_Write_UINT8(s, byte);
333  }
334  else if (value <= 0x1FFFL)
335  {
336  byte = (value >> 8) & 0x1F;
337 
338  if (negative)
339  byte |= 0x20;
340 
341  Stream_Write_UINT8(s, byte | 0x40);
342  byte = (value & 0xFF);
343  Stream_Write_UINT8(s, byte);
344  }
345  else if (value <= 0x1FFFFFL)
346  {
347  byte = (value >> 16) & 0x1F;
348 
349  if (negative)
350  byte |= 0x20;
351 
352  Stream_Write_UINT8(s, byte | 0x80);
353  byte = (value >> 8) & 0xFF;
354  Stream_Write_UINT8(s, byte);
355  byte = (value & 0xFF);
356  Stream_Write_UINT8(s, byte);
357  }
358  else if (value <= 0x1FFFFFFFL)
359  {
360  byte = (value >> 24) & 0x1F;
361 
362  if (negative)
363  byte |= 0x20;
364 
365  Stream_Write_UINT8(s, byte | 0xC0);
366  byte = (value >> 16) & 0xFF;
367  Stream_Write_UINT8(s, byte);
368  byte = (value >> 8) & 0xFF;
369  Stream_Write_UINT8(s, byte);
370  byte = (value & 0xFF);
371  Stream_Write_UINT8(s, byte);
372  }
373  else
374  {
375  return FALSE;
376  }
377 
378  return TRUE;
379 }
380 
381 BOOL rdpei_read_8byte_unsigned(wStream* s, UINT64* value)
382 {
383  UINT64 byte = 0;
384  BYTE count = 0;
385 
386  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
387  return FALSE;
388 
389  Stream_Read_UINT8(s, byte);
390 
391  count = (byte & 0xE0) >> 5;
392 
393  if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
394  return FALSE;
395 
396  switch (count)
397  {
398  case 0:
399  *value = (byte & 0x1F);
400  break;
401 
402  case 1:
403  *value = (byte & 0x1FU) << 8U;
404  Stream_Read_UINT8(s, byte);
405  *value |= byte;
406  break;
407 
408  case 2:
409  *value = (byte & 0x1FU) << 16U;
410  Stream_Read_UINT8(s, byte);
411  *value |= (byte << 8U);
412  Stream_Read_UINT8(s, byte);
413  *value |= byte;
414  break;
415 
416  case 3:
417  *value = (byte & 0x1FU) << 24U;
418  Stream_Read_UINT8(s, byte);
419  *value |= (byte << 16U);
420  Stream_Read_UINT8(s, byte);
421  *value |= (byte << 8U);
422  Stream_Read_UINT8(s, byte);
423  *value |= byte;
424  break;
425 
426  case 4:
427  *value = ((byte & 0x1FU)) << 32U;
428  Stream_Read_UINT8(s, byte);
429  *value |= (byte << 24U);
430  Stream_Read_UINT8(s, byte);
431  *value |= (byte << 16U);
432  Stream_Read_UINT8(s, byte);
433  *value |= (byte << 8U);
434  Stream_Read_UINT8(s, byte);
435  *value |= byte;
436  break;
437 
438  case 5:
439  *value = ((byte & 0x1FU)) << 40U;
440  Stream_Read_UINT8(s, byte);
441  *value |= ((byte) << 32U);
442  Stream_Read_UINT8(s, byte);
443  *value |= (byte << 24U);
444  Stream_Read_UINT8(s, byte);
445  *value |= (byte << 16U);
446  Stream_Read_UINT8(s, byte);
447  *value |= (byte << 8U);
448  Stream_Read_UINT8(s, byte);
449  *value |= byte;
450  break;
451 
452  case 6:
453  *value = ((byte & 0x1FU)) << 48U;
454  Stream_Read_UINT8(s, byte);
455  *value |= ((byte) << 40U);
456  Stream_Read_UINT8(s, byte);
457  *value |= ((byte) << 32U);
458  Stream_Read_UINT8(s, byte);
459  *value |= (byte << 24U);
460  Stream_Read_UINT8(s, byte);
461  *value |= (byte << 16U);
462  Stream_Read_UINT8(s, byte);
463  *value |= (byte << 8U);
464  Stream_Read_UINT8(s, byte);
465  *value |= byte;
466  break;
467 
468  case 7:
469  *value = ((byte & 0x1FU)) << 56U;
470  Stream_Read_UINT8(s, byte);
471  *value |= ((byte) << 48U);
472  Stream_Read_UINT8(s, byte);
473  *value |= ((byte) << 40U);
474  Stream_Read_UINT8(s, byte);
475  *value |= ((byte) << 32U);
476  Stream_Read_UINT8(s, byte);
477  *value |= (byte << 24U);
478  Stream_Read_UINT8(s, byte);
479  *value |= (byte << 16U);
480  Stream_Read_UINT8(s, byte);
481  *value |= (byte << 8U);
482  Stream_Read_UINT8(s, byte);
483  *value |= byte;
484  break;
485 
486  default:
487  break;
488  }
489 
490  return TRUE;
491 }
492 
493 BOOL rdpei_write_8byte_unsigned(wStream* s, UINT64 value)
494 {
495  BYTE byte = 0;
496 
497  if (!Stream_EnsureRemainingCapacity(s, 8))
498  return FALSE;
499 
500  if (value <= 0x1FULL)
501  {
502  byte = value & 0x1F;
503  Stream_Write_UINT8(s, byte);
504  }
505  else if (value <= 0x1FFFULL)
506  {
507  byte = (value >> 8) & 0x1F;
508  byte |= (1 << 5);
509  Stream_Write_UINT8(s, byte);
510  byte = (value & 0xFF);
511  Stream_Write_UINT8(s, byte);
512  }
513  else if (value <= 0x1FFFFFULL)
514  {
515  byte = (value >> 16) & 0x1F;
516  byte |= (2 << 5);
517  Stream_Write_UINT8(s, byte);
518  byte = (value >> 8) & 0xFF;
519  Stream_Write_UINT8(s, byte);
520  byte = (value & 0xFF);
521  Stream_Write_UINT8(s, byte);
522  }
523  else if (value <= 0x1FFFFFFFULL)
524  {
525  byte = (value >> 24) & 0x1F;
526  byte |= (3 << 5);
527  Stream_Write_UINT8(s, byte);
528  byte = (value >> 16) & 0xFF;
529  Stream_Write_UINT8(s, byte);
530  byte = (value >> 8) & 0xFF;
531  Stream_Write_UINT8(s, byte);
532  byte = (value & 0xFF);
533  Stream_Write_UINT8(s, byte);
534  }
535  else if (value <= 0x1FFFFFFFFFULL)
536  {
537  byte = (value >> 32) & 0x1F;
538  byte |= (4 << 5);
539  Stream_Write_UINT8(s, byte);
540  byte = (value >> 24) & 0x1F;
541  Stream_Write_UINT8(s, byte);
542  byte = (value >> 16) & 0xFF;
543  Stream_Write_UINT8(s, byte);
544  byte = (value >> 8) & 0xFF;
545  Stream_Write_UINT8(s, byte);
546  byte = (value & 0xFF);
547  Stream_Write_UINT8(s, byte);
548  }
549  else if (value <= 0x1FFFFFFFFFFFULL)
550  {
551  byte = (value >> 40) & 0x1F;
552  byte |= (5 << 5);
553  Stream_Write_UINT8(s, byte);
554  byte = (value >> 32) & 0x1F;
555  Stream_Write_UINT8(s, byte);
556  byte = (value >> 24) & 0x1F;
557  Stream_Write_UINT8(s, byte);
558  byte = (value >> 16) & 0xFF;
559  Stream_Write_UINT8(s, byte);
560  byte = (value >> 8) & 0xFF;
561  Stream_Write_UINT8(s, byte);
562  byte = (value & 0xFF);
563  Stream_Write_UINT8(s, byte);
564  }
565  else if (value <= 0x1FFFFFFFFFFFFFULL)
566  {
567  byte = (value >> 48) & 0x1F;
568  byte |= (6 << 5);
569  Stream_Write_UINT8(s, byte);
570  byte = (value >> 40) & 0x1F;
571  Stream_Write_UINT8(s, byte);
572  byte = (value >> 32) & 0x1F;
573  Stream_Write_UINT8(s, byte);
574  byte = (value >> 24) & 0x1F;
575  Stream_Write_UINT8(s, byte);
576  byte = (value >> 16) & 0xFF;
577  Stream_Write_UINT8(s, byte);
578  byte = (value >> 8) & 0xFF;
579  Stream_Write_UINT8(s, byte);
580  byte = (value & 0xFF);
581  Stream_Write_UINT8(s, byte);
582  }
583  else if (value <= 0x1FFFFFFFFFFFFFFFULL)
584  {
585  byte = (value >> 56) & 0x1F;
586  byte |= (7 << 5);
587  Stream_Write_UINT8(s, byte);
588  byte = (value >> 48) & 0x1F;
589  Stream_Write_UINT8(s, byte);
590  byte = (value >> 40) & 0x1F;
591  Stream_Write_UINT8(s, byte);
592  byte = (value >> 32) & 0x1F;
593  Stream_Write_UINT8(s, byte);
594  byte = (value >> 24) & 0x1F;
595  Stream_Write_UINT8(s, byte);
596  byte = (value >> 16) & 0xFF;
597  Stream_Write_UINT8(s, byte);
598  byte = (value >> 8) & 0xFF;
599  Stream_Write_UINT8(s, byte);
600  byte = (value & 0xFF);
601  Stream_Write_UINT8(s, byte);
602  }
603  else
604  {
605  return FALSE;
606  }
607 
608  return TRUE;
609 }
610 
611 void touch_event_reset(RDPINPUT_TOUCH_EVENT* event)
612 {
613  for (UINT16 i = 0; i < event->frameCount; i++)
614  touch_frame_reset(&event->frames[i]);
615 
616  free(event->frames);
617  event->frames = NULL;
618  event->frameCount = 0;
619 }
620 
621 void touch_frame_reset(RDPINPUT_TOUCH_FRAME* frame)
622 {
623  free(frame->contacts);
624  frame->contacts = NULL;
625  frame->contactCount = 0;
626 }
627 
628 void pen_event_reset(RDPINPUT_PEN_EVENT* event)
629 {
630  for (UINT16 i = 0; i < event->frameCount; i++)
631  pen_frame_reset(&event->frames[i]);
632 
633  free(event->frames);
634  event->frames = NULL;
635  event->frameCount = 0;
636 }
637 
638 void pen_frame_reset(RDPINPUT_PEN_FRAME* frame)
639 {
640  free(frame->contacts);
641  frame->contacts = NULL;
642  frame->contactCount = 0;
643 }
RDPINPUT_PEN_EVENT
a touch event with some frames
Definition: channels/rdpei.h:160
RDPINPUT_PEN_FRAME
Definition: channels/rdpei.h:152
RDPINPUT_TOUCH_EVENT
a touch event with some frames
Definition: channels/rdpei.h:129
RDPINPUT_TOUCH_FRAME
a frame containing contact points
Definition: channels/rdpei.h:121