huffext()

static int fl::third_party::huffext ( JDEC * jd, unsigned int id, unsigned int cls )

static

Definition at line 291 of file tjpgd.cpp.hpp.

{
    size_t dc = jd->dctr;
    uint8_t *dp = jd->dptr;
    unsigned int d, flg = 0;
 
#if JD_FASTDECODE == 0
    uint8_t bm, nd, bl;
    const uint8_t *hb = jd->huffbits[id][cls];   /* Bit distribution table */
    const uint16_t *hc = jd->huffcode[id][cls]; /* Code word table */
    const uint8_t *hd = jd->huffdata[id][cls];   /* Data table */
 
 
    bm = jd->dbit;  /* Bit mask to extract */
    d = 0; bl = 16; /* Max code length */
    do {
        if (!bm) {      /* Next byte? */
            if (!dc) {  /* No input data is available, re-fill input buffer */
                dp = jd->inbuf;    /* Top of input buffer */
                dc = jd->infunc(jd, dp, JD_SZBUF);
                if (!dc) return 0 - (int)JDR_INP;    /* Err: read error or wrong stream termination */
            } else {
                dp++;   /* Next data ptr */
            }
            dc--;       /* Decrement number of available bytes */
            if (flg) {      /* In flag sequence? */
                flg = 0;    /* Exit flag sequence */
                if (*dp != 0) return 0 - (int)JDR_FMT1; /* Err: unexpected flag is detected (may be collapted data) */
                *dp = 0xFF;             /* The flag is a data 0xFF */
            } else {
                if (*dp == 0xFF) {      /* Is start of flag sequence? */
                    flg = 1; continue;  /* Enter flag sequence, get trailing byte */
                }
            }
            bm = 0x80;      /* Read from MSB */
        }
        d <<= 1;            /* Get a bit */
        if (*dp & bm) d++;
        bm >>= 1;
 
        for (nd = *hb++; nd; nd--) {    /* Search the code word in this bit length */
            if (d == *hc++) {   /* Matched? */
                jd->dbit = bm; jd->dctr = dc; jd->dptr = dp;
                return *hd;     /* Return the decoded data */
            }
            hd++;
        }
        bl--;
    } while (bl);
 
#else
    const uint8_t *hb, *hd;
    const uint16_t *hc;
    unsigned int nc, bl, wbit = jd->dbit % 32;
    uint32_t w = jd->wreg & ((1UL << wbit) - 1);
 
 
    while (wbit < 16) { /* Prepare 16 bits into the working register */
        if (jd->marker) {
            d = 0xFF;   /* Input stream has stalled for a marker. Generate stuff bits */
        } else {
            if (!dc) {  /* Buffer empty, re-fill input buffer */
                dp = jd->inbuf;                        /* Top of input buffer */
                dc = jd->infunc(jd, dp, JD_SZBUF);
                if (!dc) return 0 - (int)JDR_INP;    /* Err: read error or wrong stream termination */
            }
            d = *dp++; dc--;
            if (flg) {      /* In flag sequence? */
                flg = 0;    /* Exit flag sequence */
                if (d != 0) jd->marker = d; /* Not an escape of 0xFF but a marker */
                d = 0xFF;
            } else {
                if (d == 0xFF) {        /* Is start of flag sequence? */
                    flg = 1; continue;  /* Enter flag sequence, get trailing byte */
                }
            }
        }
        w = w << 8 | d; /* Shift 8 bits in the working register */
        wbit += 8;
    }
    jd->dctr = dc; jd->dptr = dp;
    jd->wreg = w;
 
#if JD_FASTDECODE == 2
    /* Table serch for the short codes */
    d = (unsigned int)(w >> (wbit - HUFF_BIT)); /* Short code as table index */
    if (cls) {  /* AC element */
        d = jd->hufflut_ac[id][d];  /* Table decode */
        if (d != 0xFFFF) {  /* It is done if hit in short code */
            jd->dbit = wbit - (d >> 8); /* Snip the code length */
            return d & 0xFF;    /* b7..0: zero run and following data bits */
        }
    } else {    /* DC element */
        d = jd->hufflut_dc[id][d];  /* Table decode */
        if (d != 0xFF) {    /* It is done if hit in short code */
            jd->dbit = wbit - (d >> 4); /* Snip the code length  */
            return d & 0xF; /* b3..0: following data bits */
        }
    }
 
    /* Incremental serch for the codes longer than HUFF_BIT */
    hb = jd->huffbits[id][cls] + HUFF_BIT;              /* Bit distribution table */
    hc = jd->huffcode[id][cls] + jd->longofs[id][cls];  /* Code word table */
    hd = jd->huffdata[id][cls] + jd->longofs[id][cls];  /* Data table */
    bl = HUFF_BIT + 1;
#else
    /* Incremental serch for all codes */
    hb = jd->huffbits[id][cls]; /* Bit distribution table */
    hc = jd->huffcode[id][cls]; /* Code word table */
    hd = jd->huffdata[id][cls]; /* Data table */
    bl = 1;
#endif
    for ( ; bl <= 16; bl++) {   /* Incremental search */
        nc = *hb++;
        if (nc) {
            d = w >> (wbit - bl);
            do {    /* Search the code word in this bit length */
                if (d == *hc++) {       /* Matched? */
                    jd->dbit = wbit - bl;   /* Snip the huffman code */
                    return *hd;         /* Return the decoded data */
                }
                hd++;
            } while (--nc);
        }
    }
#endif
 
    return 0 - (int)JDR_FMT1;   /* Err: code not found (may be collapted data) */
}

References FL_NOEXCEPT, JD_SZBUF, JDR_FMT1, and JDR_INP.

Referenced by mcu_load().

Here is the caller graph for this function: