mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored color.h

Browse Source 
* Remove implementations from header
* Rename functions to be FreeRDP specific
* Add deprecation define for old names
* Fixed missing includes
This commit is contained in:
akallabeth 2022-04-28 05:43:31 +02:00 committed by akallabeth
parent d3e1810473
commit fb90ac280a
53 changed files with 985 additions and 922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/Mac/MRDPView.m
View File

@ -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)

2
client/Windows/wf_gdi.c
View File

@ -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;

2
client/Windows/wf_graphics.c
View File

@ -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);

1
client/X11/xf_disp.c
View File

@ -34,6 +34,7 @@
#include "xf_disp.h"
#include "xf_monitor.h"
#include <freerdp/log.h>
#define TAG CLIENT_TAG("x11disp")
#define RESIZE_MIN_DELAY 200 /* minimum delay in ms between two resizes */

1
client/X11/xf_floatbar.c
View File

@ -30,6 +30,7 @@
#include "resource/minimize.xbm"
#include "resource/restore.xbm"
#include <freerdp/log.h>
#define TAG CLIENT_TAG("x11")
#define FLOATBAR_HEIGHT 26

2
client/X11/xf_gdi.c
View File

@ -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,

4
client/X11/xf_gfx.c
View File

@ -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;

8
client/X11/xf_graphics.c
View File

@ -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;

3
client/X11/xf_rail.c
View File

@ -32,6 +32,7 @@
#include "xf_window.h"
#include "xf_rail.h"
#include <freerdp/log.h>
#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;
}

1
client/X11/xf_video.c
View File

@ -24,6 +24,7 @@
#include "xf_video.h"
#include <freerdp/log.h>
#define TAG CLIENT_TAG("video")
typedef struct

2
client/iOS/FreeRDP/ios_freerdp_ui.m
View File

@ -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);

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

@ -23,9 +23,6 @@
#define FREERDP_CODEC_COLOR_H
#include <freerdp/api.h>
#include <winpr/wlog.h>
#include <freerdp/log.h>
#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

63
libfreerdp/codec/clear.c
View File

@ -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;

742
libfreerdp/codec/color.c
View File

@ -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;
}
}

2
libfreerdp/codec/nsc.c
View File

@ -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)
{

6
libfreerdp/codec/nsc_encode.c
View File

@ -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;

30
libfreerdp/codec/planar.c
View File

@ -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,9 +960,9 @@ 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],
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,9 +979,9 @@ 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],
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++;
}

6
libfreerdp/codec/rfx.c
View File

@ -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++)

14
libfreerdp/codec/test/TestFreeRDPCodecInterleaved.c
View File

@ -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;
}

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

@ -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

8
libfreerdp/codec/test/TestFreeRDPCodecProgressive.c
View File

@ -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);

12
libfreerdp/codec/yuv.c
View File

@ -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] =

2
libfreerdp/core/proxy.c
View File

@ -30,6 +30,8 @@
#include <winpr/environment.h> /* For GetEnvironmentVariableA */
#define CRLF "\r\n"
#include <freerdp/log.h>
#define TAG FREERDP_TAG("core.proxy")
/* SOCKS Proxy auth methods by rfc1928 */

25
libfreerdp/gdi/bitmap.c
View File

@ -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,

8
libfreerdp/gdi/gdi.c
View File

@ -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;

4
libfreerdp/gdi/gdi.h
View File

@ -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;

18
libfreerdp/gdi/gfx.c
View File

@ -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);
}
}
}

14
libfreerdp/gdi/graphics.c
View File

@ -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;

4
libfreerdp/gdi/line.c
View File

@ -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)

18
libfreerdp/gdi/shape.c
View File

@ -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;

10
libfreerdp/gdi/test/TestGdiCreate.c
View File

@ -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)
{

2
libfreerdp/gdi/test/TestGdiRect.c
View File

@ -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);

12
libfreerdp/gdi/test/helpers.c
View File

@ -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);

2
libfreerdp/gdi/video.c
View File

@ -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;

2
libfreerdp/primitives/prim_YCoCg.c
View File

@ -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++)

2
libfreerdp/primitives/prim_YCoCg_opt.c
View File

@ -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);

66
libfreerdp/primitives/prim_YUV.c
View File

@ -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);

8
libfreerdp/primitives/prim_colors.c
View File

@ -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)
{

4
libfreerdp/primitives/prim_internal.h
View File

@ -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;
}

1
libfreerdp/primitives/primitives.c
View File

@ -28,6 +28,7 @@
#include "prim_internal.h"
#include <freerdp/log.h>
#define TAG FREERDP_TAG("primitives")
/* hints to know which kind of primitives to use */

4
libfreerdp/primitives/test/TestPrimitivesColors.c
View File

@ -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)
{

6
libfreerdp/primitives/test/TestPrimitivesYCbCr.c
View File

@ -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)

6
libfreerdp/primitives/test/TestPrimitivesYCoCg.c
View File

@ -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)
{

12
libfreerdp/primitives/test/TestPrimitivesYUV.c
View File

@ -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))
{

1
server/Windows/wf_interface.c
View File

@ -38,6 +38,7 @@
#include "wf_interface.h"
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"

1
server/Windows/wf_peer.c
View File

@ -38,6 +38,7 @@
#include "wf_peer.h"
#include <freerdp/peer.h>
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING

1
server/Windows/wf_rdpsnd.c
View File

@ -39,6 +39,7 @@
#endif
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
static void wf_peer_rdpsnd_activated(RdpsndServerContext* context)

1
server/Windows/wf_update.c
View File

@ -33,6 +33,7 @@
#include "wf_update.h"
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
DWORD WINAPI wf_update_thread(LPVOID lpParam)

1
server/Windows/wf_wasapi.c
View File

@ -7,6 +7,7 @@
#include <functiondiscoverykeys_devpkey.h>
#include <audioclient.h>
#include <freerdp/log.h>
#define TAG SERVER_TAG("windows")
//#define REFTIMES_PER_SEC 10000000

4
server/shadow/Mac/mac_shadow.c
View File

@ -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;

2
server/shadow/shadow.c
View File

@ -27,6 +27,8 @@
#include <winpr/tools/makecert.h>
#include <freerdp/server/shadow.h>
#include <freerdp/log.h>
#define TAG SERVER_TAG("shadow")
int main(int argc, char** argv)

3
server/shadow/shadow_client.c
View File

@ -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");

1
server/shadow/shadow_encoder.c
View File

@ -24,6 +24,7 @@
#include "shadow_encoder.h"
#include <freerdp/log.h>
#define TAG CLIENT_TAG("shadow")
UINT32 shadow_encoder_preferred_fps(rdpShadowEncoder* encoder)