/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Progressive Codec Bitmap Compression

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.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 <winpr/crt.h>

#include <winpr/print.h>

#include <winpr/bitstream.h>

#include <freerdp/primitives.h>

#include <freerdp/codec/color.h>

#include <freerdp/codec/progressive.h>

#include <freerdp/codec/region.h>

#include <freerdp/log.h>

#include "rfx_differential.h"

#include "rfx_quantization.h"

#include "rfx_rlgr.h"

#include "progressive.h"

#define TAG FREERDP_TAG("codec.progressive")

struct _RFX_PROGRESSIVE_UPGRADE_STATE

{

	BOOL nonLL;

	wBitStream* srl;

	wBitStream* raw;

	/* SRL state */

	int kp;

	int nz;

	BOOL mode;

};

typedef struct _RFX_PROGRESSIVE_UPGRADE_STATE RFX_PROGRESSIVE_UPGRADE_STATE;

static const char* progressive_get_block_type_string(UINT16 blockType)

{

	switch (blockType)

	{

		case PROGRESSIVE_WBT_SYNC:

			return "PROGRESSIVE_WBT_SYNC";

		case PROGRESSIVE_WBT_FRAME_BEGIN:

			return "PROGRESSIVE_WBT_FRAME_BEGIN";

		case PROGRESSIVE_WBT_FRAME_END:

			return "PROGRESSIVE_WBT_FRAME_END";

		case PROGRESSIVE_WBT_CONTEXT:

			return "PROGRESSIVE_WBT_CONTEXT";

		case PROGRESSIVE_WBT_REGION:

			return "PROGRESSIVE_WBT_REGION";

		case PROGRESSIVE_WBT_TILE_SIMPLE:

			return "PROGRESSIVE_WBT_TILE_SIMPLE";

		case PROGRESSIVE_WBT_TILE_FIRST:

			return "PROGRESSIVE_WBT_TILE_FIRST";

		case PROGRESSIVE_WBT_TILE_UPGRADE:

			return "PROGRESSIVE_WBT_TILE_UPGRADE";

		default:

			return "PROGRESSIVE_WBT_UNKNOWN";

	}

	return "PROGRESSIVE_WBT_UNKNOWN";

}

static INLINE void progressive_component_codec_quant_read(const BYTE* block,

        RFX_COMPONENT_CODEC_QUANT* quantVal)

{

	quantVal->LL3 = block[0] & 0x0F;

	quantVal->HL3 = block[0] >> 4;

	quantVal->LH3 = block[1] & 0x0F;

	quantVal->HH3 = block[1] >> 4;

	quantVal->HL2 = block[2] & 0x0F;

	quantVal->LH2 = block[2] >> 4;

	quantVal->HH2 = block[3] & 0x0F;

	quantVal->HL1 = block[3] >> 4;

	quantVal->LH1 = block[4] & 0x0F;

	quantVal->HH1 = block[4] >> 4;

}

static INLINE void progressive_rfx_quant_ladd(RFX_COMPONENT_CODEC_QUANT* q, int val)

{

	q->HL1 += val; /* HL1 */

	q->LH1 += val; /* LH1 */

	q->HH1 += val; /* HH1 */

	q->HL2 += val; /* HL2 */

	q->LH2 += val; /* LH2 */

	q->HH2 += val; /* HH2 */

	q->HL3 += val; /* HL3 */

	q->LH3 += val; /* LH3 */

	q->HH3 += val; /* HH3 */

	q->LL3 += val; /* LL3 */

}

static INLINE void progressive_rfx_quant_add(RFX_COMPONENT_CODEC_QUANT* q1,

        RFX_COMPONENT_CODEC_QUANT* q2,

        RFX_COMPONENT_CODEC_QUANT* dst)

