2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $XConsortium: jddctmgr.c /main/2 1996/05/09 03:47:35 drk $ */
27 * Copyright (C) 1994-1996, Thomas G. Lane.
28 * This file is part of the Independent JPEG Group's software.
29 * For conditions of distribution and use, see the accompanying README file.
31 * This file contains the inverse-DCT management logic.
32 * This code selects a particular IDCT implementation to be used,
33 * and it performs related housekeeping chores. No code in this file
34 * is executed per IDCT step, only during output pass setup.
36 * Note that the IDCT routines are responsible for performing coefficient
37 * dequantization as well as the IDCT proper. This module sets up the
38 * dequantization multiplier table needed by the IDCT routine.
41 #define JPEG_INTERNALS
44 #include "jdct.h" /* Private declarations for DCT subsystem */
48 * The decompressor input side (jdinput.c) saves away the appropriate
49 * quantization table for each component at the start of the first scan
50 * involving that component. (This is necessary in order to correctly
51 * decode files that reuse Q-table slots.)
52 * When we are ready to make an output pass, the saved Q-table is converted
53 * to a multiplier table that will actually be used by the IDCT routine.
54 * The multiplier table contents are IDCT-method-dependent. To support
55 * application changes in IDCT method between scans, we can remake the
56 * multiplier tables if necessary.
57 * In buffered-image mode, the first output pass may occur before any data
58 * has been seen for some components, and thus before their Q-tables have
59 * been saved away. To handle this case, multiplier tables are preset
60 * to zeroes; the result of the IDCT will be a neutral gray level.
64 /* Private subobject for this module */
67 struct jpeg_inverse_dct pub; /* public fields */
69 /* This array contains the IDCT method code that each multiplier table
70 * is currently set up for, or -1 if it's not yet set up.
71 * The actual multiplier tables are pointed to by dct_table in the
72 * per-component comp_info structures.
74 int cur_method[MAX_COMPONENTS];
77 typedef my_idct_controller * my_idct_ptr;
80 /* Allocated multiplier tables: big enough for any supported variant */
83 ISLOW_MULT_TYPE islow_array[DCTSIZE2];
84 #ifdef DCT_IFAST_SUPPORTED
85 IFAST_MULT_TYPE ifast_array[DCTSIZE2];
87 #ifdef DCT_FLOAT_SUPPORTED
88 FLOAT_MULT_TYPE float_array[DCTSIZE2];
93 /* The current scaled-IDCT routines require ISLOW-style multiplier tables,
94 * so be sure to compile that code if either ISLOW or SCALING is requested.
96 #ifdef DCT_ISLOW_SUPPORTED
97 #define PROVIDE_ISLOW_TABLES
99 #ifdef IDCT_SCALING_SUPPORTED
100 #define PROVIDE_ISLOW_TABLES
106 * Prepare for an output pass.
107 * Here we select the proper IDCT routine for each component and build
108 * a matching multiplier table.
112 start_pass (j_decompress_ptr cinfo)
114 my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
116 jpeg_component_info *compptr;
118 inverse_DCT_method_ptr method_ptr = NULL;
121 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
123 /* Select the proper IDCT routine for this component's scaling */
124 switch (compptr->DCT_scaled_size) {
125 #ifdef IDCT_SCALING_SUPPORTED
127 method_ptr = jpeg_idct_1x1;
128 method = JDCT_ISLOW; /* jidctred uses islow-style table */
131 method_ptr = jpeg_idct_2x2;
132 method = JDCT_ISLOW; /* jidctred uses islow-style table */
135 method_ptr = jpeg_idct_4x4;
136 method = JDCT_ISLOW; /* jidctred uses islow-style table */
140 switch (cinfo->dct_method) {
141 #ifdef DCT_ISLOW_SUPPORTED
143 method_ptr = jpeg_idct_islow;
147 #ifdef DCT_IFAST_SUPPORTED
149 method_ptr = jpeg_idct_ifast;
153 #ifdef DCT_FLOAT_SUPPORTED
155 method_ptr = jpeg_idct_float;
160 ERREXIT(cinfo, JERR_NOT_COMPILED);
165 ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
168 idct->pub.inverse_DCT[ci] = method_ptr;
169 /* Create multiplier table from quant table.
170 * However, we can skip this if the component is uninteresting
171 * or if we already built the table. Also, if no quant table
172 * has yet been saved for the component, we leave the
173 * multiplier table all-zero; we'll be reading zeroes from the
174 * coefficient controller's buffer anyway.
176 if (! compptr->component_needed || idct->cur_method[ci] == method)
178 qtbl = compptr->quant_table;
179 if (qtbl == NULL) /* happens if no data yet for component */
181 idct->cur_method[ci] = method;
183 #ifdef PROVIDE_ISLOW_TABLES
186 /* For LL&M IDCT method, multipliers are equal to raw quantization
187 * coefficients, but are stored as ints to ensure access efficiency.
189 ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
190 for (i = 0; i < DCTSIZE2; i++) {
191 ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
196 #ifdef DCT_IFAST_SUPPORTED
199 /* For AA&N IDCT method, multipliers are equal to quantization
200 * coefficients scaled by scalefactor[row]*scalefactor[col], where
202 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
203 * For integer operation, the multiplier table is to be scaled by
206 IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
207 #define CONST_BITS 14
208 static const INT16 aanscales[DCTSIZE2] = {
209 /* precomputed values scaled up by 14 bits */
210 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
211 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
212 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
213 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
214 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
215 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
216 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
217 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
221 for (i = 0; i < DCTSIZE2; i++) {
222 ifmtbl[i] = (IFAST_MULT_TYPE)
223 DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
224 (INT32) aanscales[i]),
225 CONST_BITS-IFAST_SCALE_BITS);
230 #ifdef DCT_FLOAT_SUPPORTED
233 /* For float AA&N IDCT method, multipliers are equal to quantization
234 * coefficients scaled by scalefactor[row]*scalefactor[col], where
236 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
238 FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
240 static const double aanscalefactor[DCTSIZE] = {
241 1.0, 1.387039845, 1.306562965, 1.175875602,
242 1.0, 0.785694958, 0.541196100, 0.275899379
246 for (row = 0; row < DCTSIZE; row++) {
247 for (col = 0; col < DCTSIZE; col++) {
248 fmtbl[i] = (FLOAT_MULT_TYPE)
249 ((double) qtbl->quantval[i] *
250 aanscalefactor[row] * aanscalefactor[col]);
258 ERREXIT(cinfo, JERR_NOT_COMPILED);
266 * Initialize IDCT manager.
270 jinit_inverse_dct (j_decompress_ptr cinfo)
274 jpeg_component_info *compptr;
277 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
278 SIZEOF(my_idct_controller));
279 cinfo->idct = (struct jpeg_inverse_dct *) idct;
280 idct->pub.start_pass = start_pass;
282 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
284 /* Allocate and pre-zero a multiplier table for each component */
286 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
287 SIZEOF(multiplier_table));
288 MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
289 /* Mark multiplier table not yet set up for any method */
290 idct->cur_method[ci] = -1;