/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Graphics Pipeline Extension

 *

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

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>

 * Copyright 2016 Thincast Technologies GmbH

 * Copyright 2016 Armin Novak <armin.novak@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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <assert.h>

#include <winpr/crt.h>

#include <winpr/wlog.h>

#include <winpr/print.h>

#include <winpr/synch.h>

#include <winpr/thread.h>

#include <winpr/stream.h>

#include <winpr/sysinfo.h>

#include <winpr/cmdline.h>

#include <winpr/collections.h>

#include <freerdp/addin.h>

#include <freerdp/channels/log.h>

#include "rdpgfx_common.h"

#include "rdpgfx_codec.h"

#include "rdpgfx_main.h"

#define TAG CHANNELS_TAG("rdpgfx.client")

static void free_surfaces(RdpgfxClientContext* context, wHashTable* SurfaceTable)

{

	UINT error = 0;

	ULONG_PTR* pKeys = NULL;

	int count;

	int index;

	count = HashTable_GetKeys(SurfaceTable, &pKeys);

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

	{

		RDPGFX_DELETE_SURFACE_PDU pdu;

		pdu.surfaceId = ((UINT16)pKeys[index]) - 1;

		if (context)

		{

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

			if (error)

			{

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

			}

		}

	}

	free(pKeys);

}

static void evict_cache_slots(RdpgfxClientContext* context, UINT16 MaxCacheSlots, void** CacheSlots)

{

	UINT16 index;

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

	{

		if (CacheSlots[index])

		{

			RDPGFX_EVICT_CACHE_ENTRY_PDU pdu;

			pdu.cacheSlot = (UINT16)index + 1;

			if (context && context->EvictCacheEntry)

			{

				context->EvictCacheEntry(context, &pdu);

			}

			CacheSlots[index] = NULL;

		}

	}

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_caps_advertise_pdu(RdpgfxClientContext* context,

                                           const RDPGFX_CAPS_ADVERTISE_PDU* pdu)

{

	UINT error = CHANNEL_RC_OK;

	UINT16 index;

	RDPGFX_HEADER header;

	RDPGFX_CAPSET* capsSet;

	RDPGFX_PLUGIN* gfx;

	RDPGFX_CHANNEL_CALLBACK* callback;

	wStream* s;

	gfx = (RDPGFX_PLUGIN*)context->handle;

	if (!gfx || !gfx->listener_callback)

		return ERROR_BAD_ARGUMENTS;

	callback = gfx->listener_callback->channel_callback;

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_CAPSADVERTISE;

	header.pduLength = RDPGFX_HEADER_SIZE + 2;

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

	{

		capsSet = &(pdu->capsSets[index]);

		header.pduLength += RDPGFX_CAPSET_BASE_SIZE + capsSet->length;

	}

	DEBUG_RDPGFX(gfx->log, "SendCapsAdvertisePdu %" PRIu16 "", pdu->capsSetCount);

	s = Stream_New(NULL, header.pduLength);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	if ((error = rdpgfx_write_header(s, &header)))

		goto fail;

	/* RDPGFX_CAPS_ADVERTISE_PDU */

	Stream_Write_UINT16(s, pdu->capsSetCount); /* capsSetCount (2 bytes) */

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

	{

		capsSet = &(pdu->capsSets[index]);

		Stream_Write_UINT32(s, capsSet->version); /* version (4 bytes) */

		Stream_Write_UINT32(s, capsSet->length);  /* capsDataLength (4 bytes) */

		Stream_Write_UINT32(s, capsSet->flags);   /* capsData (4 bytes) */

		Stream_Zero(s, capsSet->length - 4);

	}

	Stream_SealLength(s);

	error = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),

	                                 NULL);

fail:

	Stream_Free(s, TRUE);

	return error;

}

static BOOL rdpgfx_is_capability_filtered(RDPGFX_PLUGIN* gfx, UINT32 caps)

