/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * RemoteFX Codec Library

 *

 * Copyright 2011 Vic Lee

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 Norbert Federa <norbert.federa@thincast.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#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/tchar.h>

#include <winpr/sysinfo.h>

#include <winpr/registry.h>

#include <winpr/tchar.h>

#include <freerdp/log.h>

#include <freerdp/codec/rfx.h>

#include <freerdp/constants.h>

#include <freerdp/primitives.h>

#include <freerdp/codec/region.h>

#include <freerdp/build-config.h>

#include <freerdp/codec/region.h>

#include "rfx_constants.h"

#include "rfx_types.h"

#include "rfx_decode.h"

#include "rfx_encode.h"

#include "rfx_quantization.h"

#include "rfx_dwt.h"

#include "rfx_rlgr.h"

#include "rfx_sse2.h"

#include "rfx_neon.h"

#define TAG FREERDP_TAG("codec")

#ifndef RFX_INIT_SIMD

#define RFX_INIT_SIMD(_rfx_context) \

	do                              \

	{                               \

	} while (0)

#endif

#define RFX_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\RemoteFX"

/**

 * The quantization values control the compression rate and quality. The value

 * range is between 6 and 15. The higher value, the higher compression rate

 * and lower quality.

 *

 * This is the default values being use by the MS RDP server, and we will also

 * use it as our default values for the encoder. It can be overrided by setting

 * the context->num_quants and context->quants member.

 *

 * The order of the values are:

 * LL3, LH3, HL3, HH3, LH2, HL2, HH2, LH1, HL1, HH1

 */

static const UINT32 rfx_default_quantization_values[] = { 6, 6, 6, 6, 7, 7, 8, 8, 8, 9 };

static void rfx_profiler_create(RFX_CONTEXT* context)

{

	PROFILER_CREATE(context->priv->prof_rfx_decode_rgb, "rfx_decode_rgb")

	PROFILER_CREATE(context->priv->prof_rfx_decode_component, "rfx_decode_component")

	PROFILER_CREATE(context->priv->prof_rfx_rlgr_decode, "rfx_rlgr_decode")

	PROFILER_CREATE(context->priv->prof_rfx_differential_decode, "rfx_differential_decode")

	PROFILER_CREATE(context->priv->prof_rfx_quantization_decode, "rfx_quantization_decode")

	PROFILER_CREATE(context->priv->prof_rfx_dwt_2d_decode, "rfx_dwt_2d_decode")

	PROFILER_CREATE(context->priv->prof_rfx_ycbcr_to_rgb, "prims->yCbCrToRGB")

	PROFILER_CREATE(context->priv->prof_rfx_encode_rgb, "rfx_encode_rgb")

	PROFILER_CREATE(context->priv->prof_rfx_encode_component, "rfx_encode_component")

	PROFILER_CREATE(context->priv->prof_rfx_rlgr_encode, "rfx_rlgr_encode")

	PROFILER_CREATE(context->priv->prof_rfx_differential_encode, "rfx_differential_encode")

	PROFILER_CREATE(context->priv->prof_rfx_quantization_encode, "rfx_quantization_encode")

	PROFILER_CREATE(context->priv->prof_rfx_dwt_2d_encode, "rfx_dwt_2d_encode")

	PROFILER_CREATE(context->priv->prof_rfx_rgb_to_ycbcr, "prims->RGBToYCbCr")

	PROFILER_CREATE(context->priv->prof_rfx_encode_format_rgb, "rfx_encode_format_rgb")

}

static void rfx_profiler_free(RFX_CONTEXT* context)

{

	PROFILER_FREE(context->priv->prof_rfx_decode_rgb)

	PROFILER_FREE(context->priv->prof_rfx_decode_component)

	PROFILER_FREE(context->priv->prof_rfx_rlgr_decode)

	PROFILER_FREE(context->priv->prof_rfx_differential_decode)

	PROFILER_FREE(context->priv->prof_rfx_quantization_decode)

	PROFILER_FREE(context->priv->prof_rfx_dwt_2d_decode)

	PROFILER_FREE(context->priv->prof_rfx_ycbcr_to_rgb)

	PROFILER_FREE(context->priv->prof_rfx_encode_rgb)

	PROFILER_FREE(context->priv->prof_rfx_encode_component)

	PROFILER_FREE(context->priv->prof_rfx_rlgr_encode)

	PROFILER_FREE(context->priv->prof_rfx_differential_encode)

	PROFILER_FREE(context->priv->prof_rfx_quantization_encode)

	PROFILER_FREE(context->priv->prof_rfx_dwt_2d_encode)

	PROFILER_FREE(context->priv->prof_rfx_rgb_to_ycbcr)

	PROFILER_FREE(context->priv->prof_rfx_encode_format_rgb)

}

static void rfx_profiler_print(RFX_CONTEXT* context)

{

	PROFILER_PRINT_HEADER

	PROFILER_PRINT(context->priv->prof_rfx_decode_rgb)

	PROFILER_PRINT(context->priv->prof_rfx_decode_component)

	PROFILER_PRINT(context->priv->prof_rfx_rlgr_decode)

	PROFILER_PRINT(context->priv->prof_rfx_differential_decode)

	PROFILER_PRINT(context->priv->prof_rfx_quantization_decode)

	PROFILER_PRINT(context->priv->prof_rfx_dwt_2d_decode)

	PROFILER_PRINT(context->priv->prof_rfx_ycbcr_to_rgb)

	PROFILER_PRINT(context->priv->prof_rfx_encode_rgb)

	PROFILER_PRINT(context->priv->prof_rfx_encode_component)

	PROFILER_PRINT(context->priv->prof_rfx_rlgr_encode)

	PROFILER_PRINT(context->priv->prof_rfx_differential_encode)

	PROFILER_PRINT(context->priv->prof_rfx_quantization_encode)

	PROFILER_PRINT(context->priv->prof_rfx_dwt_2d_encode)

	PROFILER_PRINT(context->priv->prof_rfx_rgb_to_ycbcr)

	PROFILER_PRINT(context->priv->prof_rfx_encode_format_rgb)

	PROFILER_PRINT_FOOTER

}

static void rfx_tile_init(void* obj)

{

	RFX_TILE* tile = (RFX_TILE*)obj;

	if (tile)

	{

		tile->x = 0;

		tile->y = 0;

		tile->YLen = 0;

		tile->YData = NULL;

		tile->CbLen = 0;

		tile->CbData = NULL;

		tile->CrLen = 0;

		tile->CrData = NULL;

	}

}

static void* rfx_decoder_tile_new(void* val)

{

	RFX_TILE* tile = NULL;

	WINPR_UNUSED(val);

	if (!(tile = (RFX_TILE*)calloc(1, sizeof(RFX_TILE))))

		return NULL;

	if (!(tile->data = (BYTE*)_aligned_malloc(4 * 64 * 64, 16)))

	{

		free(tile);

		return NULL;

	}

	tile->allocated = TRUE;

	return tile;

}

static void rfx_decoder_tile_free(void* obj)

{

	RFX_TILE* tile = (RFX_TILE*)obj;

	if (tile)

	{

		if (tile->allocated)

			_aligned_free(tile->data);

		free(tile);

	}

}

static void* rfx_encoder_tile_new(void* val)

{

	WINPR_UNUSED(val);

	return calloc(1, sizeof(RFX_TILE));

}

static void rfx_encoder_tile_free(void* obj)

{

	free(obj);

}

RFX_CONTEXT* rfx_context_new(BOOL encoder)

{

	HKEY hKey;

	LONG status;

	DWORD dwType;

	DWORD dwSize;

	DWORD dwValue;

	SYSTEM_INFO sysinfo;

	RFX_CONTEXT* context;

	wObject* pool;

	RFX_CONTEXT_PRIV* priv;

	context = (RFX_CONTEXT*)calloc(1, sizeof(RFX_CONTEXT));

	if (!context)

		return NULL;

	context->encoder = encoder;

	context->currentMessage.freeArray = TRUE;

	context->priv = priv = (RFX_CONTEXT_PRIV*)calloc(1, sizeof(RFX_CONTEXT_PRIV));

	if (!priv)

		goto error_priv;

	priv->log = WLog_Get("com.freerdp.codec.rfx");

	WLog_OpenAppender(priv->log);

#ifdef WITH_DEBUG_RFX

	WLog_SetLogLevel(priv->log, WLOG_DEBUG);

#endif

	priv->TilePool = ObjectPool_New(TRUE);

	if (!priv->TilePool)

		goto error_tilePool;

	pool = ObjectPool_Object(priv->TilePool);

	pool->fnObjectInit = rfx_tile_init;

	if (context->encoder)

	{

		pool->fnObjectNew = rfx_encoder_tile_new;

		pool->fnObjectFree = rfx_encoder_tile_free;

	}

	else

	{

		pool->fnObjectNew = rfx_decoder_tile_new;

		pool->fnObjectFree = rfx_decoder_tile_free;

	}

	/*

	 * align buffers to 16 byte boundary (needed for SSE/NEON instructions)

	 *

	 * y_r_buffer, cb_g_buffer, cr_b_buffer: 64 * 64 * sizeof(INT16) = 8192 (0x2000)

	 * dwt_buffer: 32 * 32 * 2 * 2 * sizeof(INT16) = 8192, maximum sub-band width is 32

	 *

	 * Additionally we add 32 bytes (16 in front and 16 at the back of the buffer)

	 * in order to allow optimized functions (SEE, NEON) to read from positions

	 * that are actually in front/beyond the buffer. Offset calculations are

	 * performed at the BufferPool_Take function calls in rfx_encode/decode.c.

	 *

	 * We then multiply by 3 to use a single, partioned buffer for all 3 channels.

	 */

	priv->BufferPool = BufferPool_New(TRUE, (8192 + 32) * 3, 16);

	if (!priv->BufferPool)

		goto error_BufferPool;

#ifdef _WIN32

	{

		BOOL isVistaOrLater;

		OSVERSIONINFOA verinfo;

		ZeroMemory(&verinfo, sizeof(OSVERSIONINFOA));

		verinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);

		GetVersionExA(&verinfo);

		isVistaOrLater =

		    ((verinfo.dwMajorVersion >= 6) && (verinfo.dwMinorVersion >= 0)) ? TRUE : FALSE;

		priv->UseThreads = isVistaOrLater;

	}

#else

	priv->UseThreads = TRUE;

#endif

	GetNativeSystemInfo(&sysinfo);

	priv->MinThreadCount = sysinfo.dwNumberOfProcessors;

	priv->MaxThreadCount = 0;

	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, RFX_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

	if (status == ERROR_SUCCESS)

	{

		dwSize = sizeof(dwValue);

		if (RegQueryValueEx(hKey, _T("UseThreads"), NULL, &dwType, (BYTE*)&dwValue, &dwSize) ==

		    ERROR_SUCCESS)

			priv->UseThreads = dwValue ? 1 : 0;

		if (RegQueryValueEx(hKey, _T("MinThreadCount"), NULL, &dwType, (BYTE*)&dwValue, &dwSize) ==

		    ERROR_SUCCESS)

			priv->MinThreadCount = dwValue;

		if (RegQueryValueEx(hKey, _T("MaxThreadCount"), NULL, &dwType, (BYTE*)&dwValue, &dwSize) ==

		    ERROR_SUCCESS)

			priv->MaxThreadCount = dwValue;

		RegCloseKey(hKey);

	}

	if (priv->UseThreads)

	{

		/* Call primitives_get here in order to avoid race conditions when using primitives_get */

		/* from multiple threads. This call will initialize all function pointers correctly     */

		/* before any decoding threads are started */

		primitives_get();

		priv->ThreadPool = CreateThreadpool(NULL);

		if (!priv->ThreadPool)

			goto error_threadPool;

		InitializeThreadpoolEnvironment(&priv->ThreadPoolEnv);

		SetThreadpoolCallbackPool(&priv->ThreadPoolEnv, priv->ThreadPool);

		if (priv->MinThreadCount)

			if (!SetThreadpoolThreadMinimum(priv->ThreadPool, priv->MinThreadCount))

				goto error_threadPool_minimum;

		if (priv->MaxThreadCount)

			SetThreadpoolThreadMaximum(priv->ThreadPool, priv->MaxThreadCount);

	}

	/* initialize the default pixel format */

	rfx_context_set_pixel_format(context, PIXEL_FORMAT_BGRX32);

	/* create profilers for default decoding routines */

	rfx_profiler_create(context);

	/* set up default routines */

	context->quantization_decode = rfx_quantization_decode;

	context->quantization_encode = rfx_quantization_encode;

	context->dwt_2d_decode = rfx_dwt_2d_decode;

	context->dwt_2d_encode = rfx_dwt_2d_encode;

	context->rlgr_decode = rfx_rlgr_decode;

	context->rlgr_encode = rfx_rlgr_encode;

	RFX_INIT_SIMD(context);

	context->state = RFX_STATE_SEND_HEADERS;

	context->expectedDataBlockType = WBT_FRAME_BEGIN;

	return context;