{

	dst->HL1 = q1->HL1 + q2->HL1; /* HL1 */

	dst->LH1 = q1->LH1 + q2->LH1; /* LH1 */

	dst->HH1 = q1->HH1 + q2->HH1; /* HH1 */

	dst->HL2 = q1->HL2 + q2->HL2; /* HL2 */

	dst->LH2 = q1->LH2 + q2->LH2; /* LH2 */

	dst->HH2 = q1->HH2 + q2->HH2; /* HH2 */

	dst->HL3 = q1->HL3 + q2->HL3; /* HL3 */

	dst->LH3 = q1->LH3 + q2->LH3; /* LH3 */

	dst->HH3 = q1->HH3 + q2->HH3; /* HH3 */

	dst->LL3 = q1->LL3 + q2->LL3; /* LL3 */

}

static INLINE void progressive_rfx_quant_lsub(RFX_COMPONENT_CODEC_QUANT* q, int val)

{

	q->HL1 -= val; /* HL1 */

	q->LH1 -= val; /* LH1 */

	q->HH1 -= val; /* HH1 */

	q->HL2 -= val; /* HL2 */

	q->LH2 -= val; /* LH2 */

	q->HH2 -= val; /* HH2 */

	q->HL3 -= val; /* HL3 */

	q->LH3 -= val; /* LH3 */

	q->HH3 -= val; /* HH3 */

	q->LL3 -= val; /* LL3 */

}

static INLINE void progressive_rfx_quant_sub(RFX_COMPONENT_CODEC_QUANT* q1,

        RFX_COMPONENT_CODEC_QUANT* q2,

        RFX_COMPONENT_CODEC_QUANT* dst)

{

	dst->HL1 = q1->HL1 - q2->HL1; /* HL1 */

	dst->LH1 = q1->LH1 - q2->LH1; /* LH1 */

	dst->HH1 = q1->HH1 - q2->HH1; /* HH1 */

	dst->HL2 = q1->HL2 - q2->HL2; /* HL2 */

	dst->LH2 = q1->LH2 - q2->LH2; /* LH2 */

	dst->HH2 = q1->HH2 - q2->HH2; /* HH2 */

	dst->HL3 = q1->HL3 - q2->HL3; /* HL3 */

	dst->LH3 = q1->LH3 - q2->LH3; /* LH3 */

	dst->HH3 = q1->HH3 - q2->HH3; /* HH3 */

	dst->LL3 = q1->LL3 - q2->LL3; /* LL3 */

}

static INLINE BOOL progressive_rfx_quant_lcmp_less_equal(RFX_COMPONENT_CODEC_QUANT* q,

        int val)

{

	if (q->HL1 > val) return FALSE; /* HL1 */

	if (q->LH1 > val) return FALSE; /* LH1 */

	if (q->HH1 > val) return FALSE; /* HH1 */

	if (q->HL2 > val) return FALSE; /* HL2 */

	if (q->LH2 > val) return FALSE; /* LH2 */

	if (q->HH2 > val) return FALSE; /* HH2 */

	if (q->HL3 > val) return FALSE; /* HL3 */

	if (q->LH3 > val) return FALSE; /* LH3 */

	if (q->HH3 > val) return FALSE; /* HH3 */

	if (q->LL3 > val) return FALSE; /* LL3 */

	return TRUE;

}

static INLINE BOOL progressive_rfx_quant_cmp_less_equal(RFX_COMPONENT_CODEC_QUANT* q1,

        RFX_COMPONENT_CODEC_QUANT* q2)

{

	if (q1->HL1 > q2->HL1) return FALSE; /* HL1 */

	if (q1->LH1 > q2->LH1) return FALSE; /* LH1 */

	if (q1->HH1 > q2->HH1) return FALSE; /* HH1 */

	if (q1->HL2 > q2->HL2) return FALSE; /* HL2 */

	if (q1->LH2 > q2->LH2) return FALSE; /* LH2 */

	if (q1->HH2 > q2->HH2) return FALSE; /* HH2 */

	if (q1->HL3 > q2->HL3) return FALSE; /* HL3 */

	if (q1->LH3 > q2->LH3) return FALSE; /* LH3 */

	if (q1->HH3 > q2->HH3) return FALSE; /* HH3 */

	if (q1->LL3 > q2->LL3) return FALSE; /* LL3 */

	return TRUE;

}