{

	const UINT32 filter = gfx->capsFilter;

	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;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_supported_caps(RDPGFX_CHANNEL_CALLBACK* callback)

{

	RDPGFX_PLUGIN* gfx;

	RdpgfxClientContext* context;

	RDPGFX_CAPSET* capsSet;

	RDPGFX_CAPSET capsSets[RDPGFX_NUMBER_CAPSETS] = { 0 };

	RDPGFX_CAPS_ADVERTISE_PDU pdu;

	if (!callback)

		return ERROR_BAD_ARGUMENTS;

	gfx = (RDPGFX_PLUGIN*)callback->plugin;

	if (!gfx)

		return ERROR_BAD_CONFIGURATION;

	context = (RdpgfxClientContext*)gfx->iface.pInterface;

	if (!context)

		return ERROR_BAD_CONFIGURATION;

	pdu.capsSetCount = 0;

	pdu.capsSets = (RDPGFX_CAPSET*)capsSets;

	if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_8))

	{

		capsSet = &capsSets[pdu.capsSetCount++];

		capsSet->version = RDPGFX_CAPVERSION_8;

		capsSet->length = 4;

		capsSet->flags = 0;

		if (gfx->ThinClient)

			capsSet->flags |= RDPGFX_CAPS_FLAG_THINCLIENT;

		/* in CAPVERSION_8 the spec says that we should not have both

		 * thinclient and smallcache (and thinclient implies a small cache)

		 */

		if (gfx->SmallCache && !gfx->ThinClient)

			capsSet->flags |= RDPGFX_CAPS_FLAG_SMALL_CACHE;

	}

	if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_81))

	{

		capsSet = &capsSets[pdu.capsSetCount++];

		capsSet->version = RDPGFX_CAPVERSION_81;

		capsSet->length = 4;

		capsSet->flags = 0;

		if (gfx->ThinClient)

			capsSet->flags |= RDPGFX_CAPS_FLAG_THINCLIENT;

		if (gfx->SmallCache)

			capsSet->flags |= RDPGFX_CAPS_FLAG_SMALL_CACHE;

#ifdef WITH_GFX_H264

		if (gfx->H264)

			capsSet->flags |= RDPGFX_CAPS_FLAG_AVC420_ENABLED;

#endif

	}

	if (!gfx->H264 || gfx->AVC444)

	{

		UINT32 caps10Flags = 0;

		if (gfx->SmallCache)

			caps10Flags |= RDPGFX_CAPS_FLAG_SMALL_CACHE;

#ifdef WITH_GFX_H264

		if (!gfx->AVC444)

			caps10Flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;

#else

		caps10Flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;

#endif

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_10))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_10;

			capsSet->length = 4;

			capsSet->flags = caps10Flags;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_101))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_101;

			capsSet->length = 0x10;

			capsSet->flags = 0;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_102))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_102;

			capsSet->length = 0x4;

			capsSet->flags = caps10Flags;

		}

		if (gfx->ThinClient)

		{

			if ((caps10Flags & RDPGFX_CAPS_FLAG_AVC_DISABLED) == 0)

				caps10Flags |= RDPGFX_CAPS_FLAG_AVC_THINCLIENT;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_103))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_103;

			capsSet->length = 0x4;

			capsSet->flags = caps10Flags & ~RDPGFX_CAPS_FLAG_SMALL_CACHE;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_104))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_104;

			capsSet->length = 0x4;

			capsSet->flags = caps10Flags;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_105))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_105;

			capsSet->length = 0x4;

			capsSet->flags = caps10Flags;

		}

		if (!rdpgfx_is_capability_filtered(gfx, RDPGFX_CAPVERSION_106))

		{

			capsSet = &capsSets[pdu.capsSetCount++];

			capsSet->version = RDPGFX_CAPVERSION_106;

			capsSet->length = 0x4;

			capsSet->flags = caps10Flags;

		}

	}

	return IFCALLRESULT(ERROR_BAD_CONFIGURATION, context->CapsAdvertise, context, &pdu);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_caps_confirm_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_CAPSET capsSet;

	RDPGFX_CAPS_CONFIRM_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	pdu.capsSet = &capsSet;

	if (Stream_GetRemainingLength(s) < 12)

	{

		WLog_ERR(TAG, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, capsSet.version); /* version (4 bytes) */

	Stream_Read_UINT32(s, capsSet.length);  /* capsDataLength (4 bytes) */

	Stream_Read_UINT32(s, capsSet.flags);   /* capsData (4 bytes) */

	gfx->ConnectionCaps = capsSet;

	DEBUG_RDPGFX(gfx->log, "RecvCapsConfirmPdu: version: 0x%08" PRIX32 " flags: 0x%08" PRIX32 "",

	             capsSet.version, capsSet.flags);

	if (!context)

		return ERROR_BAD_CONFIGURATION;

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

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_frame_acknowledge_pdu(RdpgfxClientContext* context,

                                              const RDPGFX_FRAME_ACKNOWLEDGE_PDU* pdu)

{

	UINT error;

	wStream* s;

	RDPGFX_HEADER header;

	RDPGFX_PLUGIN* gfx;

	RDPGFX_CHANNEL_CALLBACK* callback;

	if (!context || !pdu)

		return ERROR_BAD_ARGUMENTS;

	gfx = (RDPGFX_PLUGIN*)context->handle;

	if (!gfx || !gfx->listener_callback)

		return ERROR_BAD_CONFIGURATION;

	callback = gfx->listener_callback->channel_callback;

	if (!callback)

		return ERROR_BAD_CONFIGURATION;

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_FRAMEACKNOWLEDGE;

	header.pduLength = RDPGFX_HEADER_SIZE + 12;

	DEBUG_RDPGFX(gfx->log, "SendFrameAcknowledgePdu: %" PRIu32 "", pdu->frameId);

	s = Stream_New(NULL, header.pduLength);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	if ((error = rdpgfx_write_header(s, &header)))

		goto fail;

	/* RDPGFX_FRAME_ACKNOWLEDGE_PDU */

	Stream_Write_UINT32(s, pdu->queueDepth);         /* queueDepth (4 bytes) */

	Stream_Write_UINT32(s, pdu->frameId);            /* frameId (4 bytes) */

	Stream_Write_UINT32(s, pdu->totalFramesDecoded); /* totalFramesDecoded (4 bytes) */

	error = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),

	                                 NULL);

	if (error == CHANNEL_RC_OK) /* frame successfully acked */

		gfx->UnacknowledgedFrames--;