error_threadPool_minimum:

	CloseThreadpool(priv->ThreadPool);

error_threadPool:

	BufferPool_Free(priv->BufferPool);

error_BufferPool:

	ObjectPool_Free(priv->TilePool);

error_tilePool:

	free(priv);

error_priv:

	free(context);

	return NULL;

}

void rfx_context_free(RFX_CONTEXT* context)

{

	RFX_CONTEXT_PRIV* priv;

	if (!context)

		return;

	assert(NULL != context);

	assert(NULL != context->priv);

	assert(NULL != context->priv->TilePool);

	assert(NULL != context->priv->BufferPool);

	priv = context->priv;

	rfx_message_free(context, &context->currentMessage);

	free(context->quants);

	ObjectPool_Free(priv->TilePool);

	rfx_profiler_print(context);

	rfx_profiler_free(context);

	if (priv->UseThreads)

	{

		CloseThreadpool(context->priv->ThreadPool);

		DestroyThreadpoolEnvironment(&context->priv->ThreadPoolEnv);

		free(priv->workObjects);

		free(priv->tileWorkParams);

#ifdef WITH_PROFILER

		WLog_VRB(TAG,

		         "WARNING: Profiling results probably unusable with multithreaded RemoteFX codec!");

#endif

	}

	BufferPool_Free(context->priv->BufferPool);

	free(context->priv);

	free(context);

}

static RFX_TILE* rfx_message_get_tile(RFX_MESSAGE* message, UINT32 index)

{

	return message->tiles[index];

}

static RFX_RECT* rfx_message_get_rect(RFX_MESSAGE* message, UINT32 index)

{

	return &message->rects[index];

}

void rfx_context_set_pixel_format(RFX_CONTEXT* context, UINT32 pixel_format)

{

	context->pixel_format = pixel_format;

	context->bits_per_pixel = GetBitsPerPixel(pixel_format);

}

BOOL rfx_context_reset(RFX_CONTEXT* context, UINT32 width, UINT32 height)

{

	if (!context)

		return FALSE;

	context->width = width;

	context->height = height;

	context->state = RFX_STATE_SEND_HEADERS;

	context->expectedDataBlockType = WBT_FRAME_BEGIN;

	context->frameIdx = 0;

	return TRUE;

}

static BOOL rfx_process_message_sync(RFX_CONTEXT* context, wStream* s)

{

	UINT32 magic;

	context->decodedHeaderBlocks &= ~_RFX_DECODED_SYNC;

	/* RFX_SYNC */

	if (Stream_GetRemainingLength(s) < 6)

	{

		WLog_ERR(TAG, "RfxSync packet too small");

		return FALSE;

	}

	Stream_Read_UINT32(s, magic); /* magic (4 bytes), 0xCACCACCA */

	if (magic != WF_MAGIC)

	{

		WLog_ERR(TAG, "invalid magic number 0x%08" PRIX32 "", magic);

		return FALSE;

	}

	Stream_Read_UINT16(s, context->version); /* version (2 bytes), WF_VERSION_1_0 (0x0100) */

	if (context->version != WF_VERSION_1_0)

	{

		WLog_ERR(TAG, "invalid version number 0x%08" PRIX32 "", context->version);

		return FALSE;

	}

	WLog_Print(context->priv->log, WLOG_DEBUG, "version 0x%08" PRIX32 "", context->version);

	context->decodedHeaderBlocks |= _RFX_DECODED_SYNC;

	return TRUE;

}

