Mercurial > libavcodec.hg
annotate jfdctfst.c @ 10320:44f31c1c9acc libavcodec
Make sure that dv encoder initializes all encoded packet data.
The specification does not say which value to use for unused
parts, so fill all unused bytes with 0xff, which is consistent
with what DV usually uses for reserved or unused parts.
author | reimar |
---|---|
date | Tue, 29 Sep 2009 19:17:18 +0000 |
parents | e9d9d946f213 |
children | f522171a5d3d |
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 /** |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
6763
diff
changeset
|
67 * @file libavcodec/jfdctfst.c |
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 #define SHIFT_TEMPS | |
80 | |
81 /* | |
82 * This module is specialized to the case DCTSIZE = 8. | |
83 */ | |
84 | |
85 #if DCTSIZE != 8 | |
86 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ | |
87 #endif | |
88 | |
89 | |
90 /* Scaling decisions are generally the same as in the LL&M algorithm; | |
91 * see jfdctint.c for more details. However, we choose to descale | |
92 * (right shift) multiplication products as soon as they are formed, | |
93 * rather than carrying additional fractional bits into subsequent additions. | |
94 * This compromises accuracy slightly, but it lets us save a few shifts. | |
95 * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) | |
96 * everywhere except in the multiplications proper; this saves a good deal | |
97 * of work on 16-bit-int machines. | |
98 * | |
99 * Again to save a few shifts, the intermediate results between pass 1 and | |
100 * pass 2 are not upscaled, but are represented only to integral precision. | |
101 * | |
102 * A final compromise is to represent the multiplicative constants to only | |
103 * 8 fractional bits, rather than 13. This saves some shifting work on some | |
104 * machines, and may also reduce the cost of multiplication (since there | |
105 * are fewer one-bits in the constants). | |
106 */ | |
107 | |
108 #define CONST_BITS 8 | |
109 | |
110 | |
111 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus | |
112 * causing a lot of useless floating-point operations at run time. | |
113 * To get around this we use the following pre-calculated constants. | |
114 * If you change CONST_BITS you may want to add appropriate values. | |
115 * (With a reasonable C compiler, you can just rely on the FIX() macro...) | |
116 */ | |
117 | |
118 #if CONST_BITS == 8 | |
2979 | 119 #define FIX_0_382683433 ((int32_t) 98) /* FIX(0.382683433) */ |
120 #define FIX_0_541196100 ((int32_t) 139) /* FIX(0.541196100) */ | |
121 #define FIX_0_707106781 ((int32_t) 181) /* FIX(0.707106781) */ | |
122 #define FIX_1_306562965 ((int32_t) 334) /* FIX(1.306562965) */ | |
0 | 123 #else |
124 #define FIX_0_382683433 FIX(0.382683433) | |
125 #define FIX_0_541196100 FIX(0.541196100) | |
126 #define FIX_0_707106781 FIX(0.707106781) | |
127 #define FIX_1_306562965 FIX(1.306562965) | |
128 #endif | |
129 | |
130 | |
131 /* We can gain a little more speed, with a further compromise in accuracy, | |
132 * by omitting the addition in a descaling shift. This yields an incorrectly | |
133 * rounded result half the time... | |
134 */ | |
135 | |
136 #ifndef USE_ACCURATE_ROUNDING | |
137 #undef DESCALE | |
138 #define DESCALE(x,n) RIGHT_SHIFT(x, n) | |
139 #endif | |
140 | |
141 | |
1064 | 142 /* Multiply a DCTELEM variable by an int32_t constant, and immediately |
0 | 143 * descale to yield a DCTELEM result. |
144 */ | |
145 | |
146 #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) | |
147 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
3669
diff
changeset
|
148 static av_always_inline void row_fdct(DCTELEM * data){ |
1589 | 149 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
150 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
151 int_fast16_t z1, z2, z3, z4, z5, z11, z13; | |
0 | 152 DCTELEM *dataptr; |
153 int ctr; | |
154 SHIFT_TEMPS | |
155 | |
156 /* Pass 1: process rows. */ | |
157 | |
158 dataptr = data; | |
159 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | |
160 tmp0 = dataptr[0] + dataptr[7]; | |
161 tmp7 = dataptr[0] - dataptr[7]; | |
162 tmp1 = dataptr[1] + dataptr[6]; | |
163 tmp6 = dataptr[1] - dataptr[6]; | |
164 tmp2 = dataptr[2] + dataptr[5]; | |
165 tmp5 = dataptr[2] - dataptr[5]; | |
166 tmp3 = dataptr[3] + dataptr[4]; | |
167 tmp4 = dataptr[3] - dataptr[4]; | |
2967 | 168 |
0 | 169 /* Even part */ |
2967 | 170 |
2979 | 171 tmp10 = tmp0 + tmp3; /* phase 2 */ |
0 | 172 tmp13 = tmp0 - tmp3; |
173 tmp11 = tmp1 + tmp2; | |
174 tmp12 = tmp1 - tmp2; | |
2967 | 175 |
0 | 176 dataptr[0] = tmp10 + tmp11; /* phase 3 */ |
177 dataptr[4] = tmp10 - tmp11; | |
2967 | 178 |
0 | 179 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
2979 | 180 dataptr[2] = tmp13 + z1; /* phase 5 */ |
0 | 181 dataptr[6] = tmp13 - z1; |
2967 | 182 |
0 | 183 /* Odd part */ |
184 | |
2979 | 185 tmp10 = tmp4 + tmp5; /* phase 2 */ |
0 | 186 tmp11 = tmp5 + tmp6; |
187 tmp12 = tmp6 + tmp7; | |
188 | |
189 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | |
190 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | |
2979 | 191 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ |
192 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | |
193 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | |
0 | 194 |
2979 | 195 z11 = tmp7 + z3; /* phase 5 */ |
0 | 196 z13 = tmp7 - z3; |
197 | |
2979 | 198 dataptr[5] = z13 + z2; /* phase 6 */ |
0 | 199 dataptr[3] = z13 - z2; |
200 dataptr[1] = z11 + z4; | |
201 dataptr[7] = z11 - z4; | |
202 | |
2979 | 203 dataptr += DCTSIZE; /* advance pointer to next row */ |
0 | 204 } |
1589 | 205 } |
0 | 206 |
1589 | 207 /* |
208 * Perform the forward DCT on one block of samples. | |
209 */ | |
210 | |
211 GLOBAL(void) | |
212 fdct_ifast (DCTELEM * data) | |
213 { | |
214 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; | |
215 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
216 int_fast16_t z1, z2, z3, z4, z5, z11, z13; | |
217 DCTELEM *dataptr; | |
218 int ctr; | |
219 SHIFT_TEMPS | |
220 | |
221 row_fdct(data); | |
2967 | 222 |
0 | 223 /* Pass 2: process columns. */ |
224 | |
225 dataptr = data; | |
226 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | |
227 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; | |
228 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; | |
229 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; | |
230 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; | |
231 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; | |
232 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; | |
233 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; | |
234 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; | |
2967 | 235 |
0 | 236 /* Even part */ |
2967 | 237 |
2979 | 238 tmp10 = tmp0 + tmp3; /* phase 2 */ |
0 | 239 tmp13 = tmp0 - tmp3; |
240 tmp11 = tmp1 + tmp2; | |
241 tmp12 = tmp1 - tmp2; | |
2967 | 242 |
0 | 243 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ |
244 dataptr[DCTSIZE*4] = tmp10 - tmp11; | |
2967 | 245 |
0 | 246 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
247 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ | |
248 dataptr[DCTSIZE*6] = tmp13 - z1; | |
2967 | 249 |
0 | 250 /* Odd part */ |
251 | |
2979 | 252 tmp10 = tmp4 + tmp5; /* phase 2 */ |
0 | 253 tmp11 = tmp5 + tmp6; |
254 tmp12 = tmp6 + tmp7; | |
255 | |
256 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | |
257 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | |
258 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ | |
259 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | |
260 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | |
261 | |
2979 | 262 z11 = tmp7 + z3; /* phase 5 */ |
0 | 263 z13 = tmp7 - z3; |
264 | |
265 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ | |
266 dataptr[DCTSIZE*3] = z13 - z2; | |
267 dataptr[DCTSIZE*1] = z11 + z4; | |
268 dataptr[DCTSIZE*7] = z11 - z4; | |
269 | |
2979 | 270 dataptr++; /* advance pointer to next column */ |
0 | 271 } |
272 } | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
273 |
1571
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 * 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
|
276 */ |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
277 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
278 GLOBAL(void) |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
279 fdct_ifast248 (DCTELEM * data) |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
280 { |
1589 | 281 int_fast16_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
282 int_fast16_t tmp10, tmp11, tmp12, tmp13; | |
283 int_fast16_t z1; | |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
284 DCTELEM *dataptr; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
285 int ctr; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
286 SHIFT_TEMPS |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
287 |
1589 | 288 row_fdct(data); |
2967 | 289 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
290 /* Pass 2: process columns. */ |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
291 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
292 dataptr = data; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
293 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
294 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*1]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
295 tmp1 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
296 tmp2 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
297 tmp3 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
298 tmp4 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*1]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
299 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
300 tmp6 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
301 tmp7 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7]; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
302 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
303 /* Even part */ |
2967 | 304 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
305 tmp10 = tmp0 + tmp3; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
306 tmp11 = tmp1 + tmp2; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
307 tmp12 = tmp1 - tmp2; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
308 tmp13 = tmp0 - tmp3; |
2967 | 309 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
310 dataptr[DCTSIZE*0] = tmp10 + tmp11; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
311 dataptr[DCTSIZE*4] = tmp10 - tmp11; |
2967 | 312 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
313 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
314 dataptr[DCTSIZE*2] = tmp13 + z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
315 dataptr[DCTSIZE*6] = tmp13 - z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
316 |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
317 tmp10 = tmp4 + tmp7; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
318 tmp11 = tmp5 + tmp6; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
319 tmp12 = tmp5 - tmp6; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
320 tmp13 = tmp4 - tmp7; |
2967 | 321 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
322 dataptr[DCTSIZE*1] = tmp10 + tmp11; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
323 dataptr[DCTSIZE*5] = tmp10 - tmp11; |
2967 | 324 |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
325 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
326 dataptr[DCTSIZE*3] = tmp13 + z1; |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
327 dataptr[DCTSIZE*7] = tmp13 - z1; |
2967 | 328 |
2979 | 329 dataptr++; /* advance pointer to next column */ |
1571
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
330 } |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
331 } |
aa4dc16c0f18
* adding integer/floating point AAN implementations for DCT 2-4-8
romansh
parents:
1106
diff
changeset
|
332 |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
333 |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
334 #undef GLOBAL |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
335 #undef CONST_BITS |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
336 #undef DESCALE |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
337 #undef FIX_0_541196100 |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
0
diff
changeset
|
338 #undef FIX_1_306562965 |