/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Progressive Codec Bitmap Compression

 *

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

 * Copyright 2019 Armin Novak <armin.novak@thincast.com>

 * Copyright 2019 Thincast Technologies GmbH

 *

 * 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_dwt.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 */

	UINT32 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";

	}

}

static INLINE void progressive_component_codec_quant_read(wStream* s,

                                                          RFX_COMPONENT_CODEC_QUANT* quantVal)

{

	BYTE b;

	Stream_Read_UINT8(s, b);

	quantVal->LL3 = b & 0x0F;

	quantVal->HL3 = b >> 4;

	Stream_Read_UINT8(s, b);

	quantVal->LH3 = b & 0x0F;

	quantVal->HH3 = b >> 4;

	Stream_Read_UINT8(s, b);

	quantVal->HL2 = b & 0x0F;

	quantVal->LH2 = b >> 4;

	Stream_Read_UINT8(s, b);

	quantVal->HH2 = b & 0x0F;

	quantVal->HL1 = b >> 4;

	Stream_Read_UINT8(s, b);

	quantVal->LH1 = b & 0x0F;

	quantVal->HH1 = b >> 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(const RFX_COMPONENT_CODEC_QUANT* q1,

                                             const 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(const RFX_COMPONENT_CODEC_QUANT* q1,

                                             const 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(const 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(const RFX_COMPONENT_CODEC_QUANT* q1,

                                                        const 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(const 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(const RFX_COMPONENT_CODEC_QUANT* q1,

                                                           const 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(const RFX_COMPONENT_CODEC_QUANT* q1,

                                                   const 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_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 PROGRESSIVE_SURFACE_CONTEXT*

progressive_get_surface_data(PROGRESSIVE_CONTEXT* progressive, UINT16 surfaceId)

{

	void* key = (void*)(((ULONG_PTR)surfaceId) + 1);

	void* pData = NULL;

	if (!progressive)

		return NULL;

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

	return pData;

}

static void progressive_tile_free(RFX_PROGRESSIVE_TILE* tile)

{

	if (tile)

	{

		_aligned_free(tile->sign);

		_aligned_free(tile->current);

		_aligned_free(tile->data);

	}

}

static void progressive_surface_context_free(PROGRESSIVE_SURFACE_CONTEXT* surface)

{

	UINT32 index;

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

	{

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

		progressive_tile_free(tile);

	}

	free(surface->tiles);

	free(surface);

}

static INLINE BOOL progressive_tile_allocate(RFX_PROGRESSIVE_TILE* tile)

{

	BOOL rc = FALSE;

	if (!tile)

		return FALSE;

	tile->width = 64;

	tile->height = 64;

	tile->stride = 4 * tile->width;

	{

		size_t dataLen = tile->stride * tile->height;

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

	}

	{

		size_t signLen = (8192 + 32) * 3;

		tile->sign = (BYTE*)_aligned_malloc(signLen, 16);

	}

	{

		size_t currentLen = (8192 + 32) * 3;

		tile->current = (BYTE*)_aligned_malloc(currentLen, 16);

	}

	rc = tile->data && tile->sign && tile->current;

	if (!rc)

		progressive_tile_free(tile);

	return rc;

}

static PROGRESSIVE_SURFACE_CONTEXT* progressive_surface_context_new(UINT16 surfaceId, UINT32 width,

                                                                    UINT32 height)

{

	UINT32 x;

	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;

	}

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

	{

		if (!progressive_tile_allocate(&surface->tiles[x]))

		{

			progressive_surface_context_free(surface);

			return NULL;

		}

	}

	return surface;

}

static BOOL progressive_surface_tile_replace(PROGRESSIVE_SURFACE_CONTEXT* surface,

                                             PROGRESSIVE_BLOCK_REGION* region,

                                             const RFX_PROGRESSIVE_TILE* tile, BOOL upgrade)

{

	RFX_PROGRESSIVE_TILE* t;

	size_t zIdx;

	if (!surface || !tile)

		return FALSE;

	zIdx = (tile->yIdx * surface->gridWidth) + tile->xIdx;

	if (zIdx >= surface->gridSize)

	{

		WLog_ERR(TAG, "Invalid zIndex %" PRIuz, zIdx);

		return FALSE;

	}

	t = &surface->tiles[zIdx];

	if (upgrade)

	{

		t->blockType = tile->blockType;

		t->blockLen = tile->blockLen;

		t->quantIdxY = tile->quantIdxY;

		t->quantIdxCb = tile->quantIdxCb;

		t->quantIdxCr = tile->quantIdxCr;

		t->xIdx = tile->xIdx;

		t->yIdx = tile->yIdx;

		t->flags = tile->flags;

		t->quality = tile->quality;

		t->ySrlLen = tile->ySrlLen;

		t->yRawLen = tile->yRawLen;

		t->cbSrlLen = tile->cbSrlLen;

		t->cbRawLen = tile->cbRawLen;

		t->crSrlLen = tile->crSrlLen;

		t->crRawLen = tile->crRawLen;

		t->ySrlData = tile->ySrlData;

		t->yRawData = tile->yRawData;

		t->cbSrlData = tile->cbSrlData;

		t->cbRawData = tile->cbRawData;

		t->crSrlData = tile->crSrlData;

		t->crRawData = tile->crRawData;

		t->x = tile->xIdx * t->width;

		t->y = tile->yIdx * t->height;

	}

	else

	{

		t->blockType = tile->blockType;

		t->blockLen = tile->blockLen;

		t->quantIdxY = tile->quantIdxY;

		t->quantIdxCb = tile->quantIdxCb;

		t->quantIdxCr = tile->quantIdxCr;

		t->xIdx = tile->xIdx;

		t->yIdx = tile->yIdx;

		t->flags = tile->flags;

		t->quality = tile->quality;

		t->yLen = tile->yLen;

		t->cbLen = tile->cbLen;

		t->crLen = tile->crLen;

		t->tailLen = tile->tailLen;

		t->yData = tile->yData;

		t->cbData = tile->cbData;

		t->crData = tile->crData;

		t->tailData = tile->tailData;

		t->x = tile->xIdx * t->width;

		t->y = tile->yIdx * t->height;

	}

	if (region->usedTiles >= region->numTiles)

	{

		WLog_ERR(TAG, "Invalid tile count, only expected %" PRIu16 ", got %" PRIu16,

		         region->numTiles, region->usedTiles);

		return FALSE;

	}

	region->tiles[region->usedTiles++] = t;

	return TRUE;

}

INT32 progressive_create_surface_context(PROGRESSIVE_CONTEXT* progressive, UINT16 surfaceId,

                                         UINT32 width, UINT32 height)

{

	PROGRESSIVE_SURFACE_CONTEXT* surface;

	surface = 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 = 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(const INT16* pLowBand, size_t nLowStep,

                                          const INT16* pHighBand, size_t nHighStep, INT16* pDstBand,

                                          size_t nDstStep, size_t nLowCount, size_t nHighCount,

                                          size_t nDstCount)

{

	size_t i;

	INT16 L0;

	INT16 H0, H1;

	INT16 X0, X1, X2;

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

	{

		size_t j;

		const INT16* pL = pLowBand;

		const INT16* pH = pHighBand;

		INT16* pX = pDstBand;

		H0 = *pH++;

		L0 = *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(const INT16* pLowBand, size_t nLowStep,

                                          const INT16* pHighBand, size_t nHighStep, INT16* pDstBand,

                                          size_t nDstStep, size_t nLowCount, size_t nHighCount,

                                          size_t nDstCount)

{

	size_t i;

	INT16 L0;

	INT16 H0, H1;

	INT16 X0, X1, X2;

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

	{

		size_t j;

		const INT16* pL = pLowBand;

		const INT16* pH = pHighBand;

		INT16* 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 size_t progressive_rfx_get_band_l_count(size_t level)

{

	return (64 >> level) + 1;

}

static INLINE size_t progressive_rfx_get_band_h_count(size_t 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, size_t level)

{

	size_t nDstStepX;

	size_t nDstStepY;

	INT16 *HL, *LH;

	INT16 *HH, *LL;

	INT16 *L, *H, *LLx;

	const size_t nBandL = progressive_rfx_get_band_l_count(level);

	const size_t nBandH = progressive_rfx_get_band_h_count(level);

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

	progressive_rfx_idwt_x(LL, nBandL, HL, nBandH, L, nDstStepX, nBandL, nBandH, nBandL);

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

	progressive_rfx_idwt_x(LH, nBandL, HH, nBandH, H, nDstStepX, nBandL, nBandH, nBandH);

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

	progressive_rfx_idwt_y(L, nDstStepX, H, nDstStepX, LLx, nDstStepY, nBandL, nBandH,

	                       nBandL + nBandH);

}

static INLINE int progressive_rfx_dwt_2d_decode(PROGRESSIVE_CONTEXT* progressive, INT16* buffer,

                                                INT16* current, BOOL coeffDiff, BOOL extrapolate,

                                                BOOL reverse)

{

	const primitives_t* prims = primitives_get();

	INT16* temp;

	if (!progressive || !buffer || !current)

		return -1;

	if (coeffDiff)

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

	if (reverse)

		CopyMemory(buffer, current, 4096 * 2);

	else

		CopyMemory(current, buffer, 4096 * 2);

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

	if (!temp)

		return -2;

	if (!extrapolate)

	{

		rfx_dwt_2d_decode_block(&buffer[3840], temp, 8);

		rfx_dwt_2d_decode_block(&buffer[3072], temp, 16);

		rfx_dwt_2d_decode_block(&buffer[0], temp, 32);

	}

	else

	{

		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);

	}

	BufferPool_Return(progressive->bufferPool, temp);

	return 1;

}

static INLINE void progressive_rfx_decode_block(const primitives_t* prims, INT16* buffer,

                                                UINT32 length, UINT32 shift)

{

	if (!shift)

		return;

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

}

static INLINE int progressive_rfx_decode_component(PROGRESSIVE_CONTEXT* progressive,

                                                   const RFX_COMPONENT_CODEC_QUANT* shift,

                                                   const BYTE* data, UINT32 length, INT16* buffer,

                                                   INT16* current, INT16* sign, BOOL coeffDiff,

                                                   BOOL subbandDiff, BOOL extrapolate)

{

	int status;

	const primitives_t* prims = primitives_get();

	if (!subbandDiff)

		WLog_WARN(TAG, "PROGRESSIVE_BLOCK_CONTEXT::flags & RFX_SUBBAND_DIFFING not set");

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

	if (status < 0)

		return status;

	CopyMemory(sign, buffer, 4096 * 2);

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

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

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