1/*
2 * jcdctmgr.c
3 *
4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1994-1996, Thomas G. Lane.
6 * libjpeg-turbo Modifications:
7 * Copyright (C) 1999-2006, MIYASAKA Masaru.
8 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 * Copyright (C) 2011, 2014-2015, D. R. Commander.
10 * For conditions of distribution and use, see the accompanying README.ijg
11 * file.
12 *
13 * This file contains the forward-DCT management logic.
14 * This code selects a particular DCT implementation to be used,
15 * and it performs related housekeeping chores including coefficient
16 * quantization.
17 */
18
19#define JPEG_INTERNALS
20#include "jinclude.h"
21#include "jpeglib.h"
22#include "jdct.h" /* Private declarations for DCT subsystem */
23#include "jsimddct.h"
24
25
26/* Private subobject for this module */
27
28typedef void (*forward_DCT_method_ptr) (DCTELEM *data);
29typedef void (*float_DCT_method_ptr) (FAST_FLOAT *data);
30
31typedef void (*convsamp_method_ptr) (JSAMPARRAY sample_data,
32 JDIMENSION start_col,
33 DCTELEM *workspace);
34typedef void (*float_convsamp_method_ptr) (JSAMPARRAY sample_data,
35 JDIMENSION start_col,
36 FAST_FLOAT *workspace);
37
38typedef void (*quantize_method_ptr) (JCOEFPTR coef_block, DCTELEM *divisors,
39 DCTELEM *workspace);
40typedef void (*float_quantize_method_ptr) (JCOEFPTR coef_block,
41 FAST_FLOAT *divisors,
42 FAST_FLOAT *workspace);
43
44METHODDEF(void) quantize(JCOEFPTR, DCTELEM *, DCTELEM *);
45
46typedef struct {
47 struct jpeg_forward_dct pub; /* public fields */
48
49 /* Pointer to the DCT routine actually in use */
50 forward_DCT_method_ptr dct;
51 convsamp_method_ptr convsamp;
52 quantize_method_ptr quantize;
53
54 /* The actual post-DCT divisors --- not identical to the quant table
55 * entries, because of scaling (especially for an unnormalized DCT).
56 * Each table is given in normal array order.
57 */
58 DCTELEM *divisors[NUM_QUANT_TBLS];
59
60 /* work area for FDCT subroutine */
61 DCTELEM *workspace;
62
63#ifdef DCT_FLOAT_SUPPORTED
64 /* Same as above for the floating-point case. */
65 float_DCT_method_ptr float_dct;
66 float_convsamp_method_ptr float_convsamp;
67 float_quantize_method_ptr float_quantize;
68 FAST_FLOAT *float_divisors[NUM_QUANT_TBLS];
69 FAST_FLOAT *float_workspace;
70#endif
71} my_fdct_controller;
72
73typedef my_fdct_controller *my_fdct_ptr;
74
75
76#if BITS_IN_JSAMPLE == 8
77
78/*
79 * Find the highest bit in an integer through binary search.
80 */
81
82LOCAL(int)
83flss(UINT16 val)
84{
85 int bit;
86
87 bit = 16;
88
89 if (!val)
90 return 0;
91
92 if (!(val & 0xff00)) {
93 bit -= 8;
94 val <<= 8;
95 }
96 if (!(val & 0xf000)) {
97 bit -= 4;
98 val <<= 4;
99 }
100 if (!(val & 0xc000)) {
101 bit -= 2;
102 val <<= 2;
103 }
104 if (!(val & 0x8000)) {
105 bit -= 1;
106 val <<= 1;
107 }
108
109 return bit;
110}
111
112
113/*
114 * Compute values to do a division using reciprocal.
115 *
116 * This implementation is based on an algorithm described in
117 * "How to optimize for the Pentium family of microprocessors"
118 * (http://www.agner.org/assem/).
119 * More information about the basic algorithm can be found in
120 * the paper "Integer Division Using Reciprocals" by Robert Alverson.
121 *
122 * The basic idea is to replace x/d by x * d^-1. In order to store
123 * d^-1 with enough precision we shift it left a few places. It turns
124 * out that this algoright gives just enough precision, and also fits
125 * into DCTELEM:
126 *
127 * b = (the number of significant bits in divisor) - 1
128 * r = (word size) + b
129 * f = 2^r / divisor
130 *
131 * f will not be an integer for most cases, so we need to compensate
132 * for the rounding error introduced:
133 *
134 * no fractional part:
135 *
136 * result = input >> r
137 *
138 * fractional part of f < 0.5:
139 *
140 * round f down to nearest integer
141 * result = ((input + 1) * f) >> r
142 *
143 * fractional part of f > 0.5:
144 *
145 * round f up to nearest integer
146 * result = (input * f) >> r
147 *
148 * This is the original algorithm that gives truncated results. But we
149 * want properly rounded results, so we replace "input" with
150 * "input + divisor/2".
151 *
152 * In order to allow SIMD implementations we also tweak the values to
153 * allow the same calculation to be made at all times:
154 *
155 * dctbl[0] = f rounded to nearest integer
156 * dctbl[1] = divisor / 2 (+ 1 if fractional part of f < 0.5)
157 * dctbl[2] = 1 << ((word size) * 2 - r)
158 * dctbl[3] = r - (word size)
159 *
160 * dctbl[2] is for stupid instruction sets where the shift operation
161 * isn't member wise (e.g. MMX).
162 *
163 * The reason dctbl[2] and dctbl[3] reduce the shift with (word size)
164 * is that most SIMD implementations have a "multiply and store top
165 * half" operation.
166 *
167 * Lastly, we store each of the values in their own table instead
168 * of in a consecutive manner, yet again in order to allow SIMD
169 * routines.
170 */
171
172LOCAL(int)
173compute_reciprocal(UINT16 divisor, DCTELEM *dtbl)
174{
175 UDCTELEM2 fq, fr;
176 UDCTELEM c;
177 int b, r;
178
179 if (divisor == 1) {
180 /* divisor == 1 means unquantized, so these reciprocal/correction/shift
181 * values will cause the C quantization algorithm to act like the
182 * identity function. Since only the C quantization algorithm is used in
183 * these cases, the scale value is irrelevant.
184 */
185 dtbl[DCTSIZE2 * 0] = (DCTELEM)1; /* reciprocal */
186 dtbl[DCTSIZE2 * 1] = (DCTELEM)0; /* correction */
187 dtbl[DCTSIZE2 * 2] = (DCTELEM)1; /* scale */
188 dtbl[DCTSIZE2 * 3] = -(DCTELEM)(sizeof(DCTELEM) * 8); /* shift */
189 return 0;
190 }
191
192 b = flss(divisor) - 1;
193 r = sizeof(DCTELEM) * 8 + b;
194
195 fq = ((UDCTELEM2)1 << r) / divisor;
196 fr = ((UDCTELEM2)1 << r) % divisor;
197
198 c = divisor / 2; /* for rounding */
199
200 if (fr == 0) { /* divisor is power of two */
201 /* fq will be one bit too large to fit in DCTELEM, so adjust */
202 fq >>= 1;
203 r--;
204 } else if (fr <= (divisor / 2U)) { /* fractional part is < 0.5 */
205 c++;
206 } else { /* fractional part is > 0.5 */
207 fq++;
208 }
209
210 dtbl[DCTSIZE2 * 0] = (DCTELEM)fq; /* reciprocal */
211 dtbl[DCTSIZE2 * 1] = (DCTELEM)c; /* correction + roundfactor */
212#ifdef WITH_SIMD
213 dtbl[DCTSIZE2 * 2] = (DCTELEM)(1 << (sizeof(DCTELEM) * 8 * 2 - r)); /* scale */
214#else
215 dtbl[DCTSIZE2 * 2] = 1;
216#endif
217 dtbl[DCTSIZE2 * 3] = (DCTELEM)r - sizeof(DCTELEM) * 8; /* shift */
218
219 if (r <= 16) return 0;
220 else return 1;
221}
222
223#endif
224
225
226/*
227 * Initialize for a processing pass.
228 * Verify that all referenced Q-tables are present, and set up
229 * the divisor table for each one.
230 * In the current implementation, DCT of all components is done during
231 * the first pass, even if only some components will be output in the
232 * first scan. Hence all components should be examined here.
233 */
234
235METHODDEF(void)
236start_pass_fdctmgr(j_compress_ptr cinfo)
237{
238 my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
239 int ci, qtblno, i;
240 jpeg_component_info *compptr;
241 JQUANT_TBL *qtbl;
242 DCTELEM *dtbl;
243
244 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
245 ci++, compptr++) {
246 qtblno = compptr->quant_tbl_no;
247 /* Make sure specified quantization table is present */
248 if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
249 cinfo->quant_tbl_ptrs[qtblno] == NULL)
250 ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
251 qtbl = cinfo->quant_tbl_ptrs[qtblno];
252 /* Compute divisors for this quant table */
253 /* We may do this more than once for same table, but it's not a big deal */
254 switch (cinfo->dct_method) {
255#ifdef DCT_ISLOW_SUPPORTED
256 case JDCT_ISLOW:
257 /* For LL&M IDCT method, divisors are equal to raw quantization
258 * coefficients multiplied by 8 (to counteract scaling).
259 */
260 if (fdct->divisors[qtblno] == NULL) {
261 fdct->divisors[qtblno] = (DCTELEM *)
262 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
263 (DCTSIZE2 * 4) * sizeof(DCTELEM));
264 }
265 dtbl = fdct->divisors[qtblno];
266 for (i = 0; i < DCTSIZE2; i++) {
267#if BITS_IN_JSAMPLE == 8
268 if (!compute_reciprocal(qtbl->quantval[i] << 3, &dtbl[i]) &&
269 fdct->quantize == jsimd_quantize)
270 fdct->quantize = quantize;
271#else
272 dtbl[i] = ((DCTELEM)qtbl->quantval[i]) << 3;
273#endif
274 }
275 break;
276#endif
277#ifdef DCT_IFAST_SUPPORTED
278 case JDCT_IFAST:
279 {
280 /* For AA&N IDCT method, divisors are equal to quantization
281 * coefficients scaled by scalefactor[row]*scalefactor[col], where
282 * scalefactor[0] = 1
283 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
284 * We apply a further scale factor of 8.
285 */
286#define CONST_BITS 14
287 static const INT16 aanscales[DCTSIZE2] = {
288 /* precomputed values scaled up by 14 bits */
289 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
290 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
291 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
292 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
293 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
294 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
295 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
296 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
297 };
298 SHIFT_TEMPS
299
300 if (fdct->divisors[qtblno] == NULL) {
301 fdct->divisors[qtblno] = (DCTELEM *)
302 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
303 (DCTSIZE2 * 4) * sizeof(DCTELEM));
304 }
305 dtbl = fdct->divisors[qtblno];
306 for (i = 0; i < DCTSIZE2; i++) {
307#if BITS_IN_JSAMPLE == 8
308 if (!compute_reciprocal(
309 DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
310 (JLONG)aanscales[i]),
311 CONST_BITS - 3), &dtbl[i]) &&
312 fdct->quantize == jsimd_quantize)
313 fdct->quantize = quantize;
314#else
315 dtbl[i] = (DCTELEM)
316 DESCALE(MULTIPLY16V16((JLONG)qtbl->quantval[i],
317 (JLONG)aanscales[i]),
318 CONST_BITS - 3);
319#endif
320 }
321 }
322 break;
323#endif
324#ifdef DCT_FLOAT_SUPPORTED
325 case JDCT_FLOAT:
326 {
327 /* For float AA&N IDCT method, divisors are equal to quantization
328 * coefficients scaled by scalefactor[row]*scalefactor[col], where
329 * scalefactor[0] = 1
330 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
331 * We apply a further scale factor of 8.
332 * What's actually stored is 1/divisor so that the inner loop can
333 * use a multiplication rather than a division.
334 */
335 FAST_FLOAT *fdtbl;
336 int row, col;
337 static const double aanscalefactor[DCTSIZE] = {
338 1.0, 1.387039845, 1.306562965, 1.175875602,
339 1.0, 0.785694958, 0.541196100, 0.275899379
340 };
341
342 if (fdct->float_divisors[qtblno] == NULL) {
343 fdct->float_divisors[qtblno] = (FAST_FLOAT *)
344 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
345 DCTSIZE2 * sizeof(FAST_FLOAT));
346 }
347 fdtbl = fdct->float_divisors[qtblno];
348 i = 0;
349 for (row = 0; row < DCTSIZE; row++) {
350 for (col = 0; col < DCTSIZE; col++) {
351 fdtbl[i] = (FAST_FLOAT)
352 (1.0 / (((double)qtbl->quantval[i] *
353 aanscalefactor[row] * aanscalefactor[col] * 8.0)));
354 i++;
355 }
356 }
357 }
358 break;
359#endif
360 default:
361 ERREXIT(cinfo, JERR_NOT_COMPILED);
362 break;
363 }
364 }
365}
366
367
368/*
369 * Load data into workspace, applying unsigned->signed conversion.
370 */
371
372METHODDEF(void)
373convsamp(JSAMPARRAY sample_data, JDIMENSION start_col, DCTELEM *workspace)
374{
375 register DCTELEM *workspaceptr;
376 register JSAMPROW elemptr;
377 register int elemr;
378
379 workspaceptr = workspace;
380 for (elemr = 0; elemr < DCTSIZE; elemr++) {
381 elemptr = sample_data[elemr] + start_col;
382
383#if DCTSIZE == 8 /* unroll the inner loop */
384 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
385 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
386 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
387 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
388 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
389 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
390 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
391 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
392#else
393 {
394 register int elemc;
395 for (elemc = DCTSIZE; elemc > 0; elemc--)
396 *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
397 }
398#endif
399 }
400}
401
402
403/*
404 * Quantize/descale the coefficients, and store into coef_blocks[].
405 */
406
407METHODDEF(void)
408quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
409{
410 int i;
411 DCTELEM temp;
412 JCOEFPTR output_ptr = coef_block;
413
414#if BITS_IN_JSAMPLE == 8
415
416 UDCTELEM recip, corr;
417 int shift;
418 UDCTELEM2 product;
419
420 for (i = 0; i < DCTSIZE2; i++) {
421 temp = workspace[i];
422 recip = divisors[i + DCTSIZE2 * 0];
423 corr = divisors[i + DCTSIZE2 * 1];
424 shift = divisors[i + DCTSIZE2 * 3];
425
426 if (temp < 0) {
427 temp = -temp;
428 product = (UDCTELEM2)(temp + corr) * recip;
429 product >>= shift + sizeof(DCTELEM) * 8;
430 temp = (DCTELEM)product;
431 temp = -temp;
432 } else {
433 product = (UDCTELEM2)(temp + corr) * recip;
434 product >>= shift + sizeof(DCTELEM) * 8;
435 temp = (DCTELEM)product;
436 }
437 output_ptr[i] = (JCOEF)temp;
438 }
439
440#else
441
442 register DCTELEM qval;
443
444 for (i = 0; i < DCTSIZE2; i++) {
445 qval = divisors[i];
446 temp = workspace[i];
447 /* Divide the coefficient value by qval, ensuring proper rounding.
448 * Since C does not specify the direction of rounding for negative
449 * quotients, we have to force the dividend positive for portability.
450 *
451 * In most files, at least half of the output values will be zero
452 * (at default quantization settings, more like three-quarters...)
453 * so we should ensure that this case is fast. On many machines,
454 * a comparison is enough cheaper than a divide to make a special test
455 * a win. Since both inputs will be nonnegative, we need only test
456 * for a < b to discover whether a/b is 0.
457 * If your machine's division is fast enough, define FAST_DIVIDE.
458 */
459#ifdef FAST_DIVIDE
460#define DIVIDE_BY(a, b) a /= b
461#else
462#define DIVIDE_BY(a, b) if (a >= b) a /= b; else a = 0
463#endif
464 if (temp < 0) {
465 temp = -temp;
466 temp += qval >> 1; /* for rounding */
467 DIVIDE_BY(temp, qval);
468 temp = -temp;
469 } else {
470 temp += qval >> 1; /* for rounding */
471 DIVIDE_BY(temp, qval);
472 }
473 output_ptr[i] = (JCOEF)temp;
474 }
475
476#endif
477
478}
479
480
481/*
482 * Perform forward DCT on one or more blocks of a component.
483 *
484 * The input samples are taken from the sample_data[] array starting at
485 * position start_row/start_col, and moving to the right for any additional
486 * blocks. The quantized coefficients are returned in coef_blocks[].
487 */
488
489METHODDEF(void)
490forward_DCT(j_compress_ptr cinfo, jpeg_component_info *compptr,
491 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
492 JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)
493/* This version is used for integer DCT implementations. */
494{
495 /* This routine is heavily used, so it's worth coding it tightly. */
496 my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
497 DCTELEM *divisors = fdct->divisors[compptr->quant_tbl_no];
498 DCTELEM *workspace;
499 JDIMENSION bi;
500
501 /* Make sure the compiler doesn't look up these every pass */
502 forward_DCT_method_ptr do_dct = fdct->dct;
503 convsamp_method_ptr do_convsamp = fdct->convsamp;
504 quantize_method_ptr do_quantize = fdct->quantize;
505 workspace = fdct->workspace;
506
507 sample_data += start_row; /* fold in the vertical offset once */
508
509 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
510 /* Load data into workspace, applying unsigned->signed conversion */
511 (*do_convsamp) (sample_data, start_col, workspace);
512
513 /* Perform the DCT */
514 (*do_dct) (workspace);
515
516 /* Quantize/descale the coefficients, and store into coef_blocks[] */
517 (*do_quantize) (coef_blocks[bi], divisors, workspace);
518 }
519}
520
521
522#ifdef DCT_FLOAT_SUPPORTED
523
524METHODDEF(void)
525convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
526 FAST_FLOAT *workspace)
527{
528 register FAST_FLOAT *workspaceptr;
529 register JSAMPROW elemptr;
530 register int elemr;
531
532 workspaceptr = workspace;
533 for (elemr = 0; elemr < DCTSIZE; elemr++) {
534 elemptr = sample_data[elemr] + start_col;
535#if DCTSIZE == 8 /* unroll the inner loop */
536 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
537 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
538 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
539 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
540 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
541 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
542 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
543 *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
544#else
545 {
546 register int elemc;
547 for (elemc = DCTSIZE; elemc > 0; elemc--)
548 *workspaceptr++ = (FAST_FLOAT)
549 (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
550 }
551#endif
552 }
553}
554
555
556METHODDEF(void)
557quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
558 FAST_FLOAT *workspace)
559{
560 register FAST_FLOAT temp;
561 register int i;
562 register JCOEFPTR output_ptr = coef_block;
563
564 for (i = 0; i < DCTSIZE2; i++) {
565 /* Apply the quantization and scaling factor */
566 temp = workspace[i] * divisors[i];
567
568 /* Round to nearest integer.
569 * Since C does not specify the direction of rounding for negative
570 * quotients, we have to force the dividend positive for portability.
571 * The maximum coefficient size is +-16K (for 12-bit data), so this
572 * code should work for either 16-bit or 32-bit ints.
573 */
574 output_ptr[i] = (JCOEF)((int)(temp + (FAST_FLOAT)16384.5) - 16384);
575 }
576}
577
578
579METHODDEF(void)
580forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr,
581 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
582 JDIMENSION start_row, JDIMENSION start_col,
583 JDIMENSION num_blocks)
584/* This version is used for floating-point DCT implementations. */
585{
586 /* This routine is heavily used, so it's worth coding it tightly. */
587 my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
588 FAST_FLOAT *divisors = fdct->float_divisors[compptr->quant_tbl_no];
589 FAST_FLOAT *workspace;
590 JDIMENSION bi;
591
592
593 /* Make sure the compiler doesn't look up these every pass */
594 float_DCT_method_ptr do_dct = fdct->float_dct;
595 float_convsamp_method_ptr do_convsamp = fdct->float_convsamp;
596 float_quantize_method_ptr do_quantize = fdct->float_quantize;
597 workspace = fdct->float_workspace;
598
599 sample_data += start_row; /* fold in the vertical offset once */
600
601 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
602 /* Load data into workspace, applying unsigned->signed conversion */
603 (*do_convsamp) (sample_data, start_col, workspace);
604
605 /* Perform the DCT */
606 (*do_dct) (workspace);
607
608 /* Quantize/descale the coefficients, and store into coef_blocks[] */
609 (*do_quantize) (coef_blocks[bi], divisors, workspace);
610 }
611}
612
613#endif /* DCT_FLOAT_SUPPORTED */
614
615
616/*
617 * Initialize FDCT manager.
618 */
619
620GLOBAL(void)
621jinit_forward_dct(j_compress_ptr cinfo)
622{
623 my_fdct_ptr fdct;
624 int i;
625
626 fdct = (my_fdct_ptr)
627 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
628 sizeof(my_fdct_controller));
629 cinfo->fdct = (struct jpeg_forward_dct *)fdct;
630 fdct->pub.start_pass = start_pass_fdctmgr;
631
632 /* First determine the DCT... */
633 switch (cinfo->dct_method) {
634#ifdef DCT_ISLOW_SUPPORTED
635 case JDCT_ISLOW:
636 fdct->pub.forward_DCT = forward_DCT;
637 if (jsimd_can_fdct_islow())
638 fdct->dct = jsimd_fdct_islow;
639 else
640 fdct->dct = jpeg_fdct_islow;
641 break;
642#endif
643#ifdef DCT_IFAST_SUPPORTED
644 case JDCT_IFAST:
645 fdct->pub.forward_DCT = forward_DCT;
646 if (jsimd_can_fdct_ifast())
647 fdct->dct = jsimd_fdct_ifast;
648 else
649 fdct->dct = jpeg_fdct_ifast;
650 break;
651#endif
652#ifdef DCT_FLOAT_SUPPORTED
653 case JDCT_FLOAT:
654 fdct->pub.forward_DCT = forward_DCT_float;
655 if (jsimd_can_fdct_float())
656 fdct->float_dct = jsimd_fdct_float;
657 else
658 fdct->float_dct = jpeg_fdct_float;
659 break;
660#endif
661 default:
662 ERREXIT(cinfo, JERR_NOT_COMPILED);
663 break;
664 }
665
666 /* ...then the supporting stages. */
667 switch (cinfo->dct_method) {
668#ifdef DCT_ISLOW_SUPPORTED
669 case JDCT_ISLOW:
670#endif
671#ifdef DCT_IFAST_SUPPORTED
672 case JDCT_IFAST:
673#endif
674#if defined(DCT_ISLOW_SUPPORTED) || defined(DCT_IFAST_SUPPORTED)
675 if (jsimd_can_convsamp())
676 fdct->convsamp = jsimd_convsamp;
677 else
678 fdct->convsamp = convsamp;
679 if (jsimd_can_quantize())
680 fdct->quantize = jsimd_quantize;
681 else
682 fdct->quantize = quantize;
683 break;
684#endif
685#ifdef DCT_FLOAT_SUPPORTED
686 case JDCT_FLOAT:
687 if (jsimd_can_convsamp_float())
688 fdct->float_convsamp = jsimd_convsamp_float;
689 else
690 fdct->float_convsamp = convsamp_float;
691 if (jsimd_can_quantize_float())
692 fdct->float_quantize = jsimd_quantize_float;
693 else
694 fdct->float_quantize = quantize_float;
695 break;
696#endif
697 default:
698 ERREXIT(cinfo, JERR_NOT_COMPILED);
699 break;
700 }
701
702 /* Allocate workspace memory */
703#ifdef DCT_FLOAT_SUPPORTED
704 if (cinfo->dct_method == JDCT_FLOAT)
705 fdct->float_workspace = (FAST_FLOAT *)
706 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
707 sizeof(FAST_FLOAT) * DCTSIZE2);
708 else
709#endif
710 fdct->workspace = (DCTELEM *)
711 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
712 sizeof(DCTELEM) * DCTSIZE2);
713
714 /* Mark divisor tables unallocated */
715 for (i = 0; i < NUM_QUANT_TBLS; i++) {
716 fdct->divisors[i] = NULL;
717#ifdef DCT_FLOAT_SUPPORTED
718 fdct->float_divisors[i] = NULL;
719#endif
720 }
721}
722