Coverage Report

Created: 2024-05-20 06:28

/src/libjpeg-turbo/jdcoefct.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * jdcoefct.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1994-1997, Thomas G. Lane.
6
 * libjpeg-turbo Modifications:
7
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
8
 * Copyright (C) 2010, 2015-2016, 2019-2020, 2022-2023, D. R. Commander.
9
 * Copyright (C) 2015, 2020, Google, Inc.
10
 * For conditions of distribution and use, see the accompanying README.ijg
11
 * file.
12
 *
13
 * This file contains the coefficient buffer controller for decompression.
14
 * This controller is the top level of the lossy JPEG decompressor proper.
15
 * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
16
 *
17
 * In buffered-image mode, this controller is the interface between
18
 * input-oriented processing and output-oriented processing.
19
 * Also, the input side (only) is used when reading a file for transcoding.
20
 */
21
22
#include "jinclude.h"
23
#include "jdcoefct.h"
24
#include "jpegapicomp.h"
25
#include "jsamplecomp.h"
26
27
28
/* Forward declarations */
29
METHODDEF(int) decompress_onepass(j_decompress_ptr cinfo,
30
                                  _JSAMPIMAGE output_buf);
31
#ifdef D_MULTISCAN_FILES_SUPPORTED
32
METHODDEF(int) decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf);
33
#endif
34
#ifdef BLOCK_SMOOTHING_SUPPORTED
35
LOCAL(boolean) smoothing_ok(j_decompress_ptr cinfo);
36
METHODDEF(int) decompress_smooth_data(j_decompress_ptr cinfo,
37
                                      _JSAMPIMAGE output_buf);
38
#endif
39
40
41
/*
42
 * Initialize for an input processing pass.
43
 */
44
45
METHODDEF(void)
46
start_input_pass(j_decompress_ptr cinfo)
47
1.31M
{
48
1.31M
  cinfo->input_iMCU_row = 0;
49
1.31M
  start_iMCU_row(cinfo);
50
1.31M
}
51
52
53
/*
54
 * Initialize for an output processing pass.
55
 */
56
57
METHODDEF(void)
58
start_output_pass(j_decompress_ptr cinfo)
59
18.9k
{
60
18.9k
#ifdef BLOCK_SMOOTHING_SUPPORTED
61
18.9k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
62
63
  /* If multipass, check to see whether to use block smoothing on this pass */
64
18.9k
  if (coef->pub.coef_arrays != NULL) {
65
7.16k
    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
66
2.34k
      coef->pub._decompress_data = decompress_smooth_data;
67
4.82k
    else
68
4.82k
      coef->pub._decompress_data = decompress_data;
69
7.16k
  }
70
18.9k
#endif
71
18.9k
  cinfo->output_iMCU_row = 0;
72
18.9k
}
73
74
75
/*
76
 * Decompress and return some data in the single-pass case.
77
 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
78
 * Input and output must run in lockstep since we have only a one-MCU buffer.
79
 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
80
 *
81
 * NB: output_buf contains a plane for each component in image,
82
 * which we index according to the component's SOF position.
83
 */
84
85
METHODDEF(int)
86
decompress_onepass(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
87
370k
{
88
370k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
89
370k
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
90
370k
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
91
370k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
92
370k
  int blkn, ci, xindex, yindex, yoffset, useful_width;
93
370k
  _JSAMPARRAY output_ptr;
94
370k
  JDIMENSION start_col, output_col;
95
370k
  jpeg_component_info *compptr;
96
370k
  _inverse_DCT_method_ptr inverse_DCT;
97
98
  /* Loop to process as much as one whole iMCU row */
99
1.24M
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
100
875k
       yoffset++) {
101
58.0M
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
102
57.2M
         MCU_col_num++) {
103
      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
104
57.2M
      jzero_far((void *)coef->MCU_buffer[0],
105
57.2M
                (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK)));
106
57.2M
      if (!cinfo->entropy->insufficient_data)
107
1.84M
        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
108
57.2M
      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
109
        /* Suspension forced; update state counters and exit */
110
0
        coef->MCU_vert_offset = yoffset;
111
0
        coef->MCU_ctr = MCU_col_num;
112
0
        return JPEG_SUSPENDED;
113
0
      }
114
115
      /* Only perform the IDCT on blocks that are contained within the desired
116
       * cropping region.
117
       */
118
57.2M
      if (MCU_col_num >= cinfo->master->first_iMCU_col &&
119
57.2M
          MCU_col_num <= cinfo->master->last_iMCU_col) {
120
        /* Determine where data should go in output_buf and do the IDCT thing.
121
         * We skip dummy blocks at the right and bottom edges (but blkn gets
122
         * incremented past them!).  Note the inner loop relies on having
123
         * allocated the MCU_buffer[] blocks sequentially.
124
         */
125
57.2M
        blkn = 0;               /* index of current DCT block within MCU */
126
130M
        for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
127
73.2M
          compptr = cinfo->cur_comp_info[ci];
128
          /* Don't bother to IDCT an uninteresting component. */
129
73.2M
          if (!compptr->component_needed) {
130
0
            blkn += compptr->MCU_blocks;
131
0
            continue;
132
0
          }
133
73.2M
          inverse_DCT = cinfo->idct->_inverse_DCT[compptr->component_index];
134
73.2M
          useful_width = (MCU_col_num < last_MCU_col) ?
135
72.0M
                         compptr->MCU_width : compptr->last_col_width;
136
73.2M
          output_ptr = output_buf[compptr->component_index] +
137
73.2M
                       yoffset * compptr->_DCT_scaled_size;
138
73.2M
          start_col = (MCU_col_num - cinfo->master->first_iMCU_col) *
139
73.2M
                      compptr->MCU_sample_width;
140
150M
          for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
141
77.3M
            if (cinfo->input_iMCU_row < last_iMCU_row ||
142
77.3M
                yoffset + yindex < compptr->last_row_height) {
143
77.0M
              output_col = start_col;
144
161M
              for (xindex = 0; xindex < useful_width; xindex++) {
145
84.8M
                (*inverse_DCT) (cinfo, compptr,
146
84.8M
                                (JCOEFPTR)coef->MCU_buffer[blkn + xindex],
147
84.8M
                                output_ptr, output_col);
148
84.8M
                output_col += compptr->_DCT_scaled_size;
149
84.8M
              }
150
77.0M
            }
151
77.3M
            blkn += compptr->MCU_width;
152
77.3M
            output_ptr += compptr->_DCT_scaled_size;
153
77.3M
          }
154
73.2M
        }
155
57.2M
      }
156
57.2M
    }
157
    /* Completed an MCU row, but perhaps not an iMCU row */
158
875k
    coef->MCU_ctr = 0;
159
875k
  }
160
  /* Completed the iMCU row, advance counters for next one */
161
370k
  cinfo->output_iMCU_row++;
162
370k
  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
163
359k
    start_iMCU_row(cinfo);
164
359k
    return JPEG_ROW_COMPLETED;
165
359k
  }
166
  /* Completed the scan */
167
11.5k
  (*cinfo->inputctl->finish_input_pass) (cinfo);
168
11.5k
  return JPEG_SCAN_COMPLETED;
169
370k
}
170
171
172
/*
173
 * Dummy consume-input routine for single-pass operation.
174
 */
175
176
METHODDEF(int)
177
dummy_consume_data(j_decompress_ptr cinfo)
178
0
{
179
0
  return JPEG_SUSPENDED;        /* Always indicate nothing was done */
180
0
}
181
182
183
#ifdef D_MULTISCAN_FILES_SUPPORTED
184
185
/*
186
 * Consume input data and store it in the full-image coefficient buffer.
187
 * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
188
 * ie, v_samp_factor block rows for each component in the scan.
189
 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
190
 */
191
192
METHODDEF(int)
193
consume_data(j_decompress_ptr cinfo)
194
22.6M
{
195
22.6M
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
196
22.6M
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
197
22.6M
  int blkn, ci, xindex, yindex, yoffset;
198
22.6M
  JDIMENSION start_col;
199
22.6M
  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
200
22.6M
  JBLOCKROW buffer_ptr;
201
22.6M
  jpeg_component_info *compptr;
202
203
  /* Align the virtual buffers for the components used in this scan. */
204
64.7M
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
205
42.0M
    compptr = cinfo->cur_comp_info[ci];
206
42.0M
    buffer[ci] = (*cinfo->mem->access_virt_barray)
207
42.0M
      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
208
42.0M
       cinfo->input_iMCU_row * compptr->v_samp_factor,
209
42.0M
       (JDIMENSION)compptr->v_samp_factor, TRUE);
210
    /* Note: entropy decoder expects buffer to be zeroed,
211
     * but this is handled automatically by the memory manager
212
     * because we requested a pre-zeroed array.
213
     */
214
42.0M
  }
215
216
  /* Loop to process one whole iMCU row */
217
66.1M
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
218
43.5M
       yoffset++) {
219
812M
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
220
769M
         MCU_col_num++) {
221
      /* Construct list of pointers to DCT blocks belonging to this MCU */
222
769M
      blkn = 0;                 /* index of current DCT block within MCU */
223
2.07G
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
224
1.30G
        compptr = cinfo->cur_comp_info[ci];
225
1.30G
        start_col = MCU_col_num * compptr->MCU_width;
226
3.28G
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
227
1.98G
          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
228
4.79G
          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
229
2.80G
            coef->MCU_buffer[blkn++] = buffer_ptr++;
230
2.80G
          }
231
1.98G
        }
232
1.30G
      }
233
769M
      if (!cinfo->entropy->insufficient_data)
234
205M
        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
235
      /* Try to fetch the MCU. */
236
769M
      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
237
        /* Suspension forced; update state counters and exit */
238
0
        coef->MCU_vert_offset = yoffset;
239
0
        coef->MCU_ctr = MCU_col_num;
240
0
        return JPEG_SUSPENDED;
241
0
      }
242
769M
    }
243
    /* Completed an MCU row, but perhaps not an iMCU row */
244
43.5M
    coef->MCU_ctr = 0;
245
43.5M
  }
246
  /* Completed the iMCU row, advance counters for next one */
247
22.6M
  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
248
21.3M
    start_iMCU_row(cinfo);
249
21.3M
    return JPEG_ROW_COMPLETED;
250
21.3M
  }
251
  /* Completed the scan */
252
1.30M
  (*cinfo->inputctl->finish_input_pass) (cinfo);
253
1.30M
  return JPEG_SCAN_COMPLETED;
254
22.6M
}
255
256
257
/*
258
 * Decompress and return some data in the multi-pass case.
259
 * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
260
 * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
261
 *
262
 * NB: output_buf contains a plane for each component in image.
263
 */
264
265
METHODDEF(int)
266
decompress_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
267
60.8k
{
268
60.8k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
269
60.8k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
270
60.8k
  JDIMENSION block_num;
271
60.8k
  int ci, block_row, block_rows;
272
60.8k
  JBLOCKARRAY buffer;
273
60.8k
  JBLOCKROW buffer_ptr;
274
60.8k
  _JSAMPARRAY output_ptr;
275
60.8k
  JDIMENSION output_col;
276
60.8k
  jpeg_component_info *compptr;
277
60.8k
  _inverse_DCT_method_ptr inverse_DCT;
278
279
  /* Force some input to be done if we are getting ahead of the input. */
280
60.8k
  while (cinfo->input_scan_number < cinfo->output_scan_number ||
281
60.8k
         (cinfo->input_scan_number == cinfo->output_scan_number &&
282
60.8k
          cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
283
0
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
284
0
      return JPEG_SUSPENDED;
285
0
  }
286
287
  /* OK, output from the virtual arrays. */
288
243k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
289
182k
       ci++, compptr++) {
290
    /* Don't bother to IDCT an uninteresting component. */
291
182k
    if (!compptr->component_needed)
292
0
      continue;
293
    /* Align the virtual buffer for this component. */
294
182k
    buffer = (*cinfo->mem->access_virt_barray)
295
182k
      ((j_common_ptr)cinfo, coef->whole_image[ci],
296
182k
       cinfo->output_iMCU_row * compptr->v_samp_factor,
297
182k
       (JDIMENSION)compptr->v_samp_factor, FALSE);
298
    /* Count non-dummy DCT block rows in this iMCU row. */
299
182k
    if (cinfo->output_iMCU_row < last_iMCU_row)
300
169k
      block_rows = compptr->v_samp_factor;
301
13.3k
    else {
302
      /* NB: can't use last_row_height here; it is input-side-dependent! */
303
13.3k
      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
304
13.3k
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
305
13.3k
    }
306
182k
    inverse_DCT = cinfo->idct->_inverse_DCT[ci];
307
182k
    output_ptr = output_buf[ci];
308
    /* Loop over all DCT blocks to be processed. */
309
393k
    for (block_row = 0; block_row < block_rows; block_row++) {
310
210k
      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
311
210k
      output_col = 0;
312
210k
      for (block_num = cinfo->master->first_MCU_col[ci];
313
5.53M
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
314
5.32M
        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr,
315
5.32M
                        output_col);
316
5.32M
        buffer_ptr++;
317
5.32M
        output_col += compptr->_DCT_scaled_size;
318
5.32M
      }
319
210k
      output_ptr += compptr->_DCT_scaled_size;
320
210k
    }
321
182k
  }
322
323
60.8k
  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
324
56.4k
    return JPEG_ROW_COMPLETED;
325
4.43k
  return JPEG_SCAN_COMPLETED;
326
60.8k
}
327
328
#endif /* D_MULTISCAN_FILES_SUPPORTED */
329
330
331
#ifdef BLOCK_SMOOTHING_SUPPORTED
332
333
/*
334
 * This code applies interblock smoothing; the first 9 AC coefficients are
335
 * estimated from the DC values of a DCT block and its 24 neighboring blocks.
336
 * We apply smoothing only for progressive JPEG decoding, and only if
337
 * the coefficients it can estimate are not yet known to full precision.
338
 */
339
340
/* Natural-order array positions of the first 9 zigzag-order coefficients */
341
175k
#define Q01_POS  1
342
175k
#define Q10_POS  8
343
175k
#define Q20_POS  16
344
175k
#define Q11_POS  9
345
174k
#define Q02_POS  2
346
93.1k
#define Q03_POS  3
347
93.0k
#define Q12_POS  10
348
92.5k
#define Q21_POS  17
349
92.0k
#define Q30_POS  24
350
351
/*
352
 * Determine whether block smoothing is applicable and safe.
353
 * We also latch the current states of the coef_bits[] entries for the
354
 * AC coefficients; otherwise, if the input side of the decompressor
355
 * advances into a new scan, we might think the coefficients are known
356
 * more accurately than they really are.
357
 */
358
359
LOCAL(boolean)
360
smoothing_ok(j_decompress_ptr cinfo)
361
7.16k
{
362
7.16k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
363
7.16k
  boolean smoothing_useful = FALSE;
364
7.16k
  int ci, coefi;
365
7.16k
  jpeg_component_info *compptr;
366
7.16k
  JQUANT_TBL *qtable;
367
7.16k
  int *coef_bits, *prev_coef_bits;
368
7.16k
  int *coef_bits_latch, *prev_coef_bits_latch;
369
370
7.16k
  if (!cinfo->progressive_mode || cinfo->coef_bits == NULL)
371
148
    return FALSE;
372
373
  /* Allocate latch area if not already done */
374
7.01k
  if (coef->coef_bits_latch == NULL)
375
7.01k
    coef->coef_bits_latch = (int *)
376
7.01k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
377
7.01k
                                  cinfo->num_components * 2 *
378
7.01k
                                  (SAVED_COEFS * sizeof(int)));
379
7.01k
  coef_bits_latch = coef->coef_bits_latch;
380
7.01k
  prev_coef_bits_latch =
381
7.01k
    &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS];
382
383
17.0k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
384
13.9k
       ci++, compptr++) {
385
    /* All components' quantization values must already be latched. */
386
13.9k
    if ((qtable = compptr->quant_table) == NULL)
387
18
      return FALSE;
388
    /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */
389
13.9k
    if (qtable->quantval[0] == 0 ||
390
13.9k
        qtable->quantval[Q01_POS] == 0 ||
391
13.9k
        qtable->quantval[Q10_POS] == 0 ||
392
13.9k
        qtable->quantval[Q20_POS] == 0 ||
393
13.9k
        qtable->quantval[Q11_POS] == 0 ||
394
13.9k
        qtable->quantval[Q02_POS] == 0 ||
395
13.9k
        qtable->quantval[Q03_POS] == 0 ||
396
13.9k
        qtable->quantval[Q12_POS] == 0 ||
397
13.9k
        qtable->quantval[Q21_POS] == 0 ||
398
13.9k
        qtable->quantval[Q30_POS] == 0)
399
3.52k
      return FALSE;
400
    /* DC values must be at least partly known for all components. */
401
10.4k
    coef_bits = cinfo->coef_bits[ci];
402
10.4k
    prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components];
403
10.4k
    if (coef_bits[0] < 0)
