Coverage Report

Created: 2024-09-08 06:18

/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
1.98M
  do                                        \
34
1.98M
  {                                         \
35
13.5M
    for (size_t x = 0; x < (_count); x++) \
36
11.5M
    {                                     \
37
11.5M
      do                                \
38
11.5M
      {                                 \
39
26.6M
        _exp                          \
40
11.5M
      } while (FALSE);                  \
41
11.5M
    }                                     \
42
1.98M
  } while (FALSE)
43
44
#define UNROLL_MULTIPLE(_condition, _exp, _count) \
45
1.70M
  do                                            \
46
1.70M
  {                                             \
47
3.68M
    while ((_condition) >= (_count))          \
48
1.98M
    {                                         \
49
1.98M
      UNROLL_BODY(_exp, _count);            \
50
1.98M
      (_condition) -= (_count);             \
51
1.98M
    }                                         \
52
1.70M
  } while (FALSE)
53
54
#define UNROLL(_condition, _exp)               \
55
567k
  do                                         \
56
567k
  {                                          \
57
567k
    UNROLL_MULTIPLE(_condition, _exp, 16); \
58
567k
    UNROLL_MULTIPLE(_condition, _exp, 4);  \
59
567k
    UNROLL_MULTIPLE(_condition, _exp, 1);  \
60
567k
  } 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
745k
#define REGULAR_BG_RUN 0x00
70
216k
#define MEGA_MEGA_BG_RUN 0xF0
71
347k
#define REGULAR_FG_RUN 0x01
72
47.2k
#define MEGA_MEGA_FG_RUN 0xF1
73
193k
#define LITE_SET_FG_FG_RUN 0x0C
74
109k
#define MEGA_MEGA_SET_FG_RUN 0xF6
75
40.2k
#define LITE_DITHERED_RUN 0x0E
76
19.7k
#define MEGA_MEGA_DITHERED_RUN 0xF8
77
484k
#define REGULAR_COLOR_RUN 0x03
78
97.4k
#define MEGA_MEGA_COLOR_RUN 0xF3
79
27.9k
#define REGULAR_FGBG_IMAGE 0x02
80
25.7k
#define MEGA_MEGA_FGBG_IMAGE 0xF2
81
65.7k
#define LITE_SET_FG_FGBG_IMAGE 0x0D
82
48.8k
#define MEGA_MEGA_SET_FGBG_IMAGE 0xF7
83
414k
#define REGULAR_COLOR_IMAGE 0x04
84
25.1k
#define MEGA_MEGA_COLOR_IMAGE 0xF4
85
2.69k
#define SPECIAL_FGBG_1 0xF9
86
3.69k
#define SPECIAL_FGBG_2 0xFA
87
2.15k
#define SPECIAL_WHITE 0xFD
88
2.31k
#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
812k
  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
