/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2017 Armin Novak <armin.novak@thincast.com>

 * Copyright 2017 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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <winpr/crt.h>

#include <winpr/file.h>

#include <winpr/path.h>

#include <winpr/synch.h>

#include <winpr/thread.h>

#include <winpr/sysinfo.h>

#include <winpr/interlocked.h>

#include <freerdp/log.h>

#include "shadow.h"

#define TAG CLIENT_TAG("shadow")

struct _SHADOW_GFX_STATUS

{

	BOOL gfxOpened;

	BOOL gfxSurfaceCreated;

};

typedef struct _SHADOW_GFX_STATUS SHADOW_GFX_STATUS;

static INLINE BOOL shadow_client_rdpgfx_new_surface(rdpShadowClient* client)

{

	UINT error = CHANNEL_RC_OK;

	RDPGFX_CREATE_SURFACE_PDU createSurface;

	RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU surfaceToOutput;

	RdpgfxServerContext* context = client->rdpgfx;

	rdpSettings* settings = ((rdpContext*)client)->settings;

	createSurface.width = settings->DesktopWidth;

	createSurface.height = settings->DesktopHeight;

	createSurface.pixelFormat = GFX_PIXEL_FORMAT_XRGB_8888;

	createSurface.surfaceId = 0;

	surfaceToOutput.outputOriginX = 0;

	surfaceToOutput.outputOriginY = 0;

	surfaceToOutput.surfaceId = 0;

	surfaceToOutput.reserved = 0;

	IFCALLRET(context->CreateSurface, error, context, &createSurface);

	if (error)

	{

		WLog_ERR(TAG, "CreateSurface failed with error %" PRIu32 "", error);

		return FALSE;

	}

	IFCALLRET(context->MapSurfaceToOutput, error, context, &surfaceToOutput);

	if (error)

	{

		WLog_ERR(TAG, "MapSurfaceToOutput failed with error %" PRIu32 "", error);

		return FALSE;

	}

	return TRUE;

}

static INLINE BOOL shadow_client_rdpgfx_release_surface(rdpShadowClient* client)

{

	UINT error = CHANNEL_RC_OK;

	RDPGFX_DELETE_SURFACE_PDU pdu;

	RdpgfxServerContext* context = client->rdpgfx;

	pdu.surfaceId = 0;

	IFCALLRET(context->DeleteSurface, error, context, &pdu);

	if (error)

	{

		WLog_ERR(TAG, "DeleteSurface failed with error %" PRIu32 "", error);

		return FALSE;

	}

	return TRUE;

}

static INLINE BOOL shadow_client_rdpgfx_reset_graphic(rdpShadowClient* client)

{

	UINT error = CHANNEL_RC_OK;

	RDPGFX_RESET_GRAPHICS_PDU pdu;

	RdpgfxServerContext* context = client->rdpgfx;

	rdpSettings* settings = ((rdpContext*)client)->settings;

	pdu.width = settings->DesktopWidth;

	pdu.height = settings->DesktopHeight;

	pdu.monitorCount = client->subsystem->numMonitors;

	pdu.monitorDefArray = client->subsystem->monitors;

	IFCALLRET(context->ResetGraphics, error, context, &pdu);

	if (error)

	{

		WLog_ERR(TAG, "ResetGraphics failed with error %" PRIu32 "", error);

		return FALSE;

	}

	return TRUE;

}

static INLINE void shadow_client_free_queued_message(void* obj)

{

	wMessage* message = (wMessage*)obj;

	if (message->Free)

	{

		message->Free(message);

		message->Free = NULL;

	}

}

static BOOL shadow_client_context_new(freerdp_peer* peer, rdpShadowClient* client)

{

	const char bind_address[] = "bind-address,";

	rdpSettings* settings;

	rdpShadowServer* server;

	const wObject cb = { NULL, NULL, NULL, shadow_client_free_queued_message, NULL };

	server = (rdpShadowServer*)peer->ContextExtra;

	client->server = server;

	client->subsystem = server->subsystem;

	settings = peer->settings;

	settings->ColorDepth = 32;

	settings->NSCodec = TRUE;

	settings->RemoteFxCodec = TRUE;

	settings->BitmapCacheV3Enabled = TRUE;

	settings->FrameMarkerCommandEnabled = TRUE;

	settings->SurfaceFrameMarkerEnabled = TRUE;

	settings->SupportGraphicsPipeline = TRUE;

	settings->GfxH264 = FALSE;

	settings->DrawAllowSkipAlpha = TRUE;

	settings->DrawAllowColorSubsampling = TRUE;

	settings->DrawAllowDynamicColorFidelity = TRUE;

	settings->CompressionLevel = PACKET_COMPR_TYPE_RDP6;

	if (!(settings->CertificateFile = _strdup(server->CertificateFile)))

		goto fail_cert_file;

	if (!(settings->PrivateKeyFile = _strdup(server->PrivateKeyFile)))

		goto fail_privkey_file;

	if (!(settings->RdpKeyFile = _strdup(settings->PrivateKeyFile)))

		goto fail_rdpkey_file;

	if (server->ipcSocket && (strncmp(bind_address, server->ipcSocket,

	                                  strnlen(bind_address, sizeof(bind_address))) != 0))

	{

		settings->LyncRdpMode = TRUE;

		settings->CompressionEnabled = FALSE;

	}

	client->inLobby = TRUE;

	client->mayView = server->mayView;

	client->mayInteract = server->mayInteract;

	if (!InitializeCriticalSectionAndSpinCount(&(client->lock), 4000))

		goto fail_client_lock;

	region16_init(&(client->invalidRegion));

	client->vcm = WTSOpenServerA((LPSTR)peer->context);

	if (!client->vcm || client->vcm == INVALID_HANDLE_VALUE)

		goto fail_open_server;

	if (!(client->MsgQueue = MessageQueue_New(&cb)))

		goto fail_message_queue;

	if (!(client->encoder = shadow_encoder_new(client)))

		goto fail_encoder_new;

	if (ArrayList_Add(server->clients, (void*)client) >= 0)

		return TRUE;

	shadow_encoder_free(client->encoder);

	client->encoder = NULL;

fail_encoder_new:

	MessageQueue_Free(client->MsgQueue);

	client->MsgQueue = NULL;

fail_message_queue:

	WTSCloseServer((HANDLE)client->vcm);

	client->vcm = NULL;

fail_open_server:

	DeleteCriticalSection(&(client->lock));

fail_client_lock:

	free(settings->RdpKeyFile);

	settings->RdpKeyFile = NULL;

fail_rdpkey_file:

	free(settings->PrivateKeyFile);

	settings->PrivateKeyFile = NULL;

fail_privkey_file:

	free(settings->CertificateFile);

	settings->CertificateFile = NULL;

fail_cert_file:

	return FALSE;

}

static void shadow_client_context_free(freerdp_peer* peer, rdpShadowClient* client)

{

	rdpShadowServer* server = client->server;

	WINPR_UNUSED(peer);

	ArrayList_Remove(server->clients, (void*)client);

	if (client->encoder)

	{

		shadow_encoder_free(client->encoder);

		client->encoder = NULL;

	}

	/* Clear queued messages and free resource */

	MessageQueue_Clear(client->MsgQueue);

	MessageQueue_Free(client->MsgQueue);

	WTSCloseServer((HANDLE)client->vcm);

	client->vcm = NULL;

	region16_uninit(&(client->invalidRegion));

	DeleteCriticalSection(&(client->lock));

}

static INLINE void shadow_client_mark_invalid(rdpShadowClient* client, int numRects,

                                              const RECTANGLE_16* rects)

{

	int index;

	RECTANGLE_16 screenRegion;

	rdpSettings* settings = ((rdpContext*)client)->settings;

	EnterCriticalSection(&(client->lock));

	/* Mark client invalid region. No rectangle means full screen */

	if (numRects > 0)

	{

		for (index = 0; index < numRects; index++)

		{

			region16_union_rect(&(client->invalidRegion), &(client->invalidRegion), &rects[index]);

		}

	}

	else

	{

		screenRegion.left = 0;

		screenRegion.top = 0;

		screenRegion.right = settings->DesktopWidth;

		screenRegion.bottom = settings->DesktopHeight;

		region16_union_rect(&(client->invalidRegion), &(client->invalidRegion), &screenRegion);

	}

	LeaveCriticalSection(&(client->lock));

}

