create_huffman_tbl()

static JRESULT fl::third_party::create_huffman_tbl ( JDEC * jd, const uint8_t * data, size_t ndata )

static

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

{
    unsigned int i, j, b, cls, num;
    size_t np;
    uint8_t d, *pb, *pd;
    uint16_t hc, *ph;
 
 
    while (ndata) { /* Process all tables in the segment */
        if (ndata < 17) return JDR_FMT1;    /* Err: wrong data size */
        ndata -= 17;
        d = *data++;                        /* Get table number and class */
        if (d & 0xEE) return JDR_FMT1;      /* Err: invalid class/number */
        cls = d >> 4; num = d & 0x0F;       /* class = dc(0)/ac(1), table number = 0/1 */
        pb = (uint8_t*)alloc_pool(jd, 16);         /* Allocate a memory block for the bit distribution table */
        if (!pb) return JDR_MEM1;           /* Err: not enough memory */
        jd->huffbits[num][cls] = pb;
        for (np = i = 0; i < 16; i++) {     /* Load number of patterns for 1 to 16-bit code */
            np += (pb[i] = *data++);        /* Get sum of code words for each code */
        }
        ph = (uint16_t*)alloc_pool(jd, np * sizeof (uint16_t));/* Allocate a memory block for the code word table */
        if (!ph) return JDR_MEM1;           /* Err: not enough memory */
        jd->huffcode[num][cls] = ph;
        hc = 0;
        for (j = i = 0; i < 16; i++) {      /* Re-build huffman code word table */
            b = pb[i];
            while (b--) ph[j++] = hc++;
            hc <<= 1;
        }
 
        if (ndata < np) return JDR_FMT1;    /* Err: wrong data size */
        ndata -= np;
        pd = (uint8_t*)alloc_pool(jd, np);         /* Allocate a memory block for the decoded data */
        if (!pd) return JDR_MEM1;           /* Err: not enough memory */
        jd->huffdata[num][cls] = pd;
        for (i = 0; i < np; i++) {          /* Load decoded data corresponds to each code word */
            d = *data++;
            if (!cls && d > 11) return JDR_FMT1;
            pd[i] = d;
        }
#if JD_FASTDECODE == 2
        {   /* Create fast huffman decode table */
            unsigned int span, td, ti;
            uint16_t *tbl_ac = 0;
            uint8_t *tbl_dc = 0;
 
            if (cls) {
                tbl_ac = (uint16_t*)alloc_pool(jd, HUFF_LEN * sizeof (uint16_t)); /* LUT for AC elements */
                if (!tbl_ac) return JDR_MEM1;       /* Err: not enough memory */
                jd->hufflut_ac[num] = tbl_ac;
                fl::memset(tbl_ac, 0xFF, HUFF_LEN * sizeof (uint16_t));       /* Default value (0xFFFF: may be long code) */
            } else {
                tbl_dc = (uint8_t*)alloc_pool(jd, HUFF_LEN * sizeof (uint8_t)); /* LUT for AC elements */
                if (!tbl_dc) return JDR_MEM1;       /* Err: not enough memory */
                jd->hufflut_dc[num] = tbl_dc;
                fl::memset(tbl_dc, 0xFF, HUFF_LEN * sizeof (uint8_t));     /* Default value (0xFF: may be long code) */
            }
            for (i = b = 0; b < HUFF_BIT; b++) {    /* Create LUT */
                for (j = pb[b]; j; j--) {
                    ti = ph[i] << (HUFF_BIT - 1 - b) & HUFF_MASK;   /* Index of input pattern for the code */
                    if (cls) {
                        td = pd[i++] | ((b + 1) << 8);  /* b15..b8: code length, b7..b0: zero run and data length */
                        for (span = 1 << (HUFF_BIT - 1 - b); span; span--, tbl_ac[ti++] = (uint16_t)td) ;
                    } else {
                        td = pd[i++] | ((b + 1) << 4);  /* b7..b4: code length, b3..b0: data length */
                        for (span = 1 << (HUFF_BIT - 1 - b); span; span--, tbl_dc[ti++] = (uint8_t)td) ;
                    }
                }
            }
            jd->longofs[num][cls] = i;  /* Code table offset for long code */
        }
#endif
    }
 
    return JDR_OK;
}

References alloc_pool(), FL_NOEXCEPT, JDR_FMT1, JDR_MEM1, JDR_OK, and fl::memset().

Referenced by jd_prepare().

Here is the call graph for this function:

Here is the caller graph for this function: