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) _pix = ((UINT16*)(_buf))[0]
471#define SRCREADPIXEL(_pix, _buf) \
472 do \
473 { \
474 (_pix) = WINPR_ASSERTING_INT_CAST(UINT16, (_buf)[0] | (((_buf)[1] << 8) & 0xFF00)); \
475 (_buf) += 2; \
476 } while (0)
477#define WRITEFGBGIMAGE WriteFgBgImage16to16
478#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage16to16
479#define RLEDECOMPRESS RleDecompress16to16
480#define RLEEXTRA
481#undef ENSURE_CAPACITY
482#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 2)
483#include "include/bitmap.h"
484
485#undef DESTWRITEPIXEL
486#undef DESTREADPIXEL
487#undef SRCREADPIXEL
488#undef WRITEFGBGIMAGE
489#undef WRITEFIRSTLINEFGBGIMAGE
490#undef RLEDECOMPRESS
491#undef RLEEXTRA
492#undef WHITE_PIXEL
493#undef PIXEL_SIZE
494#undef PIXEL
495#define PIXEL_SIZE 3
496#define PIXEL UINT32
497#define WHITE_PIXEL 0xffffff
498#define DESTWRITEPIXEL(_buf, _pix) \
499 do \
500 { \
501 write_pixel_24(_buf, _pix); \
502 (_buf) += 3; \
503 } while (0)
504#define DESTREADPIXEL(_pix, _buf) \
505 _pix = (_buf)[0] | (((_buf)[1] << 8) & 0xFF00) | (((_buf)[2] << 16) & 0xFF0000)
506#define SRCREADPIXEL(_pix, _buf) \
507 do \
508 { \
509 (_pix) = (_buf)[0] | (((_buf)[1] << 8) & 0xFF00) | (((_buf)[2] << 16) & 0xFF0000); \
510 (_buf) += 3; \
511 } while (0)
512
513#define WRITEFGBGIMAGE WriteFgBgImage24to24
514#define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage24to24
515#define RLEDECOMPRESS RleDecompress24to24
516#define RLEEXTRA
517#undef ENSURE_CAPACITY
518#define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 3)
519#include "include/bitmap.h"
520
521struct S_BITMAP_INTERLEAVED_CONTEXT
522{
523 BOOL Compressor;
524
525 UINT32 TempSize;
526 BYTE* TempBuffer;
527
528 wStream* bts;
529};
530
531BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved,
532 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth,
533 UINT32 nSrcHeight, UINT32 bpp, BYTE* WINPR_RESTRICT pDstData,
534 UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
535 UINT32 nDstWidth, UINT32 nDstHeight,
536 const gdiPalette* WINPR_RESTRICT palette)
537{
538 UINT32 scanline = 0;
539 UINT32 SrcFormat = 0;
540
541 if (!interleaved || !pSrcData || !pDstData)
542 {
543 WLog_ERR(TAG, "invalid arguments: interleaved=%p, pSrcData=%p, pDstData=%p",
544 WINPR_CXX_COMPAT_CAST(const void*, interleaved),
545 WINPR_CXX_COMPAT_CAST(const void*, pSrcData),
546 WINPR_CXX_COMPAT_CAST(const void*, pDstData));
547 return FALSE;
548 }
549
550 if ((nSrcWidth == 0) || (nSrcHeight == 0))
551 return FALSE;
552 if ((nDstWidth == 0) || (nDstHeight == 0))
553 return FALSE;
554
555 switch (bpp)
556 {
557 case 24:
558 if (nSrcWidth > UINT32_MAX / 3)
559 return FALSE;
560 scanline = nSrcWidth * 3;
561 SrcFormat = PIXEL_FORMAT_BGR24;
562 break;
563
564 case 16:
565 if (nSrcWidth > UINT32_MAX / 2)
566 return FALSE;
567 scanline = nSrcWidth * 2;
568 SrcFormat = PIXEL_FORMAT_RGB16;
569 break;
570
571 case 15:
572 if (nSrcWidth > UINT32_MAX / 2)
573 return FALSE;
574 scanline = nSrcWidth * 2;
575 SrcFormat = PIXEL_FORMAT_RGB15;
576 break;
577
578 case 8:
579 scanline = nSrcWidth;
580 SrcFormat = PIXEL_FORMAT_RGB8;
581 break;
582
583 default:
584 WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
585 return FALSE;
586 }
587
588 if (scanline > UINT32_MAX / nSrcHeight)
589 return FALSE;
590
591 const UINT32 BufferSize = scanline * nSrcHeight;
592
593 if (BufferSize > interleaved->TempSize)
594 {
595 interleaved->TempBuffer =
596 winpr_aligned_recalloc(interleaved->TempBuffer, BufferSize, sizeof(BYTE), 16);
597 interleaved->TempSize = BufferSize;
598 }
599
600 if (!interleaved->TempBuffer)
601 {
602 WLog_ERR(TAG, "interleaved->TempBuffer=nullptr");
603 return FALSE;
604 }
605
606 switch (bpp)
607 {
608 case 24:
609 if (!RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
610 nSrcWidth, nSrcHeight))
611 {
612 WLog_ERR(TAG, "RleDecompress24to24 failed");
613 return FALSE;
614 }
615
616 break;
617
618 case 16:
619 case 15:
620 if (!RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
621 nSrcWidth, nSrcHeight))
622 {
623 WLog_ERR(TAG, "RleDecompress16to16 failed");
624 return FALSE;
625 }
626
627 break;
628
629 case 8:
630 if (!RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer, scanline, nSrcWidth,
631 nSrcHeight))
632 {
633 WLog_ERR(TAG, "RleDecompress8to8 failed");
634 return FALSE;
635 }
636
637 break;
638
639 default:
640 WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
641 return FALSE;
642 }
643
644 if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
645 nDstHeight, interleaved->TempBuffer, SrcFormat, scanline, 0,
646 0, palette, FREERDP_FLIP_VERTICAL | FREERDP_KEEP_DST_ALPHA))
647 {
648 WLog_ERR(TAG, "freerdp_image_copy failed");
649 return FALSE;
650 }
651 return TRUE;
652}
653
654BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved,
655 BYTE* WINPR_RESTRICT pDstData, UINT32* WINPR_RESTRICT pDstSize,
656 UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData,
657 UINT32 SrcFormat, UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
658 const gdiPalette* WINPR_RESTRICT palette, UINT32 bpp)
659{
660 BOOL status = 0;
661 wStream* s = nullptr;
662 UINT32 DstFormat = 0;
663 const UINT32 maxSize = 64 * 64 * 4;
664
665 if (!interleaved || !pDstData || !pSrcData)
666 return FALSE;
667
668 if ((nWidth == 0) || (nHeight == 0))
669 return FALSE;
670
671 if (nWidth % 4)
672 {
673 WLog_ERR(TAG, "interleaved_compress: width is not a multiple of 4");
674 return FALSE;
675 }
676
677 if ((nWidth > 64) || (nHeight > 64))
678 {
679 WLog_ERR(TAG,
680 "interleaved_compress: width (%" PRIu32 ") or height (%" PRIu32
681 ") is greater than 64",
682 nWidth, nHeight);
683 return FALSE;
684 }
685
686 switch (bpp)
687 {
688 case 24:
689 DstFormat = PIXEL_FORMAT_BGRX32;
690 break;
691
692 case 16:
693 DstFormat = PIXEL_FORMAT_RGB16;
694 break;
695
696 case 15:
697 DstFormat = PIXEL_FORMAT_RGB15;
698 break;
699
700 default:
701 return FALSE;
702 }
703
704 if (!freerdp_image_copy_no_overlap(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth, nHeight,
705 pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette,
706 FREERDP_KEEP_DST_ALPHA))
707 return FALSE;
708
709 s = Stream_New(pDstData, *pDstSize);
710
711 if (!s)
712 return FALSE;
713
714 Stream_ResetPosition(interleaved->bts);
715
716 status = (freerdp_bitmap_compress(interleaved->TempBuffer, nWidth, nHeight, s, bpp, maxSize,
717 nHeight - 1, interleaved->bts, 0) >= 0);
718
719 Stream_SealLength(s);
720 *pDstSize = (UINT32)Stream_Length(s);
721 Stream_Free(s, FALSE);
722 return status;
723}
724
725BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
726{
727 return (interleaved != nullptr);
728}
729
730BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(WINPR_ATTR_UNUSED BOOL Compressor)
731{
732 BITMAP_INTERLEAVED_CONTEXT* interleaved = nullptr;
733 interleaved = (BITMAP_INTERLEAVED_CONTEXT*)winpr_aligned_recalloc(
734 nullptr, 1, sizeof(BITMAP_INTERLEAVED_CONTEXT), 32);
735
736 if (interleaved)
737 {
738 interleaved->TempSize = 64 * 64 * 4;
739 interleaved->TempBuffer = winpr_aligned_calloc(interleaved->TempSize, sizeof(BYTE), 16);
740
741 if (!interleaved->TempBuffer)
742 goto fail;
743
744 interleaved->bts = Stream_New(nullptr, interleaved->TempSize);
745
746 if (!interleaved->bts)
747 goto fail;
748 }
749
750 return interleaved;
751
752fail:
753 WINPR_PRAGMA_DIAG_PUSH
754 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
755 bitmap_interleaved_context_free(interleaved);
756 WINPR_PRAGMA_DIAG_POP
757 return nullptr;
758}
759
760void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
761{
762 if (!interleaved)
763 return;
764
765 winpr_aligned_free(interleaved->TempBuffer);
766 Stream_Free(interleaved->bts, TRUE);
767 winpr_aligned_free(interleaved);
768}