static INLINE BOOL progressive_rfx_quant_lcmp_greater_equal(RFX_COMPONENT_CODEC_QUANT* q,

        int val)

{

	if (q->HL1 < val) return FALSE; /* HL1 */

	if (q->LH1 < val) return FALSE; /* LH1 */

	if (q->HH1 < val) return FALSE; /* HH1 */

	if (q->HL2 < val) return FALSE; /* HL2 */

	if (q->LH2 < val) return FALSE; /* LH2 */

	if (q->HH2 < val) return FALSE; /* HH2 */

	if (q->HL3 < val) return FALSE; /* HL3 */

	if (q->LH3 < val) return FALSE; /* LH3 */

	if (q->HH3 < val) return FALSE; /* HH3 */

	if (q->LL3 < val) return FALSE; /* LL3 */

	return TRUE;

}

static INLINE BOOL progressive_rfx_quant_cmp_greater_equal(RFX_COMPONENT_CODEC_QUANT* q1,

        RFX_COMPONENT_CODEC_QUANT* q2)

{

	if (q1->HL1 < q2->HL1) return FALSE; /* HL1 */

	if (q1->LH1 < q2->LH1) return FALSE; /* LH1 */

	if (q1->HH1 < q2->HH1) return FALSE; /* HH1 */

	if (q1->HL2 < q2->HL2) return FALSE; /* HL2 */

	if (q1->LH2 < q2->LH2) return FALSE; /* LH2 */

	if (q1->HH2 < q2->HH2) return FALSE; /* HH2 */

	if (q1->HL3 < q2->HL3) return FALSE; /* HL3 */

	if (q1->LH3 < q2->LH3) return FALSE; /* LH3 */

	if (q1->HH3 < q2->HH3) return FALSE; /* HH3 */

	if (q1->LL3 < q2->LL3) return FALSE; /* LL3 */

	return TRUE;

}

static INLINE BOOL progressive_rfx_quant_cmp_equal(RFX_COMPONENT_CODEC_QUANT* q1,

        RFX_COMPONENT_CODEC_QUANT* q2)

{

	if (q1->HL1 != q2->HL1) return FALSE; /* HL1 */

	if (q1->LH1 != q2->LH1) return FALSE; /* LH1 */

	if (q1->HH1 != q2->HH1) return FALSE; /* HH1 */

	if (q1->HL2 != q2->HL2) return FALSE; /* HL2 */

	if (q1->LH2 != q2->LH2) return FALSE; /* LH2 */

	if (q1->HH2 != q2->HH2) return FALSE; /* HH2 */

	if (q1->HL3 != q2->HL3) return FALSE; /* HL3 */

	if (q1->LH3 != q2->LH3) return FALSE; /* LH3 */

	if (q1->HH3 != q2->HH3) return FALSE; /* HH3 */

	if (q1->LL3 != q2->LL3) return FALSE; /* LL3 */

	return TRUE;

}

static void progressive_rfx_quant_print(RFX_COMPONENT_CODEC_QUANT* q, const char* name)

{

	fprintf(stderr,

	        "%s: HL1: %"PRIu8" LH1: %"PRIu8" HH1: %"PRIu8" HL2: %"PRIu8" LH2: %"PRIu8" HH2: %"PRIu8" HL3: %"PRIu8" LH3: %"PRIu8" HH3: %"PRIu8" LL3: %"PRIu8"\n",

	        name, q->HL1, q->LH1, q->HH1, q->HL2, q->LH2, q->HH2, q->HL3, q->LH3, q->HH3,

	        q->LL3);

}

static INLINE BOOL progressive_set_surface_data(PROGRESSIVE_CONTEXT* progressive,

        UINT16 surfaceId, void* pData)

{

	ULONG_PTR key;

	key = ((ULONG_PTR) surfaceId) + 1;

	if (pData)

		return HashTable_Add(progressive->SurfaceContexts, (void *)key, pData) >= 0;

	HashTable_Remove(progressive->SurfaceContexts, (void*) key);

	return TRUE;

}

static INLINE void* progressive_get_surface_data(PROGRESSIVE_CONTEXT* progressive, UINT16 surfaceId)

