Coverage Report

Created: 2024-09-14 07:19

/src/skia/third_party/externals/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, 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
22.5k
{
47
22.5k
  cinfo->input_iMCU_row = 0;
48
22.5k
  start_iMCU_row(cinfo);
49
22.5k
}
50
51
52
/*
53
 * Initialize for an output processing pass.
54
 */
55
56
METHODDEF(void)
57
start_output_pass(j_decompress_ptr cinfo)
58
3.83k
{
59
3.83k
#ifdef BLOCK_SMOOTHING_SUPPORTED
60
3.83k
  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
3.83k
  if (coef->pub.coef_arrays != NULL) {
64
3.26k
    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
65
428
      coef->pub.decompress_data = decompress_smooth_data;
66
2.84k
    else
67
2.84k
      coef->pub.decompress_data = decompress_data;
68
3.26k
  }
69
3.83k
#endif
70
3.83k
  cinfo->output_iMCU_row = 0;
71
3.83k
}
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
45.5k
{
87
45.5k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
88
45.5k
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
89
45.5k
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
90
45.5k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
91
45.5k
  int blkn, ci, xindex, yindex, yoffset, useful_width;
92
45.5k
  JSAMPARRAY output_ptr;
93
45.5k
  JDIMENSION start_col, output_col;
94
45.5k
  jpeg_component_info *compptr;
95
45.5k
  inverse_DCT_method_ptr inverse_DCT;
96
97
  /* Loop to process as much as one whole iMCU row */
98
115k
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
99
70.1k
       yoffset++) {
100
616k
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
101
546k
         MCU_col_num++) {
102
      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
103
546k
      jzero_far((void *)coef->MCU_buffer[0],
104
546k
                (size_t)(cinfo->blocks_in_MCU * sizeof(JBLOCK)));
105
546k
      if (!cinfo->entropy->insufficient_data)
106
129k
        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
107
546k
      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
108
        /* Suspension forced; update state counters and exit */
109
130
        coef->MCU_vert_offset = yoffset;
110
130
        coef->MCU_ctr = MCU_col_num;
111
130
        return JPEG_SUSPENDED;
112
130
      }
113
114
      /* Only perform the IDCT on blocks that are contained within the desired
115
       * cropping region.
116
       */
117
546k
      if (MCU_col_num >= cinfo->master->first_iMCU_col &&
118
546k
          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
546k
        blkn = 0;               /* index of current DCT block within MCU */
125
1.17M
        for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
126
629k
          compptr = cinfo->cur_comp_info[ci];
127
          /* Don't bother to IDCT an uninteresting component. */
128
629k
          if (!compptr->component_needed) {
129
0
            blkn += compptr->MCU_blocks;
130
0
            continue;
131
0
          }
132
629k
          inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
133
629k
          useful_width = (MCU_col_num < last_MCU_col) ?
134
545k
                         compptr->MCU_width : compptr->last_col_width;
135
629k
          output_ptr = output_buf[compptr->component_index] +
136
629k
                       yoffset * compptr->_DCT_scaled_size;
137
629k
          start_col = (MCU_col_num - cinfo->master->first_iMCU_col) *
138
629k
                      compptr->MCU_sample_width;
139
1.34M
          for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
140
713k
            if (cinfo->input_iMCU_row < last_iMCU_row ||
141
713k
                yoffset + yindex < compptr->last_row_height) {
142
638k
              output_col = start_col;
143
1.30M
              for (xindex = 0; xindex < useful_width; xindex++) {
144
661k
                (*inverse_DCT) (cinfo, compptr,
145
661k
                                (JCOEFPTR)coef->MCU_buffer[blkn + xindex],
146
661k
                                output_ptr, output_col);
147
661k
                output_col += compptr->_DCT_scaled_size;
148
661k
              }
149
638k
            }
150
713k
            blkn += compptr->MCU_width;
151
713k
            output_ptr += compptr->_DCT_scaled_size;
152
713k
          }
153
629k
        }
154
546k
      }
155
546k
    }
156
    /* Completed an MCU row, but perhaps not an iMCU row */
157
69.9k
    coef->MCU_ctr = 0;
158
69.9k
  }
159
  /* Completed the iMCU row, advance counters for next one */
160
45.4k
  cinfo->output_iMCU_row++;
161
45.4k
  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
162
45.0k
    start_iMCU_row(cinfo);
163
45.0k
    return JPEG_ROW_COMPLETED;
164
45.0k
  }
165
  /* Completed the scan */
166
440
  (*cinfo->inputctl->finish_input_pass) (cinfo);
167
440
  return JPEG_SCAN_COMPLETED;
