4 * Copyright (C) 1991-1996, Thomas G. Lane.
5 * Modification developed 2003-2015 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
9 * This file contains a slow-but-accurate integer implementation of the
10 * forward DCT (Discrete Cosine Transform).
12 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
13 * on each column. Direct algorithms are also available, but they are
14 * much more complex and seem not to be any faster when reduced to code.
16 * This implementation is based on an algorithm described in
17 * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
18 * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
19 * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
20 * The primary algorithm described there uses 11 multiplies and 29 adds.
21 * We use their alternate method with 12 multiplies and 32 adds.
22 * The advantage of this method is that no data path contains more than one
23 * multiplication; this allows a very simple and accurate implementation in
24 * scaled fixed-point arithmetic, with a minimal number of shifts.
26 * We also provide FDCT routines with various input sample block sizes for
27 * direct resolution reduction or enlargement and for direct resolving the
28 * common 2x1 and 1x2 subsampling cases without additional resampling: NxN
29 * (N=1...16), 2NxN, and Nx2N (N=1...8) pixels for one 8x8 output DCT block.
31 * For N<8 we fill the remaining block coefficients with zero.
32 * For N>8 we apply a partial N-point FDCT on the input samples, computing
33 * just the lower 8 frequency coefficients and discarding the rest.
35 * We must scale the output coefficients of the N-point FDCT appropriately
36 * to the standard 8-point FDCT level by 8/N per 1-D pass. This scaling
37 * is folded into the constant multipliers (pass 2) and/or final/initial
40 * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
41 * since there would be too many additional constants to pre-calculate.
44 #define JPEG_INTERNALS
47 #include "jdct.h" /* Private declarations for DCT subsystem */
49 #ifdef DCT_ISLOW_SUPPORTED
53 * This module is specialized to the case DCTSIZE = 8.
57 Sorry
, this code only copes with
8x8 DCT blocks
. /* deliberate syntax err */
62 * The poop on this scaling stuff is as follows:
64 * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
65 * larger than the true DCT outputs. The final outputs are therefore
66 * a factor of N larger than desired; since N=8 this can be cured by
67 * a simple right shift at the end of the algorithm. The advantage of
68 * this arrangement is that we save two multiplications per 1-D DCT,
69 * because the y0 and y4 outputs need not be divided by sqrt(N).
70 * In the IJG code, this factor of 8 is removed by the quantization step
71 * (in jcdctmgr.c), NOT in this module.
73 * We have to do addition and subtraction of the integer inputs, which
74 * is no problem, and multiplication by fractional constants, which is
75 * a problem to do in integer arithmetic. We multiply all the constants
76 * by CONST_SCALE and convert them to integer constants (thus retaining
77 * CONST_BITS bits of precision in the constants). After doing a
78 * multiplication we have to divide the product by CONST_SCALE, with proper
79 * rounding, to produce the correct output. This division can be done
80 * cheaply as a right shift of CONST_BITS bits. We postpone shifting
81 * as long as possible so that partial sums can be added together with
82 * full fractional precision.
84 * The outputs of the first pass are scaled up by PASS1_BITS bits so that
85 * they are represented to better-than-integral precision. These outputs
86 * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
87 * with the recommended scaling. (For 12-bit sample data, the intermediate
88 * array is INT32 anyway.)
90 * To avoid overflow of the 32-bit intermediate results in pass 2, we must
91 * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
92 * shows that the values given below are the most effective.
95 #if BITS_IN_JSAMPLE == 8
100 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */
103 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
104 * causing a lot of useless floating-point operations at run time.
105 * To get around this we use the following pre-calculated constants.
106 * If you change CONST_BITS you may want to add appropriate values.
107 * (With a reasonable C compiler, you can just rely on the FIX() macro...)
111 #define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */
112 #define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */
113 #define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */
114 #define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
115 #define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
116 #define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */
117 #define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */
118 #define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
119 #define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */
120 #define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */
121 #define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
122 #define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */
124 #define FIX_0_298631336 FIX(0.298631336)
125 #define FIX_0_390180644 FIX(0.390180644)
126 #define FIX_0_541196100 FIX(0.541196100)
127 #define FIX_0_765366865 FIX(0.765366865)
128 #define FIX_0_899976223 FIX(0.899976223)
129 #define FIX_1_175875602 FIX(1.175875602)
130 #define FIX_1_501321110 FIX(1.501321110)
131 #define FIX_1_847759065 FIX(1.847759065)
132 #define FIX_1_961570560 FIX(1.961570560)
133 #define FIX_2_053119869 FIX(2.053119869)
134 #define FIX_2_562915447 FIX(2.562915447)
135 #define FIX_3_072711026 FIX(3.072711026)
139 /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
140 * For 8-bit samples with the recommended scaling, all the variable
141 * and constant values involved are no more than 16 bits wide, so a
142 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
143 * For 12-bit samples, a full 32-bit multiplication will be needed.
146 #if BITS_IN_JSAMPLE == 8
147 #define MULTIPLY(var,const) MULTIPLY16C16(var,const)
149 #define MULTIPLY(var,const) ((var) * (const))
154 * Perform the forward DCT on one block of samples.
158 jpeg_fdct_islow (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
160 INT32 tmp0
, tmp1
, tmp2
, tmp3
;
161 INT32 tmp10
, tmp11
, tmp12
, tmp13
;
168 /* Pass 1: process rows.
169 * Note results are scaled up by sqrt(8) compared to a true DCT;
170 * furthermore, we scale the results by 2**PASS1_BITS.
171 * cK represents sqrt(2) * cos(K*pi/16).
175 for (ctr
= 0; ctr
< DCTSIZE
; ctr
++) {
176 elemptr
= sample_data
[ctr
] + start_col
;
178 /* Even part per LL&M figure 1 --- note that published figure is faulty;
179 * rotator "c1" should be "c6".
182 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[7]);
183 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[6]);
184 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[5]);
185 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[4]);
192 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[7]);
193 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[6]);
194 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[5]);
195 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[4]);
197 /* Apply unsigned->signed conversion. */
198 dataptr
[0] = (DCTELEM
) ((tmp10
+ tmp11
- 8 * CENTERJSAMPLE
) << PASS1_BITS
);
199 dataptr
[4] = (DCTELEM
) ((tmp10
- tmp11
) << PASS1_BITS
);
201 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
202 /* Add fudge factor here for final descale. */
203 z1
+= ONE
<< (CONST_BITS
-PASS1_BITS
-1);
205 dataptr
[2] = (DCTELEM
)
206 RIGHT_SHIFT(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
207 CONST_BITS
-PASS1_BITS
);
208 dataptr
[6] = (DCTELEM
)
209 RIGHT_SHIFT(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
210 CONST_BITS
-PASS1_BITS
);
212 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
213 * i0..i3 in the paper are tmp0..tmp3 here.
219 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
220 /* Add fudge factor here for final descale. */
221 z1
+= ONE
<< (CONST_BITS
-PASS1_BITS
-1);
223 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
224 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
228 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
229 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
230 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
234 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
235 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
236 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
240 dataptr
[1] = (DCTELEM
) RIGHT_SHIFT(tmp0
, CONST_BITS
-PASS1_BITS
);
241 dataptr
[3] = (DCTELEM
) RIGHT_SHIFT(tmp1
, CONST_BITS
-PASS1_BITS
);
242 dataptr
[5] = (DCTELEM
) RIGHT_SHIFT(tmp2
, CONST_BITS
-PASS1_BITS
);
243 dataptr
[7] = (DCTELEM
) RIGHT_SHIFT(tmp3
, CONST_BITS
-PASS1_BITS
);
245 dataptr
+= DCTSIZE
; /* advance pointer to next row */
248 /* Pass 2: process columns.
249 * We remove the PASS1_BITS scaling, but leave the results scaled up
250 * by an overall factor of 8.
251 * cK represents sqrt(2) * cos(K*pi/16).
255 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
256 /* Even part per LL&M figure 1 --- note that published figure is faulty;
257 * rotator "c1" should be "c6".
260 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*7];
261 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*6];
262 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*5];
263 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*4];
265 /* Add fudge factor here for final descale. */
266 tmp10
= tmp0
+ tmp3
+ (ONE
<< (PASS1_BITS
-1));
271 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*7];
272 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*6];
273 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*5];
274 tmp3
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*4];
276 dataptr
[DCTSIZE
*0] = (DCTELEM
) RIGHT_SHIFT(tmp10
+ tmp11
, PASS1_BITS
);
277 dataptr
[DCTSIZE
*4] = (DCTELEM
) RIGHT_SHIFT(tmp10
- tmp11
, PASS1_BITS
);
279 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
280 /* Add fudge factor here for final descale. */
281 z1
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
283 dataptr
[DCTSIZE
*2] = (DCTELEM
)
284 RIGHT_SHIFT(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
285 CONST_BITS
+PASS1_BITS
);
286 dataptr
[DCTSIZE
*6] = (DCTELEM
)
287 RIGHT_SHIFT(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
288 CONST_BITS
+PASS1_BITS
);
290 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
291 * i0..i3 in the paper are tmp0..tmp3 here.
297 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
298 /* Add fudge factor here for final descale. */
299 z1
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
301 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
302 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
306 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
307 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
308 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
312 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
313 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
314 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
318 dataptr
[DCTSIZE
*1] = (DCTELEM
) RIGHT_SHIFT(tmp0
, CONST_BITS
+PASS1_BITS
);
319 dataptr
[DCTSIZE
*3] = (DCTELEM
) RIGHT_SHIFT(tmp1
, CONST_BITS
+PASS1_BITS
);
320 dataptr
[DCTSIZE
*5] = (DCTELEM
) RIGHT_SHIFT(tmp2
, CONST_BITS
+PASS1_BITS
);
321 dataptr
[DCTSIZE
*7] = (DCTELEM
) RIGHT_SHIFT(tmp3
, CONST_BITS
+PASS1_BITS
);
323 dataptr
++; /* advance pointer to next column */
327 #ifdef DCT_SCALING_SUPPORTED
331 * Perform the forward DCT on a 7x7 sample block.
335 jpeg_fdct_7x7 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
337 INT32 tmp0
, tmp1
, tmp2
, tmp3
;
338 INT32 tmp10
, tmp11
, tmp12
;
345 /* Pre-zero output coefficient block. */
346 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
348 /* Pass 1: process rows.
349 * Note results are scaled up by sqrt(8) compared to a true DCT;
350 * furthermore, we scale the results by 2**PASS1_BITS.
351 * cK represents sqrt(2) * cos(K*pi/14).
355 for (ctr
= 0; ctr
< 7; ctr
++) {
356 elemptr
= sample_data
[ctr
] + start_col
;
360 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[6]);
361 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[5]);
362 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[4]);
363 tmp3
= GETJSAMPLE(elemptr
[3]);
365 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[6]);
366 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[5]);
367 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[4]);
370 /* Apply unsigned->signed conversion. */
371 dataptr
[0] = (DCTELEM
)
372 ((z1
+ tmp1
+ tmp3
- 7 * CENTERJSAMPLE
) << PASS1_BITS
);
376 z1
= MULTIPLY(z1
, FIX(0.353553391)); /* (c2+c6-c4)/2 */
377 z2
= MULTIPLY(tmp0
- tmp2
, FIX(0.920609002)); /* (c2+c4-c6)/2 */
378 z3
= MULTIPLY(tmp1
- tmp2
, FIX(0.314692123)); /* c6 */
379 dataptr
[2] = (DCTELEM
) DESCALE(z1
+ z2
+ z3
, CONST_BITS
-PASS1_BITS
);
381 z2
= MULTIPLY(tmp0
- tmp1
, FIX(0.881747734)); /* c4 */
382 dataptr
[4] = (DCTELEM
)
383 DESCALE(z2
+ z3
- MULTIPLY(tmp1
- tmp3
, FIX(0.707106781)), /* c2+c6-c4 */
384 CONST_BITS
-PASS1_BITS
);
385 dataptr
[6] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
-PASS1_BITS
);
389 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(0.935414347)); /* (c3+c1-c5)/2 */
390 tmp2
= MULTIPLY(tmp10
- tmp11
, FIX(0.170262339)); /* (c3+c5-c1)/2 */
393 tmp2
= MULTIPLY(tmp11
+ tmp12
, - FIX(1.378756276)); /* -c1 */
395 tmp3
= MULTIPLY(tmp10
+ tmp12
, FIX(0.613604268)); /* c5 */
397 tmp2
+= tmp3
+ MULTIPLY(tmp12
, FIX(1.870828693)); /* c3+c1-c5 */
399 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
-PASS1_BITS
);
400 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
-PASS1_BITS
);
401 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
-PASS1_BITS
);
403 dataptr
+= DCTSIZE
; /* advance pointer to next row */
406 /* Pass 2: process columns.
407 * We remove the PASS1_BITS scaling, but leave the results scaled up
408 * by an overall factor of 8.
409 * We must also scale the output by (8/7)**2 = 64/49, which we fold
410 * into the constant multipliers:
411 * cK now represents sqrt(2) * cos(K*pi/14) * 64/49.
415 for (ctr
= 0; ctr
< 7; ctr
++) {
418 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*6];
419 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*5];
420 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*4];
421 tmp3
= dataptr
[DCTSIZE
*3];
423 tmp10
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*6];
424 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*5];
425 tmp12
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*4];
428 dataptr
[DCTSIZE
*0] = (DCTELEM
)
429 DESCALE(MULTIPLY(z1
+ tmp1
+ tmp3
, FIX(1.306122449)), /* 64/49 */
430 CONST_BITS
+PASS1_BITS
);
434 z1
= MULTIPLY(z1
, FIX(0.461784020)); /* (c2+c6-c4)/2 */
435 z2
= MULTIPLY(tmp0
- tmp2
, FIX(1.202428084)); /* (c2+c4-c6)/2 */
436 z3
= MULTIPLY(tmp1
- tmp2
, FIX(0.411026446)); /* c6 */
437 dataptr
[DCTSIZE
*2] = (DCTELEM
) DESCALE(z1
+ z2
+ z3
, CONST_BITS
+PASS1_BITS
);
439 z2
= MULTIPLY(tmp0
- tmp1
, FIX(1.151670509)); /* c4 */
440 dataptr
[DCTSIZE
*4] = (DCTELEM
)
441 DESCALE(z2
+ z3
- MULTIPLY(tmp1
- tmp3
, FIX(0.923568041)), /* c2+c6-c4 */
442 CONST_BITS
+PASS1_BITS
);
443 dataptr
[DCTSIZE
*6] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
+PASS1_BITS
);
447 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.221765677)); /* (c3+c1-c5)/2 */
448 tmp2
= MULTIPLY(tmp10
- tmp11
, FIX(0.222383464)); /* (c3+c5-c1)/2 */
451 tmp2
= MULTIPLY(tmp11
+ tmp12
, - FIX(1.800824523)); /* -c1 */
453 tmp3
= MULTIPLY(tmp10
+ tmp12
, FIX(0.801442310)); /* c5 */
455 tmp2
+= tmp3
+ MULTIPLY(tmp12
, FIX(2.443531355)); /* c3+c1-c5 */
457 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+PASS1_BITS
);
458 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+PASS1_BITS
);
459 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+PASS1_BITS
);
461 dataptr
++; /* advance pointer to next column */
467 * Perform the forward DCT on a 6x6 sample block.
471 jpeg_fdct_6x6 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
473 INT32 tmp0
, tmp1
, tmp2
;
474 INT32 tmp10
, tmp11
, tmp12
;
480 /* Pre-zero output coefficient block. */
481 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
483 /* Pass 1: process rows.
484 * Note results are scaled up by sqrt(8) compared to a true DCT;
485 * furthermore, we scale the results by 2**PASS1_BITS.
486 * cK represents sqrt(2) * cos(K*pi/12).
490 for (ctr
= 0; ctr
< 6; ctr
++) {
491 elemptr
= sample_data
[ctr
] + start_col
;
495 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[5]);
496 tmp11
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[4]);
497 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[3]);
502 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[5]);
503 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[4]);
504 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[3]);
506 /* Apply unsigned->signed conversion. */
507 dataptr
[0] = (DCTELEM
)
508 ((tmp10
+ tmp11
- 6 * CENTERJSAMPLE
) << PASS1_BITS
);
509 dataptr
[2] = (DCTELEM
)
510 DESCALE(MULTIPLY(tmp12
, FIX(1.224744871)), /* c2 */
511 CONST_BITS
-PASS1_BITS
);
512 dataptr
[4] = (DCTELEM
)
513 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(0.707106781)), /* c4 */
514 CONST_BITS
-PASS1_BITS
);
518 tmp10
= DESCALE(MULTIPLY(tmp0
+ tmp2
, FIX(0.366025404)), /* c5 */
519 CONST_BITS
-PASS1_BITS
);
521 dataptr
[1] = (DCTELEM
) (tmp10
+ ((tmp0
+ tmp1
) << PASS1_BITS
));
522 dataptr
[3] = (DCTELEM
) ((tmp0
- tmp1
- tmp2
) << PASS1_BITS
);
523 dataptr
[5] = (DCTELEM
) (tmp10
+ ((tmp2
- tmp1
) << PASS1_BITS
));
525 dataptr
+= DCTSIZE
; /* advance pointer to next row */
528 /* Pass 2: process columns.
529 * We remove the PASS1_BITS scaling, but leave the results scaled up
530 * by an overall factor of 8.
531 * We must also scale the output by (8/6)**2 = 16/9, which we fold
532 * into the constant multipliers:
533 * cK now represents sqrt(2) * cos(K*pi/12) * 16/9.
537 for (ctr
= 0; ctr
< 6; ctr
++) {
540 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*5];
541 tmp11
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*4];
542 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*3];
547 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*5];
548 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*4];
549 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*3];
551 dataptr
[DCTSIZE
*0] = (DCTELEM
)
552 DESCALE(MULTIPLY(tmp10
+ tmp11
, FIX(1.777777778)), /* 16/9 */
553 CONST_BITS
+PASS1_BITS
);
554 dataptr
[DCTSIZE
*2] = (DCTELEM
)
555 DESCALE(MULTIPLY(tmp12
, FIX(2.177324216)), /* c2 */
556 CONST_BITS
+PASS1_BITS
);
557 dataptr
[DCTSIZE
*4] = (DCTELEM
)
558 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(1.257078722)), /* c4 */
559 CONST_BITS
+PASS1_BITS
);
563 tmp10
= MULTIPLY(tmp0
+ tmp2
, FIX(0.650711829)); /* c5 */
565 dataptr
[DCTSIZE
*1] = (DCTELEM
)
566 DESCALE(tmp10
+ MULTIPLY(tmp0
+ tmp1
, FIX(1.777777778)), /* 16/9 */
567 CONST_BITS
+PASS1_BITS
);
568 dataptr
[DCTSIZE
*3] = (DCTELEM
)
569 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp2
, FIX(1.777777778)), /* 16/9 */
570 CONST_BITS
+PASS1_BITS
);
571 dataptr
[DCTSIZE
*5] = (DCTELEM
)
572 DESCALE(tmp10
+ MULTIPLY(tmp2
- tmp1
, FIX(1.777777778)), /* 16/9 */
573 CONST_BITS
+PASS1_BITS
);
575 dataptr
++; /* advance pointer to next column */
581 * Perform the forward DCT on a 5x5 sample block.
585 jpeg_fdct_5x5 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
587 INT32 tmp0
, tmp1
, tmp2
;
594 /* Pre-zero output coefficient block. */
595 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
597 /* Pass 1: process rows.
598 * Note results are scaled up by sqrt(8) compared to a true DCT;
599 * furthermore, we scale the results by 2**PASS1_BITS.
600 * We scale the results further by 2 as part of output adaption
601 * scaling for different DCT size.
602 * cK represents sqrt(2) * cos(K*pi/10).
606 for (ctr
= 0; ctr
< 5; ctr
++) {
607 elemptr
= sample_data
[ctr
] + start_col
;
611 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[4]);
612 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[3]);
613 tmp2
= GETJSAMPLE(elemptr
[2]);
618 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[4]);
619 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[3]);
621 /* Apply unsigned->signed conversion. */
622 dataptr
[0] = (DCTELEM
)
623 ((tmp10
+ tmp2
- 5 * CENTERJSAMPLE
) << (PASS1_BITS
+1));
624 tmp11
= MULTIPLY(tmp11
, FIX(0.790569415)); /* (c2+c4)/2 */
626 tmp10
= MULTIPLY(tmp10
, FIX(0.353553391)); /* (c2-c4)/2 */
627 dataptr
[2] = (DCTELEM
) DESCALE(tmp11
+ tmp10
, CONST_BITS
-PASS1_BITS
-1);
628 dataptr
[4] = (DCTELEM
) DESCALE(tmp11
- tmp10
, CONST_BITS
-PASS1_BITS
-1);
632 tmp10
= MULTIPLY(tmp0
+ tmp1
, FIX(0.831253876)); /* c3 */
634 dataptr
[1] = (DCTELEM
)
635 DESCALE(tmp10
+ MULTIPLY(tmp0
, FIX(0.513743148)), /* c1-c3 */
636 CONST_BITS
-PASS1_BITS
-1);
637 dataptr
[3] = (DCTELEM
)
638 DESCALE(tmp10
- MULTIPLY(tmp1
, FIX(2.176250899)), /* c1+c3 */
639 CONST_BITS
-PASS1_BITS
-1);
641 dataptr
+= DCTSIZE
; /* advance pointer to next row */
644 /* Pass 2: process columns.
645 * We remove the PASS1_BITS scaling, but leave the results scaled up
646 * by an overall factor of 8.
647 * We must also scale the output by (8/5)**2 = 64/25, which we partially
648 * fold into the constant multipliers (other part was done in pass 1):
649 * cK now represents sqrt(2) * cos(K*pi/10) * 32/25.
653 for (ctr
= 0; ctr
< 5; ctr
++) {
656 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*4];
657 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*3];
658 tmp2
= dataptr
[DCTSIZE
*2];
663 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*4];
664 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*3];
666 dataptr
[DCTSIZE
*0] = (DCTELEM
)
667 DESCALE(MULTIPLY(tmp10
+ tmp2
, FIX(1.28)), /* 32/25 */
668 CONST_BITS
+PASS1_BITS
);
669 tmp11
= MULTIPLY(tmp11
, FIX(1.011928851)); /* (c2+c4)/2 */
671 tmp10
= MULTIPLY(tmp10
, FIX(0.452548340)); /* (c2-c4)/2 */
672 dataptr
[DCTSIZE
*2] = (DCTELEM
) DESCALE(tmp11
+ tmp10
, CONST_BITS
+PASS1_BITS
);
673 dataptr
[DCTSIZE
*4] = (DCTELEM
) DESCALE(tmp11
- tmp10
, CONST_BITS
+PASS1_BITS
);
677 tmp10
= MULTIPLY(tmp0
+ tmp1
, FIX(1.064004961)); /* c3 */
679 dataptr
[DCTSIZE
*1] = (DCTELEM
)
680 DESCALE(tmp10
+ MULTIPLY(tmp0
, FIX(0.657591230)), /* c1-c3 */
681 CONST_BITS
+PASS1_BITS
);
682 dataptr
[DCTSIZE
*3] = (DCTELEM
)
683 DESCALE(tmp10
- MULTIPLY(tmp1
, FIX(2.785601151)), /* c1+c3 */
684 CONST_BITS
+PASS1_BITS
);
686 dataptr
++; /* advance pointer to next column */
692 * Perform the forward DCT on a 4x4 sample block.
696 jpeg_fdct_4x4 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
705 /* Pre-zero output coefficient block. */
706 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
708 /* Pass 1: process rows.
709 * Note results are scaled up by sqrt(8) compared to a true DCT;
710 * furthermore, we scale the results by 2**PASS1_BITS.
711 * We must also scale the output by (8/4)**2 = 2**2, which we add here.
712 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
716 for (ctr
= 0; ctr
< 4; ctr
++) {
717 elemptr
= sample_data
[ctr
] + start_col
;
721 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[3]);
722 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[2]);
724 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[3]);
725 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[2]);
727 /* Apply unsigned->signed conversion. */
728 dataptr
[0] = (DCTELEM
)
729 ((tmp0
+ tmp1
- 4 * CENTERJSAMPLE
) << (PASS1_BITS
+2));
730 dataptr
[2] = (DCTELEM
) ((tmp0
- tmp1
) << (PASS1_BITS
+2));
734 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
735 /* Add fudge factor here for final descale. */
736 tmp0
+= ONE
<< (CONST_BITS
-PASS1_BITS
-3);
738 dataptr
[1] = (DCTELEM
)
739 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
740 CONST_BITS
-PASS1_BITS
-2);
741 dataptr
[3] = (DCTELEM
)
742 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
743 CONST_BITS
-PASS1_BITS
-2);
745 dataptr
+= DCTSIZE
; /* advance pointer to next row */
748 /* Pass 2: process columns.
749 * We remove the PASS1_BITS scaling, but leave the results scaled up
750 * by an overall factor of 8.
751 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
755 for (ctr
= 0; ctr
< 4; ctr
++) {
758 /* Add fudge factor here for final descale. */
759 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*3] + (ONE
<< (PASS1_BITS
-1));
760 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*2];
762 tmp10
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*3];
763 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*2];
765 dataptr
[DCTSIZE
*0] = (DCTELEM
) RIGHT_SHIFT(tmp0
+ tmp1
, PASS1_BITS
);
766 dataptr
[DCTSIZE
*2] = (DCTELEM
) RIGHT_SHIFT(tmp0
- tmp1
, PASS1_BITS
);
770 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
771 /* Add fudge factor here for final descale. */
772 tmp0
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
774 dataptr
[DCTSIZE
*1] = (DCTELEM
)
775 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
776 CONST_BITS
+PASS1_BITS
);
777 dataptr
[DCTSIZE
*3] = (DCTELEM
)
778 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
779 CONST_BITS
+PASS1_BITS
);
781 dataptr
++; /* advance pointer to next column */
787 * Perform the forward DCT on a 3x3 sample block.
791 jpeg_fdct_3x3 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
793 INT32 tmp0
, tmp1
, tmp2
;
799 /* Pre-zero output coefficient block. */
800 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
802 /* Pass 1: process rows.
803 * Note results are scaled up by sqrt(8) compared to a true DCT;
804 * furthermore, we scale the results by 2**PASS1_BITS.
805 * We scale the results further by 2**2 as part of output adaption
806 * scaling for different DCT size.
807 * cK represents sqrt(2) * cos(K*pi/6).
811 for (ctr
= 0; ctr
< 3; ctr
++) {
812 elemptr
= sample_data
[ctr
] + start_col
;
816 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[2]);
817 tmp1
= GETJSAMPLE(elemptr
[1]);
819 tmp2
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[2]);
821 /* Apply unsigned->signed conversion. */
822 dataptr
[0] = (DCTELEM
)
823 ((tmp0
+ tmp1
- 3 * CENTERJSAMPLE
) << (PASS1_BITS
+2));
824 dataptr
[2] = (DCTELEM
)
825 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp1
, FIX(0.707106781)), /* c2 */
826 CONST_BITS
-PASS1_BITS
-2);
830 dataptr
[1] = (DCTELEM
)
831 DESCALE(MULTIPLY(tmp2
, FIX(1.224744871)), /* c1 */
832 CONST_BITS
-PASS1_BITS
-2);
834 dataptr
+= DCTSIZE
; /* advance pointer to next row */
837 /* Pass 2: process columns.
838 * We remove the PASS1_BITS scaling, but leave the results scaled up
839 * by an overall factor of 8.
840 * We must also scale the output by (8/3)**2 = 64/9, which we partially
841 * fold into the constant multipliers (other part was done in pass 1):
842 * cK now represents sqrt(2) * cos(K*pi/6) * 16/9.
846 for (ctr
= 0; ctr
< 3; ctr
++) {
849 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*2];
850 tmp1
= dataptr
[DCTSIZE
*1];
852 tmp2
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*2];
854 dataptr
[DCTSIZE
*0] = (DCTELEM
)
855 DESCALE(MULTIPLY(tmp0
+ tmp1
, FIX(1.777777778)), /* 16/9 */
856 CONST_BITS
+PASS1_BITS
);
857 dataptr
[DCTSIZE
*2] = (DCTELEM
)
858 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp1
, FIX(1.257078722)), /* c2 */
859 CONST_BITS
+PASS1_BITS
);
863 dataptr
[DCTSIZE
*1] = (DCTELEM
)
864 DESCALE(MULTIPLY(tmp2
, FIX(2.177324216)), /* c1 */
865 CONST_BITS
+PASS1_BITS
);
867 dataptr
++; /* advance pointer to next column */
873 * Perform the forward DCT on a 2x2 sample block.
877 jpeg_fdct_2x2 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
879 DCTELEM tmp0
, tmp1
, tmp2
, tmp3
;
882 /* Pre-zero output coefficient block. */
883 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
885 /* Pass 1: process rows.
886 * Note results are scaled up by sqrt(8) compared to a true DCT.
890 elemptr
= sample_data
[0] + start_col
;
892 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[1]);
893 tmp1
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[1]);
896 elemptr
= sample_data
[1] + start_col
;
898 tmp2
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[1]);
899 tmp3
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[1]);
901 /* Pass 2: process columns.
902 * We leave the results scaled up by an overall factor of 8.
903 * We must also scale the output by (8/2)**2 = 2**4.
907 /* Apply unsigned->signed conversion. */
908 data
[DCTSIZE
*0] = (tmp0
+ tmp2
- 4 * CENTERJSAMPLE
) << 4;
909 data
[DCTSIZE
*1] = (tmp0
- tmp2
) << 4;
912 data
[DCTSIZE
*0+1] = (tmp1
+ tmp3
) << 4;
913 data
[DCTSIZE
*1+1] = (tmp1
- tmp3
) << 4;
918 * Perform the forward DCT on a 1x1 sample block.
922 jpeg_fdct_1x1 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
926 /* Pre-zero output coefficient block. */
927 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
929 dcval
= GETJSAMPLE(sample_data
[0][start_col
]);
931 /* We leave the result scaled up by an overall factor of 8. */
932 /* We must also scale the output by (8/1)**2 = 2**6. */
933 /* Apply unsigned->signed conversion. */
934 data
[0] = (dcval
- CENTERJSAMPLE
) << 6;
939 * Perform the forward DCT on a 9x9 sample block.
943 jpeg_fdct_9x9 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
945 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
;
946 INT32 tmp10
, tmp11
, tmp12
, tmp13
;
948 DCTELEM workspace
[8];
955 /* Pass 1: process rows.
956 * Note results are scaled up by sqrt(8) compared to a true DCT;
957 * we scale the results further by 2 as part of output adaption
958 * scaling for different DCT size.
959 * cK represents sqrt(2) * cos(K*pi/18).
965 elemptr
= sample_data
[ctr
] + start_col
;
969 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[8]);
970 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[7]);
971 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[6]);
972 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[5]);
973 tmp4
= GETJSAMPLE(elemptr
[4]);
975 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[8]);
976 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[7]);
977 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[6]);
978 tmp13
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[5]);
980 z1
= tmp0
+ tmp2
+ tmp3
;
982 /* Apply unsigned->signed conversion. */
983 dataptr
[0] = (DCTELEM
) ((z1
+ z2
- 9 * CENTERJSAMPLE
) << 1);
984 dataptr
[6] = (DCTELEM
)
985 DESCALE(MULTIPLY(z1
- z2
- z2
, FIX(0.707106781)), /* c6 */
987 z1
= MULTIPLY(tmp0
- tmp2
, FIX(1.328926049)); /* c2 */
988 z2
= MULTIPLY(tmp1
- tmp4
- tmp4
, FIX(0.707106781)); /* c6 */
989 dataptr
[2] = (DCTELEM
)
990 DESCALE(MULTIPLY(tmp2
- tmp3
, FIX(1.083350441)) /* c4 */
991 + z1
+ z2
, CONST_BITS
-1);
992 dataptr
[4] = (DCTELEM
)
993 DESCALE(MULTIPLY(tmp3
- tmp0
, FIX(0.245575608)) /* c8 */
994 + z1
- z2
, CONST_BITS
-1);
998 dataptr
[3] = (DCTELEM
)
999 DESCALE(MULTIPLY(tmp10
- tmp12
- tmp13
, FIX(1.224744871)), /* c3 */
1002 tmp11
= MULTIPLY(tmp11
, FIX(1.224744871)); /* c3 */
1003 tmp0
= MULTIPLY(tmp10
+ tmp12
, FIX(0.909038955)); /* c5 */
1004 tmp1
= MULTIPLY(tmp10
+ tmp13
, FIX(0.483689525)); /* c7 */
1006 dataptr
[1] = (DCTELEM
) DESCALE(tmp11
+ tmp0
+ tmp1
, CONST_BITS
-1);
1008 tmp2
= MULTIPLY(tmp12
- tmp13
, FIX(1.392728481)); /* c1 */
1010 dataptr
[5] = (DCTELEM
) DESCALE(tmp0
- tmp11
- tmp2
, CONST_BITS
-1);
1011 dataptr
[7] = (DCTELEM
) DESCALE(tmp1
- tmp11
+ tmp2
, CONST_BITS
-1);
1015 if (ctr
!= DCTSIZE
) {
1018 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1020 dataptr
= workspace
; /* switch pointer to extended workspace */
1023 /* Pass 2: process columns.
1024 * We leave the results scaled up by an overall factor of 8.
1025 * We must also scale the output by (8/9)**2 = 64/81, which we partially
1026 * fold into the constant multipliers and final/initial shifting:
1027 * cK now represents sqrt(2) * cos(K*pi/18) * 128/81.
1032 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1035 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*0];
1036 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*7];
1037 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*6];
1038 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*5];
1039 tmp4
= dataptr
[DCTSIZE
*4];
1041 tmp10
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*0];
1042 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*7];
1043 tmp12
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*6];
1044 tmp13
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*5];
1046 z1
= tmp0
+ tmp2
+ tmp3
;
1048 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1049 DESCALE(MULTIPLY(z1
+ z2
, FIX(1.580246914)), /* 128/81 */
1051 dataptr
[DCTSIZE
*6] = (DCTELEM
)
1052 DESCALE(MULTIPLY(z1
- z2
- z2
, FIX(1.117403309)), /* c6 */
1054 z1
= MULTIPLY(tmp0
- tmp2
, FIX(2.100031287)); /* c2 */
1055 z2
= MULTIPLY(tmp1
- tmp4
- tmp4
, FIX(1.117403309)); /* c6 */
1056 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1057 DESCALE(MULTIPLY(tmp2
- tmp3
, FIX(1.711961190)) /* c4 */
1058 + z1
+ z2
, CONST_BITS
+2);
1059 dataptr
[DCTSIZE
*4] = (DCTELEM
)
1060 DESCALE(MULTIPLY(tmp3
- tmp0
, FIX(0.388070096)) /* c8 */
1061 + z1
- z2
, CONST_BITS
+2);
1065 dataptr
[DCTSIZE
*3] = (DCTELEM
)
1066 DESCALE(MULTIPLY(tmp10
- tmp12
- tmp13
, FIX(1.935399303)), /* c3 */
1069 tmp11
= MULTIPLY(tmp11
, FIX(1.935399303)); /* c3 */
1070 tmp0
= MULTIPLY(tmp10
+ tmp12
, FIX(1.436506004)); /* c5 */
1071 tmp1
= MULTIPLY(tmp10
+ tmp13
, FIX(0.764348879)); /* c7 */
1073 dataptr
[DCTSIZE
*1] = (DCTELEM
)
1074 DESCALE(tmp11
+ tmp0
+ tmp1
, CONST_BITS
+2);
1076 tmp2
= MULTIPLY(tmp12
- tmp13
, FIX(2.200854883)); /* c1 */
1078 dataptr
[DCTSIZE
*5] = (DCTELEM
)
1079 DESCALE(tmp0
- tmp11
- tmp2
, CONST_BITS
+2);
1080 dataptr
[DCTSIZE
*7] = (DCTELEM
)
1081 DESCALE(tmp1
- tmp11
+ tmp2
, CONST_BITS
+2);
1083 dataptr
++; /* advance pointer to next column */
1084 wsptr
++; /* advance pointer to next column */
1090 * Perform the forward DCT on a 10x10 sample block.
1094 jpeg_fdct_10x10 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
1096 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
;
1097 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
;
1098 DCTELEM workspace
[8*2];
1105 /* Pass 1: process rows.
1106 * Note results are scaled up by sqrt(8) compared to a true DCT;
1107 * we scale the results further by 2 as part of output adaption
1108 * scaling for different DCT size.
1109 * cK represents sqrt(2) * cos(K*pi/20).
1115 elemptr
= sample_data
[ctr
] + start_col
;
1119 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[9]);
1120 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[8]);
1121 tmp12
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[7]);
1122 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[6]);
1123 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[5]);
1125 tmp10
= tmp0
+ tmp4
;
1126 tmp13
= tmp0
- tmp4
;
1127 tmp11
= tmp1
+ tmp3
;
1128 tmp14
= tmp1
- tmp3
;
1130 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[9]);
1131 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[8]);
1132 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[7]);
1133 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[6]);
1134 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[5]);
1136 /* Apply unsigned->signed conversion. */
1137 dataptr
[0] = (DCTELEM
)
1138 ((tmp10
+ tmp11
+ tmp12
- 10 * CENTERJSAMPLE
) << 1);
1140 dataptr
[4] = (DCTELEM
)
1141 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.144122806)) - /* c4 */
1142 MULTIPLY(tmp11
- tmp12
, FIX(0.437016024)), /* c8 */
1144 tmp10
= MULTIPLY(tmp13
+ tmp14
, FIX(0.831253876)); /* c6 */
1145 dataptr
[2] = (DCTELEM
)
1146 DESCALE(tmp10
+ MULTIPLY(tmp13
, FIX(0.513743148)), /* c2-c6 */
1148 dataptr
[6] = (DCTELEM
)
1149 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(2.176250899)), /* c2+c6 */
1154 tmp10
= tmp0
+ tmp4
;
1155 tmp11
= tmp1
- tmp3
;
1156 dataptr
[5] = (DCTELEM
) ((tmp10
- tmp11
- tmp2
) << 1);
1157 tmp2
<<= CONST_BITS
;
1158 dataptr
[1] = (DCTELEM
)
1159 DESCALE(MULTIPLY(tmp0
, FIX(1.396802247)) + /* c1 */
1160 MULTIPLY(tmp1
, FIX(1.260073511)) + tmp2
+ /* c3 */
1161 MULTIPLY(tmp3
, FIX(0.642039522)) + /* c7 */
1162 MULTIPLY(tmp4
, FIX(0.221231742)), /* c9 */
1164 tmp12
= MULTIPLY(tmp0
- tmp4
, FIX(0.951056516)) - /* (c3+c7)/2 */
1165 MULTIPLY(tmp1
+ tmp3
, FIX(0.587785252)); /* (c1-c9)/2 */
1166 tmp13
= MULTIPLY(tmp10
+ tmp11
, FIX(0.309016994)) + /* (c3-c7)/2 */
1167 (tmp11
<< (CONST_BITS
- 1)) - tmp2
;
1168 dataptr
[3] = (DCTELEM
) DESCALE(tmp12
+ tmp13
, CONST_BITS
-1);
1169 dataptr
[7] = (DCTELEM
) DESCALE(tmp12
- tmp13
, CONST_BITS
-1);
1173 if (ctr
!= DCTSIZE
) {
1176 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1178 dataptr
= workspace
; /* switch pointer to extended workspace */
1181 /* Pass 2: process columns.
1182 * We leave the results scaled up by an overall factor of 8.
1183 * We must also scale the output by (8/10)**2 = 16/25, which we partially
1184 * fold into the constant multipliers and final/initial shifting:
1185 * cK now represents sqrt(2) * cos(K*pi/20) * 32/25.
1190 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1193 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*1];
1194 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*0];
1195 tmp12
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*7];
1196 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*6];
1197 tmp4
= dataptr
[DCTSIZE
*4] + dataptr
[DCTSIZE
*5];
1199 tmp10
= tmp0
+ tmp4
;
1200 tmp13
= tmp0
- tmp4
;
1201 tmp11
= tmp1
+ tmp3
;
1202 tmp14
= tmp1
- tmp3
;
1204 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*1];
1205 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*0];
1206 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*7];
1207 tmp3
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*6];
1208 tmp4
= dataptr
[DCTSIZE
*4] - dataptr
[DCTSIZE
*5];
1210 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1211 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
, FIX(1.28)), /* 32/25 */
1214 dataptr
[DCTSIZE
*4] = (DCTELEM
)
1215 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.464477191)) - /* c4 */
1216 MULTIPLY(tmp11
- tmp12
, FIX(0.559380511)), /* c8 */
1218 tmp10
= MULTIPLY(tmp13
+ tmp14
, FIX(1.064004961)); /* c6 */
1219 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1220 DESCALE(tmp10
+ MULTIPLY(tmp13
, FIX(0.657591230)), /* c2-c6 */
1222 dataptr
[DCTSIZE
*6] = (DCTELEM
)
1223 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(2.785601151)), /* c2+c6 */
1228 tmp10
= tmp0
+ tmp4
;
1229 tmp11
= tmp1
- tmp3
;
1230 dataptr
[DCTSIZE
*5] = (DCTELEM
)
1231 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp2
, FIX(1.28)), /* 32/25 */
1233 tmp2
= MULTIPLY(tmp2
, FIX(1.28)); /* 32/25 */
1234 dataptr
[DCTSIZE
*1] = (DCTELEM
)
1235 DESCALE(MULTIPLY(tmp0
, FIX(1.787906876)) + /* c1 */
1236 MULTIPLY(tmp1
, FIX(1.612894094)) + tmp2
+ /* c3 */
1237 MULTIPLY(tmp3
, FIX(0.821810588)) + /* c7 */
1238 MULTIPLY(tmp4
, FIX(0.283176630)), /* c9 */
1240 tmp12
= MULTIPLY(tmp0
- tmp4
, FIX(1.217352341)) - /* (c3+c7)/2 */
1241 MULTIPLY(tmp1
+ tmp3
, FIX(0.752365123)); /* (c1-c9)/2 */
1242 tmp13
= MULTIPLY(tmp10
+ tmp11
, FIX(0.395541753)) + /* (c3-c7)/2 */
1243 MULTIPLY(tmp11
, FIX(0.64)) - tmp2
; /* 16/25 */
1244 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp12
+ tmp13
, CONST_BITS
+2);
1245 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp12
- tmp13
, CONST_BITS
+2);
1247 dataptr
++; /* advance pointer to next column */
1248 wsptr
++; /* advance pointer to next column */
1254 * Perform the forward DCT on an 11x11 sample block.
1258 jpeg_fdct_11x11 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
1260 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
;
1261 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
;
1263 DCTELEM workspace
[8*3];
1270 /* Pass 1: process rows.
1271 * Note results are scaled up by sqrt(8) compared to a true DCT;
1272 * we scale the results further by 2 as part of output adaption
1273 * scaling for different DCT size.
1274 * cK represents sqrt(2) * cos(K*pi/22).
1280 elemptr
= sample_data
[ctr
] + start_col
;
1284 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[10]);
1285 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[9]);
1286 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[8]);
1287 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[7]);
1288 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[6]);
1289 tmp5
= GETJSAMPLE(elemptr
[5]);
1291 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[10]);
1292 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[9]);
1293 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[8]);
1294 tmp13
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[7]);
1295 tmp14
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[6]);
1297 /* Apply unsigned->signed conversion. */
1298 dataptr
[0] = (DCTELEM
)
1299 ((tmp0
+ tmp1
+ tmp2
+ tmp3
+ tmp4
+ tmp5
- 11 * CENTERJSAMPLE
) << 1);
1306 z1
= MULTIPLY(tmp0
+ tmp3
, FIX(1.356927976)) + /* c2 */
1307 MULTIPLY(tmp2
+ tmp4
, FIX(0.201263574)); /* c10 */
1308 z2
= MULTIPLY(tmp1
- tmp3
, FIX(0.926112931)); /* c6 */
1309 z3
= MULTIPLY(tmp0
- tmp1
, FIX(1.189712156)); /* c4 */
1310 dataptr
[2] = (DCTELEM
)
1311 DESCALE(z1
+ z2
- MULTIPLY(tmp3
, FIX(1.018300590)) /* c2+c8-c6 */
1312 - MULTIPLY(tmp4
, FIX(1.390975730)), /* c4+c10 */
1314 dataptr
[4] = (DCTELEM
)
1315 DESCALE(z2
+ z3
+ MULTIPLY(tmp1
, FIX(0.062335650)) /* c4-c6-c10 */
1316 - MULTIPLY(tmp2
, FIX(1.356927976)) /* c2 */
1317 + MULTIPLY(tmp4
, FIX(0.587485545)), /* c8 */
1319 dataptr
[6] = (DCTELEM
)
1320 DESCALE(z1
+ z3
- MULTIPLY(tmp0
, FIX(1.620527200)) /* c2+c4-c6 */
1321 - MULTIPLY(tmp2
, FIX(0.788749120)), /* c8+c10 */
1326 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.286413905)); /* c3 */
1327 tmp2
= MULTIPLY(tmp10
+ tmp12
, FIX(1.068791298)); /* c5 */
1328 tmp3
= MULTIPLY(tmp10
+ tmp13
, FIX(0.764581576)); /* c7 */
1329 tmp0
= tmp1
+ tmp2
+ tmp3
- MULTIPLY(tmp10
, FIX(1.719967871)) /* c7+c5+c3-c1 */
1330 + MULTIPLY(tmp14
, FIX(0.398430003)); /* c9 */
1331 tmp4
= MULTIPLY(tmp11
+ tmp12
, - FIX(0.764581576)); /* -c7 */
1332 tmp5
= MULTIPLY(tmp11
+ tmp13
, - FIX(1.399818907)); /* -c1 */
1333 tmp1
+= tmp4
+ tmp5
+ MULTIPLY(tmp11
, FIX(1.276416582)) /* c9+c7+c1-c3 */
1334 - MULTIPLY(tmp14
, FIX(1.068791298)); /* c5 */
1335 tmp10
= MULTIPLY(tmp12
+ tmp13
, FIX(0.398430003)); /* c9 */
1336 tmp2
+= tmp4
+ tmp10
- MULTIPLY(tmp12
, FIX(1.989053629)) /* c9+c5+c3-c7 */
1337 + MULTIPLY(tmp14
, FIX(1.399818907)); /* c1 */
1338 tmp3
+= tmp5
+ tmp10
+ MULTIPLY(tmp13
, FIX(1.305598626)) /* c1+c5-c9-c7 */
1339 - MULTIPLY(tmp14
, FIX(1.286413905)); /* c3 */
1341 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
-1);
1342 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
-1);
1343 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
-1);
1344 dataptr
[7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
-1);
1348 if (ctr
!= DCTSIZE
) {
1351 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1353 dataptr
= workspace
; /* switch pointer to extended workspace */
1356 /* Pass 2: process columns.
1357 * We leave the results scaled up by an overall factor of 8.
1358 * We must also scale the output by (8/11)**2 = 64/121, which we partially
1359 * fold into the constant multipliers and final/initial shifting:
1360 * cK now represents sqrt(2) * cos(K*pi/22) * 128/121.
1365 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1368 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*2];
1369 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*1];
1370 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*0];
1371 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*7];
1372 tmp4
= dataptr
[DCTSIZE
*4] + dataptr
[DCTSIZE
*6];
1373 tmp5
= dataptr
[DCTSIZE
*5];
1375 tmp10
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*2];
1376 tmp11
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*1];
1377 tmp12
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*0];
1378 tmp13
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*7];
1379 tmp14
= dataptr
[DCTSIZE
*4] - dataptr
[DCTSIZE
*6];
1381 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1382 DESCALE(MULTIPLY(tmp0
+ tmp1
+ tmp2
+ tmp3
+ tmp4
+ tmp5
,
1383 FIX(1.057851240)), /* 128/121 */
1391 z1
= MULTIPLY(tmp0
+ tmp3
, FIX(1.435427942)) + /* c2 */
1392 MULTIPLY(tmp2
+ tmp4
, FIX(0.212906922)); /* c10 */
1393 z2
= MULTIPLY(tmp1
- tmp3
, FIX(0.979689713)); /* c6 */
1394 z3
= MULTIPLY(tmp0
- tmp1
, FIX(1.258538479)); /* c4 */
1395 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1396 DESCALE(z1
+ z2
- MULTIPLY(tmp3
, FIX(1.077210542)) /* c2+c8-c6 */
1397 - MULTIPLY(tmp4
, FIX(1.471445400)), /* c4+c10 */
1399 dataptr
[DCTSIZE
*4] = (DCTELEM
)
1400 DESCALE(z2
+ z3
+ MULTIPLY(tmp1
, FIX(0.065941844)) /* c4-c6-c10 */
1401 - MULTIPLY(tmp2
, FIX(1.435427942)) /* c2 */
1402 + MULTIPLY(tmp4
, FIX(0.621472312)), /* c8 */
1404 dataptr
[DCTSIZE
*6] = (DCTELEM
)
1405 DESCALE(z1
+ z3
- MULTIPLY(tmp0
, FIX(1.714276708)) /* c2+c4-c6 */
1406 - MULTIPLY(tmp2
, FIX(0.834379234)), /* c8+c10 */
1411 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.360834544)); /* c3 */
1412 tmp2
= MULTIPLY(tmp10
+ tmp12
, FIX(1.130622199)); /* c5 */
1413 tmp3
= MULTIPLY(tmp10
+ tmp13
, FIX(0.808813568)); /* c7 */
1414 tmp0
= tmp1
+ tmp2
+ tmp3
- MULTIPLY(tmp10
, FIX(1.819470145)) /* c7+c5+c3-c1 */
1415 + MULTIPLY(tmp14
, FIX(0.421479672)); /* c9 */
1416 tmp4
= MULTIPLY(tmp11
+ tmp12
, - FIX(0.808813568)); /* -c7 */
1417 tmp5
= MULTIPLY(tmp11
+ tmp13
, - FIX(1.480800167)); /* -c1 */
1418 tmp1
+= tmp4
+ tmp5
+ MULTIPLY(tmp11
, FIX(1.350258864)) /* c9+c7+c1-c3 */
1419 - MULTIPLY(tmp14
, FIX(1.130622199)); /* c5 */
1420 tmp10
= MULTIPLY(tmp12
+ tmp13
, FIX(0.421479672)); /* c9 */
1421 tmp2
+= tmp4
+ tmp10
- MULTIPLY(tmp12
, FIX(2.104122847)) /* c9+c5+c3-c7 */
1422 + MULTIPLY(tmp14
, FIX(1.480800167)); /* c1 */
1423 tmp3
+= tmp5
+ tmp10
+ MULTIPLY(tmp13
, FIX(1.381129125)) /* c1+c5-c9-c7 */
1424 - MULTIPLY(tmp14
, FIX(1.360834544)); /* c3 */
1426 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+2);
1427 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+2);
1428 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+2);
1429 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
+2);
1431 dataptr
++; /* advance pointer to next column */
1432 wsptr
++; /* advance pointer to next column */
1438 * Perform the forward DCT on a 12x12 sample block.
1442 jpeg_fdct_12x12 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
1444 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
;
1445 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
;
1446 DCTELEM workspace
[8*4];
1453 /* Pass 1: process rows.
1454 * Note results are scaled up by sqrt(8) compared to a true DCT.
1455 * cK represents sqrt(2) * cos(K*pi/24).
1461 elemptr
= sample_data
[ctr
] + start_col
;
1465 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[11]);
1466 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[10]);
1467 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[9]);
1468 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[8]);
1469 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[7]);
1470 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[6]);
1472 tmp10
= tmp0
+ tmp5
;
1473 tmp13
= tmp0
- tmp5
;
1474 tmp11
= tmp1
+ tmp4
;
1475 tmp14
= tmp1
- tmp4
;
1476 tmp12
= tmp2
+ tmp3
;
1477 tmp15
= tmp2
- tmp3
;
1479 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[11]);
1480 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[10]);
1481 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[9]);
1482 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[8]);
1483 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[7]);
1484 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[6]);
1486 /* Apply unsigned->signed conversion. */
1487 dataptr
[0] = (DCTELEM
) (tmp10
+ tmp11
+ tmp12
- 12 * CENTERJSAMPLE
);
1488 dataptr
[6] = (DCTELEM
) (tmp13
- tmp14
- tmp15
);
1489 dataptr
[4] = (DCTELEM
)
1490 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.224744871)), /* c4 */
1492 dataptr
[2] = (DCTELEM
)
1493 DESCALE(tmp14
- tmp15
+ MULTIPLY(tmp13
+ tmp15
, FIX(1.366025404)), /* c2 */
1498 tmp10
= MULTIPLY(tmp1
+ tmp4
, FIX_0_541196100
); /* c9 */
1499 tmp14
= tmp10
+ MULTIPLY(tmp1
, FIX_0_765366865
); /* c3-c9 */
1500 tmp15
= tmp10
- MULTIPLY(tmp4
, FIX_1_847759065
); /* c3+c9 */
1501 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.121971054)); /* c5 */
1502 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(0.860918669)); /* c7 */
1503 tmp10
= tmp12
+ tmp13
+ tmp14
- MULTIPLY(tmp0
, FIX(0.580774953)) /* c5+c7-c1 */
1504 + MULTIPLY(tmp5
, FIX(0.184591911)); /* c11 */
1505 tmp11
= MULTIPLY(tmp2
+ tmp3
, - FIX(0.184591911)); /* -c11 */
1506 tmp12
+= tmp11
- tmp15
- MULTIPLY(tmp2
, FIX(2.339493912)) /* c1+c5-c11 */
1507 + MULTIPLY(tmp5
, FIX(0.860918669)); /* c7 */
1508 tmp13
+= tmp11
- tmp14
+ MULTIPLY(tmp3
, FIX(0.725788011)) /* c1+c11-c7 */
1509 - MULTIPLY(tmp5
, FIX(1.121971054)); /* c5 */
1510 tmp11
= tmp15
+ MULTIPLY(tmp0
- tmp3
, FIX(1.306562965)) /* c3 */
1511 - MULTIPLY(tmp2
+ tmp5
, FIX_0_541196100
); /* c9 */
1513 dataptr
[1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
);
1514 dataptr
[3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
);
1515 dataptr
[5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
);
1516 dataptr
[7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
);
1520 if (ctr
!= DCTSIZE
) {
1523 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1525 dataptr
= workspace
; /* switch pointer to extended workspace */
1528 /* Pass 2: process columns.
1529 * We leave the results scaled up by an overall factor of 8.
1530 * We must also scale the output by (8/12)**2 = 4/9, which we partially
1531 * fold into the constant multipliers and final shifting:
1532 * cK now represents sqrt(2) * cos(K*pi/24) * 8/9.
1537 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1540 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*3];
1541 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*2];
1542 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*1];
1543 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*0];
1544 tmp4
= dataptr
[DCTSIZE
*4] + dataptr
[DCTSIZE
*7];
1545 tmp5
= dataptr
[DCTSIZE
*5] + dataptr
[DCTSIZE
*6];
1547 tmp10
= tmp0
+ tmp5
;
1548 tmp13
= tmp0
- tmp5
;
1549 tmp11
= tmp1
+ tmp4
;
1550 tmp14
= tmp1
- tmp4
;
1551 tmp12
= tmp2
+ tmp3
;
1552 tmp15
= tmp2
- tmp3
;
1554 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*3];
1555 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*2];
1556 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*1];
1557 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*0];
1558 tmp4
= dataptr
[DCTSIZE
*4] - dataptr
[DCTSIZE
*7];
1559 tmp5
= dataptr
[DCTSIZE
*5] - dataptr
[DCTSIZE
*6];
1561 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1562 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
, FIX(0.888888889)), /* 8/9 */
1564 dataptr
[DCTSIZE
*6] = (DCTELEM
)
1565 DESCALE(MULTIPLY(tmp13
- tmp14
- tmp15
, FIX(0.888888889)), /* 8/9 */
1567 dataptr
[DCTSIZE
*4] = (DCTELEM
)
1568 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.088662108)), /* c4 */
1570 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1571 DESCALE(MULTIPLY(tmp14
- tmp15
, FIX(0.888888889)) + /* 8/9 */
1572 MULTIPLY(tmp13
+ tmp15
, FIX(1.214244803)), /* c2 */
1577 tmp10
= MULTIPLY(tmp1
+ tmp4
, FIX(0.481063200)); /* c9 */
1578 tmp14
= tmp10
+ MULTIPLY(tmp1
, FIX(0.680326102)); /* c3-c9 */
1579 tmp15
= tmp10
- MULTIPLY(tmp4
, FIX(1.642452502)); /* c3+c9 */
1580 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(0.997307603)); /* c5 */
1581 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(0.765261039)); /* c7 */
1582 tmp10
= tmp12
+ tmp13
+ tmp14
- MULTIPLY(tmp0
, FIX(0.516244403)) /* c5+c7-c1 */
1583 + MULTIPLY(tmp5
, FIX(0.164081699)); /* c11 */
1584 tmp11
= MULTIPLY(tmp2
+ tmp3
, - FIX(0.164081699)); /* -c11 */
1585 tmp12
+= tmp11
- tmp15
- MULTIPLY(tmp2
, FIX(2.079550144)) /* c1+c5-c11 */
1586 + MULTIPLY(tmp5
, FIX(0.765261039)); /* c7 */
1587 tmp13
+= tmp11
- tmp14
+ MULTIPLY(tmp3
, FIX(0.645144899)) /* c1+c11-c7 */
1588 - MULTIPLY(tmp5
, FIX(0.997307603)); /* c5 */
1589 tmp11
= tmp15
+ MULTIPLY(tmp0
- tmp3
, FIX(1.161389302)) /* c3 */
1590 - MULTIPLY(tmp2
+ tmp5
, FIX(0.481063200)); /* c9 */
1592 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
+1);
1593 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
+1);
1594 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
+1);
1595 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
+1);
1597 dataptr
++; /* advance pointer to next column */
1598 wsptr
++; /* advance pointer to next column */
1604 * Perform the forward DCT on a 13x13 sample block.
1608 jpeg_fdct_13x13 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
1610 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
;
1611 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
;
1613 DCTELEM workspace
[8*5];
1620 /* Pass 1: process rows.
1621 * Note results are scaled up by sqrt(8) compared to a true DCT.
1622 * cK represents sqrt(2) * cos(K*pi/26).
1628 elemptr
= sample_data
[ctr
] + start_col
;
1632 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[12]);
1633 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[11]);
1634 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[10]);
1635 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[9]);
1636 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[8]);
1637 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[7]);
1638 tmp6
= GETJSAMPLE(elemptr
[6]);
1640 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[12]);
1641 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[11]);
1642 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[10]);
1643 tmp13
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[9]);
1644 tmp14
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[8]);
1645 tmp15
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[7]);
1647 /* Apply unsigned->signed conversion. */
1648 dataptr
[0] = (DCTELEM
)
1649 (tmp0
+ tmp1
+ tmp2
+ tmp3
+ tmp4
+ tmp5
+ tmp6
- 13 * CENTERJSAMPLE
);
1657 dataptr
[2] = (DCTELEM
)
1658 DESCALE(MULTIPLY(tmp0
, FIX(1.373119086)) + /* c2 */
1659 MULTIPLY(tmp1
, FIX(1.058554052)) + /* c6 */
1660 MULTIPLY(tmp2
, FIX(0.501487041)) - /* c10 */
1661 MULTIPLY(tmp3
, FIX(0.170464608)) - /* c12 */
1662 MULTIPLY(tmp4
, FIX(0.803364869)) - /* c8 */
1663 MULTIPLY(tmp5
, FIX(1.252223920)), /* c4 */
1665 z1
= MULTIPLY(tmp0
- tmp2
, FIX(1.155388986)) - /* (c4+c6)/2 */
1666 MULTIPLY(tmp3
- tmp4
, FIX(0.435816023)) - /* (c2-c10)/2 */
1667 MULTIPLY(tmp1
- tmp5
, FIX(0.316450131)); /* (c8-c12)/2 */
1668 z2
= MULTIPLY(tmp0
+ tmp2
, FIX(0.096834934)) - /* (c4-c6)/2 */
1669 MULTIPLY(tmp3
+ tmp4
, FIX(0.937303064)) + /* (c2+c10)/2 */
1670 MULTIPLY(tmp1
+ tmp5
, FIX(0.486914739)); /* (c8+c12)/2 */
1672 dataptr
[4] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
);
1673 dataptr
[6] = (DCTELEM
) DESCALE(z1
- z2
, CONST_BITS
);
1677 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.322312651)); /* c3 */
1678 tmp2
= MULTIPLY(tmp10
+ tmp12
, FIX(1.163874945)); /* c5 */
1679 tmp3
= MULTIPLY(tmp10
+ tmp13
, FIX(0.937797057)) + /* c7 */
1680 MULTIPLY(tmp14
+ tmp15
, FIX(0.338443458)); /* c11 */
1681 tmp0
= tmp1
+ tmp2
+ tmp3
-
1682 MULTIPLY(tmp10
, FIX(2.020082300)) + /* c3+c5+c7-c1 */
1683 MULTIPLY(tmp14
, FIX(0.318774355)); /* c9-c11 */
1684 tmp4
= MULTIPLY(tmp14
- tmp15
, FIX(0.937797057)) - /* c7 */
1685 MULTIPLY(tmp11
+ tmp12
, FIX(0.338443458)); /* c11 */
1686 tmp5
= MULTIPLY(tmp11
+ tmp13
, - FIX(1.163874945)); /* -c5 */
1687 tmp1
+= tmp4
+ tmp5
+
1688 MULTIPLY(tmp11
, FIX(0.837223564)) - /* c5+c9+c11-c3 */
1689 MULTIPLY(tmp14
, FIX(2.341699410)); /* c1+c7 */
1690 tmp6
= MULTIPLY(tmp12
+ tmp13
, - FIX(0.657217813)); /* -c9 */
1691 tmp2
+= tmp4
+ tmp6
-
1692 MULTIPLY(tmp12
, FIX(1.572116027)) + /* c1+c5-c9-c11 */
1693 MULTIPLY(tmp15
, FIX(2.260109708)); /* c3+c7 */
1694 tmp3
+= tmp5
+ tmp6
+
1695 MULTIPLY(tmp13
, FIX(2.205608352)) - /* c3+c5+c9-c7 */
1696 MULTIPLY(tmp15
, FIX(1.742345811)); /* c1+c11 */
1698 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
);
1699 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
);
1700 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
);
1701 dataptr
[7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
);
1705 if (ctr
!= DCTSIZE
) {
1708 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1710 dataptr
= workspace
; /* switch pointer to extended workspace */
1713 /* Pass 2: process columns.
1714 * We leave the results scaled up by an overall factor of 8.
1715 * We must also scale the output by (8/13)**2 = 64/169, which we partially
1716 * fold into the constant multipliers and final shifting:
1717 * cK now represents sqrt(2) * cos(K*pi/26) * 128/169.
1722 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1725 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*4];
1726 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*3];
1727 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*2];
1728 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*1];
1729 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*0];
1730 tmp5
= dataptr
[DCTSIZE
*5] + dataptr
[DCTSIZE
*7];
1731 tmp6
= dataptr
[DCTSIZE
*6];
1733 tmp10
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*4];
1734 tmp11
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*3];
1735 tmp12
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*2];
1736 tmp13
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*1];
1737 tmp14
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*0];
1738 tmp15
= dataptr
[DCTSIZE
*5] - dataptr
[DCTSIZE
*7];
1740 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1741 DESCALE(MULTIPLY(tmp0
+ tmp1
+ tmp2
+ tmp3
+ tmp4
+ tmp5
+ tmp6
,
1742 FIX(0.757396450)), /* 128/169 */
1751 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1752 DESCALE(MULTIPLY(tmp0
, FIX(1.039995521)) + /* c2 */
1753 MULTIPLY(tmp1
, FIX(0.801745081)) + /* c6 */
1754 MULTIPLY(tmp2
, FIX(0.379824504)) - /* c10 */
1755 MULTIPLY(tmp3
, FIX(0.129109289)) - /* c12 */
1756 MULTIPLY(tmp4
, FIX(0.608465700)) - /* c8 */
1757 MULTIPLY(tmp5
, FIX(0.948429952)), /* c4 */
1759 z1
= MULTIPLY(tmp0
- tmp2
, FIX(0.875087516)) - /* (c4+c6)/2 */
1760 MULTIPLY(tmp3
- tmp4
, FIX(0.330085509)) - /* (c2-c10)/2 */
1761 MULTIPLY(tmp1
- tmp5
, FIX(0.239678205)); /* (c8-c12)/2 */
1762 z2
= MULTIPLY(tmp0
+ tmp2
, FIX(0.073342435)) - /* (c4-c6)/2 */
1763 MULTIPLY(tmp3
+ tmp4
, FIX(0.709910013)) + /* (c2+c10)/2 */
1764 MULTIPLY(tmp1
+ tmp5
, FIX(0.368787494)); /* (c8+c12)/2 */
1766 dataptr
[DCTSIZE
*4] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
+1);
1767 dataptr
[DCTSIZE
*6] = (DCTELEM
) DESCALE(z1
- z2
, CONST_BITS
+1);
1771 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.001514908)); /* c3 */
1772 tmp2
= MULTIPLY(tmp10
+ tmp12
, FIX(0.881514751)); /* c5 */
1773 tmp3
= MULTIPLY(tmp10
+ tmp13
, FIX(0.710284161)) + /* c7 */
1774 MULTIPLY(tmp14
+ tmp15
, FIX(0.256335874)); /* c11 */
1775 tmp0
= tmp1
+ tmp2
+ tmp3
-
1776 MULTIPLY(tmp10
, FIX(1.530003162)) + /* c3+c5+c7-c1 */
1777 MULTIPLY(tmp14
, FIX(0.241438564)); /* c9-c11 */
1778 tmp4
= MULTIPLY(tmp14
- tmp15
, FIX(0.710284161)) - /* c7 */
1779 MULTIPLY(tmp11
+ tmp12
, FIX(0.256335874)); /* c11 */
1780 tmp5
= MULTIPLY(tmp11
+ tmp13
, - FIX(0.881514751)); /* -c5 */
1781 tmp1
+= tmp4
+ tmp5
+
1782 MULTIPLY(tmp11
, FIX(0.634110155)) - /* c5+c9+c11-c3 */
1783 MULTIPLY(tmp14
, FIX(1.773594819)); /* c1+c7 */
1784 tmp6
= MULTIPLY(tmp12
+ tmp13
, - FIX(0.497774438)); /* -c9 */
1785 tmp2
+= tmp4
+ tmp6
-
1786 MULTIPLY(tmp12
, FIX(1.190715098)) + /* c1+c5-c9-c11 */
1787 MULTIPLY(tmp15
, FIX(1.711799069)); /* c3+c7 */
1788 tmp3
+= tmp5
+ tmp6
+
1789 MULTIPLY(tmp13
, FIX(1.670519935)) - /* c3+c5+c9-c7 */
1790 MULTIPLY(tmp15
, FIX(1.319646532)); /* c1+c11 */
1792 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+1);
1793 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+1);
1794 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+1);
1795 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
+1);
1797 dataptr
++; /* advance pointer to next column */
1798 wsptr
++; /* advance pointer to next column */
1804 * Perform the forward DCT on a 14x14 sample block.
1808 jpeg_fdct_14x14 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
1810 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
;
1811 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
;
1812 DCTELEM workspace
[8*6];
1819 /* Pass 1: process rows.
1820 * Note results are scaled up by sqrt(8) compared to a true DCT.
1821 * cK represents sqrt(2) * cos(K*pi/28).
1827 elemptr
= sample_data
[ctr
] + start_col
;
1831 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[13]);
1832 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[12]);
1833 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[11]);
1834 tmp13
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[10]);
1835 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[9]);
1836 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[8]);
1837 tmp6
= GETJSAMPLE(elemptr
[6]) + GETJSAMPLE(elemptr
[7]);
1839 tmp10
= tmp0
+ tmp6
;
1840 tmp14
= tmp0
- tmp6
;
1841 tmp11
= tmp1
+ tmp5
;
1842 tmp15
= tmp1
- tmp5
;
1843 tmp12
= tmp2
+ tmp4
;
1844 tmp16
= tmp2
- tmp4
;
1846 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[13]);
1847 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[12]);
1848 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[11]);
1849 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[10]);
1850 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[9]);
1851 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[8]);
1852 tmp6
= GETJSAMPLE(elemptr
[6]) - GETJSAMPLE(elemptr
[7]);
1854 /* Apply unsigned->signed conversion. */
1855 dataptr
[0] = (DCTELEM
)
1856 (tmp10
+ tmp11
+ tmp12
+ tmp13
- 14 * CENTERJSAMPLE
);
1858 dataptr
[4] = (DCTELEM
)
1859 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.274162392)) + /* c4 */
1860 MULTIPLY(tmp11
- tmp13
, FIX(0.314692123)) - /* c12 */
1861 MULTIPLY(tmp12
- tmp13
, FIX(0.881747734)), /* c8 */
1864 tmp10
= MULTIPLY(tmp14
+ tmp15
, FIX(1.105676686)); /* c6 */
1866 dataptr
[2] = (DCTELEM
)
1867 DESCALE(tmp10
+ MULTIPLY(tmp14
, FIX(0.273079590)) /* c2-c6 */
1868 + MULTIPLY(tmp16
, FIX(0.613604268)), /* c10 */
1870 dataptr
[6] = (DCTELEM
)
1871 DESCALE(tmp10
- MULTIPLY(tmp15
, FIX(1.719280954)) /* c6+c10 */
1872 - MULTIPLY(tmp16
, FIX(1.378756276)), /* c2 */
1877 tmp10
= tmp1
+ tmp2
;
1878 tmp11
= tmp5
- tmp4
;
1879 dataptr
[7] = (DCTELEM
) (tmp0
- tmp10
+ tmp3
- tmp11
- tmp6
);
1880 tmp3
<<= CONST_BITS
;
1881 tmp10
= MULTIPLY(tmp10
, - FIX(0.158341681)); /* -c13 */
1882 tmp11
= MULTIPLY(tmp11
, FIX(1.405321284)); /* c1 */
1883 tmp10
+= tmp11
- tmp3
;
1884 tmp11
= MULTIPLY(tmp0
+ tmp2
, FIX(1.197448846)) + /* c5 */
1885 MULTIPLY(tmp4
+ tmp6
, FIX(0.752406978)); /* c9 */
1886 dataptr
[5] = (DCTELEM
)
1887 DESCALE(tmp10
+ tmp11
- MULTIPLY(tmp2
, FIX(2.373959773)) /* c3+c5-c13 */
1888 + MULTIPLY(tmp4
, FIX(1.119999435)), /* c1+c11-c9 */
1890 tmp12
= MULTIPLY(tmp0
+ tmp1
, FIX(1.334852607)) + /* c3 */
1891 MULTIPLY(tmp5
- tmp6
, FIX(0.467085129)); /* c11 */
1892 dataptr
[3] = (DCTELEM
)
1893 DESCALE(tmp10
+ tmp12
- MULTIPLY(tmp1
, FIX(0.424103948)) /* c3-c9-c13 */
1894 - MULTIPLY(tmp5
, FIX(3.069855259)), /* c1+c5+c11 */
1896 dataptr
[1] = (DCTELEM
)
1897 DESCALE(tmp11
+ tmp12
+ tmp3
+ tmp6
-
1898 MULTIPLY(tmp0
+ tmp6
, FIX(1.126980169)), /* c3+c5-c1 */
1903 if (ctr
!= DCTSIZE
) {
1906 dataptr
+= DCTSIZE
; /* advance pointer to next row */
1908 dataptr
= workspace
; /* switch pointer to extended workspace */
1911 /* Pass 2: process columns.
1912 * We leave the results scaled up by an overall factor of 8.
1913 * We must also scale the output by (8/14)**2 = 16/49, which we partially
1914 * fold into the constant multipliers and final shifting:
1915 * cK now represents sqrt(2) * cos(K*pi/28) * 32/49.
1920 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
1923 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*5];
1924 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*4];
1925 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*3];
1926 tmp13
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*2];
1927 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*1];
1928 tmp5
= dataptr
[DCTSIZE
*5] + wsptr
[DCTSIZE
*0];
1929 tmp6
= dataptr
[DCTSIZE
*6] + dataptr
[DCTSIZE
*7];
1931 tmp10
= tmp0
+ tmp6
;
1932 tmp14
= tmp0
- tmp6
;
1933 tmp11
= tmp1
+ tmp5
;
1934 tmp15
= tmp1
- tmp5
;
1935 tmp12
= tmp2
+ tmp4
;
1936 tmp16
= tmp2
- tmp4
;
1938 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*5];
1939 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*4];
1940 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*3];
1941 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*2];
1942 tmp4
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*1];
1943 tmp5
= dataptr
[DCTSIZE
*5] - wsptr
[DCTSIZE
*0];
1944 tmp6
= dataptr
[DCTSIZE
*6] - dataptr
[DCTSIZE
*7];
1946 dataptr
[DCTSIZE
*0] = (DCTELEM
)
1947 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
+ tmp13
,
1948 FIX(0.653061224)), /* 32/49 */
1951 dataptr
[DCTSIZE
*4] = (DCTELEM
)
1952 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(0.832106052)) + /* c4 */
1953 MULTIPLY(tmp11
- tmp13
, FIX(0.205513223)) - /* c12 */
1954 MULTIPLY(tmp12
- tmp13
, FIX(0.575835255)), /* c8 */
1957 tmp10
= MULTIPLY(tmp14
+ tmp15
, FIX(0.722074570)); /* c6 */
1959 dataptr
[DCTSIZE
*2] = (DCTELEM
)
1960 DESCALE(tmp10
+ MULTIPLY(tmp14
, FIX(0.178337691)) /* c2-c6 */
1961 + MULTIPLY(tmp16
, FIX(0.400721155)), /* c10 */
1963 dataptr
[DCTSIZE
*6] = (DCTELEM
)
1964 DESCALE(tmp10
- MULTIPLY(tmp15
, FIX(1.122795725)) /* c6+c10 */
1965 - MULTIPLY(tmp16
, FIX(0.900412262)), /* c2 */
1970 tmp10
= tmp1
+ tmp2
;
1971 tmp11
= tmp5
- tmp4
;
1972 dataptr
[DCTSIZE
*7] = (DCTELEM
)
1973 DESCALE(MULTIPLY(tmp0
- tmp10
+ tmp3
- tmp11
- tmp6
,
1974 FIX(0.653061224)), /* 32/49 */
1976 tmp3
= MULTIPLY(tmp3
, FIX(0.653061224)); /* 32/49 */
1977 tmp10
= MULTIPLY(tmp10
, - FIX(0.103406812)); /* -c13 */
1978 tmp11
= MULTIPLY(tmp11
, FIX(0.917760839)); /* c1 */
1979 tmp10
+= tmp11
- tmp3
;
1980 tmp11
= MULTIPLY(tmp0
+ tmp2
, FIX(0.782007410)) + /* c5 */
1981 MULTIPLY(tmp4
+ tmp6
, FIX(0.491367823)); /* c9 */
1982 dataptr
[DCTSIZE
*5] = (DCTELEM
)
1983 DESCALE(tmp10
+ tmp11
- MULTIPLY(tmp2
, FIX(1.550341076)) /* c3+c5-c13 */
1984 + MULTIPLY(tmp4
, FIX(0.731428202)), /* c1+c11-c9 */
1986 tmp12
= MULTIPLY(tmp0
+ tmp1
, FIX(0.871740478)) + /* c3 */
1987 MULTIPLY(tmp5
- tmp6
, FIX(0.305035186)); /* c11 */
1988 dataptr
[DCTSIZE
*3] = (DCTELEM
)
1989 DESCALE(tmp10
+ tmp12
- MULTIPLY(tmp1
, FIX(0.276965844)) /* c3-c9-c13 */
1990 - MULTIPLY(tmp5
, FIX(2.004803435)), /* c1+c5+c11 */
1992 dataptr
[DCTSIZE
*1] = (DCTELEM
)
1993 DESCALE(tmp11
+ tmp12
+ tmp3
1994 - MULTIPLY(tmp0
, FIX(0.735987049)) /* c3+c5-c1 */
1995 - MULTIPLY(tmp6
, FIX(0.082925825)), /* c9-c11-c13 */
1998 dataptr
++; /* advance pointer to next column */
1999 wsptr
++; /* advance pointer to next column */
2005 * Perform the forward DCT on a 15x15 sample block.
2009 jpeg_fdct_15x15 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2011 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
, tmp7
;
2012 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
;
2014 DCTELEM workspace
[8*7];
2021 /* Pass 1: process rows.
2022 * Note results are scaled up by sqrt(8) compared to a true DCT.
2023 * cK represents sqrt(2) * cos(K*pi/30).
2029 elemptr
= sample_data
[ctr
] + start_col
;
2033 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[14]);
2034 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[13]);
2035 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[12]);
2036 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[11]);
2037 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[10]);
2038 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[9]);
2039 tmp6
= GETJSAMPLE(elemptr
[6]) + GETJSAMPLE(elemptr
[8]);
2040 tmp7
= GETJSAMPLE(elemptr
[7]);
2042 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[14]);
2043 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[13]);
2044 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[12]);
2045 tmp13
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[11]);
2046 tmp14
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[10]);
2047 tmp15
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[9]);
2048 tmp16
= GETJSAMPLE(elemptr
[6]) - GETJSAMPLE(elemptr
[8]);
2050 z1
= tmp0
+ tmp4
+ tmp5
;
2051 z2
= tmp1
+ tmp3
+ tmp6
;
2053 /* Apply unsigned->signed conversion. */
2054 dataptr
[0] = (DCTELEM
) (z1
+ z2
+ z3
- 15 * CENTERJSAMPLE
);
2056 dataptr
[6] = (DCTELEM
)
2057 DESCALE(MULTIPLY(z1
- z3
, FIX(1.144122806)) - /* c6 */
2058 MULTIPLY(z2
- z3
, FIX(0.437016024)), /* c12 */
2060 tmp2
+= ((tmp1
+ tmp4
) >> 1) - tmp7
- tmp7
;
2061 z1
= MULTIPLY(tmp3
- tmp2
, FIX(1.531135173)) - /* c2+c14 */
2062 MULTIPLY(tmp6
- tmp2
, FIX(2.238241955)); /* c4+c8 */
2063 z2
= MULTIPLY(tmp5
- tmp2
, FIX(0.798468008)) - /* c8-c14 */
2064 MULTIPLY(tmp0
- tmp2
, FIX(0.091361227)); /* c2-c4 */
2065 z3
= MULTIPLY(tmp0
- tmp3
, FIX(1.383309603)) + /* c2 */
2066 MULTIPLY(tmp6
- tmp5
, FIX(0.946293579)) + /* c8 */
2067 MULTIPLY(tmp1
- tmp4
, FIX(0.790569415)); /* (c6+c12)/2 */
2069 dataptr
[2] = (DCTELEM
) DESCALE(z1
+ z3
, CONST_BITS
);
2070 dataptr
[4] = (DCTELEM
) DESCALE(z2
+ z3
, CONST_BITS
);
2074 tmp2
= MULTIPLY(tmp10
- tmp12
- tmp13
+ tmp15
+ tmp16
,
2075 FIX(1.224744871)); /* c5 */
2076 tmp1
= MULTIPLY(tmp10
- tmp14
- tmp15
, FIX(1.344997024)) + /* c3 */
2077 MULTIPLY(tmp11
- tmp13
- tmp16
, FIX(0.831253876)); /* c9 */
2078 tmp12
= MULTIPLY(tmp12
, FIX(1.224744871)); /* c5 */
2079 tmp4
= MULTIPLY(tmp10
- tmp16
, FIX(1.406466353)) + /* c1 */
2080 MULTIPLY(tmp11
+ tmp14
, FIX(1.344997024)) + /* c3 */
2081 MULTIPLY(tmp13
+ tmp15
, FIX(0.575212477)); /* c11 */
2082 tmp0
= MULTIPLY(tmp13
, FIX(0.475753014)) - /* c7-c11 */
2083 MULTIPLY(tmp14
, FIX(0.513743148)) + /* c3-c9 */
2084 MULTIPLY(tmp16
, FIX(1.700497885)) + tmp4
+ tmp12
; /* c1+c13 */
2085 tmp3
= MULTIPLY(tmp10
, - FIX(0.355500862)) - /* -(c1-c7) */
2086 MULTIPLY(tmp11
, FIX(2.176250899)) - /* c3+c9 */
2087 MULTIPLY(tmp15
, FIX(0.869244010)) + tmp4
- tmp12
; /* c11+c13 */
2089 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
);
2090 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
);
2091 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
);
2092 dataptr
[7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
);
2096 if (ctr
!= DCTSIZE
) {
2099 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2101 dataptr
= workspace
; /* switch pointer to extended workspace */
2104 /* Pass 2: process columns.
2105 * We leave the results scaled up by an overall factor of 8.
2106 * We must also scale the output by (8/15)**2 = 64/225, which we partially
2107 * fold into the constant multipliers and final shifting:
2108 * cK now represents sqrt(2) * cos(K*pi/30) * 256/225.
2113 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2116 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*6];
2117 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*5];
2118 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*4];
2119 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*3];
2120 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*2];
2121 tmp5
= dataptr
[DCTSIZE
*5] + wsptr
[DCTSIZE
*1];
2122 tmp6
= dataptr
[DCTSIZE
*6] + wsptr
[DCTSIZE
*0];
2123 tmp7
= dataptr
[DCTSIZE
*7];
2125 tmp10
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*6];
2126 tmp11
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*5];
2127 tmp12
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*4];
2128 tmp13
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*3];
2129 tmp14
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*2];
2130 tmp15
= dataptr
[DCTSIZE
*5] - wsptr
[DCTSIZE
*1];
2131 tmp16
= dataptr
[DCTSIZE
*6] - wsptr
[DCTSIZE
*0];
2133 z1
= tmp0
+ tmp4
+ tmp5
;
2134 z2
= tmp1
+ tmp3
+ tmp6
;
2136 dataptr
[DCTSIZE
*0] = (DCTELEM
)
2137 DESCALE(MULTIPLY(z1
+ z2
+ z3
, FIX(1.137777778)), /* 256/225 */
2140 dataptr
[DCTSIZE
*6] = (DCTELEM
)
2141 DESCALE(MULTIPLY(z1
- z3
, FIX(1.301757503)) - /* c6 */
2142 MULTIPLY(z2
- z3
, FIX(0.497227121)), /* c12 */
2144 tmp2
+= ((tmp1
+ tmp4
) >> 1) - tmp7
- tmp7
;
2145 z1
= MULTIPLY(tmp3
- tmp2
, FIX(1.742091575)) - /* c2+c14 */
2146 MULTIPLY(tmp6
- tmp2
, FIX(2.546621957)); /* c4+c8 */
2147 z2
= MULTIPLY(tmp5
- tmp2
, FIX(0.908479156)) - /* c8-c14 */
2148 MULTIPLY(tmp0
- tmp2
, FIX(0.103948774)); /* c2-c4 */
2149 z3
= MULTIPLY(tmp0
- tmp3
, FIX(1.573898926)) + /* c2 */
2150 MULTIPLY(tmp6
- tmp5
, FIX(1.076671805)) + /* c8 */
2151 MULTIPLY(tmp1
- tmp4
, FIX(0.899492312)); /* (c6+c12)/2 */
2153 dataptr
[DCTSIZE
*2] = (DCTELEM
) DESCALE(z1
+ z3
, CONST_BITS
+2);
2154 dataptr
[DCTSIZE
*4] = (DCTELEM
) DESCALE(z2
+ z3
, CONST_BITS
+2);
2158 tmp2
= MULTIPLY(tmp10
- tmp12
- tmp13
+ tmp15
+ tmp16
,
2159 FIX(1.393487498)); /* c5 */
2160 tmp1
= MULTIPLY(tmp10
- tmp14
- tmp15
, FIX(1.530307725)) + /* c3 */
2161 MULTIPLY(tmp11
- tmp13
- tmp16
, FIX(0.945782187)); /* c9 */
2162 tmp12
= MULTIPLY(tmp12
, FIX(1.393487498)); /* c5 */
2163 tmp4
= MULTIPLY(tmp10
- tmp16
, FIX(1.600246161)) + /* c1 */
2164 MULTIPLY(tmp11
+ tmp14
, FIX(1.530307725)) + /* c3 */
2165 MULTIPLY(tmp13
+ tmp15
, FIX(0.654463974)); /* c11 */
2166 tmp0
= MULTIPLY(tmp13
, FIX(0.541301207)) - /* c7-c11 */
2167 MULTIPLY(tmp14
, FIX(0.584525538)) + /* c3-c9 */
2168 MULTIPLY(tmp16
, FIX(1.934788705)) + tmp4
+ tmp12
; /* c1+c13 */
2169 tmp3
= MULTIPLY(tmp10
, - FIX(0.404480980)) - /* -(c1-c7) */
2170 MULTIPLY(tmp11
, FIX(2.476089912)) - /* c3+c9 */
2171 MULTIPLY(tmp15
, FIX(0.989006518)) + tmp4
- tmp12
; /* c11+c13 */
2173 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+2);
2174 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+2);
2175 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+2);
2176 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
+2);
2178 dataptr
++; /* advance pointer to next column */
2179 wsptr
++; /* advance pointer to next column */
2185 * Perform the forward DCT on a 16x16 sample block.
2189 jpeg_fdct_16x16 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2191 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
, tmp7
;
2192 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
, tmp17
;
2193 DCTELEM workspace
[DCTSIZE2
];
2200 /* Pass 1: process rows.
2201 * Note results are scaled up by sqrt(8) compared to a true DCT;
2202 * furthermore, we scale the results by 2**PASS1_BITS.
2203 * cK represents sqrt(2) * cos(K*pi/32).
2209 elemptr
= sample_data
[ctr
] + start_col
;
2213 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[15]);
2214 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[14]);
2215 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[13]);
2216 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[12]);
2217 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[11]);
2218 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[10]);
2219 tmp6
= GETJSAMPLE(elemptr
[6]) + GETJSAMPLE(elemptr
[9]);
2220 tmp7
= GETJSAMPLE(elemptr
[7]) + GETJSAMPLE(elemptr
[8]);
2222 tmp10
= tmp0
+ tmp7
;
2223 tmp14
= tmp0
- tmp7
;
2224 tmp11
= tmp1
+ tmp6
;
2225 tmp15
= tmp1
- tmp6
;
2226 tmp12
= tmp2
+ tmp5
;
2227 tmp16
= tmp2
- tmp5
;
2228 tmp13
= tmp3
+ tmp4
;
2229 tmp17
= tmp3
- tmp4
;
2231 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[15]);
2232 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[14]);
2233 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[13]);
2234 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[12]);
2235 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[11]);
2236 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[10]);
2237 tmp6
= GETJSAMPLE(elemptr
[6]) - GETJSAMPLE(elemptr
[9]);
2238 tmp7
= GETJSAMPLE(elemptr
[7]) - GETJSAMPLE(elemptr
[8]);
2240 /* Apply unsigned->signed conversion. */
2241 dataptr
[0] = (DCTELEM
)
2242 ((tmp10
+ tmp11
+ tmp12
+ tmp13
- 16 * CENTERJSAMPLE
) << PASS1_BITS
);
2243 dataptr
[4] = (DCTELEM
)
2244 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.306562965)) + /* c4[16] = c2[8] */
2245 MULTIPLY(tmp11
- tmp12
, FIX_0_541196100
), /* c12[16] = c6[8] */
2246 CONST_BITS
-PASS1_BITS
);
2248 tmp10
= MULTIPLY(tmp17
- tmp15
, FIX(0.275899379)) + /* c14[16] = c7[8] */
2249 MULTIPLY(tmp14
- tmp16
, FIX(1.387039845)); /* c2[16] = c1[8] */
2251 dataptr
[2] = (DCTELEM
)
2252 DESCALE(tmp10
+ MULTIPLY(tmp15
, FIX(1.451774982)) /* c6+c14 */
2253 + MULTIPLY(tmp16
, FIX(2.172734804)), /* c2+c10 */
2254 CONST_BITS
-PASS1_BITS
);
2255 dataptr
[6] = (DCTELEM
)
2256 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(0.211164243)) /* c2-c6 */
2257 - MULTIPLY(tmp17
, FIX(1.061594338)), /* c10+c14 */
2258 CONST_BITS
-PASS1_BITS
);
2262 tmp11
= MULTIPLY(tmp0
+ tmp1
, FIX(1.353318001)) + /* c3 */
2263 MULTIPLY(tmp6
- tmp7
, FIX(0.410524528)); /* c13 */
2264 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.247225013)) + /* c5 */
2265 MULTIPLY(tmp5
+ tmp7
, FIX(0.666655658)); /* c11 */
2266 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(1.093201867)) + /* c7 */
2267 MULTIPLY(tmp4
- tmp7
, FIX(0.897167586)); /* c9 */
2268 tmp14
= MULTIPLY(tmp1
+ tmp2
, FIX(0.138617169)) + /* c15 */
2269 MULTIPLY(tmp6
- tmp5
, FIX(1.407403738)); /* c1 */
2270 tmp15
= MULTIPLY(tmp1
+ tmp3
, - FIX(0.666655658)) + /* -c11 */
2271 MULTIPLY(tmp4
+ tmp6
, - FIX(1.247225013)); /* -c5 */
2272 tmp16
= MULTIPLY(tmp2
+ tmp3
, - FIX(1.353318001)) + /* -c3 */
2273 MULTIPLY(tmp5
- tmp4
, FIX(0.410524528)); /* c13 */
2274 tmp10
= tmp11
+ tmp12
+ tmp13
-
2275 MULTIPLY(tmp0
, FIX(2.286341144)) + /* c7+c5+c3-c1 */
2276 MULTIPLY(tmp7
, FIX(0.779653625)); /* c15+c13-c11+c9 */
2277 tmp11
+= tmp14
+ tmp15
+ MULTIPLY(tmp1
, FIX(0.071888074)) /* c9-c3-c15+c11 */
2278 - MULTIPLY(tmp6
, FIX(1.663905119)); /* c7+c13+c1-c5 */
2279 tmp12
+= tmp14
+ tmp16
- MULTIPLY(tmp2
, FIX(1.125726048)) /* c7+c5+c15-c3 */
2280 + MULTIPLY(tmp5
, FIX(1.227391138)); /* c9-c11+c1-c13 */
2281 tmp13
+= tmp15
+ tmp16
+ MULTIPLY(tmp3
, FIX(1.065388962)) /* c15+c3+c11-c7 */
2282 + MULTIPLY(tmp4
, FIX(2.167985692)); /* c1+c13+c5-c9 */
2284 dataptr
[1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
-PASS1_BITS
);
2285 dataptr
[3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
-PASS1_BITS
);
2286 dataptr
[5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
-PASS1_BITS
);
2287 dataptr
[7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
-PASS1_BITS
);
2291 if (ctr
!= DCTSIZE
) {
2292 if (ctr
== DCTSIZE
* 2)
2294 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2296 dataptr
= workspace
; /* switch pointer to extended workspace */
2299 /* Pass 2: process columns.
2300 * We remove the PASS1_BITS scaling, but leave the results scaled up
2301 * by an overall factor of 8.
2302 * We must also scale the output by (8/16)**2 = 1/2**2.
2303 * cK represents sqrt(2) * cos(K*pi/32).
2308 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2311 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*7];
2312 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*6];
2313 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*5];
2314 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*4];
2315 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*3];
2316 tmp5
= dataptr
[DCTSIZE
*5] + wsptr
[DCTSIZE
*2];
2317 tmp6
= dataptr
[DCTSIZE
*6] + wsptr
[DCTSIZE
*1];
2318 tmp7
= dataptr
[DCTSIZE
*7] + wsptr
[DCTSIZE
*0];
2320 tmp10
= tmp0
+ tmp7
;
2321 tmp14
= tmp0
- tmp7
;
2322 tmp11
= tmp1
+ tmp6
;
2323 tmp15
= tmp1
- tmp6
;
2324 tmp12
= tmp2
+ tmp5
;
2325 tmp16
= tmp2
- tmp5
;
2326 tmp13
= tmp3
+ tmp4
;
2327 tmp17
= tmp3
- tmp4
;
2329 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*7];
2330 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*6];
2331 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*5];
2332 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*4];
2333 tmp4
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*3];
2334 tmp5
= dataptr
[DCTSIZE
*5] - wsptr
[DCTSIZE
*2];
2335 tmp6
= dataptr
[DCTSIZE
*6] - wsptr
[DCTSIZE
*1];
2336 tmp7
= dataptr
[DCTSIZE
*7] - wsptr
[DCTSIZE
*0];
2338 dataptr
[DCTSIZE
*0] = (DCTELEM
)
2339 DESCALE(tmp10
+ tmp11
+ tmp12
+ tmp13
, PASS1_BITS
+2);
2340 dataptr
[DCTSIZE
*4] = (DCTELEM
)
2341 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.306562965)) + /* c4[16] = c2[8] */
2342 MULTIPLY(tmp11
- tmp12
, FIX_0_541196100
), /* c12[16] = c6[8] */
2343 CONST_BITS
+PASS1_BITS
+2);
2345 tmp10
= MULTIPLY(tmp17
- tmp15
, FIX(0.275899379)) + /* c14[16] = c7[8] */
2346 MULTIPLY(tmp14
- tmp16
, FIX(1.387039845)); /* c2[16] = c1[8] */
2348 dataptr
[DCTSIZE
*2] = (DCTELEM
)
2349 DESCALE(tmp10
+ MULTIPLY(tmp15
, FIX(1.451774982)) /* c6+c14 */
2350 + MULTIPLY(tmp16
, FIX(2.172734804)), /* c2+10 */
2351 CONST_BITS
+PASS1_BITS
+2);
2352 dataptr
[DCTSIZE
*6] = (DCTELEM
)
2353 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(0.211164243)) /* c2-c6 */
2354 - MULTIPLY(tmp17
, FIX(1.061594338)), /* c10+c14 */
2355 CONST_BITS
+PASS1_BITS
+2);
2359 tmp11
= MULTIPLY(tmp0
+ tmp1
, FIX(1.353318001)) + /* c3 */
2360 MULTIPLY(tmp6
- tmp7
, FIX(0.410524528)); /* c13 */
2361 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.247225013)) + /* c5 */
2362 MULTIPLY(tmp5
+ tmp7
, FIX(0.666655658)); /* c11 */
2363 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(1.093201867)) + /* c7 */
2364 MULTIPLY(tmp4
- tmp7
, FIX(0.897167586)); /* c9 */
2365 tmp14
= MULTIPLY(tmp1
+ tmp2
, FIX(0.138617169)) + /* c15 */
2366 MULTIPLY(tmp6
- tmp5
, FIX(1.407403738)); /* c1 */
2367 tmp15
= MULTIPLY(tmp1
+ tmp3
, - FIX(0.666655658)) + /* -c11 */
2368 MULTIPLY(tmp4
+ tmp6
, - FIX(1.247225013)); /* -c5 */
2369 tmp16
= MULTIPLY(tmp2
+ tmp3
, - FIX(1.353318001)) + /* -c3 */
2370 MULTIPLY(tmp5
- tmp4
, FIX(0.410524528)); /* c13 */
2371 tmp10
= tmp11
+ tmp12
+ tmp13
-
2372 MULTIPLY(tmp0
, FIX(2.286341144)) + /* c7+c5+c3-c1 */
2373 MULTIPLY(tmp7
, FIX(0.779653625)); /* c15+c13-c11+c9 */
2374 tmp11
+= tmp14
+ tmp15
+ MULTIPLY(tmp1
, FIX(0.071888074)) /* c9-c3-c15+c11 */
2375 - MULTIPLY(tmp6
, FIX(1.663905119)); /* c7+c13+c1-c5 */
2376 tmp12
+= tmp14
+ tmp16
- MULTIPLY(tmp2
, FIX(1.125726048)) /* c7+c5+c15-c3 */
2377 + MULTIPLY(tmp5
, FIX(1.227391138)); /* c9-c11+c1-c13 */
2378 tmp13
+= tmp15
+ tmp16
+ MULTIPLY(tmp3
, FIX(1.065388962)) /* c15+c3+c11-c7 */
2379 + MULTIPLY(tmp4
, FIX(2.167985692)); /* c1+c13+c5-c9 */
2381 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
+PASS1_BITS
+2);
2382 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
+PASS1_BITS
+2);
2383 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
+PASS1_BITS
+2);
2384 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
+PASS1_BITS
+2);
2386 dataptr
++; /* advance pointer to next column */
2387 wsptr
++; /* advance pointer to next column */
2393 * Perform the forward DCT on a 16x8 sample block.
2395 * 16-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
2399 jpeg_fdct_16x8 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2401 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
, tmp7
;
2402 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
, tmp17
;
2409 /* Pass 1: process rows.
2410 * Note results are scaled up by sqrt(8) compared to a true DCT;
2411 * furthermore, we scale the results by 2**PASS1_BITS.
2412 * 16-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
2417 for (ctr
= 0; ctr
< DCTSIZE
; ctr
++) {
2418 elemptr
= sample_data
[ctr
] + start_col
;
2422 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[15]);
2423 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[14]);
2424 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[13]);
2425 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[12]);
2426 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[11]);
2427 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[10]);
2428 tmp6
= GETJSAMPLE(elemptr
[6]) + GETJSAMPLE(elemptr
[9]);
2429 tmp7
= GETJSAMPLE(elemptr
[7]) + GETJSAMPLE(elemptr
[8]);
2431 tmp10
= tmp0
+ tmp7
;
2432 tmp14
= tmp0
- tmp7
;
2433 tmp11
= tmp1
+ tmp6
;
2434 tmp15
= tmp1
- tmp6
;
2435 tmp12
= tmp2
+ tmp5
;
2436 tmp16
= tmp2
- tmp5
;
2437 tmp13
= tmp3
+ tmp4
;
2438 tmp17
= tmp3
- tmp4
;
2440 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[15]);
2441 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[14]);
2442 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[13]);
2443 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[12]);
2444 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[11]);
2445 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[10]);
2446 tmp6
= GETJSAMPLE(elemptr
[6]) - GETJSAMPLE(elemptr
[9]);
2447 tmp7
= GETJSAMPLE(elemptr
[7]) - GETJSAMPLE(elemptr
[8]);
2449 /* Apply unsigned->signed conversion. */
2450 dataptr
[0] = (DCTELEM
)
2451 ((tmp10
+ tmp11
+ tmp12
+ tmp13
- 16 * CENTERJSAMPLE
) << PASS1_BITS
);
2452 dataptr
[4] = (DCTELEM
)
2453 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.306562965)) + /* c4[16] = c2[8] */
2454 MULTIPLY(tmp11
- tmp12
, FIX_0_541196100
), /* c12[16] = c6[8] */
2455 CONST_BITS
-PASS1_BITS
);
2457 tmp10
= MULTIPLY(tmp17
- tmp15
, FIX(0.275899379)) + /* c14[16] = c7[8] */
2458 MULTIPLY(tmp14
- tmp16
, FIX(1.387039845)); /* c2[16] = c1[8] */
2460 dataptr
[2] = (DCTELEM
)
2461 DESCALE(tmp10
+ MULTIPLY(tmp15
, FIX(1.451774982)) /* c6+c14 */
2462 + MULTIPLY(tmp16
, FIX(2.172734804)), /* c2+c10 */
2463 CONST_BITS
-PASS1_BITS
);
2464 dataptr
[6] = (DCTELEM
)
2465 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(0.211164243)) /* c2-c6 */
2466 - MULTIPLY(tmp17
, FIX(1.061594338)), /* c10+c14 */
2467 CONST_BITS
-PASS1_BITS
);
2471 tmp11
= MULTIPLY(tmp0
+ tmp1
, FIX(1.353318001)) + /* c3 */
2472 MULTIPLY(tmp6
- tmp7
, FIX(0.410524528)); /* c13 */
2473 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.247225013)) + /* c5 */
2474 MULTIPLY(tmp5
+ tmp7
, FIX(0.666655658)); /* c11 */
2475 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(1.093201867)) + /* c7 */
2476 MULTIPLY(tmp4
- tmp7
, FIX(0.897167586)); /* c9 */
2477 tmp14
= MULTIPLY(tmp1
+ tmp2
, FIX(0.138617169)) + /* c15 */
2478 MULTIPLY(tmp6
- tmp5
, FIX(1.407403738)); /* c1 */
2479 tmp15
= MULTIPLY(tmp1
+ tmp3
, - FIX(0.666655658)) + /* -c11 */
2480 MULTIPLY(tmp4
+ tmp6
, - FIX(1.247225013)); /* -c5 */
2481 tmp16
= MULTIPLY(tmp2
+ tmp3
, - FIX(1.353318001)) + /* -c3 */
2482 MULTIPLY(tmp5
- tmp4
, FIX(0.410524528)); /* c13 */
2483 tmp10
= tmp11
+ tmp12
+ tmp13
-
2484 MULTIPLY(tmp0
, FIX(2.286341144)) + /* c7+c5+c3-c1 */
2485 MULTIPLY(tmp7
, FIX(0.779653625)); /* c15+c13-c11+c9 */
2486 tmp11
+= tmp14
+ tmp15
+ MULTIPLY(tmp1
, FIX(0.071888074)) /* c9-c3-c15+c11 */
2487 - MULTIPLY(tmp6
, FIX(1.663905119)); /* c7+c13+c1-c5 */
2488 tmp12
+= tmp14
+ tmp16
- MULTIPLY(tmp2
, FIX(1.125726048)) /* c7+c5+c15-c3 */
2489 + MULTIPLY(tmp5
, FIX(1.227391138)); /* c9-c11+c1-c13 */
2490 tmp13
+= tmp15
+ tmp16
+ MULTIPLY(tmp3
, FIX(1.065388962)) /* c15+c3+c11-c7 */
2491 + MULTIPLY(tmp4
, FIX(2.167985692)); /* c1+c13+c5-c9 */
2493 dataptr
[1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
-PASS1_BITS
);
2494 dataptr
[3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
-PASS1_BITS
);
2495 dataptr
[5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
-PASS1_BITS
);
2496 dataptr
[7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
-PASS1_BITS
);
2498 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2501 /* Pass 2: process columns.
2502 * We remove the PASS1_BITS scaling, but leave the results scaled up
2503 * by an overall factor of 8.
2504 * We must also scale the output by 8/16 = 1/2.
2505 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
2509 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2510 /* Even part per LL&M figure 1 --- note that published figure is faulty;
2511 * rotator "c1" should be "c6".
2514 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*7];
2515 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*6];
2516 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*5];
2517 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*4];
2519 tmp10
= tmp0
+ tmp3
;
2520 tmp12
= tmp0
- tmp3
;
2521 tmp11
= tmp1
+ tmp2
;
2522 tmp13
= tmp1
- tmp2
;
2524 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*7];
2525 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*6];
2526 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*5];
2527 tmp3
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*4];
2529 dataptr
[DCTSIZE
*0] = (DCTELEM
) DESCALE(tmp10
+ tmp11
, PASS1_BITS
+1);
2530 dataptr
[DCTSIZE
*4] = (DCTELEM
) DESCALE(tmp10
- tmp11
, PASS1_BITS
+1);
2532 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
2533 dataptr
[DCTSIZE
*2] = (DCTELEM
)
2534 DESCALE(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
2535 CONST_BITS
+PASS1_BITS
+1);
2536 dataptr
[DCTSIZE
*6] = (DCTELEM
)
2537 DESCALE(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
2538 CONST_BITS
+PASS1_BITS
+1);
2540 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
2541 * i0..i3 in the paper are tmp0..tmp3 here.
2544 tmp12
= tmp0
+ tmp2
;
2545 tmp13
= tmp1
+ tmp3
;
2547 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
2548 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
2549 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
2553 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
2554 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
2555 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
2559 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
2560 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
2561 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
2565 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+PASS1_BITS
+1);
2566 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+PASS1_BITS
+1);
2567 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+PASS1_BITS
+1);
2568 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
+PASS1_BITS
+1);
2570 dataptr
++; /* advance pointer to next column */
2576 * Perform the forward DCT on a 14x7 sample block.
2578 * 14-point FDCT in pass 1 (rows), 7-point in pass 2 (columns).
2582 jpeg_fdct_14x7 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2584 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
;
2585 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
;
2592 /* Zero bottom row of output coefficient block. */
2593 MEMZERO(&data
[DCTSIZE
*7], SIZEOF(DCTELEM
) * DCTSIZE
);
2595 /* Pass 1: process rows.
2596 * Note results are scaled up by sqrt(8) compared to a true DCT;
2597 * furthermore, we scale the results by 2**PASS1_BITS.
2598 * 14-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
2602 for (ctr
= 0; ctr
< 7; ctr
++) {
2603 elemptr
= sample_data
[ctr
] + start_col
;
2607 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[13]);
2608 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[12]);
2609 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[11]);
2610 tmp13
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[10]);
2611 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[9]);
2612 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[8]);
2613 tmp6
= GETJSAMPLE(elemptr
[6]) + GETJSAMPLE(elemptr
[7]);
2615 tmp10
= tmp0
+ tmp6
;
2616 tmp14
= tmp0
- tmp6
;
2617 tmp11
= tmp1
+ tmp5
;
2618 tmp15
= tmp1
- tmp5
;
2619 tmp12
= tmp2
+ tmp4
;
2620 tmp16
= tmp2
- tmp4
;
2622 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[13]);
2623 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[12]);
2624 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[11]);
2625 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[10]);
2626 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[9]);
2627 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[8]);
2628 tmp6
= GETJSAMPLE(elemptr
[6]) - GETJSAMPLE(elemptr
[7]);
2630 /* Apply unsigned->signed conversion. */
2631 dataptr
[0] = (DCTELEM
)
2632 ((tmp10
+ tmp11
+ tmp12
+ tmp13
- 14 * CENTERJSAMPLE
) << PASS1_BITS
);
2634 dataptr
[4] = (DCTELEM
)
2635 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.274162392)) + /* c4 */
2636 MULTIPLY(tmp11
- tmp13
, FIX(0.314692123)) - /* c12 */
2637 MULTIPLY(tmp12
- tmp13
, FIX(0.881747734)), /* c8 */
2638 CONST_BITS
-PASS1_BITS
);
2640 tmp10
= MULTIPLY(tmp14
+ tmp15
, FIX(1.105676686)); /* c6 */
2642 dataptr
[2] = (DCTELEM
)
2643 DESCALE(tmp10
+ MULTIPLY(tmp14
, FIX(0.273079590)) /* c2-c6 */
2644 + MULTIPLY(tmp16
, FIX(0.613604268)), /* c10 */
2645 CONST_BITS
-PASS1_BITS
);
2646 dataptr
[6] = (DCTELEM
)
2647 DESCALE(tmp10
- MULTIPLY(tmp15
, FIX(1.719280954)) /* c6+c10 */
2648 - MULTIPLY(tmp16
, FIX(1.378756276)), /* c2 */
2649 CONST_BITS
-PASS1_BITS
);
2653 tmp10
= tmp1
+ tmp2
;
2654 tmp11
= tmp5
- tmp4
;
2655 dataptr
[7] = (DCTELEM
) ((tmp0
- tmp10
+ tmp3
- tmp11
- tmp6
) << PASS1_BITS
);
2656 tmp3
<<= CONST_BITS
;
2657 tmp10
= MULTIPLY(tmp10
, - FIX(0.158341681)); /* -c13 */
2658 tmp11
= MULTIPLY(tmp11
, FIX(1.405321284)); /* c1 */
2659 tmp10
+= tmp11
- tmp3
;
2660 tmp11
= MULTIPLY(tmp0
+ tmp2
, FIX(1.197448846)) + /* c5 */
2661 MULTIPLY(tmp4
+ tmp6
, FIX(0.752406978)); /* c9 */
2662 dataptr
[5] = (DCTELEM
)
2663 DESCALE(tmp10
+ tmp11
- MULTIPLY(tmp2
, FIX(2.373959773)) /* c3+c5-c13 */
2664 + MULTIPLY(tmp4
, FIX(1.119999435)), /* c1+c11-c9 */
2665 CONST_BITS
-PASS1_BITS
);
2666 tmp12
= MULTIPLY(tmp0
+ tmp1
, FIX(1.334852607)) + /* c3 */
2667 MULTIPLY(tmp5
- tmp6
, FIX(0.467085129)); /* c11 */
2668 dataptr
[3] = (DCTELEM
)
2669 DESCALE(tmp10
+ tmp12
- MULTIPLY(tmp1
, FIX(0.424103948)) /* c3-c9-c13 */
2670 - MULTIPLY(tmp5
, FIX(3.069855259)), /* c1+c5+c11 */
2671 CONST_BITS
-PASS1_BITS
);
2672 dataptr
[1] = (DCTELEM
)
2673 DESCALE(tmp11
+ tmp12
+ tmp3
+ tmp6
-
2674 MULTIPLY(tmp0
+ tmp6
, FIX(1.126980169)), /* c3+c5-c1 */
2675 CONST_BITS
-PASS1_BITS
);
2677 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2680 /* Pass 2: process columns.
2681 * We remove the PASS1_BITS scaling, but leave the results scaled up
2682 * by an overall factor of 8.
2683 * We must also scale the output by (8/14)*(8/7) = 32/49, which we
2684 * partially fold into the constant multipliers and final shifting:
2685 * 7-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/14) * 64/49.
2689 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2692 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*6];
2693 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*5];
2694 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*4];
2695 tmp3
= dataptr
[DCTSIZE
*3];
2697 tmp10
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*6];
2698 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*5];
2699 tmp12
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*4];
2702 dataptr
[DCTSIZE
*0] = (DCTELEM
)
2703 DESCALE(MULTIPLY(z1
+ tmp1
+ tmp3
, FIX(1.306122449)), /* 64/49 */
2704 CONST_BITS
+PASS1_BITS
+1);
2708 z1
= MULTIPLY(z1
, FIX(0.461784020)); /* (c2+c6-c4)/2 */
2709 z2
= MULTIPLY(tmp0
- tmp2
, FIX(1.202428084)); /* (c2+c4-c6)/2 */
2710 z3
= MULTIPLY(tmp1
- tmp2
, FIX(0.411026446)); /* c6 */
2711 dataptr
[DCTSIZE
*2] = (DCTELEM
) DESCALE(z1
+ z2
+ z3
, CONST_BITS
+PASS1_BITS
+1);
2713 z2
= MULTIPLY(tmp0
- tmp1
, FIX(1.151670509)); /* c4 */
2714 dataptr
[DCTSIZE
*4] = (DCTELEM
)
2715 DESCALE(z2
+ z3
- MULTIPLY(tmp1
- tmp3
, FIX(0.923568041)), /* c2+c6-c4 */
2716 CONST_BITS
+PASS1_BITS
+1);
2717 dataptr
[DCTSIZE
*6] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
+PASS1_BITS
+1);
2721 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(1.221765677)); /* (c3+c1-c5)/2 */
2722 tmp2
= MULTIPLY(tmp10
- tmp11
, FIX(0.222383464)); /* (c3+c5-c1)/2 */
2725 tmp2
= MULTIPLY(tmp11
+ tmp12
, - FIX(1.800824523)); /* -c1 */
2727 tmp3
= MULTIPLY(tmp10
+ tmp12
, FIX(0.801442310)); /* c5 */
2729 tmp2
+= tmp3
+ MULTIPLY(tmp12
, FIX(2.443531355)); /* c3+c1-c5 */
2731 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
+PASS1_BITS
+1);
2732 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
+PASS1_BITS
+1);
2733 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
+PASS1_BITS
+1);
2735 dataptr
++; /* advance pointer to next column */
2741 * Perform the forward DCT on a 12x6 sample block.
2743 * 12-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
2747 jpeg_fdct_12x6 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2749 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
;
2750 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
;
2756 /* Zero 2 bottom rows of output coefficient block. */
2757 MEMZERO(&data
[DCTSIZE
*6], SIZEOF(DCTELEM
) * DCTSIZE
* 2);
2759 /* Pass 1: process rows.
2760 * Note results are scaled up by sqrt(8) compared to a true DCT;
2761 * furthermore, we scale the results by 2**PASS1_BITS.
2762 * 12-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
2766 for (ctr
= 0; ctr
< 6; ctr
++) {
2767 elemptr
= sample_data
[ctr
] + start_col
;
2771 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[11]);
2772 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[10]);
2773 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[9]);
2774 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[8]);
2775 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[7]);
2776 tmp5
= GETJSAMPLE(elemptr
[5]) + GETJSAMPLE(elemptr
[6]);
2778 tmp10
= tmp0
+ tmp5
;
2779 tmp13
= tmp0
- tmp5
;
2780 tmp11
= tmp1
+ tmp4
;
2781 tmp14
= tmp1
- tmp4
;
2782 tmp12
= tmp2
+ tmp3
;
2783 tmp15
= tmp2
- tmp3
;
2785 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[11]);
2786 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[10]);
2787 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[9]);
2788 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[8]);
2789 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[7]);
2790 tmp5
= GETJSAMPLE(elemptr
[5]) - GETJSAMPLE(elemptr
[6]);
2792 /* Apply unsigned->signed conversion. */
2793 dataptr
[0] = (DCTELEM
)
2794 ((tmp10
+ tmp11
+ tmp12
- 12 * CENTERJSAMPLE
) << PASS1_BITS
);
2795 dataptr
[6] = (DCTELEM
) ((tmp13
- tmp14
- tmp15
) << PASS1_BITS
);
2796 dataptr
[4] = (DCTELEM
)
2797 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.224744871)), /* c4 */
2798 CONST_BITS
-PASS1_BITS
);
2799 dataptr
[2] = (DCTELEM
)
2800 DESCALE(tmp14
- tmp15
+ MULTIPLY(tmp13
+ tmp15
, FIX(1.366025404)), /* c2 */
2801 CONST_BITS
-PASS1_BITS
);
2805 tmp10
= MULTIPLY(tmp1
+ tmp4
, FIX_0_541196100
); /* c9 */
2806 tmp14
= tmp10
+ MULTIPLY(tmp1
, FIX_0_765366865
); /* c3-c9 */
2807 tmp15
= tmp10
- MULTIPLY(tmp4
, FIX_1_847759065
); /* c3+c9 */
2808 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.121971054)); /* c5 */
2809 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(0.860918669)); /* c7 */
2810 tmp10
= tmp12
+ tmp13
+ tmp14
- MULTIPLY(tmp0
, FIX(0.580774953)) /* c5+c7-c1 */
2811 + MULTIPLY(tmp5
, FIX(0.184591911)); /* c11 */
2812 tmp11
= MULTIPLY(tmp2
+ tmp3
, - FIX(0.184591911)); /* -c11 */
2813 tmp12
+= tmp11
- tmp15
- MULTIPLY(tmp2
, FIX(2.339493912)) /* c1+c5-c11 */
2814 + MULTIPLY(tmp5
, FIX(0.860918669)); /* c7 */
2815 tmp13
+= tmp11
- tmp14
+ MULTIPLY(tmp3
, FIX(0.725788011)) /* c1+c11-c7 */
2816 - MULTIPLY(tmp5
, FIX(1.121971054)); /* c5 */
2817 tmp11
= tmp15
+ MULTIPLY(tmp0
- tmp3
, FIX(1.306562965)) /* c3 */
2818 - MULTIPLY(tmp2
+ tmp5
, FIX_0_541196100
); /* c9 */
2820 dataptr
[1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
-PASS1_BITS
);
2821 dataptr
[3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
-PASS1_BITS
);
2822 dataptr
[5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
-PASS1_BITS
);
2823 dataptr
[7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
-PASS1_BITS
);
2825 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2828 /* Pass 2: process columns.
2829 * We remove the PASS1_BITS scaling, but leave the results scaled up
2830 * by an overall factor of 8.
2831 * We must also scale the output by (8/12)*(8/6) = 8/9, which we
2832 * partially fold into the constant multipliers and final shifting:
2833 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12) * 16/9.
2837 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2840 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*5];
2841 tmp11
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*4];
2842 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*3];
2844 tmp10
= tmp0
+ tmp2
;
2845 tmp12
= tmp0
- tmp2
;
2847 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*5];
2848 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*4];
2849 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*3];
2851 dataptr
[DCTSIZE
*0] = (DCTELEM
)
2852 DESCALE(MULTIPLY(tmp10
+ tmp11
, FIX(1.777777778)), /* 16/9 */
2853 CONST_BITS
+PASS1_BITS
+1);
2854 dataptr
[DCTSIZE
*2] = (DCTELEM
)
2855 DESCALE(MULTIPLY(tmp12
, FIX(2.177324216)), /* c2 */
2856 CONST_BITS
+PASS1_BITS
+1);
2857 dataptr
[DCTSIZE
*4] = (DCTELEM
)
2858 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(1.257078722)), /* c4 */
2859 CONST_BITS
+PASS1_BITS
+1);
2863 tmp10
= MULTIPLY(tmp0
+ tmp2
, FIX(0.650711829)); /* c5 */
2865 dataptr
[DCTSIZE
*1] = (DCTELEM
)
2866 DESCALE(tmp10
+ MULTIPLY(tmp0
+ tmp1
, FIX(1.777777778)), /* 16/9 */
2867 CONST_BITS
+PASS1_BITS
+1);
2868 dataptr
[DCTSIZE
*3] = (DCTELEM
)
2869 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp2
, FIX(1.777777778)), /* 16/9 */
2870 CONST_BITS
+PASS1_BITS
+1);
2871 dataptr
[DCTSIZE
*5] = (DCTELEM
)
2872 DESCALE(tmp10
+ MULTIPLY(tmp2
- tmp1
, FIX(1.777777778)), /* 16/9 */
2873 CONST_BITS
+PASS1_BITS
+1);
2875 dataptr
++; /* advance pointer to next column */
2881 * Perform the forward DCT on a 10x5 sample block.
2883 * 10-point FDCT in pass 1 (rows), 5-point in pass 2 (columns).
2887 jpeg_fdct_10x5 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
2889 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
;
2890 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
;
2896 /* Zero 3 bottom rows of output coefficient block. */
2897 MEMZERO(&data
[DCTSIZE
*5], SIZEOF(DCTELEM
) * DCTSIZE
* 3);
2899 /* Pass 1: process rows.
2900 * Note results are scaled up by sqrt(8) compared to a true DCT;
2901 * furthermore, we scale the results by 2**PASS1_BITS.
2902 * 10-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
2906 for (ctr
= 0; ctr
< 5; ctr
++) {
2907 elemptr
= sample_data
[ctr
] + start_col
;
2911 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[9]);
2912 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[8]);
2913 tmp12
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[7]);
2914 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[6]);
2915 tmp4
= GETJSAMPLE(elemptr
[4]) + GETJSAMPLE(elemptr
[5]);
2917 tmp10
= tmp0
+ tmp4
;
2918 tmp13
= tmp0
- tmp4
;
2919 tmp11
= tmp1
+ tmp3
;
2920 tmp14
= tmp1
- tmp3
;
2922 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[9]);
2923 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[8]);
2924 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[7]);
2925 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[6]);
2926 tmp4
= GETJSAMPLE(elemptr
[4]) - GETJSAMPLE(elemptr
[5]);
2928 /* Apply unsigned->signed conversion. */
2929 dataptr
[0] = (DCTELEM
)
2930 ((tmp10
+ tmp11
+ tmp12
- 10 * CENTERJSAMPLE
) << PASS1_BITS
);
2932 dataptr
[4] = (DCTELEM
)
2933 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.144122806)) - /* c4 */
2934 MULTIPLY(tmp11
- tmp12
, FIX(0.437016024)), /* c8 */
2935 CONST_BITS
-PASS1_BITS
);
2936 tmp10
= MULTIPLY(tmp13
+ tmp14
, FIX(0.831253876)); /* c6 */
2937 dataptr
[2] = (DCTELEM
)
2938 DESCALE(tmp10
+ MULTIPLY(tmp13
, FIX(0.513743148)), /* c2-c6 */
2939 CONST_BITS
-PASS1_BITS
);
2940 dataptr
[6] = (DCTELEM
)
2941 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(2.176250899)), /* c2+c6 */
2942 CONST_BITS
-PASS1_BITS
);
2946 tmp10
= tmp0
+ tmp4
;
2947 tmp11
= tmp1
- tmp3
;
2948 dataptr
[5] = (DCTELEM
) ((tmp10
- tmp11
- tmp2
) << PASS1_BITS
);
2949 tmp2
<<= CONST_BITS
;
2950 dataptr
[1] = (DCTELEM
)
2951 DESCALE(MULTIPLY(tmp0
, FIX(1.396802247)) + /* c1 */
2952 MULTIPLY(tmp1
, FIX(1.260073511)) + tmp2
+ /* c3 */
2953 MULTIPLY(tmp3
, FIX(0.642039522)) + /* c7 */
2954 MULTIPLY(tmp4
, FIX(0.221231742)), /* c9 */
2955 CONST_BITS
-PASS1_BITS
);
2956 tmp12
= MULTIPLY(tmp0
- tmp4
, FIX(0.951056516)) - /* (c3+c7)/2 */
2957 MULTIPLY(tmp1
+ tmp3
, FIX(0.587785252)); /* (c1-c9)/2 */
2958 tmp13
= MULTIPLY(tmp10
+ tmp11
, FIX(0.309016994)) + /* (c3-c7)/2 */
2959 (tmp11
<< (CONST_BITS
- 1)) - tmp2
;
2960 dataptr
[3] = (DCTELEM
) DESCALE(tmp12
+ tmp13
, CONST_BITS
-PASS1_BITS
);
2961 dataptr
[7] = (DCTELEM
) DESCALE(tmp12
- tmp13
, CONST_BITS
-PASS1_BITS
);
2963 dataptr
+= DCTSIZE
; /* advance pointer to next row */
2966 /* Pass 2: process columns.
2967 * We remove the PASS1_BITS scaling, but leave the results scaled up
2968 * by an overall factor of 8.
2969 * We must also scale the output by (8/10)*(8/5) = 32/25, which we
2970 * fold into the constant multipliers:
2971 * 5-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/10) * 32/25.
2975 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
2978 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*4];
2979 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*3];
2980 tmp2
= dataptr
[DCTSIZE
*2];
2982 tmp10
= tmp0
+ tmp1
;
2983 tmp11
= tmp0
- tmp1
;
2985 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*4];
2986 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*3];
2988 dataptr
[DCTSIZE
*0] = (DCTELEM
)
2989 DESCALE(MULTIPLY(tmp10
+ tmp2
, FIX(1.28)), /* 32/25 */
2990 CONST_BITS
+PASS1_BITS
);
2991 tmp11
= MULTIPLY(tmp11
, FIX(1.011928851)); /* (c2+c4)/2 */
2993 tmp10
= MULTIPLY(tmp10
, FIX(0.452548340)); /* (c2-c4)/2 */
2994 dataptr
[DCTSIZE
*2] = (DCTELEM
) DESCALE(tmp11
+ tmp10
, CONST_BITS
+PASS1_BITS
);
2995 dataptr
[DCTSIZE
*4] = (DCTELEM
) DESCALE(tmp11
- tmp10
, CONST_BITS
+PASS1_BITS
);
2999 tmp10
= MULTIPLY(tmp0
+ tmp1
, FIX(1.064004961)); /* c3 */
3001 dataptr
[DCTSIZE
*1] = (DCTELEM
)
3002 DESCALE(tmp10
+ MULTIPLY(tmp0
, FIX(0.657591230)), /* c1-c3 */
3003 CONST_BITS
+PASS1_BITS
);
3004 dataptr
[DCTSIZE
*3] = (DCTELEM
)
3005 DESCALE(tmp10
- MULTIPLY(tmp1
, FIX(2.785601151)), /* c1+c3 */
3006 CONST_BITS
+PASS1_BITS
);
3008 dataptr
++; /* advance pointer to next column */
3014 * Perform the forward DCT on an 8x4 sample block.
3016 * 8-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
3020 jpeg_fdct_8x4 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3022 INT32 tmp0
, tmp1
, tmp2
, tmp3
;
3023 INT32 tmp10
, tmp11
, tmp12
, tmp13
;
3030 /* Zero 4 bottom rows of output coefficient block. */
3031 MEMZERO(&data
[DCTSIZE
*4], SIZEOF(DCTELEM
) * DCTSIZE
* 4);
3033 /* Pass 1: process rows.
3034 * Note results are scaled up by sqrt(8) compared to a true DCT;
3035 * furthermore, we scale the results by 2**PASS1_BITS.
3036 * We must also scale the output by 8/4 = 2, which we add here.
3037 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
3041 for (ctr
= 0; ctr
< 4; ctr
++) {
3042 elemptr
= sample_data
[ctr
] + start_col
;
3044 /* Even part per LL&M figure 1 --- note that published figure is faulty;
3045 * rotator "c1" should be "c6".
3048 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[7]);
3049 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[6]);
3050 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[5]);
3051 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[4]);
3053 tmp10
= tmp0
+ tmp3
;
3054 tmp12
= tmp0
- tmp3
;
3055 tmp11
= tmp1
+ tmp2
;
3056 tmp13
= tmp1
- tmp2
;
3058 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[7]);
3059 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[6]);
3060 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[5]);
3061 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[4]);
3063 /* Apply unsigned->signed conversion. */
3064 dataptr
[0] = (DCTELEM
)
3065 ((tmp10
+ tmp11
- 8 * CENTERJSAMPLE
) << (PASS1_BITS
+1));
3066 dataptr
[4] = (DCTELEM
) ((tmp10
- tmp11
) << (PASS1_BITS
+1));
3068 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
3069 /* Add fudge factor here for final descale. */
3070 z1
+= ONE
<< (CONST_BITS
-PASS1_BITS
-2);
3072 dataptr
[2] = (DCTELEM
)
3073 RIGHT_SHIFT(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
3074 CONST_BITS
-PASS1_BITS
-1);
3075 dataptr
[6] = (DCTELEM
)
3076 RIGHT_SHIFT(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
3077 CONST_BITS
-PASS1_BITS
-1);
3079 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
3080 * i0..i3 in the paper are tmp0..tmp3 here.
3083 tmp12
= tmp0
+ tmp2
;
3084 tmp13
= tmp1
+ tmp3
;
3086 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
3087 /* Add fudge factor here for final descale. */
3088 z1
+= ONE
<< (CONST_BITS
-PASS1_BITS
-2);
3090 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
3091 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
3095 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
3096 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
3097 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
3101 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
3102 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
3103 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
3107 dataptr
[1] = (DCTELEM
) RIGHT_SHIFT(tmp0
, CONST_BITS
-PASS1_BITS
-1);
3108 dataptr
[3] = (DCTELEM
) RIGHT_SHIFT(tmp1
, CONST_BITS
-PASS1_BITS
-1);
3109 dataptr
[5] = (DCTELEM
) RIGHT_SHIFT(tmp2
, CONST_BITS
-PASS1_BITS
-1);
3110 dataptr
[7] = (DCTELEM
) RIGHT_SHIFT(tmp3
, CONST_BITS
-PASS1_BITS
-1);
3112 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3115 /* Pass 2: process columns.
3116 * We remove the PASS1_BITS scaling, but leave the results scaled up
3117 * by an overall factor of 8.
3118 * 4-point FDCT kernel,
3119 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
3123 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
3126 /* Add fudge factor here for final descale. */
3127 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*3] + (ONE
<< (PASS1_BITS
-1));
3128 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*2];
3130 tmp10
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*3];
3131 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*2];
3133 dataptr
[DCTSIZE
*0] = (DCTELEM
) RIGHT_SHIFT(tmp0
+ tmp1
, PASS1_BITS
);
3134 dataptr
[DCTSIZE
*2] = (DCTELEM
) RIGHT_SHIFT(tmp0
- tmp1
, PASS1_BITS
);
3138 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
3139 /* Add fudge factor here for final descale. */
3140 tmp0
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
3142 dataptr
[DCTSIZE
*1] = (DCTELEM
)
3143 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
3144 CONST_BITS
+PASS1_BITS
);
3145 dataptr
[DCTSIZE
*3] = (DCTELEM
)
3146 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
3147 CONST_BITS
+PASS1_BITS
);
3149 dataptr
++; /* advance pointer to next column */
3155 * Perform the forward DCT on a 6x3 sample block.
3157 * 6-point FDCT in pass 1 (rows), 3-point in pass 2 (columns).
3161 jpeg_fdct_6x3 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3163 INT32 tmp0
, tmp1
, tmp2
;
3164 INT32 tmp10
, tmp11
, tmp12
;
3170 /* Pre-zero output coefficient block. */
3171 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3173 /* Pass 1: process rows.
3174 * Note results are scaled up by sqrt(8) compared to a true DCT;
3175 * furthermore, we scale the results by 2**PASS1_BITS.
3176 * We scale the results further by 2 as part of output adaption
3177 * scaling for different DCT size.
3178 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3182 for (ctr
= 0; ctr
< 3; ctr
++) {
3183 elemptr
= sample_data
[ctr
] + start_col
;
3187 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[5]);
3188 tmp11
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[4]);
3189 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[3]);
3191 tmp10
= tmp0
+ tmp2
;
3192 tmp12
= tmp0
- tmp2
;
3194 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[5]);
3195 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[4]);
3196 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[3]);
3198 /* Apply unsigned->signed conversion. */
3199 dataptr
[0] = (DCTELEM
)
3200 ((tmp10
+ tmp11
- 6 * CENTERJSAMPLE
) << (PASS1_BITS
+1));
3201 dataptr
[2] = (DCTELEM
)
3202 DESCALE(MULTIPLY(tmp12
, FIX(1.224744871)), /* c2 */
3203 CONST_BITS
-PASS1_BITS
-1);
3204 dataptr
[4] = (DCTELEM
)
3205 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(0.707106781)), /* c4 */
3206 CONST_BITS
-PASS1_BITS
-1);
3210 tmp10
= DESCALE(MULTIPLY(tmp0
+ tmp2
, FIX(0.366025404)), /* c5 */
3211 CONST_BITS
-PASS1_BITS
-1);
3213 dataptr
[1] = (DCTELEM
) (tmp10
+ ((tmp0
+ tmp1
) << (PASS1_BITS
+1)));
3214 dataptr
[3] = (DCTELEM
) ((tmp0
- tmp1
- tmp2
) << (PASS1_BITS
+1));
3215 dataptr
[5] = (DCTELEM
) (tmp10
+ ((tmp2
- tmp1
) << (PASS1_BITS
+1)));
3217 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3220 /* Pass 2: process columns.
3221 * We remove the PASS1_BITS scaling, but leave the results scaled up
3222 * by an overall factor of 8.
3223 * We must also scale the output by (8/6)*(8/3) = 32/9, which we partially
3224 * fold into the constant multipliers (other part was done in pass 1):
3225 * 3-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/6) * 16/9.
3229 for (ctr
= 0; ctr
< 6; ctr
++) {
3232 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*2];
3233 tmp1
= dataptr
[DCTSIZE
*1];
3235 tmp2
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*2];
3237 dataptr
[DCTSIZE
*0] = (DCTELEM
)
3238 DESCALE(MULTIPLY(tmp0
+ tmp1
, FIX(1.777777778)), /* 16/9 */
3239 CONST_BITS
+PASS1_BITS
);
3240 dataptr
[DCTSIZE
*2] = (DCTELEM
)
3241 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp1
, FIX(1.257078722)), /* c2 */
3242 CONST_BITS
+PASS1_BITS
);
3246 dataptr
[DCTSIZE
*1] = (DCTELEM
)
3247 DESCALE(MULTIPLY(tmp2
, FIX(2.177324216)), /* c1 */
3248 CONST_BITS
+PASS1_BITS
);
3250 dataptr
++; /* advance pointer to next column */
3256 * Perform the forward DCT on a 4x2 sample block.
3258 * 4-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
3262 jpeg_fdct_4x2 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3271 /* Pre-zero output coefficient block. */
3272 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3274 /* Pass 1: process rows.
3275 * Note results are scaled up by sqrt(8) compared to a true DCT;
3276 * furthermore, we scale the results by 2**PASS1_BITS.
3277 * We must also scale the output by (8/4)*(8/2) = 2**3, which we add here.
3278 * 4-point FDCT kernel,
3279 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
3283 for (ctr
= 0; ctr
< 2; ctr
++) {
3284 elemptr
= sample_data
[ctr
] + start_col
;
3288 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[3]);
3289 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[2]);
3291 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[3]);
3292 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[2]);
3294 /* Apply unsigned->signed conversion. */
3295 dataptr
[0] = (DCTELEM
)
3296 ((tmp0
+ tmp1
- 4 * CENTERJSAMPLE
) << (PASS1_BITS
+3));
3297 dataptr
[2] = (DCTELEM
) ((tmp0
- tmp1
) << (PASS1_BITS
+3));
3301 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
3302 /* Add fudge factor here for final descale. */
3303 tmp0
+= ONE
<< (CONST_BITS
-PASS1_BITS
-4);
3305 dataptr
[1] = (DCTELEM
)
3306 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
3307 CONST_BITS
-PASS1_BITS
-3);
3308 dataptr
[3] = (DCTELEM
)
3309 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
3310 CONST_BITS
-PASS1_BITS
-3);
3312 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3315 /* Pass 2: process columns.
3316 * We remove the PASS1_BITS scaling, but leave the results scaled up
3317 * by an overall factor of 8.
3321 for (ctr
= 0; ctr
< 4; ctr
++) {
3324 /* Add fudge factor here for final descale. */
3325 tmp0
= dataptr
[DCTSIZE
*0] + (ONE
<< (PASS1_BITS
-1));
3326 tmp1
= dataptr
[DCTSIZE
*1];
3328 dataptr
[DCTSIZE
*0] = (DCTELEM
) RIGHT_SHIFT(tmp0
+ tmp1
, PASS1_BITS
);
3332 dataptr
[DCTSIZE
*1] = (DCTELEM
) RIGHT_SHIFT(tmp0
- tmp1
, PASS1_BITS
);
3334 dataptr
++; /* advance pointer to next column */
3340 * Perform the forward DCT on a 2x1 sample block.
3342 * 2-point FDCT in pass 1 (rows), 1-point in pass 2 (columns).
3346 jpeg_fdct_2x1 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3351 /* Pre-zero output coefficient block. */
3352 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3354 elemptr
= sample_data
[0] + start_col
;
3356 tmp0
= GETJSAMPLE(elemptr
[0]);
3357 tmp1
= GETJSAMPLE(elemptr
[1]);
3359 /* We leave the results scaled up by an overall factor of 8.
3360 * We must also scale the output by (8/2)*(8/1) = 2**5.
3365 /* Apply unsigned->signed conversion. */
3366 data
[0] = (tmp0
+ tmp1
- 2 * CENTERJSAMPLE
) << 5;
3370 data
[1] = (tmp0
- tmp1
) << 5;
3375 * Perform the forward DCT on an 8x16 sample block.
3377 * 8-point FDCT in pass 1 (rows), 16-point in pass 2 (columns).
3381 jpeg_fdct_8x16 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3383 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
, tmp7
;
3384 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
, tmp17
;
3386 DCTELEM workspace
[DCTSIZE2
];
3393 /* Pass 1: process rows.
3394 * Note results are scaled up by sqrt(8) compared to a true DCT;
3395 * furthermore, we scale the results by 2**PASS1_BITS.
3396 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
3402 elemptr
= sample_data
[ctr
] + start_col
;
3404 /* Even part per LL&M figure 1 --- note that published figure is faulty;
3405 * rotator "c1" should be "c6".
3408 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[7]);
3409 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[6]);
3410 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[5]);
3411 tmp3
= GETJSAMPLE(elemptr
[3]) + GETJSAMPLE(elemptr
[4]);
3413 tmp10
= tmp0
+ tmp3
;
3414 tmp12
= tmp0
- tmp3
;
3415 tmp11
= tmp1
+ tmp2
;
3416 tmp13
= tmp1
- tmp2
;
3418 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[7]);
3419 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[6]);
3420 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[5]);
3421 tmp3
= GETJSAMPLE(elemptr
[3]) - GETJSAMPLE(elemptr
[4]);
3423 /* Apply unsigned->signed conversion. */
3424 dataptr
[0] = (DCTELEM
) ((tmp10
+ tmp11
- 8 * CENTERJSAMPLE
) << PASS1_BITS
);
3425 dataptr
[4] = (DCTELEM
) ((tmp10
- tmp11
) << PASS1_BITS
);
3427 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
3428 dataptr
[2] = (DCTELEM
)
3429 DESCALE(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
3430 CONST_BITS
-PASS1_BITS
);
3431 dataptr
[6] = (DCTELEM
)
3432 DESCALE(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
3433 CONST_BITS
-PASS1_BITS
);
3435 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
3436 * i0..i3 in the paper are tmp0..tmp3 here.
3439 tmp12
= tmp0
+ tmp2
;
3440 tmp13
= tmp1
+ tmp3
;
3442 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
3443 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
3444 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
3448 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
3449 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
3450 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
3454 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
3455 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
3456 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
3460 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
-PASS1_BITS
);
3461 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
-PASS1_BITS
);
3462 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
-PASS1_BITS
);
3463 dataptr
[7] = (DCTELEM
) DESCALE(tmp3
, CONST_BITS
-PASS1_BITS
);
3467 if (ctr
!= DCTSIZE
) {
3468 if (ctr
== DCTSIZE
* 2)
3470 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3472 dataptr
= workspace
; /* switch pointer to extended workspace */
3475 /* Pass 2: process columns.
3476 * We remove the PASS1_BITS scaling, but leave the results scaled up
3477 * by an overall factor of 8.
3478 * We must also scale the output by 8/16 = 1/2.
3479 * 16-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
3484 for (ctr
= DCTSIZE
-1; ctr
>= 0; ctr
--) {
3487 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*7];
3488 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*6];
3489 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*5];
3490 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*4];
3491 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*3];
3492 tmp5
= dataptr
[DCTSIZE
*5] + wsptr
[DCTSIZE
*2];
3493 tmp6
= dataptr
[DCTSIZE
*6] + wsptr
[DCTSIZE
*1];
3494 tmp7
= dataptr
[DCTSIZE
*7] + wsptr
[DCTSIZE
*0];
3496 tmp10
= tmp0
+ tmp7
;
3497 tmp14
= tmp0
- tmp7
;
3498 tmp11
= tmp1
+ tmp6
;
3499 tmp15
= tmp1
- tmp6
;
3500 tmp12
= tmp2
+ tmp5
;
3501 tmp16
= tmp2
- tmp5
;
3502 tmp13
= tmp3
+ tmp4
;
3503 tmp17
= tmp3
- tmp4
;
3505 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*7];
3506 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*6];
3507 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*5];
3508 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*4];
3509 tmp4
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*3];
3510 tmp5
= dataptr
[DCTSIZE
*5] - wsptr
[DCTSIZE
*2];
3511 tmp6
= dataptr
[DCTSIZE
*6] - wsptr
[DCTSIZE
*1];
3512 tmp7
= dataptr
[DCTSIZE
*7] - wsptr
[DCTSIZE
*0];
3514 dataptr
[DCTSIZE
*0] = (DCTELEM
)
3515 DESCALE(tmp10
+ tmp11
+ tmp12
+ tmp13
, PASS1_BITS
+1);
3516 dataptr
[DCTSIZE
*4] = (DCTELEM
)
3517 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(1.306562965)) + /* c4[16] = c2[8] */
3518 MULTIPLY(tmp11
- tmp12
, FIX_0_541196100
), /* c12[16] = c6[8] */
3519 CONST_BITS
+PASS1_BITS
+1);
3521 tmp10
= MULTIPLY(tmp17
- tmp15
, FIX(0.275899379)) + /* c14[16] = c7[8] */
3522 MULTIPLY(tmp14
- tmp16
, FIX(1.387039845)); /* c2[16] = c1[8] */
3524 dataptr
[DCTSIZE
*2] = (DCTELEM
)
3525 DESCALE(tmp10
+ MULTIPLY(tmp15
, FIX(1.451774982)) /* c6+c14 */
3526 + MULTIPLY(tmp16
, FIX(2.172734804)), /* c2+c10 */
3527 CONST_BITS
+PASS1_BITS
+1);
3528 dataptr
[DCTSIZE
*6] = (DCTELEM
)
3529 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(0.211164243)) /* c2-c6 */
3530 - MULTIPLY(tmp17
, FIX(1.061594338)), /* c10+c14 */
3531 CONST_BITS
+PASS1_BITS
+1);
3535 tmp11
= MULTIPLY(tmp0
+ tmp1
, FIX(1.353318001)) + /* c3 */
3536 MULTIPLY(tmp6
- tmp7
, FIX(0.410524528)); /* c13 */
3537 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(1.247225013)) + /* c5 */
3538 MULTIPLY(tmp5
+ tmp7
, FIX(0.666655658)); /* c11 */
3539 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(1.093201867)) + /* c7 */
3540 MULTIPLY(tmp4
- tmp7
, FIX(0.897167586)); /* c9 */
3541 tmp14
= MULTIPLY(tmp1
+ tmp2
, FIX(0.138617169)) + /* c15 */
3542 MULTIPLY(tmp6
- tmp5
, FIX(1.407403738)); /* c1 */
3543 tmp15
= MULTIPLY(tmp1
+ tmp3
, - FIX(0.666655658)) + /* -c11 */
3544 MULTIPLY(tmp4
+ tmp6
, - FIX(1.247225013)); /* -c5 */
3545 tmp16
= MULTIPLY(tmp2
+ tmp3
, - FIX(1.353318001)) + /* -c3 */
3546 MULTIPLY(tmp5
- tmp4
, FIX(0.410524528)); /* c13 */
3547 tmp10
= tmp11
+ tmp12
+ tmp13
-
3548 MULTIPLY(tmp0
, FIX(2.286341144)) + /* c7+c5+c3-c1 */
3549 MULTIPLY(tmp7
, FIX(0.779653625)); /* c15+c13-c11+c9 */
3550 tmp11
+= tmp14
+ tmp15
+ MULTIPLY(tmp1
, FIX(0.071888074)) /* c9-c3-c15+c11 */
3551 - MULTIPLY(tmp6
, FIX(1.663905119)); /* c7+c13+c1-c5 */
3552 tmp12
+= tmp14
+ tmp16
- MULTIPLY(tmp2
, FIX(1.125726048)) /* c7+c5+c15-c3 */
3553 + MULTIPLY(tmp5
, FIX(1.227391138)); /* c9-c11+c1-c13 */
3554 tmp13
+= tmp15
+ tmp16
+ MULTIPLY(tmp3
, FIX(1.065388962)) /* c15+c3+c11-c7 */
3555 + MULTIPLY(tmp4
, FIX(2.167985692)); /* c1+c13+c5-c9 */
3557 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
+PASS1_BITS
+1);
3558 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
+PASS1_BITS
+1);
3559 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
+PASS1_BITS
+1);
3560 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
+PASS1_BITS
+1);
3562 dataptr
++; /* advance pointer to next column */
3563 wsptr
++; /* advance pointer to next column */
3569 * Perform the forward DCT on a 7x14 sample block.
3571 * 7-point FDCT in pass 1 (rows), 14-point in pass 2 (columns).
3575 jpeg_fdct_7x14 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3577 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
, tmp6
;
3578 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
, tmp16
;
3580 DCTELEM workspace
[8*6];
3587 /* Pre-zero output coefficient block. */
3588 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3590 /* Pass 1: process rows.
3591 * Note results are scaled up by sqrt(8) compared to a true DCT;
3592 * furthermore, we scale the results by 2**PASS1_BITS.
3593 * 7-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
3599 elemptr
= sample_data
[ctr
] + start_col
;
3603 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[6]);
3604 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[5]);
3605 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[4]);
3606 tmp3
= GETJSAMPLE(elemptr
[3]);
3608 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[6]);
3609 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[5]);
3610 tmp12
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[4]);
3613 /* Apply unsigned->signed conversion. */
3614 dataptr
[0] = (DCTELEM
)
3615 ((z1
+ tmp1
+ tmp3
- 7 * CENTERJSAMPLE
) << PASS1_BITS
);
3619 z1
= MULTIPLY(z1
, FIX(0.353553391)); /* (c2+c6-c4)/2 */
3620 z2
= MULTIPLY(tmp0
- tmp2
, FIX(0.920609002)); /* (c2+c4-c6)/2 */
3621 z3
= MULTIPLY(tmp1
- tmp2
, FIX(0.314692123)); /* c6 */
3622 dataptr
[2] = (DCTELEM
) DESCALE(z1
+ z2
+ z3
, CONST_BITS
-PASS1_BITS
);
3624 z2
= MULTIPLY(tmp0
- tmp1
, FIX(0.881747734)); /* c4 */
3625 dataptr
[4] = (DCTELEM
)
3626 DESCALE(z2
+ z3
- MULTIPLY(tmp1
- tmp3
, FIX(0.707106781)), /* c2+c6-c4 */
3627 CONST_BITS
-PASS1_BITS
);
3628 dataptr
[6] = (DCTELEM
) DESCALE(z1
+ z2
, CONST_BITS
-PASS1_BITS
);
3632 tmp1
= MULTIPLY(tmp10
+ tmp11
, FIX(0.935414347)); /* (c3+c1-c5)/2 */
3633 tmp2
= MULTIPLY(tmp10
- tmp11
, FIX(0.170262339)); /* (c3+c5-c1)/2 */
3636 tmp2
= MULTIPLY(tmp11
+ tmp12
, - FIX(1.378756276)); /* -c1 */
3638 tmp3
= MULTIPLY(tmp10
+ tmp12
, FIX(0.613604268)); /* c5 */
3640 tmp2
+= tmp3
+ MULTIPLY(tmp12
, FIX(1.870828693)); /* c3+c1-c5 */
3642 dataptr
[1] = (DCTELEM
) DESCALE(tmp0
, CONST_BITS
-PASS1_BITS
);
3643 dataptr
[3] = (DCTELEM
) DESCALE(tmp1
, CONST_BITS
-PASS1_BITS
);
3644 dataptr
[5] = (DCTELEM
) DESCALE(tmp2
, CONST_BITS
-PASS1_BITS
);
3648 if (ctr
!= DCTSIZE
) {
3651 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3653 dataptr
= workspace
; /* switch pointer to extended workspace */
3656 /* Pass 2: process columns.
3657 * We remove the PASS1_BITS scaling, but leave the results scaled up
3658 * by an overall factor of 8.
3659 * We must also scale the output by (8/7)*(8/14) = 32/49, which we
3660 * fold into the constant multipliers:
3661 * 14-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/28) * 32/49.
3666 for (ctr
= 0; ctr
< 7; ctr
++) {
3669 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*5];
3670 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*4];
3671 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*3];
3672 tmp13
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*2];
3673 tmp4
= dataptr
[DCTSIZE
*4] + wsptr
[DCTSIZE
*1];
3674 tmp5
= dataptr
[DCTSIZE
*5] + wsptr
[DCTSIZE
*0];
3675 tmp6
= dataptr
[DCTSIZE
*6] + dataptr
[DCTSIZE
*7];
3677 tmp10
= tmp0
+ tmp6
;
3678 tmp14
= tmp0
- tmp6
;
3679 tmp11
= tmp1
+ tmp5
;
3680 tmp15
= tmp1
- tmp5
;
3681 tmp12
= tmp2
+ tmp4
;
3682 tmp16
= tmp2
- tmp4
;
3684 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*5];
3685 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*4];
3686 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*3];
3687 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*2];
3688 tmp4
= dataptr
[DCTSIZE
*4] - wsptr
[DCTSIZE
*1];
3689 tmp5
= dataptr
[DCTSIZE
*5] - wsptr
[DCTSIZE
*0];
3690 tmp6
= dataptr
[DCTSIZE
*6] - dataptr
[DCTSIZE
*7];
3692 dataptr
[DCTSIZE
*0] = (DCTELEM
)
3693 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
+ tmp13
,
3694 FIX(0.653061224)), /* 32/49 */
3695 CONST_BITS
+PASS1_BITS
);
3697 dataptr
[DCTSIZE
*4] = (DCTELEM
)
3698 DESCALE(MULTIPLY(tmp10
- tmp13
, FIX(0.832106052)) + /* c4 */
3699 MULTIPLY(tmp11
- tmp13
, FIX(0.205513223)) - /* c12 */
3700 MULTIPLY(tmp12
- tmp13
, FIX(0.575835255)), /* c8 */
3701 CONST_BITS
+PASS1_BITS
);
3703 tmp10
= MULTIPLY(tmp14
+ tmp15
, FIX(0.722074570)); /* c6 */
3705 dataptr
[DCTSIZE
*2] = (DCTELEM
)
3706 DESCALE(tmp10
+ MULTIPLY(tmp14
, FIX(0.178337691)) /* c2-c6 */
3707 + MULTIPLY(tmp16
, FIX(0.400721155)), /* c10 */
3708 CONST_BITS
+PASS1_BITS
);
3709 dataptr
[DCTSIZE
*6] = (DCTELEM
)
3710 DESCALE(tmp10
- MULTIPLY(tmp15
, FIX(1.122795725)) /* c6+c10 */
3711 - MULTIPLY(tmp16
, FIX(0.900412262)), /* c2 */
3712 CONST_BITS
+PASS1_BITS
);
3716 tmp10
= tmp1
+ tmp2
;
3717 tmp11
= tmp5
- tmp4
;
3718 dataptr
[DCTSIZE
*7] = (DCTELEM
)
3719 DESCALE(MULTIPLY(tmp0
- tmp10
+ tmp3
- tmp11
- tmp6
,
3720 FIX(0.653061224)), /* 32/49 */
3721 CONST_BITS
+PASS1_BITS
);
3722 tmp3
= MULTIPLY(tmp3
, FIX(0.653061224)); /* 32/49 */
3723 tmp10
= MULTIPLY(tmp10
, - FIX(0.103406812)); /* -c13 */
3724 tmp11
= MULTIPLY(tmp11
, FIX(0.917760839)); /* c1 */
3725 tmp10
+= tmp11
- tmp3
;
3726 tmp11
= MULTIPLY(tmp0
+ tmp2
, FIX(0.782007410)) + /* c5 */
3727 MULTIPLY(tmp4
+ tmp6
, FIX(0.491367823)); /* c9 */
3728 dataptr
[DCTSIZE
*5] = (DCTELEM
)
3729 DESCALE(tmp10
+ tmp11
- MULTIPLY(tmp2
, FIX(1.550341076)) /* c3+c5-c13 */
3730 + MULTIPLY(tmp4
, FIX(0.731428202)), /* c1+c11-c9 */
3731 CONST_BITS
+PASS1_BITS
);
3732 tmp12
= MULTIPLY(tmp0
+ tmp1
, FIX(0.871740478)) + /* c3 */
3733 MULTIPLY(tmp5
- tmp6
, FIX(0.305035186)); /* c11 */
3734 dataptr
[DCTSIZE
*3] = (DCTELEM
)
3735 DESCALE(tmp10
+ tmp12
- MULTIPLY(tmp1
, FIX(0.276965844)) /* c3-c9-c13 */
3736 - MULTIPLY(tmp5
, FIX(2.004803435)), /* c1+c5+c11 */
3737 CONST_BITS
+PASS1_BITS
);
3738 dataptr
[DCTSIZE
*1] = (DCTELEM
)
3739 DESCALE(tmp11
+ tmp12
+ tmp3
3740 - MULTIPLY(tmp0
, FIX(0.735987049)) /* c3+c5-c1 */
3741 - MULTIPLY(tmp6
, FIX(0.082925825)), /* c9-c11-c13 */
3742 CONST_BITS
+PASS1_BITS
);
3744 dataptr
++; /* advance pointer to next column */
3745 wsptr
++; /* advance pointer to next column */
3751 * Perform the forward DCT on a 6x12 sample block.
3753 * 6-point FDCT in pass 1 (rows), 12-point in pass 2 (columns).
3757 jpeg_fdct_6x12 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3759 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
, tmp5
;
3760 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
, tmp15
;
3761 DCTELEM workspace
[8*4];
3768 /* Pre-zero output coefficient block. */
3769 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3771 /* Pass 1: process rows.
3772 * Note results are scaled up by sqrt(8) compared to a true DCT;
3773 * furthermore, we scale the results by 2**PASS1_BITS.
3774 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3780 elemptr
= sample_data
[ctr
] + start_col
;
3784 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[5]);
3785 tmp11
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[4]);
3786 tmp2
= GETJSAMPLE(elemptr
[2]) + GETJSAMPLE(elemptr
[3]);
3788 tmp10
= tmp0
+ tmp2
;
3789 tmp12
= tmp0
- tmp2
;
3791 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[5]);
3792 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[4]);
3793 tmp2
= GETJSAMPLE(elemptr
[2]) - GETJSAMPLE(elemptr
[3]);
3795 /* Apply unsigned->signed conversion. */
3796 dataptr
[0] = (DCTELEM
)
3797 ((tmp10
+ tmp11
- 6 * CENTERJSAMPLE
) << PASS1_BITS
);
3798 dataptr
[2] = (DCTELEM
)
3799 DESCALE(MULTIPLY(tmp12
, FIX(1.224744871)), /* c2 */
3800 CONST_BITS
-PASS1_BITS
);
3801 dataptr
[4] = (DCTELEM
)
3802 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(0.707106781)), /* c4 */
3803 CONST_BITS
-PASS1_BITS
);
3807 tmp10
= DESCALE(MULTIPLY(tmp0
+ tmp2
, FIX(0.366025404)), /* c5 */
3808 CONST_BITS
-PASS1_BITS
);
3810 dataptr
[1] = (DCTELEM
) (tmp10
+ ((tmp0
+ tmp1
) << PASS1_BITS
));
3811 dataptr
[3] = (DCTELEM
) ((tmp0
- tmp1
- tmp2
) << PASS1_BITS
);
3812 dataptr
[5] = (DCTELEM
) (tmp10
+ ((tmp2
- tmp1
) << PASS1_BITS
));
3816 if (ctr
!= DCTSIZE
) {
3819 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3821 dataptr
= workspace
; /* switch pointer to extended workspace */
3824 /* Pass 2: process columns.
3825 * We remove the PASS1_BITS scaling, but leave the results scaled up
3826 * by an overall factor of 8.
3827 * We must also scale the output by (8/6)*(8/12) = 8/9, which we
3828 * fold into the constant multipliers:
3829 * 12-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/24) * 8/9.
3834 for (ctr
= 0; ctr
< 6; ctr
++) {
3837 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*3];
3838 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*2];
3839 tmp2
= dataptr
[DCTSIZE
*2] + wsptr
[DCTSIZE
*1];
3840 tmp3
= dataptr
[DCTSIZE
*3] + wsptr
[DCTSIZE
*0];
3841 tmp4
= dataptr
[DCTSIZE
*4] + dataptr
[DCTSIZE
*7];
3842 tmp5
= dataptr
[DCTSIZE
*5] + dataptr
[DCTSIZE
*6];
3844 tmp10
= tmp0
+ tmp5
;
3845 tmp13
= tmp0
- tmp5
;
3846 tmp11
= tmp1
+ tmp4
;
3847 tmp14
= tmp1
- tmp4
;
3848 tmp12
= tmp2
+ tmp3
;
3849 tmp15
= tmp2
- tmp3
;
3851 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*3];
3852 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*2];
3853 tmp2
= dataptr
[DCTSIZE
*2] - wsptr
[DCTSIZE
*1];
3854 tmp3
= dataptr
[DCTSIZE
*3] - wsptr
[DCTSIZE
*0];
3855 tmp4
= dataptr
[DCTSIZE
*4] - dataptr
[DCTSIZE
*7];
3856 tmp5
= dataptr
[DCTSIZE
*5] - dataptr
[DCTSIZE
*6];
3858 dataptr
[DCTSIZE
*0] = (DCTELEM
)
3859 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
, FIX(0.888888889)), /* 8/9 */
3860 CONST_BITS
+PASS1_BITS
);
3861 dataptr
[DCTSIZE
*6] = (DCTELEM
)
3862 DESCALE(MULTIPLY(tmp13
- tmp14
- tmp15
, FIX(0.888888889)), /* 8/9 */
3863 CONST_BITS
+PASS1_BITS
);
3864 dataptr
[DCTSIZE
*4] = (DCTELEM
)
3865 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.088662108)), /* c4 */
3866 CONST_BITS
+PASS1_BITS
);
3867 dataptr
[DCTSIZE
*2] = (DCTELEM
)
3868 DESCALE(MULTIPLY(tmp14
- tmp15
, FIX(0.888888889)) + /* 8/9 */
3869 MULTIPLY(tmp13
+ tmp15
, FIX(1.214244803)), /* c2 */
3870 CONST_BITS
+PASS1_BITS
);
3874 tmp10
= MULTIPLY(tmp1
+ tmp4
, FIX(0.481063200)); /* c9 */
3875 tmp14
= tmp10
+ MULTIPLY(tmp1
, FIX(0.680326102)); /* c3-c9 */
3876 tmp15
= tmp10
- MULTIPLY(tmp4
, FIX(1.642452502)); /* c3+c9 */
3877 tmp12
= MULTIPLY(tmp0
+ tmp2
, FIX(0.997307603)); /* c5 */
3878 tmp13
= MULTIPLY(tmp0
+ tmp3
, FIX(0.765261039)); /* c7 */
3879 tmp10
= tmp12
+ tmp13
+ tmp14
- MULTIPLY(tmp0
, FIX(0.516244403)) /* c5+c7-c1 */
3880 + MULTIPLY(tmp5
, FIX(0.164081699)); /* c11 */
3881 tmp11
= MULTIPLY(tmp2
+ tmp3
, - FIX(0.164081699)); /* -c11 */
3882 tmp12
+= tmp11
- tmp15
- MULTIPLY(tmp2
, FIX(2.079550144)) /* c1+c5-c11 */
3883 + MULTIPLY(tmp5
, FIX(0.765261039)); /* c7 */
3884 tmp13
+= tmp11
- tmp14
+ MULTIPLY(tmp3
, FIX(0.645144899)) /* c1+c11-c7 */
3885 - MULTIPLY(tmp5
, FIX(0.997307603)); /* c5 */
3886 tmp11
= tmp15
+ MULTIPLY(tmp0
- tmp3
, FIX(1.161389302)) /* c3 */
3887 - MULTIPLY(tmp2
+ tmp5
, FIX(0.481063200)); /* c9 */
3889 dataptr
[DCTSIZE
*1] = (DCTELEM
) DESCALE(tmp10
, CONST_BITS
+PASS1_BITS
);
3890 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp11
, CONST_BITS
+PASS1_BITS
);
3891 dataptr
[DCTSIZE
*5] = (DCTELEM
) DESCALE(tmp12
, CONST_BITS
+PASS1_BITS
);
3892 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp13
, CONST_BITS
+PASS1_BITS
);
3894 dataptr
++; /* advance pointer to next column */
3895 wsptr
++; /* advance pointer to next column */
3901 * Perform the forward DCT on a 5x10 sample block.
3903 * 5-point FDCT in pass 1 (rows), 10-point in pass 2 (columns).
3907 jpeg_fdct_5x10 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
3909 INT32 tmp0
, tmp1
, tmp2
, tmp3
, tmp4
;
3910 INT32 tmp10
, tmp11
, tmp12
, tmp13
, tmp14
;
3911 DCTELEM workspace
[8*2];
3918 /* Pre-zero output coefficient block. */
3919 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
3921 /* Pass 1: process rows.
3922 * Note results are scaled up by sqrt(8) compared to a true DCT;
3923 * furthermore, we scale the results by 2**PASS1_BITS.
3924 * 5-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
3930 elemptr
= sample_data
[ctr
] + start_col
;
3934 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[4]);
3935 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[3]);
3936 tmp2
= GETJSAMPLE(elemptr
[2]);
3938 tmp10
= tmp0
+ tmp1
;
3939 tmp11
= tmp0
- tmp1
;
3941 tmp0
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[4]);
3942 tmp1
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[3]);
3944 /* Apply unsigned->signed conversion. */
3945 dataptr
[0] = (DCTELEM
)
3946 ((tmp10
+ tmp2
- 5 * CENTERJSAMPLE
) << PASS1_BITS
);
3947 tmp11
= MULTIPLY(tmp11
, FIX(0.790569415)); /* (c2+c4)/2 */
3949 tmp10
= MULTIPLY(tmp10
, FIX(0.353553391)); /* (c2-c4)/2 */
3950 dataptr
[2] = (DCTELEM
) DESCALE(tmp11
+ tmp10
, CONST_BITS
-PASS1_BITS
);
3951 dataptr
[4] = (DCTELEM
) DESCALE(tmp11
- tmp10
, CONST_BITS
-PASS1_BITS
);
3955 tmp10
= MULTIPLY(tmp0
+ tmp1
, FIX(0.831253876)); /* c3 */
3957 dataptr
[1] = (DCTELEM
)
3958 DESCALE(tmp10
+ MULTIPLY(tmp0
, FIX(0.513743148)), /* c1-c3 */
3959 CONST_BITS
-PASS1_BITS
);
3960 dataptr
[3] = (DCTELEM
)
3961 DESCALE(tmp10
- MULTIPLY(tmp1
, FIX(2.176250899)), /* c1+c3 */
3962 CONST_BITS
-PASS1_BITS
);
3966 if (ctr
!= DCTSIZE
) {
3969 dataptr
+= DCTSIZE
; /* advance pointer to next row */
3971 dataptr
= workspace
; /* switch pointer to extended workspace */
3974 /* Pass 2: process columns.
3975 * We remove the PASS1_BITS scaling, but leave the results scaled up
3976 * by an overall factor of 8.
3977 * We must also scale the output by (8/5)*(8/10) = 32/25, which we
3978 * fold into the constant multipliers:
3979 * 10-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/20) * 32/25.
3984 for (ctr
= 0; ctr
< 5; ctr
++) {
3987 tmp0
= dataptr
[DCTSIZE
*0] + wsptr
[DCTSIZE
*1];
3988 tmp1
= dataptr
[DCTSIZE
*1] + wsptr
[DCTSIZE
*0];
3989 tmp12
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*7];
3990 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*6];
3991 tmp4
= dataptr
[DCTSIZE
*4] + dataptr
[DCTSIZE
*5];
3993 tmp10
= tmp0
+ tmp4
;
3994 tmp13
= tmp0
- tmp4
;
3995 tmp11
= tmp1
+ tmp3
;
3996 tmp14
= tmp1
- tmp3
;
3998 tmp0
= dataptr
[DCTSIZE
*0] - wsptr
[DCTSIZE
*1];
3999 tmp1
= dataptr
[DCTSIZE
*1] - wsptr
[DCTSIZE
*0];
4000 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*7];
4001 tmp3
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*6];
4002 tmp4
= dataptr
[DCTSIZE
*4] - dataptr
[DCTSIZE
*5];
4004 dataptr
[DCTSIZE
*0] = (DCTELEM
)
4005 DESCALE(MULTIPLY(tmp10
+ tmp11
+ tmp12
, FIX(1.28)), /* 32/25 */
4006 CONST_BITS
+PASS1_BITS
);
4008 dataptr
[DCTSIZE
*4] = (DCTELEM
)
4009 DESCALE(MULTIPLY(tmp10
- tmp12
, FIX(1.464477191)) - /* c4 */
4010 MULTIPLY(tmp11
- tmp12
, FIX(0.559380511)), /* c8 */
4011 CONST_BITS
+PASS1_BITS
);
4012 tmp10
= MULTIPLY(tmp13
+ tmp14
, FIX(1.064004961)); /* c6 */
4013 dataptr
[DCTSIZE
*2] = (DCTELEM
)
4014 DESCALE(tmp10
+ MULTIPLY(tmp13
, FIX(0.657591230)), /* c2-c6 */
4015 CONST_BITS
+PASS1_BITS
);
4016 dataptr
[DCTSIZE
*6] = (DCTELEM
)
4017 DESCALE(tmp10
- MULTIPLY(tmp14
, FIX(2.785601151)), /* c2+c6 */
4018 CONST_BITS
+PASS1_BITS
);
4022 tmp10
= tmp0
+ tmp4
;
4023 tmp11
= tmp1
- tmp3
;
4024 dataptr
[DCTSIZE
*5] = (DCTELEM
)
4025 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp2
, FIX(1.28)), /* 32/25 */
4026 CONST_BITS
+PASS1_BITS
);
4027 tmp2
= MULTIPLY(tmp2
, FIX(1.28)); /* 32/25 */
4028 dataptr
[DCTSIZE
*1] = (DCTELEM
)
4029 DESCALE(MULTIPLY(tmp0
, FIX(1.787906876)) + /* c1 */
4030 MULTIPLY(tmp1
, FIX(1.612894094)) + tmp2
+ /* c3 */
4031 MULTIPLY(tmp3
, FIX(0.821810588)) + /* c7 */
4032 MULTIPLY(tmp4
, FIX(0.283176630)), /* c9 */
4033 CONST_BITS
+PASS1_BITS
);
4034 tmp12
= MULTIPLY(tmp0
- tmp4
, FIX(1.217352341)) - /* (c3+c7)/2 */
4035 MULTIPLY(tmp1
+ tmp3
, FIX(0.752365123)); /* (c1-c9)/2 */
4036 tmp13
= MULTIPLY(tmp10
+ tmp11
, FIX(0.395541753)) + /* (c3-c7)/2 */
4037 MULTIPLY(tmp11
, FIX(0.64)) - tmp2
; /* 16/25 */
4038 dataptr
[DCTSIZE
*3] = (DCTELEM
) DESCALE(tmp12
+ tmp13
, CONST_BITS
+PASS1_BITS
);
4039 dataptr
[DCTSIZE
*7] = (DCTELEM
) DESCALE(tmp12
- tmp13
, CONST_BITS
+PASS1_BITS
);
4041 dataptr
++; /* advance pointer to next column */
4042 wsptr
++; /* advance pointer to next column */
4048 * Perform the forward DCT on a 4x8 sample block.
4050 * 4-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
4054 jpeg_fdct_4x8 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
4056 INT32 tmp0
, tmp1
, tmp2
, tmp3
;
4057 INT32 tmp10
, tmp11
, tmp12
, tmp13
;
4064 /* Pre-zero output coefficient block. */
4065 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
4067 /* Pass 1: process rows.
4068 * Note results are scaled up by sqrt(8) compared to a true DCT;
4069 * furthermore, we scale the results by 2**PASS1_BITS.
4070 * We must also scale the output by 8/4 = 2, which we add here.
4071 * 4-point FDCT kernel,
4072 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
4076 for (ctr
= 0; ctr
< DCTSIZE
; ctr
++) {
4077 elemptr
= sample_data
[ctr
] + start_col
;
4081 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[3]);
4082 tmp1
= GETJSAMPLE(elemptr
[1]) + GETJSAMPLE(elemptr
[2]);
4084 tmp10
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[3]);
4085 tmp11
= GETJSAMPLE(elemptr
[1]) - GETJSAMPLE(elemptr
[2]);
4087 /* Apply unsigned->signed conversion. */
4088 dataptr
[0] = (DCTELEM
)
4089 ((tmp0
+ tmp1
- 4 * CENTERJSAMPLE
) << (PASS1_BITS
+1));
4090 dataptr
[2] = (DCTELEM
) ((tmp0
- tmp1
) << (PASS1_BITS
+1));
4094 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
4095 /* Add fudge factor here for final descale. */
4096 tmp0
+= ONE
<< (CONST_BITS
-PASS1_BITS
-2);
4098 dataptr
[1] = (DCTELEM
)
4099 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
4100 CONST_BITS
-PASS1_BITS
-1);
4101 dataptr
[3] = (DCTELEM
)
4102 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
4103 CONST_BITS
-PASS1_BITS
-1);
4105 dataptr
+= DCTSIZE
; /* advance pointer to next row */
4108 /* Pass 2: process columns.
4109 * We remove the PASS1_BITS scaling, but leave the results scaled up
4110 * by an overall factor of 8.
4111 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4115 for (ctr
= 0; ctr
< 4; ctr
++) {
4116 /* Even part per LL&M figure 1 --- note that published figure is faulty;
4117 * rotator "c1" should be "c6".
4120 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*7];
4121 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*6];
4122 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*5];
4123 tmp3
= dataptr
[DCTSIZE
*3] + dataptr
[DCTSIZE
*4];
4125 /* Add fudge factor here for final descale. */
4126 tmp10
= tmp0
+ tmp3
+ (ONE
<< (PASS1_BITS
-1));
4127 tmp12
= tmp0
- tmp3
;
4128 tmp11
= tmp1
+ tmp2
;
4129 tmp13
= tmp1
- tmp2
;
4131 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*7];
4132 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*6];
4133 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*5];
4134 tmp3
= dataptr
[DCTSIZE
*3] - dataptr
[DCTSIZE
*4];
4136 dataptr
[DCTSIZE
*0] = (DCTELEM
) RIGHT_SHIFT(tmp10
+ tmp11
, PASS1_BITS
);
4137 dataptr
[DCTSIZE
*4] = (DCTELEM
) RIGHT_SHIFT(tmp10
- tmp11
, PASS1_BITS
);
4139 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_0_541196100
); /* c6 */
4140 /* Add fudge factor here for final descale. */
4141 z1
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
4143 dataptr
[DCTSIZE
*2] = (DCTELEM
)
4144 RIGHT_SHIFT(z1
+ MULTIPLY(tmp12
, FIX_0_765366865
), /* c2-c6 */
4145 CONST_BITS
+PASS1_BITS
);
4146 dataptr
[DCTSIZE
*6] = (DCTELEM
)
4147 RIGHT_SHIFT(z1
- MULTIPLY(tmp13
, FIX_1_847759065
), /* c2+c6 */
4148 CONST_BITS
+PASS1_BITS
);
4150 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
4151 * i0..i3 in the paper are tmp0..tmp3 here.
4154 tmp12
= tmp0
+ tmp2
;
4155 tmp13
= tmp1
+ tmp3
;
4157 z1
= MULTIPLY(tmp12
+ tmp13
, FIX_1_175875602
); /* c3 */
4158 /* Add fudge factor here for final descale. */
4159 z1
+= ONE
<< (CONST_BITS
+PASS1_BITS
-1);
4161 tmp12
= MULTIPLY(tmp12
, - FIX_0_390180644
); /* -c3+c5 */
4162 tmp13
= MULTIPLY(tmp13
, - FIX_1_961570560
); /* -c3-c5 */
4166 z1
= MULTIPLY(tmp0
+ tmp3
, - FIX_0_899976223
); /* -c3+c7 */
4167 tmp0
= MULTIPLY(tmp0
, FIX_1_501321110
); /* c1+c3-c5-c7 */
4168 tmp3
= MULTIPLY(tmp3
, FIX_0_298631336
); /* -c1+c3+c5-c7 */
4172 z1
= MULTIPLY(tmp1
+ tmp2
, - FIX_2_562915447
); /* -c1-c3 */
4173 tmp1
= MULTIPLY(tmp1
, FIX_3_072711026
); /* c1+c3+c5-c7 */
4174 tmp2
= MULTIPLY(tmp2
, FIX_2_053119869
); /* c1+c3-c5+c7 */
4178 dataptr
[DCTSIZE
*1] = (DCTELEM
) RIGHT_SHIFT(tmp0
, CONST_BITS
+PASS1_BITS
);
4179 dataptr
[DCTSIZE
*3] = (DCTELEM
) RIGHT_SHIFT(tmp1
, CONST_BITS
+PASS1_BITS
);
4180 dataptr
[DCTSIZE
*5] = (DCTELEM
) RIGHT_SHIFT(tmp2
, CONST_BITS
+PASS1_BITS
);
4181 dataptr
[DCTSIZE
*7] = (DCTELEM
) RIGHT_SHIFT(tmp3
, CONST_BITS
+PASS1_BITS
);
4183 dataptr
++; /* advance pointer to next column */
4189 * Perform the forward DCT on a 3x6 sample block.
4191 * 3-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
4195 jpeg_fdct_3x6 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
4197 INT32 tmp0
, tmp1
, tmp2
;
4198 INT32 tmp10
, tmp11
, tmp12
;
4204 /* Pre-zero output coefficient block. */
4205 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
4207 /* Pass 1: process rows.
4208 * Note results are scaled up by sqrt(8) compared to a true DCT;
4209 * furthermore, we scale the results by 2**PASS1_BITS.
4210 * We scale the results further by 2 as part of output adaption
4211 * scaling for different DCT size.
4212 * 3-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
4216 for (ctr
= 0; ctr
< 6; ctr
++) {
4217 elemptr
= sample_data
[ctr
] + start_col
;
4221 tmp0
= GETJSAMPLE(elemptr
[0]) + GETJSAMPLE(elemptr
[2]);
4222 tmp1
= GETJSAMPLE(elemptr
[1]);
4224 tmp2
= GETJSAMPLE(elemptr
[0]) - GETJSAMPLE(elemptr
[2]);
4226 /* Apply unsigned->signed conversion. */
4227 dataptr
[0] = (DCTELEM
)
4228 ((tmp0
+ tmp1
- 3 * CENTERJSAMPLE
) << (PASS1_BITS
+1));
4229 dataptr
[2] = (DCTELEM
)
4230 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp1
, FIX(0.707106781)), /* c2 */
4231 CONST_BITS
-PASS1_BITS
-1);
4235 dataptr
[1] = (DCTELEM
)
4236 DESCALE(MULTIPLY(tmp2
, FIX(1.224744871)), /* c1 */
4237 CONST_BITS
-PASS1_BITS
-1);
4239 dataptr
+= DCTSIZE
; /* advance pointer to next row */
4242 /* Pass 2: process columns.
4243 * We remove the PASS1_BITS scaling, but leave the results scaled up
4244 * by an overall factor of 8.
4245 * We must also scale the output by (8/6)*(8/3) = 32/9, which we partially
4246 * fold into the constant multipliers (other part was done in pass 1):
4247 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12) * 16/9.
4251 for (ctr
= 0; ctr
< 3; ctr
++) {
4254 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*5];
4255 tmp11
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*4];
4256 tmp2
= dataptr
[DCTSIZE
*2] + dataptr
[DCTSIZE
*3];
4258 tmp10
= tmp0
+ tmp2
;
4259 tmp12
= tmp0
- tmp2
;
4261 tmp0
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*5];
4262 tmp1
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*4];
4263 tmp2
= dataptr
[DCTSIZE
*2] - dataptr
[DCTSIZE
*3];
4265 dataptr
[DCTSIZE
*0] = (DCTELEM
)
4266 DESCALE(MULTIPLY(tmp10
+ tmp11
, FIX(1.777777778)), /* 16/9 */
4267 CONST_BITS
+PASS1_BITS
);
4268 dataptr
[DCTSIZE
*2] = (DCTELEM
)
4269 DESCALE(MULTIPLY(tmp12
, FIX(2.177324216)), /* c2 */
4270 CONST_BITS
+PASS1_BITS
);
4271 dataptr
[DCTSIZE
*4] = (DCTELEM
)
4272 DESCALE(MULTIPLY(tmp10
- tmp11
- tmp11
, FIX(1.257078722)), /* c4 */
4273 CONST_BITS
+PASS1_BITS
);
4277 tmp10
= MULTIPLY(tmp0
+ tmp2
, FIX(0.650711829)); /* c5 */
4279 dataptr
[DCTSIZE
*1] = (DCTELEM
)
4280 DESCALE(tmp10
+ MULTIPLY(tmp0
+ tmp1
, FIX(1.777777778)), /* 16/9 */
4281 CONST_BITS
+PASS1_BITS
);
4282 dataptr
[DCTSIZE
*3] = (DCTELEM
)
4283 DESCALE(MULTIPLY(tmp0
- tmp1
- tmp2
, FIX(1.777777778)), /* 16/9 */
4284 CONST_BITS
+PASS1_BITS
);
4285 dataptr
[DCTSIZE
*5] = (DCTELEM
)
4286 DESCALE(tmp10
+ MULTIPLY(tmp2
- tmp1
, FIX(1.777777778)), /* 16/9 */
4287 CONST_BITS
+PASS1_BITS
);
4289 dataptr
++; /* advance pointer to next column */
4295 * Perform the forward DCT on a 2x4 sample block.
4297 * 2-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
4301 jpeg_fdct_2x4 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
4310 /* Pre-zero output coefficient block. */
4311 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
4313 /* Pass 1: process rows.
4314 * Note results are scaled up by sqrt(8) compared to a true DCT.
4315 * We must also scale the output by (8/2)*(8/4) = 2**3, which we add here.
4319 for (ctr
= 0; ctr
< 4; ctr
++) {
4320 elemptr
= sample_data
[ctr
] + start_col
;
4324 tmp0
= GETJSAMPLE(elemptr
[0]);
4325 tmp1
= GETJSAMPLE(elemptr
[1]);
4327 /* Apply unsigned->signed conversion. */
4328 dataptr
[0] = (DCTELEM
) ((tmp0
+ tmp1
- 2 * CENTERJSAMPLE
) << 3);
4332 dataptr
[1] = (DCTELEM
) ((tmp0
- tmp1
) << 3);
4334 dataptr
+= DCTSIZE
; /* advance pointer to next row */
4337 /* Pass 2: process columns.
4338 * We leave the results scaled up by an overall factor of 8.
4339 * 4-point FDCT kernel,
4340 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
4344 for (ctr
= 0; ctr
< 2; ctr
++) {
4347 tmp0
= dataptr
[DCTSIZE
*0] + dataptr
[DCTSIZE
*3];
4348 tmp1
= dataptr
[DCTSIZE
*1] + dataptr
[DCTSIZE
*2];
4350 tmp10
= dataptr
[DCTSIZE
*0] - dataptr
[DCTSIZE
*3];
4351 tmp11
= dataptr
[DCTSIZE
*1] - dataptr
[DCTSIZE
*2];
4353 dataptr
[DCTSIZE
*0] = (DCTELEM
) (tmp0
+ tmp1
);
4354 dataptr
[DCTSIZE
*2] = (DCTELEM
) (tmp0
- tmp1
);
4358 tmp0
= MULTIPLY(tmp10
+ tmp11
, FIX_0_541196100
); /* c6 */
4359 /* Add fudge factor here for final descale. */
4360 tmp0
+= ONE
<< (CONST_BITS
-1);
4362 dataptr
[DCTSIZE
*1] = (DCTELEM
)
4363 RIGHT_SHIFT(tmp0
+ MULTIPLY(tmp10
, FIX_0_765366865
), /* c2-c6 */
4365 dataptr
[DCTSIZE
*3] = (DCTELEM
)
4366 RIGHT_SHIFT(tmp0
- MULTIPLY(tmp11
, FIX_1_847759065
), /* c2+c6 */
4369 dataptr
++; /* advance pointer to next column */
4375 * Perform the forward DCT on a 1x2 sample block.
4377 * 1-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
4381 jpeg_fdct_1x2 (DCTELEM
* data
, JSAMPARRAY sample_data
, JDIMENSION start_col
)
4385 /* Pre-zero output coefficient block. */
4386 MEMZERO(data
, SIZEOF(DCTELEM
) * DCTSIZE2
);
4388 /* Pass 1: empty. */
4390 /* Pass 2: process columns.
4391 * We leave the results scaled up by an overall factor of 8.
4392 * We must also scale the output by (8/1)*(8/2) = 2**5.
4397 tmp0
= GETJSAMPLE(sample_data
[0][start_col
]);
4398 tmp1
= GETJSAMPLE(sample_data
[1][start_col
]);
4400 /* Apply unsigned->signed conversion. */
4401 data
[DCTSIZE
*0] = (tmp0
+ tmp1
- 2 * CENTERJSAMPLE
) << 5;
4405 data
[DCTSIZE
*1] = (tmp0
- tmp1
) << 5;
4408 #endif /* DCT_SCALING_SUPPORTED */
4409 #endif /* DCT_ISLOW_SUPPORTED */