Bug Summary

File:jdk/src/java.desktop/share/native/libjavajpeg/jdcoefct.c
Warning:line 282, column 24
Dereference of undefined pointer value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name jdcoefct.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-clobbered -Wno-implicit-fallthrough -Wno-shift-negative-value -Wno-array-bounds -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/jdcoefct.c
1/*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5/*
6 * jdcoefct.c
7 *
8 * Copyright (C) 1994-1997, Thomas G. Lane.
9 * This file is part of the Independent JPEG Group's software.
10 * For conditions of distribution and use, see the accompanying README file.
11 *
12 * This file contains the coefficient buffer controller for decompression.
13 * This controller is the top level of the JPEG decompressor proper.
14 * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
15 *
16 * In buffered-image mode, this controller is the interface between
17 * input-oriented processing and output-oriented processing.
18 * Also, the input side (only) is used when reading a file for transcoding.
19 */
20
21#define JPEG_INTERNALS
22#include "jinclude.h"
23#include "jpeglib.h"
24
25/* Block smoothing is only applicable for progressive JPEG, so: */
26#ifndef D_PROGRESSIVE_SUPPORTED
27#undef BLOCK_SMOOTHING_SUPPORTED
28#endif
29
30/* Private buffer controller object */
31
32typedef struct {
33 struct jpeg_d_coef_controller pub; /* public fields */
34
35 /* These variables keep track of the current location of the input side. */
36 /* cinfo->input_iMCU_row is also used for this. */
37 JDIMENSION MCU_ctr; /* counts MCUs processed in current row */
38 int MCU_vert_offset; /* counts MCU rows within iMCU row */
39 int MCU_rows_per_iMCU_row; /* number of such rows needed */
40
41 /* The output side's location is represented by cinfo->output_iMCU_row. */
42
43 /* In single-pass modes, it's sufficient to buffer just one MCU.
44 * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
45 * and let the entropy decoder write into that workspace each time.
46 * (On 80x86, the workspace is FAR even though it's not really very big;
47 * this is to keep the module interfaces unchanged when a large coefficient
48 * buffer is necessary.)
49 * In multi-pass modes, this array points to the current MCU's blocks
50 * within the virtual arrays; it is used only by the input side.
51 */
52 JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU10];
53
54#ifdef D_MULTISCAN_FILES_SUPPORTED
55 /* In multi-pass modes, we need a virtual block array for each component. */
56 jvirt_barray_ptr whole_image[MAX_COMPONENTS10];
57#endif
58
59#ifdef BLOCK_SMOOTHING_SUPPORTED
60 /* When doing block smoothing, we latch coefficient Al values here */
61 int * coef_bits_latch;
62#define SAVED_COEFS6 6 /* we save coef_bits[0..5] */
63#endif
64} my_coef_controller;
65
66typedef my_coef_controller * my_coef_ptr;
67
68/* Forward declarations */
69METHODDEF(int)static int decompress_onepass
70 JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf))(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
71#ifdef D_MULTISCAN_FILES_SUPPORTED
72METHODDEF(int)static int decompress_data
73 JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf))(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
74#endif
75#ifdef BLOCK_SMOOTHING_SUPPORTED
76LOCAL(boolean)static boolean smoothing_ok JPP((j_decompress_ptr cinfo))(j_decompress_ptr cinfo);
77METHODDEF(int)static int decompress_smooth_data
78 JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf))(j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
79#endif
80
81
82LOCAL(void)static void
83start_iMCU_row (j_decompress_ptr cinfo)
84/* Reset within-iMCU-row counters for a new row (input side) */
85{
86 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
87
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.
91 */
92 if (cinfo->comps_in_scan > 1) {
93 coef->MCU_rows_per_iMCU_row = 1;
94 } else {
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;
97 else
98 coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
99 }
100
101 coef->MCU_ctr = 0;
102 coef->MCU_vert_offset = 0;
103}
104
105
106/*
107 * Initialize for an input processing pass.
108 */
109
110METHODDEF(void)static void
111start_input_pass (j_decompress_ptr cinfo)
112{
113 cinfo->input_iMCU_row = 0;
114 start_iMCU_row(cinfo);
115}
116
117
118/*
119 * Initialize for an output processing pass.
120 */
121
122METHODDEF(void)static void
123start_output_pass (j_decompress_ptr cinfo)
124{
125#ifdef BLOCK_SMOOTHING_SUPPORTED
126 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
127
128 /* If multipass, check to see whether to use block smoothing on this pass */
129 if (coef->pub.coef_arrays != NULL((void*)0)) {
130 if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
131 coef->pub.decompress_data = decompress_smooth_data;
132 else
133 coef->pub.decompress_data = decompress_data;
134 }
135#endif
136 cinfo->output_iMCU_row = 0;
137}
138
139
140/*
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.
145 *
146 * NB: output_buf contains a plane for each component in image,
147 * which we index according to the component's SOF position.
148 */
149
150METHODDEF(int)static int
151decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
152{
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 blkn, ci, xindex, yindex, yoffset, useful_width;
158 JSAMPARRAY output_ptr;
159 JDIMENSION start_col, output_col;
160 jpeg_component_info *compptr;
161 inverse_DCT_method_ptr inverse_DCT;
162
163 /* Loop to process as much as one whole iMCU row */
164 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
165 yoffset++) {
166 for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
167 MCU_col_num++) {
168 /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
169 jzero_farjZeroFar((void FAR *) coef->MCU_buffer[0],
170 (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)((size_t) sizeof(JBLOCK))));
171 if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
172 /* Suspension forced; update state counters and exit */
173 coef->MCU_vert_offset = yoffset;
174 coef->MCU_ctr = MCU_col_num;
175 return JPEG_SUSPENDED0;
176 }
177 /* Determine where data should go in output_buf and do the IDCT thing.
178 * We skip dummy blocks at the right and bottom edges (but blkn gets
179 * incremented past them!). Note the inner loop relies on having
180 * allocated the MCU_buffer[] blocks sequentially.
181 */
182 blkn = 0; /* index of current DCT block within MCU */
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 blkn += compptr->MCU_blocks;
188 continue;
189 }
190 inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
191 useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
192 : compptr->last_col_width;
193 output_ptr = output_buf[compptr->component_index] +
194 yoffset * compptr->DCT_scaled_size;
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,
202 (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
203 output_ptr, output_col);
204 output_col += compptr->DCT_scaled_size;
205 }
206 }
207 blkn += compptr->MCU_width;
208 output_ptr += compptr->DCT_scaled_size;
209 }
210 }
211 }
212 /* Completed an MCU row, but perhaps not an iMCU row */
213 coef->MCU_ctr = 0;
214 }
215 /* Completed the iMCU row, advance counters for next one */
216 cinfo->output_iMCU_row++;
217 if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
218 start_iMCU_row(cinfo);
219 return JPEG_ROW_COMPLETED3;
220 }
221 /* Completed the scan */
222 (*cinfo->inputctl->finish_input_pass) (cinfo);
223 return JPEG_SCAN_COMPLETED4;
224}
225
226
227/*
228 * Dummy consume-input routine for single-pass operation.
229 */
230
231METHODDEF(int)static int
232dummy_consume_data (j_decompress_ptr cinfo)
233{
234 return JPEG_SUSPENDED0; /* Always indicate nothing was done */
235}
236
237
238#ifdef D_MULTISCAN_FILES_SUPPORTED
239
240/*
241 * Consume input data and store it in the full-image coefficient buffer.
242 * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
243 * ie, v_samp_factor block rows for each component in the scan.
244 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
245 */
246
247METHODDEF(int)static int
248consume_data (j_decompress_ptr cinfo)
249{
250 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
251 JDIMENSION MCU_col_num; /* index of current MCU within row */
252 int blkn, ci, xindex, yindex, yoffset;
253 JDIMENSION start_col;
254 JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN4];
255 JBLOCKROW buffer_ptr;
256 jpeg_component_info *compptr;
257
258 /* Align the virtual buffers for the components used in this scan. */
259 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1
Assuming 'ci' is >= field 'comps_in_scan'
→
2
←
Loop condition is false. Execution continues on line 272
→
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, TRUE1);
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.
268 */
269 }
270
271 /* Loop to process one whole iMCU row */
272 for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
3
←
Assuming 'yoffset' is < field 'MCU_rows_per_iMCU_row'
→
4
←
Loop condition is true. Entering loop body
→
273 yoffset++) {
274 for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
5
←
Assuming 'MCU_col_num' is < field 'MCUs_per_row'
→
6
←
Loop condition is true. Entering loop body
→
10
←
Assuming 'MCU_col_num' is < field 'MCUs_per_row'
→
11
←
Loop condition is true. Entering loop body
→
275 MCU_col_num++) {
276 /* Construct list of pointers to DCT blocks belonging to this MCU */
277 blkn = 0; /* index of current DCT block within MCU */
278 for (ci = 0; ci
6.1
'ci' is >= field 'comps_in_scan'
 < cinfo->comps_in_scan; ci++) {
7
←
Loop condition is false. Execution continues on line 289
→
12
←
Assuming 'ci' is < field 'comps_in_scan'
→
13
←
Loop condition is true. Entering loop body
→
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++) {
14
←
Assuming 'yindex' is < field 'MCU_height'
→
15
←
Loop condition is true. Entering loop body
→
282 buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
16
←
Dereference of undefined pointer value
283 for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
284 coef->MCU_buffer[blkn++] = buffer_ptr++;
285 }
286 }
287 }
288 /* Try to fetch the MCU. */
289 if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
8
←
Assuming the condition is false
→
9
←
Taking false branch
→
290 /* Suspension forced; update state counters and exit */
291 coef->MCU_vert_offset = yoffset;
292 coef->MCU_ctr = MCU_col_num;
293 return JPEG_SUSPENDED0;
294 }
295 }
296 /* Completed an MCU row, but perhaps not an iMCU row */
297 coef->MCU_ctr = 0;
298 }
299 /* Completed the iMCU row, advance counters for next one */
300 if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
301 start_iMCU_row(cinfo);
302 return JPEG_ROW_COMPLETED3;
303 }
304 /* Completed the scan */
305 (*cinfo->inputctl->finish_input_pass) (cinfo);
306 return JPEG_SCAN_COMPLETED4;
307}
308
309
310/*
311 * Decompress and return some data in the multi-pass case.
312 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
313 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
314 *
315 * NB: output_buf contains a plane for each component in image.
316 */
317
318METHODDEF(int)static int
319decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
320{
321 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
322 JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
323 JDIMENSION block_num;
324 int ci, block_row, block_rows;
325 JBLOCKARRAY buffer;
326 JBLOCKROW buffer_ptr;
327 JSAMPARRAY output_ptr;
328 JDIMENSION output_col;
329 jpeg_component_info *compptr;
330 inverse_DCT_method_ptr inverse_DCT;
331
332 /* Force some input to be done if we are getting ahead of the input. */
333 while (cinfo->input_scan_number < cinfo->output_scan_number ||
334 (cinfo->input_scan_number == cinfo->output_scan_number &&
335 cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
336 if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED0)
337 return JPEG_SUSPENDED0;
338 }
339
340 /* OK, output from the virtual arrays. */
341 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
342 ci++, compptr++) {
343 /* Don't bother to IDCT an uninteresting component. */
344 if (! compptr->component_needed)
345 continue;
346 /* Align the virtual buffer for this component. */
347 buffer = (*cinfo->mem->access_virt_barray)
348 ((j_common_ptr) cinfo, coef->whole_image[ci],
349 cinfo->output_iMCU_row * compptr->v_samp_factor,
350 (JDIMENSION) compptr->v_samp_factor, FALSE0);
351 /* Count non-dummy DCT block rows in this iMCU row. */
352 if (cinfo->output_iMCU_row < last_iMCU_row)
353 block_rows = compptr->v_samp_factor;
354 else {
355 /* NB: can't use last_row_height here; it is input-side-dependent! */
356 block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
357 if (block_rows == 0) block_rows = compptr->v_samp_factor;
358 }
359 inverse_DCT = cinfo->idct->inverse_DCT[ci];
360 output_ptr = output_buf[ci];
361 /* Loop over all DCT blocks to be processed. */
362 for (block_row = 0; block_row < block_rows; block_row++) {
363 buffer_ptr = buffer[block_row];
364 output_col = 0;
365 for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
366 (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
367 output_ptr, output_col);
368 buffer_ptr++;
369 output_col += compptr->DCT_scaled_size;
370 }
371 output_ptr += compptr->DCT_scaled_size;
372 }
373 }
374
375 if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
376 return JPEG_ROW_COMPLETED3;
377 return JPEG_SCAN_COMPLETED4;
378}
379
380#endif /* D_MULTISCAN_FILES_SUPPORTED */
381
382
383#ifdef BLOCK_SMOOTHING_SUPPORTED
384
385/*
386 * This code applies interblock smoothing as described by section K.8
387 * of the JPEG standard: the first 5 AC coefficients are estimated from
388 * the DC values of a DCT block and its 8 neighboring blocks.
389 * We apply smoothing only for progressive JPEG decoding, and only if
390 * the coefficients it can estimate are not yet known to full precision.
391 */
392
393/* Natural-order array positions of the first 5 zigzag-order coefficients */
394#define Q01_POS1 1
395#define Q10_POS8 8
396#define Q20_POS16 16
397#define Q11_POS9 9
398#define Q02_POS2 2
399
400/*
401 * Determine whether block smoothing is applicable and safe.
402 * We also latch the current states of the coef_bits[] entries for the
403 * AC coefficients; otherwise, if the input side of the decompressor
404 * advances into a new scan, we might think the coefficients are known
405 * more accurately than they really are.
406 */
407
408LOCAL(boolean)static boolean
409smoothing_ok (j_decompress_ptr cinfo)
410{
411 my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
412 boolean smoothing_useful = FALSE0;
413 int ci, coefi;
414 jpeg_component_info *compptr;
415 JQUANT_TBL * qtable;
416 int * coef_bits;
417 int * coef_bits_latch;
418
419 if (! cinfo->progressive_mode || cinfo->coef_bits == NULL((void*)0))
420 return FALSE0;
421
422 /* Allocate latch area if not already done */
423 if (coef->coef_bits_latch == NULL((void*)0))
424 coef->coef_bits_latch = (int *)
425 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE1,
426 cinfo->num_components *
427 (SAVED_COEFS6 * SIZEOF(int)((size_t) sizeof(int))));
428 coef_bits_latch = coef->coef_bits_latch;
429
430 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
431 ci++, compptr++) {
432 /* All components' quantization values must already be latched. */
433 if ((qtable = compptr->quant_table) == NULL((void*)0))
434 return FALSE0;
435 /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
436 if (qtable->quantval[0] == 0 ||
437 qtable->quantval[Q01_POS1] == 0 ||
438 qtable->quantval[Q10_POS8] == 0 ||
439 qtable->quantval[Q20_POS16] == 0 ||
440 qtable->quantval[Q11_POS9] == 0 ||
441 qtable->quantval[Q02_POS2] == 0)
442 return FALSE0;
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)
446 return FALSE0;
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 = TRUE1;
452 }
453 coef_bits_latch += SAVED_COEFS6;
454 }
455
456 return smoothing_useful;
457}
458
459
460/*
461 * Variant of decompress_data for use when doing block smoothing.
462 */
463
464METHODDEF(int)static int
465decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
466{
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;
471 JBLOCKARRAY buffer;
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;
478 JBLOCK workspace;
479 int *coef_bits;
480 JQUANT_TBL *quanttbl;
481 INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
482 int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
483 int Al, pred;
484
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.
493 */
494 JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
495 if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
496 break;
497 }
498 if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED0)
499 return JPEG_SUSPENDED0;
500 }
501
502 /* OK, output from the virtual arrays. */
503 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
504 ci++, compptr++) {
505 /* Don't bother to IDCT an uninteresting component. */
506 if (! compptr->component_needed)
507 continue;
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 */
512 last_row = FALSE0;
513 } else {
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 */
518 last_row = TRUE1;
519 }
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, FALSE0);
527 buffer += compptr->v_samp_factor; /* point to current iMCU row */
528 first_row = FALSE0;
529 } else {
530 buffer = (*cinfo->mem->access_virt_barray)
531 ((j_common_ptr) cinfo, coef->whole_image[ci],
532 (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE0);
533 first_row = TRUE1;
534 }
535 /* Fetch component-dependent info */
536 coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS6);
537 quanttbl = compptr->quant_table;
538 Q00 = quanttbl->quantval[0];
539 Q01 = quanttbl->quantval[Q01_POS1];
540 Q10 = quanttbl->quantval[Q10_POS8];
541 Q20 = quanttbl->quantval[Q20_POS16];
542 Q11 = quanttbl->quantval[Q11_POS9];
543 Q02 = quanttbl->quantval[Q02_POS2];
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;
551 else
552 prev_block_row = buffer[block_row-1];
553 if (last_row && block_row == block_rows-1)
554 next_block_row = buffer_ptr;
555 else
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.
559 */
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];
563 output_col = 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_rowjCopyBlocks(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];
573 }
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.
577 */
578 /* AC01 */
579 if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
580 num = 36 * Q00 * (DC4 - DC6);
581 if (num >= 0) {
582 pred = (int) (((Q01<<7) + num) / (Q01<<8));
583 if (Al > 0 && pred >= (1<<Al))
584 pred = (1<<Al)-1;
585 } else {
586 pred = (int) (((Q01<<7) - num) / (Q01<<8));
587 if (Al > 0 && pred >= (1<<Al))
588 pred = (1<<Al)-1;
589 pred = -pred;
590 }
591 workspace[1] = (JCOEF) pred;
592 }
593 /* AC10 */
594 if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
595 num = 36 * Q00 * (DC2 - DC8);
596 if (num >= 0) {
597 pred = (int) (((Q10<<7) + num) / (Q10<<8));
598 if (Al > 0 && pred >= (1<<Al))
599 pred = (1<<Al)-1;
600 } else {
601 pred = (int) (((Q10<<7) - num) / (Q10<<8));
602 if (Al > 0 && pred >= (1<<Al))
603 pred = (1<<Al)-1;
604 pred = -pred;
605 }
606 workspace[8] = (JCOEF) pred;
607 }
608 /* AC20 */
609 if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
610 num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
611 if (num >= 0) {
612 pred = (int) (((Q20<<7) + num) / (Q20<<8));
613 if (Al > 0 && pred >= (1<<Al))
614 pred = (1<<Al)-1;
615 } else {
616 pred = (int) (((Q20<<7) - num) / (Q20<<8));
617 if (Al > 0 && pred >= (1<<Al))
618 pred = (1<<Al)-1;
619 pred = -pred;
620 }
621 workspace[16] = (JCOEF) pred;
622 }
623 /* AC11 */
624 if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
625 num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
626 if (num >= 0) {
627 pred = (int) (((Q11<<7) + num) / (Q11<<8));
628 if (Al > 0 && pred >= (1<<Al))
629 pred = (1<<Al)-1;
630 } else {
631 pred = (int) (((Q11<<7) - num) / (Q11<<8));
632 if (Al > 0 && pred >= (1<<Al))
633 pred = (1<<Al)-1;
634 pred = -pred;
635 }
636 workspace[9] = (JCOEF) pred;
637 }
638 /* AC02 */
639 if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
640 num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
641 if (num >= 0) {
642 pred = (int) (((Q02<<7) + num) / (Q02<<8));
643 if (Al > 0 && pred >= (1<<Al))
644 pred = (1<<Al)-1;
645 } else {
646 pred = (int) (((Q02<<7) - num) / (Q02<<8));
647 if (Al > 0 && pred >= (1<<Al))
648 pred = (1<<Al)-1;
649 pred = -pred;
650 }
651 workspace[2] = (JCOEF) pred;
652 }
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_scaled_size;
662 }
663 output_ptr += compptr->DCT_scaled_size;
664 }
665 }
666
667 if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
668 return JPEG_ROW_COMPLETED3;
669 return JPEG_SCAN_COMPLETED4;
670}
671
672#endif /* BLOCK_SMOOTHING_SUPPORTED */
673
674
675/*
676 * Initialize coefficient buffer controller.
677 */
678
679GLOBAL(void)void
680jinit_d_coef_controllerjIDCoefC (j_decompress_ptr cinfo, boolean need_full_buffer)
681{
682 my_coef_ptr coef;
683
684 coef = (my_coef_ptr)
685 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE1,
686 SIZEOF(my_coef_controller)((size_t) sizeof(my_coef_controller)));
687 cinfo->coef = (struct jpeg_d_coef_controller *) coef;
688 coef->pub.start_input_pass = start_input_pass;
689 coef->pub.start_output_pass = start_output_pass;
690#ifdef BLOCK_SMOOTHING_SUPPORTED
691 coef->coef_bits_latch = NULL((void*)0);
692#endif
693
694 /* Create the coefficient buffer. */
695 if (need_full_buffer) {
696#ifdef D_MULTISCAN_FILES_SUPPORTED
697 /* Allocate a full-image virtual array for each component, */
698 /* padded to a multiple of samp_factor DCT blocks in each direction. */
699 /* Note we ask for a pre-zeroed array. */
700 int ci, access_rows;
701 jpeg_component_info *compptr;
702
703 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
704 ci++, compptr++) {
705 access_rows = compptr->v_samp_factor;
706#ifdef BLOCK_SMOOTHING_SUPPORTED
707 /* If block smoothing could be used, need a bigger window */
708 if (cinfo->progressive_mode)
709 access_rows *= 3;
710#endif
711 coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
712 ((j_common_ptr) cinfo, JPOOL_IMAGE1, TRUE1,
713 (JDIMENSION) jround_upjRound((long) compptr->width_in_blocks,
714 (long) compptr->h_samp_factor),
715 (JDIMENSION) jround_upjRound((long) compptr->height_in_blocks,
716 (long) compptr->v_samp_factor),
717 (JDIMENSION) access_rows);
718 }
719 coef->pub.consume_data = consume_data;
720 coef->pub.decompress_data = decompress_data;
721 coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
722#else
723 ERREXIT(cinfo, JERR_NOT_COMPILED)((cinfo)->err->msg_code = (JERR_NOT_COMPILED), (*(cinfo
)->err->error_exit) ((j_common_ptr) (cinfo)));
724#endif
725 } else {
726 /* We only need a single-MCU buffer. */
727 JBLOCKROW buffer;
728 int i;
729
730 buffer = (JBLOCKROW)
731 (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE1,
732 D_MAX_BLOCKS_IN_MCU10 * SIZEOF(JBLOCK)((size_t) sizeof(JBLOCK)));
733 for (i = 0; i < D_MAX_BLOCKS_IN_MCU10; i++) {
734 coef->MCU_buffer[i] = buffer + i;
735 }
736 coef->pub.consume_data = dummy_consume_data;
737 coef->pub.decompress_data = decompress_onepass;
738 coef->pub.coef_arrays = NULL((void*)0); /* flag for no virtual arrays */
739 }
740}