Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/freeRDPCore/src/main/res/drawable/button_background.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:state_pressed="true">
+        <shape>
+            <solid android:color="#99D4FF" />
+            <stroke android:width="1dp" android:color="#A7A7A7" />
+            <corners android:radius="3dp" />
+            <padding android:bottom="3dp" android:left="3dp" android:right="3dp" android:top="3dp" />
+        </shape>
+    </item>
+
+    <item android:state_focused="true">
+        <shape>
+            <solid android:color="#E3E3E3" />
+            <stroke android:width="1dp" android:color="#585858" />
+            <corners android:radius="3dp" />
+            <padding android:bottom="3dp" android:left="3dp" android:right="3dp" android:top="3dp" />
+        </shape>
+    </item>
+
+    <item>
+        <shape>
+            <solid android:color="#E3E3E3" />
+            <stroke android:width="1dp" android:color="#585858" />
+            <corners android:radius="3dp" />
+            <padding android:bottom="3dp" android:left="3dp" android:right="3dp" android:top="3dp" />
+        </shape>
+    </item>
+</selector> 

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/color.c

@@ -0,0 +1,1613 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Color Conversion Routines
+ *
+ * Copyright 2010 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/log.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/primitives.h>
+
+#if defined(WITH_CAIRO)
+#include <cairo.h>
+#endif
+
+#if defined(WITH_SWSCALE)
+#include <libswscale/swscale.h>
+#endif
+
+#include "color.h"
+
+#define TAG FREERDP_TAG("color")
+
+BYTE* freerdp_glyph_convert(UINT32 width, UINT32 height, const BYTE* WINPR_RESTRICT data)
+{
+	/*
+	 * converts a 1-bit-per-pixel glyph to a one-byte-per-pixel glyph:
+	 * this approach uses a little more memory, but provides faster
+	 * means of accessing individual pixels in blitting operations
+	 */
+	const UINT32 scanline = (width + 7) / 8;
+	BYTE* dstData = (BYTE*)winpr_aligned_malloc(1ull * width * height, 16);
+
+	if (!dstData)
+		return NULL;
+
+	ZeroMemory(dstData, 1ULL * width * height);
+	BYTE* dstp = dstData;
+
+	for (UINT32 y = 0; y < height; y++)
+	{
+		const BYTE* srcp = &data[1ull * y * scanline];
+
+		for (UINT32 x = 0; x < width; x++)
+		{
+			if ((*srcp & (0x80 >> (x % 8))) != 0)
+				*dstp = 0xFF;
+
+			dstp++;
+
+			if (((x + 1) % 8 == 0) && x != 0)
+				srcp++;
+		}
+	}
+
+	return dstData;
+}
+
+BOOL freerdp_image_copy_from_monochrome(BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                                        UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
+                                        UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData,
+                                        UINT32 backColor, UINT32 foreColor,
+                                        const gdiPalette* WINPR_RESTRICT palette)
+{
+	const UINT32 dstBytesPerPixel = FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (!pDstData || !pSrcData || !palette)
+		return FALSE;
+
+	if (nDstStep == 0)
+		nDstStep = dstBytesPerPixel * nWidth;
+
+	const UINT32 monoStep = (nWidth + 7) / 8;
+
+	for (size_t y = 0; y < nHeight; y++)
+	{
+		BYTE* pDstLine = &pDstData[((nYDst + y) * nDstStep)];
+		UINT32 monoBit = 0x80;
+		const BYTE* monoBits = &pSrcData[monoStep * y];
+
+		for (size_t x = 0; x < nWidth; x++)
+		{
+			BYTE* pDstPixel = &pDstLine[((nXDst + x) * FreeRDPGetBytesPerPixel(DstFormat))];
+			BOOL monoPixel = (*monoBits & monoBit) ? TRUE : FALSE;
+
+			if (!(monoBit >>= 1))
+			{
+				monoBits++;
+				monoBit = 0x80;
+			}
+
+			if (monoPixel)
+				FreeRDPWriteColor_int(pDstPixel, DstFormat, backColor);
+			else
+				FreeRDPWriteColor_int(pDstPixel, DstFormat, foreColor);
+		}
+	}
+
+	return TRUE;
+}
+
+static INLINE UINT32 freerdp_image_inverted_pointer_color(UINT32 x, UINT32 y, UINT32 format)
+{
+#if 1
+	/**
+	 * Inverted pointer colors (where individual pixels can change their
+	 * color to accommodate the background behind them) only seem to be
+	 * supported on Windows.
+	 * Using a static replacement color for these pixels (e.g. black)
+	 * might result in invisible pointers depending on the background.
+	 * This function returns either black or white, depending on the
+	 * pixel's position.
+	 */
+	BYTE fill = (x + y) & 1 ? 0x00 : 0xFF;
+#else
+	BYTE fill = 0x00;
+#endif
+	return FreeRDPGetColor(format, fill, fill, fill, 0xFF);
+}
+
+/*
+ * DIB color palettes are arrays of RGBQUAD structs with colors in BGRX format.
+ * They are used only by 1, 2, 4, and 8-bit bitmaps.
+ */
+static void fill_gdi_palette_for_icon(const BYTE* colorTable, UINT16 cbColorTable,
+                                      gdiPalette* palette)
+{
+	WINPR_ASSERT(palette);
+
+	palette->format = PIXEL_FORMAT_BGRX32;
+	ZeroMemory(palette->palette, sizeof(palette->palette));
+
+	if (!cbColorTable)
+		return;
+
+	if ((cbColorTable % 4 != 0) || (cbColorTable / 4 > 256))
+	{
+		WLog_WARN(TAG, "weird palette size: %u", cbColorTable);
+		return;
+	}
+
+	for (UINT16 i = 0; i < cbColorTable / 4; i++)
+	{
+		palette->palette[i] = FreeRDPReadColor_int(&colorTable[4ULL * i], palette->format);
+	}
+}
+
+static INLINE UINT32 div_ceil(UINT32 a, UINT32 b)
+{
+	return (a + (b - 1)) / b;
+}
+
+static INLINE UINT32 round_up(UINT32 a, UINT32 b)
+{
+	return b * div_ceil(a, b);
+}
+
+BOOL freerdp_image_copy_from_icon_data(BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                                       UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT16 nWidth,
+                                       UINT16 nHeight, const BYTE* WINPR_RESTRICT bitsColor,
+                                       UINT16 cbBitsColor, const BYTE* WINPR_RESTRICT bitsMask,
+                                       UINT16 cbBitsMask, const BYTE* WINPR_RESTRICT colorTable,
+                                       UINT16 cbColorTable, UINT32 bpp)
+{
+	DWORD format = 0;
+	gdiPalette palette;
+
+	if (!pDstData || !bitsColor)
+		return FALSE;
+
+	/*
+	 * Color formats used by icons are DIB bitmap formats (2-bit format
+	 * is not used by MS-RDPERP). Note that 16-bit is RGB555, not RGB565,
+	 * and that 32-bit format uses BGRA order.
+	 */
+	switch (bpp)
+	{
+		case 1:
+		case 4:
+			/*
+			 * These formats are not supported by freerdp_image_copy().
+			 * PIXEL_FORMAT_MONO and PIXEL_FORMAT_A4 are *not* correct
+			 * color formats for this. Please fix freerdp_image_copy()
+			 * if you came here to fix a broken icon of some weird app
+			 * that still uses 1 or 4bpp format in the 21st century.
+			 */
+			WLog_WARN(TAG, "1bpp and 4bpp icons are not supported");
+			return FALSE;
+
+		case 8:
+			format = PIXEL_FORMAT_RGB8;
+			break;
+
+		case 16:
+			format = PIXEL_FORMAT_RGB15;
+			break;
+
+		case 24:
+			format = PIXEL_FORMAT_RGB24;
+			break;
+
+		case 32:
+			format = PIXEL_FORMAT_BGRA32;
+			break;
+
+		default:
+			WLog_WARN(TAG, "invalid icon bpp: %" PRIu32, bpp);
+			return FALSE;
+	}
+
+	/* Ensure we have enough source data bytes for image copy. */
+	if (cbBitsColor < nWidth * nHeight * FreeRDPGetBytesPerPixel(format))
+		return FALSE;
+
+	fill_gdi_palette_for_icon(colorTable, cbColorTable, &palette);
+	if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight,
+	                                   bitsColor, format, 0, 0, 0, &palette, FREERDP_FLIP_VERTICAL))
+		return FALSE;
+
+	/* apply alpha mask */
+	if (FreeRDPColorHasAlpha(DstFormat) && cbBitsMask)
+	{
+		BYTE nextBit = 0;
+		const BYTE* maskByte = NULL;
+		UINT32 stride = 0;
+		BYTE r = 0;
+		BYTE g = 0;
+		BYTE b = 0;
+		BYTE* dstBuf = pDstData;
+		UINT32 dstBpp = FreeRDPGetBytesPerPixel(DstFormat);
+
+		/*
+		 * Each byte encodes 8 adjacent pixels (with LSB padding as needed).
+		 * And due to hysterical raisins, stride of DIB bitmaps must be
+		 * a multiple of 4 bytes.
+		 */
+		stride = round_up(div_ceil(nWidth, 8), 4);
+
+		for (UINT32 y = 0; y < nHeight; y++)
+		{
+			maskByte = &bitsMask[1ULL * stride * (nHeight - 1 - y)];
+			nextBit = 0x80;
+
+			for (UINT32 x = 0; x < nWidth; x++)
+			{
+				UINT32 color = 0;
+				BYTE alpha = (*maskByte & nextBit) ? 0x00 : 0xFF;
+
+				/* read color back, add alpha and write it back */
+				color = FreeRDPReadColor_int(dstBuf, DstFormat);
+				FreeRDPSplitColor(color, DstFormat, &r, &g, &b, NULL, &palette);
+				color = FreeRDPGetColor(DstFormat, r, g, b, alpha);
+				FreeRDPWriteColor_int(dstBuf, DstFormat, color);
+
+				nextBit >>= 1;
+				dstBuf += dstBpp;
+				if (!nextBit)
+				{
+					nextBit = 0x80;
+					maskByte++;
+				}
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_image_copy_from_pointer_data_1bpp(
+    BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT xorMask, UINT32 xorMaskLength,
+    const BYTE* WINPR_RESTRICT andMask, UINT32 andMaskLength, UINT32 xorBpp)
+{
+	BOOL vFlip = 0;
+	UINT32 xorStep = 0;
+	UINT32 andStep = 0;
+	UINT32 xorBit = 0;
+	UINT32 andBit = 0;
+	UINT32 xorPixel = 0;
+	UINT32 andPixel = 0;
+
+	vFlip = (xorBpp == 1) ? FALSE : TRUE;
+	andStep = (nWidth + 7) / 8;
+	andStep += (andStep % 2);
+
+	if (!xorMask || (xorMaskLength == 0))
+		return FALSE;
+	if (!andMask || (andMaskLength == 0))
+		return FALSE;
+
+	xorStep = (nWidth + 7) / 8;
+	xorStep += (xorStep % 2);
+
+	if (xorStep * nHeight > xorMaskLength)
+		return FALSE;
+
+	if (andStep * nHeight > andMaskLength)
+		return FALSE;
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		const BYTE* andBits = NULL;
+		const BYTE* xorBits = NULL;
+		BYTE* pDstPixel = &pDstData[((1ULL * nYDst + y) * nDstStep) +
+		                            (1ULL * nXDst * FreeRDPGetBytesPerPixel(DstFormat))];
+		xorBit = andBit = 0x80;
+
+		if (!vFlip)
+		{
+			xorBits = &xorMask[1ULL * xorStep * y];
+			andBits = &andMask[1ULL * andStep * y];
+		}
+		else
+		{
+			xorBits = &xorMask[1ULL * xorStep * (nHeight - y - 1)];
+			andBits = &andMask[1ULL * andStep * (nHeight - y - 1)];
+		}
+
+		for (UINT32 x = 0; x < nWidth; x++)
+		{
+			UINT32 color = 0;
+			xorPixel = (*xorBits & xorBit) ? 1 : 0;
+
+			if (!(xorBit >>= 1))
+			{
+				xorBits++;
+				xorBit = 0x80;
+			}
+
+			andPixel = (*andBits & andBit) ? 1 : 0;
+
+			if (!(andBit >>= 1))
+			{
+				andBits++;
+				andBit = 0x80;
+			}
+
+			if (!andPixel && !xorPixel)
+				color = FreeRDPGetColor(DstFormat, 0, 0, 0, 0xFF); /* black */
+			else if (!andPixel && xorPixel)
+				color = FreeRDPGetColor(DstFormat, 0xFF, 0xFF, 0xFF, 0xFF); /* white */
+			else if (andPixel && !xorPixel)
+				color = FreeRDPGetColor(DstFormat, 0, 0, 0, 0); /* transparent */
+			else if (andPixel && xorPixel)
+				color = freerdp_image_inverted_pointer_color(x, y, DstFormat); /* inverted */
+
+			FreeRDPWriteColor_int(pDstPixel, DstFormat, color);
+			pDstPixel += FreeRDPGetBytesPerPixel(DstFormat);
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_image_copy_from_pointer_data_xbpp(
+    BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT xorMask, UINT32 xorMaskLength,
+    const BYTE* WINPR_RESTRICT andMask, UINT32 andMaskLength, UINT32 xorBpp,
+    const gdiPalette* palette)
+{
+	BOOL vFlip = 0;
+	size_t xorStep = 0;
+	size_t andStep = 0;
+	UINT32 andBit = 0;
+	UINT32 xorPixel = 0;
+	UINT32 andPixel = 0;
+	UINT32 dstBitsPerPixel = 0;
+	UINT32 xorBytesPerPixel = 0;
+	dstBitsPerPixel = FreeRDPGetBitsPerPixel(DstFormat);
+
+	vFlip = (xorBpp == 1) ? FALSE : TRUE;
+	andStep = (nWidth + 7) / 8;
+	andStep += (andStep % 2);
+
+	if (!xorMask || (xorMaskLength == 0))
+		return FALSE;
+
+	xorBytesPerPixel = xorBpp >> 3;
+	xorStep = 1ULL * nWidth * xorBytesPerPixel;
+	xorStep += (xorStep % 2);
+
+	if (xorBpp == 8 && !palette)
+	{
+		WLog_ERR(TAG, "null palette in conversion from %" PRIu32 " bpp to %" PRIu32 " bpp", xorBpp,
+		         dstBitsPerPixel);
+		return FALSE;
+	}
+
+	if (xorStep * nHeight > xorMaskLength)
+		return FALSE;
+
+	if (andMask)
+	{
+		if (andStep * nHeight > andMaskLength)
+			return FALSE;
+	}
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		const BYTE* xorBits = NULL;
+		const BYTE* andBits = NULL;
+		BYTE* pDstPixel = &pDstData[((1ULL * nYDst + y) * nDstStep) +
+		                            (1ULL * nXDst * FreeRDPGetBytesPerPixel(DstFormat))];
+		andBit = 0x80;
+
+		if (!vFlip)
+		{
+			if (andMask)
+				andBits = &andMask[andStep * y];
+
+			xorBits = &xorMask[xorStep * y];
+		}
+		else
+		{
+			if (andMask)
+				andBits = &andMask[1ULL * andStep * (nHeight - y - 1)];
+
+			xorBits = &xorMask[1ULL * xorStep * (nHeight - y - 1)];
+		}
+
+		for (UINT32 x = 0; x < nWidth; x++)
+		{
+			UINT32 pixelFormat = 0;
+			UINT32 color = 0;
+
+			if (xorBpp == 32)
+			{
+				pixelFormat = PIXEL_FORMAT_BGRA32;
+				xorPixel = FreeRDPReadColor_int(xorBits, pixelFormat);
+			}
+			else if (xorBpp == 16)
+			{
+				pixelFormat = PIXEL_FORMAT_RGB15;
+				xorPixel = FreeRDPReadColor_int(xorBits, pixelFormat);
+			}
+			else if (xorBpp == 8)
+			{
+				pixelFormat = palette->format;
+				xorPixel = palette->palette[xorBits[0]];
+			}
+			else
+			{
+				pixelFormat = PIXEL_FORMAT_BGR24;
+				xorPixel = FreeRDPReadColor_int(xorBits, pixelFormat);
+			}
+
+			xorPixel = FreeRDPConvertColor(xorPixel, pixelFormat, PIXEL_FORMAT_ARGB32, palette);
+			xorBits += xorBytesPerPixel;
+			andPixel = 0;
+
+			if (andMask)
+			{
+				andPixel = (*andBits & andBit) ? 1 : 0;
+
+				if (!(andBit >>= 1))
+				{
+					andBits++;
+					andBit = 0x80;
+				}
+			}
+
+			if (andPixel)
+			{
+				if (xorPixel == 0xFF000000) /* black -> transparent */
+					xorPixel = 0x00000000;
+				else if (xorPixel == 0xFFFFFFFF) /* white -> inverted */
+					xorPixel = freerdp_image_inverted_pointer_color(x, y, PIXEL_FORMAT_ARGB32);
+			}
+
+			color = FreeRDPConvertColor(xorPixel, PIXEL_FORMAT_ARGB32, DstFormat, palette);
+			FreeRDPWriteColor_int(pDstPixel, DstFormat, color);
+			pDstPixel += FreeRDPGetBytesPerPixel(DstFormat);
+		}
+	}
+
+	return TRUE;
+}
+
+/**
+ * Drawing Monochrome Pointers:
+ * http://msdn.microsoft.com/en-us/library/windows/hardware/ff556143/
+ *
+ * Drawing Color Pointers:
+ * http://msdn.microsoft.com/en-us/library/windows/hardware/ff556138/
+ */
+
+BOOL freerdp_image_copy_from_pointer_data(BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                                          UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+                                          UINT32 nWidth, UINT32 nHeight,
+                                          const BYTE* WINPR_RESTRICT xorMask, UINT32 xorMaskLength,
+                                          const BYTE* WINPR_RESTRICT andMask, UINT32 andMaskLength,
+                                          UINT32 xorBpp, const gdiPalette* WINPR_RESTRICT palette)
+{
+	UINT32 dstBitsPerPixel = 0;
+	UINT32 dstBytesPerPixel = 0;
+	dstBitsPerPixel = FreeRDPGetBitsPerPixel(DstFormat);
+	dstBytesPerPixel = FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (nDstStep <= 0)
+		nDstStep = dstBytesPerPixel * nWidth;
+
+	for (UINT32 y = nYDst; y < nHeight; y++)
+	{
+		BYTE* WINPR_RESTRICT pDstLine = &pDstData[y * nDstStep + nXDst * dstBytesPerPixel];
+		memset(pDstLine, 0, 1ull * dstBytesPerPixel * (nWidth - nXDst));
+	}
+
+	switch (xorBpp)
+	{
+		case 1:
+			return freerdp_image_copy_from_pointer_data_1bpp(
+			    pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, xorMask,
+			    xorMaskLength, andMask, andMaskLength, xorBpp);
+
+		case 8:
+		case 16:
+		case 24:
+		case 32:
+			return freerdp_image_copy_from_pointer_data_xbpp(
+			    pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, xorMask,
+			    xorMaskLength, andMask, andMaskLength, xorBpp, palette);
+
+		default:
+			WLog_ERR(TAG, "failed to convert from %" PRIu32 " bpp to %" PRIu32 " bpp", xorBpp,
+			         dstBitsPerPixel);
+			return FALSE;
+	}
+}
+
+static INLINE BOOL overlapping(const BYTE* pDstData, UINT32 nYDst, UINT32 nDstStep,
+                               const BYTE* pSrcData, UINT32 nYSrc, UINT32 nSrcStep, UINT32 nHeight)
+{
+	const uintptr_t src = (uintptr_t)pSrcData;
+	const uintptr_t srcstart = src + 1ULL * nSrcStep * nYSrc;
+	const uintptr_t srcend = srcstart + 1ULL * nSrcStep * nHeight;
+	const uintptr_t dst = (uintptr_t)pDstData;
+	const uintptr_t dststart = dst + 1ULL * nDstStep * nYDst;
+	const uintptr_t dstend = dststart + 1ULL * nDstStep * nHeight;
+
+	if ((dststart >= srcstart) && (dststart <= srcend))
+		return TRUE;
+
+	if ((dstend >= srcstart) && (dstend <= srcend))
+		return TRUE;
+
+	return FALSE;
+}
+
+static INLINE BOOL freerdp_image_copy_bgr24_bgrx32(BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
+                                                   UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
+                                                   UINT32 nHeight,
+                                                   const BYTE* WINPR_RESTRICT pSrcData,
+                                                   UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
+                                                   SSIZE_T srcVMultiplier, SSIZE_T srcVOffset,
+                                                   SSIZE_T dstVMultiplier, SSIZE_T dstVOffset)
+{
+
+	const SSIZE_T srcByte = 3;
+	const SSIZE_T dstByte = 4;
+
+	for (SSIZE_T y = 0; y < nHeight; y++)
+	{
+		const BYTE* WINPR_RESTRICT srcLine =
+		    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+		BYTE* WINPR_RESTRICT dstLine =
+		    &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+
+		for (SSIZE_T x = 0; x < nWidth; x++)
+		{
+			dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
+			dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
+			dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
+		}
+	}
+
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_image_copy_bgrx32_bgrx32(BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
+                                                    UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
+                                                    UINT32 nHeight,
+                                                    const BYTE* WINPR_RESTRICT pSrcData,
+                                                    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
+                                                    SSIZE_T srcVMultiplier, SSIZE_T srcVOffset,
+                                                    SSIZE_T dstVMultiplier, SSIZE_T dstVOffset)
+{
+
+	const SSIZE_T srcByte = 4;
+	const SSIZE_T dstByte = 4;
+
+	for (SSIZE_T y = 0; y < nHeight; y++)
+	{
+		const BYTE* WINPR_RESTRICT srcLine =
+		    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+		BYTE* WINPR_RESTRICT dstLine =
+		    &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+
+		for (SSIZE_T x = 0; x < nWidth; x++)
+		{
+			dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
+			dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
+			dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
+		}
+	}
+
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_image_copy_generic(
+    BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcFormat,
+    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
+    SSIZE_T srcVMultiplier, SSIZE_T srcVOffset, SSIZE_T dstVMultiplier, SSIZE_T dstVOffset)
+{
+
+	const SSIZE_T srcByte = 4;
+	const SSIZE_T dstByte = 4;
+
+	for (SSIZE_T y = 0; y < nHeight; y++)
+	{
+		const BYTE* WINPR_RESTRICT srcLine =
+		    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+		BYTE* WINPR_RESTRICT dstLine =
+		    &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+
+		UINT32 color = FreeRDPReadColor_int(&srcLine[nXSrc * srcByte], SrcFormat);
+		UINT32 oldColor = color;
+		UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
+		FreeRDPWriteColorIgnoreAlpha_int(&dstLine[nXDst * dstByte], DstFormat, dstColor);
+		for (SSIZE_T x = 1; x < nWidth; x++)
+		{
+			color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
+			if (color == oldColor)
+			{
+				FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
+				                                 dstColor);
+			}
+			else
+			{
+				oldColor = color;
+				dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
+				FreeRDPWriteColorIgnoreAlpha_int(&dstLine[(x + nXDst) * dstByte], DstFormat,
+				                                 dstColor);
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_image_copy_no_overlap_dst_alpha(
+    BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
+    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
+    SSIZE_T srcVMultiplier, SSIZE_T srcVOffset, SSIZE_T dstVMultiplier, SSIZE_T dstVOffset)
+{
+	WINPR_ASSERT(pDstData);
+	WINPR_ASSERT(pSrcData);
+
+	switch (SrcFormat)
+	{
+		case PIXEL_FORMAT_BGR24:
+			switch (DstFormat)
+			{
+				case PIXEL_FORMAT_BGRX32:
+				case PIXEL_FORMAT_BGRA32:
+					return freerdp_image_copy_bgr24_bgrx32(
+					    pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
+					    nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
+				default:
+					break;
+			}
+			break;
+		case PIXEL_FORMAT_BGRX32:
+		case PIXEL_FORMAT_BGRA32:
+			switch (DstFormat)
+			{
+				case PIXEL_FORMAT_BGRX32:
+				case PIXEL_FORMAT_BGRA32:
+					return freerdp_image_copy_bgrx32_bgrx32(
+					    pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
+					    nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
+				default:
+					break;
+			}
+			break;
+		default:
+			break;
+	}
+
+	return freerdp_image_copy_generic(pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight,
+	                                  pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette,
+	                                  srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
+}
+
+BOOL freerdp_image_copy_overlap(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst,
+                                UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, const BYTE* pSrcData,
+                                DWORD SrcFormat, UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
+                                const gdiPalette* WINPR_RESTRICT palette, UINT32 flags)
+{
+	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;
+	const BOOL vSrcVFlip = (flags & FREERDP_FLIP_VERTICAL) ? TRUE : FALSE;
+	SSIZE_T srcVOffset = 0;
+	SSIZE_T srcVMultiplier = 1;
+	SSIZE_T dstVOffset = 0;
+	SSIZE_T dstVMultiplier = 1;
+
+	WINPR_ASSERT(overlapping(pDstData, nYDst, nDstStep, pSrcData, nYSrc, nSrcStep, nHeight));
+
+	if ((nWidth == 0) || (nHeight == 0))
+		return TRUE;
+
+	if ((nHeight > INT32_MAX) || (nWidth > INT32_MAX))
+		return FALSE;
+
+	if (!pDstData || !pSrcData)
+		return FALSE;
+
+	if (nDstStep == 0)
+		nDstStep = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (nSrcStep == 0)
+		nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat);
+
+	if (vSrcVFlip)
+	{
+		srcVOffset = (nHeight - 1ll) * nSrcStep;
+		srcVMultiplier = -1;
+	}
+
+	if (((flags & FREERDP_KEEP_DST_ALPHA) != 0) && FreeRDPColorHasAlpha(DstFormat))
+	{
+		return freerdp_image_copy_no_overlap_dst_alpha(
+		    pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat,
+		    nSrcStep, nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier,
+		    dstVOffset);
+	}
+	else if (FreeRDPAreColorFormatsEqualNoAlpha_int(SrcFormat, DstFormat))
+	{
+		/* Copy down */
+		if (nYDst < nYSrc)
+		{
+			for (SSIZE_T y = 0; y < nHeight; y++)
+			{
+				const BYTE* srcLine =
+				    &pSrcData[(y + nYSrc) * nSrcStep * srcVMultiplier + srcVOffset];
+				BYTE* dstLine = &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+				memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
+			}
+		}
+		/* Copy up */
+		else if (nYDst > nYSrc)
+		{
+			for (SSIZE_T y = nHeight - 1; y >= 0; y--)
+			{
+				const BYTE* srcLine =
+				    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+				BYTE* dstLine = &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+				memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
+			}
+		}
+		/* Copy left */
+		else if (nXSrc > nXDst)
+		{
+			for (SSIZE_T y = 0; y < nHeight; y++)
+			{
+				const BYTE* srcLine =
+				    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+				BYTE* dstLine = &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+				memmove(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
+			}
+		}
+		/* Copy right */
+		else if (nXSrc < nXDst)
+		{
+			for (SSIZE_T y = nHeight - 1; y >= 0; y--)
+			{
+				const BYTE* srcLine =
+				    &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+				BYTE* dstLine = &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+				memmove(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
+			}
+		}
+		/* Source and destination are equal... */
+		else
+		{
+		}
+	}
+	else
+	{
+		for (SSIZE_T y = 0; y < nHeight; y++)
+		{
+			const BYTE* srcLine = &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
+			BYTE* dstLine = &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
+
+			UINT32 color = FreeRDPReadColor_int(&srcLine[1ULL * nXSrc * srcByte], SrcFormat);
+			UINT32 oldColor = color;
+			UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
+			FreeRDPWriteColor_int(&dstLine[1ULL * nXDst * dstByte], DstFormat, dstColor);
+			for (SSIZE_T x = 1; x < nWidth; x++)
+			{
+				color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
+				if (color == oldColor)
+				{
+					FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
+				}
+				else
+				{
+					oldColor = color;
+					dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
+					FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
+				}
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL freerdp_image_copy(BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst,
+                        UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, const BYTE* pSrcData,
+                        DWORD SrcFormat, UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
+                        const gdiPalette* WINPR_RESTRICT palette, UINT32 flags)
+{
+	if ((nHeight > INT32_MAX) || (nWidth > INT32_MAX))
+		return FALSE;
+
+	if (!pDstData || !pSrcData)
+		return FALSE;
+
+	if ((nWidth == 0) || (nHeight == 0))
+		return TRUE;
+
+	if (nDstStep == 0)
+		nDstStep = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (nSrcStep == 0)
+		nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat);
+
+	const BOOL ovl = overlapping(pDstData, nYDst, nDstStep, pSrcData, nYSrc, nSrcStep, nHeight);
+	if (ovl)
+		return freerdp_image_copy_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth,
+		                                  nHeight, pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc,
+		                                  palette, flags);
+	return freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth,
+	                                     nHeight, pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc,
+	                                     palette, flags);
+}
+
+BOOL freerdp_image_fill(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep,
+                        UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 color)
+{
+	if ((nWidth == 0) || (nHeight == 0))
+		return TRUE;
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat);
+	BYTE* WINPR_RESTRICT pFirstDstLine = NULL;
+	BYTE* WINPR_RESTRICT pFirstDstLineXOffset = NULL;
+
+	if (nDstStep == 0)
+		nDstStep = (nXDst + nWidth) * FreeRDPGetBytesPerPixel(DstFormat);
+
+	pFirstDstLine = &pDstData[1ULL * nYDst * nDstStep];
+	pFirstDstLineXOffset = &pFirstDstLine[1ULL * nXDst * bpp];
+
+	for (size_t x = 0; x < nWidth; x++)
+	{
+		BYTE* pDst = &pFirstDstLine[(x + nXDst) * bpp];
+		FreeRDPWriteColor_int(pDst, DstFormat, color);
+	}
+
+	for (size_t y = 1; y < nHeight; y++)
+	{
+		BYTE* pDstLine = &pDstData[(y + nYDst) * nDstStep + 1ULL * nXDst * bpp];
+		memcpy(pDstLine, pFirstDstLineXOffset, 1ull * nWidth * bpp);
+	}
+
+	return TRUE;
+}
+
+#if defined(WITH_SWSCALE)
+static int av_format_for_buffer(UINT32 format)
+{
+	switch (format)
+	{
+		case PIXEL_FORMAT_ARGB32:
+			return AV_PIX_FMT_BGRA;
+
+		case PIXEL_FORMAT_XRGB32:
+			return AV_PIX_FMT_BGR0;
+
+		case PIXEL_FORMAT_BGRA32:
+			return AV_PIX_FMT_RGBA;
+
+		case PIXEL_FORMAT_BGRX32:
+			return AV_PIX_FMT_RGB0;
+
+		default:
+			return AV_PIX_FMT_NONE;
+	}
+}
+#endif
+
+BOOL freerdp_image_scale(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep,
+                         UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth, UINT32 nDstHeight,
+                         const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
+                         UINT32 nXSrc, UINT32 nYSrc, UINT32 nSrcWidth, UINT32 nSrcHeight)
+{
+	BOOL rc = FALSE;
+
+	if (nDstStep == 0)
+		nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (nSrcStep == 0)
+		nSrcStep = nSrcWidth * FreeRDPGetBytesPerPixel(SrcFormat);
+
+#if defined(WITH_SWSCALE) || defined(WITH_CAIRO)
+	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... */
+	if ((nDstWidth == nSrcWidth) && (nDstHeight == nSrcHeight))
+	{
+		return freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth,
+		                                     nDstHeight, pSrcData, SrcFormat, nSrcStep, nXSrc,
+		                                     nYSrc, NULL, FREERDP_FLIP_NONE);
+	}
+	else
+#if defined(WITH_SWSCALE)
+	{
+		int res = 0;
+		struct SwsContext* resize = NULL;
+		int srcFormat = av_format_for_buffer(SrcFormat);
+		int dstFormat = av_format_for_buffer(DstFormat);
+		const int srcStep[1] = { (int)nSrcStep };
+		const int dstStep[1] = { (int)nDstStep };
+
+		if ((srcFormat == AV_PIX_FMT_NONE) || (dstFormat == AV_PIX_FMT_NONE))
+			return FALSE;
+
+		resize = sws_getContext((int)nSrcWidth, (int)nSrcHeight, srcFormat, (int)nDstWidth,
+		                        (int)nDstHeight, dstFormat, SWS_BILINEAR, NULL, NULL, NULL);
+
+		if (!resize)
+			goto fail;
+
+		res = sws_scale(resize, &src, srcStep, 0, (int)nSrcHeight, &dst, dstStep);
+		rc = (res == ((int)nDstHeight));
+	fail:
+		sws_freeContext(resize);
+	}
+
+#elif defined(WITH_CAIRO)
+	{
+		const double sx = (double)nDstWidth / (double)nSrcWidth;
+		const double sy = (double)nDstHeight / (double)nSrcHeight;
+		cairo_t* cairo_context;
+		cairo_surface_t *csrc, *cdst;
+
+		if ((nSrcWidth > INT_MAX) || (nSrcHeight > INT_MAX) || (nSrcStep > INT_MAX))
+			return FALSE;
+
+		if ((nDstWidth > INT_MAX) || (nDstHeight > INT_MAX) || (nDstStep > INT_MAX))
+			return FALSE;
+
+		csrc = cairo_image_surface_create_for_data((void*)src, CAIRO_FORMAT_ARGB32, (int)nSrcWidth,
+		                                           (int)nSrcHeight, (int)nSrcStep);
+		cdst = cairo_image_surface_create_for_data(dst, CAIRO_FORMAT_ARGB32, (int)nDstWidth,
+		                                           (int)nDstHeight, (int)nDstStep);
+
+		if (!csrc || !cdst)
+			goto fail;
+
+		cairo_context = cairo_create(cdst);
+
+		if (!cairo_context)
+			goto fail2;
+
+		cairo_scale(cairo_context, sx, sy);
+		cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
+		cairo_set_source_surface(cairo_context, csrc, 0, 0);
+		cairo_paint(cairo_context);
+		rc = TRUE;
+	fail2:
+		cairo_destroy(cairo_context);
+	fail:
+		cairo_surface_destroy(csrc);
+		cairo_surface_destroy(cdst);
+	}
+#else
+	{
+		WLog_WARN(TAG, "SmartScaling requested but compiled without libcairo support!");
+	}
+#endif
+	return rc;
+}
+
+DWORD FreeRDPAreColorFormatsEqualNoAlpha(DWORD first, DWORD second)
+{
+	return FreeRDPAreColorFormatsEqualNoAlpha_int(first, second);
+}
+
+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 = 0;
+
+	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* WINPR_RESTRICT dst, UINT32 format, UINT32 color)
+{
+	return FreeRDPWriteColorIgnoreAlpha_int(dst, format, color);
+}
+
+BOOL FreeRDPWriteColor(BYTE* WINPR_RESTRICT dst, UINT32 format, UINT32 color)
+{
+	return FreeRDPWriteColor_int(dst, format, color);
+}
+
+UINT32 FreeRDPReadColor(const BYTE* WINPR_RESTRICT src, UINT32 format)
+{
+	return FreeRDPReadColor_int(src, format);
+}
+
+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 = 0;
+
+	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;
+	}
+}
+
+BOOL freerdp_image_copy_no_overlap(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep,
+                                   UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
+                                   const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
+                                   UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
+                                   const gdiPalette* WINPR_RESTRICT palette, UINT32 flags)
+{
+	static primitives_t* prims = NULL;
+	if (!prims)
+		prims = primitives_get();
+
+	WINPR_ASSERT(!overlapping(pDstData, nYDst, nDstStep, pSrcData, nYSrc, nSrcStep, nHeight));
+	WINPR_ASSERT(prims);
+	WINPR_ASSERT(prims->copy_no_overlap);
+	return prims->copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight,
+	                              pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette,
+	                              flags) == PRIMITIVES_SUCCESS;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/dsp_fdk_impl.h

@@ -0,0 +1,45 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Digital Sound Processing
+ *
+ * Copyright 2022 Armin Novak <anovak@thincast.com>
+ * Copyright 2022 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_DSP_FDK_IMPL_H_
+#define FREERDP_DSP_FDK_IMPL_H_
+
+#include <stdlib.h>
+
+typedef void (*fdk_log_fkt_t)(unsigned log_level, const char* fmt, ...);
+
+int fdk_aac_dsp_impl_init(void** handle, int encoder, fdk_log_fkt_t log);
+void fdk_aac_dsp_impl_uninit(void** handle, int encoder, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_stream_info(void* handle, int encoder, fdk_log_fkt_t log);
+
+int fdk_aac_dsp_impl_config(void* handle, size_t* pbuffersize, int encoder, unsigned samplerate,
+                            unsigned channels, unsigned bytes_per_second,
+                            unsigned frames_per_packet, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_decode_fill(void* handle, const void* data, size_t size,
+                                     fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_encode(void* handle, const void* data, size_t size, void* dst,
+                                size_t dstSize, fdk_log_fkt_t log);
+
+ssize_t fdk_aac_dsp_impl_decode_read(void* handle, void* dst, size_t dstSize, fdk_log_fkt_t log);
+
+#endif

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/dsp_ffmpeg.h

@@ -0,0 +1,48 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Digital Sound Processing - FFMPEG backend
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CODEC_DSP_FFMPEG_H
+#define FREERDP_LIB_CODEC_DSP_FFMPEG_H
+
+#include <freerdp/api.h>
+#include <freerdp/codec/audio.h>
+#include <freerdp/codec/dsp.h>
+
+#include <libavcodec/version.h>
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 48, 101)
+#error \
+    "DSP module requires libavcodec version >= 57.48.101. Upgrade or set WITH_DSP_FFMPEG=OFF to continue"
+#endif
+
+void freerdp_dsp_ffmpeg_context_free(FREERDP_DSP_CONTEXT* context);
+
+WINPR_ATTR_MALLOC(freerdp_dsp_ffmpeg_context_free, 1)
+FREERDP_DSP_CONTEXT* freerdp_dsp_ffmpeg_context_new(BOOL encode);
+BOOL freerdp_dsp_ffmpeg_supports_format(const AUDIO_FORMAT* format, BOOL encode);
+BOOL freerdp_dsp_ffmpeg_encode(FREERDP_DSP_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
+                               const BYTE* data, size_t length, wStream* out);
+BOOL freerdp_dsp_ffmpeg_decode(FREERDP_DSP_CONTEXT* context, const AUDIO_FORMAT* srcFormat,
+                               const BYTE* data, size_t length, wStream* out);
+
+BOOL freerdp_dsp_ffmpeg_context_reset(FREERDP_DSP_CONTEXT* context,
+                                      const AUDIO_FORMAT* targetFormat);
+
+#endif /* FREERDP_LIB_CODEC_DSP_FFMPEG_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/h264.c

@@ -0,0 +1,837 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * H.264 Bitmap Compression
+ *
+ * Copyright 2014 Mike McDonald <Mike.McDonald@software.dell.com>
+ * Copyright 2017 David Fort <contact@hardening-consulting.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/library.h>
+#include <winpr/bitstream.h>
+#include <winpr/synch.h>
+
+#include <freerdp/primitives.h>
+#include <freerdp/codec/h264.h>
+#include <freerdp/codec/yuv.h>
+#include <freerdp/log.h>
+
+#include "h264.h"
+
+#define TAG FREERDP_TAG("codec")
+
+static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight);
+
+static BOOL yuv_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width, UINT32 height)
+{
+	BOOL isNull = FALSE;
+	UINT32 pheight = height;
+
+	if (!h264)
+		return FALSE;
+
+	if (stride == 0)
+		stride = width;
+
+	if (stride % 16 != 0)
+		stride += 16 - stride % 16;
+
+	if (pheight % 16 != 0)
+		pheight += 16 - pheight % 16;
+
+	const size_t nPlanes = h264->hwAccel ? 2 : 3;
+
+	for (size_t x = 0; x < nPlanes; x++)
+	{
+		if (!h264->pYUVData[x] || !h264->pOldYUVData[x])
+			isNull = TRUE;
+	}
+
+	if (pheight == 0)
+		return FALSE;
+	if (stride == 0)
+		return FALSE;
+
+	if (isNull || (width != h264->width) || (height != h264->height) ||
+	    (stride != h264->iStride[0]))
+	{
+		if (h264->hwAccel) /* NV12 */
+		{
+			h264->iStride[0] = stride;
+			h264->iStride[1] = stride;
+			h264->iStride[2] = 0;
+		}
+		else /* I420 */
+		{
+			h264->iStride[0] = stride;
+			h264->iStride[1] = (stride + 1) / 2;
+			h264->iStride[2] = (stride + 1) / 2;
+		}
+
+		h264->width = width;
+		h264->height = height;
+
+		for (size_t x = 0; x < nPlanes; x++)
+		{
+			BYTE* tmp1 = winpr_aligned_recalloc(h264->pYUVData[x], h264->iStride[x], pheight, 16);
+			BYTE* tmp2 =
+			    winpr_aligned_recalloc(h264->pOldYUVData[x], h264->iStride[x], pheight, 16);
+			if (tmp1)
+				h264->pYUVData[x] = tmp1;
+			if (tmp2)
+				h264->pOldYUVData[x] = tmp2;
+			if (!tmp1 || !tmp2)
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL avc420_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width, UINT32 height)
+{
+	return yuv_ensure_buffer(h264, stride, width, height);
+}
+
+INT32 avc420_decompress(H264_CONTEXT* h264, const BYTE* pSrcData, UINT32 SrcSize, BYTE* pDstData,
+                        DWORD DstFormat, UINT32 nDstStep, UINT32 nDstWidth, UINT32 nDstHeight,
+                        const RECTANGLE_16* regionRects, UINT32 numRegionRects)
+{
+	int status = 0;
+	const BYTE* pYUVData[3];
+
+	if (!h264 || h264->Compressor)
+		return -1001;
+
+	status = h264->subsystem->Decompress(h264, pSrcData, SrcSize);
+
+	if (status == 0)
+		return 1;
+
+	if (status < 0)
+		return status;
+
+	pYUVData[0] = h264->pYUVData[0];
+	pYUVData[1] = h264->pYUVData[1];
+	pYUVData[2] = h264->pYUVData[2];
+	if (!yuv420_context_decode(h264->yuv, pYUVData, h264->iStride, h264->height, DstFormat,
+	                           pDstData, nDstStep, regionRects, numRegionRects))
+		return -1002;
+
+	return 1;
+}
+
+static BOOL allocate_h264_metablock(UINT32 QP, RECTANGLE_16* rectangles,
+                                    RDPGFX_H264_METABLOCK* meta, size_t count)
+{
+	/* [MS-RDPEGFX] 2.2.4.4.2 RDPGFX_AVC420_QUANT_QUALITY */
+	if (!meta || (QP > UINT8_MAX))
+	{
+		free(rectangles);
+		return FALSE;
+	}
+
+	meta->regionRects = rectangles;
+	if (count == 0)
+		return TRUE;
+
+	if (count > UINT32_MAX)
+		return FALSE;
+
+	meta->quantQualityVals = calloc(count, sizeof(RDPGFX_H264_QUANT_QUALITY));
+
+	if (!meta->quantQualityVals || !meta->regionRects)
+		return FALSE;
+	meta->numRegionRects = (UINT32)count;
+	for (size_t x = 0; x < count; x++)
+	{
+		RDPGFX_H264_QUANT_QUALITY* cur = &meta->quantQualityVals[x];
+		cur->qp = (UINT8)QP;
+
+		/* qpVal bit 6 and 7 are flags, so mask them out here.
+		 * qualityVal is [0-100] so 100 - qpVal [0-64] is always in range */
+		cur->qualityVal = 100 - (QP & 0x3F);
+	}
+	return TRUE;
+}
+
+static INLINE BOOL diff_tile(const RECTANGLE_16* regionRect, BYTE* pYUVData[3],
+                             BYTE* pOldYUVData[3], UINT32 const iStride[3])
+{
+	size_t size = 0;
+
+	if (!regionRect || !pYUVData || !pOldYUVData || !iStride)
+		return FALSE;
+	size = regionRect->right - regionRect->left;
+	if (regionRect->right > iStride[0])
+		return FALSE;
+	if (regionRect->right / 2u > iStride[1])
+		return FALSE;
+	if (regionRect->right / 2u > iStride[2])
+		return FALSE;
+
+	for (size_t y = regionRect->top; y < regionRect->bottom; y++)
+	{
+		const BYTE* cur0 = &pYUVData[0][y * iStride[0]];
+		const BYTE* cur1 = &pYUVData[1][y * iStride[1]];
+		const BYTE* cur2 = &pYUVData[2][y * iStride[2]];
+		const BYTE* old0 = &pOldYUVData[0][y * iStride[0]];
+		const BYTE* old1 = &pOldYUVData[1][y * iStride[1]];
+		const BYTE* old2 = &pOldYUVData[2][y * iStride[2]];
+
+		if (memcmp(&cur0[regionRect->left], &old0[regionRect->left], size) != 0)
+			return TRUE;
+		if (memcmp(&cur1[regionRect->left / 2], &old1[regionRect->left / 2], size / 2) != 0)
+			return TRUE;
+		if (memcmp(&cur2[regionRect->left / 2], &old2[regionRect->left / 2], size / 2) != 0)
+			return TRUE;
+	}
+	return FALSE;
+}
+
+static BOOL detect_changes(BOOL firstFrameDone, const UINT32 QP, const RECTANGLE_16* regionRect,
+                           BYTE* pYUVData[3], BYTE* pOldYUVData[3], UINT32 const iStride[3],
+                           RDPGFX_H264_METABLOCK* meta)
+{
+	size_t count = 0;
+	size_t wc = 0;
+	size_t hc = 0;
+	RECTANGLE_16* rectangles = NULL;
+
+	if (!regionRect || !pYUVData || !pOldYUVData || !iStride || !meta)
+		return FALSE;
+
+	wc = (regionRect->right - regionRect->left) / 64 + 1;
+	hc = (regionRect->bottom - regionRect->top) / 64 + 1;
+	rectangles = calloc(wc * hc, sizeof(RECTANGLE_16));
+	if (!rectangles)
+		return FALSE;
+	if (!firstFrameDone)
+	{
+		rectangles[0] = *regionRect;
+		count = 1;
+	}
+	else
+	{
+		for (size_t y = regionRect->top; y < regionRect->bottom; y += 64)
+		{
+			for (size_t x = regionRect->left; x < regionRect->right; x += 64)
+			{
+				RECTANGLE_16 rect;
+				rect.left = (UINT16)MIN(UINT16_MAX, regionRect->left + x);
+				rect.top = (UINT16)MIN(UINT16_MAX, regionRect->top + y);
+				rect.right =
+				    (UINT16)MIN(UINT16_MAX, MIN(regionRect->left + x + 64, regionRect->right));
+				rect.bottom =
+				    (UINT16)MIN(UINT16_MAX, MIN(regionRect->top + y + 64, regionRect->bottom));
+				if (diff_tile(&rect, pYUVData, pOldYUVData, iStride))
+					rectangles[count++] = rect;
+			}
+		}
+	}
+	if (!allocate_h264_metablock(QP, rectangles, meta, count))
+		return FALSE;
+	return TRUE;
+}
+
+INT32 h264_get_yuv_buffer(H264_CONTEXT* h264, UINT32 nSrcStride, UINT32 nSrcWidth,
+                          UINT32 nSrcHeight, BYTE* YUVData[3], UINT32 stride[3])
+{
+	if (!h264 || !h264->Compressor || !h264->subsystem || !h264->subsystem->Compress)
+		return -1;
+
+	if (!yuv_ensure_buffer(h264, nSrcStride, nSrcWidth, nSrcHeight))
+		return -1;
+
+	for (size_t x = 0; x < 3; x++)
+	{
+		YUVData[x] = h264->pYUVData[x];
+		stride[x] = h264->iStride[x];
+	}
+
+	return 0;
+}
+
+INT32 h264_compress(H264_CONTEXT* h264, BYTE** ppDstData, UINT32* pDstSize)
+{
+	if (!h264 || !h264->Compressor || !h264->subsystem || !h264->subsystem->Compress)
+		return -1;
+
+	const BYTE* pcYUVData[3] = { h264->pYUVData[0], h264->pYUVData[1], h264->pYUVData[2] };
+
+	return h264->subsystem->Compress(h264, pcYUVData, h264->iStride, ppDstData, pDstSize);
+}
+
+INT32 avc420_compress(H264_CONTEXT* h264, const BYTE* pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
+                      UINT32 nSrcWidth, UINT32 nSrcHeight, const RECTANGLE_16* regionRect,
+                      BYTE** ppDstData, UINT32* pDstSize, RDPGFX_H264_METABLOCK* meta)
+{
+	INT32 rc = -1;
+	BYTE* pYUVData[3] = { 0 };
+	const BYTE* pcYUVData[3] = { 0 };
+	BYTE* pOldYUVData[3] = { 0 };
+
+	if (!h264 || !regionRect || !meta || !h264->Compressor)
+		return -1;
+
+	if (!h264->subsystem->Compress)
+		return -1;
+
+	if (!avc420_ensure_buffer(h264, nSrcStep, nSrcWidth, nSrcHeight))
+		return -1;
+
+	if (h264->encodingBuffer)
+	{
+		for (size_t x = 0; x < 3; x++)
+		{
+			pYUVData[x] = h264->pYUVData[x];
+			pOldYUVData[x] = h264->pOldYUVData[x];
+		}
+	}
+	else
+	{
+		for (size_t x = 0; x < 3; x++)
+		{
+			pYUVData[x] = h264->pOldYUVData[x];
+			pOldYUVData[x] = h264->pYUVData[x];
+		}
+	}
+	h264->encodingBuffer = !h264->encodingBuffer;
+
+	if (!yuv420_context_encode(h264->yuv, pSrcData, nSrcStep, SrcFormat, h264->iStride, pYUVData,
+	                           regionRect, 1))
+		goto fail;
+
+	if (!detect_changes(h264->firstLumaFrameDone, h264->QP, regionRect, pYUVData, pOldYUVData,
+	                    h264->iStride, meta))
+		goto fail;
+
+	if (meta->numRegionRects == 0)
+	{
+		rc = 0;
+		goto fail;
+	}
+
+	for (size_t x = 0; x < 3; x++)
+		pcYUVData[x] = pYUVData[x];
+
+	rc = h264->subsystem->Compress(h264, pcYUVData, h264->iStride, ppDstData, pDstSize);
+	if (rc >= 0)
+		h264->firstLumaFrameDone = TRUE;
+
+fail:
+	if (rc < 0)
+		free_h264_metablock(meta);
+	return rc;
+}
+
+INT32 avc444_compress(H264_CONTEXT* h264, const BYTE* pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
+                      UINT32 nSrcWidth, UINT32 nSrcHeight, BYTE version, const RECTANGLE_16* region,
+                      BYTE* op, BYTE** ppDstData, UINT32* pDstSize, BYTE** ppAuxDstData,
+                      UINT32* pAuxDstSize, RDPGFX_H264_METABLOCK* meta,
+                      RDPGFX_H264_METABLOCK* auxMeta)
+{
+	int rc = -1;
+	BYTE* coded = NULL;
+	UINT32 codedSize = 0;
+	BYTE** pYUV444Data = NULL;
+	BYTE** pOldYUV444Data = NULL;
+	BYTE** pYUVData = NULL;
+	BYTE** pOldYUVData = NULL;
+
+	if (!h264 || !h264->Compressor)
+		return -1;
+
+	if (!h264->subsystem->Compress)
+		return -1;
+
+	if (!avc420_ensure_buffer(h264, nSrcStep, nSrcWidth, nSrcHeight))
+		return -1;
+
+	if (!avc444_ensure_buffer(h264, nSrcHeight))
+		return -1;
+
+	if (h264->encodingBuffer)
+	{
+		pYUV444Data = h264->pOldYUV444Data;
+		pOldYUV444Data = h264->pYUV444Data;
+		pYUVData = h264->pOldYUVData;
+		pOldYUVData = h264->pYUVData;
+	}
+	else
+	{
+		pYUV444Data = h264->pYUV444Data;
+		pOldYUV444Data = h264->pOldYUV444Data;
+		pYUVData = h264->pYUVData;
+		pOldYUVData = h264->pOldYUVData;
+	}
+	h264->encodingBuffer = !h264->encodingBuffer;
+
+	if (!yuv444_context_encode(h264->yuv, version, pSrcData, nSrcStep, SrcFormat, h264->iStride,
+	                           pYUV444Data, pYUVData, region, 1))
+		goto fail;
+
+	if (!detect_changes(h264->firstLumaFrameDone, h264->QP, region, pYUV444Data, pOldYUV444Data,
+	                    h264->iStride, meta))
+		goto fail;
+	if (!detect_changes(h264->firstChromaFrameDone, h264->QP, region, pYUVData, pOldYUVData,
+	                    h264->iStride, auxMeta))
+		goto fail;
+
+	/* [MS-RDPEGFX] 2.2.4.5 RFX_AVC444_BITMAP_STREAM
+	 * LC:
+	 * 0 ... Luma & Chroma
+	 * 1 ... Luma
+	 * 2 ... Chroma
+	 */
+	if ((meta->numRegionRects > 0) && (auxMeta->numRegionRects > 0))
+		*op = 0;
+	else if (meta->numRegionRects > 0)
+		*op = 1;
+	else if (auxMeta->numRegionRects > 0)
+		*op = 2;
+	else
+	{
+		WLog_INFO(TAG, "no changes detected for luma or chroma frame");
+		rc = 0;
+		goto fail;
+	}
+
+	if ((*op == 0) || (*op == 1))
+	{
+		const BYTE* pcYUV444Data[3] = { pYUV444Data[0], pYUV444Data[1], pYUV444Data[2] };
+
+		if (h264->subsystem->Compress(h264, pcYUV444Data, h264->iStride, &coded, &codedSize) < 0)
+			goto fail;
+		h264->firstLumaFrameDone = TRUE;
+		memcpy(h264->lumaData, coded, codedSize);
+		*ppDstData = h264->lumaData;
+		*pDstSize = codedSize;
+	}
+
+	if ((*op == 0) || (*op == 2))
+	{
+		const BYTE* pcYUVData[3] = { pYUVData[0], pYUVData[1], pYUVData[2] };
+
+		if (h264->subsystem->Compress(h264, pcYUVData, h264->iStride, &coded, &codedSize) < 0)
+			goto fail;
+		h264->firstChromaFrameDone = TRUE;
+		*ppAuxDstData = coded;
+		*pAuxDstSize = codedSize;
+	}
+
+	rc = 1;
+fail:
+	if (rc < 0)
+	{
+		free_h264_metablock(meta);
+		free_h264_metablock(auxMeta);
+	}
+	return rc;
+}
+
+static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight)
+{
+	WINPR_ASSERT(h264);
+
+	const UINT32* piMainStride = h264->iStride;
+	UINT32* piDstSize = h264->iYUV444Size;
+	UINT32* piDstStride = h264->iYUV444Stride;
+	BYTE** ppYUVDstData = h264->pYUV444Data;
+	BYTE** ppOldYUVDstData = h264->pOldYUV444Data;
+
+	nDstHeight = MAX(h264->height, nDstHeight);
+	const UINT32 pad = nDstHeight % 16;
+	UINT32 padDstHeight = nDstHeight; /* Need alignment to 16x16 blocks */
+
+	if (pad != 0)
+		padDstHeight += 16 - pad;
+
+	if ((piMainStride[0] != piDstStride[0]) ||
+	    (piDstSize[0] != 1ull * piMainStride[0] * padDstHeight))
+	{
+		for (UINT32 x = 0; x < 3; x++)
+		{
+			piDstStride[x] = piMainStride[0];
+			piDstSize[x] = piDstStride[x] * padDstHeight;
+
+			if (piDstSize[x] == 0)
+				return FALSE;
+
+			BYTE* tmp1 = winpr_aligned_recalloc(ppYUVDstData[x], piDstSize[x], 1, 16);
+			if (!tmp1)
+				return FALSE;
+			ppYUVDstData[x] = tmp1;
+			BYTE* tmp2 = winpr_aligned_recalloc(ppOldYUVDstData[x], piDstSize[x], 1, 16);
+			if (!tmp2)
+				return FALSE;
+			ppOldYUVDstData[x] = tmp2;
+		}
+
+		{
+			BYTE* tmp = winpr_aligned_recalloc(h264->lumaData, piDstSize[0], 4, 16);
+			if (!tmp)
+				goto fail;
+			h264->lumaData = tmp;
+		}
+	}
+
+	for (UINT32 x = 0; x < 3; x++)
+	{
+		if (!ppOldYUVDstData[x] || !ppYUVDstData[x] || (piDstSize[x] == 0) || (piDstStride[x] == 0))
+		{
+			WLog_Print(h264->log, WLOG_ERROR,
+			           "YUV buffer not initialized! check your decoder settings");
+			goto fail;
+		}
+	}
+
+	if (!h264->lumaData)
+		goto fail;
+
+	return TRUE;
+fail:
+	return FALSE;
+}
+
+static BOOL avc444_process_rects(H264_CONTEXT* h264, const BYTE* pSrcData, UINT32 SrcSize,
+                                 BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+                                 UINT32 nDstWidth, UINT32 nDstHeight, const RECTANGLE_16* rects,
+                                 UINT32 nrRects, avc444_frame_type type)
+{
+	const BYTE* pYUVData[3];
+	BYTE* pYUVDstData[3];
+	UINT32* piDstStride = h264->iYUV444Stride;
+	BYTE** ppYUVDstData = h264->pYUV444Data;
+	const UINT32* piStride = h264->iStride;
+
+	if (h264->subsystem->Decompress(h264, pSrcData, SrcSize) < 0)
+		return FALSE;
+
+	pYUVData[0] = h264->pYUVData[0];
+	pYUVData[1] = h264->pYUVData[1];
+	pYUVData[2] = h264->pYUVData[2];
+	if (!avc444_ensure_buffer(h264, nDstHeight))
+		return FALSE;
+
+	pYUVDstData[0] = ppYUVDstData[0];
+	pYUVDstData[1] = ppYUVDstData[1];
+	pYUVDstData[2] = ppYUVDstData[2];
+	if (!yuv444_context_decode(h264->yuv, (BYTE)type, pYUVData, piStride, h264->height, pYUVDstData,
+	                           piDstStride, DstFormat, pDstData, nDstStep, rects, nrRects))
+		return FALSE;
+
+	return TRUE;
+}
+
+#if defined(AVC444_FRAME_STAT)
+static UINT64 op1 = 0;
+static double op1sum = 0;
+static UINT64 op2 = 0;
+static double op2sum = 0;
+static UINT64 op3 = 0;
+static double op3sum = 0;
+static double avg(UINT64* count, double old, double size)
+{
+	double tmp = size + *count * old;
+	(*count)++;
+	tmp = tmp / *count;
+	return tmp;
+}
+#endif
+
+INT32 avc444_decompress(H264_CONTEXT* h264, BYTE op, const RECTANGLE_16* regionRects,
+                        UINT32 numRegionRects, const BYTE* pSrcData, UINT32 SrcSize,
+                        const RECTANGLE_16* auxRegionRects, UINT32 numAuxRegionRect,
+                        const BYTE* pAuxSrcData, UINT32 AuxSrcSize, BYTE* pDstData, DWORD DstFormat,
+                        UINT32 nDstStep, UINT32 nDstWidth, UINT32 nDstHeight, UINT32 codecId)
+{
+	INT32 status = -1;
+	avc444_frame_type chroma =
+	    (codecId == RDPGFX_CODECID_AVC444) ? AVC444_CHROMAv1 : AVC444_CHROMAv2;
+
+	if (!h264 || !regionRects || !pSrcData || !pDstData || h264->Compressor)
+		return -1001;
+
+	switch (op)
+	{
+		case 0: /* YUV420 in stream 1
+		         * Chroma420 in stream 2 */
+			if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
+			                          nDstWidth, nDstHeight, regionRects, numRegionRects,
+			                          AVC444_LUMA))
+				status = -1;
+			else if (!avc444_process_rects(h264, pAuxSrcData, AuxSrcSize, pDstData, DstFormat,
+			                               nDstStep, nDstWidth, nDstHeight, auxRegionRects,
+			                               numAuxRegionRect, chroma))
+				status = -1;
+			else
+				status = 0;
+
+			break;
+
+		case 2: /* Chroma420 in stream 1 */
+			if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
+			                          nDstWidth, nDstHeight, regionRects, numRegionRects, chroma))
+				status = -1;
+			else
+				status = 0;
+
+			break;
+
+		case 1: /* YUV420 in stream 1 */
+			if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
+			                          nDstWidth, nDstHeight, regionRects, numRegionRects,
+			                          AVC444_LUMA))
+				status = -1;
+			else
+				status = 0;
+
+			break;
+
+		default: /* WTF? */
+			break;
+	}
+
+#if defined(AVC444_FRAME_STAT)
+
+	switch (op)
+	{
+		case 0:
+			op1sum = avg(&op1, op1sum, SrcSize + AuxSrcSize);
+			break;
+
+		case 1:
+			op2sum = avg(&op2, op2sum, SrcSize);
+			break;
+
+		case 2:
+			op3sum = avg(&op3, op3sum, SrcSize);
+			break;
+
+		default:
+			break;
+	}
+
+	WLog_Print(h264->log, WLOG_INFO,
+	           "luma=%" PRIu64 " [avg=%lf] chroma=%" PRIu64 " [avg=%lf] combined=%" PRIu64
+	           " [avg=%lf]",
+	           op1, op1sum, op2, op2sum, op3, op3sum);
+#endif
+	return status;
+}
+
+#define MAX_SUBSYSTEMS 10
+static INIT_ONCE subsystems_once = INIT_ONCE_STATIC_INIT;
+static const H264_CONTEXT_SUBSYSTEM* subSystems[MAX_SUBSYSTEMS] = { 0 };
+
+static BOOL CALLBACK h264_register_subsystems(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+	int i = 0;
+
+#ifdef WITH_MEDIACODEC
+	{
+		subSystems[i] = &g_Subsystem_mediacodec;
+		i++;
+	}
+#endif
+#if defined(_WIN32) && defined(WITH_MEDIA_FOUNDATION)
+	{
+		subSystems[i] = &g_Subsystem_MF;
+		i++;
+	}
+#endif
+#ifdef WITH_OPENH264
+	{
+		subSystems[i] = &g_Subsystem_OpenH264;
+		i++;
+	}
+#endif
+#ifdef WITH_VIDEO_FFMPEG
+	{
+		subSystems[i] = &g_Subsystem_libavcodec;
+		i++;
+	}
+#endif
+	return i > 0;
+}
+
+static BOOL h264_context_init(H264_CONTEXT* h264)
+{
+	if (!h264)
+		return FALSE;
+
+	h264->subsystem = NULL;
+	InitOnceExecuteOnce(&subsystems_once, h264_register_subsystems, NULL, NULL);
+
+	for (size_t i = 0; i < MAX_SUBSYSTEMS; i++)
+	{
+		const H264_CONTEXT_SUBSYSTEM* subsystem = subSystems[i];
+
+		if (!subsystem || !subsystem->Init)
+			break;
+
+		if (subsystem->Init(h264))
+		{
+			h264->subsystem = subsystem;
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL h264_context_reset(H264_CONTEXT* h264, UINT32 width, UINT32 height)
+{
+	if (!h264)
+		return FALSE;
+
+	h264->width = width;
+	h264->height = height;
+
+	if (h264->subsystem && h264->subsystem->Uninit)
+		h264->subsystem->Uninit(h264);
+	if (!h264_context_init(h264))
+		return FALSE;
+
+	return yuv_context_reset(h264->yuv, width, height);
+}
+
+H264_CONTEXT* h264_context_new(BOOL Compressor)
+{
+	H264_CONTEXT* h264 = (H264_CONTEXT*)calloc(1, sizeof(H264_CONTEXT));
+	if (!h264)
+		return NULL;
+
+	h264->log = WLog_Get(TAG);
+
+	if (!h264->log)
+		goto fail;
+
+	h264->Compressor = Compressor;
+	if (Compressor)
+	{
+		/* Default compressor settings, may be changed by caller */
+		h264->BitRate = 1000000;
+		h264->FrameRate = 30;
+	}
+
+	if (!h264_context_init(h264))
+		goto fail;
+
+	h264->yuv = yuv_context_new(Compressor, 0);
+	if (!h264->yuv)
+		goto fail;
+
+	return h264;
+
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	h264_context_free(h264);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void h264_context_free(H264_CONTEXT* h264)
+{
+	if (h264)
+	{
+		if (h264->subsystem)
+			h264->subsystem->Uninit(h264);
+
+		for (size_t x = 0; x < 3; x++)
+		{
+			if (h264->Compressor)
+			{
+				winpr_aligned_free(h264->pYUVData[x]);
+				winpr_aligned_free(h264->pOldYUVData[x]);
+			}
+			winpr_aligned_free(h264->pYUV444Data[x]);
+			winpr_aligned_free(h264->pOldYUV444Data[x]);
+		}
+		winpr_aligned_free(h264->lumaData);
+
+		yuv_context_free(h264->yuv);
+		free(h264);
+	}
+}
+
+void free_h264_metablock(RDPGFX_H264_METABLOCK* meta)
+{
+	RDPGFX_H264_METABLOCK m = { 0 };
+	if (!meta)
+		return;
+	free(meta->quantQualityVals);
+	free(meta->regionRects);
+	*meta = m;
+}
+
+BOOL h264_context_set_option(H264_CONTEXT* h264, H264_CONTEXT_OPTION option, UINT32 value)
+{
+	WINPR_ASSERT(h264);
+	switch (option)
+	{
+		case H264_CONTEXT_OPTION_BITRATE:
+			h264->BitRate = value;
+			return TRUE;
+		case H264_CONTEXT_OPTION_FRAMERATE:
+			h264->FrameRate = value;
+			return TRUE;
+		case H264_CONTEXT_OPTION_RATECONTROL:
+			h264->RateControlMode = value;
+			return TRUE;
+		case H264_CONTEXT_OPTION_QP:
+			h264->QP = value;
+			return TRUE;
+		case H264_CONTEXT_OPTION_USAGETYPE:
+			h264->UsageType = value;
+			return TRUE;
+		case H264_CONTEXT_OPTION_HW_ACCEL:
+			h264->hwAccel = value ? TRUE : FALSE;
+			return TRUE;
+		default:
+			WLog_Print(h264->log, WLOG_WARN, "Unknown H264_CONTEXT_OPTION[0x%08" PRIx32 "]",
+			           option);
+			return FALSE;
+	}
+}
+
+UINT32 h264_context_get_option(H264_CONTEXT* h264, H264_CONTEXT_OPTION option)
+{
+	WINPR_ASSERT(h264);
+	switch (option)
+	{
+		case H264_CONTEXT_OPTION_BITRATE:
+			return h264->BitRate;
+		case H264_CONTEXT_OPTION_FRAMERATE:
+			return h264->FrameRate;
+		case H264_CONTEXT_OPTION_RATECONTROL:
+			return h264->RateControlMode;
+		case H264_CONTEXT_OPTION_QP:
+			return h264->QP;
+		case H264_CONTEXT_OPTION_USAGETYPE:
+			return h264->UsageType;
+		case H264_CONTEXT_OPTION_HW_ACCEL:
+			return h264->hwAccel;
+		default:
+			WLog_Print(h264->log, WLOG_WARN, "Unknown H264_CONTEXT_OPTION[0x%08" PRIx32 "]",
+			           option);
+			return 0;
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/h264.h

@@ -0,0 +1,110 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Decode
+ *
+ * Copyright 2018 Armin Novak <anovak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CODEC_H264_H
+#define FREERDP_LIB_CODEC_H264_H
+
+#include <freerdp/api.h>
+#include <freerdp/config.h>
+#include <freerdp/codec/h264.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	typedef BOOL (*pfnH264SubsystemInit)(H264_CONTEXT* h264);
+	typedef void (*pfnH264SubsystemUninit)(H264_CONTEXT* h264);
+
+	typedef int (*pfnH264SubsystemDecompress)(H264_CONTEXT* WINPR_RESTRICT h264,
+	                                          const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize);
+	typedef int (*pfnH264SubsystemCompress)(H264_CONTEXT* WINPR_RESTRICT h264,
+	                                        const BYTE** WINPR_RESTRICT pSrcYuv,
+	                                        const UINT32* WINPR_RESTRICT pStride,
+	                                        BYTE** WINPR_RESTRICT ppDstData,
+	                                        UINT32* WINPR_RESTRICT pDstSize);
+
+	struct S_H264_CONTEXT_SUBSYSTEM
+	{
+		const char* name;
+		pfnH264SubsystemInit Init;
+		pfnH264SubsystemUninit Uninit;
+		pfnH264SubsystemDecompress Decompress;
+		pfnH264SubsystemCompress Compress;
+	};
+
+	struct S_H264_CONTEXT
+	{
+		BOOL Compressor;
+
+		UINT32 width;
+		UINT32 height;
+
+		H264_RATECONTROL_MODE RateControlMode;
+		UINT32 BitRate;
+		UINT32 FrameRate;
+		UINT32 QP;
+		UINT32 UsageType;
+		UINT32 hwAccel;
+		UINT32 NumberOfThreads;
+
+		UINT32 iStride[3];
+		BYTE* pOldYUVData[3];
+		BYTE* pYUVData[3];
+
+		UINT32 iYUV444Size[3];
+		UINT32 iYUV444Stride[3];
+		BYTE* pOldYUV444Data[3];
+		BYTE* pYUV444Data[3];
+
+		UINT32 numSystemData;
+		void* pSystemData;
+		const H264_CONTEXT_SUBSYSTEM* subsystem;
+		YUV_CONTEXT* yuv;
+
+		BOOL encodingBuffer;
+		BOOL firstLumaFrameDone;
+		BOOL firstChromaFrameDone;
+
+		void* lumaData;
+		wLog* log;
+	};
+
+	FREERDP_LOCAL BOOL avc420_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width,
+	                                        UINT32 height);
+
+#ifdef WITH_MEDIACODEC
+	extern const H264_CONTEXT_SUBSYSTEM g_Subsystem_mediacodec;
+#endif
+#if defined(_WIN32) && defined(WITH_MEDIA_FOUNDATION)
+	extern const H264_CONTEXT_SUBSYSTEM g_Subsystem_MF;
+#endif
+#ifdef WITH_OPENH264
+	extern const H264_CONTEXT_SUBSYSTEM g_Subsystem_OpenH264;
+#endif
+#ifdef WITH_VIDEO_FFMPEG
+	extern const H264_CONTEXT_SUBSYSTEM g_Subsystem_libavcodec;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CODEC_H264_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/h264_ffmpeg.c

@@ -0,0 +1,820 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * H.264 Bitmap Compression
+ *
+ * Copyright 2015 Marc-André Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2014 Mike McDonald <Mike.McDonald@software.dell.com>
+ * Copyright 2014 erbth <t.erbesdobler@team103.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <freerdp/config.h>
+
+#include <winpr/wlog.h>
+#include <freerdp/log.h>
+#include <freerdp/codec/h264.h>
+#include <libavcodec/avcodec.h>
+#include <libavutil/opt.h>
+
+#include "h264.h"
+
+#ifdef WITH_VAAPI
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 9, 0)
+#include <libavutil/hwcontext.h>
+#else
+#pragma warning You have asked for VA - API decoding, \
+    but your version of libavutil is too old !Disabling.
+#undef WITH_VAAPI
+#endif
+#endif
+
+/* Fallback support for older libavcodec versions */
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 59, 100)
+#define AV_CODEC_ID_H264 CODEC_ID_H264
+#endif
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(56, 34, 2)
+#define AV_CODEC_FLAG_LOOP_FILTER CODEC_FLAG_LOOP_FILTER
+#define AV_CODEC_CAP_TRUNCATED CODEC_CAP_TRUNCATED
+#define AV_CODEC_FLAG_TRUNCATED CODEC_FLAG_TRUNCATED
+#endif
+
+#if LIBAVUTIL_VERSION_MAJOR < 52
+#define AV_PIX_FMT_YUV420P PIX_FMT_YUV420P
+#endif
+
+/* Ubuntu 14.04 ships without the functions provided by avutil,
+ * so define error to string methods here. */
+#if !defined(av_err2str)
+static inline char* error_string(char* errbuf, size_t errbuf_size, int errnum)
+{
+	av_strerror(errnum, errbuf, errbuf_size);
+	return errbuf;
+}
+
+#define av_err2str(errnum) error_string((char[64]){ 0 }, 64, errnum)
+#endif
+
+#if defined(WITH_VAAPI) || defined(WITH_VAAPI_H264_ENCODING)
+#define VAAPI_DEVICE "/dev/dri/renderD128"
+#endif
+
+typedef struct
+{
+	const AVCodec* codecDecoder;
+	AVCodecContext* codecDecoderContext;
+	const AVCodec* codecEncoder;
+	AVCodecContext* codecEncoderContext;
+	AVCodecParserContext* codecParser;
+	AVFrame* videoFrame;
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
+	AVPacket bufferpacket;
+#endif
+	AVPacket* packet;
+#if defined(WITH_VAAPI) || defined(WITH_VAAPI_H264_ENCODING)
+	AVBufferRef* hwctx;
+	AVFrame* hwVideoFrame;
+	enum AVPixelFormat hw_pix_fmt;
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 80, 100)
+	AVBufferRef* hw_frames_ctx;
+#endif
+#endif
+} H264_CONTEXT_LIBAVCODEC;
+
+static void libavcodec_destroy_encoder_context(H264_CONTEXT* WINPR_RESTRICT h264)
+{
+	H264_CONTEXT_LIBAVCODEC* sys = NULL;
+
+	if (!h264 || !h264->subsystem)
+		return;
+
+	sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+
+	if (sys->codecEncoderContext)
+	{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 69, 100)
+		avcodec_free_context(&sys->codecEncoderContext);
+#else
+		avcodec_close(sys->codecEncoderContext);
+		av_free(sys->codecEncoderContext);
+#endif
+	}
+
+	sys->codecEncoderContext = NULL;
+}
+
+#ifdef WITH_VAAPI_H264_ENCODING
+static int set_hw_frames_ctx(H264_CONTEXT* WINPR_RESTRICT h264)
+{
+	H264_CONTEXT_LIBAVCODEC* sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+	AVBufferRef* hw_frames_ref = NULL;
+	AVHWFramesContext* frames_ctx = NULL;
+	int err = 0;
+
+	if (!(hw_frames_ref = av_hwframe_ctx_alloc(sys->hwctx)))
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to create VAAPI frame context");
+		return -1;
+	}
+	frames_ctx = (AVHWFramesContext*)(hw_frames_ref->data);
+	frames_ctx->format = AV_PIX_FMT_VAAPI;
+	frames_ctx->sw_format = AV_PIX_FMT_NV12;
+	frames_ctx->width = sys->codecEncoderContext->width;
+	frames_ctx->height = sys->codecEncoderContext->height;
+	frames_ctx->initial_pool_size = 20;
+	if ((err = av_hwframe_ctx_init(hw_frames_ref)) < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR,
+		           "Failed to initialize VAAPI frame context."
+		           "Error code: %s",
+		           av_err2str(err));
+		av_buffer_unref(&hw_frames_ref);
+		return err;
+	}
+	sys->codecEncoderContext->hw_frames_ctx = av_buffer_ref(hw_frames_ref);
+	if (!sys->codecEncoderContext->hw_frames_ctx)
+		err = AVERROR(ENOMEM);
+
+	av_buffer_unref(&hw_frames_ref);
+	return err;
+}
+#endif
+
+static BOOL libavcodec_create_encoder_context(H264_CONTEXT* WINPR_RESTRICT h264)
+{
+	BOOL recreate = FALSE;
+	H264_CONTEXT_LIBAVCODEC* sys = NULL;
+
+	if (!h264 || !h264->subsystem)
+		return FALSE;
+
+	if ((h264->width > INT_MAX) || (h264->height > INT_MAX))
+		return FALSE;
+
+	sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+	if (!sys || !sys->codecEncoder)
+		return FALSE;
+
+	recreate = !sys->codecEncoderContext;
+
+	if (sys->codecEncoderContext)
+	{
+		if ((sys->codecEncoderContext->width != (int)h264->width) ||
+		    (sys->codecEncoderContext->height != (int)h264->height))
+			recreate = TRUE;
+	}
+
+	if (!recreate)
+		return TRUE;
+
+	libavcodec_destroy_encoder_context(h264);
+
+	sys->codecEncoderContext = avcodec_alloc_context3(sys->codecEncoder);
+
+	if (!sys->codecEncoderContext)
+		goto EXCEPTION;
+
+	switch (h264->RateControlMode)
+	{
+		case H264_RATECONTROL_VBR:
+			sys->codecEncoderContext->bit_rate = h264->BitRate;
+			break;
+
+		case H264_RATECONTROL_CQP:
+			if (av_opt_set_int(sys->codecEncoderContext, "qp", h264->QP, AV_OPT_SEARCH_CHILDREN) <
+			    0)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "av_opt_set_int failed");
+			}
+			break;
+
+		default:
+			break;
+	}
+
+	sys->codecEncoderContext->width = (int)MIN(INT32_MAX, h264->width);
+	sys->codecEncoderContext->height = (int)MIN(INT32_MAX, h264->height);
+	sys->codecEncoderContext->delay = 0;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 13, 100)
+	sys->codecEncoderContext->framerate =
+	    (AVRational){ WINPR_ASSERTING_INT_CAST(int, h264->FrameRate), 1 };
+#endif
+	sys->codecEncoderContext->time_base =
+	    (AVRational){ 1, WINPR_ASSERTING_INT_CAST(int, h264->FrameRate) };
+	av_opt_set(sys->codecEncoderContext, "tune", "zerolatency", AV_OPT_SEARCH_CHILDREN);
+
+	sys->codecEncoderContext->flags |= AV_CODEC_FLAG_LOOP_FILTER;
+
+#ifdef WITH_VAAPI_H264_ENCODING
+	if (sys->hwctx)
+	{
+		av_opt_set(sys->codecEncoderContext, "preset", "veryslow", AV_OPT_SEARCH_CHILDREN);
+
+		sys->codecEncoderContext->pix_fmt = AV_PIX_FMT_VAAPI;
+		/* set hw_frames_ctx for encoder's AVCodecContext */
+		if (set_hw_frames_ctx(h264) < 0)
+			goto EXCEPTION;
+	}
+	else
+#endif
+	{
+		av_opt_set(sys->codecEncoderContext, "preset", "medium", AV_OPT_SEARCH_CHILDREN);
+		sys->codecEncoderContext->pix_fmt = AV_PIX_FMT_YUV420P;
+	}
+
+	if (avcodec_open2(sys->codecEncoderContext, sys->codecEncoder, NULL) < 0)
+		goto EXCEPTION;
+
+	return TRUE;
+EXCEPTION:
+	libavcodec_destroy_encoder_context(h264);
+	return FALSE;
+}
+
+static int libavcodec_decompress(H264_CONTEXT* WINPR_RESTRICT h264,
+                                 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize)
+{
+	union
+	{
+		const BYTE* cpv;
+		BYTE* pv;
+	} cnv;
+	int rc = -1;
+	int status = 0;
+	int gotFrame = 0;
+	AVPacket* packet = NULL;
+
+	WINPR_ASSERT(h264);
+	WINPR_ASSERT(pSrcData || (SrcSize == 0));
+
+	H264_CONTEXT_LIBAVCODEC* sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+	BYTE** pYUVData = h264->pYUVData;
+	UINT32* iStride = h264->iStride;
+
+	WINPR_ASSERT(sys);
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
+	packet = &sys->bufferpacket;
+	WINPR_ASSERT(packet);
+	av_init_packet(packet);
+#else
+	packet = av_packet_alloc();
+#endif
+	if (!packet)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to allocate AVPacket");
+		goto fail;
+	}
+
+	cnv.cpv = pSrcData;
+	packet->data = cnv.pv;
+	packet->size = (int)MIN(SrcSize, INT32_MAX);
+
+	WINPR_ASSERT(sys->codecDecoderContext);
+	/* avcodec_decode_video2 is deprecated with libavcodec 57.48.101 */
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 48, 101)
+	status = avcodec_send_packet(sys->codecDecoderContext, packet);
+
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to decode video frame (status=%d)", status);
+		goto fail;
+	}
+
+	sys->videoFrame->format = AV_PIX_FMT_YUV420P;
+
+#ifdef WITH_VAAPI
+		status = avcodec_receive_frame(sys->codecDecoderContext,
+		                               sys->hwctx ? sys->hwVideoFrame : sys->videoFrame);
+#else
+		status = avcodec_receive_frame(sys->codecDecoderContext, sys->videoFrame);
+#endif
+	    if (status == AVERROR(EAGAIN))
+	    {
+		    rc = 0;
+		    goto fail;
+	    }
+
+	gotFrame = (status == 0);
+#else
+#ifdef WITH_VAAPI
+	status =
+	    avcodec_decode_video2(sys->codecDecoderContext,
+	                          sys->hwctx ? sys->hwVideoFrame : sys->videoFrame, &gotFrame, packet);
+#else
+	status = avcodec_decode_video2(sys->codecDecoderContext, sys->videoFrame, &gotFrame, packet);
+#endif
+#endif
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to decode video frame (status=%d)", status);
+		goto fail;
+	}
+
+#ifdef WITH_VAAPI
+
+	if (sys->hwctx)
+	{
+		if (sys->hwVideoFrame->format == sys->hw_pix_fmt)
+		{
+			sys->videoFrame->width = sys->hwVideoFrame->width;
+			sys->videoFrame->height = sys->hwVideoFrame->height;
+			status = av_hwframe_transfer_data(sys->videoFrame, sys->hwVideoFrame, 0);
+		}
+		else
+		{
+			status = av_frame_copy(sys->videoFrame, sys->hwVideoFrame);
+		}
+	}
+
+	gotFrame = (status == 0);
+
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to transfer video frame (status=%d) (%s)", status,
+		           av_err2str(status));
+		goto fail;
+	}
+
+#endif
+#if 0
+	WLog_Print(h264->log, WLOG_INFO,
+	           "libavcodec_decompress: frame decoded (status=%d, gotFrame=%d, width=%d, height=%d, Y=[%p,%d], U=[%p,%d], V=[%p,%d])",
+	           status, gotFrame, sys->videoFrame->width, sys->videoFrame->height,
+	           (void*) sys->videoFrame->data[0], sys->videoFrame->linesize[0],
+	           (void*) sys->videoFrame->data[1], sys->videoFrame->linesize[1],
+	           (void*) sys->videoFrame->data[2], sys->videoFrame->linesize[2]);
+#endif
+
+	if (gotFrame)
+	{
+		WINPR_ASSERT(sys->videoFrame);
+
+		pYUVData[0] = sys->videoFrame->data[0];
+		pYUVData[1] = sys->videoFrame->data[1];
+		pYUVData[2] = sys->videoFrame->data[2];
+		iStride[0] = (UINT32)MAX(0, sys->videoFrame->linesize[0]);
+		iStride[1] = (UINT32)MAX(0, sys->videoFrame->linesize[1]);
+		iStride[2] = (UINT32)MAX(0, sys->videoFrame->linesize[2]);
+
+		rc = 1;
+	}
+	else
+		rc = -2;
+
+fail:
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
+	av_packet_unref(packet);
+#else
+	av_packet_free(&packet);
+#endif
+
+	return rc;
+}
+
+static int libavcodec_compress(H264_CONTEXT* WINPR_RESTRICT h264,
+                               const BYTE** WINPR_RESTRICT pSrcYuv,
+                               const UINT32* WINPR_RESTRICT pStride,
+                               BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
+{
+	union
+	{
+		const BYTE* cpv;
+		uint8_t* pv;
+	} cnv;
+	int rc = -1;
+	int status = 0;
+	int gotFrame = 0;
+
+	WINPR_ASSERT(h264);
+
+	H264_CONTEXT_LIBAVCODEC* sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	if (!libavcodec_create_encoder_context(h264))
+		return -1;
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
+	sys->packet = &sys->bufferpacket;
+	av_packet_unref(sys->packet);
+	av_init_packet(sys->packet);
+#else
+	av_packet_free(&sys->packet);
+	sys->packet = av_packet_alloc();
+#endif
+	if (!sys->packet)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to allocate AVPacket");
+		goto fail;
+	}
+
+	WINPR_ASSERT(sys->packet);
+	sys->packet->data = NULL;
+	sys->packet->size = 0;
+
+	WINPR_ASSERT(sys->videoFrame);
+	WINPR_ASSERT(sys->codecEncoderContext);
+	sys->videoFrame->format = AV_PIX_FMT_YUV420P;
+	sys->videoFrame->width = sys->codecEncoderContext->width;
+	sys->videoFrame->height = sys->codecEncoderContext->height;
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 48, 100)
+	sys->videoFrame->colorspace = AVCOL_SPC_BT709;
+#endif
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 92, 100)
+	sys->videoFrame->chroma_location = AVCHROMA_LOC_LEFT;
+#endif
+	cnv.cpv = pSrcYuv[0];
+	sys->videoFrame->data[0] = cnv.pv;
+
+	cnv.cpv = pSrcYuv[1];
+	sys->videoFrame->data[1] = cnv.pv;
+
+	cnv.cpv = pSrcYuv[2];
+	sys->videoFrame->data[2] = cnv.pv;
+
+	sys->videoFrame->linesize[0] = (int)pStride[0];
+	sys->videoFrame->linesize[1] = (int)pStride[1];
+	sys->videoFrame->linesize[2] = (int)pStride[2];
+	sys->videoFrame->pts++;
+
+#ifdef WITH_VAAPI_H264_ENCODING
+	if (sys->hwctx)
+	{
+		av_frame_unref(sys->hwVideoFrame);
+		if ((status = av_hwframe_get_buffer(sys->codecEncoderContext->hw_frames_ctx,
+		                                    sys->hwVideoFrame, 0)) < 0 ||
+		    !sys->hwVideoFrame->hw_frames_ctx)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "av_hwframe_get_buffer failed (%s [%d])",
+			           av_err2str(status), status);
+			goto fail;
+		}
+		sys->videoFrame->format = AV_PIX_FMT_NV12;
+		if ((status = av_hwframe_transfer_data(sys->hwVideoFrame, sys->videoFrame, 0)) < 0)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "av_hwframe_transfer_data failed (%s [%d])",
+			           av_err2str(status), status);
+			goto fail;
+		}
+	}
+#endif
+
+	/* avcodec_encode_video2 is deprecated with libavcodec 57.48.101 */
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 48, 101)
+#ifdef WITH_VAAPI_H264_ENCODING
+	status = avcodec_send_frame(sys->codecEncoderContext,
+	                            sys->hwctx ? sys->hwVideoFrame : sys->videoFrame);
+#else
+	status = avcodec_send_frame(sys->codecEncoderContext, sys->videoFrame);
+#endif
+
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to encode video frame (%s [%d])",
+		           av_err2str(status), status);
+		goto fail;
+	}
+
+	status = avcodec_receive_packet(sys->codecEncoderContext, sys->packet);
+
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to encode video frame (%s [%d])",
+		           av_err2str(status), status);
+		goto fail;
+	}
+
+	gotFrame = (status == 0);
+#elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 59, 100)
+
+	do
+	{
+		status = avcodec_encode_video2(sys->codecEncoderContext, sys->packet, sys->videoFrame,
+		                               &gotFrame);
+	} while ((status >= 0) && (gotFrame == 0));
+
+#else
+	sys->packet->size =
+	    avpicture_get_size(sys->codecDecoderContext->pix_fmt, sys->codecDecoderContext->width,
+	                       sys->codecDecoderContext->height);
+	sys->packet->data = av_malloc(sys->packet->size);
+
+	if (!sys->packet->data)
+		status = -1;
+	else
+	{
+		status = avcodec_encode_video(sys->codecDecoderContext, sys->packet->data,
+		                              sys->packet->size, sys->videoFrame);
+	}
+
+#endif
+
+	if (status < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to encode video frame (%s [%d])",
+		           av_err2str(status), status);
+		goto fail;
+	}
+
+	WINPR_ASSERT(sys->packet);
+	*ppDstData = sys->packet->data;
+	*pDstSize = (UINT32)MAX(0, sys->packet->size);
+
+	if (!gotFrame)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Did not get frame! (%s [%d])", av_err2str(status),
+		           status);
+		rc = -2;
+	}
+	else
+		rc = 1;
+fail:
+	return rc;
+}
+
+static void libavcodec_uninit(H264_CONTEXT* h264)
+{
+	WINPR_ASSERT(h264);
+
+	H264_CONTEXT_LIBAVCODEC* sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+
+	if (!sys)
+		return;
+
+	if (sys->packet)
+	{
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
+		av_packet_unref(sys->packet);
+#else
+		av_packet_free(&sys->packet);
+#endif
+	}
+
+	if (sys->videoFrame)
+	{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 18, 102)
+		av_frame_free(&sys->videoFrame);
+#else
+		av_free(sys->videoFrame);
+#endif
+	}
+
+#if defined(WITH_VAAPI) || defined(WITH_VAAPI_H264_ENCODING)
+	if (sys->hwVideoFrame)
+	{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 18, 102)
+		av_frame_free(&sys->hwVideoFrame);
+#else
+		av_free(sys->hwVideoFrame);
+#endif
+	}
+
+	if (sys->hwctx)
+		av_buffer_unref(&sys->hwctx);
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 80, 100)
+
+	if (sys->hw_frames_ctx)
+		av_buffer_unref(&sys->hw_frames_ctx);
+
+#endif
+
+#endif
+
+	if (sys->codecParser)
+		av_parser_close(sys->codecParser);
+
+	if (sys->codecDecoderContext)
+	{
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 69, 100)
+		avcodec_free_context(&sys->codecDecoderContext);
+#else
+		avcodec_close(sys->codecDecoderContext);
+		av_free(sys->codecDecoderContext);
+#endif
+	}
+
+	libavcodec_destroy_encoder_context(h264);
+	free(sys);
+	h264->pSystemData = NULL;
+}
+
+#ifdef WITH_VAAPI
+static enum AVPixelFormat libavcodec_get_format(struct AVCodecContext* ctx,
+                                                const enum AVPixelFormat* fmts)
+{
+	WINPR_ASSERT(ctx);
+
+	H264_CONTEXT* h264 = (H264_CONTEXT*)ctx->opaque;
+	WINPR_ASSERT(h264);
+
+	H264_CONTEXT_LIBAVCODEC* sys = (H264_CONTEXT_LIBAVCODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	for (const enum AVPixelFormat* p = fmts; *p != AV_PIX_FMT_NONE; p++)
+	{
+		if (*p == sys->hw_pix_fmt)
+		{
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 80, 100)
+			sys->hw_frames_ctx = av_hwframe_ctx_alloc(sys->hwctx);
+
+			if (!sys->hw_frames_ctx)
+			{
+				return AV_PIX_FMT_NONE;
+			}
+
+			sys->codecDecoderContext->pix_fmt = *p;
+			AVHWFramesContext* frames = (AVHWFramesContext*)sys->hw_frames_ctx->data;
+			frames->format = *p;
+			frames->height = sys->codecDecoderContext->coded_height;
+			frames->width = sys->codecDecoderContext->coded_width;
+			frames->sw_format =
+			    (sys->codecDecoderContext->sw_pix_fmt == AV_PIX_FMT_YUV420P10 ? AV_PIX_FMT_P010
+			                                                                  : AV_PIX_FMT_NV12);
+			frames->initial_pool_size = 20;
+
+			if (sys->codecDecoderContext->active_thread_type & FF_THREAD_FRAME)
+				frames->initial_pool_size += sys->codecDecoderContext->thread_count;
+
+			int err = av_hwframe_ctx_init(sys->hw_frames_ctx);
+
+			if (err < 0)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "Could not init hwframes context: %s",
+				           av_err2str(err));
+				return AV_PIX_FMT_NONE;
+			}
+
+			sys->codecDecoderContext->hw_frames_ctx = av_buffer_ref(sys->hw_frames_ctx);
+#endif
+			return *p;
+		}
+	}
+
+	return AV_PIX_FMT_NONE;
+}
+#endif
+
+static BOOL libavcodec_init(H264_CONTEXT* h264)
+{
+	H264_CONTEXT_LIBAVCODEC* sys = NULL;
+
+	WINPR_ASSERT(h264);
+	sys = (H264_CONTEXT_LIBAVCODEC*)calloc(1, sizeof(H264_CONTEXT_LIBAVCODEC));
+
+	if (!sys)
+	{
+		goto EXCEPTION;
+	}
+
+	h264->pSystemData = (void*)sys;
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 10, 100)
+	avcodec_register_all();
+#endif
+
+	if (!h264->Compressor)
+	{
+		sys->codecDecoder = avcodec_find_decoder(AV_CODEC_ID_H264);
+
+		if (!sys->codecDecoder)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Failed to find libav H.264 codec");
+			goto EXCEPTION;
+		}
+
+		sys->codecDecoderContext = avcodec_alloc_context3(sys->codecDecoder);
+
+		if (!sys->codecDecoderContext)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Failed to allocate libav codec context");
+			goto EXCEPTION;
+		}
+
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 18, 100)
+		if (sys->codecDecoder->capabilities & AV_CODEC_CAP_TRUNCATED)
+		{
+			sys->codecDecoderContext->flags |= AV_CODEC_FLAG_TRUNCATED;
+		}
+#endif
+
+#ifdef WITH_VAAPI
+
+		if (!sys->hwctx)
+		{
+			int ret =
+			    av_hwdevice_ctx_create(&sys->hwctx, AV_HWDEVICE_TYPE_VAAPI, VAAPI_DEVICE, NULL, 0);
+
+			if (ret < 0)
+			{
+				WLog_Print(h264->log, WLOG_ERROR,
+				           "Could not initialize hardware decoder, falling back to software: %s",
+				           av_err2str(ret));
+				sys->hwctx = NULL;
+				goto fail_hwdevice_create;
+			}
+		}
+		WLog_Print(h264->log, WLOG_INFO, "Using VAAPI for accelerated H264 decoding");
+
+		sys->codecDecoderContext->get_format = libavcodec_get_format;
+		sys->hw_pix_fmt = AV_PIX_FMT_VAAPI;
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 80, 100)
+		sys->codecDecoderContext->hw_device_ctx = av_buffer_ref(sys->hwctx);
+#endif
+		sys->codecDecoderContext->opaque = (void*)h264;
+	fail_hwdevice_create:
+#endif
+
+		if (avcodec_open2(sys->codecDecoderContext, sys->codecDecoder, NULL) < 0)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Failed to open libav codec");
+			goto EXCEPTION;
+		}
+
+		sys->codecParser = av_parser_init(AV_CODEC_ID_H264);
+
+		if (!sys->codecParser)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Failed to initialize libav parser");
+			goto EXCEPTION;
+		}
+	}
+	else
+	{
+#ifdef WITH_VAAPI_H264_ENCODING
+		if (h264->hwAccel) /* user requested hw accel */
+		{
+			sys->codecEncoder = avcodec_find_encoder_by_name("h264_vaapi");
+			if (!sys->codecEncoder)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "H264 VAAPI encoder not found");
+			}
+			else if (av_hwdevice_ctx_create(&sys->hwctx, AV_HWDEVICE_TYPE_VAAPI, VAAPI_DEVICE, NULL,
+			                                0) < 0)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "av_hwdevice_ctx_create failed");
+				sys->codecEncoder = NULL;
+				sys->hwctx = NULL;
+			}
+			else
+			{
+				WLog_Print(h264->log, WLOG_INFO, "Using VAAPI for accelerated H264 encoding");
+			}
+		}
+#endif
+		if (!sys->codecEncoder)
+		{
+			sys->codecEncoder = avcodec_find_encoder(AV_CODEC_ID_H264);
+			h264->hwAccel = FALSE; /* not supported */
+		}
+
+		if (!sys->codecEncoder)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Failed to initialize H264 encoder");
+			goto EXCEPTION;
+		}
+	}
+
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 18, 102)
+	sys->videoFrame = av_frame_alloc();
+#if defined(WITH_VAAPI) || defined(WITH_VAAPI_H264_ENCODING)
+	sys->hwVideoFrame = av_frame_alloc();
+#endif
+#else
+	sys->videoFrame = avcodec_alloc_frame();
+#endif
+
+	if (!sys->videoFrame)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to allocate libav frame");
+		goto EXCEPTION;
+	}
+
+#if defined(WITH_VAAPI) || defined(WITH_VAAPI_H264_ENCODING)
+	if (!sys->hwVideoFrame)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Failed to allocate libav hw frame");
+		goto EXCEPTION;
+	}
+
+#endif
+	sys->videoFrame->pts = 0;
+	return TRUE;
+EXCEPTION:
+	libavcodec_uninit(h264);
+	return FALSE;
+}
+
+const H264_CONTEXT_SUBSYSTEM g_Subsystem_libavcodec = { "libavcodec", libavcodec_init,
+	                                                    libavcodec_uninit, libavcodec_decompress,
+	                                                    libavcodec_compress };

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/h264_mediacodec.c