168
45.4k
}
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
8.35M
{
194
8.35M
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
195
8.35M
  JDIMENSION MCU_col_num;       /* index of current MCU within row */
196
8.35M
  int blkn, ci, xindex, yindex, yoffset;
197
8.35M
  JDIMENSION start_col;
198
8.35M
  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
199
8.35M
  JBLOCKROW buffer_ptr;
200
8.35M
  jpeg_component_info *compptr;
201
202
  /* Align the virtual buffers for the components used in this scan. */
203
20.5M
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
204
12.2M
    compptr = cinfo->cur_comp_info[ci];
205
12.2M
    buffer[ci] = (*cinfo->mem->access_virt_barray)
206
12.2M
      ((j_common_ptr)cinfo, coef->whole_image[compptr->component_index],
207
12.2M
       cinfo->input_iMCU_row * compptr->v_samp_factor,
208
12.2M
       (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
12.2M
  }
214
215
  /* Loop to process one whole iMCU row */
216
20.9M
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
217
12.6M
       yoffset++) {
218
395M
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
219
382M
         MCU_col_num++) {
220
      /* Construct list of pointers to DCT blocks belonging to this MCU */
221
382M
      blkn = 0;                 /* index of current DCT block within MCU */
222
1.01G
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
223
630M
        compptr = cinfo->cur_comp_info[ci];
224
630M
        start_col = MCU_col_num * compptr->MCU_width;
225
1.52G
        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
226
895M
          buffer_ptr = buffer[ci][yindex + yoffset] + start_col;
227
2.05G
          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
228
1.16G
            coef->MCU_buffer[blkn++] = buffer_ptr++;
229
1.16G
          }
230
895M
        }
231
630M
      }
232
382M
      if (!cinfo->entropy->insufficient_data)
233
73.4M
        cinfo->master->last_good_iMCU_row = cinfo->input_iMCU_row;
234
      /* Try to fetch the MCU. */
235
382M
      if (!(*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
236
        /* Suspension forced; update state counters and exit */
237
612
        coef->MCU_vert_offset = yoffset;
238
612
        coef->MCU_ctr = MCU_col_num;
239
612
        return JPEG_SUSPENDED;
240
612
      }
241
382M
    }
242
    /* Completed an MCU row, but perhaps not an iMCU row */
243
12.6M
    coef->MCU_ctr = 0;
244
12.6M
  }
245
  /* Completed the iMCU row, advance counters for next one */
246
8.35M
  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
247
8.33M
    start_iMCU_row(cinfo);
248
8.33M
    return JPEG_ROW_COMPLETED;
249
8.33M
  }
250
  /* Completed the scan */
251
21.3k
  (*cinfo->inputctl->finish_input_pass) (cinfo);
252
21.3k
  return JPEG_SCAN_COMPLETED;
253
8.35M
}
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
313k
{
267
313k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
268
313k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
269
313k
  JDIMENSION block_num;
270
313k
  int ci, block_row, block_rows;
271
313k
  JBLOCKARRAY buffer;
272
313k
  JBLOCKROW buffer_ptr;
273
313k
  JSAMPARRAY output_ptr;
274
313k
  JDIMENSION output_col;
275
313k
  jpeg_component_info *compptr;
276
313k
  inverse_DCT_method_ptr inverse_DCT;
277
278
  /* Force some input to be done if we are getting ahead of the input. */
279
313k
  while (cinfo->input_scan_number < cinfo->output_scan_number ||
280
313k
         (cinfo->input_scan_number == cinfo->output_scan_number &&
281
313k
          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
1.17M
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
288
859k
       ci++, compptr++) {
289
    /* Don't bother to IDCT an uninteresting component. */
290
859k
    if (!compptr->component_needed)
291
0
      continue;
292
    /* Align the virtual buffer for this component. */
293
859k
    buffer = (*cinfo->mem->access_virt_barray)
294
859k
      ((j_common_ptr)cinfo, coef->whole_image[ci],
295
859k
       cinfo->output_iMCU_row * compptr->v_samp_factor,
296
859k
       (JDIMENSION)compptr->v_samp_factor, FALSE);
297
    /* Count non-dummy DCT block rows in this iMCU row. */
298
859k
    if (cinfo->output_iMCU_row < last_iMCU_row)
299
853k
      block_rows = compptr->v_samp_factor;
300
6.50k
    else {
301
      /* NB: can't use last_row_height here; it is input-side-dependent! */
302
6.50k
      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
303
6.50k
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
304
6.50k
    }
305
859k
    inverse_DCT = cinfo->idct->inverse_DCT[ci];
306
859k
    output_ptr = output_buf[ci];
307
    /* Loop over all DCT blocks to be processed. */
308
2.68M
    for (block_row = 0; block_row < block_rows; block_row++) {
309
1.82M
      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
310
1.82M
      output_col = 0;
311
1.82M
      for (block_num = cinfo->master->first_MCU_col[ci];
312
42.0M
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
313
40.2M
        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)buffer_ptr, output_ptr,
314
40.2M
                        output_col);
315
40.2M
        buffer_ptr++;
316
40.2M
        output_col += compptr->_DCT_scaled_size;
317
40.2M
      }
318
1.82M
      output_ptr += compptr->_DCT_scaled_size;
319
1.82M
    }
320
859k
  }