404
341
      return FALSE;
405
10.0k
    coef_bits_latch[0] = coef_bits[0];
406
    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
407
100k
    for (coefi = 1; coefi < SAVED_COEFS; coefi++) {
408
90.7k
      if (cinfo->input_scan_number > 1)
409
79.1k
        prev_coef_bits_latch[coefi] = prev_coef_bits[coefi];
410
11.5k
      else
411
11.5k
        prev_coef_bits_latch[coefi] = -1;
412
90.7k
      coef_bits_latch[coefi] = coef_bits[coefi];
413
90.7k
      if (coef_bits[coefi] != 0)
414
60.4k
        smoothing_useful = TRUE;
415
90.7k
    }
416
10.0k
    coef_bits_latch += SAVED_COEFS;
417
10.0k
    prev_coef_bits_latch += SAVED_COEFS;
418
10.0k
  }
419
420
3.13k
  return smoothing_useful;
421
7.01k
}
422
423
424
/*
425
 * Variant of decompress_data for use when doing block smoothing.
426
 */
427
428
METHODDEF(int)
429
decompress_smooth_data(j_decompress_ptr cinfo, _JSAMPIMAGE output_buf)
430
63.4k
{
431
63.4k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
432
63.4k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
433
63.4k
  JDIMENSION block_num, last_block_column;
434
63.4k
  int ci, block_row, block_rows, access_rows, image_block_row,
435
63.4k
    image_block_rows;
436
63.4k
  JBLOCKARRAY buffer;
437
63.4k
  JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row;
438
63.4k
  JBLOCKROW next_block_row, next_next_block_row;
439
63.4k
  _JSAMPARRAY output_ptr;
440
63.4k
  JDIMENSION output_col;
441
63.4k
  jpeg_component_info *compptr;
442
63.4k
  _inverse_DCT_method_ptr inverse_DCT;
443
63.4k
  boolean change_dc;
444
63.4k
  JCOEF *workspace;
445
63.4k
  int *coef_bits;
446
63.4k
  JQUANT_TBL *quanttbl;
447
63.4k
  JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num;
448
63.4k
  int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12,
449
63.4k
      DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24,
450
63.4k
      DC25;
451
63.4k
  int Al, pred;
452
453
  /* Keep a local variable to avoid looking it up more than once */
454
63.4k
  workspace = coef->workspace;
455
456
  /* Force some input to be done if we are getting ahead of the input. */
457
63.4k
  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
458
63.4k
         !cinfo->inputctl->eoi_reached) {
459
0
    if (cinfo->input_scan_number == cinfo->output_scan_number) {
460
      /* If input is working on current scan, we ordinarily want it to
461
       * have completed the current row.  But if input scan is DC,
462
       * we want it to keep two rows ahead so that next two block rows' DC
463
       * values are up to date.
464
       */
465
0
      JDIMENSION delta = (cinfo->Ss == 0) ? 2 : 0;
466
0
      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row + delta)
467
0
        break;
468
0
    }
469
0
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
470
0
      return JPEG_SUSPENDED;
471
0
  }
472
473
  /* OK, output from the virtual arrays. */