@@ -0,0 +1,527 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * H.264 Bitmap Compression
+ *
+ * Copyright 2022 Ely Ronnen <elyronnen@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <winpr/wlog.h>
+#include <winpr/assert.h>
+#include <winpr/library.h>
+
+#include <freerdp/log.h>
+#include <freerdp/codec/h264.h>
+
+#include <media/NdkMediaCodec.h>
+#include <media/NdkMediaFormat.h>
+
+#include "h264.h"
+
+static const char* CODEC_NAME = "video/avc";
+
+static const int COLOR_FormatYUV420Planar = 19;
+static const int COLOR_FormatYUV420Flexible = 0x7f420888;
+
+/* https://developer.android.com/reference/android/media/MediaCodec#qualityFloor */
+static const int MEDIACODEC_MINIMUM_WIDTH = 320;
+static const int MEDIACODEC_MINIMUM_HEIGHT = 240;
+
+typedef struct
+{
+	AMediaCodec* decoder;
+	AMediaFormat* inputFormat;
+	AMediaFormat* outputFormat;
+	int32_t width;
+	int32_t height;
+	int32_t outputWidth;
+	int32_t outputHeight;
+	ssize_t currentOutputBufferIndex;
+} H264_CONTEXT_MEDIACODEC;
+
+static AMediaFormat* mediacodec_format_new(wLog* log, int width, int height)
+{
+	const char* media_format;
+	AMediaFormat* format = AMediaFormat_new();
+	if (format == NULL)
+	{
+		WLog_Print(log, WLOG_ERROR, "AMediaFormat_new failed");
+		return NULL;
+	}
+
+	AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, CODEC_NAME);
+	AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_WIDTH, width);
+	AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_HEIGHT, height);
+	AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_COLOR_FORMAT, COLOR_FormatYUV420Planar);
+
+	media_format = AMediaFormat_toString(format);
+	if (media_format == NULL)
+	{
+		WLog_Print(log, WLOG_ERROR, "AMediaFormat_toString failed");
+		AMediaFormat_delete(format);
+		return NULL;
+	}
+
+	WLog_Print(log, WLOG_DEBUG, "MediaCodec configuring with desired output format [%s]",
+	           media_format);
+
+	return format;
+}
+
+static void set_mediacodec_format(H264_CONTEXT* h264, AMediaFormat** formatVariable,
+                                  AMediaFormat* newFormat)
+{
+	media_status_t status = AMEDIA_OK;
+	H264_CONTEXT_MEDIACODEC* sys;
+
+	WINPR_ASSERT(h264);
+	WINPR_ASSERT(formatVariable);
+
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	if (*formatVariable == newFormat)
+		return;
+
+	if (*formatVariable != NULL)
+	{
+		status = AMediaFormat_delete(*formatVariable);
+		if (status != AMEDIA_OK)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Error AMediaFormat_delete %d", status);
+		}
+	}
+
+	*formatVariable = newFormat;
+}
+
+static int update_mediacodec_inputformat(H264_CONTEXT* h264)
+{
+	H264_CONTEXT_MEDIACODEC* sys;
+	AMediaFormat* inputFormat;
+	const char* mediaFormatName;
+
+	WINPR_ASSERT(h264);
+
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+#if __ANDROID__ >= 21
+	inputFormat = AMediaCodec_getInputFormat(sys->decoder);
+	if (inputFormat == NULL)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_getInputFormat failed");
+		return -1;
+	}
+#else
+	inputFormat = sys->inputFormat;
+#endif
+	set_mediacodec_format(h264, &sys->inputFormat, inputFormat);
+
+	mediaFormatName = AMediaFormat_toString(sys->inputFormat);
+	if (mediaFormatName == NULL)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaFormat_toString failed");
+		return -1;
+	}
+	WLog_Print(h264->log, WLOG_DEBUG, "Using MediaCodec with input MediaFormat [%s]",
+	           mediaFormatName);
+
+	return 1;
+}
+
+static int update_mediacodec_outputformat(H264_CONTEXT* h264)
+{
+	H264_CONTEXT_MEDIACODEC* sys;
+	AMediaFormat* outputFormat;
+	const char* mediaFormatName;
+	int32_t outputWidth, outputHeight;
+
+	WINPR_ASSERT(h264);
+
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	outputFormat = AMediaCodec_getOutputFormat(sys->decoder);
+	if (outputFormat == NULL)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_getOutputFormat failed");
+		return -1;
+	}
+	set_mediacodec_format(h264, &sys->outputFormat, outputFormat);
+
+	mediaFormatName = AMediaFormat_toString(sys->outputFormat);
+	if (mediaFormatName == NULL)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaFormat_toString failed");
+		return -1;
+	}
+	WLog_Print(h264->log, WLOG_DEBUG, "Using MediaCodec with output MediaFormat [%s]",
+	           mediaFormatName);
+
+	if (!AMediaFormat_getInt32(sys->outputFormat, AMEDIAFORMAT_KEY_WIDTH, &outputWidth))
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "fnAMediaFormat_getInt32 failed getting width");
+		return -1;
+	}
+
+	if (!AMediaFormat_getInt32(sys->outputFormat, AMEDIAFORMAT_KEY_HEIGHT, &outputHeight))
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "fnAMediaFormat_getInt32 failed getting height");
+		return -1;
+	}
+
+	sys->outputWidth = outputWidth;
+	sys->outputHeight = outputHeight;
+
+	return 1;
+}
+
+static void release_current_outputbuffer(H264_CONTEXT* h264)
+{
+	media_status_t status = AMEDIA_OK;
+	H264_CONTEXT_MEDIACODEC* sys;
+
+	WINPR_ASSERT(h264);
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	if (sys->currentOutputBufferIndex < 0)
+	{
+		return;
+	}
+
+	status = AMediaCodec_releaseOutputBuffer(sys->decoder, sys->currentOutputBufferIndex, FALSE);
+	if (status != AMEDIA_OK)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "Error AMediaCodec_releaseOutputBuffer %d", status);
+	}
+
+	sys->currentOutputBufferIndex = -1;
+}
+
+static int mediacodec_compress(H264_CONTEXT* h264, const BYTE** pSrcYuv, const UINT32* pStride,
+                               BYTE** ppDstData, UINT32* pDstSize)
+{
+	WINPR_ASSERT(h264);
+	WINPR_ASSERT(pSrcYuv);
+	WINPR_ASSERT(pStride);
+	WINPR_ASSERT(ppDstData);
+	WINPR_ASSERT(pDstSize);
+
+	WLog_Print(h264->log, WLOG_ERROR, "MediaCodec is not supported as an encoder");
+	return -1;
+}
+
+static int mediacodec_decompress(H264_CONTEXT* h264, const BYTE* pSrcData, UINT32 SrcSize)
+{
+	ssize_t inputBufferId = -1;
+	size_t inputBufferSize, outputBufferSize;
+	uint8_t* inputBuffer;
+	media_status_t status;
+	BYTE** pYUVData;
+	UINT32* iStride;
+	H264_CONTEXT_MEDIACODEC* sys;
+
+	WINPR_ASSERT(h264);
+	WINPR_ASSERT(pSrcData);
+
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+	WINPR_ASSERT(sys);
+
+	pYUVData = h264->pYUVData;
+	WINPR_ASSERT(pYUVData);
+
+	iStride = h264->iStride;
+	WINPR_ASSERT(iStride);
+
+	release_current_outputbuffer(h264);
+
+	if (sys->width != h264->width || sys->height != h264->height)
+	{
+		sys->width = h264->width;
+		sys->height = h264->height;
+
+		if (sys->width < MEDIACODEC_MINIMUM_WIDTH || sys->height < MEDIACODEC_MINIMUM_HEIGHT)
+		{
+			WLog_Print(h264->log, WLOG_ERROR,
+			           "MediaCodec got width or height smaller than minimum [%d,%d]", sys->width,
+			           sys->height);
+			return -1;
+		}
+
+		WLog_Print(h264->log, WLOG_DEBUG, "MediaCodec setting new input width and height [%d,%d]",
+		           sys->width, sys->height);
+
+#if __ANDROID__ >= 26
+		AMediaFormat_setInt32(sys->inputFormat, AMEDIAFORMAT_KEY_WIDTH, sys->width);
+		AMediaFormat_setInt32(sys->inputFormat, AMEDIAFORMAT_KEY_HEIGHT, sys->height);
+		status = AMediaCodec_setParameters(sys->decoder, sys->inputFormat);
+		if (status != AMEDIA_OK)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_setParameters failed: %d", status);
+			return -1;
+		}
+#else
+		set_mediacodec_format(h264, &sys->inputFormat,
+		                      mediacodec_format_new(h264->log, sys->width, sys->height));
+#endif
+
+		// The codec can change output width and height
+		if (update_mediacodec_outputformat(h264) < 0)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "MediaCodec failed updating input format");
+			return -1;
+		}
+	}
+
+	while (true)
+	{
+		UINT32 inputBufferCurrnetOffset = 0;
+		while (inputBufferCurrnetOffset < SrcSize)
+		{
+			UINT32 numberOfBytesToCopy = SrcSize - inputBufferCurrnetOffset;
+			inputBufferId = AMediaCodec_dequeueInputBuffer(sys->decoder, -1);
+			if (inputBufferId < 0)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_dequeueInputBuffer failed [%d]",
+				           inputBufferId);
+				// TODO: sleep?
+				continue;
+			}
+
+			inputBuffer = AMediaCodec_getInputBuffer(sys->decoder, inputBufferId, &inputBufferSize);
+			if (inputBuffer == NULL)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_getInputBuffer failed");
+				return -1;
+			}
+
+			if (numberOfBytesToCopy > inputBufferSize)
+			{
+				WLog_Print(h264->log, WLOG_WARN,
+				           "MediaCodec inputBufferSize: got [%d] but wanted [%d]", inputBufferSize,
+				           numberOfBytesToCopy);
+				numberOfBytesToCopy = inputBufferSize;
+			}
+
+			memcpy(inputBuffer, pSrcData + inputBufferCurrnetOffset, numberOfBytesToCopy);
+			inputBufferCurrnetOffset += numberOfBytesToCopy;
+
+			status = AMediaCodec_queueInputBuffer(sys->decoder, inputBufferId, 0,
+			                                      numberOfBytesToCopy, 0, 0);
+			if (status != AMEDIA_OK)
+			{
+				WLog_Print(h264->log, WLOG_ERROR, "Error AMediaCodec_queueInputBuffer %d", status);
+				return -1;
+			}
+		}
+
+		while (true)
+		{
+			AMediaCodecBufferInfo bufferInfo;
+			ssize_t outputBufferId = AMediaCodec_dequeueOutputBuffer(sys->decoder, &bufferInfo, -1);
+			if (outputBufferId >= 0)
+			{
+				sys->currentOutputBufferIndex = outputBufferId;
+
+				uint8_t* outputBuffer;
+				outputBuffer =
+				    AMediaCodec_getOutputBuffer(sys->decoder, outputBufferId, &outputBufferSize);
+				sys->currentOutputBufferIndex = outputBufferId;
+
+				if (outputBufferSize !=
+				    (sys->outputWidth * sys->outputHeight +
+				     ((sys->outputWidth + 1) / 2) * ((sys->outputHeight + 1) / 2) * 2))
+				{
+					WLog_Print(h264->log, WLOG_ERROR,
+					           "Error MediaCodec unexpected output buffer size %d",
+					           outputBufferSize);
+					return -1;
+				}
+
+				// TODO: work with AImageReader and get AImage object instead of
+				// COLOR_FormatYUV420Planar buffer.
+				iStride[0] = sys->outputWidth;
+				iStride[1] = (sys->outputWidth + 1) / 2;
+				iStride[2] = (sys->outputWidth + 1) / 2;
+				pYUVData[0] = outputBuffer;
+				pYUVData[1] = outputBuffer + iStride[0] * sys->outputHeight;
+				pYUVData[2] = outputBuffer + iStride[0] * sys->outputHeight +
+				              iStride[1] * ((sys->outputHeight + 1) / 2);
+				break;
+			}
+			else if (outputBufferId == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED)
+			{
+				if (update_mediacodec_outputformat(h264) < 0)
+				{
+					WLog_Print(h264->log, WLOG_ERROR,
+					           "MediaCodec failed updating output format in decompress");
+					return -1;
+				}
+			}
+			else if (outputBufferId == AMEDIACODEC_INFO_TRY_AGAIN_LATER)
+			{
+				WLog_Print(h264->log, WLOG_WARN,
+				           "AMediaCodec_dequeueOutputBuffer need to try again later");
+				// TODO: sleep?
+			}
+			else if (outputBufferId == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)
+			{
+				WLog_Print(h264->log, WLOG_WARN,
+				           "AMediaCodec_dequeueOutputBuffer returned deprecated value "
+				           "AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED, ignoring");
+			}
+			else
+			{
+				WLog_Print(h264->log, WLOG_ERROR,
+				           "AMediaCodec_dequeueOutputBuffer returned unknown value [%d]",
+				           outputBufferId);
+				return -1;
+			}
+		}
+
+		break;
+	}
+
+	return 1;
+}
+
+static void mediacodec_uninit(H264_CONTEXT* h264)
+{
+	media_status_t status = AMEDIA_OK;
+	H264_CONTEXT_MEDIACODEC* sys;
+
+	WINPR_ASSERT(h264);
+
+	sys = (H264_CONTEXT_MEDIACODEC*)h264->pSystemData;
+
+	WLog_Print(h264->log, WLOG_DEBUG, "Uninitializing MediaCodec");
+
+	if (!sys)
+		return;
+
+	if (sys->decoder != NULL)
+	{
+		release_current_outputbuffer(h264);
+		status = AMediaCodec_stop(sys->decoder);
+		if (status != AMEDIA_OK)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Error AMediaCodec_stop %d", status);
+		}
+
+		status = AMediaCodec_delete(sys->decoder);
+		if (status != AMEDIA_OK)
+		{
+			WLog_Print(h264->log, WLOG_ERROR, "Error AMediaCodec_delete %d", status);
+		}
+
+		sys->decoder = NULL;
+	}
+
+	set_mediacodec_format(h264, &sys->inputFormat, NULL);
+	set_mediacodec_format(h264, &sys->outputFormat, NULL);
+
+	free(sys);
+	h264->pSystemData = NULL;
+}
+
+static BOOL mediacodec_init(H264_CONTEXT* h264)
+{
+	H264_CONTEXT_MEDIACODEC* sys;
+	media_status_t status;
+
+	WINPR_ASSERT(h264);
+
+	if (h264->Compressor)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "MediaCodec is not supported as an encoder");
+		goto EXCEPTION;
+	}
+
+	WLog_Print(h264->log, WLOG_DEBUG, "Initializing MediaCodec");
+
+	sys = (H264_CONTEXT_MEDIACODEC*)calloc(1, sizeof(H264_CONTEXT_MEDIACODEC));
+
+	if (!sys)
+	{
+		goto EXCEPTION;
+	}
+
+	h264->pSystemData = (void*)sys;
+
+	sys->currentOutputBufferIndex = -1;
+
+	// updated when we're given the height and width for the first time
+	sys->width = sys->outputWidth = MEDIACODEC_MINIMUM_WIDTH;
+	sys->height = sys->outputHeight = MEDIACODEC_MINIMUM_HEIGHT;
+	sys->decoder = AMediaCodec_createDecoderByType(CODEC_NAME);
+	if (sys->decoder == NULL)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_createCodecByName failed");
+		goto EXCEPTION;
+	}
+
+#if __ANDROID_API__ >= 28
+	char* codec_name;
+	status = AMediaCodec_getName(sys->decoder, &codec_name);
+	if (status != AMEDIA_OK)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_getName failed: %d", status);
+		goto EXCEPTION;
+	}
+
+	WLog_Print(h264->log, WLOG_DEBUG, "MediaCodec using %s codec [%s]", CODEC_NAME, codec_name);
+	AMediaCodec_releaseName(sys->decoder, codec_name);
+#endif
+
+	set_mediacodec_format(h264, &sys->inputFormat,
+	                      mediacodec_format_new(h264->log, sys->width, sys->height));
+
+	status = AMediaCodec_configure(sys->decoder, sys->inputFormat, NULL, NULL, 0);
+	if (status != AMEDIA_OK)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_configure failed: %d", status);
+		goto EXCEPTION;
+	}
+
+	if (update_mediacodec_inputformat(h264) < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "MediaCodec failed updating input format");
+		goto EXCEPTION;
+	}
+
+	if (update_mediacodec_outputformat(h264) < 0)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "MediaCodec failed updating output format");
+		goto EXCEPTION;
+	}
+
+	WLog_Print(h264->log, WLOG_DEBUG, "Starting MediaCodec");
+	status = AMediaCodec_start(sys->decoder);
+	if (status != AMEDIA_OK)
+	{
+		WLog_Print(h264->log, WLOG_ERROR, "AMediaCodec_start failed %d", status);
+		goto EXCEPTION;
+	}
+
+	return TRUE;
+EXCEPTION:
+	mediacodec_uninit(h264);
+	return FALSE;
+}
+
+const H264_CONTEXT_SUBSYSTEM g_Subsystem_mediacodec = { "MediaCodec", mediacodec_init,
+	                                                    mediacodec_uninit, mediacodec_decompress,
+	                                                    mediacodec_compress };

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/nsc.c