321
322
313k
  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
323
311k
    return JPEG_ROW_COMPLETED;
324
2.25k
  return JPEG_SCAN_COMPLETED;
325
313k
}
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
169k
#define Q01_POS  1
341
169k
#define Q10_POS  8
342
169k
#define Q20_POS  16
343
169k
#define Q11_POS  9
344
169k
#define Q02_POS  2
345
63.3k
#define Q03_POS  3
346
63.3k
#define Q12_POS  10
347
63.3k
#define Q21_POS  17
348
63.3k
#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
3.26k
{
361
3.26k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
362
3.26k
  boolean smoothing_useful = FALSE;
363
3.26k
  int ci, coefi;
364
3.26k
  jpeg_component_info *compptr;
365
3.26k
  JQUANT_TBL *qtable;
366
3.26k
  int *coef_bits, *prev_coef_bits;
367
3.26k
  int *coef_bits_latch, *prev_coef_bits_latch;
368
369
3.26k
  if (!cinfo->progressive_mode || cinfo->coef_bits == NULL)
370
2.32k
    return FALSE;
371
372
  /* Allocate latch area if not already done */
373
945
  if (coef->coef_bits_latch == NULL)
374
945
    coef->coef_bits_latch = (int *)
375
945
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
376
945
                                  cinfo->num_components * 2 *
377
945
                                  (SAVED_COEFS * sizeof(int)));
378
945
  coef_bits_latch = coef->coef_bits_latch;
379
945
  prev_coef_bits_latch =
380
945
    &coef->coef_bits_latch[cinfo->num_components * SAVED_COEFS];
381
382
1.63k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
383
1.20k
       ci++, compptr++) {
384
    /* All components' quantization values must already be latched. */
385
1.20k
    if ((qtable = compptr->quant_table) == NULL)
386
326
      return FALSE;
387
    /* Verify DC & first 9 AC quantizers are nonzero to avoid zero-divide. */
388
877
    if (qtable->quantval[0] == 0 ||
389
877
        qtable->quantval[Q01_POS] == 0 ||
390
877
        qtable->quantval[Q10_POS] == 0 ||
391
877
        qtable->quantval[Q20_POS] == 0 ||
392
877
        qtable->quantval[Q11_POS] == 0 ||
393
877
        qtable->quantval[Q02_POS] == 0 ||
394
877
        qtable->quantval[Q03_POS] == 0 ||
395
877
        qtable->quantval[Q12_POS] == 0 ||
396
877
        qtable->quantval[Q21_POS] == 0 ||
397
877
        qtable->quantval[Q30_POS] == 0)
398
134
      return FALSE;
399
    /* DC values must be at least partly known for all components. */
400
743
    coef_bits = cinfo->coef_bits[ci];
401
743
    prev_coef_bits = cinfo->coef_bits[ci + cinfo->num_components];
402
743
    if (coef_bits[0] < 0)
403
57
      return FALSE;
404
686
    coef_bits_latch[0] = coef_bits[0];
405
    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
406
6.86k
    for (coefi = 1; coefi < SAVED_COEFS; coefi++) {
407
6.17k
      if (cinfo->input_scan_number > 1)
408
4.05k
        prev_coef_bits_latch[coefi] = prev_coef_bits[coefi];
409
2.12k
      else
410
2.12k
        prev_coef_bits_latch[coefi] = -1;
411
6.17k
      coef_bits_latch[coefi] = coef_bits[coefi];
412
6.17k
      if (coef_bits[coefi] != 0)
413
5.85k
        smoothing_useful = TRUE;
414
6.17k
    }
415
686
    coef_bits_latch += SAVED_COEFS;
416
686
    prev_coef_bits_latch += SAVED_COEFS;
417
686
  }
418
419
428
  return smoothing_useful;
