BOOL xf_gdi_bitmap_update(rdpContext* context,
const BITMAP_UPDATE* bitmapUpdate)
{
- int status;
int nXDst;
int nYDst;
int nXSrc;
if (bitsPerPixel < 32)
{
- status = interleaved_decompress(codecs->interleaved,
- pSrcData, SrcSize,
- bitsPerPixel,
- pDstData,
- xfc->format, -1,
- 0, 0,
- nWidth, nHeight,
- &xfc->context.gdi->palette);
+ if (!interleaved_decompress(codecs->interleaved,
+ pSrcData, SrcSize,
+ bitsPerPixel,
+ pDstData,
+ xfc->format, -1,
+ 0, 0,
+ nWidth, nHeight,
+ &xfc->context.gdi->palette))
+ return FALSE;
}
else
{
- status = planar_decompress(codecs->planar, pSrcData, SrcSize, pDstData,
- xfc->format, -1, 0, 0, nWidth, nHeight, TRUE);
- }
-
- if (status < 0)
- {
- WLog_ERR(TAG, "bitmap decompression failure");
- return FALSE;
+ if (!planar_decompress(codecs->planar, pSrcData, SrcSize, pDstData,
+ xfc->format, -1, 0, 0, nWidth, nHeight, TRUE))
+ return FALSE;
}
pSrcData = xfc->bitmap_buffer;
else
{
pDstData = xfc->bitmap_buffer;
- status = freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
- nWidth, nHeight, pSrcData, SrcFormat,
- -1, 0, 0, &xfc->context.gdi->palette);
+
+ if (!freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
+ nWidth, nHeight, pSrcData, SrcFormat,
+ -1, 0, 0, &xfc->context.gdi->palette))
+ return FALSE;
+
pSrcData = xfc->bitmap_buffer;
}
const OPAQUE_RECT_ORDER* opaque_rect)
{
UINT32 color;
+ rdpGdi* gdi = context->gdi;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
+ UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
xf_lock_x11(xfc, FALSE);
- color = xf_convert_rdp_order_color(xfc, opaque_rect->color);
+
+ if (GetBitsPerPixel(SrcFormat) > 8)
+ {
+ SrcFormat = PIXEL_FORMAT_RGB24;
+ color = GetColor(SrcFormat,
+ opaque_rect->color & 0xFF,
+ (opaque_rect->color >> 8) & 0xFF,
+ (opaque_rect->color >> 16) & 0xFF,
+ 0xFF);
+ }
+
+ color = ConvertColor(opaque_rect->color, SrcFormat,
+ gdi->drawing->hdc->format, &gdi->palette);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, color);
const MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
{
UINT32 i;
- UINT32 color;
- const DELTA_RECT* rectangle;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
+ rdpGdi* gdi = context->gdi;
+ UINT32 color;
+ UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
+
+ if (GetBitsPerPixel(SrcFormat) > 8)
+ {
+ SrcFormat = PIXEL_FORMAT_RGB24;
+ color = GetColor(SrcFormat,
+ multi_opaque_rect->color & 0xFF,
+ (multi_opaque_rect->color >> 8) & 0xFF,
+ (multi_opaque_rect->color >> 16) & 0xFF,
+ 0xFF);
+ }
+
+ color = ConvertColor(multi_opaque_rect->color, SrcFormat,
+ gdi->drawing->hdc->format, &gdi->palette);
xf_lock_x11(xfc, FALSE);
- color = xf_convert_rdp_order_color(xfc, multi_opaque_rect->color);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, color);
for (i = 1; i < multi_opaque_rect->numRectangles + 1; i++)
{
- rectangle = &multi_opaque_rect->rectangles[i];
+ const DELTA_RECT* rectangle = &multi_opaque_rect->rectangles[i];
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
rectangle->left, rectangle->top,
rectangle->width, rectangle->height);
const BYTE* data, UINT32 width, UINT32 height, UINT32 bpp, UINT32 length,
BOOL compressed, UINT32 codecId)
{
- int status;
UINT16 size;
const BYTE* pSrcData;
BYTE* pDstData;
{
if (bpp < 32)
{
- status = interleaved_decompress(context->codecs->interleaved,
- pSrcData, SrcSize, bpp,
- pDstData, xfc->format,
- -1, 0, 0, width, height,
- &context->gdi->palette);
+ if (!interleaved_decompress(context->codecs->interleaved,
+ pSrcData, SrcSize, bpp,
+ pDstData, xfc->format,
+ -1, 0, 0, width, height,
+ &context->gdi->palette))
+ return FALSE;
}
else
{
- status = planar_decompress(context->codecs->planar, pSrcData, SrcSize,
- pDstData, xfc->format, -1, 0, 0, width, height, TRUE);
- }
-
- if (status < 0)
- {
- WLog_ERR(TAG, "Bitmap Decompression Failed");
- return FALSE;
+ if (!planar_decompress(context->codecs->planar, pSrcData, SrcSize,
+ pDstData, xfc->format, -1, 0, 0, width, height, TRUE))
+ return FALSE;
}
}
else
{
SrcFormat = gdi_get_pixel_format(bpp, TRUE);
- status = freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
- width, height, pSrcData,
- SrcFormat, -1, 0, 0, &context->gdi->palette);
+
+ if (!freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
+ width, height, pSrcData,
+ SrcFormat, -1, 0, 0, &context->gdi->palette))
+ return FALSE;
}
bitmap->compressed = FALSE;
static rdpGlyph* glyph_cache_get(rdpGlyphCache* glyph_cache, UINT32 id,
UINT32 index);
-static void glyph_cache_put(rdpGlyphCache* glyph_cache, UINT32 id, UINT32 index,
+static BOOL glyph_cache_put(rdpGlyphCache* glyph_cache, UINT32 id, UINT32 index,
rdpGlyph* entry);
static void* glyph_cache_fragment_get(rdpGlyphCache* glyph, UINT32 index,
{
UINT32 i;
rdpGlyph* glyph;
- const GLYPH_DATA_V2* glyphData;
rdpCache* cache = context->cache;
for (i = 0; i < cacheGlyphV2->cGlyphs; i++)
{
- glyphData = &cacheGlyphV2->glyphData[i];
+ const GLYPH_DATA_V2* glyphData = &cacheGlyphV2->glyphData[i];
glyph = Glyph_Alloc(context);
if (!glyph)
glyph->cy = glyphData->cy;
glyph->cb = glyphData->cb;
glyph->aj = glyphData->aj;
- Glyph_New(context, glyph);
+
+ if (!Glyph_New(context, glyph))
+ {
+ Glyph_Free(context, glyph);
+ return FALSE;
+ }
+
glyph_cache_put(cache->glyph, cacheGlyphV2->cacheId, glyphData->cacheIndex,
glyph);
}
return glyph;
}
-void glyph_cache_put(rdpGlyphCache* glyphCache, UINT32 id, UINT32 index,
+BOOL glyph_cache_put(rdpGlyphCache* glyphCache, UINT32 id, UINT32 index,
rdpGlyph* glyph)
{
rdpGlyph* prevGlyph;
if (id > 9)
{
WLog_ERR(TAG, "invalid glyph cache id: %d", id);
- return;
+ return FALSE;
}
if (index > glyphCache->glyphCache[id].number)
{
WLog_ERR(TAG, "invalid glyph cache index: %d in cache id: %d", index, id);
- return;
+ return FALSE;
}
WLog_DBG(TAG, "GlyphCachePut: id: %d index: %d", id, index);
}
glyphCache->glyphCache[id].entries[index] = glyph;
+ return TRUE;
}
void* glyph_cache_fragment_get(rdpGlyphCache* glyphCache, UINT32 index,
* Write a foreground/background image to a destination buffer.
*/
static BYTE* WRITEFGBGIMAGE(BYTE* pbDest, UINT32 rowDelta,
- BYTE bitmask, PIXEL fgPel, INT32 cBits)
+ BYTE bitmask, PIXEL fgPel, INT32 cBits)
{
PIXEL xorPixel;
-
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit0)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit1)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit2)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit3)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit4)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit5)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit6)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
DESTREADPIXEL(xorPixel, pbDest - rowDelta);
+
if (bitmask & g_MaskBit7)
{
DESTWRITEPIXEL(pbDest, xorPixel ^ fgPel);
{
DESTWRITEPIXEL(pbDest, xorPixel);
}
+
DESTNEXTPIXEL(pbDest);
}
}
}
}
}
+
return pbDest;
}
* for the first line of compressed data.
*/
static BYTE* WRITEFIRSTLINEFGBGIMAGE(BYTE* pbDest, BYTE bitmask,
- PIXEL fgPel, UINT32 cBits)
+ PIXEL fgPel, UINT32 cBits)
{
if (bitmask & g_MaskBit0)
{
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit1)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit2)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit3)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit4)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit5)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit6)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
cBits = cBits - 1;
+
if (cBits > 0)
{
if (bitmask & g_MaskBit7)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
}
+
DESTNEXTPIXEL(pbDest);
}
}
}
}
}
+
return pbDest;
}
/**
* Decompress an RLE compressed bitmap.
*/
-void RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer, BYTE* pbDestBuffer,
- UINT32 rowDelta, UINT32 width, UINT32 height)
+static void RLEDECOMPRESS(const BYTE* pbSrcBuffer, UINT32 cbSrcBuffer,
+ BYTE* pbDestBuffer,
+ UINT32 rowDelta, UINT32 width, UINT32 height)
{
const BYTE* pbSrc = pbSrcBuffer;
const BYTE* pbEnd = pbSrcBuffer + cbSrcBuffer;
BYTE* pbDest = pbDestBuffer;
-
PIXEL temp;
PIXEL fgPel = WHITE_PIXEL;
BOOL fInsertFgPel = FALSE;
BOOL fFirstLine = TRUE;
-
BYTE bitmask;
PIXEL pixelA, pixelB;
-
UINT32 runLength;
UINT32 code;
-
UINT32 advance;
-
RLEEXTRA
while (pbSrc < pbEnd)
{
runLength = ExtractRunLength(code, pbSrc, &advance);
pbSrc = pbSrc + advance;
+
if (fFirstLine)
{
if (fInsertFgPel)
DESTNEXTPIXEL(pbDest);
runLength = runLength - 1;
}
+
while (runLength >= UNROLL_COUNT)
{
UNROLL(
- DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
- DESTNEXTPIXEL(pbDest); );
+ DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
+ DESTNEXTPIXEL(pbDest););
runLength = runLength - UNROLL_COUNT;
}
+
while (runLength > 0)
{
DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
DESTNEXTPIXEL(pbDest);
runLength = runLength - 1;
}
+
while (runLength >= UNROLL_COUNT)
{
UNROLL(
- DESTREADPIXEL(temp, pbDest - rowDelta);
- DESTWRITEPIXEL(pbDest, temp);
- DESTNEXTPIXEL(pbDest); );
+ DESTREADPIXEL(temp, pbDest - rowDelta);
+ DESTWRITEPIXEL(pbDest, temp);
+ DESTNEXTPIXEL(pbDest););
runLength = runLength - UNROLL_COUNT;
}
+
while (runLength > 0)
{
DESTREADPIXEL(temp, pbDest - rowDelta);
runLength = runLength - 1;
}
}
+
/* A follow-on background run order will need a foreground pel inserted. */
fInsertFgPel = TRUE;
continue;
switch (code)
{
- /* Handle Foreground Run Orders. */
- case REGULAR_FG_RUN:
- case MEGA_MEGA_FG_RUN:
- case LITE_SET_FG_FG_RUN:
- case MEGA_MEGA_SET_FG_RUN:
- runLength = ExtractRunLength(code, pbSrc, &advance);
- pbSrc = pbSrc + advance;
- if (code == LITE_SET_FG_FG_RUN || code == MEGA_MEGA_SET_FG_RUN)
- {
- SRCREADPIXEL(fgPel, pbSrc);
+ /* Handle Foreground Run Orders. */
+ case REGULAR_FG_RUN:
+ case MEGA_MEGA_FG_RUN:
+ case LITE_SET_FG_FG_RUN:
+ case MEGA_MEGA_SET_FG_RUN:
+ runLength = ExtractRunLength(code, pbSrc, &advance);
+ pbSrc = pbSrc + advance;
+
+ if (code == LITE_SET_FG_FG_RUN || code == MEGA_MEGA_SET_FG_RUN)
+ {
+ SRCREADPIXEL(fgPel, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
+ }
+
+ if (fFirstLine)
+ {
+ while (runLength >= UNROLL_COUNT)
+ {
+ UNROLL(
+ DESTWRITEPIXEL(pbDest, fgPel);
+ DESTNEXTPIXEL(pbDest););
+ runLength = runLength - UNROLL_COUNT;
+ }
+
+ while (runLength > 0)
+ {
+ DESTWRITEPIXEL(pbDest, fgPel);
+ DESTNEXTPIXEL(pbDest);
+ runLength = runLength - 1;
+ }
+ }
+ else
+ {
+ while (runLength >= UNROLL_COUNT)
+ {
+ UNROLL(
+ DESTREADPIXEL(temp, pbDest - rowDelta);
+ DESTWRITEPIXEL(pbDest, temp ^ fgPel);
+ DESTNEXTPIXEL(pbDest););
+ runLength = runLength - UNROLL_COUNT;
+ }
+
+ while (runLength > 0)
+ {
+ DESTREADPIXEL(temp, pbDest - rowDelta);
+ DESTWRITEPIXEL(pbDest, temp ^ fgPel);
+ DESTNEXTPIXEL(pbDest);
+ runLength = runLength - 1;
+ }
+ }
+
+ break;
+
+ /* Handle Dithered Run Orders. */
+ case LITE_DITHERED_RUN:
+ case MEGA_MEGA_DITHERED_RUN:
+ runLength = ExtractRunLength(code, pbSrc, &advance);
+ pbSrc = pbSrc + advance;
+ SRCREADPIXEL(pixelA, pbSrc);
SRCNEXTPIXEL(pbSrc);
- }
- if (fFirstLine)
- {
+ SRCREADPIXEL(pixelB, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
+
while (runLength >= UNROLL_COUNT)
{
UNROLL(
- DESTWRITEPIXEL(pbDest, fgPel);
- DESTNEXTPIXEL(pbDest); );
+ DESTWRITEPIXEL(pbDest, pixelA);
+ DESTNEXTPIXEL(pbDest);
+ DESTWRITEPIXEL(pbDest, pixelB);
+ DESTNEXTPIXEL(pbDest););
runLength = runLength - UNROLL_COUNT;
}
+
while (runLength > 0)
{
- DESTWRITEPIXEL(pbDest, fgPel);
+ DESTWRITEPIXEL(pbDest, pixelA);
+ DESTNEXTPIXEL(pbDest);
+ DESTWRITEPIXEL(pbDest, pixelB);
DESTNEXTPIXEL(pbDest);
runLength = runLength - 1;
}
- }
- else
- {
+
+ break;
+
+ /* Handle Color Run Orders. */
+ case REGULAR_COLOR_RUN:
+ case MEGA_MEGA_COLOR_RUN:
+ runLength = ExtractRunLength(code, pbSrc, &advance);
+ pbSrc = pbSrc + advance;
+ SRCREADPIXEL(pixelA, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
+
while (runLength >= UNROLL_COUNT)
{
UNROLL(
- DESTREADPIXEL(temp, pbDest - rowDelta);
- DESTWRITEPIXEL(pbDest, temp ^ fgPel);
- DESTNEXTPIXEL(pbDest); );
+ DESTWRITEPIXEL(pbDest, pixelA);
+ DESTNEXTPIXEL(pbDest););
runLength = runLength - UNROLL_COUNT;
}
+
while (runLength > 0)
{
- DESTREADPIXEL(temp, pbDest - rowDelta);
- DESTWRITEPIXEL(pbDest, temp ^ fgPel);
+ DESTWRITEPIXEL(pbDest, pixelA);
DESTNEXTPIXEL(pbDest);
runLength = runLength - 1;
}
- }
- break;
-
- /* Handle Dithered Run Orders. */
- case LITE_DITHERED_RUN:
- case MEGA_MEGA_DITHERED_RUN:
- runLength = ExtractRunLength(code, pbSrc, &advance);
- pbSrc = pbSrc + advance;
- SRCREADPIXEL(pixelA, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- SRCREADPIXEL(pixelB, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- while (runLength >= UNROLL_COUNT)
- {
- UNROLL(
- DESTWRITEPIXEL(pbDest, pixelA);
- DESTNEXTPIXEL(pbDest);
- DESTWRITEPIXEL(pbDest, pixelB);
- DESTNEXTPIXEL(pbDest); );
- runLength = runLength - UNROLL_COUNT;
- }
- while (runLength > 0)
- {
- DESTWRITEPIXEL(pbDest, pixelA);
- DESTNEXTPIXEL(pbDest);
- DESTWRITEPIXEL(pbDest, pixelB);
- DESTNEXTPIXEL(pbDest);
- runLength = runLength - 1;
- }
- break;
- /* Handle Color Run Orders. */
- case REGULAR_COLOR_RUN:
- case MEGA_MEGA_COLOR_RUN:
- runLength = ExtractRunLength(code, pbSrc, &advance);
- pbSrc = pbSrc + advance;
- SRCREADPIXEL(pixelA, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- while (runLength >= UNROLL_COUNT)
- {
- UNROLL(
- DESTWRITEPIXEL(pbDest, pixelA);
- DESTNEXTPIXEL(pbDest); );
- runLength = runLength - UNROLL_COUNT;
- }
- while (runLength > 0)
- {
- DESTWRITEPIXEL(pbDest, pixelA);
- DESTNEXTPIXEL(pbDest);
- runLength = runLength - 1;
- }
- break;
+ break;
/* Handle Foreground/Background Image Orders. */
- case REGULAR_FGBG_IMAGE:
- case MEGA_MEGA_FGBG_IMAGE:
- case LITE_SET_FG_FGBG_IMAGE:
- case MEGA_MEGA_SET_FGBG_IMAGE:
- runLength = ExtractRunLength(code, pbSrc, &advance);
- pbSrc = pbSrc + advance;
- if (code == LITE_SET_FG_FGBG_IMAGE || code == MEGA_MEGA_SET_FGBG_IMAGE)
- {
- SRCREADPIXEL(fgPel, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- }
- if (fFirstLine)
- {
- while (runLength > 8)
+ case REGULAR_FGBG_IMAGE:
+ case MEGA_MEGA_FGBG_IMAGE:
+ case LITE_SET_FG_FGBG_IMAGE:
+ case MEGA_MEGA_SET_FGBG_IMAGE:
+ runLength = ExtractRunLength(code, pbSrc, &advance);
+ pbSrc = pbSrc + advance;
+
+ if (code == LITE_SET_FG_FGBG_IMAGE || code == MEGA_MEGA_SET_FGBG_IMAGE)
{
- bitmask = *pbSrc;
- pbSrc = pbSrc + 1;
- pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, bitmask, fgPel, 8);
- runLength = runLength - 8;
+ SRCREADPIXEL(fgPel, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
}
- }
- else
- {
- while (runLength > 8)
+
+ if (fFirstLine)
+ {
+ while (runLength > 8)
+ {
+ bitmask = *pbSrc;
+ pbSrc = pbSrc + 1;
+ pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, bitmask, fgPel, 8);
+ runLength = runLength - 8;
+ }
+ }
+ else
+ {
+ while (runLength > 8)
+ {
+ bitmask = *pbSrc;
+ pbSrc = pbSrc + 1;
+ pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, bitmask, fgPel, 8);
+ runLength = runLength - 8;
+ }
+ }
+
+ if (runLength > 0)
{
bitmask = *pbSrc;
pbSrc = pbSrc + 1;
- pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, bitmask, fgPel, 8);
- runLength = runLength - 8;
+
+ if (fFirstLine)
+ {
+ pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, bitmask, fgPel, runLength);
+ }
+ else
+ {
+ pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, bitmask, fgPel, runLength);
+ }
}
- }
- if (runLength > 0)
- {
- bitmask = *pbSrc;
+
+ break;
+
+ /* Handle Color Image Orders. */
+ case REGULAR_COLOR_IMAGE:
+ case MEGA_MEGA_COLOR_IMAGE:
+ runLength = ExtractRunLength(code, pbSrc, &advance);
+ pbSrc = pbSrc + advance;
+
+ while (runLength >= UNROLL_COUNT)
+ {
+ UNROLL(
+ SRCREADPIXEL(temp, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
+ DESTWRITEPIXEL(pbDest, temp);
+ DESTNEXTPIXEL(pbDest););
+ runLength = runLength - UNROLL_COUNT;
+ }
+
+ while (runLength > 0)
+ {
+ SRCREADPIXEL(temp, pbSrc);
+ SRCNEXTPIXEL(pbSrc);
+ DESTWRITEPIXEL(pbDest, temp);
+ DESTNEXTPIXEL(pbDest);
+ runLength = runLength - 1;
+ }
+
+ break;
+
+ /* Handle Special Order 1. */
+ case SPECIAL_FGBG_1:
pbSrc = pbSrc + 1;
+
if (fFirstLine)
{
- pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, bitmask, fgPel, runLength);
+ pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, g_MaskSpecialFgBg1, fgPel, 8);
}
else
{
- pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, bitmask, fgPel, runLength);
+ pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, g_MaskSpecialFgBg1, fgPel, 8);
}
- }
- break;
- /* Handle Color Image Orders. */
- case REGULAR_COLOR_IMAGE:
- case MEGA_MEGA_COLOR_IMAGE:
- runLength = ExtractRunLength(code, pbSrc, &advance);
- pbSrc = pbSrc + advance;
- while (runLength >= UNROLL_COUNT)
- {
- UNROLL(
- SRCREADPIXEL(temp, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- DESTWRITEPIXEL(pbDest, temp);
- DESTNEXTPIXEL(pbDest); );
- runLength = runLength - UNROLL_COUNT;
- }
- while (runLength > 0)
- {
- SRCREADPIXEL(temp, pbSrc);
- SRCNEXTPIXEL(pbSrc);
- DESTWRITEPIXEL(pbDest, temp);
- DESTNEXTPIXEL(pbDest);
- runLength = runLength - 1;
- }
- break;
-
- /* Handle Special Order 1. */
- case SPECIAL_FGBG_1:
- pbSrc = pbSrc + 1;
- if (fFirstLine)
- {
- pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, g_MaskSpecialFgBg1, fgPel, 8);
- }
- else
- {
- pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, g_MaskSpecialFgBg1, fgPel, 8);
- }
- break;
+ break;
/* Handle Special Order 2. */
- case SPECIAL_FGBG_2:
- pbSrc = pbSrc + 1;
- if (fFirstLine)
- {
- pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, g_MaskSpecialFgBg2, fgPel, 8);
- }
- else
- {
- pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, g_MaskSpecialFgBg2, fgPel, 8);
- }
- break;
+ case SPECIAL_FGBG_2:
+ pbSrc = pbSrc + 1;
+
+ if (fFirstLine)
+ {
+ pbDest = WRITEFIRSTLINEFGBGIMAGE(pbDest, g_MaskSpecialFgBg2, fgPel, 8);
+ }
+ else
+ {
+ pbDest = WRITEFGBGIMAGE(pbDest, rowDelta, g_MaskSpecialFgBg2, fgPel, 8);
+ }
+
+ break;
/* Handle White Order. */
- case SPECIAL_WHITE:
- pbSrc = pbSrc + 1;
- DESTWRITEPIXEL(pbDest, WHITE_PIXEL);
- DESTNEXTPIXEL(pbDest);
- break;
+ case SPECIAL_WHITE:
+ pbSrc = pbSrc + 1;
+ DESTWRITEPIXEL(pbDest, WHITE_PIXEL);
+ DESTNEXTPIXEL(pbDest);
+ break;
/* Handle Black Order. */
- case SPECIAL_BLACK:
- pbSrc = pbSrc + 1;
- DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
- DESTNEXTPIXEL(pbDest);
- break;
+ case SPECIAL_BLACK:
+ pbSrc = pbSrc + 1;
+ DESTWRITEPIXEL(pbDest, BLACK_PIXEL);
+ DESTNEXTPIXEL(pbDest);
+ break;
}
}
}
if (Stream_GetRemainingLength(s) < 3)
return FALSE;
+ *color = 0;
Stream_Read_UINT8(s, byte);
- *color = (UINT32) byte << 16;
+ *color = (UINT32) byte;
Stream_Read_UINT8(s, byte);
- *color |= ((UINT32) byte << 8);
+ *color |= ((UINT32) byte << 8) & 0xFF00;
Stream_Read_UINT8(s, byte);
- *color |= (UINT32) byte;
+ *color |= ((UINT32) byte << 16) & 0xFF0000;
return TRUE;
}
return TRUE;
}
-static INLINE void update_read_colorref(wStream* s, UINT32* color)
+static INLINE BOOL update_read_colorref(wStream* s, UINT32* color)
{
BYTE byte;
+
+ if (Stream_GetRemainingLength(s) < 4)
+ return FALSE;
+
+ *color = 0;
Stream_Read_UINT8(s, byte);
*color = byte;
Stream_Read_UINT8(s, byte);
- *color |= (byte << 8);
+ *color |= ((UINT32)byte << 8);
Stream_Read_UINT8(s, byte);
- *color |= (byte << 16);
+ *color |= ((UINT32)byte << 16);
Stream_Seek_UINT8(s);
+ return TRUE;
}
-static INLINE void update_read_color_quad(wStream* s, UINT32* color)
+static INLINE BOOL update_read_color_quad(wStream* s, UINT32* color)
{
- BYTE byte;
- Stream_Read_UINT8(s, byte);
- *color = (byte << 16);
- Stream_Read_UINT8(s, byte);
- *color |= (byte << 8);
- Stream_Read_UINT8(s, byte);
- *color |= byte;
- Stream_Seek_UINT8(s);
+ return update_read_colorref(s, color);
}
static INLINE void update_write_color_quad(wStream* s, UINT32 color)
{
BYTE byte;
- byte = (color << 16) & 0xFF;
+ byte = (color >> 16) & 0xFF;
Stream_Write_UINT8(s, byte);
- byte = (color << 8) & 0xFF;
+ byte = (color >> 8) & 0xFF;
Stream_Write_UINT8(s, byte);
byte = color & 0xFF;
Stream_Write_UINT8(s, byte);
return FALSE; \
} \
} while(0)
-#define ORDER_FIELD_COLOR(NO, TARGET) \
- do { \
- if ((orderInfo->fieldFlags & (1 << (NO-1))) && !update_read_color(s, &TARGET)) { \
- WLog_ERR(TAG, "error reading %s", #TARGET); \
- return FALSE; \
- } \
- } while(0)
+static INLINE BOOL ORDER_FIELD_COLOR(const ORDER_INFO* orderInfo, wStream* s,
+ UINT32 NO, UINT32* TARGET)
+{
+ if (!TARGET || !orderInfo)
+ return FALSE;
+
+ *TARGET = 0;
-#define FIELD_SKIP_BUFFER16(s, TARGET_LEN) \
- do { \
- if (Stream_GetRemainingLength(s) < 2) {\
- WLog_ERR(TAG, "error reading length %s", #TARGET_LEN); \
- return FALSE; \
- }\
- Stream_Read_UINT16(s, TARGET_LEN); \
- if (!Stream_SafeSeek(s, TARGET_LEN)) { \
- WLog_ERR(TAG, "error skipping %d bytes", TARGET_LEN); \
- return FALSE; \
- } \
- } while(0)
+ if ((orderInfo->fieldFlags & (1 << (NO - 1))) && !update_read_color(s, TARGET))
+ return FALSE;
+
+ return TRUE;
+}
+
+static INLINE BOOL FIELD_SKIP_BUFFER16(wStream* s, UINT32 TARGET_LEN)
+{
+ if (Stream_GetRemainingLength(s) < 2)
+ return FALSE;
+
+ Stream_Read_UINT16(s, TARGET_LEN);
+
+ if (!Stream_SafeSeek(s, TARGET_LEN))
+ {
+ WLog_ERR(TAG, "error skipping %d bytes", TARGET_LEN);
+ return FALSE;
+ }
+
+ return TRUE;
+}
/* Primary Drawing Orders */
static BOOL update_read_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
ORDER_FIELD_BYTE(5, dstblt->bRop);
return TRUE;
}
-
int update_approximate_dstblt_order(ORDER_INFO* orderInfo,
const DSTBLT_ORDER* dstblt)
{
return 32;
}
-
BOOL update_write_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
const DSTBLT_ORDER* dstblt)
{
Stream_Write_UINT8(s, dstblt->bRop);
return TRUE;
}
-
static BOOL update_read_patblt_order(wStream* s, ORDER_INFO* orderInfo,
PATBLT_ORDER* patblt)
{
ORDER_FIELD_COORD(3, patblt->nWidth);
ORDER_FIELD_COORD(4, patblt->nHeight);
ORDER_FIELD_BYTE(5, patblt->bRop);
- ORDER_FIELD_COLOR(6, patblt->backColor);
- ORDER_FIELD_COLOR(7, patblt->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 6, &patblt->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 7, &patblt->foreColor);
return update_read_brush(s, &patblt->brush, orderInfo->fieldFlags >> 7);
}
-
-int update_approximate_patblt_order(ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
+int update_approximate_patblt_order(ORDER_INFO* orderInfo,
+ PATBLT_ORDER* patblt)
{
return 32;
}
-
BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo,
PATBLT_ORDER* patblt)
{
update_write_brush(s, &patblt->brush, orderInfo->fieldFlags >> 7);
return TRUE;
}
-
static BOOL update_read_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
SCRBLT_ORDER* scrblt)
{
ORDER_FIELD_COORD(7, scrblt->nYSrc);
return TRUE;
}
-
int update_approximate_scrblt_order(ORDER_INFO* orderInfo,
const SCRBLT_ORDER* scrblt)
{
return 32;
}
-
BOOL update_write_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
const SCRBLT_ORDER* scrblt)
{
update_write_coord(s, scrblt->nYSrc);
return TRUE;
}
-
static BOOL update_read_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
OPAQUE_RECT_ORDER* opaque_rect)
{
return FALSE;
Stream_Read_UINT8(s, byte);
- opaque_rect->color = (opaque_rect->color & 0xFF00FFFF) | ((UINT32) byte << 16);
+ opaque_rect->color = (opaque_rect->color & 0x00FFFF00) | ((UINT32) byte);
}
if (orderInfo->fieldFlags & ORDER_FIELD_06)
return FALSE;
Stream_Read_UINT8(s, byte);
- opaque_rect->color = (opaque_rect->color & 0xFFFF00FF) | ((UINT32) byte << 8);
+ opaque_rect->color = (opaque_rect->color & 0x00FF00FF) | ((UINT32) byte << 8);
}
if (orderInfo->fieldFlags & ORDER_FIELD_07)
return FALSE;
Stream_Read_UINT8(s, byte);
- opaque_rect->color = (opaque_rect->color & 0xFFFFFF00) | (UINT32) byte;
+ opaque_rect->color = (opaque_rect->color & 0x0000FFFF) | ((UINT32) byte << 16);
}
return TRUE;
}
-
int update_approximate_opaque_rect_order(ORDER_INFO* orderInfo,
const OPAQUE_RECT_ORDER* opaque_rect)
{
return 32;
}
-
BOOL update_write_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
const OPAQUE_RECT_ORDER* opaque_rect)
{
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
+ // TODO: Color format conversion
orderInfo->fieldFlags = 0;
orderInfo->fieldFlags |= ORDER_FIELD_01;
update_write_coord(s, opaque_rect->nLeftRect);
Stream_Write_UINT8(s, byte);
return TRUE;
}
-
-static BOOL update_read_draw_nine_grid_order(wStream* s, ORDER_INFO* orderInfo,
+static BOOL update_read_draw_nine_grid_order(wStream* s,
+ ORDER_INFO* orderInfo,
DRAW_NINE_GRID_ORDER* draw_nine_grid)
{
ORDER_FIELD_COORD(1, draw_nine_grid->srcLeft);
ORDER_FIELD_UINT16(5, draw_nine_grid->bitmapId);
return TRUE;
}
-
static BOOL update_read_multi_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
MULTI_DSTBLT_ORDER* multi_dstblt)
{
return TRUE;
}
-
static BOOL update_read_multi_patblt_order(wStream* s, ORDER_INFO* orderInfo,
MULTI_PATBLT_ORDER* multi_patblt)
{
ORDER_FIELD_COORD(3, multi_patblt->nWidth);
ORDER_FIELD_COORD(4, multi_patblt->nHeight);
ORDER_FIELD_BYTE(5, multi_patblt->bRop);
- ORDER_FIELD_COLOR(6, multi_patblt->backColor);
- ORDER_FIELD_COLOR(7, multi_patblt->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 6, &multi_patblt->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 7, &multi_patblt->foreColor);
if (!update_read_brush(s, &multi_patblt->brush, orderInfo->fieldFlags >> 7))
return FALSE;
return TRUE;
}
-
static BOOL update_read_multi_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
MULTI_SCRBLT_ORDER* multi_scrblt)
{
return TRUE;
}
-
static BOOL update_read_multi_opaque_rect_order(wStream* s,
ORDER_INFO* orderInfo,
MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | ((
- UINT32) byte << 16);
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FFFF00) | ((
+ UINT32) byte);
}
if (orderInfo->fieldFlags & ORDER_FIELD_06)
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | ((
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FF00FF) | ((
UINT32) byte << 8);
}
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) |
- (UINT32) byte;
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0x0000FFFF) |
+ ((UINT32) byte << 16);
}
ORDER_FIELD_BYTE(8, multi_opaque_rect->numRectangles);
return TRUE;
}
-
static BOOL update_read_multi_draw_nine_grid_order(wStream* s,
ORDER_INFO* orderInfo,
MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
return TRUE;
}
-
static BOOL update_read_line_to_order(wStream* s, ORDER_INFO* orderInfo,
LINE_TO_ORDER* line_to)
{
ORDER_FIELD_COORD(3, line_to->nYStart);
ORDER_FIELD_COORD(4, line_to->nXEnd);
ORDER_FIELD_COORD(5, line_to->nYEnd);
- ORDER_FIELD_COLOR(6, line_to->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 6, &line_to->backColor);
ORDER_FIELD_BYTE(7, line_to->bRop2);
ORDER_FIELD_BYTE(8, line_to->penStyle);
ORDER_FIELD_BYTE(9, line_to->penWidth);
- ORDER_FIELD_COLOR(10, line_to->penColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 10, &line_to->penColor);
return TRUE;
}
-
int update_approximate_line_to_order(ORDER_INFO* orderInfo,
const LINE_TO_ORDER* line_to)
{
return 32;
}
-
BOOL update_write_line_to_order(wStream* s, ORDER_INFO* orderInfo,
const LINE_TO_ORDER* line_to)
{
update_write_color(s, line_to->penColor);
return TRUE;
}
-
static BOOL update_read_polyline_order(wStream* s, ORDER_INFO* orderInfo,
POLYLINE_ORDER* polyline)
{
ORDER_FIELD_COORD(2, polyline->yStart);
ORDER_FIELD_BYTE(3, polyline->bRop2);
ORDER_FIELD_UINT16(4, word);
- ORDER_FIELD_COLOR(5, polyline->penColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 5, &polyline->penColor);
ORDER_FIELD_BYTE(6, new_num);
if (orderInfo->fieldFlags & ORDER_FIELD_07)
return TRUE;
}
-
static BOOL update_read_memblt_order(wStream* s, ORDER_INFO* orderInfo,
MEMBLT_ORDER* memblt)
{
memblt->bitmap = NULL;
return TRUE;
}
-
int update_approximate_memblt_order(ORDER_INFO* orderInfo,
const MEMBLT_ORDER* memblt)
{
return 64;
}
-
BOOL update_write_memblt_order(wStream* s, ORDER_INFO* orderInfo,
const MEMBLT_ORDER* memblt)
{
Stream_Write_UINT16(s, memblt->cacheIndex);
return TRUE;
}
-
static BOOL update_read_mem3blt_order(wStream* s, ORDER_INFO* orderInfo,
MEM3BLT_ORDER* mem3blt)
{
ORDER_FIELD_BYTE(6, mem3blt->bRop);
ORDER_FIELD_COORD(7, mem3blt->nXSrc);
ORDER_FIELD_COORD(8, mem3blt->nYSrc);
- ORDER_FIELD_COLOR(9, mem3blt->backColor);
- ORDER_FIELD_COLOR(10, mem3blt->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 9, &mem3blt->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 10, &mem3blt->foreColor);
if (!update_read_brush(s, &mem3blt->brush, orderInfo->fieldFlags >> 10))
return FALSE;
mem3blt->bitmap = NULL;
return TRUE;
}
-
static BOOL update_read_save_bitmap_order(wStream* s, ORDER_INFO* orderInfo,
SAVE_BITMAP_ORDER* save_bitmap)
{
ORDER_FIELD_BYTE(6, save_bitmap->operation);
return TRUE;
}
-
static BOOL update_read_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
GLYPH_INDEX_ORDER* glyph_index)
{
ORDER_FIELD_BYTE(2, glyph_index->flAccel);
ORDER_FIELD_BYTE(3, glyph_index->ulCharInc);
ORDER_FIELD_BYTE(4, glyph_index->fOpRedundant);
- ORDER_FIELD_COLOR(5, glyph_index->backColor);
- ORDER_FIELD_COLOR(6, glyph_index->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 5, &glyph_index->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 6, &glyph_index->foreColor);
ORDER_FIELD_UINT16(7, glyph_index->bkLeft);
ORDER_FIELD_UINT16(8, glyph_index->bkTop);
ORDER_FIELD_UINT16(9, glyph_index->bkRight);
return TRUE;
}
-
int update_approximate_glyph_index_order(ORDER_INFO* orderInfo,
const GLYPH_INDEX_ORDER* glyph_index)
{
return 64;
}
-
BOOL update_write_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
GLYPH_INDEX_ORDER* glyph_index)
{
Stream_Write(s, glyph_index->data, glyph_index->cbData);
return TRUE;
}
-
static BOOL update_read_fast_index_order(wStream* s, ORDER_INFO* orderInfo,
FAST_INDEX_ORDER* fast_index)
{
ORDER_FIELD_BYTE(1, fast_index->cacheId);
ORDER_FIELD_2BYTE(2, fast_index->ulCharInc, fast_index->flAccel);
- ORDER_FIELD_COLOR(3, fast_index->backColor);
- ORDER_FIELD_COLOR(4, fast_index->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 3, &fast_index->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 4, &fast_index->foreColor);
ORDER_FIELD_COORD(5, fast_index->bkLeft);
ORDER_FIELD_COORD(6, fast_index->bkTop);
ORDER_FIELD_COORD(7, fast_index->bkRight);
return TRUE;
}
-
static BOOL update_read_fast_glyph_order(wStream* s, ORDER_INFO* orderInfo,
FAST_GLYPH_ORDER* fastGlyph)
{
GLYPH_DATA_V2* glyph = &fastGlyph->glyphData;
ORDER_FIELD_BYTE(1, fastGlyph->cacheId);
ORDER_FIELD_2BYTE(2, fastGlyph->ulCharInc, fastGlyph->flAccel);
- ORDER_FIELD_COLOR(3, fastGlyph->backColor);
- ORDER_FIELD_COLOR(4, fastGlyph->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 3, &fastGlyph->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 4, &fastGlyph->foreColor);
ORDER_FIELD_COORD(5, fastGlyph->bkLeft);
ORDER_FIELD_COORD(6, fastGlyph->bkTop);
ORDER_FIELD_COORD(7, fastGlyph->bkRight);
return TRUE;
}
-
static BOOL update_read_polygon_sc_order(wStream* s, ORDER_INFO* orderInfo,
POLYGON_SC_ORDER* polygon_sc)
{
ORDER_FIELD_COORD(2, polygon_sc->yStart);
ORDER_FIELD_BYTE(3, polygon_sc->bRop2);
ORDER_FIELD_BYTE(4, polygon_sc->fillMode);
- ORDER_FIELD_COLOR(5, polygon_sc->brushColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 5, &polygon_sc->brushColor);
ORDER_FIELD_BYTE(6, num);
if (orderInfo->fieldFlags & ORDER_FIELD_07)
return TRUE;
}
-
static BOOL update_read_polygon_cb_order(wStream* s, ORDER_INFO* orderInfo,
POLYGON_CB_ORDER* polygon_cb)
{
ORDER_FIELD_COORD(2, polygon_cb->yStart);
ORDER_FIELD_BYTE(3, polygon_cb->bRop2);
ORDER_FIELD_BYTE(4, polygon_cb->fillMode);
- ORDER_FIELD_COLOR(5, polygon_cb->backColor);
- ORDER_FIELD_COLOR(6, polygon_cb->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 5, &polygon_cb->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 6, &polygon_cb->foreColor);
if (!update_read_brush(s, &polygon_cb->brush, orderInfo->fieldFlags >> 6))
return FALSE;
polygon_cb->bRop2 = (polygon_cb->bRop2 & 0x1F);
return TRUE;
}
-
static BOOL update_read_ellipse_sc_order(wStream* s, ORDER_INFO* orderInfo,
ELLIPSE_SC_ORDER* ellipse_sc)
{
ORDER_FIELD_COORD(4, ellipse_sc->bottomRect);
ORDER_FIELD_BYTE(5, ellipse_sc->bRop2);
ORDER_FIELD_BYTE(6, ellipse_sc->fillMode);
- ORDER_FIELD_COLOR(7, ellipse_sc->color);
+ ORDER_FIELD_COLOR(orderInfo, s, 7, &ellipse_sc->color);
return TRUE;
}
-
static BOOL update_read_ellipse_cb_order(wStream* s, ORDER_INFO* orderInfo,
ELLIPSE_CB_ORDER* ellipse_cb)
{
ORDER_FIELD_COORD(4, ellipse_cb->bottomRect);
ORDER_FIELD_BYTE(5, ellipse_cb->bRop2);
ORDER_FIELD_BYTE(6, ellipse_cb->fillMode);
- ORDER_FIELD_COLOR(7, ellipse_cb->backColor);
- ORDER_FIELD_COLOR(8, ellipse_cb->foreColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 7, &ellipse_cb->backColor);
+ ORDER_FIELD_COLOR(orderInfo, s, 8, &ellipse_cb->foreColor);
return update_read_brush(s, &ellipse_cb->brush, orderInfo->fieldFlags >> 8);
}
-
/* Secondary Drawing Orders */
static BOOL update_read_cache_bitmap_order(wStream* s,
CACHE_BITMAP_ORDER* cache_bitmap,
cache_bitmap->compressed = compressed;
return TRUE;
}
-
int update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER*
cache_bitmap,
BOOL compressed, UINT16* flags)
{
return 64 + cache_bitmap->bitmapLength;
}
-
BOOL update_write_cache_bitmap_order(wStream* s,
const CACHE_BITMAP_ORDER* cache_bitmap,
BOOL compressed, UINT16* flags)
return TRUE;
}
-
static BOOL update_read_cache_bitmap_v2_order(wStream* s,
CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
BOOL compressed, UINT16 flags)
cache_bitmap_v2->compressed = compressed;
return TRUE;
}
-
int update_approximate_cache_bitmap_v2_order(CACHE_BITMAP_V2_ORDER*
cache_bitmap_v2, BOOL compressed, UINT16* flags)
{
return 64 + cache_bitmap_v2->bitmapLength;
}
-
BOOL update_write_cache_bitmap_v2_order(wStream* s,
CACHE_BITMAP_V2_ORDER* cache_bitmap_v2, BOOL compressed, UINT16* flags)
{
cache_bitmap_v2->compressed = compressed;
return TRUE;
}
-
static BOOL update_read_cache_bitmap_v3_order(wStream* s,
CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
UINT16 flags)
Stream_Read(s, bitmapData->data, bitmapData->length);
return TRUE;
}
-
int update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER*
cache_bitmap_v3, UINT16* flags)
{
BITMAP_DATA_EX* bitmapData = &cache_bitmap_v3->bitmapData;
return 64 + bitmapData->length;
}
-
BOOL update_write_cache_bitmap_v3_order(wStream* s,
CACHE_BITMAP_V3_ORDER* cache_bitmap_v3, UINT16* flags)
{
Stream_Write(s, bitmapData->data, bitmapData->length);
return TRUE;
}
-
static BOOL update_read_cache_color_table_order(wStream* s,
CACHE_COLOR_TABLE_ORDER* cache_color_table,
UINT16 flags)
colorTable = (UINT32*) &cache_color_table->colorTable;
for (i = 0; i < (int) cache_color_table->numberColors; i++)
- {
update_read_color_quad(s, &colorTable[i]);
- }
return TRUE;
}
-
int update_approximate_cache_color_table_order(
const CACHE_COLOR_TABLE_ORDER* cache_color_table, UINT16* flags)
{
return 16 + (256 * 4);
}
-
BOOL update_write_cache_color_table_order(wStream* s,
const CACHE_COLOR_TABLE_ORDER* cache_color_table,
UINT16* flags)
return TRUE;
}
-
static BOOL update_read_cache_glyph_order(wStream* s,
CACHE_GLYPH_ORDER* cache_glyph_order,
UINT16 flags)
{
- int i;
+ UINT32 i;
INT16 lsi16;
GLYPH_DATA* glyph;
Stream_Read_UINT8(s, cache_glyph_order->cacheId); /* cacheId (1 byte) */
Stream_Read_UINT8(s, cache_glyph_order->cGlyphs); /* cGlyphs (1 byte) */
- for (i = 0; i < (int) cache_glyph_order->cGlyphs; i++)
+ for (i = 0; i < cache_glyph_order->cGlyphs; i++)
{
glyph = &cache_glyph_order->glyphData[i];
return TRUE;
}
-
int update_approximate_cache_glyph_order(
const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
{
return 2 + cache_glyph->cGlyphs * 32;
}
-
BOOL update_write_cache_glyph_order(wStream* s,
const CACHE_GLYPH_ORDER* cache_glyph,
UINT16* flags)
return TRUE;
}
-
static BOOL update_read_cache_glyph_v2_order(wStream* s,
CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
UINT16 flags)
return TRUE;
}
-
int update_approximate_cache_glyph_v2_order(
const CACHE_GLYPH_V2_ORDER* cache_glyph_v2, UINT16* flags)
{
return 8 + cache_glyph_v2->cGlyphs * 32;
}
-
BOOL update_write_cache_glyph_v2_order(wStream* s,
const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
UINT16* flags)
return TRUE;
}
-
static BOOL update_decompress_brush(wStream* s, BYTE* output, BYTE bpp)
{
int index;
return TRUE;
}
-
static BOOL update_compress_brush(wStream* s, const BYTE* input, BYTE bpp)
{
return FALSE;
}
-
static BOOL update_read_cache_brush_order(wStream* s,
CACHE_BRUSH_ORDER* cache_brush,
UINT16 flags)
return TRUE;
}
-
int update_approximate_cache_brush_order(
const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
{
return 64;
}
-
BOOL update_write_cache_brush_order(wStream* s,
const CACHE_BRUSH_ORDER* cache_brush,
UINT16* flags)
return TRUE;
}
-
/* Alternate Secondary Drawing Orders */
static BOOL update_read_create_offscreen_bitmap_order(wStream* s,
CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
return TRUE;
}
-
int update_approximate_create_offscreen_bitmap_order(
const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
(create_offscreen_bitmap->deleteList);
return 32 + deleteList->cIndices * 2;
}
-
BOOL update_write_create_offscreen_bitmap_order(
wStream* s,
const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
return TRUE;
}
-
static BOOL update_read_switch_surface_order(wStream* s,
SWITCH_SURFACE_ORDER* switch_surface)
{
Stream_Read_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
return TRUE;
}
-
int update_approximate_switch_surface_order(
const SWITCH_SURFACE_ORDER* switch_surface)
{
return 2;
}
-
BOOL update_write_switch_surface_order(
wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
{
Stream_Write_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
return TRUE;
}
-
static BOOL update_read_create_nine_grid_bitmap_order(
wStream* s,
CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
&nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
return TRUE;
}
-
static BOOL update_read_frame_marker_order(wStream* s,
FRAME_MARKER_ORDER* frame_marker)
{
Stream_Read_UINT32(s, frame_marker->action); /* action (4 bytes) */
return TRUE;
}
-
static BOOL update_read_stream_bitmap_first_order(
wStream* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
{
stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
return TRUE;
}
-
static BOOL update_read_stream_bitmap_next_order(
wStream* s, STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
{
stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
return TRUE;
}
-
static BOOL update_read_draw_gdiplus_first_order(
wStream* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
{
draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_first->cbSize); /* emfRecords */
}
-
static BOOL update_read_draw_gdiplus_next_order(
wStream* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
{
draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
return TRUE;
}
-
static BOOL update_read_draw_gdiplus_end_order(
wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
{
draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_end->cbSize); /* emfRecords */
}
-
static BOOL update_read_draw_gdiplus_cache_first_order(
wStream* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
{
draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
}
-
static BOOL update_read_draw_gdiplus_cache_next_order(
wStream* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
{
draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
return TRUE;
}
-
static BOOL update_read_draw_gdiplus_cache_end_order(
wStream* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
{
draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
}
-
-static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags,
+static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags,
+ BYTE flags,
BYTE fieldBytes)
{
int i;
return TRUE;
}
-
BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, BYTE flags,
BYTE fieldBytes)
{
return TRUE;
}
-
static BOOL update_read_bounds(wStream* s, rdpBounds* bounds)
{
BYTE flags;
return TRUE;
}
-
BOOL update_write_bounds(wStream* s, ORDER_INFO* orderInfo)
{
if (!(orderInfo->controlFlags & ORDER_BOUNDS))
return TRUE;
}
-
BOOL update_recv_primary_order(rdpUpdate* update, wStream* s, BYTE flags)
{
ORDER_INFO* orderInfo;
return TRUE;
}
-
BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, BYTE flags)
{
BYTE* next;
Stream_SetPointer(s, next);
return TRUE;
}
-
-static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
+static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s,
+ BYTE flags)
{
BYTE orderType;
rdpContext* context = update->context;
return TRUE;
}
-
BOOL update_recv_order(rdpUpdate* update, wStream* s)
{
BYTE controlFlags;
0x7E, 0xBD, 0xDB, 0xE7, 0xE7, 0xDB, 0xBD, 0x7E /* HS_DIACROSS */
};
+static INLINE BOOL decode_color(rdpGdi* gdi, const UINT32 srcColor,
+ UINT32* color, UINT32* format)
+{
+ UINT32 SrcFormat = gdi_get_pixel_format(gdi->context->settings->ColorDepth,
+ FALSE);
+
+ if (format)
+ *format = SrcFormat;
+
+ *color = ConvertColor(srcColor, SrcFormat,
+ gdi->drawing->hdc->format, &gdi->palette);
+ return TRUE;
+}
+
/* GDI Helper Functions */
INLINE DWORD gdi_rop3_code(BYTE code)
{
static BOOL gdi_bitmap_update(rdpContext* context,
const BITMAP_UPDATE* bitmapUpdate)
{
- int status;
UINT32 index;
rdpGdi* gdi = context->gdi;
rdpCodecs* codecs = context->codecs;
{
if (bitsPerPixel < 32)
{
- status = interleaved_decompress(codecs->interleaved,
- pSrcData, SrcSize,
- bitsPerPixel,
- gdi->primary_buffer,
- gdi->dstFormat,
- gdi->stride, nXDst, nYDst,
- nWidth, nHeight,
- &gdi->palette);
+ if (!interleaved_decompress(codecs->interleaved,
+ pSrcData, SrcSize,
+ bitsPerPixel,
+ gdi->primary_buffer,
+ gdi->primary->hdc->format,
+ gdi->stride, nXDst, nYDst,
+ nWidth, nHeight,
+ &gdi->palette))
+ return FALSE;
}
else
{
- status = planar_decompress(codecs->planar, pSrcData,
- SrcSize, gdi->primary_buffer,
- gdi->dstFormat,
- gdi->stride,
- nXDst, nYDst, nWidth, nHeight, TRUE);
- }
-
- if (status < 0)
- {
- WLog_ERR(TAG, "bitmap decompression failure");
- return FALSE;
+ if (!planar_decompress(codecs->planar, pSrcData,
+ SrcSize, gdi->primary_buffer,
+ gdi->primary->hdc->format,
+ gdi->stride,
+ nXDst, nYDst, nWidth, nHeight, TRUE))
+ return FALSE;
}
}
else
nHeight = MIN(bitmap->destBottom,
gdi->height - 1) - bitmap->destTop + 1; /* clip height */
- if (!freerdp_image_copy(gdi->primary_buffer, gdi->dstFormat, gdi->stride,
+ if (!freerdp_image_copy(gdi->primary_buffer, gdi->primary->hdc->format,
+ gdi->stride,
nXDst, nYDst, nWidth, nHeight,
pSrcData, SrcFormat, nSrcStep,
nXSrc, nYSrc, &gdi->palette))
HGDI_BRUSH originalBrush;
rdpGdi* gdi = context->gdi;
BOOL ret = TRUE;
- UINT32 SrcFormat = gdi_get_pixel_format(patblt->brush.bpp, FALSE);
- DWORD rop = gdi_rop3_code(patblt->bRop);
+ const DWORD rop = gdi_rop3_code(patblt->bRop);
UINT32 nXSrc = 0;
UINT32 nYSrc = 0;
- foreColor = ConvertColor(patblt->foreColor, SrcFormat,
- gdi->drawing->hdc->format, &gdi->palette);
- backColor = ConvertColor(patblt->backColor, SrcFormat,
- gdi->drawing->hdc->format, &gdi->palette);
+
+ if (!decode_color(gdi, patblt->foreColor, &foreColor, NULL))
+ return FALSE;
+
+ if (!decode_color(gdi, patblt->backColor, &backColor, NULL))
+ return FALSE;
+
originalColor = gdi_SetTextColor(gdi->drawing->hdc, foreColor);
switch (brush->style)
UINT32 brush_color;
rdpGdi* gdi = context->gdi;
BOOL ret;
- UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
gdi_CRgnToRect(opaque_rect->nLeftRect, opaque_rect->nTopRect,
opaque_rect->nWidth, opaque_rect->nHeight, &rect);
- brush_color = ConvertColor(opaque_rect->color, PIXEL_FORMAT_RGB16,
- gdi->drawing->hdc->format, &gdi->palette);
+
+ if (!decode_color(gdi, opaque_rect->color, &brush_color, NULL))
+ return FALSE;
if (!(hBrush = gdi_CreateSolidBrush(brush_color)))
return FALSE;
GDI_RECT rect;
HGDI_BRUSH hBrush;
UINT32 brush_color;
- const DELTA_RECT* rectangle;
rdpGdi* gdi = context->gdi;
- UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
BOOL ret = TRUE;
+ if (!decode_color(gdi, multi_opaque_rect->color, &brush_color, NULL))
+ return FALSE;
+
+ hBrush = gdi_CreateSolidBrush(brush_color);
+
+ if (!hBrush)
+ return FALSE;
+
for (i = 1; i < multi_opaque_rect->numRectangles + 1; i++)
{
- rectangle = &multi_opaque_rect->rectangles[i];
+ const DELTA_RECT* rectangle = &multi_opaque_rect->rectangles[i];
gdi_CRgnToRect(rectangle->left, rectangle->top,
rectangle->width, rectangle->height, &rect);
- brush_color = ConvertColor(multi_opaque_rect->color, SrcFormat,
- gdi->drawing->hdc->format, &gdi->palette);
- hBrush = gdi_CreateSolidBrush(brush_color);
-
- if (!hBrush)
- {
- ret = FALSE;
- break;
- }
-
gdi_FillRect(gdi->drawing->hdc, &rect, hBrush);
- gdi_DeleteObject((HGDIOBJECT) hBrush);
}
+ gdi_DeleteObject((HGDIOBJECT) hBrush);
return ret;
}
{
UINT32 color;
HGDI_PEN hPen;
+ UINT32 SrcFormat;
rdpGdi* gdi = context->gdi;
- color = lineTo->penColor;
- UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
+
+ if (!decode_color(gdi, lineTo->backColor, &color, &SrcFormat))
+ return FALSE;
if (!(hPen = gdi_CreatePen(lineTo->penStyle, lineTo->penWidth, color,
SrcFormat, &gdi->palette)))
UINT32 color;
HGDI_PEN hPen;
DELTA_POINT* points;
+ UINT32 SrcFormat;
rdpGdi* gdi = context->gdi;
- UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth, FALSE);
- color = polyline->penColor;
+
+ if (!decode_color(gdi, polyline->penColor, &color, &SrcFormat))
+ return FALSE;
if (!(hPen = gdi_CreatePen(GDI_PS_SOLID, 1, color, SrcFormat, &gdi->palette)))
return FALSE;
HGDI_BRUSH originalBrush;
rdpGdi* gdi = context->gdi;
BOOL ret = TRUE;
- const UINT32 SrcFormat = gdi_get_pixel_format(context->settings->ColorDepth,
- FALSE);
const rdpBrush* brush = &mem3blt->brush;
gdiBitmap* bitmap = (gdiBitmap*) mem3blt->bitmap;
- const UINT32 foreColor = ConvertColor(mem3blt->foreColor, SrcFormat,
- gdi->drawing->hdc->format, &gdi->palette);
- const UINT32 backColor = ConvertColor(mem3blt->backColor, SrcFormat,
- gdi->drawing->hdc->format, &gdi->palette);
- const UINT32 originalColor = gdi_SetTextColor(gdi->drawing->hdc, foreColor);
+ UINT32 foreColor;
+ UINT32 backColor;
+ UINT32 originalColor;
+
+ if (!decode_color(gdi, mem3blt->foreColor, &foreColor, NULL))
+ return FALSE;
+
+ if (!decode_color(gdi, mem3blt->backColor, &backColor, NULL))
+ return FALSE;
+
+ originalColor = gdi_SetTextColor(gdi->drawing->hdc, foreColor);
switch (brush->style)
{
{
HGDI_BITMAP hBmp;
UINT32 brushFormat;
- BYTE* data = (BYTE*) _aligned_malloc(8 * 8 * GetBytesPerPixel(gdi->dstFormat),
+ BYTE* data = (BYTE*) _aligned_malloc(8 * 8 * GetBytesPerPixel(
+ gdi->drawing->hdc->format),
16);
if (!data)
{
brushFormat = gdi_get_pixel_format(brush->bpp, FALSE);
- if (!freerdp_image_copy(data, gdi->dstFormat, 0, 0, 0,
+ if (!freerdp_image_copy(data, gdi->drawing->hdc->format, 0, 0, 0,
8, 8, brush->data, brushFormat,
0, 0, 0, &gdi->palette))
{
}
else
{
- if (!freerdp_image_copy_from_monochrome(data, gdi->dstFormat, 0, 0, 0, 8, 8,
+ if (!freerdp_image_copy_from_monochrome(data, gdi->drawing->hdc->format, 0, 0,
+ 0, 8, 8,
brush->data, backColor, foreColor,
&gdi->palette))
{
width = extents->right - extents->left;
height = extents->bottom - extents->top;
update->BeginPaint(gdi->context);
- freerdp_image_copy(gdi->primary_buffer, gdi->dstFormat, gdi->stride,
- nXDst, nYDst, width, height,
- surface->data, surface->format,
- surface->scanline, nXSrc, nYSrc, NULL);
+
+ if (!freerdp_image_copy(gdi->primary_buffer, gdi->primary->hdc->format,
+ gdi->stride,
+ nXDst, nYDst, width, height,
+ surface->data, surface->format,
+ surface->scanline, nXSrc, nYSrc, NULL))
+ return CHANNEL_RC_NULL_DATA;
+
gdi_InvalidateRegion(gdi->primary->hdc, nXDst, nYDst, width, height);
update->EndPaint(gdi->context);
}
static UINT gdi_SurfaceCommand_Planar(rdpGdi* gdi, RdpgfxClientContext* context,
const RDPGFX_SURFACE_COMMAND* cmd)
{
- INT32 rc;
UINT status = CHANNEL_RC_OK;
BYTE* DstData = NULL;
gdiGfxSurface* surface;
return ERROR_INTERNAL_ERROR;
DstData = surface->data;
- rc = planar_decompress(surface->codecs->planar, cmd->data, cmd->length,
+
+ if (!planar_decompress(surface->codecs->planar, cmd->data, cmd->length,
DstData, surface->format,
surface->scanline, cmd->left, cmd->top,
- cmd->width, cmd->height, FALSE);
-
- if (rc < 0)
+ cmd->width, cmd->height, FALSE))
return ERROR_INTERNAL_ERROR;
invalidRect.left = cmd->left;
UINT32 bpp, UINT32 length, BOOL compressed,
UINT32 codecId)
{
- int status;
UINT16 size;
UINT32 SrcSize = length;
UINT32 SrcFormat;
{
if (bpp < 32)
{
- status = interleaved_decompress(context->codecs->interleaved,
- pSrcData, SrcSize,
- bpp,
- bitmap->data, bitmap->format,
- 0, 0, 0, width, height,
- &gdi->palette);
+ if (!interleaved_decompress(context->codecs->interleaved,
+ pSrcData, SrcSize,
+ bpp,
+ bitmap->data, bitmap->format,
+ 0, 0, 0, width, height,
+ &gdi->palette))
+ return FALSE;
}
else
{
- status = planar_decompress(context->codecs->planar, pSrcData, SrcSize,
- bitmap->data, bitmap->format, 0, 0, 0,
- width, height, TRUE);
- }
-
- if (status < 0)
- {
- WLog_ERR(TAG, "Bitmap Decompression Failed");
- return FALSE;
+ if (!planar_decompress(context->codecs->planar, pSrcData, SrcSize,
+ bitmap->data, bitmap->format, 0, 0, 0,
+ width, height, TRUE))
+ return FALSE;
}
}
else
{
SrcFormat = gdi_get_pixel_format(bpp, TRUE);
- status = freerdp_image_copy(bitmap->data, bitmap->format, 0, 0, 0,
- width, height, pSrcData, SrcFormat,
- 0, 0, 0, &gdi->palette);
+
+ if (!freerdp_image_copy(bitmap->data, bitmap->format, 0, 0, 0,
+ width, height, pSrcData, SrcFormat,
+ 0, 0, 0, &gdi->palette))
+ return FALSE;
}
return TRUE;
projects / platform / upstream / freerdp.git / commitdiff