◆ jd_prepare()

JRESULT fl::third_party::jd_prepare	(	JDEC *	jd,
		size_t(*	infunc )(JDEC , uint8_t , size_t),
		void *	pool,
		size_t	sz_pool,
		void *	dev )
Definition at line 987 of file tjpgd.cpp.hpp.
{
    uint8_t *seg, b;
    uint16_t marker;
    unsigned int n, i, ofs;
    size_t len;
    JRESULT rc;
 
  uint8_t tmp = jd->swap; // Copy the swap flag
    fl::memset(jd, 0, sizeof (JDEC)); /* Clear decompression object (this might be a problem if machine's null pointer is not all bits zero) */
    jd->pool = pool;        /* Work memroy */
    jd->sz_pool = sz_pool;   /* Size of given work memory */
    jd->infunc = infunc;  /* Stream input function */
    jd->device = dev;     /* I/O device identifier */
  jd->swap = tmp; // Restore the swap flag
 
    jd->inbuf = seg = (uint8_t*)alloc_pool(jd, JD_SZBUF);     /* Allocate stream input buffer */
    if (!seg) return JDR_MEM1;
 
    ofs = marker = 0;       /* Find SOI marker */
    do {
        if (jd->infunc(jd, seg, 1) != 1) return JDR_INP;   /* Err: SOI was not detected */
        ofs++;
        marker = marker << 8 | seg[0];
    } while (marker != 0xFFD8);
 
    for (;;) {              /* Parse JPEG segments */
        /* Get a JPEG marker */
        if (jd->infunc(jd, seg, 4) != 4) return JDR_INP;
        marker = LDB_WORD(seg);     /* Marker */
        len = LDB_WORD(seg + 2);    /* Length field */
        if (len <= 2 || (marker >> 8) != 0xFF) return JDR_FMT1;
        len -= 2;           /* Segent content size */
        ofs += 4 + len;     /* Number of bytes loaded */
 
        switch (marker & 0xFF) {
        case 0xC0:  /* SOF0 (baseline JPEG) */
            if (len > JD_SZBUF) return JDR_MEM2;
            if (jd->infunc(jd, seg, len) != len) return JDR_INP;   /* Load segment data */
 
            jd->width = LDB_WORD(&seg[3]);     /* Image width in unit of pixel */
            jd->height = LDB_WORD(&seg[1]);       /* Image height in unit of pixel */
            jd->ncomp = seg[5];                    /* Number of color components */
            if (jd->ncomp != 3 && jd->ncomp != 1) return JDR_FMT3;    /* Err: Supports only Grayscale and Y/Cb/Cr */
 
            /* Check each image component */
            for (i = 0; i < jd->ncomp; i++) {
                b = seg[7 + 3 * i];                         /* Get sampling factor */
                if (i == 0) {   /* Y component */
                    if (b != 0x11 && b != 0x22 && b != 0x21) {  /* Check sampling factor */
                        return JDR_FMT3;                    /* Err: Supports only 4:4:4, 4:2:0 or 4:2:2 */
                    }
                    jd->msx = b >> 4; jd->msy = b & 15;       /* Size of MCU [blocks] */
                } else {        /* Cb/Cr component */
                    if (b != 0x11) return JDR_FMT3;         /* Err: Sampling factor of Cb/Cr must be 1 */
                }
                jd->qtid[i] = seg[8 + 3 * i];               /* Get dequantizer table ID for this component */
                if (jd->qtid[i] > 3) return JDR_FMT3;       /* Err: Invalid ID */
            }
            break;
 
        case 0xDD:  /* DRI - Define Restart Interval */
            if (len > JD_SZBUF) return JDR_MEM2;
            if (jd->infunc(jd, seg, len) != len) return JDR_INP;   /* Load segment data */
 
            jd->nrst = LDB_WORD(seg);   /* Get restart interval (MCUs) */
            break;
 
        case 0xC4:  /* DHT - Define Huffman Tables */
            if (len > JD_SZBUF) return JDR_MEM2;
            if (jd->infunc(jd, seg, len) != len) return JDR_INP;   /* Load segment data */
 
            rc = create_huffman_tbl(jd, seg, len);    /* Create huffman tables */
            if (rc) return rc;
            break;
 
        case 0xDB:  /* DQT - Define Quaitizer Tables */
            if (len > JD_SZBUF) return JDR_MEM2;
            if (jd->infunc(jd, seg, len) != len) return JDR_INP;   /* Load segment data */
 
            rc = create_qt_tbl(jd, seg, len);  /* Create de-quantizer tables */
            if (rc) return rc;
            break;
 
        case 0xDA:  /* SOS - Start of Scan */
            if (len > JD_SZBUF) return JDR_MEM2;
            if (jd->infunc(jd, seg, len) != len) return JDR_INP;   /* Load segment data */
 
            if (!jd->width || !jd->height) return JDR_FMT1;  /* Err: Invalid image size */
            if (seg[0] != jd->ncomp) return JDR_FMT3;      /* Err: Wrong color components */
 
            /* Check if all tables corresponding to each components have been loaded */
            for (i = 0; i < jd->ncomp; i++) {
                b = seg[2 + 2 * i]; /* Get huffman table ID */
                if (b != 0x00 && b != 0x11) return JDR_FMT3;    /* Err: Different table number for DC/AC element */
                n = i ? 1 : 0;                          /* Component class */
                if (!jd->huffbits[n][0] || !jd->huffbits[n][1]) {   /* Check huffman table for this component */
                    return JDR_FMT1;                    /* Err: Nnot loaded */
                }
                if (!jd->qttbl[jd->qtid[i]]) {         /* Check dequantizer table for this component */
                    return JDR_FMT1;                    /* Err: Not loaded */
                }
            }
 
            /* Allocate working buffer for MCU and pixel output */
            n = jd->msy * jd->msx;                        /* Number of Y blocks in the MCU */
            if (!n) return JDR_FMT1;                    /* Err: SOF0 has not been loaded */
            len = n * 64 * 2 + 64;                      /* Allocate buffer for IDCT and RGB output */
            if (len < 256) len = 256;                   /* but at least 256 byte is required for IDCT */
            jd->workbuf = alloc_pool(jd, len);         /* and it may occupy a part of following MCU working buffer for RGB output */
            if (!jd->workbuf) return JDR_MEM1;           /* Err: not enough memory */
            jd->mcubuf = (jd_yuv_t*)alloc_pool(jd, (n + 2) * 64 * sizeof (jd_yuv_t));   /* Allocate MCU working buffer */
            if (!jd->mcubuf) return JDR_MEM1;         /* Err: not enough memory */
 
            /* Align stream read offset to JD_SZBUF */
            if (ofs %= JD_SZBUF) {
                jd->dctr = jd->infunc(jd, seg + ofs, (size_t)(JD_SZBUF - ofs));
            }
            jd->dptr = seg + ofs - (JD_FASTDECODE ? 0 : 1);
 
            return JDR_OK;        /* Initialization succeeded. Ready to decompress the JPEG image. */
 
        case 0xC1:  /* SOF1 */
        case 0xC2:  /* SOF2 */
        case 0xC3:  /* SOF3 */
        case 0xC5:  /* SOF5 */
        case 0xC6:  /* SOF6 */
        case 0xC7:  /* SOF7 */
        case 0xC9:  /* SOF9 */
        case 0xCA:  /* SOF10 */
        case 0xCB:  /* SOF11 */
        case 0xCD:  /* SOF13 */
        case 0xCE:  /* SOF14 */
        case 0xCF:  /* SOF15 */
        case 0xD9:  /* EOI */
            return JDR_FMT3;    /* Unsuppoted JPEG standard (may be progressive JPEG) */
 
        default:    /* Unknown segment (comment, exif or etc..) */
            /* Skip segment data (null pointer specifies to remove data from the stream) */
            if (jd->infunc(jd, 0, len) != len) return JDR_INP;
        }
    }
}
Referenced by fl::third_party::TJpg_Decoder::drawJpg(), fl::third_party::TJpg_Decoder::getJpgSize(), and fl::third_party::TJpgInstanceDecoder::initializeDecoder().
Here is the call graph for this function:
Here is the caller graph for this function: