Coverage Report

Created: 2023-06-07 06:03

/src/libjpeg-turbo.main/jddctmgr.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * jddctmgr.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1994-1996, Thomas G. Lane.
6
 * Modified 2002-2010 by Guido Vollbeding.
7
 * libjpeg-turbo Modifications:
8
 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
9
 * Copyright (C) 2010, 2015, 2022, D. R. Commander.
10
 * Copyright (C) 2013, MIPS Technologies, Inc., California.
11
 * For conditions of distribution and use, see the accompanying README.ijg
12
 * file.
13
 *
14
 * This file contains the inverse-DCT management logic.
15
 * This code selects a particular IDCT implementation to be used,
16
 * and it performs related housekeeping chores.  No code in this file
17
 * is executed per IDCT step, only during output pass setup.
18
 *
19
 * Note that the IDCT routines are responsible for performing coefficient
20
 * dequantization as well as the IDCT proper.  This module sets up the
21
 * dequantization multiplier table needed by the IDCT routine.
22
 */
23
24
#define JPEG_INTERNALS
25
#include "jinclude.h"
26
#include "jpeglib.h"
27
#include "jdct.h"               /* Private declarations for DCT subsystem */
28
#include "jsimddct.h"
29
#include "jpegapicomp.h"
30
31
32
/*
33
 * The decompressor input side (jdinput.c) saves away the appropriate
34
 * quantization table for each component at the start of the first scan
35
 * involving that component.  (This is necessary in order to correctly
36
 * decode files that reuse Q-table slots.)
37
 * When we are ready to make an output pass, the saved Q-table is converted
38
 * to a multiplier table that will actually be used by the IDCT routine.
39
 * The multiplier table contents are IDCT-method-dependent.  To support
40
 * application changes in IDCT method between scans, we can remake the
41
 * multiplier tables if necessary.
42
 * In buffered-image mode, the first output pass may occur before any data
43
 * has been seen for some components, and thus before their Q-tables have
44
 * been saved away.  To handle this case, multiplier tables are preset
45
 * to zeroes; the result of the IDCT will be a neutral gray level.
46
 */
47
48
49
/* Private subobject for this module */
50
51
typedef struct {
52
  struct jpeg_inverse_dct pub;  /* public fields */
53
54
  /* This array contains the IDCT method code that each multiplier table
55
   * is currently set up for, or -1 if it's not yet set up.
56
   * The actual multiplier tables are pointed to by dct_table in the
57
   * per-component comp_info structures.
58
   */
59
  int cur_method[MAX_COMPONENTS];
60
} my_idct_controller;
61
62
typedef my_idct_controller *my_idct_ptr;
63
64
65
/* Allocated multiplier tables: big enough for any supported variant */
66
67
typedef union {
68
  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
69
#ifdef DCT_IFAST_SUPPORTED
70
  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
71
#endif
72
#ifdef DCT_FLOAT_SUPPORTED
73
  FLOAT_MULT_TYPE float_array[DCTSIZE2];
74
#endif
75
} multiplier_table;
76
77
78
/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
79
 * so be sure to compile that code if either ISLOW or SCALING is requested.
80
 */
81
#ifdef DCT_ISLOW_SUPPORTED
82
#define PROVIDE_ISLOW_TABLES
83
#else
84
#ifdef IDCT_SCALING_SUPPORTED
85
#define PROVIDE_ISLOW_TABLES
86
#endif
87
#endif
88
89
90
/*
91
 * Prepare for an output pass.
92
 * Here we select the proper IDCT routine for each component and build
93
 * a matching multiplier table.
94
 */
