Coverage Report

Created: 2024-01-20 12:28

/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
}
jinit_d_diff_controller
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 */