{

	ULONG_PTR key;

	void* pData = NULL;

	key = ((ULONG_PTR) surfaceId) + 1;

	pData = HashTable_GetItemValue(progressive->SurfaceContexts, (void*) key);

	return pData;

}

static PROGRESSIVE_SURFACE_CONTEXT* progressive_surface_context_new(UINT16 surfaceId, UINT32 width, UINT32 height)

{

	PROGRESSIVE_SURFACE_CONTEXT* surface;

	surface = (PROGRESSIVE_SURFACE_CONTEXT*) calloc(

	              1, sizeof(PROGRESSIVE_SURFACE_CONTEXT));

	if (!surface)

		return NULL;

	surface->id = surfaceId;

	surface->width = width;

	surface->height = height;

	surface->gridWidth = (width + (64 - width % 64)) / 64;

	surface->gridHeight = (height + (64 - height % 64)) / 64;

	surface->gridSize = surface->gridWidth * surface->gridHeight;

	surface->tiles = (RFX_PROGRESSIVE_TILE*) calloc(surface->gridSize, sizeof(RFX_PROGRESSIVE_TILE));

	if (!surface->tiles)

	{

		free(surface);

		return NULL;

	}

	return surface;

}

static void progressive_surface_context_free(PROGRESSIVE_SURFACE_CONTEXT* surface)

{

	UINT32 index;

	RFX_PROGRESSIVE_TILE* tile;

	for (index = 0; index < surface->gridSize; index++)

	{

		tile = &(surface->tiles[index]);

		if (tile->data)

			_aligned_free(tile->data);

		if (tile->sign)

			_aligned_free(tile->sign);

		if (tile->current)

			_aligned_free(tile->current);

	}

	free(surface->tiles);

	free(surface);

}

INT32 progressive_create_surface_context(PROGRESSIVE_CONTEXT* progressive,

        UINT16 surfaceId, UINT32 width, UINT32 height)

{

	PROGRESSIVE_SURFACE_CONTEXT* surface;

	surface = (PROGRESSIVE_SURFACE_CONTEXT *)progressive_get_surface_data(progressive, surfaceId);

	if (!surface)

	{

		surface = progressive_surface_context_new(surfaceId, width, height);

		if (!surface)

			return -1;

		if (!progressive_set_surface_data(progressive, surfaceId, (void*) surface))

		{

			progressive_surface_context_free(surface);

			return -1;

		}

	}

	return 1;

}

int progressive_delete_surface_context(PROGRESSIVE_CONTEXT* progressive,

                                       UINT16 surfaceId)

{

	PROGRESSIVE_SURFACE_CONTEXT* surface;

	surface = (PROGRESSIVE_SURFACE_CONTEXT *)progressive_get_surface_data(progressive, surfaceId);

	if (surface)

	{

		progressive_set_surface_data(progressive, surfaceId, NULL);

		progressive_surface_context_free(surface);

	}

	return 1;

}

/*

 * Band		Offset		Dimensions	Size

 *

 * HL1		0		31x33		1023

 * LH1		1023		33x31		1023

 * HH1		2046		31x31		961

 *

 * HL2		3007		16x17		272

 * LH2		3279		17x16		272

 * HH2		3551		16x16		256

 *

 * HL3		3807		8x9		72

 * LH3		3879		9x8		72

 * HH3		3951		8x8		64

 *

 * LL3		4015		9x9		81

 */

static INLINE void progressive_rfx_idwt_x(INT16* pLowBand, int nLowStep,

        INT16* pHighBand,

        int nHighStep, INT16* pDstBand, int nDstStep,

        int nLowCount, int nHighCount, int nDstCount)

{

	int i, j;

	INT16 L0;

	INT16 H0, H1;

	INT16 X0, X1, X2;

	INT16* pL, *pH, *pX;

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

	{

		pL = pLowBand;

		pH = pHighBand;

		pX = pDstBand;

		H0 = *pH;

		pH++;

		L0 = *pL;

		pL++;

		X0 = L0 - H0;

		X2 = L0 - H0;

		for (j = 0; j < (nHighCount - 1); j++)

		{

			H1 = *pH;

			pH++;

			L0 = *pL;

			pL++;

			X2 = L0 - ((H0 + H1) / 2);

			X1 = ((X0 + X2) / 2) + (2 * H0);

			pX[0] = X0;

			pX[1] = X1;

			pX += 2;

			X0 = X2;

			H0 = H1;

		}

		if (nLowCount <= (nHighCount + 1))

		{

			if (nLowCount <= nHighCount)

			{

				pX[0] = X2;

				pX[1] = X2 + (2 * H0);

			}

			else

			{

				L0 = *pL;

				pL++;

				X0 = L0 - H0;

				pX[0] = X2;

				pX[1] = ((X0 + X2) / 2) + (2 * H0);

				pX[2] = X0;

			}

		}

		else

		{

			L0 = *pL;

			pL++;

			X0 = L0 - (H0 / 2);

			pX[0] = X2;

			pX[1] = ((X0 + X2) / 2) + (2 * H0);

			pX[2] = X0;

			L0 = *pL;

			pL++;

			pX[3] = (X0 + L0) / 2;

		}

		pLowBand += nLowStep;

		pHighBand += nHighStep;

		pDstBand += nDstStep;

	}

}

static INLINE void progressive_rfx_idwt_y(INT16* pLowBand, int nLowStep,

        INT16* pHighBand,

        int nHighStep, INT16* pDstBand, int nDstStep,

        int nLowCount, int nHighCount, int nDstCount)

{

	int i, j;

	INT16 L0;

	INT16 H0, H1;

	INT16 X0, X1, X2;

	INT16* pL, *pH, *pX;

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

	{

		pL = pLowBand;

		pH = pHighBand;

		pX = pDstBand;

		H0 = *pH;

		pH += nHighStep;

		L0 = *pL;

		pL += nLowStep;

		X0 = L0 - H0;

		X2 = L0 - H0;

		for (j = 0; j < (nHighCount - 1); j++)

		{

			H1 = *pH;

			pH += nHighStep;

			L0 = *pL;

			pL += nLowStep;

			X2 = L0 - ((H0 + H1) / 2);

			X1 = ((X0 + X2) / 2) + (2 * H0);

			*pX = X0;

			pX += nDstStep;

			*pX = X1;

			pX += nDstStep;

			X0 = X2;

			H0 = H1;

		}

		if (nLowCount <= (nHighCount + 1))

		{

			if (nLowCount <= nHighCount)

			{

				*pX = X2;

				pX += nDstStep;

				*pX = X2 + (2 * H0);

			}

			else

			{

				L0 = *pL;

				X0 = L0 - H0;

				*pX = X2;

				pX += nDstStep;

				*pX = ((X0 + X2) / 2) + (2 * H0);

				pX += nDstStep;

				*pX = X0;

			}

		}

		else

		{

			L0 = *pL;

			pL += nLowStep;

			X0 = L0 - (H0 / 2);

			*pX = X2;

			pX += nDstStep;

			*pX = ((X0 + X2) / 2) + (2 * H0);

			pX += nDstStep;

			*pX = X0;

			pX += nDstStep;

			L0 = *pL;

			*pX = (X0 + L0) / 2;

		}

		pLowBand++;

		pHighBand++;

		pDstBand++;

	}

}

static INLINE int progressive_rfx_get_band_l_count(int level)

{

	return (64 >> level) + 1;

}

static INLINE int progressive_rfx_get_band_h_count(int level)

{

	if (level == 1)

		return (64 >> 1) - 1;

	else

		return (64 + (1 << (level - 1))) >> level;

}

static INLINE void progressive_rfx_dwt_2d_decode_block(INT16* buffer, INT16* temp,

        int level)

