/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Graphics Pipeline Extension

 *

 * Copyright 2016 Jiang Zihao <zihao.jiang@yahoo.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 <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <winpr/crt.h>

#include <winpr/synch.h>

#include <winpr/thread.h>

#include <winpr/stream.h>

#include <freerdp/channels/wtsvc.h>

#include <freerdp/channels/log.h>

#include "rdpgfx_common.h"

#include "rdpgfx_main.h"

#define TAG CHANNELS_TAG("rdpgfx.server")

#define RDPGFX_RESET_GRAPHICS_PDU_SIZE 340

/**

 * Function description

 * Calculate packet size from data length.

 * It would be data length + header.

 *

 * @param dataLen estimated data length without header

 *

 * @return new stream

 */

static INLINE UINT32 rdpgfx_pdu_length(UINT32 dataLen)

{

	return RDPGFX_HEADER_SIZE + dataLen;

}

static INLINE UINT rdpgfx_server_packet_init_header(wStream* s, UINT16 cmdId, UINT32 pduLength)

{

	RDPGFX_HEADER header;

	header.flags = 0;

	header.cmdId = cmdId;

	header.pduLength = pduLength;

	/* Write header. Note that actual length might be changed

	 * after the entire packet has been constructed. */

	return rdpgfx_write_header(s, &header);

}

/**

 * Function description

 * Complete the rdpgfx packet header.

 *

 * @param s stream

 * @param start saved start pos of the packet in the stream

 */

static INLINE void rdpgfx_server_packet_complete_header(wStream* s, size_t start)

{

	size_t current = Stream_GetPosition(s);

	/* Fill actual length */

	Stream_SetPosition(s, start + RDPGFX_HEADER_SIZE - sizeof(UINT32));

	Stream_Write_UINT32(s, current - start); /* pduLength (4 bytes) */

	Stream_SetPosition(s, current);

}

/**

 * Function description

 * Send the stream for rdpgfx server packet.

 * The packet would be compressed according to [MS-RDPEGFX].

 *

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

 */

static UINT rdpgfx_server_packet_send(RdpgfxServerContext* context, wStream* s)

{

	UINT error;

	UINT32 flags = 0;

	ULONG written;

	BYTE* pSrcData = Stream_Buffer(s);

	UINT32 SrcSize = Stream_GetPosition(s);

	wStream* fs;

	/* Allocate new stream with enough capacity. Additional overhead is

	 * descriptor (1 bytes) + segmentCount (2 bytes) + uncompressedSize (4 bytes)

	 * + segmentCount * size (4 bytes) */

	fs = Stream_New(NULL, SrcSize + 7 + (SrcSize / ZGFX_SEGMENTED_MAXSIZE + 1) * 4);

	if (!fs)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		error = CHANNEL_RC_NO_MEMORY;

		goto out;

	}

	if (zgfx_compress_to_stream(context->priv->zgfx, fs, pSrcData, SrcSize, &flags) < 0)

	{

		WLog_ERR(TAG, "zgfx_compress_to_stream failed!");

		error = ERROR_INTERNAL_ERROR;

		goto out;

	}

	if (!WTSVirtualChannelWrite(context->priv->rdpgfx_channel, (PCHAR)Stream_Buffer(fs),

	                            Stream_GetPosition(fs), &written))

	{

		WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");

		error = ERROR_INTERNAL_ERROR;

		goto out;

	}

	if (written < Stream_GetPosition(fs))

	{

		WLog_WARN(TAG, "Unexpected bytes written: %" PRIu32 "/%" PRIuz "", written,

		          Stream_GetPosition(fs));

	}

	error = CHANNEL_RC_OK;

out:

	Stream_Free(fs, TRUE);

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 * Create new stream for single rdpgfx packet. The new stream length

 * would be required data length + header. The header will be written

 * to the stream before return, but the pduLength field might be

 * changed in rdpgfx_server_single_packet_send.

 *

 * @param cmdId

 * @param dataLen estimated data length without header

 *

 * @return new stream

 */

static wStream* rdpgfx_server_single_packet_new(UINT16 cmdId, UINT32 dataLen)

{

	UINT error;

	wStream* s;

	UINT32 pduLength = rdpgfx_pdu_length(dataLen);

	s = Stream_New(NULL, pduLength);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		goto error;

	}

	if ((error = rdpgfx_server_packet_init_header(s, cmdId, pduLength)))

	{

		WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);

		goto error;

	}

	return s;