95
96
METHODDEF(void)
97
start_pass(j_decompress_ptr cinfo)
98
280
{
99
280
  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
100
280
  int ci, i;
101
280
  jpeg_component_info *compptr;
102
280
  int method = 0;
103
280
  _inverse_DCT_method_ptr method_ptr = NULL;
104
280
  JQUANT_TBL *qtbl;
105
106
744
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
107
464
       ci++, compptr++) {
108
    /* Select the proper IDCT routine for this component's scaling */
109
464
    switch (compptr->_DCT_scaled_size) {
110
0
#ifdef IDCT_SCALING_SUPPORTED
111
0
    case 1:
112
0
      method_ptr = _jpeg_idct_1x1;
113
0
      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
114
0
      break;
115
0
    case 2:
116
#ifdef WITH_SIMD
117
      if (jsimd_can_idct_2x2())
118
        method_ptr = jsimd_idct_2x2;
119
      else
120
#endif
121
0
        method_ptr = _jpeg_idct_2x2;
122
0
      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
123
0
      break;
124
0
    case 3:
125
0
      method_ptr = _jpeg_idct_3x3;
126
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
127
0
      break;
128
0
    case 4:
129
#ifdef WITH_SIMD
130
      if (jsimd_can_idct_4x4())
131
        method_ptr = jsimd_idct_4x4;
132
      else
133
#endif
134
0
        method_ptr = _jpeg_idct_4x4;
135
0
      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
136
0
      break;
137
0
    case 5:
138
0
      method_ptr = _jpeg_idct_5x5;
139
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
140
0
      break;
141
0
    case 6:
142
#if defined(WITH_SIMD) && defined(__mips__)
143
      if (jsimd_can_idct_6x6())
144
        method_ptr = jsimd_idct_6x6;
145
      else
146
#endif
147
0
      method_ptr = _jpeg_idct_6x6;
148
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
149
0
      break;
150
0
    case 7:
151
0
      method_ptr = _jpeg_idct_7x7;
152
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
153
0
      break;
154
0
#endif
155
464
    case DCTSIZE:
156
464
      switch (cinfo->dct_method) {
157
0
#ifdef DCT_ISLOW_SUPPORTED
158
0
      case JDCT_ISLOW:
159
#ifdef WITH_SIMD
160
        if (jsimd_can_idct_islow())
161
          method_ptr = jsimd_idct_islow;
162
        else
163
#endif
164
0
          method_ptr = _jpeg_idct_islow;
165
0
        method = JDCT_ISLOW;
166
0
        break;
167
0
#endif
168
0
#ifdef DCT_IFAST_SUPPORTED
169
464
      case JDCT_IFAST:
170
#ifdef WITH_SIMD
171
        if (jsimd_can_idct_ifast())
172
          method_ptr = jsimd_idct_ifast;
173
        else
174
#endif
175
464
          method_ptr = _jpeg_idct_ifast;
176
464
        method = JDCT_IFAST;
177
464
        break;
178
0
#endif
179
0
#ifdef DCT_FLOAT_SUPPORTED
180
0
      case JDCT_FLOAT:
181
#ifdef WITH_SIMD
182
        if (jsimd_can_idct_float())
183
          method_ptr = jsimd_idct_float;
184
        else
185
#endif
186
0
          method_ptr = _jpeg_idct_float;
187
0
        method = JDCT_FLOAT;
188
0
        break;
189
0
#endif
190
0
      default:
191
0
        ERREXIT(cinfo, JERR_NOT_COMPILED);
192
0
        break;
193
464
      }
194
464
      break;
195
464
#ifdef IDCT_SCALING_SUPPORTED
196
464
    case 9:
197
0
      method_ptr = _jpeg_idct_9x9;
198
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
199
0
      break;
200
0
    case 10:
201
0
      method_ptr = _jpeg_idct_10x10;
202
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
203
0
      break;
204
0
    case 11:
205
0
      method_ptr = _jpeg_idct_11x11;
206
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
207
0
      break;
208
0
    case 12:
209
#if defined(WITH_SIMD) && defined(__mips__)
210
      if (jsimd_can_idct_12x12())
211
        method_ptr = jsimd_idct_12x12;
212
      else
213
#endif
214
0
      method_ptr = _jpeg_idct_12x12;
215
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
216
0
      break;
217
0
    case 13:
218
0
      method_ptr = _jpeg_idct_13x13;
219
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
220
0
      break;
221
0
    case 14:
222
0
      method_ptr = _jpeg_idct_14x14;
223
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
224
0
      break;
225
0
    case 15:
226
0
      method_ptr = _jpeg_idct_15x15;
227
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
228
0
      break;
229
0
    case 16:
230
0
      method_ptr = _jpeg_idct_16x16;
231
0
      method = JDCT_ISLOW;      /* jidctint uses islow-style table */
232
0
      break;
233
0
#endif
234
0
    default:
235
0
      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->_DCT_scaled_size);
236
0
      break;
237
464
    }
238
464
    idct->pub._inverse_DCT[ci] = method_ptr;
239
    /* Create multiplier table from quant table.
240
     * However, we can skip this if the component is uninteresting
241
     * or if we already built the table.  Also, if no quant table
242
     * has yet been saved for the component, we leave the
243
     * multiplier table all-zero; we'll be reading zeroes from the
244
     * coefficient controller's buffer anyway.
245
     */
246
464
    if (!compptr->component_needed || idct->cur_method[ci] == method)
247
0
      continue;
248
464
    qtbl = compptr->quant_table;
249
464
    if (qtbl == NULL)           /* happens if no data yet for component */
250
96
      continue;
251
368
    idct->cur_method[ci] = method;
252
368
    switch (method) {
253
0
#ifdef PROVIDE_ISLOW_TABLES
254
0
    case JDCT_ISLOW:
255
0
      {
256
        /* For LL&M IDCT method, multipliers are equal to raw quantization
257
         * coefficients, but are stored as ints to ensure access efficiency.
258
         */
259
0
        ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *)compptr->dct_table;
260
0
        for (i = 0; i < DCTSIZE2; i++) {
261
0
          ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
262
0
        }
263
0
      }
