aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c964
1 files changed, 482 insertions, 482 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c
index 550b1a6..0bbdbb6 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcdctmgr.c
@@ -1,482 +1,482 @@
1/* 1/*
2 * jcdctmgr.c 2 * jcdctmgr.c
3 * 3 *
4 * Copyright (C) 1994-1996, Thomas G. Lane. 4 * Copyright (C) 1994-1996, Thomas G. Lane.
5 * This file is part of the Independent JPEG Group's software. 5 * This file is part of the Independent JPEG Group's software.
6 * For conditions of distribution and use, see the accompanying README file. 6 * For conditions of distribution and use, see the accompanying README file.
7 * 7 *
8 * This file contains the forward-DCT management logic. 8 * This file contains the forward-DCT management logic.
9 * This code selects a particular DCT implementation to be used, 9 * This code selects a particular DCT implementation to be used,
10 * and it performs related housekeeping chores including coefficient 10 * and it performs related housekeeping chores including coefficient
11 * quantization. 11 * quantization.
12 */ 12 */
13 13
14#define JPEG_INTERNALS 14#define JPEG_INTERNALS
15#include "jinclude.h" 15#include "jinclude.h"
16#include "jpeglib.h" 16#include "jpeglib.h"
17#include "jdct.h" /* Private declarations for DCT subsystem */ 17#include "jdct.h" /* Private declarations for DCT subsystem */
18 18
19 19
20/* Private subobject for this module */ 20/* Private subobject for this module */
21 21
22typedef struct { 22typedef struct {
23 struct jpeg_forward_dct pub; /* public fields */ 23 struct jpeg_forward_dct pub; /* public fields */
24 24
25 /* Pointer to the DCT routine actually in use */ 25 /* Pointer to the DCT routine actually in use */
26 forward_DCT_method_ptr do_dct[MAX_COMPONENTS]; 26 forward_DCT_method_ptr do_dct[MAX_COMPONENTS];
27 27
28 /* The actual post-DCT divisors --- not identical to the quant table 28 /* The actual post-DCT divisors --- not identical to the quant table
29 * entries, because of scaling (especially for an unnormalized DCT). 29 * entries, because of scaling (especially for an unnormalized DCT).
30 * Each table is given in normal array order. 30 * Each table is given in normal array order.
31 */ 31 */
32 DCTELEM * divisors[NUM_QUANT_TBLS]; 32 DCTELEM * divisors[NUM_QUANT_TBLS];
33 33
34#ifdef DCT_FLOAT_SUPPORTED 34#ifdef DCT_FLOAT_SUPPORTED
35 /* Same as above for the floating-point case. */ 35 /* Same as above for the floating-point case. */
36 float_DCT_method_ptr do_float_dct[MAX_COMPONENTS]; 36 float_DCT_method_ptr do_float_dct[MAX_COMPONENTS];
37 FAST_FLOAT * float_divisors[NUM_QUANT_TBLS]; 37 FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
38#endif 38#endif
39} my_fdct_controller; 39} my_fdct_controller;
40 40
41typedef my_fdct_controller * my_fdct_ptr; 41typedef my_fdct_controller * my_fdct_ptr;
42 42
43 43
44/* The current scaled-DCT routines require ISLOW-style divisor tables, 44/* The current scaled-DCT routines require ISLOW-style divisor tables,
45 * so be sure to compile that code if either ISLOW or SCALING is requested. 45 * so be sure to compile that code if either ISLOW or SCALING is requested.
46 */ 46 */
47#ifdef DCT_ISLOW_SUPPORTED 47#ifdef DCT_ISLOW_SUPPORTED
48#define PROVIDE_ISLOW_TABLES 48#define PROVIDE_ISLOW_TABLES
49#else 49#else
50#ifdef DCT_SCALING_SUPPORTED 50#ifdef DCT_SCALING_SUPPORTED
51#define PROVIDE_ISLOW_TABLES 51#define PROVIDE_ISLOW_TABLES
52#endif 52#endif
53#endif 53#endif
54 54
55 55
56/* 56/*
57 * Perform forward DCT on one or more blocks of a component. 57 * Perform forward DCT on one or more blocks of a component.
58 * 58 *
59 * The input samples are taken from the sample_data[] array starting at 59 * The input samples are taken from the sample_data[] array starting at
60 * position start_row/start_col, and moving to the right for any additional 60 * position start_row/start_col, and moving to the right for any additional
61 * blocks. The quantized coefficients are returned in coef_blocks[]. 61 * blocks. The quantized coefficients are returned in coef_blocks[].
62 */ 62 */
63 63
64METHODDEF(void) 64METHODDEF(void)
65forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr, 65forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
66 JSAMPARRAY sample_data, JBLOCKROW coef_blocks, 66 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
67 JDIMENSION start_row, JDIMENSION start_col, 67 JDIMENSION start_row, JDIMENSION start_col,
68 JDIMENSION num_blocks) 68 JDIMENSION num_blocks)
69/* This version is used for integer DCT implementations. */ 69/* This version is used for integer DCT implementations. */
70{ 70{
71 /* This routine is heavily used, so it's worth coding it tightly. */ 71 /* This routine is heavily used, so it's worth coding it tightly. */
72 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; 72 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
73 forward_DCT_method_ptr do_dct = fdct->do_dct[compptr->component_index]; 73 forward_DCT_method_ptr do_dct = fdct->do_dct[compptr->component_index];
74 DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no]; 74 DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
75 DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */ 75 DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
76 JDIMENSION bi; 76 JDIMENSION bi;
77 77
78 sample_data += start_row; /* fold in the vertical offset once */ 78 sample_data += start_row; /* fold in the vertical offset once */
79 79
80 for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) { 80 for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) {
81 /* Perform the DCT */ 81 /* Perform the DCT */
82 (*do_dct) (workspace, sample_data, start_col); 82 (*do_dct) (workspace, sample_data, start_col);
83 83
84 /* Quantize/descale the coefficients, and store into coef_blocks[] */ 84 /* Quantize/descale the coefficients, and store into coef_blocks[] */
85 { register DCTELEM temp, qval; 85 { register DCTELEM temp, qval;
86 register int i; 86 register int i;
87 register JCOEFPTR output_ptr = coef_blocks[bi]; 87 register JCOEFPTR output_ptr = coef_blocks[bi];
88 88
89 for (i = 0; i < DCTSIZE2; i++) { 89 for (i = 0; i < DCTSIZE2; i++) {
90 qval = divisors[i]; 90 qval = divisors[i];
91 temp = workspace[i]; 91 temp = workspace[i];
92 /* Divide the coefficient value by qval, ensuring proper rounding. 92 /* Divide the coefficient value by qval, ensuring proper rounding.
93 * Since C does not specify the direction of rounding for negative 93 * Since C does not specify the direction of rounding for negative
94 * quotients, we have to force the dividend positive for portability. 94 * quotients, we have to force the dividend positive for portability.
95 * 95 *
96 * In most files, at least half of the output values will be zero 96 * In most files, at least half of the output values will be zero
97 * (at default quantization settings, more like three-quarters...) 97 * (at default quantization settings, more like three-quarters...)
98 * so we should ensure that this case is fast. On many machines, 98 * so we should ensure that this case is fast. On many machines,
99 * a comparison is enough cheaper than a divide to make a special test 99 * a comparison is enough cheaper than a divide to make a special test
100 * a win. Since both inputs will be nonnegative, we need only test 100 * a win. Since both inputs will be nonnegative, we need only test
101 * for a < b to discover whether a/b is 0. 101 * for a < b to discover whether a/b is 0.
102 * If your machine's division is fast enough, define FAST_DIVIDE. 102 * If your machine's division is fast enough, define FAST_DIVIDE.
103 */ 103 */
104#ifdef FAST_DIVIDE 104#ifdef FAST_DIVIDE
105#define DIVIDE_BY(a,b) a /= b 105#define DIVIDE_BY(a,b) a /= b
106#else 106#else
107#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0 107#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
108#endif 108#endif
109 if (temp < 0) { 109 if (temp < 0) {
110 temp = -temp; 110 temp = -temp;
111 temp += qval>>1; /* for rounding */ 111 temp += qval>>1; /* for rounding */
112 DIVIDE_BY(temp, qval); 112 DIVIDE_BY(temp, qval);
113 temp = -temp; 113 temp = -temp;
114 } else { 114 } else {
115 temp += qval>>1; /* for rounding */ 115 temp += qval>>1; /* for rounding */
116 DIVIDE_BY(temp, qval); 116 DIVIDE_BY(temp, qval);
117 } 117 }
118 output_ptr[i] = (JCOEF) temp; 118 output_ptr[i] = (JCOEF) temp;
119 } 119 }
120 } 120 }
121 } 121 }
122} 122}
123 123
124 124
125#ifdef DCT_FLOAT_SUPPORTED 125#ifdef DCT_FLOAT_SUPPORTED
126 126
127METHODDEF(void) 127METHODDEF(void)
128forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr, 128forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
129 JSAMPARRAY sample_data, JBLOCKROW coef_blocks, 129 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
130 JDIMENSION start_row, JDIMENSION start_col, 130 JDIMENSION start_row, JDIMENSION start_col,
131 JDIMENSION num_blocks) 131 JDIMENSION num_blocks)
132/* This version is used for floating-point DCT implementations. */ 132/* This version is used for floating-point DCT implementations. */
133{ 133{
134 /* This routine is heavily used, so it's worth coding it tightly. */ 134 /* This routine is heavily used, so it's worth coding it tightly. */
135 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; 135 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
136 float_DCT_method_ptr do_dct = fdct->do_float_dct[compptr->component_index]; 136 float_DCT_method_ptr do_dct = fdct->do_float_dct[compptr->component_index];
137 FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no]; 137 FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
138 FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */ 138 FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
139 JDIMENSION bi; 139 JDIMENSION bi;
140 140
141 sample_data += start_row; /* fold in the vertical offset once */ 141 sample_data += start_row; /* fold in the vertical offset once */
142 142
143 for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) { 143 for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) {
144 /* Perform the DCT */ 144 /* Perform the DCT */
145 (*do_dct) (workspace, sample_data, start_col); 145 (*do_dct) (workspace, sample_data, start_col);
146 146
147 /* Quantize/descale the coefficients, and store into coef_blocks[] */ 147 /* Quantize/descale the coefficients, and store into coef_blocks[] */
148 { register FAST_FLOAT temp; 148 { register FAST_FLOAT temp;
149 register int i; 149 register int i;
150 register JCOEFPTR output_ptr = coef_blocks[bi]; 150 register JCOEFPTR output_ptr = coef_blocks[bi];
151 151
152 for (i = 0; i < DCTSIZE2; i++) { 152 for (i = 0; i < DCTSIZE2; i++) {
153 /* Apply the quantization and scaling factor */ 153 /* Apply the quantization and scaling factor */
154 temp = workspace[i] * divisors[i]; 154 temp = workspace[i] * divisors[i];
155 /* Round to nearest integer. 155 /* Round to nearest integer.
156 * Since C does not specify the direction of rounding for negative 156 * Since C does not specify the direction of rounding for negative
157 * quotients, we have to force the dividend positive for portability. 157 * quotients, we have to force the dividend positive for portability.
158 * The maximum coefficient size is +-16K (for 12-bit data), so this 158 * The maximum coefficient size is +-16K (for 12-bit data), so this
159 * code should work for either 16-bit or 32-bit ints. 159 * code should work for either 16-bit or 32-bit ints.
160 */ 160 */
161 output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384); 161 output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
162 } 162 }
163 } 163 }
164 } 164 }
165} 165}
166 166
167#endif /* DCT_FLOAT_SUPPORTED */ 167#endif /* DCT_FLOAT_SUPPORTED */
168 168
169 169
170/* 170/*
171 * Initialize for a processing pass. 171 * Initialize for a processing pass.
172 * Verify that all referenced Q-tables are present, and set up 172 * Verify that all referenced Q-tables are present, and set up
173 * the divisor table for each one. 173 * the divisor table for each one.
174 * In the current implementation, DCT of all components is done during 174 * In the current implementation, DCT of all components is done during
175 * the first pass, even if only some components will be output in the 175 * the first pass, even if only some components will be output in the
176 * first scan. Hence all components should be examined here. 176 * first scan. Hence all components should be examined here.
177 */ 177 */
178 178
179METHODDEF(void) 179METHODDEF(void)
180start_pass_fdctmgr (j_compress_ptr cinfo) 180start_pass_fdctmgr (j_compress_ptr cinfo)
181{ 181{
182 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; 182 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
183 int ci, qtblno, i; 183 int ci, qtblno, i;
184 jpeg_component_info *compptr; 184 jpeg_component_info *compptr;
185 int method = 0; 185 int method = 0;
186 JQUANT_TBL * qtbl; 186 JQUANT_TBL * qtbl;
187 DCTELEM * dtbl; 187 DCTELEM * dtbl;
188 188
189 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 189 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
190 ci++, compptr++) { 190 ci++, compptr++) {
191 /* Select the proper DCT routine for this component's scaling */ 191 /* Select the proper DCT routine for this component's scaling */
192 switch ((compptr->DCT_h_scaled_size << 8) + compptr->DCT_v_scaled_size) { 192 switch ((compptr->DCT_h_scaled_size << 8) + compptr->DCT_v_scaled_size) {
193#ifdef DCT_SCALING_SUPPORTED 193#ifdef DCT_SCALING_SUPPORTED
194 case ((1 << 8) + 1): 194 case ((1 << 8) + 1):
195 fdct->do_dct[ci] = jpeg_fdct_1x1; 195 fdct->do_dct[ci] = jpeg_fdct_1x1;
196 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 196 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
197 break; 197 break;
198 case ((2 << 8) + 2): 198 case ((2 << 8) + 2):
199 fdct->do_dct[ci] = jpeg_fdct_2x2; 199 fdct->do_dct[ci] = jpeg_fdct_2x2;
200 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 200 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
201 break; 201 break;
202 case ((3 << 8) + 3): 202 case ((3 << 8) + 3):
203 fdct->do_dct[ci] = jpeg_fdct_3x3; 203 fdct->do_dct[ci] = jpeg_fdct_3x3;
204 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 204 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
205 break; 205 break;
206 case ((4 << 8) + 4): 206 case ((4 << 8) + 4):
207 fdct->do_dct[ci] = jpeg_fdct_4x4; 207 fdct->do_dct[ci] = jpeg_fdct_4x4;
208 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 208 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
209 break; 209 break;
210 case ((5 << 8) + 5): 210 case ((5 << 8) + 5):
211 fdct->do_dct[ci] = jpeg_fdct_5x5; 211 fdct->do_dct[ci] = jpeg_fdct_5x5;
212 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 212 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
213 break; 213 break;
214 case ((6 << 8) + 6): 214 case ((6 << 8) + 6):
215 fdct->do_dct[ci] = jpeg_fdct_6x6; 215 fdct->do_dct[ci] = jpeg_fdct_6x6;
216 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 216 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
217 break; 217 break;
218 case ((7 << 8) + 7): 218 case ((7 << 8) + 7):
219 fdct->do_dct[ci] = jpeg_fdct_7x7; 219 fdct->do_dct[ci] = jpeg_fdct_7x7;
220 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 220 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
221 break; 221 break;
222 case ((9 << 8) + 9): 222 case ((9 << 8) + 9):
223 fdct->do_dct[ci] = jpeg_fdct_9x9; 223 fdct->do_dct[ci] = jpeg_fdct_9x9;
224 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 224 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
225 break; 225 break;
226 case ((10 << 8) + 10): 226 case ((10 << 8) + 10):
227 fdct->do_dct[ci] = jpeg_fdct_10x10; 227 fdct->do_dct[ci] = jpeg_fdct_10x10;
228 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 228 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
229 break; 229 break;
230 case ((11 << 8) + 11): 230 case ((11 << 8) + 11):
231 fdct->do_dct[ci] = jpeg_fdct_11x11; 231 fdct->do_dct[ci] = jpeg_fdct_11x11;
232 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 232 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
233 break; 233 break;
234 case ((12 << 8) + 12): 234 case ((12 << 8) + 12):
235 fdct->do_dct[ci] = jpeg_fdct_12x12; 235 fdct->do_dct[ci] = jpeg_fdct_12x12;
236 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 236 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
237 break; 237 break;
238 case ((13 << 8) + 13): 238 case ((13 << 8) + 13):
239 fdct->do_dct[ci] = jpeg_fdct_13x13; 239 fdct->do_dct[ci] = jpeg_fdct_13x13;
240 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 240 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
241 break; 241 break;
242 case ((14 << 8) + 14): 242 case ((14 << 8) + 14):
243 fdct->do_dct[ci] = jpeg_fdct_14x14; 243 fdct->do_dct[ci] = jpeg_fdct_14x14;
244 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 244 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
245 break; 245 break;
246 case ((15 << 8) + 15): 246 case ((15 << 8) + 15):
247 fdct->do_dct[ci] = jpeg_fdct_15x15; 247 fdct->do_dct[ci] = jpeg_fdct_15x15;
248 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 248 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
249 break; 249 break;
250 case ((16 << 8) + 16): 250 case ((16 << 8) + 16):
251 fdct->do_dct[ci] = jpeg_fdct_16x16; 251 fdct->do_dct[ci] = jpeg_fdct_16x16;
252 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 252 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
253 break; 253 break;
254 case ((16 << 8) + 8): 254 case ((16 << 8) + 8):
255 fdct->do_dct[ci] = jpeg_fdct_16x8; 255 fdct->do_dct[ci] = jpeg_fdct_16x8;
256 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 256 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
257 break; 257 break;
258 case ((14 << 8) + 7): 258 case ((14 << 8) + 7):
259 fdct->do_dct[ci] = jpeg_fdct_14x7; 259 fdct->do_dct[ci] = jpeg_fdct_14x7;
260 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 260 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
261 break; 261 break;
262 case ((12 << 8) + 6): 262 case ((12 << 8) + 6):
263 fdct->do_dct[ci] = jpeg_fdct_12x6; 263 fdct->do_dct[ci] = jpeg_fdct_12x6;
264 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 264 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
265 break; 265 break;
266 case ((10 << 8) + 5): 266 case ((10 << 8) + 5):
267 fdct->do_dct[ci] = jpeg_fdct_10x5; 267 fdct->do_dct[ci] = jpeg_fdct_10x5;
268 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 268 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
269 break; 269 break;
270 case ((8 << 8) + 4): 270 case ((8 << 8) + 4):
271 fdct->do_dct[ci] = jpeg_fdct_8x4; 271 fdct->do_dct[ci] = jpeg_fdct_8x4;
272 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 272 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
273 break; 273 break;
274 case ((6 << 8) + 3): 274 case ((6 << 8) + 3):
275 fdct->do_dct[ci] = jpeg_fdct_6x3; 275 fdct->do_dct[ci] = jpeg_fdct_6x3;
276 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 276 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
277 break; 277 break;
278 case ((4 << 8) + 2): 278 case ((4 << 8) + 2):
279 fdct->do_dct[ci] = jpeg_fdct_4x2; 279 fdct->do_dct[ci] = jpeg_fdct_4x2;
280 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 280 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
281 break; 281 break;
282 case ((2 << 8) + 1): 282 case ((2 << 8) + 1):
283 fdct->do_dct[ci] = jpeg_fdct_2x1; 283 fdct->do_dct[ci] = jpeg_fdct_2x1;
284 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 284 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
285 break; 285 break;
286 case ((8 << 8) + 16): 286 case ((8 << 8) + 16):
287 fdct->do_dct[ci] = jpeg_fdct_8x16; 287 fdct->do_dct[ci] = jpeg_fdct_8x16;
288 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 288 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
289 break; 289 break;
290 case ((7 << 8) + 14): 290 case ((7 << 8) + 14):
291 fdct->do_dct[ci] = jpeg_fdct_7x14; 291 fdct->do_dct[ci] = jpeg_fdct_7x14;
292 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 292 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
293 break; 293 break;
294 case ((6 << 8) + 12): 294 case ((6 << 8) + 12):
295 fdct->do_dct[ci] = jpeg_fdct_6x12; 295 fdct->do_dct[ci] = jpeg_fdct_6x12;
296 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 296 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
297 break; 297 break;
298 case ((5 << 8) + 10): 298 case ((5 << 8) + 10):
299 fdct->do_dct[ci] = jpeg_fdct_5x10; 299 fdct->do_dct[ci] = jpeg_fdct_5x10;
300 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 300 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
301 break; 301 break;
302 case ((4 << 8) + 8): 302 case ((4 << 8) + 8):
303 fdct->do_dct[ci] = jpeg_fdct_4x8; 303 fdct->do_dct[ci] = jpeg_fdct_4x8;
304 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 304 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
305 break; 305 break;
306 case ((3 << 8) + 6): 306 case ((3 << 8) + 6):
307 fdct->do_dct[ci] = jpeg_fdct_3x6; 307 fdct->do_dct[ci] = jpeg_fdct_3x6;
308 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 308 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
309 break; 309 break;
310 case ((2 << 8) + 4): 310 case ((2 << 8) + 4):
311 fdct->do_dct[ci] = jpeg_fdct_2x4; 311 fdct->do_dct[ci] = jpeg_fdct_2x4;
312 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 312 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
313 break; 313 break;
314 case ((1 << 8) + 2): 314 case ((1 << 8) + 2):
315 fdct->do_dct[ci] = jpeg_fdct_1x2; 315 fdct->do_dct[ci] = jpeg_fdct_1x2;
316 method = JDCT_ISLOW; /* jfdctint uses islow-style table */ 316 method = JDCT_ISLOW; /* jfdctint uses islow-style table */
317 break; 317 break;
318#endif 318#endif
319 case ((DCTSIZE << 8) + DCTSIZE): 319 case ((DCTSIZE << 8) + DCTSIZE):
320 switch (cinfo->dct_method) { 320 switch (cinfo->dct_method) {
321#ifdef DCT_ISLOW_SUPPORTED 321#ifdef DCT_ISLOW_SUPPORTED
322 case JDCT_ISLOW: 322 case JDCT_ISLOW:
323 fdct->do_dct[ci] = jpeg_fdct_islow; 323 fdct->do_dct[ci] = jpeg_fdct_islow;
324 method = JDCT_ISLOW; 324 method = JDCT_ISLOW;
325 break; 325 break;
326#endif 326#endif
327#ifdef DCT_IFAST_SUPPORTED 327#ifdef DCT_IFAST_SUPPORTED
328 case JDCT_IFAST: 328 case JDCT_IFAST:
329 fdct->do_dct[ci] = jpeg_fdct_ifast; 329 fdct->do_dct[ci] = jpeg_fdct_ifast;
330 method = JDCT_IFAST; 330 method = JDCT_IFAST;
331 break; 331 break;
332#endif 332#endif
333#ifdef DCT_FLOAT_SUPPORTED 333#ifdef DCT_FLOAT_SUPPORTED
334 case JDCT_FLOAT: 334 case JDCT_FLOAT:
335 fdct->do_float_dct[ci] = jpeg_fdct_float; 335 fdct->do_float_dct[ci] = jpeg_fdct_float;
336 method = JDCT_FLOAT; 336 method = JDCT_FLOAT;
337 break; 337 break;
338#endif 338#endif
339 default: 339 default:
340 ERREXIT(cinfo, JERR_NOT_COMPILED); 340 ERREXIT(cinfo, JERR_NOT_COMPILED);
341 break; 341 break;
342 } 342 }
343 break; 343 break;
344 default: 344 default:
345 ERREXIT2(cinfo, JERR_BAD_DCTSIZE, 345 ERREXIT2(cinfo, JERR_BAD_DCTSIZE,
346 compptr->DCT_h_scaled_size, compptr->DCT_v_scaled_size); 346 compptr->DCT_h_scaled_size, compptr->DCT_v_scaled_size);
347 break; 347 break;
348 } 348 }
349 qtblno = compptr->quant_tbl_no; 349 qtblno = compptr->quant_tbl_no;
350 /* Make sure specified quantization table is present */ 350 /* Make sure specified quantization table is present */
351 if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || 351 if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
352 cinfo->quant_tbl_ptrs[qtblno] == NULL) 352 cinfo->quant_tbl_ptrs[qtblno] == NULL)
353 ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); 353 ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
354 qtbl = cinfo->quant_tbl_ptrs[qtblno]; 354 qtbl = cinfo->quant_tbl_ptrs[qtblno];
355 /* Compute divisors for this quant table */ 355 /* Compute divisors for this quant table */
356 /* We may do this more than once for same table, but it's not a big deal */ 356 /* We may do this more than once for same table, but it's not a big deal */
357 switch (method) { 357 switch (method) {
358#ifdef PROVIDE_ISLOW_TABLES 358#ifdef PROVIDE_ISLOW_TABLES
359 case JDCT_ISLOW: 359 case JDCT_ISLOW:
360 /* For LL&M IDCT method, divisors are equal to raw quantization 360 /* For LL&M IDCT method, divisors are equal to raw quantization
361 * coefficients multiplied by 8 (to counteract scaling). 361 * coefficients multiplied by 8 (to counteract scaling).
362 */ 362 */
363 if (fdct->divisors[qtblno] == NULL) { 363 if (fdct->divisors[qtblno] == NULL) {
364 fdct->divisors[qtblno] = (DCTELEM *) 364 fdct->divisors[qtblno] = (DCTELEM *)
365 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 365 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
366 DCTSIZE2 * SIZEOF(DCTELEM)); 366 DCTSIZE2 * SIZEOF(DCTELEM));
367 } 367 }
368 dtbl = fdct->divisors[qtblno]; 368 dtbl = fdct->divisors[qtblno];
369 for (i = 0; i < DCTSIZE2; i++) { 369 for (i = 0; i < DCTSIZE2; i++) {
370 dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3; 370 dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
371 } 371 }
372 fdct->pub.forward_DCT[ci] = forward_DCT; 372 fdct->pub.forward_DCT[ci] = forward_DCT;
373 break; 373 break;
374#endif 374#endif
375#ifdef DCT_IFAST_SUPPORTED 375#ifdef DCT_IFAST_SUPPORTED
376 case JDCT_IFAST: 376 case JDCT_IFAST:
377 { 377 {
378 /* For AA&N IDCT method, divisors are equal to quantization 378 /* For AA&N IDCT method, divisors are equal to quantization
379 * coefficients scaled by scalefactor[row]*scalefactor[col], where 379 * coefficients scaled by scalefactor[row]*scalefactor[col], where
380 * scalefactor[0] = 1 380 * scalefactor[0] = 1
381 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 381 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
382 * We apply a further scale factor of 8. 382 * We apply a further scale factor of 8.
383 */ 383 */
384#define CONST_BITS 14 384#define CONST_BITS 14
385 static const INT16 aanscales[DCTSIZE2] = { 385 static const INT16 aanscales[DCTSIZE2] = {
386 /* precomputed values scaled up by 14 bits */ 386 /* precomputed values scaled up by 14 bits */
387 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 387 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
388 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, 388 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
389 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, 389 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
390 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, 390 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
391 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 391 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
392 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, 392 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
393 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, 393 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
394 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 394 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
395 }; 395 };
396 SHIFT_TEMPS 396 SHIFT_TEMPS
397 397
398 if (fdct->divisors[qtblno] == NULL) { 398 if (fdct->divisors[qtblno] == NULL) {
399 fdct->divisors[qtblno] = (DCTELEM *) 399 fdct->divisors[qtblno] = (DCTELEM *)
400 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 400 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
401 DCTSIZE2 * SIZEOF(DCTELEM)); 401 DCTSIZE2 * SIZEOF(DCTELEM));
402 } 402 }
403 dtbl = fdct->divisors[qtblno]; 403 dtbl = fdct->divisors[qtblno];
404 for (i = 0; i < DCTSIZE2; i++) { 404 for (i = 0; i < DCTSIZE2; i++) {
405 dtbl[i] = (DCTELEM) 405 dtbl[i] = (DCTELEM)
406 DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i], 406 DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
407 (INT32) aanscales[i]), 407 (INT32) aanscales[i]),
408 CONST_BITS-3); 408 CONST_BITS-3);
409 } 409 }
410 } 410 }
411 fdct->pub.forward_DCT[ci] = forward_DCT; 411 fdct->pub.forward_DCT[ci] = forward_DCT;
412 break; 412 break;
413#endif 413#endif
414#ifdef DCT_FLOAT_SUPPORTED 414#ifdef DCT_FLOAT_SUPPORTED
415 case JDCT_FLOAT: 415 case JDCT_FLOAT:
416 { 416 {
417 /* For float AA&N IDCT method, divisors are equal to quantization 417 /* For float AA&N IDCT method, divisors are equal to quantization
418 * coefficients scaled by scalefactor[row]*scalefactor[col], where 418 * coefficients scaled by scalefactor[row]*scalefactor[col], where
419 * scalefactor[0] = 1 419 * scalefactor[0] = 1
420 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 420 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
421 * We apply a further scale factor of 8. 421 * We apply a further scale factor of 8.
422 * What's actually stored is 1/divisor so that the inner loop can 422 * What's actually stored is 1/divisor so that the inner loop can
423 * use a multiplication rather than a division. 423 * use a multiplication rather than a division.
424 */ 424 */
425 FAST_FLOAT * fdtbl; 425 FAST_FLOAT * fdtbl;
426 int row, col; 426 int row, col;
427 static const double aanscalefactor[DCTSIZE] = { 427 static const double aanscalefactor[DCTSIZE] = {
428 1.0, 1.387039845, 1.306562965, 1.175875602, 428 1.0, 1.387039845, 1.306562965, 1.175875602,
429 1.0, 0.785694958, 0.541196100, 0.275899379 429 1.0, 0.785694958, 0.541196100, 0.275899379
430 }; 430 };
431 431
432 if (fdct->float_divisors[qtblno] == NULL) { 432 if (fdct->float_divisors[qtblno] == NULL) {
433 fdct->float_divisors[qtblno] = (FAST_FLOAT *) 433 fdct->float_divisors[qtblno] = (FAST_FLOAT *)
434 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 434 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
435 DCTSIZE2 * SIZEOF(FAST_FLOAT)); 435 DCTSIZE2 * SIZEOF(FAST_FLOAT));
436 } 436 }
437 fdtbl = fdct->float_divisors[qtblno]; 437 fdtbl = fdct->float_divisors[qtblno];
438 i = 0; 438 i = 0;
439 for (row = 0; row < DCTSIZE; row++) { 439 for (row = 0; row < DCTSIZE; row++) {
440 for (col = 0; col < DCTSIZE; col++) { 440 for (col = 0; col < DCTSIZE; col++) {
441 fdtbl[i] = (FAST_FLOAT) 441 fdtbl[i] = (FAST_FLOAT)
442 (1.0 / (((double) qtbl->quantval[i] * 442 (1.0 / (((double) qtbl->quantval[i] *
443 aanscalefactor[row] * aanscalefactor[col] * 8.0))); 443 aanscalefactor[row] * aanscalefactor[col] * 8.0)));
444 i++; 444 i++;
445 } 445 }
446 } 446 }
447 } 447 }
448 fdct->pub.forward_DCT[ci] = forward_DCT_float; 448 fdct->pub.forward_DCT[ci] = forward_DCT_float;
449 break; 449 break;
450#endif 450#endif
451 default: 451 default:
452 ERREXIT(cinfo, JERR_NOT_COMPILED); 452 ERREXIT(cinfo, JERR_NOT_COMPILED);
453 break; 453 break;
454 } 454 }
455 } 455 }
456} 456}
457 457
458 458
459/* 459/*
460 * Initialize FDCT manager. 460 * Initialize FDCT manager.
461 */ 461 */
462 462
463GLOBAL(void) 463GLOBAL(void)
464jinit_forward_dct (j_compress_ptr cinfo) 464jinit_forward_dct (j_compress_ptr cinfo)
465{ 465{
466 my_fdct_ptr fdct; 466 my_fdct_ptr fdct;
467 int i; 467 int i;
468 468
469 fdct = (my_fdct_ptr) 469 fdct = (my_fdct_ptr)
470 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 470 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
471 SIZEOF(my_fdct_controller)); 471 SIZEOF(my_fdct_controller));
472 cinfo->fdct = (struct jpeg_forward_dct *) fdct; 472 cinfo->fdct = (struct jpeg_forward_dct *) fdct;
473 fdct->pub.start_pass = start_pass_fdctmgr; 473 fdct->pub.start_pass = start_pass_fdctmgr;
474 474
475 /* Mark divisor tables unallocated */ 475 /* Mark divisor tables unallocated */
476 for (i = 0; i < NUM_QUANT_TBLS; i++) { 476 for (i = 0; i < NUM_QUANT_TBLS; i++) {
477 fdct->divisors[i] = NULL; 477 fdct->divisors[i] = NULL;
478#ifdef DCT_FLOAT_SUPPORTED 478#ifdef DCT_FLOAT_SUPPORTED
479 fdct->float_divisors[i] = NULL; 479 fdct->float_divisors[i] = NULL;
480#endif 480#endif
481 } 481 }
482} 482}
generated by cgit v1.1 at 2024-10-31 10:42:57 +0000