static BOOL rfx_process_message_codec_versions(RFX_CONTEXT* context, wStream* s)

{

	BYTE numCodecs;

	context->decodedHeaderBlocks &= ~_RFX_DECODED_VERSIONS;

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "%s: packet too small for reading codec versions", __FUNCTION__);

		return FALSE;

	}

	Stream_Read_UINT8(s, numCodecs);         /* numCodecs (1 byte), must be set to 0x01 */

	Stream_Read_UINT8(s, context->codec_id); /* codecId (1 byte), must be set to 0x01 */

	Stream_Read_UINT16(

	    s, context->codec_version); /* version (2 bytes), must be set to WF_VERSION_1_0 (0x0100)  */

	if (numCodecs != 1)

	{

		WLog_ERR(TAG, "%s: numCodes is 0x%02" PRIX8 " (must be 0x01)", __FUNCTION__, numCodecs);

		return FALSE;

	}

	if (context->codec_id != 0x01)

	{

		WLog_ERR(TAG, "%s: invalid codec id (0x%02" PRIX32 ")", __FUNCTION__, context->codec_id);

		return FALSE;

	}

	if (context->codec_version != WF_VERSION_1_0)

	{

		WLog_ERR(TAG, "%s: invalid codec version (0x%08" PRIX32 ")", __FUNCTION__,

		         context->codec_version);

		return FALSE;

	}

	WLog_Print(context->priv->log, WLOG_DEBUG, "id %" PRIu32 " version 0x%" PRIX32 ".",

	           context->codec_id, context->codec_version);

	context->decodedHeaderBlocks |= _RFX_DECODED_VERSIONS;

	return TRUE;

}

static BOOL rfx_process_message_channels(RFX_CONTEXT* context, wStream* s)

{

	BYTE channelId;

	BYTE numChannels;

	context->decodedHeaderBlocks &= ~_RFX_DECODED_CHANNELS;

	if (Stream_GetRemainingLength(s) < 1)

	{

		WLog_ERR(TAG, "RfxMessageChannels packet too small");

		return FALSE;

	}

	Stream_Read_UINT8(s, numChannels); /* numChannels (1 byte), must bet set to 0x01 */

	/* In RDVH sessions, numChannels will represent the number of virtual monitors

	 * configured and does not always be set to 0x01 as [MS-RDPRFX] said.

	 */

	if (numChannels < 1)

	{

		WLog_ERR(TAG, "no channels announced");

		return FALSE;

	}

	if (Stream_GetRemainingLength(s) < (size_t)(numChannels * 5))

	{

		WLog_ERR(TAG, "RfxMessageChannels packet too small for numChannels=%" PRIu8 "",

		         numChannels);

		return FALSE;

	}

	/* RFX_CHANNELT */

	Stream_Read_UINT8(s, channelId); /* channelId (1 byte), must be set to 0x00 */

	if (channelId != 0x00)

	{

		WLog_ERR(TAG, "channelId:0x%02" PRIX8 ", expected:0x00", channelId);

		return FALSE;

	}

	Stream_Read_UINT16(s, context->width);  /* width (2 bytes) */

	Stream_Read_UINT16(s, context->height); /* height (2 bytes) */

	if (!context->width || !context->height)

	{

		WLog_ERR(TAG, "%s: invalid channel with/height: %" PRIu16 "x%" PRIu16 "", __FUNCTION__,

		         context->width, context->height);

		return FALSE;

	}

	/* Now, only the first monitor can be used, therefore the other channels will be ignored. */

	Stream_Seek(s, 5 * (numChannels - 1));

	WLog_Print(context->priv->log, WLOG_DEBUG,

	           "numChannels %" PRIu8 " id %" PRIu8 ", %" PRIu16 "x%" PRIu16 ".", numChannels,

	           channelId, context->width, context->height);

	context->decodedHeaderBlocks |= _RFX_DECODED_CHANNELS;

	return TRUE;

}

static BOOL rfx_process_message_context(RFX_CONTEXT* context, wStream* s)

{

	BYTE ctxId;

	UINT16 tileSize;

	UINT16 properties;

	context->decodedHeaderBlocks &= ~_RFX_DECODED_CONTEXT;

	if (Stream_GetRemainingLength(s) < 5)

	{

		WLog_ERR(TAG, "RfxMessageContext packet too small");

		return FALSE;

	}

	Stream_Read_UINT8(s, ctxId);     /* ctxId (1 byte), must be set to 0x00 */

	Stream_Read_UINT16(s, tileSize); /* tileSize (2 bytes), must be set to CT_TILE_64x64 (0x0040) */

	Stream_Read_UINT16(s, properties); /* properties (2 bytes) */

	WLog_Print(context->priv->log, WLOG_DEBUG,

	           "ctxId %" PRIu8 " tileSize %" PRIu16 " properties 0x%04" PRIX16 ".", ctxId, tileSize,

	           properties);

	context->properties = properties;

	context->flags = (properties & 0x0007);

	if (context->flags == CODEC_MODE)

	{

		WLog_Print(context->priv->log, WLOG_DEBUG, "codec is in image mode.");

	}

	else

	{

		WLog_Print(context->priv->log, WLOG_DEBUG, "codec is in video mode.");

	}

	switch ((properties & 0x1E00) >> 9)

	{

		case CLW_ENTROPY_RLGR1:

			context->mode = RLGR1;

			WLog_Print(context->priv->log, WLOG_DEBUG, "RLGR1.");

			break;

		case CLW_ENTROPY_RLGR3:

			context->mode = RLGR3;

			WLog_Print(context->priv->log, WLOG_DEBUG, "RLGR3.");

			break;

		default:

			WLog_ERR(TAG, "unknown RLGR algorithm.");

			return FALSE;

	}

	context->decodedHeaderBlocks |= _RFX_DECODED_CONTEXT;

	return TRUE;

}

static BOOL rfx_process_message_frame_begin(RFX_CONTEXT* context, RFX_MESSAGE* message, wStream* s,

                                            UINT16* pExpectedBlockType)

{

	UINT32 frameIdx;

	UINT16 numRegions;

	if (*pExpectedBlockType != WBT_FRAME_BEGIN)

	{

		WLog_ERR(TAG, "%s: message unexpected wants WBT_FRAME_BEGIN", __FUNCTION__);

		return FALSE;

	}

	*pExpectedBlockType = WBT_REGION;

	if (Stream_GetRemainingLength(s) < 6)

	{

		WLog_ERR(TAG, "RfxMessageFrameBegin packet too small");

		return FALSE;

	}

	Stream_Read_UINT32(

	    s, frameIdx); /* frameIdx (4 bytes), if codec is in video mode, must be ignored */

	Stream_Read_UINT16(s, numRegions); /* numRegions (2 bytes) */

	WLog_Print(context->priv->log, WLOG_DEBUG,

	           "RFX_FRAME_BEGIN: frameIdx: %" PRIu32 " numRegions: %" PRIu16 "", frameIdx,

	           numRegions);

	return TRUE;

}

static BOOL rfx_process_message_frame_end(RFX_CONTEXT* context, RFX_MESSAGE* message, wStream* s,

                                          UINT16* pExpectedBlockType)

{

	if (*pExpectedBlockType != WBT_FRAME_END)

	{

		WLog_ERR(TAG, "%s: message unexpected, wants WBT_FRAME_END", __FUNCTION__);

		return FALSE;

	}

	*pExpectedBlockType = WBT_FRAME_BEGIN;

	WLog_Print(context->priv->log, WLOG_DEBUG, "RFX_FRAME_END");

	return TRUE;

}

static BOOL rfx_process_message_region(RFX_CONTEXT* context, RFX_MESSAGE* message, wStream* s,

                                       UINT16* pExpectedBlockType)

