Coverage Report

Created: 2024-01-20 12:28

/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
35.8k
{
99
35.8k
  my_idct_ptr idct = (my_idct_ptr)cinfo->idct;
100
35.8k
  int ci, i;
101
35.8k
  jpeg_component_info *compptr;
102
35.8k
  int method = 0;
103
35.8k
  _inverse_DCT_method_ptr method_ptr = NULL;
104
35.8k
  JQUANT_TBL *qtbl;
105
106
136k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
107
100k
       ci++, compptr++) {
108
    /* Select the proper IDCT routine for this component's scaling */
109
100k
    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
12.9k
    case 4:
129
#ifdef WITH_SIMD
130
      if (jsimd_can_idct_4x4())
131
        method_ptr = jsimd_idct_4x4;
132
      else
133
#endif
134
12.9k
        method_ptr = _jpeg_idct_4x4;
135
12.9k
      method = JDCT_ISLOW;      /* jidctred uses islow-style table */
136
12.9k
      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
87.6k
    case DCTSIZE:
156
87.6k
      switch (cinfo->dct_method) {
157
0
#ifdef DCT_ISLOW_SUPPORTED
158
29.8k
      case JDCT_ISLOW:
159
#ifdef WITH_SIMD
160
        if (jsimd_can_idct_islow())
161
          method_ptr = jsimd_idct_islow;
162
        else
163
#endif
164
29.8k
          method_ptr = _jpeg_idct_islow;
165
29.8k
        method = JDCT_ISLOW;
166
29.8k
        break;
167
0
#endif
168
0
#ifdef DCT_IFAST_SUPPORTED
169
57.7k
      case JDCT_IFAST:
170
#ifdef WITH_SIMD
171
        if (jsimd_can_idct_ifast())
172
          method_ptr = jsimd_idct_ifast;
173
        else
174
#endif
175
57.7k
          method_ptr = _jpeg_idct_ifast;
176
57.7k
        method = JDCT_IFAST;
177
57.7k
        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
87.6k
      }
194
87.6k
      break;
195
87.6k
#ifdef IDCT_SCALING_SUPPORTED
196
87.6k
    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
100k
    }
238
100k
    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
100k
    if (!compptr->component_needed || idct->cur_method[ci] == method)
247
10.5k
      continue;
248
90.0k
    qtbl = compptr->quant_table;
249
90.0k
    if (qtbl == NULL)           /* happens if no data yet for component */
250
2.68k
      continue;
251
87.3k
    idct->cur_method[ci] = method;
252
87.3k
    switch (method) {
253
0
#ifdef PROVIDE_ISLOW_TABLES
254
31.5k
    case JDCT_ISLOW:
255
31.5k
      {
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
31.5k
        ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *)compptr->dct_table;
260
2.04M
        for (i = 0; i < DCTSIZE2; i++) {
261
2.01M
          ismtbl[i] = (ISLOW_MULT_TYPE)qtbl->quantval[i];
262
2.01M
        }
263
31.5k
      }
264
31.5k
      break;
265
0
#endif
266
0
#ifdef DCT_IFAST_SUPPORTED
267
55.8k
    case JDCT_IFAST:
268
55.8k
      {
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
55.8k
        IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *)compptr->dct_table;
277
55.8k
#define CONST_BITS  14
278
55.8k
        static const INT16 aanscales[DCTSIZE2] = {
279
          /* precomputed values scaled up by 14 bits */
280
55.8k
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
281
55.8k
          22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
282
55.8k
          21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
283
55.8k
          19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
284
55.8k
          16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
285
55.8k
          12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
286
55.8k
           8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
287
55.8k
           4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
288
55.8k
        };
289
55.8k
        SHIFT_TEMPS
290
291
3.63M
        for (i = 0; i < DCTSIZE2; i++) {
292
3.57M
          ifmtbl[i] = (IFAST_MULT_TYPE)
293
3.57M
            DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
294
3.57M
                                  (JLONG)aanscales[i]),
295
3.57M
                    CONST_BITS - IFAST_SCALE_BITS);
296
3.57M
        }
297
55.8k
      }
298
55.8k
      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
87.3k
    }
331
87.3k
  }
332
35.8k
}
333
334
335
/*
336
 * Initialize IDCT manager.
337
 */
338
339
GLOBAL(void)
340
_jinit_inverse_dct(j_decompress_ptr cinfo)
341
88.1k
{
342
88.1k
  my_idct_ptr idct;
343
88.1k
  int ci;
344
88.1k
  jpeg_component_info *compptr;
345
346
88.1k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
88.1k
  idct = (my_idct_ptr)
350
88.1k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
88.1k
                                sizeof(my_idct_controller));
352
88.1k
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
88.1k
  idct->pub.start_pass = start_pass;
354
355
339k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
251k
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
251k
    compptr->dct_table =
359
251k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
251k
                                  sizeof(multiplier_table));
361
251k
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
251k
    idct->cur_method[ci] = -1;
364
251k
  }
365
88.1k
}
j12init_inverse_dct
Line
Count
Source
341
39.6k
{
342
39.6k
  my_idct_ptr idct;
343
39.6k
  int ci;
344
39.6k
  jpeg_component_info *compptr;
345
346
39.6k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
39.6k
  idct = (my_idct_ptr)
350
39.6k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
39.6k
                                sizeof(my_idct_controller));
352
39.6k
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
39.6k
  idct->pub.start_pass = start_pass;
354
355
151k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
111k
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
111k
    compptr->dct_table =
359
111k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
111k
                                  sizeof(multiplier_table));
361
111k
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
111k
    idct->cur_method[ci] = -1;
364
111k
  }
365
39.6k
}
jinit_inverse_dct
Line
Count
Source
341
48.4k
{
342
48.4k
  my_idct_ptr idct;
343
48.4k
  int ci;
344
48.4k
  jpeg_component_info *compptr;
345
346
48.4k
  if (cinfo->data_precision != BITS_IN_JSAMPLE)
347
0
    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
348
349
48.4k
  idct = (my_idct_ptr)
350
48.4k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
351
48.4k
                                sizeof(my_idct_controller));
352
48.4k
  cinfo->idct = (struct jpeg_inverse_dct *)idct;
353
48.4k
  idct->pub.start_pass = start_pass;
354
355
187k
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
356
139k
       ci++, compptr++) {
357
    /* Allocate and pre-zero a multiplier table for each component */
358
139k
    compptr->dct_table =
359
139k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
360
139k
                                  sizeof(multiplier_table));
361
139k
    memset(compptr->dct_table, 0, sizeof(multiplier_table));
362
    /* Mark multiplier table not yet set up for any method */
363
139k
    idct->cur_method[ci] = -1;
364
139k
  }
365
48.4k
}