fail:

	Stream_Free(s, TRUE);

	return error;

}

static UINT rdpgfx_send_qoe_frame_acknowledge_pdu(RdpgfxClientContext* context,

                                                  const RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU* pdu)

{

	UINT error;

	wStream* s;

	RDPGFX_HEADER header;

	RDPGFX_CHANNEL_CALLBACK* callback;

	RDPGFX_PLUGIN* gfx;

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_QOEFRAMEACKNOWLEDGE;

	header.pduLength = RDPGFX_HEADER_SIZE + 12;

	if (!context || !pdu)

		return ERROR_BAD_ARGUMENTS;

	gfx = (RDPGFX_PLUGIN*)context->handle;

	if (!gfx || !gfx->listener_callback)

		return ERROR_BAD_CONFIGURATION;

	callback = gfx->listener_callback->channel_callback;

	if (!callback)

		return ERROR_BAD_CONFIGURATION;

	DEBUG_RDPGFX(gfx->log, "SendQoeFrameAcknowledgePdu: %" PRIu32 "", pdu->frameId);

	s = Stream_New(NULL, header.pduLength);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	if ((error = rdpgfx_write_header(s, &header)))

		goto fail;

	/* RDPGFX_FRAME_ACKNOWLEDGE_PDU */

	Stream_Write_UINT32(s, pdu->frameId);

	Stream_Write_UINT32(s, pdu->timestamp);

	Stream_Write_UINT16(s, pdu->timeDiffSE);

	Stream_Write_UINT16(s, pdu->timeDiffEDR);

	error = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),

	                                 NULL);

fail:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_cache_import_offer_pdu(RdpgfxClientContext* context,

                                               const RDPGFX_CACHE_IMPORT_OFFER_PDU* pdu)

