morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-15 00:44:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

Updated interleaved and planar API.

Browse Source
This commit is contained in:
Armin Novak
2016-07-18 11:11:59 +02:00
parent bc8217ed42
commit e32ed83bf7
5 changed files with 3159 additions and 3164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
include/freerdp/codec/interleaved.h
View File

@@ -39,31 +39,34 @@ struct _BITMAP_INTERLEAVED_CONTEXT
};
#ifdef __cplusplus
extern "C" {
extern "C" {
#endif
FREERDP_API INT32 interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
const BYTE* pSrcData, UINT32 SrcSize,
UINT32 bpp,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
const gdiPalette* palette);
FREERDP_API BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
const BYTE* pSrcData, UINT32 SrcSize,
UINT32 bpp,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
const gdiPalette* palette);
FREERDP_API BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
BYTE* pDstData, UINT32* pDstSize,
UINT32 nWidth, UINT32 nHeight,
const BYTE* pSrcData, UINT32 SrcFormat,
UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
const gdiPalette* palette, UINT32 bpp);
BYTE* pDstData, UINT32* pDstSize,
UINT32 nWidth, UINT32 nHeight,
const BYTE* pSrcData, UINT32 SrcFormat,
UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
const gdiPalette* palette, UINT32 bpp);
FREERDP_API BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* interleaved);
FREERDP_API BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT*
interleaved);
FREERDP_API BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor);
FREERDP_API void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* interleaved);
FREERDP_API BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(
BOOL Compressor);
FREERDP_API void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT*
interleaved);
#ifdef __cplusplus
}
}
#endif
#endif /* FREERDP_CODEC_INTERLEAVED_H */

25
include/freerdp/codec/planar.h
View File

@@ -103,15 +103,6 @@ struct _BITMAP_PLANAR_CONTEXT
extern "C" {
#endif
FREERDP_API BYTE* freerdp_bitmap_planar_compress_plane_rle(
const BYTE* plane, UINT32 width, UINT32 height,
BYTE* outPlane, UINT32* dstSize);
FREERDP_API BYTE* freerdp_bitmap_planar_delta_encode_plane(
const BYTE* inPlane, UINT32 width, UINT32 height, BYTE* outPlane);
FREERDP_API BOOL freerdp_bitmap_planar_delta_encode_planes(
const BYTE* inPlanes[4], UINT32 width, UINT32 height,
BYTE* outPlanes[4]);
FREERDP_API BYTE* freerdp_bitmap_compress_planar(
BITMAP_PLANAR_CONTEXT* context,
const BYTE* data, UINT32 format,
@@ -119,18 +110,18 @@ FREERDP_API BYTE* freerdp_bitmap_compress_planar(
BYTE* dstData, UINT32* pDstSize);
FREERDP_API BOOL freerdp_bitmap_planar_context_reset(
BITMAP_PLANAR_CONTEXT* context, UINT32 width, UINT32 height);
BITMAP_PLANAR_CONTEXT* context, UINT32 width, UINT32 height);
FREERDP_API BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(
DWORD flags, UINT32 width, UINT32 height);
DWORD flags, UINT32 width, UINT32 height);
FREERDP_API void freerdp_bitmap_planar_context_free(
BITMAP_PLANAR_CONTEXT* context);
BITMAP_PLANAR_CONTEXT* context);
FREERDP_API INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight, BOOL vFlip);
FREERDP_API BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight, BOOL vFlip);
#ifdef __cplusplus
}

294
libfreerdp/codec/interleaved.c
View File