420
945
}
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
140k
{
430
140k
  my_coef_ptr coef = (my_coef_ptr)cinfo->coef;
431
140k
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
432
140k
  JDIMENSION block_num, last_block_column;
433
140k
  int ci, block_row, block_rows, access_rows;
434
140k
  JBLOCKARRAY buffer;
435
140k
  JBLOCKROW buffer_ptr, prev_prev_block_row, prev_block_row;
436
140k
  JBLOCKROW next_block_row, next_next_block_row;
437
140k
  JSAMPARRAY output_ptr;
438
140k
  JDIMENSION output_col;
439
140k
  jpeg_component_info *compptr;
440
140k
  inverse_DCT_method_ptr inverse_DCT;
441
140k
  boolean change_dc;
442
140k
  JCOEF *workspace;
443
140k
  int *coef_bits;
444
140k
  JQUANT_TBL *quanttbl;
445
140k
  JLONG Q00, Q01, Q02, Q03 = 0, Q10, Q11, Q12 = 0, Q20, Q21 = 0, Q30 = 0, num;
446
140k
  int DC01, DC02, DC03, DC04, DC05, DC06, DC07, DC08, DC09, DC10, DC11, DC12,
447
140k
      DC13, DC14, DC15, DC16, DC17, DC18, DC19, DC20, DC21, DC22, DC23, DC24,
448
140k
      DC25;
449
140k
  int Al, pred;
450
451
  /* Keep a local variable to avoid looking it up more than once */
452
140k
  workspace = coef->workspace;
453
454
  /* Force some input to be done if we are getting ahead of the input. */
455
140k
  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
456
140k
         !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
309k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
473
168k
       ci++, compptr++) {
474
    /* Don't bother to IDCT an uninteresting component. */
475
168k
    if (!compptr->component_needed)
476
0
      continue;
477
    /* Count non-dummy DCT block rows in this iMCU row. */
478
168k
    if (cinfo->output_iMCU_row + 1 < last_iMCU_row) {
479
167k
      block_rows = compptr->v_samp_factor;
480
167k
      access_rows = block_rows * 3; /* this and next two iMCU rows */
481
167k
    } else if (cinfo->output_iMCU_row < last_iMCU_row) {
482
612
      block_rows = compptr->v_samp_factor;
483
612
      access_rows = block_rows * 2; /* this and next iMCU row */
484
670
    } else {
485
      /* NB: can't use last_row_height here; it is input-side-dependent! */
486
670
      block_rows = (int)(compptr->height_in_blocks % compptr->v_samp_factor);
487
670
      if (block_rows == 0) block_rows = compptr->v_samp_factor;
488
670
      access_rows = block_rows; /* this iMCU row only */
489
670
    }
490
    /* Align the virtual buffer for this component. */
491
168k
    if (cinfo->output_iMCU_row > 1) {
492
167k
      access_rows += 2 * compptr->v_samp_factor; /* prior two iMCU rows too */
493
167k
      buffer = (*cinfo->mem->access_virt_barray)
494
167k
        ((j_common_ptr)cinfo, coef->whole_image[ci],
495
167k
         (cinfo->output_iMCU_row - 2) * compptr->v_samp_factor,
496
167k
         (JDIMENSION)access_rows, FALSE);
497
167k
      buffer += 2 * compptr->v_samp_factor; /* point to current iMCU row */
498
167k
    } else if (cinfo->output_iMCU_row > 0) {
499
612
      buffer = (*cinfo->mem->access_virt_barray)
500
612
        ((j_common_ptr)cinfo, coef->whole_image[ci],
501
612
         (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
502
612
         (JDIMENSION)access_rows, FALSE);
503
612
      buffer += compptr->v_samp_factor; /* point to current iMCU row */
504
670
    } else {
505
670
      buffer = (*cinfo->mem->access_virt_barray)
506
670
        ((j_common_ptr)cinfo, coef->whole_image[ci],
507
670
         (JDIMENSION)0, (JDIMENSION)access_rows, FALSE);
508
670
    }
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
168k
    if (cinfo->output_iMCU_row > cinfo->master->last_good_iMCU_row)
514
34.0k
      coef_bits =
515
34.0k
        coef->coef_bits_latch + ((ci + cinfo->num_components) * SAVED_COEFS);
516
134k
    else
517
134k
      coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
518
519
    /* We only do DC interpolation if no AC coefficient data is available. */
520
168k
    change_dc =
521
168k
      coef_bits[1] == -1 && coef_bits[2] == -1 && coef_bits[3] == -1 &&
522
168k
      coef_bits[4] == -1 && coef_bits[5] == -1 && coef_bits[6] == -1 &&
523
168k
      coef_bits[7] == -1 && coef_bits[8] == -1 && coef_bits[9] == -1;
524
525
168k
    quanttbl = compptr->quant_table;
526
168k
    Q00 = quanttbl->quantval[0];
527
168k
    Q01 = quanttbl->quantval[Q01_POS];
528
168k
    Q10 = quanttbl->quantval[Q10_POS];
529
168k
    Q20 = quanttbl->quantval[Q20_POS];
530
168k
    Q11 = quanttbl->quantval[Q11_POS];
531
168k
    Q02 = quanttbl->quantval[Q02_POS];
532
168k
    if (change_dc) {
533
62.5k
      Q03 = quanttbl->quantval[Q03_POS];
534
62.5k
      Q12 = quanttbl->quantval[Q12_POS];
535
62.5k
      Q21 = quanttbl->quantval[Q21_POS];
536
62.5k
      Q30 = quanttbl->quantval[Q30_POS];
537
62.5k
    }
538
168k
    inverse_DCT = cinfo->idct->inverse_DCT[ci];
539
168k
    output_ptr = output_buf[ci];
540
    /* Loop over all DCT blocks to be processed. */
541
485k
    for (block_row = 0; block_row < block_rows; block_row++) {
542
316k
      buffer_ptr = buffer[block_row] + cinfo->master->first_MCU_col[ci];
543
544
316k
      if (block_row > 0 || cinfo->output_iMCU_row > 0)
545
315k
        prev_block_row =
546
315k
          buffer[block_row - 1] + cinfo->master->first_MCU_col[ci];
547
670
      else
548
670
        prev_block_row = buffer_ptr;
549
550
316k
      if (block_row > 1 || cinfo->output_iMCU_row > 1)
551
313k
        prev_prev_block_row =
552
313k
          buffer[block_row - 2] + cinfo->master->first_MCU_col[ci];
553
2.11k
      else
554
2.11k
        prev_prev_block_row = prev_block_row;
555
556
316k
      if (block_row < block_rows - 1 || cinfo->output_iMCU_row < last_iMCU_row)
557
315k
        next_block_row =
558
315k
          buffer[block_row + 1] + cinfo->master->first_MCU_col[ci];
559
670
      else
560
670
        next_block_row = buffer_ptr;
561
562
316k
      if (block_row < block_rows - 2 ||
563
316k
          cinfo->output_iMCU_row + 1 < last_iMCU_row)
564
314k
        next_next_block_row =
565
314k
          buffer[block_row + 2] + cinfo->master->first_MCU_col[ci];
566
1.97k
      else
567
1.97k
        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
316k
      DC01 = DC02 = DC03 = DC04 = DC05 = (int)prev_prev_block_row[0][0];
573
316k
      DC06 = DC07 = DC08 = DC09 = DC10 = (int)prev_block_row[0][0];
574
316k
      DC11 = DC12 = DC13 = DC14 = DC15 = (int)buffer_ptr[0][0];
575
316k
      DC16 = DC17 = DC18 = DC19 = DC20 = (int)next_block_row[0][0];
576
316k
      DC21 = DC22 = DC23 = DC24 = DC25 = (int)next_next_block_row[0][0];
577
316k
      output_col = 0;
578
316k
      last_block_column = compptr->width_in_blocks - 1;
579
316k
      for (block_num = cinfo->master->first_MCU_col[ci];
580
1.03M
           block_num <= cinfo->master->last_MCU_col[ci]; block_num++) {
581
        /* Fetch current DCT block into workspace so we can modify it. */
582
715k
        jcopy_block_row(buffer_ptr, (JBLOCKROW)workspace, (JDIMENSION)1);
583
        /* Update DC values */
584
715k
        if (block_num == cinfo->master->first_MCU_col[ci] &&
585
715k
            block_num < last_block_column) {
586
74.6k
          DC04 = (int)prev_prev_block_row[1][0];
587
74.6k
          DC09 = (int)prev_block_row[1][0];
588
74.6k
          DC14 = (int)buffer_ptr[1][0];
589
74.6k
          DC19 = (int)next_block_row[1][0];
590
74.6k
          DC24 = (int)next_next_block_row[1][0];
591
74.6k
        }
592
715k
        if (block_num + 1 < last_block_column) {
593
325k
          DC05 = (int)prev_prev_block_row[2][0];
594
325k
          DC10 = (int)prev_block_row[2][0];
595
325k
          DC15 = (int)buffer_ptr[2][0];
596
325k
          DC20 = (int)next_block_row[2][0];
597
325k
          DC25 = (int)next_next_block_row[2][0];
598
325k
        }
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
715k
        if ((Al = coef_bits[1]) != 0 && workspace[1] == 0) {
611
633k
          num = Q00 * (change_dc ?
612
331k
                (-DC01 - DC02 + DC04 + DC05 - 3 * DC06 + 13 * DC07 -
613
331k
                 13 * DC09 + 3 * DC10 - 3 * DC11 + 38 * DC12 - 38 * DC14 +
614
331k
                 3 * DC15 - 3 * DC16 + 13 * DC17 - 13 * DC19 + 3 * DC20 -
615
331k
                 DC21 - DC22 + DC24 + DC25) :
616
633k
                (-7 * DC11 + 50 * DC12 - 50 * DC14 + 7 * DC15));
617
633k
          if (num >= 0) {
618
507k
            pred = (int)(((Q01 << 7) + num) / (Q01 << 8));
619
507k
            if (Al > 0 && pred >= (1 << Al))
620
26.0k
              pred = (1 << Al) - 1;
621
507k
          } else {
622
125k
            pred = (int)(((Q01 << 7) - num) / (Q01 << 8));
623
125k
            if (Al > 0 && pred >= (1 << Al))
624
20.4k
              pred = (1 << Al) - 1;
625
125k
            pred = -pred;
626
125k
          }
627
633k
          workspace[1] = (JCOEF)pred;
628
633k
        }
629
        /* AC10 */
630
715k
        if ((Al = coef_bits[2]) != 0 && workspace[8] == 0) {
631
645k
          num = Q00 * (change_dc ?
632
331k
                (-DC01 - 3 * DC02 - 3 * DC03 - 3 * DC04 - DC05 - DC06 +
633
331k
                 13 * DC07 + 38 * DC08 + 13 * DC09 - DC10 + DC16 -
634
331k
                 13 * DC17 - 38 * DC18 - 13 * DC19 + DC20 + DC21 +
635
331k
                 3 * DC22 + 3 * DC23 + 3 * DC24 + DC25) :
636
645k
                (-7 * DC03 + 50 * DC08 - 50 * DC18 + 7 * DC23));
637
645k
          if (num >= 0) {
638
466k
            pred = (int)(((Q10 << 7) + num) / (Q10 << 8));
639
466k
            if (Al > 0 && pred >= (1 << Al))
640
44.5k
              pred = (1 << Al) - 1;
641
466k
          } else {
642
179k
            pred = (int)(((Q10 << 7) - num) / (Q10 << 8));
643
179k
            if (Al > 0 && pred >= (1 << Al))
644
32.1k
              pred = (1 << Al) - 1;
645
179k
            pred = -pred;
646
179k
          }
647
645k
          workspace[8] = (JCOEF)pred;
648
645k
        }
649
        /* AC20 */
650
715k
        if ((Al = coef_bits[3]) != 0 && workspace[16] == 0) {
651
646k
          num = Q00 * (change_dc ?
652
331k
                (DC03 + 2 * DC07 + 7 * DC08 + 2 * DC09 - 5 * DC12 - 14 * DC13 -
653
331k
                 5 * DC14 + 2 * DC17 + 7 * DC18 + 2 * DC19 + DC23) :
654
646k
                (-DC03 + 13 * DC08 - 24 * DC13 + 13 * DC18 - DC23));
655
646k
          if (num >= 0) {
656
387k
            pred = (int)(((Q20 << 7) + num) / (Q20 << 8));
657
387k
            if (Al > 0 && pred >= (1 << Al))
658
31.5k
              pred = (1 << Al) - 1;
659
387k
          } else {
660
258k
            pred = (int)(((Q20 << 7) - num) / (Q20 << 8));
661
258k
            if (Al > 0 && pred >= (1 << Al))
662
29.1k
              pred = (1 << Al) - 1;
663
258k
            pred = -pred;
664
258k
          }
665
646k
          workspace[16] = (JCOEF)pred;
666
646k
        }
667
        /* AC11 */
668
715k
        if ((Al = coef_bits[4]) != 0 && workspace[9] == 0) {
669
656k
          num = Q00 * (change_dc ?
670
331k
                (-DC01 + DC05 + 9 * DC07 - 9 * DC09 - 9 * DC17 +
671
331k
                 9 * DC19 + DC21 - DC25) :
672
656k
                (DC10 + DC16 - 10 * DC17 + 10 * DC19 - DC02 - DC20 + DC22 -
673
324k
                 DC24 + DC04 - DC06 + 10 * DC07 - 10 * DC09));
674
656k
          if (num >= 0) {
675
528k
            pred = (int)(((Q11 << 7) + num) / (Q11 << 8));
676
528k
            if (Al > 0 && pred >= (1 << Al))
677
23.3k
              pred = (1 << Al) - 1;
678
528k
          } else {
679
127k
            pred = (int)(((Q11 << 7) - num) / (Q11 << 8));
680
127k
            if (Al > 0 && pred >= (1 << Al))
681
23.1k
              pred = (1 << Al) - 1;
682
127k
            pred = -pred;
683
127k
          }
684
656k
          workspace[9] = (JCOEF)pred;
685
656k
        }
686
        /* AC02 */
687
715k
        if ((Al = coef_bits[5]) != 0 && workspace[2] == 0) {
688
628k
          num = Q00 * (change_dc ?
689
331k
                (2 * DC07 - 5 * DC08 + 2 * DC09 + DC11 + 7 * DC12 - 14 * DC13 +
690
331k
                 7 * DC14 + DC15 + 2 * DC17 - 5 * DC18 + 2 * DC19) :
691
628k
                (-DC11 + 13 * DC12 - 24 * DC13 + 13 * DC14 - DC15));
692
628k
          if (num >= 0) {
693
439k
            pred = (int)(((Q02 << 7) + num) / (Q02 << 8));
694
439k
            if (Al > 0 && pred >= (1 << Al))
695
26.3k
              pred = (1 << Al) - 1;
696
439k
          } else {
697
189k
            pred = (int)(((Q02 << 7) - num) / (Q02 << 8));
698
189k
            if (Al > 0 && pred >= (1 << Al))
699
26.0k
              pred = (1 << Al) - 1;
700
189k
            pred = -pred;
701
189k
          }
702
628k
          workspace[2] = (JCOEF)pred;
703
628k
        }
704
715k
        if (change_dc) {
705
          /* AC03 */
706
331k
          if ((Al = coef_bits[6]) != 0 && workspace[3] == 0) {
707
330k
            num = Q00 * (DC07 - DC09 + 2 * DC12 - 2 * DC14 + DC17 - DC19);
708
330k
            if (num >= 0) {
709
259k
              pred = (int)(((Q03 << 7) + num) / (Q03 << 8));
710
259k
              if (Al > 0 && pred >= (1 << Al))
711
0
                pred = (1 << Al) - 1;
712
259k
            } else {
713
70.9k
              pred = (int)(((Q03 << 7) - num) / (Q03 << 8));
714
70.9k
              if (Al > 0 && pred >= (1 << Al))
715
0
                pred = (1 << Al) - 1;
716
70.9k
              pred = -pred;
717
70.9k
            }
718
330k
            workspace[3] = (JCOEF)pred;
719
330k
          }
720
          /* AC12 */
721
331k
          if ((Al = coef_bits[7]) != 0 && workspace[10] == 0) {
722
330k
            num = Q00 * (DC07 - 3 * DC08 + DC09 - DC17 + 3 * DC18 - DC19);
723
330k
            if (num >= 0) {
724
220k
              pred = (int)(((Q12 << 7) + num) / (Q12 << 8));
725
220k
              if (Al > 0 && pred >= (1 << Al))
726
0
                pred = (1 << Al) - 1;
727
220k
            } else {
728
110k
              pred = (int)(((Q12 << 7) - num) / (Q12 << 8));
729
110k
              if (Al > 0 && pred >= (1 << Al))
730
0
                pred = (1 << Al) - 1;
731
110k
              pred = -pred;
732
110k
            }
733
330k
            workspace[10] = (JCOEF)pred;
734
330k
          }
735
          /* AC21 */
736
331k
          if ((Al = coef_bits[8]) != 0 && workspace[17] == 0) {
737
330k
            num = Q00 * (DC07 - DC09 - 3 * DC12 + 3 * DC14 + DC17 - DC19);
738
330k
            if (num >= 0) {
739
233k
              pred = (int)(((Q21 << 7) + num) / (Q21 << 8));
740
233k
              if (Al > 0 && pred >= (1 << Al))
741
0
                pred = (1 << Al) - 1;
742
233k
            } else {
743
96.9k
              pred = (int)(((Q21 << 7) - num) / (Q21 << 8));
744
96.9k
              if (Al > 0 && pred >= (1 << Al))
745
0
                pred = (1 << Al) - 1;
746
96.9k
              pred = -pred;
747
96.9k
            }
748
330k
            workspace[17] = (JCOEF)pred;
749
330k
          }
750
          /* AC30 */
751
331k
          if ((Al = coef_bits[9]) != 0 && workspace[24] == 0) {
752
331k
            num = Q00 * (DC07 + 2 * DC08 + DC09 - DC17 - 2 * DC18 - DC19);
753
331k
            if (num >= 0) {
754
264k
              pred = (int)(((Q30 << 7) + num) / (Q30 << 8));
755
264k
              if (Al > 0 && pred >= (1 << Al))
756
0
                pred = (1 << Al) - 1;
757
264k
            } else {
758
66.2k
              pred = (int)(((Q30 << 7) - num) / (Q30 << 8));
759
66.2k
              if (Al > 0 && pred >= (1 << Al))
760
0
                pred = (1 << Al) - 1;
761
66.2k
              pred = -pred;
762
66.2k
            }
763
331k
            workspace[24] = (JCOEF)pred;
764
331k
          }
765
          /* coef_bits[0] is non-negative.  Otherwise this function would not
766
           * be called.
767
           */
768
331k
          num = Q00 *
769
331k
                (-2 * DC01 - 6 * DC02 - 8 * DC03 - 6 * DC04 - 2 * DC05 -
770
331k
                 6 * DC06 + 6 * DC07 + 42 * DC08 + 6 * DC09 - 6 * DC10 -
771
331k
                 8 * DC11 + 42 * DC12 + 152 * DC13 + 42 * DC14 - 8 * DC15 -
772
331k
                 6 * DC16 + 6 * DC17 + 42 * DC18 + 6 * DC19 - 6 * DC20 -
773
331k
                 2 * DC21 - 6 * DC22 - 8 * DC23 - 6 * DC24 - 2 * DC25);
774
331k
          if (num >= 0) {
775
207k
            pred = (int)(((Q00 << 7) + num) / (Q00 << 8));
776
207k
          } else {
777
123k
            pred = (int)(((Q00 << 7) - num) / (Q00 << 8));
778
123k
            pred = -pred;
779
123k
          }
780
331k
          workspace[0] = (JCOEF)pred;
781
331k
        }  /* change_dc */
782
783
        /* OK, do the IDCT */
784
715k
        (*inverse_DCT) (cinfo, compptr, (JCOEFPTR)workspace, output_ptr,
785
715k
                        output_col);
786
        /* Advance for next column */
787
715k
        DC01 = DC02;  DC02 = DC03;  DC03 = DC04;  DC04 = DC05;
788
715k
        DC06 = DC07;  DC07 = DC08;  DC08 = DC09;  DC09 = DC10;
789
715k
        DC11 = DC12;  DC12 = DC13;  DC13 = DC14;  DC14 = DC15;
790
715k
        DC16 = DC17;  DC17 = DC18;  DC18 = DC19;  DC19 = DC20;
791
715k
        DC21 = DC22;  DC22 = DC23;  DC23 = DC24;  DC24 = DC25;
792
715k
        buffer_ptr++, prev_block_row++, next_block_row++,
793
715k
          prev_prev_block_row++, next_next_block_row++;
794
715k
        output_col += compptr->_DCT_scaled_size;
795
715k
      }
796
316k
      output_ptr += compptr->_DCT_scaled_size;
797
316k
    }
798
168k
  }
799
800
140k
  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
801
140k
    return JPEG_ROW_COMPLETED;
802
428
  return JPEG_SCAN_COMPLETED;
803
140k
}
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
6.65k
{
815
6.65k
  my_coef_ptr coef;
816
817
6.65k
  coef = (my_coef_ptr)
818
6.65k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
819
6.65k
                                sizeof(my_coef_controller));
