FreeRDP
clear.c
1 
22 #include <freerdp/config.h>
23 
24 #include <winpr/crt.h>
25 #include <winpr/print.h>
26 #include <winpr/bitstream.h>
27 
28 #include <freerdp/codec/color.h>
29 #include <freerdp/codec/clear.h>
30 #include <freerdp/log.h>
31 
32 #define TAG FREERDP_TAG("codec.clear")
33 
34 #define CLEARCODEC_FLAG_GLYPH_INDEX 0x01
35 #define CLEARCODEC_FLAG_GLYPH_HIT 0x02
36 #define CLEARCODEC_FLAG_CACHE_RESET 0x04
37 
38 #define CLEARCODEC_VBAR_SIZE 32768
39 #define CLEARCODEC_VBAR_SHORT_SIZE 16384
40 
41 typedef struct
42 {
43  UINT32 size;
44  UINT32 count;
45  UINT32* pixels;
46 } CLEAR_GLYPH_ENTRY;
47 
48 typedef struct
49 {
50  UINT32 size;
51  UINT32 count;
52  BYTE* pixels;
53 } CLEAR_VBAR_ENTRY;
54 
55 struct S_CLEAR_CONTEXT
56 {
57  BOOL Compressor;
58  NSC_CONTEXT* nsc;
59  UINT32 seqNumber;
60  BYTE* TempBuffer;
61  UINT32 TempSize;
62  UINT32 nTempStep;
63  UINT32 TempFormat;
64  UINT32 format;
65  CLEAR_GLYPH_ENTRY GlyphCache[4000];
66  UINT32 VBarStorageCursor;
67  CLEAR_VBAR_ENTRY VBarStorage[CLEARCODEC_VBAR_SIZE];
68  UINT32 ShortVBarStorageCursor;
69  CLEAR_VBAR_ENTRY ShortVBarStorage[CLEARCODEC_VBAR_SHORT_SIZE];
70 };
71 
72 static const UINT32 CLEAR_LOG2_FLOOR[256] = {
73  0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
74  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
75  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
76  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
77  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
78  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
79  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
80  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
81 };
82 
83 static const BYTE CLEAR_8BIT_MASKS[9] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF };
84 
85 static void clear_reset_vbar_storage(CLEAR_CONTEXT* WINPR_RESTRICT clear, BOOL zero)
86 {
87  if (zero)
88  {
89  for (size_t i = 0; i < ARRAYSIZE(clear->VBarStorage); i++)
90  winpr_aligned_free(clear->VBarStorage[i].pixels);
91 
92  ZeroMemory(clear->VBarStorage, sizeof(clear->VBarStorage));
93  }
94 
95  clear->VBarStorageCursor = 0;
96 
97  if (zero)
98  {
99  for (size_t i = 0; i < ARRAYSIZE(clear->ShortVBarStorage); i++)
100  winpr_aligned_free(clear->ShortVBarStorage[i].pixels);
101 
102  ZeroMemory(clear->ShortVBarStorage, sizeof(clear->ShortVBarStorage));
103  }
104 
105  clear->ShortVBarStorageCursor = 0;
106 }
107 
108 static void clear_reset_glyph_cache(CLEAR_CONTEXT* WINPR_RESTRICT clear)
109 {
110  for (size_t i = 0; i < ARRAYSIZE(clear->GlyphCache); i++)
111  winpr_aligned_free(clear->GlyphCache[i].pixels);
112 
113  ZeroMemory(clear->GlyphCache, sizeof(clear->GlyphCache));
114 }
115 
116 static BOOL convert_color(BYTE* WINPR_RESTRICT dst, UINT32 nDstStep, UINT32 DstFormat, UINT32 nXDst,
117  UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
118  const BYTE* WINPR_RESTRICT src, UINT32 nSrcStep, UINT32 SrcFormat,
119  UINT32 nDstWidth, UINT32 nDstHeight,
120  const gdiPalette* WINPR_RESTRICT palette)
121 {
122  if (nWidth + nXDst > nDstWidth)
123  nWidth = nDstWidth - nXDst;
124 
125  if (nHeight + nYDst > nDstHeight)
126  nHeight = nDstHeight - nYDst;
127 
128  return freerdp_image_copy_no_overlap(dst, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight,
129  src, SrcFormat, nSrcStep, 0, 0, palette,
130  FREERDP_KEEP_DST_ALPHA);
131 }
132 
133 static BOOL clear_decompress_nscodec(NSC_CONTEXT* WINPR_RESTRICT nsc, UINT32 width, UINT32 height,
134  wStream* WINPR_RESTRICT s, UINT32 bitmapDataByteCount,
135  BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
136  UINT32 nDstStep, UINT32 nXDstRel, UINT32 nYDstRel)
137 {
138  BOOL rc = 0;
139 
140  if (!Stream_CheckAndLogRequiredLength(TAG, s, bitmapDataByteCount))
141  return FALSE;
142 
143  rc = nsc_process_message(nsc, 32, width, height, Stream_Pointer(s), bitmapDataByteCount,
144  pDstData, DstFormat, nDstStep, nXDstRel, nYDstRel, width, height,
145  FREERDP_FLIP_NONE);
146  Stream_Seek(s, bitmapDataByteCount);
147  return rc;
148 }
149 
150 static BOOL clear_decompress_subcode_rlex(wStream* WINPR_RESTRICT s, UINT32 bitmapDataByteCount,
151  UINT32 width, UINT32 height,
152  BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
153  UINT32 nDstStep, UINT32 nXDstRel, UINT32 nYDstRel,
154  UINT32 nDstWidth, UINT32 nDstHeight)
155 {
156  UINT32 x = 0;
157  UINT32 y = 0;
158  UINT32 pixelCount = 0;
159  UINT32 bitmapDataOffset = 0;
160  size_t pixelIndex = 0;
161  UINT32 numBits = 0;
162  BYTE startIndex = 0;
163  BYTE stopIndex = 0;
164  BYTE suiteIndex = 0;
165  BYTE suiteDepth = 0;
166  BYTE paletteCount = 0;
167  UINT32 palette[128] = { 0 };
168 
169  if (!Stream_CheckAndLogRequiredLength(TAG, s, bitmapDataByteCount))
170  return FALSE;
171 
172  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
173  return FALSE;
174  Stream_Read_UINT8(s, paletteCount);
175  bitmapDataOffset = 1 + (paletteCount * 3);
176 
177  if ((paletteCount > 127) || (paletteCount < 1))
178  {
179  WLog_ERR(TAG, "paletteCount %" PRIu8 "", paletteCount);
180  return FALSE;
181  }
182 
183  if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, paletteCount, 3ull))
184  return FALSE;
185 
186  for (UINT32 i = 0; i < paletteCount; i++)
187  {
188  BYTE r = 0;
189  BYTE g = 0;
190  BYTE b = 0;
191  Stream_Read_UINT8(s, b);
192  Stream_Read_UINT8(s, g);
193  Stream_Read_UINT8(s, r);
194  palette[i] = FreeRDPGetColor(DstFormat, r, g, b, 0xFF);
195  }
196 
197  pixelIndex = 0;
198  pixelCount = width * height;
199  numBits = CLEAR_LOG2_FLOOR[paletteCount - 1] + 1;
200 
201  while (bitmapDataOffset < bitmapDataByteCount)
202  {
203  UINT32 tmp = 0;
204  UINT32 color = 0;
205  UINT32 runLengthFactor = 0;
206 
207  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
208  return FALSE;
209 
210  Stream_Read_UINT8(s, tmp);
211  Stream_Read_UINT8(s, runLengthFactor);
212  bitmapDataOffset += 2;
213  suiteDepth = (tmp >> numBits) & CLEAR_8BIT_MASKS[(8 - numBits)];
214  stopIndex = tmp & CLEAR_8BIT_MASKS[numBits];
215  startIndex = stopIndex - suiteDepth;
216 
217  if (runLengthFactor >= 0xFF)
218  {
219  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
220  return FALSE;
221 
222  Stream_Read_UINT16(s, runLengthFactor);
223  bitmapDataOffset += 2;
224 
225  if (runLengthFactor >= 0xFFFF)
226  {
227  if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
228  return FALSE;
229 
230  Stream_Read_UINT32(s, runLengthFactor);
231  bitmapDataOffset += 4;
232  }
233  }
234 
235  if (startIndex >= paletteCount)
236  {
237  WLog_ERR(TAG, "startIndex %" PRIu8 " > paletteCount %" PRIu8 "]", startIndex,
238  paletteCount);
239  return FALSE;
240  }
241 
242  if (stopIndex >= paletteCount)
243  {
244  WLog_ERR(TAG, "stopIndex %" PRIu8 " > paletteCount %" PRIu8 "]", stopIndex,
245  paletteCount);
246  return FALSE;
247  }
248 
249  suiteIndex = startIndex;
250 
251  if (suiteIndex > 127)
252  {
253  WLog_ERR(TAG, "suiteIndex %" PRIu8 " > 127]", suiteIndex);
254  return FALSE;
255  }
256 
257  color = palette[suiteIndex];
258 
259  if ((pixelIndex + runLengthFactor) > pixelCount)
260  {
261  WLog_ERR(TAG,
262  "pixelIndex %" PRIu32 " + runLengthFactor %" PRIu32 " > pixelCount %" PRIu32
263  "",
264  pixelIndex, runLengthFactor, pixelCount);
265  return FALSE;
266  }
267 
268  for (UINT32 i = 0; i < runLengthFactor; i++)
269  {
270  BYTE* pTmpData = &pDstData[(nXDstRel + x) * FreeRDPGetBytesPerPixel(DstFormat) +
271  (nYDstRel + y) * nDstStep];
272 
273  if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))
274  FreeRDPWriteColor(pTmpData, DstFormat, color);
275 
276  if (++x >= width)
277  {
278  y++;
279  x = 0;
280  }
281  }
282 
283  pixelIndex += runLengthFactor;
284 
285  if ((pixelIndex + (suiteDepth + 1)) > pixelCount)
286  {
287  WLog_ERR(TAG,
288  "pixelIndex %" PRIu32 " + suiteDepth %" PRIu8 " + 1 > pixelCount %" PRIu32 "",
289  pixelIndex, suiteDepth, pixelCount);
290  return FALSE;
291  }
292 
293  for (UINT32 i = 0; i <= suiteDepth; i++)
294  {
295  BYTE* pTmpData = &pDstData[(nXDstRel + x) * FreeRDPGetBytesPerPixel(DstFormat) +
296  (nYDstRel + y) * nDstStep];
297  UINT32 ccolor = palette[suiteIndex];
298 
299  if (suiteIndex > 127)
300  {
301  WLog_ERR(TAG, "suiteIndex %" PRIu8 " > 127", suiteIndex);
302  return FALSE;
303  }
304 
305  suiteIndex++;
306 
307  if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))
308  FreeRDPWriteColor(pTmpData, DstFormat, ccolor);
309 
310  if (++x >= width)
311  {
312  y++;
313  x = 0;
314  }
315  }
316 
317  pixelIndex += (suiteDepth + 1);
318  }
319 
320  if (pixelIndex != pixelCount)
321  {
322  WLog_ERR(TAG, "pixelIndex %" PRIdz " != pixelCount %" PRIu32 "", pixelIndex, pixelCount);
323  return FALSE;
324  }
325 
326  return TRUE;
327 }
328 
329 static BOOL clear_resize_buffer(CLEAR_CONTEXT* WINPR_RESTRICT clear, UINT32 width, UINT32 height)
330 {
331  UINT32 size = 0;
332 
333  if (!clear)
334  return FALSE;
335 
336  size = ((width + 16) * (height + 16) * FreeRDPGetBytesPerPixel(clear->format));
337 
338  if (size > clear->TempSize)
339  {
340  BYTE* tmp = (BYTE*)winpr_aligned_recalloc(clear->TempBuffer, size, sizeof(BYTE), 32);
341 
342  if (!tmp)
343  {
344  WLog_ERR(TAG, "clear->TempBuffer winpr_aligned_recalloc failed for %" PRIu32 " bytes",
345  size);
346  return FALSE;
347  }
348 
349  clear->TempSize = size;
350  clear->TempBuffer = tmp;
351  }
352 
353  return TRUE;
354 }
355 
356 static BOOL clear_decompress_residual_data(CLEAR_CONTEXT* WINPR_RESTRICT clear,
357  wStream* WINPR_RESTRICT s, UINT32 residualByteCount,
358  UINT32 nWidth, UINT32 nHeight,
359  BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
360  UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
361  UINT32 nDstWidth, UINT32 nDstHeight,
362  const gdiPalette* WINPR_RESTRICT palette)
363 {
364  UINT32 nSrcStep = 0;
365  UINT32 suboffset = 0;
366  BYTE* dstBuffer = NULL;
367  UINT32 pixelIndex = 0;
368  UINT32 pixelCount = 0;
369 
370  if (!Stream_CheckAndLogRequiredLength(TAG, s, residualByteCount))
371  return FALSE;
372 
373  suboffset = 0;
374  pixelIndex = 0;
375  pixelCount = nWidth * nHeight;
376 
377  if (!clear_resize_buffer(clear, nWidth, nHeight))
378  return FALSE;
379 
380  dstBuffer = clear->TempBuffer;
381 
382  while (suboffset < residualByteCount)
383  {
384  BYTE r = 0;
385  BYTE g = 0;
386  BYTE b = 0;
387  UINT32 runLengthFactor = 0;
388  UINT32 color = 0;
389 
390  if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
391  return FALSE;
392 
393  Stream_Read_UINT8(s, b);
394  Stream_Read_UINT8(s, g);
395  Stream_Read_UINT8(s, r);
396  Stream_Read_UINT8(s, runLengthFactor);
397  suboffset += 4;
398  color = FreeRDPGetColor(clear->format, r, g, b, 0xFF);
399 
400  if (runLengthFactor >= 0xFF)
401  {
402  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
403  return FALSE;
404 
405  Stream_Read_UINT16(s, runLengthFactor);
406  suboffset += 2;
407 
408  if (runLengthFactor >= 0xFFFF)
409  {
410  if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
411  return FALSE;
412 
413  Stream_Read_UINT32(s, runLengthFactor);
414  suboffset += 4;
415  }
416  }
417 
418  if ((pixelIndex >= pixelCount) || (runLengthFactor > (pixelCount - pixelIndex)))
419  {
420  WLog_ERR(TAG,
421  "pixelIndex %" PRIu32 " + runLengthFactor %" PRIu32 " > pixelCount %" PRIu32
422  "",
423  pixelIndex, runLengthFactor, pixelCount);
424  return FALSE;
425  }
426 
427  for (UINT32 i = 0; i < runLengthFactor; i++)
428  {
429  FreeRDPWriteColor(dstBuffer, clear->format, color);
430  dstBuffer += FreeRDPGetBytesPerPixel(clear->format);
431  }
432 
433  pixelIndex += runLengthFactor;
434  }
435 
436  nSrcStep = nWidth * FreeRDPGetBytesPerPixel(clear->format);
437 
438  if (pixelIndex != pixelCount)
439  {
440  WLog_ERR(TAG, "pixelIndex %" PRIu32 " != pixelCount %" PRIu32 "", pixelIndex, pixelCount);
441  return FALSE;
442  }
443 
444  return convert_color(pDstData, nDstStep, DstFormat, nXDst, nYDst, nWidth, nHeight,
445  clear->TempBuffer, nSrcStep, clear->format, nDstWidth, nDstHeight,
446  palette);
447 }
448 
449 static BOOL clear_decompress_subcodecs_data(CLEAR_CONTEXT* WINPR_RESTRICT clear,
450  wStream* WINPR_RESTRICT s, UINT32 subcodecByteCount,
451  UINT32 nWidth, UINT32 nHeight,
452  BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
453  UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
454  UINT32 nDstWidth, UINT32 nDstHeight,
455  const gdiPalette* WINPR_RESTRICT palette)
456 {
457  UINT16 xStart = 0;
458  UINT16 yStart = 0;
459  UINT16 width = 0;
460  UINT16 height = 0;
461  UINT32 bitmapDataByteCount = 0;
462  BYTE subcodecId = 0;
463  UINT32 suboffset = 0;
464 
465  if (!Stream_CheckAndLogRequiredLength(TAG, s, subcodecByteCount))
466  return FALSE;
467 
468  suboffset = 0;
469 
470  while (suboffset < subcodecByteCount)
471  {
472  UINT32 nXDstRel = 0;
473  UINT32 nYDstRel = 0;
474 
475  if (!Stream_CheckAndLogRequiredLength(TAG, s, 13))
476  return FALSE;
477 
478  Stream_Read_UINT16(s, xStart);
479  Stream_Read_UINT16(s, yStart);
480  Stream_Read_UINT16(s, width);
481  Stream_Read_UINT16(s, height);
482  Stream_Read_UINT32(s, bitmapDataByteCount);
483  Stream_Read_UINT8(s, subcodecId);
484  suboffset += 13;
485 
486  if (!Stream_CheckAndLogRequiredLength(TAG, s, bitmapDataByteCount))
487  return FALSE;
488 
489  nXDstRel = nXDst + xStart;
490  nYDstRel = nYDst + yStart;
491 
492  if (1ull * xStart + width > nWidth)
493  {
494  WLog_ERR(TAG, "xStart %" PRIu16 " + width %" PRIu16 " > nWidth %" PRIu32 "", xStart,
495  width, nWidth);
496  return FALSE;
497  }
498  if (1ull * yStart + height > nHeight)
499  {
500  WLog_ERR(TAG, "yStart %" PRIu16 " + height %" PRIu16 " > nHeight %" PRIu32 "", yStart,
501  height, nHeight);
502  return FALSE;
503  }
504 
505  if (!clear_resize_buffer(clear, width, height))
506  return FALSE;
507 
508  switch (subcodecId)
509  {
510  case 0: /* Uncompressed */
511  {
512  const UINT32 nSrcStep = width * FreeRDPGetBytesPerPixel(PIXEL_FORMAT_BGR24);
513  const size_t nSrcSize = 1ull * nSrcStep * height;
514 
515  if (bitmapDataByteCount != nSrcSize)
516  {
517  WLog_ERR(TAG, "bitmapDataByteCount %" PRIu32 " != nSrcSize %" PRIuz "",
518  bitmapDataByteCount, nSrcSize);
519  return FALSE;
520  }
521 
522  if (!convert_color(pDstData, nDstStep, DstFormat, nXDstRel, nYDstRel, width, height,
523  Stream_Pointer(s), nSrcStep, PIXEL_FORMAT_BGR24, nDstWidth,
524  nDstHeight, palette))
525  return FALSE;
526 
527  Stream_Seek(s, bitmapDataByteCount);
528  }
529  break;
530 
531  case 1: /* NSCodec */
532  if (!clear_decompress_nscodec(clear->nsc, width, height, s, bitmapDataByteCount,
533  pDstData, DstFormat, nDstStep, nXDstRel, nYDstRel))
534  return FALSE;
535 
536  break;
537 
538  case 2: /* CLEARCODEC_SUBCODEC_RLEX */
539  if (!clear_decompress_subcode_rlex(s, bitmapDataByteCount, width, height, pDstData,
540  DstFormat, nDstStep, nXDstRel, nYDstRel,
541  nDstWidth, nDstHeight))
542  return FALSE;
543 
544  break;
545 
546  default:
547  WLog_ERR(TAG, "Unknown subcodec ID %" PRIu8 "", subcodecId);
548  return FALSE;
549  }
550 
551  suboffset += bitmapDataByteCount;
552  }
553 
554  return TRUE;
555 }
556 
557 static BOOL resize_vbar_entry(CLEAR_CONTEXT* WINPR_RESTRICT clear,
558  CLEAR_VBAR_ENTRY* WINPR_RESTRICT vBarEntry)
559 {
560  if (vBarEntry->count > vBarEntry->size)
561  {
562  const UINT32 bpp = FreeRDPGetBytesPerPixel(clear->format);
563  const UINT32 oldPos = vBarEntry->size * bpp;
564  const UINT32 diffSize = (vBarEntry->count - vBarEntry->size) * bpp;
565 
566  vBarEntry->size = vBarEntry->count;
567  BYTE* tmp =
568  (BYTE*)winpr_aligned_recalloc(vBarEntry->pixels, vBarEntry->count, 1ull * bpp, 32);
569 
570  if (!tmp)
571  {
572  WLog_ERR(TAG, "vBarEntry->pixels winpr_aligned_recalloc %" PRIu32 " failed",
573  vBarEntry->count * bpp);
574  return FALSE;
575  }
576 
577  memset(&tmp[oldPos], 0, diffSize);
578  vBarEntry->pixels = tmp;
579  }
580 
581  if (!vBarEntry->pixels && vBarEntry->size)
582  {
583  WLog_ERR(TAG, "vBarEntry->pixels is NULL but vBarEntry->size is %" PRIu32 "",
584  vBarEntry->size);
585  return FALSE;
586  }
587 
588  return TRUE;
589 }
590 
591 static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* WINPR_RESTRICT clear,
592  wStream* WINPR_RESTRICT s, UINT32 bandsByteCount,
593  UINT32 nWidth, UINT32 nHeight,
594  BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
595  UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
596  UINT32 nDstWidth, UINT32 nDstHeight)
597 {
598  UINT32 suboffset = 0;
599 
600  if (!Stream_CheckAndLogRequiredLength(TAG, s, bandsByteCount))
601  return FALSE;
602 
603  while (suboffset < bandsByteCount)
604  {
605  BYTE cr = 0;
606  BYTE cg = 0;
607  BYTE cb = 0;
608  UINT16 xStart = 0;
609  UINT16 xEnd = 0;
610  UINT16 yStart = 0;
611  UINT16 yEnd = 0;
612  UINT32 colorBkg = 0;
613  UINT16 vBarHeader = 0;
614  UINT16 vBarYOn = 0;
615  UINT16 vBarYOff = 0;
616  UINT32 vBarCount = 0;
617  UINT32 vBarPixelCount = 0;
618  UINT32 vBarShortPixelCount = 0;
619 
620  if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
621  return FALSE;
622 
623  Stream_Read_UINT16(s, xStart);
624  Stream_Read_UINT16(s, xEnd);
625  Stream_Read_UINT16(s, yStart);
626  Stream_Read_UINT16(s, yEnd);
627  Stream_Read_UINT8(s, cb);
628  Stream_Read_UINT8(s, cg);
629  Stream_Read_UINT8(s, cr);
630  suboffset += 11;
631  colorBkg = FreeRDPGetColor(clear->format, cr, cg, cb, 0xFF);
632 
633  if (xEnd < xStart)
634  {
635  WLog_ERR(TAG, "xEnd %" PRIu16 " < xStart %" PRIu16 "", xEnd, xStart);
636  return FALSE;
637  }
638 
639  if (yEnd < yStart)
640  {
641  WLog_ERR(TAG, "yEnd %" PRIu16 " < yStart %" PRIu16 "", yEnd, yStart);
642  return FALSE;
643  }
644 
645  vBarCount = (xEnd - xStart) + 1;
646 
647  for (UINT32 i = 0; i < vBarCount; i++)
648  {
649  UINT32 vBarHeight = 0;
650  CLEAR_VBAR_ENTRY* vBarEntry = NULL;
651  CLEAR_VBAR_ENTRY* vBarShortEntry = NULL;
652  BOOL vBarUpdate = FALSE;
653  const BYTE* cpSrcPixel = NULL;
654 
655  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
656  return FALSE;
657 
658  Stream_Read_UINT16(s, vBarHeader);
659  suboffset += 2;
660  vBarHeight = (yEnd - yStart + 1);
661 
662  if (vBarHeight > 52)
663  {
664  WLog_ERR(TAG, "vBarHeight (%" PRIu32 ") > 52", vBarHeight);
665  return FALSE;
666  }
667 
668  if ((vBarHeader & 0xC000) == 0x4000) /* SHORT_VBAR_CACHE_HIT */
669  {
670  const UINT16 vBarIndex = (vBarHeader & 0x3FFF);
671  vBarShortEntry = &(clear->ShortVBarStorage[vBarIndex]);
672 
673  if (!vBarShortEntry)
674  {
675  WLog_ERR(TAG, "missing vBarShortEntry %" PRIu16 "", vBarIndex);
676  return FALSE;
677  }
678 
679  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
680  return FALSE;
681 
682  Stream_Read_UINT8(s, vBarYOn);
683  suboffset += 1;
684  vBarShortPixelCount = vBarShortEntry->count;
685  vBarUpdate = TRUE;
686  }
687  else if ((vBarHeader & 0xC000) == 0x0000) /* SHORT_VBAR_CACHE_MISS */
688  {
689  vBarYOn = (vBarHeader & 0xFF);
690  vBarYOff = ((vBarHeader >> 8) & 0x3F);
691 
692  if (vBarYOff < vBarYOn)
693  {
694  WLog_ERR(TAG, "vBarYOff %" PRIu16 " < vBarYOn %" PRIu16 "", vBarYOff, vBarYOn);
695  return FALSE;
696  }
697 
698  vBarShortPixelCount = (vBarYOff - vBarYOn);
699 
700  if (vBarShortPixelCount > 52)
701  {
702  WLog_ERR(TAG, "vBarShortPixelCount %" PRIu32 " > 52", vBarShortPixelCount);
703  return FALSE;
704  }
705 
706  if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, vBarShortPixelCount, 3ull))
707  return FALSE;
708 
709  if (clear->ShortVBarStorageCursor >= CLEARCODEC_VBAR_SHORT_SIZE)
710  {
711  WLog_ERR(TAG,
712  "clear->ShortVBarStorageCursor %" PRIu32
713  " >= CLEARCODEC_VBAR_SHORT_SIZE (%" PRIu32 ")",
714  clear->ShortVBarStorageCursor, CLEARCODEC_VBAR_SHORT_SIZE);
715  return FALSE;
716  }
717 
718  vBarShortEntry = &(clear->ShortVBarStorage[clear->ShortVBarStorageCursor]);
719  vBarShortEntry->count = vBarShortPixelCount;
720 
721  if (!resize_vbar_entry(clear, vBarShortEntry))
722  return FALSE;
723 
724  for (size_t y = 0; y < vBarShortPixelCount; y++)
725  {
726  BYTE r = 0;
727  BYTE g = 0;
728  BYTE b = 0;
729  BYTE* dstBuffer =
730  &vBarShortEntry->pixels[y * FreeRDPGetBytesPerPixel(clear->format)];
731  UINT32 color = 0;
732  Stream_Read_UINT8(s, b);
733  Stream_Read_UINT8(s, g);
734  Stream_Read_UINT8(s, r);
735  color = FreeRDPGetColor(clear->format, r, g, b, 0xFF);
736 
737  if (!FreeRDPWriteColor(dstBuffer, clear->format, color))
738  return FALSE;
739  }
740 
741  suboffset += (vBarShortPixelCount * 3);
742  clear->ShortVBarStorageCursor =
743  (clear->ShortVBarStorageCursor + 1) % CLEARCODEC_VBAR_SHORT_SIZE;
744  vBarUpdate = TRUE;
745  }
746  else if ((vBarHeader & 0x8000) == 0x8000) /* VBAR_CACHE_HIT */
747  {
748  const UINT16 vBarIndex = (vBarHeader & 0x7FFF);
749  vBarEntry = &(clear->VBarStorage[vBarIndex]);
750 
751  /* If the cache was reset we need to fill in some dummy data. */
752  if (vBarEntry->size == 0)
753  {
754  WLog_WARN(TAG, "Empty cache index %" PRIu16 ", filling dummy data", vBarIndex);
755  vBarEntry->count = vBarHeight;
756 
757  if (!resize_vbar_entry(clear, vBarEntry))
758  return FALSE;
759  }
760  }
761  else
762  {
763  WLog_ERR(TAG, "invalid vBarHeader 0x%04" PRIX16 "", vBarHeader);
764  return FALSE; /* invalid vBarHeader */
765  }
766 
767  if (vBarUpdate)
768  {
769  BYTE* pSrcPixel = NULL;
770  BYTE* dstBuffer = NULL;
771 
772  if (clear->VBarStorageCursor >= CLEARCODEC_VBAR_SIZE)
773  {
774  WLog_ERR(TAG,
775  "clear->VBarStorageCursor %" PRIu32 " >= CLEARCODEC_VBAR_SIZE %" PRIu32
776  "",
777  clear->VBarStorageCursor, CLEARCODEC_VBAR_SIZE);
778  return FALSE;
779  }
780 
781  vBarEntry = &(clear->VBarStorage[clear->VBarStorageCursor]);
782  vBarPixelCount = vBarHeight;
783  vBarEntry->count = vBarPixelCount;
784 
785  if (!resize_vbar_entry(clear, vBarEntry))
786  return FALSE;
787 
788  dstBuffer = vBarEntry->pixels;
789  /* if (y < vBarYOn), use colorBkg */
790  UINT32 y = 0;
791  UINT32 count = vBarYOn;
792 
793  if ((y + count) > vBarPixelCount)
794  count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;
795 
796  if (count > 0)
797  {
798  while (count--)
799  {
800  FreeRDPWriteColor(dstBuffer, clear->format, colorBkg);
801  dstBuffer += FreeRDPGetBytesPerPixel(clear->format);
802  }
803  }
804 
805  /*
806  * if ((y >= vBarYOn) && (y < (vBarYOn + vBarShortPixelCount))),
807  * use vBarShortPixels at index (y - shortVBarYOn)
808  */
809  y = vBarYOn;
810  count = vBarShortPixelCount;
811 
812  if ((y + count) > vBarPixelCount)
813  count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;
814 
815  if (count > 0)
816  {
817  const size_t offset =
818  (1ull * y - vBarYOn) * FreeRDPGetBytesPerPixel(clear->format);
819  pSrcPixel = &vBarShortEntry->pixels[offset];
820  if (offset + count > vBarShortEntry->count)
821  {
822  WLog_ERR(TAG, "offset + count > vBarShortEntry->count");
823  return FALSE;
824  }
825  }
826  for (size_t x = 0; x < count; x++)
827  {
828  UINT32 color = 0;
829  color = FreeRDPReadColor(&pSrcPixel[x * FreeRDPGetBytesPerPixel(clear->format)],
830  clear->format);
831 
832  if (!FreeRDPWriteColor(dstBuffer, clear->format, color))
833  return FALSE;
834 
835  dstBuffer += FreeRDPGetBytesPerPixel(clear->format);
836  }
837 
838  /* if (y >= (vBarYOn + vBarShortPixelCount)), use colorBkg */
839  y = vBarYOn + vBarShortPixelCount;
840  count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;
841 
842  if (count > 0)
843  {
844  while (count--)
845  {
846  if (!FreeRDPWriteColor(dstBuffer, clear->format, colorBkg))
847  return FALSE;
848 
849  dstBuffer += FreeRDPGetBytesPerPixel(clear->format);
850  }
851  }
852 
853  vBarEntry->count = vBarPixelCount;
854  clear->VBarStorageCursor = (clear->VBarStorageCursor + 1) % CLEARCODEC_VBAR_SIZE;
855  }
856 
857  if (vBarEntry->count != vBarHeight)
858  {
859  WLog_ERR(TAG, "vBarEntry->count %" PRIu32 " != vBarHeight %" PRIu32 "",
860  vBarEntry->count, vBarHeight);
861  vBarEntry->count = vBarHeight;
862 
863  if (!resize_vbar_entry(clear, vBarEntry))
864  return FALSE;
865  }
866 
867  const UINT32 nXDstRel = nXDst + xStart;
868  const UINT32 nYDstRel = nYDst + yStart;
869  cpSrcPixel = vBarEntry->pixels;
870 
871  if (i < nWidth)
872  {
873  UINT32 count = vBarEntry->count;
874 
875  if (count > nHeight)
876  count = nHeight;
877 
878  if (nXDstRel + i > nDstWidth)
879  return FALSE;
880 
881  for (UINT32 y = 0; y < count; y++)
882  {
883  if (nYDstRel + y > nDstHeight)
884  return FALSE;
885 
886  BYTE* pDstPixel8 =
887  &pDstData[((nYDstRel + y) * nDstStep) +
888  ((nXDstRel + i) * FreeRDPGetBytesPerPixel(DstFormat))];
889  UINT32 color = FreeRDPReadColor(cpSrcPixel, clear->format);
890  color = FreeRDPConvertColor(color, clear->format, DstFormat, NULL);
891 
892  if (!FreeRDPWriteColor(pDstPixel8, DstFormat, color))
893  return FALSE;
894 
895  cpSrcPixel += FreeRDPGetBytesPerPixel(clear->format);
896  }
897  }
898  }
899  }
900 
901  return TRUE;
902 }
903 
904 static BOOL clear_decompress_glyph_data(CLEAR_CONTEXT* WINPR_RESTRICT clear,
905  wStream* WINPR_RESTRICT s, UINT32 glyphFlags, UINT32 nWidth,
906  UINT32 nHeight, BYTE* WINPR_RESTRICT pDstData,
907  UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst,
908  UINT32 nYDst, UINT32 nDstWidth, UINT32 nDstHeight,
909  const gdiPalette* WINPR_RESTRICT palette,
910  BYTE** WINPR_RESTRICT ppGlyphData)
911 {
912  UINT16 glyphIndex = 0;
913 
914  if (ppGlyphData)
915  *ppGlyphData = NULL;
916 
917  if ((glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT) && !(glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX))
918  {
919  WLog_ERR(TAG, "Invalid glyph flags %08" PRIX32 "", glyphFlags);
920  return FALSE;
921  }
922 
923  if ((glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX) == 0)
924  return TRUE;
925 
926  if ((nWidth * nHeight) > (1024 * 1024))
927  {
928  WLog_ERR(TAG, "glyph too large: %" PRIu32 "x%" PRIu32 "", nWidth, nHeight);
929  return FALSE;
930  }
931 
932  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
933  return FALSE;
934 
935  Stream_Read_UINT16(s, glyphIndex);
936 
937  if (glyphIndex >= 4000)
938  {
939  WLog_ERR(TAG, "Invalid glyphIndex %" PRIu16 "", glyphIndex);
940  return FALSE;
941  }
942 
943  if (glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT)
944  {
945  UINT32 nSrcStep = 0;
946  CLEAR_GLYPH_ENTRY* glyphEntry = &(clear->GlyphCache[glyphIndex]);
947  BYTE* glyphData = NULL;
948 
949  if (!glyphEntry)
950  {
951  WLog_ERR(TAG, "clear->GlyphCache[%" PRIu16 "]=NULL", glyphIndex);
952  return FALSE;
953  }
954 
955  glyphData = (BYTE*)glyphEntry->pixels;
956 
957  if (!glyphData)
958  {
959  WLog_ERR(TAG, "clear->GlyphCache[%" PRIu16 "]->pixels=NULL", glyphIndex);
960  return FALSE;
961  }
962 
963  if ((nWidth * nHeight) > glyphEntry->count)
964  {
965  WLog_ERR(TAG,
966  "(nWidth %" PRIu32 " * nHeight %" PRIu32 ") > glyphEntry->count %" PRIu32 "",
967  nWidth, nHeight, glyphEntry->count);
968  return FALSE;
969  }
970 
971  nSrcStep = nWidth * FreeRDPGetBytesPerPixel(clear->format);
972  return convert_color(pDstData, nDstStep, DstFormat, nXDst, nYDst, nWidth, nHeight,
973  glyphData, nSrcStep, clear->format, nDstWidth, nDstHeight, palette);
974  }
975 
976  if (glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX)
977  {
978  const UINT32 bpp = FreeRDPGetBytesPerPixel(clear->format);
979  CLEAR_GLYPH_ENTRY* glyphEntry = &(clear->GlyphCache[glyphIndex]);
980  glyphEntry->count = nWidth * nHeight;
981 
982  if (glyphEntry->count > glyphEntry->size)
983  {
984  BYTE* tmp =
985  winpr_aligned_recalloc(glyphEntry->pixels, glyphEntry->count, 1ull * bpp, 32);
986 
987  if (!tmp)
988  {
989  WLog_ERR(TAG, "glyphEntry->pixels winpr_aligned_recalloc %" PRIu32 " failed!",
990  glyphEntry->count * bpp);
991  return FALSE;
992  }
993 
994  glyphEntry->size = glyphEntry->count;
995  glyphEntry->pixels = (UINT32*)tmp;
996  }
997 
998  if (!glyphEntry->pixels)
999  {
1000  WLog_ERR(TAG, "glyphEntry->pixels=NULL");
1001  return FALSE;
1002  }
1003 
1004  if (ppGlyphData)
1005  *ppGlyphData = (BYTE*)glyphEntry->pixels;
1006 
1007  return TRUE;
1008  }
1009 
1010  return TRUE;
1011 }
1012 
1013 static INLINE BOOL updateContextFormat(CLEAR_CONTEXT* WINPR_RESTRICT clear, UINT32 DstFormat)
1014 {
1015  if (!clear || !clear->nsc)
1016  return FALSE;
1017 
1018  clear->format = DstFormat;
1019  return nsc_context_set_parameters(clear->nsc, NSC_COLOR_FORMAT, DstFormat);
1020 }
1021 
1022 INT32 clear_decompress(CLEAR_CONTEXT* WINPR_RESTRICT clear, const BYTE* WINPR_RESTRICT pSrcData,
1023  UINT32 SrcSize, UINT32 nWidth, UINT32 nHeight, BYTE* WINPR_RESTRICT pDstData,
1024  UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
1025  UINT32 nDstWidth, UINT32 nDstHeight,
1026  const gdiPalette* WINPR_RESTRICT palette)
1027 {
1028  INT32 rc = -1;
1029  BYTE seqNumber = 0;
1030  BYTE glyphFlags = 0;
1031  UINT32 residualByteCount = 0;
1032  UINT32 bandsByteCount = 0;
1033  UINT32 subcodecByteCount = 0;
1034  wStream sbuffer = { 0 };
1035  wStream* s = NULL;
1036  BYTE* glyphData = NULL;
1037 
1038  if (!pDstData)
1039  return -1002;
1040 
1041  if ((nDstWidth == 0) || (nDstHeight == 0))
1042  return -1022;
1043 
1044  if ((nWidth > 0xFFFF) || (nHeight > 0xFFFF))
1045  return -1004;
1046 
1047  s = Stream_StaticConstInit(&sbuffer, pSrcData, SrcSize);
1048 
1049  if (!s)
1050  return -2005;
1051 
1052  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1053  goto fail;
1054 
1055  if (!updateContextFormat(clear, DstFormat))
1056  goto fail;
1057 
1058  Stream_Read_UINT8(s, glyphFlags);
1059  Stream_Read_UINT8(s, seqNumber);
1060 
1061  if (!clear->seqNumber && seqNumber)
1062  clear->seqNumber = seqNumber;
1063 
1064  if (seqNumber != clear->seqNumber)
1065  {
1066  WLog_ERR(TAG, "Sequence number unexpected %" PRIu8 " - %" PRIu32 "", seqNumber,
1067  clear->seqNumber);
1068  WLog_ERR(TAG, "seqNumber %" PRIu8 " != clear->seqNumber %" PRIu32 "", seqNumber,
1069  clear->seqNumber);
1070  goto fail;
1071  }
1072 
1073  clear->seqNumber = (seqNumber + 1) % 256;
1074 
1075  if (glyphFlags & CLEARCODEC_FLAG_CACHE_RESET)
1076  {
1077  clear_reset_vbar_storage(clear, FALSE);
1078  }
1079 
1080  if (!clear_decompress_glyph_data(clear, s, glyphFlags, nWidth, nHeight, pDstData, DstFormat,
1081  nDstStep, nXDst, nYDst, nDstWidth, nDstHeight, palette,
1082  &glyphData))
1083  {
1084  WLog_ERR(TAG, "clear_decompress_glyph_data failed!");
1085  goto fail;
1086  }
1087 
1088  /* Read composition payload header parameters */
1089  if (Stream_GetRemainingLength(s) < 12)
1090  {
1091  const UINT32 mask = (CLEARCODEC_FLAG_GLYPH_HIT | CLEARCODEC_FLAG_GLYPH_INDEX);
1092 
1093  if ((glyphFlags & mask) == mask)
1094  goto finish;
1095 
1096  WLog_ERR(TAG,
1097  "invalid glyphFlags, missing flags: 0x%02" PRIx8 " & 0x%02" PRIx32
1098  " == 0x%02" PRIx32,
1099  glyphFlags, mask, glyphFlags & mask);
1100  goto fail;
1101  }
1102 
1103  Stream_Read_UINT32(s, residualByteCount);
1104  Stream_Read_UINT32(s, bandsByteCount);
1105  Stream_Read_UINT32(s, subcodecByteCount);
1106 
1107  if (residualByteCount > 0)
1108  {
1109  if (!clear_decompress_residual_data(clear, s, residualByteCount, nWidth, nHeight, pDstData,
1110  DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
1111  nDstHeight, palette))
1112  {
1113  WLog_ERR(TAG, "clear_decompress_residual_data failed!");
1114  goto fail;
1115  }
1116  }
1117 
1118  if (bandsByteCount > 0)
1119  {
1120  if (!clear_decompress_bands_data(clear, s, bandsByteCount, nWidth, nHeight, pDstData,
1121  DstFormat, nDstStep, nXDst, nYDst, nDstWidth, nDstHeight))
1122  {
1123  WLog_ERR(TAG, "clear_decompress_bands_data failed!");
1124  goto fail;
1125  }
1126  }
1127 
1128  if (subcodecByteCount > 0)
1129  {
1130  if (!clear_decompress_subcodecs_data(clear, s, subcodecByteCount, nWidth, nHeight, pDstData,
1131  DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
1132  nDstHeight, palette))
1133  {
1134  WLog_ERR(TAG, "clear_decompress_subcodecs_data failed!");
1135  goto fail;
1136  }
1137  }
1138 
1139  if (glyphData)
1140  {
1141  if (!freerdp_image_copy_no_overlap(glyphData, clear->format, 0, 0, 0, nWidth, nHeight,
1142  pDstData, DstFormat, nDstStep, nXDst, nYDst, palette,
1143  FREERDP_KEEP_DST_ALPHA))
1144  goto fail;
1145  }
1146 
1147 finish:
1148  rc = 0;
1149 fail:
1150  return rc;
1151 }
1152 
1153 int clear_compress(CLEAR_CONTEXT* WINPR_RESTRICT clear, const BYTE* WINPR_RESTRICT pSrcData,
1154  UINT32 SrcSize, BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
1155 {
1156  WLog_ERR(TAG, "TODO: not implemented!");
1157  return 1;
1158 }
1159 
1160 BOOL clear_context_reset(CLEAR_CONTEXT* WINPR_RESTRICT clear)
1161 {
1162  if (!clear)
1163  return FALSE;
1164 
1169  clear->seqNumber = 0;
1170  return TRUE;
1171 }
1172 
1173 CLEAR_CONTEXT* clear_context_new(BOOL Compressor)
1174 {
1175  CLEAR_CONTEXT* clear = (CLEAR_CONTEXT*)winpr_aligned_calloc(1, sizeof(CLEAR_CONTEXT), 32);
1176 
1177  if (!clear)
1178  return NULL;
1179 
1180  clear->Compressor = Compressor;
1181  clear->nsc = nsc_context_new();
1182 
1183  if (!clear->nsc)
1184  goto error_nsc;
1185 
1186  if (!updateContextFormat(clear, PIXEL_FORMAT_BGRX32))
1187  goto error_nsc;
1188 
1189  if (!clear_resize_buffer(clear, 512, 512))
1190  goto error_nsc;
1191 
1192  if (!clear->TempBuffer)
1193  goto error_nsc;
1194 
1195  if (!clear_context_reset(clear))
1196  goto error_nsc;
1197 
1198  return clear;
1199 error_nsc:
1200  WINPR_PRAGMA_DIAG_PUSH
1201  WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1202  clear_context_free(clear);
1203  WINPR_PRAGMA_DIAG_POP
1204  return NULL;
1205 }
1206 
1207 void clear_context_free(CLEAR_CONTEXT* clear)
1208 {
1209  if (!clear)
1210  return;
1211 
1212  nsc_context_free(clear->nsc);
1213  winpr_aligned_free(clear->TempBuffer);
1214 
1215  clear_reset_vbar_storage(clear, TRUE);
1216  clear_reset_glyph_cache(clear);
1217 
1218  winpr_aligned_free(clear);
1219 }