/**

 * Function description

 * Recalculate client desktop size and update to rdpSettings

 *

 * @return TRUE if width/height changed.

 */

static INLINE BOOL shadow_client_recalc_desktop_size(rdpShadowClient* client)

{

	int width, height;

	rdpShadowServer* server = client->server;

	rdpSettings* settings = client->context.settings;

	RECTANGLE_16 viewport = { 0, 0, server->surface->width, server->surface->height };

	if (server->shareSubRect)

	{

		rectangles_intersection(&viewport, &(server->subRect), &viewport);

	}

	width = viewport.right - viewport.left;

	height = viewport.bottom - viewport.top;

	if (settings->DesktopWidth != (UINT32)width || settings->DesktopHeight != (UINT32)height)

	{

		settings->DesktopWidth = width;

		settings->DesktopHeight = height;

		return TRUE;

	}

	return FALSE;

}

static BOOL shadow_client_capabilities(freerdp_peer* peer)

{

	rdpShadowSubsystem* subsystem;

	rdpShadowClient* client;

	BOOL ret = TRUE;

	client = (rdpShadowClient*)peer->context;

	subsystem = client->server->subsystem;

	IFCALLRET(subsystem->ClientCapabilities, ret, subsystem, client);

	if (!ret)

		WLog_WARN(TAG, "subsystem->ClientCapabilities failed");

	/* Recalculate desktop size regardless whether previous call fail

	 * or not. Make sure we send correct width/height to client */

	(void)shadow_client_recalc_desktop_size(client);

	return ret;

}

static BOOL shadow_client_post_connect(freerdp_peer* peer)

{

	int authStatus;

	rdpSettings* settings;

	rdpShadowClient* client;

	rdpShadowServer* server;

	rdpShadowSubsystem* subsystem;

	client = (rdpShadowClient*)peer->context;

	settings = peer->settings;

	server = client->server;

	subsystem = server->subsystem;

	if (settings->ColorDepth == 24)

		settings->ColorDepth = 16; /* disable 24bpp */

	if (settings->MultifragMaxRequestSize < 0x3F0000)

		settings->NSCodec = FALSE; /* NSCodec compressor does not support fragmentation yet */

	WLog_INFO(TAG, "Client from %s is activated (%" PRIu32 "x%" PRIu32 "@%" PRIu32 ")",

	          peer->hostname, settings->DesktopWidth, settings->DesktopHeight,

	          settings->ColorDepth);

	/* Resize client if necessary */

	if (shadow_client_recalc_desktop_size(client))

	{

		peer->update->DesktopResize(peer->update->context);

		WLog_INFO(TAG, "Client from %s is resized (%" PRIu32 "x%" PRIu32 "@%" PRIu32 ")",

		          peer->hostname, settings->DesktopWidth, settings->DesktopHeight,

		          settings->ColorDepth);

	}

	if (shadow_client_channels_post_connect(client) != CHANNEL_RC_OK)

		return FALSE;

	shadow_client_mark_invalid(client, 0, NULL);

	authStatus = -1;

	if (settings->Username && settings->Password)

		settings->AutoLogonEnabled = TRUE;

	if (server->authentication && !settings->NlaSecurity)

	{

		if (subsystem->Authenticate)

		{

			authStatus = subsystem->Authenticate(subsystem, client, settings->Username,

			                                     settings->Domain, settings->Password);

		}

		if (authStatus < 0)

		{

			WLog_ERR(TAG, "client authentication failure: %d", authStatus);

			return FALSE;

		}

	}

	if (subsystem->ClientConnect)

	{

		return subsystem->ClientConnect(subsystem, client);

	}

	return TRUE;

}

/* Convert rects in sub rect coordinate to client/surface coordinate */

static INLINE void shadow_client_convert_rects(rdpShadowClient* client, RECTANGLE_16* dst,

                                               const RECTANGLE_16* src, UINT32 numRects)

