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