?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
imm32/tests: Don't expect IME window if the parent is message-only window descendant.
[wine.git] / libs / jpeg / jfdctint.c
blob05df4750bbc352d762a81bf772daaa4cabc72b66
1 /*
2 * jfdctint.c
3 *
4 * Copyright (C) 1991-1996, Thomas G. Lane.
5 * Modification developed 2003-2018 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.
8 *
9 * This file contains a slow-but-accurate integer implementation of the
10 * forward DCT (Discrete Cosine Transform).
11 *
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.
15 *
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.
25 *
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.
30 *
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.
34 *
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
38 * shifting.
39 *
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.
42 */
43
44 #define JPEG_INTERNALS
45 #include "jinclude.h"
46 #include "jpeglib.h"
47 #include "jdct.h" /* Private declarations for DCT subsystem */
48
49 #ifdef DCT_ISLOW_SUPPORTED
50
51
52 /*
53 * This module is specialized to the case DCTSIZE = 8.
54 */
55
56 #if DCTSIZE != 8
57 Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
58 #endif
59
60
61 /*
62 * The poop on this scaling stuff is as follows:
63 *
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.
72 *
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.
83 *
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.)
89 *
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.
93 */
94
95 #if BITS_IN_JSAMPLE == 8
96 #define CONST_BITS 13
97 #define PASS1_BITS 2
98 #else
99 #define CONST_BITS 13
100 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */
101 #endif
102
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...)
108 */
109
110 #if CONST_BITS == 13
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) */
123 #else
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)
136 #endif
137
138
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.
144 */
145
146 #if BITS_IN_JSAMPLE == 8
147 #define MULTIPLY(var,const) MULTIPLY16C16(var,const)
148 #else
149 #define MULTIPLY(var,const) ((var) * (const))
150 #endif
151
152
153 /*
154 * Perform the forward DCT on one block of samples.
155 */
156
157 GLOBAL(void)
158 jpeg_fdct_islow (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
159 {
160 INT32 tmp0, tmp1, tmp2, tmp3;
161 INT32 tmp10, tmp11, tmp12, tmp13;
162 INT32 z1;
163 DCTELEM *dataptr;
164 JSAMPROW elemptr;
165 int ctr;
166 SHIFT_TEMPS
167
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).
172 */
173
174 dataptr = data;
175 for (ctr = 0; ctr < DCTSIZE; ctr++) {
176 elemptr = sample_data[ctr] + start_col;
177
178 /* Even part per LL&M figure 1 --- note that published figure is faulty;
179 * rotator "c1" should be "c6".
180 */
181
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]);
186
187 tmp10 = tmp0 + tmp3;
188 tmp12 = tmp0 - tmp3;
189 tmp11 = tmp1 + tmp2;
190 tmp13 = tmp1 - tmp2;
191
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]);
196
197 /* Apply unsigned->signed conversion. */
198 dataptr[0] = (DCTELEM) ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << PASS1_BITS);
199 dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
200
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);
204
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);
211
212 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
213 * i0..i3 in the paper are tmp0..tmp3 here.
214 */
215
216 tmp12 = tmp0 + tmp2;
217 tmp13 = tmp1 + tmp3;
218
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);
222
223 tmp12 = MULTIPLY(tmp12, - FIX_0_390180644); /* -c3+c5 */
224 tmp13 = MULTIPLY(tmp13, - FIX_1_961570560); /* -c3-c5 */
225 tmp12 += z1;
226 tmp13 += z1;
227
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 */
231 tmp0 += z1 + tmp12;
232 tmp3 += z1 + tmp13;
233
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 */
237 tmp1 += z1 + tmp13;
238 tmp2 += z1 + tmp12;
239
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);
244
245 dataptr += DCTSIZE; /* advance pointer to next row */
246 }
247
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).
252 */
253
254 dataptr = data;
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".
258 */
259
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];
264
265 /* Add fudge factor here for final descale. */
266 tmp10 = tmp0 + tmp3 + (ONE << (PASS1_BITS-1));
267 tmp12 = tmp0 - tmp3;
268 tmp11 = tmp1 + tmp2;
269 tmp13 = tmp1 - tmp2;
270
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];
275
276 dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp10 + tmp11, PASS1_BITS);
277 dataptr[DCTSIZE*4] = (DCTELEM) RIGHT_SHIFT(tmp10 - tmp11, PASS1_BITS);
278
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);
282
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);
289
290 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
291 * i0..i3 in the paper are tmp0..tmp3 here.
292 */
293
294 tmp12 = tmp0 + tmp2;
295 tmp13 = tmp1 + tmp3;
296
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);
300
301 tmp12 = MULTIPLY(tmp12, - FIX_0_390180644); /* -c3+c5 */
302 tmp13 = MULTIPLY(tmp13, - FIX_1_961570560); /* -c3-c5 */
303 tmp12 += z1;
304 tmp13 += z1;
305
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 */
309 tmp0 += z1 + tmp12;
310 tmp3 += z1 + tmp13;
311
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 */
315 tmp1 += z1 + tmp13;
316 tmp2 += z1 + tmp12;
317
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);
322
323 dataptr++; /* advance pointer to next column */
324 }
325 }
326
327 #ifdef DCT_SCALING_SUPPORTED
328
329
330 /*
331 * Perform the forward DCT on a 7x7 sample block.
332 */
333
334 GLOBAL(void)
335 jpeg_fdct_7x7 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
336 {
337 INT32 tmp0, tmp1, tmp2, tmp3;
338 INT32 tmp10, tmp11, tmp12;
339 INT32 z1, z2, z3;
340 DCTELEM *dataptr;
341 JSAMPROW elemptr;
342 int ctr;
343 SHIFT_TEMPS
344
345 /* Pre-zero output coefficient block. */
346 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
347
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).
352 */
353
354 dataptr = data;
355 for (ctr = 0; ctr < 7; ctr++) {
356 elemptr = sample_data[ctr] + start_col;
357
358 /* Even part */
359
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]);
364
365 tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[6]);
366 tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[5]);
367 tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[4]);
368
369 z1 = tmp0 + tmp2;
370 /* Apply unsigned->signed conversion. */
371 dataptr[0] = (DCTELEM)
372 ((z1 + tmp1 + tmp3 - 7 * CENTERJSAMPLE) << PASS1_BITS);
373 tmp3 += tmp3;
374 z1 -= tmp3;
375 z1 -= tmp3;
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);
380 z1 -= z2;
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);
386
387 /* Odd part */
388
389 tmp1 = MULTIPLY(tmp10 + tmp11, FIX(0.935414347)); /* (c3+c1-c5)/2 */
390 tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.170262339)); /* (c3+c5-c1)/2 */
391 tmp0 = tmp1 - tmp2;
392 tmp1 += tmp2;
393 tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.378756276)); /* -c1 */
394 tmp1 += tmp2;
395 tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.613604268)); /* c5 */
396 tmp0 += tmp3;
397 tmp2 += tmp3 + MULTIPLY(tmp12, FIX(1.870828693)); /* c3+c1-c5 */
398
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);
402
403 dataptr += DCTSIZE; /* advance pointer to next row */
404 }
405
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.
412 */
413
414 dataptr = data;
415 for (ctr = 0; ctr < 7; ctr++) {
416 /* Even part */
417
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];
422
423 tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*6];
424 tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*5];
425 tmp12 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*4];
426
427 z1 = tmp0 + tmp2;
428 dataptr[DCTSIZE*0] = (DCTELEM)
429 DESCALE(MULTIPLY(z1 + tmp1 + tmp3, FIX(1.306122449)), /* 64/49 */
430 CONST_BITS+PASS1_BITS);
431 tmp3 += tmp3;
432 z1 -= tmp3;
433 z1 -= tmp3;
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);
438 z1 -= z2;
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);
444
445 /* Odd part */
446
447 tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.221765677)); /* (c3+c1-c5)/2 */
448 tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.222383464)); /* (c3+c5-c1)/2 */
449 tmp0 = tmp1 - tmp2;
450 tmp1 += tmp2;
451 tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.800824523)); /* -c1 */
452 tmp1 += tmp2;
453 tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.801442310)); /* c5 */
454 tmp0 += tmp3;
455 tmp2 += tmp3 + MULTIPLY(tmp12, FIX(2.443531355)); /* c3+c1-c5 */
456
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);
460
461 dataptr++; /* advance pointer to next column */
462 }
463 }
464
465
466 /*
467 * Perform the forward DCT on a 6x6 sample block.
468 */
469
470 GLOBAL(void)
471 jpeg_fdct_6x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
472 {
473 INT32 tmp0, tmp1, tmp2;
474 INT32 tmp10, tmp11, tmp12;
475 DCTELEM *dataptr;
476 JSAMPROW elemptr;
477 int ctr;
478 SHIFT_TEMPS
479
480 /* Pre-zero output coefficient block. */
481 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
482
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).
487 */
488
489 dataptr = data;
490 for (ctr = 0; ctr < 6; ctr++) {
491 elemptr = sample_data[ctr] + start_col;
492
493 /* Even part */
494
495 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
496 tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
497 tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
498
499 tmp10 = tmp0 + tmp2;
500 tmp12 = tmp0 - tmp2;
501
502 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
503 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
504 tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
505
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);
515
516 /* Odd part */
517
518 tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)), /* c5 */
519 CONST_BITS-PASS1_BITS);
520
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));
524
525 dataptr += DCTSIZE; /* advance pointer to next row */
526 }
527
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.
534 */
535
536 dataptr = data;
537 for (ctr = 0; ctr < 6; ctr++) {
538 /* Even part */
539
540 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
541 tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
542 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
543
544 tmp10 = tmp0 + tmp2;
545 tmp12 = tmp0 - tmp2;
546
547 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
548 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
549 tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
550
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);
560
561 /* Odd part */
562
563 tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829)); /* c5 */
564
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);
574
575 dataptr++; /* advance pointer to next column */
576 }
577 }
578
579
580 /*
581 * Perform the forward DCT on a 5x5 sample block.
582 */
583
584 GLOBAL(void)
585 jpeg_fdct_5x5 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
586 {
587 INT32 tmp0, tmp1, tmp2;
588 INT32 tmp10, tmp11;
589 DCTELEM *dataptr;
590 JSAMPROW elemptr;
591 int ctr;
592 SHIFT_TEMPS
593
594 /* Pre-zero output coefficient block. */
595 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
596
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).
603 */
604
605 dataptr = data;
606 for (ctr = 0; ctr < 5; ctr++) {
607 elemptr = sample_data[ctr] + start_col;
608
609 /* Even part */
610
611 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[4]);
612 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[3]);
613 tmp2 = GETJSAMPLE(elemptr[2]);
614
615 tmp10 = tmp0 + tmp1;
616 tmp11 = tmp0 - tmp1;
617
618 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[4]);
619 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[3]);
620
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 */
625 tmp10 -= tmp2 << 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);
629
630 /* Odd part */
631
632 tmp10 = MULTIPLY(tmp0 + tmp1, FIX(0.831253876)); /* c3 */
633
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);
640
641 dataptr += DCTSIZE; /* advance pointer to next row */
642 }
643
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.
650 */
651
652 dataptr = data;
653 for (ctr = 0; ctr < 5; ctr++) {
654 /* Even part */
655
656 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*4];
657 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*3];
658 tmp2 = dataptr[DCTSIZE*2];
659
660 tmp10 = tmp0 + tmp1;
661 tmp11 = tmp0 - tmp1;
662
663 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*4];
664 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*3];
665
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 */
670 tmp10 -= tmp2 << 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);
674
675 /* Odd part */
676
677 tmp10 = MULTIPLY(tmp0 + tmp1, FIX(1.064004961)); /* c3 */
678
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);
685
686 dataptr++; /* advance pointer to next column */
687 }
688 }
689
690
691 /*
692 * Perform the forward DCT on a 4x4 sample block.
693 */
694
695 GLOBAL(void)
696 jpeg_fdct_4x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
697 {
698 INT32 tmp0, tmp1;
699 INT32 tmp10, tmp11;
700 DCTELEM *dataptr;
701 JSAMPROW elemptr;
702 int ctr;
703 SHIFT_TEMPS
704
705 /* Pre-zero output coefficient block. */
706 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
707
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].
713 */
714
715 dataptr = data;
716 for (ctr = 0; ctr < 4; ctr++) {
717 elemptr = sample_data[ctr] + start_col;
718
719 /* Even part */
720
721 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
722 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
723
724 tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
725 tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
726
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));
731
732 /* Odd part */
733
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);
737
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);
744
745 dataptr += DCTSIZE; /* advance pointer to next row */
746 }
747
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].
752 */
753
754 dataptr = data;
755 for (ctr = 0; ctr < 4; ctr++) {
756 /* Even part */
757
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];
761
762 tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
763 tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
764
765 dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);
766 dataptr[DCTSIZE*2] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
767
768 /* Odd part */
769
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);
773
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);
780
781 dataptr++; /* advance pointer to next column */
782 }
783 }
784
785
786 /*
787 * Perform the forward DCT on a 3x3 sample block.
788 */
789
790 GLOBAL(void)
791 jpeg_fdct_3x3 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
792 {
793 INT32 tmp0, tmp1, tmp2;
794 DCTELEM *dataptr;
795 JSAMPROW elemptr;
796 int ctr;
797 SHIFT_TEMPS
798
799 /* Pre-zero output coefficient block. */
800 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
801
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).
808 */
809
810 dataptr = data;
811 for (ctr = 0; ctr < 3; ctr++) {
812 elemptr = sample_data[ctr] + start_col;
813
814 /* Even part */
815
816 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[2]);
817 tmp1 = GETJSAMPLE(elemptr[1]);
818
819 tmp2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[2]);
820
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);
827
828 /* Odd part */
829
830 dataptr[1] = (DCTELEM)
831 DESCALE(MULTIPLY(tmp2, FIX(1.224744871)), /* c1 */
832 CONST_BITS-PASS1_BITS-2);
833
834 dataptr += DCTSIZE; /* advance pointer to next row */
835 }
836
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.
843 */
844
845 dataptr = data;
846 for (ctr = 0; ctr < 3; ctr++) {
847 /* Even part */
848
849 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*2];
850 tmp1 = dataptr[DCTSIZE*1];
851
852 tmp2 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*2];
853
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);
860
861 /* Odd part */
862
863 dataptr[DCTSIZE*1] = (DCTELEM)
864 DESCALE(MULTIPLY(tmp2, FIX(2.177324216)), /* c1 */
865 CONST_BITS+PASS1_BITS);
866
867 dataptr++; /* advance pointer to next column */
868 }
869 }
870
871
872 /*
873 * Perform the forward DCT on a 2x2 sample block.
874 */
875
876 GLOBAL(void)
877 jpeg_fdct_2x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
878 {
879 DCTELEM tmp0, tmp1, tmp2, tmp3;
880 JSAMPROW elemptr;
881
882 /* Pre-zero output coefficient block. */
883 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
884
885 /* Pass 1: process rows.
886 * Note results are scaled up by sqrt(8) compared to a true DCT.
887 */
888
889 /* Row 0 */
890 elemptr = sample_data[0] + start_col;
891
892 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[1]);
893 tmp1 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[1]);
894
895 /* Row 1 */
896 elemptr = sample_data[1] + start_col;
897
898 tmp2 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[1]);
899 tmp3 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[1]);
900
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.
904 */
905
906 /* Column 0 */
907 /* Apply unsigned->signed conversion. */
908 data[DCTSIZE*0] = (tmp0 + tmp2 - 4 * CENTERJSAMPLE) << 4;
909 data[DCTSIZE*1] = (tmp0 - tmp2) << 4;
910
911 /* Column 1 */
912 data[DCTSIZE*0+1] = (tmp1 + tmp3) << 4;
913 data[DCTSIZE*1+1] = (tmp1 - tmp3) << 4;
914 }
915
916
917 /*
918 * Perform the forward DCT on a 1x1 sample block.
919 */
920
921 GLOBAL(void)
922 jpeg_fdct_1x1 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
923 {
924 DCTELEM dcval;
925
926 /* Pre-zero output coefficient block. */
927 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
928
929 dcval = GETJSAMPLE(sample_data[0][start_col]);
930
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;
935 }
936
937
938 /*
939 * Perform the forward DCT on a 9x9 sample block.
940 */
941
942 GLOBAL(void)
943 jpeg_fdct_9x9 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
944 {
945 INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
946 INT32 tmp10, tmp11, tmp12, tmp13;
947 INT32 z1, z2;
948 DCTELEM workspace[8];
949 DCTELEM *dataptr;
950 DCTELEM *wsptr;
951 JSAMPROW elemptr;
952 int ctr;
953 SHIFT_TEMPS
954
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).
960 */
961
962 dataptr = data;
963 ctr = 0;
964 for (;;) {
965 elemptr = sample_data[ctr] + start_col;
966
967 /* Even part */
968
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]);
974
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]);
979
980 z1 = tmp0 + tmp2 + tmp3;
981 z2 = tmp1 + tmp4;
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 */
986 CONST_BITS-1);
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);
995
996 /* Odd part */
997
998 dataptr[3] = (DCTELEM)
999 DESCALE(MULTIPLY(tmp10 - tmp12 - tmp13, FIX(1.224744871)), /* c3 */
1000 CONST_BITS-1);
1001
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 */
1005
1006 dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp0 + tmp1, CONST_BITS-1);
1007
1008 tmp2 = MULTIPLY(tmp12 - tmp13, FIX(1.392728481)); /* c1 */
1009
1010 dataptr[5] = (DCTELEM) DESCALE(tmp0 - tmp11 - tmp2, CONST_BITS-1);
1011 dataptr[7] = (DCTELEM) DESCALE(tmp1 - tmp11 + tmp2, CONST_BITS-1);
1012
1013 ctr++;
1014
1015 if (ctr != DCTSIZE) {
1016 if (ctr == 9)
1017 break; /* Done. */
1018 dataptr += DCTSIZE; /* advance pointer to next row */
1019 } else
1020 dataptr = workspace; /* switch pointer to extended workspace */
1021 }
1022
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.
1028 */
1029
1030 dataptr = data;
1031 wsptr = workspace;
1032 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1033 /* Even part */
1034
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];
1040
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];
1045
1046 z1 = tmp0 + tmp2 + tmp3;
1047 z2 = tmp1 + tmp4;
1048 dataptr[DCTSIZE*0] = (DCTELEM)
1049 DESCALE(MULTIPLY(z1 + z2, FIX(1.580246914)), /* 128/81 */
1050 CONST_BITS+2);
1051 dataptr[DCTSIZE*6] = (DCTELEM)
1052 DESCALE(MULTIPLY(z1 - z2 - z2, FIX(1.117403309)), /* c6 */
1053 CONST_BITS+2);
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);
1062
1063 /* Odd part */
1064
1065 dataptr[DCTSIZE*3] = (DCTELEM)
1066 DESCALE(MULTIPLY(tmp10 - tmp12 - tmp13, FIX(1.935399303)), /* c3 */
1067 CONST_BITS+2);
1068
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 */
1072
1073 dataptr[DCTSIZE*1] = (DCTELEM)
1074 DESCALE(tmp11 + tmp0 + tmp1, CONST_BITS+2);
1075
1076 tmp2 = MULTIPLY(tmp12 - tmp13, FIX(2.200854883)); /* c1 */
1077
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);
1082
1083 dataptr++; /* advance pointer to next column */
1084 wsptr++; /* advance pointer to next column */
1085 }
1086 }
1087
1088
1089 /*
1090 * Perform the forward DCT on a 10x10 sample block.
1091 */
1092
1093 GLOBAL(void)
1094 jpeg_fdct_10x10 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
1095 {
1096 INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
1097 INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1098 DCTELEM workspace[8*2];
1099 DCTELEM *dataptr;
1100 DCTELEM *wsptr;
1101 JSAMPROW elemptr;
1102 int ctr;
1103 SHIFT_TEMPS
1104
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).
1110 */
1111
1112 dataptr = data;
1113 ctr = 0;
1114 for (;;) {
1115 elemptr = sample_data[ctr] + start_col;
1116
1117 /* Even part */
1118
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]);
1124
1125 tmp10 = tmp0 + tmp4;
1126 tmp13 = tmp0 - tmp4;
1127 tmp11 = tmp1 + tmp3;
1128 tmp14 = tmp1 - tmp3;
1129
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]);
1135
1136 /* Apply unsigned->signed conversion. */
1137 dataptr[0] = (DCTELEM)
1138 ((tmp10 + tmp11 + tmp12 - 10 * CENTERJSAMPLE) << 1);
1139 tmp12 += tmp12;
1140 dataptr[4] = (DCTELEM)
1141 DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.144122806)) - /* c4 */
1142 MULTIPLY(tmp11 - tmp12, FIX(0.437016024)), /* c8 */
1143 CONST_BITS-1);
1144 tmp10 = MULTIPLY(tmp13 + tmp14, FIX(0.831253876)); /* c6 */
1145 dataptr[2] = (DCTELEM)
1146 DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.513743148)), /* c2-c6 */
1147 CONST_BITS-1);
1148 dataptr[6] = (DCTELEM)
1149 DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.176250899)), /* c2+c6 */
1150 CONST_BITS-1);
1151
1152 /* Odd part */
1153
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 */
1163 CONST_BITS-1);
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);
1170
1171 ctr++;
1172
1173 if (ctr != DCTSIZE) {
1174 if (ctr == 10)
1175 break; /* Done. */
1176 dataptr += DCTSIZE; /* advance pointer to next row */
1177 } else
1178 dataptr = workspace; /* switch pointer to extended workspace */
1179 }
1180
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.
1186 */
1187
1188 dataptr = data;
1189 wsptr = workspace;
1190 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1191 /* Even part */
1192
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];
1198
1199 tmp10 = tmp0 + tmp4;
1200 tmp13 = tmp0 - tmp4;
1201 tmp11 = tmp1 + tmp3;
1202 tmp14 = tmp1 - tmp3;
1203
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];
1209
1210 dataptr[DCTSIZE*0] = (DCTELEM)
1211 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(1.28)), /* 32/25 */
1212 CONST_BITS+2);
1213 tmp12 += tmp12;
1214 dataptr[DCTSIZE*4] = (DCTELEM)
1215 DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.464477191)) - /* c4 */
1216 MULTIPLY(tmp11 - tmp12, FIX(0.559380511)), /* c8 */
1217 CONST_BITS+2);
1218 tmp10 = MULTIPLY(tmp13 + tmp14, FIX(1.064004961)); /* c6 */
1219 dataptr[DCTSIZE*2] = (DCTELEM)
1220 DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.657591230)), /* c2-c6 */
1221 CONST_BITS+2);
1222 dataptr[DCTSIZE*6] = (DCTELEM)
1223 DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.785601151)), /* c2+c6 */
1224 CONST_BITS+2);
1225
1226 /* Odd part */
1227
1228 tmp10 = tmp0 + tmp4;
1229 tmp11 = tmp1 - tmp3;
1230 dataptr[DCTSIZE*5] = (DCTELEM)
1231 DESCALE(MULTIPLY(tmp10 - tmp11 - tmp2, FIX(1.28)), /* 32/25 */
1232 CONST_BITS+2);
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 */
1239 CONST_BITS+2);
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);
1246
1247 dataptr++; /* advance pointer to next column */
1248 wsptr++; /* advance pointer to next column */
1249 }
1250 }
1251
1252
1253 /*
1254 * Perform the forward DCT on an 11x11 sample block.
1255 */
1256
1257 GLOBAL(void)
1258 jpeg_fdct_11x11 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
1259 {
1260 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
1261 INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1262 INT32 z1, z2, z3;
1263 DCTELEM workspace[8*3];
1264 DCTELEM *dataptr;
1265 DCTELEM *wsptr;
1266 JSAMPROW elemptr;
1267 int ctr;
1268 SHIFT_TEMPS
1269
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).
1275 */
1276
1277 dataptr = data;
1278 ctr = 0;
1279 for (;;) {
1280 elemptr = sample_data[ctr] + start_col;
1281
1282 /* Even part */
1283
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]);
1290
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]);
1296
1297 /* Apply unsigned->signed conversion. */
1298 dataptr[0] = (DCTELEM)
1299 ((tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 - 11 * CENTERJSAMPLE) << 1);
1300 tmp5 += tmp5;
1301 tmp0 -= tmp5;
1302 tmp1 -= tmp5;
1303 tmp2 -= tmp5;
1304 tmp3 -= tmp5;
1305 tmp4 -= tmp5;
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 */
1313 CONST_BITS-1);
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 */
1318 CONST_BITS-1);
1319 dataptr[6] = (DCTELEM)
1320 DESCALE(z1 + z3 - MULTIPLY(tmp0, FIX(1.620527200)) /* c2+c4-c6 */
1321 - MULTIPLY(tmp2, FIX(0.788749120)), /* c8+c10 */
1322 CONST_BITS-1);
1323
1324 /* Odd part */
1325
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 */
1340
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);
1345
1346 ctr++;
1347
1348 if (ctr != DCTSIZE) {
1349 if (ctr == 11)
1350 break; /* Done. */
1351 dataptr += DCTSIZE; /* advance pointer to next row */
1352 } else
1353 dataptr = workspace; /* switch pointer to extended workspace */
1354 }
1355
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.
1361 */
1362
1363 dataptr = data;
1364 wsptr = workspace;
1365 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1366 /* Even part */
1367
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];
1374
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];
1380
1381 dataptr[DCTSIZE*0] = (DCTELEM)
1382 DESCALE(MULTIPLY(tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5,
1383 FIX(1.057851240)), /* 128/121 */
1384 CONST_BITS+2);
1385 tmp5 += tmp5;
1386 tmp0 -= tmp5;
1387 tmp1 -= tmp5;
1388 tmp2 -= tmp5;
1389 tmp3 -= tmp5;
1390 tmp4 -= tmp5;
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 */
1398 CONST_BITS+2);
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 */
1403 CONST_BITS+2);
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 */
1407 CONST_BITS+2);
1408
1409 /* Odd part */
1410
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 */
1425
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);
1430
1431 dataptr++; /* advance pointer to next column */
1432 wsptr++; /* advance pointer to next column */
1433 }
1434 }
1435
1436
1437 /*
1438 * Perform the forward DCT on a 12x12 sample block.
1439 */
1440
1441 GLOBAL(void)
1442 jpeg_fdct_12x12 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
1443 {
1444 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
1445 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1446 DCTELEM workspace[8*4];
1447 DCTELEM *dataptr;
1448 DCTELEM *wsptr;
1449 JSAMPROW elemptr;
1450 int ctr;
1451 SHIFT_TEMPS
1452
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).
1456 */
1457
1458 dataptr = data;
1459 ctr = 0;
1460 for (;;) {
1461 elemptr = sample_data[ctr] + start_col;
1462
1463 /* Even part */
1464
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]);
1471
1472 tmp10 = tmp0 + tmp5;
1473 tmp13 = tmp0 - tmp5;
1474 tmp11 = tmp1 + tmp4;
1475 tmp14 = tmp1 - tmp4;
1476 tmp12 = tmp2 + tmp3;
1477 tmp15 = tmp2 - tmp3;
1478
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]);
1485
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 */
1491 CONST_BITS);
1492 dataptr[2] = (DCTELEM)
1493 DESCALE(tmp14 - tmp15 + MULTIPLY(tmp13 + tmp15, FIX(1.366025404)), /* c2 */
1494 CONST_BITS);
1495
1496 /* Odd part */
1497
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 */
1512
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);
1517
1518 ctr++;
1519
1520 if (ctr != DCTSIZE) {
1521 if (ctr == 12)
1522 break; /* Done. */
1523 dataptr += DCTSIZE; /* advance pointer to next row */
1524 } else
1525 dataptr = workspace; /* switch pointer to extended workspace */
1526 }
1527
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.
1533 */
1534
1535 dataptr = data;
1536 wsptr = workspace;
1537 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1538 /* Even part */
1539
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];
1546
1547 tmp10 = tmp0 + tmp5;
1548 tmp13 = tmp0 - tmp5;
1549 tmp11 = tmp1 + tmp4;
1550 tmp14 = tmp1 - tmp4;
1551 tmp12 = tmp2 + tmp3;
1552 tmp15 = tmp2 - tmp3;
1553
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];
1560
1561 dataptr[DCTSIZE*0] = (DCTELEM)
1562 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(0.888888889)), /* 8/9 */
1563 CONST_BITS+1);
1564 dataptr[DCTSIZE*6] = (DCTELEM)
1565 DESCALE(MULTIPLY(tmp13 - tmp14 - tmp15, FIX(0.888888889)), /* 8/9 */
1566 CONST_BITS+1);
1567 dataptr[DCTSIZE*4] = (DCTELEM)
1568 DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.088662108)), /* c4 */
1569 CONST_BITS+1);
1570 dataptr[DCTSIZE*2] = (DCTELEM)
1571 DESCALE(MULTIPLY(tmp14 - tmp15, FIX(0.888888889)) + /* 8/9 */
1572 MULTIPLY(tmp13 + tmp15, FIX(1.214244803)), /* c2 */
1573 CONST_BITS+1);
1574
1575 /* Odd part */
1576
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 */
1591
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);
1596
1597 dataptr++; /* advance pointer to next column */
1598 wsptr++; /* advance pointer to next column */
1599 }
1600 }
1601
1602
1603 /*
1604 * Perform the forward DCT on a 13x13 sample block.
1605 */
1606
1607 GLOBAL(void)
1608 jpeg_fdct_13x13 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
1609 {
1610 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
1611 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1612 INT32 z1, z2;
1613 DCTELEM workspace[8*5];
1614 DCTELEM *dataptr;
1615 DCTELEM *wsptr;
1616 JSAMPROW elemptr;
1617 int ctr;
1618 SHIFT_TEMPS
1619
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).
1623 */
1624
1625 dataptr = data;
1626 ctr = 0;
1627 for (;;) {
1628 elemptr = sample_data[ctr] + start_col;
1629
1630 /* Even part */
1631
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]);
1639
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]);
1646
1647 /* Apply unsigned->signed conversion. */
1648 dataptr[0] = (DCTELEM)
1649 (tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 + tmp6 - 13 * CENTERJSAMPLE);
1650 tmp6 += tmp6;
1651 tmp0 -= tmp6;
1652 tmp1 -= tmp6;
1653 tmp2 -= tmp6;
1654 tmp3 -= tmp6;
1655 tmp4 -= tmp6;
1656 tmp5 -= tmp6;
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 */
1664 CONST_BITS);
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 */
1671
1672 dataptr[4] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS);
1673 dataptr[6] = (DCTELEM) DESCALE(z1 - z2, CONST_BITS);
1674
1675 /* Odd part */
1676
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 */
1697
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);
1702
1703 ctr++;
1704
1705 if (ctr != DCTSIZE) {
1706 if (ctr == 13)
1707 break; /* Done. */
1708 dataptr += DCTSIZE; /* advance pointer to next row */
1709 } else
1710 dataptr = workspace; /* switch pointer to extended workspace */
1711 }
1712
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.
1718 */
1719
1720 dataptr = data;
1721 wsptr = workspace;
1722 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1723 /* Even part */
1724
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];
1732
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];
1739
1740 dataptr[DCTSIZE*0] = (DCTELEM)
1741 DESCALE(MULTIPLY(tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 + tmp6,
1742 FIX(0.757396450)), /* 128/169 */
1743 CONST_BITS+1);
1744 tmp6 += tmp6;
1745 tmp0 -= tmp6;
1746 tmp1 -= tmp6;
1747 tmp2 -= tmp6;
1748 tmp3 -= tmp6;
1749 tmp4 -= tmp6;
1750 tmp5 -= tmp6;
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 */
1758 CONST_BITS+1);
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 */
1765
1766 dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS+1);
1767 dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 - z2, CONST_BITS+1);
1768
1769 /* Odd part */
1770
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 */
1791
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);
1796
1797 dataptr++; /* advance pointer to next column */
1798 wsptr++; /* advance pointer to next column */
1799 }
1800 }
1801
1802
1803 /*
1804 * Perform the forward DCT on a 14x14 sample block.
1805 */
1806
1807 GLOBAL(void)
1808 jpeg_fdct_14x14 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
1809 {
1810 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
1811 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
1812 DCTELEM workspace[8*6];
1813 DCTELEM *dataptr;
1814 DCTELEM *wsptr;
1815 JSAMPROW elemptr;
1816 int ctr;
1817 SHIFT_TEMPS
1818
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).
1822 */
1823
1824 dataptr = data;
1825 ctr = 0;
1826 for (;;) {
1827 elemptr = sample_data[ctr] + start_col;
1828
1829 /* Even part */
1830
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]);
1838
1839 tmp10 = tmp0 + tmp6;
1840 tmp14 = tmp0 - tmp6;
1841 tmp11 = tmp1 + tmp5;
1842 tmp15 = tmp1 - tmp5;
1843 tmp12 = tmp2 + tmp4;
1844 tmp16 = tmp2 - tmp4;
1845
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]);
1853
1854 /* Apply unsigned->signed conversion. */
1855 dataptr[0] = (DCTELEM)
1856 (tmp10 + tmp11 + tmp12 + tmp13 - 14 * CENTERJSAMPLE);
1857 tmp13 += tmp13;
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 */
1862 CONST_BITS);
1863
1864 tmp10 = MULTIPLY(tmp14 + tmp15, FIX(1.105676686)); /* c6 */
1865
1866 dataptr[2] = (DCTELEM)
1867 DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.273079590)) /* c2-c6 */
1868 + MULTIPLY(tmp16, FIX(0.613604268)), /* c10 */
1869 CONST_BITS);
1870 dataptr[6] = (DCTELEM)
1871 DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.719280954)) /* c6+c10 */
1872 - MULTIPLY(tmp16, FIX(1.378756276)), /* c2 */
1873 CONST_BITS);
1874
1875 /* Odd part */
1876
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 */
1889 CONST_BITS);
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 */
1895 CONST_BITS);
1896 dataptr[1] = (DCTELEM)
1897 DESCALE(tmp11 + tmp12 + tmp3 + tmp6 -
1898 MULTIPLY(tmp0 + tmp6, FIX(1.126980169)), /* c3+c5-c1 */
1899 CONST_BITS);
1900
1901 ctr++;
1902
1903 if (ctr != DCTSIZE) {
1904 if (ctr == 14)
1905 break; /* Done. */
1906 dataptr += DCTSIZE; /* advance pointer to next row */
1907 } else
1908 dataptr = workspace; /* switch pointer to extended workspace */
1909 }
1910
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.
1916 */
1917
1918 dataptr = data;
1919 wsptr = workspace;
1920 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
1921 /* Even part */
1922
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];
1930
1931 tmp10 = tmp0 + tmp6;
1932 tmp14 = tmp0 - tmp6;
1933 tmp11 = tmp1 + tmp5;
1934 tmp15 = tmp1 - tmp5;
1935 tmp12 = tmp2 + tmp4;
1936 tmp16 = tmp2 - tmp4;
1937
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];
1945
1946 dataptr[DCTSIZE*0] = (DCTELEM)
1947 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12 + tmp13,
1948 FIX(0.653061224)), /* 32/49 */
1949 CONST_BITS+1);
1950 tmp13 += tmp13;
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 */
1955 CONST_BITS+1);
1956
1957 tmp10 = MULTIPLY(tmp14 + tmp15, FIX(0.722074570)); /* c6 */
1958
1959 dataptr[DCTSIZE*2] = (DCTELEM)
1960 DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.178337691)) /* c2-c6 */
1961 + MULTIPLY(tmp16, FIX(0.400721155)), /* c10 */
1962 CONST_BITS+1);
1963 dataptr[DCTSIZE*6] = (DCTELEM)
1964 DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.122795725)) /* c6+c10 */
1965 - MULTIPLY(tmp16, FIX(0.900412262)), /* c2 */
1966 CONST_BITS+1);
1967
1968 /* Odd part */
1969
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 */
1975 CONST_BITS+1);
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 */
1985 CONST_BITS+1);
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 */
1991 CONST_BITS+1);
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 */
1996 CONST_BITS+1);
1997
1998 dataptr++; /* advance pointer to next column */
1999 wsptr++; /* advance pointer to next column */
2000 }
2001 }
2002
2003
2004 /*
2005 * Perform the forward DCT on a 15x15 sample block.
2006 */
2007
2008 GLOBAL(void)
2009 jpeg_fdct_15x15 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2010 {
2011 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2012 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2013 INT32 z1, z2, z3;
2014 DCTELEM workspace[8*7];
2015 DCTELEM *dataptr;
2016 DCTELEM *wsptr;
2017 JSAMPROW elemptr;
2018 int ctr;
2019 SHIFT_TEMPS
2020
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).
2024 */
2025
2026 dataptr = data;
2027 ctr = 0;
2028 for (;;) {
2029 elemptr = sample_data[ctr] + start_col;
2030
2031 /* Even part */
2032
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]);
2041
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]);
2049
2050 z1 = tmp0 + tmp4 + tmp5;
2051 z2 = tmp1 + tmp3 + tmp6;
2052 z3 = tmp2 + tmp7;
2053 /* Apply unsigned->signed conversion. */
2054 dataptr[0] = (DCTELEM) (z1 + z2 + z3 - 15 * CENTERJSAMPLE);
2055 z3 += z3;
2056 dataptr[6] = (DCTELEM)
2057 DESCALE(MULTIPLY(z1 - z3, FIX(1.144122806)) - /* c6 */
2058 MULTIPLY(z2 - z3, FIX(0.437016024)), /* c12 */
2059 CONST_BITS);
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 */
2068
2069 dataptr[2] = (DCTELEM) DESCALE(z1 + z3, CONST_BITS);
2070 dataptr[4] = (DCTELEM) DESCALE(z2 + z3, CONST_BITS);
2071
2072 /* Odd part */
2073
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 */
2088
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);
2093
2094 ctr++;
2095
2096 if (ctr != DCTSIZE) {
2097 if (ctr == 15)
2098 break; /* Done. */
2099 dataptr += DCTSIZE; /* advance pointer to next row */
2100 } else
2101 dataptr = workspace; /* switch pointer to extended workspace */
2102 }
2103
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.
2109 */
2110
2111 dataptr = data;
2112 wsptr = workspace;
2113 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
2114 /* Even part */
2115
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];
2124
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];
2132
2133 z1 = tmp0 + tmp4 + tmp5;
2134 z2 = tmp1 + tmp3 + tmp6;
2135 z3 = tmp2 + tmp7;
2136 dataptr[DCTSIZE*0] = (DCTELEM)
2137 DESCALE(MULTIPLY(z1 + z2 + z3, FIX(1.137777778)), /* 256/225 */
2138 CONST_BITS+2);
2139 z3 += z3;
2140 dataptr[DCTSIZE*6] = (DCTELEM)
2141 DESCALE(MULTIPLY(z1 - z3, FIX(1.301757503)) - /* c6 */
2142 MULTIPLY(z2 - z3, FIX(0.497227121)), /* c12 */
2143 CONST_BITS+2);
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 */
2152
2153 dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + z3, CONST_BITS+2);
2154 dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(z2 + z3, CONST_BITS+2);
2155
2156 /* Odd part */
2157
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 */
2172
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);
2177
2178 dataptr++; /* advance pointer to next column */
2179 wsptr++; /* advance pointer to next column */
2180 }
2181 }
2182
2183
2184 /*
2185 * Perform the forward DCT on a 16x16 sample block.
2186 */
2187
2188 GLOBAL(void)
2189 jpeg_fdct_16x16 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2190 {
2191 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2192 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
2193 DCTELEM workspace[DCTSIZE2];
2194 DCTELEM *dataptr;
2195 DCTELEM *wsptr;
2196 JSAMPROW elemptr;
2197 int ctr;
2198 SHIFT_TEMPS
2199
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).
2204 */
2205
2206 dataptr = data;
2207 ctr = 0;
2208 for (;;) {
2209 elemptr = sample_data[ctr] + start_col;
2210
2211 /* Even part */
2212
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]);
2221
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;
2230
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]);
2239
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);
2247
2248 tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) + /* c14[16] = c7[8] */
2249 MULTIPLY(tmp14 - tmp16, FIX(1.387039845)); /* c2[16] = c1[8] */
2250
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);
2259
2260 /* Odd part */
2261
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 */
2283
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);
2288
2289 ctr++;
2290
2291 if (ctr != DCTSIZE) {
2292 if (ctr == DCTSIZE * 2)
2293 break; /* Done. */
2294 dataptr += DCTSIZE; /* advance pointer to next row */
2295 } else
2296 dataptr = workspace; /* switch pointer to extended workspace */
2297 }
2298
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).
2304 */
2305
2306 dataptr = data;
2307 wsptr = workspace;
2308 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
2309 /* Even part */
2310
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];
2319
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;
2328
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];
2337
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);
2344
2345 tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) + /* c14[16] = c7[8] */
2346 MULTIPLY(tmp14 - tmp16, FIX(1.387039845)); /* c2[16] = c1[8] */
2347
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);
2356
2357 /* Odd part */
2358
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 */
2380
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);
2385
2386 dataptr++; /* advance pointer to next column */
2387 wsptr++; /* advance pointer to next column */
2388 }
2389 }
2390
2391
2392 /*
2393 * Perform the forward DCT on a 16x8 sample block.
2394 *
2395 * 16-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
2396 */
2397
2398 GLOBAL(void)
2399 jpeg_fdct_16x8 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2400 {
2401 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2402 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
2403 INT32 z1;
2404 DCTELEM *dataptr;
2405 JSAMPROW elemptr;
2406 int ctr;
2407 SHIFT_TEMPS
2408
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).
2413 */
2414
2415 dataptr = data;
2416 ctr = 0;
2417 for (ctr = 0; ctr < DCTSIZE; ctr++) {
2418 elemptr = sample_data[ctr] + start_col;
2419
2420 /* Even part */
2421
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]);
2430
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;
2439
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]);
2448
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);
2456
2457 tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) + /* c14[16] = c7[8] */
2458 MULTIPLY(tmp14 - tmp16, FIX(1.387039845)); /* c2[16] = c1[8] */
2459
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);
2468
2469 /* Odd part */
2470
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 */
2492
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);
2497
2498 dataptr += DCTSIZE; /* advance pointer to next row */
2499 }
2500
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).
2506 */
2507
2508 dataptr = data;
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".
2512 */
2513
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];
2518
2519 tmp10 = tmp0 + tmp3;
2520 tmp12 = tmp0 - tmp3;
2521 tmp11 = tmp1 + tmp2;
2522 tmp13 = tmp1 - tmp2;
2523
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];
2528
2529 dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS+1);
2530 dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS+1);
2531
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);
2539
2540 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
2541 * i0..i3 in the paper are tmp0..tmp3 here.
2542 */
2543
2544 tmp12 = tmp0 + tmp2;
2545 tmp13 = tmp1 + tmp3;
2546
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 */
2550 tmp12 += z1;
2551 tmp13 += z1;
2552
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 */
2556 tmp0 += z1 + tmp12;
2557 tmp3 += z1 + tmp13;
2558
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 */
2562 tmp1 += z1 + tmp13;
2563 tmp2 += z1 + tmp12;
2564
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);
2569
2570 dataptr++; /* advance pointer to next column */
2571 }
2572 }
2573
2574
2575 /*
2576 * Perform the forward DCT on a 14x7 sample block.
2577 *
2578 * 14-point FDCT in pass 1 (rows), 7-point in pass 2 (columns).
2579 */
2580
2581 GLOBAL(void)
2582 jpeg_fdct_14x7 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2583 {
2584 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
2585 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2586 INT32 z1, z2, z3;
2587 DCTELEM *dataptr;
2588 JSAMPROW elemptr;
2589 int ctr;
2590 SHIFT_TEMPS
2591
2592 /* Zero bottom row of output coefficient block. */
2593 MEMZERO(&data[DCTSIZE*7], SIZEOF(DCTELEM) * DCTSIZE);
2594
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).
2599 */
2600
2601 dataptr = data;
2602 for (ctr = 0; ctr < 7; ctr++) {
2603 elemptr = sample_data[ctr] + start_col;
2604
2605 /* Even part */
2606
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]);
2614
2615 tmp10 = tmp0 + tmp6;
2616 tmp14 = tmp0 - tmp6;
2617 tmp11 = tmp1 + tmp5;
2618 tmp15 = tmp1 - tmp5;
2619 tmp12 = tmp2 + tmp4;
2620 tmp16 = tmp2 - tmp4;
2621
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]);
2629
2630 /* Apply unsigned->signed conversion. */
2631 dataptr[0] = (DCTELEM)
2632 ((tmp10 + tmp11 + tmp12 + tmp13 - 14 * CENTERJSAMPLE) << PASS1_BITS);
2633 tmp13 += tmp13;
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);
2639
2640 tmp10 = MULTIPLY(tmp14 + tmp15, FIX(1.105676686)); /* c6 */
2641
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);
2650
2651 /* Odd part */
2652
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);
2676
2677 dataptr += DCTSIZE; /* advance pointer to next row */
2678 }
2679
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.
2686 */
2687
2688 dataptr = data;
2689 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
2690 /* Even part */
2691
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];
2696
2697 tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*6];
2698 tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*5];
2699 tmp12 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*4];
2700
2701 z1 = tmp0 + tmp2;
2702 dataptr[DCTSIZE*0] = (DCTELEM)
2703 DESCALE(MULTIPLY(z1 + tmp1 + tmp3, FIX(1.306122449)), /* 64/49 */
2704 CONST_BITS+PASS1_BITS+1);
2705 tmp3 += tmp3;
2706 z1 -= tmp3;
2707 z1 -= tmp3;
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);
2712 z1 -= z2;
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);
2718
2719 /* Odd part */
2720
2721 tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.221765677)); /* (c3+c1-c5)/2 */
2722 tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.222383464)); /* (c3+c5-c1)/2 */
2723 tmp0 = tmp1 - tmp2;
2724 tmp1 += tmp2;
2725 tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.800824523)); /* -c1 */
2726 tmp1 += tmp2;
2727 tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.801442310)); /* c5 */
2728 tmp0 += tmp3;
2729 tmp2 += tmp3 + MULTIPLY(tmp12, FIX(2.443531355)); /* c3+c1-c5 */
2730
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);
2734
2735 dataptr++; /* advance pointer to next column */
2736 }
2737 }
2738
2739
2740 /*
2741 * Perform the forward DCT on a 12x6 sample block.
2742 *
2743 * 12-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
2744 */
2745
2746 GLOBAL(void)
2747 jpeg_fdct_12x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2748 {
2749 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
2750 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
2751 DCTELEM *dataptr;
2752 JSAMPROW elemptr;
2753 int ctr;
2754 SHIFT_TEMPS
2755
2756 /* Zero 2 bottom rows of output coefficient block. */
2757 MEMZERO(&data[DCTSIZE*6], SIZEOF(DCTELEM) * DCTSIZE * 2);
2758
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).
2763 */
2764
2765 dataptr = data;
2766 for (ctr = 0; ctr < 6; ctr++) {
2767 elemptr = sample_data[ctr] + start_col;
2768
2769 /* Even part */
2770
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]);
2777
2778 tmp10 = tmp0 + tmp5;
2779 tmp13 = tmp0 - tmp5;
2780 tmp11 = tmp1 + tmp4;
2781 tmp14 = tmp1 - tmp4;
2782 tmp12 = tmp2 + tmp3;
2783 tmp15 = tmp2 - tmp3;
2784
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]);
2791
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);
2802
2803 /* Odd part */
2804
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 */
2819
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);
2824
2825 dataptr += DCTSIZE; /* advance pointer to next row */
2826 }
2827
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.
2834 */
2835
2836 dataptr = data;
2837 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
2838 /* Even part */
2839
2840 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
2841 tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
2842 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
2843
2844 tmp10 = tmp0 + tmp2;
2845 tmp12 = tmp0 - tmp2;
2846
2847 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
2848 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
2849 tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
2850
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);
2860
2861 /* Odd part */
2862
2863 tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829)); /* c5 */
2864
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);
2874
2875 dataptr++; /* advance pointer to next column */
2876 }
2877 }
2878
2879
2880 /*
2881 * Perform the forward DCT on a 10x5 sample block.
2882 *
2883 * 10-point FDCT in pass 1 (rows), 5-point in pass 2 (columns).
2884 */
2885
2886 GLOBAL(void)
2887 jpeg_fdct_10x5 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
2888 {
2889 INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
2890 INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
2891 DCTELEM *dataptr;
2892 JSAMPROW elemptr;
2893 int ctr;
2894 SHIFT_TEMPS
2895
2896 /* Zero 3 bottom rows of output coefficient block. */
2897 MEMZERO(&data[DCTSIZE*5], SIZEOF(DCTELEM) * DCTSIZE * 3);
2898
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).
2903 */
2904
2905 dataptr = data;
2906 for (ctr = 0; ctr < 5; ctr++) {
2907 elemptr = sample_data[ctr] + start_col;
2908
2909 /* Even part */
2910
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]);
2916
2917 tmp10 = tmp0 + tmp4;
2918 tmp13 = tmp0 - tmp4;
2919 tmp11 = tmp1 + tmp3;
2920 tmp14 = tmp1 - tmp3;
2921
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]);
2927
2928 /* Apply unsigned->signed conversion. */
2929 dataptr[0] = (DCTELEM)
2930 ((tmp10 + tmp11 + tmp12 - 10 * CENTERJSAMPLE) << PASS1_BITS);
2931 tmp12 += tmp12;
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);
2943
2944 /* Odd part */
2945
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);
2962
2963 dataptr += DCTSIZE; /* advance pointer to next row */
2964 }
2965
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.
2972 */
2973
2974 dataptr = data;
2975 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
2976 /* Even part */
2977
2978 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*4];
2979 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*3];
2980 tmp2 = dataptr[DCTSIZE*2];
2981
2982 tmp10 = tmp0 + tmp1;
2983 tmp11 = tmp0 - tmp1;
2984
2985 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*4];
2986 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*3];
2987
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 */
2992 tmp10 -= tmp2 << 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);
2996
2997 /* Odd part */
2998
2999 tmp10 = MULTIPLY(tmp0 + tmp1, FIX(1.064004961)); /* c3 */
3000
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);
3007
3008 dataptr++; /* advance pointer to next column */
3009 }
3010 }
3011
3012
3013 /*
3014 * Perform the forward DCT on an 8x4 sample block.
3015 *
3016 * 8-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
3017 */
3018
3019 GLOBAL(void)
3020 jpeg_fdct_8x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3021 {
3022 INT32 tmp0, tmp1, tmp2, tmp3;
3023 INT32 tmp10, tmp11, tmp12, tmp13;
3024 INT32 z1;
3025 DCTELEM *dataptr;
3026 JSAMPROW elemptr;
3027 int ctr;
3028 SHIFT_TEMPS
3029
3030 /* Zero 4 bottom rows of output coefficient block. */
3031 MEMZERO(&data[DCTSIZE*4], SIZEOF(DCTELEM) * DCTSIZE * 4);
3032
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).
3038 */
3039
3040 dataptr = data;
3041 for (ctr = 0; ctr < 4; ctr++) {
3042 elemptr = sample_data[ctr] + start_col;
3043
3044 /* Even part per LL&M figure 1 --- note that published figure is faulty;
3045 * rotator "c1" should be "c6".
3046 */
3047
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]);
3052
3053 tmp10 = tmp0 + tmp3;
3054 tmp12 = tmp0 - tmp3;
3055 tmp11 = tmp1 + tmp2;
3056 tmp13 = tmp1 - tmp2;
3057
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]);
3062
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));
3067
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);
3071
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);
3078
3079 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
3080 * i0..i3 in the paper are tmp0..tmp3 here.
3081 */
3082
3083 tmp12 = tmp0 + tmp2;
3084 tmp13 = tmp1 + tmp3;
3085
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);
3089
3090 tmp12 = MULTIPLY(tmp12, - FIX_0_390180644); /* -c3+c5 */
3091 tmp13 = MULTIPLY(tmp13, - FIX_1_961570560); /* -c3-c5 */
3092 tmp12 += z1;
3093 tmp13 += z1;
3094
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 */
3098 tmp0 += z1 + tmp12;
3099 tmp3 += z1 + tmp13;
3100
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 */
3104 tmp1 += z1 + tmp13;
3105 tmp2 += z1 + tmp12;
3106
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);
3111
3112 dataptr += DCTSIZE; /* advance pointer to next row */
3113 }
3114
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].
3120 */
3121
3122 dataptr = data;
3123 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
3124 /* Even part */
3125
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];
3129
3130 tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
3131 tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
3132
3133 dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);
3134 dataptr[DCTSIZE*2] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
3135
3136 /* Odd part */
3137
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);
3141
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);
3148
3149 dataptr++; /* advance pointer to next column */
3150 }
3151 }
3152
3153
3154 /*
3155 * Perform the forward DCT on a 6x3 sample block.
3156 *
3157 * 6-point FDCT in pass 1 (rows), 3-point in pass 2 (columns).
3158 */
3159
3160 GLOBAL(void)
3161 jpeg_fdct_6x3 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3162 {
3163 INT32 tmp0, tmp1, tmp2;
3164 INT32 tmp10, tmp11, tmp12;
3165 DCTELEM *dataptr;
3166 JSAMPROW elemptr;
3167 int ctr;
3168 SHIFT_TEMPS
3169
3170 /* Pre-zero output coefficient block. */
3171 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3172
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).
3179 */
3180
3181 dataptr = data;
3182 for (ctr = 0; ctr < 3; ctr++) {
3183 elemptr = sample_data[ctr] + start_col;
3184
3185 /* Even part */
3186
3187 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
3188 tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
3189 tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
3190
3191 tmp10 = tmp0 + tmp2;
3192 tmp12 = tmp0 - tmp2;
3193
3194 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
3195 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
3196 tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
3197
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);
3207
3208 /* Odd part */
3209
3210 tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)), /* c5 */
3211 CONST_BITS-PASS1_BITS-1);
3212
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)));
3216
3217 dataptr += DCTSIZE; /* advance pointer to next row */
3218 }
3219
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.
3226 */
3227
3228 dataptr = data;
3229 for (ctr = 0; ctr < 6; ctr++) {
3230 /* Even part */
3231
3232 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*2];
3233 tmp1 = dataptr[DCTSIZE*1];
3234
3235 tmp2 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*2];
3236
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);
3243
3244 /* Odd part */
3245
3246 dataptr[DCTSIZE*1] = (DCTELEM)
3247 DESCALE(MULTIPLY(tmp2, FIX(2.177324216)), /* c1 */
3248 CONST_BITS+PASS1_BITS);
3249
3250 dataptr++; /* advance pointer to next column */
3251 }
3252 }
3253
3254
3255 /*
3256 * Perform the forward DCT on a 4x2 sample block.
3257 *
3258 * 4-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
3259 */
3260
3261 GLOBAL(void)
3262 jpeg_fdct_4x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3263 {
3264 DCTELEM tmp0, tmp2, tmp10, tmp12, tmp4, tmp5;
3265 INT32 tmp1, tmp3, tmp11, tmp13;
3266 INT32 z1, z2, z3;
3267 JSAMPROW elemptr;
3268 SHIFT_TEMPS
3269
3270 /* Pre-zero output coefficient block. */
3271 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3272
3273 /* Pass 1: process rows.
3274 * Note results are scaled up by sqrt(8) compared to a true DCT.
3275 * 4-point FDCT kernel,
3276 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
3277 */
3278
3279 /* Row 0 */
3280 elemptr = sample_data[0] + start_col;
3281
3282 /* Even part */
3283
3284 tmp4 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
3285 tmp5 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
3286
3287 tmp0 = tmp4 + tmp5;
3288 tmp2 = tmp4 - tmp5;
3289
3290 /* Odd part */
3291
3292 z2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
3293 z3 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
3294
3295 z1 = MULTIPLY(z2 + z3, FIX_0_541196100); /* c6 */
3296 /* Add fudge factor here for final descale. */
3297 z1 += ONE << (CONST_BITS-3-1);
3298 tmp1 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
3299 tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
3300
3301 /* Row 1 */
3302 elemptr = sample_data[1] + start_col;
3303
3304 /* Even part */
3305
3306 tmp4 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
3307 tmp5 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
3308
3309 tmp10 = tmp4 + tmp5;
3310 tmp12 = tmp4 - tmp5;
3311
3312 /* Odd part */
3313
3314 z2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
3315 z3 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
3316
3317 z1 = MULTIPLY(z2 + z3, FIX_0_541196100); /* c6 */
3318 tmp11 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
3319 tmp13 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
3320
3321 /* Pass 2: process columns.
3322 * We leave the results scaled up by an overall factor of 8.
3323 * We must also scale the output by (8/4)*(8/2) = 2**3.
3324 */
3325
3326 /* Column 0 */
3327 /* Apply unsigned->signed conversion. */
3328 data[DCTSIZE*0] = (tmp0 + tmp10 - 8 * CENTERJSAMPLE) << 3;
3329 data[DCTSIZE*1] = (tmp0 - tmp10) << 3;
3330
3331 /* Column 1 */
3332 data[DCTSIZE*0+1] = (DCTELEM) RIGHT_SHIFT(tmp1 + tmp11, CONST_BITS-3);
3333 data[DCTSIZE*1+1] = (DCTELEM) RIGHT_SHIFT(tmp1 - tmp11, CONST_BITS-3);
3334
3335 /* Column 2 */
3336 data[DCTSIZE*0+2] = (tmp2 + tmp12) << 3;
3337 data[DCTSIZE*1+2] = (tmp2 - tmp12) << 3;
3338
3339 /* Column 3 */
3340 data[DCTSIZE*0+3] = (DCTELEM) RIGHT_SHIFT(tmp3 + tmp13, CONST_BITS-3);
3341 data[DCTSIZE*1+3] = (DCTELEM) RIGHT_SHIFT(tmp3 - tmp13, CONST_BITS-3);
3342 }
3343
3344
3345 /*
3346 * Perform the forward DCT on a 2x1 sample block.
3347 *
3348 * 2-point FDCT in pass 1 (rows), 1-point in pass 2 (columns).
3349 */
3350
3351 GLOBAL(void)
3352 jpeg_fdct_2x1 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3353 {
3354 DCTELEM tmp0, tmp1;
3355 JSAMPROW elemptr;
3356
3357 /* Pre-zero output coefficient block. */
3358 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3359
3360 elemptr = sample_data[0] + start_col;
3361
3362 tmp0 = GETJSAMPLE(elemptr[0]);
3363 tmp1 = GETJSAMPLE(elemptr[1]);
3364
3365 /* We leave the results scaled up by an overall factor of 8.
3366 * We must also scale the output by (8/2)*(8/1) = 2**5.
3367 */
3368
3369 /* Even part */
3370
3371 /* Apply unsigned->signed conversion. */
3372 data[0] = (tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 5;
3373
3374 /* Odd part */
3375
3376 data[1] = (tmp0 - tmp1) << 5;
3377 }
3378
3379
3380 /*
3381 * Perform the forward DCT on an 8x16 sample block.
3382 *
3383 * 8-point FDCT in pass 1 (rows), 16-point in pass 2 (columns).
3384 */
3385
3386 GLOBAL(void)
3387 jpeg_fdct_8x16 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3388 {
3389 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
3390 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
3391 INT32 z1;
3392 DCTELEM workspace[DCTSIZE2];
3393 DCTELEM *dataptr;
3394 DCTELEM *wsptr;
3395 JSAMPROW elemptr;
3396 int ctr;
3397 SHIFT_TEMPS
3398
3399 /* Pass 1: process rows.
3400 * Note results are scaled up by sqrt(8) compared to a true DCT;
3401 * furthermore, we scale the results by 2**PASS1_BITS.
3402 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
3403 */
3404
3405 dataptr = data;
3406 ctr = 0;
3407 for (;;) {
3408 elemptr = sample_data[ctr] + start_col;
3409
3410 /* Even part per LL&M figure 1 --- note that published figure is faulty;
3411 * rotator "c1" should be "c6".
3412 */
3413
3414 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7]);
3415 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6]);
3416 tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5]);
3417 tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4]);
3418
3419 tmp10 = tmp0 + tmp3;
3420 tmp12 = tmp0 - tmp3;
3421 tmp11 = tmp1 + tmp2;
3422 tmp13 = tmp1 - tmp2;
3423
3424 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7]);
3425 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6]);
3426 tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5]);
3427 tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4]);
3428
3429 /* Apply unsigned->signed conversion. */
3430 dataptr[0] = (DCTELEM) ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << PASS1_BITS);
3431 dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
3432
3433 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); /* c6 */
3434 dataptr[2] = (DCTELEM)
3435 DESCALE(z1 + MULTIPLY(tmp12, FIX_0_765366865), /* c2-c6 */
3436 CONST_BITS-PASS1_BITS);
3437 dataptr[6] = (DCTELEM)
3438 DESCALE(z1 - MULTIPLY(tmp13, FIX_1_847759065), /* c2+c6 */
3439 CONST_BITS-PASS1_BITS);
3440
3441 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
3442 * i0..i3 in the paper are tmp0..tmp3 here.
3443 */
3444
3445 tmp12 = tmp0 + tmp2;
3446 tmp13 = tmp1 + tmp3;
3447
3448 z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /* c3 */
3449 tmp12 = MULTIPLY(tmp12, - FIX_0_390180644); /* -c3+c5 */
3450 tmp13 = MULTIPLY(tmp13, - FIX_1_961570560); /* -c3-c5 */
3451 tmp12 += z1;
3452 tmp13 += z1;
3453
3454 z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
3455 tmp0 = MULTIPLY(tmp0, FIX_1_501321110); /* c1+c3-c5-c7 */
3456 tmp3 = MULTIPLY(tmp3, FIX_0_298631336); /* -c1+c3+c5-c7 */
3457 tmp0 += z1 + tmp12;
3458 tmp3 += z1 + tmp13;
3459
3460 z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
3461 tmp1 = MULTIPLY(tmp1, FIX_3_072711026); /* c1+c3+c5-c7 */
3462 tmp2 = MULTIPLY(tmp2, FIX_2_053119869); /* c1+c3-c5+c7 */
3463 tmp1 += z1 + tmp13;
3464 tmp2 += z1 + tmp12;
3465
3466 dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS-PASS1_BITS);
3467 dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS-PASS1_BITS);
3468 dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS-PASS1_BITS);
3469 dataptr[7] = (DCTELEM) DESCALE(tmp3, CONST_BITS-PASS1_BITS);
3470
3471 ctr++;
3472
3473 if (ctr != DCTSIZE) {
3474 if (ctr == DCTSIZE * 2)
3475 break; /* Done. */
3476 dataptr += DCTSIZE; /* advance pointer to next row */
3477 } else
3478 dataptr = workspace; /* switch pointer to extended workspace */
3479 }
3480
3481 /* Pass 2: process columns.
3482 * We remove the PASS1_BITS scaling, but leave the results scaled up
3483 * by an overall factor of 8.
3484 * We must also scale the output by 8/16 = 1/2.
3485 * 16-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
3486 */
3487
3488 dataptr = data;
3489 wsptr = workspace;
3490 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
3491 /* Even part */
3492
3493 tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*7];
3494 tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*6];
3495 tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*5];
3496 tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*4];
3497 tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*3];
3498 tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*2];
3499 tmp6 = dataptr[DCTSIZE*6] + wsptr[DCTSIZE*1];
3500 tmp7 = dataptr[DCTSIZE*7] + wsptr[DCTSIZE*0];
3501
3502 tmp10 = tmp0 + tmp7;
3503 tmp14 = tmp0 - tmp7;
3504 tmp11 = tmp1 + tmp6;
3505 tmp15 = tmp1 - tmp6;
3506 tmp12 = tmp2 + tmp5;
3507 tmp16 = tmp2 - tmp5;
3508 tmp13 = tmp3 + tmp4;
3509 tmp17 = tmp3 - tmp4;
3510
3511 tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*7];
3512 tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*6];
3513 tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*5];
3514 tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*4];
3515 tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*3];
3516 tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*2];
3517 tmp6 = dataptr[DCTSIZE*6] - wsptr[DCTSIZE*1];
3518 tmp7 = dataptr[DCTSIZE*7] - wsptr[DCTSIZE*0];
3519
3520 dataptr[DCTSIZE*0] = (DCTELEM)
3521 DESCALE(tmp10 + tmp11 + tmp12 + tmp13, PASS1_BITS+1);
3522 dataptr[DCTSIZE*4] = (DCTELEM)
3523 DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.306562965)) + /* c4[16] = c2[8] */
3524 MULTIPLY(tmp11 - tmp12, FIX_0_541196100), /* c12[16] = c6[8] */
3525 CONST_BITS+PASS1_BITS+1);
3526
3527 tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) + /* c14[16] = c7[8] */
3528 MULTIPLY(tmp14 - tmp16, FIX(1.387039845)); /* c2[16] = c1[8] */
3529
3530 dataptr[DCTSIZE*2] = (DCTELEM)
3531 DESCALE(tmp10 + MULTIPLY(tmp15, FIX(1.451774982)) /* c6+c14 */
3532 + MULTIPLY(tmp16, FIX(2.172734804)), /* c2+c10 */
3533 CONST_BITS+PASS1_BITS+1);
3534 dataptr[DCTSIZE*6] = (DCTELEM)
3535 DESCALE(tmp10 - MULTIPLY(tmp14, FIX(0.211164243)) /* c2-c6 */
3536 - MULTIPLY(tmp17, FIX(1.061594338)), /* c10+c14 */
3537 CONST_BITS+PASS1_BITS+1);
3538
3539 /* Odd part */
3540
3541 tmp11 = MULTIPLY(tmp0 + tmp1, FIX(1.353318001)) + /* c3 */
3542 MULTIPLY(tmp6 - tmp7, FIX(0.410524528)); /* c13 */
3543 tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.247225013)) + /* c5 */
3544 MULTIPLY(tmp5 + tmp7, FIX(0.666655658)); /* c11 */
3545 tmp13 = MULTIPLY(tmp0 + tmp3, FIX(1.093201867)) + /* c7 */
3546 MULTIPLY(tmp4 - tmp7, FIX(0.897167586)); /* c9 */
3547 tmp14 = MULTIPLY(tmp1 + tmp2, FIX(0.138617169)) + /* c15 */
3548 MULTIPLY(tmp6 - tmp5, FIX(1.407403738)); /* c1 */
3549 tmp15 = MULTIPLY(tmp1 + tmp3, - FIX(0.666655658)) + /* -c11 */
3550 MULTIPLY(tmp4 + tmp6, - FIX(1.247225013)); /* -c5 */
3551 tmp16 = MULTIPLY(tmp2 + tmp3, - FIX(1.353318001)) + /* -c3 */
3552 MULTIPLY(tmp5 - tmp4, FIX(0.410524528)); /* c13 */
3553 tmp10 = tmp11 + tmp12 + tmp13 -
3554 MULTIPLY(tmp0, FIX(2.286341144)) + /* c7+c5+c3-c1 */
3555 MULTIPLY(tmp7, FIX(0.779653625)); /* c15+c13-c11+c9 */
3556 tmp11 += tmp14 + tmp15 + MULTIPLY(tmp1, FIX(0.071888074)) /* c9-c3-c15+c11 */
3557 - MULTIPLY(tmp6, FIX(1.663905119)); /* c7+c13+c1-c5 */
3558 tmp12 += tmp14 + tmp16 - MULTIPLY(tmp2, FIX(1.125726048)) /* c7+c5+c15-c3 */
3559 + MULTIPLY(tmp5, FIX(1.227391138)); /* c9-c11+c1-c13 */
3560 tmp13 += tmp15 + tmp16 + MULTIPLY(tmp3, FIX(1.065388962)) /* c15+c3+c11-c7 */
3561 + MULTIPLY(tmp4, FIX(2.167985692)); /* c1+c13+c5-c9 */
3562
3563 dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+PASS1_BITS+1);
3564 dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+PASS1_BITS+1);
3565 dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+PASS1_BITS+1);
3566 dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+PASS1_BITS+1);
3567
3568 dataptr++; /* advance pointer to next column */
3569 wsptr++; /* advance pointer to next column */
3570 }
3571 }
3572
3573
3574 /*
3575 * Perform the forward DCT on a 7x14 sample block.
3576 *
3577 * 7-point FDCT in pass 1 (rows), 14-point in pass 2 (columns).
3578 */
3579
3580 GLOBAL(void)
3581 jpeg_fdct_7x14 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3582 {
3583 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
3584 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
3585 INT32 z1, z2, z3;
3586 DCTELEM workspace[8*6];
3587 DCTELEM *dataptr;
3588 DCTELEM *wsptr;
3589 JSAMPROW elemptr;
3590 int ctr;
3591 SHIFT_TEMPS
3592
3593 /* Pre-zero output coefficient block. */
3594 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3595
3596 /* Pass 1: process rows.
3597 * Note results are scaled up by sqrt(8) compared to a true DCT;
3598 * furthermore, we scale the results by 2**PASS1_BITS.
3599 * 7-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
3600 */
3601
3602 dataptr = data;
3603 ctr = 0;
3604 for (;;) {
3605 elemptr = sample_data[ctr] + start_col;
3606
3607 /* Even part */
3608
3609 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[6]);
3610 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[5]);
3611 tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[4]);
3612 tmp3 = GETJSAMPLE(elemptr[3]);
3613
3614 tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[6]);
3615 tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[5]);
3616 tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[4]);
3617
3618 z1 = tmp0 + tmp2;
3619 /* Apply unsigned->signed conversion. */
3620 dataptr[0] = (DCTELEM)
3621 ((z1 + tmp1 + tmp3 - 7 * CENTERJSAMPLE) << PASS1_BITS);
3622 tmp3 += tmp3;
3623 z1 -= tmp3;
3624 z1 -= tmp3;
3625 z1 = MULTIPLY(z1, FIX(0.353553391)); /* (c2+c6-c4)/2 */
3626 z2 = MULTIPLY(tmp0 - tmp2, FIX(0.920609002)); /* (c2+c4-c6)/2 */
3627 z3 = MULTIPLY(tmp1 - tmp2, FIX(0.314692123)); /* c6 */
3628 dataptr[2] = (DCTELEM) DESCALE(z1 + z2 + z3, CONST_BITS-PASS1_BITS);
3629 z1 -= z2;
3630 z2 = MULTIPLY(tmp0 - tmp1, FIX(0.881747734)); /* c4 */
3631 dataptr[4] = (DCTELEM)
3632 DESCALE(z2 + z3 - MULTIPLY(tmp1 - tmp3, FIX(0.707106781)), /* c2+c6-c4 */
3633 CONST_BITS-PASS1_BITS);
3634 dataptr[6] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS-PASS1_BITS);
3635
3636 /* Odd part */
3637
3638 tmp1 = MULTIPLY(tmp10 + tmp11, FIX(0.935414347)); /* (c3+c1-c5)/2 */
3639 tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.170262339)); /* (c3+c5-c1)/2 */
3640 tmp0 = tmp1 - tmp2;
3641 tmp1 += tmp2;
3642 tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.378756276)); /* -c1 */
3643 tmp1 += tmp2;
3644 tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.613604268)); /* c5 */
3645 tmp0 += tmp3;
3646 tmp2 += tmp3 + MULTIPLY(tmp12, FIX(1.870828693)); /* c3+c1-c5 */
3647
3648 dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS-PASS1_BITS);
3649 dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS-PASS1_BITS);
3650 dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS-PASS1_BITS);
3651
3652 ctr++;
3653
3654 if (ctr != DCTSIZE) {
3655 if (ctr == 14)
3656 break; /* Done. */
3657 dataptr += DCTSIZE; /* advance pointer to next row */
3658 } else
3659 dataptr = workspace; /* switch pointer to extended workspace */
3660 }
3661
3662 /* Pass 2: process columns.
3663 * We remove the PASS1_BITS scaling, but leave the results scaled up
3664 * by an overall factor of 8.
3665 * We must also scale the output by (8/7)*(8/14) = 32/49, which we
3666 * fold into the constant multipliers:
3667 * 14-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/28) * 32/49.
3668 */
3669
3670 dataptr = data;
3671 wsptr = workspace;
3672 for (ctr = 0; ctr < 7; ctr++) {
3673 /* Even part */
3674
3675 tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*5];
3676 tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*4];
3677 tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*3];
3678 tmp13 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*2];
3679 tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*1];
3680 tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*0];
3681 tmp6 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7];
3682
3683 tmp10 = tmp0 + tmp6;
3684 tmp14 = tmp0 - tmp6;
3685 tmp11 = tmp1 + tmp5;
3686 tmp15 = tmp1 - tmp5;
3687 tmp12 = tmp2 + tmp4;
3688 tmp16 = tmp2 - tmp4;
3689
3690 tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*5];
3691 tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*4];
3692 tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*3];
3693 tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*2];
3694 tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*1];
3695 tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*0];
3696 tmp6 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7];
3697
3698 dataptr[DCTSIZE*0] = (DCTELEM)
3699 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12 + tmp13,
3700 FIX(0.653061224)), /* 32/49 */
3701 CONST_BITS+PASS1_BITS);
3702 tmp13 += tmp13;
3703 dataptr[DCTSIZE*4] = (DCTELEM)
3704 DESCALE(MULTIPLY(tmp10 - tmp13, FIX(0.832106052)) + /* c4 */
3705 MULTIPLY(tmp11 - tmp13, FIX(0.205513223)) - /* c12 */
3706 MULTIPLY(tmp12 - tmp13, FIX(0.575835255)), /* c8 */
3707 CONST_BITS+PASS1_BITS);
3708
3709 tmp10 = MULTIPLY(tmp14 + tmp15, FIX(0.722074570)); /* c6 */
3710
3711 dataptr[DCTSIZE*2] = (DCTELEM)
3712 DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.178337691)) /* c2-c6 */
3713 + MULTIPLY(tmp16, FIX(0.400721155)), /* c10 */
3714 CONST_BITS+PASS1_BITS);
3715 dataptr[DCTSIZE*6] = (DCTELEM)
3716 DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.122795725)) /* c6+c10 */
3717 - MULTIPLY(tmp16, FIX(0.900412262)), /* c2 */
3718 CONST_BITS+PASS1_BITS);
3719
3720 /* Odd part */
3721
3722 tmp10 = tmp1 + tmp2;
3723 tmp11 = tmp5 - tmp4;
3724 dataptr[DCTSIZE*7] = (DCTELEM)
3725 DESCALE(MULTIPLY(tmp0 - tmp10 + tmp3 - tmp11 - tmp6,
3726 FIX(0.653061224)), /* 32/49 */
3727 CONST_BITS+PASS1_BITS);
3728 tmp3 = MULTIPLY(tmp3 , FIX(0.653061224)); /* 32/49 */
3729 tmp10 = MULTIPLY(tmp10, - FIX(0.103406812)); /* -c13 */
3730 tmp11 = MULTIPLY(tmp11, FIX(0.917760839)); /* c1 */
3731 tmp10 += tmp11 - tmp3;
3732 tmp11 = MULTIPLY(tmp0 + tmp2, FIX(0.782007410)) + /* c5 */
3733 MULTIPLY(tmp4 + tmp6, FIX(0.491367823)); /* c9 */
3734 dataptr[DCTSIZE*5] = (DCTELEM)
3735 DESCALE(tmp10 + tmp11 - MULTIPLY(tmp2, FIX(1.550341076)) /* c3+c5-c13 */
3736 + MULTIPLY(tmp4, FIX(0.731428202)), /* c1+c11-c9 */
3737 CONST_BITS+PASS1_BITS);
3738 tmp12 = MULTIPLY(tmp0 + tmp1, FIX(0.871740478)) + /* c3 */
3739 MULTIPLY(tmp5 - tmp6, FIX(0.305035186)); /* c11 */
3740 dataptr[DCTSIZE*3] = (DCTELEM)
3741 DESCALE(tmp10 + tmp12 - MULTIPLY(tmp1, FIX(0.276965844)) /* c3-c9-c13 */
3742 - MULTIPLY(tmp5, FIX(2.004803435)), /* c1+c5+c11 */
3743 CONST_BITS+PASS1_BITS);
3744 dataptr[DCTSIZE*1] = (DCTELEM)
3745 DESCALE(tmp11 + tmp12 + tmp3
3746 - MULTIPLY(tmp0, FIX(0.735987049)) /* c3+c5-c1 */
3747 - MULTIPLY(tmp6, FIX(0.082925825)), /* c9-c11-c13 */
3748 CONST_BITS+PASS1_BITS);
3749
3750 dataptr++; /* advance pointer to next column */
3751 wsptr++; /* advance pointer to next column */
3752 }
3753 }
3754
3755
3756 /*
3757 * Perform the forward DCT on a 6x12 sample block.
3758 *
3759 * 6-point FDCT in pass 1 (rows), 12-point in pass 2 (columns).
3760 */
3761
3762 GLOBAL(void)
3763 jpeg_fdct_6x12 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3764 {
3765 INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
3766 INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
3767 DCTELEM workspace[8*4];
3768 DCTELEM *dataptr;
3769 DCTELEM *wsptr;
3770 JSAMPROW elemptr;
3771 int ctr;
3772 SHIFT_TEMPS
3773
3774 /* Pre-zero output coefficient block. */
3775 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3776
3777 /* Pass 1: process rows.
3778 * Note results are scaled up by sqrt(8) compared to a true DCT;
3779 * furthermore, we scale the results by 2**PASS1_BITS.
3780 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3781 */
3782
3783 dataptr = data;
3784 ctr = 0;
3785 for (;;) {
3786 elemptr = sample_data[ctr] + start_col;
3787
3788 /* Even part */
3789
3790 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
3791 tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
3792 tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
3793
3794 tmp10 = tmp0 + tmp2;
3795 tmp12 = tmp0 - tmp2;
3796
3797 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
3798 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
3799 tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
3800
3801 /* Apply unsigned->signed conversion. */
3802 dataptr[0] = (DCTELEM)
3803 ((tmp10 + tmp11 - 6 * CENTERJSAMPLE) << PASS1_BITS);
3804 dataptr[2] = (DCTELEM)
3805 DESCALE(MULTIPLY(tmp12, FIX(1.224744871)), /* c2 */
3806 CONST_BITS-PASS1_BITS);
3807 dataptr[4] = (DCTELEM)
3808 DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(0.707106781)), /* c4 */
3809 CONST_BITS-PASS1_BITS);
3810
3811 /* Odd part */
3812
3813 tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)), /* c5 */
3814 CONST_BITS-PASS1_BITS);
3815
3816 dataptr[1] = (DCTELEM) (tmp10 + ((tmp0 + tmp1) << PASS1_BITS));
3817 dataptr[3] = (DCTELEM) ((tmp0 - tmp1 - tmp2) << PASS1_BITS);
3818 dataptr[5] = (DCTELEM) (tmp10 + ((tmp2 - tmp1) << PASS1_BITS));
3819
3820 ctr++;
3821
3822 if (ctr != DCTSIZE) {
3823 if (ctr == 12)
3824 break; /* Done. */
3825 dataptr += DCTSIZE; /* advance pointer to next row */
3826 } else
3827 dataptr = workspace; /* switch pointer to extended workspace */
3828 }
3829
3830 /* Pass 2: process columns.
3831 * We remove the PASS1_BITS scaling, but leave the results scaled up
3832 * by an overall factor of 8.
3833 * We must also scale the output by (8/6)*(8/12) = 8/9, which we
3834 * fold into the constant multipliers:
3835 * 12-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/24) * 8/9.
3836 */
3837
3838 dataptr = data;
3839 wsptr = workspace;
3840 for (ctr = 0; ctr < 6; ctr++) {
3841 /* Even part */
3842
3843 tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*3];
3844 tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*2];
3845 tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*1];
3846 tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*0];
3847 tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*7];
3848 tmp5 = dataptr[DCTSIZE*5] + dataptr[DCTSIZE*6];
3849
3850 tmp10 = tmp0 + tmp5;
3851 tmp13 = tmp0 - tmp5;
3852 tmp11 = tmp1 + tmp4;
3853 tmp14 = tmp1 - tmp4;
3854 tmp12 = tmp2 + tmp3;
3855 tmp15 = tmp2 - tmp3;
3856
3857 tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*3];
3858 tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*2];
3859 tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*1];
3860 tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*0];
3861 tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*7];
3862 tmp5 = dataptr[DCTSIZE*5] - dataptr[DCTSIZE*6];
3863
3864 dataptr[DCTSIZE*0] = (DCTELEM)
3865 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(0.888888889)), /* 8/9 */
3866 CONST_BITS+PASS1_BITS);
3867 dataptr[DCTSIZE*6] = (DCTELEM)
3868 DESCALE(MULTIPLY(tmp13 - tmp14 - tmp15, FIX(0.888888889)), /* 8/9 */
3869 CONST_BITS+PASS1_BITS);
3870 dataptr[DCTSIZE*4] = (DCTELEM)
3871 DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.088662108)), /* c4 */
3872 CONST_BITS+PASS1_BITS);
3873 dataptr[DCTSIZE*2] = (DCTELEM)
3874 DESCALE(MULTIPLY(tmp14 - tmp15, FIX(0.888888889)) + /* 8/9 */
3875 MULTIPLY(tmp13 + tmp15, FIX(1.214244803)), /* c2 */
3876 CONST_BITS+PASS1_BITS);
3877
3878 /* Odd part */
3879
3880 tmp10 = MULTIPLY(tmp1 + tmp4, FIX(0.481063200)); /* c9 */
3881 tmp14 = tmp10 + MULTIPLY(tmp1, FIX(0.680326102)); /* c3-c9 */
3882 tmp15 = tmp10 - MULTIPLY(tmp4, FIX(1.642452502)); /* c3+c9 */
3883 tmp12 = MULTIPLY(tmp0 + tmp2, FIX(0.997307603)); /* c5 */
3884 tmp13 = MULTIPLY(tmp0 + tmp3, FIX(0.765261039)); /* c7 */
3885 tmp10 = tmp12 + tmp13 + tmp14 - MULTIPLY(tmp0, FIX(0.516244403)) /* c5+c7-c1 */
3886 + MULTIPLY(tmp5, FIX(0.164081699)); /* c11 */
3887 tmp11 = MULTIPLY(tmp2 + tmp3, - FIX(0.164081699)); /* -c11 */
3888 tmp12 += tmp11 - tmp15 - MULTIPLY(tmp2, FIX(2.079550144)) /* c1+c5-c11 */
3889 + MULTIPLY(tmp5, FIX(0.765261039)); /* c7 */
3890 tmp13 += tmp11 - tmp14 + MULTIPLY(tmp3, FIX(0.645144899)) /* c1+c11-c7 */
3891 - MULTIPLY(tmp5, FIX(0.997307603)); /* c5 */
3892 tmp11 = tmp15 + MULTIPLY(tmp0 - tmp3, FIX(1.161389302)) /* c3 */
3893 - MULTIPLY(tmp2 + tmp5, FIX(0.481063200)); /* c9 */
3894
3895 dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+PASS1_BITS);
3896 dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+PASS1_BITS);
3897 dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+PASS1_BITS);
3898 dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+PASS1_BITS);
3899
3900 dataptr++; /* advance pointer to next column */
3901 wsptr++; /* advance pointer to next column */
3902 }
3903 }
3904
3905
3906 /*
3907 * Perform the forward DCT on a 5x10 sample block.
3908 *
3909 * 5-point FDCT in pass 1 (rows), 10-point in pass 2 (columns).
3910 */
3911
3912 GLOBAL(void)
3913 jpeg_fdct_5x10 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
3914 {
3915 INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
3916 INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
3917 DCTELEM workspace[8*2];
3918 DCTELEM *dataptr;
3919 DCTELEM *wsptr;
3920 JSAMPROW elemptr;
3921 int ctr;
3922 SHIFT_TEMPS
3923
3924 /* Pre-zero output coefficient block. */
3925 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
3926
3927 /* Pass 1: process rows.
3928 * Note results are scaled up by sqrt(8) compared to a true DCT;
3929 * furthermore, we scale the results by 2**PASS1_BITS.
3930 * 5-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
3931 */
3932
3933 dataptr = data;
3934 ctr = 0;
3935 for (;;) {
3936 elemptr = sample_data[ctr] + start_col;
3937
3938 /* Even part */
3939
3940 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[4]);
3941 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[3]);
3942 tmp2 = GETJSAMPLE(elemptr[2]);
3943
3944 tmp10 = tmp0 + tmp1;
3945 tmp11 = tmp0 - tmp1;
3946
3947 tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[4]);
3948 tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[3]);
3949
3950 /* Apply unsigned->signed conversion. */
3951 dataptr[0] = (DCTELEM)
3952 ((tmp10 + tmp2 - 5 * CENTERJSAMPLE) << PASS1_BITS);
3953 tmp11 = MULTIPLY(tmp11, FIX(0.790569415)); /* (c2+c4)/2 */
3954 tmp10 -= tmp2 << 2;
3955 tmp10 = MULTIPLY(tmp10, FIX(0.353553391)); /* (c2-c4)/2 */
3956 dataptr[2] = (DCTELEM) DESCALE(tmp11 + tmp10, CONST_BITS-PASS1_BITS);
3957 dataptr[4] = (DCTELEM) DESCALE(tmp11 - tmp10, CONST_BITS-PASS1_BITS);
3958
3959 /* Odd part */
3960
3961 tmp10 = MULTIPLY(tmp0 + tmp1, FIX(0.831253876)); /* c3 */
3962
3963 dataptr[1] = (DCTELEM)
3964 DESCALE(tmp10 + MULTIPLY(tmp0, FIX(0.513743148)), /* c1-c3 */
3965 CONST_BITS-PASS1_BITS);
3966 dataptr[3] = (DCTELEM)
3967 DESCALE(tmp10 - MULTIPLY(tmp1, FIX(2.176250899)), /* c1+c3 */
3968 CONST_BITS-PASS1_BITS);
3969
3970 ctr++;
3971
3972 if (ctr != DCTSIZE) {
3973 if (ctr == 10)
3974 break; /* Done. */
3975 dataptr += DCTSIZE; /* advance pointer to next row */
3976 } else
3977 dataptr = workspace; /* switch pointer to extended workspace */
3978 }
3979
3980 /* Pass 2: process columns.
3981 * We remove the PASS1_BITS scaling, but leave the results scaled up
3982 * by an overall factor of 8.
3983 * We must also scale the output by (8/5)*(8/10) = 32/25, which we
3984 * fold into the constant multipliers:
3985 * 10-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/20) * 32/25.
3986 */
3987
3988 dataptr = data;
3989 wsptr = workspace;
3990 for (ctr = 0; ctr < 5; ctr++) {
3991 /* Even part */
3992
3993 tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*1];
3994 tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*0];
3995 tmp12 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*7];
3996 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*6];
3997 tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5];
3998
3999 tmp10 = tmp0 + tmp4;
4000 tmp13 = tmp0 - tmp4;
4001 tmp11 = tmp1 + tmp3;
4002 tmp14 = tmp1 - tmp3;
4003
4004 tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*1];
4005 tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*0];
4006 tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*7];
4007 tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*6];
4008 tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5];
4009
4010 dataptr[DCTSIZE*0] = (DCTELEM)
4011 DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(1.28)), /* 32/25 */
4012 CONST_BITS+PASS1_BITS);
4013 tmp12 += tmp12;
4014 dataptr[DCTSIZE*4] = (DCTELEM)
4015 DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.464477191)) - /* c4 */
4016 MULTIPLY(tmp11 - tmp12, FIX(0.559380511)), /* c8 */
4017 CONST_BITS+PASS1_BITS);
4018 tmp10 = MULTIPLY(tmp13 + tmp14, FIX(1.064004961)); /* c6 */
4019 dataptr[DCTSIZE*2] = (DCTELEM)
4020 DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.657591230)), /* c2-c6 */
4021 CONST_BITS+PASS1_BITS);
4022 dataptr[DCTSIZE*6] = (DCTELEM)
4023 DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.785601151)), /* c2+c6 */
4024 CONST_BITS+PASS1_BITS);
4025
4026 /* Odd part */
4027
4028 tmp10 = tmp0 + tmp4;
4029 tmp11 = tmp1 - tmp3;
4030 dataptr[DCTSIZE*5] = (DCTELEM)
4031 DESCALE(MULTIPLY(tmp10 - tmp11 - tmp2, FIX(1.28)), /* 32/25 */
4032 CONST_BITS+PASS1_BITS);
4033 tmp2 = MULTIPLY(tmp2, FIX(1.28)); /* 32/25 */
4034 dataptr[DCTSIZE*1] = (DCTELEM)
4035 DESCALE(MULTIPLY(tmp0, FIX(1.787906876)) + /* c1 */
4036 MULTIPLY(tmp1, FIX(1.612894094)) + tmp2 + /* c3 */
4037 MULTIPLY(tmp3, FIX(0.821810588)) + /* c7 */
4038 MULTIPLY(tmp4, FIX(0.283176630)), /* c9 */
4039 CONST_BITS+PASS1_BITS);
4040 tmp12 = MULTIPLY(tmp0 - tmp4, FIX(1.217352341)) - /* (c3+c7)/2 */
4041 MULTIPLY(tmp1 + tmp3, FIX(0.752365123)); /* (c1-c9)/2 */
4042 tmp13 = MULTIPLY(tmp10 + tmp11, FIX(0.395541753)) + /* (c3-c7)/2 */
4043 MULTIPLY(tmp11, FIX(0.64)) - tmp2; /* 16/25 */
4044 dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp12 + tmp13, CONST_BITS+PASS1_BITS);
4045 dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp12 - tmp13, CONST_BITS+PASS1_BITS);
4046
4047 dataptr++; /* advance pointer to next column */
4048 wsptr++; /* advance pointer to next column */
4049 }
4050 }
4051
4052
4053 /*
4054 * Perform the forward DCT on a 4x8 sample block.
4055 *
4056 * 4-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
4057 */
4058
4059 GLOBAL(void)
4060 jpeg_fdct_4x8 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
4061 {
4062 INT32 tmp0, tmp1, tmp2, tmp3;
4063 INT32 tmp10, tmp11, tmp12, tmp13;
4064 INT32 z1;
4065 DCTELEM *dataptr;
4066 JSAMPROW elemptr;
4067 int ctr;
4068 SHIFT_TEMPS
4069
4070 /* Pre-zero output coefficient block. */
4071 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
4072
4073 /* Pass 1: process rows.
4074 * Note results are scaled up by sqrt(8) compared to a true DCT;
4075 * furthermore, we scale the results by 2**PASS1_BITS.
4076 * We must also scale the output by 8/4 = 2, which we add here.
4077 * 4-point FDCT kernel,
4078 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
4079 */
4080
4081 dataptr = data;
4082 for (ctr = 0; ctr < DCTSIZE; ctr++) {
4083 elemptr = sample_data[ctr] + start_col;
4084
4085 /* Even part */
4086
4087 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
4088 tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
4089
4090 tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
4091 tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
4092
4093 /* Apply unsigned->signed conversion. */
4094 dataptr[0] = (DCTELEM)
4095 ((tmp0 + tmp1 - 4 * CENTERJSAMPLE) << (PASS1_BITS+1));
4096 dataptr[2] = (DCTELEM) ((tmp0 - tmp1) << (PASS1_BITS+1));
4097
4098 /* Odd part */
4099
4100 tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100); /* c6 */
4101 /* Add fudge factor here for final descale. */
4102 tmp0 += ONE << (CONST_BITS-PASS1_BITS-2);
4103
4104 dataptr[1] = (DCTELEM)
4105 RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
4106 CONST_BITS-PASS1_BITS-1);
4107 dataptr[3] = (DCTELEM)
4108 RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
4109 CONST_BITS-PASS1_BITS-1);
4110
4111 dataptr += DCTSIZE; /* advance pointer to next row */
4112 }
4113
4114 /* Pass 2: process columns.
4115 * We remove the PASS1_BITS scaling, but leave the results scaled up
4116 * by an overall factor of 8.
4117 * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4118 */
4119
4120 dataptr = data;
4121 for (ctr = 0; ctr < 4; ctr++) {
4122 /* Even part per LL&M figure 1 --- note that published figure is faulty;
4123 * rotator "c1" should be "c6".
4124 */
4125
4126 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
4127 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
4128 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
4129 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
4130
4131 /* Add fudge factor here for final descale. */
4132 tmp10 = tmp0 + tmp3 + (ONE << (PASS1_BITS-1));
4133 tmp12 = tmp0 - tmp3;
4134 tmp11 = tmp1 + tmp2;
4135 tmp13 = tmp1 - tmp2;
4136
4137 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
4138 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
4139 tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
4140 tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
4141
4142 dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp10 + tmp11, PASS1_BITS);
4143 dataptr[DCTSIZE*4] = (DCTELEM) RIGHT_SHIFT(tmp10 - tmp11, PASS1_BITS);
4144
4145 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); /* c6 */
4146 /* Add fudge factor here for final descale. */
4147 z1 += ONE << (CONST_BITS+PASS1_BITS-1);
4148
4149 dataptr[DCTSIZE*2] = (DCTELEM)
4150 RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865), /* c2-c6 */
4151 CONST_BITS+PASS1_BITS);
4152 dataptr[DCTSIZE*6] = (DCTELEM)
4153 RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065), /* c2+c6 */
4154 CONST_BITS+PASS1_BITS);
4155
4156 /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
4157 * i0..i3 in the paper are tmp0..tmp3 here.
4158 */
4159
4160 tmp12 = tmp0 + tmp2;
4161 tmp13 = tmp1 + tmp3;
4162
4163 z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /* c3 */
4164 /* Add fudge factor here for final descale. */
4165 z1 += ONE << (CONST_BITS+PASS1_BITS-1);
4166
4167 tmp12 = MULTIPLY(tmp12, - FIX_0_390180644); /* -c3+c5 */
4168 tmp13 = MULTIPLY(tmp13, - FIX_1_961570560); /* -c3-c5 */
4169 tmp12 += z1;
4170 tmp13 += z1;
4171
4172 z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
4173 tmp0 = MULTIPLY(tmp0, FIX_1_501321110); /* c1+c3-c5-c7 */
4174 tmp3 = MULTIPLY(tmp3, FIX_0_298631336); /* -c1+c3+c5-c7 */
4175 tmp0 += z1 + tmp12;
4176 tmp3 += z1 + tmp13;
4177
4178 z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
4179 tmp1 = MULTIPLY(tmp1, FIX_3_072711026); /* c1+c3+c5-c7 */
4180 tmp2 = MULTIPLY(tmp2, FIX_2_053119869); /* c1+c3-c5+c7 */
4181 tmp1 += z1 + tmp13;
4182 tmp2 += z1 + tmp12;
4183
4184 dataptr[DCTSIZE*1] = (DCTELEM) RIGHT_SHIFT(tmp0, CONST_BITS+PASS1_BITS);
4185 dataptr[DCTSIZE*3] = (DCTELEM) RIGHT_SHIFT(tmp1, CONST_BITS+PASS1_BITS);
4186 dataptr[DCTSIZE*5] = (DCTELEM) RIGHT_SHIFT(tmp2, CONST_BITS+PASS1_BITS);
4187 dataptr[DCTSIZE*7] = (DCTELEM) RIGHT_SHIFT(tmp3, CONST_BITS+PASS1_BITS);
4188
4189 dataptr++; /* advance pointer to next column */
4190 }
4191 }
4192
4193
4194 /*
4195 * Perform the forward DCT on a 3x6 sample block.
4196 *
4197 * 3-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
4198 */
4199
4200 GLOBAL(void)
4201 jpeg_fdct_3x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
4202 {
4203 INT32 tmp0, tmp1, tmp2;
4204 INT32 tmp10, tmp11, tmp12;
4205 DCTELEM *dataptr;
4206 JSAMPROW elemptr;
4207 int ctr;
4208 SHIFT_TEMPS
4209
4210 /* Pre-zero output coefficient block. */
4211 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
4212
4213 /* Pass 1: process rows.
4214 * Note results are scaled up by sqrt(8) compared to a true DCT;
4215 * furthermore, we scale the results by 2**PASS1_BITS.
4216 * We scale the results further by 2 as part of output adaption
4217 * scaling for different DCT size.
4218 * 3-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
4219 */
4220
4221 dataptr = data;
4222 for (ctr = 0; ctr < 6; ctr++) {
4223 elemptr = sample_data[ctr] + start_col;
4224
4225 /* Even part */
4226
4227 tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[2]);
4228 tmp1 = GETJSAMPLE(elemptr[1]);
4229
4230 tmp2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[2]);
4231
4232 /* Apply unsigned->signed conversion. */
4233 dataptr[0] = (DCTELEM)
4234 ((tmp0 + tmp1 - 3 * CENTERJSAMPLE) << (PASS1_BITS+1));
4235 dataptr[2] = (DCTELEM)
4236 DESCALE(MULTIPLY(tmp0 - tmp1 - tmp1, FIX(0.707106781)), /* c2 */
4237 CONST_BITS-PASS1_BITS-1);
4238
4239 /* Odd part */
4240
4241 dataptr[1] = (DCTELEM)
4242 DESCALE(MULTIPLY(tmp2, FIX(1.224744871)), /* c1 */
4243 CONST_BITS-PASS1_BITS-1);
4244
4245 dataptr += DCTSIZE; /* advance pointer to next row */
4246 }
4247
4248 /* Pass 2: process columns.
4249 * We remove the PASS1_BITS scaling, but leave the results scaled up
4250 * by an overall factor of 8.
4251 * We must also scale the output by (8/6)*(8/3) = 32/9, which we partially
4252 * fold into the constant multipliers (other part was done in pass 1):
4253 * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12) * 16/9.
4254 */
4255
4256 dataptr = data;
4257 for (ctr = 0; ctr < 3; ctr++) {
4258 /* Even part */
4259
4260 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
4261 tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
4262 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
4263
4264 tmp10 = tmp0 + tmp2;
4265 tmp12 = tmp0 - tmp2;
4266
4267 tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
4268 tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
4269 tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
4270
4271 dataptr[DCTSIZE*0] = (DCTELEM)
4272 DESCALE(MULTIPLY(tmp10 + tmp11, FIX(1.777777778)), /* 16/9 */
4273 CONST_BITS+PASS1_BITS);
4274 dataptr[DCTSIZE*2] = (DCTELEM)
4275 DESCALE(MULTIPLY(tmp12, FIX(2.177324216)), /* c2 */
4276 CONST_BITS+PASS1_BITS);
4277 dataptr[DCTSIZE*4] = (DCTELEM)
4278 DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(1.257078722)), /* c4 */
4279 CONST_BITS+PASS1_BITS);
4280
4281 /* Odd part */
4282
4283 tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829)); /* c5 */
4284
4285 dataptr[DCTSIZE*1] = (DCTELEM)
4286 DESCALE(tmp10 + MULTIPLY(tmp0 + tmp1, FIX(1.777777778)), /* 16/9 */
4287 CONST_BITS+PASS1_BITS);
4288 dataptr[DCTSIZE*3] = (DCTELEM)
4289 DESCALE(MULTIPLY(tmp0 - tmp1 - tmp2, FIX(1.777777778)), /* 16/9 */
4290 CONST_BITS+PASS1_BITS);
4291 dataptr[DCTSIZE*5] = (DCTELEM)
4292 DESCALE(tmp10 + MULTIPLY(tmp2 - tmp1, FIX(1.777777778)), /* 16/9 */
4293 CONST_BITS+PASS1_BITS);
4294
4295 dataptr++; /* advance pointer to next column */
4296 }
4297 }
4298
4299
4300 /*
4301 * Perform the forward DCT on a 2x4 sample block.
4302 *
4303 * 2-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
4304 */
4305
4306 GLOBAL(void)
4307 jpeg_fdct_2x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
4308 {
4309 INT32 tmp0, tmp1;
4310 INT32 tmp10, tmp11;
4311 DCTELEM *dataptr;
4312 JSAMPROW elemptr;
4313 int ctr;
4314 SHIFT_TEMPS
4315
4316 /* Pre-zero output coefficient block. */
4317 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
4318
4319 /* Pass 1: process rows.
4320 * Note results are scaled up by sqrt(8) compared to a true DCT.
4321 */
4322
4323 dataptr = data;
4324 for (ctr = 0; ctr < 4; ctr++) {
4325 elemptr = sample_data[ctr] + start_col;
4326
4327 /* Even part */
4328
4329 tmp0 = GETJSAMPLE(elemptr[0]);
4330 tmp1 = GETJSAMPLE(elemptr[1]);
4331
4332 /* Apply unsigned->signed conversion. */
4333 dataptr[0] = (DCTELEM) (tmp0 + tmp1 - 2 * CENTERJSAMPLE);
4334
4335 /* Odd part */
4336
4337 dataptr[1] = (DCTELEM) (tmp0 - tmp1);
4338
4339 dataptr += DCTSIZE; /* advance pointer to next row */
4340 }
4341
4342 /* Pass 2: process columns.
4343 * We leave the results scaled up by an overall factor of 8.
4344 * We must also scale the output by (8/2)*(8/4) = 2**3.
4345 * 4-point FDCT kernel,
4346 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
4347 */
4348
4349 dataptr = data;
4350 for (ctr = 0; ctr < 2; ctr++) {
4351 /* Even part */
4352
4353 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*3];
4354 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*2];
4355
4356 tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
4357 tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
4358
4359 dataptr[DCTSIZE*0] = (DCTELEM) ((tmp0 + tmp1) << 3);
4360 dataptr[DCTSIZE*2] = (DCTELEM) ((tmp0 - tmp1) << 3);
4361
4362 /* Odd part */
4363
4364 tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100); /* c6 */
4365 /* Add fudge factor here for final descale. */
4366 tmp0 += ONE << (CONST_BITS-3-1);
4367
4368 dataptr[DCTSIZE*1] = (DCTELEM)
4369 RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
4370 CONST_BITS-3);
4371 dataptr[DCTSIZE*3] = (DCTELEM)
4372 RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
4373 CONST_BITS-3);
4374
4375 dataptr++; /* advance pointer to next column */
4376 }
4377 }
4378
4379
4380 /*
4381 * Perform the forward DCT on a 1x2 sample block.
4382 *
4383 * 1-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
4384 */
4385
4386 GLOBAL(void)
4387 jpeg_fdct_1x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
4388 {
4389 DCTELEM tmp0, tmp1;
4390
4391 /* Pre-zero output coefficient block. */
4392 MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
4393
4394 /* Pass 1: empty. */
4395
4396 /* Pass 2: process columns.
4397 * We leave the results scaled up by an overall factor of 8.
4398 * We must also scale the output by (8/1)*(8/2) = 2**5.
4399 */
4400
4401 /* Even part */
4402
4403 tmp0 = GETJSAMPLE(sample_data[0][start_col]);
4404 tmp1 = GETJSAMPLE(sample_data[1][start_col]);
4405
4406 /* Apply unsigned->signed conversion. */
4407 data[DCTSIZE*0] = (tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 5;
4408
4409 /* Odd part */
4410
4411 data[DCTSIZE*1] = (tmp0 - tmp1) << 5;
4412 }
4413
4414 #endif /* DCT_SCALING_SUPPORTED */
4415 #endif /* DCT_ISLOW_SUPPORTED */
Windows API implementation