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