{

	int i;

	UINT16 regionType;

	UINT16 numTileSets;

	RFX_RECT* tmpRects;

	if (*pExpectedBlockType != WBT_REGION)

	{

		WLog_ERR(TAG, "%s: message unexpected wants WBT_REGION", __FUNCTION__);

		return FALSE;

	}

	*pExpectedBlockType = WBT_EXTENSION;

	if (Stream_GetRemainingLength(s) < 3)

	{

		WLog_ERR(TAG, "%s: packet too small (regionFlags/numRects)", __FUNCTION__);

		return FALSE;

	}

	Stream_Seek_UINT8(s);                     /* regionFlags (1 byte) */

	Stream_Read_UINT16(s, message->numRects); /* numRects (2 bytes) */

	if (message->numRects < 1)

	{

		/*

		   If numRects is zero the decoder must generate a rectangle with

		   coordinates (0, 0, width, height).

		   See [MS-RDPRFX] (revision >= 17.0) 2.2.2.3.3 TS_RFX_REGION

		   https://msdn.microsoft.com/en-us/library/ff635233.aspx

		*/

		tmpRects = realloc(message->rects, sizeof(RFX_RECT));

		if (!tmpRects)

			return FALSE;

		message->numRects = 1;

		message->rects = tmpRects;

		message->rects->x = 0;

		message->rects->y = 0;

		message->rects->width = context->width;

		message->rects->height = context->height;

		return TRUE;

	}

	if (Stream_GetRemainingLength(s) < (size_t)(8 * message->numRects))

	{

		WLog_ERR(TAG, "%s: packet too small for num_rects=%" PRIu16 "", __FUNCTION__,

		         message->numRects);

		return FALSE;

	}

	tmpRects = realloc(message->rects, message->numRects * sizeof(RFX_RECT));

	if (!tmpRects)

		return FALSE;

	message->rects = tmpRects;

	/* rects */

	for (i = 0; i < message->numRects; i++)

	{

		RFX_RECT* rect = rfx_message_get_rect(message, i);

		/* RFX_RECT */

		Stream_Read_UINT16(s, rect->x);      /* x (2 bytes) */

		Stream_Read_UINT16(s, rect->y);      /* y (2 bytes) */

		Stream_Read_UINT16(s, rect->width);  /* width (2 bytes) */

		Stream_Read_UINT16(s, rect->height); /* height (2 bytes) */

		WLog_Print(context->priv->log, WLOG_DEBUG,

		           "rect %d (x,y=%" PRIu16 ",%" PRIu16 " w,h=%" PRIu16 " %" PRIu16 ").", i, rect->x,

		           rect->y, rect->width, rect->height);

	}

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "%s: packet too small (regionType/numTileSets)", __FUNCTION__);

		return FALSE;

	}

	Stream_Read_UINT16(s, regionType);  /*regionType (2 bytes): MUST be set to CBT_REGION (0xCAC1)*/

	Stream_Read_UINT16(s, numTileSets); /*numTilesets (2 bytes): MUST be set to 0x0001.*/

	if (regionType != CBT_REGION)

	{

		WLog_ERR(TAG, "%s: invalid region type 0x%04" PRIX16 "", __FUNCTION__, regionType);

		return TRUE;

	}

	if (numTileSets != 0x0001)

	{

		WLog_ERR(TAG, "%s: invalid number of tilesets (%" PRIu16 ")", __FUNCTION__, numTileSets);

		return FALSE;

	}

	return TRUE;

}

struct _RFX_TILE_PROCESS_WORK_PARAM

{

	RFX_TILE* tile;

	RFX_CONTEXT* context;

};

typedef struct _RFX_TILE_PROCESS_WORK_PARAM RFX_TILE_PROCESS_WORK_PARAM;

static void CALLBACK rfx_process_message_tile_work_callback(PTP_CALLBACK_INSTANCE instance,

                                                            void* context, PTP_WORK work)

{

	RFX_TILE_PROCESS_WORK_PARAM* param = (RFX_TILE_PROCESS_WORK_PARAM*)context;

	rfx_decode_rgb(param->context, param->tile, param->tile->data, 64 * 4);

}

static BOOL rfx_process_message_tileset(RFX_CONTEXT* context, RFX_MESSAGE* message, wStream* s,

                                        UINT16* pExpectedBlockType)

