Coverage Report

Created: 2024-09-08 06:16

/src/FreeRDP/libfreerdp/codec/interleaved.c
Line
Count
Source (jump to first uncovered line)
1
/**
2
 * FreeRDP: A Remote Desktop Protocol Implementation
3
 * Interleaved RLE Bitmap Codec
4
 *
5
 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
6
 * Copyright 2015 Thincast Technologies GmbH
7
 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
8
 * Copyright 2016 Armin Novak <armin.novak@thincast.com>
9
 * Copyright 2016 Thincast Technologies GmbH
10
 *
11
 * Licensed under the Apache License, Version 2.0 (the "License");
12
 * you may not use this file except in compliance with the License.
13
 * You may obtain a copy of the License at
14
 *
15
 *     http://www.apache.org/licenses/LICENSE-2.0
16
 *
17
 * Unless required by applicable law or agreed to in writing, software
18
 * distributed under the License is distributed on an "AS IS" BASIS,
19
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20
 * See the License for the specific language governing permissions and
21
 * limitations under the License.
22
 */
23
24
#include <winpr/assert.h>
25
#include <freerdp/config.h>
26
27
#include <freerdp/codec/interleaved.h>
28
#include <freerdp/log.h>
29
30
#define TAG FREERDP_TAG("codec")
31
32
#define UNROLL_BODY(_exp, _count)             \
33
0
  do                                        \
34
0
  {                                         \
35
0
    for (size_t x = 0; x < (_count); x++) \
36
0
    {                                     \
37
0
      do                                \
38
0
      {                                 \
39
0
        _exp                          \
40
0
      } while (FALSE);                  \
41
0
    }                                     \
42
0
  } while (FALSE)
43
44
#define UNROLL_MULTIPLE(_condition, _exp, _count) \
45
0
  do                                            \
46
0
  {                                             \
47
0
    while ((_condition) >= (_count))          \
48
0
    {                                         \
49
0
      UNROLL_BODY(_exp, _count);            \
50
0
      (_condition) -= (_count);             \
51
0
    }                                         \
52
0
  } while (FALSE)
53
54
#define UNROLL(_condition, _exp)               \
55
0
  do                                         \
56
0
  {                                          \
57
0
    UNROLL_MULTIPLE(_condition, _exp, 16); \
58
0
    UNROLL_MULTIPLE(_condition, _exp, 4);  \
59
0
    UNROLL_MULTIPLE(_condition, _exp, 1);  \
60
0
  } while (FALSE)
