vrshoot

annotate libs/libjpeg/jdmaster.c @ 0:b2f14e535253

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sat, 01 Feb 2014 19:58:19 +0200
parents
children
rev   line source
nuclear@0 1 /*
nuclear@0 2 * jdmaster.c
nuclear@0 3 *
nuclear@0 4 * Copyright (C) 1991-1997, Thomas G. Lane.
nuclear@0 5 * This file is part of the Independent JPEG Group's software.
nuclear@0 6 * For conditions of distribution and use, see the accompanying README file.
nuclear@0 7 *
nuclear@0 8 * This file contains master control logic for the JPEG decompressor.
nuclear@0 9 * These routines are concerned with selecting the modules to be executed
nuclear@0 10 * and with determining the number of passes and the work to be done in each
nuclear@0 11 * pass.
nuclear@0 12 */
nuclear@0 13
nuclear@0 14 #define JPEG_INTERNALS
nuclear@0 15 #include "jinclude.h"
nuclear@0 16 #include "jpeglib.h"
nuclear@0 17
nuclear@0 18
nuclear@0 19 /* Private state */
nuclear@0 20
nuclear@0 21 typedef struct {
nuclear@0 22 struct jpeg_decomp_master pub; /* public fields */
nuclear@0 23
nuclear@0 24 int pass_number; /* # of passes completed */
nuclear@0 25
nuclear@0 26 boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
nuclear@0 27
nuclear@0 28 /* Saved references to initialized quantizer modules,
nuclear@0 29 * in case we need to switch modes.
nuclear@0 30 */
nuclear@0 31 struct jpeg_color_quantizer * quantizer_1pass;
nuclear@0 32 struct jpeg_color_quantizer * quantizer_2pass;
nuclear@0 33 } my_decomp_master;
nuclear@0 34
nuclear@0 35 typedef my_decomp_master * my_master_ptr;
nuclear@0 36
nuclear@0 37
nuclear@0 38 /*
nuclear@0 39 * Determine whether merged upsample/color conversion should be used.
nuclear@0 40 * CRUCIAL: this must match the actual capabilities of jdmerge.c!
nuclear@0 41 */
nuclear@0 42
nuclear@0 43 LOCAL(boolean)
nuclear@0 44 use_merged_upsample (j_decompress_ptr cinfo)
nuclear@0 45 {
nuclear@0 46 #ifdef UPSAMPLE_MERGING_SUPPORTED
nuclear@0 47 /* Merging is the equivalent of plain box-filter upsampling */
nuclear@0 48 if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
nuclear@0 49 return FALSE;
nuclear@0 50 /* jdmerge.c only supports YCC=>RGB color conversion */
nuclear@0 51 if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
nuclear@0 52 cinfo->out_color_space != JCS_RGB ||
nuclear@0 53 cinfo->out_color_components != RGB_PIXELSIZE)
nuclear@0 54 return FALSE;
nuclear@0 55 /* and it only handles 2h1v or 2h2v sampling ratios */
nuclear@0 56 if (cinfo->comp_info[0].h_samp_factor != 2 ||
nuclear@0 57 cinfo->comp_info[1].h_samp_factor != 1 ||
nuclear@0 58 cinfo->comp_info[2].h_samp_factor != 1 ||
nuclear@0 59 cinfo->comp_info[0].v_samp_factor > 2 ||
nuclear@0 60 cinfo->comp_info[1].v_samp_factor != 1 ||
nuclear@0 61 cinfo->comp_info[2].v_samp_factor != 1)
nuclear@0 62 return FALSE;
nuclear@0 63 /* furthermore, it doesn't work if we've scaled the IDCTs differently */
nuclear@0 64 if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
nuclear@0 65 cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
nuclear@0 66 cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
nuclear@0 67 return FALSE;
nuclear@0 68 /* ??? also need to test for upsample-time rescaling, when & if supported */
nuclear@0 69 return TRUE; /* by golly, it'll work... */
nuclear@0 70 #else
nuclear@0 71 return FALSE;
nuclear@0 72 #endif
nuclear@0 73 }
nuclear@0 74
nuclear@0 75
nuclear@0 76 /*
nuclear@0 77 * Compute output image dimensions and related values.
nuclear@0 78 * NOTE: this is exported for possible use by application.
nuclear@0 79 * Hence it mustn't do anything that can't be done twice.
nuclear@0 80 * Also note that it may be called before the master module is initialized!
nuclear@0 81 */
nuclear@0 82
nuclear@0 83 GLOBAL(void)
nuclear@0 84 jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
nuclear@0 85 /* Do computations that are needed before master selection phase */
nuclear@0 86 {
nuclear@0 87 #ifdef IDCT_SCALING_SUPPORTED
nuclear@0 88 int ci;
nuclear@0 89 jpeg_component_info *compptr;
nuclear@0 90 #endif
nuclear@0 91
nuclear@0 92 /* Prevent application from calling me at wrong times */
nuclear@0 93 if (cinfo->global_state != DSTATE_READY)
nuclear@0 94 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
nuclear@0 95
nuclear@0 96 #ifdef IDCT_SCALING_SUPPORTED
nuclear@0 97
nuclear@0 98 /* Compute actual output image dimensions and DCT scaling choices. */
nuclear@0 99 if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
nuclear@0 100 /* Provide 1/8 scaling */
nuclear@0 101 cinfo->output_width = (JDIMENSION)
nuclear@0 102 jdiv_round_up((long) cinfo->image_width, 8L);
nuclear@0 103 cinfo->output_height = (JDIMENSION)
nuclear@0 104 jdiv_round_up((long) cinfo->image_height, 8L);
nuclear@0 105 cinfo->min_DCT_scaled_size = 1;
nuclear@0 106 } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
nuclear@0 107 /* Provide 1/4 scaling */
nuclear@0 108 cinfo->output_width = (JDIMENSION)
nuclear@0 109 jdiv_round_up((long) cinfo->image_width, 4L);
nuclear@0 110 cinfo->output_height = (JDIMENSION)
nuclear@0 111 jdiv_round_up((long) cinfo->image_height, 4L);
nuclear@0 112 cinfo->min_DCT_scaled_size = 2;
nuclear@0 113 } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
nuclear@0 114 /* Provide 1/2 scaling */
nuclear@0 115 cinfo->output_width = (JDIMENSION)
nuclear@0 116 jdiv_round_up((long) cinfo->image_width, 2L);
nuclear@0 117 cinfo->output_height = (JDIMENSION)
nuclear@0 118 jdiv_round_up((long) cinfo->image_height, 2L);
nuclear@0 119 cinfo->min_DCT_scaled_size = 4;
nuclear@0 120 } else {
nuclear@0 121 /* Provide 1/1 scaling */
nuclear@0 122 cinfo->output_width = cinfo->image_width;
nuclear@0 123 cinfo->output_height = cinfo->image_height;
nuclear@0 124 cinfo->min_DCT_scaled_size = DCTSIZE;
nuclear@0 125 }
nuclear@0 126 /* In selecting the actual DCT scaling for each component, we try to
nuclear@0 127 * scale up the chroma components via IDCT scaling rather than upsampling.
nuclear@0 128 * This saves time if the upsampler gets to use 1:1 scaling.
nuclear@0 129 * Note this code assumes that the supported DCT scalings are powers of 2.
nuclear@0 130 */
nuclear@0 131 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
nuclear@0 132 ci++, compptr++) {
nuclear@0 133 int ssize = cinfo->min_DCT_scaled_size;
nuclear@0 134 while (ssize < DCTSIZE &&
nuclear@0 135 (compptr->h_samp_factor * ssize * 2 <=
nuclear@0 136 cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
nuclear@0 137 (compptr->v_samp_factor * ssize * 2 <=
nuclear@0 138 cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
nuclear@0 139 ssize = ssize * 2;
nuclear@0 140 }
nuclear@0 141 compptr->DCT_scaled_size = ssize;
nuclear@0 142 }
nuclear@0 143
nuclear@0 144 /* Recompute downsampled dimensions of components;
nuclear@0 145 * application needs to know these if using raw downsampled data.
nuclear@0 146 */
nuclear@0 147 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
nuclear@0 148 ci++, compptr++) {
nuclear@0 149 /* Size in samples, after IDCT scaling */
nuclear@0 150 compptr->downsampled_width = (JDIMENSION)
nuclear@0 151 jdiv_round_up((long) cinfo->image_width *
nuclear@0 152 (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
nuclear@0 153 (long) (cinfo->max_h_samp_factor * DCTSIZE));
nuclear@0 154 compptr->downsampled_height = (JDIMENSION)
nuclear@0 155 jdiv_round_up((long) cinfo->image_height *
nuclear@0 156 (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
nuclear@0 157 (long) (cinfo->max_v_samp_factor * DCTSIZE));
nuclear@0 158 }
nuclear@0 159
nuclear@0 160 #else /* !IDCT_SCALING_SUPPORTED */
nuclear@0 161
nuclear@0 162 /* Hardwire it to "no scaling" */
nuclear@0 163 cinfo->output_width = cinfo->image_width;
nuclear@0 164 cinfo->output_height = cinfo->image_height;
nuclear@0 165 /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
nuclear@0 166 * and has computed unscaled downsampled_width and downsampled_height.
nuclear@0 167 */
nuclear@0 168
nuclear@0 169 #endif /* IDCT_SCALING_SUPPORTED */
nuclear@0 170
nuclear@0 171 /* Report number of components in selected colorspace. */
nuclear@0 172 /* Probably this should be in the color conversion module... */
nuclear@0 173 switch (cinfo->out_color_space) {
nuclear@0 174 case JCS_GRAYSCALE:
nuclear@0 175 cinfo->out_color_components = 1;
nuclear@0 176 break;
nuclear@0 177 case JCS_RGB:
nuclear@0 178 #if RGB_PIXELSIZE != 3
nuclear@0 179 cinfo->out_color_components = RGB_PIXELSIZE;
nuclear@0 180 break;
nuclear@0 181 #endif /* else share code with YCbCr */
nuclear@0 182 case JCS_YCbCr:
nuclear@0 183 cinfo->out_color_components = 3;
nuclear@0 184 break;
nuclear@0 185 case JCS_CMYK:
nuclear@0 186 case JCS_YCCK:
nuclear@0 187 cinfo->out_color_components = 4;
nuclear@0 188 break;
nuclear@0 189 default: /* else must be same colorspace as in file */
nuclear@0 190 cinfo->out_color_components = cinfo->num_components;
nuclear@0 191 break;
nuclear@0 192 }
nuclear@0 193 cinfo->output_components = (cinfo->quantize_colors ? 1 :
nuclear@0 194 cinfo->out_color_components);
nuclear@0 195
nuclear@0 196 /* See if upsampler will want to emit more than one row at a time */
nuclear@0 197 if (use_merged_upsample(cinfo))
nuclear@0 198 cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
nuclear@0 199 else
nuclear@0 200 cinfo->rec_outbuf_height = 1;
nuclear@0 201 }
nuclear@0 202
nuclear@0 203
nuclear@0 204 /*
nuclear@0 205 * Several decompression processes need to range-limit values to the range
nuclear@0 206 * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
nuclear@0 207 * due to noise introduced by quantization, roundoff error, etc. These
nuclear@0 208 * processes are inner loops and need to be as fast as possible. On most
nuclear@0 209 * machines, particularly CPUs with pipelines or instruction prefetch,
nuclear@0 210 * a (subscript-check-less) C table lookup
nuclear@0 211 * x = sample_range_limit[x];
nuclear@0 212 * is faster than explicit tests
nuclear@0 213 * if (x < 0) x = 0;
nuclear@0 214 * else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
nuclear@0 215 * These processes all use a common table prepared by the routine below.
nuclear@0 216 *
nuclear@0 217 * For most steps we can mathematically guarantee that the initial value
nuclear@0 218 * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
nuclear@0 219 * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial
nuclear@0 220 * limiting step (just after the IDCT), a wildly out-of-range value is
nuclear@0 221 * possible if the input data is corrupt. To avoid any chance of indexing
nuclear@0 222 * off the end of memory and getting a bad-pointer trap, we perform the
nuclear@0 223 * post-IDCT limiting thus:
nuclear@0 224 * x = range_limit[x & MASK];
nuclear@0 225 * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
nuclear@0 226 * samples. Under normal circumstances this is more than enough range and
nuclear@0 227 * a correct output will be generated; with bogus input data the mask will
nuclear@0 228 * cause wraparound, and we will safely generate a bogus-but-in-range output.
nuclear@0 229 * For the post-IDCT step, we want to convert the data from signed to unsigned
nuclear@0 230 * representation by adding CENTERJSAMPLE at the same time that we limit it.
nuclear@0 231 * So the post-IDCT limiting table ends up looking like this:
nuclear@0 232 * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
nuclear@0 233 * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
nuclear@0 234 * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
nuclear@0 235 * 0,1,...,CENTERJSAMPLE-1
nuclear@0 236 * Negative inputs select values from the upper half of the table after
nuclear@0 237 * masking.
nuclear@0 238 *
nuclear@0 239 * We can save some space by overlapping the start of the post-IDCT table
nuclear@0 240 * with the simpler range limiting table. The post-IDCT table begins at
nuclear@0 241 * sample_range_limit + CENTERJSAMPLE.
nuclear@0 242 *
nuclear@0 243 * Note that the table is allocated in near data space on PCs; it's small
nuclear@0 244 * enough and used often enough to justify this.
nuclear@0 245 */
nuclear@0 246
nuclear@0 247 LOCAL(void)
nuclear@0 248 prepare_range_limit_table (j_decompress_ptr cinfo)
nuclear@0 249 /* Allocate and fill in the sample_range_limit table */
nuclear@0 250 {
nuclear@0 251 JSAMPLE * table;
nuclear@0 252 int i;
nuclear@0 253
nuclear@0 254 table = (JSAMPLE *)
nuclear@0 255 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
nuclear@0 256 (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
nuclear@0 257 table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */
nuclear@0 258 cinfo->sample_range_limit = table;
nuclear@0 259 /* First segment of "simple" table: limit[x] = 0 for x < 0 */
nuclear@0 260 MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
nuclear@0 261 /* Main part of "simple" table: limit[x] = x */
nuclear@0 262 for (i = 0; i <= MAXJSAMPLE; i++)
nuclear@0 263 table[i] = (JSAMPLE) i;
nuclear@0 264 table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */
nuclear@0 265 /* End of simple table, rest of first half of post-IDCT table */
nuclear@0 266 for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
nuclear@0 267 table[i] = MAXJSAMPLE;
nuclear@0 268 /* Second half of post-IDCT table */
nuclear@0 269 MEMZERO(table + (2 * (MAXJSAMPLE+1)),
nuclear@0 270 (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
nuclear@0 271 MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
nuclear@0 272 cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
nuclear@0 273 }
nuclear@0 274
nuclear@0 275
nuclear@0 276 /*
nuclear@0 277 * Master selection of decompression modules.
nuclear@0 278 * This is done once at jpeg_start_decompress time. We determine
nuclear@0 279 * which modules will be used and give them appropriate initialization calls.
nuclear@0 280 * We also initialize the decompressor input side to begin consuming data.
nuclear@0 281 *
nuclear@0 282 * Since jpeg_read_header has finished, we know what is in the SOF
nuclear@0 283 * and (first) SOS markers. We also have all the application parameter
nuclear@0 284 * settings.
nuclear@0 285 */
nuclear@0 286
nuclear@0 287 LOCAL(void)
nuclear@0 288 master_selection (j_decompress_ptr cinfo)
nuclear@0 289 {
nuclear@0 290 my_master_ptr master = (my_master_ptr) cinfo->master;
nuclear@0 291 boolean use_c_buffer;
nuclear@0 292 long samplesperrow;
nuclear@0 293 JDIMENSION jd_samplesperrow;
nuclear@0 294
nuclear@0 295 /* Initialize dimensions and other stuff */
nuclear@0 296 jpeg_calc_output_dimensions(cinfo);
nuclear@0 297 prepare_range_limit_table(cinfo);
nuclear@0 298
nuclear@0 299 /* Width of an output scanline must be representable as JDIMENSION. */
nuclear@0 300 samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
nuclear@0 301 jd_samplesperrow = (JDIMENSION) samplesperrow;
nuclear@0 302 if ((long) jd_samplesperrow != samplesperrow)
nuclear@0 303 ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
nuclear@0 304
nuclear@0 305 /* Initialize my private state */
nuclear@0 306 master->pass_number = 0;
nuclear@0 307 master->using_merged_upsample = use_merged_upsample(cinfo);
nuclear@0 308
nuclear@0 309 /* Color quantizer selection */
nuclear@0 310 master->quantizer_1pass = NULL;
nuclear@0 311 master->quantizer_2pass = NULL;
nuclear@0 312 /* No mode changes if not using buffered-image mode. */
nuclear@0 313 if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
nuclear@0 314 cinfo->enable_1pass_quant = FALSE;
nuclear@0 315 cinfo->enable_external_quant = FALSE;
nuclear@0 316 cinfo->enable_2pass_quant = FALSE;
nuclear@0 317 }
nuclear@0 318 if (cinfo->quantize_colors) {
nuclear@0 319 if (cinfo->raw_data_out)
nuclear@0 320 ERREXIT(cinfo, JERR_NOTIMPL);
nuclear@0 321 /* 2-pass quantizer only works in 3-component color space. */
nuclear@0 322 if (cinfo->out_color_components != 3) {
nuclear@0 323 cinfo->enable_1pass_quant = TRUE;
nuclear@0 324 cinfo->enable_external_quant = FALSE;
nuclear@0 325 cinfo->enable_2pass_quant = FALSE;
nuclear@0 326 cinfo->colormap = NULL;
nuclear@0 327 } else if (cinfo->colormap != NULL) {
nuclear@0 328 cinfo->enable_external_quant = TRUE;
nuclear@0 329 } else if (cinfo->two_pass_quantize) {
nuclear@0 330 cinfo->enable_2pass_quant = TRUE;
nuclear@0 331 } else {
nuclear@0 332 cinfo->enable_1pass_quant = TRUE;
nuclear@0 333 }
nuclear@0 334
nuclear@0 335 if (cinfo->enable_1pass_quant) {
nuclear@0 336 #ifdef QUANT_1PASS_SUPPORTED
nuclear@0 337 jinit_1pass_quantizer(cinfo);
nuclear@0 338 master->quantizer_1pass = cinfo->cquantize;
nuclear@0 339 #else
nuclear@0 340 ERREXIT(cinfo, JERR_NOT_COMPILED);
nuclear@0 341 #endif
nuclear@0 342 }
nuclear@0 343
nuclear@0 344 /* We use the 2-pass code to map to external colormaps. */
nuclear@0 345 if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
nuclear@0 346 #ifdef QUANT_2PASS_SUPPORTED
nuclear@0 347 jinit_2pass_quantizer(cinfo);
nuclear@0 348 master->quantizer_2pass = cinfo->cquantize;
nuclear@0 349 #else
nuclear@0 350 ERREXIT(cinfo, JERR_NOT_COMPILED);
nuclear@0 351 #endif
nuclear@0 352 }
nuclear@0 353 /* If both quantizers are initialized, the 2-pass one is left active;
nuclear@0 354 * this is necessary for starting with quantization to an external map.
nuclear@0 355 */
nuclear@0 356 }
nuclear@0 357
nuclear@0 358 /* Post-processing: in particular, color conversion first */
nuclear@0 359 if (! cinfo->raw_data_out) {
nuclear@0 360 if (master->using_merged_upsample) {
nuclear@0 361 #ifdef UPSAMPLE_MERGING_SUPPORTED
nuclear@0 362 jinit_merged_upsampler(cinfo); /* does color conversion too */
nuclear@0 363 #else
nuclear@0 364 ERREXIT(cinfo, JERR_NOT_COMPILED);
nuclear@0 365 #endif
nuclear@0 366 } else {
nuclear@0 367 jinit_color_deconverter(cinfo);
nuclear@0 368 jinit_upsampler(cinfo);
nuclear@0 369 }
nuclear@0 370 jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
nuclear@0 371 }
nuclear@0 372 /* Inverse DCT */
nuclear@0 373 jinit_inverse_dct(cinfo);
nuclear@0 374 /* Entropy decoding: either Huffman or arithmetic coding. */
nuclear@0 375 if (cinfo->arith_code) {
nuclear@0 376 ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
nuclear@0 377 } else {
nuclear@0 378 if (cinfo->progressive_mode) {
nuclear@0 379 #ifdef D_PROGRESSIVE_SUPPORTED
nuclear@0 380 jinit_phuff_decoder(cinfo);
nuclear@0 381 #else
nuclear@0 382 ERREXIT(cinfo, JERR_NOT_COMPILED);
nuclear@0 383 #endif
nuclear@0 384 } else
nuclear@0 385 jinit_huff_decoder(cinfo);
nuclear@0 386 }
nuclear@0 387
nuclear@0 388 /* Initialize principal buffer controllers. */
nuclear@0 389 use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
nuclear@0 390 jinit_d_coef_controller(cinfo, use_c_buffer);
nuclear@0 391
nuclear@0 392 if (! cinfo->raw_data_out)
nuclear@0 393 jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
nuclear@0 394
nuclear@0 395 /* We can now tell the memory manager to allocate virtual arrays. */
nuclear@0 396 (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
nuclear@0 397
nuclear@0 398 /* Initialize input side of decompressor to consume first scan. */
nuclear@0 399 (*cinfo->inputctl->start_input_pass) (cinfo);
nuclear@0 400
nuclear@0 401 #ifdef D_MULTISCAN_FILES_SUPPORTED
nuclear@0 402 /* If jpeg_start_decompress will read the whole file, initialize
nuclear@0 403 * progress monitoring appropriately. The input step is counted
nuclear@0 404 * as one pass.
nuclear@0 405 */
nuclear@0 406 if (cinfo->progress != NULL && ! cinfo->buffered_image &&
nuclear@0 407 cinfo->inputctl->has_multiple_scans) {
nuclear@0 408 int nscans;
nuclear@0 409 /* Estimate number of scans to set pass_limit. */
nuclear@0 410 if (cinfo->progressive_mode) {
nuclear@0 411 /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
nuclear@0 412 nscans = 2 + 3 * cinfo->num_components;
nuclear@0 413 } else {
nuclear@0 414 /* For a nonprogressive multiscan file, estimate 1 scan per component. */
nuclear@0 415 nscans = cinfo->num_components;
nuclear@0 416 }
nuclear@0 417 cinfo->progress->pass_counter = 0L;
nuclear@0 418 cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
nuclear@0 419 cinfo->progress->completed_passes = 0;
nuclear@0 420 cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
nuclear@0 421 /* Count the input pass as done */
nuclear@0 422 master->pass_number++;
nuclear@0 423 }
nuclear@0 424 #endif /* D_MULTISCAN_FILES_SUPPORTED */
nuclear@0 425 }
nuclear@0 426
nuclear@0 427
nuclear@0 428 /*
nuclear@0 429 * Per-pass setup.
nuclear@0 430 * This is called at the beginning of each output pass. We determine which
nuclear@0 431 * modules will be active during this pass and give them appropriate
nuclear@0 432 * start_pass calls. We also set is_dummy_pass to indicate whether this
nuclear@0 433 * is a "real" output pass or a dummy pass for color quantization.
nuclear@0 434 * (In the latter case, jdapistd.c will crank the pass to completion.)
nuclear@0 435 */
nuclear@0 436
nuclear@0 437 METHODDEF(void)
nuclear@0 438 prepare_for_output_pass (j_decompress_ptr cinfo)
nuclear@0 439 {
nuclear@0 440 my_master_ptr master = (my_master_ptr) cinfo->master;
nuclear@0 441
nuclear@0 442 if (master->pub.is_dummy_pass) {
nuclear@0 443 #ifdef QUANT_2PASS_SUPPORTED
nuclear@0 444 /* Final pass of 2-pass quantization */
nuclear@0 445 master->pub.is_dummy_pass = FALSE;
nuclear@0 446 (*cinfo->cquantize->start_pass) (cinfo, FALSE);
nuclear@0 447 (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
nuclear@0 448 (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
nuclear@0 449 #else
nuclear@0 450 ERREXIT(cinfo, JERR_NOT_COMPILED);
nuclear@0 451 #endif /* QUANT_2PASS_SUPPORTED */
nuclear@0 452 } else {
nuclear@0 453 if (cinfo->quantize_colors && cinfo->colormap == NULL) {
nuclear@0 454 /* Select new quantization method */
nuclear@0 455 if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
nuclear@0 456 cinfo->cquantize = master->quantizer_2pass;
nuclear@0 457 master->pub.is_dummy_pass = TRUE;
nuclear@0 458 } else if (cinfo->enable_1pass_quant) {
nuclear@0 459 cinfo->cquantize = master->quantizer_1pass;
nuclear@0 460 } else {
nuclear@0 461 ERREXIT(cinfo, JERR_MODE_CHANGE);
nuclear@0 462 }
nuclear@0 463 }
nuclear@0 464 (*cinfo->idct->start_pass) (cinfo);
nuclear@0 465 (*cinfo->coef->start_output_pass) (cinfo);
nuclear@0 466 if (! cinfo->raw_data_out) {
nuclear@0 467 if (! master->using_merged_upsample)
nuclear@0 468 (*cinfo->cconvert->start_pass) (cinfo);
nuclear@0 469 (*cinfo->upsample->start_pass) (cinfo);
nuclear@0 470 if (cinfo->quantize_colors)
nuclear@0 471 (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
nuclear@0 472 (*cinfo->post->start_pass) (cinfo,
nuclear@0 473 (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
nuclear@0 474 (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
nuclear@0 475 }
nuclear@0 476 }
nuclear@0 477
nuclear@0 478 /* Set up progress monitor's pass info if present */
nuclear@0 479 if (cinfo->progress != NULL) {
nuclear@0 480 cinfo->progress->completed_passes = master->pass_number;
nuclear@0 481 cinfo->progress->total_passes = master->pass_number +
nuclear@0 482 (master->pub.is_dummy_pass ? 2 : 1);
nuclear@0 483 /* In buffered-image mode, we assume one more output pass if EOI not
nuclear@0 484 * yet reached, but no more passes if EOI has been reached.
nuclear@0 485 */
nuclear@0 486 if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
nuclear@0 487 cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
nuclear@0 488 }
nuclear@0 489 }
nuclear@0 490 }
nuclear@0 491
nuclear@0 492
nuclear@0 493 /*
nuclear@0 494 * Finish up at end of an output pass.
nuclear@0 495 */
nuclear@0 496
nuclear@0 497 METHODDEF(void)
nuclear@0 498 finish_output_pass (j_decompress_ptr cinfo)
nuclear@0 499 {
nuclear@0 500 my_master_ptr master = (my_master_ptr) cinfo->master;
nuclear@0 501
nuclear@0 502 if (cinfo->quantize_colors)
nuclear@0 503 (*cinfo->cquantize->finish_pass) (cinfo);
nuclear@0 504 master->pass_number++;
nuclear@0 505 }
nuclear@0 506
nuclear@0 507
nuclear@0 508 #ifdef D_MULTISCAN_FILES_SUPPORTED
nuclear@0 509
nuclear@0 510 /*
nuclear@0 511 * Switch to a new external colormap between output passes.
nuclear@0 512 */
nuclear@0 513
nuclear@0 514 GLOBAL(void)
nuclear@0 515 jpeg_new_colormap (j_decompress_ptr cinfo)
nuclear@0 516 {
nuclear@0 517 my_master_ptr master = (my_master_ptr) cinfo->master;
nuclear@0 518
nuclear@0 519 /* Prevent application from calling me at wrong times */
nuclear@0 520 if (cinfo->global_state != DSTATE_BUFIMAGE)
nuclear@0 521 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
nuclear@0 522
nuclear@0 523 if (cinfo->quantize_colors && cinfo->enable_external_quant &&
nuclear@0 524 cinfo->colormap != NULL) {
nuclear@0 525 /* Select 2-pass quantizer for external colormap use */
nuclear@0 526 cinfo->cquantize = master->quantizer_2pass;
nuclear@0 527 /* Notify quantizer of colormap change */
nuclear@0 528 (*cinfo->cquantize->new_color_map) (cinfo);
nuclear@0 529 master->pub.is_dummy_pass = FALSE; /* just in case */
nuclear@0 530 } else
nuclear@0 531 ERREXIT(cinfo, JERR_MODE_CHANGE);
nuclear@0 532 }
nuclear@0 533
nuclear@0 534 #endif /* D_MULTISCAN_FILES_SUPPORTED */
nuclear@0 535
nuclear@0 536
nuclear@0 537 /*
nuclear@0 538 * Initialize master decompression control and select active modules.
nuclear@0 539 * This is performed at the start of jpeg_start_decompress.
nuclear@0 540 */
nuclear@0 541
nuclear@0 542 GLOBAL(void)
nuclear@0 543 jinit_master_decompress (j_decompress_ptr cinfo)
nuclear@0 544 {
nuclear@0 545 my_master_ptr master;
nuclear@0 546
nuclear@0 547 master = (my_master_ptr)
nuclear@0 548 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
nuclear@0 549 SIZEOF(my_decomp_master));
nuclear@0 550 cinfo->master = (struct jpeg_decomp_master *) master;
nuclear@0 551 master->pub.prepare_for_output_pass = prepare_for_output_pass;
nuclear@0 552 master->pub.finish_output_pass = finish_output_pass;
nuclear@0 553
nuclear@0 554 master->pub.is_dummy_pass = FALSE;
nuclear@0 555
nuclear@0 556 master_selection(cinfo);
nuclear@0 557 }