/**

 * 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")

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_caps_advertise_pdu(RDPGFX_CHANNEL_CALLBACK* callback)

{

	UINT error;

	wStream* s;

	UINT16 index;

	RDPGFX_PLUGIN* gfx;

	RDPGFX_HEADER header;

	RDPGFX_CAPSET* capsSet;

	RDPGFX_CAPSET capsSets[RDPGFX_NUMBER_CAPSETS];

	RDPGFX_CAPS_ADVERTISE_PDU pdu;

	gfx = (RDPGFX_PLUGIN*) callback->plugin;

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_CAPSADVERTISE;

	pdu.capsSetCount = 0;

	pdu.capsSets = (RDPGFX_CAPSET*) capsSets;

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

	capsSet->version = RDPGFX_CAPVERSION_8;

	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;

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

	capsSet->version = RDPGFX_CAPVERSION_81;

	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)

	{

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

		capsSet->version = RDPGFX_CAPVERSION_10;

		capsSet->flags = 0;

		if (gfx->SmallCache)

			capsSet->flags |= RDPGFX_CAPS_FLAG_SMALL_CACHE;

#ifdef WITH_GFX_H264

		if (!gfx->AVC444)

			capsSet->flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;

#else

		capsSet->flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;

#endif

		capsSets[pdu.capsSetCount] = *capsSet;

		capsSets[pdu.capsSetCount++].version = RDPGFX_CAPVERSION_102;

		capsSets[pdu.capsSetCount] = *capsSet;

		capsSets[pdu.capsSetCount++].version = RDPGFX_CAPVERSION_103;

	}

	header.pduLength = RDPGFX_HEADER_SIZE + 2 + (pdu.capsSetCount * RDPGFX_CAPSET_SIZE);

	WLog_Print(gfx->log, WLOG_DEBUG, "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, 4); /* capsDataLength (4 bytes) */

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

	}

	Stream_SealLength(s);

	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_caps_confirm_pdu(RDPGFX_CHANNEL_CALLBACK* callback,

        wStream* s)

{

	RDPGFX_CAPSET capsSet;

	UINT32 capsDataLength;

	RDPGFX_CAPS_CONFIRM_PDU pdu;

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

	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, capsDataLength); /* capsDataLength (4 bytes) */

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

	gfx->ConnectionCaps = capsSet;

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

	         capsSet.version, capsSet.flags);

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_frame_acknowledge_pdu(RDPGFX_CHANNEL_CALLBACK* callback,

        RDPGFX_FRAME_ACKNOWLEDGE_PDU* pdu)