61
62
/*
63
   RLE Compressed Bitmap Stream (RLE_BITMAP_STREAM)
64
   http://msdn.microsoft.com/en-us/library/cc240895%28v=prot.10%29.aspx
65
   pseudo-code
66
   http://msdn.microsoft.com/en-us/library/dd240593%28v=prot.10%29.aspx
67
*/
68
69
0
#define REGULAR_BG_RUN 0x00
70
0
#define MEGA_MEGA_BG_RUN 0xF0
71
0
#define REGULAR_FG_RUN 0x01
72
0
#define MEGA_MEGA_FG_RUN 0xF1
73
0
#define LITE_SET_FG_FG_RUN 0x0C
74
0
#define MEGA_MEGA_SET_FG_RUN 0xF6
75
0
#define LITE_DITHERED_RUN 0x0E
76
0
#define MEGA_MEGA_DITHERED_RUN 0xF8
77
0
#define REGULAR_COLOR_RUN 0x03
78
0
#define MEGA_MEGA_COLOR_RUN 0xF3
79
0
#define REGULAR_FGBG_IMAGE 0x02
80
0
#define MEGA_MEGA_FGBG_IMAGE 0xF2
81
0
#define LITE_SET_FG_FGBG_IMAGE 0x0D
82
0
#define MEGA_MEGA_SET_FGBG_IMAGE 0xF7
83
0
#define REGULAR_COLOR_IMAGE 0x04
84
0
#define MEGA_MEGA_COLOR_IMAGE 0xF4
85
0
#define SPECIAL_FGBG_1 0xF9
86
0
#define SPECIAL_FGBG_2 0xFA
87
0
#define SPECIAL_WHITE 0xFD
88
0
#define SPECIAL_BLACK 0xFE
89
90
#define BLACK_PIXEL 0x000000
91
92
typedef UINT32 PIXEL;
93
94
static const BYTE g_MaskSpecialFgBg1 = 0x03;
95
static const BYTE g_MaskSpecialFgBg2 = 0x05;
96
97
static const BYTE g_MaskRegularRunLength = 0x1F;
98
static const BYTE g_MaskLiteRunLength = 0x0F;
99
100
static const char* rle_code_str(UINT32 code)
101
0
{
102
0
  switch (code)
103
0
  {
104
0
    case REGULAR_BG_RUN:
105
0
      return "REGULAR_BG_RUN";
106
0
    case MEGA_MEGA_BG_RUN:
107
0
      return "MEGA_MEGA_BG_RUN";
108
0
    case REGULAR_FG_RUN:
109
0
      return "REGULAR_FG_RUN";
110
0
    case MEGA_MEGA_FG_RUN:
111
0
      return "MEGA_MEGA_FG_RUN";
112
0
    case LITE_SET_FG_FG_RUN:
113
0
      return "LITE_SET_FG_FG_RUN";
114
0
    case MEGA_MEGA_SET_FG_RUN:
115
0
      return "MEGA_MEGA_SET_FG_RUN";
116
0
    case LITE_DITHERED_RUN:
117
0
      return "LITE_DITHERED_RUN";
118
0
    case MEGA_MEGA_DITHERED_RUN:
119
0
      return "MEGA_MEGA_DITHERED_RUN";
120
0
    case REGULAR_COLOR_RUN:
121
0
      return "REGULAR_COLOR_RUN";
122
0
    case MEGA_MEGA_COLOR_RUN:
123
0
      return "MEGA_MEGA_COLOR_RUN";
124
0
    case REGULAR_FGBG_IMAGE:
125
0
      return "REGULAR_FGBG_IMAGE";
126
0
    case MEGA_MEGA_FGBG_IMAGE:
127
0
      return "MEGA_MEGA_FGBG_IMAGE";
128
0
    case LITE_SET_FG_FGBG_IMAGE:
129
0
      return "LITE_SET_FG_FGBG_IMAGE";
130
0
    case MEGA_MEGA_SET_FGBG_IMAGE:
131
0
      return "MEGA_MEGA_SET_FGBG_IMAGE";
132
0
    case REGULAR_COLOR_IMAGE:
133
0
      return "REGULAR_COLOR_IMAGE";
134
0
    case MEGA_MEGA_COLOR_IMAGE:
135
0
      return "MEGA_MEGA_COLOR_IMAGE";
136
0
    case SPECIAL_FGBG_1:
137
0
      return "SPECIAL_FGBG_1";
138
0
    case SPECIAL_FGBG_2:
139
0
      return "SPECIAL_FGBG_2";
140
0
    case SPECIAL_WHITE:
141
0
      return "SPECIAL_WHITE";
142
0
    case SPECIAL_BLACK:
143
0
      return "SPECIAL_BLACK";
144
0
    default:
145
0
      return "UNKNOWN";
146
0
  }
147
0
}
148
149
static const char* rle_code_str_buffer(UINT32 code, char* buffer, size_t size)
150
0
{
151
0
  const char* str = rle_code_str(code);
152
0
  (void)_snprintf(buffer, size, "%s [0x%08" PRIx32 "]", str, code);
153
0
  return buffer;
154
0
}
155
156
#define buffer_within_range(pbSrc, size, pbEnd) \
157
0
  buffer_within_range_((pbSrc), (size), (pbEnd), __func__, __FILE__, __LINE__)
158
static INLINE BOOL buffer_within_range_(const void* pbSrc, size_t size, const void* pbEnd,
159
                                        const char* fkt, const char* file, size_t line)
160
0
{
161
0
  WINPR_UNUSED(file);
162
0
  WINPR_ASSERT(pbSrc);
163
0
  WINPR_ASSERT(pbEnd);
164
165
0
  if ((const char*)pbSrc + size > (const char*)pbEnd)
166
0
  {
167
0
    WLog_ERR(TAG, "[%s:%" PRIuz "] pbSrc=%p + %" PRIuz " > pbEnd=%p", fkt, line, pbSrc, size,
168
0
             pbEnd);
169
0
    return FALSE;
170
0
  }
171
0
  return TRUE;
172
0
}
173
174
/**
175
 * Reads the supplied order header and extracts the compression
176
 * order code ID.
177
 */