820
6.65k
  cinfo->coef = (struct jpeg_d_coef_controller *)coef;
821
6.65k
  coef->pub.start_input_pass = start_input_pass;
822
6.65k
  coef->pub.start_output_pass = start_output_pass;
823
6.65k
#ifdef BLOCK_SMOOTHING_SUPPORTED
824
6.65k
  coef->coef_bits_latch = NULL;
825
6.65k
#endif
826
827
  /* Create the coefficient buffer. */
828
6.65k
  if (need_full_buffer) {
829
5.92k
#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
5.92k
    int ci, access_rows;
834
5.92k
    jpeg_component_info *compptr;
835
836
21.7k
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
837
15.8k
         ci++, compptr++) {
838
15.8k
      access_rows = compptr->v_samp_factor;
839
15.8k
#ifdef BLOCK_SMOOTHING_SUPPORTED
840
      /* If block smoothing could be used, need a bigger window */
841
15.8k
      if (cinfo->progressive_mode)
842
5.90k
        access_rows *= 5;
843
15.8k
#endif
844
15.8k
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
845
15.8k
        ((j_common_ptr)cinfo, JPOOL_IMAGE, TRUE,
846
15.8k
         (JDIMENSION)jround_up((long)compptr->width_in_blocks,
847
15.8k
                               (long)compptr->h_samp_factor),
848
15.8k
         (JDIMENSION)jround_up((long)compptr->height_in_blocks,
849
15.8k
                               (long)compptr->v_samp_factor),
850
15.8k
         (JDIMENSION)access_rows);
851
15.8k
    }
852
5.92k
    coef->pub.consume_data = consume_data;
853
5.92k
    coef->pub.decompress_data = decompress_data;
854
5.92k
    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
855
#else
856
    ERREXIT(cinfo, JERR_NOT_COMPILED);
857
#endif
858
5.92k
  } else {
859
    /* We only need a single-MCU buffer. */
860
723
    JBLOCKROW buffer;
861
723
    int i;
862
863
723
    buffer = (JBLOCKROW)
864
723
      (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
865
723
                                  D_MAX_BLOCKS_IN_MCU * sizeof(JBLOCK));
866
7.95k
    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
867
7.23k
      coef->MCU_buffer[i] = buffer + i;
868
7.23k
    }
869
723
    coef->pub.consume_data = dummy_consume_data;
870
723
    coef->pub.decompress_data = decompress_onepass;
871
723
    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
872
723
  }
873
874
  /* Allocate the workspace buffer */
875
6.65k
  coef->workspace = (JCOEF *)
876
6.65k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
877
6.65k
                                sizeof(JCOEF) * DCTSIZE2);
878
6.65k
}