2013-11-26 03:58:01 +04:00
|
|
|
/**
|
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
|
|
* RDP6 Planar Codec
|
|
|
|
*
|
|
|
|
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
2016-04-05 18:07:45 +03:00
|
|
|
* Copyright 2016 Armin Novak <armin.novak@thincast.com>
|
|
|
|
* Copyright 2016 Thincast Technologies GmbH
|
2013-11-26 03:58:01 +04:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2013-11-26 07:26:08 +04:00
|
|
|
#include <winpr/crt.h>
|
|
|
|
#include <winpr/print.h>
|
|
|
|
|
2014-09-07 22:08:29 +04:00
|
|
|
#include <freerdp/primitives.h>
|
2014-09-12 16:36:29 +04:00
|
|
|
#include <freerdp/log.h>
|
2013-11-26 07:26:08 +04:00
|
|
|
#include <freerdp/codec/bitmap.h>
|
2014-09-10 08:42:41 +04:00
|
|
|
#include <freerdp/codec/planar.h>
|
2013-11-26 03:58:01 +04:00
|
|
|
|
2014-09-12 16:36:29 +04:00
|
|
|
#define TAG FREERDP_TAG("codec")
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
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,
|
2016-07-19 17:15:38 +03:00
|
|
|
UINT32 nDstWidth, UINT32 nDstHeight)
|
2014-09-07 23:40:36 +04:00
|
|
|
{
|
2016-07-19 17:15:38 +03:00
|
|
|
UINT32 x, y;
|
2014-09-07 23:40:36 +04:00
|
|
|
int cRawBytes;
|
|
|
|
int nRunLength;
|
|
|
|
BYTE controlByte;
|
|
|
|
const BYTE* pRLE = pSrcData;
|
|
|
|
const BYTE* pEnd = &pSrcData[SrcSize];
|
|
|
|
|
|
|
|
for (y = 0; y < nHeight; y++)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
for (x = 0; x < nWidth;)
|
2014-09-07 23:40:36 +04:00
|
|
|
{
|
|
|
|
if (pRLE >= pEnd)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
controlByte = *pRLE++;
|
|
|
|
nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
|
|
|
|
cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
|
|
|
|
|
|
|
|
if (nRunLength == 1)
|
|
|
|
{
|
|
|
|
nRunLength = cRawBytes + 16;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
|
|
|
else if (nRunLength == 2)
|
|
|
|
{
|
|
|
|
nRunLength = cRawBytes + 32;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pRLE += cRawBytes;
|
|
|
|
x += cRawBytes;
|
|
|
|
cRawBytes = 0;
|
|
|
|
x += nRunLength;
|
|
|
|
nRunLength = 0;
|
|
|
|
|
|
|
|
if (x > nWidth)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (pRLE > pEnd)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
return (INT32)(pRLE - pSrcData);
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
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)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 x, y;
|
2013-11-29 12:06:39 +04:00
|
|
|
BYTE* dstp;
|
|
|
|
UINT32 pixel;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 cRawBytes;
|
|
|
|
UINT32 nRunLength;
|
|
|
|
INT32 deltaValue;
|
2016-04-14 00:18:55 +03:00
|
|
|
INT32 beg, end, inc;
|
2013-11-29 12:06:39 +04:00
|
|
|
BYTE controlByte;
|
|
|
|
BYTE* currentScanline;
|
|
|
|
BYTE* previousScanline;
|
2014-09-07 23:40:36 +04:00
|
|
|
const BYTE* srcp = pSrcData;
|
2014-06-19 01:46:22 +04:00
|
|
|
dstp = pDstData;
|
2013-11-29 12:06:39 +04:00
|
|
|
previousScanline = NULL;
|
|
|
|
|
2014-06-19 21:08:07 +04:00
|
|
|
if (vFlip)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2014-06-19 21:08:07 +04:00
|
|
|
beg = nHeight - 1;
|
|
|
|
end = -1;
|
|
|
|
inc = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
beg = 0;
|
|
|
|
end = nHeight;
|
|
|
|
inc = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (y = beg; y != end; y += inc)
|
|
|
|
{
|
2014-06-19 21:55:34 +04:00
|
|
|
dstp = &pDstData[((nYDst + y) * nDstStep) + (nXDst * 4) + nChannel];
|
2013-11-29 12:06:39 +04:00
|
|
|
pixel = 0;
|
|
|
|
currentScanline = dstp;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
for (x = 0; x < nWidth;)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
controlByte = *srcp;
|
|
|
|
srcp++;
|
|
|
|
|
2014-06-19 01:46:22 +04:00
|
|
|
if ((srcp - pSrcData) > SrcSize)
|
2013-11-29 13:12:59 +04:00
|
|
|
{
|
2014-09-12 16:36:29 +04:00
|
|
|
WLog_ERR(TAG, "error reading input buffer");
|
2013-11-29 13:12:59 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
|
|
|
|
cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
|
|
|
|
|
|
|
|
if (nRunLength == 1)
|
|
|
|
{
|
|
|
|
nRunLength = cRawBytes + 16;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
|
|
|
else if (nRunLength == 2)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
nRunLength = cRawBytes + 32;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-06-19 01:46:22 +04:00
|
|
|
if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 4)
|
2013-11-29 13:12:59 +04:00
|
|
|
{
|
2014-09-12 16:36:29 +04:00
|
|
|
WLog_ERR(TAG, "too many pixels in scanline");
|
2013-11-29 13:12:59 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
if (!previousScanline)
|
|
|
|
{
|
|
|
|
/* first scanline, absolute values */
|
|
|
|
while (cRawBytes > 0)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
pixel = *srcp;
|
|
|
|
srcp++;
|
|
|
|
*dstp = pixel;
|
|
|
|
dstp += 4;
|
|
|
|
x++;
|
|
|
|
cRawBytes--;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
while (nRunLength > 0)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
*dstp = pixel;
|
|
|
|
dstp += 4;
|
|
|
|
x++;
|
|
|
|
nRunLength--;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
}
|
2013-11-29 12:06:39 +04:00
|
|
|
else
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
/* delta values relative to previous scanline */
|
|
|
|
while (cRawBytes > 0)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
deltaValue = *srcp;
|
|
|
|
srcp++;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
if (deltaValue & 1)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
deltaValue = deltaValue >> 1;
|
|
|
|
deltaValue = deltaValue + 1;
|
|
|
|
pixel = -deltaValue;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
deltaValue = deltaValue >> 1;
|
|
|
|
pixel = deltaValue;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
deltaValue = previousScanline[x * 4] + pixel;
|
|
|
|
*dstp = deltaValue;
|
|
|
|
dstp += 4;
|
|
|
|
x++;
|
|
|
|
cRawBytes--;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
while (nRunLength > 0)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2013-11-29 12:06:39 +04:00
|
|
|
deltaValue = previousScanline[x * 4] + pixel;
|
|
|
|
*dstp = deltaValue;
|
|
|
|
dstp += 4;
|
|
|
|
x++;
|
|
|
|
nRunLength--;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-29 12:06:39 +04:00
|
|
|
previousScanline = currentScanline;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
return (INT32)(srcp - pSrcData);
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4],
|
2016-04-23 12:25:55 +03:00
|
|
|
BYTE* pDstData, UINT32 DstFormat,
|
|
|
|
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
|
|
|
|
BOOL alpha, BOOL vFlip)
|
2014-09-07 22:08:29 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
INT32 x, y;
|
|
|
|
INT32 beg, end, inc;
|
2014-09-07 22:08:29 +04:00
|
|
|
const BYTE* pR = pSrcData[0];
|
|
|
|
const BYTE* pG = pSrcData[1];
|
|
|
|
const BYTE* pB = pSrcData[2];
|
|
|
|
const BYTE* pA = pSrcData[3];
|
|
|
|
|
|
|
|
if (vFlip)
|
|
|
|
{
|
|
|
|
beg = nHeight - 1;
|
|
|
|
end = -1;
|
|
|
|
inc = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
beg = 0;
|
|
|
|
end = nHeight;
|
|
|
|
inc = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
for (y = beg; y != end; y += inc)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE* pRGB = &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(
|
2016-04-23 12:25:55 +03:00
|
|
|
DstFormat))];
|
2014-09-07 22:08:29 +04:00
|
|
|
|
|
|
|
for (x = 0; x < nWidth; x++)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 color = GetColor(DstFormat, *pR++, *pG++, *pB++, *pA++);
|
|
|
|
WriteColor(pRGB, DstFormat, color);
|
|
|
|
pRGB += GetBytesPerPixel(DstFormat);
|
2014-09-07 22:08:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (y = beg; y != end; y += inc)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE* pRGB = &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(
|
2016-04-23 12:25:55 +03:00
|
|
|
DstFormat))];
|
2014-09-07 22:08:29 +04:00
|
|
|
|
|
|
|
for (x = 0; x < nWidth; x++)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 color = GetColor(DstFormat, *pR++, *pG++, *pB++, 0xFF);
|
|
|
|
WriteColor(pRGB, DstFormat, color);
|
|
|
|
pRGB += GetBytesPerPixel(DstFormat);
|
2014-09-07 22:08:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
return TRUE;
|
2014-09-07 22:08:29 +04:00
|
|
|
}
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
|
|
|
|
const BYTE* pSrcData, UINT32 SrcSize,
|
2016-07-19 17:15:38 +03:00
|
|
|
UINT32 nSrcWidth, UINT32 nSrcHeight,
|
2016-07-18 12:11:59 +03:00
|
|
|
BYTE* pDstData, UINT32 DstFormat,
|
|
|
|
UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
|
2016-07-19 17:15:38 +03:00
|
|
|
UINT32 nDstWidth, UINT32 nDstHeight, BOOL vFlip)
|
2014-06-18 00:44:24 +04:00
|
|
|
{
|
2014-09-07 22:08:29 +04:00
|
|
|
BOOL cs;
|
|
|
|
BOOL rle;
|
|
|
|
UINT32 cll;
|
|
|
|
BOOL alpha;
|
2016-04-05 18:07:45 +03:00
|
|
|
INT32 status;
|
|
|
|
const BYTE* srcp;
|
|
|
|
UINT32 subSize;
|
|
|
|
UINT32 subWidth;
|
|
|
|
UINT32 subHeight;
|
|
|
|
UINT32 planeSize;
|
|
|
|
UINT32 rleSizes[4];
|
|
|
|
UINT32 rawSizes[4];
|
|
|
|
UINT32 rawWidths[4];
|
|
|
|
UINT32 rawHeights[4];
|
2014-06-18 00:44:24 +04:00
|
|
|
BYTE FormatHeader;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 dstBitsPerPixel;
|
|
|
|
UINT32 dstBytesPerPixel;
|
2014-09-07 23:40:36 +04:00
|
|
|
const BYTE* planes[4];
|
2014-06-18 00:44:24 +04:00
|
|
|
UINT32 UncompressedSize;
|
2016-07-19 17:15:38 +03:00
|
|
|
const UINT32 w = MIN(nSrcWidth, nDstWidth);
|
|
|
|
const UINT32 h = MIN(nSrcHeight, nDstHeight);
|
2014-09-07 22:08:29 +04:00
|
|
|
const primitives_t* prims = primitives_get();
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2016-07-19 17:15:38 +03:00
|
|
|
if ((nSrcWidth < 0) || (nSrcHeight < 0))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
dstBitsPerPixel = GetBitsPerPixel(DstFormat);
|
|
|
|
dstBytesPerPixel = GetBytesPerPixel(DstFormat);
|
2014-09-17 20:17:41 +04:00
|
|
|
|
2016-04-19 22:30:28 +03:00
|
|
|
if (nDstStep <= 0)
|
2016-07-19 17:15:38 +03:00
|
|
|
nDstStep = nDstWidth * GetBytesPerPixel(DstFormat);
|
2014-09-17 20:17:41 +04:00
|
|
|
|
2014-06-18 00:44:24 +04:00
|
|
|
srcp = pSrcData;
|
2016-07-19 17:15:38 +03:00
|
|
|
UncompressedSize = nSrcWidth * nSrcHeight * GetBytesPerPixel(DstFormat);
|
2014-06-18 00:44:24 +04:00
|
|
|
|
|
|
|
if (!pDstData)
|
|
|
|
{
|
2016-04-14 00:18:55 +03:00
|
|
|
WLog_ERR(TAG, "XXX");
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
}
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
FormatHeader = *srcp++;
|
2014-09-07 22:08:29 +04:00
|
|
|
cll = (FormatHeader & PLANAR_FORMAT_HEADER_CLL_MASK);
|
|
|
|
cs = (FormatHeader & PLANAR_FORMAT_HEADER_CS) ? TRUE : FALSE;
|
|
|
|
rle = (FormatHeader & PLANAR_FORMAT_HEADER_RLE) ? TRUE : FALSE;
|
|
|
|
alpha = (FormatHeader & PLANAR_FORMAT_HEADER_NA) ? FALSE : TRUE;
|
|
|
|
|
2014-09-12 16:36:29 +04:00
|
|
|
//WLog_INFO(TAG, "CLL: %d CS: %d RLE: %d ALPHA: %d", cll, cs, rle, alpha);
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (!cll && cs)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE; /* Chroma subsampling requires YCoCg */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2016-07-19 17:15:38 +03:00
|
|
|
subWidth = (nSrcWidth / 2) + (nSrcWidth % 2);
|
|
|
|
subHeight = (nSrcHeight / 2) + (nSrcHeight % 2);
|
|
|
|
planeSize = nSrcWidth * nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
subSize = subWidth * subHeight;
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (!cs)
|
|
|
|
{
|
|
|
|
rawSizes[0] = planeSize; /* LumaOrRedPlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[0] = nSrcWidth;
|
|
|
|
rawHeights[0] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
rawSizes[1] = planeSize; /* OrangeChromaOrGreenPlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[1] = nSrcWidth;
|
|
|
|
rawHeights[1] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
rawSizes[2] = planeSize; /* GreenChromaOrBluePlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[2] = nSrcWidth;
|
|
|
|
rawHeights[2] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
rawSizes[3] = planeSize; /* AlphaPlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[3] = nSrcWidth;
|
|
|
|
rawHeights[3] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
|
|
|
else /* Chroma Subsampling */
|
|
|
|
{
|
|
|
|
rawSizes[0] = planeSize; /* LumaOrRedPlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[0] = nSrcWidth;
|
|
|
|
rawHeights[0] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
rawSizes[1] = subSize; /* OrangeChromaOrGreenPlane */
|
|
|
|
rawWidths[1] = subWidth;
|
|
|
|
rawHeights[1] = subHeight;
|
|
|
|
rawSizes[2] = subSize; /* GreenChromaOrBluePlane */
|
|
|
|
rawWidths[2] = subWidth;
|
|
|
|
rawHeights[2] = subHeight;
|
|
|
|
rawSizes[3] = planeSize; /* AlphaPlane */
|
2016-07-19 17:15:38 +03:00
|
|
|
rawWidths[3] = nSrcWidth;
|
|
|
|
rawHeights[3] = nSrcHeight;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (!rle) /* RAW */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
planes[3] = srcp; /* AlphaPlane */
|
|
|
|
planes[0] = planes[3] + rawSizes[3]; /* LumaOrRedPlane */
|
|
|
|
planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
|
|
|
|
planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((SrcSize - (srcp - pSrcData)) < (planeSize * 3))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[0] = srcp; /* LumaOrRedPlane */
|
|
|
|
planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
|
|
|
|
planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* RLE */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
planes[3] = srcp;
|
|
|
|
rleSizes[3] = planar_skip_plane_rle(planes[3], SrcSize - (planes[3] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[3], rawHeights[3]); /* AlphaPlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[3] < 0)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[0] = planes[3] + rleSizes[3];
|
|
|
|
rleSizes[0] = planar_skip_plane_rle(planes[0], SrcSize - (planes[0] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[0], rawHeights[0]); /* RedPlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[0] < 0)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[1] = planes[0] + rleSizes[0];
|
|
|
|
rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[1], rawHeights[1]); /* GreenPlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[1] < 1)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[2] = planes[1] + rleSizes[1];
|
|
|
|
rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[2], rawHeights[2]); /* BluePlane */
|
2014-09-07 22:08:29 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[2] < 1)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 22:08:29 +04:00
|
|
|
}
|
2014-09-07 23:40:36 +04:00
|
|
|
else
|
2014-06-18 00:44:24 +04:00
|
|
|
{
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[0] = srcp;
|
|
|
|
rleSizes[0] = planar_skip_plane_rle(planes[0], SrcSize - (planes[0] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[0], rawHeights[0]); /* RedPlane */
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[0] < 0)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[1] = planes[0] + rleSizes[0];
|
|
|
|
rleSizes[1] = planar_skip_plane_rle(planes[1], SrcSize - (planes[1] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[1], rawHeights[1]); /* GreenPlane */
|
2014-06-19 20:11:06 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (rleSizes[1] < 1)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
planes[2] = planes[1] + rleSizes[1];
|
|
|
|
rleSizes[2] = planar_skip_plane_rle(planes[2], SrcSize - (planes[2] - pSrcData),
|
2016-04-23 12:25:55 +03:00
|
|
|
rawWidths[2], rawHeights[2]); /* BluePlane */
|
2014-09-07 23:40:36 +04:00
|
|
|
|
|
|
|
if (rleSizes[2] < 1)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (!cll) /* RGB */
|
2014-06-18 00:44:24 +04:00
|
|
|
{
|
2016-07-19 17:15:38 +03:00
|
|
|
UINT32 TempFormat;
|
|
|
|
BYTE* pTempData = pDstData;
|
|
|
|
UINT32 nTempStep = nDstStep;
|
|
|
|
|
|
|
|
if (alpha)
|
|
|
|
TempFormat = PIXEL_FORMAT_BGRA32;
|
|
|
|
else
|
|
|
|
TempFormat = PIXEL_FORMAT_BGRX32;
|
|
|
|
|
|
|
|
if ((DstFormat != TempFormat) || (nSrcWidth != nDstWidth)
|
|
|
|
|| (nSrcHeight != nDstHeight))
|
|
|
|
{
|
|
|
|
pTempData = planar->pTempData;
|
|
|
|
}
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (!rle) /* RAW */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
2016-07-19 17:15:38 +03:00
|
|
|
if (!planar_decompress_planes_raw(planes, pTempData, DstFormat, nDstStep,
|
|
|
|
nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
|
|
|
|
}
|
|
|
|
else /* NoAlpha */
|
|
|
|
{
|
2016-07-19 17:15:38 +03:00
|
|
|
if (!planar_decompress_planes_raw(planes, pTempData, DstFormat, nDstStep,
|
|
|
|
nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
|
|
|
|
}
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if ((SrcSize - (srcp - pSrcData)) == 1)
|
|
|
|
srcp++; /* pad */
|
|
|
|
}
|
|
|
|
else /* RLE */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
status = planar_decompress_plane_rle(planes[3], rleSizes[3],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* AlphaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* RedPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* GreenPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* BluePlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2] + rleSizes[3];
|
|
|
|
}
|
|
|
|
else /* NoAlpha */
|
|
|
|
{
|
|
|
|
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* RedPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* GreenPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* BluePlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
|
|
|
|
}
|
2016-07-19 17:15:38 +03:00
|
|
|
}
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2016-07-19 17:15:38 +03:00
|
|
|
if (pTempData != pDstData)
|
|
|
|
{
|
|
|
|
if (!freerdp_image_copy(pDstData, DstFormat, nDstStep, nXDst, nYDst, w,
|
|
|
|
h, pTempData,
|
|
|
|
TempFormat, nTempStep, nXDst, nYDst, NULL))
|
|
|
|
return FALSE;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
2014-06-18 00:44:24 +04:00
|
|
|
}
|
2014-09-07 23:40:36 +04:00
|
|
|
else /* YCoCg */
|
2014-06-18 00:44:24 +04:00
|
|
|
{
|
2016-04-11 15:14:17 +03:00
|
|
|
BYTE* pTempData = planar->pTempData;
|
|
|
|
UINT32 nTempStep = planar->nTempStep;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 TempFormat = PIXEL_FORMAT_RGBA32;
|
|
|
|
|
|
|
|
if (!pTempData)
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if (cs)
|
|
|
|
{
|
2014-09-12 16:36:29 +04:00
|
|
|
WLog_ERR(TAG, "Chroma subsampling unimplemented");
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
2014-09-07 23:40:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!rle) /* RAW */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
2016-07-18 12:11:59 +03:00
|
|
|
if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
|
2016-07-19 17:15:38 +03:00
|
|
|
nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
|
|
|
|
}
|
|
|
|
else /* NoAlpha */
|
|
|
|
{
|
2016-07-18 12:11:59 +03:00
|
|
|
if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep,
|
2016-07-19 17:15:38 +03:00
|
|
|
nXDst, nYDst, nSrcWidth, nSrcHeight, alpha, vFlip))
|
2016-07-18 12:11:59 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
|
|
|
|
}
|
2014-06-18 00:44:24 +04:00
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
if ((SrcSize - (srcp - pSrcData)) == 1)
|
|
|
|
srcp++; /* pad */
|
|
|
|
}
|
|
|
|
else /* RLE */
|
|
|
|
{
|
|
|
|
if (alpha)
|
|
|
|
{
|
|
|
|
status = planar_decompress_plane_rle(planes[3], rleSizes[3],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* AlphaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* LumaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* OrangeChromaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* GreenChromaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2] + rleSizes[3];
|
|
|
|
}
|
|
|
|
else /* NoAlpha */
|
|
|
|
{
|
|
|
|
status = planar_decompress_plane_rle(planes[0], rleSizes[0],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 2,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* LumaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[1], rleSizes[1],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 1,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* OrangeChromaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
status = planar_decompress_plane_rle(planes[2], rleSizes[2],
|
2016-07-19 17:15:38 +03:00
|
|
|
pTempData, nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 0,
|
2016-04-23 12:25:55 +03:00
|
|
|
vFlip); /* GreenChromaPlane */
|
2016-07-18 12:11:59 +03:00
|
|
|
|
|
|
|
if (status < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-09-07 23:40:36 +04:00
|
|
|
srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
|
|
|
|
}
|
2014-07-03 00:30:04 +04:00
|
|
|
}
|
2014-09-07 23:40:36 +04:00
|
|
|
|
2016-07-19 17:15:38 +03:00
|
|
|
if (prims->YCoCgToRGB_8u_AC4R(pTempData, nTempStep, pDstData, DstFormat,
|
|
|
|
nDstStep,
|
|
|
|
w, h, cll, alpha) != PRIMITIVES_SUCCESS)
|
|
|
|
return FALSE;
|
2014-07-03 00:30:04 +04:00
|
|
|
}
|
|
|
|
|
2016-07-18 12:11:59 +03:00
|
|
|
return (SrcSize == (srcp - pSrcData)) ? TRUE : FALSE;
|
2014-06-18 00:44:24 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static BOOL freerdp_split_color_planes(const BYTE* data, UINT32 format,
|
2016-04-23 12:25:55 +03:00
|
|
|
UINT32 width, UINT32 height,
|
|
|
|
UINT32 scanline, BYTE** planes)
|
2013-11-26 03:58:01 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
INT32 i, j, k;
|
|
|
|
UINT32* pixel;
|
2013-11-26 03:58:01 +04:00
|
|
|
k = 0;
|
2013-11-26 08:29:20 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
for (i = height - 1; i >= 0; i--)
|
2013-11-26 07:26:08 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
pixel = (UINT32*) &data[scanline * i];
|
2013-11-26 07:26:08 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
for (j = 0; j < width; j++)
|
2013-11-26 07:26:08 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
*pixel = GetColor(format, planes[1][k], planes[2][k],
|
2016-04-23 12:25:55 +03:00
|
|
|
planes[3][k], planes[0][k]);
|
2016-04-05 18:07:45 +03:00
|
|
|
pixel++;
|
|
|
|
k++;
|
2013-11-26 07:26:08 +04:00
|
|
|
}
|
2013-11-26 03:58:01 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
return TRUE;
|
2013-11-26 03:58:01 +04:00
|
|
|
}
|
2013-11-26 07:26:08 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static UINT32 freerdp_bitmap_planar_write_rle_bytes(
|
2016-04-23 12:25:55 +03:00
|
|
|
const BYTE* pInBuffer, UINT32 cRawBytes, UINT32 nRunLength,
|
|
|
|
BYTE* pOutBuffer, UINT32 outBufferSize)
|
2013-11-27 00:16:40 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
const BYTE* pInput;
|
2014-01-14 07:16:10 +04:00
|
|
|
BYTE* pOutput;
|
|
|
|
BYTE controlByte;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 nBytesToWrite;
|
2014-01-14 07:16:10 +04:00
|
|
|
pInput = pInBuffer;
|
|
|
|
pOutput = pOutBuffer;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (!cRawBytes && !nRunLength)
|
|
|
|
return 0;
|
2013-11-27 00:16:40 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (nRunLength < 3)
|
|
|
|
{
|
|
|
|
cRawBytes += nRunLength;
|
|
|
|
nRunLength = 0;
|
2013-12-04 03:50:22 +04:00
|
|
|
}
|
2013-11-27 03:04:29 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
while (cRawBytes)
|
2013-11-27 00:16:40 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
if (cRawBytes < 16)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
if (nRunLength > 15)
|
|
|
|
{
|
|
|
|
if (nRunLength < 18)
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(13, cRawBytes);
|
|
|
|
nRunLength -= 13;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(15, cRawBytes);
|
|
|
|
nRunLength -= 15;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(nRunLength, cRawBytes);
|
|
|
|
nRunLength = 0;
|
|
|
|
cRawBytes = 0;
|
|
|
|
}
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
2014-01-14 07:16:10 +04:00
|
|
|
else
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
controlByte = PLANAR_CONTROL_BYTE(0, 15);
|
|
|
|
cRawBytes -= 15;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
2013-11-27 03:04:29 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (outBufferSize < 1)
|
|
|
|
return 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
outBufferSize--;
|
|
|
|
*pOutput = controlByte;
|
|
|
|
pOutput++;
|
2016-04-05 18:07:45 +03:00
|
|
|
nBytesToWrite = (int)(controlByte >> 4);
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (nBytesToWrite)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
if (outBufferSize < nBytesToWrite)
|
|
|
|
return 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
outBufferSize -= nBytesToWrite;
|
|
|
|
CopyMemory(pOutput, pInput, nBytesToWrite);
|
|
|
|
pOutput += nBytesToWrite;
|
|
|
|
pInput += nBytesToWrite;
|
|
|
|
}
|
|
|
|
}
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
while (nRunLength)
|
|
|
|
{
|
|
|
|
if (nRunLength > 47)
|
|
|
|
{
|
|
|
|
if (nRunLength < 50)
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(2, 13);
|
|
|
|
nRunLength -= 45;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
2014-01-14 07:16:10 +04:00
|
|
|
else
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
controlByte = PLANAR_CONTROL_BYTE(2, 15);
|
|
|
|
nRunLength -= 47;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (nRunLength > 31)
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(2, (nRunLength - 32));
|
|
|
|
nRunLength = 0;
|
|
|
|
}
|
|
|
|
else if (nRunLength > 15)
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(1, (nRunLength - 16));
|
|
|
|
nRunLength = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
controlByte = PLANAR_CONTROL_BYTE(nRunLength, 0);
|
|
|
|
nRunLength = 0;
|
|
|
|
}
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (outBufferSize < 1)
|
|
|
|
return 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
--outBufferSize;
|
|
|
|
*pOutput = controlByte;
|
|
|
|
pOutput++;
|
|
|
|
}
|
2013-12-20 11:41:25 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
return (pOutput - pOutBuffer);
|
|
|
|
}
|
2013-12-20 11:41:25 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* pInBuffer,
|
2016-04-23 12:25:55 +03:00
|
|
|
UINT32 inBufferSize,
|
|
|
|
BYTE* pOutBuffer,
|
|
|
|
UINT32 outBufferSize)
|
2014-01-14 07:16:10 +04:00
|
|
|
{
|
|
|
|
BYTE symbol;
|
2016-04-05 18:07:45 +03:00
|
|
|
const BYTE* pInput;
|
2014-01-14 07:16:10 +04:00
|
|
|
BYTE* pOutput;
|
2016-04-05 18:07:45 +03:00
|
|
|
const BYTE* pBytes;
|
|
|
|
UINT32 cRawBytes;
|
|
|
|
UINT32 nRunLength;
|
|
|
|
UINT32 bSymbolMatch;
|
|
|
|
UINT32 nBytesWritten;
|
|
|
|
UINT32 nTotalBytesWritten;
|
2014-01-14 07:16:10 +04:00
|
|
|
symbol = 0;
|
|
|
|
cRawBytes = 0;
|
|
|
|
nRunLength = 0;
|
|
|
|
pInput = pInBuffer;
|
|
|
|
pOutput = pOutBuffer;
|
|
|
|
nTotalBytesWritten = 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (!outBufferSize)
|
|
|
|
return 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
do
|
|
|
|
{
|
|
|
|
if (!inBufferSize)
|
|
|
|
break;
|
2013-12-20 11:41:25 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
bSymbolMatch = (symbol == *pInput) ? TRUE : FALSE;
|
|
|
|
symbol = *pInput;
|
|
|
|
pInput++;
|
|
|
|
inBufferSize--;
|
2013-12-20 11:41:25 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (nRunLength && !bSymbolMatch)
|
|
|
|
{
|
|
|
|
if (nRunLength < 3)
|
|
|
|
{
|
|
|
|
cRawBytes += nRunLength;
|
|
|
|
nRunLength = 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
else
|
2013-11-29 04:51:29 +04:00
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
pBytes = pInput - (cRawBytes + nRunLength + 1);
|
2016-04-05 18:07:45 +03:00
|
|
|
nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(
|
2016-04-23 12:25:55 +03:00
|
|
|
pBytes, cRawBytes,
|
|
|
|
nRunLength, pOutput,
|
|
|
|
outBufferSize);
|
2014-01-14 07:16:10 +04:00
|
|
|
nRunLength = 0;
|
2013-11-27 00:16:40 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (!nBytesWritten || (nBytesWritten > outBufferSize))
|
|
|
|
return nRunLength;
|
2013-11-27 00:16:40 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
nTotalBytesWritten += nBytesWritten;
|
|
|
|
outBufferSize -= nBytesWritten;
|
|
|
|
pOutput += nBytesWritten;
|
|
|
|
cRawBytes = 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
}
|
2014-01-13 01:28:06 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
nRunLength += bSymbolMatch;
|
|
|
|
cRawBytes += (!bSymbolMatch) ? TRUE : FALSE;
|
|
|
|
}
|
|
|
|
while (outBufferSize);
|
2013-11-27 01:07:55 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (cRawBytes || nRunLength)
|
|
|
|
{
|
|
|
|
pBytes = pInput - (cRawBytes + nRunLength);
|
|
|
|
nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes,
|
2016-04-23 12:25:55 +03:00
|
|
|
cRawBytes, nRunLength, pOutput, outBufferSize);
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (!nBytesWritten)
|
|
|
|
return 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
nTotalBytesWritten += nBytesWritten;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (inBufferSize)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return nTotalBytesWritten;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE* freerdp_bitmap_planar_compress_plane_rle(const BYTE* inPlane,
|
2016-04-23 12:25:55 +03:00
|
|
|
UINT32 width, UINT32 height,
|
|
|
|
BYTE* outPlane, UINT32* dstSize)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 index;
|
|
|
|
const BYTE* pInput;
|
2014-01-14 07:16:10 +04:00
|
|
|
BYTE* pOutput;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 outBufferSize;
|
|
|
|
UINT32 nBytesWritten;
|
|
|
|
UINT32 nTotalBytesWritten;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
|
|
|
if (!outPlane)
|
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
outBufferSize = width * height;
|
2016-07-18 12:11:59 +03:00
|
|
|
|
2016-07-13 14:12:27 +03:00
|
|
|
if (outBufferSize == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
outPlane = malloc(outBufferSize);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-06-16 16:42:07 +03:00
|
|
|
if (!outPlane)
|
|
|
|
return NULL;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-01-14 07:16:10 +04:00
|
|
|
outBufferSize = *dstSize;
|
2013-11-29 11:16:16 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
index = 0;
|
|
|
|
pInput = inPlane;
|
|
|
|
pOutput = outPlane;
|
|
|
|
nTotalBytesWritten = 0;
|
2013-11-29 11:16:16 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
while (outBufferSize)
|
2013-11-29 11:16:16 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
nBytesWritten = freerdp_bitmap_planar_encode_rle_bytes(
|
2016-04-23 12:25:55 +03:00
|
|
|
pInput, width, pOutput, outBufferSize);
|
2013-12-04 03:50:22 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if ((!nBytesWritten) || (nBytesWritten > outBufferSize))
|
|
|
|
return NULL;
|
2013-11-29 13:12:59 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
outBufferSize -= nBytesWritten;
|
|
|
|
nTotalBytesWritten += nBytesWritten;
|
|
|
|
pOutput += nBytesWritten;
|
|
|
|
pInput += width;
|
|
|
|
index++;
|
2013-12-20 11:41:25 +04:00
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
if (index >= height)
|
|
|
|
break;
|
2013-11-27 01:07:55 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 07:16:10 +04:00
|
|
|
*dstSize = nTotalBytesWritten;
|
2013-11-27 03:04:29 +04:00
|
|
|
return outPlane;
|
|
|
|
}
|
2013-11-27 01:30:43 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
static UINT32 freerdp_bitmap_planar_compress_planes_rle(
|
2016-04-23 12:25:55 +03:00
|
|
|
const BYTE** inPlanes, UINT32 width, UINT32 height,
|
|
|
|
BYTE* outPlanes, UINT32* dstSizes, BOOL skipAlpha)
|
2013-11-27 03:04:29 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 outPlanesSize = width * height * 4;
|
2013-11-28 01:23:20 +04:00
|
|
|
|
2013-12-09 21:02:05 +04:00
|
|
|
/* AlphaPlane */
|
|
|
|
if (skipAlpha)
|
|
|
|
{
|
|
|
|
dstSizes[0] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dstSizes[0] = outPlanesSize;
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_bitmap_planar_compress_plane_rle(
|
2016-04-23 12:25:55 +03:00
|
|
|
inPlanes[0], width, height, outPlanes, &dstSizes[0]))
|
2013-12-09 21:02:05 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
outPlanes += dstSizes[0];
|
|
|
|
outPlanesSize -= dstSizes[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* LumaOrRedPlane */
|
2013-11-28 01:23:20 +04:00
|
|
|
dstSizes[1] = outPlanesSize;
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[1], width, height,
|
2016-04-23 12:25:55 +03:00
|
|
|
outPlanes, &dstSizes[1]))
|
2013-11-27 07:16:31 +04:00
|
|
|
return 0;
|
|
|
|
|
2013-11-28 01:23:20 +04:00
|
|
|
outPlanes += dstSizes[1];
|
|
|
|
outPlanesSize -= dstSizes[1];
|
2013-12-09 21:02:05 +04:00
|
|
|
/* OrangeChromaOrGreenPlane */
|
2013-11-28 01:23:20 +04:00
|
|
|
dstSizes[2] = outPlanesSize;
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[2], width, height,
|
2016-04-23 12:25:55 +03:00
|
|
|
outPlanes, &dstSizes[2]))
|
2013-11-27 07:16:31 +04:00
|
|
|
return 0;
|
|
|
|
|
2013-11-28 01:23:20 +04:00
|
|
|
outPlanes += dstSizes[2];
|
|
|
|
outPlanesSize -= dstSizes[2];
|
2013-12-09 21:02:05 +04:00
|
|
|
/* GreenChromeOrBluePlane */
|
2013-11-28 01:23:20 +04:00
|
|
|
dstSizes[3] = outPlanesSize;
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[3], width, height,
|
2016-04-23 12:25:55 +03:00
|
|
|
outPlanes, &dstSizes[3]))
|
2013-11-27 07:16:31 +04:00
|
|
|
return 0;
|
|
|
|
|
2013-11-28 01:23:20 +04:00
|
|
|
outPlanes += dstSizes[3];
|
|
|
|
outPlanesSize -= dstSizes[3];
|
2013-11-27 07:16:31 +04:00
|
|
|
return 1;
|
2013-11-27 03:04:29 +04:00
|
|
|
}
|
2013-11-27 01:30:43 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* inPlane,
|
2016-04-23 12:25:55 +03:00
|
|
|
UINT32 width, UINT32 height,
|
|
|
|
BYTE* outPlane)
|
2013-11-27 03:04:29 +04:00
|
|
|
{
|
|
|
|
char s2c;
|
2016-04-05 18:07:45 +03:00
|
|
|
INT32 delta;
|
|
|
|
UINT32 y, x;
|
|
|
|
BYTE* outPtr;
|
|
|
|
const BYTE* srcPtr, *prevLinePtr;
|
2013-11-27 01:30:43 +04:00
|
|
|
|
2013-11-27 03:04:29 +04:00
|
|
|
if (!outPlane)
|
2015-06-16 16:42:07 +03:00
|
|
|
{
|
2016-07-13 14:12:27 +03:00
|
|
|
if (width * height == 0)
|
|
|
|
return NULL;
|
2016-07-18 12:11:59 +03:00
|
|
|
|
2015-06-16 16:42:07 +03:00
|
|
|
if (!(outPlane = (BYTE*) malloc(width * height)))
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-11-27 01:30:43 +04:00
|
|
|
|
2014-01-14 12:44:38 +04:00
|
|
|
// first line is copied as is
|
|
|
|
CopyMemory(outPlane, inPlane, width);
|
|
|
|
outPtr = outPlane + width;
|
|
|
|
srcPtr = inPlane + width;
|
|
|
|
prevLinePtr = inPlane;
|
|
|
|
|
|
|
|
for (y = 1; y < height; y++)
|
2013-11-27 01:30:43 +04:00
|
|
|
{
|
2014-01-14 12:44:38 +04:00
|
|
|
for (x = 0; x < width; x++, outPtr++, srcPtr++, prevLinePtr++)
|
2013-11-27 01:30:43 +04:00
|
|
|
{
|
2014-01-14 12:44:38 +04:00
|
|
|
delta = *srcPtr - *prevLinePtr;
|
2016-04-05 18:07:45 +03:00
|
|
|
s2c = (delta >= 0) ? (char) delta : (char)(~((BYTE)(-delta)) + 1);
|
|
|
|
s2c = (s2c >= 0) ? (s2c << 1) : (char)(((~((BYTE) s2c) + 1) << 1) - 1);
|
2014-01-14 12:44:38 +04:00
|
|
|
*outPtr = (BYTE)s2c;
|
2013-11-27 01:30:43 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-27 03:04:29 +04:00
|
|
|
return outPlane;
|
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BOOL freerdp_bitmap_planar_delta_encode_planes(const BYTE** inPlanes,
|
2016-04-23 12:25:55 +03:00
|
|
|
UINT32 width, UINT32 height,
|
|
|
|
BYTE* outPlanes[4])
|
2013-11-27 03:04:29 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 i;
|
2013-11-27 01:30:43 +04:00
|
|
|
|
2015-06-16 16:42:07 +03:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
outPlanes[i] = freerdp_bitmap_planar_delta_encode_plane(
|
2016-04-23 12:25:55 +03:00
|
|
|
inPlanes[i], width, height, outPlanes[i]);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-06-16 16:42:07 +03:00
|
|
|
if (!outPlanes[i])
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
2013-11-27 01:07:55 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context,
|
2016-04-23 12:25:55 +03:00
|
|
|
const BYTE* data, UINT32 format,
|
|
|
|
UINT32 width, UINT32 height, UINT32 scanline,
|
|
|
|
BYTE* dstData, UINT32* pDstSize)
|
2013-11-26 07:26:08 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 size;
|
2013-11-26 07:26:08 +04:00
|
|
|
BYTE* dstp;
|
2016-04-05 18:07:45 +03:00
|
|
|
UINT32 planeSize;
|
|
|
|
UINT32 dstSizes[4];
|
2013-11-27 03:04:29 +04:00
|
|
|
BYTE FormatHeader = 0;
|
2013-11-26 07:26:08 +04:00
|
|
|
|
2013-12-09 02:06:59 +04:00
|
|
|
if (context->AllowSkipAlpha)
|
|
|
|
FormatHeader |= PLANAR_FORMAT_HEADER_NA;
|
2013-11-26 07:26:08 +04:00
|
|
|
|
2013-11-26 08:29:20 +04:00
|
|
|
planeSize = width * height;
|
2013-11-27 03:04:29 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_split_color_planes(data, format, width, height, scanline,
|
2016-04-23 12:25:55 +03:00
|
|
|
context->planes))
|
2014-11-17 03:10:45 +03:00
|
|
|
return NULL;
|
2013-11-27 03:04:29 +04:00
|
|
|
|
2013-12-09 02:06:59 +04:00
|
|
|
if (context->AllowRunLengthEncoding)
|
2013-12-04 05:14:07 +04:00
|
|
|
{
|
2016-04-05 18:07:45 +03:00
|
|
|
if (!freerdp_bitmap_planar_delta_encode_planes(
|
2016-04-23 12:25:55 +03:00
|
|
|
(const BYTE**)context->planes, width, height,
|
|
|
|
context->deltaPlanes))
|
2015-06-16 16:42:07 +03:00
|
|
|
return NULL;;
|
2013-12-04 05:14:07 +04:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (freerdp_bitmap_planar_compress_planes_rle(
|
2016-04-23 12:25:55 +03:00
|
|
|
(const BYTE**)context->deltaPlanes, width, height,
|
|
|
|
context->rlePlanesBuffer, dstSizes,
|
|
|
|
context->AllowSkipAlpha) > 0)
|
2013-12-09 02:06:59 +04:00
|
|
|
{
|
|
|
|
int offset = 0;
|
|
|
|
FormatHeader |= PLANAR_FORMAT_HEADER_RLE;
|
|
|
|
context->rlePlanes[0] = &context->rlePlanesBuffer[offset];
|
|
|
|
offset += dstSizes[0];
|
|
|
|
context->rlePlanes[1] = &context->rlePlanesBuffer[offset];
|
|
|
|
offset += dstSizes[1];
|
|
|
|
context->rlePlanes[2] = &context->rlePlanesBuffer[offset];
|
|
|
|
offset += dstSizes[2];
|
|
|
|
context->rlePlanes[3] = &context->rlePlanesBuffer[offset];
|
|
|
|
offset += dstSizes[3];
|
2015-01-20 13:10:03 +03:00
|
|
|
//WLog_DBG(TAG, "R: [%d/%d] G: [%d/%d] B: [%d/%d]",
|
2013-12-20 11:41:25 +04:00
|
|
|
// dstSizes[1], planeSize, dstSizes[2], planeSize, dstSizes[3], planeSize);
|
2013-12-09 02:06:59 +04:00
|
|
|
}
|
2013-11-27 07:16:31 +04:00
|
|
|
}
|
2013-11-27 03:04:29 +04:00
|
|
|
|
2013-11-26 07:26:08 +04:00
|
|
|
if (!dstData)
|
|
|
|
{
|
2013-11-27 07:16:31 +04:00
|
|
|
size = 1;
|
2013-11-26 07:26:08 +04:00
|
|
|
|
|
|
|
if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
|
2013-11-27 07:16:31 +04:00
|
|
|
{
|
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
size += dstSizes[0];
|
|
|
|
else
|
|
|
|
size += planeSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
size += (dstSizes[1] + dstSizes[2] + dstSizes[3]);
|
|
|
|
else
|
|
|
|
size += (planeSize * 3);
|
2013-11-26 07:26:08 +04:00
|
|
|
|
2013-11-27 07:16:31 +04:00
|
|
|
if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
|
|
|
|
size++;
|
2013-11-26 07:26:08 +04:00
|
|
|
|
|
|
|
dstData = malloc(size);
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2015-06-16 16:42:07 +03:00
|
|
|
if (!dstData)
|
|
|
|
return NULL;
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2014-09-20 23:25:33 +04:00
|
|
|
*pDstSize = size;
|
2013-11-26 07:26:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
dstp = dstData;
|
|
|
|
*dstp = FormatHeader; /* FormatHeader */
|
|
|
|
dstp++;
|
|
|
|
|
|
|
|
/* AlphaPlane */
|
|
|
|
|
|
|
|
if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
|
|
|
|
{
|
2013-11-27 07:16:31 +04:00
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->rlePlanes[0], dstSizes[0]); /* Alpha */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += dstSizes[0];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->planes[0], planeSize); /* Alpha */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += planeSize;
|
|
|
|
}
|
2013-11-26 07:26:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* LumaOrRedPlane */
|
|
|
|
|
2013-11-27 07:16:31 +04:00
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->rlePlanes[1], dstSizes[1]); /* Red */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += dstSizes[1];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->planes[1], planeSize); /* Red */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += planeSize;
|
|
|
|
}
|
2013-11-26 07:26:08 +04:00
|
|
|
|
|
|
|
/* OrangeChromaOrGreenPlane */
|
|
|
|
|
2013-11-27 07:16:31 +04:00
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->rlePlanes[2], dstSizes[2]); /* Green */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += dstSizes[2];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->planes[2], planeSize); /* Green */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += planeSize;
|
|
|
|
}
|
2013-11-26 07:26:08 +04:00
|
|
|
|
|
|
|
/* GreenChromeOrBluePlane */
|
|
|
|
|
2013-11-27 07:16:31 +04:00
|
|
|
if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->rlePlanes[3], dstSizes[3]); /* Blue */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += dstSizes[3];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-12-09 02:06:59 +04:00
|
|
|
CopyMemory(dstp, context->planes[3], planeSize); /* Blue */
|
2013-11-27 07:16:31 +04:00
|
|
|
dstp += planeSize;
|
|
|
|
}
|
2013-11-26 07:26:08 +04:00
|
|
|
|
|
|
|
/* Pad1 (1 byte) */
|
|
|
|
|
|
|
|
if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
|
|
|
|
{
|
|
|
|
*dstp = 0;
|
|
|
|
dstp++;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = (dstp - dstData);
|
2014-09-20 23:25:33 +04:00
|
|
|
*pDstSize = size;
|
2013-11-26 07:26:08 +04:00
|
|
|
return dstData;
|
|
|
|
}
|
2013-12-09 02:06:59 +04:00
|
|
|
|
2016-04-14 00:18:55 +03:00
|
|
|
BOOL freerdp_bitmap_planar_context_reset(
|
2016-04-23 12:25:55 +03:00
|
|
|
BITMAP_PLANAR_CONTEXT* context, UINT32 width, UINT32 height)
|
2014-09-12 22:57:44 +04:00
|
|
|
{
|
2016-03-01 18:17:28 +03:00
|
|
|
if (!context)
|
|
|
|
return FALSE;
|
|
|
|
|
2016-04-14 00:18:55 +03:00
|
|
|
context->maxWidth = width;
|
|
|
|
context->maxHeight = height;
|
|
|
|
context->maxPlaneSize = context->maxWidth * context->maxHeight;
|
|
|
|
context->nTempStep = context->maxWidth * 4;
|
|
|
|
context->planesBuffer = malloc(context->maxPlaneSize * 4);
|
|
|
|
context->pTempData = malloc(context->maxPlaneSize * 4);
|
|
|
|
context->deltaPlanesBuffer = malloc(context->maxPlaneSize * 4);
|
|
|
|
context->rlePlanesBuffer = malloc(context->maxPlaneSize * 4);
|
|
|
|
|
|
|
|
if (!context->planesBuffer || !context->pTempData ||
|
2016-04-23 12:25:55 +03:00
|
|
|
!context->deltaPlanesBuffer || !context->rlePlanesBuffer)
|
2016-04-14 00:18:55 +03:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
context->planes[0] = &context->planesBuffer[context->maxPlaneSize * 0];
|
|
|
|
context->planes[1] = &context->planesBuffer[context->maxPlaneSize * 1];
|
|
|
|
context->planes[2] = &context->planesBuffer[context->maxPlaneSize * 2];
|
|
|
|
context->planes[3] = &context->planesBuffer[context->maxPlaneSize * 3];
|
|
|
|
context->deltaPlanes[0] = &context->deltaPlanesBuffer[context->maxPlaneSize *
|
2016-04-23 12:25:55 +03:00
|
|
|
0];
|
2016-04-14 00:18:55 +03:00
|
|
|
context->deltaPlanes[1] = &context->deltaPlanesBuffer[context->maxPlaneSize *
|
2016-04-23 12:25:55 +03:00
|
|
|
1];
|
2016-04-14 00:18:55 +03:00
|
|
|
context->deltaPlanes[2] = &context->deltaPlanesBuffer[context->maxPlaneSize *
|
2016-04-23 12:25:55 +03:00
|
|
|
2];
|
2016-04-14 00:18:55 +03:00
|
|
|
context->deltaPlanes[3] = &context->deltaPlanesBuffer[context->maxPlaneSize *
|
2016-04-23 12:25:55 +03:00
|
|
|
3];
|
2016-03-01 18:17:28 +03:00
|
|
|
return TRUE;
|
2014-09-12 22:57:44 +04:00
|
|
|
}
|
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(
|
2016-04-23 12:25:55 +03:00
|
|
|
DWORD flags, UINT32 maxWidth, UINT32 maxHeight)
|
2013-12-09 02:06:59 +04:00
|
|
|
{
|
|
|
|
BITMAP_PLANAR_CONTEXT* context;
|
2015-06-16 16:42:07 +03:00
|
|
|
context = (BITMAP_PLANAR_CONTEXT*) calloc(1, sizeof(BITMAP_PLANAR_CONTEXT));
|
2016-04-05 18:07:45 +03:00
|
|
|
|
2013-12-09 02:06:59 +04:00
|
|
|
if (!context)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (flags & PLANAR_FORMAT_HEADER_NA)
|
|
|
|
context->AllowSkipAlpha = TRUE;
|
|
|
|
|
|
|
|
if (flags & PLANAR_FORMAT_HEADER_RLE)
|
|
|
|
context->AllowRunLengthEncoding = TRUE;
|
|
|
|
|
|
|
|
if (flags & PLANAR_FORMAT_HEADER_CS)
|
|
|
|
context->AllowColorSubsampling = TRUE;
|
|
|
|
|
|
|
|
context->ColorLossLevel = flags & PLANAR_FORMAT_HEADER_CLL_MASK;
|
|
|
|
|
|
|
|
if (context->ColorLossLevel)
|
|
|
|
context->AllowDynamicColorFidelity = TRUE;
|
|
|
|
|
2016-04-14 00:18:55 +03:00
|
|
|
if (!freerdp_bitmap_planar_context_reset(context, maxWidth, maxHeight))
|
|
|
|
{
|
|
|
|
freerdp_bitmap_planar_context_free(context);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-12-09 02:06:59 +04:00
|
|
|
|
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
|
|
|
void freerdp_bitmap_planar_context_free(BITMAP_PLANAR_CONTEXT* context)
|
|
|
|
{
|
|
|
|
if (!context)
|
|
|
|
return;
|
|
|
|
|
2016-04-11 15:14:17 +03:00
|
|
|
free(context->pTempData);
|
2013-12-09 02:06:59 +04:00
|
|
|
free(context->planesBuffer);
|
|
|
|
free(context->deltaPlanesBuffer);
|
|
|
|
free(context->rlePlanesBuffer);
|
|
|
|
free(context);
|
|
|
|
}
|