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 <[email protected]> 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++ = (*elemptr++) - CENTERJSAMPLE;
385 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
386 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
387 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
388 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
389 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
390 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
391 *workspaceptr++ = (*elemptr++) - CENTERJSAMPLE;
392#else
393 {
394 register int elemc;
395 for (elemc = DCTSIZE; elemc > 0; elemc--)
396 *workspaceptr++ = (*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)((*elemptr++) - CENTERJSAMPLE);
537 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
538 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
539 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
540 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
541 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
542 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
543 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
544#else
545 {
546 register int elemc;
547 for (elemc = DCTSIZE; elemc > 0; elemc--)
548 *workspaceptr++ = (FAST_FLOAT)((*elemptr++) - CENTERJSAMPLE);
549 }
550#endif
551 }
552}
553
554
555METHODDEF(void)
556quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
557 FAST_FLOAT *workspace)
558{
559 register FAST_FLOAT temp;
560 register int i;
561 register JCOEFPTR output_ptr = coef_block;
562
563 for (i = 0; i < DCTSIZE2; i++) {
564 /* Apply the quantization and scaling factor */
565 temp = workspace[i] * divisors[i];
566
567 /* Round to nearest integer.
568 * Since C does not specify the direction of rounding for negative
569 * quotients, we have to force the dividend positive for portability.
570 * The maximum coefficient size is +-16K (for 12-bit data), so this
571 * code should work for either 16-bit or 32-bit ints.
572 */
573 output_ptr[i] = (JCOEF)((int)(temp + (FAST_FLOAT)16384.5) - 16384);
574 }
575}
576
577
578METHODDEF(void)
579forward_DCT_float(j_compress_ptr cinfo, jpeg_component_info *compptr,
580 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
581 JDIMENSION start_row, JDIMENSION start_col,
582 JDIMENSION num_blocks)
583/* This version is used for floating-point DCT implementations. */
584{
585 /* This routine is heavily used, so it's worth coding it tightly. */
586 my_fdct_ptr fdct = (my_fdct_ptr)cinfo->fdct;
587 FAST_FLOAT *divisors = fdct->float_divisors[compptr->quant_tbl_no];
588 FAST_FLOAT *workspace;
589 JDIMENSION bi;
590
591
592 /* Make sure the compiler doesn't look up these every pass */
593 float_DCT_method_ptr do_dct = fdct->float_dct;
594 float_convsamp_method_ptr do_convsamp = fdct->float_convsamp;
595 float_quantize_method_ptr do_quantize = fdct->float_quantize;
596 workspace = fdct->float_workspace;
597
598 sample_data += start_row; /* fold in the vertical offset once */
599
600 for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
601 /* Load data into workspace, applying unsigned->signed conversion */
602 (*do_convsamp) (sample_data, start_col, workspace);
603
604 /* Perform the DCT */
605 (*do_dct) (workspace);
606
607 /* Quantize/descale the coefficients, and store into coef_blocks[] */
608 (*do_quantize) (coef_blocks[bi], divisors, workspace);
609 }
610}
611
612#endif /* DCT_FLOAT_SUPPORTED */
613
614
615/*
616 * Initialize FDCT manager.
617 */
618
619GLOBAL(void)
620jinit_forward_dct(j_compress_ptr cinfo)
621{
622 my_fdct_ptr fdct;
623 int i;
624
625 fdct = (my_fdct_ptr)
626 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
627 sizeof(my_fdct_controller));
628 cinfo->fdct = (struct jpeg_forward_dct *)fdct;
629 fdct->pub.start_pass = start_pass_fdctmgr;
630
631 /* First determine the DCT... */
632 switch (cinfo->dct_method) {
633#ifdef DCT_ISLOW_SUPPORTED
634 case JDCT_ISLOW:
635 fdct->pub.forward_DCT = forward_DCT;
636 if (jsimd_can_fdct_islow())
637 fdct->dct = jsimd_fdct_islow;
638 else
639 fdct->dct = jpeg_fdct_islow;
640 break;
641#endif
642#ifdef DCT_IFAST_SUPPORTED
643 case JDCT_IFAST:
644 fdct->pub.forward_DCT = forward_DCT;
645 if (jsimd_can_fdct_ifast())
646 fdct->dct = jsimd_fdct_ifast;
647 else
648 fdct->dct = jpeg_fdct_ifast;
649 break;
650#endif
651#ifdef DCT_FLOAT_SUPPORTED
652 case JDCT_FLOAT:
653 fdct->pub.forward_DCT = forward_DCT_float;
654 if (jsimd_can_fdct_float())
655 fdct->float_dct = jsimd_fdct_float;
656 else
657 fdct->float_dct = jpeg_fdct_float;
658 break;
659#endif
660 default:
661 ERREXIT(cinfo, JERR_NOT_COMPILED);
662 break;
663 }
664
665 /* ...then the supporting stages. */
666 switch (cinfo->dct_method) {
667#ifdef DCT_ISLOW_SUPPORTED
668 case JDCT_ISLOW:
669#endif
670#ifdef DCT_IFAST_SUPPORTED
671 case JDCT_IFAST:
672#endif
673#if defined(DCT_ISLOW_SUPPORTED) || defined(DCT_IFAST_SUPPORTED)
674 if (jsimd_can_convsamp())
675 fdct->convsamp = jsimd_convsamp;
676 else
677 fdct->convsamp = convsamp;
678 if (jsimd_can_quantize())
679 fdct->quantize = jsimd_quantize;
680 else
681 fdct->quantize = quantize;
682 break;
683#endif
684#ifdef DCT_FLOAT_SUPPORTED
685 case JDCT_FLOAT:
686 if (jsimd_can_convsamp_float())
687 fdct->float_convsamp = jsimd_convsamp_float;
688 else
689 fdct->float_convsamp = convsamp_float;
690 if (jsimd_can_quantize_float())
691 fdct->float_quantize = jsimd_quantize_float;
692 else
693 fdct->float_quantize = quantize_float;
694 break;
695#endif
696 default:
697 ERREXIT(cinfo, JERR_NOT_COMPILED);
698 break;
699 }
700
701 /* Allocate workspace memory */
702#ifdef DCT_FLOAT_SUPPORTED
703 if (cinfo->dct_method == JDCT_FLOAT)
704 fdct->float_workspace = (FAST_FLOAT *)
705 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
706 sizeof(FAST_FLOAT) * DCTSIZE2);
707 else
708#endif
709 fdct->workspace = (DCTELEM *)
710 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
711 sizeof(DCTELEM) * DCTSIZE2);
712
713 /* Mark divisor tables unallocated */
714 for (i = 0; i < NUM_QUANT_TBLS; i++) {
715 fdct->divisors[i] = NULL;
716#ifdef DCT_FLOAT_SUPPORTED
717 fdct->float_divisors[i] = NULL;
718#endif
719 }
720}
721