474
225k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
475
162k
       ci++, compptr++) {
476
    /* Don't bother to IDCT an uninteresting component. */
477
162k
    if (!compptr->component_needed)
478
0
      continue;
479
    /* Count non-dummy DCT block rows in this iMCU row. */
480
162k
    if (cinfo->output_iMCU_row + 1 < last_iMCU_row) {
481
148k
      block_rows = compptr->v_samp_factor;
482
148k
      access_rows = block_rows * 3; /* this and next two iMCU rows */
483
148k
    } else if (cinfo->output_iMCU_row < last_iMCU_row) {
484
6.95k
      block_rows = compptr->v_samp_factor;
485
6.95k
      access_rows = block_rows * 2; /* this and next iMCU row */
486
6.95k
    } else {
487
      /* NB: can't use last_row_height here; it is input-side-dependent! */
488
6.95k
      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
489
6.95k
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
490
6.95k
      access_rows = block_rows; /* this iMCU row only */
491
6.95k
    }
492
    /* Align the virtual buffer for this component. */
493
162k
    if (cinfo->output_iMCU_row > 1) {
494
148k
      access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */
495
148k
      buffer = (*cinfo->mem->access_virt_barray)
496
148k
        ((j_common_ptr)cinfo, coef->whole_image[ci],
497
148k
         (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor,
498
148k
         (JDIMENSION)access_rows, FALSE);
499
148k
      buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */
500
148k
    } else if (cinfo->output_iMCU_row > 0) {
501
6.95k
      access_rows += compptr->v_samp_factor; /* prior iMCU row too */
502
6.95k
      buffer = (*cinfo->mem->access_virt_barray)
503
6.95k
        ((j_common_ptr)cinfo, coef->whole_image[ci],
504
6.95k
         (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
505
6.95k
         (JDIMENSION)access_rows, FALSE);
506
6.95k
      buffer += compptr->v_samp_factor; /* point to current iMCU row */
507
6.95k
    } else {
508
6.95k
      buffer = (*cinfo->mem->access_virt_barray)
509
6.95k
        ((j_common_ptr)cinfo, coef->whole_image[ci],
510
6.95k
         (JDIMENSION)0, (JDIMENSION)access_rows, FALSE);
511
6.95k
    }
512
    /* Fetch component-dependent info.
513
     * If the current scan is incomplete, then we use the component-dependent
514
     * info from the previous scan.
515
     */
516
162k
    if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row)
517
74.5k
      coef_bits =
518
74.5k
        coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS);
519
87.7k
    else
520
87.7k
      coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
521
522
    /* We only do DC interpolation if no AC coefficient data is available. */
523
162k
    change_dc =
524
162k
      coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 &&
525
162k
      coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 &&
526
162k
      coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1;
527
528
162k
    quanttbl = compptr->quant_table;
529
162k
    Q00 = quanttbl->quantval[0];
530
162k
    Q01 = quanttbl->quantval[Q01_POS];
531
162k
    Q10 = quanttbl->quantval[Q10_POS];
532
162k
    Q20 = quanttbl->quantval[Q20_POS];
533
162k
    Q11 = quanttbl->quantval[Q11_POS];
534
162k
    Q02 = quanttbl->quantval[Q02_POS];
535
162k
    if (change_dc) {
536
81.3k
      Q03 = quanttbl->quantval[Q03_POS];
537
81.3k
      Q12 = quanttbl->quantval[Q12_POS];
538
81.3k
      Q21 = quanttbl->quantval[Q21_POS];
539
81.3k
      Q30 = quanttbl->quantval[Q30_POS];
540
81.3k
    }
541
162k
    inverse_DCT = cinfo->idct->_inverse_DCT[ci];
542
162k
    output_ptr = output_buf[ci];
543
    /* Loop over all DCT blocks to be processed. */
544
162k
    image_block_rows = block_rows * cinfo->total_iMCU_rows;
545
386k
    for (block_row = 0; block_row < block_rows; block_row++) {
546
224k
      image_block_row = cinfo->output_iMCU_row * block_rows + block_row;
547
224k
      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
548
549
224k
      if (image_block_row > 0)
550
217k
        prev_block_row =
551
217k
          buffer[block_row - 1] + cinfo->master->first_MCU_col[ci];
552
6.95k
      else
553
6.95k
        prev_block_row = buffer_ptr;
554
555
224k
      if (image_block_row > 1)
556
210k
        prev_prev_block_row =
557
210k
          buffer[block_row - 2] + cinfo->master->first_MCU_col[ci];
558
13.9k
      else
559
13.9k
        prev_prev_block_row = prev_block_row;
560
561
224k
      if (image_block_row < image_block_rows - 1)
562
217k
        next_block_row =
563
217k
          buffer[block_row + 1] + cinfo->master->first_MCU_col[ci];
564
6.95k
      else
565
6.95k
        next_block_row = buffer_ptr;
566
567
224k
      if (image_block_row < image_block_rows - 2)
568
210k
        next_next_block_row =
569
210k
          buffer[block_row + 2] + cinfo->master->first_MCU_col[ci];
570
13.8k
      else
571
13.8k
        next_next_block_row = next_block_row;
572
573
      /* We fetch the surrounding DC values using a sliding-register approach.
574
       * Initialize all 25 here so as to do the right thing on narrow pics.
575
       */
576
224k
      DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0];
577
224k
      DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0];
578
224k
      DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0];
579
224k
      DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0];
580
224k
      DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0];
581
224k
      output_col = 0;
582
224k
      last_block_column = compptr->width_in_blocks - 1;
583
224k
      for (block_num = cinfo->master->first_MCU_col[ci];
584
13.8M
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
585
        /* Fetch current DCT block into workspace so we can modify it. */
586
13.6M
        jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1);
587
        /* Update DC values */
588
13.6M
        if (block_num == cinfo->master->first_MCU_col[ci] &&
589
13.6M
            block_num < last_block_column) {
590
197k
          DC04 = DC05 = (int)prev_prev_block_row[1][0];
591
197k
          DC09 = DC10 = (int)prev_block_row[1][0];
592
197k
          DC14 = DC15 = (int)buffer_ptr[1][0];
593
197k
          DC19 = DC20 = (int)next_block_row[1][0];
594
197k
          DC24 = DC25 = (int)next_next_block_row[1][0];
595
197k
        }
596
13.6M
        if (block_num + 1 < last_block_column) {
597
13.2M
          DC05 = (int)prev_prev_block_row[2][0];
598
13.2M
          DC10 = (int)prev_block_row[2][0];
599
13.2M
          DC15 = (int)buffer_ptr[2][0];
600
13.2M
          DC20 = (int)next_block_row[2][0];
601
13.2M
          DC25 = (int)next_next_block_row[2][0];
602
13.2M
        }
603
        /* If DC interpolation is enabled, compute coefficient estimates using
604
         * a Gaussian-like kernel, keeping the averages of the DC values.
605
         *
606
         * If DC interpolation is disabled, compute coefficient estimates using
607
         * an algorithm similar to the one described in Section K.8 of the JPEG
608
         * standard, except applied to a 5x5 window rather than a 3x3 window.
609
         *
610
         * An estimate is applied only if the coefficient is still zero and is
611
         * not known to be fully accurate.
612
         */
613
        /* AC01 */
614
13.6M
        if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) {
615
12.0M
          num = Q00 * (change_dc ?
616
6.62M
                (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 -
617
6.62M
                 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 +
618
6.62M
                 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 -
619
6.62M
                 DC21 - DC22 + DC24 + DC25) :
620
12.0M
                (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15));
621
12.0M
          if (num >= 0) {
622
8.71M
            pred = (int)(((Q01 << 7) + num) / (Q01 << 8));
623
8.71M
            if (Al > 0 && pred >= (1 << Al))
624
518k
              pred = (1 << Al) - 1;
625
8.71M
          } else {
626
3.30M
            pred = (int)(((Q01 << 7) - num) / (Q01 << 8));
627
3.30M
            if (Al > 0 && pred >= (1 << Al))
628
808k
              pred = (1 << Al) - 1;
629
3.30M
            pred = -pred;
630
3.30M
          }
631
12.0M
          workspace[1] = (JCOEF)pred;
632
12.0M
        }
633
        /* AC10 */
