/* * jrdjfif.c * * Copyright (C) 1991, 1992, 1993, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to decode standard JPEG file headers/markers. * This code will handle "raw JPEG" and JFIF-convention JPEG files. * * You can also use this module to decode a raw-JPEG or JFIF-standard data * stream that is embedded within a larger file. To do that, you must * position the file to the JPEG SOI marker (0xFF/0xD8) that begins the * data sequence to be decoded. If nothing better is possible, you can scan * the file until you see the SOI marker, then use JUNGETC to push it back. * * This module relies on the JGETC macro and the read_jpeg_data method (which * is provided by the user interface) to read from the JPEG data stream. * Therefore, this module is not dependent on any particular assumption about * the data source; it need not be a stdio stream at all. (This fact does * NOT carry over to more complex JPEG file formats such as JPEG-in-TIFF; * those format control modules may well need to assume stdio input.) * * These routines are invoked via the methods read_file_header, * read_scan_header, read_jpeg_data, read_scan_trailer, and read_file_trailer. */ #include "jinclude.h" #ifdef JFIF_SUPPORTED typedef enum { /* JPEG marker codes */ M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JPEG_MARKER; /* * Reload the input buffer after it's been emptied, and return the next byte. * This is exported for direct use by the entropy decoder. * See the JGETC macro for calling conditions. Note in particular that * read_jpeg_data may NOT return EOF. If no more data is available, it must * exit via ERREXIT, or perhaps synthesize fake data (such as an RST marker). * For error recovery purposes, synthesizing an EOI marker is probably best. * * For this header control module, read_jpeg_data is supplied by the * user interface. However, header formats that require random access * to the input file would need to supply their own code. This code is * left here to indicate what is required. */ #if 0 /* not needed in this module */ METHODDEF int read_jpeg_data (decompress_info_ptr cinfo) { cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET; cinfo->bytes_in_buffer = (int) JFREAD(cinfo->input_file, cinfo->next_input_byte, JPEG_BUF_SIZE); if (cinfo->bytes_in_buffer <= 0) { WARNMS(cinfo->emethods, "Premature EOF in JPEG file"); cinfo->next_input_byte[0] = (char) 0xFF; cinfo->next_input_byte[1] = (char) M_EOI; cinfo->bytes_in_buffer = 2; } return JGETC(cinfo); } #endif /* * Routines to parse JPEG markers & save away the useful info. */ LOCAL INT32 get_2bytes (decompress_info_ptr cinfo) /* Get a 2-byte unsigned integer (e.g., a marker parameter length field) */ { INT32 a; a = JGETC(cinfo); return (a << 8) + JGETC(cinfo); } LOCAL void skip_variable (decompress_info_ptr cinfo, int code) /* Skip over an unknown or uninteresting variable-length marker */ { INT32 length; length = get_2bytes(cinfo); TRACEMS2(cinfo->emethods, 1, "Skipping marker 0x%02x, length %u", code, (int) length); for (length -= 2; length > 0; length--) (void) JGETC(cinfo); } LOCAL void get_dht (decompress_info_ptr cinfo) /* Process a DHT marker */ { INT32 length; UINT8 bits[17]; UINT8 huffval[256]; int i, index, count; HUFF_TBL **htblptr; length = get_2bytes(cinfo)-2; while (length > 0) { index = JGETC(cinfo); TRACEMS1(cinfo->emethods, 1, "Define Huffman Table 0x%02x", index); bits[0] = 0; count = 0; for (i = 1; i <= 16; i++) { bits[i] = (UINT8) JGETC(cinfo); count += bits[i]; } length -= 1 + 16; TRACEMS8(cinfo->emethods, 2, " %3d %3d %3d %3d %3d %3d %3d %3d", bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7], bits[8]); TRACEMS8(cinfo->emethods, 2, " %3d %3d %3d %3d %3d %3d %3d %3d", bits[9], bits[10], bits[11], bits[12], bits[13], bits[14], bits[15], bits[16]); if (count > 256 || ((INT32) count) > length) ERREXIT(cinfo->emethods, "Bogus DHT counts"); for (i = 0; i < count; i++) huffval[i] = (UINT8) JGETC(cinfo); length -= count; if (index & 0x10) { /* AC table definition */ index -= 0x10; htblptr = &cinfo->ac_huff_tbl_ptrs[index]; } else { /* DC table definition */ htblptr = &cinfo->dc_huff_tbl_ptrs[index]; } if (index < 0 || index >= NUM_HUFF_TBLS) ERREXIT1(cinfo->emethods, "Bogus DHT index %d", index); if (*htblptr == NULL) *htblptr = (HUFF_TBL *) (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL)); MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval)); } } LOCAL void get_dac (decompress_info_ptr cinfo) /* Process a DAC marker */ { INT32 length; int index, val; length = get_2bytes(cinfo)-2; while (length > 0) { index = JGETC(cinfo); val = JGETC(cinfo); TRACEMS2(cinfo->emethods, 1, "Define Arithmetic Table 0x%02x: 0x%02x", index, val); if (index < 0 || index >= (2*NUM_ARITH_TBLS)) ERREXIT1(cinfo->emethods, "Bogus DAC index %d", index); if (index >= NUM_ARITH_TBLS) { /* define AC table */ cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val; } else { /* define DC table */ cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F); cinfo->arith_dc_U[index] = (UINT8) (val >> 4); if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index]) ERREXIT1(cinfo->emethods, "Bogus DAC value 0x%x", val); } length -= 2; } } LOCAL void get_dqt (decompress_info_ptr cinfo) /* Process a DQT marker */ { INT32 length; int n, i, prec; UINT16 tmp; QUANT_TBL_PTR quant_ptr; length = get_2bytes(cinfo) - 2; while (length > 0) { n = JGETC(cinfo); prec = n >> 4; n &= 0x0F; TRACEMS2(cinfo->emethods, 1, "Define Quantization Table %d precision %d", n, prec); if (n >= NUM_QUANT_TBLS) ERREXIT1(cinfo->emethods, "Bogus table number %d", n); if (cinfo->quant_tbl_ptrs[n] == NULL) cinfo->quant_tbl_ptrs[n] = (QUANT_TBL_PTR) (*cinfo->emethods->alloc_small) (SIZEOF(QUANT_TBL)); quant_ptr = cinfo->quant_tbl_ptrs[n]; for (i = 0; i < DCTSIZE2; i++) { tmp = JGETC(cinfo); if (prec) tmp = (tmp<<8) + JGETC(cinfo); quant_ptr[i] = tmp; } for (i = 0; i < DCTSIZE2; i += 8) { TRACEMS8(cinfo->emethods, 2, " %4u %4u %4u %4u %4u %4u %4u %4u", quant_ptr[i ], quant_ptr[i+1], quant_ptr[i+2], quant_ptr[i+3], quant_ptr[i+4], quant_ptr[i+5], quant_ptr[i+6], quant_ptr[i+7]); } length -= DCTSIZE2+1; if (prec) length -= DCTSIZE2; } } LOCAL void get_dri (decompress_info_ptr cinfo) /* Process a DRI marker */ { if (get_2bytes(cinfo) != 4) ERREXIT(cinfo->emethods, "Bogus length in DRI"); cinfo->restart_interval = (UINT16) get_2bytes(cinfo); TRACEMS1(cinfo->emethods, 1, "Define Restart Interval %u", cinfo->restart_interval); } LOCAL void get_app0 (decompress_info_ptr cinfo) /* Process an APP0 marker */ { #define JFIF_LEN 14 INT32 length; UINT8 b[JFIF_LEN]; int buffp; length = get_2bytes(cinfo) - 2; /* See if a JFIF APP0 marker is present */ if (length >= JFIF_LEN) { for (buffp = 0; buffp < JFIF_LEN; buffp++) b[buffp] = (UINT8) JGETC(cinfo); length -= JFIF_LEN; if (b[0]==0x4A && b[1]==0x46 && b[2]==0x49 && b[3]==0x46 && b[4]==0) { /* Found JFIF APP0 marker: check version */ /* Major version must be 1 */ if (b[5] != 1) ERREXIT2(cinfo->emethods, "Unsupported JFIF revision number %d.%02d", b[5], b[6]); /* Minor version should be 0..2, but try to process anyway if newer */ if (b[6] > 2) TRACEMS2(cinfo->emethods, 1, "Warning: unknown JFIF revision number %d.%02d", b[5], b[6]); /* Save info */ cinfo->density_unit = b[7]; cinfo->X_density = (b[8] << 8) + b[9]; cinfo->Y_density = (b[10] << 8) + b[11]; /* Assume colorspace is YCbCr, unless UI has overridden me */ if (cinfo->jpeg_color_space == CS_UNKNOWN) cinfo->jpeg_color_space = CS_YCbCr; TRACEMS3(cinfo->emethods, 1, "JFIF APP0 marker, density %dx%d %d", cinfo->X_density, cinfo->Y_density, cinfo->density_unit); if (b[12] | b[13]) TRACEMS2(cinfo->emethods, 1, " with %d x %d thumbnail image", b[12], b[13]); if (length != ((INT32) b[12] * (INT32) b[13] * (INT32) 3)) TRACEMS1(cinfo->emethods, 1, "Warning: thumbnail image size does not match data length %u", (int) length); } else { TRACEMS1(cinfo->emethods, 1, "Unknown APP0 marker (not JFIF), length %u", (int) length + JFIF_LEN); } } else { TRACEMS1(cinfo->emethods, 1, "Short APP0 marker, length %u", (int) length); } while (--length >= 0) /* skip any remaining data */ (void) JGETC(cinfo); } LOCAL void get_com (decompress_info_ptr cinfo) /* Process a COM marker */ /* Actually we just pass this off to an application-supplied routine */ { INT32 length; length = get_2bytes(cinfo) - 2; TRACEMS1(cinfo->emethods, 1, "Comment, length %u", (int) length); (*cinfo->methods->process_comment) (cinfo, (long) length); } LOCAL void get_sof (decompress_info_ptr cinfo, int code) /* Process a SOFn marker */ { INT32 length; short ci; int c; jpeg_component_info * compptr; length = get_2bytes(cinfo); cinfo->data_precision = JGETC(cinfo); cinfo->image_height = get_2bytes(cinfo); cinfo->image_width = get_2bytes(cinfo); cinfo->num_components = JGETC(cinfo); TRACEMS4(cinfo->emethods, 1, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d", code, (int) cinfo->image_width, (int) cinfo->image_height, cinfo->num_components); /* We don't support files in which the image height is initially specified */ /* as 0 and is later redefined by DNL. As long as we have to check that, */ /* might as well have a general sanity check. */ if (cinfo->image_height <= 0 || cinfo->image_width <= 0 || cinfo->num_components <= 0) ERREXIT(cinfo->emethods, "Empty JPEG image (DNL not supported)"); #ifdef EIGHT_BIT_SAMPLES if (cinfo->data_precision != 8) ERREXIT(cinfo->emethods, "Unsupported JPEG data precision"); #endif #ifdef TWELVE_BIT_SAMPLES if (cinfo->data_precision != 12) /* this needs more thought?? */ ERREXIT(cinfo->emethods, "Unsupported JPEG data precision"); #endif #ifdef SIXTEEN_BIT_SAMPLES if (cinfo->data_precision != 16) /* this needs more thought?? */ ERREXIT(cinfo->emethods, "Unsupported JPEG data precision"); #endif if (length != (cinfo->num_components * 3 + 8)) ERREXIT(cinfo->emethods, "Bogus SOF length"); cinfo->comp_info = (jpeg_component_info *) (*cinfo->emethods->alloc_small) (cinfo->num_components * SIZEOF(jpeg_component_info)); for (ci = 0; ci < cinfo->num_components; ci++) { compptr = &cinfo->comp_info[ci]; compptr->component_index = ci; compptr->component_id = JGETC(cinfo); c = JGETC(cinfo); compptr->h_samp_factor = (c >> 4) & 15; compptr->v_samp_factor = (c ) & 15; compptr->quant_tbl_no = JGETC(cinfo); compptr->component_needed = TRUE; /* assume all components are wanted */ TRACEMS4(cinfo->emethods, 1, " Component %d: %dhx%dv q=%d", compptr->component_id, compptr->h_samp_factor, compptr->v_samp_factor, compptr->quant_tbl_no); } } LOCAL void get_sos (decompress_info_ptr cinfo) /* Process a SOS marker */ { INT32 length; int i, ci, n, c, cc; jpeg_component_info * compptr; length = get_2bytes(cinfo); n = JGETC(cinfo); /* Number of components */ cinfo->comps_in_scan = n; length -= 3; if (length != (n * 2 + 3) || n < 1 || n > MAX_COMPS_IN_SCAN) ERREXIT(cinfo->emethods, "Bogus SOS length"); TRACEMS1(cinfo->emethods, 1, "Start Of Scan: %d components", n); for (i = 0; i < n; i++) { cc = JGETC(cinfo); c = JGETC(cinfo); length -= 2; for (ci = 0; ci < cinfo->num_components; ci++) if (cc == cinfo->comp_info[ci].component_id) break; if (ci >= cinfo->num_components) ERREXIT(cinfo->emethods, "Invalid component number in SOS"); compptr = &cinfo->comp_info[ci]; cinfo->cur_comp_info[i] = compptr; compptr->dc_tbl_no = (c >> 4) & 15; compptr->ac_tbl_no = (c ) & 15; TRACEMS3(cinfo->emethods, 1, " c%d: [dc=%d ac=%d]", cc, compptr->dc_tbl_no, compptr->ac_tbl_no); } while (length > 0) { (void) JGETC(cinfo); length--; } } LOCAL void get_soi (decompress_info_ptr cinfo) /* Process an SOI marker */ { int i; TRACEMS(cinfo->emethods, 1, "Start of Image"); /* Reset all parameters that are defined to be reset by SOI */ for (i = 0; i < NUM_ARITH_TBLS; i++) { cinfo->arith_dc_L[i] = 0; cinfo->arith_dc_U[i] = 1; cinfo->arith_ac_K[i] = 5; } cinfo->restart_interval = 0; cinfo->density_unit = 0; /* set default JFIF APP0 values */ cinfo->X_density = 1; cinfo->Y_density = 1; cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling */ } LOCAL int next_marker (decompress_info_ptr cinfo) /* Find the next JPEG marker */ /* Note that the output might not be a valid marker code, */ /* but it will never be 0 or FF */ { int c, nbytes; nbytes = 0; do { do { /* skip any non-FF bytes */ nbytes++; c = JGETC(cinfo); } while (c != 0xFF); do { /* skip any duplicate FFs */ /* we don't increment nbytes here since extra FFs are legal */ c = JGETC(cinfo); } while (c == 0xFF); } while (c == 0); /* repeat if it was a stuffed FF/00 */ if (nbytes != 1) WARNMS2(cinfo->emethods, "Corrupt JPEG data: %d extraneous bytes before marker 0x%02x", nbytes-1, c); return c; } LOCAL int process_tables (decompress_info_ptr cinfo) /* Scan and process JPEG markers that can appear in any order */ /* Return when an SOI, EOI, SOFn, or SOS is found */ { int c; for (;;) { c = next_marker(cinfo); switch (c) { case M_SOF0: case M_SOF1: case M_SOF2: case M_SOF3: case M_SOF5: case M_SOF6: case M_SOF7: case M_JPG: case M_SOF9: case M_SOF10: case M_SOF11: case M_SOF13: case M_SOF14: case M_SOF15: case M_SOI: case M_EOI: case M_SOS: return c; case M_DHT: get_dht(cinfo); break; case M_DAC: get_dac(cinfo); break; case M_DQT: get_dqt(cinfo); break; case M_DRI: get_dri(cinfo); break; case M_APP0: get_app0(cinfo); break; case M_COM: get_com(cinfo); break; case M_RST0: /* these are all parameterless */ case M_RST1: case M_RST2: case M_RST3: case M_RST4: case M_RST5: case M_RST6: case M_RST7: case M_TEM: TRACEMS1(cinfo->emethods, 1, "Unexpected marker 0x%02x", c); break; default: /* must be DNL, DHP, EXP, APPn, JPGn, or RESn */ skip_variable(cinfo, c); break; } } } /* * Initialize and read the file header (everything through the SOF marker). */ METHODDEF void read_file_header (decompress_info_ptr cinfo) { int c; /* Demand an SOI marker at the start of the file --- otherwise it's * probably not a JPEG file at all. If the user interface wants to support * nonstandard headers in front of the SOI, it must skip over them itself * before calling jpeg_decompress(). */ if (JGETC(cinfo) != 0xFF || JGETC(cinfo) != (int) M_SOI) ERREXIT(cinfo->emethods, "Not a JPEG file"); get_soi(cinfo); /* OK, process SOI */ /* Process markers until SOF */ c = process_tables(cinfo); switch (c) { case M_SOF0: case M_SOF1: get_sof(cinfo, c); cinfo->arith_code = FALSE; break; case M_SOF9: get_sof(cinfo, c); cinfo->arith_code = TRUE; break; default: ERREXIT1(cinfo->emethods, "Unsupported SOF marker type 0x%02x", c); break; } /* Figure out what colorspace we have */ /* (too bad the JPEG committee didn't provide a real way to specify this) */ switch (cinfo->num_components) { case 1: cinfo->jpeg_color_space = CS_GRAYSCALE; break; case 3: /* if we saw a JFIF marker, leave it set to YCbCr; */ /* also leave it alone if UI has provided a value */ if (cinfo->jpeg_color_space == CS_UNKNOWN) { short cid0 = cinfo->comp_info[0].component_id; short cid1 = cinfo->comp_info[1].component_id; short cid2 = cinfo->comp_info[2].component_id; if (cid0 == 1 && cid1 == 2 && cid2 == 3) cinfo->jpeg_color_space = CS_YCbCr; /* assume it's JFIF w/out marker */ else if (cid0 == 1 && cid1 == 4 && cid2 == 5) cinfo->jpeg_color_space = CS_YIQ; /* prototype's YIQ matrix */ else { TRACEMS3(cinfo->emethods, 1, "Unrecognized component IDs %d %d %d, assuming YCbCr", cid0, cid1, cid2); cinfo->jpeg_color_space = CS_YCbCr; } } break; case 4: cinfo->jpeg_color_space = CS_CMYK; break; default: cinfo->jpeg_color_space = CS_UNKNOWN; break; } } /* * Read the start of a scan (everything through the SOS marker). * Return TRUE if find SOS, FALSE if find EOI. */ METHODDEF boolean read_scan_header (decompress_info_ptr cinfo) { int c; /* Process markers until SOS or EOI */ c = process_tables(cinfo); switch (c) { case M_SOS: get_sos(cinfo); return TRUE; case M_EOI: TRACEMS(cinfo->emethods, 1, "End Of Image"); return FALSE; default: ERREXIT1(cinfo->emethods, "Unexpected marker 0x%02x", c); break; } return FALSE; /* keeps lint happy */ } /* * The entropy decoder calls this routine if it finds a marker other than * the restart marker it was expecting. (This code is *not* used unless * a nonzero restart interval has been declared.) The passed parameter is * the marker code actually found (might be anything, except 0 or FF). * The desired restart marker is that indicated by cinfo->next_restart_num. * This routine is supposed to apply whatever error recovery strategy seems * appropriate in order to position the input stream to the next data segment. * For some file formats (eg, TIFF) extra information such as tile boundary * pointers may be available to help in this decision. * * This implementation is substantially constrained by wanting to treat the * input as a data stream; this means we can't back up. (For instance, we * generally can't fseek() if the input is a Unix pipe.) Therefore, we have * only the following actions to work with: * 1. Do nothing, let the entropy decoder resume at next byte of file. * 2. Read forward until we find another marker, discarding intervening * data. (In theory we could look ahead within the current bufferload, * without having to discard data if we don't find the desired marker. * This idea is not implemented here, in part because it makes behavior * dependent on buffer size and chance buffer-boundary positions.) * 3. Push back the passed marker (with JUNGETC). This will cause the * entropy decoder to process an empty data segment, inserting dummy * zeroes, and then re-read the marker we pushed back. * #2 is appropriate if we think the desired marker lies ahead, while #3 is * appropriate if the found marker is a future restart marker (indicating * that we have missed the desired restart marker, probably because it got * corrupted). * We apply #2 or #3 if the found marker is a restart marker no more than * two counts behind or ahead of the expected one. We also apply #2 if the * found marker is not a legal JPEG marker code (it's certainly bogus data). * If the found marker is a restart marker more than 2 counts away, we do #1 * (too much risk that the marker is erroneous; with luck we will be able to * resync at some future point). * For any valid non-restart JPEG marker, we apply #3. This keeps us from * overrunning the end of a scan. An implementation limited to single-scan * files might find it better to apply #2 for markers other than EOI, since * any other marker would have to be bogus data in that case. */ METHODDEF void resync_to_restart (decompress_info_ptr cinfo, int marker) { int desired = cinfo->next_restart_num; int action = 1; /* Always put up a warning. */ WARNMS2(cinfo->emethods, "Corrupt JPEG data: found 0x%02x marker instead of RST%d", marker, desired); /* Outer loop handles repeated decision after scanning forward. */ for (;;) { if (marker < (int) M_SOF0) action = 2; /* invalid marker */ else if (marker < (int) M_RST0 || marker > (int) M_RST7) action = 3; /* valid non-restart marker */ else { if (marker == ((int) M_RST0 + ((desired+1) & 7)) || marker == ((int) M_RST0 + ((desired+2) & 7))) action = 3; /* one of the next two expected restarts */ else if (marker == ((int) M_RST0 + ((desired-1) & 7)) || marker == ((int) M_RST0 + ((desired-2) & 7))) action = 2; /* a prior restart, so advance */ else action = 1; /* desired restart or too far away */ } TRACEMS2(cinfo->emethods, 4, "At marker 0x%02x, recovery action %d", marker, action); switch (action) { case 1: /* Let entropy decoder resume processing. */ return; case 2: /* Scan to the next marker, and repeat the decision loop. */ marker = next_marker(cinfo); break; case 3: /* Put back this marker & return. */ /* Entropy decoder will be forced to process an empty segment. */ JUNGETC(marker, cinfo); JUNGETC(0xFF, cinfo); return; } } } /* * Finish up after a compressed scan (series of read_jpeg_data calls); * prepare for another read_scan_header call. */ METHODDEF void read_scan_trailer (decompress_info_ptr cinfo) { /* no work needed */ } /* * Finish up at the end of the file. */ METHODDEF void read_file_trailer (decompress_info_ptr cinfo) { /* no work needed */ } /* * The method selection routine for standard JPEG header reading. * Note that this must be called by the user interface before calling * jpeg_decompress. When a non-JFIF file is to be decompressed (TIFF, * perhaps), the user interface must discover the file type and call * the appropriate method selection routine. */ GLOBAL void jselrjfif (decompress_info_ptr cinfo) { cinfo->methods->read_file_header = read_file_header; cinfo->methods->read_scan_header = read_scan_header; /* For JFIF/raw-JPEG format, the user interface supplies read_jpeg_data. */ #if 0 cinfo->methods->read_jpeg_data = read_jpeg_data; #endif cinfo->methods->resync_to_restart = resync_to_restart; cinfo->methods->read_scan_trailer = read_scan_trailer; cinfo->methods->read_file_trailer = read_file_trailer; } #endif /* JFIF_SUPPORTED */