Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 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 | }>=>>>>= |