634
13.6M
        if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) {
635
12.3M
          num = Q00 * (change_dc ?
636
6.63M
                (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 +
637
6.63M
                 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 -
638
6.63M
                 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 +
639
6.63M
                 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) :
640
12.3M
                (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23));
641
12.3M
          if (num >= 0) {
642
9.50M
            pred = (int)(((Q10 << 7) + num) / (Q10 << 8));
643
9.50M
            if (Al > 0 && pred >= (1 << Al))
644
1.33M
              pred = (1 << Al) - 1;
645
9.50M
          } else {
646
2.79M
            pred = (int)(((Q10 << 7) - num) / (Q10 << 8));
647
2.79M
            if (Al > 0 && pred >= (1 << Al))
648
1.24M
              pred = (1 << Al) - 1;
649
2.79M
            pred = -pred;
650
2.79M
          }
651
12.3M
          workspace[8] = (JCOEF)pred;
652
12.3M
        }
653
        /* AC20 */
654
13.6M
        if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) {
655
12.4M
          num = Q00 * (change_dc ?
656
6.63M
                (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 -
657
6.63M
                 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) :
658
12.4M
                (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23));
659
12.4M
          if (num >= 0) {
660
8.72M
            pred = (int)(((Q20 << 7) + num) / (Q20 << 8));
661
8.72M
            if (Al > 0 && pred >= (1 << Al))
662
1.22M
              pred = (1 << Al) - 1;
663
8.72M
          } else {
664
3.68M
            pred = (int)(((Q20 << 7) - num) / (Q20 << 8));
665
3.68M
            if (Al > 0 && pred >= (1 << Al))
666
1.21M
              pred = (1 << Al) - 1;
667
3.68M
            pred = -pred;
668
3.68M
          }
669
12.4M
          workspace[16] = (JCOEF)pred;
670
12.4M
        }
671
        /* AC11 */
672
13.6M
        if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) {
673
12.2M
          num = Q00 * (change_dc ?
674
6.63M
                (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 +
675
6.63M
                 9 * DC19 + DC21 - DC25) :
676
12.2M
                (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 -
677
5.65M
                 DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09));
678
12.2M
          if (num >= 0) {
679
9.66M
            pred = (int)(((Q11 << 7) + num) / (Q11 << 8));
680
9.66M
            if (Al > 0 && pred >= (1 << Al))
681
281k
              pred = (1 << Al) - 1;
682
9.66M
          } else {
683
2.61M
            pred = (int)(((Q11 << 7) - num) / (Q11 << 8));
684
2.61M
            if (Al > 0 && pred >= (1 << Al))
685
286k
              pred = (1 << Al) - 1;
686
2.61M
            pred = -pred;
687
2.61M
          }
688
12.2M
          workspace[9] = (JCOEF)pred;
689
12.2M
        }
690
        /* AC02 */
691
13.6M
        if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) {
692
12.4M
          num = Q00 * (change_dc ?
693
6.63M
                (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 +
694
6.63M
                 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) :
695
12.4M
                (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15));
696
12.4M
          if (num >= 0) {
697
9.14M
            pred = (int)(((Q02 << 7) + num) / (Q02 << 8));
698
9.14M
            if (Al > 0 && pred >= (1 << Al))
699
430k
              pred = (1 << Al) - 1;
700
9.14M
          } else {
701
3.32M
            pred = (int)(((Q02 << 7) - num) / (Q02 << 8));
702
3.32M
            if (Al > 0 && pred >= (1 << Al))
703
481k
              pred = (1 << Al) - 1;
704
3.32M
            pred = -pred;
705
3.32M
          }
706
12.4M
          workspace[2] = (JCOEF)pred;
707
12.4M
        }
708
13.6M
        if (change_dc) {
709
          /* AC03 */
710
6.64M
          if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) {
711
6.63M
            num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19);
712
6.63M
            if (num >= 0) {
713
5.58M
              pred = (int)(((Q03 << 7) + num) / (Q03 << 8));
714
5.58M
              if (Al > 0 && pred >= (1 << Al))
715
0
                pred = (1 << Al) - 1;
716
5.58M
            } else {
717
1.05M
              pred = (int)(((Q03 << 7) - num) / (Q03 << 8));
718
1.05M
              if (Al > 0 && pred >= (1 << Al))
719
0
                pred = (1 << Al) - 1;
720
1.05M
              pred = -pred;
721
1.05M
            }
722
6.63M
            workspace[3] = (JCOEF)pred;
723
6.63M
          }
724
          /* AC12 */
725
6.64M
          if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) {
726
6.63M
            num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19);
727
6.63M
            if (num >= 0) {
728
4.12M
              pred = (int)(((Q12 << 7) + num) / (Q12 << 8));
729
4.12M
              if (Al > 0 && pred >= (1 << Al))
730
0
                pred = (1 << Al) - 1;
731
4.12M
            } else {
732
2.51M
              pred = (int)(((Q12 << 7) - num) / (Q12 << 8));
733
2.51M
              if (Al > 0 && pred >= (1 << Al))
734
0
                pred = (1 << Al) - 1;
735
2.51M
              pred = -pred;
736
2.51M
            }
737
6.63M
            workspace[10] = (JCOEF)pred;
738
6.63M
          }
739
          /* AC21 */
740
6.64M
          if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) {
741
6.63M
            num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19);
742
6.63M
            if (num >= 0) {
743
4.57M
              pred = (int)(((Q21 << 7) + num) / (Q21 << 8));
744
4.57M
              if (Al > 0 && pred >= (1 << Al))
745
0
                pred = (1 << Al) - 1;
746
4.57M
            } else {
747
2.06M
              pred = (int)(((Q21 << 7) - num) / (Q21 << 8));
748
2.06M
              if (Al > 0 && pred >= (1 << Al))
749
0
                pred = (1 << Al) - 1;
750
2.06M
              pred = -pred;
751
2.06M
            }
