rfreeimage 0.1.0

data/vendor/FreeImage/Source/LibJXR/image/decode/segdec.c

@@ -0,0 +1,1205 @@
+//*@@@+++@@@@******************************************************************
+//
+// Copyright � Microsoft Corp.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// � Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// � Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//*@@@---@@@@******************************************************************
+
+#include "strcodec.h"
+#include "decode.h"
+
+#ifdef MEM_TRACE
+#define TRACE_MALLOC    1
+#define TRACE_NEW       0
+#define TRACE_HEAP      0
+#include "memtrace.h"
+#endif
+
+extern const int dctIndex[3][16];
+extern const int blkOffset[16];
+extern const int blkOffsetUV[4];
+static Int DecodeSignificantAbsLevel (struct CAdaptiveHuffman *pAHexpt, BitIOInfo* pIO);
+
+//#undef X86OPT_INLINE
+
+#ifdef X86OPT_INLINE
+#define _FORCEINLINE __forceinline
+#else // X86OPT_INLINE
+#define _FORCEINLINE
+#endif // X86OPT_INLINE
+
+//================================================================
+// Memory access functions
+//================================================================
+static U32 _FORCEINLINE _load4(void* pv)
+{
+#ifdef _BIG__ENDIAN_
+    return (*(U32*)pv);
+#else // _BIG__ENDIAN_
+#if defined(_M_IA64) || defined(_ARM_)
+    U32  v;
+    v = ((U16 *) pv)[0];
+    v |= ((U32)((U16 *) pv)[1]) << 16;
+    return _byteswap_ulong(v);
+#else // _M_IA64
+    return _byteswap_ulong(*(U32*)pv);
+#endif // _M_IA64
+#endif // _BIG__ENDIAN_
+}
+
+static _FORCEINLINE U32 _peekBit16(BitIOInfo* pIO, U32 cBits)
+{
+    PEEKBIT16(pIO, cBits);
+    // masking is not needed here because shift of unsigned int is implemented as a logical shift (SHR)!
+}
+
+#define LOAD16 _load4
+static _FORCEINLINE U32 _flushBit16(BitIOInfo* pIO, U32 cBits)
+{
+    FLUSHBIT16(pIO, cBits);
+}
+
+static _FORCEINLINE U32 _getBit16(BitIOInfo* pIO, U32 cBits)
+{
+    U32 uiRet = _peekBit16(pIO, cBits);
+    _flushBit16(pIO, cBits);
+
+    return uiRet;
+}
+
+#define SIGN_BIT(TypeOrValue) (((UInt) 1) << (8 * sizeof (TypeOrValue) - 1))
+/***********************************************************************************************************
+  Huffman decode (input is a fully built Huffman table)
+***********************************************************************************************************/
+Int getHuff(const short *pDecodeTable, BitIOInfo* pIO)
+{
+    Int iSymbol, iSymbolHuff;
+    iSymbol = pDecodeTable[peekBit16(pIO, HUFFMAN_DECODE_ROOT_BITS)];
+
+    flushBit16(pIO, iSymbol < 0 ? HUFFMAN_DECODE_ROOT_BITS : iSymbol & ((1 << HUFFMAN_DECODE_ROOT_BITS_LOG) - 1));
+	iSymbolHuff = iSymbol >> HUFFMAN_DECODE_ROOT_BITS_LOG;
+
+	if (iSymbolHuff < 0) {
+		iSymbolHuff = iSymbol;
+        while ((iSymbolHuff = pDecodeTable[iSymbolHuff + SIGN_BIT (pDecodeTable[0]) + getBit16(pIO, 1)]) < 0);
+	}
+    return (iSymbolHuff);
+}
+
+#if 1
+static _FORCEINLINE U32 _getBool16(BitIOInfo* pIO)
+{
+    U32 uiRet = pIO->uiAccumulator >> 31;//_peekBit16(pIO, 1);
+    //_flushBit16(pIO, 1);
+    pIO->cBitsUsed++;
+    if (pIO->cBitsUsed < 16) {
+        pIO->uiAccumulator <<= 1;
+    }
+    else {
+        pIO->pbCurrent = MASKPTR(pIO->pbCurrent + ((pIO->cBitsUsed >> 3)/* & 2*/), pIO->iMask);
+        pIO->cBitsUsed &= 16 - 1;
+        pIO->uiAccumulator = LOAD16(pIO->pbCurrent) << pIO->cBitsUsed;
+    }
+
+    return uiRet;
+}
+
+static _FORCEINLINE I32 _getSign(BitIOInfo* pIO)
+{
+    I32 uiRet = (int) pIO->uiAccumulator >> 31;//_peekBit16(pIO, 1);
+    //_flushBit16(pIO, 1);
+    pIO->cBitsUsed++;
+    if (pIO->cBitsUsed < 16) {
+        pIO->uiAccumulator <<= 1;
+    }
+    else {
+        pIO->pbCurrent = MASKPTR(pIO->pbCurrent + ((pIO->cBitsUsed >> 3)/* & 2*/), pIO->iMask);
+        pIO->cBitsUsed &= 16 - 1;
+        pIO->uiAccumulator = LOAD16(pIO->pbCurrent) << pIO->cBitsUsed;
+    }
+
+    return uiRet;
+}
+#else
+#define _getBool16(x)   _getBit16((x),1)
+#define _getSign(x)   (-_getBit16((x),1))
+#endif
+
+/** this function returns cBits if zero is read, or a signed value if first cBits are not all zero **/
+static _FORCEINLINE I32 _getBit16s(BitIOInfo* pIO, U32 cBits)
+{
+    I32 iRet = (I32)_peekBit16(pIO, cBits + 1);
+    iRet = ((iRet >> 1) ^ (-(iRet & 1))) + (iRet & 1);
+    _flushBit16(pIO, cBits + (iRet != 0));
+    return iRet;
+}
+
+/*************************************************************************
+    Huffman decoding with short tables
+*************************************************************************/
+static _FORCEINLINE Int _getHuffShort(const short *pDecodeTable, BitIOInfo* pIO)
+{
+    Int iSymbol = pDecodeTable[_peekBit16(pIO, HUFFMAN_DECODE_ROOT_BITS)];
+    assert(iSymbol >= 0);
+    // for some strange reason, inlining flushBit doesn't work well
+    flushBit16(pIO, iSymbol & ((1 << HUFFMAN_DECODE_ROOT_BITS_LOG) - 1));
+    return (iSymbol >> HUFFMAN_DECODE_ROOT_BITS_LOG);
+}
+/*************************************************************************
+    Adapt + Huffman init
+*************************************************************************/
+static Int AdaptDecFixed (CAdaptiveHuffman *pAH)
+{
+    AdaptDiscriminant (pAH);
+    return ICERR_OK;
+}
+
+/*************************************************************************
+    DecodeCBP
+*************************************************************************/
+static Void DecodeCBP(CWMImageStrCodec * pSC, CCodingContext *pContext)
+{
+    BitIOInfo* pIO = pContext->m_pIOAC;
+    const COLORFORMAT cf = pSC->m_param.cfColorFormat;
+    const Int iChannel = (cf == NCOMPONENT || cf == CMYK) ? (Int) pSC->m_param.cNumChannels : 1;
+    Int iCBPCY, iCBPCU , iCBPCV;
+    Int k, iBlock, i;
+    Int iNumCBP;
+    Bool bIsChroma;
+    CAdaptiveHuffman *pAHCBP = pContext->m_pAdaptHuffCBPCY;
+    CAdaptiveHuffman *pAHCBP1 = pContext->m_pAdaptHuffCBPCY1;
+    CAdaptiveHuffman *pAHex1 = pContext->m_pAHexpt[1];
+        
+    readIS_L1(pSC, pIO);
+
+    for (i = 0; i < iChannel; i++) {
+
+        iCBPCY = iCBPCU = iCBPCV = 0;
+        iNumCBP = _getHuffShort(pAHCBP1->m_hufDecTable, pIO);
+        pAHCBP1->m_iDiscriminant += pAHCBP1->m_pDelta[iNumCBP];
+
+        switch (iNumCBP) {
+            case 2:
+                iNumCBP = _getBit16(pIO, 2);
+                if (iNumCBP == 0)
+                    iNumCBP = 3;
+                else if (iNumCBP == 1)
+                    iNumCBP = 5;
+                else {
+                    static const Int aTab[] = { 6, 9, 10, 12 };
+                    iNumCBP = aTab[iNumCBP * 2 + _getBool16 (pIO) - 4];
+                }
+                break;
+            case 1:
+                iNumCBP = 1 << _getBit16(pIO, 2);
+                break;
+            case 3:
+                iNumCBP = 0xf ^ (1 << _getBit16(pIO, 2));
+                break;
+            case 4:
+                iNumCBP = 0xf;
+        }
+
+        for (iBlock = 0; iBlock < 4; iBlock++) {
+            if (iNumCBP & (1 << iBlock)) {
+                static const UInt gFLC0[] = { 0,2,1,2,2,0 };
+                static const UInt gOff0[] = { 0,4,2,8,12,1 };
+                static const UInt gOut0[] = { 0,15,3,12, 1,2,4,8, 5,6,9,10, 7,11,13,14 };
+                Int iNumBlockCBP = getHuff(pAHCBP->m_hufDecTable, pIO);
+                unsigned int val = (unsigned int) iNumBlockCBP + 1, iCode1;
+
+                pAHCBP->m_iDiscriminant += pAHCBP->m_pDelta[iNumBlockCBP];
+                iNumBlockCBP = 0;
+
+                if (val >= 6) { // chroma present
+                    if (_getBool16 (pIO)) {
+                        iNumBlockCBP = 0x10;
+                    }
+                    else if (_getBool16 (pIO)) {
+                        iNumBlockCBP = 0x20;
+                    }
+                    else {
+                        iNumBlockCBP = 0x30;
+                    }
+                    if (val == 9) {
+                        if (_getBool16 (pIO)) {
+                            // do nothing
+                        }
+                        else if (_getBool16 (pIO)) {
+                            val = 10;
+                        }
+                        else {
+                            val = 11;
+                        }
+                    }
+                    val -= 6;
+                }
+                iCode1 = gOff0[val];
+                if (gFLC0[val]) {
+                    iCode1 += _getBit16(pIO, gFLC0[val]);
+                }
+                iNumBlockCBP += gOut0[iCode1];
+
+                switch (cf) {
+                    case YUV_444:
+                        iCBPCY |= ((iNumBlockCBP & 0xf) << (iBlock * 4));
+                        for (k = 0; k < 2; k++) {
+                            bIsChroma = ((iNumBlockCBP>>(k+4)) & 0x01);
+                            if (bIsChroma) { // U is present in block
+                                Int iCode = _getHuffShort(pAHex1->m_hufDecTable, pIO);
+                                switch (iCode) { 
+                            case 1:
+                                iCode = _getBit16(pIO, 2);
+                                if (iCode == 0)
+                                    iCode = 3;
+                                else if (iCode == 1)
+                                    iCode = 5;
+                                else {
+                                    static const Int aTab[] = { 6, 9, 10, 12 };
+                                    iCode = aTab[iCode * 2 + _getBool16 (pIO) - 4];
+                                }
+                                break;
+                            case 0:
+                                iCode = 1 << _getBit16(pIO, 2);
+                                break;
+                            case 2:
+                                iCode = 0xf ^ (1 << _getBit16(pIO, 2));
+                                break;
+                            case 3:
+                                iCode = 0xf;
+                                }
+                                if (k == 0)
+                                    iCBPCU |= (iCode << (iBlock * 4));
+                                else 
+                                    iCBPCV |= (iCode << (iBlock * 4));
+                            }
+                        }
+                        break;
+
+                    case YUV_420:
+                        iCBPCY |= ((iNumBlockCBP & 0xf) << (iBlock * 4));
+                        iCBPCU |= ((iNumBlockCBP >> 4) & 0x1) << (iBlock);
+                        iCBPCV |= ((iNumBlockCBP >> 5) & 0x1) << (iBlock);
+                        break;
+
+                    case YUV_422:
+                        iCBPCY |= ((iNumBlockCBP & 0xf) << (iBlock * 4));
+                        for (k = 0; k < 2; k ++) {
+                            Int iCode = 5;
+                            const Int iShift[4] = {0, 1, 4, 5};
+                            if((iNumBlockCBP >> (k + 4)) & 0x01) {
+                                if(_getBool16(pIO)) {
+                                    iCode = 1;
+                                }
+                                else if(_getBool16(pIO)){
+                                    iCode = 4;
+                                }
+                                iCode <<= iShift[iBlock];
+                                if(k == 0) iCBPCU |= iCode;
+                                else iCBPCV |= iCode;
+                            }
+                        }
+                        break;
+
+                    default:
+                        iCBPCY |= (iNumBlockCBP << (iBlock * 4));
+                }
+            }
+        }
+
+        pSC->MBInfo.iDiffCBP[i] = iCBPCY;
+        if (cf == YUV_420 || cf == YUV_444 || cf == YUV_422) {
+            pSC->MBInfo.iDiffCBP[1] = iCBPCU;
+            pSC->MBInfo.iDiffCBP[2] = iCBPCV;
+        }
+    }
+}
+
+/*************************************************************************
+    Experimental code -- decodeBlock
+    SR = <0 1 2> == <last, nonsignificant, significant run>
+    alphabet 12:
+        pAHexpt[0] == <SR', SL, SR | first symbol>
+    alphabet 6:
+        pAHexpt[1] == <SR', SL | continuous>
+        pAHexpt[2] == <SR', SL | continuous>
+    alphabet 4:
+        pAHexpt[3] == <SR', SL | 2 free slots> (SR may be last or insignificant only)
+    alphabet f(run) (this can be extended to 6 contexts - SL and SR')
+        pAHexpt[4] == <run | continuous>
+    alphabet f(lev) (this can be extended to 9 contexts)
+        pAHexpt[5-6] == <lev | continuous> first symbol
+        pAHexpt[7-8] == <lev | continuous> condition on SRn no use
+*************************************************************************/
+
+Int _FORCEINLINE DecodeSignificantRun (Int iMaxRun, struct CAdaptiveHuffman *pAHexpt, BitIOInfo* pIO)
+{
+    Int iIndex;
+    static const Int aRemap[] = {1,2,3,5,7,   1,2,3,5,7,   /*1,2,3,4,6,  */1,2,3,4,5 };
+    Int iBin = gSignificantRunBin[iMaxRun];
+    Int iRun = 0, iFLC = 0;
+
+    if (iMaxRun < 5) {
+        if (iMaxRun == 1) {
+            return 1;
+        }
+        else if (_getBool16 (pIO)) {
+            return 1;
+        }
+        else if (iMaxRun == 2 || _getBool16 (pIO)) {
+            return 2;
+        }
+        else if (iMaxRun == 3 || _getBool16 (pIO)) {
+            return 3;
+        }
+        return 4;
+    }
+    iIndex = _getHuffShort (pAHexpt->m_hufDecTable, pIO);
+    iIndex += iBin * 5;
+    iRun = aRemap[iIndex];
+    iFLC = gSignificantRunFixedLength[iIndex];
+    if (iFLC) {
+        iRun += _getBit16 (pIO, iFLC);
+    }
+    return iRun;
+}
+
+#ifndef X86OPT_INLINE
+static Void DecodeFirstIndex (Int *pIndex, struct CAdaptiveHuffman *pAHexpt, 
+                      BitIOInfo* pIO)
+#else
+static __forceinline Void DecodeFirstIndex (Int *pIndex, struct CAdaptiveHuffman *pAHexpt, 
+                      BitIOInfo* pIO)
+#endif
+{
+    Int iIndex;
+    iIndex = getHuff (pAHexpt->m_hufDecTable, pIO);
+    pAHexpt->m_iDiscriminant += pAHexpt->m_pDelta[iIndex];
+    pAHexpt->m_iDiscriminant1 += pAHexpt->m_pDelta1[iIndex];
+    *pIndex = iIndex;
+}
+
+#ifndef X86OPT_INLINE
+static Void DecodeIndex (Int *pIndex, Int iLoc, struct CAdaptiveHuffman *pAHexpt, 
+                 BitIOInfo* pIO)
+#else
+static __forceinline Void DecodeIndex (Int *pIndex, Int iLoc,
+                                       struct CAdaptiveHuffman *pAHexpt, BitIOInfo* pIO)
+#endif
+{
+    Int iIndex;
+    if (iLoc < 15) {
+        iIndex = _getHuffShort (pAHexpt->m_hufDecTable, pIO);
+        pAHexpt->m_iDiscriminant += pAHexpt->m_pDelta[iIndex];
+        pAHexpt->m_iDiscriminant1 += pAHexpt->m_pDelta1[iIndex];
+        *pIndex = iIndex;
+    }
+    else if (iLoc == 15) {
+        if (_getBool16 (pIO) == 0) {
+            iIndex = 0;
+        }
+        else if (_getBool16 (pIO) == 0) {
+            iIndex = 2;
+        }
+        else {
+            iIndex = 1 + 2 * _getBool16 (pIO);
+        }
+        *pIndex = iIndex;
+    }
+    else { //if (iLoc == 16) { /* deterministic */
+        Int iSL = _getBit16 (pIO, 1/* + 1*/);
+        *pIndex = iSL;// >> 1;
+    }
+}
+
+static _FORCEINLINE Int DecodeBlock (Bool bChroma, Int *aLocalCoef, struct CAdaptiveHuffman **pAHexpt,
+                        const Int iContextOffset, BitIOInfo* pIO, Int iLocation)
+{
+    Int iSR, iSRn, iIndex, iNumNonzero = 1, iCont, iSign;
+    struct CAdaptiveHuffman **pAH1 = pAHexpt + iContextOffset + bChroma * 3;
+
+    /** first symbol **/
+    DecodeFirstIndex (&iIndex, /*&iSign, */pAH1[0], pIO);
+    iSR = (iIndex & 1);
+    iSRn = iIndex >> 2;
+
+    iCont = iSR & iSRn;
+    iSign = _getSign(pIO);
+
+    if (iIndex & 2 /* iSL */) {
+        aLocalCoef[1] = (DecodeSignificantAbsLevel (pAHexpt[6 + iContextOffset + iCont], pIO) ^ iSign) - iSign;
+    }
+    else {
+        aLocalCoef[1] = (1 | iSign); // 0 -> 1; -1 -> -1
+    }
+    aLocalCoef[0] = 0;
+    if (iSR == 0) {
+        aLocalCoef[0] = DecodeSignificantRun (15 - iLocation, pAHexpt[0], pIO);
+    }
+    iLocation += aLocalCoef[0] + 1;
+
+    while (iSRn != 0) {
+        iSR = iSRn & 1;
+        aLocalCoef[iNumNonzero * 2] = 0;
+        if (iSR == 0) {
+            aLocalCoef[iNumNonzero * 2] = DecodeSignificantRun (15 - iLocation, pAHexpt[0], pIO);
+        }
+        iLocation += aLocalCoef[iNumNonzero * 2] + 1;
+        DecodeIndex (&iIndex, /*&iSign, */iLocation, pAH1[iCont + 1], pIO);
+        iSRn = iIndex >> 1;
+
+        assert (iSRn >= 0 && iSRn < 3);
+        iCont &= iSRn;  /** huge difference! **/
+        iSign = _getSign(pIO);
+
+        if (iIndex & 1 /* iSL */) {
+            aLocalCoef[iNumNonzero * 2 + 1] = 
+                (DecodeSignificantAbsLevel (pAHexpt[6 + iContextOffset + iCont], pIO) ^ iSign) - iSign;
+        }
+        else {
+            aLocalCoef[iNumNonzero * 2 + 1] = (1 | iSign); // 0 -> 1; -1 -> -1 (was 1 + (iSign * 2))
+        }
+        iNumNonzero++;
+    }
+    return iNumNonzero;
+}
+
+/*************************************************************************
+    DecodeBlockHighpass : 
+*************************************************************************/
+static _FORCEINLINE Int DecodeBlockHighpass (const Bool bChroma, struct CAdaptiveHuffman **pAHexpt,
+                       BitIOInfo* pIO, const Int iQP, Int *pCoef, CAdaptiveScan *pScan)
+{
+    const Int iContextOffset = CTDC + CONTEXTX;
+    UInt  iLoc = 1;
+    Int iSR, iSRn, iIndex, iNumNonzero = 1, iCont, iSign, iLevel;
+    struct CAdaptiveHuffman **pAH1 = pAHexpt + iContextOffset + bChroma * 3;
+    const CAdaptiveScan *pConstScan = (const CAdaptiveScan *) pScan;
+
+    /** first symbol **/
+    DecodeFirstIndex (&iIndex, /*&iSign, */pAH1[0], pIO);
+    iSR = (iIndex & 1);
+    iSRn = iIndex >> 2;
+
+    iCont = iSR & iSRn;
+    iSign = _getSign(pIO);
+
+    iLevel = (iQP ^ iSign) - iSign;
+    if (iIndex & 2 /* iSL */) {
+        iLevel *= DecodeSignificantAbsLevel (pAHexpt[6 + iContextOffset + iCont], pIO);// ^ iSign) - iSign;
+    }
+    //else {
+    //    iLevel = (1 | iSign); // 0 -> 1; -1 -> -1
+    //}
+    if (iSR == 0) {
+       iLoc += DecodeSignificantRun (15 - iLoc, pAHexpt[0], pIO);
+    }
+    iLoc &= 0xf;
+	pCoef[pConstScan[iLoc].uScan] = (PixelI) iLevel;//(PixelI)(iQP * iLevel);
+    pScan[iLoc].uTotal++;
+	if (iLoc && pScan[iLoc].uTotal > pScan[iLoc - 1].uTotal) {
+		CAdaptiveScan cTemp = pScan[iLoc];
+		pScan[iLoc] = pScan[iLoc - 1];
+		pScan[iLoc - 1] = cTemp;
+    }
+    iLoc = (iLoc + 1) & 0xf;
+    //iLoc++;
+
+    while (iSRn != 0) {
+        iSR = iSRn & 1;
+        if (iSR == 0) {
+            iLoc += DecodeSignificantRun (15 - iLoc, pAHexpt[0], pIO);
+            if (iLoc >= 16)
+                return 16;
+        }
+        DecodeIndex (&iIndex, /*&iSign, */iLoc + 1, pAH1[iCont + 1], pIO);
+        iSRn = iIndex >> 1;
+
+        assert (iSRn >= 0 && iSRn < 3);
+        iCont &= iSRn;  /** huge difference! **/
+        iSign = _getSign(pIO);
+
+        iLevel = (iQP ^ iSign) - iSign;
+        if (iIndex & 1 /* iSL */) {
+            iLevel *= DecodeSignificantAbsLevel (pAHexpt[6 + iContextOffset + iCont], pIO);// ^ iSign) - iSign;
+            //iLevel = (DecodeSignificantAbsLevel (pAHexpt[6 + iContextOffset + iCont], pIO) ^ iSign) - iSign;
+        }
+        //else {
+        //    iLevel = (1 | iSign); // 0 -> 1; -1 -> -1 (was 1 + (iSign * 2))
+        //}
+       
+	    pCoef[pConstScan[iLoc].uScan] = (PixelI) iLevel;//(PixelI)(iQP * iLevel);
+        pScan[iLoc].uTotal++;
+	    if (iLoc && pScan[iLoc].uTotal > pScan[iLoc - 1].uTotal) {
+		    CAdaptiveScan cTemp = pScan[iLoc];
+		    pScan[iLoc] = pScan[iLoc - 1];
+		    pScan[iLoc - 1] = cTemp;
+        }
+
+        iLoc = (iLoc + 1) & 0xf;
+        iNumNonzero++;
+    }
+    return iNumNonzero;
+}
+
+/*************************************************************************
+    DecodeBlockAdaptive
+*************************************************************************/
+static _FORCEINLINE Int DecodeBlockAdaptive (Bool bNoSkip, Bool bChroma, CAdaptiveHuffman **pAdHuff,
+                                BitIOInfo *pIO, BitIOInfo *pIOFL,
+                                PixelI *pCoeffs, CAdaptiveScan *pScan,
+                                const Int iModelBits, const Int iTrim, const Int iQP,
+                                const Int *pOrder, const Bool bSkipFlexbits)
+{
+    // const Int iLocation = 1;
+    // const Int iContextOffset = CTDC + CONTEXTX;
+    Int kk, iNumNonzero = 0, iFlex = iModelBits - iTrim;
+
+    if (iFlex < 0 || bSkipFlexbits)
+        iFlex = 0;
+
+    if (bNoSkip) {
+        const Int iQP1 = (iQP << iModelBits);
+        iNumNonzero = DecodeBlockHighpass (bChroma, pAdHuff, pIO, iQP1, pCoeffs, pScan);
+    }
+    if (iFlex) {
+        UInt k;
+        if (iQP + iTrim == 1) { // only iTrim = 0, iQP = 1 is legal
+            assert (iTrim == 0);
+            assert (iQP == 1);
+
+            for (k = 1; k < 16; k++) {
+                PixelI *pk = pCoeffs + pOrder[k];
+                if (*pk < 0) {
+                    Int fine = _getBit16(pIOFL, iFlex);
+                    *pk -= (PixelI)(fine);
+                }
+                else if (*pk > 0) {
+                    Int fine = _getBit16(pIOFL, iFlex);
+                    *pk += (PixelI)(fine);
+                }
+                else {
+                    *pk = (PixelI)(_getBit16s(pIOFL, iFlex));
+                }
+            }
+        }
+        else {
+            const Int iQP1 = iQP << iTrim;
+            for (k = 1; k < 16; k++) {
+                kk = pCoeffs[pOrder[k]];
+                if (kk < 0) {
+                    Int fine = _getBit16(pIOFL, iFlex);
+                    pCoeffs[pOrder[k]] -= (PixelI)(iQP1 * fine);
+                }
+                else if (kk > 0) {
+                    Int fine = _getBit16(pIOFL, iFlex);
+                    pCoeffs[pOrder[k]] += (PixelI)(iQP1 * fine);
+                }
+                else {
+                    pCoeffs[pOrder[k]] = (PixelI)(iQP1 * _getBit16s(pIOFL, iFlex));
+                }
+            }
+        }
+    }
+
+    return iNumNonzero;
+}
+
+
+/*************************************************************************
+    GetCoeffs
+*************************************************************************/
+static _FORCEINLINE Int DecodeCoeffs (CWMImageStrCodec * pSC, CCodingContext *pContext,
+                         Int iMBX, Int iMBY,
+                         BitIOInfo* pIO, BitIOInfo *pIOFL)
+{
+    CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
+    const COLORFORMAT cf = pSC->m_param.cfColorFormat;
+    const Int iChannels = (Int) pSC->m_param.cNumChannels;
+    const Int iPlanes = (cf == YUV_420 || cf == YUV_422) ? 1 : iChannels;
+    Int  iQP;
+    CAdaptiveScan *pScan;
+    PixelI  *pCoeffs;
+    Int i, iBlock, iSubblock, iNBlocks = 4;
+    Int iModelBits = pContext->m_aModelAC.m_iFlcBits[0];
+    Int aLaplacianMean[2] = { 0, 0}, *pLM = aLaplacianMean + 0;
+    const Int *pOrder = dctIndex[0];
+    const Int iOrient = pSC->MBInfo.iOrientation;
+    Bool bChroma = FALSE;
+
+    Int iCBPCU = pSC->MBInfo.iCBP[1];
+    Int iCBPCV = pSC->MBInfo.iCBP[2];
+    Int iCBPCY = pSC->MBInfo.iCBP[0];
+
+    UNREFERENCED_PARAMETER( iMBX );
+    UNREFERENCED_PARAMETER( iMBY );
+
+    /** set scan arrays and other MB level constants **/
+    if (iOrient == 1) {
+        pScan = pContext->m_aScanVert;
+    }
+    else {
+        pScan = pContext->m_aScanHoriz;
+    }
+
+    if (cf == YUV_420) {
+        iNBlocks = 6;
+        iCBPCY += (iCBPCU << 16) + (iCBPCV << 20);
+    }
+    else if (cf == YUV_422) {
+        iNBlocks = 8;
+        iCBPCY += (iCBPCU << 16) + (iCBPCV << 24);
+    }
+
+    for (i = 0; i < iPlanes; i++) {
+        Int iIndex = 0, iNumNonZero;
+
+        if(pSC->WMISCP.sbSubband != SB_NO_FLEXBITS)
+            readIS_L1(pSC, pIOFL);
+
+        for (iBlock = 0; iBlock < iNBlocks; iBlock++) {
+
+            readIS_L2(pSC, pIO);
+            if (pIO != pIOFL)
+                readIS_L2(pSC, pIOFL);
+
+            iQP = (pSC->m_param.bTranscode ? 1 : pTile->pQuantizerHP[iPlanes > 1 ? i : (iBlock > 3 ? (cf == YUV_420 ? iBlock - 3 : iBlock / 2 - 1) : 0)][pSC->MBInfo.iQIndexHP].iQP);
+
+            for (iSubblock = 0; iSubblock < 4; iSubblock++, iIndex++, iCBPCY >>= 1) {
+                pCoeffs = pSC->p1MBbuffer[i] + blkOffset[iIndex & 0xf];
+
+                //if (iBlock < 4) {//(cf == YUV_444) {
+                    //bBlockNoSkip = ((iTempCBPC & (1 << iIndex1)) != 0);
+                    //pCoeffs = pSC->p1MBbuffer[iBlock >> 2] + blkOffset[iIndex & 0xf];
+                //}
+                //else {
+                if (iBlock >= 4) {
+                    if(cf == YUV_420) {
+                        pCoeffs = pSC->p1MBbuffer[iBlock - 3] + blkOffsetUV[iSubblock];
+                    }
+                    else { // YUV_422
+                        pCoeffs = pSC->p1MBbuffer[1 + (1 & (iBlock >> 1))] + ((iBlock & 1) * 32) + blkOffsetUV_422[iSubblock];
+                    }
+                }
+
+                /** read AC values **/
+                assert (pSC->m_Dparam->bSkipFlexbits == 0 || pSC->WMISCP.bfBitstreamFormat == FREQUENCY || pSC->WMISCP.sbSubband == SB_NO_FLEXBITS);
+                iNumNonZero = DecodeBlockAdaptive ((iCBPCY & 1), bChroma, pContext->m_pAHexpt,
+                    pIO, pIOFL, pCoeffs, pScan, iModelBits, pContext->m_iTrimFlexBits,
+                    iQP, pOrder, pSC->m_Dparam->bSkipFlexbits);
+                if(iNumNonZero > 16) // something is wrong!
+                    return ICERR_ERROR;
+                // shouldn't this be > 15?
+                (*pLM) += iNumNonZero;
+            }
+            if (iBlock == 3) {
+                iModelBits = pContext->m_aModelAC.m_iFlcBits[1];
+                pLM = aLaplacianMean + 1;
+                bChroma = TRUE;
+            }
+        }
+
+        iCBPCY = pSC->MBInfo.iCBP[(i + 1) & 0xf];
+        assert (MAX_CHANNELS == 16);
+    }
+
+    /** update model at end of MB **/
+    UpdateModelMB (cf, iChannels, aLaplacianMean, &(pContext->m_aModelAC));
+    return ICERR_OK;
+}
+
+/*************************************************************************
+    DecodeSignificantAbsLevel
+*************************************************************************/
+#ifndef X86OPT_INLINE
+static Int DecodeSignificantAbsLevel (struct CAdaptiveHuffman *pAHexpt, BitIOInfo* pIO)
+#else
+static __forceinline Int DecodeSignificantAbsLevel (struct CAdaptiveHuffman *pAHexpt, BitIOInfo* pIO)
+#endif
+{
+    UInt iIndex;
+    Int iFixed, iLevel;
+    static const Int aRemap[] = { 2, 3, 4, 6, 10, 14 };
+    static const Int aFixedLength[] = { 0, 0, 1, 2, 2, 2 };
+
+    iIndex = (UInt)getHuff (pAHexpt->m_hufDecTable, pIO);
+    assert(iIndex <= 6);
+    pAHexpt->m_iDiscriminant += pAHexpt->m_pDelta[iIndex];
+    if (iIndex < 2) {
+        iLevel = iIndex + 2; // = aRemap[iIndex]
+    }
+    else if (iIndex < 6) {
+        iFixed = aFixedLength[iIndex];
+        iLevel = aRemap[iIndex] + _getBit16 (pIO, iFixed);
+    }
+    else{
+        iFixed = _getBit16 (pIO, 4) + 4;
+        if (iFixed == 19) {
+            iFixed += _getBit16 (pIO, 2);
+            if (iFixed == 22) {
+                iFixed += _getBit16 (pIO, 3);
+            }
+        }
+        iLevel = 2 + (1 << iFixed);
+        iIndex = getBit32 (pIO, iFixed);
+        iLevel += iIndex;
+    }
+    return iLevel;
+}
+
+U8 decodeQPIndex(BitIOInfo* pIO,U8 cBits)
+{
+    if(_getBit16(pIO, 1) == 0)
+        return 0;
+    return (U8)(_getBit16(pIO, cBits) + 1);
+}
+
+/*************************************************************************
+    DecodeSecondStageCoeff
+*************************************************************************/
+Int DecodeMacroblockLowpass (CWMImageStrCodec * pSC, CCodingContext *pContext,
+        Int iMBX, Int iMBYdummy)
+{
+    const COLORFORMAT cf = pSC->m_param.cfColorFormat;
+    const Int iChannels = (Int) pSC->m_param.cNumChannels;
+    const Int iFullPlanes = (cf == YUV_420 || cf == YUV_422) ? 2 : iChannels;
+    Int k;
+	CAdaptiveScan *pScan = pContext->m_aScanLowpass;
+    BitIOInfo* pIO = pContext->m_pIOLP;
+    Int iModelBits = pContext->m_aModelLP.m_iFlcBits[0];
+    Int aRLCoeffs[32], iNumNonzero = 0, iIndex = 0;
+    Int aLaplacianMean[2] = { 0, 0}, *pLM = aLaplacianMean;
+    Int iChannel, iCBP = 0;
+#ifndef ARMOPT_BITIO    // ARM opt always uses 32-bit version of getBits
+    U32 (*getBits)(BitIOInfo* pIO, U32 cBits) = _getBit16;
+#endif
+    CWMIMBInfo * pMBInfo = &pSC->MBInfo;
+    I32 *aDC[MAX_CHANNELS];
+
+    UNREFERENCED_PARAMETER( iMBX );
+    UNREFERENCED_PARAMETER( iMBYdummy );
+
+    readIS_L1(pSC, pIO);
+    if((pSC->WMISCP.bfBitstreamFormat != SPATIAL) && (pSC->pTile[pSC->cTileColumn].cBitsLP > 0))  // MB-based LP QP index
+        pMBInfo->iQIndexLP = decodeQPIndex(pIO, pSC->pTile[pSC->cTileColumn].cBitsLP);
+    
+    // set arrays
+    for (k = 0; k < (Int) pSC->m_param.cNumChannels; k++) {
+        aDC[k & 15] = pMBInfo->iBlockDC[k];
+    }
+
+    /** reset adaptive scan totals **/
+    if (pSC->m_bResetRGITotals) {
+        int iScale = 2;
+        int iWeight = iScale * 16;
+		pScan[0].uTotal = MAXTOTAL;
+        for (k = 1; k < 16; k++) {
+			pScan[k].uTotal = iWeight;
+            iWeight -= iScale;
+        }
+    }
+
+    /** in raw mode, this can take 6% of the bits in the extreme low rate case!!! **/
+    if (cf == YUV_420 || cf == YUV_422 || cf == YUV_444) {
+        int iCountM = pContext->m_iCBPCountMax, iCountZ = pContext->m_iCBPCountZero;
+        int iMax = iFullPlanes * 4 - 5; /* actually (1 << iNChannels) - 1 **/
+        if (iCountZ <= 0 || iCountM < 0) {
+            iCBP = 0;
+            if (_getBool16 (pIO)) {
+                iCBP = 1;
+                k = _getBit16 (pIO, iFullPlanes - 1);
+                if (k) {
+                    iCBP = k * 2 + _getBit16(pIO, 1);
+                }
+            }
+            if (iCountM < iCountZ)
+                iCBP = iMax - iCBP;
+        }
+        else {
+            iCBP = _getBit16(pIO, iFullPlanes);
+        }
+
+        iCountM += 1 - 4 * (iCBP == iMax);//(b + c - 2*a);
+        iCountZ += 1 - 4 * (iCBP == 0);//(a + b - 2*c);
+        if (iCountM < -8)
+            iCountM = -8;
+        else if (iCountM > 7)
+            iCountM = 7;
+        pContext->m_iCBPCountMax = iCountM;
+
+        if (iCountZ < -8)
+            iCountZ = -8;
+        else if (iCountZ > 7)
+            iCountZ = 7;
+        pContext->m_iCBPCountZero = iCountZ;
+    }
+    else { /** 1 or N channel **/
+        for (iChannel = 0; iChannel < iChannels; iChannel++)
+            iCBP |= (getBits (pIO, 1) << iChannel);
+    }
+
+#ifndef ARMOPT_BITIO    // ARM opt always uses 32-bit version of getBits
+    if (pContext->m_aModelLP.m_iFlcBits[0] > 14 || pContext->m_aModelLP.m_iFlcBits[1] > 14) {
+        getBits = getBit32;
+    }
+#endif
+
+    for (iChannel = 0; iChannel < iFullPlanes; iChannel++) {
+        PixelI *pCoeffs = aDC[iChannel];
+
+        if (iCBP & 1) {
+            iNumNonzero = DecodeBlock (iChannel > 0, aRLCoeffs, pContext->m_pAHexpt,
+                CTDC, pIO, 1 + 9 * ((cf == YUV_420) && (iChannel == 1))
+                + ((cf == YUV_422) && (iChannel == 1)));
+
+            if ((cf == YUV_420 || cf == YUV_422) && iChannel) {
+                Int aTemp[16]; //14 required, 16 for security
+                static const Int aRemap[] = { 4,  1,2,3,  5,6,7 };
+                const Int *pRemap = aRemap + (cf == YUV_420);
+                const Int iCount = (cf == YUV_420) ? 6 : 14;
+
+                (*pLM) += iNumNonzero;
+                iIndex = 0;
+                memset (aTemp, 0, sizeof(aTemp));
+
+                for (k = 0; k < iNumNonzero; k++) {
+                    iIndex += aRLCoeffs[k * 2];
+                    aTemp[iIndex & 0xf] = aRLCoeffs[k * 2 + 1];
+                    iIndex++;
+                }
+
+                for (k = 0; k < iCount; k++) {
+                    aDC[(k & 1) + 1][pRemap[k >> 1]] = aTemp[k];
+                }
+            }
+            else {
+                (*pLM) += iNumNonzero;
+                iIndex = 1;
+
+                for (k = 0; k < iNumNonzero; k++) {
+                    iIndex += aRLCoeffs[k * 2];
+					pCoeffs[pScan[iIndex].uScan] = aRLCoeffs[k * 2 + 1];
+					pScan[iIndex].uTotal++;
+					if (pScan[iIndex].uTotal > pScan[iIndex - 1].uTotal) {
+						CAdaptiveScan cTemp = pScan[iIndex];
+						pScan[iIndex] = pScan[iIndex - 1];
+						pScan[iIndex - 1] = cTemp;
+					}
+                    iIndex++;
+                }
+            }
+        }
+
+        if (iModelBits) {
+            if ((cf == YUV_420 || cf == YUV_422) && iChannel) {
+                for (k = 1; k < (cf == YUV_420 ? 4 : 8); k++) {
+                    if (aDC[1][k] > 0) {
+                        aDC[1][k] <<= iModelBits;
+                        aDC[1][k] += getBits (pIO, iModelBits);
+                    }
+                    else if (aDC[1][k] < 0) {
+                        aDC[1][k] <<= iModelBits;
+                        aDC[1][k] -= getBits (pIO, iModelBits);
+                    }
+                    else {
+                        aDC[1][k] = getBits (pIO, iModelBits);
+                        if (aDC[1][k] && _getBool16 (pIO))
+                            aDC[1][k] = -aDC[1][k];
+                    }
+
+                    if (aDC[2][k] > 0) {
+                        aDC[2][k] <<= iModelBits;
+                        aDC[2][k] += getBits (pIO, iModelBits);
+                    }
+                    else if (aDC[2][k] < 0) {
+                        aDC[2][k] <<= iModelBits;
+                        aDC[2][k] -= getBits (pIO, iModelBits);
+                    }
+                    else {
+                        aDC[2][k] = getBits (pIO, iModelBits);
+                        if (aDC[2][k] && _getBool16 (pIO))
+                            aDC[2][k] = -aDC[2][k];
+                    }
+                }
+            }
+            else {
+#ifdef WIN32
+                const Int iMask = (1 << iModelBits) - 1;
+#endif // WIN32
+                for (k = 1; k < 16; k++) {
+#ifdef WIN32
+                    if (pCoeffs[k]) {
+                        Int r1 = _rotl(pCoeffs[k], iModelBits);
+                        pCoeffs[k] = (r1 ^ getBits(pIO, iModelBits)) - (r1 & iMask);
+                    }
+#else // WIN32
+                    if (pCoeffs[k] > 0) {
+                        pCoeffs[k] <<= iModelBits;
+                        pCoeffs[k] += getBits (pIO, iModelBits);
+                    }
+                    else if (pCoeffs[k] < 0) {
+                        pCoeffs[k] <<= iModelBits;
+                        pCoeffs[k] -= getBits (pIO, iModelBits);
+                    }
+#endif // WIN32
+                    else {
+                        //pCoeffs[k] = getBits (pIO, iModelBits);
+                        //if (pCoeffs[k] && _getBool16 (pIO))
+                        //    pCoeffs[k] = -pCoeffs[k];
+                        Int r1 = _peekBit16 (pIO, iModelBits + 1);
+                        pCoeffs[k] = ((r1 >> 1) ^ (-(r1 & 1))) + (r1 & 1);
+                        _flushBit16 (pIO, iModelBits + (pCoeffs[k] != 0));
+                    }
+                }
+            }
+        }
+        pLM = aLaplacianMean + 1;
+        iModelBits = pContext->m_aModelLP.m_iFlcBits[1];
+
+        iCBP >>= 1;
+    }
+
+    UpdateModelMB (cf, iChannels, aLaplacianMean, &(pContext->m_aModelLP));
+
+    if (pSC->m_bResetContext) {
+        AdaptLowpassDec(pContext);
+    }
+
+    return ICERR_OK;
+}
+
+/*************************************************************************
+    8 bit YUV 420 macroblock decode function with 4x4 transform
+    Index order is as follows:
+    Y:              U:      V:
+     0  1  4  5     16 17   20 21
+     2  3  6  7     18 19   22 23
+     8  9 12 13
+    10 11 14 15
+
+    DCAC coefficients stored for 4x4 - offsets (x == no storage)
+    Y:
+    x x x [0..3]
+    x x x [4..7]
+    x x x [8..11]
+    [16..19] [20..23] [24..27] [28..31,12..15]
+
+    U, V:
+    x [0..3]
+    [8..11] [4..7,12..15]
+*************************************************************************/
+Int DecodeMacroblockDC(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY)
+{
+    CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
+    CWMIMBInfo * pMBInfo = &pSC->MBInfo;
+    const COLORFORMAT cf = pSC->m_param.cfColorFormat;
+    const Int iChannels = (Int) pSC->m_param.cNumChannels;
+    BitIOInfo* pIO = pContext->m_pIODC;
+    Int iIndex, i;
+    Int aLaplacianMean[2] = { 0, 0}, *pLM = aLaplacianMean;
+    Int iModelBits = pContext->m_aModelDC.m_iFlcBits[0];
+    struct CAdaptiveHuffman *pAH;
+    Int iQDCY, iQDCU, iQDCV;
+    // const Int iChromaElements = (cf == YUV_420) ? 8 * 8 : ((cf == YUV_422) ? 8 * 16 : 16 * 16);
+
+    UNREFERENCED_PARAMETER( iMBX );
+    UNREFERENCED_PARAMETER( iMBY );
+
+    for (i = 0; i < iChannels; i++)
+        memset (pMBInfo->iBlockDC[i], 0, 16 * sizeof (I32));
+
+    readIS_L1(pSC, pIO);
+
+    pMBInfo->iQIndexLP = pMBInfo->iQIndexHP = 0;
+
+    if(pSC->WMISCP.bfBitstreamFormat == SPATIAL && pSC->WMISCP.sbSubband != SB_DC_ONLY){
+        if(pTile->cBitsLP > 0)  // MB-based LP QP index
+            pMBInfo->iQIndexLP = decodeQPIndex(pIO, pTile->cBitsLP);
+        if( pSC->WMISCP.sbSubband != SB_NO_HIGHPASS && pTile->cBitsHP > 0)  // MB-based HP QP index
+            pMBInfo->iQIndexHP = decodeQPIndex(pIO, pTile->cBitsHP);
+    }
+    if(pTile->cBitsHP == 0 && pTile->cNumQPHP > 1) // use LP QP
+        pMBInfo->iQIndexHP = pMBInfo->iQIndexLP;
+    if (pMBInfo->iQIndexLP >= pTile->cNumQPLP || pMBInfo->iQIndexHP >= pTile->cNumQPHP)
+        return ICERR_ERROR;
+
+    if(cf == Y_ONLY || cf == CMYK || cf == NCOMPONENT) {
+        for (i = 0; i < iChannels; i++) {
+            iQDCY = 0;
+            /** get luminance DC **/
+            if (_getBool16 (pIO)) {
+                iQDCY = DecodeSignificantAbsLevel(pContext->m_pAHexpt[3], pIO) - 1;
+                *pLM += 1;
+            }
+            if (iModelBits) {
+                iQDCY = (iQDCY << iModelBits) | _getBit16(pIO, iModelBits);
+            }
+            if (iQDCY && _getBool16 (pIO))
+                iQDCY = -iQDCY;
+            pMBInfo->iBlockDC[i][0] = iQDCY;
+
+            pLM = aLaplacianMean + 1;
+            iModelBits = pContext->m_aModelDC.m_iFlcBits[1];
+        }
+    }
+    else {
+        /** find significant level in 3D **/
+        pAH = pContext->m_pAHexpt[2];
+        iIndex = getHuff (pAH->m_hufDecTable, pIO);
+        iQDCY = iIndex >> 2;
+        iQDCU = (iIndex >> 1) & 1;
+        iQDCV = iIndex & 1;
+
+        /** get luminance DC **/
+        if (iQDCY) {
+            iQDCY = DecodeSignificantAbsLevel(pContext->m_pAHexpt[3], pIO) - 1;
+            *pLM += 1;
+        }
+        if (iModelBits) {
+            iQDCY = (iQDCY << iModelBits) | _getBit16(pIO, iModelBits);
+        }
+        if (iQDCY && _getBool16 (pIO))
+            iQDCY = -iQDCY;
+        pMBInfo->iBlockDC[0][0] = iQDCY;
+
+        /** get chrominance DC **/        
+        pLM = aLaplacianMean + 1;
+        iModelBits = pContext->m_aModelDC.m_iFlcBits[1];
+
+        if (iQDCU) {
+            iQDCU = DecodeSignificantAbsLevel(pContext->m_pAHexpt[4], pIO) - 1;
+            *pLM += 1;
+        }
+        if (iModelBits) {
+            iQDCU = (iQDCU << iModelBits) | _getBit16(pIO, iModelBits);
+        }
+        if (iQDCU && _getBool16 (pIO))
+            iQDCU = -iQDCU;
+        pMBInfo->iBlockDC[1][0] = iQDCU;
+
+        if (iQDCV) {
+            iQDCV = DecodeSignificantAbsLevel(pContext->m_pAHexpt[4], pIO) - 1;
+            *pLM += 1;
+        }
+        if (iModelBits) {
+            iQDCV = (iQDCV << iModelBits) | _getBit16(pIO, iModelBits);
+        }
+        if (iQDCV && _getBool16 (pIO))
+            iQDCV = -iQDCV;
+        pMBInfo->iBlockDC[2][0] = iQDCV;
+    }
+
+    UpdateModelMB (cf, iChannels, aLaplacianMean, &(pContext->m_aModelDC));
+    
+    if(((!(pSC->WMISCP.bfBitstreamFormat != FREQUENCY || pSC->m_Dparam->cThumbnailScale < 16)) || pSC->WMISCP.sbSubband == SB_DC_ONLY) && pSC->m_bResetContext){
+        Int kk;
+        for (kk = 2; kk < 5; kk++) {
+            if (ICERR_OK != AdaptDecFixed (pContext->m_pAHexpt[kk])) {
+                return ICERR_ERROR;
+            }
+        }
+    }
+
+    return ICERR_OK;
+}
+
+/*************************************************************************
+    DecodeMacroblockHighpass
+*************************************************************************/
+Int DecodeMacroblockHighpass (CWMImageStrCodec *pSC, CCodingContext *pContext, 
+                      Int iMBX, Int iMBY)
+{   
+    /** reset adaptive scan totals **/
+    if (pSC->m_bResetRGITotals) {
+        int iScale = 2, k;
+        int iWeight = iScale * 16;
+        pContext->m_aScanHoriz[0].uTotal = pContext->m_aScanVert[0].uTotal = MAXTOTAL;
+        for (k = 1; k < 16; k++) {
+            pContext->m_aScanHoriz[k].uTotal = pContext->m_aScanVert[k].uTotal = iWeight;
+            iWeight -= iScale;
+        }
+    }
+    if((pSC->WMISCP.bfBitstreamFormat != SPATIAL) && (pSC->pTile[pSC->cTileColumn].cBitsHP > 0)) { // MB-based HP QP index
+        pSC->MBInfo.iQIndexHP = decodeQPIndex(pContext->m_pIOAC, pSC->pTile[pSC->cTileColumn].cBitsHP);
+        if (pSC->MBInfo.iQIndexHP >= pSC->pTile[pSC->cTileColumn].cNumQPHP)
+            goto ErrorExit;
+    }
+    else if(pSC->pTile[pSC->cTileColumn].cBitsHP == 0 && pSC->pTile[pSC->cTileColumn].cNumQPHP > 1) // use LP QP
+        pSC->MBInfo.iQIndexHP = pSC->MBInfo.iQIndexLP;
+
+
+    DecodeCBP (pSC, pContext);
+    predCBPDec(pSC, pContext);
+
+    if (DecodeCoeffs (pSC, pContext, iMBX, iMBY, 
+        pContext->m_pIOAC, pContext->m_pIOFL) != ICERR_OK)
+        goto ErrorExit;
+
+    if (pSC->m_bResetContext) {
+        AdaptHighpassDec(pContext);
+    }
+
+    return ICERR_OK;
+ErrorExit:
+    return ICERR_ERROR;
+}
+
+/*************************************************************************
+    Adapt
+*************************************************************************/
+Int AdaptLowpassDec(CCodingContext * pSC)
+{
+    Int kk;
+    for (kk = 0; kk < CONTEXTX + CTDC; kk++) {
+        if (ICERR_OK != AdaptDecFixed (pSC->m_pAHexpt[kk])) {
+            goto ErrorExit;
+        }
+    }
+    return ICERR_OK;
+
+ErrorExit:
+    return ICERR_ERROR;
+
+}
+
+Int AdaptHighpassDec(CCodingContext * pSC)
+{
+    Int kk;
+    if (ICERR_OK != AdaptDecFixed (pSC->m_pAdaptHuffCBPCY)) {
+        goto ErrorExit;
+    }
+    if (ICERR_OK != AdaptDecFixed (pSC->m_pAdaptHuffCBPCY1)) {
+        goto ErrorExit;
+    }
+    for (kk = 0; kk < CONTEXTX; kk++) {
+        if (ICERR_OK != AdaptDecFixed (pSC->m_pAHexpt[kk + CONTEXTX + CTDC])) {
+            goto ErrorExit;
+        }
+    }
+
+    return ICERR_OK;
+    
+ErrorExit:
+    return ICERR_ERROR;
+}