/** * FreeRDP: A Remote Desktop Protocol Implementation * Progressive Codec Bitmap Compression * * Copyright 2014 Marc-Andre Moreau * * 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 #include #include #include #include #include #include #include #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); if (!bit) { /* '0' bit, nz >= (1 << k), nz = (1 << k) */ state->nz = (1 << k); state->kp += 4; if (state->kp > 80) state->kp = 80; state->nz--; return 0; } else { /* '1' bit, nz < (1 << k), nz = next k bits */ state->nz = 0; state->mode = 1; /* unary encoding is next */ if (k) { bs->mask = ((1 << k) - 1); state->nz = ((bs->accumulator >> (32 - k)) & bs->mask); BitStream_Shift(bs, k); } if (state->nz) { state->nz--; return 0; } } } state->mode = 0; /* zero encoding is next */ /* unary encoding */ /* read sign bit */ sign = (bs->accumulator & 0x80000000) ? 1 : 0; BitStream_Shift(bs, 1); state->kp -= 6; if (state->kp < 0) state->kp = 0; if (numBits == 1) return sign ? -1 : 1; mag = 1; max = (1 << numBits) - 1; while (mag < max) { bit = (bs->accumulator & 0x80000000) ? 1 : 0; BitStream_Shift(bs, 1); if (bit) break; mag++; } return sign ? -1 * mag : mag; } static INLINE int progressive_rfx_upgrade_state_finish(RFX_PROGRESSIVE_UPGRADE_STATE* state) { int pad; wBitStream* srl; wBitStream* raw; srl = state->srl; raw = state->raw; /* Read trailing bits from RAW/SRL bit streams */ pad = (raw->position % 8) ? (8 - (raw->position % 8)) : 0; if (pad) BitStream_Shift(raw, pad); pad = (srl->position % 8) ? (8 - (srl->position % 8)) : 0; if (pad) BitStream_Shift(srl, pad); if (BitStream_GetRemainingLength(srl) == 8) BitStream_Shift(srl, 8); return 1; } static INLINE int progressive_rfx_upgrade_block(RFX_PROGRESSIVE_UPGRADE_STATE* state, INT16* buffer, INT16* sign, UINT32 length, UINT32 shift, UINT32 bitPos, UINT32 numBits) { int index; INT16 input; wBitStream* raw; if (!numBits) return 1; raw = state->raw; if (!state->nonLL) { for (index = 0; index < length; index++) { raw->mask = ((1 << numBits) - 1); input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask); BitStream_Shift(raw, numBits); buffer[index] += (input << shift); } return 1; } for (index = 0; index < length; index++) { if (sign[index] > 0) { /* sign > 0, read from raw */ raw->mask = ((1 << numBits) - 1); input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask); BitStream_Shift(raw, numBits); } else if (sign[index] < 0) { /* sign < 0, read from raw */ raw->mask = ((1 << numBits) - 1); input = (INT16)((raw->accumulator >> (32 - numBits)) & raw->mask); BitStream_Shift(raw, numBits); input *= -1; } else { /* sign == 0, read from srl */ input = progressive_rfx_srl_read(state, numBits); sign[index] = input; } buffer[index] += (input << shift); } return 1; } static INLINE int progressive_rfx_upgrade_component(PROGRESSIVE_CONTEXT* progressive, RFX_COMPONENT_CODEC_QUANT* shift, RFX_COMPONENT_CODEC_QUANT* bitPos, RFX_COMPONENT_CODEC_QUANT* numBits, INT16* buffer, INT16* current, INT16* sign, const BYTE* srlData, UINT32 srlLen, const BYTE* rawData, UINT32 rawLen) { INT16* temp; UINT32 aRawLen; UINT32 aSrlLen; wBitStream s_srl; wBitStream s_raw; RFX_PROGRESSIVE_UPGRADE_STATE state; ZeroMemory(&s_srl, sizeof(wBitStream)); ZeroMemory(&s_raw, sizeof(wBitStream)); ZeroMemory(&state, sizeof(RFX_PROGRESSIVE_UPGRADE_STATE)); state.kp = 8; state.mode = 0; state.srl = &s_srl; state.raw = &s_raw; BitStream_Attach(state.srl, srlData, srlLen); BitStream_Fetch(state.srl); BitStream_Attach(state.raw, rawData, rawLen); BitStream_Fetch(state.raw); state.nonLL = TRUE; progressive_rfx_upgrade_block(&state, ¤t[0], &sign[0], 1023, shift->HL1, bitPos->HL1, numBits->HL1); /* HL1 */ progressive_rfx_upgrade_block(&state, ¤t[1023], &sign[1023], 1023, shift->LH1, bitPos->LH1, numBits->LH1); /* LH1 */ progressive_rfx_upgrade_block(&state, ¤t[2046], &sign[2046], 961, shift->HH1, bitPos->HH1, numBits->HH1); /* HH1 */ progressive_rfx_upgrade_block(&state, ¤t[3007], &sign[3007], 272, shift->HL2, bitPos->HL2, numBits->HL2); /* HL2 */ progressive_rfx_upgrade_block(&state, ¤t[3279], &sign[3279], 272, shift->LH2, bitPos->LH2, numBits->LH2); /* LH2 */ progressive_rfx_upgrade_block(&state, ¤t[3551], &sign[3551], 256, shift->HH2, bitPos->HH2, numBits->HH2); /* HH2 */ progressive_rfx_upgrade_block(&state, ¤t[3807], &sign[3807], 72, shift->HL3, bitPos->HL3, numBits->HL3); /* HL3 */ progressive_rfx_upgrade_block(&state, ¤t[3879], &sign[3879], 72, shift->LH3, bitPos->LH3, numBits->LH3); /* LH3 */ progressive_rfx_upgrade_block(&state, ¤t[3951], &sign[3951], 64, shift->HH3, bitPos->HH3, numBits->HH3); /* HH3 */ state.nonLL = FALSE; progressive_rfx_upgrade_block(&state, ¤t[4015], &sign[4015], 81, shift->LL3, bitPos->LL3, numBits->LL3); /* LL3 */ progressive_rfx_upgrade_state_finish(&state); aRawLen = (state.raw->position + 7) / 8; aSrlLen = (state.srl->position + 7) / 8; if ((aRawLen != rawLen) || (aSrlLen != srlLen)) { int pRawLen = 0; int pSrlLen = 0; if (rawLen) pRawLen = (int)((((float) aRawLen) / ((float) rawLen)) * 100.0f); if (srlLen) pSrlLen = (int)((((float) aSrlLen) / ((float) srlLen)) * 100.0f); WLog_Print(progressive->log, WLOG_INFO, "RAW: %"PRIu32"/%"PRIu32" %d%% (%"PRIu32"/%"PRIu32":%"PRIu32")\tSRL: %"PRIu32"/%"PRIu32" %d%% (%"PRIu32"/%"PRIu32":%"PRIu32")", aRawLen, rawLen, pRawLen, state.raw->position, rawLen * 8, (rawLen * 8) - state.raw->position, aSrlLen, srlLen, pSrlLen, state.srl->position, srlLen * 8, (srlLen * 8) - state.srl->position); return -1; } temp = (INT16*) BufferPool_Take(progressive->bufferPool, -1); /* DWT buffer */ CopyMemory(buffer, current, 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); BufferPool_Return(progressive->bufferPool, temp); return 1; } static INLINE int progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* progressive, RFX_PROGRESSIVE_TILE* tile) { int status; 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 yBitPos; RFX_COMPONENT_CODEC_QUANT cbBitPos; RFX_COMPONENT_CODEC_QUANT crBitPos; RFX_COMPONENT_CODEC_QUANT yNumBits; RFX_COMPONENT_CODEC_QUANT cbNumBits; RFX_COMPONENT_CODEC_QUANT crNumBits; 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* quantProg; static const prim_size_t roi_64x64 = { 64, 64 }; const primitives_t* prims = primitives_get(); tile->pass++; WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveTileUpgrade: pass: %"PRIu16" quantIdx Y: %"PRIu8" Cb: %"PRIu8" Cr: %"PRIu8" xIdx: %"PRIu16" yIdx: %"PRIu16" quality: %"PRIu8" ySrlLen: %"PRIu16" yRawLen: %"PRIu16" cbSrlLen: %"PRIu16" cbRawLen: %"PRIu16" crSrlLen: %"PRIu16" crRawLen: %"PRIu16"", tile->pass, tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen, tile->cbRawLen, tile->crSrlLen, tile->crRawLen); 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) { quantProg = &(progressive->quantProgValFull); } else { if (tile->quality >= region->numProgQuant) return -1; quantProg = &(region->quantProgVals[tile->quality]); } quantProgY = &(quantProg->yQuantValues); quantProgCb = &(quantProg->cbQuantValues); quantProgCr = &(quantProg->crQuantValues); if (!progressive_rfx_quant_cmp_equal(quantY, &(tile->yQuant))) WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantY has changed!"); if (!progressive_rfx_quant_cmp_equal(quantCb, &(tile->cbQuant))) WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCb has changed!"); if (!progressive_rfx_quant_cmp_equal(quantCr, &(tile->crQuant))) WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCr has changed!"); progressive_rfx_quant_add(quantY, quantProgY, &yBitPos); progressive_rfx_quant_add(quantCb, quantProgCb, &cbBitPos); progressive_rfx_quant_add(quantCr, quantProgCr, &crBitPos); progressive_rfx_quant_sub(&(tile->yBitPos), &yBitPos, &yNumBits); progressive_rfx_quant_sub(&(tile->cbBitPos), &cbBitPos, &cbNumBits); progressive_rfx_quant_sub(&(tile->crBitPos), &crBitPos, &crNumBits); 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 */ CopyMemory(&(tile->yBitPos), &yBitPos, sizeof(RFX_COMPONENT_CODEC_QUANT)); CopyMemory(&(tile->cbBitPos), &cbBitPos, sizeof(RFX_COMPONENT_CODEC_QUANT)); CopyMemory(&(tile->crBitPos), &crBitPos, sizeof(RFX_COMPONENT_CODEC_QUANT)); 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)); 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 */ status = progressive_rfx_upgrade_component(progressive, &shiftY, quantProgY, &yNumBits, pSrcDst[0], pCurrent[0], pSign[0], tile->ySrlData, tile->ySrlLen, tile->yRawData, tile->yRawLen); /* Y */ if (status < 0) return -1; status = progressive_rfx_upgrade_component(progressive, &shiftCb, quantProgCb, &cbNumBits, pSrcDst[1], pCurrent[1], pSign[1], tile->cbSrlData, tile->cbSrlLen, tile->cbRawData, tile->cbRawLen); /* Cb */ if (status < 0) return -1; status = progressive_rfx_upgrade_component(progressive, &shiftCr, quantProgCr, &crNumBits, pSrcDst[2], pCurrent[2], pSign[2], tile->crSrlData, tile->crSrlLen, tile->crRawData, tile->crRawLen); /* Cr */ if (status < 0) return -1; 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 int progressive_process_tiles(PROGRESSIVE_CONTEXT* progressive, const BYTE* blocks, UINT32 blocksLen, const PROGRESSIVE_SURFACE_CONTEXT* surface) { int status = -1; const BYTE* block; UINT16 xIdx; UINT16 yIdx; UINT16 zIdx; UINT16 index; UINT32 boffset; UINT16 blockType; UINT32 blockLen; UINT32 count = 0; UINT32 offset = 0; RFX_PROGRESSIVE_TILE* tile; RFX_PROGRESSIVE_TILE** tiles; PROGRESSIVE_BLOCK_REGION* region; region = &(progressive->region); tiles = region->tiles; while ((blocksLen - offset) >= 6) { boffset = 0; block = &blocks[offset]; blockType = *((UINT16*) &block[boffset + 0]); /* blockType (2 bytes) */ blockLen = *((UINT32*) &block[boffset + 2]); /* blockLen (4 bytes) */ boffset += 6; WLog_Print(progressive->log, WLOG_DEBUG, "%s", progressive_get_block_type_string(blockType)); if ((blocksLen - offset) < blockLen) return -1003; switch (blockType) { case PROGRESSIVE_WBT_TILE_SIMPLE: if ((blockLen - boffset) < 16) return -1022; xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ zIdx = (yIdx * surface->gridWidth) + xIdx; if (zIdx >= surface->gridSize) return -1; tiles[count] = tile = &(surface->tiles[zIdx]); tile->blockType = blockType; tile->blockLen = blockLen; tile->quality = 0xFF; /* simple tiles use no progressive techniques */ tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */ tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */ tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */ tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ tile->flags = block[boffset + 7] & 1; /* flags (1 byte) */ tile->yLen = *((UINT16*) &block[boffset + 8]); /* yLen (2 bytes) */ tile->cbLen = *((UINT16*) &block[boffset + 10]); /* cbLen (2 bytes) */ tile->crLen = *((UINT16*) &block[boffset + 12]); /* crLen (2 bytes) */ tile->tailLen = *((UINT16*) &block[boffset + 14]); /* tailLen (2 bytes) */ boffset += 16; if ((tile->blockLen - boffset) < tile->yLen) return -1023; tile->yData = &block[boffset]; boffset += tile->yLen; if ((tile->blockLen - boffset) < tile->cbLen) return -1024; tile->cbData = &block[boffset]; boffset += tile->cbLen; if ((tile->blockLen - boffset) < tile->crLen) return -1025; tile->crData = &block[boffset]; boffset += tile->crLen; if ((tile->blockLen - boffset) < tile->tailLen) return -1026; tile->tailData = &block[boffset]; boffset += tile->tailLen; tile->width = 64; tile->height = 64; tile->x = tile->xIdx * 64; tile->y = tile->yIdx * 64; tile->format = progressive->format; tile->stride = GetBytesPerPixel(tile->format) * tile->width; tile->flags &= 1; break; case PROGRESSIVE_WBT_TILE_FIRST: if ((blockLen - boffset) < 17) return -1027; xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ zIdx = (yIdx * surface->gridWidth) + xIdx; if (zIdx >= surface->gridSize) return -1; tiles[count] = tile = &(surface->tiles[zIdx]); tile->blockType = blockType; tile->blockLen = blockLen; tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */ tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */ tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */ tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ tile->flags = block[boffset + 7] & 1; /* flags (1 byte) */ tile->quality = block[boffset + 8]; /* quality (1 byte) */ tile->yLen = *((UINT16*) &block[boffset + 9]); /* yLen (2 bytes) */ tile->cbLen = *((UINT16*) &block[boffset + 11]); /* cbLen (2 bytes) */ tile->crLen = *((UINT16*) &block[boffset + 13]); /* crLen (2 bytes) */ tile->tailLen = *((UINT16*) &block[boffset + 15]); /* tailLen (2 bytes) */ boffset += 17; if ((tile->blockLen - boffset) < tile->yLen) return -1028; tile->yData = &block[boffset]; boffset += tile->yLen; if ((tile->blockLen - boffset) < tile->cbLen) return -1029; tile->cbData = &block[boffset]; boffset += tile->cbLen; if ((tile->blockLen - boffset) < tile->crLen) return -1030; tile->crData = &block[boffset]; boffset += tile->crLen; if ((tile->blockLen - boffset) < tile->tailLen) return -1031; tile->tailData = &block[boffset]; boffset += tile->tailLen; tile->width = 64; tile->height = 64; tile->x = tile->xIdx * 64; tile->y = tile->yIdx * 64; tile->format = progressive->format; tile->stride = GetBytesPerPixel(tile->format) * tile->width; break; case PROGRESSIVE_WBT_TILE_UPGRADE: if ((blockLen - boffset) < 20) return -1032; xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ zIdx = (yIdx * surface->gridWidth) + xIdx; if (zIdx >= surface->gridSize) return -1; tiles[count] = tile = &(surface->tiles[zIdx]); tile->blockType = blockType; tile->blockLen = blockLen; tile->flags = 0; tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */ tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */ tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */ tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */ tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */ tile->quality = block[boffset + 7]; /* quality (1 byte) */ tile->ySrlLen = *((UINT16*) &block[boffset + 8]); /* ySrlLen (2 bytes) */ tile->yRawLen = *((UINT16*) &block[boffset + 10]); /* yRawLen (2 bytes) */ tile->cbSrlLen = *((UINT16*) &block[boffset + 12]); /* cbSrlLen (2 bytes) */ tile->cbRawLen = *((UINT16*) &block[boffset + 14]); /* cbRawLen (2 bytes) */ tile->crSrlLen = *((UINT16*) &block[boffset + 16]); /* crSrlLen (2 bytes) */ tile->crRawLen = *((UINT16*) &block[boffset + 18]); /* crRawLen (2 bytes) */ boffset += 20; if ((tile->blockLen - boffset) < tile->ySrlLen) return -1033; tile->ySrlData = &block[boffset]; boffset += tile->ySrlLen; if ((tile->blockLen - boffset) < tile->yRawLen) return -1034; tile->yRawData = &block[boffset]; boffset += tile->yRawLen; if ((tile->blockLen - boffset) < tile->cbSrlLen) return -1035; tile->cbSrlData = &block[boffset]; boffset += tile->cbSrlLen; if ((tile->blockLen - boffset) < tile->cbRawLen) return -1036; tile->cbRawData = &block[boffset]; boffset += tile->cbRawLen; if ((tile->blockLen - boffset) < tile->crSrlLen) return -1037; tile->crSrlData = &block[boffset]; boffset += tile->crSrlLen; if ((tile->blockLen - boffset) < tile->crRawLen) return -1038; tile->crRawData = &block[boffset]; boffset += tile->crRawLen; tile->width = 64; tile->height = 64; tile->x = tile->xIdx * 64; tile->y = tile->yIdx * 64; tile->format = progressive->format; tile->stride = GetBytesPerPixel(tile->format) * tile->width; break; default: return -1039; } if (boffset != blockLen) return -1040; offset += blockLen; count++; } if (offset != blocksLen) return -1041; if (count != region->numTiles) { WLog_Print(progressive->log, WLOG_WARN, "numTiles inconsistency: actual: %"PRIu32", expected: %"PRIu16"\n", count, region->numTiles); } for (index = 0; index < region->numTiles; index++) { tile = tiles[index]; switch (tile->blockType) { case PROGRESSIVE_WBT_TILE_SIMPLE: case PROGRESSIVE_WBT_TILE_FIRST: status = progressive_decompress_tile_first(progressive, tile); break; case PROGRESSIVE_WBT_TILE_UPGRADE: status = progressive_decompress_tile_upgrade(progressive, tile); break; } if (status < 0) return -1; } return (int) offset; } INT32 progressive_decompress(PROGRESSIVE_CONTEXT* progressive, const BYTE* pSrcData, UINT32 SrcSize, BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, REGION16* invalidRegion, UINT16 surfaceId) { INT32 rc = 1; INT32 status; const BYTE* block; const BYTE* blocks; UINT16 i, j; UINT16 index; UINT16 boxLeft; UINT16 boxTop; UINT16 boxRight; UINT16 boxBottom; UINT16 idxLeft; UINT16 idxTop; UINT16 idxRight; UINT16 idxBottom; UINT32 boffset; UINT16 blockType; UINT32 blockLen; UINT32 blocksLen; UINT32 count = 0; UINT32 offset = 0; RFX_RECT* rect = NULL; REGION16 clippingRects, updateRegion; PROGRESSIVE_SURFACE_CONTEXT* surface; PROGRESSIVE_BLOCK_REGION* region; surface = (PROGRESSIVE_SURFACE_CONTEXT*) progressive_get_surface_data( progressive, surfaceId); if (!surface) return -1001; blocks = pSrcData; blocksLen = SrcSize; region = &(progressive->region); progressive->format = DstFormat; while ((blocksLen - offset) >= 6) { PROGRESSIVE_BLOCK_SYNC sync; PROGRESSIVE_BLOCK_CONTEXT context; PROGRESSIVE_BLOCK_FRAME_BEGIN frameBegin; PROGRESSIVE_BLOCK_FRAME_END frameEnd; RFX_COMPONENT_CODEC_QUANT* quantVal; RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal; boffset = 0; block = &blocks[offset]; blockType = *((UINT16*) &block[boffset + 0]); /* blockType (2 bytes) */ blockLen = *((UINT32*) &block[boffset + 2]); /* blockLen (4 bytes) */ boffset += 6; if ((blocksLen - offset) < blockLen) return -1003; switch (blockType) { case PROGRESSIVE_WBT_SYNC: WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveSync"); sync.blockType = blockType; sync.blockLen = blockLen; if ((blockLen - boffset) != 6) return -1004; sync.magic = (UINT32) * ((UINT32*) &block[boffset + 0]); /* magic (4 bytes) */ sync.version = (UINT32) * ((UINT16*) &block[boffset + 4]); /* version (2 bytes) */ boffset += 6; if (sync.magic != 0xCACCACCA) return -1005; if (sync.version != 0x0100) return -1006; break; case PROGRESSIVE_WBT_FRAME_BEGIN: frameBegin.blockType = blockType; frameBegin.blockLen = blockLen; if ((blockLen - boffset) < 6) return -1007; frameBegin.frameIndex = (UINT32) * ((UINT32*) &block[boffset + 0]); /* frameIndex (4 bytes) */ frameBegin.regionCount = (UINT32) * ((UINT16*) &block[boffset + 4]); /* regionCount (2 bytes) */ boffset += 6; WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveFrameBegin: frameIndex: %"PRIu32" regionCount: %"PRIu16"", frameBegin.frameIndex, frameBegin.regionCount); /** * If the number of elements specified by the regionCount field is * larger than the actual number of elements in the regions field, * the decoder SHOULD ignore this inconsistency. */ break; case PROGRESSIVE_WBT_FRAME_END: WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveFrameEnd"); frameEnd.blockType = blockType; frameEnd.blockLen = blockLen; if ((blockLen - boffset) != 0) return -1008; break; case PROGRESSIVE_WBT_CONTEXT: context.blockType = blockType; context.blockLen = blockLen; if ((blockLen - boffset) != 4) return -1009; context.ctxId = block[boffset + 0]; /* ctxId (1 byte) */ context.tileSize = *((UINT16*) &block[boffset + 1]); /* tileSize (2 bytes) */ context.flags = block[boffset + 3]; /* flags (1 byte) */ boffset += 4; if (context.tileSize != 64) return -1010; WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveContext: flags: 0x%02"PRIX8"", context.flags); if (!(context.flags & RFX_SUBBAND_DIFFING)) WLog_Print(progressive->log, WLOG_WARN, "RFX_SUBBAND_DIFFING is not set"); break; case PROGRESSIVE_WBT_REGION: region->blockType = blockType; region->blockLen = blockLen; if ((blockLen - boffset) < 12) return -1011; region->tileSize = block[boffset + 0]; /* tileSize (1 byte) */ region->numRects = *((UINT16*) &block[boffset + 1]); /* numRects (2 bytes) */ region->numQuant = block[boffset + 3]; /* numQuant (1 byte) */ region->numProgQuant = block[boffset + 4]; /* numProgQuant (1 byte) */ region->flags = block[boffset + 5]; /* flags (1 byte) */ region->numTiles = *((UINT16*) &block[boffset + 6]); /* numTiles (2 bytes) */ region->tileDataSize = *((UINT32*) &block[boffset + 8]); /* tileDataSize (4 bytes) */ boffset += 12; if (region->tileSize != 64) return -1012; if (region->numRects < 1) return -1013; if (region->numQuant > 7) return -1014; if ((blockLen - boffset) < (region->numRects * 8)) return -1015; if (region->numRects > progressive->cRects) { progressive->rects = (RFX_RECT*) realloc(progressive->rects, region->numRects * sizeof(RFX_RECT)); progressive->cRects = region->numRects; } region->rects = progressive->rects; if (!region->rects) return -1016; for (index = 0; index < region->numRects; index++) { rect = &(region->rects[index]); rect->x = *((UINT16*) &block[boffset + 0]); rect->y = *((UINT16*) &block[boffset + 2]); rect->width = *((UINT16*) &block[boffset + 4]); rect->height = *((UINT16*) &block[boffset + 6]); boffset += 8; } if ((blockLen - boffset) < (region->numQuant * 5)) return -1017; if (region->numQuant > progressive->cQuant) { progressive->quantVals = (RFX_COMPONENT_CODEC_QUANT*) realloc( progressive->quantVals, region->numQuant * sizeof(RFX_COMPONENT_CODEC_QUANT)); progressive->cQuant = region->numQuant; } region->quantVals = progressive->quantVals; if (!region->quantVals) return -1018; for (index = 0; index < region->numQuant; index++) { quantVal = &(region->quantVals[index]); progressive_component_codec_quant_read(&block[boffset], quantVal); boffset += 5; if (!progressive_rfx_quant_lcmp_greater_equal(quantVal, 6)) return -1; if (!progressive_rfx_quant_lcmp_less_equal(quantVal, 15)) return -1; } if ((blockLen - boffset) < (region->numProgQuant * 16)) return -1019; if (region->numProgQuant > progressive->cProgQuant) { progressive->quantProgVals = (RFX_PROGRESSIVE_CODEC_QUANT*) realloc( progressive->quantProgVals, region->numProgQuant * sizeof(RFX_PROGRESSIVE_CODEC_QUANT)); progressive->cProgQuant = region->numProgQuant; } region->quantProgVals = progressive->quantProgVals; if (!region->quantProgVals) return -1020; for (index = 0; index < region->numProgQuant; index++) { quantProgVal = &(region->quantProgVals[index]); quantProgVal->quality = block[boffset + 0]; progressive_component_codec_quant_read(&block[boffset + 1], &(quantProgVal->yQuantValues)); progressive_component_codec_quant_read(&block[boffset + 6], &(quantProgVal->cbQuantValues)); progressive_component_codec_quant_read(&block[boffset + 11], &(quantProgVal->crQuantValues)); boffset += 16; } if ((blockLen - boffset) < region->tileDataSize) return -1021; if (progressive->cTiles < surface->gridSize) { progressive->tiles = (RFX_PROGRESSIVE_TILE**) realloc(progressive->tiles, surface->gridSize * sizeof(RFX_PROGRESSIVE_TILE*)); progressive->cTiles = surface->gridSize; } region->tiles = progressive->tiles; if (!region->tiles) return -1; WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveRegion: numRects: %"PRIu16" numTiles: %"PRIu16" tileDataSize: %"PRIu32" flags: 0x%02"PRIX8" numQuant: %"PRIu8" numProgQuant: %"PRIu8"", region->numRects, region->numTiles, region->tileDataSize, region->flags, region->numQuant, region->numProgQuant); if (!(region->flags & RFX_DWT_REDUCE_EXTRAPOLATE)) WLog_Print(progressive->log, WLOG_WARN, "RFX_DWT_REDUCE_EXTRAPOLATE is not set"); boxLeft = surface->gridWidth; boxTop = surface->gridHeight; boxRight = 0; boxBottom = 0; for (index = 0; index < region->numRects; index++) { rect = &(region->rects[index]); idxLeft = rect->x / 64; idxTop = rect->y / 64; idxRight = (rect->x + rect->width + 63) / 64; idxBottom = (rect->y + rect->height + 63) / 64; if (idxLeft < boxLeft) boxLeft = idxLeft; if (idxTop < boxTop) boxTop = idxTop; if (idxRight > boxRight) boxRight = idxRight; if (idxBottom > boxBottom) boxBottom = idxBottom; WLog_Print(progressive->log, WLOG_DEBUG, "rect[%"PRIu16"]: x: %"PRIu16" y: %"PRIu16" w: %"PRIu16" h: %"PRIu16"", index, rect->x, rect->y, rect->width, rect->height); } status = progressive_process_tiles(progressive, &block[boffset], region->tileDataSize, surface); if (status < 0) return status; region->numTiles = 0; for (index = 0; index < surface->gridSize; index++) { RFX_PROGRESSIVE_TILE* tile = &(surface->tiles[index]); if (!tile->data) continue; if ((tile->xIdx < boxLeft) || (tile->xIdx > boxRight)) continue; if ((tile->yIdx < boxTop) || (tile->yIdx > boxBottom)) continue; region->tiles[region->numTiles++] = tile; } boffset += (UINT32) status; break; default: return -1039; break; } if (boffset != blockLen) return -1040; offset += blockLen; count++; } if (offset != blocksLen) return -1041; region = &(progressive->region); region16_init(&clippingRects); for (i = 0; i < region->numRects; i++) { RECTANGLE_16 clippingRect; const RFX_RECT* rect = &(region->rects[i]); clippingRect.left = nXDst + rect->x; clippingRect.top = nYDst + rect->y; clippingRect.right = clippingRect.left + rect->width; clippingRect.bottom = clippingRect.top + rect->height; region16_union_rect(&clippingRects, &clippingRects, &clippingRect); } for (i = 0; i < region->numTiles; i++) { UINT32 nbUpdateRects; const RECTANGLE_16* updateRects; RECTANGLE_16 updateRect; RFX_PROGRESSIVE_TILE* tile = region->tiles[i]; updateRect.left = nXDst + tile->x; updateRect.top = nYDst + tile->y; updateRect.right = updateRect.left + 64; updateRect.bottom = updateRect.top + 64; region16_init(&updateRegion); region16_intersect_rect(&updateRegion, &clippingRects, &updateRect); updateRects = region16_rects(&updateRegion, &nbUpdateRects); for (j = 0; j < nbUpdateRects; j++) { const RECTANGLE_16* rect = &updateRects[j]; const UINT32 nXSrc = rect->left - (nXDst + tile->x); const UINT32 nYSrc = rect->top - (nYDst + tile->y); const UINT32 width = rect->right - rect->left; const UINT32 height = rect->bottom - rect->top; if (!freerdp_image_copy(pDstData, DstFormat, nDstStep, rect->left, rect->top, width, height, tile->data, tile->format, tile->stride, nXSrc, nYSrc, NULL, FREERDP_FLIP_NONE)) { rc = -42; break; } if (invalidRegion) region16_union_rect(invalidRegion, invalidRegion, rect); } region16_uninit(&updateRegion); } region16_uninit(&clippingRects); return rc; } int progressive_compress(PROGRESSIVE_CONTEXT* progressive, const BYTE* pSrcData, UINT32 SrcSize, BYTE** ppDstData, UINT32* pDstSize) { return -1; } BOOL progressive_context_reset(PROGRESSIVE_CONTEXT* progressive) { if (!progressive) return FALSE; return TRUE; } PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor) { PROGRESSIVE_CONTEXT* progressive; progressive = (PROGRESSIVE_CONTEXT*) calloc(1, sizeof(PROGRESSIVE_CONTEXT)); if (progressive) { progressive->Compressor = Compressor; progressive->bufferPool = BufferPool_New(TRUE, (8192 + 32) * 3, 16); progressive->cRects = 64; progressive->rects = (RFX_RECT*) calloc(progressive->cRects, sizeof(RFX_RECT)); if (!progressive->rects) goto cleanup; progressive->cTiles = 64; progressive->tiles = (RFX_PROGRESSIVE_TILE**) calloc(progressive->cTiles, sizeof(RFX_PROGRESSIVE_TILE*)); if (!progressive->tiles) goto cleanup; progressive->cQuant = 8; progressive->quantVals = (RFX_COMPONENT_CODEC_QUANT*) calloc( progressive->cQuant, sizeof(RFX_COMPONENT_CODEC_QUANT)); if (!progressive->quantVals) goto cleanup; progressive->cProgQuant = 8; progressive->quantProgVals = (RFX_PROGRESSIVE_CODEC_QUANT*) calloc( progressive->cProgQuant, sizeof(RFX_PROGRESSIVE_CODEC_QUANT)); if (!progressive->quantProgVals) goto cleanup; ZeroMemory(&(progressive->quantProgValFull), sizeof(RFX_PROGRESSIVE_CODEC_QUANT)); progressive->quantProgValFull.quality = 100; progressive->SurfaceContexts = HashTable_New(TRUE); progressive_context_reset(progressive); progressive->log = WLog_Get(TAG); } return progressive; cleanup: progressive_context_free(progressive); return NULL; } void progressive_context_free(PROGRESSIVE_CONTEXT* progressive) { int count; int index; ULONG_PTR* pKeys = NULL; PROGRESSIVE_SURFACE_CONTEXT* surface; if (!progressive) return; BufferPool_Free(progressive->bufferPool); free(progressive->rects); free(progressive->tiles); free(progressive->quantVals); free(progressive->quantProgVals); if (progressive->SurfaceContexts) { count = HashTable_GetKeys(progressive->SurfaceContexts, &pKeys); for (index = 0; index < count; index++) { surface = (PROGRESSIVE_SURFACE_CONTEXT*) HashTable_GetItemValue(progressive->SurfaceContexts, (void*) pKeys[index]); progressive_surface_context_free(surface); } free(pKeys); HashTable_Free(progressive->SurfaceContexts); } free(progressive); }