{

	int offset;

	int nBandL;

	int nBandH;

	int nDstStepX;

	int nDstStepY;

	INT16* HL, *LH;

	INT16* HH, *LL;

	INT16* L, *H, *LLx;

	INT16* pLowBand[3];

	INT16* pHighBand[3];

	INT16* pDstBand[3];

	int nLowStep[3];

	int nHighStep[3];

	int nDstStep[3];

	int nLowCount[3];

	int nHighCount[3];

	int nDstCount[3];

	nBandL = progressive_rfx_get_band_l_count(level);

	nBandH = progressive_rfx_get_band_h_count(level);

	offset = 0;

	HL = &buffer[offset];

	offset += (nBandH * nBandL);

	LH = &buffer[offset];

	offset += (nBandL * nBandH);

	HH = &buffer[offset];

	offset += (nBandH * nBandH);

	LL = &buffer[offset];

	nDstStepX = (nBandL + nBandH);

	nDstStepY = (nBandL + nBandH);

	offset = 0;

	L = &temp[offset];

	offset += (nBandL * nDstStepX);

	H = &temp[offset];

	LLx = &buffer[0];

	/* horizontal (LL + HL -> L) */

	pLowBand[0] = LL;

	nLowStep[0] = nBandL;

	pHighBand[0] = HL;

	nHighStep[0] = nBandH;

	pDstBand[0] = L;

	nDstStep[0] = nDstStepX;

	nLowCount[0] = nBandL;

	nHighCount[0] = nBandH;

	nDstCount[0] = nBandL;

	progressive_rfx_idwt_x(pLowBand[0], nLowStep[0], pHighBand[0], nHighStep[0],

	                       pDstBand[0], nDstStep[0], nLowCount[0], nHighCount[0], nDstCount[0]);

	/* horizontal (LH + HH -> H) */

	pLowBand[1] = LH;

	nLowStep[1] = nBandL;

	pHighBand[1] = HH;

	nHighStep[1] = nBandH;

	pDstBand[1] = H;

	nDstStep[1] = nDstStepX;

	nLowCount[1] = nBandL;

	nHighCount[1] = nBandH;

	nDstCount[1] = nBandH;

	progressive_rfx_idwt_x(pLowBand[1], nLowStep[1], pHighBand[1], nHighStep[1],

	                       pDstBand[1], nDstStep[1], nLowCount[1], nHighCount[1], nDstCount[1]);

	/* vertical (L + H -> LL) */

	pLowBand[2] = pDstBand[0];

	nLowStep[2] = nDstStep[0];

	pHighBand[2] = pDstBand[1];

	nHighStep[2] = nDstStep[1];

	pDstBand[2] = LLx;

	nDstStep[2] = nDstStepY;

	nLowCount[2] = nBandL;

	nHighCount[2] = nBandH;

	nDstCount[2] = nBandL + nBandH;

	progressive_rfx_idwt_y(pLowBand[2], nLowStep[2], pHighBand[2], nHighStep[2],

	                       pDstBand[2], nDstStep[2], nLowCount[2], nHighCount[2], nDstCount[2]);

}

static INLINE void progressive_rfx_dwt_2d_decode(INT16* buffer, INT16* temp,

        INT16* current, INT16* sign, BOOL diff)

{

	const primitives_t* prims = primitives_get();

	if (diff)

		prims->add_16s(buffer, current, buffer, 4096);

	CopyMemory(current, buffer, 4096 * 2);

	progressive_rfx_dwt_2d_decode_block(&buffer[3807], temp, 3);

	progressive_rfx_dwt_2d_decode_block(&buffer[3007], temp, 2);

	progressive_rfx_dwt_2d_decode_block(&buffer[0], temp, 1);

}

static INLINE void progressive_rfx_decode_block(const primitives_t* prims,

        INT16* buffer,

        int length, UINT32 shift)

{

	if (!shift)

		return;

	prims->lShiftC_16s(buffer, shift, buffer, length);

}

static INLINE int progressive_rfx_decode_component(PROGRESSIVE_CONTEXT* progressive,

        RFX_COMPONENT_CODEC_QUANT* shift,

        const BYTE* data, int length,

        INT16* buffer, INT16* current,

        INT16* sign, BOOL diff)

