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