{

	if (client->server->shareSubRect)

	{

		UINT32 i = 0;

		UINT16 offsetX = client->server->subRect.left;

		UINT16 offsetY = client->server->subRect.top;

		for (i = 0; i < numRects; i++)

		{

			dst[i].left = src[i].left + offsetX;

			dst[i].right = src[i].right + offsetX;

			dst[i].top = src[i].top + offsetY;

			dst[i].bottom = src[i].bottom + offsetY;

		}

	}

	else

	{

		if (src != dst)

		{

			CopyMemory(dst, src, numRects * sizeof(RECTANGLE_16));

		}

	}

}

static BOOL shadow_client_refresh_request(rdpShadowClient* client)

{

	wMessage message = { 0 };

	wMessagePipe* MsgPipe = client->subsystem->MsgPipe;

	message.id = SHADOW_MSG_IN_REFRESH_REQUEST_ID;

	message.wParam = NULL;

	message.lParam = NULL;

	message.context = (void*)client;

	message.Free = NULL;

	return MessageQueue_Dispatch(MsgPipe->In, &message);

}

static BOOL shadow_client_refresh_rect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)

{

	rdpShadowClient* client = (rdpShadowClient*)context;

	RECTANGLE_16* rects;

	/* It is invalid if we have area count but no actual area */

	if (count && !areas)

		return FALSE;

	if (count)

	{

		rects = (RECTANGLE_16*)calloc(count, sizeof(RECTANGLE_16));

		if (!rects)

		{

			return FALSE;

		}

		shadow_client_convert_rects(client, rects, areas, count);

		shadow_client_mark_invalid(client, count, rects);

		free(rects);

	}

	else

	{

		shadow_client_mark_invalid(client, 0, NULL);

	}

	return shadow_client_refresh_request(client);

}

static BOOL shadow_client_suppress_output(rdpContext* context, BYTE allow, const RECTANGLE_16* area)

{

	rdpShadowClient* client = (rdpShadowClient*)context;

	RECTANGLE_16 region;

	client->suppressOutput = allow ? FALSE : TRUE;

	if (allow)

	{

		if (area)

		{

			shadow_client_convert_rects(client, &region, area, 1);

			shadow_client_mark_invalid(client, 1, &region);

		}

		else

		{

			shadow_client_mark_invalid(client, 0, NULL);

		}

	}

	return shadow_client_refresh_request(client);

}

static BOOL shadow_client_activate(freerdp_peer* peer)

{

	rdpSettings* settings = peer->settings;

	rdpShadowClient* client = (rdpShadowClient*)peer->context;

	if (settings->ClientDir && (strcmp(settings->ClientDir, "librdp") == 0))

	{

		/* Hack for Mac/iOS/Android Microsoft RDP clients */

		settings->RemoteFxCodec = FALSE;

		settings->NSCodec = FALSE;

		settings->NSCodecAllowSubsampling = FALSE;

		settings->SurfaceFrameMarkerEnabled = FALSE;

	}

	client->activated = TRUE;

	client->inLobby = client->mayView ? FALSE : TRUE;

	if (shadow_encoder_reset(client->encoder) < 0)

	{

		WLog_ERR(TAG, "Failed to reset encoder");

		return FALSE;

	}

	/* Update full screen in next update */

	return shadow_client_refresh_rect(&client->context, 0, NULL);

}

static BOOL shadow_client_logon(freerdp_peer* peer, SEC_WINNT_AUTH_IDENTITY* identity,

                                BOOL automatic)

{

	char* user = NULL;

	char* domain = NULL;

	char* password = NULL;

	rdpSettings* settings = peer->settings;

	if (identity->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)

	{

		if (identity->User)

			ConvertFromUnicode(CP_UTF8, 0, identity->User, identity->UserLength, &user, 0, NULL,

			                   NULL);

		if (identity->Domain)

			ConvertFromUnicode(CP_UTF8, 0, identity->Domain, identity->DomainLength, &domain, 0,

			                   NULL, NULL);

		if (identity->Password)

			ConvertFromUnicode(CP_UTF8, 0, identity->Password, identity->PasswordLength, &user, 0,

			                   NULL, NULL);

	}

	else

	{

		if (identity->User)

			user = _strdup((char*)identity->User);

		if (identity->Domain)

			domain = _strdup((char*)identity->Domain);

		if (identity->Password)

			password = _strdup((char*)identity->Password);

	}

	if ((identity->User && !user) || (identity->Domain && !domain) ||

	    (identity->Password && !password))

	{

		free(user);

		free(domain);

		free(password);

		return FALSE;

	}

	if (user)

	{

		free(settings->Username);

		settings->Username = user;

		user = NULL;

	}

	if (domain)

	{

		free(settings->Domain);

		settings->Domain = domain;

		domain = NULL;

	}

	if (password)

	{

		free(settings->Password);

		settings->Password = password;

		password = NULL;

	}

	free(user);

	free(domain);

	free(password);

	return TRUE;

}