@@ -84,17 +84,20 @@ static const BYTE g_MaskLiteRunLength = 0x0F;
*/
static INLINE UINT32 ExtractCodeId(BYTE bOrderHdr)
{
if ((bOrderHdr & 0xC0U) != 0xC0U) {
if ((bOrderHdr & 0xC0U) != 0xC0U)
{
/* REGULAR orders
* (000x xxxx, 001x xxxx, 010x xxxx, 011x xxxx, 100x xxxx)
*/
return bOrderHdr >> 5;
}
else if ((bOrderHdr & 0xF0U) == 0xF0U) {
else if ((bOrderHdr & 0xF0U) == 0xF0U)
{
/* MEGA and SPECIAL orders (0xF*) */
return bOrderHdr;
}
else {
else
{
/* LITE orders
* 1100 xxxx, 1101 xxxx, 1110 xxxx)
*/
@@ -105,73 +108,87 @@ static INLINE UINT32 ExtractCodeId(BYTE bOrderHdr)
/**
* Extract the run length of a compression order.
*/
static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, UINT32* advance)
static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr,
UINT32* advance)
{
UINT32 runLength;
UINT32 ladvance;
ladvance = 1;
runLength = 0;
switch (code)
{
case REGULAR_FGBG_IMAGE:
runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
if (runLength == 0)
{
runLength = (*(pbOrderHdr + 1)) + 1;
ladvance += 1;
}
else
{
runLength = runLength * 8;
}
break;
case LITE_SET_FG_FGBG_IMAGE:
runLength = (*pbOrderHdr) & g_MaskLiteRunLength;
if (runLength == 0)
{
runLength = (*(pbOrderHdr + 1)) + 1;
ladvance += 1;
}
else
{
runLength = runLength * 8;
}
break;
case REGULAR_BG_RUN:
case REGULAR_FG_RUN:
case REGULAR_COLOR_RUN:
case REGULAR_COLOR_IMAGE:
runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
if (runLength == 0)
{
/* An extended (MEGA) run. */
runLength = (*(pbOrderHdr + 1)) + 32;
ladvance += 1;
}
break;
case LITE_SET_FG_FG_RUN:
case LITE_DITHERED_RUN:
runLength = (*pbOrderHdr) & g_MaskLiteRunLength;
if (runLength == 0)
{
/* An extended (MEGA) run. */
runLength = (*(pbOrderHdr + 1)) + 16;
ladvance += 1;
}
break;
case MEGA_MEGA_BG_RUN:
case MEGA_MEGA_FG_RUN:
case MEGA_MEGA_SET_FG_RUN:
case MEGA_MEGA_DITHERED_RUN:
case MEGA_MEGA_COLOR_RUN:
case MEGA_MEGA_FGBG_IMAGE:
case MEGA_MEGA_SET_FGBG_IMAGE:
case MEGA_MEGA_COLOR_IMAGE:
runLength = ((UINT16) pbOrderHdr[1]) | ((UINT16) (pbOrderHdr[2] << 8));
ladvance += 2;
break;
case REGULAR_FGBG_IMAGE:
runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
if (runLength == 0)
{
runLength = (*(pbOrderHdr + 1)) + 1;
ladvance += 1;
}
else
{
runLength = runLength * 8;
}
break;
case LITE_SET_FG_FGBG_IMAGE:
runLength = (*pbOrderHdr) & g_MaskLiteRunLength;
if (runLength == 0)
{
runLength = (*(pbOrderHdr + 1)) + 1;
ladvance += 1;
}
else
{
runLength = runLength * 8;
}
break;
case REGULAR_BG_RUN:
case REGULAR_FG_RUN:
case REGULAR_COLOR_RUN:
case REGULAR_COLOR_IMAGE:
runLength = (*pbOrderHdr) & g_MaskRegularRunLength;
if (runLength == 0)
{
/* An extended (MEGA) run. */
runLength = (*(pbOrderHdr + 1)) + 32;
ladvance += 1;
}
break;
case LITE_SET_FG_FG_RUN:
case LITE_DITHERED_RUN:
runLength = (*pbOrderHdr) & g_MaskLiteRunLength;
if (runLength == 0)
{
/* An extended (MEGA) run. */
runLength = (*(pbOrderHdr + 1)) + 16;
ladvance += 1;
}
break;
case MEGA_MEGA_BG_RUN:
case MEGA_MEGA_FG_RUN:
case MEGA_MEGA_SET_FG_RUN:
case MEGA_MEGA_DITHERED_RUN:
case MEGA_MEGA_COLOR_RUN:
case MEGA_MEGA_FGBG_IMAGE:
case MEGA_MEGA_SET_FGBG_IMAGE:
case MEGA_MEGA_COLOR_IMAGE:
runLength = ((UINT16) pbOrderHdr[1]) | ((UINT16)(pbOrderHdr[2] << 8));
ladvance += 2;
break;
}
*advance = ladvance;
return runLength;
}
@@ -233,11 +250,11 @@ static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, UINT3
#undef RLEDECOMPRESS
#undef RLEEXTRA
#define DESTWRITEPIXEL(_buf, _pix) do { (_buf)[0] = (BYTE)(_pix); \
(_buf)[1] = (BYTE)((_pix) >> 8); (_buf)[2] = (BYTE)((_pix) >> 16); } while (0)
(_buf)[1] = (BYTE)((_pix) >> 8); (_buf)[2] = (BYTE)((_pix) >> 16); } while (0)
#define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | \
((_buf)[2] << 16)
((_buf)[2] << 16)
#define SRCREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | \
((_buf)[2] << 16)
((_buf)[2] << 16)
#define DESTNEXTPIXEL(_buf) _buf += 3
#define SRCNEXTPIXEL(_buf) _buf += 3
#define WRITEFGBGIMAGE WriteFgBgImage24to24
@@ -246,97 +263,101 @@ static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, UINT3
#define RLEEXTRA
#include "include/bitmap.c"
INT32 interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
const BYTE* pSrcData, UINT32 SrcSize,
UINT32 bpp,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
const gdiPalette* palette)
BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
const BYTE* pSrcData, UINT32 SrcSize,
UINT32 bpp,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
const gdiPalette* palette)
{
INT32 status;
UINT32 scanline;
UINT32 SrcFormat;
UINT32 BufferSize;
UINT32 dstBitsPerPixel;
UINT32 dstBytesPerPixel;
dstBitsPerPixel = GetBitsPerPixel(DstFormat);
dstBytesPerPixel = GetBytesPerPixel(DstFormat);
if (!interleaved)
return -1;
return FALSE;
if (nDstStep <= 0)
nDstStep = nWidth * dstBytesPerPixel;
switch(bpp)
switch (bpp)
{
case 24:
scanline = nWidth * 3;
SrcFormat = PIXEL_FORMAT_BGR24_VF;
break;
case 16:
scanline = nWidth * 2;
SrcFormat = PIXEL_FORMAT_RGB16_VF;
break;
case 15:
scanline = nWidth * 2;
SrcFormat = PIXEL_FORMAT_RGB15_VF;
break;
case 8:
scanline = nWidth;
SrcFormat = PIXEL_FORMAT_RGB8_VF;
break;
default:
WLog_ERR(TAG, "Invalid color depth %d", bpp);
return -1;
case 24:
scanline = nWidth * 3;
SrcFormat = PIXEL_FORMAT_BGR24_VF;
break;
case 16:
scanline = nWidth * 2;
SrcFormat = PIXEL_FORMAT_RGB16_VF;
break;
case 15:
scanline = nWidth * 2;
SrcFormat = PIXEL_FORMAT_RGB15_VF;
break;
case 8:
scanline = nWidth;
SrcFormat = PIXEL_FORMAT_RGB8_VF;
break;
default:
WLog_ERR(TAG, "Invalid color depth %d", bpp);
return FALSE;
}
BufferSize = scanline * nHeight;
if (BufferSize > interleaved->TempSize)
{
interleaved->TempBuffer = _aligned_realloc(
interleaved->TempBuffer,
BufferSize, 16);
interleaved->TempBuffer,
BufferSize, 16);
interleaved->TempSize = BufferSize;
}
if (!interleaved->TempBuffer)
return -1;
return FALSE;
switch(bpp)
switch (bpp)
{
case 24:
RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
case 16:
case 15:
RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
case 8:
RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
default:
return -1;
case 24:
RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
case 16:
case 15:
RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
case 8:
RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer,
scanline, nWidth, nHeight);
break;
default:
return FALSE;
}
status = freerdp_image_copy(pDstData, DstFormat, nDstStep, nXDst, nYDst,
nWidth, nHeight, interleaved->TempBuffer,
SrcFormat, scanline, 0, 0, palette);
return status;
return freerdp_image_copy(pDstData, DstFormat, nDstStep, nXDst, nYDst,
nWidth, nHeight, interleaved->TempBuffer,
SrcFormat, scanline, 0, 0, palette);
}
BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
BYTE* pDstData, UINT32* pDstSize,
UINT32 nWidth, UINT32 nHeight,
const BYTE* pSrcData, UINT32 SrcFormat,
UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
const gdiPalette* palette, UINT32 bpp)
BYTE* pDstData, UINT32* pDstSize,
UINT32 nWidth, UINT32 nHeight,
const BYTE* pSrcData, UINT32 SrcFormat,
UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
const gdiPalette* palette, UINT32 bpp)
{
int status;
wStream* s;
@@ -351,7 +372,9 @@ BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
if ((nWidth > 64) || (nHeight > 64))
{
WLog_ERR(TAG, "interleaved_compress: width (%d) or height (%d) is greater than 64", nWidth, nHeight);
WLog_ERR(TAG,
"interleaved_compress: width (%d) or height (%d) is greater than 64", nWidth,
nHeight);
return FALSE;
}
@@ -367,22 +390,20 @@ BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* interleaved,
if (!DstFormat)
return FALSE;
status = freerdp_image_copy(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth, nHeight,
pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette);
status = freerdp_image_copy(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth,
nHeight,
pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette);
s = Stream_New(pDstData, maxSize);
if (!s)
return FALSE;
status = freerdp_bitmap_compress((char*) interleaved->TempBuffer, nWidth, nHeight,
s, bpp, maxSize, nHeight - 1, interleaved->bts, 0);
status = freerdp_bitmap_compress((char*) interleaved->TempBuffer, nWidth,
nHeight,
s, bpp, maxSize, nHeight - 1, interleaved->bts, 0);
Stream_SealLength(s);
*pDstSize = (UINT32) Stream_Length(s);
Stream_Free(s, FALSE);
return status;
}
@@ -397,19 +418,21 @@ BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* interleaved)
BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor)
{
BITMAP_INTERLEAVED_CONTEXT* interleaved;
interleaved = (BITMAP_INTERLEAVED_CONTEXT*) calloc(1, sizeof(BITMAP_INTERLEAVED_CONTEXT));
interleaved = (BITMAP_INTERLEAVED_CONTEXT*) calloc(1,
sizeof(BITMAP_INTERLEAVED_CONTEXT));
if (interleaved)
{
interleaved->TempSize = 64 * 64 * 4;
interleaved->TempBuffer = _aligned_malloc(interleaved->TempSize, 16);
if (!interleaved->TempBuffer)
{
free(interleaved);
WLog_ERR(TAG, "_aligned_malloc failed!");
return NULL;
}
interleaved->bts = Stream_New(NULL, interleaved->TempSize);
if (!interleaved->bts)
@@ -431,6 +454,5 @@ void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* interleaved)
_aligned_free(interleaved->TempBuffer);
Stream_Free(interleaved->bts, TRUE);
free(interleaved);
}

