4 * Copyright (C) 1994-1997, Thomas G. Lane.
5 * Modified 2002-2011 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
22 /* Block smoothing is only applicable for progressive JPEG, so: */
23 #ifndef D_PROGRESSIVE_SUPPORTED
24 #undef BLOCK_SMOOTHING_SUPPORTED
27 /* Private buffer controller object */
30 struct jpeg_d_coef_controller pub
; /* public fields */
32 /* These variables keep track of the current location of the input side. */
33 /* cinfo->input_iMCU_row is also used for this. */
34 JDIMENSION MCU_ctr
; /* counts MCUs processed in current row */
35 int MCU_vert_offset
; /* counts MCU rows within iMCU row */
36 int MCU_rows_per_iMCU_row
; /* number of such rows needed */
38 /* The output side's location is represented by cinfo->output_iMCU_row. */
40 /* In single-pass modes, it's sufficient to buffer just one MCU.
41 * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
42 * and let the entropy decoder write into that workspace each time.
43 * (On 80x86, the workspace is FAR even though it's not really very big;
44 * this is to keep the module interfaces unchanged when a large coefficient
45 * buffer is necessary.)
46 * In multi-pass modes, this array points to the current MCU's blocks
47 * within the virtual arrays; it is used only by the input side.
49 JBLOCKROW MCU_buffer
[D_MAX_BLOCKS_IN_MCU
];
51 #ifdef D_MULTISCAN_FILES_SUPPORTED
52 /* In multi-pass modes, we need a virtual block array for each component. */
53 jvirt_barray_ptr whole_image
[MAX_COMPONENTS
];
56 #ifdef BLOCK_SMOOTHING_SUPPORTED
57 /* When doing block smoothing, we latch coefficient Al values here */
58 int * coef_bits_latch
;
59 #define SAVED_COEFS 6 /* we save coef_bits[0..5] */
63 typedef my_coef_controller
* my_coef_ptr
;
65 /* Forward declarations */
66 METHODDEF(int) decompress_onepass
67 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
68 #ifdef D_MULTISCAN_FILES_SUPPORTED
69 METHODDEF(int) decompress_data
70 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
72 #ifdef BLOCK_SMOOTHING_SUPPORTED
73 LOCAL(boolean
) smoothing_ok
JPP((j_decompress_ptr cinfo
));
74 METHODDEF(int) decompress_smooth_data
75 JPP((j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
));
80 start_iMCU_row (j_decompress_ptr cinfo
)
81 /* Reset within-iMCU-row counters for a new row (input side) */
83 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
85 /* In an interleaved scan, an MCU row is the same as an iMCU row.
86 * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
87 * But at the bottom of the image, process only what's left.
89 if (cinfo
->comps_in_scan
> 1) {
90 coef
->MCU_rows_per_iMCU_row
= 1;
92 if (cinfo
->input_iMCU_row
< (cinfo
->total_iMCU_rows
-1))
93 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->v_samp_factor
;
95 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->last_row_height
;
99 coef
->MCU_vert_offset
= 0;
104 * Initialize for an input processing pass.
108 start_input_pass (j_decompress_ptr cinfo
)
110 cinfo
->input_iMCU_row
= 0;
111 start_iMCU_row(cinfo
);
116 * Initialize for an output processing pass.
120 start_output_pass (j_decompress_ptr cinfo
)
122 #ifdef BLOCK_SMOOTHING_SUPPORTED
123 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
125 /* If multipass, check to see whether to use block smoothing on this pass */
126 if (coef
->pub
.coef_arrays
!= NULL
) {
127 if (cinfo
->do_block_smoothing
&& smoothing_ok(cinfo
))
128 coef
->pub
.decompress_data
= decompress_smooth_data
;
130 coef
->pub
.decompress_data
= decompress_data
;
133 cinfo
->output_iMCU_row
= 0;
138 * Decompress and return some data in the single-pass case.
139 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
140 * Input and output must run in lockstep since we have only a one-MCU buffer.
141 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
143 * NB: output_buf contains a plane for each component in image,
144 * which we index according to the component's SOF position.
148 decompress_onepass (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
150 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
151 JDIMENSION MCU_col_num
; /* index of current MCU within row */
152 JDIMENSION last_MCU_col
= cinfo
->MCUs_per_row
- 1;
153 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
154 int blkn
, ci
, xindex
, yindex
, yoffset
, useful_width
;
155 JSAMPARRAY output_ptr
;
156 JDIMENSION start_col
, output_col
;
157 jpeg_component_info
*compptr
;
158 inverse_DCT_method_ptr inverse_DCT
;
160 /* Loop to process as much as one whole iMCU row */
161 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
163 for (MCU_col_num
= coef
->MCU_ctr
; MCU_col_num
<= last_MCU_col
;
165 /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
166 if (cinfo
->lim_Se
) /* can bypass in DC only case */
167 FMEMZERO((void FAR
*) coef
->MCU_buffer
[0],
168 (size_t) (cinfo
->blocks_in_MCU
* SIZEOF(JBLOCK
)));
169 if (! (*cinfo
->entropy
->decode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
170 /* Suspension forced; update state counters and exit */
171 coef
->MCU_vert_offset
= yoffset
;
172 coef
->MCU_ctr
= MCU_col_num
;
173 return JPEG_SUSPENDED
;
175 /* Determine where data should go in output_buf and do the IDCT thing.
176 * We skip dummy blocks at the right and bottom edges (but blkn gets
177 * incremented past them!). Note the inner loop relies on having
178 * allocated the MCU_buffer[] blocks sequentially.
180 blkn
= 0; /* index of current DCT block within MCU */
181 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
182 compptr
= cinfo
->cur_comp_info
[ci
];
183 /* Don't bother to IDCT an uninteresting component. */
184 if (! compptr
->component_needed
) {
185 blkn
+= compptr
->MCU_blocks
;
188 inverse_DCT
= cinfo
->idct
->inverse_DCT
[compptr
->component_index
];
189 useful_width
= (MCU_col_num
< last_MCU_col
) ? compptr
->MCU_width
190 : compptr
->last_col_width
;
191 output_ptr
= output_buf
[compptr
->component_index
] +
192 yoffset
* compptr
->DCT_v_scaled_size
;
193 start_col
= MCU_col_num
* compptr
->MCU_sample_width
;
194 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
195 if (cinfo
->input_iMCU_row
< last_iMCU_row
||
196 yoffset
+yindex
< compptr
->last_row_height
) {
197 output_col
= start_col
;
198 for (xindex
= 0; xindex
< useful_width
; xindex
++) {
199 (*inverse_DCT
) (cinfo
, compptr
,
200 (JCOEFPTR
) coef
->MCU_buffer
[blkn
+xindex
],
201 output_ptr
, output_col
);
202 output_col
+= compptr
->DCT_h_scaled_size
;
205 blkn
+= compptr
->MCU_width
;
206 output_ptr
+= compptr
->DCT_v_scaled_size
;
210 /* Completed an MCU row, but perhaps not an iMCU row */
213 /* Completed the iMCU row, advance counters for next one */
214 cinfo
->output_iMCU_row
++;
215 if (++(cinfo
->input_iMCU_row
) < cinfo
->total_iMCU_rows
) {
216 start_iMCU_row(cinfo
);
217 return JPEG_ROW_COMPLETED
;
219 /* Completed the scan */
220 (*cinfo
->inputctl
->finish_input_pass
) (cinfo
);
221 return JPEG_SCAN_COMPLETED
;
226 * Dummy consume-input routine for single-pass operation.
230 dummy_consume_data (j_decompress_ptr cinfo
)
232 return JPEG_SUSPENDED
; /* Always indicate nothing was done */
236 #ifdef D_MULTISCAN_FILES_SUPPORTED
239 * Consume input data and store it in the full-image coefficient buffer.
240 * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
241 * ie, v_samp_factor block rows for each component in the scan.
242 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
246 consume_data (j_decompress_ptr cinfo
)
248 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
249 JDIMENSION MCU_col_num
; /* index of current MCU within row */
250 int blkn
, ci
, xindex
, yindex
, yoffset
;
251 JDIMENSION start_col
;
252 JBLOCKARRAY buffer
[MAX_COMPS_IN_SCAN
];
253 JBLOCKROW buffer_ptr
;
254 jpeg_component_info
*compptr
;
256 /* Align the virtual buffers for the components used in this scan. */
257 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
258 compptr
= cinfo
->cur_comp_info
[ci
];
259 buffer
[ci
] = (*cinfo
->mem
->access_virt_barray
)
260 ((j_common_ptr
) cinfo
, coef
->whole_image
[compptr
->component_index
],
261 cinfo
->input_iMCU_row
* compptr
->v_samp_factor
,
262 (JDIMENSION
) compptr
->v_samp_factor
, TRUE
);
263 /* Note: entropy decoder expects buffer to be zeroed,
264 * but this is handled automatically by the memory manager
265 * because we requested a pre-zeroed array.
269 /* Loop to process one whole iMCU row */
270 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
272 for (MCU_col_num
= coef
->MCU_ctr
; MCU_col_num
< cinfo
->MCUs_per_row
;
274 /* Construct list of pointers to DCT blocks belonging to this MCU */
275 blkn
= 0; /* index of current DCT block within MCU */
276 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
277 compptr
= cinfo
->cur_comp_info
[ci
];
278 start_col
= MCU_col_num
* compptr
->MCU_width
;
279 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
280 buffer_ptr
= buffer
[ci
][yindex
+yoffset
] + start_col
;
281 for (xindex
= 0; xindex
< compptr
->MCU_width
; xindex
++) {
282 coef
->MCU_buffer
[blkn
++] = buffer_ptr
++;
286 /* Try to fetch the MCU. */
287 if (! (*cinfo
->entropy
->decode_mcu
) (cinfo
, coef
->MCU_buffer
)) {
288 /* Suspension forced; update state counters and exit */
289 coef
->MCU_vert_offset
= yoffset
;
290 coef
->MCU_ctr
= MCU_col_num
;
291 return JPEG_SUSPENDED
;
294 /* Completed an MCU row, but perhaps not an iMCU row */
297 /* Completed the iMCU row, advance counters for next one */
298 if (++(cinfo
->input_iMCU_row
) < cinfo
->total_iMCU_rows
) {
299 start_iMCU_row(cinfo
);
300 return JPEG_ROW_COMPLETED
;
302 /* Completed the scan */
303 (*cinfo
->inputctl
->finish_input_pass
) (cinfo
);
304 return JPEG_SCAN_COMPLETED
;
309 * Decompress and return some data in the multi-pass case.
310 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
311 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
313 * NB: output_buf contains a plane for each component in image.
317 decompress_data (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
319 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
320 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
321 JDIMENSION block_num
;
322 int ci
, block_row
, block_rows
;
324 JBLOCKROW buffer_ptr
;
325 JSAMPARRAY output_ptr
;
326 JDIMENSION output_col
;
327 jpeg_component_info
*compptr
;
328 inverse_DCT_method_ptr inverse_DCT
;
330 /* Force some input to be done if we are getting ahead of the input. */
331 while (cinfo
->input_scan_number
< cinfo
->output_scan_number
||
332 (cinfo
->input_scan_number
== cinfo
->output_scan_number
&&
333 cinfo
->input_iMCU_row
<= cinfo
->output_iMCU_row
)) {
334 if ((*cinfo
->inputctl
->consume_input
)(cinfo
) == JPEG_SUSPENDED
)
335 return JPEG_SUSPENDED
;
338 /* OK, output from the virtual arrays. */
339 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
341 /* Don't bother to IDCT an uninteresting component. */
342 if (! compptr
->component_needed
)
344 /* Align the virtual buffer for this component. */
345 buffer
= (*cinfo
->mem
->access_virt_barray
)
346 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
347 cinfo
->output_iMCU_row
* compptr
->v_samp_factor
,
348 (JDIMENSION
) compptr
->v_samp_factor
, FALSE
);
349 /* Count non-dummy DCT block rows in this iMCU row. */
350 if (cinfo
->output_iMCU_row
< last_iMCU_row
)
351 block_rows
= compptr
->v_samp_factor
;
353 /* NB: can't use last_row_height here; it is input-side-dependent! */
354 block_rows
= (int) (compptr
->height_in_blocks
% compptr
->v_samp_factor
);
355 if (block_rows
== 0) block_rows
= compptr
->v_samp_factor
;
357 inverse_DCT
= cinfo
->idct
->inverse_DCT
[ci
];
358 output_ptr
= output_buf
[ci
];
359 /* Loop over all DCT blocks to be processed. */
360 for (block_row
= 0; block_row
< block_rows
; block_row
++) {
361 buffer_ptr
= buffer
[block_row
];
363 for (block_num
= 0; block_num
< compptr
->width_in_blocks
; block_num
++) {
364 (*inverse_DCT
) (cinfo
, compptr
, (JCOEFPTR
) buffer_ptr
,
365 output_ptr
, output_col
);
367 output_col
+= compptr
->DCT_h_scaled_size
;
369 output_ptr
+= compptr
->DCT_v_scaled_size
;
373 if (++(cinfo
->output_iMCU_row
) < cinfo
->total_iMCU_rows
)
374 return JPEG_ROW_COMPLETED
;
375 return JPEG_SCAN_COMPLETED
;
378 #endif /* D_MULTISCAN_FILES_SUPPORTED */
381 #ifdef BLOCK_SMOOTHING_SUPPORTED
384 * This code applies interblock smoothing as described by section K.8
385 * of the JPEG standard: the first 5 AC coefficients are estimated from
386 * the DC values of a DCT block and its 8 neighboring blocks.
387 * We apply smoothing only for progressive JPEG decoding, and only if
388 * the coefficients it can estimate are not yet known to full precision.
391 /* Natural-order array positions of the first 5 zigzag-order coefficients */
399 * Determine whether block smoothing is applicable and safe.
400 * We also latch the current states of the coef_bits[] entries for the
401 * AC coefficients; otherwise, if the input side of the decompressor
402 * advances into a new scan, we might think the coefficients are known
403 * more accurately than they really are.
407 smoothing_ok (j_decompress_ptr cinfo
)
409 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
410 boolean smoothing_useful
= FALSE
;
412 jpeg_component_info
*compptr
;
415 int * coef_bits_latch
;
417 if (! cinfo
->progressive_mode
|| cinfo
->coef_bits
== NULL
)
420 /* Allocate latch area if not already done */
421 if (coef
->coef_bits_latch
== NULL
)
422 coef
->coef_bits_latch
= (int *)
423 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
424 cinfo
->num_components
*
425 (SAVED_COEFS
* SIZEOF(int)));
426 coef_bits_latch
= coef
->coef_bits_latch
;
428 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
430 /* All components' quantization values must already be latched. */
431 if ((qtable
= compptr
->quant_table
) == NULL
)
433 /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
434 if (qtable
->quantval
[0] == 0 ||
435 qtable
->quantval
[Q01_POS
] == 0 ||
436 qtable
->quantval
[Q10_POS
] == 0 ||
437 qtable
->quantval
[Q20_POS
] == 0 ||
438 qtable
->quantval
[Q11_POS
] == 0 ||
439 qtable
->quantval
[Q02_POS
] == 0)
441 /* DC values must be at least partly known for all components. */
442 coef_bits
= cinfo
->coef_bits
[ci
];
443 if (coef_bits
[0] < 0)
445 /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
446 for (coefi
= 1; coefi
<= 5; coefi
++) {
447 coef_bits_latch
[coefi
] = coef_bits
[coefi
];
448 if (coef_bits
[coefi
] != 0)
449 smoothing_useful
= TRUE
;
451 coef_bits_latch
+= SAVED_COEFS
;
454 return smoothing_useful
;
459 * Variant of decompress_data for use when doing block smoothing.
463 decompress_smooth_data (j_decompress_ptr cinfo
, JSAMPIMAGE output_buf
)
465 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
466 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
467 JDIMENSION block_num
, last_block_column
;
468 int ci
, block_row
, block_rows
, access_rows
;
470 JBLOCKROW buffer_ptr
, prev_block_row
, next_block_row
;
471 JSAMPARRAY output_ptr
;
472 JDIMENSION output_col
;
473 jpeg_component_info
*compptr
;
474 inverse_DCT_method_ptr inverse_DCT
;
475 boolean first_row
, last_row
;
478 JQUANT_TBL
*quanttbl
;
479 INT32 Q00
,Q01
,Q02
,Q10
,Q11
,Q20
, num
;
480 int DC1
,DC2
,DC3
,DC4
,DC5
,DC6
,DC7
,DC8
,DC9
;
483 /* Force some input to be done if we are getting ahead of the input. */
484 while (cinfo
->input_scan_number
<= cinfo
->output_scan_number
&&
485 ! cinfo
->inputctl
->eoi_reached
) {
486 if (cinfo
->input_scan_number
== cinfo
->output_scan_number
) {
487 /* If input is working on current scan, we ordinarily want it to
488 * have completed the current row. But if input scan is DC,
489 * we want it to keep one row ahead so that next block row's DC
490 * values are up to date.
492 JDIMENSION delta
= (cinfo
->Ss
== 0) ? 1 : 0;
493 if (cinfo
->input_iMCU_row
> cinfo
->output_iMCU_row
+delta
)
496 if ((*cinfo
->inputctl
->consume_input
)(cinfo
) == JPEG_SUSPENDED
)
497 return JPEG_SUSPENDED
;
500 /* OK, output from the virtual arrays. */
501 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
503 /* Don't bother to IDCT an uninteresting component. */
504 if (! compptr
->component_needed
)
506 /* Count non-dummy DCT block rows in this iMCU row. */
507 if (cinfo
->output_iMCU_row
< last_iMCU_row
) {
508 block_rows
= compptr
->v_samp_factor
;
509 access_rows
= block_rows
* 2; /* this and next iMCU row */
512 /* NB: can't use last_row_height here; it is input-side-dependent! */
513 block_rows
= (int) (compptr
->height_in_blocks
% compptr
->v_samp_factor
);
514 if (block_rows
== 0) block_rows
= compptr
->v_samp_factor
;
515 access_rows
= block_rows
; /* this iMCU row only */
518 /* Align the virtual buffer for this component. */
519 if (cinfo
->output_iMCU_row
> 0) {
520 access_rows
+= compptr
->v_samp_factor
; /* prior iMCU row too */
521 buffer
= (*cinfo
->mem
->access_virt_barray
)
522 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
523 (cinfo
->output_iMCU_row
- 1) * compptr
->v_samp_factor
,
524 (JDIMENSION
) access_rows
, FALSE
);
525 buffer
+= compptr
->v_samp_factor
; /* point to current iMCU row */
528 buffer
= (*cinfo
->mem
->access_virt_barray
)
529 ((j_common_ptr
) cinfo
, coef
->whole_image
[ci
],
530 (JDIMENSION
) 0, (JDIMENSION
) access_rows
, FALSE
);
533 /* Fetch component-dependent info */
534 coef_bits
= coef
->coef_bits_latch
+ (ci
* SAVED_COEFS
);
535 quanttbl
= compptr
->quant_table
;
536 Q00
= quanttbl
->quantval
[0];
537 Q01
= quanttbl
->quantval
[Q01_POS
];
538 Q10
= quanttbl
->quantval
[Q10_POS
];
539 Q20
= quanttbl
->quantval
[Q20_POS
];
540 Q11
= quanttbl
->quantval
[Q11_POS
];
541 Q02
= quanttbl
->quantval
[Q02_POS
];
542 inverse_DCT
= cinfo
->idct
->inverse_DCT
[ci
];
543 output_ptr
= output_buf
[ci
];
544 /* Loop over all DCT blocks to be processed. */
545 for (block_row
= 0; block_row
< block_rows
; block_row
++) {
546 buffer_ptr
= buffer
[block_row
];
547 if (first_row
&& block_row
== 0)
548 prev_block_row
= buffer_ptr
;
550 prev_block_row
= buffer
[block_row
-1];
551 if (last_row
&& block_row
== block_rows
-1)
552 next_block_row
= buffer_ptr
;
554 next_block_row
= buffer
[block_row
+1];
555 /* We fetch the surrounding DC values using a sliding-register approach.
556 * Initialize all nine here so as to do the right thing on narrow pics.
558 DC1
= DC2
= DC3
= (int) prev_block_row
[0][0];
559 DC4
= DC5
= DC6
= (int) buffer_ptr
[0][0];
560 DC7
= DC8
= DC9
= (int) next_block_row
[0][0];
562 last_block_column
= compptr
->width_in_blocks
- 1;
563 for (block_num
= 0; block_num
<= last_block_column
; block_num
++) {
564 /* Fetch current DCT block into workspace so we can modify it. */
565 jcopy_block_row(buffer_ptr
, (JBLOCKROW
) workspace
, (JDIMENSION
) 1);
566 /* Update DC values */
567 if (block_num
< last_block_column
) {
568 DC3
= (int) prev_block_row
[1][0];
569 DC6
= (int) buffer_ptr
[1][0];
570 DC9
= (int) next_block_row
[1][0];
572 /* Compute coefficient estimates per K.8.
573 * An estimate is applied only if coefficient is still zero,
574 * and is not known to be fully accurate.
577 if ((Al
=coef_bits
[1]) != 0 && workspace
[1] == 0) {
578 num
= 36 * Q00
* (DC4
- DC6
);
580 pred
= (int) (((Q01
<<7) + num
) / (Q01
<<8));
581 if (Al
> 0 && pred
>= (1<<Al
))
584 pred
= (int) (((Q01
<<7) - num
) / (Q01
<<8));
585 if (Al
> 0 && pred
>= (1<<Al
))
589 workspace
[1] = (JCOEF
) pred
;
592 if ((Al
=coef_bits
[2]) != 0 && workspace
[8] == 0) {
593 num
= 36 * Q00
* (DC2
- DC8
);
595 pred
= (int) (((Q10
<<7) + num
) / (Q10
<<8));
596 if (Al
> 0 && pred
>= (1<<Al
))
599 pred
= (int) (((Q10
<<7) - num
) / (Q10
<<8));
600 if (Al
> 0 && pred
>= (1<<Al
))
604 workspace
[8] = (JCOEF
) pred
;
607 if ((Al
=coef_bits
[3]) != 0 && workspace
[16] == 0) {
608 num
= 9 * Q00
* (DC2
+ DC8
- 2*DC5
);
610 pred
= (int) (((Q20
<<7) + num
) / (Q20
<<8));
611 if (Al
> 0 && pred
>= (1<<Al
))
614 pred
= (int) (((Q20
<<7) - num
) / (Q20
<<8));
615 if (Al
> 0 && pred
>= (1<<Al
))
619 workspace
[16] = (JCOEF
) pred
;
622 if ((Al
=coef_bits
[4]) != 0 && workspace
[9] == 0) {
623 num
= 5 * Q00
* (DC1
- DC3
- DC7
+ DC9
);
625 pred
= (int) (((Q11
<<7) + num
) / (Q11
<<8));
626 if (Al
> 0 && pred
>= (1<<Al
))
629 pred
= (int) (((Q11
<<7) - num
) / (Q11
<<8));
630 if (Al
> 0 && pred
>= (1<<Al
))
634 workspace
[9] = (JCOEF
) pred
;
637 if ((Al
=coef_bits
[5]) != 0 && workspace
[2] == 0) {
638 num
= 9 * Q00
* (DC4
+ DC6
- 2*DC5
);
640 pred
= (int) (((Q02
<<7) + num
) / (Q02
<<8));
641 if (Al
> 0 && pred
>= (1<<Al
))
644 pred
= (int) (((Q02
<<7) - num
) / (Q02
<<8));
645 if (Al
> 0 && pred
>= (1<<Al
))
649 workspace
[2] = (JCOEF
) pred
;
651 /* OK, do the IDCT */
652 (*inverse_DCT
) (cinfo
, compptr
, (JCOEFPTR
) workspace
,
653 output_ptr
, output_col
);
654 /* Advance for next column */
655 DC1
= DC2
; DC2
= DC3
;
656 DC4
= DC5
; DC5
= DC6
;
657 DC7
= DC8
; DC8
= DC9
;
658 buffer_ptr
++, prev_block_row
++, next_block_row
++;
659 output_col
+= compptr
->DCT_h_scaled_size
;
661 output_ptr
+= compptr
->DCT_v_scaled_size
;
665 if (++(cinfo
->output_iMCU_row
) < cinfo
->total_iMCU_rows
)
666 return JPEG_ROW_COMPLETED
;
667 return JPEG_SCAN_COMPLETED
;
670 #endif /* BLOCK_SMOOTHING_SUPPORTED */
674 * Initialize coefficient buffer controller.
678 jinit_d_coef_controller (j_decompress_ptr cinfo
, boolean need_full_buffer
)
683 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
684 SIZEOF(my_coef_controller
));
685 cinfo
->coef
= (struct jpeg_d_coef_controller
*) coef
;
686 coef
->pub
.start_input_pass
= start_input_pass
;
687 coef
->pub
.start_output_pass
= start_output_pass
;
688 #ifdef BLOCK_SMOOTHING_SUPPORTED
689 coef
->coef_bits_latch
= NULL
;
692 /* Create the coefficient buffer. */
693 if (need_full_buffer
) {
694 #ifdef D_MULTISCAN_FILES_SUPPORTED
695 /* Allocate a full-image virtual array for each component, */
696 /* padded to a multiple of samp_factor DCT blocks in each direction. */
697 /* Note we ask for a pre-zeroed array. */
699 jpeg_component_info
*compptr
;
701 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
703 access_rows
= compptr
->v_samp_factor
;
704 #ifdef BLOCK_SMOOTHING_SUPPORTED
705 /* If block smoothing could be used, need a bigger window */
706 if (cinfo
->progressive_mode
)
709 coef
->whole_image
[ci
] = (*cinfo
->mem
->request_virt_barray
)
710 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, TRUE
,
711 (JDIMENSION
) jround_up((long) compptr
->width_in_blocks
,
712 (long) compptr
->h_samp_factor
),
713 (JDIMENSION
) jround_up((long) compptr
->height_in_blocks
,
714 (long) compptr
->v_samp_factor
),
715 (JDIMENSION
) access_rows
);
717 coef
->pub
.consume_data
= consume_data
;
718 coef
->pub
.decompress_data
= decompress_data
;
719 coef
->pub
.coef_arrays
= coef
->whole_image
; /* link to virtual arrays */
721 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
724 /* We only need a single-MCU buffer. */
729 (*cinfo
->mem
->alloc_large
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
730 D_MAX_BLOCKS_IN_MCU
* SIZEOF(JBLOCK
));
731 for (i
= 0; i
< D_MAX_BLOCKS_IN_MCU
; i
++) {
732 coef
->MCU_buffer
[i
] = buffer
+ i
;
734 if (cinfo
->lim_Se
== 0) /* DC only case: want to bypass later */
735 FMEMZERO((void FAR
*) buffer
,
736 (size_t) (D_MAX_BLOCKS_IN_MCU
* SIZEOF(JBLOCK
)));
737 coef
->pub
.consume_data
= dummy_consume_data
;
738 coef
->pub
.decompress_data
= decompress_onepass
;
739 coef
->pub
.coef_arrays
= NULL
; /* flag for no virtual arrays */