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