Mercurial > libavcodec.hg
annotate jfdctfst.c @ 12266:48d6738904a9 libavcodec
Fix SPLATB_REG mess. Used to be a if/elseif/elseif/elseif spaghetti, so this
splits it into small optimization-specific macros which are selected for each
DSP function. The advantage of this approach is that the sse4 functions now
use the ssse3 codepath also without needing an explicit sse4 codepath.
author | rbultje |
---|---|
date | Sat, 24 Jul 2010 19:33:05 +0000 |
parents | 7dd2a45249a9 |
children |
rev | line source |
---|---|
0 | 1 /* |
2 * jfdctfst.c | |
3 * | |
4 * This file is part of the Independent JPEG Group's software. | |
3669
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
5 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
6 * The authors make NO WARRANTY or representation, either express or implied, |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
7 * with respect to this software, its quality, accuracy, merchantability, or |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
8 * fitness for a particular purpose. This software is provided "AS IS", and |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
9 * you, its user, assume the entire risk as to its quality and accuracy. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
10 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
11 * This software is copyright (C) 1994-1996, Thomas G. Lane. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
12 * All Rights Reserved except as specified below. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
13 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
14 * Permission is hereby granted to use, copy, modify, and distribute this |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
15 * software (or portions thereof) for any purpose, without fee, subject to |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
16 * these conditions: |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
17 * (1) If any part of the source code for this software is distributed, then |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
18 * this README file must be included, with this copyright and no-warranty |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
19 * notice unaltered; and any additions, deletions, or changes to the original |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
20 * files must be clearly indicated in accompanying documentation. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
21 * (2) If only executable code is distributed, then the accompanying |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
22 * documentation must state that "this software is based in part on the work |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
23 * of the Independent JPEG Group". |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
24 * (3) Permission for use of this software is granted only if the user accepts |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
25 * full responsibility for any undesirable consequences; the authors accept |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
26 * NO LIABILITY for damages of any kind. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
27 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
28 * These conditions apply to any software derived from or based on the IJG |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
29 * code, not just to the unmodified library. If you use our work, you ought |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
30 * to acknowledge us. |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
31 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
32 * Permission is NOT granted for the use of any IJG author's name or company |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
33 * name in advertising or publicity relating to this software or products |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
34 * derived from it. This software may be referred to only as "the Independent |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
35 * JPEG Group's software". |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
36 * |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
37 * We specifically permit and encourage the use of this software as the basis |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
38 * of commercial products, provided that all warranty or liability claims are |
9b98e18a1b1c
Add copyright notice from the Independent JPEG Group instead of referring
diego
parents:
2979
diff
changeset
|
39 * assumed by the product vendor. |
0 | 40 * |
41 * This file contains a fast, not so accurate integer implementation of the | |
42 * forward DCT (Discrete Cosine Transform). | |
43 * | |
44 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT | |
45 * on each column. Direct algorithms are also available, but they are | |
46 * much more complex and seem not to be any faster when reduced to code. | |
47 * | |
48 * This implementation is based on Arai, Agui, and Nakajima's algorithm for | |
49 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in | |
50 * Japanese, but the algorithm is described in the Pennebaker & Mitchell | |
51 * JPEG textbook (see REFERENCES section in file README). The following code | |
52 * is based directly on figure 4-8 in P&M. | |
53 * While an 8-point DCT cannot be done in less than 11 multiplies, it is | |
54 * possible to arrange the computation so that many of the multiplies are | |
55 * simple scalings of the final outputs. These multiplies can then be | |
56 * folded into the multiplications or divisions by the JPEG quantization | |
57 * table entries. The AA&N method leaves only 5 multiplies and 29 adds | |
58 * to be done in the DCT itself. | |
59 * The primary disadvantage of this method is that with fixed-point math, | |
60 * accuracy is lost due to imprecise representation of the scaled | |
61 * quantization values. The smaller the quantization table entry, the less | |
62 * precise the scaled value, so this implementation does worse with high- | |
63 * quality-setting files than with low-quality ones. | |
64 */ | |
65 | |
1106 | 66 /** |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
10446
diff
changeset
|
67 * @file |
1106 | 68 * Independent JPEG Group's fast AAN dct. |
69 */ | |
2967 | 70 |
0 | 71 #include <stdlib.h> |
72 #include <stdio.h> | |
6763 | 73 #include "libavutil/common.h" |
0 | 74 #include "dsputil.h" |
75 | |
76 #define DCTSIZE 8 | |
77 #define GLOBAL(x) x | |
78 #define RIGHT_SHIFT(x, n) ((x) >> (n)) | |
79 | |
80 /* | |
81 * This module is specialized to the case DCTSIZE = 8. | |
82 */ | |
83 | |
84 #if DCTSIZE != 8 | |
85 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ | |
86 #endif | |
87 | |
88 | |
89 /* Scaling decisions are generally the same as in the LL&M algorithm; | |
90 * see jfdctint.c for more details. However, we choose to descale | |
91 * (right shift) multiplication products as soon as they are formed, | |
92 * rather than carrying additional fractional bits into subsequent additions. | |
93 * This compromises accuracy slightly, but it lets us save a few shifts. | |
94 * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) | |
95 * everywhere except in the multiplications proper; this saves a good deal | |
96 * of work on 16-bit-int machines. | |
97 * | |
98 * Again to save a few shifts, the intermediate results between pass 1 and | |
99 * pass 2 are not upscaled, but are represented only to integral precision. | |
100 * | |
101 * A final compromise is to represent the multiplicative constants to only | |
102 * 8 fractional bits, rather than 13. This saves some shifting work on some | |
103 * machines, and may also reduce the cost of multiplication (since there | |
104 * are fewer one-bits in the constants). | |
105 */ | |
106 | |
107 #define CONST_BITS 8 | |
108 | |
109 | |
110 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus | |
111 * causing a lot of useless floating-point operations at run time. | |
112 * To get around this we use the following pre-calculated constants. | |
113 * If you change CONST_BITS you may want to add appropriate values. | |
114 * (With a reasonable C compiler, you can just rely on the FIX() macro...) | |
115 */ | |
116 | |
117 #if CONST_BITS == 8 | |
2979 | 118 #define FIX_0_382683433 ((int32_t) 98) /* FIX(0.382683433) */ |
119 #define FIX_0_541196100 ((int32_t) 139) /* FIX(0.541196100) */ | |
120 #define FIX_0_707106781 ((int32_t) 181) /* FIX(0.707106781) */ | |
121 #define FIX_1_306562965 ((int32_t) 334) /* FIX(1.306562965) */ | |
0 | 122 #else |
123 #define FIX_0_382683433 FIX(0.382683433) | |
124 #define FIX_0_541196100 FIX(0.541196100) | |
125 #define FIX_0_707106781 FIX(0.707106781) | |
126 #define FIX_1_306562965 FIX(1.306562965) | |
127 #endif | |
128 | |
129 | |
130 /* We can gain a little more speed, with a further compromise in accuracy, | |
131 * by omitting the addition in a descaling shift. This yields an incorrectly | |
132 * rounded result half the time... | |
133 */ | |
134 | |
135 #ifndef USE_ACCURATE_ROUNDING | |
136 #undef DESCALE | |
137 #define DESCALE(x,n) RIGHT_SHIFT(x, n) | |
138 #endif | |
139 | |
140 | |
1064 | 141 /* Multiply a DCTELEM variable by an int32_t constant, and immediately |
0 | 142 * descale to yield a DCTELEM result. |
143 */ | |
144 | |
145 #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) | |
146 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
3669
diff
changeset
|
147 static av_always_inline void row_fdct(DCTELEM * data){ |
1589 | 148 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
149 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
150 int_fast16_t z1, z2, z3, z4, z5, z11, z13; | |
0 | 151 DCTELEM *dataptr; |
152 int ctr; | |
153 | |
154 /* Pass 1: process rows. */ | |
155 | |
156 dataptr = data; | |
157 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | |
158 tmp0 = dataptr[0] + dataptr[7]; | |
159 tmp7 = dataptr[0] - dataptr[7]; | |
160 tmp1 = dataptr[1] + dataptr[6]; | |
161 tmp6 = dataptr[1] - dataptr[6]; | |
162 tmp2 = dataptr[2] + dataptr[5]; | |
163 tmp5 = dataptr[2] - dataptr[5]; | |
164 tmp3 = dataptr[3] + dataptr[4]; | |
165 tmp4 = dataptr[3] - dataptr[4]; | |
2967 | 166 |
0 | 167 /* Even part */ |
2967 | 168 |
2979 | 169 tmp10 = tmp0 + tmp3; /* phase 2 */ |
0 | 170 tmp13 = tmp0 - tmp3; |
171 tmp11 = tmp1 + tmp2; | |
172 tmp12 = tmp1 - tmp2; | |
2967 | 173 |
0 | 174 dataptr[0] = tmp10 + tmp11; /* phase 3 */ |
175 dataptr[4] = tmp10 - tmp11; | |
2967 | 176 |
0 | 177 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
2979 | 178 dataptr[2] = tmp13 + z1; /* phase 5 */ |
0 | 179 dataptr[6] = tmp13 - z1; |
2967 | 180 |
0 | 181 /* Odd part */ |
182 | |
2979 | 183 tmp10 = tmp4 + tmp5; /* phase 2 */ |
0 | 184 tmp11 = tmp5 + tmp6; |
185 tmp12 = tmp6 + tmp7; | |
186 | |
187 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | |
188 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | |
2979 | 189 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ |
190 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | |
191 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | |
0 | 192 |
2979 | 193 z11 = tmp7 + z3; /* phase 5 */ |
0 | 194 z13 = tmp7 - z3; |
195 | |
2979 | 196 dataptr[5] = z13 + z2; /* phase 6 */ |
0 | 197 dataptr[3] = z13 - z2; |
198 dataptr[1] = z11 + z4; | |
199 dataptr[7] = z11 - z4; | |
200 | |
2979 | 201 dataptr += DCTSIZE; /* advance pointer to next row */ |
0 | 202 } |
1589 | 203 } |
0 | 204 |
1589 | 205 /* |
206 * Perform the forward DCT on one block of samples. | |
207 */ | |
208 | |
209 GLOBAL(void) | |
210 fdct_ifast (DCTELEM * data) | |
211 { | |
212 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; | |
213 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
214 int_fast16_t z1, z2, z3, z4, z5, z11, z13; | |
215 DCTELEM *dataptr; | |
216 int ctr; | |
217 | |
218 row_fdct(data); | |
2967 | 219 |
0 | 220 /* Pass 2: process columns. */ |
221 | |
222 dataptr = data; | |
223 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | |
224 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; | |
225 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; | |
226 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; | |
227 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; | |
228 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; | |
229 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; | |
230 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; | |
231 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; | |
2967 | 232 |
0 | 233 /* Even part */ |
2967 | 234 |
2979 | 235 tmp10 = tmp0 + tmp3; /* phase 2 */ |
0 | 236 tmp13 = tmp0 - tmp3; |
237 tmp11 = tmp1 + tmp2; | |
238 tmp12 = tmp1 - tmp2; | |
2967 | 239 |
0 | 240 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ |
241 dataptr[DCTSIZE*4] = tmp10 - tmp11; | |
2967 | 242 |
0 | 243 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
244 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ | |
245 dataptr[DCTSIZE*6] = tmp13 - z1; | |
2967 | 246 |
0 | 247 /* Odd part */ |
248 | |
2979 | 249 tmp10 = tmp4 + tmp5; /* phase 2 */ |
0 | 250 tmp11 = tmp5 + tmp6; |
251 tmp12 = tmp6 + tmp7; | |
252 | |
253 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | |
254 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | |
255 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ | |
256 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | |
257 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | |
258 | |
2979 | 259 z11 = tmp7 + z3; /* phase 5 */ |
0 | 260 z13 = tmp7 - z3; |
261 | |
262 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ | |
263 dataptr[DCTSIZE*3] = z13 - z2; | |
264 dataptr[DCTSIZE*1] = z11 + z4; | |
265 dataptr[DCTSIZE*7] = z11 - z4; | |
266 | |
2979 | 267 dataptr++; /* advance pointer to next column */ |
0 | 268 } |
269 } | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
270 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
271 /* |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
272 * Perform the forward 2-4-8 DCT on one block of samples. |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
273 */ |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
274 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
275 GLOBAL(void) |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
276 fdct_ifast248 (DCTELEM * data) |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
277 { |
1589 | 278 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
279 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
280 int_fast16_t z1; | |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
281 DCTELEM *dataptr; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
282 int ctr; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
283 |
1589 | 284 row_fdct(data); |
2967 | 285 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
286 /* Pass 2: process columns. */ |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
287 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
288 dataptr = data; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
289 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
290 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*1]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
291 tmp1 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
292 tmp2 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
293 tmp3 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
294 tmp4 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*1]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
295 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
296 tmp6 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
297 tmp7 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
298 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
299 /* Even part */ |
2967 | 300 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
301 tmp10 = tmp0 + tmp3; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
302 tmp11 = tmp1 + tmp2; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
303 tmp12 = tmp1 - tmp2; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
304 tmp13 = tmp0 - tmp3; |
2967 | 305 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
306 dataptr[DCTSIZE*0] = tmp10 + tmp11; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
307 dataptr[DCTSIZE*4] = tmp10 - tmp11; |
2967 | 308 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
309 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
310 dataptr[DCTSIZE*2] = tmp13 + z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
311 dataptr[DCTSIZE*6] = tmp13 - z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
312 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
313 tmp10 = tmp4 + tmp7; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
314 tmp11 = tmp5 + tmp6; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
315 tmp12 = tmp5 - tmp6; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
316 tmp13 = tmp4 - tmp7; |
2967 | 317 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
318 dataptr[DCTSIZE*1] = tmp10 + tmp11; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
319 dataptr[DCTSIZE*5] = tmp10 - tmp11; |
2967 | 320 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
321 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
322 dataptr[DCTSIZE*3] = tmp13 + z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
323 dataptr[DCTSIZE*7] = tmp13 - z1; |
2967 | 324 |
2979 | 325 dataptr++; /* advance pointer to next column */ |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
326 } |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
327 } |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
328 |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
329 |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
330 #undef GLOBAL |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
331 #undef CONST_BITS |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
332 #undef DESCALE |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
333 #undef FIX_0_541196100 |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
334 #undef FIX_1_306562965 |