Coverage Report

Created: 2023-03-23 11:52

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