| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

jcdctmgr.c
Go to the documentation of this file.
1 /*
2 * jcdctmgr.c
3 *
4 * Copyright (C) 1994-1996, Thomas G. Lane.
5 * This file is part of the Independent JPEG Group's software.
6 * For conditions of distribution and use, see the accompanying README file.
7 *
8 * This file contains the forward-DCT management logic.
9 * This code selects a particular DCT implementation to be used,
10 * and it performs related housekeeping chores including coefficient
11 * quantization.
12 */
13
14 #define JPEG_INTERNALS
15 #include "jinclude.h"
16 #include "jpeglib.h"
17 #include "jdct.h" /* Private declarations for DCT subsystem */
18
19
20 /* Private subobject for this module */
21
22 typedef struct {
23 struct jpeg_forward_dct pub; /* public fields */
24
25 /* Pointer to the DCT routine actually in use */
26 forward_DCT_method_ptr do_dct;
27
28 /* The actual post-DCT divisors --- not identical to the quant table
29 * entries, because of scaling (especially for an unnormalized DCT).
30 * Each table is given in normal array order.
31 */
32 DCTELEM * divisors[NUM_QUANT_TBLS];
33
34 #ifdef DCT_FLOAT_SUPPORTED
35 /* Same as above for the floating-point case. */
36 float_DCT_method_ptr do_float_dct;
37 FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
38 #endif
39 } my_fdct_controller;
40
41 typedef my_fdct_controller * my_fdct_ptr;
42
43
44 /*
45 * Initialize for a processing pass.
46 * Verify that all referenced Q-tables are present, and set up
47 * the divisor table for each one.
48 * In the current implementation, DCT of all components is done during
49 * the first pass, even if only some components will be output in the
50 * first scan. Hence all components should be examined here.
51 */
52
53 METHODDEF(void)
54 start_pass_fdctmgr (j_compress_ptr cinfo)
55 {
56 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
57 int ci, qtblno, i;
58 jpeg_component_info *compptr;
59 JQUANT_TBL * qtbl;
60 DCTELEM * dtbl;
61
62 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
63 ci++, compptr++) {
64 qtblno = compptr->quant_tbl_no;
65 /* Make sure specified quantization table is present */
66 if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
67 cinfo->quant_tbl_ptrs[qtblno] == NULL)
68 ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
69 qtbl = cinfo->quant_tbl_ptrs[qtblno];
70 /* Compute divisors for this quant table */
71 /* We may do this more than once for same table, but it's not a big deal */
72 switch (cinfo->dct_method) {
73 #ifdef DCT_ISLOW_SUPPORTED
74 case JDCT_ISLOW:
75 /* For LL&M IDCT method, divisors are equal to raw quantization
76 * coefficients multiplied by 8 (to counteract scaling).
77 */
78 if (fdct->divisors[qtblno] == NULL) {
79 fdct->divisors[qtblno] = (DCTELEM *)
80 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
81 DCTSIZE2 * SIZEOF(DCTELEM));
82 }
83 dtbl = fdct->divisors[qtblno];
84 for (i = 0; i < DCTSIZE2; i++) {
85 dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
86 }
87 break;
88 #endif
89 #ifdef DCT_IFAST_SUPPORTED
90 case JDCT_IFAST:
91 {
92 /* For AA&N IDCT method, divisors are equal to quantization
93 * coefficients scaled by scalefactor[row]*scalefactor[col], where
94 * scalefactor[0] = 1
95 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
96 * We apply a further scale factor of 8.
97 */
98 #define CONST_BITS 14
99 static const INT16 aanscales[DCTSIZE2] = {
100 /* precomputed values scaled up by 14 bits */
101 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
102 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
103 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
104 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
105 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
106 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
107 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
108 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
109 };
110 SHIFT_TEMPS
111
112 if (fdct->divisors[qtblno] == NULL) {
113 fdct->divisors[qtblno] = (DCTELEM *)
114 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
115 DCTSIZE2 * SIZEOF(DCTELEM));
116 }
117 dtbl = fdct->divisors[qtblno];
118 for (i = 0; i < DCTSIZE2; i++) {
119 dtbl[i] = (DCTELEM)
120 DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
121 (INT32) aanscales[i]),
122 CONST_BITS-3);
123 }
124 }
125 break;
126 #endif
127 #ifdef DCT_FLOAT_SUPPORTED
128 case JDCT_FLOAT:
129 {
130 /* For float AA&N IDCT method, divisors are equal to quantization
131 * coefficients scaled by scalefactor[row]*scalefactor[col], where
132 * scalefactor[0] = 1
133 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
134 * We apply a further scale factor of 8.
135 * What's actually stored is 1/divisor so that the inner loop can
136 * use a multiplication rather than a division.
137 */
138 FAST_FLOAT * fdtbl;
139 int row, col;
140 static const double aanscalefactor[DCTSIZE] = {
141 1.0, 1.387039845, 1.306562965, 1.175875602,
142 1.0, 0.785694958, 0.541196100, 0.275899379
143 };
144
145 if (fdct->float_divisors[qtblno] == NULL) {
146 fdct->float_divisors[qtblno] = (FAST_FLOAT *)
147 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
148 DCTSIZE2 * SIZEOF(FAST_FLOAT));
149 }
150 fdtbl = fdct->float_divisors[qtblno];
151 i = 0;
152 for (row = 0; row < DCTSIZE; row++) {
153 for (col = 0; col < DCTSIZE; col++) {
154 fdtbl[i] = (FAST_FLOAT)
155 (1.0 / (((double) qtbl->quantval[i] *
156 aanscalefactor[row] * aanscalefactor[col] * 8.0)));
157 i++;
158 }
159 }
160 }
161 break;
162 #endif
163 default:
164 ERREXIT(cinfo, JERR_NOT_COMPILED);
165 break;
166 }
167 }
168 }
169
170
171 /*
172 * Perform forward DCT on one or more blocks of a component.
173 *
174 * The input samples are taken from the sample_data[] array starting at
175 * position start_row/start_col, and moving to the right for any additional
176 * blocks. The quantized coefficients are returned in coef_blocks[].
177 */
178
179 METHODDEF(void)
180 forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
181 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
182 JDIMENSION start_row, JDIMENSION start_col,
183 JDIMENSION num_blocks)
184 /* This version is used for integer DCT implementations. */
185 {
186 /* This routine is heavily used, so it's worth coding it tightly. */
187 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
188 forward_DCT_method_ptr do_dct = fdct->do_dct;
189 DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
190 DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
191 JDIMENSION bi;
192
193 sample_data += start_row; /* fold in the vertical offset once */
194
195 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
196 /* Load data into workspace, applying unsigned->signed conversion */
197 { register DCTELEM *workspaceptr;
198 register JSAMPROW elemptr;
199 register int elemr;
200
201 workspaceptr = workspace;
202 for (elemr = 0; elemr < DCTSIZE; elemr++) {
203 elemptr = sample_data[elemr] + start_col;
204 #if DCTSIZE == 8 /* unroll the inner loop */
205 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
206 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
207 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
208 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
209 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
210 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
211 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
212 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
213 #else
214 { register int elemc;
215 for (elemc = DCTSIZE; elemc > 0; elemc--) {
216 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
217 }
218 }
219 #endif
220 }
221 }
222
223 /* Perform the DCT */
224 (*do_dct) (workspace);
225
226 /* Quantize/descale the coefficients, and store into coef_blocks[] */
227 { register DCTELEM temp, qval;
228 register int i;
229 register JCOEFPTR output_ptr = coef_blocks[bi];
230
231 for (i = 0; i < DCTSIZE2; i++) {
232 qval = divisors[i];
233 temp = workspace[i];
234 /* Divide the coefficient value by qval, ensuring proper rounding.
235 * Since C does not specify the direction of rounding for negative
236 * quotients, we have to force the dividend positive for portability.
237 *
238 * In most files, at least half of the output values will be zero
239 * (at default quantization settings, more like three-quarters...)
240 * so we should ensure that this case is fast. On many machines,
241 * a comparison is enough cheaper than a divide to make a special test
242 * a win. Since both inputs will be nonnegative, we need only test
243 * for a < b to discover whether a/b is 0.
244 * If your machine's division is fast enough, define FAST_DIVIDE.
245 */
246 #ifdef FAST_DIVIDE
247 #define DIVIDE_BY(a,b) a /= b
248 #else
249 #define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
250 #endif
251 if (temp < 0) {
252 temp = -temp;
253 temp += qval>>1; /* for rounding */
254 DIVIDE_BY(temp, qval);
255 temp = -temp;
256 } else {
257 temp += qval>>1; /* for rounding */
258 DIVIDE_BY(temp, qval);
259 }
260 output_ptr[i] = (JCOEF) temp;
261 }
262 }
263 }
264 }
265
266
267 #ifdef DCT_FLOAT_SUPPORTED
268
269 METHODDEF(void)
270 forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
271 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
272 JDIMENSION start_row, JDIMENSION start_col,
273 JDIMENSION num_blocks)
274 /* This version is used for floating-point DCT implementations. */
275 {
276 /* This routine is heavily used, so it's worth coding it tightly. */
277 my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
278 float_DCT_method_ptr do_dct = fdct->do_float_dct;
279 FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
280 FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
281 JDIMENSION bi;
282
283 sample_data += start_row; /* fold in the vertical offset once */
284
285 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
286 /* Load data into workspace, applying unsigned->signed conversion */
287 { register FAST_FLOAT *workspaceptr;
288 register JSAMPROW elemptr;
289 register int elemr;
290
291 workspaceptr = workspace;
292 for (elemr = 0; elemr < DCTSIZE; elemr++) {
293 elemptr = sample_data[elemr] + start_col;
294 #if DCTSIZE == 8 /* unroll the inner loop */
295 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
296 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
297 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
298 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
299 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
300 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
301 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
302 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
303 #else
304 { register int elemc;
305 for (elemc = DCTSIZE; elemc > 0; elemc--) {
306 *workspaceptr++ = (FAST_FLOAT)
307 (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
308 }
309 }
310 #endif
311 }
312 }
313
314 /* Perform the DCT */
315 (*do_dct) (workspace);
316
317 /* Quantize/descale the coefficients, and store into coef_blocks[] */
318 { register FAST_FLOAT temp;
319 register int i;
320 register JCOEFPTR output_ptr = coef_blocks[bi];
321
322 for (i = 0; i < DCTSIZE2; i++) {
323 /* Apply the quantization and scaling factor */
324 temp = workspace[i] * divisors[i];
325 /* Round to nearest integer.
326 * Since C does not specify the direction of rounding for negative
327 * quotients, we have to force the dividend positive for portability.
328 * The maximum coefficient size is +-16K (for 12-bit data), so this
329 * code should work for either 16-bit or 32-bit ints.
330 */
331 output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
332 }
333 }
334 }
335 }
336
337 #endif /* DCT_FLOAT_SUPPORTED */
338
339
340 /*
341 * Initialize FDCT manager.
342 */
343
344 GLOBAL(void)
345 jinit_forward_dct (j_compress_ptr cinfo)
346 {
347 my_fdct_ptr fdct;
348 int i;
349
350 fdct = (my_fdct_ptr)
351 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
352 SIZEOF(my_fdct_controller));
353 cinfo->fdct = (struct jpeg_forward_dct *) fdct;
354 fdct->pub.start_pass = start_pass_fdctmgr;
355
356 switch (cinfo->dct_method) {
357 #ifdef DCT_ISLOW_SUPPORTED
358 case JDCT_ISLOW:
359 fdct->pub.forward_DCT = forward_DCT;
360 fdct->do_dct = jpeg_fdct_islow;
361 break;
362 #endif
363 #ifdef DCT_IFAST_SUPPORTED
364 case JDCT_IFAST:
365 fdct->pub.forward_DCT = forward_DCT;
366 fdct->do_dct = jpeg_fdct_ifast;
367 break;
368 #endif
369 #ifdef DCT_FLOAT_SUPPORTED
370 case JDCT_FLOAT:
371 fdct->pub.forward_DCT = forward_DCT_float;
372 fdct->do_float_dct = jpeg_fdct_float;
373 break;
374 #endif
375 default:
376 ERREXIT(cinfo, JERR_NOT_COMPILED);
377 break;
378 }
379
380 /* Mark divisor tables unallocated */
381 for (i = 0; i < NUM_QUANT_TBLS; i++) {
382 fdct->divisors[i] = NULL;
383 #ifdef DCT_FLOAT_SUPPORTED
384 fdct->float_divisors[i] = NULL;
385 #endif
386 }
387 }
DESCALE
#define DESCALE(x, n)
Definition: jdct.h:146
CENTERJSAMPLE
#define CENTERJSAMPLE
Definition: jmorecfg.h:74
DIVIDE_BY
#define DIVIDE_BY(a, b)
my_fdct_controller::do_dct
forward_DCT_method_ptr do_dct
Definition: jcdctmgr.c:26
my_fdct_ptr
my_fdct_controller * my_fdct_ptr
Definition: jcdctmgr.c:41
INT16
short INT16
Definition: jmorecfg.h:155
JSAMPROW
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:66
NUM_QUANT_TBLS
#define NUM_QUANT_TBLS
Definition: jpeglib.h:43
my_fdct_controller::float_divisors
FAST_FLOAT * float_divisors[NUM_QUANT_TBLS]
Definition: jcdctmgr.c:37
forward_DCT_float
forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
Definition: jcdctmgr.c:270
j_common_ptr
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
DCTELEM
INT32 DCTELEM
Definition: jdct.h:32
GETJSAMPLE
#define GETJSAMPLE(value)
Definition: jmorecfg.h:68
JQUANT_TBL
Definition: jpeglib.h:83
jdct.h
ERREXIT
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
forward_DCT
forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
Definition: jcdctmgr.c:180
SIZEOF
#define SIZEOF(object)
Definition: jinclude.h:80
JCOEF
short JCOEF
Definition: jmorecfg.h:99
INT32
long INT32
Definition: jmorecfg.h:161
SHIFT_TEMPS
#define SHIFT_TEMPS
Definition: jpegint.h:289
JDCT_IFAST
Definition: jpeglib.h:219
jinit_forward_dct
jinit_forward_dct(j_compress_ptr cinfo)
Definition: jcdctmgr.c:345
compptr
jpeg_component_info * compptr
Definition: jdct.h:102
jpeg_forward_dct
Definition: jpegint.h:102
JPOOL_IMAGE
#define JPOOL_IMAGE
Definition: jpeglib.h:749
my_fdct_controller::divisors
DCTELEM * divisors[NUM_QUANT_TBLS]
Definition: jcdctmgr.c:32
my_fdct_controller::do_float_dct
float_DCT_method_ptr do_float_dct
Definition: jcdctmgr.c:36
jpeg_component_info::quant_tbl_no
int quant_tbl_no
Definition: jpeglib.h:124
DCTSIZE2
#define DCTSIZE2
Definition: jpeglib.h:42
num_blocks
JBLOCKROW JDIMENSION num_blocks
Definition: jpegint.h:376
jpeg_fdct_float
jpeg_fdct_float(FAST_FLOAT *data)
Definition: jfdctflt.c:59
JBLOCKROW
JBLOCK FAR * JBLOCKROW
Definition: jpeglib.h:71
my_fdct_controller::pub
struct jpeg_forward_dct pub
Definition: jcdctmgr.c:23
JCOEFPTR
JCOEF FAR * JCOEFPTR
Definition: jpeglib.h:75
CONST_BITS
#define CONST_BITS
jinclude.h
my_fdct_controller
Definition: jcdctmgr.c:22
ERREXIT1
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:208
jpeg_fdct_islow
jpeg_fdct_islow(DCTELEM *data)
Definition: jfdctint.c:140
jpeg_compress_struct
Definition: jpeglib.h:268
JSAMPARRAY
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:67
jpeg_component_info
Definition: jpeglib.h:116
GLOBAL
#define GLOBAL(type)
Definition: jmorecfg.h:188
METHODDEF
#define METHODDEF(type)
Definition: jmorecfg.h:184
JDCT_FLOAT
Definition: jpeglib.h:220
start_pass_fdctmgr
start_pass_fdctmgr(j_compress_ptr cinfo)
Definition: jcdctmgr.c:54
DCTSIZE
#define DCTSIZE
Definition: jpeglib.h:41
JDIMENSION
unsigned int JDIMENSION
Definition: jmorecfg.h:171
jpeg_fdct_ifast
jpeg_fdct_ifast(DCTELEM *data)
Definition: jfdctfst.c:114
jpeglib.h
JDCT_ISLOW
Definition: jpeglib.h:218
MULTIPLY16V16
#define MULTIPLY16V16(var1, var2)
Definition: jdct.h:175