752
6.63M
            workspace[17] = (JCOEF)pred;
753
6.63M
          }
754
          /* AC30 */
755
6.64M
          if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) {
756
6.63M
            num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19);
757
6.63M
            if (num >= 0) {
758
5.65M
              pred = (int)(((Q30 << 7) + num) / (Q30 << 8));
759
5.65M
              if (Al > 0 && pred >= (1 << Al))
760
0
                pred = (1 << Al) - 1;
761
5.65M
            } else {
762
986k
              pred = (int)(((Q30 << 7) - num) / (Q30 << 8));
763
986k
              if (Al > 0 && pred >= (1 << Al))
764
0
                pred = (1 << Al) - 1;
765
986k
              pred = -pred;
766
986k
            }
767
6.63M
            workspace[24] = (JCOEF)pred;
768
6.63M
          }
769
          /* coef_bits[0] is non-negative.  Otherwise this function would not
770
           * be called.
771
           */
772
6.64M
          num = Q00 *
773
6.64M
                (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 -
774
6.64M
                 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 -
775
6.64M
                 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 -
776
6.64M
                 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 -
777
6.64M
                 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25);
778
6.64M
          if (num >= 0) {
779
4.44M
            pred = (int)(((Q00 << 7) + num) / (Q00 << 8));
780
4.44M
          } else {
781
2.20M
            pred = (int)(((Q00 << 7) - num) / (Q00 << 8));
782
2.20M
            pred = -pred;
783
2.20M
          }
784
6.64M
          workspace[0] = (JCOEF)pred;
785
6.64M
        }  /* change_dc */
786
787
        /* OK, do the IDCT */
788
13.6M
        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr,
789
13.6M
                        output_col);
790
        /* Advance for next column */
791
13.6M
        DC01 = DC02;  DC02 = DC03;  DC03 = DC04;  DC04 = DC05;
792
13.6M
        DC06 = DC07;  DC07 = DC08;  DC08 = DC09;  DC09 = DC10;
793
13.6M
        DC11 = DC12;  DC12 = DC13;  DC13 = DC14;  DC14 = DC15;
794
13.6M
        DC16 = DC17;  DC17 = DC18;  DC18 = DC19;  DC19 = DC20;
795
13.6M
        DC21 = DC22;  DC22 = DC23;  DC23 = DC24;  DC24 = DC25;
796
13.6M
        buffer_ptr++, prev_block_row++, next_block_row++,
797
13.6M
          prev_prev_block_row++, next_next_block_row++;
798
13.6M
        output_col += compptr->_DCT_scaled_size;
799
13.6M
      }
800
224k
      output_ptr += compptr->_DCT_scaled_size;
801
224k
    }
802
162k
  }
803
804
63.4k
  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
805
61.0k
    return JPEG_ROW_COMPLETED;
806
2.33k
  return JPEG_SCAN_COMPLETED;
807
63.4k
}
808
809
#endif /* BLOCK_SMOOTHING_SUPPORTED */
810
811
812
/*
813
 * Initialize coefficient buffer controller.
814
 */
815
816
GLOBAL(void)
817
_jinit_d_coef_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
818
28.7k
{
819
28.7k
  my_coef_ptr coef;
820
821
28.7k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
822
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
823
824
28.7k
  coef = (my_coef_ptr)
825
28.7k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
826
28.7k
                                sizeof(my_coef_controller));
827
28.7k
  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
828
28.7k
  coef->pub.start_input_pass = start_input_pass;
829
28.7k
  coef->pub.start_output_pass = start_output_pass;
830
28.7k
#ifdef BLOCK_SMOOTHING_SUPPORTED
831
28.7k
  coef->coef_bits_latch = NULL;
832
28.7k
#endif
833
834
  /* Create the coefficient buffer. */
835
28.7k
  if (need_full_buffer) {
836
13.9k
#ifdef D_MULTISCAN_FILES_SUPPORTED
837
    /* Allocate a full-image virtual array for each component, */
838
    /* padded to a multiple of samp_factor DCT blocks in each direction. */
839
    /* Note we ask for a pre-zeroed array. */
840
13.9k
    int ci, access_rows;
841
13.9k
    jpeg_component_info *compptr;
842
843
55.3k
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
844
41.4k
         ci++, compptr++) {
845
41.4k
      access_rows = compptr->v_samp_factor;
846
41.4k
#ifdef BLOCK_SMOOTHING_SUPPORTED
847
      /* If block smoothing could be used, need a bigger window */
848
41.4k
      if (cinfo->progressive_mode)
849
38.9k
        access_rows *= 5;
850
41.4k
#endif
851
41.4k
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
852
41.4k
        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
853
41.4k
         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
854
41.4k
                               (long)compptr->h_samp_factor),
855
41.4k
         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
856
41.4k
                               (long)compptr->v_samp_factor),
857
41.4k
         (JDIMENSION)access_rows);
858
41.4k
    }
859
13.9k
    coef->pub.consume_data = consume_data;
860
13.9k
    coef->pub._decompress_data = decompress_data;
861
13.9k
    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
862
#else
863
    ERREXIT(cinfo, JERR_NOT_COMPILED);
864
#endif
865
14.8k
  } else {
866
    /* We only need a single-MCU buffer. */
867
14.8k
    JBLOCKROW buffer;
868
14.8k
    int i;
869
870
14.8k
    buffer = (JBLOCKROW)
871
14.8k
      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
872
14.8k
                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
873
162k
    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
874
148k
      coef->MCU_buffer[i] = buffer + i;
875
148k
    }
876
14.8k
    coef->pub.consume_data = dummy_consume_data;
877
14.8k
    coef->pub._decompress_data = decompress_onepass;
878
14.8k
    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
879
14.8k
  }
880
881
  /* Allocate the workspace buffer */
882
28.7k
  coef->workspace = (JCOEF *)
883
28.7k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
884
28.7k
                                sizeof(JCOEF) * DCTSIZE2);
885
28.7k
}
j12init_d_coef_controller
Line
Count
Source
818
687
{
819
687
  my_coef_ptr coef;
820
821
687
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
822
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
823
824
687
  coef = (my_coef_ptr)
825
687
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
826
687
                                sizeof(my_coef_controller));
827
687
  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
828
687
  coef->pub.start_input_pass = start_input_pass;
829
687
  coef->pub.start_output_pass = start_output_pass;
830
687
#ifdef BLOCK_SMOOTHING_SUPPORTED
831
687
  coef->coef_bits_latch = NULL;
832
687
#endif
833
834
  /* Create the coefficient buffer. */
835
687
  if (need_full_buffer) {
836
481
#ifdef D_MULTISCAN_FILES_SUPPORTED
837
    /* Allocate a full-image virtual array for each component, */
838
    /* padded to a multiple of samp_factor DCT blocks in each direction. */
839
    /* Note we ask for a pre-zeroed array. */
840
481
    int ci, access_rows;
841
481
    jpeg_component_info *compptr;
842
843
1.93k
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
844
1.45k
         ci++, compptr++) {
845
1.45k
      access_rows = compptr->v_samp_factor;
846
1.45k
#ifdef BLOCK_SMOOTHING_SUPPORTED
847
      /* If block smoothing could be used, need a bigger window */
848
1.45k
      if (cinfo->progressive_mode)
849
1.30k
        access_rows *= 5;
850
1.45k
#endif
851
1.45k
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
852
1.45k
        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
853
1.45k
         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
854
1.45k
                               (long)compptr->h_samp_factor),
855
1.45k
         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
856
1.45k
                               (long)compptr->v_samp_factor),
857
1.45k
         (JDIMENSION)access_rows);
858
1.45k
    }
859
481
    coef->pub.consume_data = consume_data;
860
481
    coef->pub._decompress_data = decompress_data;
861
481
    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
862
#else
863
    ERREXIT(cinfo, JERR_NOT_COMPILED);
864
#endif
865
481
  } else {
866
    /* We only need a single-MCU buffer. */
867
206
    JBLOCKROW buffer;
868
206
    int i;
869
870
206
    buffer = (JBLOCKROW)
871
206
      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
872
206
                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
873
2.26k
    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
874
2.06k
      coef->MCU_buffer[i] = buffer + i;
875
2.06k
    }
876
206
    coef->pub.consume_data = dummy_consume_data;
877
206
    coef->pub._decompress_data = decompress_onepass;
878
206
    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
879
206
  }
880
881
  /* Allocate the workspace buffer */
882
687
  coef->workspace = (JCOEF *)
883
687
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
884
687
                                sizeof(JCOEF) * DCTSIZE2);
885
687
}
jinit_d_coef_controller
Line
Count
Source
818
28.0k
{
819
28.0k
  my_coef_ptr coef;
820
821
28.0k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
822
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
823
824
28.0k
  coef = (my_coef_ptr)
825
28.0k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
826
28.0k
                                sizeof(my_coef_controller));
827
28.0k
  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
828
28.0k
  coef->pub.start_input_pass = start_input_pass;
829
28.0k
  coef->pub.start_output_pass = start_output_pass;
830
28.0k
#ifdef BLOCK_SMOOTHING_SUPPORTED
831
28.0k
  coef->coef_bits_latch = NULL;
832
28.0k
#endif
833
834
  /* Create the coefficient buffer. */
835
28.0k
  if (need_full_buffer) {
836
13.4k
#ifdef D_MULTISCAN_FILES_SUPPORTED
837
    /* Allocate a full-image virtual array for each component, */
838
    /* padded to a multiple of samp_factor DCT blocks in each direction. */
839
    /* Note we ask for a pre-zeroed array. */
840
13.4k
    int ci, access_rows;
841
13.4k
    jpeg_component_info *compptr;
842
843
53.4k
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
844
39.9k
         ci++, compptr++) {
845
39.9k
      access_rows = compptr->v_samp_factor;
846
39.9k
#ifdef BLOCK_SMOOTHING_SUPPORTED
847
      /* If block smoothing could be used, need a bigger window */
848
39.9k
      if (cinfo->progressive_mode)
849
37.6k
        access_rows *= 5;
850
39.9k
#endif
851
39.9k
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
852
39.9k
        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
853
39.9k
         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
854
39.9k
                               (long)compptr->h_samp_factor),
855
39.9k
         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
856
39.9k
                               (long)compptr->v_samp_factor),
857
39.9k
         (JDIMENSION)access_rows);
858
39.9k
    }
859
13.4k
    coef->pub.consume_data = consume_data;
860
13.4k
    coef->pub._decompress_data = decompress_data;
861
13.4k
    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
862
#else
863
    ERREXIT(cinfo, JERR_NOT_COMPILED);
864
#endif
865
14.6k
  } else {
866
    /* We only need a single-MCU buffer. */
867
14.6k
    JBLOCKROW buffer;
868
14.6k
    int i;
869
870
14.6k
    buffer = (JBLOCKROW)
871
14.6k
      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
872
14.6k
                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
873
160k
    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
874
146k
      coef->MCU_buffer[i] = buffer + i;
875
146k
    }
876
14.6k
    coef->pub.consume_data = dummy_consume_data;
877
14.6k
    coef->pub._decompress_data = decompress_onepass;
878
14.6k
    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
879
14.6k
  }
880
881
  /* Allocate the workspace buffer */
882
28.0k
  coef->workspace = (JCOEF *)
883
28.0k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
884
28.0k
                                sizeof(JCOEF) * DCTSIZE2);
885
28.0k
}