mcu_load()

static JRESULT fl::third_party::mcu_load ( JDEC * jd )

static

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

{
    int32_t *tmp = (int32_t*)jd->workbuf;  /* Block working buffer for de-quantize and IDCT */
    int d, e;
    unsigned int blk, nby, i, bc, z, id, cmp;
    jd_yuv_t *bp;
    const int32_t *dqf;
 
 
    nby = jd->msx * jd->msy;  /* Number of Y blocks (1, 2 or 4) */
    bp = jd->mcubuf;          /* Pointer to the first block of MCU */
 
    for (blk = 0; blk < nby + 2; blk++) {   /* Get nby Y blocks and two C blocks */
        cmp = (blk < nby) ? 0 : blk - nby + 1;  /* Component number 0:Y, 1:Cb, 2:Cr */
 
        if (cmp && jd->ncomp != 3) {       /* Clear C blocks if not exist (monochrome image) */
            for (i = 0; i < 64; bp[i++] = 128) ;
 
        } else {                            /* Load Y/C blocks from input stream */
            id = cmp ? 1 : 0;                       /* Huffman table ID of this component */
 
            /* Extract a DC element from input stream */
            d = huffext(jd, id, 0);                  /* Extract a huffman coded data (bit length) */
            if (d < 0) return (JRESULT)(0 - d);      /* Err: invalid code or input */
            bc = (unsigned int)d;
            d = jd->dcv[cmp];                        /* DC value of previous block */
            if (bc) {                               /* If there is any difference from previous block */
                e = bitext(jd, bc);                   /* Extract data bits */
                if (e < 0) return (JRESULT)(0 - e);  /* Err: input */
                bc = 1 << (bc - 1);                 /* MSB position */
                if (!(e & bc)) e -= (bc << 1) - 1;  /* Restore negative value if needed */
                d += e;                             /* Get current value */
                jd->dcv[cmp] = (int16_t)d;            /* Save current DC value for next block */
            }
            dqf = jd->qttbl[jd->qtid[cmp]];            /* De-quantizer table ID for this component */
            tmp[0] = d * dqf[0] >> 8;               /* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */
 
            /* Extract following 63 AC elements from input stream */
            fl::memset(&tmp[1], 0, 63 * sizeof (int32_t)); /* Initialize all AC elements */
            z = 1;     /* Top of the AC elements (in zigzag-order) */
            do {
                d = huffext(jd, id, 1);              /* Extract a huffman coded value (zero runs and bit length) */
                if (d == 0) break;                  /* EOB? */
                if (d < 0) return (JRESULT)(0 - d);  /* Err: invalid code or input error */
                bc = (unsigned int)d;
                z += bc >> 4;                      /* Skip leading zero run */
                if (z >= 64) return JDR_FMT1;      /* Too long zero run */
                if (bc &= 0x0F) {                   /* Bit length? */
                    d = bitext(jd, bc);               /* Extract data bits */
                    if (d < 0) return (JRESULT)(0 - d);  /* Err: input device */
                    bc = 1 << (bc - 1);             /* MSB position */
                    if (!(d & bc)) d -= (bc << 1) - 1;  /* Restore negative value if needed */
                    i = Zig[z];                     /* Get raster-order index */
                    tmp[i] = d * dqf[i] >> 8;       /* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */
                }
            } while (++z < 64);        /* Next AC element */
 
            if (JD_FORMAT != 2 || !cmp) {  /* C components may not be processed if in grayscale output */
                if (z == 1 || (JD_USE_SCALE && jd->scale == 3)) { /* If no AC element or scale ratio is 1/8, IDCT can be ommited and the block is filled with DC value */
                    d = (jd_yuv_t)((*tmp / 256) + 128);
                    if (JD_FASTDECODE >= 1) {
                        for (i = 0; i < 64; bp[i++] = d) ;
                    } else {
                        fl::memset(bp, d, 64);
                    }
                } else {
                    block_idct(tmp, bp);  /* Apply IDCT and store the block to the MCU buffer */
                }
            }
        }
 
        bp += 64;               /* Next block */
    }
 
    return JDR_OK;    /* All blocks have been loaded successfully */
}

References bitext(), block_idct(), FL_NOEXCEPT, huffext(), JD_FASTDECODE, JD_FORMAT, JD_USE_SCALE, JDR_FMT1, JDR_OK, fl::memset(), z, and Zig.

Referenced by jd_decomp(), and jd_decomp_progressive().

Here is the call graph for this function:

Here is the caller graph for this function: