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