4 * Copyright (C) 1994-1997, Thomas G. Lane.
5 * Modified 2002-2020 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
9 * This file contains the coefficient buffer controller for decompression.
10 * This controller is the top level of the JPEG decompressor proper.
11 * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
13 * In buffered-image mode, this controller is the interface between
14 * input-oriented processing and output-oriented processing.
15 * Also, the input side (only) is used when reading a file for transcoding.
18 #define JPEG_INTERNALS
23 /* Block smoothing is only applicable for progressive JPEG, so: */
24 #ifndef D_PROGRESSIVE_SUPPORTED
25 #undef BLOCK_SMOOTHING_SUPPORTED
29 /* Private buffer controller object */
32 struct jpeg_d_coef_controller pub
; /* public fields */
34 /* These variables keep track of the current location of the input side. */
35 /* cinfo->input_iMCU_row is also used for this. */
36 JDIMENSION MCU_ctr
; /* counts MCUs processed in current row */
37 int MCU_vert_offset
; /* counts MCU rows within iMCU row */
38 int MCU_rows_per_iMCU_row
; /* number of such rows needed */
40 /* The output side's location is represented by cinfo->output_iMCU_row. */
42 /* In single-pass modes, it's sufficient to buffer just one MCU.
43 * We append a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
44 * and let the entropy decoder write into that workspace each time.
45 * In multi-pass modes, this array points to the current MCU's blocks
46 * within the virtual arrays; it is used only by the input side.
48 JBLOCKROW MCU_buffer
[D_MAX_BLOCKS_IN_MCU
];
50 #ifdef D_MULTISCAN_FILES_SUPPORTED
51 /* In multi-pass modes, we need a virtual block array for each component. */
52 jvirt_barray_ptr whole_image
[MAX_COMPONENTS
];
55 #ifdef BLOCK_SMOOTHING_SUPPORTED
56 /* When doing block smoothing, we latch coefficient Al values here */
57 int * coef_bits_latch
;
58 #define SAVED_COEFS 6 /* we save coef_bits[0..5] */
61 /* Workspace for single-pass modes (omitted otherwise). */
62 JBLOCK blk_buffer
[D_MAX_BLOCKS_IN_MCU
];
65 typedef my_coef_controller
* my_coef_ptr
;
68 /* Forward declarations */
69 METHODDEF(int) decompress_onepass
70 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
71 #ifdef D_MULTISCAN_FILES_SUPPORTED
72 METHODDEF(int) decompress_data
73 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
75 #ifdef BLOCK_SMOOTHING_SUPPORTED
76 LOCAL(boolean
) smoothing_ok
JPP((j_decompress_ptr cinfo
));
77 METHODDEF(int) decompress_smooth_data
78 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
83 start_iMCU_row (j_decompress_ptr cinfo
)
84 /* Reset within-iMCU-row counters for a new row (input side) */
86 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
88 /* In an interleaved scan, an MCU row is the same as an iMCU row.
89 * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
90 * But at the bottom of the image, process only what's left.
92 if (cinfo
->comps_in_scan
> 1) {
93 coef
->MCU_rows_per_iMCU_row
= 1;
95 if (cinfo
->input_iMCU_row
< (cinfo
->total_iMCU_rows
-1))
96 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->v_samp_factor
;
98 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->last_row_height
;
102 coef
->MCU_vert_offset
= 0;
107 * Initialize for an input processing pass.
111 start_input_pass (j_decompress_ptr cinfo
)
113 cinfo
->input_iMCU_row
= 0;
114 start_iMCU_row(cinfo
);
119 * Initialize for an output processing pass.
123 start_output_pass (j_decompress_ptr cinfo
)
125 #ifdef BLOCK_SMOOTHING_SUPPORTED
126 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
128 /* If multipass, check to see whether to use block smoothing on this pass */
129 if (coef
->pub
.coef_arrays
!= NULL
) {
130 if (cinfo
->do_block_smoothing
&& smoothing_ok(cinfo
))
131 coef
->pub
.decompress_data
= decompress_smooth_data
;
133 coef
->pub
.decompress_data
= decompress_data
;
136 cinfo
->output_iMCU_row
= 0;
141 * Decompress and return some data in the single-pass case.
142 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
143 * Input and output must run in lockstep since we have only a one-MCU buffer.
144 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
146 * NB: output_buf contains a plane for each component in image,
147 * which we index according to the component's SOF position.
151 decompress_onepass (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
153 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
154 JDIMENSION MCU_col_num
; /* index of current MCU within row */
155 JDIMENSION last_MCU_col
= cinfo
->MCUs_per_row
- 1;
156 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
157 int ci
, xindex
, yindex
, yoffset
, useful_width
;
159 JSAMPARRAY output_ptr
;
160 JDIMENSION start_col
, output_col
;
161 jpeg_component_info
*compptr
;
162 inverse_DCT_method_ptr inverse_DCT
;
164 /* Loop to process as much as one whole iMCU row */
165 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
167 for (MCU_col_num
= coef
->MCU_ctr
; MCU_col_num
<= last_MCU_col
;
169 blkp
= coef
->blk_buffer
; /* pointer to current DCT block within MCU */
170 /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
171 if (cinfo
->lim_Se
) /* can bypass in DC only case */
172 MEMZERO(blkp
, cinfo
->blocks_in_MCU
* SIZEOF(JBLOCK
));
173 if (! (*cinfo
->entropy
->decode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
174 /* Suspension forced; update state counters and exit */
175 coef
->MCU_vert_offset
= yoffset
;
176 coef
->MCU_ctr
= MCU_col_num
;
177 return JPEG_SUSPENDED
;
179 /* Determine where data should go in output_buf and do the IDCT thing.
180 * We skip dummy blocks at the right and bottom edges (but blkp gets
181 * incremented past them!).
183 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
184 compptr
= cinfo
->cur_comp_info
[ci
];
185 /* Don't bother to IDCT an uninteresting component. */
186 if (! compptr
->component_needed
) {
187 blkp
+= compptr
->MCU_blocks
;
190 inverse_DCT
= cinfo
->idct
->inverse_DCT
[compptr
->component_index
];
191 output_ptr
= output_buf
[compptr
->component_index
] +
192 yoffset
* compptr
->DCT_v_scaled_size
;
193 useful_width
= (MCU_col_num
< last_MCU_col
) ? compptr
->MCU_width
194 : compptr
->last_col_width
;
195 start_col
= MCU_col_num
* compptr
->MCU_sample_width
;
196 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
197 if (cinfo
->input_iMCU_row
< last_iMCU_row
||
198 yoffset
+ yindex
< compptr
->last_row_height
) {
199 output_col
= start_col
;
200 for (xindex
= 0; xindex
< useful_width
; xindex
++) {
201 (*inverse_DCT
) (cinfo
, compptr
, (JCOEFPTR
) (blkp
+ xindex
),
202 output_ptr
, output_col
);
203 output_col
+= compptr
->DCT_h_scaled_size
;
205 output_ptr
+= compptr
->DCT_v_scaled_size
;
207 blkp
+= compptr
->MCU_width
;
211 /* Completed an MCU row, but perhaps not an iMCU row */
214 /* Completed the iMCU row, advance counters for next one */
215 cinfo
->output_iMCU_row
++;
216 if (++(cinfo
->input_iMCU_row
) <= last_iMCU_row
) {
217 start_iMCU_row(cinfo
);
218 return JPEG_ROW_COMPLETED
;
220 /* Completed the scan */
221 (*cinfo
->inputctl
->finish_input_pass
) (cinfo
);
222 return JPEG_SCAN_COMPLETED
;
227 * Dummy consume-input routine for single-pass operation.
231 dummy_consume_data (j_decompress_ptr cinfo
)
233 return JPEG_SUSPENDED
; /* Always indicate nothing was done */
237 #ifdef D_MULTISCAN_FILES_SUPPORTED
240 * Consume input data and store it in the full-image coefficient buffer.
241 * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
242 * ie, v_samp_factor block rows for each component in the scan.
243 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
247 consume_data (j_decompress_ptr cinfo
)
249 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
250 JDIMENSION MCU_col_num
; /* index of current MCU within row */
251 int ci
, xindex
, yindex
, yoffset
;
252 JDIMENSION start_col
;
254 JBLOCKARRAY buffer
[MAX_COMPS_IN_SCAN
];
255 JBLOCKROW buffer_ptr
;
256 jpeg_component_info
*compptr
;
258 /* Align the virtual buffers for the components used in this scan. */
259 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
260 compptr
= cinfo
->cur_comp_info
[ci
];
261 buffer
[ci
] = (*cinfo
->mem
->access_virt_barray
)
262 ((j_common_ptr
) cinfo
, coef
->whole_image
[compptr
->component_index
],
263 cinfo
->input_iMCU_row
* compptr
->v_samp_factor
,
264 (JDIMENSION
) compptr
->v_samp_factor
, TRUE
);
265 /* Note: entropy decoder expects buffer to be zeroed,
266 * but this is handled automatically by the memory manager
267 * because we requested a pre-zeroed array.
271 /* Loop to process one whole iMCU row */
272 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
274 for (MCU_col_num
= coef
->MCU_ctr
; MCU_col_num
< cinfo
->MCUs_per_row
;
276 /* Construct list of pointers to DCT blocks belonging to this MCU */
277 blkp
= coef
->MCU_buffer
; /* pointer to current DCT block within MCU */
278 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
279 compptr
= cinfo
->cur_comp_info
[ci
];
280 start_col
= MCU_col_num
* compptr
->MCU_width
;
281 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
282 buffer_ptr
= buffer
[ci
][yoffset
+ yindex
] + start_col
;
283 xindex
= compptr
->MCU_width
;
285 *blkp
++ = buffer_ptr
++;
289 /* Try to fetch the MCU. */
290 if (! (*cinfo
->entropy
->decode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
291 /* Suspension forced; update state counters and exit */
292 coef
->MCU_vert_offset
= yoffset
;
293 coef
->MCU_ctr
= MCU_col_num
;
294 return JPEG_SUSPENDED
;
297 /* Completed an MCU row, but perhaps not an iMCU row */
300 /* Completed the iMCU row, advance counters for next one */
301 if (++(cinfo
->input_iMCU_row
) < cinfo
->total_iMCU_rows
) {
302 start_iMCU_row(cinfo
);
303 return JPEG_ROW_COMPLETED
;
305 /* Completed the scan */
306 (*cinfo
->inputctl
->finish_input_pass
) (cinfo
);
307 return JPEG_SCAN_COMPLETED
;
312 * Decompress and return some data in the multi-pass case.
313 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
314 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
316 * NB: output_buf contains a plane for each component in image.
320 decompress_data (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
322 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
323 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
324 JDIMENSION block_num
;
325 int ci
, block_row
, block_rows
;
327 JBLOCKROW buffer_ptr
;
328 JSAMPARRAY output_ptr
;
329 JDIMENSION output_col
;
330 jpeg_component_info
*compptr
;
331 inverse_DCT_method_ptr inverse_DCT
;
333 /* Force some input to be done if we are getting ahead of the input. */
334 while (cinfo
->input_scan_number
< cinfo
->output_scan_number
||
335 (cinfo
->input_scan_number
== cinfo
->output_scan_number
&&
336 cinfo
->input_iMCU_row
<= cinfo
->output_iMCU_row
)) {
337 if ((*cinfo
->inputctl
->consume_input
)(cinfo
) == JPEG_SUSPENDED
)
338 return JPEG_SUSPENDED
;
341 /* OK, output from the virtual arrays. */
342 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
344 /* Don't bother to IDCT an uninteresting component. */
345 if (! compptr
->component_needed
)
347 /* Align the virtual buffer for this component. */
348 buffer
= (*cinfo
->mem
->access_virt_barray
)
349 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
350 cinfo
->output_iMCU_row
* compptr
->v_samp_factor
,
351 (JDIMENSION
) compptr
->v_samp_factor
, FALSE
);
352 /* Count non-dummy DCT block rows in this iMCU row. */
353 if (cinfo
->output_iMCU_row
< last_iMCU_row
)
354 block_rows
= compptr
->v_samp_factor
;
356 /* NB: can't use last_row_height here; it is input-side-dependent! */
357 block_rows
= (int) (compptr
->height_in_blocks
% compptr
->v_samp_factor
);
358 if (block_rows
== 0) block_rows
= compptr
->v_samp_factor
;
360 inverse_DCT
= cinfo
->idct
->inverse_DCT
[ci
];
361 output_ptr
= output_buf
[ci
];
362 /* Loop over all DCT blocks to be processed. */
363 for (block_row
= 0; block_row
< block_rows
; block_row
++) {
364 buffer_ptr
= buffer
[block_row
];
366 for (block_num
= 0; block_num
< compptr
->width_in_blocks
; block_num
++) {
367 (*inverse_DCT
) (cinfo
, compptr
, (JCOEFPTR
) buffer_ptr
,
368 output_ptr
, output_col
);
370 output_col
+= compptr
->DCT_h_scaled_size
;
372 output_ptr
+= compptr
->DCT_v_scaled_size
;
376 if (++(cinfo
->output_iMCU_row
) <= last_iMCU_row
)
377 return JPEG_ROW_COMPLETED
;
378 return JPEG_SCAN_COMPLETED
;
381 #endif /* D_MULTISCAN_FILES_SUPPORTED */
384 #ifdef BLOCK_SMOOTHING_SUPPORTED
387 * This code applies interblock smoothing as described by section K.8
388 * of the JPEG standard: the first 5 AC coefficients are estimated from
389 * the DC values of a DCT block and its 8 neighboring blocks.
390 * We apply smoothing only for progressive JPEG decoding, and only if
391 * the coefficients it can estimate are not yet known to full precision.
394 /* Natural-order array positions of the first 5 zigzag-order coefficients */
402 * Determine whether block smoothing is applicable and safe.
403 * We also latch the current states of the coef_bits[] entries for the
404 * AC coefficients; otherwise, if the input side of the decompressor
405 * advances into a new scan, we might think the coefficients are known
406 * more accurately than they really are.
410 smoothing_ok (j_decompress_ptr cinfo
)
412 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
413 boolean smoothing_useful
= FALSE
;
415 jpeg_component_info
*compptr
;
418 int * coef_bits_latch
;
420 if (! cinfo
->progressive_mode
|| cinfo
->coef_bits
== NULL
)
423 /* Allocate latch area if not already done */
424 if (coef
->coef_bits_latch
== NULL
)
425 coef
->coef_bits_latch
= (int *) (*cinfo
->mem
->alloc_small
)
426 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
427 cinfo
->num_components
* (SAVED_COEFS
* SIZEOF(int)));
428 coef_bits_latch
= coef
->coef_bits_latch
;
430 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
432 /* All components' quantization values must already be latched. */
433 if ((qtable
= compptr
->quant_table
) == NULL
)
435 /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
436 if (qtable
->quantval
[0] == 0 ||
437 qtable
->quantval
[Q01_POS
] == 0 ||
438 qtable
->quantval
[Q10_POS
] == 0 ||
439 qtable
->quantval
[Q20_POS
] == 0 ||
440 qtable
->quantval
[Q11_POS
] == 0 ||
441 qtable
->quantval
[Q02_POS
] == 0)
443 /* DC values must be at least partly known for all components. */
444 coef_bits
= cinfo
->coef_bits
[ci
];
445 if (coef_bits
[0] < 0)
447 /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
448 for (coefi
= 1; coefi
<= 5; coefi
++) {
449 coef_bits_latch
[coefi
] = coef_bits
[coefi
];
450 if (coef_bits
[coefi
] != 0)
451 smoothing_useful
= TRUE
;
453 coef_bits_latch
+= SAVED_COEFS
;
456 return smoothing_useful
;
461 * Variant of decompress_data for use when doing block smoothing.
465 decompress_smooth_data (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
467 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
468 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
469 JDIMENSION block_num
, last_block_column
;
470 int ci
, block_row
, block_rows
, access_rows
;
472 JBLOCKROW buffer_ptr
, prev_block_row
, next_block_row
;
473 JSAMPARRAY output_ptr
;
474 JDIMENSION output_col
;
475 jpeg_component_info
*compptr
;
476 inverse_DCT_method_ptr inverse_DCT
;
477 boolean first_row
, last_row
;
480 JQUANT_TBL
*quanttbl
;
481 INT32 Q00
,Q01
,Q02
,Q10
,Q11
,Q20
, num
;
482 int DC1
,DC2
,DC3
,DC4
,DC5
,DC6
,DC7
,DC8
,DC9
;
485 /* Force some input to be done if we are getting ahead of the input. */
486 while (cinfo
->input_scan_number
<= cinfo
->output_scan_number
&&
487 ! cinfo
->inputctl
->eoi_reached
) {
488 if (cinfo
->input_scan_number
== cinfo
->output_scan_number
) {
489 /* If input is working on current scan, we ordinarily want it to
490 * have completed the current row. But if input scan is DC,
491 * we want it to keep one row ahead so that next block row's DC
492 * values are up to date.
494 JDIMENSION delta
= (cinfo
->Ss
== 0) ? 1 : 0;
495 if (cinfo
->input_iMCU_row
> cinfo
->output_iMCU_row
+delta
)
498 if ((*cinfo
->inputctl
->consume_input
)(cinfo
) == JPEG_SUSPENDED
)
499 return JPEG_SUSPENDED
;
502 /* OK, output from the virtual arrays. */
503 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
505 /* Don't bother to IDCT an uninteresting component. */
506 if (! compptr
->component_needed
)
508 /* Count non-dummy DCT block rows in this iMCU row. */
509 if (cinfo
->output_iMCU_row
< last_iMCU_row
) {
510 block_rows
= compptr
->v_samp_factor
;
511 access_rows
= block_rows
* 2; /* this and next iMCU row */
514 /* NB: can't use last_row_height here; it is input-side-dependent! */
515 block_rows
= (int) (compptr
->height_in_blocks
% compptr
->v_samp_factor
);
516 if (block_rows
== 0) block_rows
= compptr
->v_samp_factor
;
517 access_rows
= block_rows
; /* this iMCU row only */
520 /* Align the virtual buffer for this component. */
521 if (cinfo
->output_iMCU_row
> 0) {
522 access_rows
+= compptr
->v_samp_factor
; /* prior iMCU row too */
523 buffer
= (*cinfo
->mem
->access_virt_barray
)
524 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
525 (cinfo
->output_iMCU_row
- 1) * compptr
->v_samp_factor
,
526 (JDIMENSION
) access_rows
, FALSE
);
527 buffer
+= compptr
->v_samp_factor
; /* point to current iMCU row */
530 buffer
= (*cinfo
->mem
->access_virt_barray
)
531 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
532 (JDIMENSION
) 0, (JDIMENSION
) access_rows
, FALSE
);
535 /* Fetch component-dependent info */
536 coef_bits
= coef
->coef_bits_latch
+ (ci
* SAVED_COEFS
);
537 quanttbl
= compptr
->quant_table
;
538 Q00
= quanttbl
->quantval
[0];
539 Q01
= quanttbl
->quantval
[Q01_POS
];
540 Q10
= quanttbl
->quantval
[Q10_POS
];
541 Q20
= quanttbl
->quantval
[Q20_POS
];
542 Q11
= quanttbl
->quantval
[Q11_POS
];
543 Q02
= quanttbl
->quantval
[Q02_POS
];
544 inverse_DCT
= cinfo
->idct
->inverse_DCT
[ci
];
545 output_ptr
= output_buf
[ci
];
546 /* Loop over all DCT blocks to be processed. */
547 for (block_row
= 0; block_row
< block_rows
; block_row
++) {
548 buffer_ptr
= buffer
[block_row
];
549 if (first_row
&& block_row
== 0)
550 prev_block_row
= buffer_ptr
;
552 prev_block_row
= buffer
[block_row
-1];
553 if (last_row
&& block_row
== block_rows
-1)
554 next_block_row
= buffer_ptr
;
556 next_block_row
= buffer
[block_row
+1];
557 /* We fetch the surrounding DC values using a sliding-register approach.
558 * Initialize all nine here so as to do the right thing on narrow pics.
560 DC1
= DC2
= DC3
= (int) prev_block_row
[0][0];
561 DC4
= DC5
= DC6
= (int) buffer_ptr
[0][0];
562 DC7
= DC8
= DC9
= (int) next_block_row
[0][0];
564 last_block_column
= compptr
->width_in_blocks
- 1;
565 for (block_num
= 0; block_num
<= last_block_column
; block_num
++) {
566 /* Fetch current DCT block into workspace so we can modify it. */
567 jcopy_block_row(buffer_ptr
, (JBLOCKROW
) workspace
, (JDIMENSION
) 1);
568 /* Update DC values */
569 if (block_num
< last_block_column
) {
570 DC3
= (int) prev_block_row
[1][0];
571 DC6
= (int) buffer_ptr
[1][0];
572 DC9
= (int) next_block_row
[1][0];
574 /* Compute coefficient estimates per K.8.
575 * An estimate is applied only if coefficient is still zero,
576 * and is not known to be fully accurate.
579 if ((Al
=coef_bits
[1]) != 0 && workspace
[1] == 0) {
580 num
= 36 * Q00
* (DC4
- DC6
);
582 pred
= (int) (((Q01
<<7) + num
) / (Q01
<<8));
583 if (Al
> 0 && pred
>= (1<<Al
))
586 pred
= (int) (((Q01
<<7) - num
) / (Q01
<<8));
587 if (Al
> 0 && pred
>= (1<<Al
))
591 workspace
[1] = (JCOEF
) pred
;
594 if ((Al
=coef_bits
[2]) != 0 && workspace
[8] == 0) {
595 num
= 36 * Q00
* (DC2
- DC8
);
597 pred
= (int) (((Q10
<<7) + num
) / (Q10
<<8));
598 if (Al
> 0 && pred
>= (1<<Al
))
601 pred
= (int) (((Q10
<<7) - num
) / (Q10
<<8));
602 if (Al
> 0 && pred
>= (1<<Al
))
606 workspace
[8] = (JCOEF
) pred
;
609 if ((Al
=coef_bits
[3]) != 0 && workspace
[16] == 0) {
610 num
= 9 * Q00
* (DC2
+ DC8
- 2*DC5
);
612 pred
= (int) (((Q20
<<7) + num
) / (Q20
<<8));
613 if (Al
> 0 && pred
>= (1<<Al
))
616 pred
= (int) (((Q20
<<7) - num
) / (Q20
<<8));
617 if (Al
> 0 && pred
>= (1<<Al
))
621 workspace
[16] = (JCOEF
) pred
;
624 if ((Al
=coef_bits
[4]) != 0 && workspace
[9] == 0) {
625 num
= 5 * Q00
* (DC1
- DC3
- DC7
+ DC9
);
627 pred
= (int) (((Q11
<<7) + num
) / (Q11
<<8));
628 if (Al
> 0 && pred
>= (1<<Al
))
631 pred
= (int) (((Q11
<<7) - num
) / (Q11
<<8));
632 if (Al
> 0 && pred
>= (1<<Al
))
636 workspace
[9] = (JCOEF
) pred
;
639 if ((Al
=coef_bits
[5]) != 0 && workspace
[2] == 0) {
640 num
= 9 * Q00
* (DC4
+ DC6
- 2*DC5
);
642 pred
= (int) (((Q02
<<7) + num
) / (Q02
<<8));
643 if (Al
> 0 && pred
>= (1<<Al
))
646 pred
= (int) (((Q02
<<7) - num
) / (Q02
<<8));
647 if (Al
> 0 && pred
>= (1<<Al
))
651 workspace
[2] = (JCOEF
) pred
;
653 /* OK, do the IDCT */
654 (*inverse_DCT
) (cinfo
, compptr
, (JCOEFPTR
) workspace
,
655 output_ptr
, output_col
);
656 /* Advance for next column */
657 DC1
= DC2
; DC2
= DC3
;
658 DC4
= DC5
; DC5
= DC6
;
659 DC7
= DC8
; DC8
= DC9
;
660 buffer_ptr
++, prev_block_row
++, next_block_row
++;
661 output_col
+= compptr
->DCT_h_scaled_size
;
663 output_ptr
+= compptr
->DCT_v_scaled_size
;
667 if (++(cinfo
->output_iMCU_row
) <= last_iMCU_row
)
668 return JPEG_ROW_COMPLETED
;
669 return JPEG_SCAN_COMPLETED
;
672 #endif /* BLOCK_SMOOTHING_SUPPORTED */
676 * Initialize coefficient buffer controller.
680 jinit_d_coef_controller (j_decompress_ptr cinfo
, boolean need_full_buffer
)
684 if (need_full_buffer
) {
685 #ifdef D_MULTISCAN_FILES_SUPPORTED
686 /* Allocate a full-image virtual array for each component, */
687 /* padded to a multiple of samp_factor DCT blocks in each direction. */
688 /* Note we ask for a pre-zeroed array. */
690 jpeg_component_info
*compptr
;
692 coef
= (my_coef_ptr
) (*cinfo
->mem
->alloc_small
)
693 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
694 SIZEOF(my_coef_controller
) - SIZEOF(coef
->blk_buffer
));
695 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
697 access_rows
= compptr
->v_samp_factor
;
698 #ifdef BLOCK_SMOOTHING_SUPPORTED
699 /* If block smoothing could be used, need a bigger window */
700 if (cinfo
->progressive_mode
)
703 coef
->whole_image
[ci
] = (*cinfo
->mem
->request_virt_barray
)
704 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, TRUE
,
705 (JDIMENSION
) jround_up((long) compptr
->width_in_blocks
,
706 (long) compptr
->h_samp_factor
),
707 (JDIMENSION
) jround_up((long) compptr
->height_in_blocks
,
708 (long) compptr
->v_samp_factor
),
709 (JDIMENSION
) access_rows
);
711 coef
->pub
.consume_data
= consume_data
;
712 coef
->pub
.decompress_data
= decompress_data
;
713 coef
->pub
.coef_arrays
= coef
->whole_image
; /* link to virtual arrays */
715 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
718 /* We only need a single-MCU buffer. */
720 JBLOCKROW buffer_ptr
;
723 coef
= (my_coef_ptr
) (*cinfo
->mem
->alloc_small
)
724 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, SIZEOF(my_coef_controller
));
725 buffer_ptr
= coef
->blk_buffer
;
726 if (cinfo
->lim_Se
== 0) /* DC only case: want to bypass later */
727 MEMZERO(buffer_ptr
, SIZEOF(coef
->blk_buffer
));
728 blkp
= coef
->MCU_buffer
;
729 bi
= D_MAX_BLOCKS_IN_MCU
;
731 *blkp
++ = buffer_ptr
++;
733 coef
->pub
.consume_data
= dummy_consume_data
;
734 coef
->pub
.decompress_data
= decompress_onepass
;
735 coef
->pub
.coef_arrays
= NULL
; /* flag for no virtual arrays */
738 coef
->pub
.start_input_pass
= start_input_pass
;
739 coef
->pub
.start_output_pass
= start_output_pass
;
740 #ifdef BLOCK_SMOOTHING_SUPPORTED
741 coef
->coef_bits_latch
= NULL
;
743 cinfo
->coef
= &coef
->pub
;