264
0
      break;
265
0
#endif
266
0
#ifdef DCT_IFAST_SUPPORTED
267
368
    case JDCT_IFAST:
268
368
      {
269
        /* For AA&N IDCT method, multipliers are equal to quantization
270
         * coefficients scaled by scalefactor[row]*scalefactor[col], where
271
         *   scalefactor[0] = 1
272
         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
273
         * For integer operation, the multiplier table is to be scaled by
274
         * IFAST_SCALE_BITS.
275
         */
276
368
        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
277
368
#define CONST_BITS  14
278
368
        static const INT16 aanscales[DCTSIZE2] = {
279
          /* precomputed values scaled up by 14 bits */
280
368
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
281
368
          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
282
368
          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
283
368
          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
284
368
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
285
368
          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
286
368
           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
287
368
           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
288
368
        };
289
368
        SHIFT_TEMPS
290
291
23.9k
        for (i = 0; i < DCTSIZE2; i++) {
292
23.5k
          ifmtbl[i] = (IFAST_MULT_TYPE)
293
23.5k
            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
294
23.5k
                                  (JLONG)aanscales[i]),
295
23.5k
                    CONST_BITS - IFAST_SCALE_BITS);
296
23.5k
        }
297
368
      }
298
368
      break;
299
0
#endif
300
0
#ifdef DCT_FLOAT_SUPPORTED
301
0
    case JDCT_FLOAT:
302
0
      {
303
        /* For float AA&N IDCT method, multipliers are equal to quantization
304
         * coefficients scaled by scalefactor[row]*scalefactor[col], where
305
         *   scalefactor[0] = 1
306
         *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
307
         */
308
0
        FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *)compptr->dct_table;
309
0
        int row, col;
310
0
        static const double aanscalefactor[DCTSIZE] = {
311
0
          1.0, 1.387039845, 1.306562965, 1.175875602,
312
0
          1.0, 0.785694958, 0.541196100, 0.275899379
313
0
        };
314
315
0
        i = 0;
316
0
        for (row = 0; row < DCTSIZE; row++) {
317
0
          for (col = 0; col < DCTSIZE; col++) {
318
0
            fmtbl[i] = (FLOAT_MULT_TYPE)
319
0
              ((double)qtbl->quantval[i] *
320
0
               aanscalefactor[row] * aanscalefactor[col]);
321
0
            i++;
322
0
          }
323
0
        }
324
0
      }
325
0
      break;
326
0
#endif
327
0
    default:
328
0
      ERREXIT(cinfo, JERR_NOT_COMPILED);
329
0
      break;
330
368
    }
331
368
  }
332
280
}
333
334
335
/*
336
 * Initialize IDCT manager.
337
 */
338
339
GLOBAL(void)
340
_jinit_inverse_dct(j_decompress_ptr cinfo)
341
4.19k
{
342
4.19k
  my_idct_ptr idct;
343
4.19k
  int ci;
344
4.19k
  jpeg_component_info *compptr;
345
346
4.19k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
4.19k
  idct = (my_idct_ptr)
350
4.19k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
4.19k
                                sizeof(my_idct_controller));
352
4.19k
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
4.19k
  idct->pub.start_pass = start_pass;
354
355
11.4k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
7.26k
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
7.26k
    compptr->dct_table =
359
7.26k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
7.26k
                                  sizeof(multiplier_table));
361
7.26k
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
7.26k
    idct->cur_method[ci] = -1;
364
7.26k
  }
365
4.19k
}
j12init_inverse_dct
Line
Count
Source
341
311
{
342
311
  my_idct_ptr idct;
343
311
  int ci;
344
311
  jpeg_component_info *compptr;
345
346
311
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
311
  idct = (my_idct_ptr)
350
311
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
311
                                sizeof(my_idct_controller));
352
311
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
311
  idct->pub.start_pass = start_pass;
354
355
842
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
531
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
531
    compptr->dct_table =
359
531
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
531
                                  sizeof(multiplier_table));
361
531
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
531
    idct->cur_method[ci] = -1;
364
531
  }
365
311
}
jinit_inverse_dct
Line
Count
Source
341
3.88k
{
342
3.88k
  my_idct_ptr idct;
343
3.88k
  int ci;
344
3.88k
  jpeg_component_info *compptr;
345
346
3.88k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
3.88k
  idct = (my_idct_ptr)
350
3.88k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
3.88k
                                sizeof(my_idct_controller));
352
3.88k
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
3.88k
  idct->pub.start_pass = start_pass;
354
355
10.6k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
6.73k
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
6.73k
    compptr->dct_table =
359
6.73k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
6.73k
                                  sizeof(multiplier_table));
361
6.73k
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
6.73k
    idct->cur_method[ci] = -1;
364
6.73k
  }
365
3.88k
}