mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2023 from ptsekov/software-gdi-improvements 

Software GDI improvements
This commit is contained in:
Marc-André Moreau 2014-08-18 16:22:23 -04:00
parent 241b3d7134 651887c7e0
commit 82a53057a1
9 changed files with 233 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
client/Android/FreeRDPCore/jni/android_freerdp.c
View File

@ -141,6 +141,7 @@ BOOL android_pre_connect(freerdp* instance)
static BOOL android_post_connect(freerdp* instance)
{
UINT32 gdi_flags;
rdpSettings *settings = instance->settings;
DEBUG_ANDROID("android_post_connect");
@ -154,9 +155,12 @@ static BOOL android_post_connect(freerdp* instance)
instance->context->cache = cache_new(settings);
gdi_init(instance, CLRCONV_ALPHA | CLRCONV_INVERT |
((instance->settings->ColorDepth > 16) ? CLRBUF_32BPP : CLRBUF_16BPP),
NULL);
if (instance->settings->ColorDepth > 16)
gdi_flags = CLRBUF_32BPP | CLRCONV_ALPHA | CLRCONV_INVERT;
else
gdi_flags = CLRBUF_16BPP;
gdi_init(instance, gdi_flags, NULL);
instance->update->BeginPaint = android_begin_paint;
instance->update->EndPaint = android_end_paint;
@ -935,7 +939,7 @@ JNIEXPORT void JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jin
static void copy_pixel_buffer(UINT8* dstBuf, UINT8* srcBuf, int x, int y, int width, int height, int wBuf, int hBuf, int bpp)
{
int i, j;
int i;
int length;
int scanline;
UINT8 *dstp, *srcp;
@ -946,31 +950,11 @@ static void copy_pixel_buffer(UINT8* dstBuf, UINT8* srcBuf, int x, int y, int wi
srcp = (UINT8*) &srcBuf[(scanline * y) + (x * bpp)];
dstp = (UINT8*) &dstBuf[(scanline * y) + (x * bpp)];
if (bpp == 4)
for (i = 0; i < height; i++)
{
for (i = 0; i < height; i++)
{
for (j = 0; j < width * 4; j += 4)
{
// ARGB <-> ABGR
dstp[j + 0] = srcp[j + 2];
dstp[j + 1] = srcp[j + 1];
dstp[j + 2] = srcp[j + 0];
dstp[j + 3] = srcp[j + 3];
}
srcp += scanline;
dstp += scanline;
}
}
else
{
for (i = 0; i < height; i++)
{
memcpy(dstp, srcp, length);
srcp += scanline;
dstp += scanline;
}
memcpy(dstp, srcp, length);
srcp += scanline;
dstp += scanline;
}
}

9
include/freerdp/codec/color.h
View File

@ -373,6 +373,14 @@ typedef CLRCONV* HCLRCONV;
typedef BYTE* (*p_freerdp_image_convert)(BYTE* srcData, BYTE* dstData, int width, int height, int srcBpp, int dstBpp, HCLRCONV clrconv);
static INLINE UINT32 RGB32_to_BGR32(UINT32 pixel)
{
UINT32 temp;
temp = (pixel ^ (pixel >> 16)) & ((1 << 8) - 1);
return (pixel ^ (temp | (temp << 16)));
}
FREERDP_API int freerdp_get_pixel(BYTE* data, int x, int y, int width, int height, int bpp);
FREERDP_API void freerdp_set_pixel(BYTE* data, int x, int y, int width, int height, int bpp, int pixel);
@ -392,6 +400,7 @@ FREERDP_API UINT32 freerdp_color_convert_rgb_bgr(UINT32 srcColor, int srcBpp, in
FREERDP_API UINT32 freerdp_color_convert_bgr_rgb(UINT32 srcColor, int srcBpp, int dstBpp, HCLRCONV clrconv);
FREERDP_API UINT32 freerdp_color_convert_var_rgb(UINT32 srcColor, int srcBpp, int dstBpp, HCLRCONV clrconv);
FREERDP_API UINT32 freerdp_color_convert_var_bgr(UINT32 srcColor, int srcBpp, int dstBpp, HCLRCONV clrconv);
FREERDP_API UINT32 freerdp_color_convert_drawing_order_color_to_gdi_color(UINT32 color, int bpp, HCLRCONV clrconv);
FREERDP_API HCLRCONV freerdp_clrconv_new(UINT32 flags);
FREERDP_API void freerdp_clrconv_free(HCLRCONV clrconv);

249
libfreerdp/codec/color.c
View File

@ -379,6 +379,43 @@ UINT32 freerdp_color_convert_var_bgr(UINT32 srcColor, int srcBpp, int dstBpp, HC
return freerdp_color_convert_rgb_bgr(srcColor, srcBpp, dstBpp, clrconv);
}
UINT32 freerdp_color_convert_drawing_order_color_to_gdi_color(UINT32 color, int bpp, HCLRCONV clrconv)
{
UINT32 r, g, b;
switch (bpp)
{
case 16:
color = (color & (UINT32) 0xFF00) | ((color >> 16) & (UINT32) 0xFF);
GetRGB16(r, g, b, color);
break;
case 15:
color = (color & (UINT32) 0xFF00) | ((color >> 16) & (UINT32) 0xFF);
GetRGB15(r, g, b, color);
break;
case 8:
color = (color >> 16) & (UINT32) 0xFF;
r = clrconv->palette->entries[color].red;
g = clrconv->palette->entries[color].green;
b = clrconv->palette->entries[color].blue;
break;
case 1:
r = g = b = 0;
if (color != 0)
r = g = b = 0xFF;
break;
default:
return color;
break;
}
return RGB32(r, g, b);
}
BYTE* freerdp_image_convert_8bpp(BYTE* srcData, BYTE* dstData, int width, int height, int srcBpp, int dstBpp, HCLRCONV clrconv)
{
int i;
@ -470,11 +507,11 @@ BYTE* freerdp_image_convert_8bpp(BYTE* srcData, BYTE* dstData, int width, int he
blue = clrconv->palette->entries[pixel].blue;
if (clrconv->alpha)
{
pixel = (clrconv->invert) ? ARGB32(0xFF, red, green, blue) : ABGR32(0xFF, red, green, blue);
pixel = (clrconv->invert) ? ABGR32(0xFF, red, green, blue) : ARGB32(0xFF, red, green, blue);
}
else
{
pixel = (clrconv->invert) ? RGB32(red, green, blue) : BGR32(red, green, blue);
pixel = (clrconv->invert) ? BGR32(red, green, blue) : RGB32(red, green, blue);
}
*dst32 = pixel;
dst32++;
@ -668,7 +705,9 @@ BYTE* freerdp_image_convert_24bpp(BYTE* srcData, BYTE* dstData, int width, int h
if (dstBpp == 32)
{
BYTE* dstp;
UINT32 pixel, alpha_mask, temp;
UINT32* srcp;
UINT32* dstp;
if (!dstData)
dstData = (BYTE*) _aligned_malloc(width * height * 4, 16);
@ -676,14 +715,81 @@ BYTE* freerdp_image_convert_24bpp(BYTE* srcData, BYTE* dstData, int width, int h
if (!dstData)
return NULL;
dstp = dstData;
alpha_mask = clrconv->alpha ? 0xFF000000 : 0;
for (i = width * height; i > 0; i--)
srcp = (UINT32*) srcData;
dstp = (UINT32*) dstData;
if (clrconv->invert)
{
*(dstp++) = *(srcData++);
*(dstp++) = *(srcData++);
*(dstp++) = *(srcData++);
*(dstp++) = 0xFF;
/* Each iteration handles four pixels using 32-bit load and
store operations. */
for (i = ((width * height) / 4); i > 0; i--)
{
temp = 0;
pixel = temp;
temp = *srcp++;
pixel |= temp & 0x00FFFFFF;
temp = temp >> 24;
*dstp++ = alpha_mask | RGB32_to_BGR32(pixel);
pixel = temp;
temp = *srcp++;
pixel |= (temp & 0x0000FFFF) << 8;
temp = temp >> 16;
*dstp++ = alpha_mask | RGB32_to_BGR32(pixel);
pixel = temp;
temp = *srcp++;
pixel |= (temp & 0x000000FF) << 16;
temp = temp >> 8;
*dstp++ = alpha_mask | RGB32_to_BGR32(pixel);
*dstp++ = alpha_mask | RGB32_to_BGR32(temp);
}
/* Handle any remainder. */
for (i = (width * height) % 4; i > 0; i--)
{
pixel = ABGR32(alpha_mask, srcData[2], srcData[1], srcData[0]);
*dstp++ = pixel;
srcData += 3;
}
}
else
{
for (i = ((width * height) / 4); i > 0; i--)
{
temp = 0;
pixel = temp;
temp = *srcp++;
pixel |= temp & 0x00FFFFFF;
temp = temp >> 24;
*dstp++ = alpha_mask | pixel;
pixel = temp;
temp = *srcp++;
pixel |= (temp & 0x0000FFFF) << 8;
temp = temp >> 16;
*dstp++ = alpha_mask | pixel;
pixel = temp;
temp = *srcp++;
pixel |= (temp & 0x000000FF) << 16;
temp = temp >> 8;
*dstp++ = alpha_mask | pixel;
*dstp++ = alpha_mask | temp;
}
for (i = (width * height) % 4; i > 0; i--)
{
pixel = ARGB32(alpha_mask, srcData[2], srcData[1], srcData[0]);
*dstp++ = pixel;
srcData += 3;
}
}
return dstData;
@ -760,33 +866,47 @@ BYTE* freerdp_image_convert_32bpp(BYTE* srcData, BYTE* dstData, int width, int h
}
else if (dstBpp == 32)
{
int i;
UINT32 pixel;
UINT32 alpha_mask;
UINT32* srcp;
UINT32* dstp;
BYTE red, green, blue;
if (!dstData)
dstData = (BYTE*) _aligned_malloc(width * height * 4, 16);
if (!dstData)
return NULL;
if (clrconv->alpha)
alpha_mask = clrconv->alpha ? 0xFF000000 : 0;
srcp = (UINT32*) srcData;
dstp = (UINT32*) dstData;
if (clrconv->invert)
{
int x, y;
BYTE* dstp;
CopyMemory(dstData, srcData, width * height * 4);
dstp = dstData;
for (y = 0; y < height; y++)
for (i = width * height; i > 0; i--)
{
for (x = 0; x < width * 4; x += 4)
{
dstp += 3;
*dstp = 0xFF;
dstp++;
}
pixel = *srcp;
srcp++;
GetRGB32(red, green, blue, pixel);
pixel = alpha_mask | BGR32(red, green, blue);
*dstp = pixel;
dstp++;
}
}
else
{
CopyMemory(dstData, srcData, width * height * 4);
for (i = width * height; i > 0; i--)
{
pixel = *srcp;
srcp++;
GetRGB32(red, green, blue, pixel);
pixel = alpha_mask | RGB32(red, green, blue);
*dstp = pixel;
dstp++;
}
}
return dstData;
@ -995,58 +1115,12 @@ BYTE* freerdp_mono_image_convert(BYTE* srcData, int width, int height, int srcBp
int bitIndex;
BYTE redBg, greenBg, blueBg;
BYTE redFg, greenFg, blueFg;
switch (srcBpp)
{
case 8:
bgcolor &= 0xFF;
redBg = clrconv->palette->entries[bgcolor].red;
greenBg = clrconv->palette->entries[bgcolor].green;
blueBg = clrconv->palette->entries[bgcolor].blue;
fgcolor &= 0xFF;
redFg = clrconv->palette->entries[fgcolor].red;
greenFg = clrconv->palette->entries[fgcolor].green;
blueFg = clrconv->palette->entries[fgcolor].blue;
break;
case 16:
GetRGB16(redBg, greenBg, blueBg, bgcolor);
GetRGB16(redFg, greenFg, blueFg, fgcolor);
break;
case 15:
GetRGB15(redBg, greenBg, blueBg, bgcolor);
GetRGB15(redFg, greenFg, blueFg, fgcolor);
break;
default:
GetRGB32(redBg, greenBg, blueBg, bgcolor);
GetRGB32(redFg, greenFg, blueFg, fgcolor);
break;
}
GetRGB32(redBg, greenBg, blueBg, bgcolor);
GetRGB32(redFg, greenFg, blueFg, fgcolor);
if (dstBpp == 16)
{
if (clrconv->rgb555)
{
if (srcBpp == 16)
{
/* convert 15-bit colors to 16-bit colors */
RGB16_RGB15(redBg, greenBg, blueBg, bgcolor);
RGB16_RGB15(redFg, greenFg, blueFg, fgcolor);
}
}
else
{
if (srcBpp == 15)
{
/* convert 15-bit colors to 16-bit colors */
RGB15_RGB16(redBg, greenBg, blueBg, bgcolor);
RGB15_RGB16(redFg, greenFg, blueFg, fgcolor);
}
}
dstData = (BYTE*) _aligned_malloc(width * height * 2, 16);
if (!dstData)
@ -1054,6 +1128,17 @@ BYTE* freerdp_mono_image_convert(BYTE* srcData, int width, int height, int srcBp
dst16 = (UINT16*) dstData;
if (clrconv->rgb555)
{
bgcolor = clrconv->invert ? BGR15(redBg, greenBg, blueBg) : RGB15(redBg, greenBg, blueBg);
fgcolor = clrconv->invert ? BGR15(redFg, greenFg, blueFg) : RGB15(redFg, greenFg, blueFg);
}
else
{
bgcolor = clrconv->invert ? BGR16(redBg, greenBg, blueBg) : RGB16(redBg, greenBg, blueBg);
fgcolor = clrconv->invert ? BGR16(redFg, greenFg, blueFg) : RGB16(redFg, greenFg, blueFg);
}
for (index = height; index > 0; index--)
{
/* each bit encodes a pixel */
@ -1092,11 +1177,25 @@ BYTE* freerdp_mono_image_convert(BYTE* srcData, int width, int height, int srcBp
{
if ((bitMask >> bitIndex) & 0x01)
{
*dst32 = (clrconv->invert) ? BGR32(redBg, greenBg, blueBg) : RGB32(redBg, greenBg, blueBg);
if (clrconv->alpha)
{
*dst32 = (clrconv->invert) ? ABGR32(0xFF, redBg, greenBg, blueBg) : ARGB32(0xFF, redBg, greenBg, blueBg);
}
else
{
*dst32 = (clrconv->invert) ? BGR32(redBg, greenBg, blueBg) : RGB32(redBg, greenBg, blueBg);
}
}
else
{
*dst32 = (clrconv->invert) ? BGR32(redFg, greenFg, blueFg) : RGB32(redFg, greenFg, blueFg);
if (clrconv->alpha)
{
*dst32 = (clrconv->invert) ? ABGR32(0xFF, redFg, greenFg, blueFg) : ARGB32(0xFF, redFg, greenFg, blueFg);
}
else
{
*dst32 = (clrconv->invert) ? BGR32(redFg, greenFg, blueFg) : RGB32(redFg, greenFg, blueFg);
}
}
dst32++;
}

18
libfreerdp/core/orders.c
View File

@ -223,11 +223,11 @@ static INLINE BOOL update_read_color(wStream* s, UINT32* color)
return FALSE;
Stream_Read_UINT8(s, byte);
*color = byte;
*color = (UINT32) byte << 16;
Stream_Read_UINT8(s, byte);
*color |= (byte << 8);
*color |= ((UINT32) byte << 8);
Stream_Read_UINT8(s, byte);
*color |= (byte << 16);
*color |= (UINT32) byte;
return TRUE;
}
@ -979,7 +979,7 @@ BOOL update_read_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, OPAQUE_REC
return FALSE;
Stream_Read_UINT8(s, byte);
opaque_rect->color = (opaque_rect->color & 0xFFFFFF00) | byte;
opaque_rect->color = (opaque_rect->color & 0xFF00FFFF) | ((UINT32) byte << 16);
}
if (orderInfo->fieldFlags & ORDER_FIELD_06)
@ -988,7 +988,7 @@ BOOL update_read_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, OPAQUE_REC
return FALSE;
Stream_Read_UINT8(s, byte);
opaque_rect->color = (opaque_rect->color & 0xFFFF00FF) | (byte << 8);
opaque_rect->color = (opaque_rect->color & 0xFFFF00FF) | ((UINT32) byte << 8);
}
if (orderInfo->fieldFlags & ORDER_FIELD_07)
@ -997,7 +997,7 @@ BOOL update_read_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, OPAQUE_REC
return FALSE;
Stream_Read_UINT8(s, byte);
opaque_rect->color = (opaque_rect->color & 0xFF00FFFF) | (byte << 16);
opaque_rect->color = (opaque_rect->color & 0xFFFFFF00) | (UINT32) byte;
}
return TRUE;
@ -1178,7 +1178,7 @@ BOOL update_read_multi_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, MULT
return FALSE;
Stream_Read_UINT8(s, byte);
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) | byte;
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | ((UINT32) byte << 16);
}
if (orderInfo->fieldFlags & ORDER_FIELD_06)
@ -1187,7 +1187,7 @@ BOOL update_read_multi_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, MULT
return FALSE;
Stream_Read_UINT8(s, byte);
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | (byte << 8);
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | ((UINT32) byte << 8);
}
if (orderInfo->fieldFlags & ORDER_FIELD_07)
@ -1196,7 +1196,7 @@ BOOL update_read_multi_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo, MULT
return FALSE;
Stream_Read_UINT8(s, byte);
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | (byte << 16);
multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) | (UINT32) byte;
}
ORDER_FIELD_BYTE(8, multi_opaque_rect->numRectangles);

4
libfreerdp/core/update.c
View File

@ -230,9 +230,9 @@ BOOL update_read_palette(rdpUpdate* update, wStream* s, PALETTE_UPDATE* palette_
{
entry = &palette_update->entries[i];
Stream_Read_UINT8(s, entry->blue);
Stream_Read_UINT8(s, entry->green);
Stream_Read_UINT8(s, entry->red);
Stream_Read_UINT8(s, entry->green);
Stream_Read_UINT8(s, entry->blue);
}
return TRUE;
}

2
libfreerdp/gdi/16bpp.c
View File

@ -43,7 +43,7 @@ UINT16 gdi_get_color_16bpp(HGDI_DC hdc, GDI_COLOR color)
BYTE r, g, b;
UINT16 color16;
GetBGR32(r, g, b, color);
GetRGB32(r, g, b, color);
if (hdc->rgb555)
{

2
libfreerdp/gdi/32bpp.c
View File

@ -44,7 +44,7 @@ UINT32 gdi_get_color_32bpp(HGDI_DC hdc, GDI_COLOR color)
BYTE a, r, g, b;
a = 0xFF;
GetBGR32(r, g, b, color);
GetRGB32(r, g, b, color);
if (hdc->invert)
{

31
libfreerdp/gdi/gdi.c
View File

@ -495,8 +495,8 @@ void gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
brush = &patblt->brush;
foreColor = freerdp_color_convert_rgb(patblt->foreColor, gdi->srcBpp, 24, gdi->clrconv);
backColor = freerdp_color_convert_rgb(patblt->backColor, gdi->srcBpp, 24, gdi->clrconv);
foreColor = freerdp_color_convert_drawing_order_color_to_gdi_color(patblt->foreColor, gdi->srcBpp, gdi->clrconv);
backColor = freerdp_color_convert_drawing_order_color_to_gdi_color(patblt->backColor, gdi->srcBpp, gdi->clrconv);
originalColor = gdi_SetTextColor(gdi->drawing->hdc, foreColor);
@ -517,7 +517,7 @@ void gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
HGDI_BITMAP hBmp;
data = freerdp_mono_image_convert(GDI_BS_HATCHED_PATTERNS + 8 * brush->hatch, 8, 8, 1,
gdi->dstBpp, patblt->backColor, patblt->foreColor, gdi->clrconv);
gdi->dstBpp, backColor, foreColor, gdi->clrconv);
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
@ -541,7 +541,7 @@ void gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
else
{
data = freerdp_mono_image_convert(brush->data, 8, 8, gdi->srcBpp, gdi->dstBpp,
patblt->backColor, patblt->foreColor, gdi->clrconv);
backColor, foreColor, gdi->clrconv);
}
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
@ -582,7 +582,8 @@ void gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
gdi_CRgnToRect(opaque_rect->nLeftRect, opaque_rect->nTopRect,
opaque_rect->nWidth, opaque_rect->nHeight, &rect);
brush_color = freerdp_color_convert_var_bgr(opaque_rect->color, gdi->srcBpp, 32, gdi->clrconv);
brush_color = freerdp_color_convert_drawing_order_color_to_gdi_color(
opaque_rect->color, gdi->srcBpp, gdi->clrconv);
hBrush = gdi_CreateSolidBrush(brush_color);
gdi_FillRect(gdi->drawing->hdc, &rect, hBrush);
@ -606,7 +607,8 @@ void gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_o
gdi_CRgnToRect(rectangle->left, rectangle->top,
rectangle->width, rectangle->height, &rect);
brush_color = freerdp_color_convert_var_bgr(multi_opaque_rect->color, gdi->srcBpp, 32, gdi->clrconv);
brush_color = freerdp_color_convert_drawing_order_color_to_gdi_color(
multi_opaque_rect->color, gdi->srcBpp, gdi->clrconv);
hBrush = gdi_CreateSolidBrush(brush_color);
gdi_FillRect(gdi->drawing->hdc, &rect, hBrush);
@ -621,7 +623,8 @@ void gdi_line_to(rdpContext* context, LINE_TO_ORDER* lineTo)
HGDI_PEN hPen;
rdpGdi* gdi = context->gdi;
color = freerdp_color_convert_rgb(lineTo->penColor, gdi->srcBpp, 32, gdi->clrconv);
color = freerdp_color_convert_drawing_order_color_to_gdi_color(
lineTo->penColor, gdi->srcBpp, gdi->clrconv);
hPen = gdi_CreatePen(lineTo->penStyle, lineTo->penWidth, (GDI_COLOR) color);
gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT) hPen);
gdi_SetROP2(gdi->drawing->hdc, lineTo->bRop2);
@ -642,7 +645,8 @@ void gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
DELTA_POINT* points;
rdpGdi* gdi = context->gdi;
color = freerdp_color_convert_rgb(polyline->penColor, gdi->srcBpp, 32, gdi->clrconv);
color = freerdp_color_convert_drawing_order_color_to_gdi_color(
polyline->penColor, gdi->srcBpp, gdi->clrconv);
hPen = gdi_CreatePen(GDI_PS_SOLID, 1, (GDI_COLOR) color);
gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT) hPen);
gdi_SetROP2(gdi->drawing->hdc, polyline->bRop2);
@ -689,8 +693,8 @@ void gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
brush = &mem3blt->brush;
bitmap = (gdiBitmap*) mem3blt->bitmap;
foreColor = freerdp_color_convert_rgb(mem3blt->foreColor, gdi->srcBpp, 24, gdi->clrconv);
backColor = freerdp_color_convert_rgb(mem3blt->backColor, gdi->srcBpp, 24, gdi->clrconv);
foreColor = freerdp_color_convert_drawing_order_color_to_gdi_color(mem3blt->foreColor, gdi->srcBpp, gdi->clrconv);
backColor = freerdp_color_convert_drawing_order_color_to_gdi_color(mem3blt->backColor, gdi->srcBpp, gdi->clrconv);
originalColor = gdi_SetTextColor(gdi->drawing->hdc, foreColor);
@ -717,7 +721,7 @@ void gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
else
{
data = freerdp_mono_image_convert(brush->data, 8, 8, gdi->srcBpp, gdi->dstBpp,
mem3blt->backColor, mem3blt->foreColor, gdi->clrconv);
backColor, foreColor, gdi->clrconv);
}
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
@ -851,7 +855,10 @@ void gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits_co
gdi->image->bitmap->bitsPerPixel = surface_bits_command->bpp;
gdi->image->bitmap->bytesPerPixel = gdi->image->bitmap->bitsPerPixel / 8;
gdi->image->bitmap->data = (BYTE*) _aligned_realloc(gdi->image->bitmap->data, gdi->image->bitmap->width * gdi->image->bitmap->height * 4, 16);
freerdp_image_flip(nsc_context->BitmapData, gdi->image->bitmap->data, gdi->image->bitmap->width, gdi->image->bitmap->height, 32);
freerdp_image_convert(nsc_context->BitmapData, gdi->image->bitmap->data,
surface_bits_command->width, surface_bits_command->height,
surface_bits_command->bpp, gdi->dstBpp, gdi->clrconv);
freerdp_image_flip(gdi->image->bitmap->data, gdi->image->bitmap->data, gdi->image->bitmap->width, gdi->image->bitmap->height, gdi->dstBpp);
gdi_BitBlt(gdi->primary->hdc, surface_bits_command->destLeft, surface_bits_command->destTop, surface_bits_command->width, surface_bits_command->height, gdi->image->hdc, 0, 0, GDI_SRCCOPY);
}
else if (surface_bits_command->codecID == RDP_CODEC_ID_NONE)

