Line data Source code
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, 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 "jpegcomp.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 0 : start_pass (j_decompress_ptr cinfo)
98 : {
99 0 : my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
100 : int ci, i;
101 : jpeg_component_info *compptr;
102 0 : int method = 0;
103 0 : inverse_DCT_method_ptr method_ptr = NULL;
104 : 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 : #ifdef IDCT_SCALING_SUPPORTED
111 : case 1:
112 0 : method_ptr = jpeg_idct_1x1;
113 0 : method = JDCT_ISLOW; /* jidctred uses islow-style table */
114 0 : break;
115 : case 2:
116 0 : if (jsimd_can_idct_2x2())
117 0 : method_ptr = jsimd_idct_2x2;
118 : else
119 0 : method_ptr = jpeg_idct_2x2;
120 0 : method = JDCT_ISLOW; /* jidctred uses islow-style table */
121 0 : break;
122 : case 3:
123 0 : method_ptr = jpeg_idct_3x3;
124 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
125 0 : break;
126 : case 4:
127 0 : if (jsimd_can_idct_4x4())
128 0 : method_ptr = jsimd_idct_4x4;
129 : else
130 0 : method_ptr = jpeg_idct_4x4;
131 0 : method = JDCT_ISLOW; /* jidctred uses islow-style table */
132 0 : break;
133 : case 5:
134 0 : method_ptr = jpeg_idct_5x5;
135 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
136 0 : break;
137 : case 6:
138 : #if defined(__mips__)
139 : if (jsimd_can_idct_6x6())
140 : method_ptr = jsimd_idct_6x6;
141 : else
142 : #endif
143 0 : method_ptr = jpeg_idct_6x6;
144 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
145 0 : break;
146 : case 7:
147 0 : method_ptr = jpeg_idct_7x7;
148 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
149 0 : break;
150 : #endif
151 : case DCTSIZE:
152 0 : switch (cinfo->dct_method) {
153 : #ifdef DCT_ISLOW_SUPPORTED
154 : case JDCT_ISLOW:
155 0 : if (jsimd_can_idct_islow())
156 0 : method_ptr = jsimd_idct_islow;
157 : else
158 0 : method_ptr = jpeg_idct_islow;
159 0 : method = JDCT_ISLOW;
160 0 : break;
161 : #endif
162 : #ifdef DCT_IFAST_SUPPORTED
163 : case JDCT_IFAST:
164 0 : if (jsimd_can_idct_ifast())
165 0 : method_ptr = jsimd_idct_ifast;
166 : else
167 0 : method_ptr = jpeg_idct_ifast;
168 0 : method = JDCT_IFAST;
169 0 : break;
170 : #endif
171 : #ifdef DCT_FLOAT_SUPPORTED
172 : case JDCT_FLOAT:
173 0 : if (jsimd_can_idct_float())
174 0 : method_ptr = jsimd_idct_float;
175 : else
176 0 : method_ptr = jpeg_idct_float;
177 0 : method = JDCT_FLOAT;
178 0 : break;
179 : #endif
180 : default:
181 0 : ERREXIT(cinfo, JERR_NOT_COMPILED);
182 0 : break;
183 : }
184 0 : break;
185 : #ifdef IDCT_SCALING_SUPPORTED
186 : case 9:
187 0 : method_ptr = jpeg_idct_9x9;
188 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
189 0 : break;
190 : case 10:
191 0 : method_ptr = jpeg_idct_10x10;
192 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
193 0 : break;
194 : case 11:
195 0 : method_ptr = jpeg_idct_11x11;
196 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
197 0 : break;
198 : case 12:
199 : #if defined(__mips__)
200 : if (jsimd_can_idct_12x12())
201 : method_ptr = jsimd_idct_12x12;
202 : else
203 : #endif
204 0 : method_ptr = jpeg_idct_12x12;
205 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
206 0 : break;
207 : case 13:
208 0 : method_ptr = jpeg_idct_13x13;
209 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
210 0 : break;
211 : case 14:
212 0 : method_ptr = jpeg_idct_14x14;
213 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
214 0 : break;
215 : case 15:
216 0 : method_ptr = jpeg_idct_15x15;
217 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
218 0 : break;
219 : case 16:
220 0 : method_ptr = jpeg_idct_16x16;
221 0 : method = JDCT_ISLOW; /* jidctint uses islow-style table */
222 0 : break;
223 : #endif
224 : default:
225 0 : ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->_DCT_scaled_size);
226 0 : break;
227 : }
228 0 : idct->pub.inverse_DCT[ci] = method_ptr;
229 : /* Create multiplier table from quant table.
230 : * However, we can skip this if the component is uninteresting
231 : * or if we already built the table. Also, if no quant table
232 : * has yet been saved for the component, we leave the
233 : * multiplier table all-zero; we'll be reading zeroes from the
234 : * coefficient controller's buffer anyway.
235 : */
236 0 : if (! compptr->component_needed || idct->cur_method[ci] == method)
237 0 : continue;
238 0 : qtbl = compptr->quant_table;
239 0 : if (qtbl == NULL) /* happens if no data yet for component */
240 0 : continue;
241 0 : idct->cur_method[ci] = method;
242 0 : switch (method) {
243 : #ifdef PROVIDE_ISLOW_TABLES
244 : case JDCT_ISLOW:
245 : {
246 : /* For LL&M IDCT method, multipliers are equal to raw quantization
247 : * coefficients, but are stored as ints to ensure access efficiency.
248 : */
249 0 : ISLOW_MULT_TYPE *ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
250 0 : for (i = 0; i < DCTSIZE2; i++) {
251 0 : ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
252 : }
253 : }
254 0 : break;
255 : #endif
256 : #ifdef DCT_IFAST_SUPPORTED
257 : case JDCT_IFAST:
258 : {
259 : /* For AA&N IDCT method, multipliers are equal to quantization
260 : * coefficients scaled by scalefactor[row]*scalefactor[col], where
261 : * scalefactor[0] = 1
262 : * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
263 : * For integer operation, the multiplier table is to be scaled by
264 : * IFAST_SCALE_BITS.
265 : */
266 0 : IFAST_MULT_TYPE *ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
267 : #define CONST_BITS 14
268 : static const INT16 aanscales[DCTSIZE2] = {
269 : /* precomputed values scaled up by 14 bits */
270 : 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
271 : 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
272 : 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
273 : 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
274 : 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
275 : 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
276 : 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
277 : 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
278 : };
279 : SHIFT_TEMPS
280 :
281 0 : for (i = 0; i < DCTSIZE2; i++) {
282 0 : ifmtbl[i] = (IFAST_MULT_TYPE)
283 0 : DESCALE(MULTIPLY16V16((JLONG) qtbl->quantval[i],
284 : (JLONG) aanscales[i]),
285 : CONST_BITS-IFAST_SCALE_BITS);
286 : }
287 : }
288 0 : break;
289 : #endif
290 : #ifdef DCT_FLOAT_SUPPORTED
291 : case JDCT_FLOAT:
292 : {
293 : /* For float AA&N IDCT method, multipliers are equal to quantization
294 : * coefficients scaled by scalefactor[row]*scalefactor[col], where
295 : * scalefactor[0] = 1
296 : * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
297 : */
298 0 : FLOAT_MULT_TYPE *fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
299 : int row, col;
300 : static const double aanscalefactor[DCTSIZE] = {
301 : 1.0, 1.387039845, 1.306562965, 1.175875602,
302 : 1.0, 0.785694958, 0.541196100, 0.275899379
303 : };
304 :
305 0 : i = 0;
306 0 : for (row = 0; row < DCTSIZE; row++) {
307 0 : for (col = 0; col < DCTSIZE; col++) {
308 0 : fmtbl[i] = (FLOAT_MULT_TYPE)
309 0 : ((double) qtbl->quantval[i] *
310 0 : aanscalefactor[row] * aanscalefactor[col]);
311 0 : i++;
312 : }
313 : }
314 : }
315 0 : break;
316 : #endif
317 : default:
318 0 : ERREXIT(cinfo, JERR_NOT_COMPILED);
319 0 : break;
320 : }
321 : }
322 0 : }
323 :
324 :
325 : /*
326 : * Initialize IDCT manager.
327 : */
328 :
329 : GLOBAL(void)
330 0 : jinit_inverse_dct (j_decompress_ptr cinfo)
331 : {
332 : my_idct_ptr idct;
333 : int ci;
334 : jpeg_component_info *compptr;
335 :
336 0 : idct = (my_idct_ptr)
337 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
338 : sizeof(my_idct_controller));
339 0 : cinfo->idct = (struct jpeg_inverse_dct *) idct;
340 0 : idct->pub.start_pass = start_pass;
341 :
342 0 : for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
343 0 : ci++, compptr++) {
344 : /* Allocate and pre-zero a multiplier table for each component */
345 0 : compptr->dct_table =
346 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
347 : sizeof(multiplier_table));
348 0 : MEMZERO(compptr->dct_table, sizeof(multiplier_table));
349 : /* Mark multiplier table not yet set up for any method */
350 0 : idct->cur_method[ci] = -1;
351 : }
352 0 : }
|