178
static INLINE UINT32 ExtractCodeId(BYTE bOrderHdr)
179
0
{
180
0
  if ((bOrderHdr & 0xC0U) != 0xC0U)
181
0
  {
182
    /* REGULAR orders
183
     * (000x xxxx, 001x xxxx, 010x xxxx, 011x xxxx, 100x xxxx)
184
     */
185
0
    return bOrderHdr >> 5;
186
0
  }
187
0
  else if ((bOrderHdr & 0xF0U) == 0xF0U)
188
0
  {
189
    /* MEGA and SPECIAL orders (0xF*) */
190
0
    return bOrderHdr;
191
0
  }
192
0
  else
193
0
  {
194
    /* LITE orders
195
     * 1100 xxxx, 1101 xxxx, 1110 xxxx)
196
     */
197
0
    return bOrderHdr >> 4;
198
0
  }
199
0
}
200
201
/**
202
 * Extract the run length of a compression order.
203
 */
204
static UINT ExtractRunLengthRegularFgBg(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
205
0
{
206
0
  UINT runLength = 0;
207
208
0
  WINPR_ASSERT(pbOrderHdr);
209
0
  WINPR_ASSERT(pbEnd);
210
0
  WINPR_ASSERT(advance);
211
212
0
  runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
213
0
  if (runLength == 0)
214
0
  {
215
0
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
216
0
    {
217
0
      *advance = 0;
218
0
      return 0;
219
0
    }
220
0
    runLength = *(pbOrderHdr + 1) + 1;
221
0
    (*advance)++;
222
0
  }
223
0
  else
224
0
    runLength = runLength * 8;
225
226
0
  return runLength;
227
0
}
228
229
static UINT ExtractRunLengthLiteFgBg(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
230
0
{
231
0
  UINT runLength = 0;
232
233
0
  WINPR_ASSERT(pbOrderHdr);
234
0
  WINPR_ASSERT(pbEnd);
235
0
  WINPR_ASSERT(advance);
236
237
0
  runLength = *pbOrderHdr & g_MaskLiteRunLength;
238
0
  if (runLength == 0)
239
0
  {
240
0
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
241
0
    {
242
0
      *advance = 0;
243
0
      return 0;
244
0
    }
245
0
    runLength = *(pbOrderHdr + 1) + 1;
246
0
    (*advance)++;
247
0
  }
248
0
  else
249
0
    runLength = runLength * 8;
250
251
0
  return runLength;
252
0
}
253
254
static UINT ExtractRunLengthRegular(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
255
0
{
256
0
  UINT runLength = 0;
257
258
0
  WINPR_ASSERT(pbOrderHdr);
259
0
  WINPR_ASSERT(pbEnd);
260
0
  WINPR_ASSERT(advance);
261
262
0
  runLength = *pbOrderHdr & g_MaskRegularRunLength;
263
0
  if (runLength == 0)
264
0
  {
265
0
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
266
0
    {
267
0
      *advance = 0;
268
0
      return 0;
269
0
    }
270
0
    runLength = *(pbOrderHdr + 1) + 32;
271
0
    (*advance)++;
272
0
  }
273
274
0
  return runLength;
275
0
}
276
277
static UINT ExtractRunLengthMegaMega(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
278
0
{
279
0
  UINT runLength = 0;
280
281
0
  WINPR_ASSERT(pbOrderHdr);
282
0
  WINPR_ASSERT(pbEnd);
283
0
  WINPR_ASSERT(advance);
284
285
0
  if (!buffer_within_range(pbOrderHdr, 3, pbEnd))
286
0
  {
287
0
    *advance = 0;
288
0
    return 0;
289
0
  }
290
291
0
  runLength = ((UINT16)pbOrderHdr[1]) | (((UINT16)pbOrderHdr[2]) << 8);
292
0
  (*advance) += 2;
293
294
0
  return runLength;
295
0
}
296
297
static UINT ExtractRunLengthLite(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
298
0
{
299
0
  UINT runLength = 0;
300
301
0
  WINPR_ASSERT(pbOrderHdr);
302
0
  WINPR_ASSERT(pbEnd);
303
0
  WINPR_ASSERT(advance);
304
305
0
  runLength = *pbOrderHdr & g_MaskLiteRunLength;
306
0
  if (runLength == 0)
307
0
  {
308
0
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
309
0
    {
310
0
      *advance = 0;
311
0
      return 0;
312
0
    }
313
0
    runLength = *(pbOrderHdr + 1) + 16;
314
0
    (*advance)++;
315
0
  }
316
0
  return runLength;
317
0
}
318
319
static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, const BYTE* pbEnd,
320
                                      UINT32* advance)
321
0
{
322
0
  UINT32 runLength = 0;
323
0
  UINT32 ladvance = 1;
324
325
0
  WINPR_ASSERT(pbOrderHdr);
326
0
  WINPR_ASSERT(pbEnd);
327
0
  WINPR_ASSERT(advance);
328
329
0
  *advance = 0;
330
0
  if (!buffer_within_range(pbOrderHdr, 0, pbEnd))
331
0
    return 0;
332
333
0
  switch (code)
334
0
  {
335
0
    case REGULAR_FGBG_IMAGE:
336
0
      runLength = ExtractRunLengthRegularFgBg(pbOrderHdr, pbEnd, &ladvance);
337
0
      break;
338
339
0
    case LITE_SET_FG_FGBG_IMAGE:
340
0
      runLength = ExtractRunLengthLiteFgBg(pbOrderHdr, pbEnd, &ladvance);
341
0
      break;
342
343
0
    case REGULAR_BG_RUN:
344
0
    case REGULAR_FG_RUN:
345
0
    case REGULAR_COLOR_RUN:
346
0
    case REGULAR_COLOR_IMAGE:
347
0
      runLength = ExtractRunLengthRegular(pbOrderHdr, pbEnd, &ladvance);
348
0
      break;
349
350
0
    case LITE_SET_FG_FG_RUN:
351
0
    case LITE_DITHERED_RUN:
352
0
      runLength = ExtractRunLengthLite(pbOrderHdr, pbEnd, &ladvance);
353
0
      break;
354
355
0
    case MEGA_MEGA_BG_RUN:
356
0
    case MEGA_MEGA_FG_RUN:
357
0
    case MEGA_MEGA_SET_FG_RUN:
358
0
    case MEGA_MEGA_DITHERED_RUN:
359
0
    case MEGA_MEGA_COLOR_RUN:
360
0
    case MEGA_MEGA_FGBG_IMAGE:
361
0
    case MEGA_MEGA_SET_FGBG_IMAGE:
362
0
    case MEGA_MEGA_COLOR_IMAGE:
363
0
      runLength = ExtractRunLengthMegaMega(pbOrderHdr, pbEnd, &ladvance);
364
0
      break;
365
366
0
    default:
367
0
      runLength = 0;
368
0
      ladvance = 0;
369
0
      break;
370
0
  }
371
372
0
  *advance = ladvance;
373
0
  return runLength;
374
0
}
375
376
#define ensure_capacity(start, end, size, base) \
377
0
  ensure_capacity_((start), (end), (size), (base), __func__, __FILE__, __LINE__)
378
static INLINE BOOL ensure_capacity_(const BYTE* start, const BYTE* end, size_t size, size_t base,
379
                                    const char* fkt, const char* file, size_t line)
380
0
{
381
0
  const size_t available = (uintptr_t)end - (uintptr_t)start;
382
0
  const BOOL rc = available >= size * base;
383
0
  const BOOL res = rc && (start <= end);
384
385
0
  if (!res)
386
0
    WLog_ERR(TAG,
387
0
             "[%s:%" PRIuz "] failed: start=%p <= end=%p, available=%" PRIuz " >= size=%" PRIuz
388
0
             " * base=%" PRIuz,
389
0
             fkt, line, start, end, available, size, base);
390
0
  return res;
391
0
}
392
393
static INLINE void write_pixel_8(BYTE* _buf, BYTE _pix)
394
0
{
395
0
  WINPR_ASSERT(_buf);
396
0
  *_buf = _pix;
397
0
}
398
399
static INLINE void write_pixel_24(BYTE* _buf, UINT32 _pix)
400
0
{
401
0
  WINPR_ASSERT(_buf);
402
0
  (_buf)[0] = (BYTE)(_pix);
403
0
  (_buf)[1] = (BYTE)((_pix) >> 8);
404
0
  (_buf)[2] = (BYTE)((_pix) >> 16);
405
0
}
406
407
static INLINE void write_pixel_16(BYTE* _buf, UINT16 _pix)
408
0
{
409
0
  WINPR_ASSERT(_buf);
410
0
  _buf[0] = _pix & 0xFF;
411
0
  _buf[1] = (_pix >> 8) & 0xFF;
412
0
}
413
414
#undef DESTWRITEPIXEL
415
#undef DESTREADPIXEL
416
#undef SRCREADPIXEL
417
#undef WRITEFGBGIMAGE
418
#undef WRITEFIRSTLINEFGBGIMAGE
419
#undef RLEDECOMPRESS
420
#undef RLEEXTRA
421
#undef WHITE_PIXEL
422
#undef PIXEL_SIZE
423
#undef PIXEL
424
#define PIXEL_SIZE 1
425
0
#define PIXEL BYTE
426
0
#define WHITE_PIXEL 0xFF
427
#define DESTWRITEPIXEL(_buf, _pix) \
428
0
  do                             \
429
0
  {                              \
430
0
    write_pixel_8(_buf, _pix); \
431
0
    (_buf) += 1;               \
432
0
  } while (0)
433
0
#define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0]
434
#define SRCREADPIXEL(_pix, _buf) \
435
0
  do                           \
436
0
  {                            \
437
0
    (_pix) = (_buf)[0];      \
438
0
    (_buf) += 1;             \
439
0
  } while (0)
440
441
0
#define WRITEFGBGIMAGE WriteFgBgImage8to8
442
0
#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage8to8
443
#define RLEDECOMPRESS RleDecompress8to8
444
#define RLEEXTRA
445
#undef ENSURE_CAPACITY
446
0
#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 1)
447
#include "include/bitmap.h"
448
449
#undef DESTWRITEPIXEL
450
#undef DESTREADPIXEL
451
#undef SRCREADPIXEL
452
#undef WRITEFGBGIMAGE
453
#undef WRITEFIRSTLINEFGBGIMAGE
454
#undef RLEDECOMPRESS
455
#undef RLEEXTRA
456
#undef WHITE_PIXEL
457
#undef PIXEL_SIZE
458
#undef PIXEL
459
#define PIXEL_SIZE 2
460
0
#define PIXEL UINT16
461
0
#define WHITE_PIXEL 0xFFFF
462
#define DESTWRITEPIXEL(_buf, _pix)  \
463
0
  do                              \
464
0
  {                               \
465
0
    write_pixel_16(_buf, _pix); \
466
0
    (_buf) += 2;                \
467
0
  } while (0)
468
0
#define DESTREADPIXEL(_pix, _buf) _pix = ((UINT16*)(_buf))[0]
469
#define SRCREADPIXEL(_pix, _buf)               \
470
0
  do                                         \
471
0
  {                                          \
472
0
    (_pix) = (_buf)[0] | ((_buf)[1] << 8); \
473
0
    (_buf) += 2;                           \
474
0
  } while (0)
475
0
#define WRITEFGBGIMAGE WriteFgBgImage16to16
476
0
#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage16to16
477
#define RLEDECOMPRESS RleDecompress16to16
478
#define RLEEXTRA
479
#undef ENSURE_CAPACITY
480
0
#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 2)
481
#include "include/bitmap.h"
482
483
#undef DESTWRITEPIXEL
484
#undef DESTREADPIXEL
485
#undef SRCREADPIXEL
486
#undef WRITEFGBGIMAGE
487
#undef WRITEFIRSTLINEFGBGIMAGE
488
#undef RLEDECOMPRESS
489
#undef RLEEXTRA
490
#undef WHITE_PIXEL
491
#undef PIXEL_SIZE
492
#undef PIXEL
493
#define PIXEL_SIZE 3
494
0
#define PIXEL UINT32
495
0
#define WHITE_PIXEL 0xffffff
496
#define DESTWRITEPIXEL(_buf, _pix)  \
497
0
  do                              \
498
0
  {                               \
499
0
    write_pixel_24(_buf, _pix); \
500
0
    (_buf) += 3;                \
501
0
  } while (0)
502
0
#define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16)
503
#define SRCREADPIXEL(_pix, _buf)                                   \
504
0
  do                                                             \
505
0
  {                                                              \
506
0
    (_pix) = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16); \
507
0
    (_buf) += 3;                                               \
508
0
  } while (0)
509
510
0
#define WRITEFGBGIMAGE WriteFgBgImage24to24
511
0
#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage24to24
512
#define RLEDECOMPRESS RleDecompress24to24
513
#define RLEEXTRA
514
#undef ENSURE_CAPACITY
515
0
#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 3)
516
#include "include/bitmap.h"
517
518
struct S_BITMAP_INTERLEAVED_CONTEXT
519
{
520
  BOOL Compressor;
521
522
  UINT32 TempSize;
523
  BYTE* TempBuffer;
524
525
  wStream* bts;
526
};
527
528
BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved,
529
                            const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth,
530
                            UINT32 nSrcHeight, UINT32 bpp, BYTE* WINPR_RESTRICT pDstData,
531
                            UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
532
                            UINT32 nDstWidth, UINT32 nDstHeight,
533
                            const gdiPalette* WINPR_RESTRICT palette)
534
0
{
535
0
  UINT32 scanline = 0;
536
0
  UINT32 SrcFormat = 0;
537
0
  UINT32 BufferSize = 0;
538
539
0
  if (!interleaved || !pSrcData || !pDstData)
540
0
  {
541
0
    WLog_ERR(TAG, "invalid arguments: interleaved=%p, pSrcData=%p, pDstData=%p", interleaved,
542
0
             pSrcData, pDstData);
543
0
    return FALSE;
544
0
  }
545
546
0
  switch (bpp)
547
0
  {
548
0
    case 24:
549
0
      scanline = nSrcWidth * 3;
550
0
      SrcFormat = PIXEL_FORMAT_BGR24;
551
0
      break;
552
553
0
    case 16:
554
0
      scanline = nSrcWidth * 2;
555
0
      SrcFormat = PIXEL_FORMAT_RGB16;
556
0
      break;
557
558
0
    case 15:
559
0
      scanline = nSrcWidth * 2;
560
0
      SrcFormat = PIXEL_FORMAT_RGB15;
561
0
      break;
562
563
0
    case 8:
564
0
      scanline = nSrcWidth;
565
0
      SrcFormat = PIXEL_FORMAT_RGB8;
566
0
      break;
567
568
0
    default:
569
0
      WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
570
0
      return FALSE;
571
0
  }
572
573
0
  BufferSize = scanline * nSrcHeight;
574
575
0
  if (BufferSize > interleaved->TempSize)
576
0
  {
577
0
    interleaved->TempBuffer =
578
0
        winpr_aligned_recalloc(interleaved->TempBuffer, BufferSize, sizeof(BYTE), 16);
579
0
    interleaved->TempSize = BufferSize;
580
0
  }
581
582
0
  if (!interleaved->TempBuffer)
583
0
  {
584
0
    WLog_ERR(TAG, "interleaved->TempBuffer=%p", interleaved->TempBuffer);
585
0
    return FALSE;
586
0
  }
587
588
0
  switch (bpp)
589
0
  {
590
0
    case 24:
591
0
      if (!RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
592
0
                               nSrcWidth, nSrcHeight))
593
0
      {
594
0
        WLog_ERR(TAG, "RleDecompress24to24 failed");
595
0
        return FALSE;
596
0
      }
597
598
0
      break;
599
600
0
    case 16:
601
0
    case 15:
602
0
      if (!RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
603
0
                               nSrcWidth, nSrcHeight))
604
0
      {
605
0
        WLog_ERR(TAG, "RleDecompress16to16 failed");
606
0
        return FALSE;
607
0
      }
608
609
0
      break;
610
611
0
    case 8:
612
0
      if (!RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer, scanline, nSrcWidth,
613
0
                             nSrcHeight))
614
0
      {
615
0
        WLog_ERR(TAG, "RleDecompress8to8 failed");
616
0
        return FALSE;
617
0
      }
618
619
0
      break;
620
621
0
    default:
622
0
      WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
623
0
      return FALSE;
624
0
  }