static INLINE void shadow_client_common_frame_acknowledge(rdpShadowClient* client, UINT32 frameId)

{

	/*

	 * Record the last client acknowledged frame id to

	 * calculate how much frames are in progress.

	 * Some rdp clients (win7 mstsc) skips frame ACK if it is

	 * inactive, we should not expect ACK for each frame.

	 * So it is OK to calculate inflight frame count according to

	 * a latest acknowledged frame id.

	 */

	client->encoder->lastAckframeId = frameId;

}

static BOOL shadow_client_surface_frame_acknowledge(rdpContext* context, UINT32 frameId)

{

	rdpShadowClient* client = (rdpShadowClient*)context;

	shadow_client_common_frame_acknowledge(client, frameId);

	/*

	 * Reset queueDepth for legacy none RDPGFX acknowledge

	 */

	client->encoder->queueDepth = QUEUE_DEPTH_UNAVAILABLE;

	return TRUE;

}

static UINT

shadow_client_rdpgfx_frame_acknowledge(RdpgfxServerContext* context,

                                       const RDPGFX_FRAME_ACKNOWLEDGE_PDU* frameAcknowledge)

{

	rdpShadowClient* client = (rdpShadowClient*)context->custom;

	shadow_client_common_frame_acknowledge(client, frameAcknowledge->frameId);

	client->encoder->queueDepth = frameAcknowledge->queueDepth;

	return CHANNEL_RC_OK;

}

static BOOL shadow_are_caps_filtered(const rdpSettings* settings, UINT32 caps)

{

	const UINT32 filter = settings->GfxCapsFilter;

	const UINT32 capList[] = {

		RDPGFX_CAPVERSION_8,   RDPGFX_CAPVERSION_81,  RDPGFX_CAPVERSION_10,

		RDPGFX_CAPVERSION_101, RDPGFX_CAPVERSION_102, RDPGFX_CAPVERSION_103,

		RDPGFX_CAPVERSION_104, RDPGFX_CAPVERSION_105, RDPGFX_CAPVERSION_106

	};

	UINT32 x;

	for (x = 0; x < ARRAYSIZE(capList); x++)

	{

		if (caps == capList[x])

			return (filter & (1 << x)) != 0;

	}

	return TRUE;

}

static BOOL shadow_client_caps_test_version(RdpgfxServerContext* context, BOOL h264,

                                            const RDPGFX_CAPSET* capsSets, UINT32 capsSetCount,

                                            UINT32 capsVersion, UINT* rc)

