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