{

	UINT16 index;

	UINT error = CHANNEL_RC_OK;

	wStream* s;

	RDPGFX_PLUGIN* gfx;

	RDPGFX_CHANNEL_CALLBACK* callback;

	RDPGFX_HEADER header;

	RDPGFX_CACHE_ENTRY_METADATA* cacheEntries;

	if (!context || !pdu)

		return ERROR_BAD_ARGUMENTS;

	gfx = (RDPGFX_PLUGIN*)context->handle;

	if (!gfx || !gfx->listener_callback)

		return ERROR_BAD_CONFIGURATION;

	callback = gfx->listener_callback->channel_callback;

	if (!callback)

		return ERROR_BAD_CONFIGURATION;

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_CACHEIMPORTOFFER;

	header.pduLength = RDPGFX_HEADER_SIZE + 2 + pdu->cacheEntriesCount * 12;

	DEBUG_RDPGFX(gfx->log, "SendCacheImportOfferPdu: cacheEntriesCount: %" PRIu16 "",

	             pdu->cacheEntriesCount);

	s = Stream_New(NULL, header.pduLength);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	if ((error = rdpgfx_write_header(s, &header)))

		goto fail;

	if (pdu->cacheEntriesCount <= 0)

	{

		WLog_ERR(TAG, "Invalid cacheEntriesCount: %" PRIu16 "", pdu->cacheEntriesCount);

		error = ERROR_INVALID_DATA;

		goto fail;

	}

	/* cacheEntriesCount (2 bytes) */

	Stream_Write_UINT16(s, pdu->cacheEntriesCount);

	for (index = 0; index < pdu->cacheEntriesCount; index++)

	{

		cacheEntries = &(pdu->cacheEntries[index]);

		Stream_Write_UINT64(s, cacheEntries->cacheKey);     /* cacheKey (8 bytes) */

		Stream_Write_UINT32(s, cacheEntries->bitmapLength); /* bitmapLength (4 bytes) */

	}

	error = callback->channel->Write(callback->channel, (UINT32)Stream_Length(s), Stream_Buffer(s),

	                                 NULL);

fail:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_reset_graphics_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	int pad;

	UINT32 index;

	MONITOR_DEF* monitor;

	RDPGFX_RESET_GRAPHICS_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	GraphicsResetEventArgs graphicsReset;

	if (Stream_GetRemainingLength(s) < 12)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.width);        /* width (4 bytes) */

	Stream_Read_UINT32(s, pdu.height);       /* height (4 bytes) */

	Stream_Read_UINT32(s, pdu.monitorCount); /* monitorCount (4 bytes) */

	if (Stream_GetRemainingLength(s) < (pdu.monitorCount * 20))

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	pdu.monitorDefArray = (MONITOR_DEF*)calloc(pdu.monitorCount, sizeof(MONITOR_DEF));

	if (!pdu.monitorDefArray)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "calloc failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	for (index = 0; index < pdu.monitorCount; index++)

	{

		monitor = &(pdu.monitorDefArray[index]);

		Stream_Read_UINT32(s, monitor->left);   /* left (4 bytes) */

		Stream_Read_UINT32(s, monitor->top);    /* top (4 bytes) */

		Stream_Read_UINT32(s, monitor->right);  /* right (4 bytes) */

		Stream_Read_UINT32(s, monitor->bottom); /* bottom (4 bytes) */

		Stream_Read_UINT32(s, monitor->flags);  /* flags (4 bytes) */

	}

	pad = 340 - (RDPGFX_HEADER_SIZE + 12 + (pdu.monitorCount * 20));

	if (Stream_GetRemainingLength(s) < (size_t)pad)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "Stream_GetRemainingLength failed!");

		free(pdu.monitorDefArray);

		return CHANNEL_RC_NO_MEMORY;

	}

	Stream_Seek(s, pad); /* pad (total size is 340 bytes) */

	DEBUG_RDPGFX(gfx->log,

	             "RecvResetGraphicsPdu: width: %" PRIu32 " height: %" PRIu32 " count: %" PRIu32 "",

	             pdu.width, pdu.height, pdu.monitorCount);

	for (index = 0; index < pdu.monitorCount; index++)

	{

		monitor = &(pdu.monitorDefArray[index]);

		DEBUG_RDPGFX(gfx->log,

		             "RecvResetGraphicsPdu: monitor left:%" PRIi32 " top:%" PRIi32 " right:%" PRIi32

		             " bottom:%" PRIi32 " flags:0x%" PRIx32 "",

		             monitor->left, monitor->top, monitor->right, monitor->bottom, monitor->flags);

	}

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->ResetGraphics failed with error %" PRIu32 "",

			           error);

	}

	/* some listeners may be interested (namely the display channel) */

	EventArgsInit(&graphicsReset, "libfreerdp");

	graphicsReset.width = pdu.width;

	graphicsReset.height = pdu.height;

	PubSub_OnGraphicsReset(gfx->rdpcontext->pubSub, gfx->rdpcontext, &graphicsReset);

	free(pdu.monitorDefArray);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_evict_cache_entry_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_EVICT_CACHE_ENTRY_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < 2)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.cacheSlot); /* cacheSlot (2 bytes) */

	WLog_Print(gfx->log, WLOG_DEBUG, "RecvEvictCacheEntryPdu: cacheSlot: %" PRIu16 "",

	           pdu.cacheSlot);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR,

			           "context->EvictCacheEntry failed with error %" PRIu32 "", error);

	}

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_cache_import_reply_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	UINT16 index;

	RDPGFX_CACHE_IMPORT_REPLY_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < 2)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.importedEntriesCount); /* cacheSlot (2 bytes) */

	if (Stream_GetRemainingLength(s) < (size_t)(pdu.importedEntriesCount * 2))

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	pdu.cacheSlots = (UINT16*)calloc(pdu.importedEntriesCount, sizeof(UINT16));

	if (!pdu.cacheSlots)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "calloc failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	for (index = 0; index < pdu.importedEntriesCount; index++)

	{

		Stream_Read_UINT16(s, pdu.cacheSlots[index]); /* cacheSlot (2 bytes) */

	}

	DEBUG_RDPGFX(gfx->log, "RecvCacheImportReplyPdu: importedEntriesCount: %" PRIu16 "",

	             pdu.importedEntriesCount);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR,

			           "context->CacheImportReply failed with error %" PRIu32 "", error);

	}

	free(pdu.cacheSlots);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_create_surface_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_CREATE_SURFACE_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < 7)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.surfaceId);  /* surfaceId (2 bytes) */

	Stream_Read_UINT16(s, pdu.width);      /* width (2 bytes) */

	Stream_Read_UINT16(s, pdu.height);     /* height (2 bytes) */

	Stream_Read_UINT8(s, pdu.pixelFormat); /* RDPGFX_PIXELFORMAT (1 byte) */

	DEBUG_RDPGFX(gfx->log,

	             "RecvCreateSurfacePdu: surfaceId: %" PRIu16 " width: %" PRIu16 " height: %" PRIu16

	             " pixelFormat: 0x%02" PRIX8 "",

	             pdu.surfaceId, pdu.width, pdu.height, pdu.pixelFormat);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->CreateSurface failed with error %" PRIu32 "",

			           error);

	}

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_delete_surface_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_DELETE_SURFACE_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < 2)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.surfaceId); /* surfaceId (2 bytes) */

	DEBUG_RDPGFX(gfx->log, "RecvDeleteSurfacePdu: surfaceId: %" PRIu16 "", pdu.surfaceId);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->DeleteSurface failed with error %" PRIu32 "",

			           error);

	}

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_start_frame_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_START_FRAME_PDU pdu;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < RDPGFX_START_FRAME_PDU_SIZE)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.timestamp); /* timestamp (4 bytes) */

	Stream_Read_UINT32(s, pdu.frameId);   /* frameId (4 bytes) */

	DEBUG_RDPGFX(gfx->log, "RecvStartFramePdu: frameId: %" PRIu32 " timestamp: 0x%08" PRIX32 "",

	             pdu.frameId, pdu.timestamp);

	gfx->StartDecodingTime = GetTickCount64();

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->StartFrame failed with error %" PRIu32 "",

			           error);

	}

	gfx->UnacknowledgedFrames++;

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_end_frame_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)

