DecodeHuffmanPairs()

static int fl::third_party::DecodeHuffmanPairs ( int32_t * xy, int nVals, int tabIdx, int bitsLeft, const unsigned char * buf, int bitOffset )

static

Definition at line 88 of file huffman.hpp.

{
    int i, x, y;
    int cachedBits, padBits, len, startBits, linBits, maxBits, minBits;
    HuffTabType tabType;
    unsigned short cw, *tBase, *tCurr;
    unsigned int cache;
 
    if(nVals <= 0) 
        return 0;
 
    if (bitsLeft < 0)
        return -1;
    startBits = bitsLeft;
 
    tBase = (unsigned short *)(huffTable + huffTabOffset[tabIdx]);
    linBits = huffTabLookup[tabIdx].linBits;
    tabType = huffTabLookup[tabIdx].tabType;
 
    ASSERT(!(nVals & 0x01));
    ASSERT(tabIdx < HUFF_PAIRTABS);
    ASSERT(tabIdx >= 0);
    ASSERT(tabType != invalidTab);
 
    /* initially fill cache with any partial byte */
    cache = 0;
    cachedBits = (8 - bitOffset) & 0x07;
    if (cachedBits)
        cache = (unsigned int)(*buf++) << (32 - cachedBits);
    bitsLeft -= cachedBits;
 
    if (tabType == noBits) {
        /* table 0, no data, x = y = 0 */
        for (i = 0; i < nVals; i+=2) {
            xy[i+0] = 0;
            xy[i+1] = 0;
        }
        return 0;
    } else if (tabType == oneShot) {
        /* single lookup, no escapes */
        maxBits = GetMaxbits(tBase[0]);
        tBase++;
        padBits = 0;
        while (nVals > 0) {
            /* refill cache - assumes cachedBits <= 16 */
            if (bitsLeft >= 16) {
                /* load 2 new bytes into left-justified cache */
                cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                cache |= (unsigned int)(*buf++) << (16 - cachedBits);
                cachedBits += 16;
                bitsLeft -= 16;
            } else {
                /* last time through, pad cache with zeros and drain cache */
                if (cachedBits + bitsLeft <= 0) return -1;
                if (bitsLeft > 0)   cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                if (bitsLeft > 8)   cache |= (unsigned int)(*buf++) << (16 - cachedBits);
                cachedBits += bitsLeft;
                bitsLeft = 0;
 
                cache &= (signed int)(int32_t)0x80000000 >> (cachedBits - 1);
                padBits = 11;
                cachedBits += padBits;  /* okay if this is > 32 (0's automatically shifted in from right) */
            }
 
            /* largest maxBits = 9, plus 2 for sign bits, so make sure cache has at least 11 bits */
            while (nVals > 0 && cachedBits >= 11 ) {
                cw = tBase[cache >> (32 - maxBits)];
                len = GetHLen(cw);
                cachedBits -= len;
                cache <<= len;
 
                x = GetCWX(cw);      if (x) {ApplySign(x, cache); cache <<= 1; cachedBits--;}
                y = GetCWY(cw);      if (y) {ApplySign(y, cache); cache <<= 1; cachedBits--;}
 
                /* ran out of bits - should never have consumed padBits */
                if (cachedBits < padBits)
                    return -1;
 
                *xy++ = x;
                *xy++ = y;
                nVals -= 2;
            }
        }
        bitsLeft += (cachedBits - padBits);
        return (startBits - bitsLeft);
    } else if (tabType == loopLinbits || tabType == loopNoLinbits) {
        tCurr = tBase;
        padBits = 0;
        while (nVals > 0) {
            /* refill cache - assumes cachedBits <= 16 */
            if (bitsLeft >= 16) {
                /* load 2 new bytes into left-justified cache */
                cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                cache |= (unsigned int)(*buf++) << (16 - cachedBits);
                cachedBits += 16;
                bitsLeft -= 16;
            } else {
                /* last time through, pad cache with zeros and drain cache */
                if (cachedBits + bitsLeft <= 0) return -1;
                if (bitsLeft > 0)   cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                if (bitsLeft > 8)   cache |= (unsigned int)(*buf++) << (16 - cachedBits);
                cachedBits += bitsLeft;
                bitsLeft = 0;
 
                cache &= (signed int)(int32_t)0x80000000 >> (cachedBits - 1);
                padBits = 11;
                cachedBits += padBits;  /* okay if this is > 32 (0's automatically shifted in from right) */
            }
 
            /* largest maxBits = 9, plus 2 for sign bits, so make sure cache has at least 11 bits */
            while (nVals > 0 && cachedBits >= 11 ) {
                maxBits = GetMaxbits(tCurr[0]);
                cw = tCurr[(cache >> (32 - maxBits)) + 1];
                len = GetHLen(cw);
                if (!len) {
                    cachedBits -= maxBits;
                    cache <<= maxBits;
                    tCurr += cw;
                    continue;
                }
                cachedBits -= len;
                cache <<= len;
            
                x = GetCWX(cw);
                y = GetCWY(cw);
 
                if (x == 15 && tabType == loopLinbits) {
                    minBits = linBits + 1 + (y ? 1 : 0);
                    if (cachedBits + bitsLeft < minBits)
                        return -1;
                    while (cachedBits < minBits) {
                        cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                        cachedBits += 8;
                        bitsLeft -= 8;
                    }
                    if (bitsLeft < 0) {
                        cachedBits += bitsLeft;
                        bitsLeft = 0;
                        cache &= (signed int)(int32_t)0x80000000 >> (cachedBits - 1);
                    }
                    x += (int)(cache >> (32 - linBits));
                    cachedBits -= linBits;
                    cache <<= linBits;
                }
                if (x) {ApplySign(x, cache); cache <<= 1; cachedBits--;}
 
                if (y == 15 && tabType == loopLinbits) {
                    minBits = linBits + 1;
                    if (cachedBits + bitsLeft < minBits)
                        return -1;
                    while (cachedBits < minBits) {
                        cache |= (unsigned int)(*buf++) << (24 - cachedBits);
                        cachedBits += 8;
                        bitsLeft -= 8;
                    }
                    if (bitsLeft < 0) {
                        cachedBits += bitsLeft;
                        bitsLeft = 0;
                        cache &= (signed int)(int32_t)0x80000000 >> (cachedBits - 1);
                    }
                    y += (int)(cache >> (32 - linBits));
                    cachedBits -= linBits;
                    cache <<= linBits;
                }
                if (y) {ApplySign(y, cache); cache <<= 1; cachedBits--;}
 
                /* ran out of bits - should never have consumed padBits */
                if (cachedBits < padBits)
                    return -1;
 
                *xy++ = x;
                *xy++ = y;
                nVals -= 2;
                tCurr = tBase;
            }
        }
        bitsLeft += (cachedBits - padBits);
        return (startBits - bitsLeft);
    }
 
    /* error in bitstream - trying to access unused Huffman table */
    return -1;
}

References ApplySign, ASSERT, FL_NOEXCEPT, GetCWX, GetCWY, GetHLen, GetMaxbits, HUFF_PAIRTABS, huffTable, huffTabLookup, huffTabOffset, invalidTab, loopLinbits, loopNoLinbits, noBits, oneShot, fl::x, xy(), and fl::y.

Referenced by DecodeHuffman().

Here is the call graph for this function:

Here is the caller graph for this function: