| 1 | /*
|
---|
| 2 | * jdinput.c
|
---|
| 3 | *
|
---|
| 4 | * Copyright (C) 1991-1997, Thomas G. Lane.
|
---|
| 5 | * This file is part of the Independent JPEG Group's software.
|
---|
| 6 | * For conditions of distribution and use, see the accompanying README file.
|
---|
| 7 | *
|
---|
| 8 | * This file contains input control logic for the JPEG decompressor.
|
---|
| 9 | * These routines are concerned with controlling the decompressor's input
|
---|
| 10 | * processing (marker reading and coefficient decoding). The actual input
|
---|
| 11 | * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
|
---|
| 12 | */
|
---|
| 13 |
|
---|
| 14 | #define JPEG_INTERNALS
|
---|
| 15 | #include "jinclude.h"
|
---|
| 16 | #include "jpeglib.h"
|
---|
| 17 |
|
---|
| 18 |
|
---|
| 19 | /* Private state */
|
---|
| 20 |
|
---|
| 21 | typedef struct {
|
---|
| 22 | struct jpeg_input_controller pub; /* public fields */
|
---|
| 23 |
|
---|
| 24 | boolean inheaders; /* TRUE until first SOS is reached */
|
---|
| 25 | } my_input_controller;
|
---|
| 26 |
|
---|
| 27 | typedef my_input_controller * my_inputctl_ptr;
|
---|
| 28 |
|
---|
| 29 |
|
---|
| 30 | /* Forward declarations */
|
---|
| 31 | METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo));
|
---|
| 32 |
|
---|
| 33 |
|
---|
| 34 | /*
|
---|
| 35 | * Routines to calculate various quantities related to the size of the image.
|
---|
| 36 | */
|
---|
| 37 |
|
---|
| 38 | LOCAL(void)
|
---|
| 39 | initial_setup (j_decompress_ptr cinfo)
|
---|
| 40 | /* Called once, when first SOS marker is reached */
|
---|
| 41 | {
|
---|
| 42 | int ci;
|
---|
| 43 | jpeg_component_info *compptr;
|
---|
| 44 |
|
---|
| 45 | /* Make sure image isn't bigger than I can handle */
|
---|
| 46 | if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
|
---|
| 47 | (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
|
---|
| 48 | ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
|
---|
| 49 |
|
---|
| 50 | /* For now, precision must match compiled-in value... */
|
---|
| 51 | if (cinfo->data_precision != BITS_IN_JSAMPLE)
|
---|
| 52 | ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
|
---|
| 53 |
|
---|
| 54 | /* Check that number of components won't exceed internal array sizes */
|
---|
| 55 | if (cinfo->num_components > MAX_COMPONENTS)
|
---|
| 56 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
|
---|
| 57 | MAX_COMPONENTS);
|
---|
| 58 |
|
---|
| 59 | /* Compute maximum sampling factors; check factor validity */
|
---|
| 60 | cinfo->max_h_samp_factor = 1;
|
---|
| 61 | cinfo->max_v_samp_factor = 1;
|
---|
| 62 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
|
---|
| 63 | ci++, compptr++) {
|
---|
| 64 | if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
|
---|
| 65 | compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
|
---|
| 66 | ERREXIT(cinfo, JERR_BAD_SAMPLING);
|
---|
| 67 | cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
|
---|
| 68 | compptr->h_samp_factor);
|
---|
| 69 | cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
|
---|
| 70 | compptr->v_samp_factor);
|
---|
| 71 | }
|
---|
| 72 |
|
---|
| 73 | /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
|
---|
| 74 | * In the full decompressor, this will be overridden by jdmaster.c;
|
---|
| 75 | * but in the transcoder, jdmaster.c is not used, so we must do it here.
|
---|
| 76 | */
|
---|
| 77 | cinfo->min_DCT_scaled_size = DCTSIZE;
|
---|
| 78 |
|
---|
| 79 | /* Compute dimensions of components */
|
---|
| 80 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
|
---|
| 81 | ci++, compptr++) {
|
---|
| 82 | compptr->DCT_scaled_size = DCTSIZE;
|
---|
| 83 | /* Size in DCT blocks */
|
---|
| 84 | compptr->width_in_blocks = (JDIMENSION)
|
---|
| 85 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
|
---|
| 86 | (long) (cinfo->max_h_samp_factor * DCTSIZE));
|
---|
| 87 | compptr->height_in_blocks = (JDIMENSION)
|
---|
| 88 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
|
---|
| 89 | (long) (cinfo->max_v_samp_factor * DCTSIZE));
|
---|
| 90 | /* downsampled_width and downsampled_height will also be overridden by
|
---|
| 91 | * jdmaster.c if we are doing full decompression. The transcoder library
|
---|
| 92 | * doesn't use these values, but the calling application might.
|
---|
| 93 | */
|
---|
| 94 | /* Size in samples */
|
---|
| 95 | compptr->downsampled_width = (JDIMENSION)
|
---|
| 96 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
|
---|
| 97 | (long) cinfo->max_h_samp_factor);
|
---|
| 98 | compptr->downsampled_height = (JDIMENSION)
|
---|
| 99 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
|
---|
| 100 | (long) cinfo->max_v_samp_factor);
|
---|
| 101 | /* Mark component needed, until color conversion says otherwise */
|
---|
| 102 | compptr->component_needed = TRUE;
|
---|
| 103 | /* Mark no quantization table yet saved for component */
|
---|
| 104 | compptr->quant_table = NULL;
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 107 | /* Compute number of fully interleaved MCU rows. */
|
---|
| 108 | cinfo->total_iMCU_rows = (JDIMENSION)
|
---|
| 109 | jdiv_round_up((long) cinfo->image_height,
|
---|
| 110 | (long) (cinfo->max_v_samp_factor*DCTSIZE));
|
---|
| 111 |
|
---|
| 112 | /* Decide whether file contains multiple scans */
|
---|
| 113 | if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
|
---|
| 114 | cinfo->inputctl->has_multiple_scans = TRUE;
|
---|
| 115 | else
|
---|
| 116 | cinfo->inputctl->has_multiple_scans = FALSE;
|
---|
| 117 | }
|
---|
| 118 |
|
---|
| 119 |
|
---|
| 120 | LOCAL(void)
|
---|
| 121 | per_scan_setup (j_decompress_ptr cinfo)
|
---|
| 122 | /* Do computations that are needed before processing a JPEG scan */
|
---|
| 123 | /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
|
---|
| 124 | {
|
---|
| 125 | int ci, mcublks, tmp;
|
---|
| 126 | jpeg_component_info *compptr;
|
---|
| 127 |
|
---|
| 128 | if (cinfo->comps_in_scan == 1) {
|
---|
| 129 |
|
---|
| 130 | /* Noninterleaved (single-component) scan */
|
---|
| 131 | compptr = cinfo->cur_comp_info[0];
|
---|
| 132 |
|
---|
| 133 | /* Overall image size in MCUs */
|
---|
| 134 | cinfo->MCUs_per_row = compptr->width_in_blocks;
|
---|
| 135 | cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
|
---|
| 136 |
|
---|
| 137 | /* For noninterleaved scan, always one block per MCU */
|
---|
| 138 | compptr->MCU_width = 1;
|
---|
| 139 | compptr->MCU_height = 1;
|
---|
| 140 | compptr->MCU_blocks = 1;
|
---|
| 141 | compptr->MCU_sample_width = compptr->DCT_scaled_size;
|
---|
| 142 | compptr->last_col_width = 1;
|
---|
| 143 | /* For noninterleaved scans, it is convenient to define last_row_height
|
---|
| 144 | * as the number of block rows present in the last iMCU row.
|
---|
| 145 | */
|
---|
| 146 | tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
|
---|
| 147 | if (tmp == 0) tmp = compptr->v_samp_factor;
|
---|
| 148 | compptr->last_row_height = tmp;
|
---|
| 149 |
|
---|
| 150 | /* Prepare array describing MCU composition */
|
---|
| 151 | cinfo->blocks_in_MCU = 1;
|
---|
| 152 | cinfo->MCU_membership[0] = 0;
|
---|
| 153 |
|
---|
| 154 | } else {
|
---|
| 155 |
|
---|
| 156 | /* Interleaved (multi-component) scan */
|
---|
| 157 | if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
|
---|
| 158 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
|
---|
| 159 | MAX_COMPS_IN_SCAN);
|
---|
| 160 |
|
---|
| 161 | /* Overall image size in MCUs */
|
---|
| 162 | cinfo->MCUs_per_row = (JDIMENSION)
|
---|
| 163 | jdiv_round_up((long) cinfo->image_width,
|
---|
| 164 | (long) (cinfo->max_h_samp_factor*DCTSIZE));
|
---|
| 165 | cinfo->MCU_rows_in_scan = (JDIMENSION)
|
---|
| 166 | jdiv_round_up((long) cinfo->image_height,
|
---|
| 167 | (long) (cinfo->max_v_samp_factor*DCTSIZE));
|
---|
| 168 |
|
---|
| 169 | cinfo->blocks_in_MCU = 0;
|
---|
| 170 |
|
---|
| 171 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
|
---|
| 172 | compptr = cinfo->cur_comp_info[ci];
|
---|
| 173 | /* Sampling factors give # of blocks of component in each MCU */
|
---|
| 174 | compptr->MCU_width = compptr->h_samp_factor;
|
---|
| 175 | compptr->MCU_height = compptr->v_samp_factor;
|
---|
| 176 | compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
|
---|
| 177 | compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
|
---|
| 178 | /* Figure number of non-dummy blocks in last MCU column & row */
|
---|
| 179 | tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
|
---|
| 180 | if (tmp == 0) tmp = compptr->MCU_width;
|
---|
| 181 | compptr->last_col_width = tmp;
|
---|
| 182 | tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
|
---|
| 183 | if (tmp == 0) tmp = compptr->MCU_height;
|
---|
| 184 | compptr->last_row_height = tmp;
|
---|
| 185 | /* Prepare array describing MCU composition */
|
---|
| 186 | mcublks = compptr->MCU_blocks;
|
---|
| 187 | if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
|
---|
| 188 | ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
|
---|
| 189 | while (mcublks-- > 0) {
|
---|
| 190 | cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
|
---|
| 191 | }
|
---|
| 192 | }
|
---|
| 193 |
|
---|
| 194 | }
|
---|
| 195 | }
|
---|
| 196 |
|
---|
| 197 |
|
---|
| 198 | /*
|
---|
| 199 | * Save away a copy of the Q-table referenced by each component present
|
---|
| 200 | * in the current scan, unless already saved during a prior scan.
|
---|
| 201 | *
|
---|
| 202 | * In a multiple-scan JPEG file, the encoder could assign different components
|
---|
| 203 | * the same Q-table slot number, but change table definitions between scans
|
---|
| 204 | * so that each component uses a different Q-table. (The IJG encoder is not
|
---|
| 205 | * currently capable of doing this, but other encoders might.) Since we want
|
---|
| 206 | * to be able to dequantize all the components at the end of the file, this
|
---|
| 207 | * means that we have to save away the table actually used for each component.
|
---|
| 208 | * We do this by copying the table at the start of the first scan containing
|
---|
| 209 | * the component.
|
---|
| 210 | * The JPEG spec prohibits the encoder from changing the contents of a Q-table
|
---|
| 211 | * slot between scans of a component using that slot. If the encoder does so
|
---|
| 212 | * anyway, this decoder will simply use the Q-table values that were current
|
---|
| 213 | * at the start of the first scan for the component.
|
---|
| 214 | *
|
---|
| 215 | * The decompressor output side looks only at the saved quant tables,
|
---|
| 216 | * not at the current Q-table slots.
|
---|
| 217 | */
|
---|
| 218 |
|
---|
| 219 | LOCAL(void)
|
---|
| 220 | latch_quant_tables (j_decompress_ptr cinfo)
|
---|
| 221 | {
|
---|
| 222 | int ci, qtblno;
|
---|
| 223 | jpeg_component_info *compptr;
|
---|
| 224 | JQUANT_TBL * qtbl;
|
---|
| 225 |
|
---|
| 226 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
|
---|
| 227 | compptr = cinfo->cur_comp_info[ci];
|
---|
| 228 | /* No work if we already saved Q-table for this component */
|
---|
| 229 | if (compptr->quant_table != NULL)
|
---|
| 230 | continue;
|
---|
| 231 | /* Make sure specified quantization table is present */
|
---|
| 232 | qtblno = compptr->quant_tbl_no;
|
---|
| 233 | if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
|
---|
| 234 | cinfo->quant_tbl_ptrs[qtblno] == NULL)
|
---|
| 235 | ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
|
---|
| 236 | /* OK, save away the quantization table */
|
---|
| 237 | qtbl = (JQUANT_TBL *)
|
---|
| 238 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
---|
| 239 | SIZEOF(JQUANT_TBL));
|
---|
| 240 | MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
|
---|
| 241 | compptr->quant_table = qtbl;
|
---|
| 242 | }
|
---|
| 243 | }
|
---|
| 244 |
|
---|
| 245 |
|
---|
| 246 | /*
|
---|
| 247 | * Initialize the input modules to read a scan of compressed data.
|
---|
| 248 | * The first call to this is done by jdmaster.c after initializing
|
---|
| 249 | * the entire decompressor (during jpeg_start_decompress).
|
---|
| 250 | * Subsequent calls come from consume_markers, below.
|
---|
| 251 | */
|
---|
| 252 |
|
---|
| 253 | METHODDEF(void)
|
---|
| 254 | start_input_pass (j_decompress_ptr cinfo)
|
---|
| 255 | {
|
---|
| 256 | per_scan_setup(cinfo);
|
---|
| 257 | latch_quant_tables(cinfo);
|
---|
| 258 | (*cinfo->entropy->start_pass) (cinfo);
|
---|
| 259 | (*cinfo->coef->start_input_pass) (cinfo);
|
---|
| 260 | cinfo->inputctl->consume_input = cinfo->coef->consume_data;
|
---|
| 261 | }
|
---|
| 262 |
|
---|
| 263 |
|
---|
| 264 | /*
|
---|
| 265 | * Finish up after inputting a compressed-data scan.
|
---|
| 266 | * This is called by the coefficient controller after it's read all
|
---|
| 267 | * the expected data of the scan.
|
---|
| 268 | */
|
---|
| 269 |
|
---|
| 270 | METHODDEF(void)
|
---|
| 271 | finish_input_pass (j_decompress_ptr cinfo)
|
---|
| 272 | {
|
---|
| 273 | cinfo->inputctl->consume_input = consume_markers;
|
---|
| 274 | }
|
---|
| 275 |
|
---|
| 276 |
|
---|
| 277 | /*
|
---|
| 278 | * Read JPEG markers before, between, or after compressed-data scans.
|
---|
| 279 | * Change state as necessary when a new scan is reached.
|
---|
| 280 | * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
|
---|
| 281 | *
|
---|
| 282 | * The consume_input method pointer points either here or to the
|
---|
| 283 | * coefficient controller's consume_data routine, depending on whether
|
---|
| 284 | * we are reading a compressed data segment or inter-segment markers.
|
---|
| 285 | */
|
---|
| 286 |
|
---|
| 287 | METHODDEF(int)
|
---|
| 288 | consume_markers (j_decompress_ptr cinfo)
|
---|
| 289 | {
|
---|
| 290 | my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
|
---|
| 291 | int val;
|
---|
| 292 |
|
---|
| 293 | if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
|
---|
| 294 | return JPEG_REACHED_EOI;
|
---|
| 295 |
|
---|
| 296 | val = (*cinfo->marker->read_markers) (cinfo);
|
---|
| 297 |
|
---|
| 298 | switch (val) {
|
---|
| 299 | case JPEG_REACHED_SOS: /* Found SOS */
|
---|
| 300 | if (inputctl->inheaders) { /* 1st SOS */
|
---|
| 301 | initial_setup(cinfo);
|
---|
| 302 | inputctl->inheaders = FALSE;
|
---|
| 303 | /* Note: start_input_pass must be called by jdmaster.c
|
---|
| 304 | * before any more input can be consumed. jdapimin.c is
|
---|
| 305 | * responsible for enforcing this sequencing.
|
---|
| 306 | */
|
---|
| 307 | } else { /* 2nd or later SOS marker */
|
---|
| 308 | if (! inputctl->pub.has_multiple_scans)
|
---|
| 309 | ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
|
---|
| 310 | start_input_pass(cinfo);
|
---|
| 311 | }
|
---|
| 312 | break;
|
---|
| 313 | case JPEG_REACHED_EOI: /* Found EOI */
|
---|
| 314 | inputctl->pub.eoi_reached = TRUE;
|
---|
| 315 | if (inputctl->inheaders) { /* Tables-only datastream, apparently */
|
---|
| 316 | if (cinfo->marker->saw_SOF)
|
---|
| 317 | ERREXIT(cinfo, JERR_SOF_NO_SOS);
|
---|
| 318 | } else {
|
---|
| 319 | /* Prevent infinite loop in coef ctlr's decompress_data routine
|
---|
| 320 | * if user set output_scan_number larger than number of scans.
|
---|
| 321 | */
|
---|
| 322 | if (cinfo->output_scan_number > cinfo->input_scan_number)
|
---|
| 323 | cinfo->output_scan_number = cinfo->input_scan_number;
|
---|
| 324 | }
|
---|
| 325 | break;
|
---|
| 326 | case JPEG_SUSPENDED:
|
---|
| 327 | break;
|
---|
| 328 | }
|
---|
| 329 |
|
---|
| 330 | return val;
|
---|
| 331 | }
|
---|
| 332 |
|
---|
| 333 |
|
---|
| 334 | /*
|
---|
| 335 | * Reset state to begin a fresh datastream.
|
---|
| 336 | */
|
---|
| 337 |
|
---|
| 338 | METHODDEF(void)
|
---|
| 339 | reset_input_controller (j_decompress_ptr cinfo)
|
---|
| 340 | {
|
---|
| 341 | my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
|
---|
| 342 |
|
---|
| 343 | inputctl->pub.consume_input = consume_markers;
|
---|
| 344 | inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
|
---|
| 345 | inputctl->pub.eoi_reached = FALSE;
|
---|
| 346 | inputctl->inheaders = TRUE;
|
---|
| 347 | /* Reset other modules */
|
---|
| 348 | (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
|
---|
| 349 | (*cinfo->marker->reset_marker_reader) (cinfo);
|
---|
| 350 | /* Reset progression state -- would be cleaner if entropy decoder did this */
|
---|
| 351 | cinfo->coef_bits = NULL;
|
---|
| 352 | }
|
---|
| 353 |
|
---|
| 354 |
|
---|
| 355 | /*
|
---|
| 356 | * Initialize the input controller module.
|
---|
| 357 | * This is called only once, when the decompression object is created.
|
---|
| 358 | */
|
---|
| 359 |
|
---|
| 360 | GLOBAL(void)
|
---|
| 361 | jinit_input_controller (j_decompress_ptr cinfo)
|
---|
| 362 | {
|
---|
| 363 | my_inputctl_ptr inputctl;
|
---|
| 364 |
|
---|
| 365 | /* Create subobject in permanent pool */
|
---|
| 366 | inputctl = (my_inputctl_ptr)
|
---|
| 367 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
|
---|
| 368 | SIZEOF(my_input_controller));
|
---|
| 369 | cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
|
---|
| 370 | /* Initialize method pointers */
|
---|
| 371 | inputctl->pub.consume_input = consume_markers;
|
---|
| 372 | inputctl->pub.reset_input_controller = reset_input_controller;
|
---|
| 373 | inputctl->pub.start_input_pass = start_input_pass;
|
---|
| 374 | inputctl->pub.finish_input_pass = finish_input_pass;
|
---|
| 375 | /* Initialize state: can't use reset_input_controller since we don't
|
---|
| 376 | * want to try to reset other modules yet.
|
---|
| 377 | */
|
---|
| 378 | inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
|
---|
| 379 | inputctl->pub.eoi_reached = FALSE;
|
---|
| 380 | inputctl->inheaders = TRUE;
|
---|
| 381 | }
|
---|