4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1994-1997, Thomas G. Lane.
6 * It was modified by The libjpeg-turbo Project to include only code and
7 * information relevant to libjpeg-turbo.
8 * For conditions of distribution and use, see the accompanying README.ijg
11 * This file contains the coefficient buffer controller for compression.
12 * This controller is the top level of the JPEG compressor proper.
13 * The coefficient buffer lies between forward-DCT and entropy encoding steps.
16 #define JPEG_INTERNALS
21 /* We use a full-image coefficient buffer when doing Huffman optimization,
22 * and also for writing multiple-scan JPEG files. In all cases, the DCT
23 * step is run during the first pass, and subsequent passes need only read
24 * the buffered coefficients.
26 #ifdef ENTROPY_OPT_SUPPORTED
27 #define FULL_COEF_BUFFER_SUPPORTED
29 #ifdef C_MULTISCAN_FILES_SUPPORTED
30 #define FULL_COEF_BUFFER_SUPPORTED
35 /* Private buffer controller object */
38 struct jpeg_c_coef_controller pub
; /* public fields */
40 JDIMENSION iMCU_row_num
; /* iMCU row # within image */
41 JDIMENSION mcu_ctr
; /* counts MCUs processed in current row */
42 int MCU_vert_offset
; /* counts MCU rows within iMCU row */
43 int MCU_rows_per_iMCU_row
; /* number of such rows needed */
45 /* For single-pass compression, it's sufficient to buffer just one MCU
46 * (although this may prove a bit slow in practice). We allocate a
47 * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
48 * MCU constructed and sent. In multi-pass modes, this array points to the
49 * current MCU's blocks within the virtual arrays.
51 JBLOCKROW MCU_buffer
[C_MAX_BLOCKS_IN_MCU
];
53 /* In multi-pass modes, we need a virtual block array for each component. */
54 jvirt_barray_ptr whole_image
[MAX_COMPONENTS
];
57 typedef my_coef_controller
*my_coef_ptr
;
60 /* Forward declarations */
61 METHODDEF(boolean
) compress_data(j_compress_ptr cinfo
, JSAMPIMAGE input_buf
);
62 #ifdef FULL_COEF_BUFFER_SUPPORTED
63 METHODDEF(boolean
) compress_first_pass(j_compress_ptr cinfo
,
64 JSAMPIMAGE input_buf
);
65 METHODDEF(boolean
) compress_output(j_compress_ptr cinfo
, JSAMPIMAGE input_buf
);
70 start_iMCU_row(j_compress_ptr cinfo
)
71 /* Reset within-iMCU-row counters for a new row */
73 my_coef_ptr coef
= (my_coef_ptr
)cinfo
->coef
;
75 /* In an interleaved scan, an MCU row is the same as an iMCU row.
76 * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
77 * But at the bottom of the image, process only what's left.
79 if (cinfo
->comps_in_scan
> 1) {
80 coef
->MCU_rows_per_iMCU_row
= 1;
82 if (coef
->iMCU_row_num
< (cinfo
->total_iMCU_rows
- 1))
83 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->v_samp_factor
;
85 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->last_row_height
;
89 coef
->MCU_vert_offset
= 0;
94 * Initialize for a processing pass.
98 start_pass_coef(j_compress_ptr cinfo
, J_BUF_MODE pass_mode
)
100 my_coef_ptr coef
= (my_coef_ptr
)cinfo
->coef
;
102 coef
->iMCU_row_num
= 0;
103 start_iMCU_row(cinfo
);
107 if (coef
->whole_image
[0] != NULL
)
108 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
109 coef
->pub
.compress_data
= compress_data
;
111 #ifdef FULL_COEF_BUFFER_SUPPORTED
112 case JBUF_SAVE_AND_PASS
:
113 if (coef
->whole_image
[0] == NULL
)
114 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
115 coef
->pub
.compress_data
= compress_first_pass
;
117 case JBUF_CRANK_DEST
:
118 if (coef
->whole_image
[0] == NULL
)
119 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
120 coef
->pub
.compress_data
= compress_output
;
124 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
131 * Process some data in the single-pass case.
132 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
133 * per call, ie, v_samp_factor block rows for each component in the image.
134 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
136 * NB: input_buf contains a plane for each component in image,
137 * which we index according to the component's SOF position.
141 compress_data(j_compress_ptr cinfo
, JSAMPIMAGE input_buf
)
143 my_coef_ptr coef
= (my_coef_ptr
)cinfo
->coef
;
144 JDIMENSION MCU_col_num
; /* index of current MCU within row */
145 JDIMENSION last_MCU_col
= cinfo
->MCUs_per_row
- 1;
146 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
147 int blkn
, bi
, ci
, yindex
, yoffset
, blockcnt
;
148 JDIMENSION ypos
, xpos
;
149 jpeg_component_info
*compptr
;
151 /* Loop to write as much as one whole iMCU row */
152 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
154 for (MCU_col_num
= coef
->mcu_ctr
; MCU_col_num
<= last_MCU_col
;
156 /* Determine where data comes from in input_buf and do the DCT thing.
157 * Each call on forward_DCT processes a horizontal row of DCT blocks
158 * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
159 * sequentially. Dummy blocks at the right or bottom edge are filled in
160 * specially. The data in them does not matter for image reconstruction,
161 * so we fill them with values that will encode to the smallest amount of
162 * data, viz: all zeroes in the AC entries, DC entries equal to previous
163 * block's DC value. (Thanks to Thomas Kinsman for this idea.)
166 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
167 compptr
= cinfo
->cur_comp_info
[ci
];
168 blockcnt
= (MCU_col_num
< last_MCU_col
) ? compptr
->MCU_width
:
169 compptr
->last_col_width
;
170 xpos
= MCU_col_num
* compptr
->MCU_sample_width
;
171 ypos
= yoffset
* DCTSIZE
; /* ypos == (yoffset+yindex) * DCTSIZE */
172 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
173 if (coef
->iMCU_row_num
< last_iMCU_row
||
174 yoffset
+ yindex
< compptr
->last_row_height
) {
175 (*cinfo
->fdct
->forward_DCT
) (cinfo
, compptr
,
176 input_buf
[compptr
->component_index
],
177 coef
->MCU_buffer
[blkn
],
178 ypos
, xpos
, (JDIMENSION
)blockcnt
);
179 if (blockcnt
< compptr
->MCU_width
) {
180 /* Create some dummy blocks at the right edge of the image. */
181 jzero_far((void *)coef
->MCU_buffer
[blkn
+ blockcnt
],
182 (compptr
->MCU_width
- blockcnt
) * sizeof(JBLOCK
));
183 for (bi
= blockcnt
; bi
< compptr
->MCU_width
; bi
++) {
184 coef
->MCU_buffer
[blkn
+ bi
][0][0] =
185 coef
->MCU_buffer
[blkn
+ bi
- 1][0][0];
189 /* Create a row of dummy blocks at the bottom of the image. */
190 jzero_far((void *)coef
->MCU_buffer
[blkn
],
191 compptr
->MCU_width
* sizeof(JBLOCK
));
192 for (bi
= 0; bi
< compptr
->MCU_width
; bi
++) {
193 coef
->MCU_buffer
[blkn
+ bi
][0][0] =
194 coef
->MCU_buffer
[blkn
- 1][0][0];
197 blkn
+= compptr
->MCU_width
;
201 /* Try to write the MCU. In event of a suspension failure, we will
202 * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
204 if (!(*cinfo
->entropy
->encode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
205 /* Suspension forced; update state counters and exit */
206 coef
->MCU_vert_offset
= yoffset
;
207 coef
->mcu_ctr
= MCU_col_num
;
211 /* Completed an MCU row, but perhaps not an iMCU row */
214 /* Completed the iMCU row, advance counters for next one */
215 coef
->iMCU_row_num
++;
216 start_iMCU_row(cinfo
);
221 #ifdef FULL_COEF_BUFFER_SUPPORTED
224 * Process some data in the first pass of a multi-pass case.
225 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
226 * per call, ie, v_samp_factor block rows for each component in the image.
227 * This amount of data is read from the source buffer, DCT'd and quantized,
228 * and saved into the virtual arrays. We also generate suitable dummy blocks
229 * as needed at the right and lower edges. (The dummy blocks are constructed
230 * in the virtual arrays, which have been padded appropriately.) This makes
231 * it possible for subsequent passes not to worry about real vs. dummy blocks.
233 * We must also emit the data to the entropy encoder. This is conveniently
234 * done by calling compress_output() after we've loaded the current strip
235 * of the virtual arrays.
237 * NB: input_buf contains a plane for each component in image. All
238 * components are DCT'd and loaded into the virtual arrays in this pass.
239 * However, it may be that only a subset of the components are emitted to
240 * the entropy encoder during this first pass; be careful about looking
241 * at the scan-dependent variables (MCU dimensions, etc).
245 compress_first_pass(j_compress_ptr cinfo
, JSAMPIMAGE input_buf
)
247 my_coef_ptr coef
= (my_coef_ptr
)cinfo
->coef
;
248 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
249 JDIMENSION blocks_across
, MCUs_across
, MCUindex
;
250 int bi
, ci
, h_samp_factor
, block_row
, block_rows
, ndummy
;
252 jpeg_component_info
*compptr
;
254 JBLOCKROW thisblockrow
, lastblockrow
;
256 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
258 /* Align the virtual buffer for this component. */
259 buffer
= (*cinfo
->mem
->access_virt_barray
)
260 ((j_common_ptr
)cinfo
, coef
->whole_image
[ci
],
261 coef
->iMCU_row_num
* compptr
->v_samp_factor
,
262 (JDIMENSION
)compptr
->v_samp_factor
, TRUE
);
263 /* Count non-dummy DCT block rows in this iMCU row. */
264 if (coef
->iMCU_row_num
< last_iMCU_row
)
265 block_rows
= compptr
->v_samp_factor
;
267 /* NB: can't use last_row_height here, since may not be set! */
268 block_rows
= (int)(compptr
->height_in_blocks
% compptr
->v_samp_factor
);
269 if (block_rows
== 0) block_rows
= compptr
->v_samp_factor
;
271 blocks_across
= compptr
->width_in_blocks
;
272 h_samp_factor
= compptr
->h_samp_factor
;
273 /* Count number of dummy blocks to be added at the right margin. */
274 ndummy
= (int)(blocks_across
% h_samp_factor
);
276 ndummy
= h_samp_factor
- ndummy
;
277 /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
278 * on forward_DCT processes a complete horizontal row of DCT blocks.
280 for (block_row
= 0; block_row
< block_rows
; block_row
++) {
281 thisblockrow
= buffer
[block_row
];
282 (*cinfo
->fdct
->forward_DCT
) (cinfo
, compptr
,
283 input_buf
[ci
], thisblockrow
,
284 (JDIMENSION
)(block_row
* DCTSIZE
),
285 (JDIMENSION
)0, blocks_across
);
287 /* Create dummy blocks at the right edge of the image. */
288 thisblockrow
+= blocks_across
; /* => first dummy block */
289 jzero_far((void *)thisblockrow
, ndummy
* sizeof(JBLOCK
));
290 lastDC
= thisblockrow
[-1][0];
291 for (bi
= 0; bi
< ndummy
; bi
++) {
292 thisblockrow
[bi
][0] = lastDC
;
296 /* If at end of image, create dummy block rows as needed.
297 * The tricky part here is that within each MCU, we want the DC values
298 * of the dummy blocks to match the last real block's DC value.
299 * This squeezes a few more bytes out of the resulting file...
301 if (coef
->iMCU_row_num
== last_iMCU_row
) {
302 blocks_across
+= ndummy
; /* include lower right corner */
303 MCUs_across
= blocks_across
/ h_samp_factor
;
304 for (block_row
= block_rows
; block_row
< compptr
->v_samp_factor
;
306 thisblockrow
= buffer
[block_row
];
307 lastblockrow
= buffer
[block_row
- 1];
308 jzero_far((void *)thisblockrow
,
309 (size_t)(blocks_across
* sizeof(JBLOCK
)));
310 for (MCUindex
= 0; MCUindex
< MCUs_across
; MCUindex
++) {
311 lastDC
= lastblockrow
[h_samp_factor
- 1][0];
312 for (bi
= 0; bi
< h_samp_factor
; bi
++) {
313 thisblockrow
[bi
][0] = lastDC
;
315 thisblockrow
+= h_samp_factor
; /* advance to next MCU in row */
316 lastblockrow
+= h_samp_factor
;
321 /* NB: compress_output will increment iMCU_row_num if successful.
322 * A suspension return will result in redoing all the work above next time.
325 /* Emit data to the entropy encoder, sharing code with subsequent passes */
326 return compress_output(cinfo
, input_buf
);
331 * Process some data in subsequent passes of a multi-pass case.
332 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
333 * per call, ie, v_samp_factor block rows for each component in the scan.
334 * The data is obtained from the virtual arrays and fed to the entropy coder.
335 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
337 * NB: input_buf is ignored; it is likely to be a NULL pointer.
341 compress_output(j_compress_ptr cinfo
, JSAMPIMAGE input_buf
)
343 my_coef_ptr coef
= (my_coef_ptr
)cinfo
->coef
;
344 JDIMENSION MCU_col_num
; /* index of current MCU within row */
345 int blkn
, ci
, xindex
, yindex
, yoffset
;
346 JDIMENSION start_col
;
347 JBLOCKARRAY buffer
[MAX_COMPS_IN_SCAN
];
348 JBLOCKROW buffer_ptr
;
349 jpeg_component_info
*compptr
;
351 /* Align the virtual buffers for the components used in this scan.
352 * NB: during first pass, this is safe only because the buffers will
353 * already be aligned properly, so jmemmgr.c won't need to do any I/O.
355 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
356 compptr
= cinfo
->cur_comp_info
[ci
];
357 buffer
[ci
] = (*cinfo
->mem
->access_virt_barray
)
358 ((j_common_ptr
)cinfo
, coef
->whole_image
[compptr
->component_index
],
359 coef
->iMCU_row_num
* compptr
->v_samp_factor
,
360 (JDIMENSION
)compptr
->v_samp_factor
, FALSE
);
363 /* Loop to process one whole iMCU row */
364 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
366 for (MCU_col_num
= coef
->mcu_ctr
; MCU_col_num
< cinfo
->MCUs_per_row
;
368 /* Construct list of pointers to DCT blocks belonging to this MCU */
369 blkn
= 0; /* index of current DCT block within MCU */
370 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
371 compptr
= cinfo
->cur_comp_info
[ci
];
372 start_col
= MCU_col_num
* compptr
->MCU_width
;
373 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
374 buffer_ptr
= buffer
[ci
][yindex
+ yoffset
] + start_col
;
375 for (xindex
= 0; xindex
< compptr
->MCU_width
; xindex
++) {
376 coef
->MCU_buffer
[blkn
++] = buffer_ptr
++;
380 /* Try to write the MCU. */
381 if (!(*cinfo
->entropy
->encode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
382 /* Suspension forced; update state counters and exit */
383 coef
->MCU_vert_offset
= yoffset
;
384 coef
->mcu_ctr
= MCU_col_num
;
388 /* Completed an MCU row, but perhaps not an iMCU row */
391 /* Completed the iMCU row, advance counters for next one */
392 coef
->iMCU_row_num
++;
393 start_iMCU_row(cinfo
);
397 #endif /* FULL_COEF_BUFFER_SUPPORTED */
401 * Initialize coefficient buffer controller.
405 jinit_c_coef_controller(j_compress_ptr cinfo
, boolean need_full_buffer
)
410 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
)cinfo
, JPOOL_IMAGE
,
411 sizeof(my_coef_controller
));
412 cinfo
->coef
= (struct jpeg_c_coef_controller
*)coef
;
413 coef
->pub
.start_pass
= start_pass_coef
;
415 /* Create the coefficient buffer. */
416 if (need_full_buffer
) {
417 #ifdef FULL_COEF_BUFFER_SUPPORTED
418 /* Allocate a full-image virtual array for each component, */
419 /* padded to a multiple of samp_factor DCT blocks in each direction. */
421 jpeg_component_info
*compptr
;
423 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
425 coef
->whole_image
[ci
] = (*cinfo
->mem
->request_virt_barray
)
426 ((j_common_ptr
)cinfo
, JPOOL_IMAGE
, FALSE
,
427 (JDIMENSION
)jround_up((long)compptr
->width_in_blocks
,
428 (long)compptr
->h_samp_factor
),
429 (JDIMENSION
)jround_up((long)compptr
->height_in_blocks
,
430 (long)compptr
->v_samp_factor
),
431 (JDIMENSION
)compptr
->v_samp_factor
);
434 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
437 /* We only need a single-MCU buffer. */
442 (*cinfo
->mem
->alloc_large
) ((j_common_ptr
)cinfo
, JPOOL_IMAGE
,
443 C_MAX_BLOCKS_IN_MCU
* sizeof(JBLOCK
));
444 for (i
= 0; i
< C_MAX_BLOCKS_IN_MCU
; i
++) {
445 coef
->MCU_buffer
[i
] = buffer
+ i
;
447 coef
->whole_image
[0] = NULL
; /* flag for no virtual arrays */