Coverage Report

Created: 2024-06-18 06:05

/src/libjpeg-turbo/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
0
{
99
0
  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
100
0
  int ci, i;
101
0
  jpeg_component_info *compptr;
102
0
  int method = 0;
103
0
  _inverse_DCT_method_ptr method_ptr = NULL;
104
0
  JQUANT_TBL *qtbl;
105
106
0
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
107
0
       ci++, compptr++) {
108
    /* Select the proper IDCT routine for this component's scaling */
109
0
    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
0
    case DCTSIZE:
156
0
      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
0
      case JDCT_IFAST:
170
#ifdef WITH_SIMD
171
        if (jsimd_can_idct_ifast())
172
          method_ptr = jsimd_idct_ifast;
173
        else
174
#endif
175
0
          method_ptr = _jpeg_idct_ifast;
176
0
        method = JDCT_IFAST;
177
0
        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
0
      }
194
0
      break;
195
0
#ifdef IDCT_SCALING_SUPPORTED
196
0
    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
0
    }
238
0
    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
0
    if (!compptr->component_needed || idct->cur_method[ci] == method)
247
0
      continue;
248
0
    qtbl = compptr->quant_table;
249
0
    if (qtbl == NULL)           /* happens if no data yet for component */
250
0
      continue;
251
0
    idct->cur_method[ci] = method;
252
0
    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
0
    case JDCT_IFAST:
268
0
      {
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
0
        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
277
0
#define CONST_BITS  14
278
0
        static const INT16 aanscales[DCTSIZE2] = {
279
          /* precomputed values scaled up by 14 bits */
280
0
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
281
0
          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
282
0
          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
283
0
          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
284
0
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
285
0
          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
286
0
           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
287
0
           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
288
0
        };
289
0
        SHIFT_TEMPS
290
291
0
        for (i = 0; i < DCTSIZE2; i++) {
292
0
          ifmtbl[i] = (IFAST_MULT_TYPE)
293
0
            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
294
0
                                  (JLONG)aanscales[i]),
295
0
                    CONST_BITS - IFAST_SCALE_BITS);
296
0
        }
297
0
      }
298
0
      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
0
    }
331
0
  }
332
0
}
333
334
335
/*
336
 * Initialize IDCT manager.
337
 */
338
339
GLOBAL(void)
340
_jinit_inverse_dct(j_decompress_ptr cinfo)
341
0
{
342
0
  my_idct_ptr idct;
343
0
  int ci;
344
0
  jpeg_component_info *compptr;
345
346
0
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
0
  idct = (my_idct_ptr)
350
0
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
0
                                sizeof(my_idct_controller));
352
0
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
0
  idct->pub.start_pass = start_pass;
354
355
0
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
0
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
0
    compptr->dct_table =
359
0
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
0
                                  sizeof(multiplier_table));
361
0
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
0
    idct->cur_method[ci] = -1;
364
0
  }
365
0
}
Unexecuted instantiation: j12init_inverse_dct
Unexecuted instantiation: jinit_inverse_dct