error:

	Stream_Free(s, TRUE);

	return NULL;

}

/**

 * Function description

 * Send the stream for single rdpgfx packet.

 * The header will be filled with actual length.

 * The packet would be compressed according to [MS-RDPEGFX].

 *

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

 */

static INLINE UINT rdpgfx_server_single_packet_send(RdpgfxServerContext* context, wStream* s)

{

	/* Fill actual length */

	rdpgfx_server_packet_complete_header(s, 0);

	return rdpgfx_server_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_caps_confirm_pdu(RdpgfxServerContext* context,

                                         const RDPGFX_CAPS_CONFIRM_PDU* capsConfirm)

{

	RDPGFX_CAPSET* capsSet = capsConfirm->capsSet;

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_CAPSCONFIRM,

	                                             RDPGFX_CAPSET_BASE_SIZE + capsSet->length);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

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

	if (capsSet->length >= 4)

	{

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

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

	}

	else

		Stream_Zero(s, capsSet->length);

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_reset_graphics_pdu(RdpgfxServerContext* context,

                                           const RDPGFX_RESET_GRAPHICS_PDU* pdu)

{

	UINT32 index;

	MONITOR_DEF* monitor;

	wStream* s;

	/* Check monitorCount. This ensures total size within 340 bytes) */

	if (pdu->monitorCount >= 16)

	{

		WLog_ERR(TAG, "Monitor count MUST be less than or equal to 16: %" PRIu32 "",

		         pdu->monitorCount);

		return ERROR_INVALID_DATA;

	}

	s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_RESETGRAPHICS,

	                                    RDPGFX_RESET_GRAPHICS_PDU_SIZE - RDPGFX_HEADER_SIZE);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

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

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

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

	{

		monitor = &(pdu->monitorDefArray[index]);

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

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

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

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

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

	}

	/* pad (total size must be 340 bytes) */

	Stream_SetPosition(s, RDPGFX_RESET_GRAPHICS_PDU_SIZE);

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_evict_cache_entry_pdu(RdpgfxServerContext* context,

                                              const RDPGFX_EVICT_CACHE_ENTRY_PDU* pdu)

{

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_EVICTCACHEENTRY, 2);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_cache_import_reply_pdu(RdpgfxServerContext* context,

                                               const RDPGFX_CACHE_IMPORT_REPLY_PDU* pdu)

{

	UINT16 index;

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_CACHEIMPORTREPLY,

	                                             2 + 2 * pdu->importedEntriesCount);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	/* importedEntriesCount (2 bytes) */

	Stream_Write_UINT16(s, pdu->importedEntriesCount);

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

	{

		Stream_Write_UINT16(s, pdu->cacheSlots[index]); /* cacheSlot (2 bytes) */

	}

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_create_surface_pdu(RdpgfxServerContext* context,

                                           const RDPGFX_CREATE_SURFACE_PDU* pdu)

{

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_CREATESURFACE, 7);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

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

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

	Stream_Write_UINT8(s, pdu->pixelFormat); /* RDPGFX_PIXELFORMAT (1 byte) */

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_delete_surface_pdu(RdpgfxServerContext* context,

                                           const RDPGFX_DELETE_SURFACE_PDU* pdu)

{

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_DELETESURFACE, 2);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

	return rdpgfx_server_single_packet_send(context, s);

}

static INLINE void rdpgfx_write_start_frame_pdu(wStream* s, const RDPGFX_START_FRAME_PDU* pdu)

{

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

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

}

static INLINE void rdpgfx_write_end_frame_pdu(wStream* s, const RDPGFX_END_FRAME_PDU* pdu)

