4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1991-1997, Thomas G. Lane.
6 * Modified 2003-2010 by Guido Vollbeding.
7 * libjpeg-turbo Modifications:
8 * Copyright (C) 2010, 2016, 2018, D. R. Commander.
9 * For conditions of distribution and use, see the accompanying README.ijg
12 * This file contains master control logic for the JPEG compressor.
13 * These routines are concerned with parameter validation, initial setup,
14 * and inter-pass control (determining the number of passes and the work
15 * to be done in each pass).
18 #define JPEG_INTERNALS
27 main_pass
, /* input data, also do first output step */
28 huff_opt_pass
, /* Huffman code optimization pass */
29 output_pass
/* data output pass */
33 struct jpeg_comp_master pub
; /* public fields */
35 c_pass_type pass_type
; /* the type of the current pass */
37 int pass_number
; /* # of passes completed */
38 int total_passes
; /* total # of passes needed */
40 int scan_number
; /* current index in scan_info[] */
43 * This is here so we can add libjpeg-turbo version/build information to the
44 * global string table without introducing a new global symbol. Adding this
45 * information to the global string table allows one to examine a binary
46 * object and determine which version of libjpeg-turbo it was built from or
49 const char *jpeg_version
;
53 typedef my_comp_master
*my_master_ptr
;
57 * Support routines that do various essential calculations.
60 #if JPEG_LIB_VERSION >= 70
62 * Compute JPEG image dimensions and related values.
63 * NOTE: this is exported for possible use by application.
64 * Hence it mustn't do anything that can't be done twice.
68 jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo
)
69 /* Do computations that are needed before master selection phase */
71 /* Hardwire it to "no scaling" */
72 cinfo
->jpeg_width
= cinfo
->image_width
;
73 cinfo
->jpeg_height
= cinfo
->image_height
;
74 cinfo
->min_DCT_h_scaled_size
= DCTSIZE
;
75 cinfo
->min_DCT_v_scaled_size
= DCTSIZE
;
81 initial_setup(j_compress_ptr cinfo
, boolean transcode_only
)
82 /* Do computations that are needed before master selection phase */
85 jpeg_component_info
*compptr
;
87 JDIMENSION jd_samplesperrow
;
89 #if JPEG_LIB_VERSION >= 70
90 #if JPEG_LIB_VERSION >= 80
93 jpeg_calc_jpeg_dimensions(cinfo
);
96 /* Sanity check on image dimensions */
97 if (cinfo
->_jpeg_height
<= 0 || cinfo
->_jpeg_width
<= 0 ||
98 cinfo
->num_components
<= 0 || cinfo
->input_components
<= 0)
99 ERREXIT(cinfo
, JERR_EMPTY_IMAGE
);
101 /* Make sure image isn't bigger than I can handle */
102 if ((long)cinfo
->_jpeg_height
> (long)JPEG_MAX_DIMENSION
||
103 (long)cinfo
->_jpeg_width
> (long)JPEG_MAX_DIMENSION
)
104 ERREXIT1(cinfo
, JERR_IMAGE_TOO_BIG
, (unsigned int)JPEG_MAX_DIMENSION
);
106 /* Width of an input scanline must be representable as JDIMENSION. */
107 samplesperrow
= (long)cinfo
->image_width
* (long)cinfo
->input_components
;
108 jd_samplesperrow
= (JDIMENSION
)samplesperrow
;
109 if ((long)jd_samplesperrow
!= samplesperrow
)
110 ERREXIT(cinfo
, JERR_WIDTH_OVERFLOW
);
112 /* For now, precision must match compiled-in value... */
113 if (cinfo
->data_precision
!= BITS_IN_JSAMPLE
)
114 ERREXIT1(cinfo
, JERR_BAD_PRECISION
, cinfo
->data_precision
);
116 /* Check that number of components won't exceed internal array sizes */
117 if (cinfo
->num_components
> MAX_COMPONENTS
)
118 ERREXIT2(cinfo
, JERR_COMPONENT_COUNT
, cinfo
->num_components
,
121 /* Compute maximum sampling factors; check factor validity */
122 cinfo
->max_h_samp_factor
= 1;
123 cinfo
->max_v_samp_factor
= 1;
124 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
126 if (compptr
->h_samp_factor
<= 0 ||
127 compptr
->h_samp_factor
> MAX_SAMP_FACTOR
||
128 compptr
->v_samp_factor
<= 0 ||
129 compptr
->v_samp_factor
> MAX_SAMP_FACTOR
)
130 ERREXIT(cinfo
, JERR_BAD_SAMPLING
);
131 cinfo
->max_h_samp_factor
= MAX(cinfo
->max_h_samp_factor
,
132 compptr
->h_samp_factor
);
133 cinfo
->max_v_samp_factor
= MAX(cinfo
->max_v_samp_factor
,
134 compptr
->v_samp_factor
);
137 /* Compute dimensions of components */
138 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
140 /* Fill in the correct component_index value; don't rely on application */
141 compptr
->component_index
= ci
;
142 /* For compression, we never do DCT scaling. */
143 #if JPEG_LIB_VERSION >= 70
144 compptr
->DCT_h_scaled_size
= compptr
->DCT_v_scaled_size
= DCTSIZE
;
146 compptr
->DCT_scaled_size
= DCTSIZE
;
148 /* Size in DCT blocks */
149 compptr
->width_in_blocks
= (JDIMENSION
)
150 jdiv_round_up((long)cinfo
->_jpeg_width
* (long)compptr
->h_samp_factor
,
151 (long)(cinfo
->max_h_samp_factor
* DCTSIZE
));
152 compptr
->height_in_blocks
= (JDIMENSION
)
153 jdiv_round_up((long)cinfo
->_jpeg_height
* (long)compptr
->v_samp_factor
,
154 (long)(cinfo
->max_v_samp_factor
* DCTSIZE
));
155 /* Size in samples */
156 compptr
->downsampled_width
= (JDIMENSION
)
157 jdiv_round_up((long)cinfo
->_jpeg_width
* (long)compptr
->h_samp_factor
,
158 (long)cinfo
->max_h_samp_factor
);
159 compptr
->downsampled_height
= (JDIMENSION
)
160 jdiv_round_up((long)cinfo
->_jpeg_height
* (long)compptr
->v_samp_factor
,
161 (long)cinfo
->max_v_samp_factor
);
162 /* Mark component needed (this flag isn't actually used for compression) */
163 compptr
->component_needed
= TRUE
;
166 /* Compute number of fully interleaved MCU rows (number of times that
167 * main controller will call coefficient controller).
169 cinfo
->total_iMCU_rows
= (JDIMENSION
)
170 jdiv_round_up((long)cinfo
->_jpeg_height
,
171 (long)(cinfo
->max_v_samp_factor
* DCTSIZE
));
175 #ifdef C_MULTISCAN_FILES_SUPPORTED
178 validate_script(j_compress_ptr cinfo
)
179 /* Verify that the scan script in cinfo->scan_info[] is valid; also
180 * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
183 const jpeg_scan_info
*scanptr
;
184 int scanno
, ncomps
, ci
, coefi
, thisi
;
186 boolean component_sent
[MAX_COMPONENTS
];
187 #ifdef C_PROGRESSIVE_SUPPORTED
188 int *last_bitpos_ptr
;
189 int last_bitpos
[MAX_COMPONENTS
][DCTSIZE2
];
190 /* -1 until that coefficient has been seen; then last Al for it */
193 if (cinfo
->num_scans
<= 0)
194 ERREXIT1(cinfo
, JERR_BAD_SCAN_SCRIPT
, 0);
196 /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
197 * for progressive JPEG, no scan can have this.
199 scanptr
= cinfo
->scan_info
;
200 if (scanptr
->Ss
!= 0 || scanptr
->Se
!= DCTSIZE2
- 1) {
201 #ifdef C_PROGRESSIVE_SUPPORTED
202 cinfo
->progressive_mode
= TRUE
;
203 last_bitpos_ptr
= &last_bitpos
[0][0];
204 for (ci
= 0; ci
< cinfo
->num_components
; ci
++)
205 for (coefi
= 0; coefi
< DCTSIZE2
; coefi
++)
206 *last_bitpos_ptr
++ = -1;
208 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
211 cinfo
->progressive_mode
= FALSE
;
212 for (ci
= 0; ci
< cinfo
->num_components
; ci
++)
213 component_sent
[ci
] = FALSE
;
216 for (scanno
= 1; scanno
<= cinfo
->num_scans
; scanptr
++, scanno
++) {
217 /* Validate component indexes */
218 ncomps
= scanptr
->comps_in_scan
;
219 if (ncomps
<= 0 || ncomps
> MAX_COMPS_IN_SCAN
)
220 ERREXIT2(cinfo
, JERR_COMPONENT_COUNT
, ncomps
, MAX_COMPS_IN_SCAN
);
221 for (ci
= 0; ci
< ncomps
; ci
++) {
222 thisi
= scanptr
->component_index
[ci
];
223 if (thisi
< 0 || thisi
>= cinfo
->num_components
)
224 ERREXIT1(cinfo
, JERR_BAD_SCAN_SCRIPT
, scanno
);
225 /* Components must appear in SOF order within each scan */
226 if (ci
> 0 && thisi
<= scanptr
->component_index
[ci
- 1])
227 ERREXIT1(cinfo
, JERR_BAD_SCAN_SCRIPT
, scanno
);
229 /* Validate progression parameters */
234 if (cinfo
->progressive_mode
) {
235 #ifdef C_PROGRESSIVE_SUPPORTED
236 /* Rec. ITU-T T.81 | ISO/IEC 10918-1 simply gives the ranges 0..13 for Ah
237 * and Al, but that seems wrong: the upper bound ought to depend on data
238 * precision. Perhaps they really meant 0..N+1 for N-bit precision.
239 * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
240 * out-of-range reconstructed DC values during the first DC scan,
241 * which might cause problems for some decoders.
243 #if BITS_IN_JSAMPLE == 8
248 if (Ss
< 0 || Ss
>= DCTSIZE2
|| Se
< Ss
|| Se
>= DCTSIZE2
||
249 Ah
< 0 || Ah
> MAX_AH_AL
|| Al
< 0 || Al
> MAX_AH_AL
)
250 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
252 if (Se
!= 0) /* DC and AC together not OK */
253 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
255 if (ncomps
!= 1) /* AC scans must be for only one component */
256 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
258 for (ci
= 0; ci
< ncomps
; ci
++) {
259 last_bitpos_ptr
= &last_bitpos
[scanptr
->component_index
[ci
]][0];
260 if (Ss
!= 0 && last_bitpos_ptr
[0] < 0) /* AC without prior DC scan */
261 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
262 for (coefi
= Ss
; coefi
<= Se
; coefi
++) {
263 if (last_bitpos_ptr
[coefi
] < 0) {
264 /* first scan of this coefficient */
266 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
269 if (Ah
!= last_bitpos_ptr
[coefi
] || Al
!= Ah
- 1)
270 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
272 last_bitpos_ptr
[coefi
] = Al
;
277 /* For sequential JPEG, all progression parameters must be these: */
278 if (Ss
!= 0 || Se
!= DCTSIZE2
- 1 || Ah
!= 0 || Al
!= 0)
279 ERREXIT1(cinfo
, JERR_BAD_PROG_SCRIPT
, scanno
);
280 /* Make sure components are not sent twice */
281 for (ci
= 0; ci
< ncomps
; ci
++) {
282 thisi
= scanptr
->component_index
[ci
];
283 if (component_sent
[thisi
])
284 ERREXIT1(cinfo
, JERR_BAD_SCAN_SCRIPT
, scanno
);
285 component_sent
[thisi
] = TRUE
;
290 /* Now verify that everything got sent. */
291 if (cinfo
->progressive_mode
) {
292 #ifdef C_PROGRESSIVE_SUPPORTED
293 /* For progressive mode, we only check that at least some DC data
294 * got sent for each component; the spec does not require that all bits
295 * of all coefficients be transmitted. Would it be wiser to enforce
296 * transmission of all coefficient bits??
298 for (ci
= 0; ci
< cinfo
->num_components
; ci
++) {
299 if (last_bitpos
[ci
][0] < 0)
300 ERREXIT(cinfo
, JERR_MISSING_DATA
);
304 for (ci
= 0; ci
< cinfo
->num_components
; ci
++) {
305 if (!component_sent
[ci
])
306 ERREXIT(cinfo
, JERR_MISSING_DATA
);
311 #endif /* C_MULTISCAN_FILES_SUPPORTED */
315 select_scan_parameters(j_compress_ptr cinfo
)
316 /* Set up the scan parameters for the current scan */
320 #ifdef C_MULTISCAN_FILES_SUPPORTED
321 if (cinfo
->scan_info
!= NULL
) {
322 /* Prepare for current scan --- the script is already validated */
323 my_master_ptr master
= (my_master_ptr
)cinfo
->master
;
324 const jpeg_scan_info
*scanptr
= cinfo
->scan_info
+ master
->scan_number
;
326 cinfo
->comps_in_scan
= scanptr
->comps_in_scan
;
327 for (ci
= 0; ci
< scanptr
->comps_in_scan
; ci
++) {
328 cinfo
->cur_comp_info
[ci
] =
329 &cinfo
->comp_info
[scanptr
->component_index
[ci
]];
331 cinfo
->Ss
= scanptr
->Ss
;
332 cinfo
->Se
= scanptr
->Se
;
333 cinfo
->Ah
= scanptr
->Ah
;
334 cinfo
->Al
= scanptr
->Al
;
338 /* Prepare for single sequential-JPEG scan containing all components */
339 if (cinfo
->num_components
> MAX_COMPS_IN_SCAN
)
340 ERREXIT2(cinfo
, JERR_COMPONENT_COUNT
, cinfo
->num_components
,
342 cinfo
->comps_in_scan
= cinfo
->num_components
;
343 for (ci
= 0; ci
< cinfo
->num_components
; ci
++) {
344 cinfo
->cur_comp_info
[ci
] = &cinfo
->comp_info
[ci
];
347 cinfo
->Se
= DCTSIZE2
- 1;
355 per_scan_setup(j_compress_ptr cinfo
)
356 /* Do computations that are needed before processing a JPEG scan */
357 /* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
359 int ci
, mcublks
, tmp
;
360 jpeg_component_info
*compptr
;
362 if (cinfo
->comps_in_scan
== 1) {
364 /* Noninterleaved (single-component) scan */
365 compptr
= cinfo
->cur_comp_info
[0];
367 /* Overall image size in MCUs */
368 cinfo
->MCUs_per_row
= compptr
->width_in_blocks
;
369 cinfo
->MCU_rows_in_scan
= compptr
->height_in_blocks
;
371 /* For noninterleaved scan, always one block per MCU */
372 compptr
->MCU_width
= 1;
373 compptr
->MCU_height
= 1;
374 compptr
->MCU_blocks
= 1;
375 compptr
->MCU_sample_width
= DCTSIZE
;
376 compptr
->last_col_width
= 1;
377 /* For noninterleaved scans, it is convenient to define last_row_height
378 * as the number of block rows present in the last iMCU row.
380 tmp
= (int)(compptr
->height_in_blocks
% compptr
->v_samp_factor
);
381 if (tmp
== 0) tmp
= compptr
->v_samp_factor
;
382 compptr
->last_row_height
= tmp
;
384 /* Prepare array describing MCU composition */
385 cinfo
->blocks_in_MCU
= 1;
386 cinfo
->MCU_membership
[0] = 0;
390 /* Interleaved (multi-component) scan */
391 if (cinfo
->comps_in_scan
<= 0 || cinfo
->comps_in_scan
> MAX_COMPS_IN_SCAN
)
392 ERREXIT2(cinfo
, JERR_COMPONENT_COUNT
, cinfo
->comps_in_scan
,
395 /* Overall image size in MCUs */
396 cinfo
->MCUs_per_row
= (JDIMENSION
)
397 jdiv_round_up((long)cinfo
->_jpeg_width
,
398 (long)(cinfo
->max_h_samp_factor
* DCTSIZE
));
399 cinfo
->MCU_rows_in_scan
= (JDIMENSION
)
400 jdiv_round_up((long)cinfo
->_jpeg_height
,
401 (long)(cinfo
->max_v_samp_factor
* DCTSIZE
));
403 cinfo
->blocks_in_MCU
= 0;
405 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
406 compptr
= cinfo
->cur_comp_info
[ci
];
407 /* Sampling factors give # of blocks of component in each MCU */
408 compptr
->MCU_width
= compptr
->h_samp_factor
;
409 compptr
->MCU_height
= compptr
->v_samp_factor
;
410 compptr
->MCU_blocks
= compptr
->MCU_width
* compptr
->MCU_height
;
411 compptr
->MCU_sample_width
= compptr
->MCU_width
* DCTSIZE
;
412 /* Figure number of non-dummy blocks in last MCU column & row */
413 tmp
= (int)(compptr
->width_in_blocks
% compptr
->MCU_width
);
414 if (tmp
== 0) tmp
= compptr
->MCU_width
;
415 compptr
->last_col_width
= tmp
;
416 tmp
= (int)(compptr
->height_in_blocks
% compptr
->MCU_height
);
417 if (tmp
== 0) tmp
= compptr
->MCU_height
;
418 compptr
->last_row_height
= tmp
;
419 /* Prepare array describing MCU composition */
420 mcublks
= compptr
->MCU_blocks
;
421 if (cinfo
->blocks_in_MCU
+ mcublks
> C_MAX_BLOCKS_IN_MCU
)
422 ERREXIT(cinfo
, JERR_BAD_MCU_SIZE
);
423 while (mcublks
-- > 0) {
424 cinfo
->MCU_membership
[cinfo
->blocks_in_MCU
++] = ci
;
430 /* Convert restart specified in rows to actual MCU count. */
431 /* Note that count must fit in 16 bits, so we provide limiting. */
432 if (cinfo
->restart_in_rows
> 0) {
433 long nominal
= (long)cinfo
->restart_in_rows
* (long)cinfo
->MCUs_per_row
;
434 cinfo
->restart_interval
= (unsigned int)MIN(nominal
, 65535L);
441 * This is called at the beginning of each pass. We determine which modules
442 * will be active during this pass and give them appropriate start_pass calls.
443 * We also set is_last_pass to indicate whether any more passes will be
448 prepare_for_pass(j_compress_ptr cinfo
)
450 my_master_ptr master
= (my_master_ptr
)cinfo
->master
;
452 switch (master
->pass_type
) {
454 /* Initial pass: will collect input data, and do either Huffman
455 * optimization or data output for the first scan.
457 select_scan_parameters(cinfo
);
458 per_scan_setup(cinfo
);
459 if (!cinfo
->raw_data_in
) {
460 (*cinfo
->cconvert
->start_pass
) (cinfo
);
461 (*cinfo
->downsample
->start_pass
) (cinfo
);
462 (*cinfo
->prep
->start_pass
) (cinfo
, JBUF_PASS_THRU
);
464 (*cinfo
->fdct
->start_pass
) (cinfo
);
465 (*cinfo
->entropy
->start_pass
) (cinfo
, cinfo
->optimize_coding
);
466 (*cinfo
->coef
->start_pass
) (cinfo
,
467 (master
->total_passes
> 1 ?
468 JBUF_SAVE_AND_PASS
: JBUF_PASS_THRU
));
469 (*cinfo
->main
->start_pass
) (cinfo
, JBUF_PASS_THRU
);
470 if (cinfo
->optimize_coding
) {
471 /* No immediate data output; postpone writing frame/scan headers */
472 master
->pub
.call_pass_startup
= FALSE
;
474 /* Will write frame/scan headers at first jpeg_write_scanlines call */
475 master
->pub
.call_pass_startup
= TRUE
;
478 #ifdef ENTROPY_OPT_SUPPORTED
480 /* Do Huffman optimization for a scan after the first one. */
481 select_scan_parameters(cinfo
);
482 per_scan_setup(cinfo
);
483 if (cinfo
->Ss
!= 0 || cinfo
->Ah
== 0 || cinfo
->arith_code
) {
484 (*cinfo
->entropy
->start_pass
) (cinfo
, TRUE
);
485 (*cinfo
->coef
->start_pass
) (cinfo
, JBUF_CRANK_DEST
);
486 master
->pub
.call_pass_startup
= FALSE
;
489 /* Special case: Huffman DC refinement scans need no Huffman table
490 * and therefore we can skip the optimization pass for them.
492 master
->pass_type
= output_pass
;
493 master
->pass_number
++;
495 FALLTHROUGH
/*FALLTHROUGH*/
497 /* Do a data-output pass. */
498 /* We need not repeat per-scan setup if prior optimization pass did it. */
499 if (!cinfo
->optimize_coding
) {
500 select_scan_parameters(cinfo
);
501 per_scan_setup(cinfo
);
503 (*cinfo
->entropy
->start_pass
) (cinfo
, FALSE
);
504 (*cinfo
->coef
->start_pass
) (cinfo
, JBUF_CRANK_DEST
);
505 /* We emit frame/scan headers now */
506 if (master
->scan_number
== 0)
507 (*cinfo
->marker
->write_frame_header
) (cinfo
);
508 (*cinfo
->marker
->write_scan_header
) (cinfo
);
509 master
->pub
.call_pass_startup
= FALSE
;
512 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
515 master
->pub
.is_last_pass
= (master
->pass_number
== master
->total_passes
- 1);
517 /* Set up progress monitor's pass info if present */
518 if (cinfo
->progress
!= NULL
) {
519 cinfo
->progress
->completed_passes
= master
->pass_number
;
520 cinfo
->progress
->total_passes
= master
->total_passes
;
526 * Special start-of-pass hook.
527 * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
528 * In single-pass processing, we need this hook because we don't want to
529 * write frame/scan headers during jpeg_start_compress; we want to let the
530 * application write COM markers etc. between jpeg_start_compress and the
531 * jpeg_write_scanlines loop.
532 * In multi-pass processing, this routine is not used.
536 pass_startup(j_compress_ptr cinfo
)
538 cinfo
->master
->call_pass_startup
= FALSE
; /* reset flag so call only once */
540 (*cinfo
->marker
->write_frame_header
) (cinfo
);
541 (*cinfo
->marker
->write_scan_header
) (cinfo
);
546 * Finish up at end of pass.
550 finish_pass_master(j_compress_ptr cinfo
)
552 my_master_ptr master
= (my_master_ptr
)cinfo
->master
;
554 /* The entropy coder always needs an end-of-pass call,
555 * either to analyze statistics or to flush its output buffer.
557 (*cinfo
->entropy
->finish_pass
) (cinfo
);
559 /* Update state for next pass */
560 switch (master
->pass_type
) {
562 /* next pass is either output of scan 0 (after optimization)
563 * or output of scan 1 (if no optimization).
565 master
->pass_type
= output_pass
;
566 if (!cinfo
->optimize_coding
)
567 master
->scan_number
++;
570 /* next pass is always output of current scan */
571 master
->pass_type
= output_pass
;
574 /* next pass is either optimization or output of next scan */
575 if (cinfo
->optimize_coding
)
576 master
->pass_type
= huff_opt_pass
;
577 master
->scan_number
++;
581 master
->pass_number
++;
586 * Initialize master compression control.
590 jinit_c_master_control(j_compress_ptr cinfo
, boolean transcode_only
)
592 my_master_ptr master
;
594 master
= (my_master_ptr
)
595 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
)cinfo
, JPOOL_IMAGE
,
596 sizeof(my_comp_master
));
597 cinfo
->master
= (struct jpeg_comp_master
*)master
;
598 master
->pub
.prepare_for_pass
= prepare_for_pass
;
599 master
->pub
.pass_startup
= pass_startup
;
600 master
->pub
.finish_pass
= finish_pass_master
;
601 master
->pub
.is_last_pass
= FALSE
;
603 /* Validate parameters, determine derived values */
604 initial_setup(cinfo
, transcode_only
);
606 if (cinfo
->scan_info
!= NULL
) {
607 #ifdef C_MULTISCAN_FILES_SUPPORTED
608 validate_script(cinfo
);
610 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
613 cinfo
->progressive_mode
= FALSE
;
614 cinfo
->num_scans
= 1;
617 if (cinfo
->progressive_mode
&& !cinfo
->arith_code
) /* TEMPORARY HACK ??? */
618 cinfo
->optimize_coding
= TRUE
; /* assume default tables no good for progressive mode */
620 /* Initialize my private state */
621 if (transcode_only
) {
622 /* no main pass in transcoding */
623 if (cinfo
->optimize_coding
)
624 master
->pass_type
= huff_opt_pass
;
626 master
->pass_type
= output_pass
;
628 /* for normal compression, first pass is always this type: */
629 master
->pass_type
= main_pass
;
631 master
->scan_number
= 0;
632 master
->pass_number
= 0;
633 if (cinfo
->optimize_coding
)
634 master
->total_passes
= cinfo
->num_scans
* 2;
636 master
->total_passes
= cinfo
->num_scans
;
638 master
->jpeg_version
= PACKAGE_NAME
" version " VERSION
" (build " BUILD
")";