154
libfreerdp/codec/planar.c
View File

@@ -33,8 +33,17 @@
#define TAG FREERDP_TAG("codec")
static int planar_skip_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
int nWidth, int nHeight)
static BYTE* freerdp_bitmap_planar_compress_plane_rle(
const BYTE* plane, UINT32 width, UINT32 height,
BYTE* outPlane, UINT32* dstSize);
static BYTE* freerdp_bitmap_planar_delta_encode_plane(
const BYTE* inPlane, UINT32 width, UINT32 height, BYTE* outPlane);
static BOOL freerdp_bitmap_planar_delta_encode_planes(
const BYTE* inPlanes[4], UINT32 width, UINT32 height,
BYTE* outPlanes[4]);
static INT32 planar_skip_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
int nWidth, int nHeight)
{
int x, y;
int cRawBytes;
@@ -79,14 +88,14 @@ static int planar_skip_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
}
}
return (int)(pRLE - pSrcData);
return (INT32)(pRLE - pSrcData);
}
static int planar_decompress_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, INT32 nDstStep,
UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
UINT32 nChannel, BOOL vFlip)
static INT32 planar_decompress_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, INT32 nDstStep,
UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight,
UINT32 nChannel, BOOL vFlip)
{
UINT32 x, y;
BYTE* dstp;
@@ -214,7 +223,7 @@ static int planar_decompress_plane_rle(const BYTE* pSrcData, UINT32 SrcSize,
previousScanline = currentScanline;
}
return (int)(srcp - pSrcData);
return (INT32)(srcp - pSrcData);
}
static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
@@ -276,11 +285,11 @@ static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
return TRUE;
}
INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight, BOOL vFlip)
BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const BYTE* pSrcData, UINT32 SrcSize,
BYTE* pDstData, UINT32 DstFormat,
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight, BOOL vFlip)
{
BOOL cs;
BOOL rle;
@@ -304,7 +313,7 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const primitives_t* prims = primitives_get();
if ((nWidth < 0) || (nHeight < 0))
return -1;
return FALSE;
dstBitsPerPixel = GetBitsPerPixel(DstFormat);
dstBytesPerPixel = GetBytesPerPixel(DstFormat);
@@ -318,7 +327,7 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
if (!pDstData)
{
WLog_ERR(TAG, "XXX");
return -1;
return FALSE;
}
FormatHeader = *srcp++;
@@ -330,7 +339,7 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
//WLog_INFO(TAG, "CLL: %d CS: %d RLE: %d ALPHA: %d", cll, cs, rle, alpha);
if (!cll && cs)
return -1; /* Chroma subsampling requires YCoCg */
return FALSE; /* Chroma subsampling requires YCoCg */
subWidth = (nWidth / 2) + (nWidth % 2);
subHeight = (nHeight / 2) + (nHeight % 2);
@@ -378,19 +387,19 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
return -1;
return FALSE;
}
else
{
if ((SrcSize - (srcp - pSrcData)) < (planeSize * 3))
return -1;
return FALSE;
planes[0] = srcp; /* LumaOrRedPlane */
planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
return -1;
return FALSE;
}
}
else /* RLE */
@@ -402,28 +411,28 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
rawWidths[3], rawHeights[3]); /* AlphaPlane */
if (rleSizes[3] < 0)
return -1;
return FALSE;
planes[0] = planes[3] + rleSizes[3];
rleSizes[0] = planar_skip_plane_rle(planes[0], SrcSize - (planes[0] - pSrcData),
rawWidths[0], rawHeights[0]); /* RedPlane */
if (rleSizes[0] < 0)
return -1;
return FALSE;
planes[1] = planes[0] + rleSizes[0];
rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
rawWidths[1], rawHeights[1]); /* GreenPlane */
if (rleSizes[1] < 1)
return -1;
return FALSE;
planes[2] = planes[1] + rleSizes[1];
rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
rawWidths[2], rawHeights[2]); /* BluePlane */
if (rleSizes[2] < 1)
return -1;
return FALSE;
}
else
{
@@ -432,21 +441,21 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
rawWidths[0], rawHeights[0]); /* RedPlane */
if (rleSizes[0] < 0)
return -1;
return FALSE;
planes[1] = planes[0] + rleSizes[0];
rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
rawWidths[1], rawHeights[1]); /* GreenPlane */
if (rleSizes[1] < 1)
return -1;
return FALSE;
planes[2] = planes[1] + rleSizes[1];
rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
rawWidths[2], rawHeights[2]); /* BluePlane */
if (rleSizes[2] < 1)
return -1;
return FALSE;
}
}
@@ -456,14 +465,18 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
{
if (alpha)
{
planar_decompress_planes_raw(planes, pDstData, DstFormat, nDstStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip);
if (!planar_decompress_planes_raw(planes, pDstData, DstFormat, nDstStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip))
return FALSE;
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
}
else /* NoAlpha */
{
planar_decompress_planes_raw(planes, pDstData, DstFormat, nDstStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip);
if (!planar_decompress_planes_raw(planes, pDstData, DstFormat, nDstStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip))
return FALSE;
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
}
@@ -491,15 +504,31 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
status = planar_decompress_plane_rle(planes[3], rleSizes[3],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 3,
vFlip); /* AlphaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 2,
vFlip); /* RedPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 1,
vFlip); /* GreenPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 0,
vFlip); /* BluePlane */
if (status < 0)
return FALSE;
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2] + rleSizes[3];
}
else /* NoAlpha */
@@ -507,12 +536,24 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 2,
vFlip); /* RedPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 1,
vFlip); /* GreenPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 0,
vFlip); /* BluePlane */
if (status < 0)
return FALSE;
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
}
@@ -522,7 +563,7 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
nHeight,
pTempData,
TempFormat, nTempStep, nXDst, nYDst, NULL))
return -1;
return FALSE;
}
}
}
@@ -533,26 +574,30 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
UINT32 TempFormat = PIXEL_FORMAT_RGBA32;
if (!pTempData)
return -1;
return FALSE;
if (cs)
{
WLog_ERR(TAG, "Chroma subsampling unimplemented");
return -1;
return FALSE;
}
if (!rle) /* RAW */
{
if (alpha)
{
planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip);
if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip))
return FALSE;
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
}
else /* NoAlpha */
{
planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip);
if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
nXDst, nYDst, nWidth, nHeight, alpha, vFlip))
return FALSE;
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
}
@@ -566,15 +611,31 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
status = planar_decompress_plane_rle(planes[3], rleSizes[3],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 3,
vFlip); /* AlphaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 2,
vFlip); /* LumaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 1,
vFlip); /* OrangeChromaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 0,
vFlip); /* GreenChromaPlane */
if (status < 0)
return FALSE;
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2] + rleSizes[3];
}
else /* NoAlpha */
@@ -582,12 +643,24 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 2,
vFlip); /* LumaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 1,
vFlip); /* OrangeChromaPlane */
if (status < 0)
return FALSE;
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
pTempData, nTempStep, nXDst, nYDst, nWidth, nHeight, 0,
vFlip); /* GreenChromaPlane */
if (status < 0)
return FALSE;
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
}
}
@@ -596,8 +669,7 @@ INT32 planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
nWidth, nHeight, cll, alpha);
}
status = (SrcSize == (srcp - pSrcData)) ? 1 : -1;
return status;
return (SrcSize == (srcp - pSrcData)) ? TRUE : FALSE;
}
static BOOL freerdp_split_color_planes(const BYTE* data, UINT32 format,
@@ -835,6 +907,7 @@ BYTE* freerdp_bitmap_planar_compress_plane_rle(const BYTE* inPlane,
if (!outPlane)
{
outBufferSize = width * height;
if (outBufferSize == 0)
return NULL;
@@ -942,6 +1015,7 @@ BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* inPlane,
{
if (width * height == 0)
return NULL;
if (!(outPlane = (BYTE*) malloc(width * height)))
return NULL;
}

5813
libfreerdp/codec/test/TestFreeRDPCodecPlanar.c
View File

File diff suppressed because it is too large Load Diff