625
626
0
  if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
627
0
                                     nDstHeight, interleaved->TempBuffer, SrcFormat, scanline, 0,
628
0
                                     0, palette, FREERDP_FLIP_VERTICAL | FREERDP_KEEP_DST_ALPHA))
629
0
  {
630
0
    WLog_ERR(TAG, "freerdp_image_copy failed");
631
0
    return FALSE;
632
0
  }
633
0
  return TRUE;
634
0
}
635
636
BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved,
637
                          BYTE* WINPR_RESTRICT pDstData, UINT32* pDstSize, UINT32 nWidth,
638
                          UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcFormat,
639
                          UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
640
                          const gdiPalette* WINPR_RESTRICT palette, UINT32 bpp)
641
0
{
642
0
  BOOL status = 0;
643
0
  wStream* s = NULL;
644
0
  UINT32 DstFormat = 0;
645
0
  const UINT32 maxSize = 64 * 64 * 4;
646
647
0
  if (!interleaved || !pDstData || !pSrcData)
648
0
    return FALSE;
649
650
0
  if ((nWidth == 0) || (nHeight == 0))
651
0
    return FALSE;
652
653
0
  if (nWidth % 4)
654
0
  {
655
0
    WLog_ERR(TAG, "interleaved_compress: width is not a multiple of 4");
656
0
    return FALSE;
657
0
  }
658
659
0
  if ((nWidth > 64) || (nHeight > 64))
660
0
  {
661
0
    WLog_ERR(TAG,
662
0
             "interleaved_compress: width (%" PRIu32 ") or height (%" PRIu32
663
0
             ") is greater than 64",
664
0
             nWidth, nHeight);
665
0
    return FALSE;
666
0
  }
667
668
0
  switch (bpp)
669
0
  {
670
0
    case 24:
671
0
      DstFormat = PIXEL_FORMAT_BGRX32;
672
0
      break;
673
674
0
    case 16:
675
0
      DstFormat = PIXEL_FORMAT_RGB16;
676
0
      break;
677
678
0
    case 15:
679
0
      DstFormat = PIXEL_FORMAT_RGB15;
680
0
      break;
681
682
0
    default:
683
0
      return FALSE;
684
0
  }
685
686
0
  if (!freerdp_image_copy_no_overlap(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth, nHeight,
687
0
                                     pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette,
688
0
                                     FREERDP_KEEP_DST_ALPHA))
689
0
    return FALSE;
690
691
0
  s = Stream_New(pDstData, *pDstSize);
692
693
0
  if (!s)
694
0
    return FALSE;
695
696
0
  Stream_SetPosition(interleaved->bts, 0);
697
698
0
  if (freerdp_bitmap_compress(interleaved->TempBuffer, nWidth, nHeight, s, bpp, maxSize,
699
0
                              nHeight - 1, interleaved->bts, 0) < 0)
700
0
    status = FALSE;
701
0
  else
702
0
    status = TRUE;
703
704
0
  Stream_SealLength(s);
705
0
  *pDstSize = (UINT32)Stream_Length(s);
706
0
  Stream_Free(s, FALSE);
707
0
  return status;
708
0
}
709
710
BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
711
0
{
712
0
  if (!interleaved)
713
0
    return FALSE;
714
715
0
  return TRUE;
716
0
}
717
718
BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor)
719
0
{
720
0
  BITMAP_INTERLEAVED_CONTEXT* interleaved = NULL;
721
0
  interleaved = (BITMAP_INTERLEAVED_CONTEXT*)winpr_aligned_recalloc(
722
0
      NULL, 1, sizeof(BITMAP_INTERLEAVED_CONTEXT), 32);
723
724
0
  if (interleaved)
725
0
  {
726
0
    interleaved->TempSize = 64 * 64 * 4;
727
0
    interleaved->TempBuffer = winpr_aligned_calloc(interleaved->TempSize, sizeof(BYTE), 16);
728
729
0
    if (!interleaved->TempBuffer)
730
0
      goto fail;
731
732
0
    interleaved->bts = Stream_New(NULL, interleaved->TempSize);
733
734
0
    if (!interleaved->bts)
735
0
      goto fail;
736
0
  }
737
738
0
  return interleaved;
739
740
0
fail:
741
0
  WINPR_PRAGMA_DIAG_PUSH
742
0
  WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
743
0
  bitmap_interleaved_context_free(interleaved);
744
0
  WINPR_PRAGMA_DIAG_POP
745
0
  return NULL;
746
0
}
747
748
void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
749
0
{
750
0
  if (!interleaved)
751
0
    return;
752
753
0
  winpr_aligned_free(interleaved->TempBuffer);
754
0
  Stream_Free(interleaved->bts, TRUE);
755
0
  winpr_aligned_free(interleaved);
756
0
}