812k
{
161
812k
  WINPR_UNUSED(file);
162
812k
  WINPR_ASSERT(pbSrc);
163
812k
  WINPR_ASSERT(pbEnd);
164
165
812k
  if ((const char*)pbSrc + size > (const char*)pbEnd)
166
3.52k
  {
167
3.52k
    WLog_ERR(TAG, "[%s:%" PRIuz "] pbSrc=%p + %" PRIuz " > pbEnd=%p", fkt, line, pbSrc, size,
168
3.52k
             pbEnd);
169
3.52k
    return FALSE;
170
3.52k
  }
171
808k
  return TRUE;
172
812k
}
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
480k
{
180
480k
  if ((bOrderHdr & 0xC0U) != 0xC0U)
181
420k
  {
182
    /* REGULAR orders
183
     * (000x xxxx, 001x xxxx, 010x xxxx, 011x xxxx, 100x xxxx)
184
     */
185
420k
    return bOrderHdr >> 5;
186
420k
  }
187
60.3k
  else if ((bOrderHdr & 0xF0U) == 0xF0U)
188
28.7k
  {
189
    /* MEGA and SPECIAL orders (0xF*) */
190
28.7k
    return bOrderHdr;
191
28.7k
  }
192
31.5k
  else
193
31.5k
  {
194
    /* LITE orders
195
     * 1100 xxxx, 1101 xxxx, 1110 xxxx)
196
     */
197
31.5k
    return bOrderHdr >> 4;
198
31.5k
  }
199
480k
}
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
13.9k
{
206
13.9k
  UINT runLength = 0;
207
208
13.9k
  WINPR_ASSERT(pbOrderHdr);
209
13.9k
  WINPR_ASSERT(pbEnd);
210
13.9k
  WINPR_ASSERT(advance);
211
212
13.9k
  runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
213
13.9k
  if (runLength == 0)
214
5.81k
  {
215
5.81k
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
216
38
    {
217
38
      *advance = 0;
218
38
      return 0;
219
38
    }
220
5.77k
    runLength = *(pbOrderHdr + 1) + 1;
221
5.77k
    (*advance)++;
222
5.77k
  }
223
8.14k
  else
224
8.14k
    runLength = runLength * 8;
225
226
13.9k
  return runLength;
227
13.9k
}
228
229
static UINT ExtractRunLengthLiteFgBg(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
230
3.80k
{
231
3.80k
  UINT runLength = 0;
232
233
3.80k
  WINPR_ASSERT(pbOrderHdr);
234
3.80k
  WINPR_ASSERT(pbEnd);
235
3.80k
  WINPR_ASSERT(advance);
236
237
3.80k
  runLength = *pbOrderHdr & g_MaskLiteRunLength;
238
3.80k
  if (runLength == 0)
239
486
  {
240
486
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
241
9
    {
242
9
      *advance = 0;
243
9
      return 0;
244
9
    }
245
477
    runLength = *(pbOrderHdr + 1) + 1;
246
477
    (*advance)++;
247
477
  }
248
3.32k
  else
249
3.32k
    runLength = runLength * 8;
250
251
3.79k
  return runLength;
252
3.80k
}
253
254
static UINT ExtractRunLengthRegular(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
255
404k
{
256
404k
  UINT runLength = 0;
257
258
404k
  WINPR_ASSERT(pbOrderHdr);
259
404k
  WINPR_ASSERT(pbEnd);
260
404k
  WINPR_ASSERT(advance);
261
262
404k
  runLength = *pbOrderHdr & g_MaskRegularRunLength;
263
404k
  if (runLength == 0)
264
138k
  {
265
138k
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
266
616
    {
267
616
      *advance = 0;
268
616
      return 0;
269
616
    }
270
138k
    runLength = *(pbOrderHdr + 1) + 32;
271
138k
    (*advance)++;
272
138k
  }
273
274
404k
  return runLength;
275
404k
}
276
277
static UINT ExtractRunLengthMegaMega(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
278
13.1k
{
279
13.1k
  UINT runLength = 0;
280
281
13.1k
  WINPR_ASSERT(pbOrderHdr);
282
13.1k
  WINPR_ASSERT(pbEnd);
283
13.1k
  WINPR_ASSERT(advance);
284
285
13.1k
  if (!buffer_within_range(pbOrderHdr, 3, pbEnd))
286
379
  {
287
379
    *advance = 0;
288
379
    return 0;
289
379
  }
290
291
12.7k
  runLength = ((UINT16)pbOrderHdr[1]) | (((UINT16)pbOrderHdr[2]) << 8);
292
12.7k
  (*advance) += 2;
293
294
12.7k
  return runLength;
295
13.1k
}
296
297
static UINT ExtractRunLengthLite(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance)
298
27.7k
{
299
27.7k
  UINT runLength = 0;
300
301
27.7k
  WINPR_ASSERT(pbOrderHdr);
302
27.7k
  WINPR_ASSERT(pbEnd);
303
27.7k
  WINPR_ASSERT(advance);
304
305
27.7k
  runLength = *pbOrderHdr & g_MaskLiteRunLength;
306
27.7k
  if (runLength == 0)
307
3.69k
  {
308
3.69k
    if (!buffer_within_range(pbOrderHdr, 2, pbEnd))
309
20
    {
310
20
      *advance = 0;
311
20
      return 0;
312
20
    }
313
3.67k
    runLength = *(pbOrderHdr + 1) + 16;
314
3.67k
    (*advance)++;
315
3.67k
  }
316
27.7k
  return runLength;
317
27.7k
}
318
319
static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, const BYTE* pbEnd,
320
                                      UINT32* advance)
321
463k
{
322
463k
  UINT32 runLength = 0;
323
463k
  UINT32 ladvance = 1;
324
325
463k
  WINPR_ASSERT(pbOrderHdr);
326
463k
  WINPR_ASSERT(pbEnd);
327
463k
  WINPR_ASSERT(advance);
328
329
463k
  *advance = 0;
330
463k
  if (!buffer_within_range(pbOrderHdr, 0, pbEnd))
331
0
    return 0;
332
333
463k
  switch (code)
334
463k
  {
335
13.9k
    case REGULAR_FGBG_IMAGE:
336
13.9k
      runLength = ExtractRunLengthRegularFgBg(pbOrderHdr, pbEnd, &ladvance);
337
13.9k
      break;
338
339
3.80k
    case LITE_SET_FG_FGBG_IMAGE:
340
3.80k
      runLength = ExtractRunLengthLiteFgBg(pbOrderHdr, pbEnd, &ladvance);
341
3.80k
      break;
342
343
265k
    case REGULAR_BG_RUN:
344
306k
    case REGULAR_FG_RUN:
345
395k
    case REGULAR_COLOR_RUN:
346
404k
    case REGULAR_COLOR_IMAGE:
347
404k
      runLength = ExtractRunLengthRegular(pbOrderHdr, pbEnd, &ladvance);
348
404k
      break;
349
350
15.2k
    case LITE_SET_FG_FG_RUN:
351
27.7k
    case LITE_DITHERED_RUN:
352
27.7k
      runLength = ExtractRunLengthLite(pbOrderHdr, pbEnd, &ladvance);
353
27.7k
      break;
354
355
1.60k
    case MEGA_MEGA_BG_RUN:
356
3.93k
    case MEGA_MEGA_FG_RUN:
357
5.11k
    case MEGA_MEGA_SET_FG_RUN:
358
6.16k
    case MEGA_MEGA_DITHERED_RUN:
359
7.20k
    case MEGA_MEGA_COLOR_RUN:
360
9.48k
    case MEGA_MEGA_FGBG_IMAGE:
361
10.5k
    case MEGA_MEGA_SET_FGBG_IMAGE:
362
13.1k
    case MEGA_MEGA_COLOR_IMAGE:
363
13.1k
      runLength = ExtractRunLengthMegaMega(pbOrderHdr, pbEnd, &ladvance);
364
13.1k
      break;
365
366
0
    default:
367
0
      runLength = 0;
368
0
      ladvance = 0;
369
0
      break;
370
463k
  }
371
372
463k
  *advance = ladvance;
373
463k
  return runLength;
374
463k
}
375
376
#define ensure_capacity(start, end, size, base) \
377
816k
  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
816k
{
381
816k
  const size_t available = (uintptr_t)end - (uintptr_t)start;
382
816k
  const BOOL rc = available >= size * base;
383
816k
  const BOOL res = rc && (start <= end);
384
385
816k
  if (!res)
386
816k
    WLog_ERR(TAG,
387
816k
             "[%s:%" PRIuz "] failed: start=%p <= end=%p, available=%" PRIuz " >= size=%" PRIuz
388
816k
             " * base=%" PRIuz,
389
816k
             fkt, line, start, end, available, size, base);
390
816k
  return res;
391
816k
}
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
3.81M
{
401
3.81M
  WINPR_ASSERT(_buf);
402
3.81M
  (_buf)[0] = (BYTE)(_pix);
403
3.81M
  (_buf)[1] = (BYTE)((_pix) >> 8);
404
3.81M
  (_buf)[2] = (BYTE)((_pix) >> 16);
405
3.81M
}
406
407
static INLINE void write_pixel_16(BYTE* _buf, UINT16 _pix)
408
8.61M
{
409
8.61M
  WINPR_ASSERT(_buf);
410
8.61M
  _buf[0] = _pix & 0xFF;
411
8.61M
  _buf[1] = (_pix >> 8) & 0xFF;
412
8.61M
}
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
100k
#define PIXEL UINT16
461
10.8k
#define WHITE_PIXEL 0xFFFF
462
#define DESTWRITEPIXEL(_buf, _pix)  \
463
158k
  do                              \
464
158k
  {                               \
465
158k
    write_pixel_16(_buf, _pix); \
466
158k
    (_buf) += 2;                \
467
158k
  } while (0)
468
142k
#define DESTREADPIXEL(_pix, _buf) _pix = ((UINT16*)(_buf))[0]
469
#define SRCREADPIXEL(_pix, _buf)               \
470
92.8k
  do                                         \
471
92.8k
  {                                          \
472
92.8k
    (_pix) = (_buf)[0] | ((_buf)[1] << 8); \
473
92.8k
    (_buf) += 2;                           \
474
92.8k
  } while (0)
475
68.4k
#define WRITEFGBGIMAGE WriteFgBgImage16to16
476
22.5k
#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage16to16
477
#define RLEDECOMPRESS RleDecompress16to16
478
#define RLEEXTRA
479
#undef ENSURE_CAPACITY
480
556k
#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
43.9k
#define PIXEL UINT32
495
5.40k
#define WHITE_PIXEL 0xffffff
496
#define DESTWRITEPIXEL(_buf, _pix)  \
497
76.4k
  do                              \
498
76.4k
  {                               \
499
76.4k
    write_pixel_24(_buf, _pix); \
500
76.4k
    (_buf) += 3;                \
501
76.4k
  } while (0)
502
68.1k
#define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16)
503
#define SRCREADPIXEL(_pix, _buf)                                   \
504
43.8k
  do                                                             \
505
43.8k
  {                                                              \
506
43.8k
    (_pix) = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16); \
507
43.8k
    (_buf) += 3;                                               \
508
43.8k
  } while (0)
509
510
27.7k
#define WRITEFGBGIMAGE WriteFgBgImage24to24
511
10.7k
#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage24to24
512
#define RLEDECOMPRESS RleDecompress24to24
513
#define RLEEXTRA
514
#undef ENSURE_CAPACITY
515
260k
#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
16.2k
{
535
16.2k
  UINT32 scanline = 0;
536
16.2k
  UINT32 SrcFormat = 0;
537
16.2k
  UINT32 BufferSize = 0;
538
539
16.2k
  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
16.2k
  switch (bpp)
547
16.2k
  {
548
5.40k
    case 24:
549
5.40k
      scanline = nSrcWidth * 3;
550
5.40k
      SrcFormat = PIXEL_FORMAT_BGR24;
551
5.40k
      break;
552
553
5.40k
    case 16:
554
5.40k
      scanline = nSrcWidth * 2;
555
5.40k
      SrcFormat = PIXEL_FORMAT_RGB16;
556
5.40k
      break;
557
558
5.40k
    case 15:
559
5.40k
      scanline = nSrcWidth * 2;
560
5.40k
      SrcFormat = PIXEL_FORMAT_RGB15;
561
5.40k
      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
16.2k
  }
572
573
16.2k
  BufferSize = scanline * nSrcHeight;
574
575
16.2k
  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
16.2k
  if (!interleaved->TempBuffer)
583
0
  {
584
0
    WLog_ERR(TAG, "interleaved->TempBuffer=%p", interleaved->TempBuffer);
585
0
    return FALSE;
586
0
  }
587
588
16.2k
  switch (bpp)
589
16.2k
  {
590
5.40k
    case 24:
591
5.40k
      if (!RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
592
5.40k
                               nSrcWidth, nSrcHeight))
593
4.07k
      {
594
4.07k
        WLog_ERR(TAG, "RleDecompress24to24 failed");
595
4.07k
        return FALSE;
596
4.07k
      }
597
598
1.33k
      break;
599
600
5.40k
    case 16:
601
10.8k
    case 15:
602
10.8k
      if (!RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
603
10.8k
                               nSrcWidth, nSrcHeight))
604
8.10k
      {
605
8.10k
        WLog_ERR(TAG, "RleDecompress16to16 failed");
606
8.10k
        return FALSE;
607
8.10k
      }
608
609
2.70k
      break;
610
611
2.70k
    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
16.2k
  }