@@ -0,0 +1,512 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * NSCodec Codec
+ *
+ * Copyright 2011 Samsung, Author Jiten Pathy
+ * Copyright 2012 Vic Lee
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+#include <winpr/crt.h>
+
+#include <freerdp/codec/nsc.h>
+#include <freerdp/codec/color.h>
+
+#include "nsc_types.h"
+#include "nsc_encode.h"
+
+#include "sse/nsc_sse2.h"
+#include "neon/nsc_neon.h"
+
+#include <freerdp/log.h>
+
+static BOOL nsc_decode(NSC_CONTEXT* WINPR_RESTRICT context)
+{
+	size_t pos = 0;
+
+	if (!context)
+		return FALSE;
+
+	const UINT16 rw = ROUND_UP_TO(context->width, 8);
+	WINPR_ASSERT(context->ColorLossLevel >= 1);
+	const BYTE shift = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel -
+	                                                      1); /* colorloss recovery + YCoCg shift */
+	BYTE* bmpdata = context->BitmapData;
+
+	if (!bmpdata)
+		return FALSE;
+
+	for (size_t y = 0; y < context->height; y++)
+	{
+		const BYTE* yplane = NULL;
+		const BYTE* coplane = NULL;
+		const BYTE* cgplane = NULL;
+		const BYTE* aplane = context->priv->PlaneBuffers[3] + y * context->width; /* A */
+
+		if (context->ChromaSubsamplingLevel)
+		{
+			yplane = context->priv->PlaneBuffers[0] + y * rw;                /* Y */
+			coplane = context->priv->PlaneBuffers[1] + (y >> 1) * (rw >> 1); /* Co, supersampled */
+			cgplane = context->priv->PlaneBuffers[2] + (y >> 1) * (rw >> 1); /* Cg, supersampled */
+		}
+		else
+		{
+			yplane = context->priv->PlaneBuffers[0] + y * context->width;  /* Y */
+			coplane = context->priv->PlaneBuffers[1] + y * context->width; /* Co */
+			cgplane = context->priv->PlaneBuffers[2] + y * context->width; /* Cg */
+		}
+
+		for (UINT32 x = 0; x < context->width; x++)
+		{
+			INT16 y_val = (INT16)*yplane;
+			INT16 co_val = (INT16)(INT8)(((INT16)*coplane) << shift);
+			INT16 cg_val = (INT16)(INT8)(((INT16)*cgplane) << shift);
+			INT16 r_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + co_val - cg_val);
+			INT16 g_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + cg_val);
+			INT16 b_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val - co_val - cg_val);
+
+			if (pos + 4 > context->BitmapDataLength)
+				return FALSE;
+
+			pos += 4;
+			*bmpdata++ = MINMAX(b_val, 0, 0xFF);
+			*bmpdata++ = MINMAX(g_val, 0, 0xFF);
+			*bmpdata++ = MINMAX(r_val, 0, 0xFF);
+			*bmpdata++ = *aplane;
+			yplane++;
+			coplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
+			cgplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
+			aplane++;
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL nsc_rle_decode(const BYTE* WINPR_RESTRICT in, size_t inSize, BYTE* WINPR_RESTRICT out,
+                           UINT32 outSize, UINT32 originalSize)
+{
+	UINT32 left = originalSize;
+
+	while (left > 4)
+	{
+		if (inSize < 1)
+			return FALSE;
+		inSize--;
+
+		const BYTE value = *in++;
+		UINT32 len = 0;
+
+		if (left == 5)
+		{
+			if (outSize < 1)
+				return FALSE;
+
+			outSize--;
+			*out++ = value;
+			left--;
+		}
+		else if (inSize < 1)
+			return FALSE;
+		else if (value == *in)
+		{
+			inSize--;
+			in++;
+
+			if (inSize < 1)
+				return FALSE;
+			else if (*in < 0xFF)
+			{
+				inSize--;
+				len = (UINT32)*in++;
+				len += 2;
+			}
+			else
+			{
+				if (inSize < 5)
+					return FALSE;
+				inSize -= 5;
+				in++;
+				len = ((UINT32)(*in++));
+				len |= ((UINT32)(*in++)) << 8U;
+				len |= ((UINT32)(*in++)) << 16U;
+				len |= ((UINT32)(*in++)) << 24U;
+			}
+
+			if ((outSize < len) || (left < len))
+				return FALSE;
+
+			outSize -= len;
+			FillMemory(out, len, value);
+			out += len;
+			left -= len;
+		}
+		else
+		{
+			if (outSize < 1)
+				return FALSE;
+
+			outSize--;
+			*out++ = value;
+			left--;
+		}
+	}
+
+	if ((outSize < 4) || (left < 4))
+		return FALSE;
+
+	if (inSize < 4)
+		return FALSE;
+	memcpy(out, in, 4);
+	return TRUE;
+}
+
+static BOOL nsc_rle_decompress_data(NSC_CONTEXT* WINPR_RESTRICT context)
+{
+	if (!context)
+		return FALSE;
+
+	const BYTE* rle = context->Planes;
+	size_t rleSize = context->PlanesSize;
+	WINPR_ASSERT(rle);
+
+	for (size_t i = 0; i < 4; i++)
+	{
+		const UINT32 originalSize = context->OrgByteCount[i];
+		const UINT32 planeSize = context->PlaneByteCount[i];
+
+		if (rleSize < planeSize)
+			return FALSE;
+
+		if (planeSize == 0)
+		{
+			if (context->priv->PlaneBuffersLength < originalSize)
+				return FALSE;
+
+			FillMemory(context->priv->PlaneBuffers[i], originalSize, 0xFF);
+		}
+		else if (planeSize < originalSize)
+		{
+			if (!nsc_rle_decode(rle, rleSize, context->priv->PlaneBuffers[i],
+			                    context->priv->PlaneBuffersLength, originalSize))
+				return FALSE;
+		}
+		else
+		{
+			if (context->priv->PlaneBuffersLength < originalSize)
+				return FALSE;
+
+			if (rleSize < originalSize)
+				return FALSE;
+
+			CopyMemory(context->priv->PlaneBuffers[i], rle, originalSize);
+		}
+
+		rle += planeSize;
+		rleSize -= planeSize;
+	}
+
+	return TRUE;
+}
+
+static BOOL nsc_stream_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->priv);
+	if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 20))
+		return FALSE;
+
+	size_t total = 0;
+	for (size_t i = 0; i < 4; i++)
+	{
+		Stream_Read_UINT32(s, context->PlaneByteCount[i]);
+		total += context->PlaneByteCount[i];
+	}
+
+	Stream_Read_UINT8(s, context->ColorLossLevel);         /* ColorLossLevel (1 byte) */
+	if ((context->ColorLossLevel < 1) || (context->ColorLossLevel > 7))
+	{
+		WLog_Print(context->priv->log, WLOG_ERROR,
+		           "ColorLossLevel=%" PRIu8 " out of range, must be [1,7] inclusive",
+		           context->ColorLossLevel);
+		return FALSE;
+	}
+	Stream_Read_UINT8(s, context->ChromaSubsamplingLevel); /* ChromaSubsamplingLevel (1 byte) */
+	Stream_Seek(s, 2);                                     /* Reserved (2 bytes) */
+	context->Planes = Stream_Pointer(s);
+	context->PlanesSize = total;
+	return Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, total);
+}
+
+static BOOL nsc_context_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
+{
+	if (!nsc_stream_initialize(context, s))
+		return FALSE;
+
+	const size_t blength = 4ull * context->width * context->height;
+
+	if (!context->BitmapData || (blength > context->BitmapDataLength))
+	{
+		void* tmp = winpr_aligned_recalloc(context->BitmapData, blength + 16, sizeof(BYTE), 32);
+
+		if (!tmp)
+			return FALSE;
+
+		context->BitmapData = tmp;
+		context->BitmapDataLength = blength;
+	}
+
+	const UINT32 tempWidth = ROUND_UP_TO(context->width, 8);
+	const UINT32 tempHeight = ROUND_UP_TO(context->height, 2);
+	/* The maximum length a decoded plane can reach in all cases */
+	const size_t plength = 1ull * tempWidth * tempHeight;
+	if (plength > UINT32_MAX)
+		return FALSE;
+
+	if (plength > context->priv->PlaneBuffersLength)
+	{
+		for (size_t i = 0; i < 4; i++)
+		{
+			void* tmp = (BYTE*)winpr_aligned_recalloc(context->priv->PlaneBuffers[i], plength,
+			                                          sizeof(BYTE), 32);
+
+			if (!tmp)
+				return FALSE;
+
+			context->priv->PlaneBuffers[i] = tmp;
+		}
+
+		context->priv->PlaneBuffersLength = (UINT32)plength;
+	}
+
+	for (size_t i = 0; i < 4; i++)
+		context->OrgByteCount[i] = context->width * context->height;
+
+	if (context->ChromaSubsamplingLevel)
+	{
+		context->OrgByteCount[0] = tempWidth * context->height;
+		context->OrgByteCount[1] = (tempWidth >> 1) * (tempHeight >> 1);
+		context->OrgByteCount[2] = context->OrgByteCount[1];
+	}
+
+	return TRUE;
+}
+
+static void nsc_profiler_print(NSC_CONTEXT_PRIV* WINPR_RESTRICT priv)
+{
+	WINPR_UNUSED(priv);
+
+	PROFILER_PRINT_HEADER
+	PROFILER_PRINT(priv->prof_nsc_rle_decompress_data)
+	PROFILER_PRINT(priv->prof_nsc_decode)
+	PROFILER_PRINT(priv->prof_nsc_rle_compress_data)
+	PROFILER_PRINT(priv->prof_nsc_encode)
+	PROFILER_PRINT_FOOTER
+}
+
+BOOL nsc_context_reset(NSC_CONTEXT* WINPR_RESTRICT context, UINT32 width, UINT32 height)
+{
+	if (!context)
+		return FALSE;
+
+	if ((width > UINT16_MAX) || (height > UINT16_MAX))
+		return FALSE;
+
+	context->width = (UINT16)width;
+	context->height = (UINT16)height;
+	return TRUE;
+}
+
+NSC_CONTEXT* nsc_context_new(void)
+{
+	NSC_CONTEXT* context = (NSC_CONTEXT*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT), 32);
+
+	if (!context)
+		return NULL;
+
+	context->priv = (NSC_CONTEXT_PRIV*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT_PRIV), 32);
+
+	if (!context->priv)
+		goto error;
+
+	context->priv->log = WLog_Get("com.freerdp.codec.nsc");
+	WLog_OpenAppender(context->priv->log);
+	context->BitmapData = NULL;
+	context->decode = nsc_decode;
+	context->encode = nsc_encode;
+
+	PROFILER_CREATE(context->priv->prof_nsc_rle_decompress_data, "nsc_rle_decompress_data")
+	PROFILER_CREATE(context->priv->prof_nsc_decode, "nsc_decode")
+	PROFILER_CREATE(context->priv->prof_nsc_rle_compress_data, "nsc_rle_compress_data")
+	PROFILER_CREATE(context->priv->prof_nsc_encode, "nsc_encode")
+	/* Default encoding parameters */
+	context->ColorLossLevel = 3;
+	context->ChromaSubsamplingLevel = 1;
+	/* init optimized methods */
+	nsc_init_sse2(context);
+	nsc_init_neon(context);
+	return context;
+error:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	nsc_context_free(context);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void nsc_context_free(NSC_CONTEXT* context)
+{
+	if (!context)
+		return;
+
+	if (context->priv)
+	{
+		for (size_t i = 0; i < 5; i++)
+			winpr_aligned_free(context->priv->PlaneBuffers[i]);
+
+		nsc_profiler_print(context->priv);
+		PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data)
+		PROFILER_FREE(context->priv->prof_nsc_decode)
+		PROFILER_FREE(context->priv->prof_nsc_rle_compress_data)
+		PROFILER_FREE(context->priv->prof_nsc_encode)
+		winpr_aligned_free(context->priv);
+	}
+
+	winpr_aligned_free(context->BitmapData);
+	winpr_aligned_free(context);
+}
+
+#if defined(WITH_FREERDP_DEPRECATED)
+BOOL nsc_context_set_pixel_format(NSC_CONTEXT* context, UINT32 pixel_format)
+{
+	return nsc_context_set_parameters(context, NSC_COLOR_FORMAT, pixel_format);
+}
+#endif
+
+BOOL nsc_context_set_parameters(NSC_CONTEXT* WINPR_RESTRICT context, NSC_PARAMETER what,
+                                UINT32 value)
+{
+	if (!context)
+		return FALSE;
+
+	switch (what)
+	{
+		case NSC_COLOR_LOSS_LEVEL:
+			context->ColorLossLevel = value;
+			break;
+		case NSC_ALLOW_SUBSAMPLING:
+			context->ChromaSubsamplingLevel = value;
+			break;
+		case NSC_DYNAMIC_COLOR_FIDELITY:
+			context->DynamicColorFidelity = value != 0;
+			break;
+		case NSC_COLOR_FORMAT:
+			context->format = value;
+			break;
+		default:
+			return FALSE;
+	}
+	return TRUE;
+}
+
+BOOL nsc_process_message(NSC_CONTEXT* WINPR_RESTRICT context, UINT16 bpp, UINT32 width,
+                         UINT32 height, const BYTE* data, UINT32 length,
+                         BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStride,
+                         UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 flip)
+{
+	wStream* s = NULL;
+	wStream sbuffer = { 0 };
+	BOOL ret = 0;
+	if (!context || !data || !pDstData)
+		return FALSE;
+
+	s = Stream_StaticConstInit(&sbuffer, data, length);
+
+	if (!s)
+		return FALSE;
+
+	if (nDstStride == 0)
+		nDstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	switch (bpp)
+	{
+		case 32:
+			context->format = PIXEL_FORMAT_BGRA32;
+			break;
+
+		case 24:
+			context->format = PIXEL_FORMAT_BGR24;
+			break;
+
+		case 16:
+			context->format = PIXEL_FORMAT_BGR16;
+			break;
+
+		case 8:
+			context->format = PIXEL_FORMAT_RGB8;
+			break;
+
+		case 4:
+			context->format = PIXEL_FORMAT_A4;
+			break;
+
+		default:
+			return FALSE;
+	}
+
+	context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
+	context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
+	ret = nsc_context_initialize(context, s);
+
+	if (!ret)
+		return FALSE;
+
+	/* RLE decode */
+	{
+		BOOL rc = 0;
+		PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
+		rc = nsc_rle_decompress_data(context);
+		PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)
+
+		if (!rc)
+			return FALSE;
+	}
+	/* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
+	{
+		BOOL rc = 0;
+		PROFILER_ENTER(context->priv->prof_nsc_decode)
+		rc = context->decode(context);
+		PROFILER_EXIT(context->priv->prof_nsc_decode)
+
+		if (!rc)
+			return FALSE;
+	}
+
+	if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width, height,
+	                                   context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0, NULL,
+	                                   flip))
+		return FALSE;
+
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/nsc_encode.c

@@ -0,0 +1,541 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * NSCodec Encoder
+ *
+ * Copyright 2012 Vic Lee
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+#include <winpr/crt.h>
+
+#include <freerdp/codec/nsc.h>
+#include <freerdp/codec/color.h>
+
+#include "nsc_types.h"
+#include "nsc_encode.h"
+
+typedef struct
+{
+	UINT32 x;
+	UINT32 y;
+	UINT32 width;
+	UINT32 height;
+	const BYTE* data;
+	UINT32 scanline;
+	BYTE* PlaneBuffer;
+	UINT32 MaxPlaneSize;
+	BYTE* PlaneBuffers[5];
+	UINT32 OrgByteCount[4];
+
+	UINT32 LumaPlaneByteCount;
+	UINT32 OrangeChromaPlaneByteCount;
+	UINT32 GreenChromaPlaneByteCount;
+	UINT32 AlphaPlaneByteCount;
+	UINT8 ColorLossLevel;
+	UINT8 ChromaSubsamplingLevel;
+} NSC_MESSAGE;
+
+static BOOL nsc_write_message(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
+                              const NSC_MESSAGE* WINPR_RESTRICT message);
+
+static BOOL nsc_context_initialize_encode(NSC_CONTEXT* WINPR_RESTRICT context)
+{
+	UINT32 length = 0;
+	UINT32 tempWidth = 0;
+	UINT32 tempHeight = 0;
+	tempWidth = ROUND_UP_TO(context->width, 8);
+	tempHeight = ROUND_UP_TO(context->height, 2);
+	/* The maximum length a decoded plane can reach in all cases */
+	length = tempWidth * tempHeight + 16;
+
+	if (length > context->priv->PlaneBuffersLength)
+	{
+		for (int i = 0; i < 5; i++)
+		{
+			BYTE* tmp = (BYTE*)winpr_aligned_recalloc(context->priv->PlaneBuffers[i], length,
+			                                          sizeof(BYTE), 32);
+
+			if (!tmp)
+				goto fail;
+
+			context->priv->PlaneBuffers[i] = tmp;
+		}
+
+		context->priv->PlaneBuffersLength = length;
+	}
+
+	if (context->ChromaSubsamplingLevel)
+	{
+		context->OrgByteCount[0] = tempWidth * context->height;
+		context->OrgByteCount[1] = tempWidth * tempHeight / 4;
+		context->OrgByteCount[2] = tempWidth * tempHeight / 4;
+		context->OrgByteCount[3] = context->width * context->height;
+	}
+	else
+	{
+		context->OrgByteCount[0] = context->width * context->height;
+		context->OrgByteCount[1] = context->width * context->height;
+		context->OrgByteCount[2] = context->width * context->height;
+		context->OrgByteCount[3] = context->width * context->height;
+	}
+
+	return TRUE;
+fail:
+
+	if (length > context->priv->PlaneBuffersLength)
+	{
+		for (int i = 0; i < 5; i++)
+			winpr_aligned_free(context->priv->PlaneBuffers[i]);
+	}
+
+	return FALSE;
+}
+
+static BOOL nsc_encode_argb_to_aycocg(NSC_CONTEXT* WINPR_RESTRICT context,
+                                      const BYTE* WINPR_RESTRICT data, UINT32 scanline)
+{
+	size_t y = 0;
+	const BYTE* src = NULL;
+	BYTE* yplane = NULL;
+	BYTE* coplane = NULL;
+	BYTE* cgplane = NULL;
+	BYTE* aplane = NULL;
+	INT16 r_val = 0;
+	INT16 g_val = 0;
+	INT16 b_val = 0;
+	BYTE a_val = 0;
+
+	UINT16 tempWidth = ROUND_UP_TO(context->width, 8);
+	const UINT16 rw = (context->ChromaSubsamplingLevel ? tempWidth : context->width);
+	const BYTE ccl = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel);
+
+	for (; y < context->height; y++)
+	{
+		src = data + (context->height - 1 - y) * scanline;
+		yplane = context->priv->PlaneBuffers[0] + y * rw;
+		coplane = context->priv->PlaneBuffers[1] + y * rw;
+		cgplane = context->priv->PlaneBuffers[2] + y * rw;
+		aplane = context->priv->PlaneBuffers[3] + y * context->width;
+
+		UINT16 x = 0;
+		for (; x < context->width; x++)
+		{
+			switch (context->format)
+			{
+				case PIXEL_FORMAT_BGRX32:
+					b_val = *src++;
+					g_val = *src++;
+					r_val = *src++;
+					src++;
+					a_val = 0xFF;
+					break;
+
+				case PIXEL_FORMAT_BGRA32:
+					b_val = *src++;
+					g_val = *src++;
+					r_val = *src++;
+					a_val = *src++;
+					break;
+
+				case PIXEL_FORMAT_RGBX32:
+					r_val = *src++;
+					g_val = *src++;
+					b_val = *src++;
+					src++;
+					a_val = 0xFF;
+					break;
+
+				case PIXEL_FORMAT_RGBA32:
+					r_val = *src++;
+					g_val = *src++;
+					b_val = *src++;
+					a_val = *src++;
+					break;
+
+				case PIXEL_FORMAT_BGR24:
+					b_val = *src++;
+					g_val = *src++;
+					r_val = *src++;
+					a_val = 0xFF;
+					break;
+
+				case PIXEL_FORMAT_RGB24:
+					r_val = *src++;
+					g_val = *src++;
+					b_val = *src++;
+					a_val = 0xFF;
+					break;
+
+				case PIXEL_FORMAT_BGR16:
+					b_val = (INT16)(((*(src + 1)) & 0xF8) | ((*(src + 1)) >> 5));
+					g_val = (INT16)((((*(src + 1)) & 0x07) << 5) | (((*src) & 0xE0) >> 3));
+					r_val = (INT16)((((*src) & 0x1F) << 3) | (((*src) >> 2) & 0x07));
+					a_val = 0xFF;
+					src += 2;
+					break;
+
+				case PIXEL_FORMAT_RGB16:
+					r_val = (INT16)(((*(src + 1)) & 0xF8) | ((*(src + 1)) >> 5));
+					g_val = (INT16)((((*(src + 1)) & 0x07) << 5) | (((*src) & 0xE0) >> 3));
+					b_val = (INT16)((((*src) & 0x1F) << 3) | (((*src) >> 2) & 0x07));
+					a_val = 0xFF;
+					src += 2;
+					break;
+
+				case PIXEL_FORMAT_A4:
+				{
+					int shift = 0;
+					BYTE idx = 0;
+					shift = (7 - (x % 8));
+					idx = ((*src) >> shift) & 1;
+					idx |= (((*(src + 1)) >> shift) & 1) << 1;
+					idx |= (((*(src + 2)) >> shift) & 1) << 2;
+					idx |= (((*(src + 3)) >> shift) & 1) << 3;
+					idx *= 3;
+					r_val = (INT16)context->palette[idx];
+					g_val = (INT16)context->palette[idx + 1];
+					b_val = (INT16)context->palette[idx + 2];
+
+					if (shift == 0)
+						src += 4;
+				}
+
+					a_val = 0xFF;
+					break;
+
+				case PIXEL_FORMAT_RGB8:
+				{
+					int idx = (*src) * 3;
+					r_val = (INT16)context->palette[idx];
+					g_val = (INT16)context->palette[idx + 1];
+					b_val = (INT16)context->palette[idx + 2];
+					src++;
+				}
+
+					a_val = 0xFF;
+					break;
+
+				default:
+					r_val = g_val = b_val = a_val = 0;
+					break;
+			}
+
+			*yplane++ = (BYTE)((r_val >> 2) + (g_val >> 1) + (b_val >> 2));
+			/* Perform color loss reduction here */
+			*coplane++ = (BYTE)((r_val - b_val) >> ccl);
+			*cgplane++ = (BYTE)((-(r_val >> 1) + g_val - (b_val >> 1)) >> ccl);
+			*aplane++ = a_val;
+		}
+
+		if (context->ChromaSubsamplingLevel && (x % 2) == 1)
+		{
+			*yplane = *(yplane - 1);
+			*coplane = *(coplane - 1);
+			*cgplane = *(cgplane - 1);
+		}
+	}
+
+	if (context->ChromaSubsamplingLevel && (y % 2) == 1)
+	{
+		yplane = context->priv->PlaneBuffers[0] + y * rw;
+		coplane = context->priv->PlaneBuffers[1] + y * rw;
+		cgplane = context->priv->PlaneBuffers[2] + y * rw;
+		CopyMemory(yplane, yplane - rw, rw);
+		CopyMemory(coplane, coplane - rw, rw);
+		CopyMemory(cgplane, cgplane - rw, rw);
+	}
+
+	return TRUE;
+}
+
+static BOOL nsc_encode_subsampling(NSC_CONTEXT* WINPR_RESTRICT context)
+{
+	UINT32 tempWidth = 0;
+	UINT32 tempHeight = 0;
+
+	if (!context)
+		return FALSE;
+
+	tempWidth = ROUND_UP_TO(context->width, 8);
+	tempHeight = ROUND_UP_TO(context->height, 2);
+
+	if (tempHeight == 0)
+		return FALSE;
+
+	if (tempWidth > context->priv->PlaneBuffersLength / tempHeight)
+		return FALSE;
+
+	for (size_t y = 0; y < tempHeight >> 1; y++)
+	{
+		BYTE* co_dst = context->priv->PlaneBuffers[1] + y * (tempWidth >> 1);
+		BYTE* cg_dst = context->priv->PlaneBuffers[2] + y * (tempWidth >> 1);
+		const INT8* co_src0 = (INT8*)context->priv->PlaneBuffers[1] + (y << 1) * tempWidth;
+		const INT8* co_src1 = co_src0 + tempWidth;
+		const INT8* cg_src0 = (INT8*)context->priv->PlaneBuffers[2] + (y << 1) * tempWidth;
+		const INT8* cg_src1 = cg_src0 + tempWidth;
+
+		for (UINT32 x = 0; x < tempWidth >> 1; x++)
+		{
+			*co_dst++ = (BYTE)(((INT16)*co_src0 + (INT16) * (co_src0 + 1) + (INT16)*co_src1 +
+			                    (INT16) * (co_src1 + 1)) >>
+			                   2);
+			*cg_dst++ = (BYTE)(((INT16)*cg_src0 + (INT16) * (cg_src0 + 1) + (INT16)*cg_src1 +
+			                    (INT16) * (cg_src1 + 1)) >>
+			                   2);
+			co_src0 += 2;
+			co_src1 += 2;
+			cg_src0 += 2;
+			cg_src1 += 2;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL nsc_encode(NSC_CONTEXT* WINPR_RESTRICT context, const BYTE* WINPR_RESTRICT bmpdata,
+                UINT32 rowstride)
+{
+	if (!context || !bmpdata || (rowstride == 0))
+		return FALSE;
+
+	if (!nsc_encode_argb_to_aycocg(context, bmpdata, rowstride))
+		return FALSE;
+
+	if (context->ChromaSubsamplingLevel)
+	{
+		if (!nsc_encode_subsampling(context))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static UINT32 nsc_rle_encode(const BYTE* WINPR_RESTRICT in, BYTE* WINPR_RESTRICT out,
+                             UINT32 originalSize)
+{
+	UINT32 left = 0;
+	UINT32 runlength = 1;
+	UINT32 planeSize = 0;
+	left = originalSize;
+
+	/**
+	 * We quit the loop if the running compressed size is larger than the original.
+	 * In such cases data will be sent uncompressed.
+	 */
+	while (left > 4 && planeSize < originalSize - 4)
+	{
+		if (left > 5 && *in == *(in + 1))
+		{
+			runlength++;
+		}
+		else if (runlength == 1)
+		{
+			*out++ = *in;
+			planeSize++;
+		}
+		else if (runlength < 256)
+		{
+			*out++ = *in;
+			*out++ = *in;
+			WINPR_ASSERT(runlength >= 2);
+			*out++ = WINPR_ASSERTING_INT_CAST(BYTE, runlength - 2);
+			runlength = 1;
+			planeSize += 3;
+		}
+		else
+		{
+			*out++ = *in;
+			*out++ = *in;
+			*out++ = 0xFF;
+			*out++ = (runlength & 0x000000FF);
+			*out++ = (runlength & 0x0000FF00) >> 8;
+			*out++ = (runlength & 0x00FF0000) >> 16;
+			*out++ = (runlength & 0xFF000000) >> 24;
+			runlength = 1;
+			planeSize += 7;
+		}
+
+		in++;
+		left--;
+	}
+
+	if (planeSize < originalSize - 4)
+		CopyMemory(out, in, 4);
+
+	planeSize += 4;
+	return planeSize;
+}
+
+static void nsc_rle_compress_data(NSC_CONTEXT* WINPR_RESTRICT context)
+{
+	UINT32 planeSize = 0;
+	UINT32 originalSize = 0;
+
+	for (UINT16 i = 0; i < 4; i++)
+	{
+		originalSize = context->OrgByteCount[i];
+
+		if (originalSize == 0)
+		{
+			planeSize = 0;
+		}
+		else
+		{
+			planeSize = nsc_rle_encode(context->priv->PlaneBuffers[i],
+			                           context->priv->PlaneBuffers[4], originalSize);
+
+			if (planeSize < originalSize)
+				CopyMemory(context->priv->PlaneBuffers[i], context->priv->PlaneBuffers[4],
+				           planeSize);
+			else
+				planeSize = originalSize;
+		}
+
+		context->PlaneByteCount[i] = planeSize;
+	}
+}
+
+static UINT32 nsc_compute_byte_count(NSC_CONTEXT* WINPR_RESTRICT context,
+                                     UINT32* WINPR_RESTRICT ByteCount, UINT32 width, UINT32 height)
+{
+	UINT32 tempWidth = 0;
+	UINT32 tempHeight = 0;
+	UINT32 maxPlaneSize = 0;
+	tempWidth = ROUND_UP_TO(width, 8);
+	tempHeight = ROUND_UP_TO(height, 2);
+	maxPlaneSize = tempWidth * tempHeight + 16;
+
+	if (context->ChromaSubsamplingLevel)
+	{
+		ByteCount[0] = tempWidth * height;
+		ByteCount[1] = tempWidth * tempHeight / 4;
+		ByteCount[2] = tempWidth * tempHeight / 4;
+		ByteCount[3] = width * height;
+	}
+	else
+	{
+		ByteCount[0] = width * height;
+		ByteCount[1] = width * height;
+		ByteCount[2] = width * height;
+		ByteCount[3] = width * height;
+	}
+
+	return maxPlaneSize;
+}
+
+BOOL nsc_write_message(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
+                       const NSC_MESSAGE* WINPR_RESTRICT message)
+{
+	UINT32 totalPlaneByteCount = 0;
+	totalPlaneByteCount = message->LumaPlaneByteCount + message->OrangeChromaPlaneByteCount +
+	                      message->GreenChromaPlaneByteCount + message->AlphaPlaneByteCount;
+
+	if (!Stream_EnsureRemainingCapacity(s, 20 + totalPlaneByteCount))
+		return FALSE;
+
+	Stream_Write_UINT32(s, message->LumaPlaneByteCount); /* LumaPlaneByteCount (4 bytes) */
+	Stream_Write_UINT32(
+	    s, message->OrangeChromaPlaneByteCount); /* OrangeChromaPlaneByteCount (4 bytes) */
+	Stream_Write_UINT32(
+	    s, message->GreenChromaPlaneByteCount);           /* GreenChromaPlaneByteCount (4 bytes) */
+	Stream_Write_UINT32(s, message->AlphaPlaneByteCount); /* AlphaPlaneByteCount (4 bytes) */
+	Stream_Write_UINT8(s, message->ColorLossLevel);       /* ColorLossLevel (1 byte) */
+	Stream_Write_UINT8(s, message->ChromaSubsamplingLevel); /* ChromaSubsamplingLevel (1 byte) */
+	Stream_Write_UINT16(s, 0);                              /* Reserved (2 bytes) */
+
+	if (message->LumaPlaneByteCount)
+		Stream_Write(s, message->PlaneBuffers[0], message->LumaPlaneByteCount); /* LumaPlane */
+
+	if (message->OrangeChromaPlaneByteCount)
+		Stream_Write(s, message->PlaneBuffers[1],
+		             message->OrangeChromaPlaneByteCount); /* OrangeChromaPlane */
+
+	if (message->GreenChromaPlaneByteCount)
+		Stream_Write(s, message->PlaneBuffers[2],
+		             message->GreenChromaPlaneByteCount); /* GreenChromaPlane */
+
+	if (message->AlphaPlaneByteCount)
+		Stream_Write(s, message->PlaneBuffers[3], message->AlphaPlaneByteCount); /* AlphaPlane */
+
+	return TRUE;
+}
+
+BOOL nsc_compose_message(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
+                         const BYTE* WINPR_RESTRICT data, UINT32 width, UINT32 height,
+                         UINT32 scanline)
+{
+	BOOL rc = 0;
+	NSC_MESSAGE message = { 0 };
+
+	if (!context || !s || !data)
+		return FALSE;
+
+	context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
+	context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
+
+	if (!nsc_context_initialize_encode(context))
+		return FALSE;
+
+	/* ARGB to AYCoCg conversion, chroma subsampling and colorloss reduction */
+	PROFILER_ENTER(context->priv->prof_nsc_encode)
+	rc = context->encode(context, data, scanline);
+	PROFILER_EXIT(context->priv->prof_nsc_encode)
+	if (!rc)
+		return FALSE;
+
+	/* RLE encode */
+	PROFILER_ENTER(context->priv->prof_nsc_rle_compress_data)
+	nsc_rle_compress_data(context);
+	PROFILER_EXIT(context->priv->prof_nsc_rle_compress_data)
+	message.PlaneBuffers[0] = context->priv->PlaneBuffers[0];
+	message.PlaneBuffers[1] = context->priv->PlaneBuffers[1];
+	message.PlaneBuffers[2] = context->priv->PlaneBuffers[2];
+	message.PlaneBuffers[3] = context->priv->PlaneBuffers[3];
+	message.LumaPlaneByteCount = context->PlaneByteCount[0];
+	message.OrangeChromaPlaneByteCount = context->PlaneByteCount[1];
+	message.GreenChromaPlaneByteCount = context->PlaneByteCount[2];
+	message.AlphaPlaneByteCount = context->PlaneByteCount[3];
+
+	message.ColorLossLevel = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel);
+	message.ChromaSubsamplingLevel =
+	    WINPR_ASSERTING_INT_CAST(BYTE, context->ChromaSubsamplingLevel);
+	return nsc_write_message(context, s, &message);
+}
+
+BOOL nsc_decompose_message(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
+                           BYTE* WINPR_RESTRICT bmpdata, UINT32 x, UINT32 y, UINT32 width,
+                           UINT32 height, UINT32 rowstride, UINT32 format, UINT32 flip)
+{
+	size_t size = Stream_GetRemainingLength(s);
+
+	if (size > UINT32_MAX)
+		return FALSE;
+
+	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;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/planar.c

@@ -0,0 +1,1797 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP6 Planar Codec
+ *
+ * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/wtypes.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+#include <winpr/print.h>
+
+#include <freerdp/primitives.h>
+#include <freerdp/log.h>
+#include <freerdp/codec/bitmap.h>
+#include <freerdp/codec/planar.h>
+
+#define TAG FREERDP_TAG("codec")
+
+#define PLANAR_ALIGN(val, align) \
+	((val) % (align) == 0) ? (val) : ((val) + (align) - (val) % (align))
+
+typedef struct
+{
+	/**
+	 * controlByte:
+	 * [0-3]: nRunLength
+	 * [4-7]: cRawBytes
+	 */
+	BYTE controlByte;
+	BYTE* rawValues;
+} RDP6_RLE_SEGMENT;
+
+typedef struct
+{
+	UINT32 cSegments;
+	RDP6_RLE_SEGMENT* segments;
+} RDP6_RLE_SEGMENTS;
+
+typedef struct
+{
+	/**
+	 * formatHeader:
+	 * [0-2]: Color Loss Level (CLL)
+	 *  [3] : Chroma Subsampling (CS)
+	 *  [4] : Run Length Encoding (RLE)
+	 *  [5] : No Alpha (NA)
+	 * [6-7]: Reserved
+	 */
+	BYTE formatHeader;
+} RDP6_BITMAP_STREAM;
+
+struct S_BITMAP_PLANAR_CONTEXT
+{
+	UINT32 maxWidth;
+	UINT32 maxHeight;
+	UINT32 maxPlaneSize;
+
+	BOOL AllowSkipAlpha;
+	BOOL AllowRunLengthEncoding;
+	BOOL AllowColorSubsampling;
+	BOOL AllowDynamicColorFidelity;
+
+	UINT32 ColorLossLevel;
+
+	BYTE* planes[4];
+	BYTE* planesBuffer;
+
+	BYTE* deltaPlanes[4];
+	BYTE* deltaPlanesBuffer;
+
+	BYTE* rlePlanes[4];
+	BYTE* rlePlanesBuffer;
+
+	BYTE* pTempData;
+	UINT32 nTempStep;
+
+	BOOL bgr;
+	BOOL topdown;
+};
+
+static INLINE UINT32 planar_invert_format(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL alpha,
+                                          UINT32 DstFormat)
+{
+
+	if (planar->bgr && alpha)
+	{
+		switch (DstFormat)
+		{
+			case PIXEL_FORMAT_ARGB32:
+				DstFormat = PIXEL_FORMAT_ABGR32;
+				break;
+			case PIXEL_FORMAT_XRGB32:
+				DstFormat = PIXEL_FORMAT_XBGR32;
+				break;
+			case PIXEL_FORMAT_ABGR32:
+				DstFormat = PIXEL_FORMAT_ARGB32;
+				break;
+			case PIXEL_FORMAT_XBGR32:
+				DstFormat = PIXEL_FORMAT_XRGB32;
+				break;
+			case PIXEL_FORMAT_BGRA32:
+				DstFormat = PIXEL_FORMAT_RGBA32;
+				break;
+			case PIXEL_FORMAT_BGRX32:
+				DstFormat = PIXEL_FORMAT_RGBX32;
+				break;
+			case PIXEL_FORMAT_RGBA32:
+				DstFormat = PIXEL_FORMAT_BGRA32;
+				break;
+			case PIXEL_FORMAT_RGBX32:
+				DstFormat = PIXEL_FORMAT_BGRX32;
+				break;
+			case PIXEL_FORMAT_RGB24:
+				DstFormat = PIXEL_FORMAT_BGR24;
+				break;
+			case PIXEL_FORMAT_BGR24:
+				DstFormat = PIXEL_FORMAT_RGB24;
+				break;
+			case PIXEL_FORMAT_RGB16:
+				DstFormat = PIXEL_FORMAT_BGR16;
+				break;
+			case PIXEL_FORMAT_BGR16:
+				DstFormat = PIXEL_FORMAT_RGB16;
+				break;
+			case PIXEL_FORMAT_ARGB15:
+				DstFormat = PIXEL_FORMAT_ABGR15;
+				break;
+			case PIXEL_FORMAT_RGB15:
+				DstFormat = PIXEL_FORMAT_BGR15;
+				break;
+			case PIXEL_FORMAT_ABGR15:
+				DstFormat = PIXEL_FORMAT_ARGB15;
+				break;
+			case PIXEL_FORMAT_BGR15:
+				DstFormat = PIXEL_FORMAT_RGB15;
+				break;
+			default:
+				break;
+		}
+	}
+	return DstFormat;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_compress_plane_rle(const BYTE* WINPR_RESTRICT inPlane,
+                                                            UINT32 width, UINT32 height,
+                                                            BYTE* WINPR_RESTRICT outPlane,
+                                                            UINT32* WINPR_RESTRICT dstSize);
+static INLINE BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* WINPR_RESTRICT inPlane,
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlane);
+
+static INLINE INT32 planar_skip_plane_rle(const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
+                                          UINT32 nWidth, UINT32 nHeight)
+{
+	UINT32 used = 0;
+
+	WINPR_ASSERT(pSrcData);
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		for (UINT32 x = 0; x < nWidth;)
+		{
+			if (used >= SrcSize)
+			{
+				WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used,
+				         SrcSize);
+				return -1;
+			}
+
+			const uint8_t controlByte = pSrcData[used++];
+			uint32_t nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			uint32_t cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			used += cRawBytes;
+			x += cRawBytes;
+			x += nRunLength;
+
+			if (x > nWidth)
+			{
+				WLog_ERR(TAG, "planar plane x %" PRIu32 " exceeds width %" PRIu32, x, nWidth);
+				return -1;
+			}
+
+			if (used > SrcSize)
+			{
+				WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used,
+				         INT32_MAX);
+				return -1;
+			}
+		}
+	}
+
+	if (used > INT32_MAX)
+	{
+		WLog_ERR(TAG, "planar plane used %" PRIu32 " exceeds SrcSize %" PRIu32, used, SrcSize);
+		return -1;
+	}
+	return (INT32)used;
+}
+
+static inline UINT8 clamp(INT16 val)
+{
+	return (UINT8)val;
+}
+
+static INLINE INT32 planar_decompress_plane_rle_only(const BYTE* WINPR_RESTRICT pSrcData,
+                                                     UINT32 SrcSize, BYTE* WINPR_RESTRICT pDstData,
+                                                     UINT32 nWidth, UINT32 nHeight)
+{
+	BYTE* previousScanline = NULL;
+	const BYTE* srcp = pSrcData;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		BYTE* dstp = &pDstData[1ULL * (y)*nWidth];
+		INT16 pixel = 0;
+		BYTE* currentScanline = dstp;
+
+		for (UINT32 x = 0; x < nWidth;)
+		{
+			BYTE controlByte = *srcp;
+			srcp++;
+
+			if ((srcp - pSrcData) > SrcSize * 1ll)
+			{
+				WLog_ERR(TAG, "error reading input buffer");
+				return -1;
+			}
+
+			UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 1ll)
+			{
+				WLog_ERR(TAG, "too many pixels in scanline");
+				return -1;
+			}
+
+			if (!previousScanline)
+			{
+				/* first scanline, absolute values */
+				while (cRawBytes > 0)
+				{
+					pixel = *srcp;
+					srcp++;
+					*dstp = clamp(pixel);
+					dstp++;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					*dstp = clamp(pixel);
+					dstp++;
+					x++;
+					nRunLength--;
+				}
+			}
+			else
+			{
+				/* delta values relative to previous scanline */
+				while (cRawBytes > 0)
+				{
+					UINT8 deltaValue = *srcp;
+					srcp++;
+
+					if (deltaValue & 1)
+					{
+						deltaValue = deltaValue >> 1;
+						deltaValue = deltaValue + 1;
+						pixel = WINPR_ASSERTING_INT_CAST(int16_t, -1 * (int16_t)deltaValue);
+					}
+					else
+					{
+						deltaValue = deltaValue >> 1;
+						pixel = WINPR_ASSERTING_INT_CAST(INT16, deltaValue);
+					}
+
+					const INT16 delta =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
+					*dstp = clamp(delta);
+					dstp++;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					const INT16 deltaValue =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[x] + pixel);
+					*dstp = clamp(deltaValue);
+					dstp++;
+					x++;
+					nRunLength--;
+				}
+			}
+		}
+
+		previousScanline = currentScanline;
+	}
+
+	return (INT32)(srcp - pSrcData);
+}
+
+static INLINE INT32 planar_decompress_plane_rle(const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
+                                                BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
+                                                UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
+                                                UINT32 nHeight, UINT32 nChannel, BOOL vFlip)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+	BYTE* previousScanline = NULL;
+	const BYTE* srcp = pSrcData;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+	WINPR_ASSERT(nDstStep <= INT32_MAX);
+
+	previousScanline = NULL;
+
+	if (vFlip)
+	{
+		beg = (INT32)nHeight - 1;
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = (INT32)nHeight;
+		inc = 1;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
+		BYTE* dstp = &pDstData[off];
+		BYTE* currentScanline = dstp;
+		INT16 pixel = 0;
+
+		for (INT32 x = 0; x < (INT32)nWidth;)
+		{
+			const BYTE controlByte = *srcp;
+			srcp++;
+
+			if ((srcp - pSrcData) > SrcSize * 1ll)
+			{
+				WLog_ERR(TAG, "error reading input buffer");
+				return -1;
+			}
+
+			UINT32 nRunLength = PLANAR_CONTROL_BYTE_RUN_LENGTH(controlByte);
+			UINT32 cRawBytes = PLANAR_CONTROL_BYTE_RAW_BYTES(controlByte);
+
+			if (nRunLength == 1)
+			{
+				nRunLength = cRawBytes + 16;
+				cRawBytes = 0;
+			}
+			else if (nRunLength == 2)
+			{
+				nRunLength = cRawBytes + 32;
+				cRawBytes = 0;
+			}
+
+			if (((dstp + (cRawBytes + nRunLength)) - currentScanline) > nWidth * 4ll)
+			{
+				WLog_ERR(TAG, "too many pixels in scanline");
+				return -1;
+			}
+
+			if (!previousScanline)
+			{
+				/* first scanline, absolute values */
+				while (cRawBytes > 0)
+				{
+					pixel = *srcp;
+					srcp++;
+					*dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
+					dstp += 4;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					*dstp = WINPR_ASSERTING_INT_CAST(BYTE, pixel);
+					dstp += 4;
+					x++;
+					nRunLength--;
+				}
+			}
+			else
+			{
+				/* delta values relative to previous scanline */
+				while (cRawBytes > 0)
+				{
+					BYTE deltaValue = *srcp;
+					srcp++;
+
+					if (deltaValue & 1)
+					{
+						deltaValue = deltaValue >> 1;
+						deltaValue = deltaValue + 1;
+						pixel = WINPR_ASSERTING_INT_CAST(int16_t, -deltaValue);
+					}
+					else
+					{
+						deltaValue = deltaValue >> 1;
+						pixel = deltaValue;
+					}
+
+					const INT16 delta =
+					    WINPR_ASSERTING_INT_CAST(int16_t, previousScanline[4LL * x] + pixel);
+					*dstp = clamp(delta);
+					dstp += 4;
+					x++;
+					cRawBytes--;
+				}
+
+				while (nRunLength > 0)
+				{
+					const INT16 deltaValue =
+					    WINPR_ASSERTING_INT_CAST(int16_t, pixel + previousScanline[4LL * x]);
+					*dstp = clamp(deltaValue);
+					dstp += 4;
+					x++;
+					nRunLength--;
+				}
+			}
+		}
+
+		previousScanline = currentScanline;
+	}
+
+	return (INT32)(srcp - pSrcData);
+}
+
+static INLINE INT32 planar_set_plane(BYTE bValue, BYTE* pDstData, UINT32 nDstStep, UINT32 nXDst,
+                                     UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 nChannel,
+                                     BOOL vFlip)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+
+	WINPR_ASSERT(nHeight <= INT32_MAX);
+	WINPR_ASSERT(nWidth <= INT32_MAX);
+	WINPR_ASSERT(nDstStep <= INT32_MAX);
+
+	if (vFlip)
+	{
+		beg = (INT32)nHeight - 1;
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = (INT32)nHeight;
+		inc = 1;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (4LL * nXDst) + nChannel * 1LL;
+		BYTE* dstp = &pDstData[off];
+
+		for (INT32 x = 0; x < (INT32)nWidth; ++x)
+		{
+			*dstp = bValue;
+			dstp += 4;
+		}
+	}
+
+	return 0;
+}
+
+static INLINE BOOL writeLine(BYTE** WINPR_RESTRICT ppRgba, UINT32 DstFormat, UINT32 width,
+                             const BYTE** WINPR_RESTRICT ppR, const BYTE** WINPR_RESTRICT ppG,
+                             const BYTE** WINPR_RESTRICT ppB, const BYTE** WINPR_RESTRICT ppA)
+{
+	WINPR_ASSERT(ppRgba);
+	WINPR_ASSERT(ppR);
+	WINPR_ASSERT(ppG);
+	WINPR_ASSERT(ppB);
+
+	switch (DstFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+			for (UINT32 x = 0; x < width; x++)
+			{
+				*(*ppRgba)++ = *(*ppB)++;
+				*(*ppRgba)++ = *(*ppG)++;
+				*(*ppRgba)++ = *(*ppR)++;
+				*(*ppRgba)++ = *(*ppA)++;
+			}
+
+			return TRUE;
+
+		case PIXEL_FORMAT_BGRX32:
+			for (UINT32 x = 0; x < width; x++)
+			{
+				*(*ppRgba)++ = *(*ppB)++;
+				*(*ppRgba)++ = *(*ppG)++;
+				*(*ppRgba)++ = *(*ppR)++;
+				*(*ppRgba)++ = 0xFF;
+			}
+
+			return TRUE;
+
+		default:
+			if (ppA)
+			{
+				for (UINT32 x = 0; x < width; x++)
+				{
+					BYTE alpha = *(*ppA)++;
+					UINT32 color =
+					    FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
+					FreeRDPWriteColor(*ppRgba, DstFormat, color);
+					*ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
+				}
+			}
+			else
+			{
+				const BYTE alpha = 0xFF;
+
+				for (UINT32 x = 0; x < width; x++)
+				{
+					UINT32 color =
+					    FreeRDPGetColor(DstFormat, *(*ppR)++, *(*ppG)++, *(*ppB)++, alpha);
+					FreeRDPWriteColor(*ppRgba, DstFormat, color);
+					*ppRgba += FreeRDPGetBytesPerPixel(DstFormat);
+				}
+			}
+
+			return TRUE;
+	}
+}
+
+static INLINE BOOL planar_decompress_planes_raw(const BYTE* WINPR_RESTRICT pSrcData[4],
+                                                BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                                                UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
+                                                UINT32 nWidth, UINT32 nHeight, BOOL vFlip,
+                                                UINT32 totalHeight)
+{
+	INT32 beg = 0;
+	INT32 end = 0;
+	INT32 inc = 0;
+	const BYTE* pR = pSrcData[0];
+	const BYTE* pG = pSrcData[1];
+	const BYTE* pB = pSrcData[2];
+	const BYTE* pA = pSrcData[3];
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(DstFormat);
+
+	if (vFlip)
+	{
+		beg = WINPR_ASSERTING_INT_CAST(int32_t, nHeight - 1);
+		end = -1;
+		inc = -1;
+	}
+	else
+	{
+		beg = 0;
+		end = WINPR_ASSERTING_INT_CAST(int32_t, nHeight);
+		inc = 1;
+	}
+
+	if (nYDst + nHeight > totalHeight)
+	{
+		WLog_ERR(TAG,
+		         "planar plane destination Y %" PRIu32 " + height %" PRIu32
+		         " exceeds totalHeight %" PRIu32,
+		         nYDst, nHeight, totalHeight);
+		return FALSE;
+	}
+
+	if ((nXDst + nWidth) * bpp > nDstStep)
+	{
+		WLog_ERR(TAG,
+		         "planar plane destination (X %" PRIu32 " + width %" PRIu32 ") * bpp %" PRIu32
+		         " exceeds stride %" PRIu32,
+		         nXDst, nWidth, bpp, nDstStep);
+		return FALSE;
+	}
+
+	for (INT32 y = beg; y != end; y += inc)
+	{
+		BYTE* pRGB = NULL;
+
+		if (y > WINPR_ASSERTING_INT_CAST(INT64, nHeight))
+		{
+			WLog_ERR(TAG, "planar plane destination Y %" PRId32 " exceeds height %" PRIu32, y,
+			         nHeight);
+			return FALSE;
+		}
+
+		const intptr_t off = ((1LL * nYDst + y) * nDstStep) + (1LL * nXDst * bpp);
+		pRGB = &pDstData[off];
+
+		if (!writeLine(&pRGB, DstFormat, nWidth, &pR, &pG, &pB, &pA))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL planar_subsample_expand(const BYTE* WINPR_RESTRICT plane, size_t planeLength,
+                                    UINT32 nWidth, UINT32 nHeight, UINT32 nPlaneWidth,
+                                    UINT32 nPlaneHeight, BYTE* WINPR_RESTRICT deltaPlane)
+{
+	size_t pos = 0;
+	WINPR_UNUSED(planeLength);
+
+	WINPR_ASSERT(plane);
+	WINPR_ASSERT(deltaPlane);
+
+	if (nWidth > nPlaneWidth * 2)
+	{
+		WLog_ERR(TAG, "planar subsample width %" PRIu32 " > PlaneWidth %" PRIu32 " * 2", nWidth,
+		         nPlaneWidth);
+		return FALSE;
+	}
+
+	if (nHeight > nPlaneHeight * 2)
+	{
+		WLog_ERR(TAG, "planar subsample height %" PRIu32 " > PlaneHeight %" PRIu32 " * 2", nHeight,
+		         nPlaneHeight);
+		return FALSE;
+	}
+
+	for (size_t y = 0; y < nHeight; y++)
+	{
+		const BYTE* src = plane + y / 2 * nPlaneWidth;
+
+		for (UINT32 x = 0; x < nWidth; x++)
+		{
+			deltaPlane[pos++] = src[x / 2];
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
+                       const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth,
+                       UINT32 nSrcHeight, BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat,
+                       UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
+                       UINT32 nDstHeight, BOOL vFlip)
+{
+	BOOL useAlpha = FALSE;
+	INT32 status = 0;
+	INT32 rleSizes[4] = { 0, 0, 0, 0 };
+	UINT32 rawSizes[4] = { 0 };
+	UINT32 rawWidths[4] = { 0 };
+	UINT32 rawHeights[4] = { 0 };
+	const BYTE* planes[4] = { 0 };
+	const UINT32 w = MIN(nSrcWidth, nDstWidth);
+	const UINT32 h = MIN(nSrcHeight, nDstHeight);
+	const primitives_t* prims = primitives_get();
+
+	WINPR_ASSERT(planar);
+	WINPR_ASSERT(prims);
+
+	if (nDstStep <= 0)
+		nDstStep = nDstWidth * FreeRDPGetBytesPerPixel(DstFormat);
+
+	const BYTE* srcp = pSrcData;
+
+	if (!pSrcData)
+	{
+		WLog_ERR(TAG, "Invalid argument pSrcData=NULL");
+		return FALSE;
+	}
+
+	if (!pDstData)
+	{
+		WLog_ERR(TAG, "Invalid argument pDstData=NULL");
+		return FALSE;
+	}
+
+	const BYTE FormatHeader = *srcp++;
+	const BYTE cll = (FormatHeader & PLANAR_FORMAT_HEADER_CLL_MASK);
+	const BYTE cs = (FormatHeader & PLANAR_FORMAT_HEADER_CS) ? TRUE : FALSE;
+	const BYTE rle = (FormatHeader & PLANAR_FORMAT_HEADER_RLE) ? TRUE : FALSE;
+	const BYTE alpha = (FormatHeader & PLANAR_FORMAT_HEADER_NA) ? FALSE : TRUE;
+
+	DstFormat = planar_invert_format(planar, alpha, DstFormat);
+
+	if (alpha)
+		useAlpha = FreeRDPColorHasAlpha(DstFormat);
+
+	// WLog_INFO(TAG, "CLL: %"PRIu32" CS: %"PRIu8" RLE: %"PRIu8" ALPHA: %"PRIu8"", cll, cs, rle,
+	// alpha);
+
+	if (!cll && cs)
+	{
+		WLog_ERR(TAG, "Chroma subsampling requires YCoCg and does not work with RGB data");
+		return FALSE; /* Chroma subsampling requires YCoCg */
+	}
+
+	const UINT32 subWidth = (nSrcWidth / 2) + (nSrcWidth % 2);
+	const UINT32 subHeight = (nSrcHeight / 2) + (nSrcHeight % 2);
+	const UINT32 planeSize = nSrcWidth * nSrcHeight;
+	const UINT32 subSize = subWidth * subHeight;
+
+	if (!cs)
+	{
+		rawSizes[0] = planeSize; /* LumaOrRedPlane */
+		rawWidths[0] = nSrcWidth;
+		rawHeights[0] = nSrcHeight;
+		rawSizes[1] = planeSize; /* OrangeChromaOrGreenPlane */
+		rawWidths[1] = nSrcWidth;
+		rawHeights[1] = nSrcHeight;
+		rawSizes[2] = planeSize; /* GreenChromaOrBluePlane */
+		rawWidths[2] = nSrcWidth;
+		rawHeights[2] = nSrcHeight;
+		rawSizes[3] = planeSize; /* AlphaPlane */
+		rawWidths[3] = nSrcWidth;
+		rawHeights[3] = nSrcHeight;
+	}
+	else /* Chroma Subsampling */
+	{
+		rawSizes[0] = planeSize; /* LumaOrRedPlane */
+		rawWidths[0] = nSrcWidth;
+		rawHeights[0] = nSrcHeight;
+		rawSizes[1] = subSize; /* OrangeChromaOrGreenPlane */
+		rawWidths[1] = subWidth;
+		rawHeights[1] = subHeight;
+		rawSizes[2] = subSize; /* GreenChromaOrBluePlane */
+		rawWidths[2] = subWidth;
+		rawHeights[2] = subHeight;
+		rawSizes[3] = planeSize; /* AlphaPlane */
+		rawWidths[3] = nSrcWidth;
+		rawHeights[3] = nSrcHeight;
+	}
+
+	const size_t diff = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(srcp - pSrcData));
+	if (SrcSize < diff)
+	{
+		WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff);
+		return FALSE;
+	}
+
+	if (!rle) /* RAW */
+	{
+
+		UINT32 base = planeSize * 3;
+		if (cs)
+			base = planeSize + planeSize / 2;
+
+		if (alpha)
+		{
+			if ((SrcSize - diff) < (planeSize + base))
+			{
+				WLog_ERR(TAG, "Alpha plane size mismatch %" PRIuz " < %" PRIu32, SrcSize - diff,
+				         (planeSize + base));
+				return FALSE;
+			}
+
+			planes[3] = srcp;                    /* AlphaPlane */
+			planes[0] = planes[3] + rawSizes[3]; /* LumaOrRedPlane */
+			planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
+			planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
+
+			if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
+			{
+				WLog_ERR(TAG, "plane size mismatch %p + %" PRIu32 " > %p", planes[2], rawSizes[2],
+				         &pSrcData[SrcSize]);
+				return FALSE;
+			}
+		}
+		else
+		{
+			if ((SrcSize - diff) < base)
+			{
+				WLog_ERR(TAG, "plane size mismatch %" PRIu32 " < %" PRIu32, SrcSize - diff, base);
+				return FALSE;
+			}
+
+			planes[0] = srcp;                    /* LumaOrRedPlane */
+			planes[1] = planes[0] + rawSizes[0]; /* OrangeChromaOrGreenPlane */
+			planes[2] = planes[1] + rawSizes[1]; /* GreenChromaOrBluePlane */
+
+			if ((planes[2] + rawSizes[2]) > &pSrcData[SrcSize])
+			{
+				WLog_ERR(TAG, "plane size mismatch %p + %" PRIu32 " > %p", planes[2], rawSizes[2],
+				         &pSrcData[SrcSize]);
+				return FALSE;
+			}
+		}
+	}
+	else /* RLE */
+	{
+		if (alpha)
+		{
+			planes[3] = srcp;
+			rleSizes[3] = planar_skip_plane_rle(planes[3], (UINT32)(SrcSize - diff), rawWidths[3],
+			                                    rawHeights[3]); /* AlphaPlane */
+
+			if (rleSizes[3] < 0)
+				return FALSE;
+
+			planes[0] = planes[3] + rleSizes[3];
+		}
+		else
+			planes[0] = srcp;
+
+		const size_t diff0 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[0] - pSrcData));
+		if (SrcSize < diff0)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff0);
+			return FALSE;
+		}
+		rleSizes[0] = planar_skip_plane_rle(planes[0], (UINT32)(SrcSize - diff0), rawWidths[0],
+		                                    rawHeights[0]); /* RedPlane */
+
+		if (rleSizes[0] < 0)
+			return FALSE;
+
+		planes[1] = planes[0] + rleSizes[0];
+
+		const size_t diff1 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[1] - pSrcData));
+		if (SrcSize < diff1)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff1);
+			return FALSE;
+		}
+		rleSizes[1] = planar_skip_plane_rle(planes[1], (UINT32)(SrcSize - diff1), rawWidths[1],
+		                                    rawHeights[1]); /* GreenPlane */
+
+		if (rleSizes[1] < 1)
+			return FALSE;
+
+		planes[2] = planes[1] + rleSizes[1];
+		const size_t diff2 = WINPR_ASSERTING_INT_CAST(size_t, (intptr_t)(planes[2] - pSrcData));
+		if (SrcSize < diff2)
+		{
+			WLog_ERR(TAG, "Size mismatch %" PRIu32 " < %" PRIuz, SrcSize, diff);
+			return FALSE;
+		}
+		rleSizes[2] = planar_skip_plane_rle(planes[2], (UINT32)(SrcSize - diff2), rawWidths[2],
+		                                    rawHeights[2]); /* BluePlane */
+
+		if (rleSizes[2] < 1)
+			return FALSE;
+	}
+
+	if (!cll) /* RGB */
+	{
+		UINT32 TempFormat = 0;
+		BYTE* pTempData = pDstData;
+		UINT32 nTempStep = nDstStep;
+		UINT32 nTotalHeight = nYDst + nDstHeight;
+
+		if (useAlpha)
+			TempFormat = PIXEL_FORMAT_BGRA32;
+		else
+			TempFormat = PIXEL_FORMAT_BGRX32;
+
+		TempFormat = planar_invert_format(planar, alpha, TempFormat);
+
+		if ((TempFormat != DstFormat) || (nSrcWidth != nDstWidth) || (nSrcHeight != nDstHeight))
+		{
+			pTempData = planar->pTempData;
+			nTempStep = planar->nTempStep;
+			nTotalHeight = planar->maxHeight;
+		}
+
+		if (!rle) /* RAW */
+		{
+			if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
+			                                  nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
+				return FALSE;
+
+			if (alpha)
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
+			else /* NoAlpha */
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
+
+			if ((SrcSize - (srcp - pSrcData)) == 1)
+				srcp++; /* pad */
+		}
+		else /* RLE */
+		{
+			status = planar_decompress_plane_rle(
+			    planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 2, vFlip); /* RedPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle(
+			    planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 1, vFlip); /* GreenPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle(
+			    planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), pTempData, nTempStep,
+			    nXDst, nYDst, nSrcWidth, nSrcHeight, 0, vFlip); /* BluePlane */
+
+			if (status < 0)
+				return FALSE;
+
+			srcp += rleSizes[0] + rleSizes[1] + rleSizes[2];
+
+			if (useAlpha)
+			{
+				status = planar_decompress_plane_rle(
+				    planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), pTempData,
+				    nTempStep, nXDst, nYDst, nSrcWidth, nSrcHeight, 3, vFlip); /* AlphaPlane */
+			}
+			else
+				status = planar_set_plane(0xFF, pTempData, nTempStep, nXDst, nYDst, nSrcWidth,
+				                          nSrcHeight, 3, vFlip);
+
+			if (status < 0)
+				return FALSE;
+
+			if (alpha)
+				srcp += rleSizes[3];
+		}
+
+		if (pTempData != pDstData)
+		{
+			if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, w, h,
+			                                   pTempData, TempFormat, nTempStep, nXDst, nYDst, NULL,
+			                                   FREERDP_FLIP_NONE))
+			{
+				WLog_ERR(TAG, "planar image copy failed");
+				return FALSE;
+			}
+		}
+	}
+	else /* YCoCg */
+	{
+		UINT32 TempFormat = 0;
+		BYTE* pTempData = planar->pTempData;
+		UINT32 nTempStep = planar->nTempStep;
+		UINT32 nTotalHeight = planar->maxHeight;
+		BYTE* dst = &pDstData[nXDst * FreeRDPGetBytesPerPixel(DstFormat) + nYDst * nDstStep];
+
+		if (useAlpha)
+			TempFormat = PIXEL_FORMAT_BGRA32;
+		else
+			TempFormat = PIXEL_FORMAT_BGRX32;
+
+		if (!pTempData)
+			return FALSE;
+
+		if (rle) /* RLE encoded data. Decode and handle it like raw data. */
+		{
+			BYTE* rleBuffer[4] = { 0 };
+
+			if (!planar->rlePlanesBuffer)
+				return FALSE;
+
+			rleBuffer[3] = planar->rlePlanesBuffer;  /* AlphaPlane */
+			rleBuffer[0] = rleBuffer[3] + planeSize; /* LumaOrRedPlane */
+			rleBuffer[1] = rleBuffer[0] + planeSize; /* OrangeChromaOrGreenPlane */
+			rleBuffer[2] = rleBuffer[1] + planeSize; /* GreenChromaOrBluePlane */
+			if (useAlpha)
+			{
+				status = planar_decompress_plane_rle_only(
+				    planes[3], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[3]), rleBuffer[3],
+				    rawWidths[3], rawHeights[3]); /* AlphaPlane */
+
+				if (status < 0)
+					return FALSE;
+			}
+
+			if (alpha)
+				srcp += rleSizes[3];
+
+			status = planar_decompress_plane_rle_only(
+			    planes[0], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[0]), rleBuffer[0],
+			    rawWidths[0], rawHeights[0]); /* LumaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle_only(
+			    planes[1], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[1]), rleBuffer[1],
+			    rawWidths[1], rawHeights[1]); /* OrangeChromaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			status = planar_decompress_plane_rle_only(
+			    planes[2], WINPR_ASSERTING_INT_CAST(uint32_t, rleSizes[2]), rleBuffer[2],
+			    rawWidths[2], rawHeights[2]); /* GreenChromaPlane */
+
+			if (status < 0)
+				return FALSE;
+
+			planes[0] = rleBuffer[0];
+			planes[1] = rleBuffer[1];
+			planes[2] = rleBuffer[2];
+			planes[3] = rleBuffer[3];
+		}
+
+		/* RAW */
+		{
+			if (cs)
+			{ /* Chroma subsampling for Co and Cg:
+			   * Each pixel contains the value that should be expanded to
+			   * [2x,2y;2x+1,2y;2x+1,2y+1;2x;2y+1] */
+				if (!planar_subsample_expand(planes[1], rawSizes[1], nSrcWidth, nSrcHeight,
+				                             rawWidths[1], rawHeights[1], planar->deltaPlanes[0]))
+					return FALSE;
+
+				planes[1] = planar->deltaPlanes[0];
+				rawSizes[1] = planeSize; /* OrangeChromaOrGreenPlane */
+				rawWidths[1] = nSrcWidth;
+				rawHeights[1] = nSrcHeight;
+
+				if (!planar_subsample_expand(planes[2], rawSizes[2], nSrcWidth, nSrcHeight,
+				                             rawWidths[2], rawHeights[2], planar->deltaPlanes[1]))
+					return FALSE;
+
+				planes[2] = planar->deltaPlanes[1];
+				rawSizes[2] = planeSize; /* GreenChromaOrBluePlane */
+				rawWidths[2] = nSrcWidth;
+				rawHeights[2] = nSrcHeight;
+			}
+
+			if (!planar_decompress_planes_raw(planes, pTempData, TempFormat, nTempStep, nXDst,
+			                                  nYDst, nSrcWidth, nSrcHeight, vFlip, nTotalHeight))
+				return FALSE;
+
+			if (alpha)
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2] + rawSizes[3];
+			else /* NoAlpha */
+				srcp += rawSizes[0] + rawSizes[1] + rawSizes[2];
+
+			if ((SrcSize - (srcp - pSrcData)) == 1)
+				srcp++; /* pad */
+		}
+
+		WINPR_ASSERT(prims->YCoCgToRGB_8u_AC4R);
+		int rc = prims->YCoCgToRGB_8u_AC4R(
+		    pTempData, WINPR_ASSERTING_INT_CAST(int32_t, nTempStep), dst, DstFormat,
+		    WINPR_ASSERTING_INT_CAST(int32_t, nDstStep), w, h, cll, useAlpha);
+		if (rc != PRIMITIVES_SUCCESS)
+		{
+			WLog_ERR(TAG, "YCoCgToRGB_8u_AC4R failed with %d", rc);
+			return FALSE;
+		}
+	}
+
+	WINPR_UNUSED(srcp);
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_split_color_planes(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar,
+                                              const BYTE* WINPR_RESTRICT data, UINT32 format,
+                                              UINT32 width, UINT32 height, UINT32 scanline,
+                                              BYTE* WINPR_RESTRICT planes[4])
+{
+	WINPR_ASSERT(planar);
+
+	if ((width > INT32_MAX) || (height > INT32_MAX) || (scanline > INT32_MAX))
+		return FALSE;
+
+	if (scanline == 0)
+		scanline = width * FreeRDPGetBytesPerPixel(format);
+
+	if (planar->topdown)
+	{
+		UINT32 k = 0;
+		for (UINT32 i = 0; i < height; i++)
+		{
+			const BYTE* pixel = &data[1ULL * scanline * i];
+
+			for (UINT32 j = 0; j < width; j++)
+			{
+				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++;
+			}
+		}
+	}
+	else
+	{
+		UINT32 k = 0;
+
+		for (INT64 i = (INT64)height - 1; i >= 0; i--)
+		{
+			const BYTE* pixel = &data[1ULL * scanline * (UINT32)i];
+
+			for (UINT32 j = 0; j < width; j++)
+			{
+				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++;
+			}
+		}
+	}
+	return TRUE;
+}
+
+static INLINE UINT32 freerdp_bitmap_planar_write_rle_bytes(const BYTE* WINPR_RESTRICT pInBuffer,
+                                                           UINT32 cRawBytes, UINT32 nRunLength,
+                                                           BYTE* WINPR_RESTRICT pOutBuffer,
+                                                           UINT32 outBufferSize)
+{
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	BYTE controlByte = 0;
+	UINT32 nBytesToWrite = 0;
+	pInput = pInBuffer;
+	pOutput = pOutBuffer;
+
+	if (!cRawBytes && !nRunLength)
+		return 0;
+
+	if (nRunLength < 3)
+	{
+		cRawBytes += nRunLength;
+		nRunLength = 0;
+	}
+
+	while (cRawBytes)
+	{
+		if (cRawBytes < 16)
+		{
+			if (nRunLength > 15)
+			{
+				if (nRunLength < 18)
+				{
+					controlByte = PLANAR_CONTROL_BYTE(13, cRawBytes);
+					nRunLength -= 13;
+					cRawBytes = 0;
+				}
+				else
+				{
+					controlByte = PLANAR_CONTROL_BYTE(15, cRawBytes);
+					nRunLength -= 15;
+					cRawBytes = 0;
+				}
+			}
+			else
+			{
+				controlByte = PLANAR_CONTROL_BYTE(nRunLength, cRawBytes);
+				nRunLength = 0;
+				cRawBytes = 0;
+			}
+		}
+		else
+		{
+			controlByte = PLANAR_CONTROL_BYTE(0, 15);
+			cRawBytes -= 15;
+		}
+
+		if (outBufferSize < 1)
+			return 0;
+
+		outBufferSize--;
+		*pOutput = controlByte;
+		pOutput++;
+		nBytesToWrite = (controlByte >> 4);
+
+		if (nBytesToWrite)
+		{
+			if (outBufferSize < nBytesToWrite)
+				return 0;
+
+			outBufferSize -= nBytesToWrite;
+			CopyMemory(pOutput, pInput, nBytesToWrite);
+			pOutput += nBytesToWrite;
+			pInput += nBytesToWrite;
+		}
+	}
+
+	while (nRunLength)
+	{
+		if (nRunLength > 47)
+		{
+			if (nRunLength < 50)
+			{
+				controlByte = PLANAR_CONTROL_BYTE(2, 13);
+				nRunLength -= 45;
+			}
+			else
+			{
+				controlByte = PLANAR_CONTROL_BYTE(2, 15);
+				nRunLength -= 47;
+			}
+		}
+		else if (nRunLength > 31)
+		{
+			controlByte = PLANAR_CONTROL_BYTE(2, (nRunLength - 32));
+			nRunLength = 0;
+		}
+		else if (nRunLength > 15)
+		{
+			controlByte = PLANAR_CONTROL_BYTE(1, (nRunLength - 16));
+			nRunLength = 0;
+		}
+		else
+		{
+			controlByte = PLANAR_CONTROL_BYTE(nRunLength, 0);
+			nRunLength = 0;
+		}
+
+		if (outBufferSize < 1)
+			return 0;
+
+		--outBufferSize;
+		*pOutput = controlByte;
+		pOutput++;
+	}
+
+	const intptr_t diff = (pOutput - pOutBuffer);
+	if ((diff < 0) || (diff > UINT32_MAX))
+		return 0;
+	return (UINT32)diff;
+}
+
+static INLINE UINT32 freerdp_bitmap_planar_encode_rle_bytes(const BYTE* WINPR_RESTRICT pInBuffer,
+                                                            UINT32 inBufferSize,
+                                                            BYTE* WINPR_RESTRICT pOutBuffer,
+                                                            UINT32 outBufferSize)
+{
+	BYTE symbol = 0;
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	const BYTE* pBytes = NULL;
+	UINT32 cRawBytes = 0;
+	UINT32 nRunLength = 0;
+	UINT32 bSymbolMatch = 0;
+	UINT32 nBytesWritten = 0;
+	UINT32 nTotalBytesWritten = 0;
+	symbol = 0;
+	cRawBytes = 0;
+	nRunLength = 0;
+	pInput = pInBuffer;
+	pOutput = pOutBuffer;
+	nTotalBytesWritten = 0;
+
+	if (!outBufferSize)
+		return 0;
+
+	do
+	{
+		if (!inBufferSize)
+			break;
+
+		bSymbolMatch = (symbol == *pInput) ? TRUE : FALSE;
+		symbol = *pInput;
+		pInput++;
+		inBufferSize--;
+
+		if (nRunLength && !bSymbolMatch)
+		{
+			if (nRunLength < 3)
+			{
+				cRawBytes += nRunLength;
+				nRunLength = 0;
+			}
+			else
+			{
+				pBytes = pInput - (cRawBytes + nRunLength + 1);
+				nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
+				                                                      pOutput, outBufferSize);
+				nRunLength = 0;
+
+				if (!nBytesWritten || (nBytesWritten > outBufferSize))
+					return nRunLength;
+
+				nTotalBytesWritten += nBytesWritten;
+				outBufferSize -= nBytesWritten;
+				pOutput += nBytesWritten;
+				cRawBytes = 0;
+			}
+		}
+
+		nRunLength += bSymbolMatch;
+		cRawBytes += (!bSymbolMatch) ? TRUE : FALSE;
+	} while (outBufferSize);
+
+	if (cRawBytes || nRunLength)
+	{
+		pBytes = pInput - (cRawBytes + nRunLength);
+		nBytesWritten = freerdp_bitmap_planar_write_rle_bytes(pBytes, cRawBytes, nRunLength,
+		                                                      pOutput, outBufferSize);
+
+		if (!nBytesWritten)
+			return 0;
+
+		nTotalBytesWritten += nBytesWritten;
+	}
+
+	if (inBufferSize)
+		return 0;
+
+	return nTotalBytesWritten;
+}
+
+BOOL freerdp_bitmap_planar_compress_plane_rle(const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
+                                              UINT32 height, BYTE* WINPR_RESTRICT outPlane,
+                                              UINT32* WINPR_RESTRICT dstSize)
+{
+	UINT32 index = 0;
+	const BYTE* pInput = NULL;
+	BYTE* pOutput = NULL;
+	UINT32 outBufferSize = 0;
+	UINT32 nBytesWritten = 0;
+	UINT32 nTotalBytesWritten = 0;
+
+	if (!outPlane)
+		return FALSE;
+
+	index = 0;
+	pInput = inPlane;
+	pOutput = outPlane;
+	outBufferSize = *dstSize;
+	nTotalBytesWritten = 0;
+
+	while (outBufferSize)
+	{
+		nBytesWritten =
+		    freerdp_bitmap_planar_encode_rle_bytes(pInput, width, pOutput, outBufferSize);
+
+		if ((!nBytesWritten) || (nBytesWritten > outBufferSize))
+			return FALSE;
+
+		outBufferSize -= nBytesWritten;
+		nTotalBytesWritten += nBytesWritten;
+		pOutput += nBytesWritten;
+		pInput += width;
+		index++;
+
+		if (index >= height)
+			break;
+	}
+
+	*dstSize = nTotalBytesWritten;
+	return TRUE;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_compress_planes_rle(BYTE* WINPR_RESTRICT inPlanes[4],
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlanes,
+                                                             UINT32* WINPR_RESTRICT dstSizes,
+                                                             BOOL skipAlpha)
+{
+	UINT32 outPlanesSize = width * height * 4;
+
+	/* AlphaPlane */
+	if (skipAlpha)
+	{
+		dstSizes[0] = 0;
+	}
+	else
+	{
+		dstSizes[0] = outPlanesSize;
+
+		if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[0], width, height, outPlanes,
+		                                              &dstSizes[0]))
+			return FALSE;
+
+		outPlanes += dstSizes[0];
+		outPlanesSize -= dstSizes[0];
+	}
+
+	/* LumaOrRedPlane */
+	dstSizes[1] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[1], width, height, outPlanes,
+	                                              &dstSizes[1]))
+		return FALSE;
+
+	outPlanes += dstSizes[1];
+	outPlanesSize -= dstSizes[1];
+	/* OrangeChromaOrGreenPlane */
+	dstSizes[2] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[2], width, height, outPlanes,
+	                                              &dstSizes[2]))
+		return FALSE;
+
+	outPlanes += dstSizes[2];
+	outPlanesSize -= dstSizes[2];
+	/* GreenChromeOrBluePlane */
+	dstSizes[3] = outPlanesSize;
+
+	if (!freerdp_bitmap_planar_compress_plane_rle(inPlanes[3], width, height, outPlanes,
+	                                              &dstSizes[3]))
+		return FALSE;
+
+	return TRUE;
+}
+
+BYTE* freerdp_bitmap_planar_delta_encode_plane(const BYTE* WINPR_RESTRICT inPlane, UINT32 width,
+                                               UINT32 height, BYTE* WINPR_RESTRICT outPlane)
+{
+	BYTE* outPtr = NULL;
+	const BYTE* srcPtr = NULL;
+	const BYTE* prevLinePtr = NULL;
+
+	if (!outPlane)
+	{
+		if (width * height == 0)
+			return NULL;
+
+		if (!(outPlane = (BYTE*)calloc(height, width)))
+			return NULL;
+	}
+
+	// first line is copied as is
+	CopyMemory(outPlane, inPlane, width);
+	outPtr = outPlane + width;
+	srcPtr = inPlane + width;
+	prevLinePtr = inPlane;
+
+	for (UINT32 y = 1; y < height; y++)
+	{
+		for (UINT32 x = 0; x < width; x++, outPtr++, srcPtr++, prevLinePtr++)
+		{
+			INT32 delta = *srcPtr - *prevLinePtr;
+			BYTE s2c = WINPR_ASSERTING_INT_CAST(
+			    BYTE, (delta >= 0) ? delta : (~((BYTE)(-delta)) + 1) & 0xFF);
+			s2c = WINPR_ASSERTING_INT_CAST(
+			    BYTE,
+			    (s2c >= 0) ? (s2c << 1) & 0xFF : (((UINT32)(~((BYTE)s2c) + 1) << 1) - 1) & 0xFF);
+			*outPtr = s2c;
+		}
+	}
+
+	return outPlane;
+}
+
+static INLINE BOOL freerdp_bitmap_planar_delta_encode_planes(BYTE* WINPR_RESTRICT inPlanes[4],
+                                                             UINT32 width, UINT32 height,
+                                                             BYTE* WINPR_RESTRICT outPlanes[4])
+{
+	for (UINT32 i = 0; i < 4; i++)
+	{
+		outPlanes[i] =
+		    freerdp_bitmap_planar_delta_encode_plane(inPlanes[i], width, height, outPlanes[i]);
+
+		if (!outPlanes[i])
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
+                                     const BYTE* WINPR_RESTRICT data, UINT32 format, UINT32 width,
+                                     UINT32 height, UINT32 scanline, BYTE* WINPR_RESTRICT dstData,
+                                     UINT32* WINPR_RESTRICT pDstSize)
+{
+	UINT32 size = 0;
+	BYTE* dstp = NULL;
+	UINT32 planeSize = 0;
+	UINT32 dstSizes[4] = { 0 };
+	BYTE FormatHeader = 0;
+
+	if (!context || !context->rlePlanesBuffer)
+		return NULL;
+
+	if (context->AllowSkipAlpha)
+		FormatHeader |= PLANAR_FORMAT_HEADER_NA;
+
+	planeSize = width * height;
+
+	if (!context->AllowSkipAlpha)
+		format = planar_invert_format(context, TRUE, format);
+
+	if (!freerdp_split_color_planes(context, data, format, width, height, scanline,
+	                                context->planes))
+		return NULL;
+
+	if (context->AllowRunLengthEncoding)
+	{
+		if (!freerdp_bitmap_planar_delta_encode_planes(context->planes, width, height,
+		                                               context->deltaPlanes))
+			return NULL;
+
+		if (!freerdp_bitmap_planar_compress_planes_rle(context->deltaPlanes, width, height,
+		                                               context->rlePlanesBuffer, dstSizes,
+		                                               context->AllowSkipAlpha))
+			return NULL;
+
+		{
+			uint32_t offset = 0;
+			FormatHeader |= PLANAR_FORMAT_HEADER_RLE;
+			context->rlePlanes[0] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[0];
+			context->rlePlanes[1] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[1];
+			context->rlePlanes[2] = &context->rlePlanesBuffer[offset];
+			offset += dstSizes[2];
+			context->rlePlanes[3] = &context->rlePlanesBuffer[offset];
+
+#if defined(WITH_DEBUG_CODECS)
+			WLog_DBG(TAG,
+			         "R: [%" PRIu32 "/%" PRIu32 "] G: [%" PRIu32 "/%" PRIu32 "] B: [%" PRIu32
+			         " / %" PRIu32 "] ",
+			         dstSizes[1], planeSize, dstSizes[2], planeSize, dstSizes[3], planeSize);
+#endif
+		}
+	}
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		if (!context->AllowRunLengthEncoding)
+			return NULL;
+
+		if (context->rlePlanes[0] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[1] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[2] == NULL)
+			return NULL;
+
+		if (context->rlePlanes[3] == NULL)
+			return NULL;
+	}
+
+	if (!dstData)
+	{
+		size = 1;
+
+		if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
+		{
+			if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+				size += dstSizes[0];
+			else
+				size += planeSize;
+		}
+
+		if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+			size += (dstSizes[1] + dstSizes[2] + dstSizes[3]);
+		else
+			size += (planeSize * 3);
+
+		if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
+			size++;
+
+		dstData = malloc(size);
+
+		if (!dstData)
+			return NULL;
+
+		*pDstSize = size;
+	}
+
+	dstp = dstData;
+	*dstp = FormatHeader; /* FormatHeader */
+	dstp++;
+
+	/* AlphaPlane */
+
+	if (!(FormatHeader & PLANAR_FORMAT_HEADER_NA))
+	{
+		if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+		{
+			CopyMemory(dstp, context->rlePlanes[0], dstSizes[0]); /* Alpha */
+			dstp += dstSizes[0];
+		}
+		else
+		{
+			CopyMemory(dstp, context->planes[0], planeSize); /* Alpha */
+			dstp += planeSize;
+		}
+	}
+
+	/* LumaOrRedPlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[1], dstSizes[1]); /* Red */
+		dstp += dstSizes[1];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[1], planeSize); /* Red */
+		dstp += planeSize;
+	}
+
+	/* OrangeChromaOrGreenPlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[2], dstSizes[2]); /* Green */
+		dstp += dstSizes[2];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[2], planeSize); /* Green */
+		dstp += planeSize;
+	}
+
+	/* GreenChromeOrBluePlane */
+
+	if (FormatHeader & PLANAR_FORMAT_HEADER_RLE)
+	{
+		CopyMemory(dstp, context->rlePlanes[3], dstSizes[3]); /* Blue */
+		dstp += dstSizes[3];
+	}
+	else
+	{
+		CopyMemory(dstp, context->planes[3], planeSize); /* Blue */
+		dstp += planeSize;
+	}
+
+	/* Pad1 (1 byte) */
+
+	if (!(FormatHeader & PLANAR_FORMAT_HEADER_RLE))
+	{
+		*dstp = 0;
+		dstp++;
+	}
+
+	const intptr_t diff = (dstp - dstData);
+	if ((diff < 0) || (diff > UINT32_MAX))
+	{
+		free(dstData);
+		return NULL;
+	}
+	size = (UINT32)diff;
+	*pDstSize = size;
+	return dstData;
+}
+
+BOOL freerdp_bitmap_planar_context_reset(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT context,
+                                         UINT32 width, UINT32 height)
+{
+	if (!context)
+		return FALSE;
+
+	context->bgr = FALSE;
+	context->maxWidth = PLANAR_ALIGN(width, 4);
+	context->maxHeight = PLANAR_ALIGN(height, 4);
+	{
+		const UINT64 tmp = (UINT64)context->maxWidth * context->maxHeight;
+		if (tmp > UINT32_MAX)
+			return FALSE;
+		context->maxPlaneSize = (UINT32)tmp;
+	}
+
+	if (context->maxWidth > UINT32_MAX / 4)
+		return FALSE;
+	context->nTempStep = context->maxWidth * 4;
+
+	memset((void*)context->planes, 0, sizeof(context->planes));
+	memset((void*)context->rlePlanes, 0, sizeof(context->rlePlanes));
+	memset((void*)context->deltaPlanes, 0, sizeof(context->deltaPlanes));
+
+	if (context->maxPlaneSize > 0)
+	{
+		void* tmp = winpr_aligned_recalloc(context->planesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->planesBuffer = tmp;
+
+		tmp = winpr_aligned_recalloc(context->pTempData, context->maxPlaneSize, 6, 32);
+		if (!tmp)
+			return FALSE;
+		context->pTempData = tmp;
+
+		tmp = winpr_aligned_recalloc(context->deltaPlanesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->deltaPlanesBuffer = tmp;
+
+		tmp = winpr_aligned_recalloc(context->rlePlanesBuffer, context->maxPlaneSize, 4, 32);
+		if (!tmp)
+			return FALSE;
+		context->rlePlanesBuffer = tmp;
+
+		context->planes[0] = &context->planesBuffer[0ULL * context->maxPlaneSize];
+		context->planes[1] = &context->planesBuffer[1ULL * context->maxPlaneSize];
+		context->planes[2] = &context->planesBuffer[2ULL * context->maxPlaneSize];
+		context->planes[3] = &context->planesBuffer[3ULL * context->maxPlaneSize];
+		context->deltaPlanes[0] = &context->deltaPlanesBuffer[0ULL * context->maxPlaneSize];
+		context->deltaPlanes[1] = &context->deltaPlanesBuffer[1ULL * context->maxPlaneSize];
+		context->deltaPlanes[2] = &context->deltaPlanesBuffer[2ULL * context->maxPlaneSize];
+		context->deltaPlanes[3] = &context->deltaPlanesBuffer[3ULL * context->maxPlaneSize];
+	}
+	return TRUE;
+}
+
+BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(DWORD flags, UINT32 maxWidth,
+                                                         UINT32 maxHeight)
+{
+	BITMAP_PLANAR_CONTEXT* context =
+	    (BITMAP_PLANAR_CONTEXT*)winpr_aligned_calloc(1, sizeof(BITMAP_PLANAR_CONTEXT), 32);
+
+	if (!context)
+		return NULL;
+
+	if (flags & PLANAR_FORMAT_HEADER_NA)
+		context->AllowSkipAlpha = TRUE;
+
+	if (flags & PLANAR_FORMAT_HEADER_RLE)
+		context->AllowRunLengthEncoding = TRUE;
+
+	if (flags & PLANAR_FORMAT_HEADER_CS)
+		context->AllowColorSubsampling = TRUE;
+
+	context->ColorLossLevel = flags & PLANAR_FORMAT_HEADER_CLL_MASK;
+
+	if (context->ColorLossLevel)
+		context->AllowDynamicColorFidelity = TRUE;
+
+	if (!freerdp_bitmap_planar_context_reset(context, maxWidth, maxHeight))
+	{
+		WINPR_PRAGMA_DIAG_PUSH
+		WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+		freerdp_bitmap_planar_context_free(context);
+		WINPR_PRAGMA_DIAG_POP
+		return NULL;
+	}
+
+	return context;
+}
+
+void freerdp_bitmap_planar_context_free(BITMAP_PLANAR_CONTEXT* context)
+{
+	if (!context)
+		return;
+
+	winpr_aligned_free(context->pTempData);
+	winpr_aligned_free(context->planesBuffer);
+	winpr_aligned_free(context->deltaPlanesBuffer);
+	winpr_aligned_free(context->rlePlanesBuffer);
+	winpr_aligned_free(context);
+}
+
+void freerdp_planar_switch_bgr(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL bgr)
+{
+	WINPR_ASSERT(planar);
+	planar->bgr = bgr;
+}
+
+void freerdp_planar_topdown_image(BITMAP_PLANAR_CONTEXT* WINPR_RESTRICT planar, BOOL topdown)
+{
+	WINPR_ASSERT(planar);
+	planar->topdown = topdown;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/rfx_bitstream.h

@@ -0,0 +1,134 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Bit Stream
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CODEC_RFX_BITSTREAM_H
+#define FREERDP_LIB_CODEC_RFX_BITSTREAM_H
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/codec/rfx.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	typedef struct
+	{
+		BYTE* buffer;
+		uint32_t nbytes;
+		uint32_t byte_pos;
+		uint32_t bits_left;
+	} RFX_BITSTREAM;
+
+	static inline void rfx_bitstream_attach(RFX_BITSTREAM* bs, BYTE* WINPR_RESTRICT buffer,
+	                                        size_t nbytes)
+	{
+		WINPR_ASSERT(bs);
+		bs->buffer = (buffer);
+
+		WINPR_ASSERT(nbytes <= UINT32_MAX);
+		bs->nbytes = WINPR_ASSERTING_INT_CAST(uint32_t, nbytes);
+		bs->byte_pos = 0;
+		bs->bits_left = 8;
+	}
+
+	static inline uint32_t rfx_bitstream_get_bits(RFX_BITSTREAM* bs, uint32_t nbits)
+	{
+		UINT16 n = 0;
+		while (bs->byte_pos < bs->nbytes && nbits > 0)
+		{
+			uint32_t b = nbits;
+			if (b > bs->bits_left)
+				b = bs->bits_left;
+			if (n)
+				n <<= b;
+			n |= (bs->buffer[bs->byte_pos] >> (bs->bits_left - b)) & ((1 << b) - 1);
+			bs->bits_left -= b;
+			nbits -= b;
+			if (bs->bits_left == 0)
+			{
+				bs->bits_left = 8;
+				bs->byte_pos++;
+			}
+		}
+		return n;
+	}
+
+	static inline void rfx_bitstream_put_bits(RFX_BITSTREAM* bs, uint32_t _bits, uint32_t _nbits)
+	{
+		UINT16 bits = WINPR_ASSERTING_INT_CAST(UINT16, _bits);
+
+		uint32_t nbits = (_nbits);
+		while (bs->byte_pos < bs->nbytes && nbits > 0)
+		{
+			uint32_t b = nbits;
+			if (b > bs->bits_left)
+				b = bs->bits_left;
+			bs->buffer[bs->byte_pos] |= ((bits >> (nbits - b)) & ((1 << b) - 1))
+			                            << (bs->bits_left - b);
+			bs->bits_left -= b;
+			nbits -= b;
+			if (bs->bits_left == 0)
+			{
+				bs->bits_left = 8;
+				bs->byte_pos++;
+			}
+		}
+	}
+
+	static inline void rfx_bitstream_flush(RFX_BITSTREAM* bs)
+	{
+		WINPR_ASSERT(bs);
+		if (bs->bits_left != 8)
+		{
+			uint32_t _nbits = 8 - bs->bits_left;
+			rfx_bitstream_put_bits(bs, 0, _nbits);
+		}
+	}
+
+	static inline BOOL rfx_bitstream_eos(RFX_BITSTREAM* bs)
+	{
+		WINPR_ASSERT(bs);
+		return ((bs)->byte_pos >= (bs)->nbytes);
+	}
+
+	static inline uint32_t rfx_bitstream_left(RFX_BITSTREAM* bs)
+	{
+		WINPR_ASSERT(bs);
+
+		if ((bs)->byte_pos >= (bs)->nbytes)
+			return 0;
+
+		return ((bs)->nbytes - (bs)->byte_pos - 1) * 8 + (bs)->bits_left;
+	}
+
+	static inline uint32_t rfx_bitstream_get_processed_bytes(RFX_BITSTREAM* bs)
+	{
+		WINPR_ASSERT(bs);
+		if ((bs)->bits_left < 8)
+			return (bs)->byte_pos + 1;
+		return (bs)->byte_pos;
+	}
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* FREERDP_LIB_CODEC_RFX_BITSTREAM_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/rfx_decode.c

@@ -0,0 +1,104 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Decode
+ *
+ * Copyright 2011 Vic Lee
+ * Copyright 2011 Norbert Federa <norbert.federa@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/stream.h>
+#include <freerdp/primitives.h>
+
+#include "rfx_types.h"
+#include "rfx_rlgr.h"
+#include "rfx_differential.h"
+#include "rfx_quantization.h"
+#include "rfx_dwt.h"
+
+#include "rfx_decode.h"
+
+static INLINE void rfx_decode_component(RFX_CONTEXT* WINPR_RESTRICT context,
+                                        const UINT32* WINPR_RESTRICT quantization_values,
+                                        const BYTE* WINPR_RESTRICT data, size_t size,
+                                        INT16* WINPR_RESTRICT buffer)
+{
+	INT16* dwt_buffer = NULL;
+	dwt_buffer = BufferPool_Take(context->priv->BufferPool, -1); /* dwt_buffer */
+	PROFILER_ENTER(context->priv->prof_rfx_decode_component)
+	PROFILER_ENTER(context->priv->prof_rfx_rlgr_decode)
+	WINPR_ASSERT(size <= UINT32_MAX);
+	context->rlgr_decode(context->mode, data, (UINT32)size, buffer, 4096);
+	PROFILER_EXIT(context->priv->prof_rfx_rlgr_decode)
+	PROFILER_ENTER(context->priv->prof_rfx_differential_decode)
+	rfx_differential_decode(buffer + 4032, 64);
+	PROFILER_EXIT(context->priv->prof_rfx_differential_decode)
+	PROFILER_ENTER(context->priv->prof_rfx_quantization_decode)
+	context->quantization_decode(buffer, quantization_values);
+	PROFILER_EXIT(context->priv->prof_rfx_quantization_decode)
+	PROFILER_ENTER(context->priv->prof_rfx_dwt_2d_decode)
+	context->dwt_2d_decode(buffer, dwt_buffer);
+	PROFILER_EXIT(context->priv->prof_rfx_dwt_2d_decode)
+	PROFILER_EXIT(context->priv->prof_rfx_decode_component)
+	BufferPool_Return(context->priv->BufferPool, dwt_buffer);
+}
+
+/* rfx_decode_ycbcr_to_rgb code now resides in the primitives library. */
+
+/* stride is bytes between rows in the output buffer. */
+BOOL rfx_decode_rgb(RFX_CONTEXT* WINPR_RESTRICT context, const RFX_TILE* WINPR_RESTRICT tile,
+                    BYTE* WINPR_RESTRICT rgb_buffer, UINT32 stride)
+{
+	union
+	{
+		const INT16** cpv;
+		INT16** pv;
+	} cnv;
+	BOOL rc = TRUE;
+	BYTE* pBuffer = NULL;
+	INT16* pSrcDst[3];
+	UINT32* y_quants = NULL;
+	UINT32* cb_quants = NULL;
+	UINT32* cr_quants = NULL;
+	static const prim_size_t roi_64x64 = { 64, 64 };
+	const primitives_t* prims = primitives_get();
+	PROFILER_ENTER(context->priv->prof_rfx_decode_rgb)
+	y_quants = context->quants + (10ULL * tile->quantIdxY);
+	cb_quants = context->quants + (10ULL * tile->quantIdxCb);
+	cr_quants = context->quants + (10ULL * tile->quantIdxCr);
+	pBuffer = (BYTE*)BufferPool_Take(context->priv->BufferPool, -1);
+	pSrcDst[0] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 0ULL) + 16ULL]));        /* y_r_buffer */
+	pSrcDst[1] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 1ULL) + 16ULL]));        /* cb_g_buffer */
+	pSrcDst[2] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 2ULL) + 16ULL]));        /* cr_b_buffer */
+	rfx_decode_component(context, y_quants, tile->YData, tile->YLen, pSrcDst[0]); /* YData */
+	rfx_decode_component(context, cb_quants, tile->CbData, tile->CbLen, pSrcDst[1]); /* CbData */
+	rfx_decode_component(context, cr_quants, tile->CrData, tile->CrLen, pSrcDst[2]); /* CrData */
+	PROFILER_ENTER(context->priv->prof_rfx_ycbcr_to_rgb)
+
+	cnv.pv = pSrcDst;
+	if (prims->yCbCrToRGB_16s8u_P3AC4R(cnv.cpv, 64 * sizeof(INT16), rgb_buffer, stride,
+	                                   context->pixel_format, &roi_64x64) != PRIMITIVES_SUCCESS)
+		rc = FALSE;
+
+	PROFILER_EXIT(context->priv->prof_rfx_ycbcr_to_rgb)
+	PROFILER_EXIT(context->priv->prof_rfx_decode_rgb)
+	BufferPool_Return(context->priv->BufferPool, pBuffer);
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/rfx_decode.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RemoteFX Codec Library - Decode
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CODEC_RFX_DECODE_H
+#define FREERDP_LIB_CODEC_RFX_DECODE_H
+
+#include <winpr/wtypes.h>
+
+#include <freerdp/codec/rfx.h>
+#include <freerdp/api.h>
+
+/* stride is bytes between rows in the output buffer. */
+FREERDP_LOCAL BOOL rfx_decode_rgb(RFX_CONTEXT* WINPR_RESTRICT context,
+                                  const RFX_TILE* WINPR_RESTRICT tile,
+                                  BYTE* WINPR_RESTRICT rgb_buffer, UINT32 stride);
+
+#endif /* FREERDP_LIB_CODEC_RFX_DECODE_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/xcrush.h