{

	RDPGFX_END_FRAME_PDU pdu;

	RDPGFX_FRAME_ACKNOWLEDGE_PDU ack;

	RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*)callback->plugin;

	RdpgfxClientContext* context = (RdpgfxClientContext*)gfx->iface.pInterface;

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < RDPGFX_END_FRAME_PDU_SIZE)

	{

		WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.frameId); /* frameId (4 bytes) */

	DEBUG_RDPGFX(gfx->log, "RecvEndFramePdu: frameId: %" PRIu32 "", pdu.frameId);

	if (context)

	{

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

		if (error)

		{

			WLog_Print(gfx->log, WLOG_ERROR, "context->EndFrame failed with error %" PRIu32 "",

			           error);

			return error;

		}

	}

	gfx->TotalDecodedFrames++;

	if (!gfx->sendFrameAcks)

		return error;

	ack.frameId = pdu.frameId;

	ack.totalFramesDecoded = gfx->TotalDecodedFrames;

	if (gfx->suspendFrameAcks)

	{

		ack.queueDepth = SUSPEND_FRAME_ACKNOWLEDGEMENT;

		if (gfx->TotalDecodedFrames == 1)

			if ((error = rdpgfx_send_frame_acknowledge_pdu(context, &ack)))

				WLog_Print(gfx->log, WLOG_ERROR,

				           "rdpgfx_send_frame_acknowledge_pdu failed with error %" PRIu32 "",

				           error);