/src/libjpeg-turbo/jdcoefct.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * jdcoefct.c |
3 | | * |
4 | | * This file was part of the Independent JPEG Group's software: |
5 | | * Copyright (C) 1994-1997, Thomas G. Lane. |
6 | | * libjpeg-turbo Modifications: |
7 | | * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB |
8 | | * Copyright (C) 2010, 2015-2016, 2019-2020, 2022-2023, D. R. Commander. |
9 | | * Copyright (C) 2015, 2020, Google, Inc. |
10 | | * For conditions of distribution and use, see the accompanying README.ijg |
11 | | * file. |
12 | | * |
13 | | * This file contains the coefficient buffer controller for decompression. |
14 | | * This controller is the top level of the lossy JPEG decompressor proper. |
15 | | * The coefficient buffer lies between entropy decoding and inverse-DCT steps. |
16 | | * |
17 | | * In buffered-image mode, this controller is the interface between |
18 | | * input-oriented processing and output-oriented processing. |
19 | | * Also, the input side (only) is used when reading a file for transcoding. |
20 | | */ |
21 | | |
22 | | #include "jinclude.h" |
23 | | #include "jdcoefct.h" |
24 | | #include "jpegapicomp.h" |
25 | | #include "jsamplecomp.h" |
26 | | |
27 | | |
28 | | /* Forward declarations */ |
29 | | METHODDEF(int) decompress_onepass(j_decompress_ptr cinfo, |
30 | | _JSAMPIMAGE output_buf); |
31 | | #ifdef D_MULTISCAN_FILES_SUPPORTED |
32 | | METHODDEF(int) decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf); |
33 | | #endif |
34 | | #ifdef BLOCK_SMOOTHING_SUPPORTED |
35 | | LOCAL(boolean) smoothing_ok(j_decompress_ptr cinfo); |
36 | | METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo, |
37 | | _JSAMPIMAGE output_buf); |
38 | | #endif |
39 | | |
40 | | |
41 | | /* |
42 | | * Initialize for an input processing pass. |
43 | | */ |
44 | | |
45 | | METHODDEF(void) |
46 | | start_input_pass(j_decompress_ptr cinfo) |
47 | 0 | { |
48 | 0 | cinfo->input_iMCU_row = 0; |
49 | 0 | start_iMCU_row(cinfo); |
50 | 0 | } |
51 | | |
52 | | |
53 | | /* |
54 | | * Initialize for an output processing pass. |
55 | | */ |
56 | | |
57 | | METHODDEF(void) |
58 | | start_output_pass(j_decompress_ptr cinfo) |
59 | 0 | { |
60 | 0 | #ifdef BLOCK_SMOOTHING_SUPPORTED |
61 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
62 | | |
63 | | /* If multipass, check to see whether to use block smoothing on this pass */ |
64 | 0 | if (coef->pub.coef_arrays != NULL) { |
65 | 0 | if (cinfo->do_block_smoothing && smoothing_ok(cinfo)) |
66 | 0 | coef->pub._decompress_data = decompress_smooth_data; |
67 | 0 | else |
68 | 0 | coef->pub._decompress_data = decompress_data; |
69 | 0 | } |
70 | 0 | #endif |
71 | 0 | cinfo->output_iMCU_row = 0; |
72 | 0 | } |
73 | | |
74 | | |
75 | | /* |
76 | | * Decompress and return some data in the single-pass case. |
77 | | * Always attempts to emit one fully interleaved MCU row ("iMCU" row). |
78 | | * Input and output must run in lockstep since we have only a one-MCU buffer. |
79 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
80 | | * |
81 | | * NB: output_buf contains a plane for each component in image, |
82 | | * which we index according to the component's SOF position. |
83 | | */ |
84 | | |
85 | | METHODDEF(int) |
86 | | decompress_onepass(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) |
87 | 0 | { |
88 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
89 | 0 | JDIMENSION MCU_col_num; /* index of current MCU within row */ |
90 | 0 | JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; |
91 | 0 | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
92 | 0 | int blkn, ci, xindex, yindex, yoffset, useful_width; |
93 | 0 | _JSAMPARRAY output_ptr; |
94 | 0 | JDIMENSION start_col, output_col; |
95 | 0 | jpeg_component_info *compptr; |
96 | 0 | _inverse_DCT_method_ptr inverse_DCT; |
97 | | |
98 | | /* Loop to process as much as one whole iMCU row */ |
99 | 0 | for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; |
100 | 0 | yoffset++) { |
101 | 0 | for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col; |
102 | 0 | MCU_col_num++) { |
103 | | /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */ |
104 | 0 | jzero_far((void *)coef->MCU_buffer[0], |
105 | 0 | (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK))); |
106 | 0 | if (!cinfo->entropy->insufficient_data) |
107 | 0 | cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; |
108 | 0 | if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { |
109 | | /* Suspension forced; update state counters and exit */ |
110 | 0 | coef->MCU_vert_offset = yoffset; |
111 | 0 | coef->MCU_ctr = MCU_col_num; |
112 | 0 | return JPEG_SUSPENDED; |
113 | 0 | } |
114 | | |
115 | | /* Only perform the IDCT on blocks that are contained within the desired |
116 | | * cropping region. |
117 | | */ |
118 | 0 | if (MCU_col_num >= cinfo->master->first_iMCU_col && |
119 | 0 | MCU_col_num <= cinfo->master->last_iMCU_col) { |
120 | | /* Determine where data should go in output_buf and do the IDCT thing. |
121 | | * We skip dummy blocks at the right and bottom edges (but blkn gets |
122 | | * incremented past them!). Note the inner loop relies on having |
123 | | * allocated the MCU_buffer[] blocks sequentially. |
124 | | */ |
125 | 0 | blkn = 0; /* index of current DCT block within MCU */ |
126 | 0 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
127 | 0 | compptr = cinfo->cur_comp_info[ci]; |
128 | | /* Don't bother to IDCT an uninteresting component. */ |
129 | 0 | if (!compptr->component_needed) { |
130 | 0 | blkn += compptr->MCU_blocks; |
131 | 0 | continue; |
132 | 0 | } |
133 | 0 | inverse_DCT = cinfo->idct->_inverse_DCT[compptr->component_index]; |
134 | 0 | useful_width = (MCU_col_num < last_MCU_col) ? |
135 | 0 | compptr->MCU_width : compptr->last_col_width; |
136 | 0 | output_ptr = output_buf[compptr->component_index] + |
137 | 0 | yoffset * compptr->_DCT_scaled_size; |
138 | 0 | start_col = (MCU_col_num - cinfo->master->first_iMCU_col) * |
139 | 0 | compptr->MCU_sample_width; |
140 | 0 | for (yindex = 0; yindex < compptr->MCU_height; yindex++) { |
141 | 0 | if (cinfo->input_iMCU_row < last_iMCU_row || |
142 | 0 | yoffset + yindex < compptr->last_row_height) { |
143 | 0 | output_col = start_col; |
144 | 0 | for (xindex = 0; xindex < useful_width; xindex++) { |
145 | 0 | (*inverse_DCT) (cinfo, compptr, |
146 | 0 | (JCOEFPTR)coef->MCU_buffer[blkn + xindex], |
147 | 0 | output_ptr, output_col); |
148 | 0 | output_col += compptr->_DCT_scaled_size; |
149 | 0 | } |
150 | 0 | } |
151 | 0 | blkn += compptr->MCU_width; |
152 | 0 | output_ptr += compptr->_DCT_scaled_size; |
153 | 0 | } |
154 | 0 | } |
155 | 0 | } |
156 | 0 | } |
157 | | /* Completed an MCU row, but perhaps not an iMCU row */ |
158 | 0 | coef->MCU_ctr = 0; |
159 | 0 | } |
160 | | /* Completed the iMCU row, advance counters for next one */ |
161 | 0 | cinfo->output_iMCU_row++; |
162 | 0 | if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { |
163 | 0 | start_iMCU_row(cinfo); |
164 | 0 | return JPEG_ROW_COMPLETED; |
165 | 0 | } |
166 | | /* Completed the scan */ |
167 | 0 | (*cinfo->inputctl->finish_input_pass) (cinfo); |
168 | 0 | return JPEG_SCAN_COMPLETED; |
169 | 0 | } |
170 | | |
171 | | |
172 | | /* |
173 | | * Dummy consume-input routine for single-pass operation. |
174 | | */ |
175 | | |
176 | | METHODDEF(int) |
177 | | dummy_consume_data(j_decompress_ptr cinfo) |
178 | 0 | { |
179 | 0 | return JPEG_SUSPENDED; /* Always indicate nothing was done */ |
180 | 0 | } |
181 | | |
182 | | |
183 | | #ifdef D_MULTISCAN_FILES_SUPPORTED |
184 | | |
185 | | /* |
186 | | * Consume input data and store it in the full-image coefficient buffer. |
187 | | * We read as much as one fully interleaved MCU row ("iMCU" row) per call, |
188 | | * ie, v_samp_factor block rows for each component in the scan. |
189 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
190 | | */ |
191 | | |
192 | | METHODDEF(int) |
193 | | consume_data(j_decompress_ptr cinfo) |
194 | 0 | { |
195 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
196 | 0 | JDIMENSION MCU_col_num; /* index of current MCU within row */ |
197 | 0 | int blkn, ci, xindex, yindex, yoffset; |
198 | 0 | JDIMENSION start_col; |
199 | 0 | JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; |
200 | 0 | JBLOCKROW buffer_ptr; |
201 | 0 | jpeg_component_info *compptr; |
202 | | |
203 | | /* Align the virtual buffers for the components used in this scan. */ |
204 | 0 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
205 | 0 | compptr = cinfo->cur_comp_info[ci]; |
206 | 0 | buffer[ci] = (*cinfo->mem->access_virt_barray) |
207 | 0 | ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index], |
208 | 0 | cinfo->input_iMCU_row * compptr->v_samp_factor, |
209 | 0 | (JDIMENSION)compptr->v_samp_factor, TRUE); |
210 | | /* Note: entropy decoder expects buffer to be zeroed, |
211 | | * but this is handled automatically by the memory manager |
212 | | * because we requested a pre-zeroed array. |
213 | | */ |
214 | 0 | } |
215 | | |
216 | | /* Loop to process one whole iMCU row */ |
217 | 0 | for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; |
218 | 0 | yoffset++) { |
219 | 0 | for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; |
220 | 0 | MCU_col_num++) { |
221 | | /* Construct list of pointers to DCT blocks belonging to this MCU */ |
222 | 0 | blkn = 0; /* index of current DCT block within MCU */ |
223 | 0 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
224 | 0 | compptr = cinfo->cur_comp_info[ci]; |
225 | 0 | start_col = MCU_col_num * compptr->MCU_width; |
226 | 0 | for (yindex = 0; yindex < compptr->MCU_height; yindex++) { |
227 | 0 | buffer_ptr = buffer[ci][yindex + yoffset] + start_col; |
228 | 0 | for (xindex = 0; xindex < compptr->MCU_width; xindex++) { |
229 | 0 | coef->MCU_buffer[blkn++] = buffer_ptr++; |
230 | 0 | } |
231 | 0 | } |
232 | 0 | } |
233 | 0 | if (!cinfo->entropy->insufficient_data) |
234 | 0 | cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row; |
235 | | /* Try to fetch the MCU. */ |
236 | 0 | if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { |
237 | | /* Suspension forced; update state counters and exit */ |
238 | 0 | coef->MCU_vert_offset = yoffset; |
239 | 0 | coef->MCU_ctr = MCU_col_num; |
240 | 0 | return JPEG_SUSPENDED; |
241 | 0 | } |
242 | 0 | } |
243 | | /* Completed an MCU row, but perhaps not an iMCU row */ |
244 | 0 | coef->MCU_ctr = 0; |
245 | 0 | } |
246 | | /* Completed the iMCU row, advance counters for next one */ |
247 | 0 | if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { |
248 | 0 | start_iMCU_row(cinfo); |
249 | 0 | return JPEG_ROW_COMPLETED; |
250 | 0 | } |
251 | | /* Completed the scan */ |
252 | 0 | (*cinfo->inputctl->finish_input_pass) (cinfo); |
253 | 0 | return JPEG_SCAN_COMPLETED; |
254 | 0 | } |
255 | | |
256 | | |
257 | | /* |
258 | | * Decompress and return some data in the multi-pass case. |
259 | | * Always attempts to emit one fully interleaved MCU row ("iMCU" row). |
260 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
261 | | * |
262 | | * NB: output_buf contains a plane for each component in image. |
263 | | */ |
264 | | |
265 | | METHODDEF(int) |
266 | | decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) |
267 | 0 | { |
268 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
269 | 0 | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
270 | 0 | JDIMENSION block_num; |
271 | 0 | int ci, block_row, block_rows; |
272 | 0 | JBLOCKARRAY buffer; |
273 | 0 | JBLOCKROW buffer_ptr; |
274 | 0 | _JSAMPARRAY output_ptr; |
275 | 0 | JDIMENSION output_col; |
276 | 0 | jpeg_component_info *compptr; |
277 | 0 | _inverse_DCT_method_ptr inverse_DCT; |
278 | | |
279 | | /* Force some input to be done if we are getting ahead of the input. */ |
280 | 0 | while (cinfo->input_scan_number < cinfo->output_scan_number || |
281 | 0 | (cinfo->input_scan_number == cinfo->output_scan_number && |
282 | 0 | cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) { |
283 | 0 | if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) |
284 | 0 | return JPEG_SUSPENDED; |
285 | 0 | } |
286 | | |
287 | | /* OK, output from the virtual arrays. */ |
288 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
289 | 0 | ci++, compptr++) { |
290 | | /* Don't bother to IDCT an uninteresting component. */ |
291 | 0 | if (!compptr->component_needed) |
292 | 0 | continue; |
293 | | /* Align the virtual buffer for this component. */ |
294 | 0 | buffer = (*cinfo->mem->access_virt_barray) |
295 | 0 | ((j_common_ptr)cinfo, coef->whole_image[ci], |
296 | 0 | cinfo->output_iMCU_row * compptr->v_samp_factor, |
297 | 0 | (JDIMENSION)compptr->v_samp_factor, FALSE); |
298 | | /* Count non-dummy DCT block rows in this iMCU row. */ |
299 | 0 | if (cinfo->output_iMCU_row < last_iMCU_row) |
300 | 0 | block_rows = compptr->v_samp_factor; |
301 | 0 | else { |
302 | | /* NB: can't use last_row_height here; it is input-side-dependent! */ |
303 | 0 | block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); |
304 | 0 | if (block_rows == 0) block_rows = compptr->v_samp_factor; |
305 | 0 | } |
306 | 0 | inverse_DCT = cinfo->idct->_inverse_DCT[ci]; |
307 | 0 | output_ptr = output_buf[ci]; |
308 | | /* Loop over all DCT blocks to be processed. */ |
309 | 0 | for (block_row = 0; block_row < block_rows; block_row++) { |
310 | 0 | buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci]; |
311 | 0 | output_col = 0; |
312 | 0 | for (block_num = cinfo->master->first_MCU_col[ci]; |
313 | 0 | block_num <= cinfo->master->last_MCU_col[ci]; block_num++) { |
314 | 0 | (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr, |
315 | 0 | output_col); |
316 | 0 | buffer_ptr++; |
317 | 0 | output_col += compptr->_DCT_scaled_size; |
318 | 0 | } |
319 | 0 | output_ptr += compptr->_DCT_scaled_size; |
320 | 0 | } |
321 | 0 | } |
322 | |
|
323 | 0 | if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) |
324 | 0 | return JPEG_ROW_COMPLETED; |
325 | 0 | return JPEG_SCAN_COMPLETED; |
326 | 0 | } |
327 | | |
328 | | #endif /* D_MULTISCAN_FILES_SUPPORTED */ |
329 | | |
330 | | |
331 | | #ifdef BLOCK_SMOOTHING_SUPPORTED |
332 | | |
333 | | /* |
334 | | * This code applies interblock smoothing; the first 9 AC coefficients are |
335 | | * estimated from the DC values of a DCT block and its 24 neighboring blocks. |
336 | | * We apply smoothing only for progressive JPEG decoding, and only if |
337 | | * the coefficients it can estimate are not yet known to full precision. |
338 | | */ |
339 | | |
340 | | /* Natural-order array positions of the first 9 zigzag-order coefficients */ |
341 | 0 | #define Q01_POS 1 |
342 | 0 | #define Q10_POS 8 |
343 | 0 | #define Q20_POS 16 |
344 | 0 | #define Q11_POS 9 |
345 | 0 | #define Q02_POS 2 |
346 | 0 | #define Q03_POS 3 |
347 | 0 | #define Q12_POS 10 |
348 | 0 | #define Q21_POS 17 |
349 | 0 | #define Q30_POS 24 |
350 | | |
351 | | /* |
352 | | * Determine whether block smoothing is applicable and safe. |
353 | | * We also latch the current states of the coef_bits[] entries for the |
354 | | * AC coefficients; otherwise, if the input side of the decompressor |
355 | | * advances into a new scan, we might think the coefficients are known |
356 | | * more accurately than they really are. |
357 | | */ |
358 | | |
359 | | LOCAL(boolean) |
360 | | smoothing_ok(j_decompress_ptr cinfo) |
361 | 0 | { |
362 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
363 | 0 | boolean smoothing_useful = FALSE; |
364 | 0 | int ci, coefi; |
365 | 0 | jpeg_component_info *compptr; |
366 | 0 | JQUANT_TBL *qtable; |
367 | 0 | int *coef_bits, *prev_coef_bits; |
368 | 0 | int *coef_bits_latch, *prev_coef_bits_latch; |
369 | |
|
370 | 0 | if (!cinfo->progressive_mode || cinfo->coef_bits == NULL) |
371 | 0 | return FALSE; |
372 | | |
373 | | /* Allocate latch area if not already done */ |
374 | 0 | if (coef->coef_bits_latch == NULL) |
375 | 0 | coef->coef_bits_latch = (int *) |
376 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
377 | 0 | cinfo->num_components * 2 * |
378 | 0 | (SAVED_COEFS * sizeof(int))); |
379 | 0 | coef_bits_latch = coef->coef_bits_latch; |
380 | 0 | prev_coef_bits_latch = |
381 | 0 | &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS]; |
382 | |
|
383 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
384 | 0 | ci++, compptr++) { |
385 | | /* All components' quantization values must already be latched. */ |
386 | 0 | if ((qtable = compptr->quant_table) == NULL) |
387 | 0 | return FALSE; |
388 | | /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */ |
389 | 0 | if (qtable->quantval[0] == 0 || |
390 | 0 | qtable->quantval[Q01_POS] == 0 || |
391 | 0 | qtable->quantval[Q10_POS] == 0 || |
392 | 0 | qtable->quantval[Q20_POS] == 0 || |
393 | 0 | qtable->quantval[Q11_POS] == 0 || |
394 | 0 | qtable->quantval[Q02_POS] == 0 || |
395 | 0 | qtable->quantval[Q03_POS] == 0 || |
396 | 0 | qtable->quantval[Q12_POS] == 0 || |
397 | 0 | qtable->quantval[Q21_POS] == 0 || |
398 | 0 | qtable->quantval[Q30_POS] == 0) |
399 | 0 | return FALSE; |
400 | | /* DC values must be at least partly known for all components. */ |
401 | 0 | coef_bits = cinfo->coef_bits[ci]; |
402 | 0 | prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components]; |
403 | 0 | if (coef_bits[0] < 0) |
404 | 0 | return FALSE; |
405 | 0 | coef_bits_latch[0] = coef_bits[0]; |
406 | | /* Block smoothing is helpful if some AC coefficients remain inaccurate. */ |
407 | 0 | for (coefi = 1; coefi < SAVED_COEFS; coefi++) { |
408 | 0 | if (cinfo->input_scan_number > 1) |
409 | 0 | prev_coef_bits_latch[coefi] = prev_coef_bits[coefi]; |
410 | 0 | else |
411 | 0 | prev_coef_bits_latch[coefi] = -1; |
412 | 0 | coef_bits_latch[coefi] = coef_bits[coefi]; |
413 | 0 | if (coef_bits[coefi] != 0) |
414 | 0 | smoothing_useful = TRUE; |
415 | 0 | } |
416 | 0 | coef_bits_latch += SAVED_COEFS; |
417 | 0 | prev_coef_bits_latch += SAVED_COEFS; |
418 | 0 | } |
419 | | |
420 | 0 | return smoothing_useful; |
421 | 0 | } |
422 | | |
423 | | |
424 | | /* |
425 | | * Variant of decompress_data for use when doing block smoothing. |
426 | | */ |
427 | | |
428 | | METHODDEF(int) |
429 | | decompress_smooth_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) |
430 | 0 | { |
431 | 0 | my_coef_ptr coef = (my_coef_ptr)cinfo->coef; |
432 | 0 | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
433 | 0 | JDIMENSION block_num, last_block_column; |
434 | 0 | int ci, block_row, block_rows, access_rows, image_block_row, |
435 | 0 | image_block_rows; |
436 | 0 | JBLOCKARRAY buffer; |
437 | 0 | JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row; |
438 | 0 | JBLOCKROW next_block_row, next_next_block_row; |
439 | 0 | _JSAMPARRAY output_ptr; |
440 | 0 | JDIMENSION output_col; |
441 | 0 | jpeg_component_info *compptr; |
442 | 0 | _inverse_DCT_method_ptr inverse_DCT; |
443 | 0 | boolean change_dc; |
444 | 0 | JCOEF *workspace; |
445 | 0 | int *coef_bits; |
446 | 0 | JQUANT_TBL *quanttbl; |
447 | 0 | JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num; |
448 | 0 | int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12, |
449 | 0 | DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24, |
450 | 0 | DC25; |
451 | 0 | int Al, pred; |
452 | | |
453 | | /* Keep a local variable to avoid looking it up more than once */ |
454 | 0 | workspace = coef->workspace; |
455 | | |
456 | | /* Force some input to be done if we are getting ahead of the input. */ |
457 | 0 | while (cinfo->input_scan_number <= cinfo->output_scan_number && |
458 | 0 | !cinfo->inputctl->eoi_reached) { |
459 | 0 | if (cinfo->input_scan_number == cinfo->output_scan_number) { |
460 | | /* If input is working on current scan, we ordinarily want it to |
461 | | * have completed the current row. But if input scan is DC, |
462 | | * we want it to keep two rows ahead so that next two block rows' DC |
463 | | * values are up to date. |
464 | | */ |
465 | 0 | JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0; |
466 | 0 | if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta) |
467 | 0 | break; |
468 | 0 | } |
469 | 0 | if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) |
470 | 0 | return JPEG_SUSPENDED; |
471 | 0 | } |
472 | | |
473 | | /* OK, output from the virtual arrays. */ |
474 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
475 | 0 | ci++, compptr++) { |
476 | | /* Don't bother to IDCT an uninteresting component. */ |
477 | 0 | if (!compptr->component_needed) |
478 | 0 | continue; |
479 | | /* Count non-dummy DCT block rows in this iMCU row. */ |
480 | 0 | if (cinfo->output_iMCU_row + 1 < last_iMCU_row) { |
481 | 0 | block_rows = compptr->v_samp_factor; |
482 | 0 | access_rows = block_rows * 3; /* this and next two iMCU rows */ |
483 | 0 | } else if (cinfo->output_iMCU_row < last_iMCU_row) { |
484 | 0 | block_rows = compptr->v_samp_factor; |
485 | 0 | access_rows = block_rows * 2; /* this and next iMCU row */ |
486 | 0 | } else { |
487 | | /* NB: can't use last_row_height here; it is input-side-dependent! */ |
488 | 0 | block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); |
489 | 0 | if (block_rows == 0) block_rows = compptr->v_samp_factor; |
490 | 0 | access_rows = block_rows; /* this iMCU row only */ |
491 | 0 | } |
492 | | /* Align the virtual buffer for this component. */ |
493 | 0 | if (cinfo->output_iMCU_row > 1) { |
494 | 0 | access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */ |
495 | 0 | buffer = (*cinfo->mem->access_virt_barray) |
496 | 0 | ((j_common_ptr)cinfo, coef->whole_image[ci], |
497 | 0 | (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor, |
498 | 0 | (JDIMENSION)access_rows, FALSE); |
499 | 0 | buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */ |
500 | 0 | } else if (cinfo->output_iMCU_row > 0) { |
501 | 0 | access_rows += compptr->v_samp_factor; /* prior iMCU row too */ |
502 | 0 | buffer = (*cinfo->mem->access_virt_barray) |
503 | 0 | ((j_common_ptr)cinfo, coef->whole_image[ci], |
504 | 0 | (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor, |
505 | 0 | (JDIMENSION)access_rows, FALSE); |
506 | 0 | buffer += compptr->v_samp_factor; /* point to current iMCU row */ |
507 | 0 | } else { |
508 | 0 | buffer = (*cinfo->mem->access_virt_barray) |
509 | 0 | ((j_common_ptr)cinfo, coef->whole_image[ci], |
510 | 0 | (JDIMENSION)0, (JDIMENSION)access_rows, FALSE); |
511 | 0 | } |
512 | | /* Fetch component-dependent info. |
513 | | * If the current scan is incomplete, then we use the component-dependent |
514 | | * info from the previous scan. |
515 | | */ |
516 | 0 | if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row) |
517 | 0 | coef_bits = |
518 | 0 | coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS); |
519 | 0 | else |
520 | 0 | coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); |
521 | | |
522 | | /* We only do DC interpolation if no AC coefficient data is available. */ |
523 | 0 | change_dc = |
524 | 0 | coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 && |
525 | 0 | coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 && |
526 | 0 | coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1; |
527 | |
|
528 | 0 | quanttbl = compptr->quant_table; |
529 | 0 | Q00 = quanttbl->quantval[0]; |
530 | 0 | Q01 = quanttbl->quantval[Q01_POS]; |
531 | 0 | Q10 = quanttbl->quantval[Q10_POS]; |
532 | 0 | Q20 = quanttbl->quantval[Q20_POS]; |
533 | 0 | Q11 = quanttbl->quantval[Q11_POS]; |
534 | 0 | Q02 = quanttbl->quantval[Q02_POS]; |
535 | 0 | if (change_dc) { |
536 | 0 | Q03 = quanttbl->quantval[Q03_POS]; |
537 | 0 | Q12 = quanttbl->quantval[Q12_POS]; |
538 | 0 | Q21 = quanttbl->quantval[Q21_POS]; |
539 | 0 | Q30 = quanttbl->quantval[Q30_POS]; |
540 | 0 | } |
541 | 0 | inverse_DCT = cinfo->idct->_inverse_DCT[ci]; |
542 | 0 | output_ptr = output_buf[ci]; |
543 | | /* Loop over all DCT blocks to be processed. */ |
544 | 0 | image_block_rows = block_rows * cinfo->total_iMCU_rows; |
545 | 0 | for (block_row = 0; block_row < block_rows; block_row++) { |
546 | 0 | image_block_row = cinfo->output_iMCU_row * block_rows + block_row; |
547 | 0 | buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci]; |
548 | |
|
549 | 0 | if (image_block_row > 0) |
550 | 0 | prev_block_row = |
551 | 0 | buffer[block_row - 1] + cinfo->master->first_MCU_col[ci]; |
552 | 0 | else |
553 | 0 | prev_block_row = buffer_ptr; |
554 | |
|
555 | 0 | if (image_block_row > 1) |
556 | 0 | prev_prev_block_row = |
557 | 0 | buffer[block_row - 2] + cinfo->master->first_MCU_col[ci]; |
558 | 0 | else |
559 | 0 | prev_prev_block_row = prev_block_row; |
560 | |
|
561 | 0 | if (image_block_row < image_block_rows - 1) |
562 | 0 | next_block_row = |
563 | 0 | buffer[block_row + 1] + cinfo->master->first_MCU_col[ci]; |
564 | 0 | else |
565 | 0 | next_block_row = buffer_ptr; |
566 | |
|
567 | 0 | if (image_block_row < image_block_rows - 2) |
568 | 0 | next_next_block_row = |
569 | 0 | buffer[block_row + 2] + cinfo->master->first_MCU_col[ci]; |
570 | 0 | else |
571 | 0 | next_next_block_row = next_block_row; |
572 | | |
573 | | /* We fetch the surrounding DC values using a sliding-register approach. |
574 | | * Initialize all 25 here so as to do the right thing on narrow pics. |
575 | | */ |
576 | 0 | DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0]; |
577 | 0 | DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0]; |
578 | 0 | DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0]; |
579 | 0 | DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0]; |
580 | 0 | DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0]; |
581 | 0 | output_col = 0; |
582 | 0 | last_block_column = compptr->width_in_blocks - 1; |
583 | 0 | for (block_num = cinfo->master->first_MCU_col[ci]; |
584 | 0 | block_num <= cinfo->master->last_MCU_col[ci]; block_num++) { |
585 | | /* Fetch current DCT block into workspace so we can modify it. */ |
586 | 0 | jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1); |
587 | | /* Update DC values */ |
588 | 0 | if (block_num == cinfo->master->first_MCU_col[ci] && |
589 | 0 | block_num < last_block_column) { |
590 | 0 | DC04 = DC05 = (int)prev_prev_block_row[1][0]; |
591 | 0 | DC09 = DC10 = (int)prev_block_row[1][0]; |
592 | 0 | DC14 = DC15 = (int)buffer_ptr[1][0]; |
593 | 0 | DC19 = DC20 = (int)next_block_row[1][0]; |
594 | 0 | DC24 = DC25 = (int)next_next_block_row[1][0]; |
595 | 0 | } |
596 | 0 | if (block_num + 1 < last_block_column) { |
597 | 0 | DC05 = (int)prev_prev_block_row[2][0]; |
598 | 0 | DC10 = (int)prev_block_row[2][0]; |
599 | 0 | DC15 = (int)buffer_ptr[2][0]; |
600 | 0 | DC20 = (int)next_block_row[2][0]; |
601 | 0 | DC25 = (int)next_next_block_row[2][0]; |
602 | 0 | } |
603 | | /* If DC interpolation is enabled, compute coefficient estimates using |
604 | | * a Gaussian-like kernel, keeping the averages of the DC values. |
605 | | * |
606 | | * If DC interpolation is disabled, compute coefficient estimates using |
607 | | * an algorithm similar to the one described in Section K.8 of the JPEG |
608 | | * standard, except applied to a 5x5 window rather than a 3x3 window. |
609 | | * |
610 | | * An estimate is applied only if the coefficient is still zero and is |
611 | | * not known to be fully accurate. |
612 | | */ |
613 | | /* AC01 */ |
614 | 0 | if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) { |
615 | 0 | num = Q00 * (change_dc ? |
616 | 0 | (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 - |
617 | 0 | 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 + |
618 | 0 | 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 - |
619 | 0 | DC21 - DC22 + DC24 + DC25) : |
620 | 0 | (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15)); |
621 | 0 | if (num >= 0) { |
622 | 0 | pred = (int)(((Q01 << 7) + num) / (Q01 << 8)); |
623 | 0 | if (Al > 0 && pred >= (1 << Al)) |
624 | 0 | pred = (1 << Al) - 1; |
625 | 0 | } else { |
626 | 0 | pred = (int)(((Q01 << 7) - num) / (Q01 << 8)); |
627 | 0 | if (Al > 0 && pred >= (1 << Al)) |
628 | 0 | pred = (1 << Al) - 1; |
629 | 0 | pred = -pred; |
630 | 0 | } |
631 | 0 | workspace[1] = (JCOEF)pred; |
632 | 0 | } |
633 | | /* AC10 */ |
634 | 0 | if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) { |
635 | 0 | num = Q00 * (change_dc ? |
636 | 0 | (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 + |
637 | 0 | 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 - |
638 | 0 | 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 + |
639 | 0 | 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) : |
640 | 0 | (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23)); |
641 | 0 | if (num >= 0) { |
642 | 0 | pred = (int)(((Q10 << 7) + num) / (Q10 << 8)); |
643 | 0 | if (Al > 0 && pred >= (1 << Al)) |
644 | 0 | pred = (1 << Al) - 1; |
645 | 0 | } else { |
646 | 0 | pred = (int)(((Q10 << 7) - num) / (Q10 << 8)); |
647 | 0 | if (Al > 0 && pred >= (1 << Al)) |
648 | 0 | pred = (1 << Al) - 1; |
649 | 0 | pred = -pred; |
650 | 0 | } |
651 | 0 | workspace[8] = (JCOEF)pred; |
652 | 0 | } |
653 | | /* AC20 */ |
654 | 0 | if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) { |
655 | 0 | num = Q00 * (change_dc ? |
656 | 0 | (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 - |
657 | 0 | 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) : |
658 | 0 | (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23)); |
659 | 0 | if (num >= 0) { |
660 | 0 | pred = (int)(((Q20 << 7) + num) / (Q20 << 8)); |
661 | 0 | if (Al > 0 && pred >= (1 << Al)) |
662 | 0 | pred = (1 << Al) - 1; |
663 | 0 | } else { |
664 | 0 | pred = (int)(((Q20 << 7) - num) / (Q20 << 8)); |
665 | 0 | if (Al > 0 && pred >= (1 << Al)) |
666 | 0 | pred = (1 << Al) - 1; |
667 | 0 | pred = -pred; |
668 | 0 | } |
669 | 0 | workspace[16] = (JCOEF)pred; |
670 | 0 | } |
671 | | /* AC11 */ |
672 | 0 | if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) { |
673 | 0 | num = Q00 * (change_dc ? |
674 | 0 | (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 + |
675 | 0 | 9 * DC19 + DC21 - DC25) : |
676 | 0 | (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 - |
677 | 0 | DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09)); |
678 | 0 | if (num >= 0) { |
679 | 0 | pred = (int)(((Q11 << 7) + num) / (Q11 << 8)); |
680 | 0 | if (Al > 0 && pred >= (1 << Al)) |
681 | 0 | pred = (1 << Al) - 1; |
682 | 0 | } else { |
683 | 0 | pred = (int)(((Q11 << 7) - num) / (Q11 << 8)); |
684 | 0 | if (Al > 0 && pred >= (1 << Al)) |
685 | 0 | pred = (1 << Al) - 1; |
686 | 0 | pred = -pred; |
687 | 0 | } |
688 | 0 | workspace[9] = (JCOEF)pred; |
689 | 0 | } |
690 | | /* AC02 */ |
691 | 0 | if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) { |
692 | 0 | num = Q00 * (change_dc ? |
693 | 0 | (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 + |
694 | 0 | 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) : |
695 | 0 | (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15)); |
696 | 0 | if (num >= 0) { |
697 | 0 | pred = (int)(((Q02 << 7) + num) / (Q02 << 8)); |
698 | 0 | if (Al > 0 && pred >= (1 << Al)) |
699 | 0 | pred = (1 << Al) - 1; |
700 | 0 | } else { |
701 | 0 | pred = (int)(((Q02 << 7) - num) / (Q02 << 8)); |
702 | 0 | if (Al > 0 && pred >= (1 << Al)) |
703 | 0 | pred = (1 << Al) - 1; |
704 | 0 | pred = -pred; |
705 | 0 | } |
706 | 0 | workspace[2] = (JCOEF)pred; |
707 | 0 | } |
708 | 0 | if (change_dc) { |
709 | | /* AC03 */ |
710 | 0 | if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) { |
711 | 0 | num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19); |
712 | 0 | if (num >= 0) { |
713 | 0 | pred = (int)(((Q03 << 7) + num) / (Q03 << 8)); |
714 | 0 | if (Al > 0 && pred >= (1 << Al)) |
715 | 0 | pred = (1 << Al) - 1; |
716 | 0 | } else { |
717 | 0 | pred = (int)(((Q03 << 7) - num) / (Q03 << 8)); |
718 | 0 | if (Al > 0 && pred >= (1 << Al)) |
719 | 0 | pred = (1 << Al) - 1; |
720 | 0 | pred = -pred; |
721 | 0 | } |
722 | 0 | workspace[3] = (JCOEF)pred; |
723 | 0 | } |
724 | | /* AC12 */ |
725 | 0 | if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) { |
726 | 0 | num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19); |
727 | 0 | if (num >= 0) { |
728 | 0 | pred = (int)(((Q12 << 7) + num) / (Q12 << 8)); |
729 | 0 | if (Al > 0 && pred >= (1 << Al)) |
730 | 0 | pred = (1 << Al) - 1; |
731 | 0 | } else { |
732 | 0 | pred = (int)(((Q12 << 7) - num) / (Q12 << 8)); |
733 | 0 | if (Al > 0 && pred >= (1 << Al)) |
734 | 0 | pred = (1 << Al) - 1; |
735 | 0 | pred = -pred; |
736 | 0 | } |
737 | 0 | workspace[10] = (JCOEF)pred; |
738 | 0 | } |
739 | | /* AC21 */ |
740 | 0 | if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) { |
741 | 0 | num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19); |
742 | 0 | if (num >= 0) { |
743 | 0 | pred = (int)(((Q21 << 7) + num) / (Q21 << 8)); |
744 | 0 | if (Al > 0 && pred >= (1 << Al)) |
745 | 0 | pred = (1 << Al) - 1; |
746 | 0 | } else { |
747 | 0 | pred = (int)(((Q21 << 7) - num) / (Q21 << 8)); |
748 | 0 | if (Al > 0 && pred >= (1 << Al)) |
749 | 0 | pred = (1 << Al) - 1; |
750 | 0 | pred = -pred; |
751 | 0 | } |
752 | 0 | workspace[17] = (JCOEF)pred; |
753 | 0 | } |
754 | | /* AC30 */ |
755 | 0 | if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) { |
756 | 0 | num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19); |
757 | 0 | if (num >= 0) { |
758 | 0 | pred = (int)(((Q30 << 7) + num) / (Q30 << 8)); |
759 | 0 | if (Al > 0 && pred >= (1 << Al)) |
760 | 0 | pred = (1 << Al) - 1; |
761 | 0 | } else { |
762 | 0 | pred = (int)(((Q30 << 7) - num) / (Q30 << 8)); |
763 | 0 | if (Al > 0 && pred >= (1 << Al)) |
764 | 0 | pred = (1 << Al) - 1; |
765 | 0 | pred = -pred; |
766 | 0 | } |
767 | 0 | workspace[24] = (JCOEF)pred; |
768 | 0 | } |
769 | | /* coef_bits[0] is non-negative. Otherwise this function would not |
770 | | * be called. |
771 | | */ |
772 | 0 | num = Q00 * |
773 | 0 | (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 - |
774 | 0 | 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 - |
775 | 0 | 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 - |
776 | 0 | 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 - |
777 | 0 | 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25); |
778 | 0 | if (num >= 0) { |
779 | 0 | pred = (int)(((Q00 << 7) + num) / (Q00 << 8)); |
780 | 0 | } else { |
781 | 0 | pred = (int)(((Q00 << 7) - num) / (Q00 << 8)); |
782 | 0 | pred = -pred; |
783 | 0 | } |
784 | 0 | workspace[0] = (JCOEF)pred; |
785 | 0 | } /* change_dc */ |
786 | | |
787 | | /* OK, do the IDCT */ |
788 | 0 | (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr, |
789 | 0 | output_col); |
790 | | /* Advance for next column */ |
791 | 0 | DC01 = DC02; DC02 = DC03; DC03 = DC04; DC04 = DC05; |
792 | 0 | DC06 = DC07; DC07 = DC08; DC08 = DC09; DC09 = DC10; |
793 | 0 | DC11 = DC12; DC12 = DC13; DC13 = DC14; DC14 = DC15; |
794 | 0 | DC16 = DC17; DC17 = DC18; DC18 = DC19; DC19 = DC20; |
795 | 0 | DC21 = DC22; DC22 = DC23; DC23 = DC24; DC24 = DC25; |
796 | 0 | buffer_ptr++, prev_block_row++, next_block_row++, |
797 | 0 | prev_prev_block_row++, next_next_block_row++; |
798 | 0 | output_col += compptr->_DCT_scaled_size; |
799 | 0 | } |
800 | 0 | output_ptr += compptr->_DCT_scaled_size; |
801 | 0 | } |
802 | 0 | } |
803 | |
|
804 | 0 | if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) |
805 | 0 | return JPEG_ROW_COMPLETED; |
806 | 0 | return JPEG_SCAN_COMPLETED; |
807 | 0 | } |
808 | | |
809 | | #endif /* BLOCK_SMOOTHING_SUPPORTED */ |
810 | | |
811 | | |
812 | | /* |
813 | | * Initialize coefficient buffer controller. |
814 | | */ |
815 | | |
816 | | GLOBAL(void) |
817 | | _jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer) |
818 | 0 | { |
819 | 0 | my_coef_ptr coef; |
820 | |
|
821 | 0 | if (cinfo->data_precision != BITS_IN_JSAMPLE) |
822 | 0 | ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); |
823 | |
|
824 | 0 | coef = (my_coef_ptr) |
825 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
826 | 0 | sizeof(my_coef_controller)); |
827 | 0 | cinfo->coef = (struct jpeg_d_coef_controller *)coef; |
828 | 0 | coef->pub.start_input_pass = start_input_pass; |
829 | 0 | coef->pub.start_output_pass = start_output_pass; |
830 | 0 | #ifdef BLOCK_SMOOTHING_SUPPORTED |
831 | 0 | coef->coef_bits_latch = NULL; |
832 | 0 | #endif |
833 | | |
834 | | /* Create the coefficient buffer. */ |
835 | 0 | if (need_full_buffer) { |
836 | 0 | #ifdef D_MULTISCAN_FILES_SUPPORTED |
837 | | /* Allocate a full-image virtual array for each component, */ |
838 | | /* padded to a multiple of samp_factor DCT blocks in each direction. */ |
839 | | /* Note we ask for a pre-zeroed array. */ |
840 | 0 | int ci, access_rows; |
841 | 0 | jpeg_component_info *compptr; |
842 | |
|
843 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
844 | 0 | ci++, compptr++) { |
845 | 0 | access_rows = compptr->v_samp_factor; |
846 | 0 | #ifdef BLOCK_SMOOTHING_SUPPORTED |
847 | | /* If block smoothing could be used, need a bigger window */ |
848 | 0 | if (cinfo->progressive_mode) |
849 | 0 | access_rows *= 5; |
850 | 0 | #endif |
851 | 0 | coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) |
852 | 0 | ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE, |
853 | 0 | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
854 | 0 | (long)compptr->h_samp_factor), |
855 | 0 | (JDIMENSION)jround_up((long)compptr->height_in_blocks, |
856 | 0 | (long)compptr->v_samp_factor), |
857 | 0 | (JDIMENSION)access_rows); |
858 | 0 | } |
859 | 0 | coef->pub.consume_data = consume_data; |
860 | 0 | coef->pub._decompress_data = decompress_data; |
861 | 0 | coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */ |
862 | | #else |
863 | | ERREXIT(cinfo, JERR_NOT_COMPILED); |
864 | | #endif |
865 | 0 | } else { |
866 | | /* We only need a single-MCU buffer. */ |
867 | 0 | JBLOCKROW buffer; |
868 | 0 | int i; |
869 | |
|
870 | 0 | buffer = (JBLOCKROW) |
871 | 0 | (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
872 | 0 | D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK)); |
873 | 0 | for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) { |
874 | 0 | coef->MCU_buffer[i] = buffer + i; |
875 | 0 | } |
876 | 0 | coef->pub.consume_data = dummy_consume_data; |
877 | 0 | coef->pub._decompress_data = decompress_onepass; |
878 | 0 | coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */ |
879 | 0 | } |
880 | | |
881 | | /* Allocate the workspace buffer */ |
882 | 0 | coef->workspace = (JCOEF *) |
883 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
884 | 0 | sizeof(JCOEF) * DCTSIZE2); |
885 | 0 | } Unexecuted instantiation: j12init_d_coef_controller Unexecuted instantiation: jinit_d_coef_controller |