{

	int status;

	INT16* temp;

	const primitives_t* prims = primitives_get();

	status = rfx_rlgr_decode(RLGR1, data, length, buffer, 4096);

	if (status < 0)

		return status;

	CopyMemory(sign, buffer, 4096 * 2);

	rfx_differential_decode(&buffer[4015], 81); /* LL3 */

	progressive_rfx_decode_block(prims, &buffer[0], 1023, shift->HL1); /* HL1 */

	progressive_rfx_decode_block(prims, &buffer[1023], 1023, shift->LH1); /* LH1 */

	progressive_rfx_decode_block(prims, &buffer[2046], 961, shift->HH1); /* HH1 */

	progressive_rfx_decode_block(prims, &buffer[3007], 272, shift->HL2); /* HL2 */

	progressive_rfx_decode_block(prims, &buffer[3279], 272, shift->LH2); /* LH2 */

	progressive_rfx_decode_block(prims, &buffer[3551], 256, shift->HH2); /* HH2 */

	progressive_rfx_decode_block(prims, &buffer[3807], 72, shift->HL3); /* HL3 */

	progressive_rfx_decode_block(prims, &buffer[3879], 72, shift->LH3); /* LH3 */

	progressive_rfx_decode_block(prims, &buffer[3951], 64, shift->HH3); /* HH3 */

	progressive_rfx_decode_block(prims, &buffer[4015], 81, shift->LL3); /* LL3 */

	temp = (INT16*) BufferPool_Take(progressive->bufferPool, -1); /* DWT buffer */

	progressive_rfx_dwt_2d_decode(buffer, temp, current, sign, diff);

	BufferPool_Return(progressive->bufferPool, temp);

	return 1;

}

static INLINE int progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* progressive,

        RFX_PROGRESSIVE_TILE* tile)

