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 UINT32 BufferSize = 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 switch (bpp)
552 {
553 case 24:
554 scanline = nSrcWidth * 3;
555 SrcFormat = PIXEL_FORMAT_BGR24;
556 break;
557
558 case 16:
559 scanline = nSrcWidth * 2;
560 SrcFormat = PIXEL_FORMAT_RGB16;
561 break;
562
563 case 15:
564 scanline = nSrcWidth * 2;
565 SrcFormat = PIXEL_FORMAT_RGB15;
566 break;
567
568 case 8:
569 scanline = nSrcWidth;
570 SrcFormat = PIXEL_FORMAT_RGB8;
571 break;
572
573 default:
574 WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
575 return FALSE;
576 }
577
578 BufferSize = scanline * nSrcHeight;
579
580 if (BufferSize > interleaved->TempSize)
581 {
582 interleaved->TempBuffer =
583 winpr_aligned_recalloc(interleaved->TempBuffer, BufferSize, sizeof(BYTE), 16);
584 interleaved->TempSize = BufferSize;
585 }
586
587 if (!interleaved->TempBuffer)
588 {
589 WLog_ERR(TAG, "interleaved->TempBuffer=NULL");
590 return FALSE;
591 }
592
593 switch (bpp)
594 {
595 case 24:
596 if (!RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
597 nSrcWidth, nSrcHeight))
598 {
599 WLog_ERR(TAG, "RleDecompress24to24 failed");
600 return FALSE;
601 }
602
603 break;
604
605 case 16:
606 case 15:
607 if (!RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer, scanline,
608 nSrcWidth, nSrcHeight))
609 {
610 WLog_ERR(TAG, "RleDecompress16to16 failed");
611 return FALSE;
612 }
613
614 break;
615
616 case 8:
617 if (!RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer, scanline, nSrcWidth,
618 nSrcHeight))
619 {
620 WLog_ERR(TAG, "RleDecompress8to8 failed");
621 return FALSE;
622 }
623
624 break;
625
626 default:
627 WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp);
628 return FALSE;
629 }
630
631 if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
632 nDstHeight, interleaved->TempBuffer, SrcFormat, scanline, 0,
633 0, palette, FREERDP_FLIP_VERTICAL | FREERDP_KEEP_DST_ALPHA))
634 {
635 WLog_ERR(TAG, "freerdp_image_copy failed");
636 return FALSE;
637 }
638 return TRUE;
639}
640
641BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved,
642 BYTE* WINPR_RESTRICT pDstData, UINT32* WINPR_RESTRICT pDstSize,
643 UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData,
644 UINT32 SrcFormat, UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
645 const gdiPalette* WINPR_RESTRICT palette, UINT32 bpp)
646{
647 BOOL status = 0;
648 wStream* s = NULL;
649 UINT32 DstFormat = 0;
650 const UINT32 maxSize = 64 * 64 * 4;
651
652 if (!interleaved || !pDstData || !pSrcData)
653 return FALSE;
654
655 if ((nWidth == 0) || (nHeight == 0))
656 return FALSE;
657
658 if (nWidth % 4)
659 {
660 WLog_ERR(TAG, "interleaved_compress: width is not a multiple of 4");
661 return FALSE;
662 }
663
664 if ((nWidth > 64) || (nHeight > 64))
665 {
666 WLog_ERR(TAG,
667 "interleaved_compress: width (%" PRIu32 ") or height (%" PRIu32
668 ") is greater than 64",
669 nWidth, nHeight);
670 return FALSE;
671 }
672
673 switch (bpp)
674 {
675 case 24:
676 DstFormat = PIXEL_FORMAT_BGRX32;
677 break;
678
679 case 16:
680 DstFormat = PIXEL_FORMAT_RGB16;
681 break;
682
683 case 15:
684 DstFormat = PIXEL_FORMAT_RGB15;
685 break;
686
687 default:
688 return FALSE;
689 }
690
691 if (!freerdp_image_copy_no_overlap(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth, nHeight,
692 pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette,
693 FREERDP_KEEP_DST_ALPHA))
694 return FALSE;
695
696 s = Stream_New(pDstData, *pDstSize);
697
698 if (!s)
699 return FALSE;
700
701 Stream_SetPosition(interleaved->bts, 0);
702
703 if (freerdp_bitmap_compress(interleaved->TempBuffer, nWidth, nHeight, s, bpp, maxSize,
704 nHeight - 1, interleaved->bts, 0) < 0)
705 status = FALSE;
706 else
707 status = TRUE;
708
709 Stream_SealLength(s);
710 *pDstSize = (UINT32)Stream_Length(s);
711 Stream_Free(s, FALSE);
712 return status;
713}
714
715BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
716{
717 if (!interleaved)
718 return FALSE;
719
720 return TRUE;
721}
722
723BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(WINPR_ATTR_UNUSED BOOL Compressor)
724{
725 BITMAP_INTERLEAVED_CONTEXT* interleaved = NULL;
726 interleaved = (BITMAP_INTERLEAVED_CONTEXT*)winpr_aligned_recalloc(
727 NULL, 1, sizeof(BITMAP_INTERLEAVED_CONTEXT), 32);
728
729 if (interleaved)
730 {
731 interleaved->TempSize = 64 * 64 * 4;
732 interleaved->TempBuffer = winpr_aligned_calloc(interleaved->TempSize, sizeof(BYTE), 16);
733
734 if (!interleaved->TempBuffer)
735 goto fail;
736
737 interleaved->bts = Stream_New(NULL, interleaved->TempSize);
738
739 if (!interleaved->bts)
740 goto fail;
741 }
742
743 return interleaved;
744
745fail:
746 WINPR_PRAGMA_DIAG_PUSH
747 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
748 bitmap_interleaved_context_free(interleaved);
749 WINPR_PRAGMA_DIAG_POP
750 return NULL;
751}
752
753void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved)
754{
755 if (!interleaved)
756 return;
757
758 winpr_aligned_free(interleaved->TempBuffer);
759 Stream_Free(interleaved->bts, TRUE);
760 winpr_aligned_free(interleaved);
761}