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