{

	BOOL diff;

	BYTE* pBuffer;

	INT16* pSign[3];

	INT16* pSrcDst[3];

	INT16* pCurrent[3];

	PROGRESSIVE_BLOCK_REGION* region;

	RFX_COMPONENT_CODEC_QUANT shiftY;

	RFX_COMPONENT_CODEC_QUANT shiftCb;

	RFX_COMPONENT_CODEC_QUANT shiftCr;

	RFX_COMPONENT_CODEC_QUANT* quantY;

	RFX_COMPONENT_CODEC_QUANT* quantCb;

	RFX_COMPONENT_CODEC_QUANT* quantCr;

	RFX_COMPONENT_CODEC_QUANT* quantProgY;

	RFX_COMPONENT_CODEC_QUANT* quantProgCb;

	RFX_COMPONENT_CODEC_QUANT* quantProgCr;

	RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal;

	static const prim_size_t roi_64x64 = { 64, 64 };

	const primitives_t* prims = primitives_get();

	tile->pass = 1;

	diff = tile->flags & RFX_TILE_DIFFERENCE;

	WLog_Print(progressive->log, WLOG_DEBUG,

	           "ProgressiveTile%s: quantIdx Y: %"PRIu8" Cb: %"PRIu8" Cr: %"PRIu8" xIdx: %"PRIu16" yIdx: %"PRIu16" flags: 0x%02"PRIX8" quality: %"PRIu8" yLen: %"PRIu16" cbLen: %"PRIu16" crLen: %"PRIu16" tailLen: %"PRIu16"",

	           (tile->blockType == PROGRESSIVE_WBT_TILE_FIRST) ? "First" : "Simple",

	           tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr,

	           tile->xIdx, tile->yIdx, tile->flags, tile->quality, tile->yLen,

	           tile->cbLen, tile->crLen, tile->tailLen);

	region = &(progressive->region);

	if (tile->quantIdxY >= region->numQuant)

		return -1;

	quantY = &(region->quantVals[tile->quantIdxY]);

	if (tile->quantIdxCb >= region->numQuant)

		return -1;

	quantCb = &(region->quantVals[tile->quantIdxCb]);

	if (tile->quantIdxCr >= region->numQuant)

		return -1;

	quantCr = &(region->quantVals[tile->quantIdxCr]);

	if (tile->quality == 0xFF)

	{

		quantProgVal = &(progressive->quantProgValFull);

	}

	else

	{

		if (tile->quality >= region->numProgQuant)

			return -1;

		quantProgVal = &(region->quantProgVals[tile->quality]);

	}

	quantProgY = &(quantProgVal->yQuantValues);

	quantProgCb = &(quantProgVal->cbQuantValues);

	quantProgCr = &(quantProgVal->crQuantValues);

	CopyMemory(&(tile->yQuant), quantY, sizeof(RFX_COMPONENT_CODEC_QUANT));

	CopyMemory(&(tile->cbQuant), quantCb, sizeof(RFX_COMPONENT_CODEC_QUANT));

	CopyMemory(&(tile->crQuant), quantCr, sizeof(RFX_COMPONENT_CODEC_QUANT));

	CopyMemory(&(tile->yProgQuant), quantProgY, sizeof(RFX_COMPONENT_CODEC_QUANT));

	CopyMemory(&(tile->cbProgQuant), quantProgCb, sizeof(RFX_COMPONENT_CODEC_QUANT));

	CopyMemory(&(tile->crProgQuant), quantProgCr, sizeof(RFX_COMPONENT_CODEC_QUANT));

	progressive_rfx_quant_add(quantY, quantProgY, &(tile->yBitPos));

	progressive_rfx_quant_add(quantCb, quantProgCb, &(tile->cbBitPos));

	progressive_rfx_quant_add(quantCr, quantProgCr, &(tile->crBitPos));

	progressive_rfx_quant_add(quantY, quantProgY, &shiftY);

	progressive_rfx_quant_lsub(&shiftY, 1); /* -6 + 5 = -1 */

	progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);

	progressive_rfx_quant_lsub(&shiftCb, 1); /* -6 + 5 = -1 */

	progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);

	progressive_rfx_quant_lsub(&shiftCr, 1); /* -6 + 5 = -1 */

	if (!tile->data)

	{

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

		if (!tile->data)

			return -1;

	}

	if (!tile->sign)

	{

		tile->sign = (BYTE*) _aligned_malloc((8192 + 32) * 3, 16);

		if (!tile->sign)

			return -1;

	}

	if (!tile->current)

	{

		tile->current = (BYTE*) _aligned_malloc((8192 + 32) * 3, 16);

		if (!tile->current)

			return -1;

	}

	pBuffer = tile->sign;

	pSign[0] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */

	pSign[1] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */

	pSign[2] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */

	pBuffer = tile->current;

	pCurrent[0] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */

	pCurrent[1] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */

	pCurrent[2] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */

	pBuffer = (BYTE*) BufferPool_Take(progressive->bufferPool, -1);

	pSrcDst[0] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */

	pSrcDst[1] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */

	pSrcDst[2] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */

	progressive_rfx_decode_component(progressive, &shiftY, tile->yData, tile->yLen,

	                                 pSrcDst[0], pCurrent[0], pSign[0], diff); /* Y */

	progressive_rfx_decode_component(progressive, &shiftCb, tile->cbData, tile->cbLen,

	                                 pSrcDst[1], pCurrent[1], pSign[1], diff); /* Cb */

	progressive_rfx_decode_component(progressive, &shiftCr, tile->crData, tile->crLen,

	                                 pSrcDst[2], pCurrent[2], pSign[2], diff); /* Cr */

	prims->yCbCrToRGB_16s8u_P3AC4R((const INT16**) pSrcDst, 64 * 2, tile->data, tile->stride,

								tile->format, &roi_64x64);

	BufferPool_Return(progressive->bufferPool, pBuffer);

	return 1;

}

static INLINE INT16 progressive_rfx_srl_read(RFX_PROGRESSIVE_UPGRADE_STATE* state,

        UINT32 numBits)

{

	int k;

	UINT32 bit;

	UINT32 max;

	UINT32 mag;

	UINT32 sign;

	wBitStream* bs = state->srl;

	if (state->nz)

	{

		state->nz--;

		return 0;

	}

	k = state->kp / 8;

	if (!state->mode)

	{

		/* zero encoding */

		bit = (bs->accumulator & 0x80000000) ? 1 : 0;

		BitStream_Shift(bs, 1);