{

	UINT32 flags = 0;

	UINT32 index;

	rdpSettings* settings;

	settings = context->rdpcontext->settings;

	if (shadow_are_caps_filtered(settings, capsVersion))

		return FALSE;

	for (index = 0; index < capsSetCount; index++)

	{

		const RDPGFX_CAPSET* currentCaps = &capsSets[index];

		if (currentCaps->version == capsVersion)

		{

			RDPGFX_CAPSET caps = *currentCaps;

			RDPGFX_CAPS_CONFIRM_PDU pdu;

			pdu.capsSet = ∩︀

			if (settings)

			{

				flags = pdu.capsSet->flags;

				settings->GfxSmallCache = (flags & RDPGFX_CAPS_FLAG_SMALL_CACHE);

				if (h264)

					settings->GfxAVC444v2 = settings->GfxAVC444 = settings->GfxH264 =

					    !(flags & RDPGFX_CAPS_FLAG_AVC_DISABLED);

				else

				{

					settings->GfxAVC444v2 = settings->GfxAVC444 = settings->GfxH264 = FALSE;

					pdu.capsSet->flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;

				}

			}

			*rc = context->CapsConfirm(context, &pdu);

			return TRUE;

		}

	}

	return FALSE;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT shadow_client_rdpgfx_caps_advertise(RdpgfxServerContext* context,

                                                const RDPGFX_CAPS_ADVERTISE_PDU* capsAdvertise)

{

	UINT16 index;

	UINT rc = ERROR_INTERNAL_ERROR;

	BOOL h264 = FALSE;

	rdpSettings* settings = context->rdpcontext->settings;

	UINT32 flags = 0;

	rdpShadowClient* client = (rdpShadowClient*)context->custom;

#ifdef WITH_GFX_H264

	if (shadow_encoder_prepare(client->encoder, FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444) >= 0)

		h264 = TRUE;

#endif

	/* Request full screen update for new gfx channel */

	if (!shadow_client_refresh_rect(&client->context, 0, NULL))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_106, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_105, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_104, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_103, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_102, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_101, &rc))

		return rc;

	if (shadow_client_caps_test_version(context, h264, capsAdvertise->capsSets,

	                                    capsAdvertise->capsSetCount, RDPGFX_CAPVERSION_10, &rc))

		return rc;

	if (!shadow_are_caps_filtered(settings, RDPGFX_CAPVERSION_81))

	{

		for (index = 0; index < capsAdvertise->capsSetCount; index++)

		{

			const RDPGFX_CAPSET* currentCaps = &capsAdvertise->capsSets[index];

			if (currentCaps->version == RDPGFX_CAPVERSION_81)

			{

				RDPGFX_CAPSET caps = *currentCaps;

				RDPGFX_CAPS_CONFIRM_PDU pdu;

				pdu.capsSet = ∩︀

				if (settings)

				{

					flags = pdu.capsSet->flags;

					settings->GfxAVC444v2 = settings->GfxAVC444 = FALSE;

					settings->GfxThinClient = (flags & RDPGFX_CAPS_FLAG_THINCLIENT);

					settings->GfxSmallCache = (flags & RDPGFX_CAPS_FLAG_SMALL_CACHE);

#ifndef WITH_GFX_H264

					settings->GfxH264 = FALSE;

					pdu.capsSet->flags &= ~RDPGFX_CAPS_FLAG_AVC420_ENABLED;

#else

					if (h264)

						settings->GfxH264 = (flags & RDPGFX_CAPS_FLAG_AVC420_ENABLED);

					else

						settings->GfxH264 = FALSE;

#endif

				}

				return context->CapsConfirm(context, &pdu);

			}

		}

	}

	if (!shadow_are_caps_filtered(settings, RDPGFX_CAPVERSION_8))

	{

		for (index = 0; index < capsAdvertise->capsSetCount; index++)

		{

			const RDPGFX_CAPSET* currentCaps = &capsAdvertise->capsSets[index];

			if (currentCaps->version == RDPGFX_CAPVERSION_8)

			{

				RDPGFX_CAPSET caps = *currentCaps;

				RDPGFX_CAPS_CONFIRM_PDU pdu;

				pdu.capsSet = ∩︀

				if (settings)

				{

					flags = pdu.capsSet->flags;

					settings->GfxThinClient = (flags & RDPGFX_CAPS_FLAG_THINCLIENT);

					settings->GfxSmallCache = (flags & RDPGFX_CAPS_FLAG_SMALL_CACHE);

				}

				return context->CapsConfirm(context, &pdu);

			}

		}

	}

	return CHANNEL_RC_UNSUPPORTED_VERSION;

}

static INLINE UINT32 rdpgfx_estimate_h264_avc420(RDPGFX_AVC420_BITMAP_STREAM* havc420)

{

	/* H264 metadata + H264 stream. See rdpgfx_write_h264_avc420 */

	return sizeof(UINT32) /* numRegionRects */

	       + 10           /* regionRects + quantQualityVals */

	             * havc420->meta.numRegionRects +

	       havc420->length;

}

/**

 * Function description

 *

 * @return TRUE on success

 */

static BOOL shadow_client_send_surface_gfx(rdpShadowClient* client, const BYTE* pSrcData,

                                           int nSrcStep, int nXSrc, int nYSrc, int nWidth,

                                           int nHeight)