{

	UINT error;

	wStream* s;

	RDPGFX_HEADER header;

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

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_FRAMEACKNOWLEDGE;

	header.pduLength = RDPGFX_HEADER_SIZE + 12;

	WLog_Print(gfx->log, WLOG_DEBUG, "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);

fail:

	Stream_Free(s, TRUE);

	return error;

}

static UINT rdpgfx_send_qoe_frame_acknowledge_pdu(RDPGFX_CHANNEL_CALLBACK* callback,

                                                  const RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU* pdu)

{

	UINT error;

	wStream* s;

	RDPGFX_HEADER header;

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

	header.flags = 0;

	header.cmdId = RDPGFX_CMDID_QOEFRAMEACKNOWLEDGE;

	header.pduLength = RDPGFX_HEADER_SIZE + 12;

	WLog_Print(gfx->log, WLOG_DEBUG, "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_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) */

	WLog_Print(gfx->log, WLOG_DEBUG, "RecvResetGraphicsPdu: width: %"PRIu32" height: %"PRIu32" count: %"PRIu32"",

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

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

	{

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

		WLog_Print(gfx->log, WLOG_DEBUG,

		         "RecvResetGraphicsPdu: monitor left:%"PRIi32" top:%"PRIi32" right:%"PRIi32" left:%"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, "xfreerdp");

	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) */

	}

	WLog_Print(gfx->log, WLOG_DEBUG, "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) */

	WLog_Print(gfx->log, WLOG_DEBUG,

	         "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) */

	WLog_Print(gfx->log, WLOG_DEBUG, "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) */

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

	         pdu.frameId, pdu.timestamp);

	gfx->StartDecodingTime = GetTickCountPrecise();

	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) */

	WLog_Print(gfx->log, WLOG_DEBUG, "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->UnacknowledgedFrames--;

	gfx->TotalDecodedFrames++;

	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(callback, &ack)))

				WLog_Print(gfx->log, WLOG_ERROR, "rdpgfx_send_frame_acknowledge_pdu failed with error %"PRIu32"", error);

	}

	else

	{

		ack.queueDepth = QUEUE_DEPTH_UNAVAILABLE;

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

			WLog_Print(gfx->log, WLOG_DEBUG, "rdpgfx_send_frame_acknowledge_pdu failed with error %"PRIu32"", error);

	}

	switch(gfx->ConnectionCaps.version)

	{

	case RDPGFX_CAPVERSION_10:

	case RDPGFX_CAPVERSION_102:

	case RDPGFX_CAPVERSION_103:

		if (gfx->SendQoeAck)

		{

			RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU qoe;

			UINT32 diff = (GetTickCountPrecise() - gfx->StartDecodingTime);

			if (diff > 65000)

				diff = 0;

			qoe.frameId = pdu.frameId;

			qoe.timestamp = gfx->StartDecodingTime;

			qoe.timeDiffSE = diff;

			qoe.timeDiffEDR = 1;

			if ((error = rdpgfx_send_qoe_frame_acknowledge_pdu(callback, &qoe)))

				WLog_Print(gfx->log, WLOG_DEBUG, "rdpgfx_send_frame_acknowledge_pdu failed with error %"PRIu32"", error);

		}

		break;

	default:

		break;

	}

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_wire_to_surface_1_pdu(RDPGFX_CHANNEL_CALLBACK* callback,

        wStream* s)

{

	RDPGFX_SURFACE_COMMAND cmd;

	RDPGFX_WIRE_TO_SURFACE_PDU_1 pdu;

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

	UINT error;

	if (Stream_GetRemainingLength(s) < RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE)

	{

		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.codecId); /* codecId (2 bytes) */

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

	if ((error = rdpgfx_read_rect16(s, &(pdu.destRect)))) /* destRect (8 bytes) */

	{

		WLog_Print(gfx->log, WLOG_ERROR, "rdpgfx_read_rect16 failed with error %"PRIu32"", error);

		return error;

	}

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

	if (pdu.bitmapDataLength > Stream_GetRemainingLength(s))

	{

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

		return ERROR_INVALID_DATA;

	}

	pdu.bitmapData = Stream_Pointer(s);

	Stream_Seek(s, pdu.bitmapDataLength);

	WLog_Print(gfx->log, WLOG_DEBUG,

	         "RecvWireToSurface1Pdu: surfaceId: %"PRIu16" codecId: %s (0x%04"PRIX16") pixelFormat: 0x%02"PRIX8" "

	         "destRect: left: %"PRIu16" top: %"PRIu16" right: %"PRIu16" bottom: %"PRIu16" bitmapDataLength: %"PRIu32"",

	         pdu.surfaceId, rdpgfx_get_codec_id_string(pdu.codecId),

	         pdu.codecId, pdu.pixelFormat,

	         pdu.destRect.left, pdu.destRect.top,

	         pdu.destRect.right, pdu.destRect.bottom,

	         pdu.bitmapDataLength);

	cmd.surfaceId = pdu.surfaceId;

	cmd.codecId = pdu.codecId;

	cmd.contextId = 0;

	switch (pdu.pixelFormat)

	{

		case GFX_PIXEL_FORMAT_XRGB_8888:

			cmd.format = PIXEL_FORMAT_BGRX32;

			break;

		case GFX_PIXEL_FORMAT_ARGB_8888:

			cmd.format = PIXEL_FORMAT_BGRA32;

			break;

		default:

			return ERROR_INVALID_DATA;

	}

	cmd.left = pdu.destRect.left;

	cmd.top = pdu.destRect.top;

	cmd.right = pdu.destRect.right;

	cmd.bottom = pdu.destRect.bottom;

	cmd.width = cmd.right - cmd.left;

	cmd.height = cmd.bottom - cmd.top;

	cmd.length = pdu.bitmapDataLength;

	cmd.data = pdu.bitmapData;

	cmd.extra = NULL;

	if ((error = rdpgfx_decode(gfx, &cmd)))

		WLog_Print(gfx->log, WLOG_ERROR, "rdpgfx_decode failed with error %"PRIu32"!", error);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_wire_to_surface_2_pdu(RDPGFX_CHANNEL_CALLBACK* callback,

        wStream* s)

{

	RDPGFX_SURFACE_COMMAND cmd;

	RDPGFX_WIRE_TO_SURFACE_PDU_2 pdu;

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

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

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < RDPGFX_WIRE_TO_SURFACE_PDU_2_SIZE)

	{

		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.codecId); /* codecId (2 bytes) */

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

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

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

	pdu.bitmapData = Stream_Pointer(s);

	Stream_Seek(s, pdu.bitmapDataLength);

	WLog_Print(gfx->log, WLOG_DEBUG, "RecvWireToSurface2Pdu: surfaceId: %"PRIu16" codecId: %s (0x%04"PRIX16") "

	         "codecContextId: %"PRIu32" pixelFormat: 0x%02"PRIX8" bitmapDataLength: %"PRIu32"",

	         pdu.surfaceId, rdpgfx_get_codec_id_string(pdu.codecId), pdu.codecId,

	         pdu.codecContextId, pdu.pixelFormat, pdu.bitmapDataLength);

	cmd.surfaceId = pdu.surfaceId;

	cmd.codecId = pdu.codecId;

	cmd.contextId = pdu.codecContextId;

	cmd.format = pdu.pixelFormat;

	cmd.left = 0;

	cmd.top = 0;

	cmd.right = 0;

	cmd.bottom = 0;

	cmd.width = 0;

	cmd.height = 0;

	cmd.length = pdu.bitmapDataLength;

	cmd.data = pdu.bitmapData;

	cmd.extra = NULL;

	if (context)

	{

		IFCALLRET(context->SurfaceCommand, error, context, &cmd);

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->SurfaceCommand failed with error %"PRIu32"", error);

	}

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_delete_encoding_context_pdu(RDPGFX_CHANNEL_CALLBACK*

        callback, wStream* s)

{

	RDPGFX_DELETE_ENCODING_CONTEXT_PDU pdu;

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

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

	UINT error = CHANNEL_RC_OK;

	if (Stream_GetRemainingLength(s) < 6)

	{

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

		return ERROR_INVALID_DATA;

	}

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

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

	WLog_Print(gfx->log, WLOG_DEBUG, "RecvDeleteEncodingContextPdu: surfaceId: %"PRIu16" codecContextId: %"PRIu32"",

	         pdu.surfaceId, pdu.codecContextId);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->DeleteEncodingContext failed with error %"PRIu32"", error);

	}

	return error;

}

/**

 * Function description

 *

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

 */

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

{

	UINT16 index;

	RECTANGLE_16* fillRect;

	RDPGFX_SOLID_FILL_PDU pdu;

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

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

	UINT error;

	if (Stream_GetRemainingLength(s) < 8)

	{

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

		return ERROR_INVALID_DATA;

	}

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

	if ((error = rdpgfx_read_color32(s, &(pdu.fillPixel)))) /* fillPixel (4 bytes) */

	{

		WLog_Print(gfx->log, WLOG_ERROR, "rdpgfx_read_color32 failed with error %"PRIu32"!", error);

		return error;

	}

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

	if (Stream_GetRemainingLength(s) < (size_t)(pdu.fillRectCount * 8))

	{

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

		return ERROR_INVALID_DATA;

	}

	pdu.fillRects = (RECTANGLE_16*) calloc(pdu.fillRectCount, sizeof(RECTANGLE_16));

	if (!pdu.fillRects)

	{

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

		return CHANNEL_RC_NO_MEMORY;

	}

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

	{

		fillRect = &(pdu.fillRects[index]);

		if ((error = rdpgfx_read_rect16(s, fillRect)))

		{

			WLog_Print(gfx->log, WLOG_ERROR, "rdpgfx_read_rect16 failed with error %"PRIu32"!", error);

			free(pdu.fillRects);

			return error;

		}

	}

	WLog_Print(gfx->log, WLOG_DEBUG, "RecvSolidFillPdu: surfaceId: %"PRIu16" fillRectCount: %"PRIu16"",

	         pdu.surfaceId, pdu.fillRectCount);

	if (context)

	{

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

		if (error)

			WLog_Print(gfx->log, WLOG_ERROR, "context->SolidFill failed with error %"PRIu32"", error);

	}

	free(pdu.fillRects);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_recv_surface_to_surface_pdu(RDPGFX_CHANNEL_CALLBACK*

        callback, wStream* s)

{

	UINT16 index;

	RDPGFX_POINT16* destPt;