@@ -0,0 +1,51 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * XCrush (RDP6.1) Bulk Data Compression
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CODEC_XCRUSH_H
+#define FREERDP_CODEC_XCRUSH_H
+
+#include <freerdp/api.h>
+#include <freerdp/types.h>
+
+#include "mppc.h"
+
+typedef struct s_XCRUSH_CONTEXT XCRUSH_CONTEXT;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL int xcrush_compress(XCRUSH_CONTEXT* xcrush, const BYTE* pSrcData, UINT32 SrcSize,
+	                                  BYTE* pDstBuffer, const BYTE** ppDstData, UINT32* pDstSize,
+	                                  UINT32* pFlags);
+	FREERDP_LOCAL int xcrush_decompress(XCRUSH_CONTEXT* xcrush, const BYTE* pSrcData,
+	                                    UINT32 SrcSize, const BYTE** ppDstData, UINT32* pDstSize,
+	                                    UINT32 flags);
+
+	FREERDP_LOCAL void xcrush_context_reset(XCRUSH_CONTEXT* xcrush, BOOL flush);
+
+	FREERDP_LOCAL XCRUSH_CONTEXT* xcrush_context_new(BOOL Compressor);
+	FREERDP_LOCAL void xcrush_context_free(XCRUSH_CONTEXT* xcrush);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_CODEC_XCRUSH_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/client.c

