Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 1 | /* |
2 | * jcmaster.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 compressor. |
||
9 | * These routines are concerned with parameter validation, initial setup, |
||
10 | * and inter-pass control (determining the number of passes and the work |
||
11 | * to be done in each pass). |
||
12 | */ |
||
13 | |||
14 | #define JPEG_INTERNALS |
||
15 | #include "jinclude.h" |
||
16 | #include "jpeglib.h" |
||
17 | |||
18 | |||
19 | /* Private state */ |
||
20 | |||
21 | typedef enum { |
||
22 | main_pass, /* input data, also do first output step */ |
||
23 | huff_opt_pass, /* Huffman code optimization pass */ |
||
24 | output_pass /* data output pass */ |
||
25 | } c_pass_type; |
||
26 | |||
27 | typedef struct { |
||
28 | struct jpeg_comp_master pub; /* public fields */ |
||
29 | |||
30 | c_pass_type pass_type; /* the type of the current pass */ |
||
31 | |||
32 | int pass_number; /* # of passes completed */ |
||
33 | int total_passes; /* total # of passes needed */ |
||
34 | |||
35 | int scan_number; /* current index in scan_info[] */ |
||
36 | } my_comp_master; |
||
37 | |||
38 | typedef my_comp_master * my_master_ptr; |
||
39 | |||
40 | |||
41 | /* |
||
42 | * Support routines that do various essential calculations. |
||
43 | */ |
||
44 | |||
45 | LOCAL(void) |
||
46 | initial_setup (j_compress_ptr cinfo) |
||
47 | /* Do computations that are needed before master selection phase */ |
||
48 | { |
||
49 | int ci; |
||
50 | jpeg_component_info *compptr; |
||
51 | long samplesperrow; |
||
52 | JDIMENSION jd_samplesperrow; |
||
53 | |||
54 | /* Sanity check on image dimensions */ |
||
55 | if (cinfo->image_height <= 0 || cinfo->image_width <= 0 |
||
56 | || cinfo->num_components <= 0 || cinfo->input_components <= 0) |
||
57 | ERREXIT(cinfo, JERR_EMPTY_IMAGE); |
||
58 | |||
59 | /* Make sure image isn't bigger than I can handle */ |
||
60 | if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || |
||
61 | (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) |
||
62 | ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); |
||
63 | |||
64 | /* Width of an input scanline must be representable as JDIMENSION. */ |
||
65 | samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components; |
||
66 | jd_samplesperrow = (JDIMENSION) samplesperrow; |
||
67 | if ((long) jd_samplesperrow != samplesperrow) |
||
68 | ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); |
||
69 | |||
70 | /* For now, precision must match compiled-in value... */ |
||
71 | if (cinfo->data_precision != BITS_IN_JSAMPLE) |
||
72 | ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); |
||
73 | |||
74 | /* Check that number of components won't exceed internal array sizes */ |
||
75 | if (cinfo->num_components > MAX_COMPONENTS) |
||
76 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, |
||
77 | MAX_COMPONENTS); |
||
78 | |||
79 | /* Compute maximum sampling factors; check factor validity */ |
||
80 | cinfo->max_h_samp_factor = 1; |
||
81 | cinfo->max_v_samp_factor = 1; |
||
82 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
83 | ci++, compptr++) { |
||
84 | if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || |
||
85 | compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) |
||
86 | ERREXIT(cinfo, JERR_BAD_SAMPLING); |
||
87 | cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, |
||
88 | compptr->h_samp_factor); |
||
89 | cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, |
||
90 | compptr->v_samp_factor); |
||
91 | } |
||
92 | |||
93 | /* Compute dimensions of components */ |
||
94 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
95 | ci++, compptr++) { |
||
96 | /* Fill in the correct component_index value; don't rely on application */ |
||
97 | compptr->component_index = ci; |
||
98 | /* For compression, we never do DCT scaling. */ |
||
99 | compptr->DCT_scaled_size = DCTSIZE; |
||
100 | /* Size in DCT blocks */ |
||
101 | compptr->width_in_blocks = (JDIMENSION) |
||
102 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, |
||
103 | (long) (cinfo->max_h_samp_factor * DCTSIZE)); |
||
104 | compptr->height_in_blocks = (JDIMENSION) |
||
105 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, |
||
106 | (long) (cinfo->max_v_samp_factor * DCTSIZE)); |
||
107 | /* Size in samples */ |
||
108 | compptr->downsampled_width = (JDIMENSION) |
||
109 | jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, |
||
110 | (long) cinfo->max_h_samp_factor); |
||
111 | compptr->downsampled_height = (JDIMENSION) |
||
112 | jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, |
||
113 | (long) cinfo->max_v_samp_factor); |
||
114 | /* Mark component needed (this flag isn't actually used for compression) */ |
||
115 | compptr->component_needed = TRUE; |
||
116 | } |
||
117 | |||
118 | /* Compute number of fully interleaved MCU rows (number of times that |
||
119 | * main controller will call coefficient controller). |
||
120 | */ |
||
121 | cinfo->total_iMCU_rows = (JDIMENSION) |
||
122 | jdiv_round_up((long) cinfo->image_height, |
||
123 | (long) (cinfo->max_v_samp_factor*DCTSIZE)); |
||
124 | } |
||
125 | |||
126 | |||
127 | #ifdef C_MULTISCAN_FILES_SUPPORTED |
||
128 | |||
129 | LOCAL(void) |
||
130 | validate_script (j_compress_ptr cinfo) |
||
131 | /* Verify that the scan script in cinfo->scan_info[] is valid; also |
||
132 | * determine whether it uses progressive JPEG, and set cinfo->progressive_mode. |
||
133 | */ |
||
134 | { |
||
135 | const jpeg_scan_info * scanptr; |
||
136 | int scanno, ncomps, ci, coefi, thisi; |
||
137 | int Ss, Se, Ah, Al; |
||
138 | boolean component_sent[MAX_COMPONENTS]; |
||
139 | #ifdef C_PROGRESSIVE_SUPPORTED |
||
140 | int * last_bitpos_ptr; |
||
141 | int last_bitpos[MAX_COMPONENTS][DCTSIZE2]; |
||
142 | /* -1 until that coefficient has been seen; then last Al for it */ |
||
143 | #endif |
||
144 | |||
145 | if (cinfo->num_scans <= 0) |
||
146 | ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0); |
||
147 | |||
148 | /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1; |
||
149 | * for progressive JPEG, no scan can have this. |
||
150 | */ |
||
151 | scanptr = cinfo->scan_info; |
||
152 | if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) { |
||
153 | #ifdef C_PROGRESSIVE_SUPPORTED |
||
154 | cinfo->progressive_mode = TRUE; |
||
155 | last_bitpos_ptr = & last_bitpos[0][0]; |
||
156 | for (ci = 0; ci < cinfo->num_components; ci++) |
||
157 | for (coefi = 0; coefi < DCTSIZE2; coefi++) |
||
158 | *last_bitpos_ptr++ = -1; |
||
159 | #else |
||
160 | ERREXIT(cinfo, JERR_NOT_COMPILED); |
||
161 | #endif |
||
162 | } else { |
||
163 | cinfo->progressive_mode = FALSE; |
||
164 | for (ci = 0; ci < cinfo->num_components; ci++) |
||
165 | component_sent[ci] = FALSE; |
||
166 | } |
||
167 | |||
168 | for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) { |
||
169 | /* Validate component indexes */ |
||
170 | ncomps = scanptr->comps_in_scan; |
||
171 | if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN) |
||
172 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN); |
||
173 | for (ci = 0; ci < ncomps; ci++) { |
||
174 | thisi = scanptr->component_index[ci]; |
||
175 | if (thisi < 0 || thisi >= cinfo->num_components) |
||
176 | ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); |
||
177 | /* Components must appear in SOF order within each scan */ |
||
178 | if (ci > 0 && thisi <= scanptr->component_index[ci-1]) |
||
179 | ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); |
||
180 | } |
||
181 | /* Validate progression parameters */ |
||
182 | Ss = scanptr->Ss; |
||
183 | Se = scanptr->Se; |
||
184 | Ah = scanptr->Ah; |
||
185 | Al = scanptr->Al; |
||
186 | if (cinfo->progressive_mode) { |
||
187 | #ifdef C_PROGRESSIVE_SUPPORTED |
||
188 | /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that |
||
189 | * seems wrong: the upper bound ought to depend on data precision. |
||
190 | * Perhaps they really meant 0..N+1 for N-bit precision. |
||
191 | * Here we allow 0..10 for 8-bit data; Al larger than 10 results in |
||
192 | * out-of-range reconstructed DC values during the first DC scan, |
||
193 | * which might cause problems for some decoders. |
||
194 | */ |
||
195 | #if BITS_IN_JSAMPLE == 8 |
||
196 | #define MAX_AH_AL 10 |
||
197 | #else |
||
198 | #define MAX_AH_AL 13 |
||
199 | #endif |
||
200 | if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 || |
||
201 | Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL) |
||
202 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
203 | if (Ss == 0) { |
||
204 | if (Se != 0) /* DC and AC together not OK */ |
||
205 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
206 | } else { |
||
207 | if (ncomps != 1) /* AC scans must be for only one component */ |
||
208 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
209 | } |
||
210 | for (ci = 0; ci < ncomps; ci++) { |
||
211 | last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0]; |
||
212 | if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */ |
||
213 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
214 | for (coefi = Ss; coefi <= Se; coefi++) { |
||
215 | if (last_bitpos_ptr[coefi] < 0) { |
||
216 | /* first scan of this coefficient */ |
||
217 | if (Ah != 0) |
||
218 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
219 | } else { |
||
220 | /* not first scan */ |
||
221 | if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1) |
||
222 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
223 | } |
||
224 | last_bitpos_ptr[coefi] = Al; |
||
225 | } |
||
226 | } |
||
227 | #endif |
||
228 | } else { |
||
229 | /* For sequential JPEG, all progression parameters must be these: */ |
||
230 | if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0) |
||
231 | ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); |
||
232 | /* Make sure components are not sent twice */ |
||
233 | for (ci = 0; ci < ncomps; ci++) { |
||
234 | thisi = scanptr->component_index[ci]; |
||
235 | if (component_sent[thisi]) |
||
236 | ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); |
||
237 | component_sent[thisi] = TRUE; |
||
238 | } |
||
239 | } |
||
240 | } |
||
241 | |||
242 | /* Now verify that everything got sent. */ |
||
243 | if (cinfo->progressive_mode) { |
||
244 | #ifdef C_PROGRESSIVE_SUPPORTED |
||
245 | /* For progressive mode, we only check that at least some DC data |
||
246 | * got sent for each component; the spec does not require that all bits |
||
247 | * of all coefficients be transmitted. Would it be wiser to enforce |
||
248 | * transmission of all coefficient bits?? |
||
249 | */ |
||
250 | for (ci = 0; ci < cinfo->num_components; ci++) { |
||
251 | if (last_bitpos[ci][0] < 0) |
||
252 | ERREXIT(cinfo, JERR_MISSING_DATA); |
||
253 | } |
||
254 | #endif |
||
255 | } else { |
||
256 | for (ci = 0; ci < cinfo->num_components; ci++) { |
||
257 | if (! component_sent[ci]) |
||
258 | ERREXIT(cinfo, JERR_MISSING_DATA); |
||
259 | } |
||
260 | } |
||
261 | } |
||
262 | |||
263 | #endif /* C_MULTISCAN_FILES_SUPPORTED */ |
||
264 | |||
265 | |||
266 | LOCAL(void) |
||
267 | select_scan_parameters (j_compress_ptr cinfo) |
||
268 | /* Set up the scan parameters for the current scan */ |
||
269 | { |
||
270 | int ci; |
||
271 | |||
272 | #ifdef C_MULTISCAN_FILES_SUPPORTED |
||
273 | if (cinfo->scan_info != NULL) { |
||
274 | /* Prepare for current scan --- the script is already validated */ |
||
275 | my_master_ptr master = (my_master_ptr) cinfo->master; |
||
276 | const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number; |
||
277 | |||
278 | cinfo->comps_in_scan = scanptr->comps_in_scan; |
||
279 | for (ci = 0; ci < scanptr->comps_in_scan; ci++) { |
||
280 | cinfo->cur_comp_info[ci] = |
||
281 | &cinfo->comp_info[scanptr->component_index[ci]]; |
||
282 | } |
||
283 | cinfo->Ss = scanptr->Ss; |
||
284 | cinfo->Se = scanptr->Se; |
||
285 | cinfo->Ah = scanptr->Ah; |
||
286 | cinfo->Al = scanptr->Al; |
||
287 | } |
||
288 | else |
||
289 | #endif |
||
290 | { |
||
291 | /* Prepare for single sequential-JPEG scan containing all components */ |
||
292 | if (cinfo->num_components > MAX_COMPS_IN_SCAN) |
||
293 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, |
||
294 | MAX_COMPS_IN_SCAN); |
||
295 | cinfo->comps_in_scan = cinfo->num_components; |
||
296 | for (ci = 0; ci < cinfo->num_components; ci++) { |
||
297 | cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci]; |
||
298 | } |
||
299 | cinfo->Ss = 0; |
||
300 | cinfo->Se = DCTSIZE2-1; |
||
301 | cinfo->Ah = 0; |
||
302 | cinfo->Al = 0; |
||
303 | } |
||
304 | } |
||
305 | |||
306 | |||
307 | LOCAL(void) |
||
308 | per_scan_setup (j_compress_ptr cinfo) |
||
309 | /* Do computations that are needed before processing a JPEG scan */ |
||
310 | /* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */ |
||
311 | { |
||
312 | int ci, mcublks, tmp; |
||
313 | jpeg_component_info *compptr; |
||
314 | |||
315 | if (cinfo->comps_in_scan == 1) { |
||
316 | |||
317 | /* Noninterleaved (single-component) scan */ |
||
318 | compptr = cinfo->cur_comp_info[0]; |
||
319 | |||
320 | /* Overall image size in MCUs */ |
||
321 | cinfo->MCUs_per_row = compptr->width_in_blocks; |
||
322 | cinfo->MCU_rows_in_scan = compptr->height_in_blocks; |
||
323 | |||
324 | /* For noninterleaved scan, always one block per MCU */ |
||
325 | compptr->MCU_width = 1; |
||
326 | compptr->MCU_height = 1; |
||
327 | compptr->MCU_blocks = 1; |
||
328 | compptr->MCU_sample_width = DCTSIZE; |
||
329 | compptr->last_col_width = 1; |
||
330 | /* For noninterleaved scans, it is convenient to define last_row_height |
||
331 | * as the number of block rows present in the last iMCU row. |
||
332 | */ |
||
333 | tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); |
||
334 | if (tmp == 0) tmp = compptr->v_samp_factor; |
||
335 | compptr->last_row_height = tmp; |
||
336 | |||
337 | /* Prepare array describing MCU composition */ |
||
338 | cinfo->blocks_in_MCU = 1; |
||
339 | cinfo->MCU_membership[0] = 0; |
||
340 | |||
341 | } else { |
||
342 | |||
343 | /* Interleaved (multi-component) scan */ |
||
344 | if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) |
||
345 | ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, |
||
346 | MAX_COMPS_IN_SCAN); |
||
347 | |||
348 | /* Overall image size in MCUs */ |
||
349 | cinfo->MCUs_per_row = (JDIMENSION) |
||
350 | jdiv_round_up((long) cinfo->image_width, |
||
351 | (long) (cinfo->max_h_samp_factor*DCTSIZE)); |
||
352 | cinfo->MCU_rows_in_scan = (JDIMENSION) |
||
353 | jdiv_round_up((long) cinfo->image_height, |
||
354 | (long) (cinfo->max_v_samp_factor*DCTSIZE)); |
||
355 | |||
356 | cinfo->blocks_in_MCU = 0; |
||
357 | |||
358 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
||
359 | compptr = cinfo->cur_comp_info[ci]; |
||
360 | /* Sampling factors give # of blocks of component in each MCU */ |
||
361 | compptr->MCU_width = compptr->h_samp_factor; |
||
362 | compptr->MCU_height = compptr->v_samp_factor; |
||
363 | compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; |
||
364 | compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE; |
||
365 | /* Figure number of non-dummy blocks in last MCU column & row */ |
||
366 | tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); |
||
367 | if (tmp == 0) tmp = compptr->MCU_width; |
||
368 | compptr->last_col_width = tmp; |
||
369 | tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); |
||
370 | if (tmp == 0) tmp = compptr->MCU_height; |
||
371 | compptr->last_row_height = tmp; |
||
372 | /* Prepare array describing MCU composition */ |
||
373 | mcublks = compptr->MCU_blocks; |
||
374 | if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU) |
||
375 | ERREXIT(cinfo, JERR_BAD_MCU_SIZE); |
||
376 | while (mcublks-- > 0) { |
||
377 | cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; |
||
378 | } |
||
379 | } |
||
380 | |||
381 | } |
||
382 | |||
383 | /* Convert restart specified in rows to actual MCU count. */ |
||
384 | /* Note that count must fit in 16 bits, so we provide limiting. */ |
||
385 | if (cinfo->restart_in_rows > 0) { |
||
386 | long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row; |
||
387 | cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L); |
||
388 | } |
||
389 | } |
||
390 | |||
391 | |||
392 | /* |
||
393 | * Per-pass setup. |
||
394 | * This is called at the beginning of each pass. We determine which modules |
||
395 | * will be active during this pass and give them appropriate start_pass calls. |
||
396 | * We also set is_last_pass to indicate whether any more passes will be |
||
397 | * required. |
||
398 | */ |
||
399 | |||
400 | METHODDEF(void) |
||
401 | prepare_for_pass (j_compress_ptr cinfo) |
||
402 | { |
||
403 | my_master_ptr master = (my_master_ptr) cinfo->master; |
||
404 | |||
405 | switch (master->pass_type) { |
||
406 | case main_pass: |
||
407 | /* Initial pass: will collect input data, and do either Huffman |
||
408 | * optimization or data output for the first scan. |
||
409 | */ |
||
410 | select_scan_parameters(cinfo); |
||
411 | per_scan_setup(cinfo); |
||
412 | if (! cinfo->raw_data_in) { |
||
413 | (*cinfo->cconvert->start_pass) (cinfo); |
||
414 | (*cinfo->downsample->start_pass) (cinfo); |
||
415 | (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU); |
||
416 | } |
||
417 | (*cinfo->fdct->start_pass) (cinfo); |
||
418 | (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding); |
||
419 | (*cinfo->coef->start_pass) (cinfo, |
||
420 | (master->total_passes > 1 ? |
||
421 | JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); |
||
422 | (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); |
||
423 | if (cinfo->optimize_coding) { |
||
424 | /* No immediate data output; postpone writing frame/scan headers */ |
||
425 | master->pub.call_pass_startup = FALSE; |
||
426 | } else { |
||
427 | /* Will write frame/scan headers at first jpeg_write_scanlines call */ |
||
428 | master->pub.call_pass_startup = TRUE; |
||
429 | } |
||
430 | break; |
||
431 | #ifdef ENTROPY_OPT_SUPPORTED |
||
432 | case huff_opt_pass: |
||
433 | /* Do Huffman optimization for a scan after the first one. */ |
||
434 | select_scan_parameters(cinfo); |
||
435 | per_scan_setup(cinfo); |
||
436 | if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) { |
||
437 | (*cinfo->entropy->start_pass) (cinfo, TRUE); |
||
438 | (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); |
||
439 | master->pub.call_pass_startup = FALSE; |
||
440 | break; |
||
441 | } |
||
442 | /* Special case: Huffman DC refinement scans need no Huffman table |
||
443 | * and therefore we can skip the optimization pass for them. |
||
444 | */ |
||
445 | master->pass_type = output_pass; |
||
446 | master->pass_number++; |
||
447 | /*FALLTHROUGH*/ |
||
448 | #endif |
||
449 | case output_pass: |
||
450 | /* Do a data-output pass. */ |
||
451 | /* We need not repeat per-scan setup if prior optimization pass did it. */ |
||
452 | if (! cinfo->optimize_coding) { |
||
453 | select_scan_parameters(cinfo); |
||
454 | per_scan_setup(cinfo); |
||
455 | } |
||
456 | (*cinfo->entropy->start_pass) (cinfo, FALSE); |
||
457 | (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); |
||
458 | /* We emit frame/scan headers now */ |
||
459 | if (master->scan_number == 0) |
||
460 | (*cinfo->marker->write_frame_header) (cinfo); |
||
461 | (*cinfo->marker->write_scan_header) (cinfo); |
||
462 | master->pub.call_pass_startup = FALSE; |
||
463 | break; |
||
464 | default: |
||
465 | ERREXIT(cinfo, JERR_NOT_COMPILED); |
||
466 | } |
||
467 | |||
468 | master->pub.is_last_pass = (master->pass_number == master->total_passes-1); |
||
469 | |||
470 | /* Set up progress monitor's pass info if present */ |
||
471 | if (cinfo->progress != NULL) { |
||
472 | cinfo->progress->completed_passes = master->pass_number; |
||
473 | cinfo->progress->total_passes = master->total_passes; |
||
474 | } |
||
475 | } |
||
476 | |||
477 | |||
478 | /* |
||
479 | * Special start-of-pass hook. |
||
480 | * This is called by jpeg_write_scanlines if call_pass_startup is TRUE. |
||
481 | * In single-pass processing, we need this hook because we don't want to |
||
482 | * write frame/scan headers during jpeg_start_compress; we want to let the |
||
483 | * application write COM markers etc. between jpeg_start_compress and the |
||
484 | * jpeg_write_scanlines loop. |
||
485 | * In multi-pass processing, this routine is not used. |
||
486 | */ |
||
487 | |||
488 | METHODDEF(void) |
||
489 | pass_startup (j_compress_ptr cinfo) |
||
490 | { |
||
491 | cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */ |
||
492 | |||
493 | (*cinfo->marker->write_frame_header) (cinfo); |
||
494 | (*cinfo->marker->write_scan_header) (cinfo); |
||
495 | } |
||
496 | |||
497 | |||
498 | /* |
||
499 | * Finish up at end of pass. |
||
500 | */ |
||
501 | |||
502 | METHODDEF(void) |
||
503 | finish_pass_master (j_compress_ptr cinfo) |
||
504 | { |
||
505 | my_master_ptr master = (my_master_ptr) cinfo->master; |
||
506 | |||
507 | /* The entropy coder always needs an end-of-pass call, |
||
508 | * either to analyze statistics or to flush its output buffer. |
||
509 | */ |
||
510 | (*cinfo->entropy->finish_pass) (cinfo); |
||
511 | |||
512 | /* Update state for next pass */ |
||
513 | switch (master->pass_type) { |
||
514 | case main_pass: |
||
515 | /* next pass is either output of scan 0 (after optimization) |
||
516 | * or output of scan 1 (if no optimization). |
||
517 | */ |
||
518 | master->pass_type = output_pass; |
||
519 | if (! cinfo->optimize_coding) |
||
520 | master->scan_number++; |
||
521 | break; |
||
522 | case huff_opt_pass: |
||
523 | /* next pass is always output of current scan */ |
||
524 | master->pass_type = output_pass; |
||
525 | break; |
||
526 | case output_pass: |
||
527 | /* next pass is either optimization or output of next scan */ |
||
528 | if (cinfo->optimize_coding) |
||
529 | master->pass_type = huff_opt_pass; |
||
530 | master->scan_number++; |
||
531 | break; |
||
532 | } |
||
533 | |||
534 | master->pass_number++; |
||
535 | } |
||
536 | |||
537 | |||
538 | /* |
||
539 | * Initialize master compression control. |
||
540 | */ |
||
541 | |||
542 | GLOBAL(void) |
||
543 | jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only) |
||
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_comp_master)); |
||
550 | cinfo->master = (struct jpeg_comp_master *) master; |
||
551 | master->pub.prepare_for_pass = prepare_for_pass; |
||
552 | master->pub.pass_startup = pass_startup; |
||
553 | master->pub.finish_pass = finish_pass_master; |
||
554 | master->pub.is_last_pass = FALSE; |
||
555 | |||
556 | /* Validate parameters, determine derived values */ |
||
557 | initial_setup(cinfo); |
||
558 | |||
559 | if (cinfo->scan_info != NULL) { |
||
560 | #ifdef C_MULTISCAN_FILES_SUPPORTED |
||
561 | validate_script(cinfo); |
||
562 | #else |
||
563 | ERREXIT(cinfo, JERR_NOT_COMPILED); |
||
564 | #endif |
||
565 | } else { |
||
566 | cinfo->progressive_mode = FALSE; |
||
567 | cinfo->num_scans = 1; |
||
568 | } |
||
569 | |||
570 | if (cinfo->progressive_mode) /* TEMPORARY HACK ??? */ |
||
571 | cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */ |
||
572 | |||
573 | /* Initialize my private state */ |
||
574 | if (transcode_only) { |
||
575 | /* no main pass in transcoding */ |
||
576 | if (cinfo->optimize_coding) |
||
577 | master->pass_type = huff_opt_pass; |
||
578 | else |
||
579 | master->pass_type = output_pass; |
||
580 | } else { |
||
581 | /* for normal compression, first pass is always this type: */ |
||
582 | master->pass_type = main_pass; |
||
583 | } |
||
584 | master->scan_number = 0; |
||
585 | master->pass_number = 0; |
||
586 | if (cinfo->optimize_coding) |
||
587 | master->total_passes = cinfo->num_scans * 2; |
||
588 | else |
||
589 | master->total_passes = cinfo->num_scans; |
||
590 | }>=>>>>>>>>=>>>>>>>=>>>=>=>>>>=>>=0>=0>>=>=>=>=> |