/src/libjpeg-turbo.main/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 | 42.6M | { |
68 | 42.6M | 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 | 42.6M | if (cinfo->comps_in_scan > 1) { |
75 | 25.8M | diff->MCU_rows_per_iMCU_row = 1; |
76 | 25.8M | } else { |
77 | 16.8M | if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1)) |
78 | 16.8M | diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; |
79 | 16.6k | else |
80 | 16.6k | diff->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; |
81 | 16.8M | } |
82 | | |
83 | 42.6M | diff->MCU_ctr = 0; |
84 | 42.6M | diff->MCU_vert_offset = 0; |
85 | 42.6M | } |
86 | | |
87 | | |
88 | | /* |
89 | | * Initialize for an input processing pass. |
90 | | */ |
91 | | |
92 | | METHODDEF(void) |
93 | | start_input_pass(j_decompress_ptr cinfo) |
94 | 32.1k | { |
95 | 32.1k | 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 | 32.1k | (*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 | 32.1k | if (cinfo->restart_interval % cinfo->MCUs_per_row != 0) |
108 | 72 | ERREXIT2(cinfo, JERR_BAD_RESTART, |
109 | 32.1k | cinfo->restart_interval, cinfo->MCUs_per_row); |
110 | | |
111 | | /* Initialize restart counter */ |
112 | 32.1k | diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row; |
113 | | |
114 | 32.1k | cinfo->input_iMCU_row = 0; |
115 | 32.1k | start_iMCU_row(cinfo); |
116 | 32.1k | } |
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 | 632k | { |
127 | 632k | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
128 | | |
129 | 632k | if (!(*cinfo->entropy->process_restart) (cinfo)) |
130 | 0 | return FALSE; |
131 | | |
132 | 632k | (*cinfo->idct->start_pass) (cinfo); |
133 | | |
134 | | /* Reset restart counter */ |
135 | 632k | diff->restart_rows_to_go = cinfo->restart_interval / cinfo->MCUs_per_row; |
136 | | |
137 | 632k | return TRUE; |
138 | 632k | } |
139 | | |
140 | | |
141 | | /* |
142 | | * Initialize for an output processing pass. |
143 | | */ |
144 | | |
145 | | METHODDEF(void) |
146 | | start_output_pass(j_decompress_ptr cinfo) |
147 | 11.3k | { |
148 | 11.3k | cinfo->output_iMCU_row = 0; |
149 | 11.3k | } |
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 | 42.6M | { |
165 | 42.6M | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
166 | 42.6M | lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct; |
167 | 42.6M | JDIMENSION MCU_col_num; /* index of current MCU within row */ |
168 | 42.6M | JDIMENSION MCU_count; /* number of MCUs decoded */ |
169 | 42.6M | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
170 | 42.6M | int ci, compi, row, prev_row; |
171 | 42.6M | unsigned int yoffset; |
172 | 42.6M | jpeg_component_info *compptr; |
173 | | |
174 | | /* Loop to process as much as one whole iMCU row */ |
175 | 110M | for (yoffset = diff->MCU_vert_offset; yoffset < diff->MCU_rows_per_iMCU_row; |
176 | 68.1M | yoffset++) { |
177 | | |
178 | | /* Process restart marker if needed; may have to suspend */ |
179 | 68.1M | if (cinfo->restart_interval) { |
180 | 13.0M | if (diff->restart_rows_to_go == 0) |
181 | 632k | if (!process_restart(cinfo)) |
182 | 0 | return JPEG_SUSPENDED; |
183 | 13.0M | } |
184 | | |
185 | 68.1M | MCU_col_num = diff->MCU_ctr; |
186 | | /* Try to fetch an MCU row (or remaining portion of suspended MCU row). */ |
187 | 68.1M | MCU_count = |
188 | 68.1M | (*cinfo->entropy->decode_mcus) (cinfo, |
189 | 68.1M | diff->diff_buf, yoffset, MCU_col_num, |
190 | 68.1M | cinfo->MCUs_per_row - MCU_col_num); |
191 | 68.1M | 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 | 68.1M | if (cinfo->restart_interval) |
200 | 13.0M | diff->restart_rows_to_go--; |
201 | | |
202 | | /* Completed an MCU row, but perhaps not an iMCU row */ |
203 | 68.1M | diff->MCU_ctr = 0; |
204 | 68.1M | } |
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 | 137M | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
212 | 94.3M | compptr = cinfo->cur_comp_info[ci]; |
213 | 94.3M | compi = compptr->component_index; |
214 | 94.3M | for (row = 0, prev_row = compptr->v_samp_factor - 1; |
215 | 226M | row < (cinfo->input_iMCU_row == last_iMCU_row ? |
216 | 226M | compptr->last_row_height : compptr->v_samp_factor); |
217 | 131M | prev_row = row, row++) { |
218 | 131M | (*losslessd->predict_undifference[compi]) |
219 | 131M | (cinfo, compi, diff->diff_buf[compi][row], |
220 | 131M | diff->undiff_buf[compi][prev_row], diff->undiff_buf[compi][row], |
221 | 131M | compptr->width_in_blocks); |
222 | 131M | (*losslessd->scaler_scale) (cinfo, diff->undiff_buf[compi][row], |
223 | 131M | output_buf[compi][row], |
224 | 131M | compptr->width_in_blocks); |
225 | 131M | } |
226 | 94.3M | } |
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 | 42.6M | if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { |
235 | 42.6M | start_iMCU_row(cinfo); |
236 | 42.6M | return JPEG_ROW_COMPLETED; |
237 | 42.6M | } |
238 | | /* Completed the scan */ |
239 | 31.0k | (*cinfo->inputctl->finish_input_pass) (cinfo); |
240 | 31.0k | return JPEG_SCAN_COMPLETED; |
241 | 42.6M | } |
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 | 18.0M | { |
267 | 18.0M | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
268 | 18.0M | int ci, compi; |
269 | 18.0M | _JSAMPARRAY buffer[MAX_COMPS_IN_SCAN]; |
270 | 18.0M | jpeg_component_info *compptr; |
271 | | |
272 | | /* Align the virtual buffers for the components used in this scan. */ |
273 | 38.4M | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
274 | 20.4M | compptr = cinfo->cur_comp_info[ci]; |
275 | 20.4M | compi = compptr->component_index; |
276 | 20.4M | buffer[compi] = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray) |
277 | 20.4M | ((j_common_ptr)cinfo, diff->whole_image[compi], |
278 | 20.4M | cinfo->input_iMCU_row * compptr->v_samp_factor, |
279 | 20.4M | (JDIMENSION)compptr->v_samp_factor, TRUE); |
280 | 20.4M | } |
281 | | |
282 | 18.0M | return decompress_data(cinfo, buffer); |
283 | 18.0M | } |
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 | 113k | { |
297 | 113k | my_diff_ptr diff = (my_diff_ptr)cinfo->coef; |
298 | 113k | JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; |
299 | 113k | int ci, samp_rows, row; |
300 | 113k | _JSAMPARRAY buffer; |
301 | 113k | jpeg_component_info *compptr; |
302 | | |
303 | | /* Force some input to be done if we are getting ahead of the input. */ |
304 | 113k | while (cinfo->input_scan_number < cinfo->output_scan_number || |
305 | 113k | (cinfo->input_scan_number == cinfo->output_scan_number && |
306 | 113k | 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 | 453k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
313 | 340k | ci++, compptr++) { |
314 | | /* Align the virtual buffer for this component. */ |
315 | 340k | buffer = (_JSAMPARRAY)(*cinfo->mem->access_virt_sarray) |
316 | 340k | ((j_common_ptr)cinfo, diff->whole_image[ci], |
317 | 340k | cinfo->output_iMCU_row * compptr->v_samp_factor, |
318 | 340k | (JDIMENSION)compptr->v_samp_factor, FALSE); |
319 | | |
320 | 340k | if (cinfo->output_iMCU_row < last_iMCU_row) |
321 | 339k | samp_rows = compptr->v_samp_factor; |
322 | 1.05k | else { |
323 | | /* NB: can't use last_row_height here; it is input-side-dependent! */ |
324 | 1.05k | samp_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor); |
325 | 1.05k | if (samp_rows == 0) samp_rows = compptr->v_samp_factor; |
326 | 1.05k | } |
327 | | |
328 | 1.00M | for (row = 0; row < samp_rows; row++) { |
329 | 661k | memcpy(output_buf[ci][row], buffer[row], |
330 | 661k | compptr->width_in_blocks * sizeof(_JSAMPLE)); |
331 | 661k | } |
332 | 340k | } |
333 | | |
334 | 113k | if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) |
335 | 113k | return JPEG_ROW_COMPLETED; |
336 | 720 | return JPEG_SCAN_COMPLETED; |
337 | 113k | } |
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 | 13.5k | { |
349 | 13.5k | my_diff_ptr diff; |
350 | 13.5k | int ci; |
351 | 13.5k | jpeg_component_info *compptr; |
352 | | |
353 | 13.5k | diff = (my_diff_ptr) |
354 | 13.5k | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
355 | 13.5k | sizeof(my_diff_controller)); |
356 | 13.5k | cinfo->coef = (struct jpeg_d_coef_controller *)diff; |
357 | 13.5k | diff->pub.start_input_pass = start_input_pass; |
358 | 13.5k | diff->pub.start_output_pass = start_output_pass; |
359 | | |
360 | | /* Create the [un]difference buffers. */ |
361 | 54.3k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
362 | 40.7k | ci++, compptr++) { |
363 | 40.7k | diff->diff_buf[ci] = |
364 | 40.7k | ALLOC_DARRAY(JPOOL_IMAGE, |
365 | 40.7k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
366 | 40.7k | (long)compptr->h_samp_factor), |
367 | 40.7k | (JDIMENSION)compptr->v_samp_factor); |
368 | 40.7k | diff->undiff_buf[ci] = |
369 | 40.7k | ALLOC_DARRAY(JPOOL_IMAGE, |
370 | 40.7k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
371 | 40.7k | (long)compptr->h_samp_factor), |
372 | 40.7k | (JDIMENSION)compptr->v_samp_factor); |
373 | 40.7k | } |
374 | | |
375 | 13.5k | if (need_full_buffer) { |
376 | 2.47k | #ifdef D_MULTISCAN_FILES_SUPPORTED |
377 | | /* Allocate a full-image virtual array for each component. */ |
378 | 2.47k | int access_rows; |
379 | | |
380 | 9.91k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
381 | 7.43k | ci++, compptr++) { |
382 | 7.43k | access_rows = compptr->v_samp_factor; |
383 | 7.43k | diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray) |
384 | 7.43k | ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE, |
385 | 7.43k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, |
386 | 7.43k | (long)compptr->h_samp_factor), |
387 | 7.43k | (JDIMENSION)jround_up((long)compptr->height_in_blocks, |
388 | 7.43k | (long)compptr->v_samp_factor), |
389 | 7.43k | (JDIMENSION)access_rows); |
390 | 7.43k | } |
391 | 2.47k | diff->pub.consume_data = consume_data; |
392 | 2.47k | diff->pub._decompress_data = output_data; |
393 | | #else |
394 | | ERREXIT(cinfo, JERR_NOT_COMPILED); |
395 | | #endif |
396 | 11.1k | } else { |
397 | 11.1k | diff->pub.consume_data = dummy_consume_data; |
398 | 11.1k | diff->pub._decompress_data = decompress_data; |
399 | 11.1k | diff->whole_image[0] = NULL; /* flag for no virtual arrays */ |
400 | 11.1k | } |
401 | 13.5k | } j12init_d_diff_controller Line | Count | Source | 348 | 4.28k | { | 349 | 4.28k | my_diff_ptr diff; | 350 | 4.28k | int ci; | 351 | 4.28k | jpeg_component_info *compptr; | 352 | | | 353 | 4.28k | diff = (my_diff_ptr) | 354 | 4.28k | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, | 355 | 4.28k | sizeof(my_diff_controller)); | 356 | 4.28k | cinfo->coef = (struct jpeg_d_coef_controller *)diff; | 357 | 4.28k | diff->pub.start_input_pass = start_input_pass; | 358 | 4.28k | diff->pub.start_output_pass = start_output_pass; | 359 | | | 360 | | /* Create the [un]difference buffers. */ | 361 | 17.1k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 362 | 12.8k | ci++, compptr++) { | 363 | 12.8k | diff->diff_buf[ci] = | 364 | 12.8k | ALLOC_DARRAY(JPOOL_IMAGE, | 365 | 12.8k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 366 | 12.8k | (long)compptr->h_samp_factor), | 367 | 12.8k | (JDIMENSION)compptr->v_samp_factor); | 368 | 12.8k | diff->undiff_buf[ci] = | 369 | 12.8k | ALLOC_DARRAY(JPOOL_IMAGE, | 370 | 12.8k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 371 | 12.8k | (long)compptr->h_samp_factor), | 372 | 12.8k | (JDIMENSION)compptr->v_samp_factor); | 373 | 12.8k | } | 374 | | | 375 | 4.28k | if (need_full_buffer) { | 376 | 823 | #ifdef D_MULTISCAN_FILES_SUPPORTED | 377 | | /* Allocate a full-image virtual array for each component. */ | 378 | 823 | int access_rows; | 379 | | | 380 | 3.29k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 381 | 2.46k | ci++, compptr++) { | 382 | 2.46k | access_rows = compptr->v_samp_factor; | 383 | 2.46k | diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray) | 384 | 2.46k | ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE, | 385 | 2.46k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 386 | 2.46k | (long)compptr->h_samp_factor), | 387 | 2.46k | (JDIMENSION)jround_up((long)compptr->height_in_blocks, | 388 | 2.46k | (long)compptr->v_samp_factor), | 389 | 2.46k | (JDIMENSION)access_rows); | 390 | 2.46k | } | 391 | 823 | diff->pub.consume_data = consume_data; | 392 | 823 | diff->pub._decompress_data = output_data; | 393 | | #else | 394 | | ERREXIT(cinfo, JERR_NOT_COMPILED); | 395 | | #endif | 396 | 3.46k | } else { | 397 | 3.46k | diff->pub.consume_data = dummy_consume_data; | 398 | 3.46k | diff->pub._decompress_data = decompress_data; | 399 | 3.46k | diff->whole_image[0] = NULL; /* flag for no virtual arrays */ | 400 | 3.46k | } | 401 | 4.28k | } |
j16init_d_diff_controller Line | Count | Source | 348 | 4.77k | { | 349 | 4.77k | my_diff_ptr diff; | 350 | 4.77k | int ci; | 351 | 4.77k | jpeg_component_info *compptr; | 352 | | | 353 | 4.77k | diff = (my_diff_ptr) | 354 | 4.77k | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, | 355 | 4.77k | sizeof(my_diff_controller)); | 356 | 4.77k | cinfo->coef = (struct jpeg_d_coef_controller *)diff; | 357 | 4.77k | diff->pub.start_input_pass = start_input_pass; | 358 | 4.77k | diff->pub.start_output_pass = start_output_pass; | 359 | | | 360 | | /* Create the [un]difference buffers. */ | 361 | 19.0k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 362 | 14.3k | ci++, compptr++) { | 363 | 14.3k | diff->diff_buf[ci] = | 364 | 14.3k | ALLOC_DARRAY(JPOOL_IMAGE, | 365 | 14.3k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 366 | 14.3k | (long)compptr->h_samp_factor), | 367 | 14.3k | (JDIMENSION)compptr->v_samp_factor); | 368 | 14.3k | diff->undiff_buf[ci] = | 369 | 14.3k | ALLOC_DARRAY(JPOOL_IMAGE, | 370 | 14.3k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 371 | 14.3k | (long)compptr->h_samp_factor), | 372 | 14.3k | (JDIMENSION)compptr->v_samp_factor); | 373 | 14.3k | } | 374 | | | 375 | 4.77k | if (need_full_buffer) { | 376 | 851 | #ifdef D_MULTISCAN_FILES_SUPPORTED | 377 | | /* Allocate a full-image virtual array for each component. */ | 378 | 851 | int access_rows; | 379 | | | 380 | 3.40k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 381 | 2.55k | ci++, compptr++) { | 382 | 2.55k | access_rows = compptr->v_samp_factor; | 383 | 2.55k | diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray) | 384 | 2.55k | ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE, | 385 | 2.55k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 386 | 2.55k | (long)compptr->h_samp_factor), | 387 | 2.55k | (JDIMENSION)jround_up((long)compptr->height_in_blocks, | 388 | 2.55k | (long)compptr->v_samp_factor), | 389 | 2.55k | (JDIMENSION)access_rows); | 390 | 2.55k | } | 391 | 851 | diff->pub.consume_data = consume_data; | 392 | 851 | diff->pub._decompress_data = output_data; | 393 | | #else | 394 | | ERREXIT(cinfo, JERR_NOT_COMPILED); | 395 | | #endif | 396 | 3.92k | } else { | 397 | 3.92k | diff->pub.consume_data = dummy_consume_data; | 398 | 3.92k | diff->pub._decompress_data = decompress_data; | 399 | 3.92k | diff->whole_image[0] = NULL; /* flag for no virtual arrays */ | 400 | 3.92k | } | 401 | 4.77k | } |
Line | Count | Source | 348 | 4.52k | { | 349 | 4.52k | my_diff_ptr diff; | 350 | 4.52k | int ci; | 351 | 4.52k | jpeg_component_info *compptr; | 352 | | | 353 | 4.52k | diff = (my_diff_ptr) | 354 | 4.52k | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, | 355 | 4.52k | sizeof(my_diff_controller)); | 356 | 4.52k | cinfo->coef = (struct jpeg_d_coef_controller *)diff; | 357 | 4.52k | diff->pub.start_input_pass = start_input_pass; | 358 | 4.52k | diff->pub.start_output_pass = start_output_pass; | 359 | | | 360 | | /* Create the [un]difference buffers. */ | 361 | 18.1k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 362 | 13.5k | ci++, compptr++) { | 363 | 13.5k | diff->diff_buf[ci] = | 364 | 13.5k | ALLOC_DARRAY(JPOOL_IMAGE, | 365 | 13.5k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 366 | 13.5k | (long)compptr->h_samp_factor), | 367 | 13.5k | (JDIMENSION)compptr->v_samp_factor); | 368 | 13.5k | diff->undiff_buf[ci] = | 369 | 13.5k | ALLOC_DARRAY(JPOOL_IMAGE, | 370 | 13.5k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 371 | 13.5k | (long)compptr->h_samp_factor), | 372 | 13.5k | (JDIMENSION)compptr->v_samp_factor); | 373 | 13.5k | } | 374 | | | 375 | 4.52k | if (need_full_buffer) { | 376 | 804 | #ifdef D_MULTISCAN_FILES_SUPPORTED | 377 | | /* Allocate a full-image virtual array for each component. */ | 378 | 804 | int access_rows; | 379 | | | 380 | 3.21k | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | 381 | 2.41k | ci++, compptr++) { | 382 | 2.41k | access_rows = compptr->v_samp_factor; | 383 | 2.41k | diff->whole_image[ci] = (*cinfo->mem->request_virt_sarray) | 384 | 2.41k | ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE, | 385 | 2.41k | (JDIMENSION)jround_up((long)compptr->width_in_blocks, | 386 | 2.41k | (long)compptr->h_samp_factor), | 387 | 2.41k | (JDIMENSION)jround_up((long)compptr->height_in_blocks, | 388 | 2.41k | (long)compptr->v_samp_factor), | 389 | 2.41k | (JDIMENSION)access_rows); | 390 | 2.41k | } | 391 | 804 | diff->pub.consume_data = consume_data; | 392 | 804 | diff->pub._decompress_data = output_data; | 393 | | #else | 394 | | ERREXIT(cinfo, JERR_NOT_COMPILED); | 395 | | #endif | 396 | 3.72k | } else { | 397 | 3.72k | diff->pub.consume_data = dummy_consume_data; | 398 | 3.72k | diff->pub._decompress_data = decompress_data; | 399 | 3.72k | diff->whole_image[0] = NULL; /* flag for no virtual arrays */ | 400 | 3.72k | } | 401 | 4.52k | } |
|
402 | | |
403 | | #endif /* D_LOSSLESS_SUPPORTED */ |