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