625
626
4.03k
  if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
627
4.03k
                                     nDstHeight, interleaved->TempBuffer, SrcFormat, scanline, 0,
628
4.03k
                                     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
4.03k
  return TRUE;
634
4.03k
}
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
16.2k
{
712
16.2k
  if (!interleaved)
713
0
    return FALSE;
714
715
16.2k
  return TRUE;
716
16.2k
}
717
718
BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor)
719
5.40k
{
720
5.40k
  BITMAP_INTERLEAVED_CONTEXT* interleaved = NULL;
721
5.40k
  interleaved = (BITMAP_INTERLEAVED_CONTEXT*)winpr_aligned_recalloc(
722
5.40k
      NULL, 1, sizeof(BITMAP_INTERLEAVED_CONTEXT), 32);
723
724
5.40k
  if (interleaved)
725
5.40k
  {
726
5.40k
    interleaved->TempSize = 64 * 64 * 4;
727
5.40k
    interleaved->TempBuffer = winpr_aligned_calloc(interleaved->TempSize, sizeof(BYTE), 16);
728
729
5.40k
    if (!interleaved->TempBuffer)
730
0
      goto fail;
731
732
5.40k
    interleaved->bts = Stream_New(NULL, interleaved->TempSize);
733
734
5.40k
    if (!interleaved->bts)
735
0
      goto fail;
736
5.40k
  }
737
738
5.40k
  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
5.40k
}
747
748
void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
749
5.40k
{
750
5.40k
  if (!interleaved)
751
0
    return;
752
753
5.40k
  winpr_aligned_free(interleaved->TempBuffer);
754
5.40k
  Stream_Free(interleaved->bts, TRUE);
755
5.40k
  winpr_aligned_free(interleaved);
756
5.40k
}