/src/libjpeg-turbo/jddiffct.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * jddiffct.c |
3 | | * |
4 | | * This file was part of the Independent JPEG Group's software: |
5 | | * Copyright (C) 1994-1997, Thomas G. Lane. |
6 | | * Lossless JPEG Modifications: |
7 | | * Copyright (C) 1999, Ken Murchison. |
8 | | * libjpeg-turbo Modifications: |
9 | | * Copyright (C) 2022, D. R. Commander. |
10 | | * For conditions of distribution and use, see the accompanying README.ijg |
11 | | * file. |
12 | | * |
13 | | * This file contains the [un]difference buffer controller for decompression. |
14 | | * This controller is the top level of the lossless JPEG decompressor proper. |
15 | | * The difference buffer lies between the entropy decoding and |
16 | | * prediction/undifferencing steps. The undifference buffer lies between the |
17 | | * prediction/undifferencing and scaling steps. |
18 | | * |
19 | | * In buffered-image mode, this controller is the interface between |
20 | | * input-oriented processing and output-oriented processing. |
21 | | */ |
22 | | |
23 | | #define JPEG_INTERNALS |
24 | | #include "jinclude.h" |
25 | | #include "jpeglib.h" |
26 | | #include "jlossls.h" /* Private declarations for lossless codec */ |
27 | | |
28 | | |
29 | | #ifdef D_LOSSLESS_SUPPORTED |
30 | | |
31 | | /* Private buffer controller object */ |
32 | | |
33 | | typedef struct { |
34 | | struct jpeg_d_coef_controller pub; /* public fields */ |
35 | | |
36 | | /* These variables keep track of the current location of the input side. */ |
37 | | /* cinfo->input_iMCU_row is also used for this. */ |
38 | | JDIMENSION MCU_ctr; /* counts MCUs processed in current row */ |
39 | | unsigned int restart_rows_to_go; /* MCU rows left in this restart |
40 | | interval */ |
41 | | unsigned int MCU_vert_offset; /* counts MCU rows within iMCU row */ |
42 | | unsigned int MCU_rows_per_iMCU_row; /* number of such rows needed */ |
43 | | |
44 | | /* The output side's location is represented by cinfo->output_iMCU_row. */ |
45 | | |
46 | | JDIFFARRAY diff_buf[MAX_COMPONENTS]; /* iMCU row of differences */ |
47 | | JDIFFARRAY undiff_buf[MAX_COMPONENTS]; /* iMCU row of undiff'd samples */ |
48 | | |
49 | | #ifdef D_MULTISCAN_FILES_SUPPORTED |
50 | | /* In multi-pass modes, we need a virtual sample array for each component. */ |
51 | | jvirt_sarray_ptr whole_image[MAX_COMPONENTS]; |
52 | | #endif |
53 | | } my_diff_controller; |
54 | | |
55 | | typedef my_diff_controller *my_diff_ptr; |
56 | | |
57 | | /* Forward declarations */ |
58 | | METHODDEF(int) decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf); |
59 | | #ifdef D_MULTISCAN_FILES_SUPPORTED |
60 | | METHODDEF(int) output_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf); |
61 | | #endif |
62 | | |
63 | | |
64 | | LOCAL(void) |
65 | | start_iMCU_row(j_decompress_ptr cinfo) |
66 | | /* Reset within-iMCU-row counters for a new row (input side) */ |
67 | 0 | { |
68 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
69 | | |
70 | | /* In an interleaved scan, an MCU row is the same as an iMCU row. |
71 | | * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. |
72 | | * But at the bottom of the image, process only what's left. |
73 | | */ |
74 | 0 | if (cinfo->comps_in_scan > 1) { |
75 | 0 | diff->MCU_rows_per_iMCU_row = 1; |
76 | 0 | } else { |
77 | 0 | if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1)) |
78 | 0 | diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; |
79 | 0 | else |
80 | 0 | diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; |
81 | 0 | } |
82 | |
|
83 | 0 | diff->MCU_ctr = 0; |
84 | 0 | diff->MCU_vert_offset = 0; |
85 | 0 | } |
86 | | |
87 | | |
88 | | /* |
89 | | * Initialize for an input processing pass. |
90 | | */ |
91 | | |
92 | | METHODDEF(void) |
93 | | start_input_pass(j_decompress_ptr cinfo) |
94 | 0 | { |
95 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
96 | | |
97 | | /* Because it is hitching a ride on the jpeg_inverse_dct struct, |
98 | | * start_pass_lossless() will be called at the start of the output pass. |
99 | | * This ensures that it will be called at the start of the input pass as |
100 | | * well. |
101 | | */ |
102 | 0 | (*cinfo->idct->start_pass) (cinfo); |
103 | | |
104 | | /* Check that the restart interval is an integer multiple of the number |
105 | | * of MCUs in an MCU row. |
106 | | */ |
107 | 0 | if (cinfo->restart_interval % cinfo->MCUs_per_row != 0) |
108 | 0 | ERREXIT2(cinfo, JERR_BAD_RESTART, |
109 | 0 | cinfo->restart_interval, cinfo->MCUs_per_row); |
110 | | |
111 | | /* Initialize restart counter */ |
112 | 0 | diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row; |
113 | |
|
114 | 0 | cinfo->input_iMCU_row = 0; |
115 | 0 | start_iMCU_row(cinfo); |
116 | 0 | } |
117 | | |
118 | | |
119 | | /* |
120 | | * Check for a restart marker & resynchronize decoder, undifferencer. |
121 | | * Returns FALSE if must suspend. |
122 | | */ |
123 | | |
124 | | METHODDEF(boolean) |
125 | | process_restart(j_decompress_ptr cinfo) |
126 | 0 | { |
127 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
128 | |
|
129 | 0 | if (!(*cinfo->entropy->process_restart) (cinfo)) |
130 | 0 | return FALSE; |
131 | | |
132 | 0 | (*cinfo->idct->start_pass) (cinfo); |
133 | | |
134 | | /* Reset restart counter */ |
135 | 0 | diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row; |
136 | |
|
137 | 0 | return TRUE; |
138 | 0 | } |
139 | | |
140 | | |
141 | | /* |
142 | | * Initialize for an output processing pass. |
143 | | */ |
144 | | |
145 | | METHODDEF(void) |
146 | | start_output_pass(j_decompress_ptr cinfo) |
147 | 0 | { |
148 | 0 | cinfo->output_iMCU_row = 0; |
149 | 0 | } |
150 | | |
151 | | |
152 | | /* |
153 | | * Decompress and return some data in the supplied buffer. |
154 | | * Always attempts to emit one fully interleaved MCU row ("iMCU" row). |
155 | | * Input and output must run in lockstep since we have only a one-MCU buffer. |
156 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
157 | | * |
158 | | * NB: output_buf contains a plane for each component in image, |
159 | | * which we index according to the component's SOF position. |
160 | | */ |
161 | | |
162 | | METHODDEF(int) |
163 | | decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) |
164 | 0 | { |
165 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
166 | 0 | lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct; |
167 | 0 | JDIMENSION MCU_col_num; /* index of current MCU within row */ |
168 | 0 | JDIMENSION MCU_count; /* number of MCUs decoded */ |
169 | 0 | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
170 | 0 | int ci, compi, row, prev_row; |
171 | 0 | unsigned int yoffset; |
172 | 0 | jpeg_component_info *compptr; |
173 | | |
174 | | /* Loop to process as much as one whole iMCU row */ |
175 | 0 | for (yoffset = diff->MCU_vert_offset; yoffset < diff->MCU_rows_per_iMCU_row; |
176 | 0 | yoffset++) { |
177 | | |
178 | | /* Process restart marker if needed; may have to suspend */ |
179 | 0 | if (cinfo->restart_interval) { |
180 | 0 | if (diff->restart_rows_to_go == 0) |
181 | 0 | if (!process_restart(cinfo)) |
182 | 0 | return JPEG_SUSPENDED; |
183 | 0 | } |
184 | | |
185 | 0 | MCU_col_num = diff->MCU_ctr; |
186 | | /* Try to fetch an MCU row (or remaining portion of suspended MCU row). */ |
187 | 0 | MCU_count = |
188 | 0 | (*cinfo->entropy->decode_mcus) (cinfo, |
189 | 0 | diff->diff_buf, yoffset, MCU_col_num, |
190 | 0 | cinfo->MCUs_per_row - MCU_col_num); |
191 | 0 | if (MCU_count != cinfo->MCUs_per_row - MCU_col_num) { |
192 | | /* Suspension forced; update state counters and exit */ |
193 | 0 | diff->MCU_vert_offset = yoffset; |
194 | 0 | diff->MCU_ctr += MCU_count; |
195 | 0 | return JPEG_SUSPENDED; |
196 | 0 | } |
197 | | |
198 | | /* Account for restart interval (no-op if not using restarts) */ |
199 | 0 | if (cinfo->restart_interval) |
200 | 0 | diff->restart_rows_to_go--; |
201 | | |
202 | | /* Completed an MCU row, but perhaps not an iMCU row */ |
203 | 0 | diff->MCU_ctr = 0; |
204 | 0 | } |
205 | | |
206 | | /* |
207 | | * Undifference and scale each scanline of the disassembled MCU row |
208 | | * separately. We do not process dummy samples at the end of a scanline |
209 | | * or dummy rows at the end of the image. |
210 | | */ |
211 | 0 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
212 | 0 | compptr = cinfo->cur_comp_info[ci]; |
213 | 0 | compi = compptr->component_index; |
214 | 0 | for (row = 0, prev_row = compptr->v_samp_factor - 1; |
215 | 0 | row < (cinfo->input_iMCU_row == last_iMCU_row ? |
216 | 0 | compptr->last_row_height : compptr->v_samp_factor); |
217 | 0 | prev_row = row, row++) { |
218 | 0 | (*losslessd->predict_undifference[compi]) |
219 | 0 | (cinfo, compi, diff->diff_buf[compi][row], |
220 | 0 | diff->undiff_buf[compi][prev_row], diff->undiff_buf[compi][row], |
221 | 0 | compptr->width_in_blocks); |
222 | 0 | (*losslessd->scaler_scale) (cinfo, diff->undiff_buf[compi][row], |
223 | 0 | output_buf[compi][row], |
224 | 0 | compptr->width_in_blocks); |
225 | 0 | } |
226 | 0 | } |
227 | | |
228 | | /* Completed the iMCU row, advance counters for next one. |
229 | | * |
230 | | * NB: output_data will increment output_iMCU_row. |
231 | | * This counter is not needed for the single-pass case |
232 | | * or the input side of the multi-pass case. |
233 | | */ |
234 | 0 | if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { |
235 | 0 | start_iMCU_row(cinfo); |
236 | 0 | return JPEG_ROW_COMPLETED; |
237 | 0 | } |
238 | | /* Completed the scan */ |
239 | 0 | (*cinfo->inputctl->finish_input_pass) (cinfo); |
240 | 0 | return JPEG_SCAN_COMPLETED; |
241 | 0 | } |
242 | | |
243 | | |
244 | | /* |
245 | | * Dummy consume-input routine for single-pass operation. |
246 | | */ |
247 | | |
248 | | METHODDEF(int) |
249 | | dummy_consume_data(j_decompress_ptr cinfo) |
250 | 0 | { |
251 | 0 | return JPEG_SUSPENDED; /* Always indicate nothing was done */ |
252 | 0 | } |
253 | | |
254 | | |
255 | | #ifdef D_MULTISCAN_FILES_SUPPORTED |
256 | | |
257 | | /* |
258 | | * Consume input data and store it in the full-image sample buffer. |
259 | | * We read as much as one fully interleaved MCU row ("iMCU" row) per call, |
260 | | * ie, v_samp_factor rows for each component in the scan. |
261 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
262 | | */ |
263 | | |
264 | | METHODDEF(int) |
265 | | consume_data(j_decompress_ptr cinfo) |
266 | 0 | { |
267 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
268 | 0 | int ci, compi; |
269 | 0 | _JSAMPARRAY buffer[MAX_COMPS_IN_SCAN]; |
270 | 0 | jpeg_component_info *compptr; |
271 | | |
272 | | /* Align the virtual buffers for the components used in this scan. */ |
273 | 0 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
274 | 0 | compptr = cinfo->cur_comp_info[ci]; |
275 | 0 | compi = compptr->component_index; |
276 | 0 | buffer[compi] = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray) |
277 | 0 | ((j_common_ptr)cinfo, diff->whole_image[compi], |
278 | 0 | cinfo->input_iMCU_row * compptr->v_samp_factor, |
279 | 0 | (JDIMENSION)compptr->v_samp_factor, TRUE); |
280 | 0 | } |
281 | |
|
282 | 0 | return decompress_data(cinfo, buffer); |
283 | 0 | } |
284 | | |
285 | | |
286 | | /* |
287 | | * Output some data from the full-image sample buffer in the multi-pass case. |
288 | | * Always attempts to emit one fully interleaved MCU row ("iMCU" row). |
289 | | * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. |
290 | | * |
291 | | * NB: output_buf contains a plane for each component in image. |
292 | | */ |
293 | | |
294 | | METHODDEF(int) |
295 | | output_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf) |
296 | 0 | { |
297 | 0 | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
298 | 0 | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
299 | 0 | int ci, samp_rows, row; |
300 | 0 | _JSAMPARRAY buffer; |
301 | 0 | jpeg_component_info *compptr; |
302 | | |
303 | | /* Force some input to be done if we are getting ahead of the input. */ |
304 | 0 | while (cinfo->input_scan_number < cinfo->output_scan_number || |
305 | 0 | (cinfo->input_scan_number == cinfo->output_scan_number && |
306 | 0 | cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) { |
307 | 0 | if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) |
308 | 0 | return JPEG_SUSPENDED; |
309 | 0 | } |
310 | | |
311 | | /* OK, output from the virtual arrays. */ |
312 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
313 | 0 | ci++, compptr++) { |
314 | | /* Align the virtual buffer for this component. */ |
315 | 0 | buffer = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray) |
316 | 0 | ((j_common_ptr)cinfo, diff->whole_image[ci], |
317 | 0 | cinfo->output_iMCU_row * compptr->v_samp_factor, |
318 | 0 | (JDIMENSION)compptr->v_samp_factor, FALSE); |
319 | |
|
320 | 0 | if (cinfo->output_iMCU_row < last_iMCU_row) |
321 | 0 | samp_rows = compptr->v_samp_factor; |
322 | 0 | else { |
323 | | /* NB: can't use last_row_height here; it is input-side-dependent! */ |
324 | 0 | samp_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); |
325 | 0 | if (samp_rows == 0) samp_rows = compptr->v_samp_factor; |
326 | 0 | } |
327 | |
|
328 | 0 | for (row = 0; row < samp_rows; row++) { |
329 | 0 | memcpy(output_buf[ci][row], buffer[row], |
330 | 0 | compptr->width_in_blocks * sizeof(_JSAMPLE)); |
331 | 0 | } |
332 | 0 | } |
333 | |
|
334 | 0 | if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) |
335 | 0 | return JPEG_ROW_COMPLETED; |
336 | 0 | return JPEG_SCAN_COMPLETED; |
337 | 0 | } |
338 | | |
339 | | #endif /* D_MULTISCAN_FILES_SUPPORTED */ |
340 | | |
341 | | |
342 | | /* |
343 | | * Initialize difference buffer controller. |
344 | | */ |
345 | | |
346 | | GLOBAL(void) |
347 | | _jinit_d_diff_controller(j_decompress_ptr cinfo, boolean need_full_buffer) |
348 | 0 | { |
349 | 0 | my_diff_ptr diff; |
350 | 0 | int ci; |
351 | 0 | jpeg_component_info *compptr; |
352 | |
|
353 | 0 | diff = (my_diff_ptr) |
354 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
355 | 0 | sizeof(my_diff_controller)); |
356 | 0 | cinfo->coef = (struct jpeg_d_coef_controller *)diff; |
357 | 0 | diff->pub.start_input_pass = start_input_pass; |
358 | 0 | diff->pub.start_output_pass = start_output_pass; |
359 | | |
360 | | /* Create the [un]difference buffers. */ |
361 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
362 | 0 | ci++, compptr++) { |
363 | 0 | diff->diff_buf[ci] = |
364 | 0 | ALLOC_DARRAY(JPOOL_IMAGE, |
365 | 0 | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
366 | 0 | (long)compptr->h_samp_factor), |
367 | 0 | (JDIMENSION)compptr->v_samp_factor); |
368 | 0 | diff->undiff_buf[ci] = |
369 | 0 | ALLOC_DARRAY(JPOOL_IMAGE, |
370 | 0 | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
371 | 0 | (long)compptr->h_samp_factor), |
372 | 0 | (JDIMENSION)compptr->v_samp_factor); |
373 | 0 | } |
374 | |
|
375 | 0 | if (need_full_buffer) { |
376 | 0 | #ifdef D_MULTISCAN_FILES_SUPPORTED |
377 | | /* Allocate a full-image virtual array for each component. */ |
378 | 0 | int access_rows; |
379 | |
|
380 | 0 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
381 | 0 | ci++, compptr++) { |
382 | 0 | access_rows = compptr->v_samp_factor; |
383 | 0 | diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray) |
384 | 0 | ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE, |
385 | 0 | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
386 | 0 | (long)compptr->h_samp_factor), |
387 | 0 | (JDIMENSION)jround_up((long)compptr->height_in_blocks, |
388 | 0 | (long)compptr->v_samp_factor), |
389 | 0 | (JDIMENSION)access_rows); |
390 | 0 | } |
391 | 0 | diff->pub.consume_data = consume_data; |
392 | 0 | diff->pub._decompress_data = output_data; |
393 | | #else |
394 | | ERREXIT(cinfo, JERR_NOT_COMPILED); |
395 | | #endif |
396 | 0 | } else { |
397 | 0 | diff->pub.consume_data = dummy_consume_data; |
398 | 0 | diff->pub._decompress_data = decompress_data; |
399 | 0 | diff->whole_image[0] = NULL; /* flag for no virtual arrays */ |
400 | 0 | } |
401 | 0 | } Unexecuted instantiation: j12init_d_diff_controller Unexecuted instantiation: j16init_d_diff_controller Unexecuted instantiation: jinit_d_diff_controller |
402 | | |
403 | | #endif /* D_LOSSLESS_SUPPORTED */ |