|
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_components; |
|
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 } |