22#include <freerdp/config.h>
25#include <winpr/wtypes.h>
26#include <winpr/assert.h>
27#include <winpr/cast.h>
28#include <winpr/print.h>
30#include <freerdp/primitives.h>
31#include <freerdp/log.h>
32#include <freerdp/codec/bitmap.h>
33#include <freerdp/codec/planar.h>
35#define TAG FREERDP_TAG("codec")
37#define PLANAR_ALIGN(val, align) \
38 ((val) % (align) == 0) ? (val) : ((val) + (align) - (val) % (align))
54 RDP6_RLE_SEGMENT* segments;
70struct S_BITMAP_PLANAR_CONTEXT
77 BOOL AllowRunLengthEncoding;
78 BOOL AllowColorSubsampling;
79 BOOL AllowDynamicColorFidelity;
81 UINT32 ColorLossLevel;
87 BYTE* deltaPlanesBuffer;
90 BYTE* rlePlanesBuffer;
99static inline BYTE PLANAR_CONTROL_BYTE(UINT32 nRunLength, UINT32 cRawBytes)
101 return WINPR_ASSERTING_INT_CAST(UINT8, ((nRunLength & 0x0F) | ((cRawBytes & 0x0F) << 4)));
104static inline BYTE PLANAR_CONTROL_BYTE_RUN_LENGTH(UINT32 controlByte)
106 return (controlByte & 0x0F);
108static inline BYTE PLANAR_CONTROL_BYTE_RAW_BYTES(UINT32 controlByte)
110 return ((controlByte >> 4) & 0x0F);
113static inline UINT32 planar_invert_format(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL alpha,
116 WINPR_ASSERT(planar);
117 if (planar->bgr && alpha)
121 case PIXEL_FORMAT_ARGB32:
122 DstFormat = PIXEL_FORMAT_ABGR32;
124 case PIXEL_FORMAT_XRGB32:
125 DstFormat = PIXEL_FORMAT_XBGR32;
127 case PIXEL_FORMAT_ABGR32:
128 DstFormat = PIXEL_FORMAT_ARGB32;
130 case PIXEL_FORMAT_XBGR32:
131 DstFormat = PIXEL_FORMAT_XRGB32;
133 case PIXEL_FORMAT_BGRA32:
134 DstFormat = PIXEL_FORMAT_RGBA32;
136 case PIXEL_FORMAT_BGRX32:
137 DstFormat = PIXEL_FORMAT_RGBX32;
139 case PIXEL_FORMAT_RGBA32:
140 DstFormat = PIXEL_FORMAT_BGRA32;
142 case PIXEL_FORMAT_RGBX32:
143 DstFormat = PIXEL_FORMAT_BGRX32;
145 case PIXEL_FORMAT_RGB24:
146 DstFormat = PIXEL_FORMAT_BGR24;
148 case PIXEL_FORMAT_BGR24:
149 DstFormat = PIXEL_FORMAT_RGB24;
151 case PIXEL_FORMAT_RGB16:
152 DstFormat = PIXEL_FORMAT_BGR16;
154 case PIXEL_FORMAT_BGR16:
155 DstFormat = PIXEL_FORMAT_RGB16;
157 case PIXEL_FORMAT_ARGB15:
158 DstFormat = PIXEL_FORMAT_ABGR15;
160 case PIXEL_FORMAT_RGB15:
161 DstFormat = PIXEL_FORMAT_BGR15;
163 case PIXEL_FORMAT_ABGR15:
164 DstFormat = PIXEL_FORMAT_ARGB15;
166 case PIXEL_FORMAT_BGR15:
167 DstFormat = PIXEL_FORMAT_RGB15;
176static inline BOOL freerdp_bitmap_planar_compress_plane_rle(
const BYTE* WINPR_RESTRICT inPlane,
177 UINT32 width, UINT32 height,
178 BYTE* WINPR_RESTRICT outPlane,
179 UINT32* WINPR_RESTRICT dstSize);
180static inline BYTE* freerdp_bitmap_planar_delta_encode_plane(
const BYTE* WINPR_RESTRICT inPlane,
181 UINT32 width, UINT32 height,
182 BYTE* WINPR_RESTRICT outPlane);
184static inline INT32 planar_skip_plane_rle(
const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
185 UINT32 nWidth, UINT32 nHeight)
189 WINPR_ASSERT(pSrcData);
191 for (UINT32 y = 0; y < nHeight; y++)
193 for (UINT32 x = 0; x < nWidth;)
197 WLog_ERR(TAG,
"planar plane used %" PRIu32
" exceeds SrcSize %" PRIu32, used,
202 const uint8_t controlByte = pSrcData[used++];
203 uint32_t nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
204 uint32_t cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
208 nRunLength = cRawBytes + 16;
211 else if (nRunLength == 2)
213 nRunLength = cRawBytes + 32;
223 WLog_ERR(TAG,
"planar plane x %" PRIu32
" exceeds width %" PRIu32, x, nWidth);
229 WLog_ERR(TAG,
"planar plane used %" PRIu32
" exceeds SrcSize %" PRIu32, used,
236 if (used > INT32_MAX)
238 WLog_ERR(TAG,
"planar plane used %" PRIu32
" exceeds SrcSize %" PRIu32, used, SrcSize);
244static inline UINT8 clamp(INT16 val)
249static inline INT32 planar_decompress_plane_rle_only(
const BYTE* WINPR_RESTRICT pSrcData,
250 UINT32 SrcSize, BYTE* WINPR_RESTRICT pDstData,
251 UINT32 nWidth, UINT32 nHeight)
253 BYTE* previousScanline = NULL;
254 const BYTE* srcp = pSrcData;
256 WINPR_ASSERT(nHeight <= INT32_MAX);
257 WINPR_ASSERT(nWidth <= INT32_MAX);
259 for (UINT32 y = 0; y < nHeight; y++)
261 BYTE* dstp = &pDstData[1ULL * (y)*nWidth];
263 BYTE* currentScanline = dstp;
265 for (UINT32 x = 0; x < nWidth;)
267 BYTE controlByte = *srcp;
270 if ((srcp - pSrcData) > SrcSize * 1ll)
272 WLog_ERR(TAG,
"error reading input buffer");
276 UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
277 UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
281 nRunLength = cRawBytes + 16;
284 else if (nRunLength == 2)
286 nRunLength = cRawBytes + 32;
290 if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 1ll)
292 WLog_ERR(TAG,
"too many pixels in scanline");
296 if (!previousScanline)
299 while (cRawBytes > 0)
303 *dstp = clamp(pixel);
309 while (nRunLength > 0)
311 *dstp = clamp(pixel);
320 while (cRawBytes > 0)
322 UINT8 deltaValue = *srcp;
327 deltaValue = deltaValue >> 1;
328 deltaValue = deltaValue + 1;
329 pixel = WINPR_ASSERTING_INT_CAST(int16_t, -1 * (int16_t)deltaValue);
333 deltaValue = deltaValue >> 1;
334 pixel = WINPR_ASSERTING_INT_CAST(INT16, deltaValue);
338 WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
339 *dstp = clamp(delta);
345 while (nRunLength > 0)
347 const INT16 deltaValue =
348 WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
349 *dstp = clamp(deltaValue);
357 previousScanline = currentScanline;
360 return (INT32)(srcp - pSrcData);
363static inline INT32 planar_decompress_plane_rle(
const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
364 BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
365 UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
366 UINT32 nHeight, UINT32 nChannel, BOOL vFlip)
371 BYTE* previousScanline = NULL;
372 const BYTE* srcp = pSrcData;
374 WINPR_ASSERT(nHeight <= INT32_MAX);
375 WINPR_ASSERT(nWidth <= INT32_MAX);
376 WINPR_ASSERT(nDstStep <= INT32_MAX);
380 beg = (INT32)nHeight - 1;
387 end = (INT32)nHeight;
391 for (INT32 y = beg; y != end; y += inc)
393 const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
394 BYTE* dstp = &pDstData[off];
395 BYTE* currentScanline = dstp;
398 for (INT32 x = 0; x < (INT32)nWidth;)
400 const BYTE controlByte = *srcp;
403 if ((srcp - pSrcData) > SrcSize * 1ll)
405 WLog_ERR(TAG,
"error reading input buffer");
409 UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
410 UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
414 nRunLength = cRawBytes + 16;
417 else if (nRunLength == 2)
419 nRunLength = cRawBytes + 32;
423 if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 4ll)
425 WLog_ERR(TAG,
"too many pixels in scanline");
429 if (!previousScanline)
432 while (cRawBytes > 0)
436 *dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
442 while (nRunLength > 0)
444 *dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
453 while (cRawBytes > 0)
455 BYTE deltaValue = *srcp;
460 deltaValue = deltaValue >> 1;
461 deltaValue = deltaValue + 1;
462 pixel = WINPR_ASSERTING_INT_CAST(int16_t, -deltaValue);
466 deltaValue = deltaValue >> 1;
471 WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[4LL * x] + pixel);
472 *dstp = clamp(delta);
478 while (nRunLength > 0)
480 const INT16 deltaValue =
481 WINPR_ASSERTING_INT_CAST(int16_t, pixel + previousScanline[4LL * x]);
482 *dstp = clamp(deltaValue);
490 previousScanline = currentScanline;
493 return (INT32)(srcp - pSrcData);
496static inline INT32 planar_set_plane(BYTE bValue, BYTE* pDstData, UINT32 nDstStep, UINT32 nXDst,
497 UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 nChannel,
501 INT32 end = (INT32)nHeight;
504 WINPR_ASSERT(nHeight <= INT32_MAX);
505 WINPR_ASSERT(nWidth <= INT32_MAX);
506 WINPR_ASSERT(nDstStep <= INT32_MAX);
510 beg = (INT32)nHeight - 1;
515 for (INT32 y = beg; y != end; y += inc)
517 const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
518 BYTE* dstp = &pDstData[off];
520 for (INT32 x = 0; x < (INT32)nWidth; ++x)
530static inline BOOL writeLine(BYTE** WINPR_RESTRICT ppRgba, UINT32 DstFormat, UINT32 width,
531 const BYTE** WINPR_RESTRICT ppR,
const BYTE** WINPR_RESTRICT ppG,
532 const BYTE** WINPR_RESTRICT ppB,
const BYTE** WINPR_RESTRICT ppA)
534 WINPR_ASSERT(ppRgba);
541 case PIXEL_FORMAT_BGRA32:
542 for (UINT32 x = 0; x < width; x++)
544 *(*ppRgba)++ = *(*ppB)++;
545 *(*ppRgba)++ = *(*ppG)++;
546 *(*ppRgba)++ = *(*ppR)++;
547 *(*ppRgba)++ = *(*ppA)++;
552 case PIXEL_FORMAT_BGRX32:
553 for (UINT32 x = 0; x < width; x++)
555 *(*ppRgba)++ = *(*ppB)++;
556 *(*ppRgba)++ = *(*ppG)++;
557 *(*ppRgba)++ = *(*ppR)++;
566 for (UINT32 x = 0; x < width; x++)
568 BYTE alpha = *(*ppA)++;
570 FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
571 FreeRDPWriteColor(*ppRgba, DstFormat, color);
572 *ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
577 const BYTE alpha = 0xFF;
579 for (UINT32 x = 0; x < width; x++)
582 FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
583 FreeRDPWriteColor(*ppRgba, DstFormat, color);
584 *ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
592static inline BOOL planar_decompress_planes_raw(
const BYTE* WINPR_RESTRICT pSrcData[4],
593 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
594 UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
595 UINT32 nWidth, UINT32 nHeight, BOOL vFlip,
601 const BYTE* pR = pSrcData[0];
602 const BYTE* pG = pSrcData[1];
603 const BYTE* pB = pSrcData[2];
604 const BYTE* pA = pSrcData[3];
605 const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat);
609 beg = WINPR_ASSERTING_INT_CAST(int32_t, nHeight - 1);
616 end = WINPR_ASSERTING_INT_CAST(int32_t, nHeight);
620 if (nYDst + nHeight > totalHeight)
623 "planar plane destination Y %" PRIu32
" + height %" PRIu32
624 " exceeds totalHeight %" PRIu32,
625 nYDst, nHeight, totalHeight);
629 if ((nXDst + nWidth) * bpp > nDstStep)
632 "planar plane destination (X %" PRIu32
" + width %" PRIu32
") * bpp %" PRIu32
633 " exceeds stride %" PRIu32,
634 nXDst, nWidth, bpp, nDstStep);
638 for (INT32 y = beg; y != end; y += inc)
642 if (y > WINPR_ASSERTING_INT_CAST(INT64, nHeight))
644 WLog_ERR(TAG,
"planar plane destination Y %" PRId32
" exceeds height %" PRIu32, y,
649 const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (1LL * nXDst * bpp);
650 pRGB = &pDstData[off];
652 if (!writeLine(&pRGB, DstFormat, nWidth, &pR, &pG, &pB, &pA))
659static BOOL planar_subsample_expand(
const BYTE* WINPR_RESTRICT plane,
size_t planeLength,
660 UINT32 nWidth, UINT32 nHeight, UINT32 nPlaneWidth,
661 UINT32 nPlaneHeight, BYTE* WINPR_RESTRICT deltaPlane)
664 WINPR_UNUSED(planeLength);
667 WINPR_ASSERT(deltaPlane);
669 if (nWidth > nPlaneWidth * 2)
671 WLog_ERR(TAG,
"planar subsample width %" PRIu32
" > PlaneWidth %" PRIu32
" * 2", nWidth,
676 if (nHeight > nPlaneHeight * 2)
678 WLog_ERR(TAG,
"planar subsample height %" PRIu32
" > PlaneHeight %" PRIu32
" * 2", nHeight,
683 for (
size_t y = 0; y < nHeight; y++)
685 const BYTE* src = plane + y / 2 * nPlaneWidth;
687 for (UINT32 x = 0; x < nWidth; x++)
689 deltaPlane[pos++] = src[x / 2];
696#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
697BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
698 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth,
699 UINT32 nSrcHeight, BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
700 UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
701 UINT32 nDstHeight, BOOL vFlip)
703 return freerdp_bitmap_decompress_planar(planar, pSrcData, SrcSize, nSrcWidth, nSrcHeight,
704 pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
709BOOL freerdp_bitmap_decompress_planar(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
710 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
711 UINT32 nSrcWidth, UINT32 nSrcHeight,
712 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
713 UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
714 UINT32 nDstHeight, BOOL vFlip)
716 BOOL useAlpha = FALSE;
718 INT32 rleSizes[4] = { 0, 0, 0, 0 };
719 UINT32 rawSizes[4] = { 0 };
720 UINT32 rawWidths[4] = { 0 };
721 UINT32 rawHeights[4] = { 0 };
722 const BYTE* planes[4] = { 0 };
723 const UINT32 w = MIN(nSrcWidth, nDstWidth);
724 const UINT32 h = MIN(nSrcHeight, nDstHeight);
727 WINPR_ASSERT(planar);
731 nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat);
733 const BYTE* srcp = pSrcData;
737 WLog_ERR(TAG,
"Invalid argument pSrcData=NULL");
743 WLog_ERR(TAG,
"Invalid argument pDstData=NULL");
747 const BYTE FormatHeader = *srcp++;
748 const BYTE cll = (FormatHeader & PLANAR_FORMAT_HEADER_CLL_MASK);
749 const BYTE cs = (FormatHeader & PLANAR_FORMAT_HEADER_CS) ? TRUE : FALSE;
750 const BYTE rle = (FormatHeader & PLANAR_FORMAT_HEADER_RLE) ? TRUE : FALSE;
751 const BYTE alpha = (FormatHeader & PLANAR_FORMAT_HEADER_NA) ? FALSE : TRUE;
753 DstFormat = planar_invert_format(planar, alpha, DstFormat);
756 useAlpha = FreeRDPColorHasAlpha(DstFormat);
763 WLog_ERR(TAG,
"Chroma subsampling requires YCoCg and does not work with RGB data");
767 const UINT32 subWidth = (nSrcWidth / 2) + (nSrcWidth % 2);
768 const UINT32 subHeight = (nSrcHeight / 2) + (nSrcHeight % 2);
769 const UINT32 planeSize = nSrcWidth * nSrcHeight;
770 const UINT32 subSize = subWidth * subHeight;
774 rawSizes[0] = planeSize;
775 rawWidths[0] = nSrcWidth;
776 rawHeights[0] = nSrcHeight;
777 rawSizes[1] = planeSize;
778 rawWidths[1] = nSrcWidth;
779 rawHeights[1] = nSrcHeight;
780 rawSizes[2] = planeSize;
781 rawWidths[2] = nSrcWidth;
782 rawHeights[2] = nSrcHeight;
783 rawSizes[3] = planeSize;
784 rawWidths[3] = nSrcWidth;
785 rawHeights[3] = nSrcHeight;
789 rawSizes[0] = planeSize;
790 rawWidths[0] = nSrcWidth;
791 rawHeights[0] = nSrcHeight;
792 rawSizes[1] = subSize;
793 rawWidths[1] = subWidth;
794 rawHeights[1] = subHeight;
795 rawSizes[2] = subSize;
796 rawWidths[2] = subWidth;
797 rawHeights[2] = subHeight;
798 rawSizes[3] = planeSize;
799 rawWidths[3] = nSrcWidth;
800 rawHeights[3] = nSrcHeight;
803 const size_t diff = WINPR_ASSERTING_INT_CAST(
size_t, (intptr_t)(srcp - pSrcData));
806 WLog_ERR(TAG,
"Size mismatch %" PRIu32
" < %" PRIuz, SrcSize, diff);
813 UINT32 base = planeSize * 3;
815 base = planeSize + planeSize / 2;
819 if ((SrcSize - diff) < (planeSize + base))
821 WLog_ERR(TAG,
"Alpha plane size mismatch %" PRIuz
" < %" PRIu32, SrcSize - diff,
827 planes[0] = planes[3] + rawSizes[3];
828 planes[1] = planes[0] + rawSizes[0];
829 planes[2] = planes[1] + rawSizes[1];
831 if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
833 WLog_ERR(TAG,
"plane size mismatch %p + %" PRIu32
" > %p", planes[2], rawSizes[2],
840 if ((SrcSize - diff) < base)
842 WLog_ERR(TAG,
"plane size mismatch %" PRIu32
" < %" PRIu32, SrcSize - diff, base);
847 planes[1] = planes[0] + rawSizes[0];
848 planes[2] = planes[1] + rawSizes[1];
850 if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
852 WLog_ERR(TAG,
"plane size mismatch %p + %" PRIu32
" > %p", planes[2], rawSizes[2],
863 rleSizes[3] = planar_skip_plane_rle(planes[3], (UINT32)(SrcSize - diff), rawWidths[3],
869 planes[0] = planes[3] + rleSizes[3];
874 const size_t diff0 = WINPR_ASSERTING_INT_CAST(
size_t, (intptr_t)(planes[0] - pSrcData));
877 WLog_ERR(TAG,
"Size mismatch %" PRIu32
" < %" PRIuz, SrcSize, diff0);
880 rleSizes[0] = planar_skip_plane_rle(planes[0], (UINT32)(SrcSize - diff0), rawWidths[0],
886 planes[1] = planes[0] + rleSizes[0];
888 const size_t diff1 = WINPR_ASSERTING_INT_CAST(
size_t, (intptr_t)(planes[1] - pSrcData));
891 WLog_ERR(TAG,
"Size mismatch %" PRIu32
" < %" PRIuz, SrcSize, diff1);
894 rleSizes[1] = planar_skip_plane_rle(planes[1], (UINT32)(SrcSize - diff1), rawWidths[1],
900 planes[2] = planes[1] + rleSizes[1];
901 const size_t diff2 = WINPR_ASSERTING_INT_CAST(
size_t, (intptr_t)(planes[2] - pSrcData));
904 WLog_ERR(TAG,
"Size mismatch %" PRIu32
" < %" PRIuz, SrcSize, diff);
907 rleSizes[2] = planar_skip_plane_rle(planes[2], (UINT32)(SrcSize - diff2), rawWidths[2],
916 UINT32 TempFormat = 0;
917 BYTE* pTempData = pDstData;
918 UINT32 nTempStep = nDstStep;
919 UINT32 nTotalHeight = nYDst + nDstHeight;
922 TempFormat = PIXEL_FORMAT_BGRA32;
924 TempFormat = PIXEL_FORMAT_BGRX32;
926 TempFormat = planar_invert_format(planar, alpha, TempFormat);
928 if ((TempFormat != DstFormat) || (nSrcWidth != nDstWidth) || (nSrcHeight != nDstHeight))
930 pTempData = planar->pTempData;
931 nTempStep = planar->nTempStep;
932 nTotalHeight = planar->maxHeight;
937 if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
938 nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
942 srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
944 srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
946 if ((SrcSize - (srcp - pSrcData)) == 1)
951 status = planar_decompress_plane_rle(
952 planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), pTempData, nTempStep,
953 nXDst, nYDst, nSrcWidth, nSrcHeight, 2, vFlip);
958 status = planar_decompress_plane_rle(
959 planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), pTempData, nTempStep,
960 nXDst, nYDst, nSrcWidth, nSrcHeight, 1, vFlip);
965 status = planar_decompress_plane_rle(
966 planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), pTempData, nTempStep,
967 nXDst, nYDst, nSrcWidth, nSrcHeight, 0, vFlip);
972 srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
976 status = planar_decompress_plane_rle(
977 planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), pTempData,
978 nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3, vFlip);
981 status = planar_set_plane(0xFF, pTempData, nTempStep, nXDst, nYDst, nSrcWidth,
982 nSrcHeight, 3, vFlip);
991 if (pTempData != pDstData)
993 if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, w, h,
994 pTempData, TempFormat, nTempStep, nXDst, nYDst, NULL,
997 WLog_ERR(TAG,
"planar image copy failed");
1004 UINT32 TempFormat = 0;
1005 BYTE* pTempData = planar->pTempData;
1006 UINT32 nTempStep = planar->nTempStep;
1007 UINT32 nTotalHeight = planar->maxHeight;
1008 BYTE* dst = &pDstData[nXDst * FreeRDPGetBytesPerPixel(DstFormat) + nYDst * nDstStep];
1011 TempFormat = PIXEL_FORMAT_BGRA32;
1013 TempFormat = PIXEL_FORMAT_BGRX32;
1020 BYTE* rleBuffer[4] = { 0 };
1022 if (!planar->rlePlanesBuffer)
1025 rleBuffer[3] = planar->rlePlanesBuffer;
1026 rleBuffer[0] = rleBuffer[3] + planeSize;
1027 rleBuffer[1] = rleBuffer[0] + planeSize;
1028 rleBuffer[2] = rleBuffer[1] + planeSize;
1031 status = planar_decompress_plane_rle_only(
1032 planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), rleBuffer[3],
1033 rawWidths[3], rawHeights[3]);
1040 srcp += rleSizes[3];
1042 status = planar_decompress_plane_rle_only(
1043 planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), rleBuffer[0],
1044 rawWidths[0], rawHeights[0]);
1049 status = planar_decompress_plane_rle_only(
1050 planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), rleBuffer[1],
1051 rawWidths[1], rawHeights[1]);
1056 status = planar_decompress_plane_rle_only(
1057 planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), rleBuffer[2],
1058 rawWidths[2], rawHeights[2]);
1063 planes[0] = rleBuffer[0];
1064 planes[1] = rleBuffer[1];
1065 planes[2] = rleBuffer[2];
1066 planes[3] = rleBuffer[3];
1075 if (!planar_subsample_expand(planes[1], rawSizes[1], nSrcWidth, nSrcHeight,
1076 rawWidths[1], rawHeights[1], planar->deltaPlanes[0]))
1079 planes[1] = planar->deltaPlanes[0];
1080 rawSizes[1] = planeSize;
1081 rawWidths[1] = nSrcWidth;
1082 rawHeights[1] = nSrcHeight;
1084 if (!planar_subsample_expand(planes[2], rawSizes[2], nSrcWidth, nSrcHeight,
1085 rawWidths[2], rawHeights[2], planar->deltaPlanes[1]))
1088 planes[2] = planar->deltaPlanes[1];
1089 rawSizes[2] = planeSize;
1090 rawWidths[2] = nSrcWidth;
1091 rawHeights[2] = nSrcHeight;
1094 if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
1095 nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
1099 srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
1101 srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
1103 if ((SrcSize - (srcp - pSrcData)) == 1)
1107 WINPR_ASSERT(prims->YCoCgToRGB_8u_AC4R);
1108 int rc = prims->YCoCgToRGB_8u_AC4R(
1109 pTempData, WINPR_ASSERTING_INT_CAST(int32_t, nTempStep), dst, DstFormat,
1110 WINPR_ASSERTING_INT_CAST(int32_t, nDstStep), w, h, cll, useAlpha);
1111 if (rc != PRIMITIVES_SUCCESS)
1113 WLog_ERR(TAG,
"YCoCgToRGB_8u_AC4R failed with %d", rc);
1122static inline BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
1123 const BYTE* WINPR_RESTRICT data, UINT32 format,
1124 UINT32 width, UINT32 height, UINT32 scanline,
1125 BYTE* WINPR_RESTRICT planes[4])
1127 WINPR_ASSERT(planar);
1129 if ((width > INT32_MAX) || (height > INT32_MAX) || (scanline > INT32_MAX))
1133 scanline = width * FreeRDPGetBytesPerPixel(format);
1135 if (planar->topdown)
1138 for (UINT32 i = 0; i < height; i++)
1140 const BYTE* pixel = &data[1ULL * scanline * i];
1142 for (UINT32 j = 0; j < width; j++)
1144 const UINT32 color = FreeRDPReadColor(pixel, format);
1145 pixel += FreeRDPGetBytesPerPixel(format);
1146 FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k],
1147 &planes[0][k], NULL);
1156 for (INT64 i = (INT64)height - 1; i >= 0; i--)
1158 const BYTE* pixel = &data[1ULL * scanline * (UINT32)i];
1160 for (UINT32 j = 0; j < width; j++)
1162 const UINT32 color = FreeRDPReadColor(pixel, format);
1163 pixel += FreeRDPGetBytesPerPixel(format);
1164 FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k],
1165 &planes[0][k], NULL);
1173static inline UINT32 freerdp_bitmap_planar_write_rle_bytes(
const BYTE* WINPR_RESTRICT pInBuffer,
1174 UINT32 cRawBytes, UINT32 nRunLength,
1175 BYTE* WINPR_RESTRICT pOutBuffer,
1176 UINT32 outBufferSize)
1178 const BYTE* pInput = pInBuffer;
1179 BYTE* pOutput = pOutBuffer;
1180 BYTE controlByte = 0;
1181 UINT32 nBytesToWrite = 0;
1183 if (!cRawBytes && !nRunLength)
1188 cRawBytes += nRunLength;
1196 if (nRunLength > 15)
1198 if (nRunLength < 18)
1200 controlByte = PLANAR_CONTROL_BYTE(13, cRawBytes);
1206 controlByte = PLANAR_CONTROL_BYTE(15, cRawBytes);
1213 controlByte = PLANAR_CONTROL_BYTE(nRunLength, cRawBytes);
1220 controlByte = PLANAR_CONTROL_BYTE(0, 15);
1224 if (outBufferSize < 1)
1228 *pOutput = controlByte;
1230 nBytesToWrite = (controlByte >> 4);
1234 if (outBufferSize < nBytesToWrite)
1237 outBufferSize -= nBytesToWrite;
1238 CopyMemory(pOutput, pInput, nBytesToWrite);
1239 pOutput += nBytesToWrite;
1240 pInput += nBytesToWrite;
1246 if (nRunLength > 47)
1248 if (nRunLength < 50)
1250 controlByte = PLANAR_CONTROL_BYTE(2, 13);
1255 controlByte = PLANAR_CONTROL_BYTE(2, 15);
1259 else if (nRunLength > 31)
1261 controlByte = PLANAR_CONTROL_BYTE(2, (nRunLength - 32));
1264 else if (nRunLength > 15)
1266 controlByte = PLANAR_CONTROL_BYTE(1, (nRunLength - 16));
1271 controlByte = PLANAR_CONTROL_BYTE(nRunLength, 0);
1275 if (outBufferSize < 1)
1279 *pOutput = controlByte;
1283 const intptr_t diff = (pOutput - pOutBuffer);
1284 if ((diff < 0) || (diff > UINT32_MAX))
1286 return (UINT32)diff;
1289static inline UINT32 freerdp_bitmap_planar_encode_rle_bytes(
const BYTE* WINPR_RESTRICT pInBuffer,
1290 UINT32 inBufferSize,
1291 BYTE* WINPR_RESTRICT pOutBuffer,
1292 UINT32 outBufferSize)
1295 const BYTE* pInput = pInBuffer;
1296 BYTE* pOutput = pOutBuffer;
1297 const BYTE* pBytes = NULL;
1298 UINT32 cRawBytes = 0;
1299 UINT32 nRunLength = 0;
1300 UINT32 nBytesWritten = 0;
1301 UINT32 nTotalBytesWritten = 0;
1311 const UINT32 bSymbolMatch = (symbol == *pInput) ? TRUE : FALSE;
1316 if (nRunLength && !bSymbolMatch)
1320 cRawBytes += nRunLength;
1325 pBytes = pInput - (cRawBytes + nRunLength + 1);
1326 nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
1327 pOutput, outBufferSize);
1330 if (!nBytesWritten || (nBytesWritten > outBufferSize))
1333 nTotalBytesWritten += nBytesWritten;
1334 outBufferSize -= nBytesWritten;
1335 pOutput += nBytesWritten;
1340 nRunLength += bSymbolMatch;
1341 cRawBytes += (!bSymbolMatch) ? TRUE : FALSE;
1342 }
while (outBufferSize);
1344 if (cRawBytes || nRunLength)
1346 pBytes = pInput - (cRawBytes + nRunLength);
1347 nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
1348 pOutput, outBufferSize);
1353 nTotalBytesWritten += nBytesWritten;
1359 return nTotalBytesWritten;
1362BOOL freerdp_bitmap_planar_compress_plane_rle(
const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
1363 UINT32 height, BYTE* WINPR_RESTRICT outPlane,
1364 UINT32* WINPR_RESTRICT dstSize)
1370 const BYTE* pInput = inPlane;
1371 BYTE* pOutput = outPlane;
1372 UINT32 outBufferSize = *dstSize;
1373 UINT32 nTotalBytesWritten = 0;
1375 while (outBufferSize > 0)
1377 const UINT32 nBytesWritten =
1378 freerdp_bitmap_planar_encode_rle_bytes(pInput, width, pOutput, outBufferSize);
1380 if ((!nBytesWritten) || (nBytesWritten > outBufferSize))
1383 outBufferSize -= nBytesWritten;
1384 nTotalBytesWritten += nBytesWritten;
1385 pOutput += nBytesWritten;
1389 if (index >= height)
1393 *dstSize = nTotalBytesWritten;
1397static inline BOOL freerdp_bitmap_planar_compress_planes_rle(BYTE* WINPR_RESTRICT inPlanes[4],
1398 UINT32 width, UINT32 height,
1399 BYTE* WINPR_RESTRICT outPlanes,
1400 UINT32* WINPR_RESTRICT dstSizes,
1403 UINT32 outPlanesSize = width * height * 4;
1412 dstSizes[0] = outPlanesSize;
1414 if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[0], width, height, outPlanes,
1418 outPlanes += dstSizes[0];
1419 outPlanesSize -= dstSizes[0];
1423 dstSizes[1] = outPlanesSize;
1425 if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[1], width, height, outPlanes,
1429 outPlanes += dstSizes[1];
1430 outPlanesSize -= dstSizes[1];
1432 dstSizes[2] = outPlanesSize;
1434 if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[2], width, height, outPlanes,
1438 outPlanes += dstSizes[2];
1439 outPlanesSize -= dstSizes[2];
1441 dstSizes[3] = outPlanesSize;
1443 if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[3], width, height, outPlanes,
1450BYTE* freerdp_bitmap_planar_delta_encode_plane(
const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
1451 UINT32 height, BYTE* WINPR_RESTRICT outPlane)
1455 if (width * height == 0)
1458 outPlane = (BYTE*)calloc(height, width);
1464 CopyMemory(outPlane, inPlane, width);
1466 for (UINT32 y = 1; y < height; y++)
1468 const size_t off = 1ull * width * y;
1469 BYTE* outPtr = &outPlane[off];
1470 const BYTE* srcPtr = &inPlane[off];
1471 const BYTE* prevLinePtr = &inPlane[off - width];
1472 for (UINT32 x = 0; x < width; x++)
1474 const int delta = (int)srcPtr[x] - (
int)prevLinePtr[x];
1475 const int s2c1i = (delta >= 0) ? delta : (INT_MAX + delta) + 1;
1476 const int8_t s2c1 = WINPR_CXX_COMPAT_CAST(int8_t, s2c1i);
1477 const uint32_t s2c =
1478 (s2c1 >= 0) ? ((UINT32)s2c1 << 1) : (((UINT32)(~(s2c1) + 1) << 1) - 1);
1479 outPtr[x] = (BYTE)s2c;
1486static inline BOOL freerdp_bitmap_planar_delta_encode_planes(BYTE* WINPR_RESTRICT inPlanes[4],
1487 UINT32 width, UINT32 height,
1488 BYTE* WINPR_RESTRICT outPlanes[4])
1490 for (UINT32 i = 0; i < 4; i++)
1493 freerdp_bitmap_planar_delta_encode_plane(inPlanes[i], width, height, outPlanes[i]);
1502BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
1503 const BYTE* WINPR_RESTRICT data, UINT32 format, UINT32 width,
1504 UINT32 height, UINT32 scanline, BYTE* WINPR_RESTRICT dstData,
1505 UINT32* WINPR_RESTRICT pDstSize)
1509 UINT32 dstSizes[4] = { 0 };
1510 BYTE FormatHeader = 0;
1512 if (!context || !context->rlePlanesBuffer)
1515 if (context->AllowSkipAlpha)
1516 FormatHeader |= PLANAR_FORMAT_HEADER_NA;
1518 const UINT32 planeSize = width * height;
1520 if (!context->AllowSkipAlpha)
1521 format = planar_invert_format(context, TRUE, format);
1523 if (!freerdp_split_color_planes(context, data, format, width, height, scanline,
1527 if (context->AllowRunLengthEncoding)
1529 if (!freerdp_bitmap_planar_delta_encode_planes(context->planes, width, height,
1530 context->deltaPlanes))
1533 if (!freerdp_bitmap_planar_compress_planes_rle(context->deltaPlanes, width, height,
1534 context->rlePlanesBuffer, dstSizes,
1535 context->AllowSkipAlpha))
1539 uint32_t offset = 0;
1540 FormatHeader |= PLANAR_FORMAT_HEADER_RLE;
1541 context->rlePlanes[0] = &context->rlePlanesBuffer[offset];
1542 offset += dstSizes[0];
1543 context->rlePlanes[1] = &context->rlePlanesBuffer[offset];
1544 offset += dstSizes[1];
1545 context->rlePlanes[2] = &context->rlePlanesBuffer[offset];
1546 offset += dstSizes[2];
1547 context->rlePlanes[3] = &context->rlePlanesBuffer[offset];
1549#if defined(WITH_DEBUG_CODECS)
1551 "R: [%" PRIu32
"/%" PRIu32
"] G: [%" PRIu32
"/%" PRIu32
"] B: [%" PRIu32
1553 dstSizes[1], planeSize, dstSizes[2], planeSize, dstSizes[3], planeSize);
1558 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1560 if (!context->AllowRunLengthEncoding)
1563 if (context->rlePlanes[0] == NULL)
1566 if (context->rlePlanes[1] == NULL)
1569 if (context->rlePlanes[2] == NULL)
1572 if (context->rlePlanes[3] == NULL)
1580 if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
1582 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1583 size += dstSizes[0];
1588 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1589 size += (dstSizes[1] + dstSizes[2] + dstSizes[3]);
1591 size += (planeSize * 3);
1593 if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
1596 dstData = malloc(size);
1605 *dstp = FormatHeader;
1610 if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
1612 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1614 CopyMemory(dstp, context->rlePlanes[0], dstSizes[0]);
1615 dstp += dstSizes[0];
1619 CopyMemory(dstp, context->planes[0], planeSize);
1626 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1628 CopyMemory(dstp, context->rlePlanes[1], dstSizes[1]);
1629 dstp += dstSizes[1];
1633 CopyMemory(dstp, context->planes[1], planeSize);
1639 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1641 CopyMemory(dstp, context->rlePlanes[2], dstSizes[2]);
1642 dstp += dstSizes[2];
1646 CopyMemory(dstp, context->planes[2], planeSize);
1652 if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
1654 CopyMemory(dstp, context->rlePlanes[3], dstSizes[3]);
1655 dstp += dstSizes[3];
1659 CopyMemory(dstp, context->planes[3], planeSize);
1665 if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
1671 const intptr_t diff = (dstp - dstData);
1672 if ((diff < 0) || (diff > UINT32_MAX))
1677 size = (UINT32)diff;
1682BOOL freerdp_bitmap_planar_context_reset(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
1683 UINT32 width, UINT32 height)
1688 context->bgr = FALSE;
1689 context->maxWidth = PLANAR_ALIGN(width, 4);
1690 context->maxHeight = PLANAR_ALIGN(height, 4);
1692 const UINT64 tmp = (UINT64)context->maxWidth * context->maxHeight;
1693 if (tmp > UINT32_MAX)
1695 context->maxPlaneSize = (UINT32)tmp;
1698 if (context->maxWidth > UINT32_MAX / 4)
1700 context->nTempStep = context->maxWidth * 4;
1702 memset((
void*)context->planes, 0,
sizeof(context->planes));
1703 memset((
void*)context->rlePlanes, 0,
sizeof(context->rlePlanes));
1704 memset((
void*)context->deltaPlanes, 0,
sizeof(context->deltaPlanes));
1706 if (context->maxPlaneSize > 0)
1708 void* tmp = winpr_aligned_recalloc(context->planesBuffer, context->maxPlaneSize, 4, 32);
1711 context->planesBuffer = tmp;
1713 tmp = winpr_aligned_recalloc(context->pTempData, context->maxPlaneSize, 6, 32);
1716 context->pTempData = tmp;
1718 tmp = winpr_aligned_recalloc(context->deltaPlanesBuffer, context->maxPlaneSize, 4, 32);
1721 context->deltaPlanesBuffer = tmp;
1723 tmp = winpr_aligned_recalloc(context->rlePlanesBuffer, context->maxPlaneSize, 4, 32);
1726 context->rlePlanesBuffer = tmp;
1728 context->planes[0] = &context->planesBuffer[0ULL * context->maxPlaneSize];
1729 context->planes[1] = &context->planesBuffer[1ULL * context->maxPlaneSize];
1730 context->planes[2] = &context->planesBuffer[2ULL * context->maxPlaneSize];
1731 context->planes[3] = &context->planesBuffer[3ULL * context->maxPlaneSize];
1732 context->deltaPlanes[0] = &context->deltaPlanesBuffer[0ULL * context->maxPlaneSize];
1733 context->deltaPlanes[1] = &context->deltaPlanesBuffer[1ULL * context->maxPlaneSize];
1734 context->deltaPlanes[2] = &context->deltaPlanesBuffer[2ULL * context->maxPlaneSize];
1735 context->deltaPlanes[3] = &context->deltaPlanesBuffer[3ULL * context->maxPlaneSize];
1740BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(DWORD flags, UINT32 maxWidth,
1743 BITMAP_PLANAR_CONTEXT* context =
1744 (BITMAP_PLANAR_CONTEXT*)winpr_aligned_calloc(1,
sizeof(BITMAP_PLANAR_CONTEXT), 32);
1749 if (flags & PLANAR_FORMAT_HEADER_NA)
1750 context->AllowSkipAlpha = TRUE;
1752 if (flags & PLANAR_FORMAT_HEADER_RLE)
1753 context->AllowRunLengthEncoding = TRUE;
1755 if (flags & PLANAR_FORMAT_HEADER_CS)
1756 context->AllowColorSubsampling = TRUE;
1758 context->ColorLossLevel = flags & PLANAR_FORMAT_HEADER_CLL_MASK;
1760 if (context->ColorLossLevel)
1761 context->AllowDynamicColorFidelity = TRUE;
1763 if (!freerdp_bitmap_planar_context_reset(context, maxWidth, maxHeight))
1765 WINPR_PRAGMA_DIAG_PUSH
1766 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1767 freerdp_bitmap_planar_context_free(context);
1768 WINPR_PRAGMA_DIAG_POP
1775void freerdp_bitmap_planar_context_free(BITMAP_PLANAR_CONTEXT* context)
1780 winpr_aligned_free(context->pTempData);
1781 winpr_aligned_free(context->planesBuffer);
1782 winpr_aligned_free(context->deltaPlanesBuffer);
1783 winpr_aligned_free(context->rlePlanesBuffer);
1784 winpr_aligned_free(context);
1787void freerdp_planar_switch_bgr(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL bgr)
1789 WINPR_ASSERT(planar);
1793void freerdp_planar_topdown_image(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL topdown)
1795 WINPR_ASSERT(planar);
1796 planar->topdown = topdown;