{

	UINT error = CHANNEL_RC_OK;

	rdpContext* context = (rdpContext*)client;

	rdpSettings* settings;

	rdpShadowEncoder* encoder;

	RDPGFX_SURFACE_COMMAND cmd;

	RDPGFX_START_FRAME_PDU cmdstart;

	RDPGFX_END_FRAME_PDU cmdend;

	SYSTEMTIME sTime;

	if (!context || !pSrcData)

		return FALSE;

	settings = context->settings;

	encoder = client->encoder;

	if (!settings || !encoder)

		return FALSE;

	cmdstart.frameId = shadow_encoder_create_frame_id(encoder);

	GetSystemTime(&sTime);

	cmdstart.timestamp =

	    sTime.wHour << 22 | sTime.wMinute << 16 | sTime.wSecond << 10 | sTime.wMilliseconds;

	cmdend.frameId = cmdstart.frameId;

	cmd.surfaceId = 0;

	cmd.codecId = 0;

	cmd.contextId = 0;

	cmd.format = PIXEL_FORMAT_BGRX32;

	cmd.left = nXSrc;

	cmd.top = nYSrc;

	cmd.right = cmd.left + nWidth;

	cmd.bottom = cmd.top + nHeight;

	cmd.width = nWidth;

	cmd.height = nHeight;

	cmd.length = 0;

	cmd.data = NULL;

	cmd.extra = NULL;

	if (settings->GfxAVC444 || settings->GfxAVC444v2)

	{

		RDPGFX_AVC444_BITMAP_STREAM avc444;

		RECTANGLE_16 regionRect;

		RDPGFX_H264_QUANT_QUALITY quantQualityVal;

		BYTE version = settings->GfxAVC444v2 ? 2 : 1;

		if (shadow_encoder_prepare(encoder, FREERDP_CODEC_AVC444) < 0)

		{

			WLog_ERR(TAG, "Failed to prepare encoder FREERDP_CODEC_AVC444");

			return FALSE;

		}

		if (avc444_compress(encoder->h264, pSrcData, cmd.format, nSrcStep, nWidth, nHeight, version,

		                    &avc444.LC, &avc444.bitstream[0].data, &avc444.bitstream[0].length,

		                    &avc444.bitstream[1].data, &avc444.bitstream[1].length) < 0)

		{

			WLog_ERR(TAG, "avc420_compress failed for avc444");

			return FALSE;

		}

		regionRect.left = cmd.left;

		regionRect.top = cmd.top;

		regionRect.right = cmd.right;

		regionRect.bottom = cmd.bottom;

		quantQualityVal.qp = encoder->h264->QP;

		quantQualityVal.r = 0;

		quantQualityVal.p = 0;

		quantQualityVal.qualityVal = 100 - quantQualityVal.qp;

		avc444.bitstream[0].meta.numRegionRects = 1;

		avc444.bitstream[0].meta.regionRects = &regionRect;

		avc444.bitstream[0].meta.quantQualityVals = &quantQualityVal;

		avc444.bitstream[1].meta.numRegionRects = 1;

		avc444.bitstream[1].meta.regionRects = &regionRect;

		avc444.bitstream[1].meta.quantQualityVals = &quantQualityVal;

		avc444.cbAvc420EncodedBitstream1 = rdpgfx_estimate_h264_avc420(&avc444.bitstream[0]);

		cmd.codecId = settings->GfxAVC444v2 ? RDPGFX_CODECID_AVC444v2 : RDPGFX_CODECID_AVC444;

		cmd.extra = (void*)&avc444;

		IFCALLRET(client->rdpgfx->SurfaceFrameCommand, error, client->rdpgfx, &cmd, &cmdstart,

		          &cmdend);

		if (error)

		{

			WLog_ERR(TAG, "SurfaceFrameCommand failed with error %" PRIu32 "", error);

			return FALSE;

		}

	}

	else if (settings->GfxH264)

	{

		RDPGFX_AVC420_BITMAP_STREAM avc420;

		RECTANGLE_16 regionRect;

		RDPGFX_H264_QUANT_QUALITY quantQualityVal;