{

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

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_start_frame_pdu(RdpgfxServerContext* context,

                                        const RDPGFX_START_FRAME_PDU* pdu)

{

	wStream* s =

	    rdpgfx_server_single_packet_new(RDPGFX_CMDID_STARTFRAME, RDPGFX_START_FRAME_PDU_SIZE);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	rdpgfx_write_start_frame_pdu(s, pdu);

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_end_frame_pdu(RdpgfxServerContext* context, const RDPGFX_END_FRAME_PDU* pdu)

{

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_ENDFRAME, RDPGFX_END_FRAME_PDU_SIZE);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	rdpgfx_write_end_frame_pdu(s, pdu);

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 * Estimate RFX_AVC420_BITMAP_STREAM structure size in stream

 *

 * @return estimated size

 */

static INLINE UINT32 rdpgfx_estimate_h264_avc420(const 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

 * Estimate surface command packet size in stream without header

 *

 * @return estimated size

 */

static INLINE UINT32 rdpgfx_estimate_surface_command(const RDPGFX_SURFACE_COMMAND* cmd)

{

	RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;

	RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;

	UINT32 h264Size = 0;

	/* Estimate stream size according to codec. */

	switch (cmd->codecId)

	{

		case RDPGFX_CODECID_CAPROGRESSIVE:

		case RDPGFX_CODECID_CAPROGRESSIVE_V2:

			return RDPGFX_WIRE_TO_SURFACE_PDU_2_SIZE + cmd->length;

		case RDPGFX_CODECID_AVC420:

			havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;

			h264Size = rdpgfx_estimate_h264_avc420(havc420);

			return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + h264Size;

		case RDPGFX_CODECID_AVC444:

			havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;

			h264Size = sizeof(UINT32); /* cbAvc420EncodedBitstream1 */

			/* avc420EncodedBitstream1 */

			havc420 = &(havc444->bitstream[0]);

			h264Size += rdpgfx_estimate_h264_avc420(havc420);

			/* avc420EncodedBitstream2 */

			if (havc444->LC == 0)

			{

				havc420 = &(havc444->bitstream[1]);

				h264Size += rdpgfx_estimate_h264_avc420(havc420);

			}

			return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + h264Size;

		default:

			return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + cmd->length;

	}

}

/**

 * Function description

 * Resolve RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2

 * according to codecId

 *

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

 */

static INLINE UINT16 rdpgfx_surface_command_cmdid(const RDPGFX_SURFACE_COMMAND* cmd)

{

	if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||

	    cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)

	{

		return RDPGFX_CMDID_WIRETOSURFACE_2;

	}

	return RDPGFX_CMDID_WIRETOSURFACE_1;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_write_h264_metablock(wStream* s, const RDPGFX_H264_METABLOCK* meta)

{

	UINT32 index;

	RECTANGLE_16* regionRect;

	RDPGFX_H264_QUANT_QUALITY* quantQualityVal;

	UINT error = CHANNEL_RC_OK;

	if (!Stream_EnsureRemainingCapacity(s, 4 + meta->numRegionRects * 10))

		return ERROR_OUTOFMEMORY;

	Stream_Write_UINT32(s, meta->numRegionRects); /* numRegionRects (4 bytes) */

	for (index = 0; index < meta->numRegionRects; index++)

	{

		regionRect = &(meta->regionRects[index]);

		if ((error = rdpgfx_write_rect16(s, regionRect)))

		{

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

			return error;

		}

	}

	for (index = 0; index < meta->numRegionRects; index++)

	{

		quantQualityVal = &(meta->quantQualityVals[index]);

		Stream_Write_UINT8(s, quantQualityVal->qp | (quantQualityVal->r << 6) |

		                          (quantQualityVal->p << 7)); /* qpVal (1 byte) */

		/* qualityVal (1 byte) */

		Stream_Write_UINT8(s, quantQualityVal->qualityVal);

	}

	return error;

}

/**

 * Function description

 * Write RFX_AVC420_BITMAP_STREAM structure to stream

 *

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

 */

static INLINE UINT rdpgfx_write_h264_avc420(wStream* s, RDPGFX_AVC420_BITMAP_STREAM* havc420)

{

	UINT error = CHANNEL_RC_OK;

	if ((error = rdpgfx_write_h264_metablock(s, &(havc420->meta))))

	{

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

		return error;

	}

	if (!Stream_EnsureRemainingCapacity(s, havc420->length))

		return ERROR_OUTOFMEMORY;

	Stream_Write(s, havc420->data, havc420->length);

	return error;

}

/**

 * Function description

 * Write RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2

 * to the stream according to RDPGFX_SURFACE_COMMAND message

 *

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

 */

static UINT rdpgfx_write_surface_command(wStream* s, const RDPGFX_SURFACE_COMMAND* cmd)

{

	UINT error = CHANNEL_RC_OK;

	RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;

	RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;

	UINT32 bitmapDataStart = 0;

	UINT32 bitmapDataLength = 0;

	UINT8 pixelFormat = 0;

	switch (cmd->format)

	{

		case PIXEL_FORMAT_BGRX32:

			pixelFormat = GFX_PIXEL_FORMAT_XRGB_8888;

			break;

		case PIXEL_FORMAT_BGRA32:

			pixelFormat = GFX_PIXEL_FORMAT_ARGB_8888;

			break;

		default:

			WLog_ERR(TAG, "Format %s not supported!", FreeRDPGetColorFormatName(cmd->format));

			return ERROR_INVALID_DATA;

	}

	if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||

	    cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)

	{

		/* Write RDPGFX_CMDID_WIRETOSURFACE_2 format for CAPROGRESSIVE */

		Stream_Write_UINT16(s, cmd->surfaceId); /* surfaceId (2 bytes) */

		Stream_Write_UINT16(s, cmd->codecId);   /* codecId (2 bytes) */

		Stream_Write_UINT32(s, cmd->contextId); /* codecContextId (4 bytes) */

		Stream_Write_UINT8(s, pixelFormat);     /* pixelFormat (1 byte) */

		Stream_Write_UINT32(s, cmd->length);    /* bitmapDataLength (4 bytes) */

		Stream_Write(s, cmd->data, cmd->length);

	}

	else

	{

		/* Write RDPGFX_CMDID_WIRETOSURFACE_1 format for others */

		Stream_Write_UINT16(s, cmd->surfaceId); /* surfaceId (2 bytes) */

		Stream_Write_UINT16(s, cmd->codecId);   /* codecId (2 bytes) */

		Stream_Write_UINT8(s, pixelFormat);     /* pixelFormat (1 byte) */

		Stream_Write_UINT16(s, cmd->left);      /* left (2 bytes) */

		Stream_Write_UINT16(s, cmd->top);       /* top (2 bytes) */

		Stream_Write_UINT16(s, cmd->right);     /* right (2 bytes) */

		Stream_Write_UINT16(s, cmd->bottom);    /* bottom (2 bytes) */

		Stream_Write_UINT32(s, cmd->length);    /* bitmapDataLength (4 bytes) */

		bitmapDataStart = Stream_GetPosition(s);

		if (cmd->codecId == RDPGFX_CODECID_AVC420)

		{

			havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;

			error = rdpgfx_write_h264_avc420(s, havc420);

			if (error != CHANNEL_RC_OK)

			{

				WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");

				return error;

			}

		}

		else if ((cmd->codecId == RDPGFX_CODECID_AVC444) ||

		         (cmd->codecId == RDPGFX_CODECID_AVC444v2))

		{

			havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;

			havc420 = &(havc444->bitstream[0]); /* avc420EncodedBitstreamInfo (4 bytes) */

			Stream_Write_UINT32(s, havc444->cbAvc420EncodedBitstream1 | (havc444->LC << 30UL));

			/* avc420EncodedBitstream1 */

			error = rdpgfx_write_h264_avc420(s, havc420);

			if (error != CHANNEL_RC_OK)

			{

				WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");

				return error;

			}

			/* avc420EncodedBitstream2 */

			if (havc444->LC == 0)

			{

				havc420 = &(havc444->bitstream[1]);

				error = rdpgfx_write_h264_avc420(s, havc420);

				if (error != CHANNEL_RC_OK)

				{

					WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");

					return error;

				}

			}

		}

		else

		{

			Stream_Write(s, cmd->data, cmd->length);

		}

		/* Fill actual bitmap data length */

		bitmapDataLength = Stream_GetPosition(s) - bitmapDataStart;

		Stream_SetPosition(s, bitmapDataStart - sizeof(UINT32));

		Stream_Write_UINT32(s, bitmapDataLength); /* bitmapDataLength (4 bytes) */

		Stream_Seek(s, bitmapDataLength);

	}

	return error;

}

/**

 * Function description

 * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2

 * message according to codecId

 *

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

 */

static UINT rdpgfx_send_surface_command(RdpgfxServerContext* context,

                                        const RDPGFX_SURFACE_COMMAND* cmd)

{

	UINT error = CHANNEL_RC_OK;

	wStream* s;

	s = rdpgfx_server_single_packet_new(rdpgfx_surface_command_cmdid(cmd),

	                                    rdpgfx_estimate_surface_command(cmd));

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	error = rdpgfx_write_surface_command(s, cmd);

	if (error != CHANNEL_RC_OK)

	{

		WLog_ERR(TAG, "rdpgfx_write_surface_command failed!");

		goto error;

	}

	return rdpgfx_server_single_packet_send(context, s);

error:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 * Send RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2

 * message according to codecId.

 * Prepend/append start/end frame message in same packet if exists.

 *

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

 */

static UINT rdpgfx_send_surface_frame_command(RdpgfxServerContext* context,

                                              const RDPGFX_SURFACE_COMMAND* cmd,

                                              const RDPGFX_START_FRAME_PDU* startFrame,

                                              const RDPGFX_END_FRAME_PDU* endFrame)

{

	UINT error = CHANNEL_RC_OK;

	wStream* s;

	UINT32 position = 0;

	UINT32 size = rdpgfx_pdu_length(rdpgfx_estimate_surface_command(cmd));

	if (startFrame)

	{

		size += rdpgfx_pdu_length(RDPGFX_START_FRAME_PDU_SIZE);

	}

	if (endFrame)

	{

		size += rdpgfx_pdu_length(RDPGFX_END_FRAME_PDU_SIZE);

	}

	s = Stream_New(NULL, size);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	/* Write start frame if exists */

	if (startFrame)

	{

		position = Stream_GetPosition(s);

		error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_STARTFRAME, 0);

		if (error != CHANNEL_RC_OK)

		{

			WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);

			goto error;

		}

		rdpgfx_write_start_frame_pdu(s, startFrame);

		rdpgfx_server_packet_complete_header(s, position);

	}

	/* Write RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2 */

	position = Stream_GetPosition(s);

	error = rdpgfx_server_packet_init_header(s, rdpgfx_surface_command_cmdid(cmd),

	                                         0); // Actual length will be filled later

	if (error != CHANNEL_RC_OK)

	{

		WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);

		goto error;

	}

	error = rdpgfx_write_surface_command(s, cmd);

	if (error != CHANNEL_RC_OK)

	{

		WLog_ERR(TAG, "rdpgfx_write_surface_command failed!");

		goto error;

	}

	rdpgfx_server_packet_complete_header(s, position);

	/* Write end frame if exists */

	if (endFrame)

	{

		position = Stream_GetPosition(s);

		error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_ENDFRAME, 0);

		if (error != CHANNEL_RC_OK)

		{

			WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);

			goto error;

		}

		rdpgfx_write_end_frame_pdu(s, endFrame);

		rdpgfx_server_packet_complete_header(s, position);

	}

	return rdpgfx_server_packet_send(context, s);

error:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_delete_encoding_context_pdu(RdpgfxServerContext* context,

                                                    const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* pdu)

{

	wStream* s = rdpgfx_server_single_packet_new(RDPGFX_CMDID_DELETEENCODINGCONTEXT, 6);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

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

	return rdpgfx_server_single_packet_send(context, s);

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_solid_fill_pdu(RdpgfxServerContext* context,

                                       const RDPGFX_SOLID_FILL_PDU* pdu)

{

	UINT error = CHANNEL_RC_OK;

	UINT16 index;

	RECTANGLE_16* fillRect;

	wStream* s =

	    rdpgfx_server_single_packet_new(RDPGFX_CMDID_SOLIDFILL, 8 + 8 * pdu->fillRectCount);

	if (!s)

	{

		WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

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

	/* fillPixel (4 bytes) */

	if ((error = rdpgfx_write_color32(s, &(pdu->fillPixel))))

	{

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

		goto error;

	}

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

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

	{

		fillRect = &(pdu->fillRects[index]);

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

		{

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

			goto error;

		}

	}

	return rdpgfx_server_single_packet_send(context, s);

error:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpgfx_send_surface_to_surface_pdu(RdpgfxServerContext* context,

                                               const RDPGFX_SURFACE_TO_SURFACE_PDU* pdu)

{

	UINT error = CHANNEL_RC_OK;

	UINT16 index;

	RDPGFX_POINT16* destPt;

	wStream* s =

	    rdpgfx_server_single_packet_new(RDPGFX_CMDID_SURFACETOSURFACE, 14 + 4 * pdu->destPtsCount);

	if (!s)

	{