9
libfreerdp/gdi/graphics.c
View File

@ -242,8 +242,10 @@ void gdi_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int heigh
HGDI_BRUSH brush;
rdpGdi* gdi = context->gdi;
bgcolor = freerdp_color_convert_var_bgr(bgcolor, gdi->srcBpp, 32, gdi->clrconv);
fgcolor = freerdp_color_convert_var_bgr(fgcolor, gdi->srcBpp, 32, gdi->clrconv);
bgcolor = freerdp_color_convert_drawing_order_color_to_gdi_color(
bgcolor, gdi->srcBpp, gdi->clrconv);
fgcolor = freerdp_color_convert_drawing_order_color_to_gdi_color(
fgcolor, gdi->srcBpp, gdi->clrconv);
gdi_CRgnToRect(x, y, width, height, &rect);
@ -258,7 +260,8 @@ void gdi_Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height,
{
rdpGdi* gdi = context->gdi;
bgcolor = freerdp_color_convert_var_bgr(bgcolor, gdi->srcBpp, 32, gdi->clrconv);
bgcolor = freerdp_color_convert_drawing_order_color_to_gdi_color(
bgcolor, gdi->srcBpp, gdi->clrconv);
gdi->textColor = gdi_SetTextColor(gdi->drawing->hdc, bgcolor);
}