{

	BOOL rc;

	int i, close_cnt;

	BYTE quant;

	RFX_TILE* tile;

	RFX_TILE** tmpTiles;

	UINT32* quants;

	UINT16 subtype, numTiles;

	UINT32 blockLen;

	UINT32 blockType;

	UINT32 tilesDataSize;

	PTP_WORK* work_objects = NULL;

	RFX_TILE_PROCESS_WORK_PARAM* params = NULL;

	void* pmem;

	if (*pExpectedBlockType != WBT_EXTENSION)

	{

		WLog_ERR(TAG, "%s: message unexpected wants a tileset", __FUNCTION__);

		return FALSE;

	}

	*pExpectedBlockType = WBT_FRAME_END;

	if (Stream_GetRemainingLength(s) < 14)

	{

		WLog_ERR(TAG, "RfxMessageTileSet packet too small");

		return FALSE;

	}

	Stream_Read_UINT16(s, subtype); /* subtype (2 bytes) must be set to CBT_TILESET (0xCAC2) */

	if (subtype != CBT_TILESET)

	{

		WLog_ERR(TAG, "invalid subtype, expected CBT_TILESET.");

		return FALSE;

	}

	Stream_Seek_UINT16(s);                   /* idx (2 bytes), must be set to 0x0000 */

	Stream_Seek_UINT16(s);                   /* properties (2 bytes) */

	Stream_Read_UINT8(s, context->numQuant); /* numQuant (1 byte) */

	Stream_Seek_UINT8(s);                    /* tileSize (1 byte), must be set to 0x40 */

	if (context->numQuant < 1)

	{

		WLog_ERR(TAG, "no quantization value.");

		return FALSE;

	}

	Stream_Read_UINT16(s, numTiles); /* numTiles (2 bytes) */

	if (numTiles < 1)

	{

		/* Windows Server 2012 (not R2) can send empty tile sets */

		return TRUE;

	}

	Stream_Read_UINT32(s, tilesDataSize); /* tilesDataSize (4 bytes) */

	if (!(pmem = realloc((void*)context->quants, context->numQuant * 10 * sizeof(UINT32))))

		return FALSE;

	quants = context->quants = (UINT32*)pmem;

	/* quantVals */

	if (Stream_GetRemainingLength(s) < (size_t)(context->numQuant * 5))

	{

		WLog_ERR(TAG, "RfxMessageTileSet packet too small for num_quants=%" PRIu8 "",

		         context->numQuant);

		return FALSE;

	}

	for (i = 0; i < context->numQuant; i++)

	{

		/* RFX_CODEC_QUANT */

		Stream_Read_UINT8(s, quant);

		*quants++ = (quant & 0x0F);

		*quants++ = (quant >> 4);

		Stream_Read_UINT8(s, quant);

		*quants++ = (quant & 0x0F);

		*quants++ = (quant >> 4);

		Stream_Read_UINT8(s, quant);

		*quants++ = (quant & 0x0F);

		*quants++ = (quant >> 4);

		Stream_Read_UINT8(s, quant);

		*quants++ = (quant & 0x0F);

		*quants++ = (quant >> 4);

		Stream_Read_UINT8(s, quant);

		*quants++ = (quant & 0x0F);

		*quants++ = (quant >> 4);

		WLog_Print(context->priv->log, WLOG_DEBUG,

		           "quant %d (%" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32

		           " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 ").",

		           i, context->quants[i * 10], context->quants[i * 10 + 1],

		           context->quants[i * 10 + 2], context->quants[i * 10 + 3],

		           context->quants[i * 10 + 4], context->quants[i * 10 + 5],

		           context->quants[i * 10 + 6], context->quants[i * 10 + 7],

		           context->quants[i * 10 + 8], context->quants[i * 10 + 9]);

	}

	for (i = 0; i < message->numTiles; i++)

	{

		ObjectPool_Return(context->priv->TilePool, message->tiles[i]);

		message->tiles[i] = NULL;

	}

	tmpTiles = (RFX_TILE**)realloc(message->tiles, numTiles * sizeof(RFX_TILE*));

	if (!tmpTiles)

		return FALSE;

	message->tiles = tmpTiles;

	message->numTiles = numTiles;

	if (context->priv->UseThreads)

	{

		work_objects = (PTP_WORK*)calloc(message->numTiles, sizeof(PTP_WORK));

		params = (RFX_TILE_PROCESS_WORK_PARAM*)calloc(message->numTiles,

		                                              sizeof(RFX_TILE_PROCESS_WORK_PARAM));

		if (!work_objects)

		{

			free(params);

			return FALSE;

		}

		if (!params)

		{

			free(work_objects);

			return FALSE;

		}

	}