@@ -0,0 +1,1509 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Client Channels
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "settings.h"
+
+#include <winpr/assert.h>
+
+#include <freerdp/log.h>
+#include <freerdp/channels/drdynvc.h>
+
+#include "rdp.h"
+#include "client.h"
+
+#define TAG FREERDP_TAG("core.client")
+
+typedef struct
+{
+	freerdp_channel_handle_fkt_t fkt;
+	void* userdata;
+} ChannelEventEntry;
+
+/* Use this instance to get access to channels in VirtualChannelInit. It is set during
+ * freerdp_connect so channels that use VirtualChannelInit must be initialized from the same thread
+ * as freerdp_connect was called */
+static WINPR_TLS freerdp* g_Instance = NULL;
+
+/* use global counter to ensure uniqueness across channel manager instances */
+static volatile LONG g_OpenHandleSeq = 1;
+
+/* HashTable mapping channel handles to CHANNEL_OPEN_DATA */
+static INIT_ONCE g_ChannelHandlesOnce = INIT_ONCE_STATIC_INIT;
+static wHashTable* g_ChannelHandles = NULL;
+
+static BOOL freerdp_channels_process_message_free(wMessage* message, DWORD type);
+
+static CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(rdpChannels* channels,
+                                                                          const char* name)
+{
+	for (int index = 0; index < channels->openDataCount; index++)
+	{
+		CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
+
+		if (strncmp(name, pChannelOpenData->name, CHANNEL_NAME_LEN + 1) == 0)
+			return pChannelOpenData;
+	}
+
+	return NULL;
+}
+
+/* returns rdpChannel for the channel name passed in */
+static rdpMcsChannel* freerdp_channels_find_channel_by_name(rdpRdp* rdp, const char* name)
+{
+	rdpMcs* mcs = NULL;
+
+	if (!rdp)
+		return NULL;
+
+	mcs = rdp->mcs;
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* channel = &mcs->channels[index];
+
+		if (strncmp(name, channel->Name, CHANNEL_NAME_LEN + 1) == 0)
+		{
+			return channel;
+		}
+	}
+
+	return NULL;
+}
+
+static rdpMcsChannel* freerdp_channels_find_channel_by_id(rdpRdp* rdp, UINT16 channel_id)
+{
+	rdpMcsChannel* channel = NULL;
+	rdpMcs* mcs = NULL;
+
+	if (!rdp)
+		return NULL;
+
+	mcs = rdp->mcs;
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		channel = &mcs->channels[index];
+
+		if (channel->ChannelId == channel_id)
+		{
+			return channel;
+		}
+	}
+
+	return NULL;
+}
+
+static void channel_queue_message_free(wMessage* msg)
+{
+	CHANNEL_OPEN_EVENT* ev = NULL;
+
+	if (!msg || (msg->id != 0))
+		return;
+
+	ev = (CHANNEL_OPEN_EVENT*)msg->wParam;
+	free(ev);
+}
+
+static void channel_queue_free(void* obj)
+{
+	wMessage* msg = (wMessage*)obj;
+	freerdp_channels_process_message_free(msg, CHANNEL_EVENT_WRITE_CANCELLED);
+	channel_queue_message_free(msg);
+}
+
+static BOOL CALLBACK init_channel_handles_table(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+	g_ChannelHandles = HashTable_New(TRUE);
+	return TRUE;
+}
+
+static void* channel_event_entry_clone(const void* data)
+{
+	const ChannelEventEntry* entry = data;
+	if (!entry)
+		return NULL;
+
+	ChannelEventEntry* copy = calloc(1, sizeof(ChannelEventEntry));
+	if (!copy)
+		return NULL;
+	*copy = *entry;
+	return copy;
+}
+
+rdpChannels* freerdp_channels_new(freerdp* instance)
+{
+	wObject* obj = NULL;
+	rdpChannels* channels = NULL;
+	channels = (rdpChannels*)calloc(1, sizeof(rdpChannels));
+
+	if (!channels)
+		return NULL;
+
+	InitOnceExecuteOnce(&g_ChannelHandlesOnce, init_channel_handles_table, NULL, NULL);
+
+	if (!g_ChannelHandles)
+		goto error;
+	if (!InitializeCriticalSectionAndSpinCount(&channels->channelsLock, 4000))
+		goto error;
+
+	channels->instance = instance;
+	channels->queue = MessageQueue_New(NULL);
+
+	if (!channels->queue)
+		goto error;
+
+	obj = MessageQueue_Object(channels->queue);
+	obj->fnObjectFree = channel_queue_free;
+
+	channels->channelEvents = HashTable_New(FALSE);
+	if (!channels->channelEvents)
+		goto error;
+
+	obj = HashTable_ValueObject(channels->channelEvents);
+	WINPR_ASSERT(obj);
+	obj->fnObjectFree = free;
+	obj->fnObjectNew = channel_event_entry_clone;
+	return channels;
+error:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_channels_free(channels);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void freerdp_channels_free(rdpChannels* channels)
+{
+	if (!channels)
+		return;
+
+	HashTable_Free(channels->channelEvents);
+
+	DeleteCriticalSection(&channels->channelsLock);
+
+	if (channels->queue)
+	{
+		MessageQueue_Free(channels->queue);
+		channels->queue = NULL;
+	}
+
+	free(channels);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT freerdp_drdynvc_on_channel_connected(DrdynvcClientContext* context, const char* name,
+                                                 void* pInterface)
+{
+	UINT status = CHANNEL_RC_OK;
+	ChannelConnectedEventArgs e = { 0 };
+	rdpChannels* channels = (rdpChannels*)context->custom;
+	freerdp* instance = channels->instance;
+	EventArgsInit(&e, "freerdp");
+	e.name = name;
+	e.pInterface = pInterface;
+	PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e);
+	return status;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT freerdp_drdynvc_on_channel_disconnected(DrdynvcClientContext* context, const char* name,
+                                                    void* pInterface)
+{
+	UINT status = CHANNEL_RC_OK;
+	ChannelDisconnectedEventArgs e = { 0 };
+	rdpChannels* channels = (rdpChannels*)context->custom;
+	freerdp* instance = channels->instance;
+	EventArgsInit(&e, "freerdp");
+	e.name = name;
+	e.pInterface = pInterface;
+	PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
+	return status;
+}
+
+static UINT freerdp_drdynvc_on_channel_attached(DrdynvcClientContext* context, const char* name,
+                                                void* pInterface)
+{
+	UINT status = CHANNEL_RC_OK;
+	ChannelAttachedEventArgs e = { 0 };
+	rdpChannels* channels = (rdpChannels*)context->custom;
+	freerdp* instance = channels->instance;
+	EventArgsInit(&e, "freerdp");
+	e.name = name;
+	e.pInterface = pInterface;
+	PubSub_OnChannelAttached(instance->context->pubSub, instance->context, &e);
+	return status;
+}
+
+static UINT freerdp_drdynvc_on_channel_detached(DrdynvcClientContext* context, const char* name,
+                                                void* pInterface)
+{
+	UINT status = CHANNEL_RC_OK;
+	ChannelDetachedEventArgs e = { 0 };
+	rdpChannels* channels = (rdpChannels*)context->custom;
+	freerdp* instance = channels->instance;
+	EventArgsInit(&e, "freerdp");
+	e.name = name;
+	e.pInterface = pInterface;
+	PubSub_OnChannelDetached(instance->context->pubSub, instance->context, &e);
+	return status;
+}
+
+void freerdp_channels_register_instance(rdpChannels* channels, freerdp* instance)
+{
+	/* store instance in TLS so future VirtualChannelInit calls can use it */
+	g_Instance = instance;
+}
+
+/**
+ * go through and inform all the libraries that we are initialized
+ * called only from main thread
+ */
+UINT freerdp_channels_pre_connect(rdpChannels* channels, freerdp* instance)
+{
+	UINT error = CHANNEL_RC_OK;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	MessageQueue_Clear(channels->queue);
+
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		pChannelClientData = &channels->clientDataList[index];
+
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_INITIALIZED, 0, 0);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
+			                                            pChannelClientData->pInitHandle,
+			                                            CHANNEL_EVENT_INITIALIZED, 0, 0);
+		}
+
+		if (CHANNEL_RC_OK != getChannelError(instance->context))
+			break;
+	}
+
+	return error;
+}
+
+UINT freerdp_channels_attach(freerdp* instance)
+{
+	UINT error = CHANNEL_RC_OK;
+	const char* hostname = NULL;
+	size_t hostnameLength = 0;
+	rdpChannels* channels = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	channels = instance->context->channels;
+	hostname = freerdp_settings_get_string(instance->context->settings, FreeRDP_ServerHostname);
+	WINPR_ASSERT(hostname);
+	hostnameLength = strnlen(hostname, MAX_PATH);
+
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		union
+		{
+			const void* cpv;
+			void* pv;
+		} cnv;
+		ChannelAttachedEventArgs e = { 0 };
+		CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+
+		cnv.cpv = hostname;
+		pChannelClientData = &channels->clientDataList[index];
+
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_ATTACHED, cnv.pv,
+			                                          (UINT)hostnameLength);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(
+			    pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
+			    CHANNEL_EVENT_ATTACHED, cnv.pv, (UINT)hostnameLength);
+		}
+
+		if (getChannelError(instance->context) != CHANNEL_RC_OK)
+			goto fail;
+
+		pChannelOpenData = &channels->openDataList[index];
+		EventArgsInit(&e, "freerdp");
+		e.name = pChannelOpenData->name;
+		e.pInterface = pChannelOpenData->pInterface;
+		PubSub_OnChannelAttached(instance->context->pubSub, instance->context, &e);
+	}
+
+fail:
+	return error;
+}
+
+UINT freerdp_channels_detach(freerdp* instance)
+{
+	UINT error = CHANNEL_RC_OK;
+	const char* hostname = NULL;
+	size_t hostnameLength = 0;
+	rdpChannels* channels = NULL;
+	rdpContext* context = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(instance);
+
+	context = instance->context;
+	WINPR_ASSERT(context);
+
+	channels = context->channels;
+	WINPR_ASSERT(channels);
+
+	WINPR_ASSERT(context->settings);
+	hostname = freerdp_settings_get_string(context->settings, FreeRDP_ServerHostname);
+	WINPR_ASSERT(hostname);
+	hostnameLength = strnlen(hostname, MAX_PATH);
+
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		union
+		{
+			const void* cpv;
+			void* pv;
+		} cnv;
+
+		ChannelDetachedEventArgs e = { 0 };
+		CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+
+		cnv.cpv = hostname;
+		pChannelClientData = &channels->clientDataList[index];
+
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_DETACHED, cnv.pv,
+			                                          (UINT)hostnameLength);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(
+			    pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
+			    CHANNEL_EVENT_DETACHED, cnv.pv, (UINT)hostnameLength);
+		}
+
+		if (getChannelError(context) != CHANNEL_RC_OK)
+			goto fail;
+
+		pChannelOpenData = &channels->openDataList[index];
+		EventArgsInit(&e, "freerdp");
+		e.name = pChannelOpenData->name;
+		e.pInterface = pChannelOpenData->pInterface;
+		PubSub_OnChannelDetached(context->pubSub, context, &e);
+	}
+
+fail:
+	return error;
+}
+
+/**
+ * go through and inform all the libraries that we are connected
+ * this will tell the libraries that its ok to call MyVirtualChannelOpen
+ * called only from main thread
+ */
+UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
+{
+	UINT error = CHANNEL_RC_OK;
+	const char* hostname = NULL;
+	size_t hostnameLength = 0;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(channels);
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	channels->connected = TRUE;
+	hostname = freerdp_settings_get_string(instance->context->settings, FreeRDP_ServerHostname);
+	WINPR_ASSERT(hostname);
+	hostnameLength = strnlen(hostname, MAX_PATH);
+
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		union
+		{
+			const void* pcb;
+			void* pb;
+		} cnv;
+		ChannelConnectedEventArgs e = { 0 };
+		CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+		pChannelClientData = &channels->clientDataList[index];
+
+		cnv.pcb = hostname;
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_CONNECTED, cnv.pb,
+			                                          (UINT)hostnameLength);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(
+			    pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
+			    CHANNEL_EVENT_CONNECTED, cnv.pb, (UINT)hostnameLength);
+		}
+
+		error = getChannelError(instance->context);
+		if (error != CHANNEL_RC_OK)
+			goto fail;
+
+		pChannelOpenData = &channels->openDataList[index];
+		EventArgsInit(&e, "freerdp");
+		e.name = pChannelOpenData->name;
+		e.pInterface = pChannelOpenData->pInterface;
+		PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e);
+	}
+
+	channels->drdynvc = (DrdynvcClientContext*)freerdp_channels_get_static_channel_interface(
+	    channels, DRDYNVC_SVC_CHANNEL_NAME);
+
+	if (channels->drdynvc)
+	{
+		channels->drdynvc->custom = (void*)channels;
+		channels->drdynvc->OnChannelConnected = freerdp_drdynvc_on_channel_connected;
+		channels->drdynvc->OnChannelDisconnected = freerdp_drdynvc_on_channel_disconnected;
+		channels->drdynvc->OnChannelAttached = freerdp_drdynvc_on_channel_attached;
+		channels->drdynvc->OnChannelDetached = freerdp_drdynvc_on_channel_detached;
+	}
+
+fail:
+	return error;
+}
+
+BOOL freerdp_channels_data(freerdp* instance, UINT16 channelId, const BYTE* cdata, size_t dataSize,
+                           UINT32 flags, size_t totalSize)
+{
+	rdpMcs* mcs = NULL;
+	rdpChannels* channels = NULL;
+	rdpMcsChannel* channel = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	union
+	{
+		const BYTE* pcb;
+		BYTE* pb;
+	} data;
+
+	data.pcb = cdata;
+	if (!instance || !data.pcb)
+	{
+		WLog_ERR(TAG, "(%p, %" PRIu16 ", %p, 0x%08x): Invalid arguments", instance, channelId,
+		         data.pcb, flags);
+		return FALSE;
+	}
+
+	mcs = instance->context->rdp->mcs;
+	channels = instance->context->channels;
+
+	if (!channels || !mcs)
+	{
+		return FALSE;
+	}
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* cur = &mcs->channels[index];
+
+		if (cur->ChannelId == channelId)
+		{
+			channel = cur;
+			break;
+		}
+	}
+
+	if (!channel)
+	{
+		return FALSE;
+	}
+
+	pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, channel->Name);
+
+	if (!pChannelOpenData)
+	{
+		return FALSE;
+	}
+
+	if (pChannelOpenData->pChannelOpenEventProc)
+	{
+		pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->OpenHandle,
+		                                        CHANNEL_EVENT_DATA_RECEIVED, data.pb,
+		                                        (UINT32)dataSize, (UINT32)totalSize, flags);
+	}
+	else if (pChannelOpenData->pChannelOpenEventProcEx)
+	{
+		pChannelOpenData->pChannelOpenEventProcEx(
+		    pChannelOpenData->lpUserParam, pChannelOpenData->OpenHandle,
+		    CHANNEL_EVENT_DATA_RECEIVED, data.pb, (UINT32)dataSize, (UINT32)totalSize, flags);
+	}
+
+	return TRUE;
+}
+
+UINT16 freerdp_channels_get_id_by_name(freerdp* instance, const char* channel_name)
+{
+	if (!instance || !channel_name)
+		return 0;
+
+	rdpMcsChannel* mcsChannel =
+	    freerdp_channels_find_channel_by_name(instance->context->rdp, channel_name);
+	if (!mcsChannel)
+		return 0;
+
+	return mcsChannel->ChannelId;
+}
+
+const char* freerdp_channels_get_name_by_id(freerdp* instance, UINT16 channelId)
+{
+	rdpMcsChannel* mcsChannel = NULL;
+	if (!instance)
+		return NULL;
+
+	mcsChannel = freerdp_channels_find_channel_by_id(instance->context->rdp, channelId);
+	if (!mcsChannel)
+		return NULL;
+
+	return mcsChannel->Name;
+}
+
+BOOL freerdp_channels_process_message_free(wMessage* message, DWORD type)
+{
+	if (message->id == WMQ_QUIT)
+	{
+		return FALSE;
+	}
+
+	if (message->id == 0)
+	{
+		CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+		CHANNEL_OPEN_EVENT* item = (CHANNEL_OPEN_EVENT*)message->wParam;
+
+		if (!item)
+			return FALSE;
+
+		pChannelOpenData = item->pChannelOpenData;
+
+		if (pChannelOpenData->pChannelOpenEventProc)
+		{
+			pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->OpenHandle, type,
+			                                        item->UserData, item->DataLength,
+			                                        item->DataLength, 0);
+		}
+		else if (pChannelOpenData->pChannelOpenEventProcEx)
+		{
+			pChannelOpenData->pChannelOpenEventProcEx(
+			    pChannelOpenData->lpUserParam, pChannelOpenData->OpenHandle, type, item->UserData,
+			    item->DataLength, item->DataLength, 0);
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_channels_process_message(freerdp* instance, wMessage* message)
+{
+	BOOL ret = TRUE;
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(message);
+
+	if (message->id == WMQ_QUIT)
+		goto fail;
+	else if (message->id == 0)
+	{
+		rdpMcsChannel* channel = NULL;
+		CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+		CHANNEL_OPEN_EVENT* item = (CHANNEL_OPEN_EVENT*)message->wParam;
+
+		if (!item)
+			goto fail;
+
+		pChannelOpenData = item->pChannelOpenData;
+		if (pChannelOpenData->flags != 2)
+		{
+			freerdp_channels_process_message_free(message, CHANNEL_EVENT_WRITE_CANCELLED);
+			goto fail;
+		}
+		channel =
+		    freerdp_channels_find_channel_by_name(instance->context->rdp, pChannelOpenData->name);
+
+		if (channel)
+			ret = instance->SendChannelData(instance, channel->ChannelId, item->Data,
+			                                item->DataLength);
+	}
+
+	if (!freerdp_channels_process_message_free(message, CHANNEL_EVENT_WRITE_COMPLETE))
+		goto fail;
+
+	rc = ret;
+
+fail:
+	IFCALL(message->Free, message);
+	return rc;
+}
+
+/**
+ * called only from main thread
+ */
+static BOOL freerdp_channels_process_sync(rdpChannels* channels, freerdp* instance)
+{
+	BOOL status = TRUE;
+	wMessage message = { 0 };
+
+	WINPR_ASSERT(channels);
+
+	while (MessageQueue_Peek(channels->queue, &message, TRUE))
+	{
+		if (!freerdp_channels_process_message(instance, &message))
+			status = FALSE;
+	}
+
+	return status;
+}
+
+/**
+ * called only from main thread
+ */
+#if defined(WITH_FREERDP_DEPRECATED)
+BOOL freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance, void** read_fds,
+                              int* read_count, void** write_fds, int* write_count)
+{
+	void* pfd = NULL;
+	pfd = GetEventWaitObject(MessageQueue_Event(channels->queue));
+
+	if (pfd)
+	{
+		read_fds[*read_count] = pfd;
+		(*read_count)++;
+	}
+
+	return TRUE;
+}
+#endif
+
+void* freerdp_channels_get_static_channel_interface(rdpChannels* channels, const char* name)
+{
+	void* pInterface = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData =
+	    freerdp_channels_find_channel_open_data_by_name(channels, name);
+
+	if (pChannelOpenData)
+		pInterface = pChannelOpenData->pInterface;
+
+	return pInterface;
+}
+
+HANDLE freerdp_channels_get_event_handle(freerdp* instance)
+{
+	if (!instance)
+		return INVALID_HANDLE_VALUE;
+
+	WINPR_ASSERT(instance->context);
+
+	rdpChannels* channels = instance->context->channels;
+	WINPR_ASSERT(channels);
+
+	return MessageQueue_Event(channels->queue);
+}
+
+static BOOL channels_process(const void* key, void* value, void* arg)
+{
+	ChannelEventEntry* entry = value;
+	rdpContext* context = arg;
+
+	WINPR_UNUSED(key);
+
+	if (!entry->fkt)
+		return FALSE;
+	return entry->fkt(context, entry->userdata);
+}
+
+int freerdp_channels_process_pending_messages(freerdp* instance)
+{
+	if (!instance)
+		return -1;
+
+	WINPR_ASSERT(instance->context);
+
+	rdpChannels* channels = instance->context->channels;
+	WINPR_ASSERT(channels);
+
+	const DWORD status = WaitForSingleObject(MessageQueue_Event(channels->queue), 0);
+	if (status == WAIT_OBJECT_0)
+	{
+		if (!freerdp_channels_process_sync(channels, instance))
+			return -1;
+	}
+
+	if (!HashTable_Foreach(channels->channelEvents, channels_process, instance->context))
+		return -1;
+
+	return 1;
+}
+
+/**
+ * called only from main thread
+ */
+BOOL freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance)
+{
+	WINPR_ASSERT(channels);
+	WINPR_UNUSED(channels);
+
+	const int rc = freerdp_channels_process_pending_messages(instance);
+	return rc == 1;
+}
+
+BOOL freerdp_client_channel_register(rdpChannels* channels, HANDLE handle,
+                                     freerdp_channel_handle_fkt_t fkt, void* userdata)
+{
+	if (!channels || (handle == INVALID_HANDLE_VALUE) || !fkt)
+	{
+		WLog_ERR(TAG, "Invalid function arguments (channels=%p, handle=%p, fkt=%p, userdata=%p",
+		         channels, handle, fkt, userdata);
+		return FALSE;
+	}
+
+	ChannelEventEntry entry = { .fkt = fkt, .userdata = userdata };
+	return HashTable_Insert(channels->channelEvents, handle, &entry);
+}
+
+BOOL freerdp_client_channel_unregister(rdpChannels* channels, HANDLE handle)
+{
+	if (!channels || (handle == INVALID_HANDLE_VALUE))
+	{
+		WLog_ERR(TAG, "Invalid function arguments (channels=%p, handle=%p", channels, handle);
+		return FALSE;
+	}
+
+	return HashTable_Remove(channels->channelEvents, handle);
+}
+
+SSIZE_T freerdp_client_channel_get_registered_event_handles(rdpChannels* channels, HANDLE* events,
+                                                            DWORD count)
+{
+	SSIZE_T rc = -1;
+
+	WINPR_ASSERT(channels);
+	WINPR_ASSERT(events || (count == 0));
+
+	HashTable_Lock(channels->channelEvents);
+	size_t len = HashTable_Count(channels->channelEvents);
+	if (len <= count)
+	{
+		ULONG_PTR* keys = NULL;
+		const size_t nrKeys = HashTable_GetKeys(channels->channelEvents, &keys);
+		if ((nrKeys <= SSIZE_MAX) && (nrKeys == len))
+		{
+			for (size_t x = 0; x < nrKeys; x++)
+			{
+				HANDLE cur = (HANDLE)keys[x];
+				events[x] = cur;
+			}
+			rc = (SSIZE_T)nrKeys;
+		}
+		free(keys);
+	}
+	HashTable_Unlock(channels->channelEvents);
+	return rc;
+}
+
+UINT freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance)
+{
+	UINT error = CHANNEL_RC_OK;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(channels);
+
+	if (!channels->connected)
+		return 0;
+
+	(void)freerdp_channels_check_fds(channels, instance);
+
+	/* tell all libraries we are shutting down */
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		ChannelDisconnectedEventArgs e = { 0 };
+		pChannelClientData = &channels->clientDataList[index];
+
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_DISCONNECTED, 0, 0);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
+			                                            pChannelClientData->pInitHandle,
+			                                            CHANNEL_EVENT_DISCONNECTED, 0, 0);
+		}
+
+		if (getChannelError(instance->context) != CHANNEL_RC_OK)
+			continue;
+
+		pChannelOpenData = &channels->openDataList[index];
+		EventArgsInit(&e, "freerdp");
+		e.name = pChannelOpenData->name;
+		e.pInterface = pChannelOpenData->pInterface;
+		PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
+	}
+
+	channels->connected = FALSE;
+
+	/* Flush pending messages */
+	(void)freerdp_channels_check_fds(channels, instance);
+	return error;
+}
+
+void freerdp_channels_close(rdpChannels* channels, freerdp* instance)
+{
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(channels);
+	WINPR_ASSERT(instance);
+
+	MessageQueue_PostQuit(channels->queue, 0);
+	(void)freerdp_channels_check_fds(channels, instance);
+
+	/* tell all libraries we are shutting down */
+	for (int index = 0; index < channels->clientDataCount; index++)
+	{
+		pChannelClientData = &channels->clientDataList[index];
+
+		if (pChannelClientData->pChannelInitEventProc)
+		{
+			pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+			                                          CHANNEL_EVENT_TERMINATED, 0, 0);
+		}
+		else if (pChannelClientData->pChannelInitEventProcEx)
+		{
+			pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
+			                                            pChannelClientData->pInitHandle,
+			                                            CHANNEL_EVENT_TERMINATED, 0, 0);
+		}
+	}
+
+	for (int index = 0; index < channels->openDataCount; index++)
+	{
+		pChannelOpenData = &channels->openDataList[index];
+		HashTable_Remove(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->OpenHandle);
+	}
+
+	channels->openDataCount = 0;
+	channels->initDataCount = 0;
+	channels->clientDataCount = 0;
+
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+	instance->context->settings->ChannelCount = 0;
+	g_Instance = NULL;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
+    LPVOID lpUserParam, LPVOID clientContext, LPVOID pInitHandle, PCHANNEL_DEF pChannel,
+    INT channelCount, ULONG versionRequested, PCHANNEL_INIT_EVENT_EX_FN pChannelInitEventProcEx)
+{
+	rdpSettings* settings = NULL;
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+	rdpChannels* channels = NULL;
+
+	if (!pInitHandle)
+		return CHANNEL_RC_BAD_INIT_HANDLE;
+
+	if (!pChannel)
+		return CHANNEL_RC_BAD_CHANNEL;
+
+	if ((channelCount <= 0) || !pChannelInitEventProcEx)
+		return CHANNEL_RC_INITIALIZATION_ERROR;
+
+	pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
+	WINPR_ASSERT(pChannelInitData);
+
+	channels = pChannelInitData->channels;
+	WINPR_ASSERT(channels);
+
+	if (!channels->can_call_init)
+		return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
+
+	if ((channels->openDataCount + channelCount) > CHANNEL_MAX_COUNT)
+		return CHANNEL_RC_TOO_MANY_CHANNELS;
+
+	if (channels->connected)
+		return CHANNEL_RC_ALREADY_CONNECTED;
+
+	if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
+	{
+	}
+
+	for (int index = 0; index < channelCount; index++)
+	{
+		const PCHANNEL_DEF pChannelDef = &pChannel[index];
+
+		if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != 0)
+		{
+			return CHANNEL_RC_BAD_CHANNEL;
+		}
+	}
+
+	pChannelInitData->pInterface = clientContext;
+	pChannelClientData = &channels->clientDataList[channels->clientDataCount];
+	pChannelClientData->pChannelInitEventProcEx = pChannelInitEventProcEx;
+	pChannelClientData->pInitHandle = pInitHandle;
+	pChannelClientData->lpUserParam = lpUserParam;
+	channels->clientDataCount++;
+
+	WINPR_ASSERT(channels->instance);
+	WINPR_ASSERT(channels->instance->context);
+	settings = channels->instance->context->settings;
+	WINPR_ASSERT(settings);
+
+	for (int index = 0; index < channelCount; index++)
+	{
+		const PCHANNEL_DEF pChannelDef = &pChannel[index];
+		CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[channels->openDataCount];
+
+		WINPR_ASSERT(pChannelOpenData);
+
+		const LONG hdl = InterlockedIncrement(&g_OpenHandleSeq);
+		pChannelOpenData->OpenHandle = WINPR_ASSERTING_INT_CAST(uint32_t, hdl);
+		pChannelOpenData->channels = channels;
+		pChannelOpenData->lpUserParam = lpUserParam;
+		if (!HashTable_Insert(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->OpenHandle,
+		                      (void*)pChannelOpenData))
+		{
+			pChannelInitData->pInterface = NULL;
+			return CHANNEL_RC_INITIALIZATION_ERROR;
+		}
+		pChannelOpenData->flags = 1; /* init */
+		strncpy(pChannelOpenData->name, pChannelDef->name, CHANNEL_NAME_LEN);
+		pChannelOpenData->options = pChannelDef->options;
+
+		const UINT32 max = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
+		WINPR_ASSERT(max >= CHANNEL_MAX_COUNT);
+		if (settings->ChannelCount < max)
+		{
+			CHANNEL_DEF* channel = freerdp_settings_get_pointer_array_writable(
+			    settings, FreeRDP_ChannelDefArray, settings->ChannelCount);
+			if (!channel)
+				continue;
+			strncpy(channel->name, pChannelDef->name, CHANNEL_NAME_LEN);
+			channel->options = pChannelDef->options;
+			settings->ChannelCount++;
+		}
+
+		channels->openDataCount++;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle, PCHANNEL_DEF pChannel,
+                                                 INT channelCount, ULONG versionRequested,
+                                                 PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
+{
+	CHANNEL_DEF* channel = NULL;
+	rdpSettings* settings = NULL;
+	PCHANNEL_DEF pChannelDef = NULL;
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+	rdpChannels* channels = NULL;
+
+	/* g_Instance should have been set during freerdp_connect - otherwise VirtualChannelInit was
+	 * called from a different thread */
+	if (!g_Instance || !g_Instance->context)
+		return CHANNEL_RC_NOT_INITIALIZED;
+
+	channels = g_Instance->context->channels;
+
+	if (!ppInitHandle || !channels)
+		return CHANNEL_RC_BAD_INIT_HANDLE;
+
+	if (!pChannel)
+		return CHANNEL_RC_BAD_CHANNEL;
+
+	if ((channelCount <= 0) || !pChannelInitEventProc)
+		return CHANNEL_RC_INITIALIZATION_ERROR;
+
+	pChannelInitData = &(channels->initDataList[channels->initDataCount]);
+	*ppInitHandle = pChannelInitData;
+	channels->initDataCount++;
+	pChannelInitData->channels = channels;
+	pChannelInitData->pInterface = NULL;
+
+	if (!channels->can_call_init)
+		return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
+
+	if (channels->openDataCount + channelCount > CHANNEL_MAX_COUNT)
+		return CHANNEL_RC_TOO_MANY_CHANNELS;
+
+	if (channels->connected)
+		return CHANNEL_RC_ALREADY_CONNECTED;
+
+	if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
+	{
+	}
+
+	for (int index = 0; index < channelCount; index++)
+	{
+		pChannelDef = &pChannel[index];
+
+		if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != 0)
+		{
+			return CHANNEL_RC_BAD_CHANNEL;
+		}
+	}
+
+	pChannelClientData = &channels->clientDataList[channels->clientDataCount];
+	pChannelClientData->pChannelInitEventProc = pChannelInitEventProc;
+	pChannelClientData->pInitHandle = *ppInitHandle;
+	channels->clientDataCount++;
+	settings = channels->instance->context->settings;
+
+	for (int index = 0; index < channelCount; index++)
+	{
+		UINT32 ChannelCount = freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount);
+
+		pChannelDef = &pChannel[index];
+
+		pChannelOpenData = &channels->openDataList[channels->openDataCount];
+
+		const LONG hdl = InterlockedIncrement(&g_OpenHandleSeq);
+		pChannelOpenData->OpenHandle = WINPR_ASSERTING_INT_CAST(uint32_t, hdl);
+		pChannelOpenData->channels = channels;
+		if (!HashTable_Insert(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->OpenHandle,
+		                      (void*)pChannelOpenData))
+			return CHANNEL_RC_INITIALIZATION_ERROR;
+		pChannelOpenData->flags = 1; /* init */
+		strncpy(pChannelOpenData->name, pChannelDef->name, CHANNEL_NAME_LEN);
+		pChannelOpenData->options = pChannelDef->options;
+
+		if (ChannelCount < CHANNEL_MAX_COUNT)
+		{
+			channel = freerdp_settings_get_pointer_array_writable(settings, FreeRDP_ChannelDefArray,
+			                                                      ChannelCount++);
+			strncpy(channel->name, pChannelDef->name, CHANNEL_NAME_LEN);
+			channel->options = pChannelDef->options;
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, ChannelCount))
+				return ERROR_INTERNAL_ERROR;
+		}
+
+		channels->openDataCount++;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE
+FreeRDP_VirtualChannelOpenEx(LPVOID pInitHandle, LPDWORD pOpenHandle, PCHAR pChannelName,
+                             PCHANNEL_OPEN_EVENT_EX_FN pChannelOpenEventProcEx)
+{
+	void* pInterface = NULL;
+	rdpChannels* channels = NULL;
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
+	channels = pChannelInitData->channels;
+	pInterface = pChannelInitData->pInterface;
+
+	if (!pOpenHandle)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (!pChannelOpenEventProcEx)
+		return CHANNEL_RC_BAD_PROC;
+
+	if (!channels->connected)
+		return CHANNEL_RC_NOT_CONNECTED;
+
+	pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, pChannelName);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
+
+	if (pChannelOpenData->flags == 2)
+		return CHANNEL_RC_ALREADY_OPEN;
+
+	pChannelOpenData->flags = 2; /* open */
+	pChannelOpenData->pInterface = pInterface;
+	pChannelOpenData->pChannelOpenEventProcEx = pChannelOpenEventProcEx;
+	*pOpenHandle = pChannelOpenData->OpenHandle;
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelOpen(LPVOID pInitHandle, LPDWORD pOpenHandle,
+                                                 PCHAR pChannelName,
+                                                 PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
+{
+	void* pInterface = NULL;
+	rdpChannels* channels = NULL;
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
+	channels = pChannelInitData->channels;
+	pInterface = pChannelInitData->pInterface;
+
+	if (!pOpenHandle)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (!pChannelOpenEventProc)
+		return CHANNEL_RC_BAD_PROC;
+
+	if (!channels->connected)
+		return CHANNEL_RC_NOT_CONNECTED;
+
+	pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, pChannelName);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
+
+	if (pChannelOpenData->flags == 2)
+		return CHANNEL_RC_ALREADY_OPEN;
+
+	pChannelOpenData->flags = 2; /* open */
+	pChannelOpenData->pInterface = pInterface;
+	pChannelOpenData->pChannelOpenEventProc = pChannelOpenEventProc;
+	*pOpenHandle = pChannelOpenData->OpenHandle;
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelCloseEx(LPVOID pInitHandle, DWORD openHandle)
+{
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+
+	if (!pInitHandle)
+		return CHANNEL_RC_BAD_INIT_HANDLE;
+
+	pChannelOpenData = HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (pChannelOpenData->flags != 2)
+		return CHANNEL_RC_NOT_OPEN;
+
+	pChannelOpenData->flags = 0;
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelClose(DWORD openHandle)
+{
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+
+	pChannelOpenData = HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (pChannelOpenData->flags != 2)
+		return CHANNEL_RC_NOT_OPEN;
+
+	pChannelOpenData->flags = 0;
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelWriteEx(LPVOID pInitHandle, DWORD openHandle,
+                                                    LPVOID pData, ULONG dataLength,
+                                                    LPVOID pUserData)
+{
+	rdpChannels* channels = NULL;
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	CHANNEL_OPEN_EVENT* pChannelOpenEvent = NULL;
+	wMessage message = { 0 };
+
+	if (!pInitHandle)
+		return CHANNEL_RC_BAD_INIT_HANDLE;
+
+	pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
+	channels = pChannelInitData->channels;
+
+	if (!channels)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	pChannelOpenData = HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (!channels->connected)
+		return CHANNEL_RC_NOT_CONNECTED;
+
+	if (!pData)
+		return CHANNEL_RC_NULL_DATA;
+
+	if (!dataLength)
+		return CHANNEL_RC_ZERO_LENGTH;
+
+	if (pChannelOpenData->flags != 2)
+		return CHANNEL_RC_NOT_OPEN;
+
+	pChannelOpenEvent = (CHANNEL_OPEN_EVENT*)malloc(sizeof(CHANNEL_OPEN_EVENT));
+
+	if (!pChannelOpenEvent)
+		return CHANNEL_RC_NO_MEMORY;
+
+	pChannelOpenEvent->Data = pData;
+	pChannelOpenEvent->DataLength = dataLength;
+	pChannelOpenEvent->UserData = pUserData;
+	pChannelOpenEvent->pChannelOpenData = pChannelOpenData;
+	message.context = channels;
+	message.id = 0;
+	message.wParam = pChannelOpenEvent;
+	message.lParam = NULL;
+	message.Free = channel_queue_message_free;
+
+	if (!MessageQueue_Dispatch(channels->queue, &message))
+	{
+		free(pChannelOpenEvent);
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT VCAPITYPE FreeRDP_VirtualChannelWrite(DWORD openHandle, LPVOID pData, ULONG dataLength,
+                                                  LPVOID pUserData)
+{
+	wMessage message = { 0 };
+	CHANNEL_OPEN_DATA* pChannelOpenData = NULL;
+	CHANNEL_OPEN_EVENT* pChannelOpenEvent = NULL;
+	rdpChannels* channels = NULL;
+
+	pChannelOpenData = HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
+
+	if (!pChannelOpenData)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	channels = pChannelOpenData->channels;
+	if (!channels)
+		return CHANNEL_RC_BAD_CHANNEL_HANDLE;
+
+	if (!channels->connected)
+		return CHANNEL_RC_NOT_CONNECTED;
+
+	if (!pData)
+		return CHANNEL_RC_NULL_DATA;
+
+	if (!dataLength)
+		return CHANNEL_RC_ZERO_LENGTH;
+
+	if (pChannelOpenData->flags != 2)
+		return CHANNEL_RC_NOT_OPEN;
+
+	pChannelOpenEvent = (CHANNEL_OPEN_EVENT*)malloc(sizeof(CHANNEL_OPEN_EVENT));
+
+	if (!pChannelOpenEvent)
+		return CHANNEL_RC_NO_MEMORY;
+
+	pChannelOpenEvent->Data = pData;
+	pChannelOpenEvent->DataLength = dataLength;
+	pChannelOpenEvent->UserData = pUserData;
+	pChannelOpenEvent->pChannelOpenData = pChannelOpenData;
+	message.context = channels;
+	message.id = 0;
+	message.wParam = pChannelOpenEvent;
+	message.lParam = NULL;
+	message.Free = channel_queue_message_free;
+
+	if (!MessageQueue_Dispatch(channels->queue, &message))
+	{
+		free(pChannelOpenEvent);
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static BOOL freerdp_channels_is_loaded(rdpChannels* channels, PVIRTUALCHANNELENTRY entry)
+{
+	for (int i = 0; i < channels->clientDataCount; i++)
+	{
+		CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[i];
+
+		if (pChannelClientData->entry == entry)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL freerdp_channels_is_loaded_ex(rdpChannels* channels, PVIRTUALCHANNELENTRYEX entryEx)
+{
+	for (int i = 0; i < channels->clientDataCount; i++)
+	{
+		CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[i];
+
+		if (pChannelClientData->entryEx == entryEx)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings,
+                                 PVIRTUALCHANNELENTRY entry, void* data)
+{
+	int status = 0;
+	CHANNEL_ENTRY_POINTS_FREERDP EntryPoints = { 0 };
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(channels);
+	WINPR_ASSERT(channels->instance);
+	WINPR_ASSERT(channels->instance->context);
+	WINPR_ASSERT(entry);
+
+	if (channels->clientDataCount + 1 > CHANNEL_MAX_COUNT)
+	{
+		WLog_ERR(TAG, "error: too many channels");
+		return 1;
+	}
+
+	if (freerdp_channels_is_loaded(channels, entry))
+	{
+		WLog_WARN(TAG, "Skipping, channel already loaded");
+		return 0;
+	}
+
+	pChannelClientData = &channels->clientDataList[channels->clientDataCount];
+	pChannelClientData->entry = entry;
+
+	EntryPoints.cbSize = sizeof(EntryPoints);
+	EntryPoints.protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000;
+	EntryPoints.pVirtualChannelInit = FreeRDP_VirtualChannelInit;
+	EntryPoints.pVirtualChannelOpen = FreeRDP_VirtualChannelOpen;
+	EntryPoints.pVirtualChannelClose = FreeRDP_VirtualChannelClose;
+	EntryPoints.pVirtualChannelWrite = FreeRDP_VirtualChannelWrite;
+	EntryPoints.MagicNumber = FREERDP_CHANNEL_MAGIC_NUMBER;
+	EntryPoints.pExtendedData = data;
+	EntryPoints.context = channels->instance->context;
+	/* enable VirtualChannelInit */
+	channels->can_call_init = TRUE;
+	EnterCriticalSection(&channels->channelsLock);
+	status = pChannelClientData->entry((PCHANNEL_ENTRY_POINTS)&EntryPoints);
+	LeaveCriticalSection(&channels->channelsLock);
+	/* disable MyVirtualChannelInit */
+	channels->can_call_init = FALSE;
+
+	if (!status)
+	{
+		WLog_ERR(TAG, "error: channel export function call failed");
+		return 1;
+	}
+
+	return 0;
+}
+
+int freerdp_channels_client_load_ex(rdpChannels* channels, rdpSettings* settings,
+                                    PVIRTUALCHANNELENTRYEX entryEx, void* data)
+{
+	int status = 0;
+	void* pInitHandle = NULL;
+	CHANNEL_ENTRY_POINTS_FREERDP_EX EntryPointsEx = { 0 };
+	CHANNEL_INIT_DATA* pChannelInitData = NULL;
+	CHANNEL_CLIENT_DATA* pChannelClientData = NULL;
+
+	WINPR_ASSERT(channels);
+	WINPR_ASSERT(channels->instance);
+	WINPR_ASSERT(channels->instance->context);
+	WINPR_ASSERT(entryEx);
+
+	if (channels->clientDataCount + 1 > CHANNEL_MAX_COUNT)
+	{
+		WLog_ERR(TAG, "error: too many channels");
+		return 1;
+	}
+
+	if (freerdp_channels_is_loaded_ex(channels, entryEx))
+	{
+		WLog_WARN(TAG, "Skipping, channel already loaded");
+		return 0;
+	}
+
+	pChannelClientData = &channels->clientDataList[channels->clientDataCount];
+	pChannelClientData->entryEx = entryEx;
+	pChannelInitData = &(channels->initDataList[channels->initDataCount++]);
+	pInitHandle = pChannelInitData;
+	pChannelInitData->channels = channels;
+	EntryPointsEx.cbSize = sizeof(EntryPointsEx);
+	EntryPointsEx.protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000;
+	EntryPointsEx.pVirtualChannelInitEx = FreeRDP_VirtualChannelInitEx;
+	EntryPointsEx.pVirtualChannelOpenEx = FreeRDP_VirtualChannelOpenEx;
+	EntryPointsEx.pVirtualChannelCloseEx = FreeRDP_VirtualChannelCloseEx;
+	EntryPointsEx.pVirtualChannelWriteEx = FreeRDP_VirtualChannelWriteEx;
+	EntryPointsEx.MagicNumber = FREERDP_CHANNEL_MAGIC_NUMBER;
+	EntryPointsEx.pExtendedData = data;
+	EntryPointsEx.context = channels->instance->context;
+	/* enable VirtualChannelInit */
+	channels->can_call_init = TRUE;
+	EnterCriticalSection(&channels->channelsLock);
+	status = pChannelClientData->entryEx((PCHANNEL_ENTRY_POINTS_EX)&EntryPointsEx, pInitHandle);
+	LeaveCriticalSection(&channels->channelsLock);
+	/* disable MyVirtualChannelInit */
+	channels->can_call_init = FALSE;
+
+	if (!status)
+	{
+		WLog_ERR(TAG, "error: channel export function call failed");
+		return 1;
+	}
+
+	return 0;
+}
+
+/**
+ * this is called when processing the command line parameters
+ * called only from main thread
+ */
+int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings, const char* name,
+                                 void* data)
+{
+	PVIRTUALCHANNELENTRY entry =
+	    freerdp_load_channel_addin_entry(name, NULL, NULL, FREERDP_ADDIN_CHANNEL_STATIC);
+
+	if (!entry)
+		return 1;
+
+	return freerdp_channels_client_load(channels, settings, entry, data);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/listener.c

@@ -0,0 +1,552 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Server Listener
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <winpr/crt.h>
+#include <winpr/windows.h>
+#include <freerdp/log.h>
+
+#ifndef _WIN32
+#include <netdb.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#endif
+
+#if defined(HAVE_AF_VSOCK_H)
+#include <ctype.h>
+#include <linux/vm_sockets.h>
+#endif
+
+#include <winpr/handle.h>
+
+#include "listener.h"
+#include "utils.h"
+
+#define TAG FREERDP_TAG("core.listener")
+
+static BOOL freerdp_listener_open_from_vsock(freerdp_listener* instance, const char* bind_address,
+                                             UINT16 port)
+{
+#if defined(HAVE_AF_VSOCK_H)
+	rdpListener* listener = (rdpListener*)instance->listener;
+	const int sockfd = socket(AF_VSOCK, SOCK_STREAM, 0);
+	if (sockfd == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "Error creating socket: %s", winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		return FALSE;
+	}
+	const int flags = fcntl(sockfd, F_GETFL, 0);
+	if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "Error making socket nonblocking: %s",
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		close(sockfd);
+		return FALSE;
+	}
+	struct sockaddr_vm addr = { 0 };
+
+	addr.svm_family = AF_VSOCK;
+	addr.svm_port = port;
+
+	errno = 0;
+	char* ptr = NULL;
+	unsigned long val = strtoul(bind_address, &ptr, 10);
+	if (errno || (val > UINT32_MAX))
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "could not extract port from '%s', value=%ul, error=%s", bind_address, val,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		close(sockfd);
+		return FALSE;
+	}
+	addr.svm_cid = WINPR_ASSERTING_INT_CAST(unsigned int, val);
+	if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_vm)) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "Error binding vsock at cid %d port %d: %s", addr.svm_cid, port,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		close(sockfd);
+		return FALSE;
+	}
+
+	if (listen(sockfd, 10) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "Error listening to socket at cid %d port %d: %s", addr.svm_cid, port,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		close(sockfd);
+		return FALSE;
+	}
+	listener->sockfds[listener->num_sockfds] = sockfd;
+	listener->events[listener->num_sockfds] = WSACreateEvent();
+
+	if (!listener->events[listener->num_sockfds])
+	{
+		listener->num_sockfds = 0;
+	}
+
+	WSAEventSelect((SOCKET)sockfd, listener->events[listener->num_sockfds],
+	               FD_READ | FD_ACCEPT | FD_CLOSE);
+	listener->num_sockfds++;
+
+	WLog_INFO(TAG, "Listening on %s:%d", bind_address, port);
+	return TRUE;
+#else
+	WLog_ERR(TAG, "compiled without AF_VSOCK, '%s' not supported", bind_address);
+	return FALSE;
+#endif
+}
+
+static BOOL freerdp_listener_open(freerdp_listener* instance, const char* bind_address, UINT16 port)
+{
+	int ai_flags = 0;
+	int status = 0;
+	int sockfd = 0;
+	char addr[64];
+	void* sin_addr = NULL;
+	int option_value = 0;
+	struct addrinfo* res = NULL;
+	rdpListener* listener = (rdpListener*)instance->listener;
+#ifdef _WIN32
+	u_long arg;
+#endif
+
+	if (!bind_address)
+		ai_flags = AI_PASSIVE;
+
+	if (utils_is_vsock(bind_address))
+	{
+		bind_address = utils_is_vsock(bind_address);
+		return freerdp_listener_open_from_vsock(instance, bind_address, port);
+	}
+
+	res = freerdp_tcp_resolve_host(bind_address, port, ai_flags);
+
+	if (!res)
+		return FALSE;
+
+	for (struct addrinfo* ai = res; ai && (listener->num_sockfds < 5); ai = ai->ai_next)
+	{
+		if ((ai->ai_family != AF_INET) && (ai->ai_family != AF_INET6))
+			continue;
+
+		if (listener->num_sockfds == MAX_LISTENER_HANDLES)
+		{
+			WLog_ERR(TAG, "too many listening sockets");
+			continue;
+		}
+
+		sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+
+		if (sockfd == -1)
+		{
+			WLog_ERR(TAG, "socket");
+			continue;
+		}
+
+		option_value = 1;
+
+		if (ai->ai_family == AF_INET)
+			sin_addr = &(((struct sockaddr_in*)ai->ai_addr)->sin_addr);
+		else
+		{
+			sin_addr = &(((struct sockaddr_in6*)ai->ai_addr)->sin6_addr);
+			if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&option_value,
+			               sizeof(option_value)) == -1)
+				WLog_ERR(TAG, "setsockopt");
+		}
+
+		inet_ntop(ai->ai_family, sin_addr, addr, sizeof(addr));
+
+		if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&option_value,
+		               sizeof(option_value)) == -1)
+			WLog_ERR(TAG, "setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR)");
+
+#ifndef _WIN32
+		if (fcntl(sockfd, F_SETFL, O_NONBLOCK) != 0)
+			WLog_ERR(TAG, "fcntl(sockfd, F_SETFL, O_NONBLOCK)");
+#else
+		arg = 1;
+		ioctlsocket(sockfd, FIONBIO, &arg);
+#endif
+		status = _bind((SOCKET)sockfd, ai->ai_addr, WINPR_ASSERTING_INT_CAST(int, ai->ai_addrlen));
+
+		if (status != 0)
+		{
+			closesocket((SOCKET)sockfd);
+			continue;
+		}
+
+		status = _listen((SOCKET)sockfd, 10);
+
+		if (status != 0)
+		{
+			WLog_ERR(TAG, "listen");
+			closesocket((SOCKET)sockfd);
+			continue;
+		}
+
+		/* FIXME: these file descriptors do not work on Windows */
+		listener->sockfds[listener->num_sockfds] = sockfd;
+		listener->events[listener->num_sockfds] = WSACreateEvent();
+
+		if (!listener->events[listener->num_sockfds])
+		{
+			listener->num_sockfds = 0;
+			break;
+		}
+
+		WSAEventSelect((SOCKET)sockfd, listener->events[listener->num_sockfds],
+		               FD_READ | FD_ACCEPT | FD_CLOSE);
+		listener->num_sockfds++;
+		WLog_INFO(TAG, "Listening on [%s]:%" PRIu16, addr, port);
+	}
+
+	freeaddrinfo(res);
+	return (listener->num_sockfds > 0 ? TRUE : FALSE);
+}
+
+static BOOL freerdp_listener_open_local(freerdp_listener* instance, const char* path)
+{
+#ifndef _WIN32
+	int status = 0;
+	int sockfd = 0;
+	struct sockaddr_un addr = { 0 };
+	rdpListener* listener = (rdpListener*)instance->listener;
+	HANDLE hevent = NULL;
+
+	if (listener->num_sockfds == MAX_LISTENER_HANDLES)
+	{
+		WLog_ERR(TAG, "too many listening sockets");
+		return FALSE;
+	}
+
+	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+	if (sockfd == -1)
+	{
+		WLog_ERR(TAG, "socket");
+		return FALSE;
+	}
+
+	int rc = fcntl(sockfd, F_SETFL, O_NONBLOCK);
+	if (rc != 0)
+	{
+		WLog_ERR(TAG, "fcntl(sockfd, F_SETFL, O_NONBLOCK)");
+		closesocket((SOCKET)sockfd);
+		return FALSE;
+	}
+
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
+	unlink(path);
+	status = _bind((SOCKET)sockfd, (struct sockaddr*)&addr, sizeof(addr));
+
+	if (status != 0)
+	{
+		WLog_ERR(TAG, "bind");
+		closesocket((SOCKET)sockfd);
+		return FALSE;
+	}
+
+	status = _listen((SOCKET)sockfd, 10);
+
+	if (status != 0)
+	{
+		WLog_ERR(TAG, "listen");
+		closesocket((SOCKET)sockfd);
+		return FALSE;
+	}
+
+	hevent = CreateFileDescriptorEvent(NULL, FALSE, FALSE, sockfd, WINPR_FD_READ);
+
+	if (!hevent)
+	{
+		WLog_ERR(TAG, "failed to create sockfd event");
+		closesocket((SOCKET)sockfd);
+		return FALSE;
+	}
+
+	listener->sockfds[listener->num_sockfds] = sockfd;
+	listener->events[listener->num_sockfds] = hevent;
+	listener->num_sockfds++;
+	WLog_INFO(TAG, "Listening on socket %s.", addr.sun_path);
+	return TRUE;
+#else
+	return TRUE;
+#endif
+}
+
+static BOOL freerdp_listener_open_from_socket(freerdp_listener* instance, int fd)
+{
+#ifndef _WIN32
+	rdpListener* listener = (rdpListener*)instance->listener;
+
+	if (listener->num_sockfds == MAX_LISTENER_HANDLES)
+	{
+		WLog_ERR(TAG, "too many listening sockets");
+		return FALSE;
+	}
+
+	if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
+		return FALSE;
+
+	listener->sockfds[listener->num_sockfds] = fd;
+	listener->events[listener->num_sockfds] = WSACreateEvent();
+
+	if (!listener->events[listener->num_sockfds])
+		return FALSE;
+
+	WSAEventSelect((SOCKET)fd, listener->events[listener->num_sockfds],
+	               FD_READ | FD_ACCEPT | FD_CLOSE);
+
+	listener->num_sockfds++;
+	WLog_INFO(TAG, "Listening on socket %d.", fd);
+	return TRUE;
+#else
+	return FALSE;
+#endif
+}
+
+static void freerdp_listener_close(freerdp_listener* instance)
+{
+	rdpListener* listener = (rdpListener*)instance->listener;
+
+	for (int i = 0; i < listener->num_sockfds; i++)
+	{
+		closesocket((SOCKET)listener->sockfds[i]);
+		(void)CloseHandle(listener->events[i]);
+	}
+
+	listener->num_sockfds = 0;
+}
+
+#if defined(WITH_FREERDP_DEPRECATED)
+static BOOL freerdp_listener_get_fds(freerdp_listener* instance, void** rfds, int* rcount)
+{
+	rdpListener* listener = (rdpListener*)instance->listener;
+
+	if (listener->num_sockfds < 1)
+		return FALSE;
+
+	for (int index = 0; index < listener->num_sockfds; index++)
+	{
+		rfds[*rcount] = (void*)(long)(listener->sockfds[index]);
+		(*rcount)++;
+	}
+
+	return TRUE;
+}
+#endif
+
+static DWORD freerdp_listener_get_event_handles(freerdp_listener* instance, HANDLE* events,
+                                                DWORD nCount)
+{
+	rdpListener* listener = (rdpListener*)instance->listener;
+
+	if (listener->num_sockfds < 1)
+		return 0;
+
+	if (listener->num_sockfds > (INT64)nCount)
+		return 0;
+
+	for (int index = 0; index < listener->num_sockfds; index++)
+	{
+		events[index] = listener->events[index];
+	}
+
+	return WINPR_ASSERTING_INT_CAST(uint32_t, listener->num_sockfds);
+}
+
+BOOL freerdp_peer_set_local_and_hostname(freerdp_peer* client,
+                                         const struct sockaddr_storage* peer_addr)
+{
+	const void* sin_addr = NULL;
+	const BYTE localhost6_bytes[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(peer_addr);
+
+	if (peer_addr->ss_family == AF_INET)
+	{
+		const UINT32* usin_addr = sin_addr = &(((const struct sockaddr_in*)peer_addr)->sin_addr);
+
+		if ((*usin_addr) == 0x0100007f)
+			client->local = TRUE;
+	}
+	else if (peer_addr->ss_family == AF_INET6)
+	{
+		const struct sockaddr_in6* usin_addr = sin_addr =
+		    &(((const struct sockaddr_in6*)peer_addr)->sin6_addr);
+
+		if (memcmp(usin_addr, localhost6_bytes, 16) == 0)
+			client->local = TRUE;
+	}
+
+#ifndef _WIN32
+#if defined(HAVE_AF_VSOCK_H)
+	else if (peer_addr->ss_family == AF_UNIX || peer_addr->ss_family == AF_VSOCK)
+#else
+	else if (peer_addr->ss_family == AF_UNIX)
+#endif
+		client->local = TRUE;
+#endif
+
+	if (client->local)
+		WLog_INFO(TAG, "Accepting client from localhost");
+
+	if (sin_addr)
+		inet_ntop(peer_addr->ss_family, sin_addr, client->hostname, sizeof(client->hostname));
+
+	return TRUE;
+}
+
+static BOOL freerdp_check_and_create_client(freerdp_listener* instance, int peer_sockfd,
+                                            const struct sockaddr_storage* peer_addr)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(peer_sockfd >= 0);
+	WINPR_ASSERT(peer_addr);
+
+	const BOOL check = IFCALLRESULT(TRUE, instance->CheckPeerAcceptRestrictions, instance);
+	if (!check)
+	{
+		closesocket((SOCKET)peer_sockfd);
+		return TRUE;
+	}
+
+	freerdp_peer* client = freerdp_peer_new(peer_sockfd);
+	if (!client)
+	{
+		closesocket((SOCKET)peer_sockfd);
+		return FALSE;
+	}
+
+	if (!freerdp_peer_set_local_and_hostname(client, peer_addr))
+	{
+		freerdp_peer_free(client);
+		return FALSE;
+	}
+
+	const BOOL peer_accepted = IFCALLRESULT(FALSE, instance->PeerAccepted, instance, client);
+	if (!peer_accepted)
+	{
+		WLog_ERR(TAG, "PeerAccepted callback failed");
+		freerdp_peer_free(client);
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_listener_check_fds(freerdp_listener* instance)
+{
+	rdpListener* listener = (rdpListener*)instance->listener;
+
+	if (listener->num_sockfds < 1)
+		return FALSE;
+
+	for (int i = 0; i < listener->num_sockfds; i++)
+	{
+		struct sockaddr_storage peer_addr = { 0 };
+
+		(void)WSAResetEvent(listener->events[i]);
+		int peer_addr_size = sizeof(peer_addr);
+		SOCKET peer_sockfd =
+		    _accept((SOCKET)listener->sockfds[i], (struct sockaddr*)&peer_addr, &peer_addr_size);
+
+		if (peer_sockfd == (SOCKET)-1)
+		{
+			char buffer[128] = { 0 };
+#ifdef _WIN32
+			int wsa_error = WSAGetLastError();
+
+			/* No data available */
+			if (wsa_error == WSAEWOULDBLOCK)
+				continue;
+
+#else
+
+			if (errno == EAGAIN || errno == EWOULDBLOCK)
+				continue;
+
+#endif
+			WLog_WARN(TAG, "accept failed with %s", winpr_strerror(errno, buffer, sizeof(buffer)));
+			return FALSE;
+		}
+
+		if (!freerdp_check_and_create_client(instance, (int)peer_sockfd, &peer_addr))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+freerdp_listener* freerdp_listener_new(void)
+{
+	freerdp_listener* instance = NULL;
+	rdpListener* listener = NULL;
+	instance = (freerdp_listener*)calloc(1, sizeof(freerdp_listener));
+
+	if (!instance)
+		return NULL;
+
+	instance->Open = freerdp_listener_open;
+	instance->OpenLocal = freerdp_listener_open_local;
+	instance->OpenFromSocket = freerdp_listener_open_from_socket;
+#if defined(WITH_FREERDP_DEPRECATED)
+	instance->GetFileDescriptor = freerdp_listener_get_fds;
+#endif
+	instance->GetEventHandles = freerdp_listener_get_event_handles;
+	instance->CheckFileDescriptor = freerdp_listener_check_fds;
+	instance->Close = freerdp_listener_close;
+	listener = (rdpListener*)calloc(1, sizeof(rdpListener));
+
+	if (!listener)
+	{
+		free(instance);
+		return NULL;
+	}
+
+	listener->instance = instance;
+	instance->listener = (void*)listener;
+	return instance;
+}
+
+void freerdp_listener_free(freerdp_listener* instance)
+{
+	if (instance)
+	{
+		free(instance->listener);
+		free(instance);
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/proxy.h

@@ -0,0 +1,32 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * HTTP proxy support
+ *
+ * Copyright 2014 Christian Plattner <ccpp@gmx.at>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_HTTP_PROXY_H
+#define FREERDP_LIB_CORE_HTTP_PROXY_H
+
+#include "freerdp/settings.h"
+#include <openssl/bio.h>
+
+BOOL proxy_prepare(rdpSettings* settings, const char** lpPeerHostname, UINT16* lpPeerPort,
+                   const char** lpProxyUsername, const char** lpProxyPassword);
+
+BOOL proxy_connect(rdpContext* context, BIO* bio, const char* proxyUsername,
+                   const char* proxyPassword, const char* hostname, UINT16 port);
+
+#endif /* FREERDP_LIB_CORE_HTTP_PROXY_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/graphics.c

@@ -0,0 +1,468 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Graphical Objects
+ *
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/log.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/shape.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include "clipping.h"
+#include "drawing.h"
+#include "brush.h"
+#include "graphics.h"
+
+#define TAG FREERDP_TAG("gdi")
+/* Bitmap Class */
+
+HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, UINT32 nWidth, UINT32 nHeight, UINT32 SrcFormat,
+                              BYTE* data)
+{
+	UINT32 nSrcStep = 0;
+	UINT32 nDstStep = 0;
+	BYTE* pSrcData = NULL;
+	BYTE* pDstData = NULL;
+	HGDI_BITMAP bitmap = NULL;
+
+	if (!gdi)
+		return NULL;
+
+	nDstStep = nWidth * FreeRDPGetBytesPerPixel(gdi->dstFormat);
+	pDstData = winpr_aligned_malloc(1ull * nHeight * nDstStep, 16);
+
+	if (!pDstData)
+		return NULL;
+
+	pSrcData = data;
+	nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat);
+
+	if (!freerdp_image_copy_no_overlap(pDstData, gdi->dstFormat, nDstStep, 0, 0, nWidth, nHeight,
+	                                   pSrcData, SrcFormat, nSrcStep, 0, 0, &gdi->palette,
+	                                   FREERDP_FLIP_NONE))
+	{
+		winpr_aligned_free(pDstData);
+		return NULL;
+	}
+
+	bitmap = gdi_CreateBitmap(nWidth, nHeight, gdi->dstFormat, pDstData);
+	return bitmap;
+}
+
+static BOOL gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+{
+	gdiBitmap* gdi_bitmap = NULL;
+	rdpGdi* gdi = context->gdi;
+	gdi_bitmap = (gdiBitmap*)bitmap;
+	gdi_bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);
+
+	if (!gdi_bitmap->hdc)
+		return FALSE;
+
+	if (!bitmap->data)
+		gdi_bitmap->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, bitmap->width, bitmap->height);
+	else
+	{
+		UINT32 format = bitmap->format;
+		gdi_bitmap->bitmap =
+		    gdi_create_bitmap(gdi, bitmap->width, bitmap->height, format, bitmap->data);
+	}
+
+	if (!gdi_bitmap->bitmap)
+	{
+		gdi_DeleteDC(gdi_bitmap->hdc);
+		gdi_bitmap->hdc = NULL;
+		return FALSE;
+	}
+
+	gdi_bitmap->hdc->format = gdi_bitmap->bitmap->format;
+	gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT)gdi_bitmap->bitmap);
+	gdi_bitmap->org_bitmap = NULL;
+	return TRUE;
+}
+
+static void gdi_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
+{
+	gdiBitmap* gdi_bitmap = (gdiBitmap*)bitmap;
+
+	if (gdi_bitmap)
+	{
+		if (gdi_bitmap->hdc)
+			gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT)gdi_bitmap->org_bitmap);
+
+		gdi_DeleteObject((HGDIOBJECT)gdi_bitmap->bitmap);
+		gdi_DeleteDC(gdi_bitmap->hdc);
+		winpr_aligned_free(bitmap->data);
+	}
+
+	free(bitmap);
+}
+
+static BOOL gdi_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
+{
+	gdiBitmap* gdi_bitmap = (gdiBitmap*)bitmap;
+	UINT32 width = bitmap->right - bitmap->left + 1;
+	UINT32 height = bitmap->bottom - bitmap->top + 1;
+	return gdi_BitBlt(context->gdi->primary->hdc, WINPR_ASSERTING_INT_CAST(int, bitmap->left),
+	                  WINPR_ASSERTING_INT_CAST(int, bitmap->top),
+	                  WINPR_ASSERTING_INT_CAST(int, width), WINPR_ASSERTING_INT_CAST(int, height),
+	                  gdi_bitmap->hdc, 0, 0, GDI_SRCCOPY, &context->gdi->palette);
+}
+
+static BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap, const BYTE* pSrcData,
+                                  UINT32 DstWidth, UINT32 DstHeight, UINT32 bpp, UINT32 length,
+                                  BOOL compressed, UINT32 codecId)
+{
+	UINT32 SrcSize = length;
+	rdpGdi* gdi = context->gdi;
+	UINT32 size = DstWidth * DstHeight;
+	bitmap->compressed = FALSE;
+	bitmap->format = gdi->dstFormat;
+
+	if ((FreeRDPGetBytesPerPixel(bitmap->format) == 0) || (DstWidth == 0) || (DstHeight == 0) ||
+	    (DstWidth > UINT32_MAX / DstHeight) ||
+	    (size > (UINT32_MAX / FreeRDPGetBytesPerPixel(bitmap->format))))
+	{
+		WLog_ERR(TAG, "invalid input data");
+		return FALSE;
+	}
+
+	size *= FreeRDPGetBytesPerPixel(bitmap->format);
+	bitmap->length = size;
+	bitmap->data = (BYTE*)winpr_aligned_malloc(bitmap->length, 16);
+
+	if (!bitmap->data)
+		return FALSE;
+
+	if (compressed)
+	{
+		if ((codecId == RDP_CODEC_ID_REMOTEFX) || (codecId == RDP_CODEC_ID_IMAGE_REMOTEFX))
+		{
+			REGION16 invalidRegion = { 0 };
+			region16_init(&invalidRegion);
+
+			const BOOL rc =
+			    rfx_process_message(context->codecs->rfx, pSrcData, SrcSize, bitmap->left,
+			                        bitmap->top, bitmap->data, bitmap->format, gdi->stride,
+			                        WINPR_ASSERTING_INT_CAST(UINT32, gdi->height), &invalidRegion);
+			region16_uninit(&invalidRegion);
+
+			if (!rc)
+			{
+				WLog_ERR(TAG, "rfx_process_message failed");
+				return FALSE;
+			}
+		}
+		else if (codecId == RDP_CODEC_ID_NSCODEC)
+		{
+			const int status = nsc_process_message(
+			    context->codecs->nsc, 32, DstWidth, DstHeight, pSrcData, SrcSize, bitmap->data,
+			    bitmap->format, 0, 0, 0, DstWidth, DstHeight, FREERDP_FLIP_VERTICAL);
+
+			if (status < 1)
+			{
+				WLog_ERR(TAG, "nsc_process_message failed");
+				return FALSE;
+			}
+
+			return freerdp_image_copy_no_overlap(bitmap->data, bitmap->format, 0, 0, 0, DstWidth,
+			                                     DstHeight, pSrcData, PIXEL_FORMAT_XRGB32, 0, 0, 0,
+			                                     &gdi->palette, FREERDP_FLIP_VERTICAL);
+		}
+		else if (bpp < 32)
+		{
+			if (!interleaved_decompress(context->codecs->interleaved, pSrcData, SrcSize, DstWidth,
+			                            DstHeight, bpp, bitmap->data, bitmap->format, 0, 0, 0,
+			                            DstWidth, DstHeight, &gdi->palette))
+			{
+				WLog_ERR(TAG, "interleaved_decompress failed");
+				return FALSE;
+			}
+		}
+		else
+		{
+			const BOOL fidelity =
+			    freerdp_settings_get_bool(context->settings, FreeRDP_DrawAllowDynamicColorFidelity);
+			freerdp_planar_switch_bgr(context->codecs->planar, fidelity);
+			if (!planar_decompress(context->codecs->planar, pSrcData, SrcSize, DstWidth, DstHeight,
+			                       bitmap->data, bitmap->format, 0, 0, 0, DstWidth, DstHeight,
+			                       TRUE))
+			{
+				WLog_ERR(TAG, "planar_decompress failed");
+				return FALSE;
+			}
+		}
+	}
+	else
+	{
+		const UINT32 SrcFormat = gdi_get_pixel_format(bpp);
+		const size_t sbpp = FreeRDPGetBytesPerPixel(SrcFormat);
+		const size_t dbpp = FreeRDPGetBytesPerPixel(bitmap->format);
+
+		if ((sbpp == 0) || (dbpp == 0))
+			return FALSE;
+		else
+		{
+			const size_t dstSize = SrcSize * dbpp / sbpp;
+
+			if (dstSize < bitmap->length)
+			{
+				WLog_ERR(TAG, "dstSize %" PRIuz " < bitmap->length %" PRIu32, dstSize,
+				         bitmap->length);
+				return FALSE;
+			}
+		}
+
+		if (!freerdp_image_copy_no_overlap(bitmap->data, bitmap->format, 0, 0, 0, DstWidth,
+		                                   DstHeight, pSrcData, SrcFormat, 0, 0, 0, &gdi->palette,
+		                                   FREERDP_FLIP_VERTICAL))
+		{
+			WLog_ERR(TAG, "freerdp_image_copy failed");
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL gdi_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
+{
+	rdpGdi* gdi = NULL;
+
+	if (!context)
+		return FALSE;
+
+	gdi = context->gdi;
+
+	if (!gdi)
+		return FALSE;
+
+	if (primary)
+		gdi->drawing = gdi->primary;
+	else
+		gdi->drawing = (gdiBitmap*)bitmap;
+
+	return TRUE;
+}
+
+/* Glyph Class */
+static BOOL gdi_Glyph_New(rdpContext* context, rdpGlyph* glyph)
+{
+	BYTE* data = NULL;
+	gdiGlyph* gdi_glyph = NULL;
+
+	if (!context || !glyph)
+		return FALSE;
+
+	gdi_glyph = (gdiGlyph*)glyph;
+	gdi_glyph->hdc = gdi_GetDC();
+
+	if (!gdi_glyph->hdc)
+		return FALSE;
+
+	gdi_glyph->hdc->format = PIXEL_FORMAT_MONO;
+	data = freerdp_glyph_convert(glyph->cx, glyph->cy, glyph->aj);
+
+	if (!data)
+	{
+		gdi_DeleteDC(gdi_glyph->hdc);
+		return FALSE;
+	}
+
+	gdi_glyph->bitmap = gdi_CreateBitmap(glyph->cx, glyph->cy, PIXEL_FORMAT_MONO, data);
+
+	if (!gdi_glyph->bitmap)
+	{
+		gdi_DeleteDC(gdi_glyph->hdc);
+		winpr_aligned_free(data);
+		return FALSE;
+	}
+
+	gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT)gdi_glyph->bitmap);
+	gdi_glyph->org_bitmap = NULL;
+	return TRUE;
+}
+
+static void gdi_Glyph_Free(rdpContext* context, rdpGlyph* glyph)
+{
+	gdiGlyph* gdi_glyph = NULL;
+	gdi_glyph = (gdiGlyph*)glyph;
+
+	if (gdi_glyph)
+	{
+		gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT)gdi_glyph->org_bitmap);
+		gdi_DeleteObject((HGDIOBJECT)gdi_glyph->bitmap);
+		gdi_DeleteDC(gdi_glyph->hdc);
+		free(glyph->aj);
+		free(glyph);
+	}
+}
+
+static BOOL gdi_Glyph_Draw(rdpContext* context, const rdpGlyph* glyph, INT32 x, INT32 y, INT32 w,
+                           INT32 h, INT32 sx, INT32 sy, BOOL fOpRedundant)
+{
+	const gdiGlyph* gdi_glyph = NULL;
+	rdpGdi* gdi = NULL;
+	HGDI_BRUSH brush = NULL;
+	BOOL rc = FALSE;
+
+	if (!context || !glyph)
+		return FALSE;
+
+	gdi = context->gdi;
+	gdi_glyph = (const gdiGlyph*)glyph;
+
+	if (!fOpRedundant)
+	{
+		GDI_RECT rect = { 0 };
+
+		if (x > 0)
+			rect.left = x;
+
+		if (y > 0)
+			rect.top = y;
+
+		if (x + w > 0)
+			rect.right = x + w - 1;
+
+		if (y + h > 0)
+			rect.bottom = y + h - 1;
+
+		if ((rect.left < rect.right) && (rect.top < rect.bottom))
+		{
+			brush = gdi_CreateSolidBrush(gdi->drawing->hdc->bkColor);
+
+			if (!brush)
+				return FALSE;
+
+			gdi_FillRect(gdi->drawing->hdc, &rect, brush);
+			gdi_DeleteObject((HGDIOBJECT)brush);
+		}
+	}
+
+	brush = gdi_CreateSolidBrush(gdi->drawing->hdc->textColor);
+
+	if (!brush)
+		return FALSE;
+
+	gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT)brush);
+	rc = gdi_BitBlt(gdi->drawing->hdc, x, y, w, h, gdi_glyph->hdc, sx, sy, GDI_GLYPH_ORDER,
+	                &context->gdi->palette);
+	gdi_DeleteObject((HGDIOBJECT)brush);
+	return rc;
+}
+
+static BOOL gdi_Glyph_BeginDraw(rdpContext* context, INT32 x, INT32 y, INT32 width, INT32 height,
+                                UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
+{
+	rdpGdi* gdi = NULL;
+
+	if (!context || !context->gdi)
+		return FALSE;
+
+	gdi = context->gdi;
+
+	if (!gdi->drawing || !gdi->drawing->hdc)
+		return FALSE;
+
+	if (!fOpRedundant)
+	{
+		if (!gdi_decode_color(gdi, bgcolor, &bgcolor, NULL))
+			return FALSE;
+
+		if (!gdi_decode_color(gdi, fgcolor, &fgcolor, NULL))
+			return FALSE;
+
+		gdi_SetClipRgn(gdi->drawing->hdc, x, y, width, height);
+		gdi_SetTextColor(gdi->drawing->hdc, bgcolor);
+		gdi_SetBkColor(gdi->drawing->hdc, fgcolor);
+
+		if (1)
+		{
+			GDI_RECT rect = { 0 };
+			HGDI_BRUSH brush = gdi_CreateSolidBrush(fgcolor);
+
+			if (!brush)
+				return FALSE;
+
+			if (x > 0)
+				rect.left = x;
+
+			if (y > 0)
+				rect.top = y;
+
+			rect.right = x + width - 1;
+			rect.bottom = y + height - 1;
+
+			if ((x + width > rect.left) && (y + height > rect.top))
+				gdi_FillRect(gdi->drawing->hdc, &rect, brush);
+
+			gdi_DeleteObject((HGDIOBJECT)brush);
+		}
+
+		return gdi_SetNullClipRgn(gdi->drawing->hdc);
+	}
+
+	return TRUE;
+}
+
+static BOOL gdi_Glyph_EndDraw(rdpContext* context, INT32 x, INT32 y, INT32 width, INT32 height,
+                              UINT32 bgcolor, UINT32 fgcolor)
+{
+	rdpGdi* gdi = NULL;
+
+	if (!context || !context->gdi)
+		return FALSE;
+
+	gdi = context->gdi;
+
+	if (!gdi->drawing || !gdi->drawing->hdc)
+		return FALSE;
+
+	gdi_SetNullClipRgn(gdi->drawing->hdc);
+	return TRUE;
+}
+
+/* Graphics Module */
+BOOL gdi_register_graphics(rdpGraphics* graphics)
+{
+	rdpBitmap bitmap = { 0 };
+	rdpGlyph glyph = { 0 };
+	bitmap.size = sizeof(gdiBitmap);
+	bitmap.New = gdi_Bitmap_New;
+	bitmap.Free = gdi_Bitmap_Free;
+	bitmap.Paint = gdi_Bitmap_Paint;
+	bitmap.Decompress = gdi_Bitmap_Decompress;
+	bitmap.SetSurface = gdi_Bitmap_SetSurface;
+	graphics_register_bitmap(graphics, &bitmap);
+	glyph.size = sizeof(gdiGlyph);
+	glyph.New = gdi_Glyph_New;
+	glyph.Free = gdi_Glyph_Free;
+	glyph.Draw = gdi_Glyph_Draw;
+	glyph.BeginDraw = gdi_Glyph_BeginDraw;
+	glyph.EndDraw = gdi_Glyph_EndDraw;
+	graphics_register_glyph(graphics, &glyph);
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/shape.c

@@ -0,0 +1,299 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Shape Functions
+ *
+ * Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/bitmap.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/shape.h>
+
+#include <freerdp/log.h>
+
+#include "clipping.h"
+#include "../gdi/gdi.h"
+
+#define TAG FREERDP_TAG("gdi.shape")
+
+static void Ellipse_Bresenham(HGDI_DC hdc, int x1, int y1, int x2, int y2)
+{
+	INT32 e = 0;
+	INT32 e2 = 0;
+	INT32 dx = 0;
+	INT32 dy = 0;
+	INT32 a = 0;
+	INT32 b = 0;
+	INT32 c = 0;
+	a = (x1 < x2) ? x2 - x1 : x1 - x2;
+	b = (y1 < y2) ? y2 - y1 : y1 - y2;
+	c = b & 1;
+	dx = 4 * (1 - a) * b * b;
+	dy = 4 * (c + 1) * a * a;
+	e = dx + dy + c * a * a;
+
+	if (x1 > x2)
+	{
+		x1 = x2;
+		x2 += a;
+	}
+
+	if (y1 > y2)
+		y1 = y2;
+
+	y1 += (b + 1) / 2;
+	y2 = y1 - c;
+	a *= 8 * a;
+	c = 8 * b * b;
+
+	do
+	{
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x2),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x1),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x1),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y2), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(UINT32, x2),
+		             WINPR_ASSERTING_INT_CAST(UINT32, y2), 0);
+		e2 = 2 * e;
+
+		if (e2 >= dx)
+		{
+			x1++;
+			x2--;
+			e += dx += c;
+		}
+
+		if (e2 <= dy)
+		{
+			y1++;
+			y2--;
+			e += dy += a;
+		}
+	} while (x1 <= x2);
+
+	while (y1 - y2 < b)
+	{
+		y1++;
+		y2--;
+
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(uint32_t, x1 - 1),
+		             WINPR_ASSERTING_INT_CAST(uint32_t, y1), 0);
+		gdi_SetPixel(hdc, WINPR_ASSERTING_INT_CAST(uint32_t, x1 - 1),
+		             WINPR_ASSERTING_INT_CAST(uint32_t, y2), 0);
+	}
+}
+
+/**
+ * Draw an ellipse
+ * msdn{dd162510}
+ *
+ * @param hdc device context
+ * @param nLeftRect x1
+ * @param nTopRect y1
+ * @param nRightRect x2
+ * @param nBottomRect y2
+ *
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
+{
+	Ellipse_Bresenham(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
+	return TRUE;
+}
+
+/**
+ * Fill a rectangle with the given brush.
+ * msdn{dd162719}
+ *
+ * @param hdc device context
+ * @param rect rectangle
+ * @param hbr brush
+ *
+ * @return nonzero if successful, 0 otherwise
+ */
+
+BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr)
+{
+	UINT32 color = 0;
+	UINT32 dstColor = 0;
+	BOOL monochrome = FALSE;
+	INT32 nXDest = 0;
+	INT32 nYDest = 0;
+	INT32 nWidth = 0;
+	INT32 nHeight = 0;
+	const BYTE* srcp = NULL;
+	DWORD formatSize = 0;
+	gdi_RectToCRgn(rect, &nXDest, &nYDest, &nWidth, &nHeight);
+
+	if (!hdc || !hbr)
+		return FALSE;
+
+	if (!gdi_ClipCoords(hdc, &nXDest, &nYDest, &nWidth, &nHeight, NULL, NULL))
+		return TRUE;
+
+	switch (hbr->style)
+	{
+		case GDI_BS_SOLID:
+			color = hbr->color;
+
+			for (INT32 x = 0; x < nWidth; x++)
+			{
+				BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x, nYDest);
+
+				if (dstp)
+					FreeRDPWriteColor(dstp, hdc->format, color);
+			}
+
+			srcp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest);
+			formatSize = FreeRDPGetBytesPerPixel(hdc->format);
+
+			for (INT32 y = 1; y < nHeight; y++)
+			{
+				BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest + y);
+				memcpy(dstp, srcp, 1ull * WINPR_ASSERTING_INT_CAST(size_t, nWidth) * formatSize);
+			}
+
+			break;
+
+		case GDI_BS_HATCHED:
+		case GDI_BS_PATTERN:
+			monochrome = (hbr->pattern->format == PIXEL_FORMAT_MONO);
+			formatSize = FreeRDPGetBytesPerPixel(hbr->pattern->format);
+
+			for (INT32 y = 0; y < nHeight; y++)
+			{
+				for (INT32 x = 0; x < nWidth; x++)
+				{
+					const size_t yOffset =
+					    ((1ULL * WINPR_ASSERTING_INT_CAST(size_t, nYDest) +
+					      WINPR_ASSERTING_INT_CAST(size_t, y)) *
+					     WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->width) %
+					     WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->height)) *
+					    formatSize;
+					const size_t xOffset = ((1ULL * WINPR_ASSERTING_INT_CAST(size_t, nXDest) +
+					                         WINPR_ASSERTING_INT_CAST(size_t, x)) %
+					                        WINPR_ASSERTING_INT_CAST(size_t, hbr->pattern->width)) *
+					                       formatSize;
+					const BYTE* patp = &hbr->pattern->data[yOffset + xOffset];
+
+					if (monochrome)
+					{
+						if (*patp == 0)
+							dstColor = hdc->bkColor;
+						else
+							dstColor = hdc->textColor;
+					}
+					else
+					{
+						dstColor = FreeRDPReadColor(patp, hbr->pattern->format);
+						dstColor =
+						    FreeRDPConvertColor(dstColor, hbr->pattern->format, hdc->format, NULL);
+					}
+
+					BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x, nYDest + y);
+					if (dstp)
+						FreeRDPWriteColor(dstp, hdc->format, dstColor);
+				}
+			}
+
+			break;
+
+		default:
+			break;
+	}
+
+	if (!gdi_InvalidateRegion(hdc, nXDest, nYDest, nWidth, nHeight))
+		return FALSE;
+
+	return TRUE;
+}
+
+/**
+ * Draw a polygon
+ * msdn{dd162814}
+ * @param hdc device context
+ * @param lpPoints array of points
+ * @param nCount number of points
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_Polygon(HGDI_DC hdc, GDI_POINT* lpPoints, int nCount)
+{
+	WLog_ERR(TAG, "Not implemented!");
+	return FALSE;
+}
+
+/**
+ * Draw a series of closed polygons
+ * msdn{dd162818}
+ * @param hdc device context
+ * @param lpPoints array of series of points
+ * @param lpPolyCounts array of number of points in each series
+ * @param nCount count of number of points in lpPolyCounts
+ * @return nonzero if successful, 0 otherwise
+ */
+BOOL gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT* lpPoints, int* lpPolyCounts, int nCount)
+{
+	WLog_ERR(TAG, "Not implemented!");
+	return FALSE;
+}
+
+BOOL gdi_Rectangle(HGDI_DC hdc, INT32 nXDst, INT32 nYDst, INT32 nWidth, INT32 nHeight)
+{
+	UINT32 color = 0;
+
+	if (!gdi_ClipCoords(hdc, &nXDst, &nYDst, &nWidth, &nHeight, NULL, NULL))
+		return TRUE;
+
+	color = hdc->textColor;
+
+	for (INT32 y = 0; y < nHeight; y++)
+	{
+		BYTE* dstLeft = gdi_get_bitmap_pointer(hdc, nXDst, nYDst + y);
+		BYTE* dstRight = gdi_get_bitmap_pointer(hdc, nXDst + nWidth - 1, nYDst + y);
+
+		if (dstLeft)
+			FreeRDPWriteColor(dstLeft, hdc->format, color);
+
+		if (dstRight)
+			FreeRDPWriteColor(dstRight, hdc->format, color);
+	}
+
+	for (INT32 x = 0; x < nWidth; x++)
+	{
+		BYTE* dstTop = gdi_get_bitmap_pointer(hdc, nXDst + x, nYDst);
+		BYTE* dstBottom = gdi_get_bitmap_pointer(hdc, nXDst + x, nYDst + nHeight - 1);
+
+		if (dstTop)
+			FreeRDPWriteColor(dstTop, hdc->format, color);
+
+		if (dstBottom)
+			FreeRDPWriteColor(dstBottom, hdc->format, color);
+	}
+
+	return FALSE;
+}