diff --git a/client/Mac/MRDPView.m b/client/Mac/MRDPView.m index 3d4fb8c1f..473d9f971 100644 --- a/client/Mac/MRDPView.m +++ b/client/Mac/MRDPView.m @@ -1156,7 +1156,7 @@ BOOL mf_Pointer_New(rdpContext *context, rdpPointer *pointer) isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace bitmapFormat:0 - bytesPerRow:rect.size.width * GetBytesPerPixel(format) + bytesPerRow:rect.size.width * FreeRDPGetBytesPerPixel(format) bitsPerPixel:0]; mrdpCursor->bmiRep = bmiRep; /* create an image using above representation */ @@ -1242,7 +1242,7 @@ CGContextRef mac_create_bitmap_context(rdpContext *context) { CGContextRef bitmap_context; rdpGdi *gdi = context->gdi; - UINT32 bpp = GetBytesPerPixel(gdi->dstFormat); + UINT32 bpp = FreeRDPGetBytesPerPixel(gdi->dstFormat); CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); if (bpp == 2) diff --git a/client/Windows/wf_gdi.c b/client/Windows/wf_gdi.c index fb6768efc..4384f5d43 100644 --- a/client/Windows/wf_gdi.c +++ b/client/Windows/wf_gdi.c @@ -80,7 +80,7 @@ static BOOL wf_decode_color(wfContext* wfc, const UINT32 srcColor, COLORREF* col if (format) *format = SrcFormat; - switch (GetBitsPerPixel(gdi->dstFormat)) + switch (FreeRDPGetBitsPerPixel(gdi->dstFormat)) { case 32: DstFormat = PIXEL_FORMAT_ABGR32; diff --git a/client/Windows/wf_graphics.c b/client/Windows/wf_graphics.c index 055a5d4aa..b3ceb0ec4 100644 --- a/client/Windows/wf_graphics.c +++ b/client/Windows/wf_graphics.c @@ -50,7 +50,7 @@ HBITMAP wf_create_dib(wfContext* wfc, UINT32 width, UINT32 height, UINT32 srcFor bmi.bmiHeader.biWidth = width; bmi.bmiHeader.biHeight = negHeight; bmi.bmiHeader.biPlanes = 1; - bmi.bmiHeader.biBitCount = GetBitsPerPixel(dstFormat); + bmi.bmiHeader.biBitCount = FreeRDPGetBitsPerPixel(dstFormat); bmi.bmiHeader.biCompression = BI_RGB; bitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**)&cdata, NULL, 0); diff --git a/client/X11/xf_disp.c b/client/X11/xf_disp.c index 77a9c6cc2..289340a32 100644 --- a/client/X11/xf_disp.c +++ b/client/X11/xf_disp.c @@ -34,6 +34,7 @@ #include "xf_disp.h" #include "xf_monitor.h" +#include #define TAG CLIENT_TAG("x11disp") #define RESIZE_MIN_DELAY 200 /* minimum delay in ms between two resizes */ diff --git a/client/X11/xf_floatbar.c b/client/X11/xf_floatbar.c index b9b787b3f..2dad3dcc9 100644 --- a/client/X11/xf_floatbar.c +++ b/client/X11/xf_floatbar.c @@ -30,6 +30,7 @@ #include "resource/minimize.xbm" #include "resource/restore.xbm" +#include #define TAG CLIENT_TAG("x11") #define FLOATBAR_HEIGHT 26 diff --git a/client/X11/xf_gdi.c b/client/X11/xf_gdi.c index 9ff149184..d10b642e2 100644 --- a/client/X11/xf_gdi.c +++ b/client/X11/xf_gdi.c @@ -1078,7 +1078,7 @@ static BOOL xf_gdi_surface_bits(rdpContext* context, const SURFACE_BITS_COMMAND* case RDP_CODEC_ID_NONE: pSrcData = cmd->bmp.bitmapData; format = gdi_get_pixel_format(cmd->bmp.bpp); - size = cmd->bmp.width * cmd->bmp.height * GetBytesPerPixel(format) * 1ULL; + size = cmd->bmp.width * cmd->bmp.height * FreeRDPGetBytesPerPixel(format) * 1ULL; if (size > cmd->bmp.bitmapDataLength) { WLog_ERR(TAG, "Short nocodec message: got %" PRIu32 " bytes, require %" PRIuz, diff --git a/client/X11/xf_gfx.c b/client/X11/xf_gfx.c index 9ab3939e5..f0bb5e8e8 100644 --- a/client/X11/xf_gfx.c +++ b/client/X11/xf_gfx.c @@ -302,7 +302,7 @@ static UINT xf_CreateSurface(RdpgfxClientContext* context, goto out_free; } - surface->gdi.scanline = surface->gdi.width * GetBytesPerPixel(surface->gdi.format); + surface->gdi.scanline = surface->gdi.width * FreeRDPGetBytesPerPixel(surface->gdi.format); surface->gdi.scanline = x11_pad_scanline(surface->gdi.scanline, xfc->scanline_pad); size = surface->gdi.scanline * surface->gdi.height * 1ULL; surface->gdi.data = (BYTE*)_aligned_malloc(size, 16); @@ -325,7 +325,7 @@ static UINT xf_CreateSurface(RdpgfxClientContext* context, else { UINT32 width = surface->gdi.width; - UINT32 bytes = GetBytesPerPixel(gdi->dstFormat); + UINT32 bytes = FreeRDPGetBytesPerPixel(gdi->dstFormat); surface->stageScanline = width * bytes; surface->stageScanline = x11_pad_scanline(surface->stageScanline, xfc->scanline_pad); size = surface->stageScanline * surface->gdi.height * 1ULL; diff --git a/client/X11/xf_graphics.c b/client/X11/xf_graphics.c index 16a9fb752..40c1afbf0 100644 --- a/client/X11/xf_graphics.c +++ b/client/X11/xf_graphics.c @@ -84,7 +84,7 @@ BOOL xf_decode_color(xfContext* xfc, const UINT32 srcColor, XColor* color) return FALSE; } - SplitColor(srcColor, SrcFormat, &r, &g, &b, &a, &gdi->palette); + FreeRDPSplitColor(srcColor, SrcFormat, &r, &g, &b, &a, &gdi->palette); color->blue = (unsigned short)(b << 8); color->green = (unsigned short)(g << 8); color->red = (unsigned short)(r << 8); @@ -111,7 +111,7 @@ static BOOL xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap) gdi = context->gdi; xf_lock_x11(xfc); - depth = GetBitsPerPixel(bitmap->format); + depth = FreeRDPGetBitsPerPixel(bitmap->format); xbitmap->pixmap = XCreatePixmap(xfc->display, xfc->drawable, bitmap->width, bitmap->height, xfc->depth); @@ -310,7 +310,7 @@ static BOOL _xf_Pointer_GetCursorForCurrentScale(rdpContext* context, const rdpP ci.height = yTargetSize; ci.xhot = pointer->xPos * xscale; ci.yhot = pointer->yPos * yscale; - size = ci.height * ci.width * GetBytesPerPixel(CursorFormat) * 1ULL; + size = ci.height * ci.width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL; tmp = _aligned_malloc(size, 16); if (!tmp) @@ -399,7 +399,7 @@ static BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer) xpointer->nCursors = 0; xpointer->mCursors = 0; - size = pointer->height * pointer->width * GetBytesPerPixel(CursorFormat) * 1ULL; + size = pointer->height * pointer->width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL; if (!(xpointer->cursorPixels = (XcursorPixel*)_aligned_malloc(size, 16))) return FALSE; diff --git a/client/X11/xf_rail.c b/client/X11/xf_rail.c index e2792d95a..4392c405c 100644 --- a/client/X11/xf_rail.c +++ b/client/X11/xf_rail.c @@ -32,6 +32,7 @@ #include "xf_window.h" #include "xf_rail.h" +#include #define TAG CLIENT_TAG("x11") static const char* error_code_names[] = { "RAIL_EXEC_S_OK", @@ -634,7 +635,7 @@ static BOOL convert_rail_icon(const ICON_INFO* iconInfo, xfRailIcon* railIcon) for (i = 2; i < nelements; i++) { - pixels[i] = ReadColor(nextPixel, PIXEL_FORMAT_BGRA32); + pixels[i] = FreeRDPReadColor(nextPixel, PIXEL_FORMAT_BGRA32); nextPixel += 4; } diff --git a/client/X11/xf_video.c b/client/X11/xf_video.c index cfa27f8e2..36d96ded9 100644 --- a/client/X11/xf_video.c +++ b/client/X11/xf_video.c @@ -24,6 +24,7 @@ #include "xf_video.h" +#include #define TAG CLIENT_TAG("video") typedef struct diff --git a/client/iOS/FreeRDP/ios_freerdp_ui.m b/client/iOS/FreeRDP/ios_freerdp_ui.m index 8f39631af..f03d50888 100644 --- a/client/iOS/FreeRDP/ios_freerdp_ui.m +++ b/client/iOS/FreeRDP/ios_freerdp_ui.m @@ -176,7 +176,7 @@ static void ios_create_bitmap_context(mfInfo *mfi) rdpGdi *gdi = mfi->instance->context->gdi; CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); - if (GetBytesPerPixel(gdi->dstFormat) == 2) + if (FreeRDPGetBytesPerPixel(gdi->dstFormat) == 2) mfi->bitmap_context = CGBitmapContextCreate( gdi->primary_buffer, gdi->width, gdi->height, 5, gdi->stride, colorSpace, kCGBitmapByteOrder16Little | kCGImageAlphaNoneSkipFirst); diff --git a/include/freerdp/codec/color.h b/include/freerdp/codec/color.h index fa83623c9..3c18beb21 100644 --- a/include/freerdp/codec/color.h +++ b/include/freerdp/codec/color.h @@ -23,9 +23,6 @@ #define FREERDP_CODEC_COLOR_H #include -#include -#include -#define CTAG FREERDP_TAG("codec.color") #define FREERDP_PIXEL_FORMAT_TYPE_A 0 #define FREERDP_PIXEL_FORMAT_TYPE_ARGB 1 @@ -50,8 +47,8 @@ * The format naming scheme is based on byte position in memory. * RGBA for example names a byte array with red on positon 0, green on 1 etc. * - * To read and write the appropriate format from / to memory use ReadColor and - * WriteColor. + * To read and write the appropriate format from / to memory use FreeRDPReadColor and + * FreeRDPWriteColor. * * The single pixel manipulation functions use an intermediate integer representation * that must not be interpreted outside the functions as it is platform dependent. @@ -122,83 +119,10 @@ extern "C" * * @return A string representation of format */ - static const char* FreeRDPGetColorFormatName(UINT32 format) - { - switch (format) - { - /* 32bpp formats */ - case PIXEL_FORMAT_ARGB32: - return "PIXEL_FORMAT_ARGB32"; - - case PIXEL_FORMAT_XRGB32: - return "PIXEL_FORMAT_XRGB32"; - - case PIXEL_FORMAT_ABGR32: - return "PIXEL_FORMAT_ABGR32"; - - case PIXEL_FORMAT_XBGR32: - return "PIXEL_FORMAT_XBGR32"; - - case PIXEL_FORMAT_BGRA32: - return "PIXEL_FORMAT_BGRA32"; - - case PIXEL_FORMAT_BGRX32: - return "PIXEL_FORMAT_BGRX32"; - - case PIXEL_FORMAT_RGBA32: - return "PIXEL_FORMAT_RGBA32"; - - case PIXEL_FORMAT_RGBX32: - return "PIXEL_FORMAT_RGBX32"; - - case PIXEL_FORMAT_BGRX32_DEPTH30: - return "PIXEL_FORMAT_BGRX32_DEPTH30"; - - case PIXEL_FORMAT_RGBX32_DEPTH30: - return "PIXEL_FORMAT_RGBX32_DEPTH30"; - - /* 24bpp formats */ - case PIXEL_FORMAT_RGB24: - return "PIXEL_FORMAT_RGB24"; - - case PIXEL_FORMAT_BGR24: - return "PIXEL_FORMAT_BGR24"; - - /* 16bpp formats */ - case PIXEL_FORMAT_RGB16: - return "PIXEL_FORMAT_RGB16"; - - case PIXEL_FORMAT_BGR16: - return "PIXEL_FORMAT_BGR16"; - - case PIXEL_FORMAT_ARGB15: - return "PIXEL_FORMAT_ARGB15"; - - case PIXEL_FORMAT_RGB15: - return "PIXEL_FORMAT_RGB15"; - - case PIXEL_FORMAT_ABGR15: - return "PIXEL_FORMAT_ABGR15"; - - case PIXEL_FORMAT_BGR15: - return "PIXEL_FORMAT_BGR15"; - - /* 8bpp formats */ - case PIXEL_FORMAT_RGB8: - return "PIXEL_FORMAT_RGB8"; - - /* 4 bpp formats */ - case PIXEL_FORMAT_A4: - return "PIXEL_FORMAT_A4"; - - /* 1bpp formats */ - case PIXEL_FORMAT_MONO: - return "PIXEL_FORMAT_MONO"; - - default: - return "UNKNOWN"; - } - } +#if defined(WITH_FREERDP_DEPRECATED) +#define GetColorFormatName(...) FreeRDPGetColorFormatName(__VA_ARGS__) +#endif + FREERDP_API const char* FreeRDPGetColorFormatName(UINT32 format); /*** * @@ -213,388 +137,11 @@ extern "C" * @param _a alpha color value * @param palette pallete to use (only used for 8 bit color!) */ - static INLINE void SplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g, BYTE* _b, - BYTE* _a, const gdiPalette* palette) - { - UINT32 tmp; - - switch (format) - { - /* 32bpp formats */ - case PIXEL_FORMAT_ARGB32: - if (_a) - *_a = (BYTE)(color >> 24); - - if (_r) - *_r = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_b) - *_b = (BYTE)color; - - break; - - case PIXEL_FORMAT_XRGB32: - if (_r) - *_r = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_b) - *_b = (BYTE)color; - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_ABGR32: - if (_a) - *_a = (BYTE)(color >> 24); - - if (_b) - *_b = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_r) - *_r = (BYTE)color; - - break; - - case PIXEL_FORMAT_XBGR32: - if (_b) - *_b = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_r) - *_r = (BYTE)color; - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_RGBA32: - if (_r) - *_r = (BYTE)(color >> 24); - - if (_g) - *_g = (BYTE)(color >> 16); - - if (_b) - *_b = (BYTE)(color >> 8); - - if (_a) - *_a = (BYTE)color; - - break; - - case PIXEL_FORMAT_RGBX32: - if (_r) - *_r = (BYTE)(color >> 24); - - if (_g) - *_g = (BYTE)(color >> 16); - - if (_b) - *_b = (BYTE)(color >> 8); - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_BGRA32: - if (_b) - *_b = (BYTE)(color >> 24); - - if (_g) - *_g = (BYTE)(color >> 16); - - if (_r) - *_r = (BYTE)(color >> 8); - - if (_a) - *_a = (BYTE)color; - - break; - - case PIXEL_FORMAT_BGRX32: - if (_b) - *_b = (BYTE)(color >> 24); - - if (_g) - *_g = (BYTE)(color >> 16); - - if (_r) - *_r = (BYTE)(color >> 8); - - if (_a) - *_a = 0xFF; - - break; - - /* 24bpp formats */ - case PIXEL_FORMAT_RGB24: - if (_r) - *_r = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_b) - *_b = (BYTE)color; - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_BGR24: - if (_b) - *_b = (BYTE)(color >> 16); - - if (_g) - *_g = (BYTE)(color >> 8); - - if (_r) - *_r = (BYTE)color; - - if (_a) - *_a = 0xFF; - - break; - - /* 16bpp formats */ - case PIXEL_FORMAT_RGB16: - if (_r) - { - const UINT32 c = (color >> 11) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x3F; - const UINT32 val = (c << 2) + c / 4 / 2; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_BGR16: - if (_r) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x3F; - const UINT32 val = (c << 2) + c / 4 / 2; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color >> 11) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_ARGB15: - if (_r) - { - const UINT32 c = (color >> 10) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = color & 0x8000 ? 0xFF : 0x00; - - break; - - case PIXEL_FORMAT_ABGR15: - if (_r) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color >> 10) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = color & 0x8000 ? 0xFF : 0x00; - - break; - - /* 15bpp formats */ - case PIXEL_FORMAT_RGB15: - if (_r) - { - const UINT32 c = (color >> 10) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = 0xFF; - - break; - - case PIXEL_FORMAT_BGR15: - if (_r) - { - const UINT32 c = (color)&0x1F; - const UINT32 val = (c << 3) + c / 4; - *_r = (BYTE)(val > 255 ? 255 : val); - } - - if (_g) - { - const UINT32 c = (color >> 5) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_g = (BYTE)(val > 255 ? 255 : val); - } - - if (_b) - { - const UINT32 c = (color >> 10) & 0x1F; - const UINT32 val = (c << 3) + c / 4; - *_b = (BYTE)(val > 255 ? 255 : val); - } - - if (_a) - *_a = 0xFF; - - break; - - /* 8bpp formats */ - case PIXEL_FORMAT_RGB8: - if (color <= 0xFF) - { - tmp = palette->palette[color]; - SplitColor(tmp, palette->format, _r, _g, _b, _a, NULL); - } - else - { - if (_r) - *_r = 0x00; - - if (_g) - *_g = 0x00; - - if (_b) - *_b = 0x00; - - if (_a) - *_a = 0x00; - } - - break; - - /* 1bpp formats */ - case PIXEL_FORMAT_MONO: - if (_r) - *_r = (color) ? 0xFF : 0x00; - - if (_g) - *_g = (color) ? 0xFF : 0x00; - - if (_b) - *_b = (color) ? 0xFF : 0x00; - - if (_a) - *_a = (color) ? 0xFF : 0x00; - - break; - - /* 4 bpp formats */ - case PIXEL_FORMAT_A4: - default: - if (_r) - *_r = 0x00; - - if (_g) - *_g = 0x00; - - if (_b) - *_b = 0x00; - - if (_a) - *_a = 0x00; - - WLog_ERR(CTAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); - break; - } - } +#if defined(WITH_FREERDP_DEPRECATED) +#define SplitColor(...) FreeRDPSplitColor(__VA_ARGS__) +#endif + FREERDP_API void FreeRDPSplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g, BYTE* _b, + BYTE* _a, const gdiPalette* palette); /*** * @@ -609,95 +156,10 @@ extern "C" * @return The pixel color in the desired format. Value is in internal * representation. */ - static INLINE UINT32 FreeRDPGetColor(UINT32 format, BYTE r, BYTE g, BYTE b, BYTE a) - { - UINT32 _r = r; - UINT32 _g = g; - UINT32 _b = b; - UINT32 _a = a; - UINT32 t; - - switch (format) - { - /* 32bpp formats */ - case PIXEL_FORMAT_ARGB32: - return (_a << 24) | (_r << 16) | (_g << 8) | _b; - - case PIXEL_FORMAT_XRGB32: - return (_r << 16) | (_g << 8) | _b; - - case PIXEL_FORMAT_ABGR32: - return (_a << 24) | (_b << 16) | (_g << 8) | _r; - - case PIXEL_FORMAT_XBGR32: - return (_b << 16) | (_g << 8) | _r; - - case PIXEL_FORMAT_RGBA32: - return (_r << 24) | (_g << 16) | (_b << 8) | _a; - - case PIXEL_FORMAT_RGBX32: - return (_r << 24) | (_g << 16) | (_b << 8) | _a; - - case PIXEL_FORMAT_BGRA32: - return (_b << 24) | (_g << 16) | (_r << 8) | _a; - - case PIXEL_FORMAT_BGRX32: - return (_b << 24) | (_g << 16) | (_r << 8) | _a; - - case PIXEL_FORMAT_RGBX32_DEPTH30: - // TODO: Not tested - t = (_r << 22) | (_g << 12) | (_b << 2); - // NOTE: Swapping byte-order because WriteColor written UINT32 in big-endian - return ((t & 0xff) << 24) | (((t >> 8) & 0xff) << 16) | (((t >> 16) & 0xff) << 8) | (t >> 24); - - case PIXEL_FORMAT_BGRX32_DEPTH30: - // NOTE: Swapping b and r channel (unknown reason) - t = (_r << 22) | (_g << 12) | (_b << 2); - // NOTE: Swapping byte-order because WriteColor written UINT32 in big-endian - return ((t & 0xff) << 24) | (((t >> 8) & 0xff) << 16) | (((t >> 16) & 0xff) << 8) | (t >> 24); - - /* 24bpp formats */ - case PIXEL_FORMAT_RGB24: - return (_r << 16) | (_g << 8) | _b; - - case PIXEL_FORMAT_BGR24: - return (_b << 16) | (_g << 8) | _r; - - /* 16bpp formats */ - case PIXEL_FORMAT_RGB16: - return (((_r >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((_b >> 3) & 0x1F); - - case PIXEL_FORMAT_BGR16: - return (((_b >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((_r >> 3) & 0x1F); - - case PIXEL_FORMAT_ARGB15: - return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_b >> 3) & 0x1F) | - (_a ? 0x8000 : 0x0000); - - case PIXEL_FORMAT_ABGR15: - return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_r >> 3) & 0x1F) | - (_a ? 0x8000 : 0x0000); - - /* 15bpp formats */ - case PIXEL_FORMAT_RGB15: - return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_b >> 3) & 0x1F); - - case PIXEL_FORMAT_BGR15: - return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_r >> 3) & 0x1F); - - /* 8bpp formats */ - case PIXEL_FORMAT_RGB8: - - /* 4 bpp formats */ - case PIXEL_FORMAT_A4: - - /* 1bpp formats */ - case PIXEL_FORMAT_MONO: - default: - WLog_ERR(CTAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); - return 0; - } - } +#if defined(WITH_FREERDP_DEPRECATED) +#define GetColor(...) FreeRDPGetColor(__VA_ARGS__) +#endif + FREERDP_API UINT32 FreeRDPGetColor(UINT32 format, BYTE r, BYTE g, BYTE b, BYTE a); /*** * @@ -707,7 +169,10 @@ extern "C" * * @return The number of bits the format requires per pixel. */ - static INLINE UINT32 GetBitsPerPixel(UINT32 format) +#if defined(WITH_FREERDP_DEPRECATED) +#define GetBitsPerPixel(...) FreeRDPGetBitsPerPixel(__VA_ARGS__) +#endif + static INLINE UINT32 FreeRDPGetBitsPerPixel(UINT32 format) { return (((format) >> 24) & 0x3F); } @@ -717,7 +182,10 @@ extern "C" * * @return TRUE if the format has an alpha channel, FALSE otherwise. */ - static INLINE BOOL ColorHasAlpha(UINT32 format) +#if defined(WITH_FREERDP_DEPRECATED) +#define ColorHasAlpha(...) FreeRDPColorHasAlpha(__VA_ARGS__) +#endif + static INLINE BOOL FreeRDPColorHasAlpha(UINT32 format) { UINT32 alpha = (((format) >> 12) & 0x0F); @@ -736,47 +204,10 @@ extern "C" * * @return The pixel color in internal representation */ - static INLINE UINT32 ReadColor(const BYTE* src, UINT32 format) - { - UINT32 color; - - switch (GetBitsPerPixel(format)) - { - case 32: - color = ((UINT32)src[0] << 24) | ((UINT32)src[1] << 16) | ((UINT32)src[2] << 8) | - src[3]; - break; - - case 24: - color = ((UINT32)src[0] << 16) | ((UINT32)src[1] << 8) | src[2]; - break; - - case 16: - color = ((UINT32)src[1] << 8) | src[0]; - break; - - case 15: - color = ((UINT32)src[1] << 8) | src[0]; - - if (!ColorHasAlpha(format)) - color = color & 0x7FFF; - - break; - - case 8: - case 4: - case 1: - color = *src; - break; - - default: - WLog_ERR(CTAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); - color = 0; - break; - } - - return color; - } +#if defined(WITH_FREERDP_DEPRECATED) +#define ReadColor(...) FreeRDPReadColor(__VA_ARGS__) +#endif + FREERDP_API UINT32 FreeRDPReadColor(const BYTE* src, UINT32 format); /*** * @@ -788,68 +219,12 @@ extern "C" * * @return TRUE if successful, FALSE otherwise */ - static INLINE BOOL WriteColor(BYTE* dst, UINT32 format, UINT32 color) - { - switch (GetBitsPerPixel(format)) - { - case 32: - dst[0] = (BYTE)(color >> 24); - dst[1] = (BYTE)(color >> 16); - dst[2] = (BYTE)(color >> 8); - dst[3] = (BYTE)color; - break; - - case 24: - dst[0] = (BYTE)(color >> 16); - dst[1] = (BYTE)(color >> 8); - dst[2] = (BYTE)color; - break; - - case 16: - dst[1] = (BYTE)(color >> 8); - dst[0] = (BYTE)color; - break; - - case 15: - if (!ColorHasAlpha(format)) - color = color & 0x7FFF; - - dst[1] = (BYTE)(color >> 8); - dst[0] = (BYTE)color; - break; - - case 8: - dst[0] = (BYTE)color; - break; - - default: - WLog_ERR(CTAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); - return FALSE; - } - - return TRUE; - } - - static INLINE BOOL WriteColorIgnoreAlpha(BYTE* dst, UINT32 format, UINT32 color) - { - switch (format) - { - case PIXEL_FORMAT_ABGR32: - case PIXEL_FORMAT_ARGB32: - { - const UINT32 tmp = ((UINT32)dst[0] << 24ULL) | (color & 0x00FFFFFFULL); - return WriteColor(dst, format, tmp); - } - case PIXEL_FORMAT_BGRA32: - case PIXEL_FORMAT_RGBA32: - { - const UINT32 tmp = ((UINT32)dst[3]) | (color & 0xFFFFFF00ULL); - return WriteColor(dst, format, tmp); - } - default: - return WriteColor(dst, format, color); - } - } +#if defined(WITH_FREERDP_DEPRECATED) +#define WriteColor(...) FreeRDPWriteColor(__VA_ARGS__) +#define WriteColorIgnoreAlpha(...) FreeRDPWriteColorIgnoreAlpha(__VA_ARGS__) +#endif + FREERDP_API BOOL FreeRDPWriteColor(BYTE* dst, UINT32 format, UINT32 color); + FREERDP_API BOOL FreeRDPWriteColorIgnoreAlpha(BYTE* dst, UINT32 format, UINT32 color); /*** * @@ -863,6 +238,9 @@ extern "C" * * @return The converted pixel color in dstFormat representation */ +#if defined(WITH_FREERDP_DEPRECATED) +#define ConvertColor(...) FreeRDPConvertColor(__VA_ARGS__) +#endif static INLINE UINT32 FreeRDPConvertColor(UINT32 color, UINT32 srcFormat, UINT32 dstFormat, const gdiPalette* palette) { @@ -870,7 +248,7 @@ extern "C" BYTE g = 0; BYTE b = 0; BYTE a = 0; - SplitColor(color, srcFormat, &r, &g, &b, &a, palette); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, &a, palette); return FreeRDPGetColor(dstFormat, r, g, b, a); } @@ -882,9 +260,12 @@ extern "C" * * @return The number of bytes the format requires per pixel. */ - static INLINE UINT32 GetBytesPerPixel(UINT32 format) +#if defined(WITH_FREERDP_DEPRECATED) +#define GetBytesPerPixel(...) FreeRDPGetBytesPerPixel(__VA_ARGS__) +#endif + static INLINE UINT32 FreeRDPGetBytesPerPixel(UINT32 format) { - return (GetBitsPerPixel(format) + 7) / 8; + return (FreeRDPGetBitsPerPixel(format) + 7) / 8; } /*** @@ -1039,12 +420,6 @@ extern "C" UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 color); -#if !defined(__APPLE__) -#define GetColorFormatName FreeRDPGetColorFormatName -#define GetColor FreeRDPGetColor -#define ConvertColor FreeRDPConvertColor -#endif - #ifdef __cplusplus } #endif diff --git a/libfreerdp/codec/clear.c b/libfreerdp/codec/clear.c index fe931795c..cb971a30a 100644 --- a/libfreerdp/codec/clear.c +++ b/libfreerdp/codec/clear.c @@ -230,11 +230,11 @@ static BOOL clear_decompress_subcode_rlex(wStream* s, UINT32 bitmapDataByteCount for (i = 0; i < runLengthFactor; i++) { - BYTE* pTmpData = - &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) + (nYDstRel + y) * nDstStep]; + BYTE* pTmpData = &pDstData[(nXDstRel + x) * FreeRDPGetBytesPerPixel(DstFormat) + + (nYDstRel + y) * nDstStep]; if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight)) - WriteColor(pTmpData, DstFormat, color); + FreeRDPWriteColor(pTmpData, DstFormat, color); if (++x >= width) { @@ -255,8 +255,8 @@ static BOOL clear_decompress_subcode_rlex(wStream* s, UINT32 bitmapDataByteCount for (i = 0; i <= suiteDepth; i++) { - BYTE* pTmpData = - &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) + (nYDstRel + y) * nDstStep]; + BYTE* pTmpData = &pDstData[(nXDstRel + x) * FreeRDPGetBytesPerPixel(DstFormat) + + (nYDstRel + y) * nDstStep]; UINT32 ccolor = palette[suiteIndex]; if (suiteIndex > 127) @@ -268,7 +268,7 @@ static BOOL clear_decompress_subcode_rlex(wStream* s, UINT32 bitmapDataByteCount suiteIndex++; if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight)) - WriteColor(pTmpData, DstFormat, ccolor); + FreeRDPWriteColor(pTmpData, DstFormat, ccolor); if (++x >= width) { @@ -296,7 +296,7 @@ static BOOL clear_resize_buffer(CLEAR_CONTEXT* clear, UINT32 width, UINT32 heigh if (!clear) return FALSE; - size = ((width + 16) * (height + 16) * GetBytesPerPixel(clear->format)); + size = ((width + 16) * (height + 16) * FreeRDPGetBytesPerPixel(clear->format)); if (size > clear->TempSize) { @@ -385,14 +385,14 @@ static BOOL clear_decompress_residual_data(CLEAR_CONTEXT* clear, wStream* s, for (i = 0; i < runLengthFactor; i++) { - WriteColor(dstBuffer, clear->format, color); - dstBuffer += GetBytesPerPixel(clear->format); + FreeRDPWriteColor(dstBuffer, clear->format, color); + dstBuffer += FreeRDPGetBytesPerPixel(clear->format); } pixelIndex += runLengthFactor; } - nSrcStep = nWidth * GetBytesPerPixel(clear->format); + nSrcStep = nWidth * FreeRDPGetBytesPerPixel(clear->format); if (pixelIndex != pixelCount) { @@ -465,7 +465,7 @@ static BOOL clear_decompress_subcodecs_data(CLEAR_CONTEXT* clear, wStream* s, { case 0: /* Uncompressed */ { - UINT32 nSrcStep = width * GetBytesPerPixel(PIXEL_FORMAT_BGR24); + UINT32 nSrcStep = width * FreeRDPGetBytesPerPixel(PIXEL_FORMAT_BGR24); UINT32 nSrcSize = nSrcStep * height; if (bitmapDataByteCount != nSrcSize) @@ -514,7 +514,7 @@ static BOOL resize_vbar_entry(CLEAR_CONTEXT* clear, CLEAR_VBAR_ENTRY* vBarEntry) { if (vBarEntry->count > vBarEntry->size) { - const UINT32 bpp = GetBytesPerPixel(clear->format); + const UINT32 bpp = FreeRDPGetBytesPerPixel(clear->format); const UINT32 oldPos = vBarEntry->size * bpp; const UINT32 diffSize = (vBarEntry->count - vBarEntry->size) * bpp; BYTE* tmp; @@ -679,14 +679,15 @@ static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 for (y = 0; y < vBarShortPixelCount; y++) { BYTE r, g, b; - BYTE* dstBuffer = &vBarShortEntry->pixels[y * GetBytesPerPixel(clear->format)]; + BYTE* dstBuffer = + &vBarShortEntry->pixels[y * FreeRDPGetBytesPerPixel(clear->format)]; UINT32 color; Stream_Read_UINT8(s, b); Stream_Read_UINT8(s, g); Stream_Read_UINT8(s, r); color = FreeRDPGetColor(clear->format, r, g, b, 0xFF); - if (!WriteColor(dstBuffer, clear->format, color)) + if (!FreeRDPWriteColor(dstBuffer, clear->format, color)) return FALSE; } @@ -748,8 +749,8 @@ static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 while (count--) { - WriteColor(dstBuffer, clear->format, colorBkg); - dstBuffer += GetBytesPerPixel(clear->format); + FreeRDPWriteColor(dstBuffer, clear->format, colorBkg); + dstBuffer += FreeRDPGetBytesPerPixel(clear->format); } /* @@ -764,18 +765,19 @@ static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 if (count > 0) pSrcPixel = - &vBarShortEntry->pixels[(y - vBarYOn) * GetBytesPerPixel(clear->format)]; + &vBarShortEntry + ->pixels[(y - vBarYOn) * FreeRDPGetBytesPerPixel(clear->format)]; for (x = 0; x < count; x++) { UINT32 color; - color = - ReadColor(&pSrcPixel[x * GetBytesPerPixel(clear->format)], clear->format); + color = FreeRDPReadColor(&pSrcPixel[x * FreeRDPGetBytesPerPixel(clear->format)], + clear->format); - if (!WriteColor(dstBuffer, clear->format, color)) + if (!FreeRDPWriteColor(dstBuffer, clear->format, color)) return FALSE; - dstBuffer += GetBytesPerPixel(clear->format); + dstBuffer += FreeRDPGetBytesPerPixel(clear->format); } /* if (y >= (vBarYOn + vBarShortPixelCount)), use colorBkg */ @@ -784,10 +786,10 @@ static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 while (count--) { - if (!WriteColor(dstBuffer, clear->format, colorBkg)) + if (!FreeRDPWriteColor(dstBuffer, clear->format, colorBkg)) return FALSE; - dstBuffer += GetBytesPerPixel(clear->format); + dstBuffer += FreeRDPGetBytesPerPixel(clear->format); } vBarEntry->count = vBarPixelCount; @@ -817,15 +819,16 @@ static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 for (y = 0; y < count; y++) { - BYTE* pDstPixel8 = &pDstData[((nYDstRel + y) * nDstStep) + - ((nXDstRel + i) * GetBytesPerPixel(DstFormat))]; - UINT32 color = ReadColor(cpSrcPixel, clear->format); + BYTE* pDstPixel8 = + &pDstData[((nYDstRel + y) * nDstStep) + + ((nXDstRel + i) * FreeRDPGetBytesPerPixel(DstFormat))]; + UINT32 color = FreeRDPReadColor(cpSrcPixel, clear->format); color = FreeRDPConvertColor(color, clear->format, DstFormat, NULL); - if (!WriteColor(pDstPixel8, DstFormat, color)) + if (!FreeRDPWriteColor(pDstPixel8, DstFormat, color)) return FALSE; - cpSrcPixel += GetBytesPerPixel(clear->format); + cpSrcPixel += FreeRDPGetBytesPerPixel(clear->format); } } } @@ -899,14 +902,14 @@ static BOOL clear_decompress_glyph_data(CLEAR_CONTEXT* clear, wStream* s, UINT32 return FALSE; } - nSrcStep = nWidth * GetBytesPerPixel(clear->format); + nSrcStep = nWidth * FreeRDPGetBytesPerPixel(clear->format); return convert_color(pDstData, nDstStep, DstFormat, nXDst, nYDst, nWidth, nHeight, glyphData, nSrcStep, clear->format, nDstWidth, nDstHeight, palette); } if (glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX) { - const UINT32 bpp = GetBytesPerPixel(clear->format); + const UINT32 bpp = FreeRDPGetBytesPerPixel(clear->format); CLEAR_GLYPH_ENTRY* glyphEntry = &(clear->GlyphCache[glyphIndex]); glyphEntry->count = nWidth * nHeight; diff --git a/libfreerdp/codec/color.c b/libfreerdp/codec/color.c index 53d585303..d4899e4f1 100644 --- a/libfreerdp/codec/color.c +++ b/libfreerdp/codec/color.c @@ -89,7 +89,7 @@ BOOL freerdp_image_copy_from_monochrome(BYTE* pDstData, UINT32 DstFormat, UINT32 UINT32 x, y; BOOL vFlip; UINT32 monoStep; - const UINT32 dstBytesPerPixel = GetBytesPerPixel(DstFormat); + const UINT32 dstBytesPerPixel = FreeRDPGetBytesPerPixel(DstFormat); if (!pDstData || !pSrcData || !palette) return FALSE; @@ -113,7 +113,7 @@ BOOL freerdp_image_copy_from_monochrome(BYTE* pDstData, UINT32 DstFormat, UINT32 for (x = 0; x < nWidth; x++) { - BYTE* pDstPixel = &pDstLine[((nXDst + x) * GetBytesPerPixel(DstFormat))]; + BYTE* pDstPixel = &pDstLine[((nXDst + x) * FreeRDPGetBytesPerPixel(DstFormat))]; BOOL monoPixel = (*monoBits & monoBit) ? TRUE : FALSE; if (!(monoBit >>= 1)) @@ -123,9 +123,9 @@ BOOL freerdp_image_copy_from_monochrome(BYTE* pDstData, UINT32 DstFormat, UINT32 } if (monoPixel) - WriteColor(pDstPixel, DstFormat, backColor); + FreeRDPWriteColor(pDstPixel, DstFormat, backColor); else - WriteColor(pDstPixel, DstFormat, foreColor); + FreeRDPWriteColor(pDstPixel, DstFormat, foreColor); } } @@ -173,7 +173,7 @@ static void fill_gdi_palette_for_icon(const BYTE* colorTable, UINT16 cbColorTabl for (i = 0; i < cbColorTable / 4; i++) { - palette->palette[i] = ReadColor(&colorTable[4 * i], palette->format); + palette->palette[i] = FreeRDPReadColor(&colorTable[4 * i], palette->format); } } @@ -240,7 +240,7 @@ BOOL freerdp_image_copy_from_icon_data(BYTE* pDstData, UINT32 DstFormat, UINT32 } /* Ensure we have enough source data bytes for image copy. */ - if (cbBitsColor < nWidth * nHeight * GetBytesPerPixel(format)) + if (cbBitsColor < nWidth * nHeight * FreeRDPGetBytesPerPixel(format)) return FALSE; fill_gdi_palette_for_icon(colorTable, cbColorTable, &palette); @@ -249,7 +249,7 @@ BOOL freerdp_image_copy_from_icon_data(BYTE* pDstData, UINT32 DstFormat, UINT32 return FALSE; /* apply alpha mask */ - if (ColorHasAlpha(DstFormat) && cbBitsMask) + if (FreeRDPColorHasAlpha(DstFormat) && cbBitsMask) { BYTE nextBit; const BYTE* maskByte; @@ -257,7 +257,7 @@ BOOL freerdp_image_copy_from_icon_data(BYTE* pDstData, UINT32 DstFormat, UINT32 UINT32 stride; BYTE r, g, b; BYTE* dstBuf = pDstData; - UINT32 dstBpp = GetBytesPerPixel(DstFormat); + UINT32 dstBpp = FreeRDPGetBytesPerPixel(DstFormat); /* * Each byte encodes 8 adjacent pixels (with LSB padding as needed). @@ -277,10 +277,10 @@ BOOL freerdp_image_copy_from_icon_data(BYTE* pDstData, UINT32 DstFormat, UINT32 BYTE alpha = (*maskByte & nextBit) ? 0x00 : 0xFF; /* read color back, add alpha and write it back */ - color = ReadColor(dstBuf, DstFormat); - SplitColor(color, DstFormat, &r, &g, &b, NULL, &palette); + color = FreeRDPReadColor(dstBuf, DstFormat); + FreeRDPSplitColor(color, DstFormat, &r, &g, &b, NULL, &palette); color = FreeRDPGetColor(DstFormat, r, g, b, alpha); - WriteColor(dstBuf, DstFormat, color); + FreeRDPWriteColor(dstBuf, DstFormat, color); nextBit >>= 1; dstBuf += dstBpp; @@ -335,7 +335,7 @@ static BOOL freerdp_image_copy_from_pointer_data_1bpp(BYTE* pDstData, UINT32 Dst const BYTE* andBits; const BYTE* xorBits; BYTE* pDstPixel = - &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(DstFormat))]; + &pDstData[((nYDst + y) * nDstStep) + (nXDst * FreeRDPGetBytesPerPixel(DstFormat))]; xorBit = andBit = 0x80; if (!vFlip) @@ -377,8 +377,8 @@ static BOOL freerdp_image_copy_from_pointer_data_1bpp(BYTE* pDstData, UINT32 Dst else if (andPixel && xorPixel) color = freerdp_image_inverted_pointer_color(x, y, DstFormat); /* inverted */ - WriteColor(pDstPixel, DstFormat, color); - pDstPixel += GetBytesPerPixel(DstFormat); + FreeRDPWriteColor(pDstPixel, DstFormat, color); + pDstPixel += FreeRDPGetBytesPerPixel(DstFormat); } } @@ -401,7 +401,7 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(BYTE* pDstData, UINT32 Dst UINT32 andPixel; UINT32 dstBitsPerPixel; UINT32 xorBytesPerPixel; - dstBitsPerPixel = GetBitsPerPixel(DstFormat); + dstBitsPerPixel = FreeRDPGetBitsPerPixel(DstFormat); vFlip = (xorBpp == 1) ? FALSE : TRUE; andStep = (nWidth + 7) / 8; @@ -435,7 +435,7 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(BYTE* pDstData, UINT32 Dst const BYTE* xorBits; const BYTE* andBits = NULL; BYTE* pDstPixel = - &pDstData[((nYDst + y) * nDstStep) + (nXDst * GetBytesPerPixel(DstFormat))]; + &pDstData[((nYDst + y) * nDstStep) + (nXDst * FreeRDPGetBytesPerPixel(DstFormat))]; andBit = 0x80; if (!vFlip) @@ -461,12 +461,12 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(BYTE* pDstData, UINT32 Dst if (xorBpp == 32) { pixelFormat = PIXEL_FORMAT_BGRA32; - xorPixel = ReadColor(xorBits, pixelFormat); + xorPixel = FreeRDPReadColor(xorBits, pixelFormat); } else if (xorBpp == 16) { pixelFormat = PIXEL_FORMAT_RGB15; - xorPixel = ReadColor(xorBits, pixelFormat); + xorPixel = FreeRDPReadColor(xorBits, pixelFormat); } else if (xorBpp == 8) { @@ -476,7 +476,7 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(BYTE* pDstData, UINT32 Dst else { pixelFormat = PIXEL_FORMAT_BGR24; - xorPixel = ReadColor(xorBits, pixelFormat); + xorPixel = FreeRDPReadColor(xorBits, pixelFormat); } xorPixel = FreeRDPConvertColor(xorPixel, pixelFormat, PIXEL_FORMAT_ARGB32, palette); @@ -503,8 +503,8 @@ static BOOL freerdp_image_copy_from_pointer_data_xbpp(BYTE* pDstData, UINT32 Dst } color = FreeRDPConvertColor(xorPixel, PIXEL_FORMAT_ARGB32, DstFormat, palette); - WriteColor(pDstPixel, DstFormat, color); - pDstPixel += GetBytesPerPixel(DstFormat); + FreeRDPWriteColor(pDstPixel, DstFormat, color); + pDstPixel += FreeRDPGetBytesPerPixel(DstFormat); } } @@ -528,8 +528,8 @@ BOOL freerdp_image_copy_from_pointer_data(BYTE* pDstData, UINT32 DstFormat, UINT UINT32 y; UINT32 dstBitsPerPixel; UINT32 dstBytesPerPixel; - dstBitsPerPixel = GetBitsPerPixel(DstFormat); - dstBytesPerPixel = GetBytesPerPixel(DstFormat); + dstBitsPerPixel = FreeRDPGetBitsPerPixel(DstFormat); + dstBytesPerPixel = FreeRDPGetBytesPerPixel(DstFormat); if (nDstStep <= 0) nDstStep = dstBytesPerPixel * nWidth; @@ -588,8 +588,8 @@ BOOL freerdp_image_copy(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 DWORD SrcFormat, UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* palette, UINT32 flags) { - const UINT32 dstByte = GetBytesPerPixel(DstFormat); - const UINT32 srcByte = GetBytesPerPixel(SrcFormat); + const UINT32 dstByte = FreeRDPGetBytesPerPixel(DstFormat); + const UINT32 srcByte = FreeRDPGetBytesPerPixel(SrcFormat); const UINT32 copyDstWidth = nWidth * dstByte; const UINT32 xSrcOffset = nXSrc * srcByte; const UINT32 xDstOffset = nXDst * dstByte; @@ -606,10 +606,10 @@ BOOL freerdp_image_copy(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 return FALSE; if (nDstStep == 0) - nDstStep = nWidth * GetBytesPerPixel(DstFormat); + nDstStep = nWidth * FreeRDPGetBytesPerPixel(DstFormat); if (nSrcStep == 0) - nSrcStep = nWidth * GetBytesPerPixel(SrcFormat); + nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat); if (vSrcVFlip) { @@ -693,22 +693,22 @@ BOOL freerdp_image_copy(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 const BYTE* srcLine = &pSrcData[(y + nYSrc) * nSrcStep * srcVMultiplier + srcVOffset]; BYTE* dstLine = &pDstData[(y + nYDst) * nDstStep * dstVMultiplier + dstVOffset]; - UINT32 color = ReadColor(&srcLine[nXSrc * srcByte], SrcFormat); + UINT32 color = FreeRDPReadColor(&srcLine[nXSrc * srcByte], SrcFormat); UINT32 oldColor = color; UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette); - WriteColor(&dstLine[nXDst * dstByte], DstFormat, dstColor); + FreeRDPWriteColor(&dstLine[nXDst * dstByte], DstFormat, dstColor); for (x = 1; x < nWidth; x++) { - color = ReadColor(&srcLine[(x + nXSrc) * srcByte], SrcFormat); + color = FreeRDPReadColor(&srcLine[(x + nXSrc) * srcByte], SrcFormat); if (color == oldColor) { - WriteColor(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor); + FreeRDPWriteColor(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor); } else { oldColor = color; dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette); - WriteColor(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor); + FreeRDPWriteColor(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor); } } } @@ -721,12 +721,12 @@ BOOL freerdp_image_fill(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 color) { UINT32 x, y; - const UINT32 bpp = GetBytesPerPixel(DstFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat); BYTE* pFirstDstLine; BYTE* pFirstDstLineXOffset; if (nDstStep == 0) - nDstStep = (nXDst + nWidth) * GetBytesPerPixel(DstFormat); + nDstStep = (nXDst + nWidth) * FreeRDPGetBytesPerPixel(DstFormat); pFirstDstLine = &pDstData[nYDst * nDstStep]; pFirstDstLineXOffset = &pFirstDstLine[nXDst * bpp]; @@ -734,7 +734,7 @@ BOOL freerdp_image_fill(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 for (x = 0; x < nWidth; x++) { BYTE* pDst = &pFirstDstLine[(x + nXDst) * bpp]; - WriteColor(pDst, DstFormat, color); + FreeRDPWriteColor(pDst, DstFormat, color); } for (y = 1; y < nHeight; y++) @@ -777,14 +777,14 @@ BOOL freerdp_image_scale(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT3 BOOL rc = FALSE; if (nDstStep == 0) - nDstStep = nDstWidth * GetBytesPerPixel(DstFormat); + nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat); if (nSrcStep == 0) - nSrcStep = nSrcWidth * GetBytesPerPixel(SrcFormat); + nSrcStep = nSrcWidth * FreeRDPGetBytesPerPixel(SrcFormat); #if defined(SWSCALE_FOUND) || defined(CAIRO_FOUND) - const BYTE* src = &pSrcData[nXSrc * GetBytesPerPixel(SrcFormat) + nYSrc * nSrcStep]; - BYTE* dst = &pDstData[nXDst * GetBytesPerPixel(DstFormat) + nYDst * nDstStep]; + const BYTE* src = &pSrcData[nXSrc * FreeRDPGetBytesPerPixel(SrcFormat) + nYSrc * nSrcStep]; + BYTE* dst = &pDstData[nXDst * FreeRDPGetBytesPerPixel(DstFormat) + nYDst * nDstStep]; #endif /* direct copy is much faster than scaling, so check if we can simply copy... */ @@ -863,3 +863,667 @@ BOOL freerdp_image_scale(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT3 #endif return rc; } + +DWORD FreeRDPAreColorFormatsEqualNoAlpha(DWORD first, DWORD second) +{ + const DWORD mask = (DWORD) ~(8UL << 12UL); + return (first & mask) == (second & mask); +} + +const char* FreeRDPGetColorFormatName(UINT32 format) +{ + switch (format) + { + /* 32bpp formats */ + case PIXEL_FORMAT_ARGB32: + return "PIXEL_FORMAT_ARGB32"; + + case PIXEL_FORMAT_XRGB32: + return "PIXEL_FORMAT_XRGB32"; + + case PIXEL_FORMAT_ABGR32: + return "PIXEL_FORMAT_ABGR32"; + + case PIXEL_FORMAT_XBGR32: + return "PIXEL_FORMAT_XBGR32"; + + case PIXEL_FORMAT_BGRA32: + return "PIXEL_FORMAT_BGRA32"; + + case PIXEL_FORMAT_BGRX32: + return "PIXEL_FORMAT_BGRX32"; + + case PIXEL_FORMAT_RGBA32: + return "PIXEL_FORMAT_RGBA32"; + + case PIXEL_FORMAT_RGBX32: + return "PIXEL_FORMAT_RGBX32"; + + case PIXEL_FORMAT_BGRX32_DEPTH30: + return "PIXEL_FORMAT_BGRX32_DEPTH30"; + + case PIXEL_FORMAT_RGBX32_DEPTH30: + return "PIXEL_FORMAT_RGBX32_DEPTH30"; + + /* 24bpp formats */ + case PIXEL_FORMAT_RGB24: + return "PIXEL_FORMAT_RGB24"; + + case PIXEL_FORMAT_BGR24: + return "PIXEL_FORMAT_BGR24"; + + /* 16bpp formats */ + case PIXEL_FORMAT_RGB16: + return "PIXEL_FORMAT_RGB16"; + + case PIXEL_FORMAT_BGR16: + return "PIXEL_FORMAT_BGR16"; + + case PIXEL_FORMAT_ARGB15: + return "PIXEL_FORMAT_ARGB15"; + + case PIXEL_FORMAT_RGB15: + return "PIXEL_FORMAT_RGB15"; + + case PIXEL_FORMAT_ABGR15: + return "PIXEL_FORMAT_ABGR15"; + + case PIXEL_FORMAT_BGR15: + return "PIXEL_FORMAT_BGR15"; + + /* 8bpp formats */ + case PIXEL_FORMAT_RGB8: + return "PIXEL_FORMAT_RGB8"; + + /* 4 bpp formats */ + case PIXEL_FORMAT_A4: + return "PIXEL_FORMAT_A4"; + + /* 1bpp formats */ + case PIXEL_FORMAT_MONO: + return "PIXEL_FORMAT_MONO"; + + default: + return "UNKNOWN"; + } +} + +void FreeRDPSplitColor(UINT32 color, UINT32 format, BYTE* _r, BYTE* _g, BYTE* _b, BYTE* _a, + const gdiPalette* palette) +{ + UINT32 tmp; + + switch (format) + { + /* 32bpp formats */ + case PIXEL_FORMAT_ARGB32: + if (_a) + *_a = (BYTE)(color >> 24); + + if (_r) + *_r = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_b) + *_b = (BYTE)color; + + break; + + case PIXEL_FORMAT_XRGB32: + if (_r) + *_r = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_b) + *_b = (BYTE)color; + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_ABGR32: + if (_a) + *_a = (BYTE)(color >> 24); + + if (_b) + *_b = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_r) + *_r = (BYTE)color; + + break; + + case PIXEL_FORMAT_XBGR32: + if (_b) + *_b = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_r) + *_r = (BYTE)color; + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_RGBA32: + if (_r) + *_r = (BYTE)(color >> 24); + + if (_g) + *_g = (BYTE)(color >> 16); + + if (_b) + *_b = (BYTE)(color >> 8); + + if (_a) + *_a = (BYTE)color; + + break; + + case PIXEL_FORMAT_RGBX32: + if (_r) + *_r = (BYTE)(color >> 24); + + if (_g) + *_g = (BYTE)(color >> 16); + + if (_b) + *_b = (BYTE)(color >> 8); + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_BGRA32: + if (_b) + *_b = (BYTE)(color >> 24); + + if (_g) + *_g = (BYTE)(color >> 16); + + if (_r) + *_r = (BYTE)(color >> 8); + + if (_a) + *_a = (BYTE)color; + + break; + + case PIXEL_FORMAT_BGRX32: + if (_b) + *_b = (BYTE)(color >> 24); + + if (_g) + *_g = (BYTE)(color >> 16); + + if (_r) + *_r = (BYTE)(color >> 8); + + if (_a) + *_a = 0xFF; + + break; + + /* 24bpp formats */ + case PIXEL_FORMAT_RGB24: + if (_r) + *_r = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_b) + *_b = (BYTE)color; + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_BGR24: + if (_b) + *_b = (BYTE)(color >> 16); + + if (_g) + *_g = (BYTE)(color >> 8); + + if (_r) + *_r = (BYTE)color; + + if (_a) + *_a = 0xFF; + + break; + + /* 16bpp formats */ + case PIXEL_FORMAT_RGB16: + if (_r) + { + const UINT32 c = (color >> 11) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x3F; + const UINT32 val = (c << 2) + c / 4 / 2; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_BGR16: + if (_r) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x3F; + const UINT32 val = (c << 2) + c / 4 / 2; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color >> 11) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_ARGB15: + if (_r) + { + const UINT32 c = (color >> 10) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = color & 0x8000 ? 0xFF : 0x00; + + break; + + case PIXEL_FORMAT_ABGR15: + if (_r) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color >> 10) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = color & 0x8000 ? 0xFF : 0x00; + + break; + + /* 15bpp formats */ + case PIXEL_FORMAT_RGB15: + if (_r) + { + const UINT32 c = (color >> 10) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = 0xFF; + + break; + + case PIXEL_FORMAT_BGR15: + if (_r) + { + const UINT32 c = (color)&0x1F; + const UINT32 val = (c << 3) + c / 4; + *_r = (BYTE)(val > 255 ? 255 : val); + } + + if (_g) + { + const UINT32 c = (color >> 5) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_g = (BYTE)(val > 255 ? 255 : val); + } + + if (_b) + { + const UINT32 c = (color >> 10) & 0x1F; + const UINT32 val = (c << 3) + c / 4; + *_b = (BYTE)(val > 255 ? 255 : val); + } + + if (_a) + *_a = 0xFF; + + break; + + /* 8bpp formats */ + case PIXEL_FORMAT_RGB8: + if (color <= 0xFF) + { + tmp = palette->palette[color]; + FreeRDPSplitColor(tmp, palette->format, _r, _g, _b, _a, NULL); + } + else + { + if (_r) + *_r = 0x00; + + if (_g) + *_g = 0x00; + + if (_b) + *_b = 0x00; + + if (_a) + *_a = 0x00; + } + + break; + + /* 1bpp formats */ + case PIXEL_FORMAT_MONO: + if (_r) + *_r = (color) ? 0xFF : 0x00; + + if (_g) + *_g = (color) ? 0xFF : 0x00; + + if (_b) + *_b = (color) ? 0xFF : 0x00; + + if (_a) + *_a = (color) ? 0xFF : 0x00; + + break; + + /* 4 bpp formats */ + case PIXEL_FORMAT_A4: + default: + if (_r) + *_r = 0x00; + + if (_g) + *_g = 0x00; + + if (_b) + *_b = 0x00; + + if (_a) + *_a = 0x00; + + WLog_ERR(TAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); + break; + } +} + +BOOL FreeRDPWriteColorIgnoreAlpha(BYTE* dst, UINT32 format, UINT32 color) +{ + switch (format) + { + case PIXEL_FORMAT_ABGR32: + case PIXEL_FORMAT_ARGB32: + { + const UINT32 tmp = ((UINT32)dst[0] << 24ULL) | (color & 0x00FFFFFFULL); + return FreeRDPWriteColor(dst, format, tmp); + } + case PIXEL_FORMAT_BGRA32: + case PIXEL_FORMAT_RGBA32: + { + const UINT32 tmp = ((UINT32)dst[3]) | (color & 0xFFFFFF00ULL); + return FreeRDPWriteColor(dst, format, tmp); + } + default: + return FreeRDPWriteColor(dst, format, color); + } +} + +BOOL FreeRDPWriteColor(BYTE* dst, UINT32 format, UINT32 color) +{ + switch (FreeRDPGetBitsPerPixel(format)) + { + case 32: + dst[0] = (BYTE)(color >> 24); + dst[1] = (BYTE)(color >> 16); + dst[2] = (BYTE)(color >> 8); + dst[3] = (BYTE)color; + break; + + case 24: + dst[0] = (BYTE)(color >> 16); + dst[1] = (BYTE)(color >> 8); + dst[2] = (BYTE)color; + break; + + case 16: + dst[1] = (BYTE)(color >> 8); + dst[0] = (BYTE)color; + break; + + case 15: + if (!FreeRDPColorHasAlpha(format)) + color = color & 0x7FFF; + + dst[1] = (BYTE)(color >> 8); + dst[0] = (BYTE)color; + break; + + case 8: + dst[0] = (BYTE)color; + break; + + default: + WLog_ERR(TAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); + return FALSE; + } + + return TRUE; +} + +UINT32 FreeRDPReadColor(const BYTE* src, UINT32 format) +{ + UINT32 color; + + switch (FreeRDPGetBitsPerPixel(format)) + { + case 32: + color = + ((UINT32)src[0] << 24) | ((UINT32)src[1] << 16) | ((UINT32)src[2] << 8) | src[3]; + break; + + case 24: + color = ((UINT32)src[0] << 16) | ((UINT32)src[1] << 8) | src[2]; + break; + + case 16: + color = ((UINT32)src[1] << 8) | src[0]; + break; + + case 15: + color = ((UINT32)src[1] << 8) | src[0]; + + if (!FreeRDPColorHasAlpha(format)) + color = color & 0x7FFF; + + break; + + case 8: + case 4: + case 1: + color = *src; + break; + + default: + WLog_ERR(TAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); + color = 0; + break; + } + + return color; +} + +UINT32 FreeRDPGetColor(UINT32 format, BYTE r, BYTE g, BYTE b, BYTE a) +{ + UINT32 _r = r; + UINT32 _g = g; + UINT32 _b = b; + UINT32 _a = a; + UINT32 t; + + switch (format) + { + /* 32bpp formats */ + case PIXEL_FORMAT_ARGB32: + return (_a << 24) | (_r << 16) | (_g << 8) | _b; + + case PIXEL_FORMAT_XRGB32: + return (_r << 16) | (_g << 8) | _b; + + case PIXEL_FORMAT_ABGR32: + return (_a << 24) | (_b << 16) | (_g << 8) | _r; + + case PIXEL_FORMAT_XBGR32: + return (_b << 16) | (_g << 8) | _r; + + case PIXEL_FORMAT_RGBA32: + return (_r << 24) | (_g << 16) | (_b << 8) | _a; + + case PIXEL_FORMAT_RGBX32: + return (_r << 24) | (_g << 16) | (_b << 8) | _a; + + case PIXEL_FORMAT_BGRA32: + return (_b << 24) | (_g << 16) | (_r << 8) | _a; + + case PIXEL_FORMAT_BGRX32: + return (_b << 24) | (_g << 16) | (_r << 8) | _a; + + case PIXEL_FORMAT_RGBX32_DEPTH30: + // TODO: Not tested + t = (_r << 22) | (_g << 12) | (_b << 2); + // NOTE: Swapping byte-order because FreeRDPWriteColor written UINT32 in big-endian + return ((t & 0xff) << 24) | (((t >> 8) & 0xff) << 16) | (((t >> 16) & 0xff) << 8) | + (t >> 24); + + case PIXEL_FORMAT_BGRX32_DEPTH30: + // NOTE: Swapping b and r channel (unknown reason) + t = (_r << 22) | (_g << 12) | (_b << 2); + // NOTE: Swapping byte-order because FreeRDPWriteColor written UINT32 in big-endian + return ((t & 0xff) << 24) | (((t >> 8) & 0xff) << 16) | (((t >> 16) & 0xff) << 8) | + (t >> 24); + + /* 24bpp formats */ + case PIXEL_FORMAT_RGB24: + return (_r << 16) | (_g << 8) | _b; + + case PIXEL_FORMAT_BGR24: + return (_b << 16) | (_g << 8) | _r; + + /* 16bpp formats */ + case PIXEL_FORMAT_RGB16: + return (((_r >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((_b >> 3) & 0x1F); + + case PIXEL_FORMAT_BGR16: + return (((_b >> 3) & 0x1F) << 11) | (((_g >> 2) & 0x3F) << 5) | ((_r >> 3) & 0x1F); + + case PIXEL_FORMAT_ARGB15: + return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_b >> 3) & 0x1F) | + (_a ? 0x8000 : 0x0000); + + case PIXEL_FORMAT_ABGR15: + return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_r >> 3) & 0x1F) | + (_a ? 0x8000 : 0x0000); + + /* 15bpp formats */ + case PIXEL_FORMAT_RGB15: + return (((_r >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_b >> 3) & 0x1F); + + case PIXEL_FORMAT_BGR15: + return (((_b >> 3) & 0x1F) << 10) | (((_g >> 3) & 0x1F) << 5) | ((_r >> 3) & 0x1F); + + /* 8bpp formats */ + case PIXEL_FORMAT_RGB8: + + /* 4 bpp formats */ + case PIXEL_FORMAT_A4: + + /* 1bpp formats */ + case PIXEL_FORMAT_MONO: + default: + WLog_ERR(TAG, "Unsupported format %s", FreeRDPGetColorFormatName(format)); + return 0; + } +} diff --git a/libfreerdp/codec/nsc.c b/libfreerdp/codec/nsc.c index 0cb5a872f..2de6ef143 100644 --- a/libfreerdp/codec/nsc.c +++ b/libfreerdp/codec/nsc.c @@ -433,7 +433,7 @@ BOOL nsc_process_message(NSC_CONTEXT* context, UINT16 bpp, UINT32 width, UINT32 return FALSE; if (nDstStride == 0) - nDstStride = nWidth * GetBytesPerPixel(DstFormat); + nDstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat); switch (bpp) { diff --git a/libfreerdp/codec/nsc_encode.c b/libfreerdp/codec/nsc_encode.c index 25ac90678..2a428b1a1 100644 --- a/libfreerdp/codec/nsc_encode.c +++ b/libfreerdp/codec/nsc_encode.c @@ -527,9 +527,9 @@ BOOL nsc_decompose_message(NSC_CONTEXT* context, wStream* s, BYTE* bmpdata, UINT if (size > UINT32_MAX) return FALSE; - if (!nsc_process_message(context, (UINT16)GetBitsPerPixel(context->format), width, height, - Stream_Pointer(s), (UINT32)size, bmpdata, format, rowstride, x, y, - width, height, flip)) + if (!nsc_process_message(context, (UINT16)FreeRDPGetBitsPerPixel(context->format), width, + height, Stream_Pointer(s), (UINT32)size, bmpdata, format, rowstride, x, + y, width, height, flip)) return FALSE; Stream_Seek(s, size); return TRUE; diff --git a/libfreerdp/codec/planar.c b/libfreerdp/codec/planar.c index b2037f91a..38f7b8b8e 100644 --- a/libfreerdp/codec/planar.c +++ b/libfreerdp/codec/planar.c @@ -486,8 +486,8 @@ static INLINE BOOL writeLine(BYTE** ppRgba, UINT32 DstFormat, UINT32 width, cons BYTE alpha = *(*ppA)++; UINT32 color = FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha); - WriteColor(*ppRgba, DstFormat, color); - *ppRgba += GetBytesPerPixel(DstFormat); + FreeRDPWriteColor(*ppRgba, DstFormat, color); + *ppRgba += FreeRDPGetBytesPerPixel(DstFormat); } } else @@ -498,8 +498,8 @@ static INLINE BOOL writeLine(BYTE** ppRgba, UINT32 DstFormat, UINT32 width, cons { UINT32 color = FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha); - WriteColor(*ppRgba, DstFormat, color); - *ppRgba += GetBytesPerPixel(DstFormat); + FreeRDPWriteColor(*ppRgba, DstFormat, color); + *ppRgba += FreeRDPGetBytesPerPixel(DstFormat); } } @@ -518,7 +518,7 @@ static INLINE BOOL planar_decompress_planes_raw(const BYTE* pSrcData[4], BYTE* p const BYTE* pG = pSrcData[1]; const BYTE* pB = pSrcData[2]; const BYTE* pA = pSrcData[3]; - const UINT32 bpp = GetBytesPerPixel(DstFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat); if (vFlip) { @@ -613,7 +613,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar, const BYTE* pSrcData, UINT const primitives_t* prims = primitives_get(); if (nDstStep <= 0) - nDstStep = nDstWidth * GetBytesPerPixel(DstFormat); + nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat); srcp = pSrcData; @@ -632,7 +632,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar, const BYTE* pSrcData, UINT DstFormat = planar_invert_format(planar, alpha, DstFormat); if (alpha) - useAlpha = ColorHasAlpha(DstFormat); + useAlpha = FreeRDPColorHasAlpha(DstFormat); // WLog_INFO(TAG, "CLL: %"PRIu32" CS: %"PRIu8" RLE: %"PRIu8" ALPHA: %"PRIu8"", cll, cs, rle, // alpha); @@ -836,7 +836,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar, const BYTE* pSrcData, UINT BYTE* pTempData = planar->pTempData; UINT32 nTempStep = planar->nTempStep; UINT32 nTotalHeight = planar->maxHeight; - BYTE* dst = &pDstData[nXDst * GetBytesPerPixel(DstFormat) + nYDst * nDstStep]; + BYTE* dst = &pDstData[nXDst * FreeRDPGetBytesPerPixel(DstFormat) + nYDst * nDstStep]; if (useAlpha) TempFormat = PIXEL_FORMAT_BGRA32; @@ -949,7 +949,7 @@ static INLINE BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* planar, con return FALSE; if (scanline == 0) - scanline = width * GetBytesPerPixel(format); + scanline = width * FreeRDPGetBytesPerPixel(format); if (planar->topdown) { @@ -960,10 +960,10 @@ static INLINE BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* planar, con for (j = 0; j < width; j++) { - const UINT32 color = ReadColor(pixel, format); - pixel += GetBytesPerPixel(format); - SplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k], - &planes[0][k], NULL); + const UINT32 color = FreeRDPReadColor(pixel, format); + pixel += FreeRDPGetBytesPerPixel(format); + FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k], + &planes[0][k], NULL); k++; } } @@ -979,10 +979,10 @@ static INLINE BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* planar, con for (j = 0; j < width; j++) { - const UINT32 color = ReadColor(pixel, format); - pixel += GetBytesPerPixel(format); - SplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k], - &planes[0][k], NULL); + const UINT32 color = FreeRDPReadColor(pixel, format); + pixel += FreeRDPGetBytesPerPixel(format); + FreeRDPSplitColor(color, format, &planes[1][k], &planes[2][k], &planes[3][k], + &planes[0][k], NULL); k++; } } diff --git a/libfreerdp/codec/rfx.c b/libfreerdp/codec/rfx.c index 3fa66eb09..4e0f4c6ef 100644 --- a/libfreerdp/codec/rfx.c +++ b/libfreerdp/codec/rfx.c @@ -413,7 +413,7 @@ static RFX_RECT* rfx_message_get_rect(RFX_MESSAGE* message, UINT32 index) void rfx_context_set_pixel_format(RFX_CONTEXT* context, UINT32 pixel_format) { context->pixel_format = pixel_format; - context->bits_per_pixel = GetBitsPerPixel(pixel_format); + context->bits_per_pixel = FreeRDPGetBitsPerPixel(pixel_format); } BOOL rfx_context_reset(RFX_CONTEXT* context, UINT32 width, UINT32 height) @@ -1153,8 +1153,8 @@ BOOL rfx_process_message(RFX_CONTEXT* context, const BYTE* data, UINT32 length, UINT32 nbUpdateRects; REGION16 clippingRects; const RECTANGLE_16* updateRects; - const DWORD formatSize = GetBytesPerPixel(context->pixel_format); - const UINT32 dstWidth = dstStride / GetBytesPerPixel(dstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(context->pixel_format); + const UINT32 dstWidth = dstStride / FreeRDPGetBytesPerPixel(dstFormat); region16_init(&clippingRects); for (i = 0; i < message->numRects; i++) diff --git a/libfreerdp/codec/test/TestFreeRDPCodecInterleaved.c b/libfreerdp/codec/test/TestFreeRDPCodecInterleaved.c index 9959f50cf..9e5ce54db 100644 --- a/libfreerdp/codec/test/TestFreeRDPCodecInterleaved.c +++ b/libfreerdp/codec/test/TestFreeRDPCodecInterleaved.c @@ -29,7 +29,7 @@ static BOOL run_encode_decode_single(UINT16 bpp, BITMAP_INTERLEAVED_CONTEXT* enc const UINT32 x = 0; const UINT32 y = 0; const UINT32 format = PIXEL_FORMAT_RGBX32; - const UINT32 bstep = GetBytesPerPixel(format); + const UINT32 bstep = FreeRDPGetBytesPerPixel(format); const size_t step = (w + 13) * 4; const size_t SrcSize = step * h; const float maxDiff = 4.0f * ((bpp < 24) ? 2.0f : 1.0f); @@ -70,10 +70,10 @@ static BOOL run_encode_decode_single(UINT16 bpp, BITMAP_INTERLEAVED_CONTEXT* enc for (j = 0; j < w; j++) { BYTE r, g, b, dr, dg, db; - const UINT32 srcColor = ReadColor(&srcLine[j * bstep], format); - const UINT32 dstColor = ReadColor(&dstLine[j * bstep], format); - SplitColor(srcColor, format, &r, &g, &b, NULL, NULL); - SplitColor(dstColor, format, &dr, &dg, &db, NULL, NULL); + const UINT32 srcColor = FreeRDPReadColor(&srcLine[j * bstep], format); + const UINT32 dstColor = FreeRDPReadColor(&dstLine[j * bstep], format); + FreeRDPSplitColor(srcColor, format, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(dstColor, format, &dr, &dg, &db, NULL, NULL); if (fabsf((float)r - dr) > maxDiff) goto fail; @@ -169,11 +169,11 @@ static BOOL TestColorConversion(void) const UINT32 colorLow32 = FreeRDPConvertColor(colorLow, format, dstFormat, NULL); const UINT32 colorHigh32 = FreeRDPConvertColor(colorHigh, format, dstFormat, NULL); BYTE r, g, b, a; - SplitColor(colorLow32, dstFormat, &r, &g, &b, &a, NULL); + FreeRDPSplitColor(colorLow32, dstFormat, &r, &g, &b, &a, NULL); if ((r != 0) || (g != 0) || (b != 0)) return FALSE; - SplitColor(colorHigh32, dstFormat, &r, &g, &b, &a, NULL); + FreeRDPSplitColor(colorHigh32, dstFormat, &r, &g, &b, &a, NULL); if ((r != 255) || (g != 255) || (b != 255)) return FALSE; } diff --git a/libfreerdp/codec/test/TestFreeRDPCodecPlanar.c b/libfreerdp/codec/test/TestFreeRDPCodecPlanar.c index e79a35047..f0012fcee 100644 --- a/libfreerdp/codec/test/TestFreeRDPCodecPlanar.c +++ b/libfreerdp/codec/test/TestFreeRDPCodecPlanar.c @@ -5424,8 +5424,8 @@ static BOOL CompareBitmap(const BYTE* srcA, UINT32 srcAFormat, const BYTE* srcB, UINT32 width, UINT32 height) { double maxDiff; - const UINT32 srcABits = GetBitsPerPixel(srcAFormat); - const UINT32 srcBBits = GetBitsPerPixel(srcBFormat); + const UINT32 srcABits = FreeRDPGetBitsPerPixel(srcAFormat); + const UINT32 srcBBits = FreeRDPGetBitsPerPixel(srcBFormat); UINT32 diff = fabs((double)srcABits - srcBBits); UINT32 x, y; @@ -5464,18 +5464,18 @@ static BOOL CompareBitmap(const BYTE* srcA, UINT32 srcAFormat, const BYTE* srcB, for (y = 0; y < height; y++) { - const BYTE* lineA = &srcA[width * GetBytesPerPixel(srcAFormat) * y]; - const BYTE* lineB = &srcB[width * GetBytesPerPixel(srcBFormat) * y]; + const BYTE* lineA = &srcA[width * FreeRDPGetBytesPerPixel(srcAFormat) * y]; + const BYTE* lineB = &srcB[width * FreeRDPGetBytesPerPixel(srcBFormat) * y]; for (x = 0; x < width; x++) { BYTE sR, sG, sB, sA, dR, dG, dB, dA; - const BYTE* a = &lineA[x * GetBytesPerPixel(srcAFormat)]; - const BYTE* b = &lineB[x * GetBytesPerPixel(srcBFormat)]; - UINT32 colorA = ReadColor(a, srcAFormat); - UINT32 colorB = ReadColor(b, srcBFormat); - SplitColor(colorA, srcAFormat, &sR, &sG, &sB, &sA, NULL); - SplitColor(colorB, srcBFormat, &dR, &dG, &dB, &dA, NULL); + const BYTE* a = &lineA[x * FreeRDPGetBytesPerPixel(srcAFormat)]; + const BYTE* b = &lineB[x * FreeRDPGetBytesPerPixel(srcBFormat)]; + UINT32 colorA = FreeRDPReadColor(a, srcAFormat); + UINT32 colorB = FreeRDPReadColor(b, srcBFormat); + FreeRDPSplitColor(colorA, srcAFormat, &sR, &sG, &sB, &sA, NULL); + FreeRDPSplitColor(colorB, srcBFormat, &dR, &dG, &dB, &dA, NULL); if (fabs((double)sR - dR) > maxDiff) return FALSE; @@ -5502,7 +5502,7 @@ static BOOL RunTestPlanar(BITMAP_PLANAR_CONTEXT* planar, const BYTE* srcBitmap, UINT32 dstSize; BYTE* compressedBitmap = freerdp_bitmap_compress_planar(planar, srcBitmap, srcFormat, width, height, 0, NULL, &dstSize); - BYTE* decompressedBitmap = (BYTE*)calloc(height, width * GetBytesPerPixel(dstFormat)); + BYTE* decompressedBitmap = (BYTE*)calloc(height, width * FreeRDPGetBytesPerPixel(dstFormat)); printf("%s [%s] --> [%s]: ", __FUNCTION__, FreeRDPGetColorFormatName(srcFormat), FreeRDPGetColorFormatName(dstFormat)); fflush(stdout); @@ -5558,8 +5558,8 @@ static BOOL RunTestPlanarSingleColor(BITMAP_PLANAR_CONTEXT* planar, const UINT32 const UINT32 width = i; const UINT32 height = i; BOOL failed = TRUE; - const UINT32 srcSize = width * height * GetBytesPerPixel(srcFormat); - const UINT32 dstSize = width * height * GetBytesPerPixel(dstFormat); + const UINT32 srcSize = width * height * FreeRDPGetBytesPerPixel(srcFormat); + const UINT32 dstSize = width * height * FreeRDPGetBytesPerPixel(dstFormat); BYTE* compressedBitmap = NULL; BYTE* bmp = malloc(srcSize); BYTE* decompressedBitmap = (BYTE*)malloc(dstSize); @@ -5569,12 +5569,12 @@ static BOOL RunTestPlanarSingleColor(BITMAP_PLANAR_CONTEXT* planar, const UINT32 for (y = 0; y < height; y++) { - BYTE* line = &bmp[width * GetBytesPerPixel(srcFormat) * y]; + BYTE* line = &bmp[width * FreeRDPGetBytesPerPixel(srcFormat) * y]; for (x = 0; x < width; x++) { - WriteColor(line, srcFormat, color); - line += GetBytesPerPixel(srcFormat); + FreeRDPWriteColor(line, srcFormat, color); + line += FreeRDPGetBytesPerPixel(srcFormat); } } @@ -5744,9 +5744,9 @@ static BOOL FuzzPlanar(void) nDstStep = prand(sizeof(dstData)); nXDst = prand(nDstStep); nYDst = prand(sizeof(dstData) / nDstStep); - nDstWidth = prand(nDstStep / GetBytesPerPixel(DstFormat)); + nDstWidth = prand(nDstStep / FreeRDPGetBytesPerPixel(DstFormat)); nDstHeight = prand(sizeof(dstData) / nDstStep); - invalid = nXDst * GetBytesPerPixel(DstFormat) + (nYDst + nDstHeight) * nDstStep > + invalid = nXDst * FreeRDPGetBytesPerPixel(DstFormat) + (nYDst + nDstHeight) * nDstStep > sizeof(dstData); } while (invalid); printf("DstFormat=%s, nXDst=%" PRIu32 ", nYDst=%" PRIu32 ", nDstWidth=%" PRIu32 diff --git a/libfreerdp/codec/test/TestFreeRDPCodecProgressive.c b/libfreerdp/codec/test/TestFreeRDPCodecProgressive.c index 1501d7a9a..c95ee618d 100644 --- a/libfreerdp/codec/test/TestFreeRDPCodecProgressive.c +++ b/libfreerdp/codec/test/TestFreeRDPCodecProgressive.c @@ -1032,8 +1032,8 @@ static BOOL colordiff(UINT32 format, UINT32 a, UINT32 b) { BYTE ar, ag, ab, aa; BYTE br, bg, bb, ba; - SplitColor(a, format, &ar, &ag, &ab, &aa, NULL); - SplitColor(b, format, &br, &bg, &bb, &ba, NULL); + FreeRDPSplitColor(a, format, &ar, &ag, &ab, &aa, NULL); + FreeRDPSplitColor(b, format, &br, &bg, &bb, &ba, NULL); if (!diff(aa, ba) || !diff(ar, br) || !diff(ag, bg) || !diff(ab, bb)) return FALSE; return TRUE; @@ -1098,8 +1098,8 @@ static BOOL test_encode_decode(const char* path) const BYTE* po = &orig[x * 4]; const BYTE* pd = &dec[x * 4]; - const DWORD a = ReadColor(po, ColorFormat); - const DWORD b = ReadColor(pd, ColorFormat); + const DWORD a = FreeRDPReadColor(po, ColorFormat); + const DWORD b = FreeRDPReadColor(pd, ColorFormat); if (!colordiff(ColorFormat, a, b)) { printf("xxxxxxx [%u:%u] %08X != %08X\n", x, y, a, b); diff --git a/libfreerdp/codec/yuv.c b/libfreerdp/codec/yuv.c index 7cb8e8571..50969185a 100644 --- a/libfreerdp/codec/yuv.c +++ b/libfreerdp/codec/yuv.c @@ -80,7 +80,8 @@ static INLINE BOOL avc420_yuv_to_rgb(const BYTE* pYUVData[3], const UINT32 iStri const INT32 width = rect->right - rect->left; const INT32 height = rect->bottom - rect->top; - BYTE* pDstPoint = pDstData + rect->top * nDstStep + rect->left * GetBytesPerPixel(DstFormat); + BYTE* pDstPoint = + pDstData + rect->top * nDstStep + rect->left * FreeRDPGetBytesPerPixel(DstFormat); pYUVPoint[0] = pYUVData[0] + rect->top * iStride[0] + rect->left; pYUVPoint[1] = pYUVData[1] + rect->top / 2 * iStride[1] + rect->left / 2; @@ -111,7 +112,8 @@ static INLINE BOOL avc444_yuv_to_rgb(const BYTE* pYUVData[3], const UINT32 iStri const INT32 width = rect->right - rect->left; const INT32 height = rect->bottom - rect->top; - BYTE* pDstPoint = pDstData + rect->top * nDstStep + rect->left * GetBytesPerPixel(DstFormat); + BYTE* pDstPoint = + pDstData + rect->top * nDstStep + rect->left * FreeRDPGetBytesPerPixel(DstFormat); pYUVPoint[0] = pYUVData[0] + rect->top * iStride[0] + rect->left; pYUVPoint[1] = pYUVData[1] + rect->top * iStride[1] + rect->left; @@ -606,7 +608,7 @@ static void CALLBACK yuv420_encode_work_callback(PTP_CALLBACK_INSTANCE instance, roi.width = param->rect.right - param->rect.left; roi.height = param->rect.bottom - param->rect.top; src = param->pSrcData + param->nSrcStep * param->rect.top + - param->rect.left * GetBytesPerPixel(param->SrcFormat); + param->rect.left * FreeRDPGetBytesPerPixel(param->SrcFormat); pYUVData[0] = param->pYUVLumaData[0] + param->rect.top * param->iStride[0] + param->rect.left; pYUVData[1] = param->pYUVLumaData[1] + param->rect.top / 2 * param->iStride[1] + param->rect.left / 2; @@ -637,7 +639,7 @@ static void CALLBACK yuv444v1_encode_work_callback(PTP_CALLBACK_INSTANCE instanc roi.width = param->rect.right - param->rect.left; roi.height = param->rect.bottom - param->rect.top; src = param->pSrcData + param->nSrcStep * param->rect.top + - param->rect.left * GetBytesPerPixel(param->SrcFormat); + param->rect.left * FreeRDPGetBytesPerPixel(param->SrcFormat); pYUVLumaData[0] = param->pYUVLumaData[0] + param->rect.top * param->iStride[0] + param->rect.left; pYUVLumaData[1] = @@ -674,7 +676,7 @@ static void CALLBACK yuv444v2_encode_work_callback(PTP_CALLBACK_INSTANCE instanc roi.width = param->rect.right - param->rect.left; roi.height = param->rect.bottom - param->rect.top; src = param->pSrcData + param->nSrcStep * param->rect.top + - param->rect.left * GetBytesPerPixel(param->SrcFormat); + param->rect.left * FreeRDPGetBytesPerPixel(param->SrcFormat); pYUVLumaData[0] = param->pYUVLumaData[0] + param->rect.top * param->iStride[0] + param->rect.left; pYUVLumaData[1] = diff --git a/libfreerdp/core/proxy.c b/libfreerdp/core/proxy.c index 12d43bf56..ade920b08 100644 --- a/libfreerdp/core/proxy.c +++ b/libfreerdp/core/proxy.c @@ -30,6 +30,8 @@ #include /* For GetEnvironmentVariableA */ #define CRLF "\r\n" + +#include #define TAG FREERDP_TAG("core.proxy") /* SOCKS Proxy auth methods by rfc1928 */ diff --git a/libfreerdp/gdi/bitmap.c b/libfreerdp/gdi/bitmap.c index 14c5d955f..a4a808140 100644 --- a/libfreerdp/gdi/bitmap.c +++ b/libfreerdp/gdi/bitmap.c @@ -53,13 +53,14 @@ UINT32 gdi_GetPixel(HGDI_DC hdc, UINT32 nXPos, UINT32 nYPos) { HGDI_BITMAP hBmp = (HGDI_BITMAP)hdc->selectedObject; - BYTE* data = &(hBmp->data[(nYPos * hBmp->scanline) + nXPos * GetBytesPerPixel(hBmp->format)]); - return ReadColor(data, hBmp->format); + BYTE* data = + &(hBmp->data[(nYPos * hBmp->scanline) + nXPos * FreeRDPGetBytesPerPixel(hBmp->format)]); + return FreeRDPReadColor(data, hBmp->format); } BYTE* gdi_GetPointer(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y) { - UINT32 bpp = GetBytesPerPixel(hBmp->format); + UINT32 bpp = FreeRDPGetBytesPerPixel(hBmp->format); return &hBmp->data[(Y * hBmp->width * bpp) + X * bpp]; } @@ -75,8 +76,8 @@ BYTE* gdi_GetPointer(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y) static INLINE UINT32 gdi_SetPixelBmp(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y, UINT32 crColor) { - BYTE* p = &hBmp->data[(Y * hBmp->scanline) + X * GetBytesPerPixel(hBmp->format)]; - WriteColor(p, hBmp->format, crColor); + BYTE* p = &hBmp->data[(Y * hBmp->scanline) + X * FreeRDPGetBytesPerPixel(hBmp->format)]; + FreeRDPWriteColor(p, hBmp->format, crColor); return crColor; } @@ -116,7 +117,7 @@ HGDI_BITMAP gdi_CreateBitmapEx(UINT32 nWidth, UINT32 nHeight, UINT32 format, UIN if (stride > 0) hBitmap->scanline = stride; else - hBitmap->scanline = nWidth * GetBytesPerPixel(hBitmap->format); + hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format); hBitmap->width = nWidth; hBitmap->height = nHeight; @@ -146,7 +147,7 @@ HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, UINT32 nWidth, UINT32 nHeigh hBitmap->width = nWidth; hBitmap->height = nHeight; hBitmap->data = - _aligned_malloc(nWidth * nHeight * GetBytesPerPixel(hBitmap->format) * 1ULL, 16); + _aligned_malloc(nWidth * nHeight * FreeRDPGetBytesPerPixel(hBitmap->format) * 1ULL, 16); hBitmap->free = _aligned_free; if (!hBitmap->data) @@ -155,7 +156,7 @@ HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, UINT32 nWidth, UINT32 nHeigh return NULL; } - hBitmap->scanline = nWidth * GetBytesPerPixel(hBitmap->format); + hBitmap->scanline = nWidth * FreeRDPGetBytesPerPixel(hBitmap->format); return hBitmap; } @@ -284,7 +285,7 @@ static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, I return FALSE; } - colorA = ReadColor(dstp, hdcDest->format); + colorA = FreeRDPReadColor(dstp, hdcDest->format); if (useSrc) { @@ -296,7 +297,7 @@ static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, I return FALSE; } - colorC = ReadColor(srcp, hdcSrc->format); + colorC = FreeRDPReadColor(srcp, hdcSrc->format); colorC = FreeRDPConvertColor(colorC, hdcSrc->format, hdcDest->format, palette); } @@ -319,7 +320,7 @@ static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, I return FALSE; } - colorB = ReadColor(patp, hdcDest->format); + colorB = FreeRDPReadColor(patp, hdcDest->format); } break; @@ -329,7 +330,7 @@ static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, INT32 nXDest, I } dstColor = process_rop(colorC, colorA, colorB, rop, hdcDest->format); - return WriteColor(dstp, hdcDest->format, dstColor); + return FreeRDPWriteColor(dstp, hdcDest->format, dstColor); } static BOOL adjust_src_coordinates(HGDI_DC hdcSrc, INT32 nWidth, INT32 nHeight, INT32* px, diff --git a/libfreerdp/gdi/gdi.c b/libfreerdp/gdi/gdi.c index ffa238232..3562c816f 100644 --- a/libfreerdp/gdi/gdi.c +++ b/libfreerdp/gdi/gdi.c @@ -867,8 +867,8 @@ static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt) { HGDI_BITMAP hBmp; UINT32 brushFormat; - BYTE* data = - (BYTE*)_aligned_malloc(8 * 8 * GetBytesPerPixel(gdi->drawing->hdc->format), 16); + BYTE* data = (BYTE*)_aligned_malloc( + 8 * 8 * FreeRDPGetBytesPerPixel(gdi->drawing->hdc->format), 16); if (!data) { @@ -1057,7 +1057,7 @@ static BOOL gdi_surface_bits(rdpContext* context, const SURFACE_BITS_COMMAND* cm case RDP_CODEC_ID_NONE: format = gdi_get_pixel_format(cmd->bmp.bpp); - size = cmd->bmp.width * cmd->bmp.height * GetBytesPerPixel(format) * 1ULL; + size = cmd->bmp.width * cmd->bmp.height * FreeRDPGetBytesPerPixel(format) * 1ULL; if (size > cmd->bmp.bitmapDataLength) { WLog_ERR(TAG, "Short nocodec message: got %" PRIu32 " bytes, require %" PRIuz, @@ -1172,7 +1172,7 @@ static BOOL gdi_init_primary(rdpGdi* gdi, UINT32 stride, UINT32 format, BYTE* bu if (stride > 0) gdi->stride = stride; else - gdi->stride = gdi->width * GetBytesPerPixel(gdi->dstFormat); + gdi->stride = gdi->width * FreeRDPGetBytesPerPixel(gdi->dstFormat); if (!gdi->primary) goto fail_primary; diff --git a/libfreerdp/gdi/gdi.h b/libfreerdp/gdi/gdi.h index 8ca2f3518..58d3515dd 100644 --- a/libfreerdp/gdi/gdi.h +++ b/libfreerdp/gdi/gdi.h @@ -37,7 +37,7 @@ static INLINE BYTE* gdi_get_bitmap_pointer(HGDI_DC hdcBmp, INT32 x, INT32 y) if ((x >= 0) && (y >= 0) && (x < hBmp->width) && (y < hBmp->height)) { - p = hBmp->data + (y * hBmp->scanline) + (x * GetBytesPerPixel(hdcBmp->format)); + p = hBmp->data + (y * hBmp->scanline) + (x * FreeRDPGetBytesPerPixel(hdcBmp->format)); return p; } else @@ -77,7 +77,7 @@ static INLINE BYTE* gdi_get_brush_pointer(HGDI_DC hdcBrush, UINT32 x, UINT32 y) y = (y + hBmpBrush->height - (hdcBrush->brush->nYOrg % hBmpBrush->height)) % hBmpBrush->height; p = hBmpBrush->data + (y * hBmpBrush->scanline) + - (x * GetBytesPerPixel(hBmpBrush->format)); + (x * FreeRDPGetBytesPerPixel(hBmpBrush->format)); return p; } break; diff --git a/libfreerdp/gdi/gfx.c b/libfreerdp/gdi/gfx.c index a9f4b865f..b85999552 100644 --- a/libfreerdp/gdi/gfx.c +++ b/libfreerdp/gdi/gfx.c @@ -333,7 +333,7 @@ static UINT gdi_SurfaceCommand_Uncompressed(rdpGdi* gdi, RdpgfxClientContext* co if (!is_within_surface(surface, cmd)) return ERROR_INVALID_DATA; - bpp = GetBytesPerPixel(cmd->format); + bpp = FreeRDPGetBytesPerPixel(cmd->format); size = bpp * cmd->width * cmd->height * 1ULL; if (cmd->length < size) { @@ -733,7 +733,7 @@ static BOOL gdi_apply_alpha(BYTE* data, UINT32 format, UINT32 stride, RECTANGLE_ UINT32 y; UINT32 written = 0; BOOL first = TRUE; - const UINT32 bpp = GetBytesPerPixel(format); + const UINT32 bpp = FreeRDPGetBytesPerPixel(format); WINPR_ASSERT(rect); for (y = rect->top; y < rect->bottom; y++) @@ -751,10 +751,10 @@ static BOOL gdi_apply_alpha(BYTE* data, UINT32 format, UINT32 stride, RECTANGLE_ return TRUE; src = &line[x * bpp]; - color = ReadColor(src, format); - SplitColor(color, format, &r, &g, &b, NULL, NULL); + color = FreeRDPReadColor(src, format); + FreeRDPSplitColor(color, format, &r, &g, &b, NULL, NULL); color = FreeRDPGetColor(format, r, g, b, a); - WriteColor(src, format, color); + FreeRDPWriteColor(src, format, color); written++; } @@ -819,12 +819,12 @@ static UINT gdi_SurfaceCommand_Alpha(rdpGdi* gdi, RdpgfxClientContext* context, { UINT32 color; BYTE r, g, b, a; - BYTE* src = &line[x * GetBytesPerPixel(surface->format)]; + BYTE* src = &line[x * FreeRDPGetBytesPerPixel(surface->format)]; Stream_Read_UINT8(s, a); - color = ReadColor(src, surface->format); - SplitColor(color, surface->format, &r, &g, &b, NULL, NULL); + color = FreeRDPReadColor(src, surface->format); + FreeRDPSplitColor(color, surface->format, &r, &g, &b, NULL, NULL); color = FreeRDPGetColor(surface->format, r, g, b, a); - WriteColor(src, surface->format, color); + FreeRDPWriteColor(src, surface->format, color); } } } diff --git a/libfreerdp/gdi/graphics.c b/libfreerdp/gdi/graphics.c index 7001c3b31..c9a5d4694 100644 --- a/libfreerdp/gdi/graphics.c +++ b/libfreerdp/gdi/graphics.c @@ -49,14 +49,14 @@ HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, UINT32 nWidth, UINT32 nHeight, UINT32 if (!gdi) return NULL; - nDstStep = nWidth * GetBytesPerPixel(gdi->dstFormat); + nDstStep = nWidth * FreeRDPGetBytesPerPixel(gdi->dstFormat); pDstData = _aligned_malloc(nHeight * nDstStep * 1ULL, 16); if (!pDstData) return NULL; pSrcData = data; - nSrcStep = nWidth * GetBytesPerPixel(SrcFormat); + nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat); if (!freerdp_image_copy(pDstData, gdi->dstFormat, nDstStep, 0, 0, nWidth, nHeight, pSrcData, SrcFormat, nSrcStep, 0, 0, &gdi->palette, FREERDP_FLIP_NONE)) @@ -137,12 +137,12 @@ static BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap, const bitmap->compressed = FALSE; bitmap->format = gdi->dstFormat; - if ((GetBytesPerPixel(bitmap->format) == 0) || (DstWidth == 0) || (DstHeight == 0) || + if ((FreeRDPGetBytesPerPixel(bitmap->format) == 0) || (DstWidth == 0) || (DstHeight == 0) || (DstWidth > UINT32_MAX / DstHeight) || - (size > (UINT32_MAX / GetBytesPerPixel(bitmap->format)))) + (size > (UINT32_MAX / FreeRDPGetBytesPerPixel(bitmap->format)))) return FALSE; - size *= GetBytesPerPixel(bitmap->format); + size *= FreeRDPGetBytesPerPixel(bitmap->format); bitmap->length = size; bitmap->data = (BYTE*)_aligned_malloc(bitmap->length, 16); @@ -171,8 +171,8 @@ static BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap, const else { const UINT32 SrcFormat = gdi_get_pixel_format(bpp); - const size_t sbpp = GetBytesPerPixel(SrcFormat); - const size_t dbpp = GetBytesPerPixel(bitmap->format); + const size_t sbpp = FreeRDPGetBytesPerPixel(SrcFormat); + const size_t dbpp = FreeRDPGetBytesPerPixel(bitmap->format); if ((sbpp == 0) || (dbpp == 0)) return FALSE; diff --git a/libfreerdp/gdi/line.c b/libfreerdp/gdi/line.c index 8a8876ccf..3acf9d8a3 100644 --- a/libfreerdp/gdi/line.c +++ b/libfreerdp/gdi/line.c @@ -45,7 +45,7 @@ */ static BOOL gdi_rop_color(UINT32 rop, BYTE* pixelPtr, UINT32 pen, UINT32 format) { - const UINT32 srcPixel = ReadColor(pixelPtr, format); + const UINT32 srcPixel = FreeRDPReadColor(pixelPtr, format); UINT32 dstPixel; switch (rop) @@ -118,7 +118,7 @@ static BOOL gdi_rop_color(UINT32 rop, BYTE* pixelPtr, UINT32 pen, UINT32 format) return FALSE; } - return WriteColor(pixelPtr, format, dstPixel); + return FreeRDPWriteColor(pixelPtr, format, dstPixel); } BOOL gdi_LineTo(HGDI_DC hdc, UINT32 nXEnd, UINT32 nYEnd) diff --git a/libfreerdp/gdi/shape.c b/libfreerdp/gdi/shape.c index fcb468734..5c2720bd7 100644 --- a/libfreerdp/gdi/shape.c +++ b/libfreerdp/gdi/shape.c @@ -147,11 +147,11 @@ BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr) BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x, nYDest); if (dstp) - WriteColor(dstp, hdc->format, color); + FreeRDPWriteColor(dstp, hdc->format, color); } srcp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest); - formatSize = GetBytesPerPixel(hdc->format); + formatSize = FreeRDPGetBytesPerPixel(hdc->format); for (y = 1; y < nHeight; y++) { @@ -164,7 +164,7 @@ BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr) case GDI_BS_HATCHED: case GDI_BS_PATTERN: monochrome = (hbr->pattern->format == PIXEL_FORMAT_MONO); - formatSize = GetBytesPerPixel(hbr->pattern->format); + formatSize = FreeRDPGetBytesPerPixel(hbr->pattern->format); for (y = 0; y < nHeight; y++) { @@ -188,13 +188,13 @@ BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr) } else { - dstColor = ReadColor(patp, hbr->pattern->format); + dstColor = FreeRDPReadColor(patp, hbr->pattern->format); dstColor = FreeRDPConvertColor(dstColor, hbr->pattern->format, hdc->format, NULL); } if (dstp) - WriteColor(dstp, hdc->format, dstColor); + FreeRDPWriteColor(dstp, hdc->format, dstColor); } } @@ -255,10 +255,10 @@ BOOL gdi_Rectangle(HGDI_DC hdc, INT32 nXDst, INT32 nYDst, INT32 nWidth, INT32 nH BYTE* dstRight = gdi_get_bitmap_pointer(hdc, nXDst + nWidth - 1, nYDst + y); if (dstLeft) - WriteColor(dstLeft, hdc->format, color); + FreeRDPWriteColor(dstLeft, hdc->format, color); if (dstRight) - WriteColor(dstRight, hdc->format, color); + FreeRDPWriteColor(dstRight, hdc->format, color); } for (x = 0; x < nWidth; x++) @@ -267,10 +267,10 @@ BOOL gdi_Rectangle(HGDI_DC hdc, INT32 nXDst, INT32 nYDst, INT32 nWidth, INT32 nH BYTE* dstBottom = gdi_get_bitmap_pointer(hdc, nXDst + x, nYDst + nHeight - 1); if (dstTop) - WriteColor(dstTop, hdc->format, color); + FreeRDPWriteColor(dstTop, hdc->format, color); if (dstBottom) - WriteColor(dstBottom, hdc->format, color); + FreeRDPWriteColor(dstBottom, hdc->format, color); } return FALSE; diff --git a/libfreerdp/gdi/test/TestGdiCreate.c b/libfreerdp/gdi/test/TestGdiCreate.c index eab83877c..b933d28ae 100644 --- a/libfreerdp/gdi/test/TestGdiCreate.c +++ b/libfreerdp/gdi/test/TestGdiCreate.c @@ -355,7 +355,7 @@ static BOOL test_gdi_GetPixel(void) } gdi_SelectObject(hdc, (HGDIOBJECT)hBitmap); - bpp = GetBytesPerPixel(hBitmap->format); + bpp = FreeRDPGetBytesPerPixel(hBitmap->format); for (i = 0; i < height; i++) { @@ -364,7 +364,8 @@ static BOOL test_gdi_GetPixel(void) UINT32 pixel; const UINT32 color = FreeRDPGetColor(hBitmap->format, rand(), rand(), rand(), rand()); - WriteColor(&hBitmap->data[i * hBitmap->scanline + j * bpp], hBitmap->format, color); + FreeRDPWriteColor(&hBitmap->data[i * hBitmap->scanline + j * bpp], hBitmap->format, + color); pixel = gdi_GetPixel(hdc, j, i); if (pixel != color) @@ -407,7 +408,7 @@ static BOOL test_gdi_SetPixel(void) hdc->format = colorFormatList[x]; hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height); gdi_SelectObject(hdc, (HGDIOBJECT)hBitmap); - bpp = GetBytesPerPixel(hBitmap->format); + bpp = FreeRDPGetBytesPerPixel(hBitmap->format); for (i = 0; i < height; i++) { @@ -417,7 +418,8 @@ static BOOL test_gdi_SetPixel(void) const UINT32 color = FreeRDPGetColor(hBitmap->format, rand(), rand(), rand(), rand()); gdi_SetPixel(hdc, j, i, color); - pixel = ReadColor(&hBitmap->data[i * hBitmap->scanline + j * bpp], hBitmap->format); + pixel = FreeRDPReadColor(&hBitmap->data[i * hBitmap->scanline + j * bpp], + hBitmap->format); if (pixel != color) { diff --git a/libfreerdp/gdi/test/TestGdiRect.c b/libfreerdp/gdi/test/TestGdiRect.c index b02e092c3..44f4dd5f1 100644 --- a/libfreerdp/gdi/test/TestGdiRect.c +++ b/libfreerdp/gdi/test/TestGdiRect.c @@ -97,7 +97,7 @@ static int test_gdi_FillRect(void) } hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height); - ZeroMemory(hBitmap->data, width * height * GetBytesPerPixel(hdc->format)); + ZeroMemory(hBitmap->data, width * height * FreeRDPGetBytesPerPixel(hdc->format)); gdi_SelectObject(hdc, (HGDIOBJECT)hBitmap); color = FreeRDPGetColor(PIXEL_FORMAT_ARGB32, 0xAA, 0xBB, 0xCC, 0xFF); hBrush = gdi_CreateSolidBrush(color); diff --git a/libfreerdp/gdi/test/helpers.c b/libfreerdp/gdi/test/helpers.c index 2c5d48dc6..0dbda3ae0 100644 --- a/libfreerdp/gdi/test/helpers.c +++ b/libfreerdp/gdi/test/helpers.c @@ -28,7 +28,7 @@ HGDI_BITMAP test_convert_to_bitmap(const BYTE* src, UINT32 SrcFormat, UINT32 Src BYTE* data; if (DstStride == 0) - DstStride = nWidth * GetBytesPerPixel(DstFormat); + DstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat); data = _aligned_malloc(DstStride * nHeight, 16); @@ -85,7 +85,7 @@ static void test_dump_data(unsigned char* p, int len, int width, const char* nam void test_dump_bitmap(HGDI_BITMAP hBmp, const char* name) { - UINT32 stride = hBmp->width * GetBytesPerPixel(hBmp->format); + UINT32 stride = hBmp->width * FreeRDPGetBytesPerPixel(hBmp->format); test_dump_data(hBmp->data, hBmp->height * stride, stride, name); } @@ -102,10 +102,10 @@ static BOOL CompareBitmaps(HGDI_BITMAP hBmp1, HGDI_BITMAP hBmp2, const gdiPalett { for (x = 0; x < minw; x++) { - colorA = ReadColor(p1, hBmp1->format); - colorB = ReadColor(p2, hBmp2->format); - p1 += GetBytesPerPixel(hBmp1->format); - p2 += GetBytesPerPixel(hBmp2->format); + colorA = FreeRDPReadColor(p1, hBmp1->format); + colorB = FreeRDPReadColor(p2, hBmp2->format); + p1 += FreeRDPGetBytesPerPixel(hBmp1->format); + p2 += FreeRDPGetBytesPerPixel(hBmp2->format); if (hBmp1->format != hBmp2->format) colorB = FreeRDPConvertColor(colorB, hBmp2->format, hBmp1->format, palette); diff --git a/libfreerdp/gdi/video.c b/libfreerdp/gdi/video.c index 3384622e5..451d942a1 100644 --- a/libfreerdp/gdi/video.c +++ b/libfreerdp/gdi/video.c @@ -193,7 +193,7 @@ VideoSurface* VideoClient_CreateCommonContext(size_t size, UINT32 x, UINT32 y, U ret->alignedWidth = ret->w + 32 - ret->w % 16; ret->alignedHeight = ret->h + 32 - ret->h % 16; - ret->scanline = ret->alignedWidth * GetBytesPerPixel(ret->format); + ret->scanline = ret->alignedWidth * FreeRDPGetBytesPerPixel(ret->format); ret->data = _aligned_malloc(ret->scanline * ret->alignedHeight * 1ULL, 64); if (!ret->data) goto fail; diff --git a/libfreerdp/primitives/prim_YCoCg.c b/libfreerdp/primitives/prim_YCoCg.c index 0455586b3..2e627491d 100644 --- a/libfreerdp/primitives/prim_YCoCg.c +++ b/libfreerdp/primitives/prim_YCoCg.c @@ -38,7 +38,7 @@ static pstatus_t general_YCoCgToRGB_8u_AC4R(const BYTE* pSrc, INT32 srcStep, BYT UINT32 height, UINT8 shift, BOOL withAlpha) { UINT32 x, y; - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, TRUE); for (y = 0; y < height; y++) diff --git a/libfreerdp/primitives/prim_YCoCg_opt.c b/libfreerdp/primitives/prim_YCoCg_opt.c index aa39cf793..e703f74d2 100644 --- a/libfreerdp/primitives/prim_YCoCg_opt.c +++ b/libfreerdp/primitives/prim_YCoCg_opt.c @@ -431,7 +431,7 @@ static pstatus_t neon_YCoCgToRGB_8u_X(const BYTE* pSrc, INT32 srcStep, BYTE* pDs UINT32 y; BYTE* dptr = pDst; const BYTE* sptr = pSrc; - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); const int8_t cll = shift - 1; /* -1 builds in the /2's */ const UINT32 srcPad = srcStep - (width * 4); const UINT32 dstPad = dstStep - (width * formatSize); diff --git a/libfreerdp/primitives/prim_YUV.c b/libfreerdp/primitives/prim_YUV.c index fdabf9890..789bf2b83 100644 --- a/libfreerdp/primitives/prim_YUV.c +++ b/libfreerdp/primitives/prim_YUV.c @@ -382,7 +382,7 @@ static pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* const pSrc[3] { UINT32 x, y; UINT32 nWidth, nHeight; - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE); nWidth = roi->width; nHeight = roi->height; @@ -416,7 +416,7 @@ static pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* const pSrc[3], { UINT32 x, y; UINT32 nWidth, nHeight; - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); nWidth = roi->width; nHeight = roi->height; @@ -478,7 +478,7 @@ static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* const pSrc[3], const BYTE* pRGB = pDst; UINT32 nWidth, nHeight; UINT32 lastRow, lastCol; - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE); pY = pSrc[0]; pU = pSrc[1]; @@ -610,7 +610,7 @@ static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* pSrc, UINT32 SrcForma const UINT32 srcStep, BYTE* pDst[3], UINT32 dstStep[3], const prim_size_t* roi) { - const UINT32 bpp = GetBytesPerPixel(SrcFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat); UINT32 x, y; UINT32 nWidth, nHeight; nWidth = roi->width; @@ -626,8 +626,8 @@ static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* pSrc, UINT32 SrcForma for (x = 0; x < nWidth; x++) { BYTE B, G, R; - const UINT32 color = ReadColor(&pRGB[x * bpp], SrcFormat); - SplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL); + const UINT32 color = FreeRDPReadColor(&pRGB[x * bpp], SrcFormat); + FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL); pY[x] = RGB2Y(R, G, B); pU[x] = RGB2U(R, G, B); pV[x] = RGB2V(R, G, B); @@ -773,7 +773,7 @@ static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* pSrc, UINT32 srcForm BYTE* pDst[3], const UINT32 dstStep[3], const prim_size_t* roi) { - const UINT32 bpp = GetBytesPerPixel(srcFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat); UINT32 x, y, i; size_t x1 = 0, x2 = bpp, x3 = srcStep, x4 = srcStep + bpp; size_t y1 = 0, y2 = 1, y3 = dstStep[0], y4 = dstStep[0] + 1; @@ -793,8 +793,8 @@ static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* pSrc, UINT32 srcForm INT32 Ra, Ga, Ba; UINT32 color; /* row 1, pixel 1 */ - color = ReadColor(src + x1, srcFormat); - SplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); + color = FreeRDPReadColor(src + x1, srcFormat); + FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); Ra = R; Ga = G; Ba = B; @@ -803,8 +803,8 @@ static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* pSrc, UINT32 srcForm if (x < max_x) { /* row 1, pixel 2 */ - color = ReadColor(src + x2, srcFormat); - SplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); + color = FreeRDPReadColor(src + x2, srcFormat); + FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); Ra += R; Ga += G; Ba += B; @@ -814,8 +814,8 @@ static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* pSrc, UINT32 srcForm if (y < max_y) { /* row 2, pixel 1 */ - color = ReadColor(src + x3, srcFormat); - SplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); + color = FreeRDPReadColor(src + x3, srcFormat); + FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); Ra += R; Ga += G; Ba += B; @@ -824,8 +824,8 @@ static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* pSrc, UINT32 srcForm if (x < max_x) { /* row 2, pixel 2 */ - color = ReadColor(src + x4, srcFormat); - SplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); + color = FreeRDPReadColor(src + x4, srcFormat); + FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL); Ra += R; Ga += G; Ba += B; @@ -1132,7 +1132,7 @@ static INLINE void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(const BYTE* srcEven, co BYTE* b1Odd, BYTE* b2, BYTE* b3, BYTE* b4, BYTE* b5, BYTE* b6, BYTE* b7, UINT32 width) { - const UINT32 bpp = GetBytesPerPixel(srcFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat); UINT32 x; for (x = 0; x < width; x += 2) @@ -1143,9 +1143,9 @@ static INLINE void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(const BYTE* srcEven, co /* Read 4 pixels, 2 from even, 2 from odd lines */ { BYTE r, g, b; - const UINT32 color = ReadColor(srcEven, srcFormat); + const UINT32 color = FreeRDPReadColor(srcEven, srcFormat); srcEven += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b); U1e = U2e = U1o = U2o = RGB2U(r, g, b); V1e = V2e = V1o = V2o = RGB2V(r, g, b); @@ -1154,9 +1154,9 @@ static INLINE void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(const BYTE* srcEven, co if (!lastX) { BYTE r, g, b; - const UINT32 color = ReadColor(srcEven, srcFormat); + const UINT32 color = FreeRDPReadColor(srcEven, srcFormat); srcEven += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Y2e = RGB2Y(r, g, b); U2e = RGB2U(r, g, b); V2e = RGB2V(r, g, b); @@ -1165,9 +1165,9 @@ static INLINE void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(const BYTE* srcEven, co if (b1Odd) { BYTE r, g, b; - const UINT32 color = ReadColor(srcOdd, srcFormat); + const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat); srcOdd += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Y1o = Y2o = RGB2Y(r, g, b); U1o = U2o = RGB2U(r, g, b); V1o = V2o = RGB2V(r, g, b); @@ -1176,9 +1176,9 @@ static INLINE void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(const BYTE* srcEven, co if (b1Odd && !lastX) { BYTE r, g, b; - const UINT32 color = ReadColor(srcOdd, srcFormat); + const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat); srcOdd += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Y2o = RGB2Y(r, g, b); U2o = RGB2U(r, g, b); V2o = RGB2V(r, g, b); @@ -1359,7 +1359,7 @@ static INLINE void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW( BYTE* vChromaDst1, BYTE* vChromaDst2, UINT32 width) { UINT32 x; - const UINT32 bpp = GetBytesPerPixel(srcFormat); + const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat); for (x = 0; x < width; x += 2) { @@ -1369,9 +1369,9 @@ static INLINE void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW( BYTE Yd, Ud, Vd; { BYTE b, g, r; - const UINT32 color = ReadColor(srcEven, srcFormat); + const UINT32 color = FreeRDPReadColor(srcEven, srcFormat); srcEven += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Ya = RGB2Y(r, g, b); Ua = RGB2U(r, g, b); Va = RGB2V(r, g, b); @@ -1380,9 +1380,9 @@ static INLINE void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW( if (x < width - 1) { BYTE b, g, r; - const UINT32 color = ReadColor(srcEven, srcFormat); + const UINT32 color = FreeRDPReadColor(srcEven, srcFormat); srcEven += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Yb = RGB2Y(r, g, b); Ub = RGB2U(r, g, b); Vb = RGB2V(r, g, b); @@ -1397,9 +1397,9 @@ static INLINE void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW( if (srcOdd) { BYTE b, g, r; - const UINT32 color = ReadColor(srcOdd, srcFormat); + const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat); srcOdd += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Yc = RGB2Y(r, g, b); Uc = RGB2U(r, g, b); Vc = RGB2V(r, g, b); @@ -1414,9 +1414,9 @@ static INLINE void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW( if (srcOdd && (x < width - 1)) { BYTE b, g, r; - const UINT32 color = ReadColor(srcOdd, srcFormat); + const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat); srcOdd += bpp; - SplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); + FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL); Yd = RGB2Y(r, g, b); Ud = RGB2U(r, g, b); Vd = RGB2V(r, g, b); diff --git a/libfreerdp/primitives/prim_colors.c b/libfreerdp/primitives/prim_colors.c index ca3c676f5..d0dbf22fe 100644 --- a/libfreerdp/primitives/prim_colors.c +++ b/libfreerdp/primitives/prim_colors.c @@ -40,7 +40,7 @@ static pstatus_t general_yCbCrToRGB_16s8u_P3AC4R_BGRX(const INT16* const pSrc[3] const INT16* pCr = pSrc[2]; const size_t srcPad = (srcStep - (roi->width * 2)) / 2; const size_t dstPad = (dstStep - (roi->width * 4)); - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); for (y = 0; y < roi->height; y++) { @@ -82,7 +82,7 @@ static pstatus_t general_yCbCrToRGB_16s8u_P3AC4R_general(const INT16* const pSrc const size_t srcPad = (srcStep - (roi->width * 2)) / 2; const size_t dstPad = (dstStep - (roi->width * 4)); const fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE); - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); for (y = 0; y < roi->height; y++) { @@ -448,7 +448,7 @@ general_RGBToRGB_16s8u_P3AC4R_general(const INT16* const pSrc[3], /* 16-bit R,G, UINT32 y; const DWORD srcAdd = srcStep / sizeof(INT16); fkt_writeScanline writeScanline = getScanlineWriteFunction(DstFormat); - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); for (y = 0; y < roi->height; ++y) { @@ -475,7 +475,7 @@ general_RGBToRGB_16s8u_P3AC4R_BGRX(const INT16* const pSrc[3], /* 16-bit R,G, an const INT16* b = pSrc[2]; UINT32 y; const DWORD srcAdd = srcStep / sizeof(INT16); - const DWORD formatSize = GetBytesPerPixel(DstFormat); + const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat); for (y = 0; y < roi->height; ++y) { diff --git a/libfreerdp/primitives/prim_internal.h b/libfreerdp/primitives/prim_internal.h index ee1951d2d..d0a7ec3d0 100644 --- a/libfreerdp/primitives/prim_internal.h +++ b/libfreerdp/primitives/prim_internal.h @@ -159,7 +159,7 @@ static INLINE BYTE* writePixelGenericAlpha(BYTE* dst, DWORD formatSize, UINT32 f BYTE G, BYTE B, BYTE A) { UINT32 color = FreeRDPGetColor(format, R, G, B, A); - WriteColor(dst, format, color); + FreeRDPWriteColor(dst, format, color); return dst + formatSize; } @@ -167,7 +167,7 @@ static INLINE BYTE* writePixelGeneric(BYTE* dst, DWORD formatSize, UINT32 format BYTE B, BYTE A) { UINT32 color = FreeRDPGetColor(format, R, G, B, A); - WriteColorIgnoreAlpha(dst, format, color); + FreeRDPWriteColorIgnoreAlpha(dst, format, color); return dst + formatSize; } diff --git a/libfreerdp/primitives/primitives.c b/libfreerdp/primitives/primitives.c index 941a2600b..b843c1ace 100644 --- a/libfreerdp/primitives/primitives.c +++ b/libfreerdp/primitives/primitives.c @@ -28,6 +28,7 @@ #include "prim_internal.h" +#include #define TAG FREERDP_TAG("primitives") /* hints to know which kind of primitives to use */ diff --git a/libfreerdp/primitives/test/TestPrimitivesColors.c b/libfreerdp/primitives/test/TestPrimitivesColors.c index 285ecb968..de75c3a58 100644 --- a/libfreerdp/primitives/test/TestPrimitivesColors.c +++ b/libfreerdp/primitives/test/TestPrimitivesColors.c @@ -86,8 +86,8 @@ static BOOL test_RGBToRGB_16s8u_P3AC4R_func(prim_size_t roi, DWORD DstFormat) { for (i = 0; i < roi.width * roi.height; ++i) { - const UINT32 o1 = ReadColor(out1 + 4 * i, DstFormat); - const UINT32 o2 = ReadColor(out2 + 4 * i, DstFormat); + const UINT32 o1 = FreeRDPReadColor(out1 + 4 * i, DstFormat); + const UINT32 o2 = FreeRDPReadColor(out2 + 4 * i, DstFormat); if (o1 != o2) { diff --git a/libfreerdp/primitives/test/TestPrimitivesYCbCr.c b/libfreerdp/primitives/test/TestPrimitivesYCbCr.c index d48bd74a2..a6173b0d6 100644 --- a/libfreerdp/primitives/test/TestPrimitivesYCbCr.c +++ b/libfreerdp/primitives/test/TestPrimitivesYCbCr.c @@ -1536,8 +1536,8 @@ static int test_bmp_cmp_dump(const BYTE* actual, const BYTE* expected, int size, BYTE R, G, B; BYTE eR, eG, eB; - SplitColor(pixel, PIXEL_FORMAT_XRGB32, &R, &G, &B, NULL, NULL); - SplitColor(ePixel, PIXEL_FORMAT_XRGB32, &eR, &eG, &eB, NULL, NULL); + FreeRDPSplitColor(pixel, PIXEL_FORMAT_XRGB32, &R, &G, &B, NULL, NULL); + FreeRDPSplitColor(ePixel, PIXEL_FORMAT_XRGB32, &eR, &eG, &eB, NULL, NULL); error[0] = (R > eR) ? R - eR : eR - R; error[1] = (G > eG) ? G - eG : eG - G; error[2] = (B > eB) ? B - eB : eB - B; @@ -1571,7 +1571,7 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s int margin = 1; INT16* pYCbCr[3] = { NULL, NULL, NULL }; const UINT32 srcStride = roi.width * 2; - const UINT32 dstStride = roi.width * GetBytesPerPixel(format); + const UINT32 dstStride = roi.width * FreeRDPGetBytesPerPixel(format); const UINT32 srcSize = srcStride * roi.height; const UINT32 dstSize = dstStride * roi.height; PROFILER_DEFINE(prof) diff --git a/libfreerdp/primitives/test/TestPrimitivesYCoCg.c b/libfreerdp/primitives/test/TestPrimitivesYCoCg.c index 4b13159b0..abd9ff5cd 100644 --- a/libfreerdp/primitives/test/TestPrimitivesYCoCg.c +++ b/libfreerdp/primitives/test/TestPrimitivesYCoCg.c @@ -48,7 +48,7 @@ static BOOL test_YCoCgRToRGB_8u_AC4R_func(UINT32 width, UINT32 height) for (x = 0; x < sizeof(formats) / sizeof(formats[0]); x++) { const UINT32 format = formats[x]; - const UINT32 dstStride = width * GetBytesPerPixel(format); + const UINT32 dstStride = width * FreeRDPGetBytesPerPixel(format); const char* formatName = FreeRDPGetColorFormatName(format); PROFILER_CREATE(genericProf, "YCoCgRToRGB_8u_AC4R-GENERIC") PROFILER_CREATE(optProf, "YCoCgRToRGB_8u_AC4R-OPT") @@ -72,8 +72,8 @@ static BOOL test_YCoCgRToRGB_8u_AC4R_func(UINT32 width, UINT32 height) { for (i = 0; i < width * height; ++i) { - const UINT32 c = ReadColor(out_c + 4 * i, format); - const UINT32 sse = ReadColor(out_sse + 4 * i, format); + const UINT32 c = FreeRDPReadColor(out_c + 4 * i, format); + const UINT32 sse = FreeRDPReadColor(out_sse + 4 * i, format); if (c != sse) { diff --git a/libfreerdp/primitives/test/TestPrimitivesYUV.c b/libfreerdp/primitives/test/TestPrimitivesYUV.c index 92012ac5d..e121d9d3c 100644 --- a/libfreerdp/primitives/test/TestPrimitivesYUV.c +++ b/libfreerdp/primitives/test/TestPrimitivesYUV.c @@ -38,9 +38,9 @@ static BOOL similar(const BYTE* src, const BYTE* dst, size_t size) static BOOL similarRGB(const BYTE* src, const BYTE* dst, size_t size, UINT32 format, BOOL use444) { size_t x; - const UINT32 bpp = GetBytesPerPixel(format); + const UINT32 bpp = FreeRDPGetBytesPerPixel(format); BYTE fill = PADDING_FILL_VALUE; - if (!ColorHasAlpha(format)) + if (!FreeRDPColorHasAlpha(format)) fill = 0xFF; for (x = 0; x < size; x++) @@ -49,12 +49,12 @@ static BOOL similarRGB(const BYTE* src, const BYTE* dst, size_t size, UINT32 for UINT32 sColor, dColor; BYTE sR, sG, sB, sA; BYTE dR, dG, dB, dA; - sColor = ReadColor(src, format); - dColor = ReadColor(dst, format); + sColor = FreeRDPReadColor(src, format); + dColor = FreeRDPReadColor(dst, format); src += bpp; dst += bpp; - SplitColor(sColor, format, &sR, &sG, &sB, &sA, NULL); - SplitColor(dColor, format, &dR, &dG, &dB, &dA, NULL); + FreeRDPSplitColor(sColor, format, &sR, &sG, &sB, &sA, NULL); + FreeRDPSplitColor(dColor, format, &dR, &dG, &dB, &dA, NULL); if ((abs(sR - dR) > maxDiff) || (abs(sG - dG) > maxDiff) || (abs(sB - dB) > maxDiff)) { diff --git a/server/Windows/wf_interface.c b/server/Windows/wf_interface.c index 8fffa8810..37923bf00 100644 --- a/server/Windows/wf_interface.c +++ b/server/Windows/wf_interface.c @@ -38,6 +38,7 @@ #include "wf_interface.h" +#include #define TAG SERVER_TAG("windows") #define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server" diff --git a/server/Windows/wf_peer.c b/server/Windows/wf_peer.c index 8a454c83a..17d0db96c 100644 --- a/server/Windows/wf_peer.c +++ b/server/Windows/wf_peer.c @@ -38,6 +38,7 @@ #include "wf_peer.h" #include +#include #define TAG SERVER_TAG("windows") #define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING diff --git a/server/Windows/wf_rdpsnd.c b/server/Windows/wf_rdpsnd.c index 936e8f49e..7d2c2e260 100644 --- a/server/Windows/wf_rdpsnd.c +++ b/server/Windows/wf_rdpsnd.c @@ -39,6 +39,7 @@ #endif +#include #define TAG SERVER_TAG("windows") static void wf_peer_rdpsnd_activated(RdpsndServerContext* context) diff --git a/server/Windows/wf_update.c b/server/Windows/wf_update.c index 7eab50381..a301b582f 100644 --- a/server/Windows/wf_update.c +++ b/server/Windows/wf_update.c @@ -33,6 +33,7 @@ #include "wf_update.h" +#include #define TAG SERVER_TAG("windows") DWORD WINAPI wf_update_thread(LPVOID lpParam) diff --git a/server/Windows/wf_wasapi.c b/server/Windows/wf_wasapi.c index 9a1b70283..753934606 100644 --- a/server/Windows/wf_wasapi.c +++ b/server/Windows/wf_wasapi.c @@ -7,6 +7,7 @@ #include #include +#include #define TAG SERVER_TAG("windows") //#define REFTIMES_PER_SEC 10000000 diff --git a/server/shadow/Mac/mac_shadow.c b/server/shadow/Mac/mac_shadow.c index eccbdefc7..c55a162f9 100644 --- a/server/shadow/Mac/mac_shadow.c +++ b/server/shadow/Mac/mac_shadow.c @@ -327,8 +327,8 @@ static int freerdp_image_copy_from_retina(BYTE* pDstData, DWORD DstFormat, int n if (nSrcStep < 0) nSrcStep = srcBytesPerPixel * nWidth; - dstBitsPerPixel = GetBitsPerPixel(DstFormat); - dstBytesPerPixel = GetBytesPerPixel(DstFormat); + dstBitsPerPixel = FreeRDPGetBitsPerPixel(DstFormat); + dstBytesPerPixel = FreeRDPGetBytesPerPixel(DstFormat); if (nDstStep < 0) nDstStep = dstBytesPerPixel * nWidth; diff --git a/server/shadow/shadow.c b/server/shadow/shadow.c index a1b24a3c8..c11ae1e59 100644 --- a/server/shadow/shadow.c +++ b/server/shadow/shadow.c @@ -27,6 +27,8 @@ #include #include + +#include #define TAG SERVER_TAG("shadow") int main(int argc, char** argv) diff --git a/server/shadow/shadow_client.c b/server/shadow/shadow_client.c index 495cd2672..08b81eaa9 100644 --- a/server/shadow/shadow_client.c +++ b/server/shadow/shadow_client.c @@ -1229,7 +1229,8 @@ static BOOL shadow_client_send_surface_gfx(rdpShadowClient* client, const BYTE* BOOL rc; const UINT32 w = cmd.right - cmd.left; const UINT32 h = cmd.bottom - cmd.top; - const BYTE* src = &pSrcData[cmd.top * nSrcStep + cmd.left * GetBytesPerPixel(SrcFormat)]; + const BYTE* src = + &pSrcData[cmd.top * nSrcStep + cmd.left * FreeRDPGetBytesPerPixel(SrcFormat)]; if (shadow_encoder_prepare(encoder, FREERDP_CODEC_PLANAR) < 0) { WLog_ERR(TAG, "Failed to prepare encoder FREERDP_CODEC_PLANAR"); diff --git a/server/shadow/shadow_encoder.c b/server/shadow/shadow_encoder.c index 851297a73..37f9c658c 100644 --- a/server/shadow/shadow_encoder.c +++ b/server/shadow/shadow_encoder.c @@ -24,6 +24,7 @@ #include "shadow_encoder.h" +#include #define TAG CLIENT_TAG("shadow") UINT32 shadow_encoder_preferred_fps(rdpShadowEncoder* encoder)