diff options
author | Sean Bartell <wingedtachikoma@gmail.com> | 2011-06-25 21:32:25 -0400 |
---|---|---|
committer | Nils Wallménius <nils@rockbox.org> | 2012-04-25 22:13:20 +0200 |
commit | f40bfc9267b13b54e6379dfe7539447662879d24 (patch) | |
tree | 9b20069d5e62809ff434061ad730096836f916f2 /apps/codecs/lib | |
parent | a0009907de7a0107d49040d8a180f140e2eff299 (diff) | |
download | rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.tar.gz rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.zip |
Add codecs to librbcodec.
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97
Reviewed-on: http://gerrit.rockbox.org/137
Reviewed-by: Nils Wallménius <nils@rockbox.org>
Tested-by: Nils Wallménius <nils@rockbox.org>
Diffstat (limited to 'apps/codecs/lib')
-rw-r--r-- | apps/codecs/lib/SOURCES | 12 | ||||
-rw-r--r-- | apps/codecs/lib/asm_arm.h | 292 | ||||
-rw-r--r-- | apps/codecs/lib/asm_mcf5249.h | 353 | ||||
-rw-r--r-- | apps/codecs/lib/codeclib.c | 182 | ||||
-rw-r--r-- | apps/codecs/lib/codeclib.h | 163 | ||||
-rw-r--r-- | apps/codecs/lib/codeclib_misc.h | 310 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_bitstream.c | 374 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_bswap.h | 150 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_get_bits.h | 743 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_intreadwrite.h | 484 | ||||
-rw-r--r-- | apps/codecs/lib/ffmpeg_put_bits.h | 323 | ||||
-rw-r--r-- | apps/codecs/lib/fft-ffmpeg.c | 473 | ||||
-rw-r--r-- | apps/codecs/lib/fft-ffmpeg_arm.h | 456 | ||||
-rw-r--r-- | apps/codecs/lib/fft-ffmpeg_cf.h | 370 | ||||
-rw-r--r-- | apps/codecs/lib/fft.h | 64 | ||||
-rw-r--r-- | apps/codecs/lib/fixedpoint.c | 1 | ||||
-rw-r--r-- | apps/codecs/lib/fixedpoint.h | 49 | ||||
-rw-r--r-- | apps/codecs/lib/libcodec.make | 37 | ||||
-rw-r--r-- | apps/codecs/lib/mdct.c | 644 | ||||
-rw-r--r-- | apps/codecs/lib/mdct.h | 139 | ||||
-rw-r--r-- | apps/codecs/lib/mdct_lookup.c | 872 | ||||
-rw-r--r-- | apps/codecs/lib/mdct_lookup.h | 24 | ||||
-rw-r--r-- | apps/codecs/lib/osx.dummy.c | 0 |
23 files changed, 0 insertions, 6515 deletions
diff --git a/apps/codecs/lib/SOURCES b/apps/codecs/lib/SOURCES deleted file mode 100644 index 257dcb5838..0000000000 --- a/apps/codecs/lib/SOURCES +++ /dev/null | |||
@@ -1,12 +0,0 @@ | |||
1 | #if CONFIG_CODEC == SWCODEC /* software codec platforms */ | ||
2 | codeclib.c | ||
3 | fixedpoint.c | ||
4 | ffmpeg_bitstream.c | ||
5 | |||
6 | mdct_lookup.c | ||
7 | fft-ffmpeg.c | ||
8 | mdct.c | ||
9 | |||
10 | #elif (CONFIG_PLATFORM & PLATFORM_HOSTED) && defined(__APPLE__) | ||
11 | osx.dummy.c | ||
12 | #endif | ||
diff --git a/apps/codecs/lib/asm_arm.h b/apps/codecs/lib/asm_arm.h deleted file mode 100644 index 8e5d0e68df..0000000000 --- a/apps/codecs/lib/asm_arm.h +++ /dev/null | |||
@@ -1,292 +0,0 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: arm7 and later wide math functions | ||
15 | |||
16 | ********************************************************************/ | ||
17 | #ifdef CPU_ARM | ||
18 | |||
19 | #define INCL_OPTIMIZED_MULT32 | ||
20 | #if ARM_ARCH >= 6 | ||
21 | static inline int32_t MULT32(int32_t x, int32_t y) { | ||
22 | int32_t hi; | ||
23 | asm volatile("smmul %[hi], %[x], %[y] \n\t" | ||
24 | : [hi] "=&r" (hi) | ||
25 | : [x] "r" (x), [y] "r" (y) ); | ||
26 | return(hi); | ||
27 | } | ||
28 | #else | ||
29 | static inline int32_t MULT32(int32_t x, int32_t y) { | ||
30 | int32_t lo, hi; | ||
31 | asm volatile("smull\t%0, %1, %2, %3 \n\t" | ||
32 | : "=&r"(lo),"=&r"(hi) | ||
33 | : "r"(x),"r"(y) ); | ||
34 | return(hi); | ||
35 | } | ||
36 | #endif | ||
37 | |||
38 | #define INCL_OPTIMIZED_MULT31 | ||
39 | static inline int32_t MULT31(int32_t x, int32_t y) { | ||
40 | return MULT32(x,y)<<1; | ||
41 | } | ||
42 | |||
43 | #define INCL_OPTIMIZED_MULT31_SHIFT15 | ||
44 | static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) { | ||
45 | int32_t lo,hi; | ||
46 | asm volatile("smull %0, %1, %2, %3\n\t" | ||
47 | "movs %0, %0, lsr #15\n\t" | ||
48 | "adc %1, %0, %1, lsl #17\n\t" | ||
49 | : "=&r"(lo),"=&r"(hi) | ||
50 | : "r"(x),"r"(y) | ||
51 | : "cc" ); | ||
52 | return(hi); | ||
53 | } | ||
54 | |||
55 | #define INCL_OPTIMIZED_MULT31_SHIFT16 | ||
56 | static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) { | ||
57 | int32_t lo,hi; | ||
58 | asm volatile("smull %0, %1, %2, %3\n\t" | ||
59 | "movs %0, %0, lsr #16\n\t" | ||
60 | "adc %1, %0, %1, lsl #16\n\t" | ||
61 | : "=&r"(lo),"=&r"(hi) | ||
62 | : "r"(x),"r"(y) | ||
63 | : "cc" ); | ||
64 | return(hi); | ||
65 | } | ||
66 | |||
67 | #define INCL_OPTIMIZED_XPROD32 | ||
68 | #define XPROD32(a, b, t, v, x, y) \ | ||
69 | { \ | ||
70 | int32_t l; \ | ||
71 | asm("smull %0, %1, %3, %5\n\t" \ | ||
72 | "rsb %2, %6, #0\n\t" \ | ||
73 | "smlal %0, %1, %4, %6\n\t" \ | ||
74 | "smull %0, %2, %3, %2\n\t" \ | ||
75 | "smlal %0, %2, %4, %5" \ | ||
76 | : "=&r" (l), "=&r" (x), "=&r" (y) \ | ||
77 | : "r" ((a)), "r" ((b)), "r" ((t)), "r" ((v)) ); \ | ||
78 | } | ||
79 | |||
80 | #define INCL_OPTIMIZED_XPROD31_R | ||
81 | #define INCL_OPTIMIZED_XNPROD31_R | ||
82 | #if ARM_ARCH >= 6 | ||
83 | /* These may yield slightly different result from the macros below | ||
84 | because only the high 32 bits of the multiplications are accumulated while | ||
85 | the below macros use a 64 bit accumulator that is truncated to 32 bits.*/ | ||
86 | #define XPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
87 | {\ | ||
88 | int32_t x1, y1;\ | ||
89 | asm("smmul %[x1], %[t], %[a] \n\t"\ | ||
90 | "smmul %[y1], %[t], %[b] \n\t"\ | ||
91 | "smmla %[x1], %[v], %[b], %[x1] \n\t"\ | ||
92 | "smmls %[y1], %[v], %[a], %[y1] \n\t"\ | ||
93 | : [x1] "=&r" (x1), [y1] "=&r" (y1)\ | ||
94 | : [a] "r" (_a), [b] "r" (_b), [t] "r" (_t), [v] "r" (_v) );\ | ||
95 | _x = x1 << 1;\ | ||
96 | _y = y1 << 1;\ | ||
97 | } | ||
98 | |||
99 | #define XNPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
100 | {\ | ||
101 | int32_t x1, y1;\ | ||
102 | asm("smmul %[x1], %[t], %[a] \n\t"\ | ||
103 | "smmul %[y1], %[t], %[b] \n\t"\ | ||
104 | "smmls %[x1], %[v], %[b], %[x1] \n\t"\ | ||
105 | "smmla %[y1], %[v], %[a], %[y1] \n\t"\ | ||
106 | : [x1] "=&r" (x1), [y1] "=&r" (y1)\ | ||
107 | : [a] "r" (_a), [b] "r" (_b), [t] "r" (_t), [v] "r" (_v) );\ | ||
108 | _x = x1 << 1;\ | ||
109 | _y = y1 << 1;\ | ||
110 | } | ||
111 | #else | ||
112 | #define XPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
113 | {\ | ||
114 | int32_t x1, y1, l;\ | ||
115 | asm("smull %0, %1, %5, %3\n\t"\ | ||
116 | "rsb %2, %3, #0\n\t"\ | ||
117 | "smlal %0, %1, %6, %4\n\t"\ | ||
118 | "smull %0, %2, %6, %2\n\t"\ | ||
119 | "smlal %0, %2, %5, %4"\ | ||
120 | : "=&r" (l), "=&r" (x1), "=&r" (y1)\ | ||
121 | : "r" (_a), "r" (_b), "r" (_t), "r" (_v) );\ | ||
122 | _x = x1 << 1;\ | ||
123 | _y = y1 << 1;\ | ||
124 | } | ||
125 | |||
126 | #define XNPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
127 | {\ | ||
128 | int32_t x1, y1, l;\ | ||
129 | asm("smull %0, %1, %5, %3\n\t"\ | ||
130 | "rsb %2, %4, #0\n\t"\ | ||
131 | "smlal %0, %1, %6, %2\n\t"\ | ||
132 | "smull %0, %2, %5, %4\n\t"\ | ||
133 | "smlal %0, %2, %6, %3"\ | ||
134 | : "=&r" (l), "=&r" (x1), "=&r" (y1)\ | ||
135 | : "r" (_a), "r" (_b), "r" (_t), "r" (_v) );\ | ||
136 | _x = x1 << 1;\ | ||
137 | _y = y1 << 1;\ | ||
138 | } | ||
139 | #endif | ||
140 | |||
141 | #define INCL_OPTIMIZED_XPROD31 | ||
142 | static inline void XPROD31(int32_t a, int32_t b, | ||
143 | int32_t t, int32_t v, | ||
144 | int32_t *x, int32_t *y) | ||
145 | { | ||
146 | int32_t _x1, _y1; | ||
147 | XPROD31_R(a, b, t, v, _x1, _y1); | ||
148 | *x = _x1; | ||
149 | *y = _y1; | ||
150 | } | ||
151 | |||
152 | #define INCL_OPTIMIZED_XNPROD31 | ||
153 | static inline void XNPROD31(int32_t a, int32_t b, | ||
154 | int32_t t, int32_t v, | ||
155 | int32_t *x, int32_t *y) | ||
156 | { | ||
157 | int32_t _x1, _y1; | ||
158 | XNPROD31_R(a, b, t, v, _x1, _y1); | ||
159 | *x = _x1; | ||
160 | *y = _y1; | ||
161 | } | ||
162 | |||
163 | |||
164 | #ifndef _V_VECT_OPS | ||
165 | #define _V_VECT_OPS | ||
166 | |||
167 | /* asm versions of vector operations for block.c, window.c */ | ||
168 | static inline | ||
169 | void vect_add(int32_t *x, const int32_t *y, int n) | ||
170 | { | ||
171 | while (n>=4) { | ||
172 | asm volatile ("ldmia %[x], {r0, r1, r2, r3};" | ||
173 | "ldmia %[y]!, {r4, r5, r6, r7};" | ||
174 | "add r0, r0, r4;" | ||
175 | "add r1, r1, r5;" | ||
176 | "add r2, r2, r6;" | ||
177 | "add r3, r3, r7;" | ||
178 | "stmia %[x]!, {r0, r1, r2, r3};" | ||
179 | : [x] "+r" (x), [y] "+r" (y) | ||
180 | : : "r0", "r1", "r2", "r3", | ||
181 | "r4", "r5", "r6", "r7", | ||
182 | "memory"); | ||
183 | n -= 4; | ||
184 | } | ||
185 | /* add final elements */ | ||
186 | while (n>0) { | ||
187 | *x++ += *y++; | ||
188 | n--; | ||
189 | } | ||
190 | } | ||
191 | |||
192 | static inline | ||
193 | void vect_copy(int32_t *x, const int32_t *y, int n) | ||
194 | { | ||
195 | while (n>=4) { | ||
196 | asm volatile ("ldmia %[y]!, {r0, r1, r2, r3};" | ||
197 | "stmia %[x]!, {r0, r1, r2, r3};" | ||
198 | : [x] "+r" (x), [y] "+r" (y) | ||
199 | : : "r0", "r1", "r2", "r3", | ||
200 | "memory"); | ||
201 | n -= 4; | ||
202 | } | ||
203 | /* copy final elements */ | ||
204 | while (n>0) { | ||
205 | *x++ = *y++; | ||
206 | n--; | ||
207 | } | ||
208 | } | ||
209 | |||
210 | static inline | ||
211 | void vect_mult_fw(int32_t *data, const int32_t *window, int n) | ||
212 | { | ||
213 | while (n>=4) { | ||
214 | asm volatile ("ldmia %[d], {r0, r1, r2, r3};" | ||
215 | "ldmia %[w]!, {r4, r5, r6, r7};" | ||
216 | "smull r8, r9, r0, r4;" | ||
217 | "mov r0, r9, lsl #1;" | ||
218 | "smull r8, r9, r1, r5;" | ||
219 | "mov r1, r9, lsl #1;" | ||
220 | "smull r8, r9, r2, r6;" | ||
221 | "mov r2, r9, lsl #1;" | ||
222 | "smull r8, r9, r3, r7;" | ||
223 | "mov r3, r9, lsl #1;" | ||
224 | "stmia %[d]!, {r0, r1, r2, r3};" | ||
225 | : [d] "+r" (data), [w] "+r" (window) | ||
226 | : : "r0", "r1", "r2", "r3", | ||
227 | "r4", "r5", "r6", "r7", "r8", "r9", | ||
228 | "memory" ); | ||
229 | n -= 4; | ||
230 | } | ||
231 | while(n>0) { | ||
232 | *data = MULT31(*data, *window); | ||
233 | data++; | ||
234 | window++; | ||
235 | n--; | ||
236 | } | ||
237 | } | ||
238 | |||
239 | static inline | ||
240 | void vect_mult_bw(int32_t *data, const int32_t *window, int n) | ||
241 | { | ||
242 | while (n>=4) { | ||
243 | asm volatile ("ldmia %[d], {r0, r1, r2, r3};" | ||
244 | "ldmda %[w]!, {r4, r5, r6, r7};" | ||
245 | "smull r8, r9, r0, r7;" | ||
246 | "mov r0, r9, lsl #1;" | ||
247 | "smull r8, r9, r1, r6;" | ||
248 | "mov r1, r9, lsl #1;" | ||
249 | "smull r8, r9, r2, r5;" | ||
250 | "mov r2, r9, lsl #1;" | ||
251 | "smull r8, r9, r3, r4;" | ||
252 | "mov r3, r9, lsl #1;" | ||
253 | "stmia %[d]!, {r0, r1, r2, r3};" | ||
254 | : [d] "+r" (data), [w] "+r" (window) | ||
255 | : : "r0", "r1", "r2", "r3", | ||
256 | "r4", "r5", "r6", "r7", "r8", "r9", | ||
257 | "memory" ); | ||
258 | n -= 4; | ||
259 | } | ||
260 | while(n>0) { | ||
261 | *data = MULT31(*data, *window); | ||
262 | data++; | ||
263 | window--; | ||
264 | n--; | ||
265 | } | ||
266 | } | ||
267 | |||
268 | #endif | ||
269 | |||
270 | /* not used anymore */ | ||
271 | /* | ||
272 | #ifndef _V_CLIP_MATH | ||
273 | #define _V_CLIP_MATH | ||
274 | |||
275 | static inline int32_t CLIP_TO_15(int32_t x) { | ||
276 | int tmp; | ||
277 | asm volatile("subs %1, %0, #32768\n\t" | ||
278 | "movpl %0, #0x7f00\n\t" | ||
279 | "orrpl %0, %0, #0xff\n" | ||
280 | "adds %1, %0, #32768\n\t" | ||
281 | "movmi %0, #0x8000" | ||
282 | : "+r"(x),"=r"(tmp) | ||
283 | : | ||
284 | : "cc"); | ||
285 | return(x); | ||
286 | } | ||
287 | |||
288 | #endif | ||
289 | */ | ||
290 | |||
291 | #endif | ||
292 | |||
diff --git a/apps/codecs/lib/asm_mcf5249.h b/apps/codecs/lib/asm_mcf5249.h deleted file mode 100644 index 841c413a94..0000000000 --- a/apps/codecs/lib/asm_mcf5249.h +++ /dev/null | |||
@@ -1,353 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * | ||
9 | * Copyright (C) 2005 by Pedro Vasconcelos | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU General Public License | ||
13 | * as published by the Free Software Foundation; either version 2 | ||
14 | * of the License, or (at your option) any later version. | ||
15 | * | ||
16 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
17 | * KIND, either express or implied. | ||
18 | * | ||
19 | ****************************************************************************/ | ||
20 | /* asm routines for wide math on the MCF5249 */ | ||
21 | |||
22 | #if defined(CPU_COLDFIRE) | ||
23 | |||
24 | #define INCL_OPTIMIZED_MULT32 | ||
25 | static inline int32_t MULT32(int32_t x, int32_t y) { | ||
26 | |||
27 | asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply & shift */ | ||
28 | "movclr.l %%acc0, %[x];" /* move & clear acc */ | ||
29 | "asr.l #1, %[x];" /* no overflow test */ | ||
30 | : [x] "+&d" (x) | ||
31 | : [y] "r" (y) | ||
32 | : "cc"); | ||
33 | return x; | ||
34 | } | ||
35 | |||
36 | #define INCL_OPTIMIZED_MULT31 | ||
37 | static inline int32_t MULT31(int32_t x, int32_t y) { | ||
38 | asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */ | ||
39 | "movclr.l %%acc0, %[x];" /* move and clear */ | ||
40 | : [x] "+&r" (x) | ||
41 | : [y] "r" (y) | ||
42 | : "cc"); | ||
43 | return x; | ||
44 | } | ||
45 | |||
46 | #define INCL_OPTIMIZED_MULT31_SHIFT15 | ||
47 | /* NOTE: this requires that the emac is *NOT* rounding */ | ||
48 | static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) { | ||
49 | int32_t r; | ||
50 | |||
51 | asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */ | ||
52 | "mulu.l %[y], %[x];" /* get lower half, avoid emac stall */ | ||
53 | "movclr.l %%acc0, %[r];" /* get higher half */ | ||
54 | "swap %[r];" /* hi<<16, plus one free */ | ||
55 | "lsr.l #8, %[x];" /* (unsigned)lo >> 15 */ | ||
56 | "lsr.l #7, %[x];" | ||
57 | "move.w %[x], %[r];" /* logical-or results */ | ||
58 | : [r] "=&d" (r), [x] "+d" (x) | ||
59 | : [y] "d" (y) | ||
60 | : "cc"); | ||
61 | return r; | ||
62 | } | ||
63 | |||
64 | #define INCL_OPTIMIZED_MULT31_SHIFT16 | ||
65 | static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) { | ||
66 | int32_t r; | ||
67 | |||
68 | asm volatile ("mac.l %[x], %[y], %%acc0;" /* multiply */ | ||
69 | "mulu.l %[y], %[x];" /* get lower half, avoid emac stall */ | ||
70 | "movclr.l %%acc0, %[r];" /* get higher half */ | ||
71 | "lsr.l #1, %[r];" /* hi >> 1, to compensate emac shift */ | ||
72 | "move.w %[r], %[x];" /* x = x & 0xffff0000 | r & 0xffff */ | ||
73 | "swap %[x];" /* x = (unsigned)x << 16 | (unsigned)x >> 16 */ | ||
74 | : [r] "=&d" (r), [x] "+d" (x) | ||
75 | : [y] "d" (y) | ||
76 | : "cc"); | ||
77 | return x; | ||
78 | } | ||
79 | |||
80 | #define INCL_OPTIMIZED_XPROD31 | ||
81 | static inline | ||
82 | void XPROD31(int32_t a, int32_t b, | ||
83 | int32_t t, int32_t v, | ||
84 | int32_t *x, int32_t *y) | ||
85 | { | ||
86 | asm volatile ("mac.l %[a], %[t], %%acc0;" | ||
87 | "mac.l %[b], %[v], %%acc0;" | ||
88 | "mac.l %[b], %[t], %%acc1;" | ||
89 | "msac.l %[a], %[v], %%acc1;" | ||
90 | "movclr.l %%acc0, %[a];" | ||
91 | "move.l %[a], (%[x]);" | ||
92 | "movclr.l %%acc1, %[a];" | ||
93 | "move.l %[a], (%[y]);" | ||
94 | : [a] "+&r" (a) | ||
95 | : [x] "a" (x), [y] "a" (y), | ||
96 | [b] "r" (b), [t] "r" (t), [v] "r" (v) | ||
97 | : "cc", "memory"); | ||
98 | } | ||
99 | |||
100 | #define INCL_OPTIMIZED_XNPROD31 | ||
101 | static inline | ||
102 | void XNPROD31(int32_t a, int32_t b, | ||
103 | int32_t t, int32_t v, | ||
104 | int32_t *x, int32_t *y) | ||
105 | { | ||
106 | asm volatile ("mac.l %[a], %[t], %%acc0;" | ||
107 | "msac.l %[b], %[v], %%acc0;" | ||
108 | "mac.l %[b], %[t], %%acc1;" | ||
109 | "mac.l %[a], %[v], %%acc1;" | ||
110 | "movclr.l %%acc0, %[a];" | ||
111 | "move.l %[a], (%[x]);" | ||
112 | "movclr.l %%acc1, %[a];" | ||
113 | "move.l %[a], (%[y]);" | ||
114 | : [a] "+&r" (a) | ||
115 | : [x] "a" (x), [y] "a" (y), | ||
116 | [b] "r" (b), [t] "r" (t), [v] "r" (v) | ||
117 | : "cc", "memory"); | ||
118 | } | ||
119 | |||
120 | |||
121 | /* this could lose the LSB by overflow, but i don't think it'll ever happen. | ||
122 | if anyone think they can hear a bug caused by this, please try the above | ||
123 | version. */ | ||
124 | #define INCL_OPTIMIZED_XPROD32 | ||
125 | #define XPROD32(_a, _b, _t, _v, _x, _y) \ | ||
126 | asm volatile ("mac.l %[a], %[t], %%acc0;" \ | ||
127 | "mac.l %[b], %[v], %%acc0;" \ | ||
128 | "mac.l %[b], %[t], %%acc1;" \ | ||
129 | "msac.l %[a], %[v], %%acc1;" \ | ||
130 | "movclr.l %%acc0, %[x];" \ | ||
131 | "asr.l #1, %[x];" \ | ||
132 | "movclr.l %%acc1, %[y];" \ | ||
133 | "asr.l #1, %[y];" \ | ||
134 | : [x] "=d" (_x), [y] "=d" (_y) \ | ||
135 | : [a] "r" (_a), [b] "r" (_b), \ | ||
136 | [t] "r" (_t), [v] "r" (_v) \ | ||
137 | : "cc"); | ||
138 | |||
139 | #define INCL_OPTIMIZED_XPROD31_R | ||
140 | #define XPROD31_R(_a, _b, _t, _v, _x, _y) \ | ||
141 | asm volatile ("mac.l %[a], %[t], %%acc0;" \ | ||
142 | "mac.l %[b], %[v], %%acc0;" \ | ||
143 | "mac.l %[b], %[t], %%acc1;" \ | ||
144 | "msac.l %[a], %[v], %%acc1;" \ | ||
145 | "movclr.l %%acc0, %[x];" \ | ||
146 | "movclr.l %%acc1, %[y];" \ | ||
147 | : [x] "=r" (_x), [y] "=r" (_y) \ | ||
148 | : [a] "r" (_a), [b] "r" (_b), \ | ||
149 | [t] "r" (_t), [v] "r" (_v) \ | ||
150 | : "cc"); | ||
151 | |||
152 | #define INCL_OPTIMIZED_XNPROD31_R | ||
153 | #define XNPROD31_R(_a, _b, _t, _v, _x, _y) \ | ||
154 | asm volatile ("mac.l %[a], %[t], %%acc0;" \ | ||
155 | "msac.l %[b], %[v], %%acc0;" \ | ||
156 | "mac.l %[b], %[t], %%acc1;" \ | ||
157 | "mac.l %[a], %[v], %%acc1;" \ | ||
158 | "movclr.l %%acc0, %[x];" \ | ||
159 | "movclr.l %%acc1, %[y];" \ | ||
160 | : [x] "=r" (_x), [y] "=r" (_y) \ | ||
161 | : [a] "r" (_a), [b] "r" (_b), \ | ||
162 | [t] "r" (_t), [v] "r" (_v) \ | ||
163 | : "cc"); | ||
164 | |||
165 | #ifndef _V_VECT_OPS | ||
166 | #define _V_VECT_OPS | ||
167 | |||
168 | /* asm versions of vector operations for block.c, window.c */ | ||
169 | /* assumes MAC is initialized & accumulators cleared */ | ||
170 | static inline | ||
171 | void vect_add(int32_t *x, const int32_t *y, int n) | ||
172 | { | ||
173 | /* align to 16 bytes */ | ||
174 | while(n>0 && (int)x&15) { | ||
175 | *x++ += *y++; | ||
176 | n--; | ||
177 | } | ||
178 | asm volatile ("bra 1f;" | ||
179 | "0:" /* loop start */ | ||
180 | "movem.l (%[x]), %%d0-%%d3;" /* fetch values */ | ||
181 | "movem.l (%[y]), %%a0-%%a3;" | ||
182 | /* add */ | ||
183 | "add.l %%a0, %%d0;" | ||
184 | "add.l %%a1, %%d1;" | ||
185 | "add.l %%a2, %%d2;" | ||
186 | "add.l %%a3, %%d3;" | ||
187 | /* store and advance */ | ||
188 | "movem.l %%d0-%%d3, (%[x]);" | ||
189 | "lea.l (4*4, %[x]), %[x];" | ||
190 | "lea.l (4*4, %[y]), %[y];" | ||
191 | "subq.l #4, %[n];" /* done 4 elements */ | ||
192 | "1: cmpi.l #4, %[n];" | ||
193 | "bge 0b;" | ||
194 | : [n] "+d" (n), [x] "+a" (x), [y] "+a" (y) | ||
195 | : : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3", | ||
196 | "cc", "memory"); | ||
197 | /* add final elements */ | ||
198 | while (n>0) { | ||
199 | *x++ += *y++; | ||
200 | n--; | ||
201 | } | ||
202 | } | ||
203 | |||
204 | static inline | ||
205 | void vect_copy(int32_t *x, const int32_t *y, int n) | ||
206 | { | ||
207 | /* align to 16 bytes */ | ||
208 | while(n>0 && (int)x&15) { | ||
209 | *x++ = *y++; | ||
210 | n--; | ||
211 | } | ||
212 | asm volatile ("bra 1f;" | ||
213 | "0:" /* loop start */ | ||
214 | "movem.l (%[y]), %%d0-%%d3;" /* fetch values */ | ||
215 | "movem.l %%d0-%%d3, (%[x]);" /* store */ | ||
216 | "lea.l (4*4, %[x]), %[x];" /* advance */ | ||
217 | "lea.l (4*4, %[y]), %[y];" | ||
218 | "subq.l #4, %[n];" /* done 4 elements */ | ||
219 | "1: cmpi.l #4, %[n];" | ||
220 | "bge 0b;" | ||
221 | : [n] "+d" (n), [x] "+a" (x), [y] "+a" (y) | ||
222 | : : "%d0", "%d1", "%d2", "%d3", "cc", "memory"); | ||
223 | /* copy final elements */ | ||
224 | while (n>0) { | ||
225 | *x++ = *y++; | ||
226 | n--; | ||
227 | } | ||
228 | } | ||
229 | |||
230 | static inline | ||
231 | void vect_mult_fw(int32_t *data, const int32_t *window, int n) | ||
232 | { | ||
233 | /* ensure data is aligned to 16-bytes */ | ||
234 | while(n>0 && (int)data&15) { | ||
235 | *data = MULT31(*data, *window); | ||
236 | data++; | ||
237 | window++; | ||
238 | n--; | ||
239 | } | ||
240 | asm volatile ("movem.l (%[d]), %%d0-%%d3;" /* loop start */ | ||
241 | "movem.l (%[w]), %%a0-%%a3;" /* pre-fetch registers */ | ||
242 | "lea.l (4*4, %[w]), %[w];" | ||
243 | "bra 1f;" /* jump to loop condition */ | ||
244 | "0:" /* loop body */ | ||
245 | /* multiply and load next window values */ | ||
246 | "mac.l %%d0, %%a0, (%[w])+, %%a0, %%acc0;" | ||
247 | "mac.l %%d1, %%a1, (%[w])+, %%a1, %%acc1;" | ||
248 | "mac.l %%d2, %%a2, (%[w])+, %%a2, %%acc2;" | ||
249 | "mac.l %%d3, %%a3, (%[w])+, %%a3, %%acc3;" | ||
250 | "movclr.l %%acc0, %%d0;" /* get the products */ | ||
251 | "movclr.l %%acc1, %%d1;" | ||
252 | "movclr.l %%acc2, %%d2;" | ||
253 | "movclr.l %%acc3, %%d3;" | ||
254 | /* store and advance */ | ||
255 | "movem.l %%d0-%%d3, (%[d]);" | ||
256 | "lea.l (4*4, %[d]), %[d];" | ||
257 | "movem.l (%[d]), %%d0-%%d3;" | ||
258 | "subq.l #4, %[n];" /* done 4 elements */ | ||
259 | "1: cmpi.l #4, %[n];" | ||
260 | "bge 0b;" | ||
261 | /* multiply final elements */ | ||
262 | "tst.l %[n];" | ||
263 | "beq 1f;" /* n=0 */ | ||
264 | "mac.l %%d0, %%a0, %%acc0;" | ||
265 | "movclr.l %%acc0, %%d0;" | ||
266 | "move.l %%d0, (%[d])+;" | ||
267 | "subq.l #1, %[n];" | ||
268 | "beq 1f;" /* n=1 */ | ||
269 | "mac.l %%d1, %%a1, %%acc0;" | ||
270 | "movclr.l %%acc0, %%d1;" | ||
271 | "move.l %%d1, (%[d])+;" | ||
272 | "subq.l #1, %[n];" | ||
273 | "beq 1f;" /* n=2 */ | ||
274 | /* otherwise n = 3 */ | ||
275 | "mac.l %%d2, %%a2, %%acc0;" | ||
276 | "movclr.l %%acc0, %%d2;" | ||
277 | "move.l %%d2, (%[d])+;" | ||
278 | "1:" | ||
279 | : [n] "+d" (n), [d] "+a" (data), [w] "+a" (window) | ||
280 | : : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3", | ||
281 | "cc", "memory"); | ||
282 | } | ||
283 | |||
284 | static inline | ||
285 | void vect_mult_bw(int32_t *data, const int32_t *window, int n) | ||
286 | { | ||
287 | /* ensure at least data is aligned to 16-bytes */ | ||
288 | while(n>0 && (int)data&15) { | ||
289 | *data = MULT31(*data, *window); | ||
290 | data++; | ||
291 | window--; | ||
292 | n--; | ||
293 | } | ||
294 | asm volatile ("lea.l (-3*4, %[w]), %[w];" /* loop start */ | ||
295 | "movem.l (%[d]), %%d0-%%d3;" /* pre-fetch registers */ | ||
296 | "movem.l (%[w]), %%a0-%%a3;" | ||
297 | "bra 1f;" /* jump to loop condition */ | ||
298 | "0:" /* loop body */ | ||
299 | /* multiply and load next window value */ | ||
300 | "mac.l %%d0, %%a3, -(%[w]), %%a3, %%acc0;" | ||
301 | "mac.l %%d1, %%a2, -(%[w]), %%a2, %%acc1;" | ||
302 | "mac.l %%d2, %%a1, -(%[w]), %%a1, %%acc2;" | ||
303 | "mac.l %%d3, %%a0, -(%[w]), %%a0, %%acc3;" | ||
304 | "movclr.l %%acc0, %%d0;" /* get the products */ | ||
305 | "movclr.l %%acc1, %%d1;" | ||
306 | "movclr.l %%acc2, %%d2;" | ||
307 | "movclr.l %%acc3, %%d3;" | ||
308 | /* store and advance */ | ||
309 | "movem.l %%d0-%%d3, (%[d]);" | ||
310 | "lea.l (4*4, %[d]), %[d];" | ||
311 | "movem.l (%[d]), %%d0-%%d3;" | ||
312 | "subq.l #4, %[n];" /* done 4 elements */ | ||
313 | "1: cmpi.l #4, %[n];" | ||
314 | "bge 0b;" | ||
315 | /* multiply final elements */ | ||
316 | "tst.l %[n];" | ||
317 | "beq 1f;" /* n=0 */ | ||
318 | "mac.l %%d0, %%a3, %%acc0;" | ||
319 | "movclr.l %%acc0, %%d0;" | ||
320 | "move.l %%d0, (%[d])+;" | ||
321 | "subq.l #1, %[n];" | ||
322 | "beq 1f;" /* n=1 */ | ||
323 | "mac.l %%d1, %%a2, %%acc0;" | ||
324 | "movclr.l %%acc0, %%d1;" | ||
325 | "move.l %%d1, (%[d])+;" | ||
326 | "subq.l #1, %[n];" | ||
327 | "beq 1f;" /* n=2 */ | ||
328 | /* otherwise n = 3 */ | ||
329 | "mac.l %%d2, %%a1, %%acc0;" | ||
330 | "movclr.l %%acc0, %%d2;" | ||
331 | "move.l %%d2, (%[d])+;" | ||
332 | "1:" | ||
333 | : [n] "+d" (n), [d] "+a" (data), [w] "+a" (window) | ||
334 | : : "%d0", "%d1", "%d2", "%d3", "%a0", "%a1", "%a2", "%a3", | ||
335 | "cc", "memory"); | ||
336 | } | ||
337 | |||
338 | #endif | ||
339 | |||
340 | /* not used anymore */ | ||
341 | /* | ||
342 | #ifndef _V_CLIP_MATH | ||
343 | #define _V_CLIP_MATH | ||
344 | |||
345 | * this is portable C and simple; why not use this as default? | ||
346 | static inline int32_t CLIP_TO_15(register int32_t x) { | ||
347 | register int32_t hi=32767, lo=-32768; | ||
348 | return (x>=hi ? hi : (x<=lo ? lo : x)); | ||
349 | } | ||
350 | |||
351 | #endif | ||
352 | */ | ||
353 | #endif | ||
diff --git a/apps/codecs/lib/codeclib.c b/apps/codecs/lib/codeclib.c deleted file mode 100644 index 36f4279941..0000000000 --- a/apps/codecs/lib/codeclib.c +++ /dev/null | |||
@@ -1,182 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 Dave Chapman | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or | ||
13 | * modify it under the terms of the GNU General Public License | ||
14 | * as published by the Free Software Foundation; either version 2 | ||
15 | * of the License, or (at your option) any later version. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | |||
22 | /* "helper functions" common to all codecs */ | ||
23 | |||
24 | #include <string.h> | ||
25 | #include "codecs.h" | ||
26 | #include "dsp.h" | ||
27 | #include "codeclib.h" | ||
28 | #include "metadata.h" | ||
29 | |||
30 | /* The following variables are used by codec_malloc() to make use of free RAM | ||
31 | * within the statically allocated codec buffer. */ | ||
32 | static size_t mem_ptr = 0; | ||
33 | static size_t bufsize = 0; | ||
34 | static unsigned char* mallocbuf = NULL; | ||
35 | |||
36 | int codec_init(void) | ||
37 | { | ||
38 | /* codec_get_buffer() aligns the resulting point to CACHEALIGN_SIZE. */ | ||
39 | mem_ptr = 0; | ||
40 | mallocbuf = (unsigned char *)ci->codec_get_buffer((size_t *)&bufsize); | ||
41 | |||
42 | return 0; | ||
43 | } | ||
44 | |||
45 | void codec_set_replaygain(const struct mp3entry *id3) | ||
46 | { | ||
47 | ci->configure(DSP_SET_TRACK_GAIN, id3->track_gain); | ||
48 | ci->configure(DSP_SET_ALBUM_GAIN, id3->album_gain); | ||
49 | ci->configure(DSP_SET_TRACK_PEAK, id3->track_peak); | ||
50 | ci->configure(DSP_SET_ALBUM_PEAK, id3->album_peak); | ||
51 | } | ||
52 | |||
53 | /* Various "helper functions" common to all the xxx2wav decoder plugins */ | ||
54 | |||
55 | |||
56 | void* codec_malloc(size_t size) | ||
57 | { | ||
58 | void* x; | ||
59 | |||
60 | if (mem_ptr + (long)size > bufsize) | ||
61 | return NULL; | ||
62 | |||
63 | x=&mallocbuf[mem_ptr]; | ||
64 | |||
65 | /* Keep memory aligned to CACHEALIGN_SIZE. */ | ||
66 | mem_ptr += (size + (CACHEALIGN_SIZE-1)) & ~(CACHEALIGN_SIZE-1); | ||
67 | |||
68 | return(x); | ||
69 | } | ||
70 | |||
71 | void* codec_calloc(size_t nmemb, size_t size) | ||
72 | { | ||
73 | void* x; | ||
74 | x = codec_malloc(nmemb*size); | ||
75 | if (x == NULL) | ||
76 | return NULL; | ||
77 | ci->memset(x,0,nmemb*size); | ||
78 | return(x); | ||
79 | } | ||
80 | |||
81 | void codec_free(void* ptr) { | ||
82 | (void)ptr; | ||
83 | } | ||
84 | |||
85 | void* codec_realloc(void* ptr, size_t size) | ||
86 | { | ||
87 | void* x; | ||
88 | (void)ptr; | ||
89 | x = codec_malloc(size); | ||
90 | return(x); | ||
91 | } | ||
92 | |||
93 | size_t strlen(const char *s) | ||
94 | { | ||
95 | return(ci->strlen(s)); | ||
96 | } | ||
97 | |||
98 | char *strcpy(char *dest, const char *src) | ||
99 | { | ||
100 | return(ci->strcpy(dest,src)); | ||
101 | } | ||
102 | |||
103 | char *strcat(char *dest, const char *src) | ||
104 | { | ||
105 | return(ci->strcat(dest,src)); | ||
106 | } | ||
107 | |||
108 | int strcmp(const char *s1, const char *s2) | ||
109 | { | ||
110 | return(ci->strcmp(s1,s2)); | ||
111 | } | ||
112 | |||
113 | void *memcpy(void *dest, const void *src, size_t n) | ||
114 | { | ||
115 | return(ci->memcpy(dest,src,n)); | ||
116 | } | ||
117 | |||
118 | void *memset(void *s, int c, size_t n) | ||
119 | { | ||
120 | return(ci->memset(s,c,n)); | ||
121 | } | ||
122 | |||
123 | int memcmp(const void *s1, const void *s2, size_t n) | ||
124 | { | ||
125 | return(ci->memcmp(s1,s2,n)); | ||
126 | } | ||
127 | |||
128 | void* memchr(const void *s, int c, size_t n) | ||
129 | { | ||
130 | return(ci->memchr(s,c,n)); | ||
131 | } | ||
132 | |||
133 | void *memmove(void *dest, const void *src, size_t n) | ||
134 | { | ||
135 | return(ci->memmove(dest,src,n)); | ||
136 | } | ||
137 | |||
138 | void qsort(void *base, size_t nmemb, size_t size, | ||
139 | int(*compar)(const void *, const void *)) | ||
140 | { | ||
141 | ci->qsort(base,nmemb,size,compar); | ||
142 | } | ||
143 | |||
144 | /* From ffmpeg - libavutil/common.h */ | ||
145 | const uint8_t bs_log2_tab[256] ICONST_ATTR = { | ||
146 | 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, | ||
147 | 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, | ||
148 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, | ||
149 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, | ||
150 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, | ||
151 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, | ||
152 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, | ||
153 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 | ||
154 | }; | ||
155 | |||
156 | const uint8_t bs_clz_tab[256] ICONST_ATTR = { | ||
157 | 8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, | ||
158 | 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, | ||
159 | 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, | ||
160 | 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, | ||
161 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, | ||
162 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, | ||
163 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, | ||
164 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 | ||
165 | }; | ||
166 | |||
167 | #ifdef RB_PROFILE | ||
168 | void __cyg_profile_func_enter(void *this_fn, void *call_site) { | ||
169 | /* This workaround is required for coldfire gcc 3.4 but is broken for 4.4 | ||
170 | and 4.5, but for those the other way works. */ | ||
171 | #if defined(CPU_COLDFIRE) && defined(__GNUC__) && __GNUC__ < 4 | ||
172 | (void)call_site; | ||
173 | ci->profile_func_enter(this_fn, __builtin_return_address(1)); | ||
174 | #else | ||
175 | ci->profile_func_enter(this_fn, call_site); | ||
176 | #endif | ||
177 | } | ||
178 | |||
179 | void __cyg_profile_func_exit(void *this_fn, void *call_site) { | ||
180 | ci->profile_func_exit(this_fn,call_site); | ||
181 | } | ||
182 | #endif | ||
diff --git a/apps/codecs/lib/codeclib.h b/apps/codecs/lib/codeclib.h deleted file mode 100644 index d0f985b8e1..0000000000 --- a/apps/codecs/lib/codeclib.h +++ /dev/null | |||
@@ -1,163 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 Dave Chapman | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or | ||
13 | * modify it under the terms of the GNU General Public License | ||
14 | * as published by the Free Software Foundation; either version 2 | ||
15 | * of the License, or (at your option) any later version. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | |||
22 | #ifndef __CODECLIB_H__ | ||
23 | #define __CODECLIB_H__ | ||
24 | |||
25 | #include <inttypes.h> | ||
26 | #include <string.h> | ||
27 | #include "config.h" | ||
28 | #include "codecs.h" | ||
29 | #include "mdct.h" | ||
30 | #include "fft.h" | ||
31 | |||
32 | extern struct codec_api *ci; | ||
33 | |||
34 | /* Standard library functions that are used by the codecs follow here */ | ||
35 | |||
36 | /* Get these functions 'out of the way' of the standard functions. Not doing | ||
37 | * so confuses the cygwin linker, and maybe others. These functions need to | ||
38 | * be implemented elsewhere */ | ||
39 | #define malloc(x) codec_malloc(x) | ||
40 | #define calloc(x,y) codec_calloc(x,y) | ||
41 | #define realloc(x,y) codec_realloc(x,y) | ||
42 | #define free(x) codec_free(x) | ||
43 | #undef alloca | ||
44 | #define alloca(x) __builtin_alloca(x) | ||
45 | |||
46 | void* codec_malloc(size_t size); | ||
47 | void* codec_calloc(size_t nmemb, size_t size); | ||
48 | void* codec_realloc(void* ptr, size_t size); | ||
49 | void codec_free(void* ptr); | ||
50 | |||
51 | void *memcpy(void *dest, const void *src, size_t n); | ||
52 | void *memset(void *s, int c, size_t n); | ||
53 | int memcmp(const void *s1, const void *s2, size_t n); | ||
54 | void *memmove(void *s1, const void *s2, size_t n); | ||
55 | |||
56 | size_t strlen(const char *s); | ||
57 | char *strcpy(char *dest, const char *src); | ||
58 | char *strcat(char *dest, const char *src); | ||
59 | |||
60 | /* on some platforms strcmp() seems to be a tricky define which | ||
61 | * breaks if we write down strcmp's prototype */ | ||
62 | #undef strcmp | ||
63 | int strcmp(const char *s1, const char *s2); | ||
64 | |||
65 | void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)); | ||
66 | |||
67 | /*MDCT library functions*/ | ||
68 | /* -1- Tremor mdct */ | ||
69 | extern void mdct_backward(int n, int32_t *in, int32_t *out); | ||
70 | /* -2- ffmpeg fft-based mdct */ | ||
71 | extern void ff_imdct_half(unsigned int nbits, int32_t *output, const int32_t *input); | ||
72 | extern void ff_imdct_calc(unsigned int nbits, int32_t *output, const int32_t *input); | ||
73 | /*ffmpeg fft (can be used without mdct)*/ | ||
74 | extern void ff_fft_calc_c(int nbits, FFTComplex *z); | ||
75 | |||
76 | #if !defined(CPU_ARM) || ARM_ARCH < 5 | ||
77 | /* From libavutil/common.h */ | ||
78 | extern const uint8_t bs_log2_tab[256] ICONST_ATTR; | ||
79 | extern const uint8_t bs_clz_tab[256] ICONST_ATTR; | ||
80 | #endif | ||
81 | |||
82 | #define BS_LOG2 0 /* default personality, equivalent floor(log2(x)) */ | ||
83 | #define BS_CLZ 1 /* alternate personality, Count Leading Zeros */ | ||
84 | #define BS_SHORT 2 /* input guaranteed not to exceed 16 bits */ | ||
85 | #define BS_0_0 4 /* guarantee mapping of 0 input to 0 output */ | ||
86 | |||
87 | /* Generic bit-scanning function, used to wrap platform CLZ instruction or | ||
88 | scan-and-lookup code, and to provide control over output for 0 inputs. */ | ||
89 | static inline unsigned int bs_generic(unsigned int v, int mode) | ||
90 | { | ||
91 | #if defined(CPU_ARM) && ARM_ARCH >= 5 | ||
92 | unsigned int r = __builtin_clz(v); | ||
93 | if (mode & BS_CLZ) | ||
94 | { | ||
95 | if (mode & BS_0_0) | ||
96 | r &= 31; | ||
97 | } else { | ||
98 | r = 31 - r; | ||
99 | /* If mode is constant, this is a single conditional instruction */ | ||
100 | if (mode & BS_0_0 && (signed)r < 0) | ||
101 | r += 1; | ||
102 | } | ||
103 | #else | ||
104 | const uint8_t *bs_tab; | ||
105 | unsigned int r; | ||
106 | unsigned int n = v; | ||
107 | int inc; | ||
108 | /* Set up table, increment, and initial result value based on | ||
109 | personality. */ | ||
110 | if (mode & BS_CLZ) | ||
111 | { | ||
112 | bs_tab = bs_clz_tab; | ||
113 | r = 24; | ||
114 | inc = -16; | ||
115 | } else { | ||
116 | bs_tab = bs_log2_tab; | ||
117 | r = 0; | ||
118 | inc = 16; | ||
119 | } | ||
120 | if (!(mode & BS_SHORT) && n >= 0x10000) { | ||
121 | n >>= 16; | ||
122 | r += inc; | ||
123 | } | ||
124 | if (n > 0xff) { | ||
125 | n >>= 8; | ||
126 | r += inc / 2; | ||
127 | } | ||
128 | #ifdef CPU_COLDFIRE | ||
129 | /* The high 24 bits of n are guaranteed empty after the above, so a | ||
130 | superfluous ext.b instruction can be saved by loading the LUT value over | ||
131 | n with asm */ | ||
132 | asm volatile ( | ||
133 | "move.b (%1,%0.l),%0" | ||
134 | : "+d" (n) | ||
135 | : "a" (bs_tab) | ||
136 | ); | ||
137 | #else | ||
138 | n = bs_tab[n]; | ||
139 | #endif | ||
140 | r += n; | ||
141 | if (mode & BS_CLZ && mode & BS_0_0 && v == 0) | ||
142 | r = 0; | ||
143 | #endif | ||
144 | return r; | ||
145 | } | ||
146 | |||
147 | /* TODO figure out if we really need to care about calculating | ||
148 | av_log2(0) */ | ||
149 | #define av_log2(v) bs_generic(v, BS_0_0) | ||
150 | |||
151 | /* Various codec helper functions */ | ||
152 | |||
153 | int codec_init(void); | ||
154 | void codec_set_replaygain(const struct mp3entry *id3); | ||
155 | |||
156 | #ifdef RB_PROFILE | ||
157 | void __cyg_profile_func_enter(void *this_fn, void *call_site) | ||
158 | NO_PROF_ATTR ICODE_ATTR; | ||
159 | void __cyg_profile_func_exit(void *this_fn, void *call_site) | ||
160 | NO_PROF_ATTR ICODE_ATTR; | ||
161 | #endif | ||
162 | |||
163 | #endif /* __CODECLIB_H__ */ | ||
diff --git a/apps/codecs/lib/codeclib_misc.h b/apps/codecs/lib/codeclib_misc.h deleted file mode 100644 index 8ebe22e37b..0000000000 --- a/apps/codecs/lib/codeclib_misc.h +++ /dev/null | |||
@@ -1,310 +0,0 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: miscellaneous math and prototypes | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | #ifndef _CODECLIB_MISC_H_ | ||
19 | #define _CODECLIB_MISC_H_ | ||
20 | |||
21 | #include <stdint.h> | ||
22 | #include "asm_arm.h" | ||
23 | #include "asm_mcf5249.h" | ||
24 | |||
25 | #ifndef _LOW_ACCURACY_ | ||
26 | /* 64 bit multiply */ | ||
27 | |||
28 | #ifdef ROCKBOX_LITTLE_ENDIAN | ||
29 | union magic { | ||
30 | struct { | ||
31 | int32_t lo; | ||
32 | int32_t hi; | ||
33 | } halves; | ||
34 | int64_t whole; | ||
35 | }; | ||
36 | #elif defined(ROCKBOX_BIG_ENDIAN) | ||
37 | union magic { | ||
38 | struct { | ||
39 | int32_t hi; | ||
40 | int32_t lo; | ||
41 | } halves; | ||
42 | int64_t whole; | ||
43 | }; | ||
44 | #endif | ||
45 | |||
46 | #ifndef INCL_OPTIMIZED_MULT32 | ||
47 | #define INCL_OPTIMIZED_MULT32 | ||
48 | static inline int32_t MULT32(int32_t x, int32_t y) { | ||
49 | union magic magic; | ||
50 | magic.whole = (int64_t)x * y; | ||
51 | return magic.halves.hi; | ||
52 | } | ||
53 | #endif | ||
54 | |||
55 | #ifndef INCL_OPTIMIZED_MULT31 | ||
56 | #define INCL_OPTIMIZED_MULT31 | ||
57 | static inline int32_t MULT31(int32_t x, int32_t y) { | ||
58 | return MULT32(x,y)<<1; | ||
59 | } | ||
60 | #endif | ||
61 | |||
62 | #ifndef INCL_OPTIMIZED_MULT31_SHIFT15 | ||
63 | #define INCL_OPTIMIZED_MULT31_SHIFT15 | ||
64 | static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) { | ||
65 | union magic magic; | ||
66 | magic.whole = (int64_t)x * y; | ||
67 | return ((uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17); | ||
68 | } | ||
69 | #endif | ||
70 | |||
71 | #ifndef INCL_OPTIMIZED_MULT31_SHIFT16 | ||
72 | #define INCL_OPTIMIZED_MULT31_SHIFT16 | ||
73 | static inline int32_t MULT31_SHIFT16(int32_t x, int32_t y) { | ||
74 | union magic magic; | ||
75 | magic.whole = (int64_t)x * y; | ||
76 | return ((uint32_t)(magic.halves.lo)>>16) | ((magic.halves.hi)<<16); | ||
77 | } | ||
78 | #endif | ||
79 | |||
80 | #else | ||
81 | /* Rockbox: unused */ | ||
82 | #if 0 | ||
83 | /* 32 bit multiply, more portable but less accurate */ | ||
84 | |||
85 | /* | ||
86 | * Note: Precision is biased towards the first argument therefore ordering | ||
87 | * is important. Shift values were chosen for the best sound quality after | ||
88 | * many listening tests. | ||
89 | */ | ||
90 | |||
91 | /* | ||
92 | * For MULT32 and MULT31: The second argument is always a lookup table | ||
93 | * value already preshifted from 31 to 8 bits. We therefore take the | ||
94 | * opportunity to save on text space and use unsigned char for those | ||
95 | * tables in this case. | ||
96 | */ | ||
97 | |||
98 | static inline int32_t MULT32(int32_t x, int32_t y) { | ||
99 | return (x >> 9) * y; /* y preshifted >>23 */ | ||
100 | } | ||
101 | |||
102 | static inline int32_t MULT31(int32_t x, int32_t y) { | ||
103 | return (x >> 8) * y; /* y preshifted >>23 */ | ||
104 | } | ||
105 | |||
106 | static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) { | ||
107 | return (x >> 6) * y; /* y preshifted >>9 */ | ||
108 | } | ||
109 | #endif | ||
110 | #endif | ||
111 | |||
112 | /* | ||
113 | * The XPROD functions are meant to optimize the cross products found all | ||
114 | * over the place in mdct.c by forcing memory operation ordering to avoid | ||
115 | * unnecessary register reloads as soon as memory is being written to. | ||
116 | * However this is only beneficial on CPUs with a sane number of general | ||
117 | * purpose registers which exclude the Intel x86. On Intel, better let the | ||
118 | * compiler actually reload registers directly from original memory by using | ||
119 | * macros. | ||
120 | */ | ||
121 | |||
122 | #ifndef INCL_OPTIMIZED_XPROD32 | ||
123 | #define INCL_OPTIMIZED_XPROD32 | ||
124 | /* replaced XPROD32 with a macro to avoid memory reference | ||
125 | _x, _y are the results (must be l-values) */ | ||
126 | #define XPROD32(_a, _b, _t, _v, _x, _y) \ | ||
127 | { (_x)=MULT32(_a,_t)+MULT32(_b,_v); \ | ||
128 | (_y)=MULT32(_b,_t)-MULT32(_a,_v); } | ||
129 | #endif | ||
130 | |||
131 | /* Rockbox: Unused */ | ||
132 | /* | ||
133 | #ifdef __i386__ | ||
134 | |||
135 | #define XPROD31(_a, _b, _t, _v, _x, _y) \ | ||
136 | { *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \ | ||
137 | *(_y)=MULT31(_b,_t)-MULT31(_a,_v); } | ||
138 | #define XNPROD31(_a, _b, _t, _v, _x, _y) \ | ||
139 | { *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \ | ||
140 | *(_y)=MULT31(_b,_t)+MULT31(_a,_v); } | ||
141 | |||
142 | #else | ||
143 | */ | ||
144 | |||
145 | #ifndef INCL_OPTIMIZED_XPROD31 | ||
146 | #define INCL_OPTIMIZED_XPROD31 | ||
147 | static inline void XPROD31(int32_t a, int32_t b, | ||
148 | int32_t t, int32_t v, | ||
149 | int32_t *x, int32_t *y) | ||
150 | { | ||
151 | *x = MULT31(a, t) + MULT31(b, v); | ||
152 | *y = MULT31(b, t) - MULT31(a, v); | ||
153 | } | ||
154 | #endif | ||
155 | |||
156 | #ifndef INCL_OPTIMIZED_XNPROD31 | ||
157 | #define INCL_OPTIMIZED_XNPROD31 | ||
158 | static inline void XNPROD31(int32_t a, int32_t b, | ||
159 | int32_t t, int32_t v, | ||
160 | int32_t *x, int32_t *y) | ||
161 | { | ||
162 | *x = MULT31(a, t) - MULT31(b, v); | ||
163 | *y = MULT31(b, t) + MULT31(a, v); | ||
164 | } | ||
165 | #endif | ||
166 | /*#endif*/ | ||
167 | |||
168 | #ifndef INCL_OPTIMIZED_XPROD31_R | ||
169 | #define INCL_OPTIMIZED_XPROD31_R | ||
170 | #define XPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
171 | {\ | ||
172 | _x = MULT31(_a, _t) + MULT31(_b, _v);\ | ||
173 | _y = MULT31(_b, _t) - MULT31(_a, _v);\ | ||
174 | } | ||
175 | #endif | ||
176 | |||
177 | #ifndef INCL_OPTIMIZED_XNPROD31_R | ||
178 | #define INCL_OPTIMIZED_XNPROD31_R | ||
179 | #define XNPROD31_R(_a, _b, _t, _v, _x, _y)\ | ||
180 | {\ | ||
181 | _x = MULT31(_a, _t) - MULT31(_b, _v);\ | ||
182 | _y = MULT31(_b, _t) + MULT31(_a, _v);\ | ||
183 | } | ||
184 | #endif | ||
185 | |||
186 | #ifndef _V_VECT_OPS | ||
187 | #define _V_VECT_OPS | ||
188 | |||
189 | static inline | ||
190 | void vect_add(int32_t *x, const int32_t *y, int n) | ||
191 | { | ||
192 | while (n>0) { | ||
193 | *x++ += *y++; | ||
194 | n--; | ||
195 | } | ||
196 | } | ||
197 | |||
198 | static inline | ||
199 | void vect_copy(int32_t *x, const int32_t *y, int n) | ||
200 | { | ||
201 | while (n>0) { | ||
202 | *x++ = *y++; | ||
203 | n--; | ||
204 | } | ||
205 | } | ||
206 | |||
207 | static inline | ||
208 | void vect_mult_fw(int32_t *data, const int32_t *window, int n) | ||
209 | { | ||
210 | while(n>0) { | ||
211 | *data = MULT31(*data, *window); | ||
212 | data++; | ||
213 | window++; | ||
214 | n--; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | static inline | ||
219 | void vect_mult_bw(int32_t *data, const int32_t *window, int n) | ||
220 | { | ||
221 | while(n>0) { | ||
222 | *data = MULT31(*data, *window); | ||
223 | data++; | ||
224 | window--; | ||
225 | n--; | ||
226 | } | ||
227 | } | ||
228 | #endif | ||
229 | |||
230 | /* not used anymore */ | ||
231 | /* | ||
232 | #ifndef _V_CLIP_MATH | ||
233 | #define _V_CLIP_MATH | ||
234 | |||
235 | static inline int32_t CLIP_TO_15(int32_t x) { | ||
236 | int ret=x; | ||
237 | ret-= ((x<=32767)-1)&(x-32767); | ||
238 | ret-= ((x>=-32768)-1)&(x+32768); | ||
239 | return(ret); | ||
240 | } | ||
241 | |||
242 | #endif | ||
243 | */ | ||
244 | static inline int32_t VFLOAT_MULT(int32_t a,int32_t ap, | ||
245 | int32_t b,int32_t bp, | ||
246 | int32_t *p){ | ||
247 | if(a && b){ | ||
248 | #ifndef _LOW_ACCURACY_ | ||
249 | *p=ap+bp+32; | ||
250 | return MULT32(a,b); | ||
251 | #else | ||
252 | *p=ap+bp+31; | ||
253 | return (a>>15)*(b>>16); | ||
254 | #endif | ||
255 | }else | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | /*static inline int32_t VFLOAT_MULTI(int32_t a,int32_t ap, | ||
260 | int32_t i, | ||
261 | int32_t *p){ | ||
262 | |||
263 | int ip=_ilog(abs(i))-31; | ||
264 | return VFLOAT_MULT(a,ap,i<<-ip,ip,p); | ||
265 | } | ||
266 | */ | ||
267 | static inline int32_t VFLOAT_ADD(int32_t a,int32_t ap, | ||
268 | int32_t b,int32_t bp, | ||
269 | int32_t *p){ | ||
270 | |||
271 | if(!a){ | ||
272 | *p=bp; | ||
273 | return b; | ||
274 | }else if(!b){ | ||
275 | *p=ap; | ||
276 | return a; | ||
277 | } | ||
278 | |||
279 | /* yes, this can leak a bit. */ | ||
280 | if(ap>bp){ | ||
281 | int shift=ap-bp+1; | ||
282 | *p=ap+1; | ||
283 | a>>=1; | ||
284 | if(shift<32){ | ||
285 | b=(b+(1<<(shift-1)))>>shift; | ||
286 | }else{ | ||
287 | b=0; | ||
288 | } | ||
289 | }else{ | ||
290 | int shift=bp-ap+1; | ||
291 | *p=bp+1; | ||
292 | b>>=1; | ||
293 | if(shift<32){ | ||
294 | a=(a+(1<<(shift-1)))>>shift; | ||
295 | }else{ | ||
296 | a=0; | ||
297 | } | ||
298 | } | ||
299 | |||
300 | a+=b; | ||
301 | if((a&0xc0000000)==0xc0000000 || | ||
302 | (a&0xc0000000)==0){ | ||
303 | a<<=1; | ||
304 | (*p)--; | ||
305 | } | ||
306 | return(a); | ||
307 | } | ||
308 | |||
309 | #endif | ||
310 | |||
diff --git a/apps/codecs/lib/ffmpeg_bitstream.c b/apps/codecs/lib/ffmpeg_bitstream.c deleted file mode 100644 index e16df8dcce..0000000000 --- a/apps/codecs/lib/ffmpeg_bitstream.c +++ /dev/null | |||
@@ -1,374 +0,0 @@ | |||
1 | /* | ||
2 | * Common bit i/o utils | ||
3 | * Copyright (c) 2000, 2001 Fabrice Bellard | ||
4 | * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> | ||
5 | * Copyright (c) 2010 Loren Merritt | ||
6 | * | ||
7 | * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at> | ||
8 | * | ||
9 | * This file is part of FFmpeg. | ||
10 | * | ||
11 | * FFmpeg is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU Lesser General Public | ||
13 | * License as published by the Free Software Foundation; either | ||
14 | * version 2.1 of the License, or (at your option) any later version. | ||
15 | * | ||
16 | * FFmpeg is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
19 | * Lesser General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU Lesser General Public | ||
22 | * License along with FFmpeg; if not, write to the Free Software | ||
23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
24 | */ | ||
25 | |||
26 | /** | ||
27 | * @file | ||
28 | * bitstream api. | ||
29 | */ | ||
30 | |||
31 | //#include "avcodec.h" | ||
32 | #include "ffmpeg_get_bits.h" | ||
33 | #include "ffmpeg_put_bits.h" | ||
34 | #include "ffmpeg_intreadwrite.h" | ||
35 | |||
36 | #define av_log(...) | ||
37 | |||
38 | #ifdef ROCKBOX | ||
39 | #undef DEBUGF | ||
40 | #define DEBUGF(...) | ||
41 | #endif | ||
42 | |||
43 | const uint8_t ff_log2_run[32]={ | ||
44 | 0, 0, 0, 0, 1, 1, 1, 1, | ||
45 | 2, 2, 2, 2, 3, 3, 3, 3, | ||
46 | 4, 4, 5, 5, 6, 6, 7, 7, | ||
47 | 8, 9,10,11,12,13,14,15 | ||
48 | }; | ||
49 | |||
50 | #if 0 // unused in rockbox | ||
51 | void align_put_bits(PutBitContext *s) | ||
52 | { | ||
53 | #ifdef ALT_BITSTREAM_WRITER | ||
54 | put_bits(s,( - s->index) & 7,0); | ||
55 | #else | ||
56 | put_bits(s,s->bit_left & 7,0); | ||
57 | #endif | ||
58 | } | ||
59 | |||
60 | void ff_put_string(PutBitContext *pb, const char *string, int terminate_string) | ||
61 | { | ||
62 | while(*string){ | ||
63 | put_bits(pb, 8, *string); | ||
64 | string++; | ||
65 | } | ||
66 | if(terminate_string) | ||
67 | put_bits(pb, 8, 0); | ||
68 | } | ||
69 | #endif | ||
70 | |||
71 | void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) | ||
72 | { | ||
73 | int words= length>>4; | ||
74 | int bits= length&15; | ||
75 | int i; | ||
76 | |||
77 | if(length==0) return; | ||
78 | |||
79 | if(words < 16 || put_bits_count(pb)&7){ | ||
80 | for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i)); | ||
81 | }else{ | ||
82 | for(i=0; put_bits_count(pb)&31; i++) | ||
83 | put_bits(pb, 8, src[i]); | ||
84 | flush_put_bits(pb); | ||
85 | memcpy(put_bits_ptr(pb), src+i, 2*words-i); | ||
86 | skip_put_bytes(pb, 2*words-i); | ||
87 | } | ||
88 | |||
89 | put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits)); | ||
90 | } | ||
91 | |||
92 | /* VLC decoding */ | ||
93 | |||
94 | //#define DEBUG_VLC | ||
95 | |||
96 | #define GET_DATA(v, table, i, wrap, size) \ | ||
97 | {\ | ||
98 | const uint8_t *ptr = (const uint8_t *)table + i * wrap;\ | ||
99 | switch(size) {\ | ||
100 | case 1:\ | ||
101 | v = *(const uint8_t *)ptr;\ | ||
102 | break;\ | ||
103 | case 2:\ | ||
104 | v = *(const uint16_t *)ptr;\ | ||
105 | break;\ | ||
106 | default:\ | ||
107 | v = *(const uint32_t *)ptr;\ | ||
108 | break;\ | ||
109 | }\ | ||
110 | } | ||
111 | |||
112 | |||
113 | static int alloc_table(VLC *vlc, int size, int use_static) | ||
114 | { | ||
115 | int index; | ||
116 | index = vlc->table_size; | ||
117 | vlc->table_size += size; | ||
118 | if (vlc->table_size > vlc->table_allocated) { | ||
119 | if(use_static) | ||
120 | { | ||
121 | DEBUGF("init_vlc() used with too little memory : table_size > allocated_memory\n"); | ||
122 | return -1; | ||
123 | } | ||
124 | // abort(); //cant do anything, init_vlc() is used with too little memory | ||
125 | // vlc->table_allocated += (1 << vlc->bits); | ||
126 | // vlc->table = av_realloc(vlc->table, | ||
127 | // sizeof(VLC_TYPE) * 2 * vlc->table_allocated); | ||
128 | if (!vlc->table) | ||
129 | return -1; | ||
130 | } | ||
131 | return index; | ||
132 | } | ||
133 | |||
134 | /* | ||
135 | static av_always_inline uint32_t bitswap_32(uint32_t x) { | ||
136 | return av_reverse[x&0xFF]<<24 | ||
137 | | av_reverse[(x>>8)&0xFF]<<16 | ||
138 | | av_reverse[(x>>16)&0xFF]<<8 | ||
139 | | av_reverse[x>>24]; | ||
140 | } | ||
141 | */ | ||
142 | |||
143 | typedef struct { | ||
144 | uint8_t bits; | ||
145 | uint16_t symbol; | ||
146 | /** codeword, with the first bit-to-be-read in the msb | ||
147 | * (even if intended for a little-endian bitstream reader) */ | ||
148 | uint32_t code; | ||
149 | } __attribute__((__packed__)) VLCcode; /* packed to save space */ | ||
150 | |||
151 | static int compare_vlcspec(const void *a, const void *b) | ||
152 | { | ||
153 | const VLCcode *sa=a, *sb=b; | ||
154 | return (sa->code >> 1) - (sb->code >> 1); | ||
155 | } | ||
156 | |||
157 | /** | ||
158 | * Build VLC decoding tables suitable for use with get_vlc(). | ||
159 | * | ||
160 | * @param vlc the context to be initted | ||
161 | * | ||
162 | * @param table_nb_bits max length of vlc codes to store directly in this table | ||
163 | * (Longer codes are delegated to subtables.) | ||
164 | * | ||
165 | * @param nb_codes number of elements in codes[] | ||
166 | * | ||
167 | * @param codes descriptions of the vlc codes | ||
168 | * These must be ordered such that codes going into the same subtable are contiguous. | ||
169 | * Sorting by VLCcode.code is sufficient, though not necessary. | ||
170 | */ | ||
171 | static int build_table(VLC *vlc, int table_nb_bits, int nb_codes, | ||
172 | VLCcode *codes, int flags) | ||
173 | { | ||
174 | int table_size, table_index, index, symbol, subtable_bits; | ||
175 | int i, j, k, n, nb, inc; | ||
176 | uint32_t code, code_prefix; | ||
177 | VLC_TYPE (*table)[2]; | ||
178 | |||
179 | table_size = 1 << table_nb_bits; | ||
180 | table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC); | ||
181 | #ifdef DEBUG_VLC | ||
182 | av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d\n", | ||
183 | table_index, table_size); | ||
184 | #endif | ||
185 | if (table_index < 0) | ||
186 | return -1; | ||
187 | table = &vlc->table[table_index]; | ||
188 | |||
189 | for (i = 0; i < table_size; i++) { | ||
190 | table[i][1] = 0; //bits | ||
191 | table[i][0] = -1; //codes | ||
192 | } | ||
193 | |||
194 | /* first pass: map codes and compute auxillary table sizes */ | ||
195 | for (i = 0; i < nb_codes; i++) { | ||
196 | n = codes[i].bits; | ||
197 | code = codes[i].code; | ||
198 | symbol = codes[i].symbol; | ||
199 | #if defined(DEBUG_VLC) && 0 | ||
200 | av_log(NULL,AV_LOG_DEBUG,"i=%d n=%d code=0x%x\n", i, n, code); | ||
201 | #endif | ||
202 | if (n <= table_nb_bits) { | ||
203 | /* no need to add another table */ | ||
204 | j = code >> (32 - table_nb_bits); | ||
205 | nb = 1 << (table_nb_bits - n); | ||
206 | inc = 1; | ||
207 | /* if (flags & INIT_VLC_LE) { | ||
208 | j = bitswap_32(code); | ||
209 | inc = 1 << n; | ||
210 | } */ | ||
211 | for (k = 0; k < nb; k++) { | ||
212 | #ifdef DEBUG_VLC | ||
213 | av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n", | ||
214 | j, i, n); | ||
215 | #endif | ||
216 | if (table[j][1] /*bits*/ != 0) { | ||
217 | av_log(NULL, AV_LOG_ERROR, "incorrect codes\n"); | ||
218 | return -1; | ||
219 | } | ||
220 | table[j][1] = n; //bits | ||
221 | table[j][0] = symbol; | ||
222 | j += inc; | ||
223 | } | ||
224 | } else { | ||
225 | /* fill auxiliary table recursively */ | ||
226 | n -= table_nb_bits; | ||
227 | code_prefix = code >> (32 - table_nb_bits); | ||
228 | subtable_bits = n; | ||
229 | codes[i].bits = n; | ||
230 | codes[i].code = code << table_nb_bits; | ||
231 | for (k = i+1; k < nb_codes; k++) { | ||
232 | n = codes[k].bits - table_nb_bits; | ||
233 | if (n <= 0) | ||
234 | break; | ||
235 | code = codes[k].code; | ||
236 | if (code >> (32 - table_nb_bits) != code_prefix) | ||
237 | break; | ||
238 | codes[k].bits = n; | ||
239 | codes[k].code = code << table_nb_bits; | ||
240 | subtable_bits = FFMAX(subtable_bits, n); | ||
241 | } | ||
242 | subtable_bits = FFMIN(subtable_bits, table_nb_bits); | ||
243 | j = /*(flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) :*/ code_prefix; | ||
244 | table[j][1] = -subtable_bits; | ||
245 | #ifdef DEBUG_VLC | ||
246 | av_log(NULL,AV_LOG_DEBUG,"%4x: n=%d (subtable)\n", | ||
247 | j, codes[i].bits + table_nb_bits); | ||
248 | #endif | ||
249 | index = build_table(vlc, subtable_bits, k-i, codes+i, flags); | ||
250 | if (index < 0) | ||
251 | return -1; | ||
252 | /* note: realloc has been done, so reload tables */ | ||
253 | table = &vlc->table[table_index]; | ||
254 | table[j][0] = index; //code | ||
255 | i = k-1; | ||
256 | } | ||
257 | } | ||
258 | return table_index; | ||
259 | } | ||
260 | |||
261 | |||
262 | /* Build VLC decoding tables suitable for use with get_vlc(). | ||
263 | |||
264 | 'nb_bits' set thee decoding table size (2^nb_bits) entries. The | ||
265 | bigger it is, the faster is the decoding. But it should not be too | ||
266 | big to save memory and L1 cache. '9' is a good compromise. | ||
267 | |||
268 | 'nb_codes' : number of vlcs codes | ||
269 | |||
270 | 'bits' : table which gives the size (in bits) of each vlc code. | ||
271 | |||
272 | 'codes' : table which gives the bit pattern of of each vlc code. | ||
273 | |||
274 | 'symbols' : table which gives the values to be returned from get_vlc(). | ||
275 | |||
276 | 'xxx_wrap' : give the number of bytes between each entry of the | ||
277 | 'bits' or 'codes' tables. | ||
278 | |||
279 | 'xxx_size' : gives the number of bytes of each entry of the 'bits' | ||
280 | or 'codes' tables. | ||
281 | |||
282 | 'wrap' and 'size' allows to use any memory configuration and types | ||
283 | (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables. | ||
284 | |||
285 | 'use_static' should be set to 1 for tables, which should be freed | ||
286 | with av_free_static(), 0 if free_vlc() will be used. | ||
287 | */ | ||
288 | |||
289 | /* Rockbox: support for INIT_VLC_LE is currently disabled since none of our | ||
290 | codecs use it, there's a LUT based bit reverse function for this commented | ||
291 | out above (bitswap_32) and an inline asm version in libtremor/codebook.c | ||
292 | if we ever want this */ | ||
293 | |||
294 | static VLCcode buf[1336+1]; /* worst case is wma, which has one table with 1336 entries */ | ||
295 | |||
296 | int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, | ||
297 | const void *bits, int bits_wrap, int bits_size, | ||
298 | const void *codes, int codes_wrap, int codes_size, | ||
299 | const void *symbols, int symbols_wrap, int symbols_size, | ||
300 | int flags) | ||
301 | { | ||
302 | if (nb_codes+1 > (int)(sizeof (buf)/ sizeof (VLCcode))) | ||
303 | { | ||
304 | DEBUGF("Table is larger than temp buffer!\n"); | ||
305 | return -1; | ||
306 | } | ||
307 | |||
308 | int i, j, ret; | ||
309 | |||
310 | vlc->bits = nb_bits; | ||
311 | if(flags & INIT_VLC_USE_NEW_STATIC){ | ||
312 | if(vlc->table_size && vlc->table_size == vlc->table_allocated){ | ||
313 | return 0; | ||
314 | }else if(vlc->table_size){ | ||
315 | DEBUGF("fatal error, we are called on a partially initialized table\n"); | ||
316 | return -1; | ||
317 | // abort(); // fatal error, we are called on a partially initialized table | ||
318 | } | ||
319 | }else { | ||
320 | vlc->table = NULL; | ||
321 | vlc->table_allocated = 0; | ||
322 | vlc->table_size = 0; | ||
323 | } | ||
324 | |||
325 | #ifdef DEBUG_VLC | ||
326 | av_log(NULL,AV_LOG_DEBUG,"build table nb_codes=%d\n", nb_codes); | ||
327 | #endif | ||
328 | |||
329 | // buf = av_malloc((nb_codes+1)*sizeof(VLCcode)); | ||
330 | |||
331 | // assert(symbols_size <= 2 || !symbols); | ||
332 | j = 0; | ||
333 | #define COPY(condition)\ | ||
334 | for (i = 0; i < nb_codes; i++) {\ | ||
335 | GET_DATA(buf[j].bits, bits, i, bits_wrap, bits_size);\ | ||
336 | if (!(condition))\ | ||
337 | continue;\ | ||
338 | GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size);\ | ||
339 | /* if (flags & INIT_VLC_LE)*/\ | ||
340 | /* buf[j].code = bitswap_32(buf[j].code);*/\ | ||
341 | /* else*/\ | ||
342 | buf[j].code <<= 32 - buf[j].bits;\ | ||
343 | if (symbols)\ | ||
344 | GET_DATA(buf[j].symbol, symbols, i, symbols_wrap, symbols_size)\ | ||
345 | else\ | ||
346 | buf[j].symbol = i;\ | ||
347 | j++;\ | ||
348 | } | ||
349 | COPY(buf[j].bits > nb_bits); | ||
350 | // qsort is the slowest part of init_vlc, and could probably be improved or avoided | ||
351 | qsort(buf, j, sizeof(VLCcode), compare_vlcspec); | ||
352 | COPY(buf[j].bits && buf[j].bits <= nb_bits); | ||
353 | nb_codes = j; | ||
354 | |||
355 | ret = build_table(vlc, nb_bits, nb_codes, buf, flags); | ||
356 | |||
357 | // av_free(buf); | ||
358 | if (ret < 0) { | ||
359 | // av_freep(&vlc->table); | ||
360 | return -1; | ||
361 | } | ||
362 | if((flags & INIT_VLC_USE_NEW_STATIC) && vlc->table_size != vlc->table_allocated) { | ||
363 | av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", vlc->table_size, vlc->table_allocated); | ||
364 | } | ||
365 | return 0; | ||
366 | } | ||
367 | |||
368 | /* not used in rockbox | ||
369 | void free_vlc(VLC *vlc) | ||
370 | { | ||
371 | av_freep(&vlc->table); | ||
372 | } | ||
373 | */ | ||
374 | |||
diff --git a/apps/codecs/lib/ffmpeg_bswap.h b/apps/codecs/lib/ffmpeg_bswap.h deleted file mode 100644 index 24a2aab7ea..0000000000 --- a/apps/codecs/lib/ffmpeg_bswap.h +++ /dev/null | |||
@@ -1,150 +0,0 @@ | |||
1 | /** | ||
2 | * @file bswap.h | ||
3 | * byte swap. | ||
4 | */ | ||
5 | |||
6 | #ifndef __BSWAP_H__ | ||
7 | #define __BSWAP_H__ | ||
8 | |||
9 | #ifdef HAVE_BYTESWAP_H | ||
10 | #include <byteswap.h> | ||
11 | #else | ||
12 | |||
13 | #ifdef ROCKBOX | ||
14 | #include "codecs.h" | ||
15 | |||
16 | /* rockbox' optimised inline functions */ | ||
17 | #define bswap_16(x) swap16(x) | ||
18 | #define bswap_32(x) swap32(x) | ||
19 | |||
20 | static inline uint64_t ByteSwap64(uint64_t x) | ||
21 | { | ||
22 | union { | ||
23 | uint64_t ll; | ||
24 | struct { | ||
25 | uint32_t l,h; | ||
26 | } l; | ||
27 | } r; | ||
28 | r.l.l = bswap_32 (x); | ||
29 | r.l.h = bswap_32 (x>>32); | ||
30 | return r.ll; | ||
31 | } | ||
32 | #define bswap_64(x) ByteSwap64(x) | ||
33 | |||
34 | #elif defined(ARCH_X86) | ||
35 | static inline unsigned short ByteSwap16(unsigned short x) | ||
36 | { | ||
37 | __asm("xchgb %b0,%h0" : | ||
38 | "=q" (x) : | ||
39 | "0" (x)); | ||
40 | return x; | ||
41 | } | ||
42 | #define bswap_16(x) ByteSwap16(x) | ||
43 | |||
44 | static inline unsigned int ByteSwap32(unsigned int x) | ||
45 | { | ||
46 | #if __CPU__ > 386 | ||
47 | __asm("bswap %0": | ||
48 | "=r" (x) : | ||
49 | #else | ||
50 | __asm("xchgb %b0,%h0\n" | ||
51 | " rorl $16,%0\n" | ||
52 | " xchgb %b0,%h0": | ||
53 | "=q" (x) : | ||
54 | #endif | ||
55 | "0" (x)); | ||
56 | return x; | ||
57 | } | ||
58 | #define bswap_32(x) ByteSwap32(x) | ||
59 | |||
60 | static inline unsigned long long int ByteSwap64(unsigned long long int x) | ||
61 | { | ||
62 | register union { __extension__ uint64_t __ll; | ||
63 | uint32_t __l[2]; } __x; | ||
64 | asm("xchgl %0,%1": | ||
65 | "=r"(__x.__l[0]),"=r"(__x.__l[1]): | ||
66 | "0"(bswap_32((unsigned long)x)),"1"(bswap_32((unsigned long)(x>>32)))); | ||
67 | return __x.__ll; | ||
68 | } | ||
69 | #define bswap_64(x) ByteSwap64(x) | ||
70 | |||
71 | #elif defined(ARCH_SH4) | ||
72 | |||
73 | static inline uint16_t ByteSwap16(uint16_t x) { | ||
74 | __asm__("swap.b %0,%0":"=r"(x):"0"(x)); | ||
75 | return x; | ||
76 | } | ||
77 | |||
78 | static inline uint32_t ByteSwap32(uint32_t x) { | ||
79 | __asm__( | ||
80 | "swap.b %0,%0\n" | ||
81 | "swap.w %0,%0\n" | ||
82 | "swap.b %0,%0\n" | ||
83 | :"=r"(x):"0"(x)); | ||
84 | return x; | ||
85 | } | ||
86 | |||
87 | #define bswap_16(x) ByteSwap16(x) | ||
88 | #define bswap_32(x) ByteSwap32(x) | ||
89 | |||
90 | static inline uint64_t ByteSwap64(uint64_t x) | ||
91 | { | ||
92 | union { | ||
93 | uint64_t ll; | ||
94 | struct { | ||
95 | uint32_t l,h; | ||
96 | } l; | ||
97 | } r; | ||
98 | r.l.l = bswap_32 (x); | ||
99 | r.l.h = bswap_32 (x>>32); | ||
100 | return r.ll; | ||
101 | } | ||
102 | #define bswap_64(x) ByteSwap64(x) | ||
103 | |||
104 | #else | ||
105 | |||
106 | #define bswap_16(x) (((x) & 0x00ff) << 8 | ((x) & 0xff00) >> 8) | ||
107 | |||
108 | |||
109 | // code from bits/byteswap.h (C) 1997, 1998 Free Software Foundation, Inc. | ||
110 | #define bswap_32(x) \ | ||
111 | ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ | ||
112 | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) | ||
113 | |||
114 | static inline uint64_t ByteSwap64(uint64_t x) | ||
115 | { | ||
116 | union { | ||
117 | uint64_t ll; | ||
118 | uint32_t l[2]; | ||
119 | } w, r; | ||
120 | w.ll = x; | ||
121 | r.l[0] = bswap_32 (w.l[1]); | ||
122 | r.l[1] = bswap_32 (w.l[0]); | ||
123 | return r.ll; | ||
124 | } | ||
125 | #define bswap_64(x) ByteSwap64(x) | ||
126 | |||
127 | #endif /* !ARCH_X86 */ | ||
128 | |||
129 | #endif /* !HAVE_BYTESWAP_H */ | ||
130 | |||
131 | // be2me ... BigEndian to MachineEndian | ||
132 | // le2me ... LittleEndian to MachineEndian | ||
133 | |||
134 | #ifdef ROCKBOX_BIG_ENDIAN | ||
135 | #define be2me_16(x) (x) | ||
136 | #define be2me_32(x) (x) | ||
137 | #define be2me_64(x) (x) | ||
138 | #define le2me_16(x) bswap_16(x) | ||
139 | #define le2me_32(x) bswap_32(x) | ||
140 | #define le2me_64(x) bswap_64(x) | ||
141 | #else | ||
142 | #define be2me_16(x) bswap_16(x) | ||
143 | #define be2me_32(x) bswap_32(x) | ||
144 | #define be2me_64(x) bswap_64(x) | ||
145 | #define le2me_16(x) (x) | ||
146 | #define le2me_32(x) (x) | ||
147 | #define le2me_64(x) (x) | ||
148 | #endif | ||
149 | |||
150 | #endif /* __BSWAP_H__ */ | ||
diff --git a/apps/codecs/lib/ffmpeg_get_bits.h b/apps/codecs/lib/ffmpeg_get_bits.h deleted file mode 100644 index 04eda021a7..0000000000 --- a/apps/codecs/lib/ffmpeg_get_bits.h +++ /dev/null | |||
@@ -1,743 +0,0 @@ | |||
1 | /* | ||
2 | * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file | ||
23 | * bitstream reader API header. | ||
24 | */ | ||
25 | |||
26 | #ifndef AVCODEC_GET_BITS_H | ||
27 | #define AVCODEC_GET_BITS_H | ||
28 | |||
29 | #include <stdint.h> | ||
30 | #include <stdlib.h> | ||
31 | #include "ffmpeg_intreadwrite.h" | ||
32 | //#include <assert.h> | ||
33 | //#include "libavutil/bswap.h" | ||
34 | //#include "libavutil/common.h" | ||
35 | //#include "libavutil/intreadwrite.h" | ||
36 | //#include "libavutil/log.h" | ||
37 | //#include "mathops.h" | ||
38 | |||
39 | #include "codecs.h" | ||
40 | |||
41 | /* rockbox' optimised inline functions */ | ||
42 | #define bswap_16(x) swap16(x) | ||
43 | #define bswap_32(x) swap32(x) | ||
44 | |||
45 | #ifdef ROCKBOX_BIG_ENDIAN | ||
46 | #define be2me_16(x) (x) | ||
47 | #define be2me_32(x) (x) | ||
48 | #define le2me_16(x) bswap_16(x) | ||
49 | #define le2me_32(x) bswap_32(x) | ||
50 | #else | ||
51 | #define be2me_16(x) bswap_16(x) | ||
52 | #define be2me_32(x) bswap_32(x) | ||
53 | #define le2me_16(x) (x) | ||
54 | #define le2me_32(x) (x) | ||
55 | #endif | ||
56 | |||
57 | #define av_const __attribute__((const)) | ||
58 | #define av_always_inline inline __attribute__((always_inline)) | ||
59 | |||
60 | /* The following is taken from mathops.h */ | ||
61 | |||
62 | #ifndef sign_extend | ||
63 | static inline av_const int sign_extend(int val, unsigned bits) | ||
64 | { | ||
65 | return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits); | ||
66 | } | ||
67 | #endif | ||
68 | |||
69 | #ifndef NEG_SSR32 | ||
70 | # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s))) | ||
71 | #endif | ||
72 | |||
73 | #ifndef NEG_USR32 | ||
74 | # define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s))) | ||
75 | #endif | ||
76 | |||
77 | /* these 2 are from libavutil/common.h */ | ||
78 | |||
79 | #define FFMAX(a,b) ((a) > (b) ? (a) : (b)) | ||
80 | #define FFMIN(a,b) ((a) > (b) ? (b) : (a)) | ||
81 | |||
82 | #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER) | ||
83 | # define ALT_BITSTREAM_READER | ||
84 | #endif | ||
85 | |||
86 | /* | ||
87 | #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER) | ||
88 | # if ARCH_ARM && !HAVE_FAST_UNALIGNED | ||
89 | # define A32_BITSTREAM_READER | ||
90 | # else | ||
91 | */ | ||
92 | # define ALT_BITSTREAM_READER | ||
93 | /* | ||
94 | //#define LIBMPEG2_BITSTREAM_READER | ||
95 | //#define A32_BITSTREAM_READER | ||
96 | # endif | ||
97 | #endif | ||
98 | */ | ||
99 | |||
100 | /* bit input */ | ||
101 | /* buffer, buffer_end and size_in_bits must be present and used by every reader */ | ||
102 | typedef struct GetBitContext { | ||
103 | const uint8_t *buffer, *buffer_end; | ||
104 | #ifdef ALT_BITSTREAM_READER | ||
105 | int index; | ||
106 | #elif defined LIBMPEG2_BITSTREAM_READER | ||
107 | uint8_t *buffer_ptr; | ||
108 | uint32_t cache; | ||
109 | int bit_count; | ||
110 | #elif defined A32_BITSTREAM_READER | ||
111 | uint32_t *buffer_ptr; | ||
112 | uint32_t cache0; | ||
113 | uint32_t cache1; | ||
114 | int bit_count; | ||
115 | #endif | ||
116 | int size_in_bits; | ||
117 | } GetBitContext; | ||
118 | |||
119 | #define VLC_TYPE int16_t | ||
120 | |||
121 | typedef struct VLC { | ||
122 | int bits; | ||
123 | VLC_TYPE (*table)[2]; ///< code, bits | ||
124 | int table_size, table_allocated; | ||
125 | } VLC; | ||
126 | |||
127 | typedef struct RL_VLC_ELEM { | ||
128 | int16_t level; | ||
129 | int8_t len; | ||
130 | uint8_t run; | ||
131 | } RL_VLC_ELEM; | ||
132 | |||
133 | /* Bitstream reader API docs: | ||
134 | name | ||
135 | arbitrary name which is used as prefix for the internal variables | ||
136 | |||
137 | gb | ||
138 | getbitcontext | ||
139 | |||
140 | OPEN_READER(name, gb) | ||
141 | loads gb into local variables | ||
142 | |||
143 | CLOSE_READER(name, gb) | ||
144 | stores local vars in gb | ||
145 | |||
146 | UPDATE_CACHE(name, gb) | ||
147 | refills the internal cache from the bitstream | ||
148 | after this call at least MIN_CACHE_BITS will be available, | ||
149 | |||
150 | GET_CACHE(name, gb) | ||
151 | will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit) | ||
152 | |||
153 | SHOW_UBITS(name, gb, num) | ||
154 | will return the next num bits | ||
155 | |||
156 | SHOW_SBITS(name, gb, num) | ||
157 | will return the next num bits and do sign extension | ||
158 | |||
159 | SKIP_BITS(name, gb, num) | ||
160 | will skip over the next num bits | ||
161 | note, this is equivalent to SKIP_CACHE; SKIP_COUNTER | ||
162 | |||
163 | SKIP_CACHE(name, gb, num) | ||
164 | will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER) | ||
165 | |||
166 | SKIP_COUNTER(name, gb, num) | ||
167 | will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS) | ||
168 | |||
169 | LAST_SKIP_CACHE(name, gb, num) | ||
170 | will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing | ||
171 | |||
172 | LAST_SKIP_BITS(name, gb, num) | ||
173 | is equivalent to LAST_SKIP_CACHE; SKIP_COUNTER | ||
174 | |||
175 | for examples see get_bits, show_bits, skip_bits, get_vlc | ||
176 | */ | ||
177 | |||
178 | #ifdef ALT_BITSTREAM_READER | ||
179 | # define MIN_CACHE_BITS 25 | ||
180 | |||
181 | |||
182 | /* ROCKBOX: work around "set but not used" warning */ | ||
183 | # define OPEN_READER(name, gb)\ | ||
184 | unsigned int name##_index= (gb)->index;\ | ||
185 | int name##_cache __attribute__((unused)) = 0;\ | ||
186 | |||
187 | # define CLOSE_READER(name, gb)\ | ||
188 | (gb)->index= name##_index;\ | ||
189 | |||
190 | # ifdef ALT_BITSTREAM_READER_LE | ||
191 | # define UPDATE_CACHE(name, gb)\ | ||
192 | name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\ | ||
193 | |||
194 | # define SKIP_CACHE(name, gb, num)\ | ||
195 | name##_cache >>= (num); | ||
196 | # else | ||
197 | # define UPDATE_CACHE(name, gb)\ | ||
198 | name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\ | ||
199 | |||
200 | # define SKIP_CACHE(name, gb, num)\ | ||
201 | name##_cache <<= (num); | ||
202 | # endif | ||
203 | |||
204 | // FIXME name? | ||
205 | # define SKIP_COUNTER(name, gb, num)\ | ||
206 | name##_index += (num);\ | ||
207 | |||
208 | # define SKIP_BITS(name, gb, num)\ | ||
209 | {\ | ||
210 | SKIP_CACHE(name, gb, num)\ | ||
211 | SKIP_COUNTER(name, gb, num)\ | ||
212 | }\ | ||
213 | |||
214 | # define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num) | ||
215 | # define LAST_SKIP_CACHE(name, gb, num) ; | ||
216 | |||
217 | # ifdef ALT_BITSTREAM_READER_LE | ||
218 | # define SHOW_UBITS(name, gb, num)\ | ||
219 | zero_extend(name##_cache, num) | ||
220 | |||
221 | # define SHOW_SBITS(name, gb, num)\ | ||
222 | sign_extend(name##_cache, num) | ||
223 | # else | ||
224 | # define SHOW_UBITS(name, gb, num)\ | ||
225 | NEG_USR32(name##_cache, num) | ||
226 | |||
227 | # define SHOW_SBITS(name, gb, num)\ | ||
228 | NEG_SSR32(name##_cache, num) | ||
229 | # endif | ||
230 | |||
231 | # define GET_CACHE(name, gb)\ | ||
232 | ((uint32_t)name##_cache) | ||
233 | |||
234 | static inline int get_bits_count(const GetBitContext *s){ | ||
235 | return s->index; | ||
236 | } | ||
237 | |||
238 | static inline void skip_bits_long(GetBitContext *s, int n){ | ||
239 | s->index += n; | ||
240 | } | ||
241 | |||
242 | #elif defined LIBMPEG2_BITSTREAM_READER | ||
243 | //libmpeg2 like reader | ||
244 | |||
245 | # define MIN_CACHE_BITS 17 | ||
246 | |||
247 | # define OPEN_READER(name, gb)\ | ||
248 | int name##_bit_count=(gb)->bit_count;\ | ||
249 | int name##_cache= (gb)->cache;\ | ||
250 | uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\ | ||
251 | |||
252 | # define CLOSE_READER(name, gb)\ | ||
253 | (gb)->bit_count= name##_bit_count;\ | ||
254 | (gb)->cache= name##_cache;\ | ||
255 | (gb)->buffer_ptr= name##_buffer_ptr;\ | ||
256 | |||
257 | # define UPDATE_CACHE(name, gb)\ | ||
258 | if(name##_bit_count >= 0){\ | ||
259 | name##_cache+= AV_RB16(name##_buffer_ptr) << name##_bit_count; \ | ||
260 | name##_buffer_ptr+=2;\ | ||
261 | name##_bit_count-= 16;\ | ||
262 | }\ | ||
263 | |||
264 | # define SKIP_CACHE(name, gb, num)\ | ||
265 | name##_cache <<= (num);\ | ||
266 | |||
267 | # define SKIP_COUNTER(name, gb, num)\ | ||
268 | name##_bit_count += (num);\ | ||
269 | |||
270 | # define SKIP_BITS(name, gb, num)\ | ||
271 | {\ | ||
272 | SKIP_CACHE(name, gb, num)\ | ||
273 | SKIP_COUNTER(name, gb, num)\ | ||
274 | }\ | ||
275 | |||
276 | # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) | ||
277 | # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) | ||
278 | |||
279 | # define SHOW_UBITS(name, gb, num)\ | ||
280 | NEG_USR32(name##_cache, num) | ||
281 | |||
282 | # define SHOW_SBITS(name, gb, num)\ | ||
283 | NEG_SSR32(name##_cache, num) | ||
284 | |||
285 | # define GET_CACHE(name, gb)\ | ||
286 | ((uint32_t)name##_cache) | ||
287 | |||
288 | static inline int get_bits_count(const GetBitContext *s){ | ||
289 | return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count; | ||
290 | } | ||
291 | |||
292 | static inline void skip_bits_long(GetBitContext *s, int n){ | ||
293 | OPEN_READER(re, s) | ||
294 | re_bit_count += n; | ||
295 | re_buffer_ptr += 2*(re_bit_count>>4); | ||
296 | re_bit_count &= 15; | ||
297 | re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count); | ||
298 | UPDATE_CACHE(re, s) | ||
299 | CLOSE_READER(re, s) | ||
300 | } | ||
301 | |||
302 | #elif defined A32_BITSTREAM_READER | ||
303 | |||
304 | # define MIN_CACHE_BITS 32 | ||
305 | |||
306 | # define OPEN_READER(name, gb)\ | ||
307 | int name##_bit_count=(gb)->bit_count;\ | ||
308 | uint32_t name##_cache0= (gb)->cache0;\ | ||
309 | uint32_t name##_cache1= (gb)->cache1;\ | ||
310 | uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\ | ||
311 | |||
312 | # define CLOSE_READER(name, gb)\ | ||
313 | (gb)->bit_count= name##_bit_count;\ | ||
314 | (gb)->cache0= name##_cache0;\ | ||
315 | (gb)->cache1= name##_cache1;\ | ||
316 | (gb)->buffer_ptr= name##_buffer_ptr;\ | ||
317 | |||
318 | # define UPDATE_CACHE(name, gb)\ | ||
319 | if(name##_bit_count > 0){\ | ||
320 | const uint32_t next= av_be2ne32( *name##_buffer_ptr );\ | ||
321 | name##_cache0 |= NEG_USR32(next,name##_bit_count);\ | ||
322 | name##_cache1 |= next<<name##_bit_count;\ | ||
323 | name##_buffer_ptr++;\ | ||
324 | name##_bit_count-= 32;\ | ||
325 | }\ | ||
326 | |||
327 | #if ARCH_X86 | ||
328 | # define SKIP_CACHE(name, gb, num)\ | ||
329 | __asm__(\ | ||
330 | "shldl %2, %1, %0 \n\t"\ | ||
331 | "shll %2, %1 \n\t"\ | ||
332 | : "+r" (name##_cache0), "+r" (name##_cache1)\ | ||
333 | : "Ic" ((uint8_t)(num))\ | ||
334 | ); | ||
335 | #else | ||
336 | # define SKIP_CACHE(name, gb, num)\ | ||
337 | name##_cache0 <<= (num);\ | ||
338 | name##_cache0 |= NEG_USR32(name##_cache1,num);\ | ||
339 | name##_cache1 <<= (num); | ||
340 | #endif | ||
341 | |||
342 | # define SKIP_COUNTER(name, gb, num)\ | ||
343 | name##_bit_count += (num);\ | ||
344 | |||
345 | # define SKIP_BITS(name, gb, num)\ | ||
346 | {\ | ||
347 | SKIP_CACHE(name, gb, num)\ | ||
348 | SKIP_COUNTER(name, gb, num)\ | ||
349 | }\ | ||
350 | |||
351 | # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num) | ||
352 | # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num) | ||
353 | |||
354 | # define SHOW_UBITS(name, gb, num)\ | ||
355 | NEG_USR32(name##_cache0, num) | ||
356 | |||
357 | # define SHOW_SBITS(name, gb, num)\ | ||
358 | NEG_SSR32(name##_cache0, num) | ||
359 | |||
360 | # define GET_CACHE(name, gb)\ | ||
361 | (name##_cache0) | ||
362 | |||
363 | static inline int get_bits_count(const GetBitContext *s){ | ||
364 | return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count; | ||
365 | } | ||
366 | |||
367 | static inline void skip_bits_long(GetBitContext *s, int n){ | ||
368 | OPEN_READER(re, s) | ||
369 | re_bit_count += n; | ||
370 | re_buffer_ptr += re_bit_count>>5; | ||
371 | re_bit_count &= 31; | ||
372 | re_cache0 = av_be2ne32( re_buffer_ptr[-1] ) << re_bit_count; | ||
373 | re_cache1 = 0; | ||
374 | UPDATE_CACHE(re, s) | ||
375 | CLOSE_READER(re, s) | ||
376 | } | ||
377 | |||
378 | #endif | ||
379 | |||
380 | /** | ||
381 | * read mpeg1 dc style vlc (sign bit + mantisse with no MSB). | ||
382 | * if MSB not set it is negative | ||
383 | * @param n length in bits | ||
384 | * @author BERO | ||
385 | */ | ||
386 | static inline int get_xbits(GetBitContext *s, int n){ | ||
387 | register int sign; | ||
388 | register int32_t cache; | ||
389 | OPEN_READER(re, s) | ||
390 | UPDATE_CACHE(re, s) | ||
391 | cache = GET_CACHE(re,s); | ||
392 | sign=(~cache)>>31; | ||
393 | LAST_SKIP_BITS(re, s, n) | ||
394 | CLOSE_READER(re, s) | ||
395 | return (NEG_USR32(sign ^ cache, n) ^ sign) - sign; | ||
396 | } | ||
397 | |||
398 | static inline int get_sbits(GetBitContext *s, int n){ | ||
399 | register int tmp; | ||
400 | OPEN_READER(re, s) | ||
401 | UPDATE_CACHE(re, s) | ||
402 | tmp= SHOW_SBITS(re, s, n); | ||
403 | LAST_SKIP_BITS(re, s, n) | ||
404 | CLOSE_READER(re, s) | ||
405 | return tmp; | ||
406 | } | ||
407 | |||
408 | /** | ||
409 | * reads 1-17 bits. | ||
410 | * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't | ||
411 | */ | ||
412 | static inline unsigned int get_bits(GetBitContext *s, int n){ | ||
413 | register int tmp; | ||
414 | OPEN_READER(re, s) | ||
415 | UPDATE_CACHE(re, s) | ||
416 | tmp= SHOW_UBITS(re, s, n); | ||
417 | LAST_SKIP_BITS(re, s, n) | ||
418 | CLOSE_READER(re, s) | ||
419 | return tmp; | ||
420 | } | ||
421 | |||
422 | /** | ||
423 | * shows 1-17 bits. | ||
424 | * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't | ||
425 | */ | ||
426 | static inline unsigned int show_bits(GetBitContext *s, int n){ | ||
427 | register int tmp; | ||
428 | OPEN_READER(re, s) | ||
429 | UPDATE_CACHE(re, s) | ||
430 | tmp= SHOW_UBITS(re, s, n); | ||
431 | // CLOSE_READER(re, s) | ||
432 | return tmp; | ||
433 | } | ||
434 | |||
435 | static inline void skip_bits(GetBitContext *s, int n){ | ||
436 | //Note gcc seems to optimize this to s->index+=n for the ALT_READER :)) | ||
437 | OPEN_READER(re, s) | ||
438 | UPDATE_CACHE(re, s) | ||
439 | LAST_SKIP_BITS(re, s, n) | ||
440 | CLOSE_READER(re, s) | ||
441 | } | ||
442 | |||
443 | static inline unsigned int get_bits1(GetBitContext *s){ | ||
444 | #ifdef ALT_BITSTREAM_READER | ||
445 | unsigned int index= s->index; | ||
446 | uint8_t result= s->buffer[ index>>3 ]; | ||
447 | #ifdef ALT_BITSTREAM_READER_LE | ||
448 | result>>= (index&0x07); | ||
449 | result&= 1; | ||
450 | #else | ||
451 | result<<= (index&0x07); | ||
452 | result>>= 8 - 1; | ||
453 | #endif | ||
454 | index++; | ||
455 | s->index= index; | ||
456 | |||
457 | return result; | ||
458 | #else | ||
459 | return get_bits(s, 1); | ||
460 | #endif | ||
461 | } | ||
462 | |||
463 | static inline unsigned int show_bits1(GetBitContext *s){ | ||
464 | return show_bits(s, 1); | ||
465 | } | ||
466 | |||
467 | static inline void skip_bits1(GetBitContext *s){ | ||
468 | skip_bits(s, 1); | ||
469 | } | ||
470 | |||
471 | /** | ||
472 | * reads 0-32 bits. | ||
473 | */ | ||
474 | static inline unsigned int get_bits_long(GetBitContext *s, int n){ | ||
475 | if(n<=MIN_CACHE_BITS) return get_bits(s, n); | ||
476 | else{ | ||
477 | #ifdef ALT_BITSTREAM_READER_LE | ||
478 | int ret= get_bits(s, 16); | ||
479 | return ret | (get_bits(s, n-16) << 16); | ||
480 | #else | ||
481 | int ret= get_bits(s, 16) << (n-16); | ||
482 | return ret | get_bits(s, n-16); | ||
483 | #endif | ||
484 | } | ||
485 | } | ||
486 | |||
487 | /** | ||
488 | * reads 0-32 bits as a signed integer. | ||
489 | */ | ||
490 | static inline int get_sbits_long(GetBitContext *s, int n) { | ||
491 | return sign_extend(get_bits_long(s, n), n); | ||
492 | } | ||
493 | |||
494 | /** | ||
495 | * shows 0-32 bits. | ||
496 | */ | ||
497 | static inline unsigned int show_bits_long(GetBitContext *s, int n){ | ||
498 | if(n<=MIN_CACHE_BITS) return show_bits(s, n); | ||
499 | else{ | ||
500 | GetBitContext gb= *s; | ||
501 | return get_bits_long(&gb, n); | ||
502 | } | ||
503 | } | ||
504 | |||
505 | /* not used | ||
506 | static inline int check_marker(GetBitContext *s, const char *msg) | ||
507 | { | ||
508 | int bit= get_bits1(s); | ||
509 | if(!bit) | ||
510 | av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg); | ||
511 | |||
512 | return bit; | ||
513 | } | ||
514 | */ | ||
515 | |||
516 | /** | ||
517 | * init GetBitContext. | ||
518 | * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits | ||
519 | * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end | ||
520 | * @param bit_size the size of the buffer in bits | ||
521 | * | ||
522 | * While GetBitContext stores the buffer size, for performance reasons you are | ||
523 | * responsible for checking for the buffer end yourself (take advantage of the padding)! | ||
524 | */ | ||
525 | static inline void init_get_bits(GetBitContext *s, | ||
526 | const uint8_t *buffer, int bit_size) | ||
527 | { | ||
528 | int buffer_size= (bit_size+7)>>3; | ||
529 | if(buffer_size < 0 || bit_size < 0) { | ||
530 | buffer_size = bit_size = 0; | ||
531 | buffer = NULL; | ||
532 | } | ||
533 | |||
534 | s->buffer= buffer; | ||
535 | s->size_in_bits= bit_size; | ||
536 | s->buffer_end= buffer + buffer_size; | ||
537 | #ifdef ALT_BITSTREAM_READER | ||
538 | s->index=0; | ||
539 | #elif defined LIBMPEG2_BITSTREAM_READER | ||
540 | s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1)); | ||
541 | s->bit_count = 16 + 8*((intptr_t)buffer&1); | ||
542 | skip_bits_long(s, 0); | ||
543 | #elif defined A32_BITSTREAM_READER | ||
544 | s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3)); | ||
545 | s->bit_count = 32 + 8*((intptr_t)buffer&3); | ||
546 | skip_bits_long(s, 0); | ||
547 | #endif | ||
548 | } | ||
549 | |||
550 | static inline void align_get_bits(GetBitContext *s) | ||
551 | { | ||
552 | int n= (-get_bits_count(s)) & 7; | ||
553 | if(n) skip_bits(s, n); | ||
554 | } | ||
555 | |||
556 | #define init_vlc(vlc, nb_bits, nb_codes,\ | ||
557 | bits, bits_wrap, bits_size,\ | ||
558 | codes, codes_wrap, codes_size,\ | ||
559 | flags)\ | ||
560 | init_vlc_sparse(vlc, nb_bits, nb_codes,\ | ||
561 | bits, bits_wrap, bits_size,\ | ||
562 | codes, codes_wrap, codes_size,\ | ||
563 | NULL, 0, 0, flags) | ||
564 | |||
565 | int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, | ||
566 | const void *bits, int bits_wrap, int bits_size, | ||
567 | const void *codes, int codes_wrap, int codes_size, | ||
568 | const void *symbols, int symbols_wrap, int symbols_size, | ||
569 | int flags); | ||
570 | #define INIT_VLC_LE 2 | ||
571 | #define INIT_VLC_USE_NEW_STATIC 4 | ||
572 | void free_vlc(VLC *vlc); | ||
573 | |||
574 | #define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size, attr)\ | ||
575 | {\ | ||
576 | static VLC_TYPE table[static_size][2] attr;\ | ||
577 | (vlc)->table= table;\ | ||
578 | (vlc)->table_allocated= static_size;\ | ||
579 | init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);\ | ||
580 | } | ||
581 | |||
582 | |||
583 | /** | ||
584 | * | ||
585 | * If the vlc code is invalid and max_depth=1, then no bits will be removed. | ||
586 | * If the vlc code is invalid and max_depth>1, then the number of bits removed | ||
587 | * is undefined. | ||
588 | */ | ||
589 | #define GET_VLC(code, name, gb, table, bits, max_depth)\ | ||
590 | {\ | ||
591 | int n, nb_bits;\ | ||
592 | unsigned int index;\ | ||
593 | \ | ||
594 | index= SHOW_UBITS(name, gb, bits);\ | ||
595 | code = table[index][0];\ | ||
596 | n = table[index][1];\ | ||
597 | \ | ||
598 | if(max_depth > 1 && n < 0){\ | ||
599 | LAST_SKIP_BITS(name, gb, bits)\ | ||
600 | UPDATE_CACHE(name, gb)\ | ||
601 | \ | ||
602 | nb_bits = -n;\ | ||
603 | \ | ||
604 | index= SHOW_UBITS(name, gb, nb_bits) + code;\ | ||
605 | code = table[index][0];\ | ||
606 | n = table[index][1];\ | ||
607 | if(max_depth > 2 && n < 0){\ | ||
608 | LAST_SKIP_BITS(name, gb, nb_bits)\ | ||
609 | UPDATE_CACHE(name, gb)\ | ||
610 | \ | ||
611 | nb_bits = -n;\ | ||
612 | \ | ||
613 | index= SHOW_UBITS(name, gb, nb_bits) + code;\ | ||
614 | code = table[index][0];\ | ||
615 | n = table[index][1];\ | ||
616 | }\ | ||
617 | }\ | ||
618 | SKIP_BITS(name, gb, n)\ | ||
619 | } | ||
620 | |||
621 | #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\ | ||
622 | {\ | ||
623 | int n, nb_bits;\ | ||
624 | unsigned int index;\ | ||
625 | \ | ||
626 | index= SHOW_UBITS(name, gb, bits);\ | ||
627 | level = table[index].level;\ | ||
628 | n = table[index].len;\ | ||
629 | \ | ||
630 | if(max_depth > 1 && n < 0){\ | ||
631 | SKIP_BITS(name, gb, bits)\ | ||
632 | if(need_update){\ | ||
633 | UPDATE_CACHE(name, gb)\ | ||
634 | }\ | ||
635 | \ | ||
636 | nb_bits = -n;\ | ||
637 | \ | ||
638 | index= SHOW_UBITS(name, gb, nb_bits) + level;\ | ||
639 | level = table[index].level;\ | ||
640 | n = table[index].len;\ | ||
641 | }\ | ||
642 | run= table[index].run;\ | ||
643 | SKIP_BITS(name, gb, n)\ | ||
644 | } | ||
645 | |||
646 | |||
647 | /** | ||
648 | * parses a vlc code, faster then get_vlc() | ||
649 | * @param bits is the number of bits which will be read at once, must be | ||
650 | * identical to nb_bits in init_vlc() | ||
651 | * @param max_depth is the number of times bits bits must be read to completely | ||
652 | * read the longest vlc code | ||
653 | * = (max_vlc_length + bits - 1) / bits | ||
654 | */ | ||
655 | static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2], | ||
656 | int bits, int max_depth) | ||
657 | { | ||
658 | int code; | ||
659 | |||
660 | OPEN_READER(re, s) | ||
661 | UPDATE_CACHE(re, s) | ||
662 | |||
663 | GET_VLC(code, re, s, table, bits, max_depth) | ||
664 | |||
665 | CLOSE_READER(re, s) | ||
666 | return code; | ||
667 | } | ||
668 | |||
669 | //#define TRACE | ||
670 | |||
671 | #ifdef TRACE | ||
672 | static inline void print_bin(int bits, int n){ | ||
673 | int i; | ||
674 | |||
675 | for(i=n-1; i>=0; i--){ | ||
676 | av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1); | ||
677 | } | ||
678 | for(i=n; i<24; i++) | ||
679 | av_log(NULL, AV_LOG_DEBUG, " "); | ||
680 | } | ||
681 | |||
682 | static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ | ||
683 | int r= get_bits(s, n); | ||
684 | |||
685 | print_bin(r, n); | ||
686 | av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line); | ||
687 | return r; | ||
688 | } | ||
689 | static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){ | ||
690 | int show= show_bits(s, 24); | ||
691 | int pos= get_bits_count(s); | ||
692 | int r= get_vlc2(s, table, bits, max_depth); | ||
693 | int len= get_bits_count(s) - pos; | ||
694 | int bits2= show>>(24-len); | ||
695 | |||
696 | print_bin(bits2, len); | ||
697 | |||
698 | av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line); | ||
699 | return r; | ||
700 | } | ||
701 | static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){ | ||
702 | int show= show_bits(s, n); | ||
703 | int r= get_xbits(s, n); | ||
704 | |||
705 | print_bin(show, n); | ||
706 | av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line); | ||
707 | return r; | ||
708 | } | ||
709 | |||
710 | #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | ||
711 | #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__) | ||
712 | #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__) | ||
713 | #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__) | ||
714 | #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__) | ||
715 | |||
716 | #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__) | ||
717 | |||
718 | #else //TRACE | ||
719 | #define tprintf(p, ...) {} | ||
720 | #endif | ||
721 | |||
722 | static inline int decode012(GetBitContext *gb){ | ||
723 | int n; | ||
724 | n = get_bits1(gb); | ||
725 | if (n == 0) | ||
726 | return 0; | ||
727 | else | ||
728 | return get_bits1(gb) + 1; | ||
729 | } | ||
730 | |||
731 | static inline int decode210(GetBitContext *gb){ | ||
732 | if (get_bits1(gb)) | ||
733 | return 0; | ||
734 | else | ||
735 | return 2 - get_bits1(gb); | ||
736 | } | ||
737 | |||
738 | static inline int get_bits_left(GetBitContext *gb) | ||
739 | { | ||
740 | return gb->size_in_bits - get_bits_count(gb); | ||
741 | } | ||
742 | |||
743 | #endif /* AVCODEC_GET_BITS_H */ | ||
diff --git a/apps/codecs/lib/ffmpeg_intreadwrite.h b/apps/codecs/lib/ffmpeg_intreadwrite.h deleted file mode 100644 index 24f03292e8..0000000000 --- a/apps/codecs/lib/ffmpeg_intreadwrite.h +++ /dev/null | |||
@@ -1,484 +0,0 @@ | |||
1 | /* | ||
2 | * This file is part of FFmpeg. | ||
3 | * | ||
4 | * FFmpeg is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * FFmpeg is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with FFmpeg; if not, write to the Free Software | ||
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
17 | */ | ||
18 | |||
19 | #ifndef AVUTIL_INTREADWRITE_H | ||
20 | #define AVUTIL_INTREADWRITE_H | ||
21 | |||
22 | #include <stdint.h> | ||
23 | /* | ||
24 | * Arch-specific headers can provide any combination of | ||
25 | * AV_[RW][BLN](16|24|32|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. | ||
26 | * Preprocessor symbols must be defined, even if these are implemented | ||
27 | * as inline functions. | ||
28 | */ | ||
29 | |||
30 | /* | ||
31 | * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. | ||
32 | */ | ||
33 | #define HAVE_BIGENDIAN 0 | ||
34 | #if HAVE_BIGENDIAN | ||
35 | |||
36 | # if defined(AV_RN16) && !defined(AV_RB16) | ||
37 | # define AV_RB16(p) AV_RN16(p) | ||
38 | # elif !defined(AV_RN16) && defined(AV_RB16) | ||
39 | # define AV_RN16(p) AV_RB16(p) | ||
40 | # endif | ||
41 | |||
42 | # if defined(AV_WN16) && !defined(AV_WB16) | ||
43 | # define AV_WB16(p, v) AV_WN16(p, v) | ||
44 | # elif !defined(AV_WN16) && defined(AV_WB16) | ||
45 | # define AV_WN16(p, v) AV_WB16(p, v) | ||
46 | # endif | ||
47 | |||
48 | # if defined(AV_RN24) && !defined(AV_RB24) | ||
49 | # define AV_RB24(p) AV_RN24(p) | ||
50 | # elif !defined(AV_RN24) && defined(AV_RB24) | ||
51 | # define AV_RN24(p) AV_RB24(p) | ||
52 | # endif | ||
53 | |||
54 | # if defined(AV_WN24) && !defined(AV_WB24) | ||
55 | # define AV_WB24(p, v) AV_WN24(p, v) | ||
56 | # elif !defined(AV_WN24) && defined(AV_WB24) | ||
57 | # define AV_WN24(p, v) AV_WB24(p, v) | ||
58 | # endif | ||
59 | |||
60 | # if defined(AV_RN32) && !defined(AV_RB32) | ||
61 | # define AV_RB32(p) AV_RN32(p) | ||
62 | # elif !defined(AV_RN32) && defined(AV_RB32) | ||
63 | # define AV_RN32(p) AV_RB32(p) | ||
64 | # endif | ||
65 | |||
66 | # if defined(AV_WN32) && !defined(AV_WB32) | ||
67 | # define AV_WB32(p, v) AV_WN32(p, v) | ||
68 | # elif !defined(AV_WN32) && defined(AV_WB32) | ||
69 | # define AV_WN32(p, v) AV_WB32(p, v) | ||
70 | # endif | ||
71 | |||
72 | # if defined(AV_RN64) && !defined(AV_RB64) | ||
73 | # define AV_RB64(p) AV_RN64(p) | ||
74 | # elif !defined(AV_RN64) && defined(AV_RB64) | ||
75 | # define AV_RN64(p) AV_RB64(p) | ||
76 | # endif | ||
77 | |||
78 | # if defined(AV_WN64) && !defined(AV_WB64) | ||
79 | # define AV_WB64(p, v) AV_WN64(p, v) | ||
80 | # elif !defined(AV_WN64) && defined(AV_WB64) | ||
81 | # define AV_WN64(p, v) AV_WB64(p, v) | ||
82 | # endif | ||
83 | |||
84 | #else /* HAVE_BIGENDIAN */ | ||
85 | |||
86 | # if defined(AV_RN16) && !defined(AV_RL16) | ||
87 | # define AV_RL16(p) AV_RN16(p) | ||
88 | # elif !defined(AV_RN16) && defined(AV_RL16) | ||
89 | # define AV_RN16(p) AV_RL16(p) | ||
90 | # endif | ||
91 | |||
92 | # if defined(AV_WN16) && !defined(AV_WL16) | ||
93 | # define AV_WL16(p, v) AV_WN16(p, v) | ||
94 | # elif !defined(AV_WN16) && defined(AV_WL16) | ||
95 | # define AV_WN16(p, v) AV_WL16(p, v) | ||
96 | # endif | ||
97 | |||
98 | # if defined(AV_RN24) && !defined(AV_RL24) | ||
99 | # define AV_RL24(p) AV_RN24(p) | ||
100 | # elif !defined(AV_RN24) && defined(AV_RL24) | ||
101 | # define AV_RN24(p) AV_RL24(p) | ||
102 | # endif | ||
103 | |||
104 | # if defined(AV_WN24) && !defined(AV_WL24) | ||
105 | # define AV_WL24(p, v) AV_WN24(p, v) | ||
106 | # elif !defined(AV_WN24) && defined(AV_WL24) | ||
107 | # define AV_WN24(p, v) AV_WL24(p, v) | ||
108 | # endif | ||
109 | |||
110 | # if defined(AV_RN32) && !defined(AV_RL32) | ||
111 | # define AV_RL32(p) AV_RN32(p) | ||
112 | # elif !defined(AV_RN32) && defined(AV_RL32) | ||
113 | # define AV_RN32(p) AV_RL32(p) | ||
114 | # endif | ||
115 | |||
116 | # if defined(AV_WN32) && !defined(AV_WL32) | ||
117 | # define AV_WL32(p, v) AV_WN32(p, v) | ||
118 | # elif !defined(AV_WN32) && defined(AV_WL32) | ||
119 | # define AV_WN32(p, v) AV_WL32(p, v) | ||
120 | # endif | ||
121 | |||
122 | # if defined(AV_RN64) && !defined(AV_RL64) | ||
123 | # define AV_RL64(p) AV_RN64(p) | ||
124 | # elif !defined(AV_RN64) && defined(AV_RL64) | ||
125 | # define AV_RN64(p) AV_RL64(p) | ||
126 | # endif | ||
127 | |||
128 | # if defined(AV_WN64) && !defined(AV_WL64) | ||
129 | # define AV_WL64(p, v) AV_WN64(p, v) | ||
130 | # elif !defined(AV_WN64) && defined(AV_WL64) | ||
131 | # define AV_WN64(p, v) AV_WL64(p, v) | ||
132 | # endif | ||
133 | |||
134 | #endif /* !HAVE_BIGENDIAN */ | ||
135 | |||
136 | #define HAVE_ATTRIBUTE_PACKED 0 | ||
137 | #define HAVE_FAST_UNALIGNED 0 | ||
138 | /* | ||
139 | * Define AV_[RW]N helper macros to simplify definitions not provided | ||
140 | * by per-arch headers. | ||
141 | */ | ||
142 | |||
143 | #if HAVE_ATTRIBUTE_PACKED | ||
144 | |||
145 | union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; | ||
146 | union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; | ||
147 | union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias; | ||
148 | |||
149 | # define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) | ||
150 | # define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) | ||
151 | |||
152 | #elif defined(__DECC) | ||
153 | |||
154 | # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) | ||
155 | # define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) | ||
156 | |||
157 | #elif HAVE_FAST_UNALIGNED | ||
158 | |||
159 | # define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) | ||
160 | # define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | ||
161 | |||
162 | #else | ||
163 | |||
164 | #ifndef AV_RB16 | ||
165 | # define AV_RB16(x) \ | ||
166 | ((((const uint8_t*)(x))[0] << 8) | \ | ||
167 | ((const uint8_t*)(x))[1]) | ||
168 | #endif | ||
169 | #ifndef AV_WB16 | ||
170 | # define AV_WB16(p, d) do { \ | ||
171 | ((uint8_t*)(p))[1] = (d); \ | ||
172 | ((uint8_t*)(p))[0] = (d)>>8; \ | ||
173 | } while(0) | ||
174 | #endif | ||
175 | |||
176 | #ifndef AV_RL16 | ||
177 | # define AV_RL16(x) \ | ||
178 | ((((const uint8_t*)(x))[1] << 8) | \ | ||
179 | ((const uint8_t*)(x))[0]) | ||
180 | #endif | ||
181 | #ifndef AV_WL16 | ||
182 | # define AV_WL16(p, d) do { \ | ||
183 | ((uint8_t*)(p))[0] = (d); \ | ||
184 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
185 | } while(0) | ||
186 | #endif | ||
187 | |||
188 | #ifndef AV_RB32 | ||
189 | /* Coldfire and ARMv6 and above support unaligned long reads */ | ||
190 | #if defined CPU_COLDFIRE || (defined CPU_ARM && ARM_ARCH >= 6) | ||
191 | #define AV_RB32(x) (htobe32(*(const uint32_t*)(x))) | ||
192 | #else | ||
193 | # define AV_RB32(x) \ | ||
194 | ((((const uint8_t*)(x))[0] << 24) | \ | ||
195 | (((const uint8_t*)(x))[1] << 16) | \ | ||
196 | (((const uint8_t*)(x))[2] << 8) | \ | ||
197 | ((const uint8_t*)(x))[3]) | ||
198 | #endif | ||
199 | #endif | ||
200 | #ifndef AV_WB32 | ||
201 | # define AV_WB32(p, d) do { \ | ||
202 | ((uint8_t*)(p))[3] = (d); \ | ||
203 | ((uint8_t*)(p))[2] = (d)>>8; \ | ||
204 | ((uint8_t*)(p))[1] = (d)>>16; \ | ||
205 | ((uint8_t*)(p))[0] = (d)>>24; \ | ||
206 | } while(0) | ||
207 | #endif | ||
208 | |||
209 | #ifndef AV_RL32 | ||
210 | # define AV_RL32(x) \ | ||
211 | ((((const uint8_t*)(x))[3] << 24) | \ | ||
212 | (((const uint8_t*)(x))[2] << 16) | \ | ||
213 | (((const uint8_t*)(x))[1] << 8) | \ | ||
214 | ((const uint8_t*)(x))[0]) | ||
215 | #endif | ||
216 | #ifndef AV_WL32 | ||
217 | # define AV_WL32(p, d) do { \ | ||
218 | ((uint8_t*)(p))[0] = (d); \ | ||
219 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
220 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
221 | ((uint8_t*)(p))[3] = (d)>>24; \ | ||
222 | } while(0) | ||
223 | #endif | ||
224 | |||
225 | #ifndef AV_RB64 | ||
226 | # define AV_RB64(x) \ | ||
227 | (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ | ||
228 | ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ | ||
229 | ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ | ||
230 | ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ | ||
231 | ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ | ||
232 | ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ | ||
233 | ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ | ||
234 | (uint64_t)((const uint8_t*)(x))[7]) | ||
235 | #endif | ||
236 | #ifndef AV_WB64 | ||
237 | # define AV_WB64(p, d) do { \ | ||
238 | ((uint8_t*)(p))[7] = (d); \ | ||
239 | ((uint8_t*)(p))[6] = (d)>>8; \ | ||
240 | ((uint8_t*)(p))[5] = (d)>>16; \ | ||
241 | ((uint8_t*)(p))[4] = (d)>>24; \ | ||
242 | ((uint8_t*)(p))[3] = (d)>>32; \ | ||
243 | ((uint8_t*)(p))[2] = (d)>>40; \ | ||
244 | ((uint8_t*)(p))[1] = (d)>>48; \ | ||
245 | ((uint8_t*)(p))[0] = (d)>>56; \ | ||
246 | } while(0) | ||
247 | #endif | ||
248 | |||
249 | #ifndef AV_RL64 | ||
250 | # define AV_RL64(x) \ | ||
251 | (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ | ||
252 | ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ | ||
253 | ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | ||
254 | ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | ||
255 | ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | ||
256 | ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | ||
257 | ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | ||
258 | (uint64_t)((const uint8_t*)(x))[0]) | ||
259 | #endif | ||
260 | #ifndef AV_WL64 | ||
261 | # define AV_WL64(p, d) do { \ | ||
262 | ((uint8_t*)(p))[0] = (d); \ | ||
263 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
264 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
265 | ((uint8_t*)(p))[3] = (d)>>24; \ | ||
266 | ((uint8_t*)(p))[4] = (d)>>32; \ | ||
267 | ((uint8_t*)(p))[5] = (d)>>40; \ | ||
268 | ((uint8_t*)(p))[6] = (d)>>48; \ | ||
269 | ((uint8_t*)(p))[7] = (d)>>56; \ | ||
270 | } while(0) | ||
271 | #endif | ||
272 | |||
273 | #if HAVE_BIGENDIAN | ||
274 | # define AV_RN(s, p) AV_RB##s(p) | ||
275 | # define AV_WN(s, p, v) AV_WB##s(p, v) | ||
276 | #else | ||
277 | # define AV_RN(s, p) AV_RL##s(p) | ||
278 | # define AV_WN(s, p, v) AV_WL##s(p, v) | ||
279 | #endif | ||
280 | |||
281 | #endif /* HAVE_FAST_UNALIGNED */ | ||
282 | |||
283 | #ifndef AV_RN16 | ||
284 | # define AV_RN16(p) AV_RN(16, p) | ||
285 | #endif | ||
286 | |||
287 | #ifndef AV_RN32 | ||
288 | # define AV_RN32(p) AV_RN(32, p) | ||
289 | #endif | ||
290 | |||
291 | #ifndef AV_RN64 | ||
292 | # define AV_RN64(p) AV_RN(64, p) | ||
293 | #endif | ||
294 | |||
295 | #ifndef AV_WN16 | ||
296 | # define AV_WN16(p, v) AV_WN(16, p, v) | ||
297 | #endif | ||
298 | |||
299 | #ifndef AV_WN32 | ||
300 | # define AV_WN32(p, v) AV_WN(32, p, v) | ||
301 | #endif | ||
302 | |||
303 | #ifndef AV_WN64 | ||
304 | # define AV_WN64(p, v) AV_WN(64, p, v) | ||
305 | #endif | ||
306 | |||
307 | #if HAVE_BIGENDIAN | ||
308 | # define AV_RB(s, p) AV_RN##s(p) | ||
309 | # define AV_WB(s, p, v) AV_WN##s(p, v) | ||
310 | # define AV_RL(s, p) bswap_##s(AV_RN##s(p)) | ||
311 | # define AV_WL(s, p, v) AV_WN##s(p, bswap_##s(v)) | ||
312 | #else | ||
313 | # define AV_RB(s, p) bswap_##s(AV_RN##s(p)) | ||
314 | # define AV_WB(s, p, v) AV_WN##s(p, bswap_##s(v)) | ||
315 | # define AV_RL(s, p) AV_RN##s(p) | ||
316 | # define AV_WL(s, p, v) AV_WN##s(p, v) | ||
317 | #endif | ||
318 | |||
319 | #define AV_RB8(x) (((const uint8_t*)(x))[0]) | ||
320 | #define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) | ||
321 | |||
322 | #define AV_RL8(x) AV_RB8(x) | ||
323 | #define AV_WL8(p, d) AV_WB8(p, d) | ||
324 | |||
325 | #ifndef AV_RB16 | ||
326 | # define AV_RB16(p) AV_RB(16, p) | ||
327 | #endif | ||
328 | #ifndef AV_WB16 | ||
329 | # define AV_WB16(p, v) AV_WB(16, p, v) | ||
330 | #endif | ||
331 | |||
332 | #ifndef AV_RL16 | ||
333 | # define AV_RL16(p) AV_RL(16, p) | ||
334 | #endif | ||
335 | #ifndef AV_WL16 | ||
336 | # define AV_WL16(p, v) AV_WL(16, p, v) | ||
337 | #endif | ||
338 | |||
339 | #ifndef AV_RB32 | ||
340 | # define AV_RB32(p) AV_RB(32, p) | ||
341 | #endif | ||
342 | #ifndef AV_WB32 | ||
343 | # define AV_WB32(p, v) AV_WB(32, p, v) | ||
344 | #endif | ||
345 | |||
346 | #ifndef AV_RL32 | ||
347 | # define AV_RL32(p) AV_RL(32, p) | ||
348 | #endif | ||
349 | #ifndef AV_WL32 | ||
350 | # define AV_WL32(p, v) AV_WL(32, p, v) | ||
351 | #endif | ||
352 | |||
353 | #ifndef AV_RB64 | ||
354 | # define AV_RB64(p) AV_RB(64, p) | ||
355 | #endif | ||
356 | #ifndef AV_WB64 | ||
357 | # define AV_WB64(p, v) AV_WB(64, p, v) | ||
358 | #endif | ||
359 | |||
360 | #ifndef AV_RL64 | ||
361 | # define AV_RL64(p) AV_RL(64, p) | ||
362 | #endif | ||
363 | #ifndef AV_WL64 | ||
364 | # define AV_WL64(p, v) AV_WL(64, p, v) | ||
365 | #endif | ||
366 | |||
367 | #ifndef AV_RB24 | ||
368 | # define AV_RB24(x) \ | ||
369 | ((((const uint8_t*)(x))[0] << 16) | \ | ||
370 | (((const uint8_t*)(x))[1] << 8) | \ | ||
371 | ((const uint8_t*)(x))[2]) | ||
372 | #endif | ||
373 | #ifndef AV_WB24 | ||
374 | # define AV_WB24(p, d) do { \ | ||
375 | ((uint8_t*)(p))[2] = (d); \ | ||
376 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
377 | ((uint8_t*)(p))[0] = (d)>>16; \ | ||
378 | } while(0) | ||
379 | #endif | ||
380 | |||
381 | #ifndef AV_RL24 | ||
382 | # define AV_RL24(x) \ | ||
383 | ((((const uint8_t*)(x))[2] << 16) | \ | ||
384 | (((const uint8_t*)(x))[1] << 8) | \ | ||
385 | ((const uint8_t*)(x))[0]) | ||
386 | #endif | ||
387 | #ifndef AV_WL24 | ||
388 | # define AV_WL24(p, d) do { \ | ||
389 | ((uint8_t*)(p))[0] = (d); \ | ||
390 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
391 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
392 | } while(0) | ||
393 | #endif | ||
394 | |||
395 | /* | ||
396 | * The AV_[RW]NA macros access naturally aligned data | ||
397 | * in a type-safe way. | ||
398 | */ | ||
399 | |||
400 | #define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s) | ||
401 | #define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v)) | ||
402 | |||
403 | #ifndef AV_RN16A | ||
404 | # define AV_RN16A(p) AV_RNA(16, p) | ||
405 | #endif | ||
406 | |||
407 | #ifndef AV_RN32A | ||
408 | # define AV_RN32A(p) AV_RNA(32, p) | ||
409 | #endif | ||
410 | |||
411 | #ifndef AV_RN64A | ||
412 | # define AV_RN64A(p) AV_RNA(64, p) | ||
413 | #endif | ||
414 | |||
415 | #ifndef AV_WN16A | ||
416 | # define AV_WN16A(p, v) AV_WNA(16, p, v) | ||
417 | #endif | ||
418 | |||
419 | #ifndef AV_WN32A | ||
420 | # define AV_WN32A(p, v) AV_WNA(32, p, v) | ||
421 | #endif | ||
422 | |||
423 | #ifndef AV_WN64A | ||
424 | # define AV_WN64A(p, v) AV_WNA(64, p, v) | ||
425 | #endif | ||
426 | |||
427 | /* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be | ||
428 | * naturally aligned. They may be implemented using MMX, | ||
429 | * so emms_c() must be called before using any float code | ||
430 | * afterwards. | ||
431 | */ | ||
432 | |||
433 | #define AV_COPY(n, d, s) \ | ||
434 | (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) | ||
435 | |||
436 | #ifndef AV_COPY16 | ||
437 | # define AV_COPY16(d, s) AV_COPY(16, d, s) | ||
438 | #endif | ||
439 | |||
440 | #ifndef AV_COPY32 | ||
441 | # define AV_COPY32(d, s) AV_COPY(32, d, s) | ||
442 | #endif | ||
443 | |||
444 | #ifndef AV_COPY64 | ||
445 | # define AV_COPY64(d, s) AV_COPY(64, d, s) | ||
446 | #endif | ||
447 | |||
448 | #ifndef AV_COPY128 | ||
449 | # define AV_COPY128(d, s) \ | ||
450 | do { \ | ||
451 | AV_COPY64(d, s); \ | ||
452 | AV_COPY64((char*)(d)+8, (char*)(s)+8); \ | ||
453 | } while(0) | ||
454 | #endif | ||
455 | |||
456 | #define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) | ||
457 | |||
458 | #ifndef AV_SWAP64 | ||
459 | # define AV_SWAP64(a, b) AV_SWAP(64, a, b) | ||
460 | #endif | ||
461 | |||
462 | #define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) | ||
463 | |||
464 | #ifndef AV_ZERO16 | ||
465 | # define AV_ZERO16(d) AV_ZERO(16, d) | ||
466 | #endif | ||
467 | |||
468 | #ifndef AV_ZERO32 | ||
469 | # define AV_ZERO32(d) AV_ZERO(32, d) | ||
470 | #endif | ||
471 | |||
472 | #ifndef AV_ZERO64 | ||
473 | # define AV_ZERO64(d) AV_ZERO(64, d) | ||
474 | #endif | ||
475 | |||
476 | #ifndef AV_ZERO128 | ||
477 | # define AV_ZERO128(d) \ | ||
478 | do { \ | ||
479 | AV_ZERO64(d); \ | ||
480 | AV_ZERO64((char*)(d)+8); \ | ||
481 | } while(0) | ||
482 | #endif | ||
483 | |||
484 | #endif /* AVUTIL_INTREADWRITE_H */ | ||
diff --git a/apps/codecs/lib/ffmpeg_put_bits.h b/apps/codecs/lib/ffmpeg_put_bits.h deleted file mode 100644 index 38db55fe18..0000000000 --- a/apps/codecs/lib/ffmpeg_put_bits.h +++ /dev/null | |||
@@ -1,323 +0,0 @@ | |||
1 | /* | ||
2 | * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file libavcodec/put_bits.h | ||
23 | * bitstream writer API | ||
24 | */ | ||
25 | |||
26 | #ifndef AVCODEC_PUT_BITS_H | ||
27 | #define AVCODEC_PUT_BITS_H | ||
28 | |||
29 | #include <stdint.h> | ||
30 | #include <stdlib.h> | ||
31 | #include "ffmpeg_bswap.h" | ||
32 | #include "ffmpeg_intreadwrite.h" | ||
33 | |||
34 | #define av_log(...) | ||
35 | #define HAVE_FAST_UNALIGNED 0 | ||
36 | |||
37 | /* buf and buf_end must be present and used by every alternative writer. */ | ||
38 | typedef struct PutBitContext { | ||
39 | #ifdef ALT_BITSTREAM_WRITER | ||
40 | uint8_t *buf, *buf_end; | ||
41 | int index; | ||
42 | #else | ||
43 | uint32_t bit_buf; | ||
44 | int bit_left; | ||
45 | uint8_t *buf, *buf_ptr, *buf_end; | ||
46 | #endif | ||
47 | int size_in_bits; | ||
48 | } PutBitContext; | ||
49 | |||
50 | /** | ||
51 | * Initializes the PutBitContext s. | ||
52 | * | ||
53 | * @param buffer the buffer where to put bits | ||
54 | * @param buffer_size the size in bytes of buffer | ||
55 | */ | ||
56 | static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size) | ||
57 | { | ||
58 | if(buffer_size < 0) { | ||
59 | buffer_size = 0; | ||
60 | buffer = NULL; | ||
61 | } | ||
62 | |||
63 | s->size_in_bits= 8*buffer_size; | ||
64 | s->buf = buffer; | ||
65 | s->buf_end = s->buf + buffer_size; | ||
66 | #ifdef ALT_BITSTREAM_WRITER | ||
67 | s->index=0; | ||
68 | ((uint32_t*)(s->buf))[0]=0; | ||
69 | // memset(buffer, 0, buffer_size); | ||
70 | #else | ||
71 | s->buf_ptr = s->buf; | ||
72 | s->bit_left=32; | ||
73 | s->bit_buf=0; | ||
74 | #endif | ||
75 | } | ||
76 | |||
77 | /** | ||
78 | * Returns the total number of bits written to the bitstream. | ||
79 | */ | ||
80 | static inline int put_bits_count(PutBitContext *s) | ||
81 | { | ||
82 | #ifdef ALT_BITSTREAM_WRITER | ||
83 | return s->index; | ||
84 | #else | ||
85 | return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left; | ||
86 | #endif | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * Pads the end of the output stream with zeros. | ||
91 | */ | ||
92 | static inline void flush_put_bits(PutBitContext *s) | ||
93 | { | ||
94 | #ifdef ALT_BITSTREAM_WRITER | ||
95 | align_put_bits(s); | ||
96 | #else | ||
97 | #ifndef BITSTREAM_WRITER_LE | ||
98 | s->bit_buf<<= s->bit_left; | ||
99 | #endif | ||
100 | while (s->bit_left < 32) { | ||
101 | /* XXX: should test end of buffer */ | ||
102 | #ifdef BITSTREAM_WRITER_LE | ||
103 | *s->buf_ptr++=s->bit_buf; | ||
104 | s->bit_buf>>=8; | ||
105 | #else | ||
106 | *s->buf_ptr++=s->bit_buf >> 24; | ||
107 | s->bit_buf<<=8; | ||
108 | #endif | ||
109 | s->bit_left+=8; | ||
110 | } | ||
111 | s->bit_left=32; | ||
112 | s->bit_buf=0; | ||
113 | #endif | ||
114 | } | ||
115 | |||
116 | #if defined(ALT_BITSTREAM_WRITER) || defined(BITSTREAM_WRITER_LE) | ||
117 | #define align_put_bits align_put_bits_unsupported_here | ||
118 | #define ff_put_string ff_put_string_unsupported_here | ||
119 | #define ff_copy_bits ff_copy_bits_unsupported_here | ||
120 | #else | ||
121 | /** | ||
122 | * Pads the bitstream with zeros up to the next byte boundary. | ||
123 | */ | ||
124 | void align_put_bits(PutBitContext *s); | ||
125 | |||
126 | /** | ||
127 | * Puts the string string in the bitstream. | ||
128 | * | ||
129 | * @param terminate_string 0-terminates the written string if value is 1 | ||
130 | */ | ||
131 | void ff_put_string(PutBitContext *pb, const char *string, int terminate_string); | ||
132 | |||
133 | /** | ||
134 | * Copies the content of src to the bitstream. | ||
135 | * | ||
136 | * @param length the number of bits of src to copy | ||
137 | */ | ||
138 | void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length); | ||
139 | #endif | ||
140 | |||
141 | /** | ||
142 | * Writes up to 31 bits into a bitstream. | ||
143 | * Use put_bits32 to write 32 bits. | ||
144 | */ | ||
145 | static inline void put_bits(PutBitContext *s, int n, unsigned int value) | ||
146 | #ifndef ALT_BITSTREAM_WRITER | ||
147 | { | ||
148 | unsigned int bit_buf; | ||
149 | int bit_left; | ||
150 | |||
151 | // printf("put_bits=%d %x\n", n, value); | ||
152 | //assert(n <= 31 && value < (1U << n)); | ||
153 | |||
154 | bit_buf = s->bit_buf; | ||
155 | bit_left = s->bit_left; | ||
156 | |||
157 | // printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf); | ||
158 | /* XXX: optimize */ | ||
159 | #ifdef BITSTREAM_WRITER_LE | ||
160 | bit_buf |= value << (32 - bit_left); | ||
161 | if (n >= bit_left) { | ||
162 | #if !HAVE_FAST_UNALIGNED | ||
163 | if (3 & (intptr_t) s->buf_ptr) { | ||
164 | AV_WL32(s->buf_ptr, bit_buf); | ||
165 | } else | ||
166 | #endif | ||
167 | *(uint32_t *)s->buf_ptr = le2me_32(bit_buf); | ||
168 | s->buf_ptr+=4; | ||
169 | bit_buf = (bit_left==32)?0:value >> bit_left; | ||
170 | bit_left+=32; | ||
171 | } | ||
172 | bit_left-=n; | ||
173 | #else | ||
174 | if (n < bit_left) { | ||
175 | bit_buf = (bit_buf<<n) | value; | ||
176 | bit_left-=n; | ||
177 | } else { | ||
178 | bit_buf<<=bit_left; | ||
179 | bit_buf |= value >> (n - bit_left); | ||
180 | #if !HAVE_FAST_UNALIGNED | ||
181 | if (3 & (intptr_t) s->buf_ptr) { | ||
182 | AV_WB32(s->buf_ptr, bit_buf); | ||
183 | } else | ||
184 | #endif | ||
185 | *(uint32_t *)s->buf_ptr = be2me_32(bit_buf); | ||
186 | //printf("bitbuf = %08x\n", bit_buf); | ||
187 | s->buf_ptr+=4; | ||
188 | bit_left+=32 - n; | ||
189 | bit_buf = value; | ||
190 | } | ||
191 | #endif | ||
192 | |||
193 | s->bit_buf = bit_buf; | ||
194 | s->bit_left = bit_left; | ||
195 | } | ||
196 | #else /* ALT_BITSTREAM_WRITER defined */ | ||
197 | { | ||
198 | # ifdef ALIGNED_BITSTREAM_WRITER | ||
199 | # if ARCH_X86 | ||
200 | __asm__ volatile( | ||
201 | "movl %0, %%ecx \n\t" | ||
202 | "xorl %%eax, %%eax \n\t" | ||
203 | "shrdl %%cl, %1, %%eax \n\t" | ||
204 | "shrl %%cl, %1 \n\t" | ||
205 | "movl %0, %%ecx \n\t" | ||
206 | "shrl $3, %%ecx \n\t" | ||
207 | "andl $0xFFFFFFFC, %%ecx \n\t" | ||
208 | "bswapl %1 \n\t" | ||
209 | "orl %1, (%2, %%ecx) \n\t" | ||
210 | "bswapl %%eax \n\t" | ||
211 | "addl %3, %0 \n\t" | ||
212 | "movl %%eax, 4(%2, %%ecx) \n\t" | ||
213 | : "=&r" (s->index), "=&r" (value) | ||
214 | : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n)) | ||
215 | : "%eax", "%ecx" | ||
216 | ); | ||
217 | # else | ||
218 | int index= s->index; | ||
219 | uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5); | ||
220 | |||
221 | value<<= 32-n; | ||
222 | |||
223 | ptr[0] |= be2me_32(value>>(index&31)); | ||
224 | ptr[1] = be2me_32(value<<(32-(index&31))); | ||
225 | //if(n>24) printf("%d %d\n", n, value); | ||
226 | index+= n; | ||
227 | s->index= index; | ||
228 | # endif | ||
229 | # else //ALIGNED_BITSTREAM_WRITER | ||
230 | # if ARCH_X86 | ||
231 | __asm__ volatile( | ||
232 | "movl $7, %%ecx \n\t" | ||
233 | "andl %0, %%ecx \n\t" | ||
234 | "addl %3, %%ecx \n\t" | ||
235 | "negl %%ecx \n\t" | ||
236 | "shll %%cl, %1 \n\t" | ||
237 | "bswapl %1 \n\t" | ||
238 | "movl %0, %%ecx \n\t" | ||
239 | "shrl $3, %%ecx \n\t" | ||
240 | "orl %1, (%%ecx, %2) \n\t" | ||
241 | "addl %3, %0 \n\t" | ||
242 | "movl $0, 4(%%ecx, %2) \n\t" | ||
243 | : "=&r" (s->index), "=&r" (value) | ||
244 | : "r" (s->buf), "r" (n), "0" (s->index), "1" (value) | ||
245 | : "%ecx" | ||
246 | ); | ||
247 | # else | ||
248 | int index= s->index; | ||
249 | uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3)); | ||
250 | |||
251 | ptr[0] |= be2me_32(value<<(32-n-(index&7) )); | ||
252 | ptr[1] = 0; | ||
253 | //if(n>24) printf("%d %d\n", n, value); | ||
254 | index+= n; | ||
255 | s->index= index; | ||
256 | # endif | ||
257 | # endif //!ALIGNED_BITSTREAM_WRITER | ||
258 | } | ||
259 | #endif | ||
260 | |||
261 | static inline void put_sbits(PutBitContext *pb, int n, int32_t value) | ||
262 | { | ||
263 | //assert(n >= 0 && n <= 31); | ||
264 | |||
265 | put_bits(pb, n, value & ((1<<n)-1)); | ||
266 | } | ||
267 | |||
268 | /** | ||
269 | * Returns the pointer to the byte where the bitstream writer will put | ||
270 | * the next bit. | ||
271 | */ | ||
272 | static inline uint8_t* put_bits_ptr(PutBitContext *s) | ||
273 | { | ||
274 | #ifdef ALT_BITSTREAM_WRITER | ||
275 | return s->buf + (s->index>>3); | ||
276 | #else | ||
277 | return s->buf_ptr; | ||
278 | #endif | ||
279 | } | ||
280 | |||
281 | /** | ||
282 | * Skips the given number of bytes. | ||
283 | * PutBitContext must be flushed & aligned to a byte boundary before calling this. | ||
284 | */ | ||
285 | static inline void skip_put_bytes(PutBitContext *s, int n) | ||
286 | { | ||
287 | //assert((put_bits_count(s)&7)==0); | ||
288 | #ifdef ALT_BITSTREAM_WRITER | ||
289 | FIXME may need some cleaning of the buffer | ||
290 | s->index += n<<3; | ||
291 | #else | ||
292 | //assert(s->bit_left==32); | ||
293 | s->buf_ptr += n; | ||
294 | #endif | ||
295 | } | ||
296 | |||
297 | /** | ||
298 | * Skips the given number of bits. | ||
299 | * Must only be used if the actual values in the bitstream do not matter. | ||
300 | * If n is 0 the behavior is undefined. | ||
301 | */ | ||
302 | static inline void skip_put_bits(PutBitContext *s, int n) | ||
303 | { | ||
304 | #ifdef ALT_BITSTREAM_WRITER | ||
305 | s->index += n; | ||
306 | #else | ||
307 | s->bit_left -= n; | ||
308 | s->buf_ptr-= 4*(s->bit_left>>5); | ||
309 | s->bit_left &= 31; | ||
310 | #endif | ||
311 | } | ||
312 | |||
313 | /** | ||
314 | * Changes the end of the buffer. | ||
315 | * | ||
316 | * @param size the new size in bytes of the buffer where to put bits | ||
317 | */ | ||
318 | static inline void set_put_bits_buffer_size(PutBitContext *s, int size) | ||
319 | { | ||
320 | s->buf_end= s->buf + size; | ||
321 | } | ||
322 | |||
323 | #endif /* AVCODEC_PUT_BITS_H */ | ||
diff --git a/apps/codecs/lib/fft-ffmpeg.c b/apps/codecs/lib/fft-ffmpeg.c deleted file mode 100644 index 807f606038..0000000000 --- a/apps/codecs/lib/fft-ffmpeg.c +++ /dev/null | |||
@@ -1,473 +0,0 @@ | |||
1 | /* | ||
2 | * FFT/IFFT transforms converted to integer precision | ||
3 | * Copyright (c) 2010 Dave Hooper, Mohamed Tarek, Michael Giacomelli | ||
4 | * Copyright (c) 2008 Loren Merritt | ||
5 | * Copyright (c) 2002 Fabrice Bellard | ||
6 | * Partly based on libdjbfft by D. J. Bernstein | ||
7 | * | ||
8 | * This file is part of FFmpeg. | ||
9 | * | ||
10 | * FFmpeg is free software; you can redistribute it and/or | ||
11 | * modify it under the terms of the GNU Lesser General Public | ||
12 | * License as published by the Free Software Foundation; either | ||
13 | * version 2.1 of the License, or (at your option) any later version. | ||
14 | * | ||
15 | * FFmpeg is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
18 | * Lesser General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU Lesser General Public | ||
21 | * License along with FFmpeg; if not, write to the Free Software | ||
22 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
23 | */ | ||
24 | |||
25 | /** | ||
26 | * @file libavcodec/fft.c | ||
27 | * FFT/IFFT transforms. | ||
28 | */ | ||
29 | |||
30 | |||
31 | #ifdef CPU_ARM | ||
32 | // we definitely want CONFIG_SMALL undefined for ipod | ||
33 | // so we get the inlined version of fft16 (which is measurably faster) | ||
34 | #undef CONFIG_SMALL | ||
35 | #else | ||
36 | #undef CONFIG_SMALL | ||
37 | #endif | ||
38 | |||
39 | #include "fft.h" | ||
40 | #include <string.h> | ||
41 | #include <stdlib.h> | ||
42 | #include <math.h> | ||
43 | #include <inttypes.h> | ||
44 | #include <time.h> | ||
45 | #include <codecs/lib/codeclib.h> | ||
46 | |||
47 | #include "codeclib_misc.h" | ||
48 | #include "mdct_lookup.h" | ||
49 | |||
50 | /* constants for fft_16 (same constants as in mdct_arm.S ... ) */ | ||
51 | #define cPI1_8 (0x7641af3d) /* cos(pi/8) s.31 */ | ||
52 | #define cPI2_8 (0x5a82799a) /* cos(2pi/8) = 1/sqrt(2) s.31 */ | ||
53 | #define cPI3_8 (0x30fbc54d) /* cos(3pi/8) s.31 */ | ||
54 | |||
55 | /* asm-optimised functions and/or macros */ | ||
56 | #include "fft-ffmpeg_arm.h" | ||
57 | #include "fft-ffmpeg_cf.h" | ||
58 | |||
59 | #ifndef ICODE_ATTR_TREMOR_MDCT | ||
60 | #define ICODE_ATTR_TREMOR_MDCT ICODE_ATTR | ||
61 | #endif | ||
62 | |||
63 | #if 0 | ||
64 | static int split_radix_permutation(int i, int n, int inverse) | ||
65 | { | ||
66 | int m; | ||
67 | if(n <= 2) return i&1; | ||
68 | m = n >> 1; | ||
69 | if(!(i&m)) return split_radix_permutation(i, m, inverse)*2; | ||
70 | m >>= 1; | ||
71 | if(inverse == !(i&m)) return split_radix_permutation(i, m, inverse)*4 + 1; | ||
72 | else return split_radix_permutation(i, m, inverse)*4 - 1; | ||
73 | } | ||
74 | |||
75 | static void ff_fft_permute_c(FFTContext *s, FFTComplex *z) | ||
76 | { | ||
77 | int j, k, np; | ||
78 | FFTComplex tmp; | ||
79 | //const uint16_t *revtab = s->revtab; | ||
80 | np = 1 << s->nbits; | ||
81 | |||
82 | const int revtab_shift = (12 - s->nbits); | ||
83 | |||
84 | /* reverse */ | ||
85 | for(j=0;j<np;j++) { | ||
86 | k = revtab[j]>>revtab_shift; | ||
87 | if (k < j) { | ||
88 | tmp = z[k]; | ||
89 | z[k] = z[j]; | ||
90 | z[j] = tmp; | ||
91 | } | ||
92 | } | ||
93 | } | ||
94 | #endif | ||
95 | |||
96 | #define BF(x,y,a,b) {\ | ||
97 | x = a - b;\ | ||
98 | y = a + b;\ | ||
99 | } | ||
100 | |||
101 | #define BF_REV(x,y,a,b) {\ | ||
102 | x = a + b;\ | ||
103 | y = a - b;\ | ||
104 | } | ||
105 | |||
106 | #ifndef FFT_FFMPEG_INCL_OPTIMISED_BUTTERFLIES | ||
107 | #define BUTTERFLIES(a0,a1,a2,a3) {\ | ||
108 | {\ | ||
109 | FFTSample temp1,temp2;\ | ||
110 | BF(temp1, temp2, t5, t1);\ | ||
111 | BF(a2.re, a0.re, a0.re, temp2);\ | ||
112 | BF(a3.im, a1.im, a1.im, temp1);\ | ||
113 | }\ | ||
114 | {\ | ||
115 | FFTSample temp1,temp2;\ | ||
116 | BF(temp1, temp2, t2, t6);\ | ||
117 | BF(a3.re, a1.re, a1.re, temp1);\ | ||
118 | BF(a2.im, a0.im, a0.im, temp2);\ | ||
119 | }\ | ||
120 | } | ||
121 | |||
122 | // force loading all the inputs before storing any. | ||
123 | // this is slightly slower for small data, but avoids store->load aliasing | ||
124 | // for addresses separated by large powers of 2. | ||
125 | #define BUTTERFLIES_BIG(a0,a1,a2,a3) {\ | ||
126 | FFTSample r0=a0.re, i0=a0.im, r1=a1.re, i1=a1.im;\ | ||
127 | {\ | ||
128 | FFTSample temp1, temp2;\ | ||
129 | BF(temp1, temp2, t5, t1);\ | ||
130 | BF(a2.re, a0.re, r0, temp2);\ | ||
131 | BF(a3.im, a1.im, i1, temp1);\ | ||
132 | }\ | ||
133 | {\ | ||
134 | FFTSample temp1, temp2;\ | ||
135 | BF(temp1, temp2, t2, t6);\ | ||
136 | BF(a3.re, a1.re, r1, temp1);\ | ||
137 | BF(a2.im, a0.im, i0, temp2);\ | ||
138 | }\ | ||
139 | } | ||
140 | #endif | ||
141 | |||
142 | /* | ||
143 | see conjugate pair description in | ||
144 | http://www.fftw.org/newsplit.pdf | ||
145 | |||
146 | a0 = z[k] | ||
147 | a1 = z[k+N/4] | ||
148 | a2 = z[k+2N/4] | ||
149 | a3 = z[k+3N/4] | ||
150 | |||
151 | result: | ||
152 | y[k] = z[k]+w(z[k+2N/4])+w'(z[k+3N/4]) | ||
153 | y[k+N/4] = z[k+N/4]-iw(z[k+2N/4])+iw'(z[k+3N/4]) | ||
154 | y[k+2N/4] = z[k]-w(z[k+2N/4])-w'(z[k+3N/4]) | ||
155 | y[k+3N/4] = z[k+N/4]+iw(z[k+2N/4])-iw'(z[k+3N/4]) | ||
156 | |||
157 | i.e. | ||
158 | |||
159 | a0 = a0 + (w.a2 + w'.a3) | ||
160 | a1 = a1 - i(w.a2 - w'.a3) | ||
161 | a2 = a0 - (w.a2 + w'.a3) | ||
162 | a3 = a1 + i(w.a2 - w'.a3) | ||
163 | |||
164 | note re(w') = re(w) and im(w') = -im(w) | ||
165 | |||
166 | so therefore | ||
167 | |||
168 | re(a0) = re(a0) + re(w.a2) + re(w.a3) | ||
169 | im(a0) = im(a0) + im(w.a2) - im(w.a3) etc | ||
170 | |||
171 | and remember also that | ||
172 | Re([s+it][u+iv]) = su-tv | ||
173 | Im([s+it][u+iv]) = sv+tu | ||
174 | |||
175 | so | ||
176 | Re(w'.(s+it)) = Re(w').s - Im(w').t = Re(w).s + Im(w).t | ||
177 | Im(w'.(s+it)) = Re(w').t + Im(w').s = Re(w).t - Im(w).s | ||
178 | |||
179 | For inverse dft we take the complex conjugate of all twiddle factors. | ||
180 | Hence | ||
181 | |||
182 | a0 = a0 + (w'.a2 + w.a3) | ||
183 | a1 = a1 - i(w'.a2 - w.a3) | ||
184 | a2 = a0 - (w'.a2 + w.a3) | ||
185 | a3 = a1 + i(w'.a2 - w.a3) | ||
186 | |||
187 | Define t1 = Re(w'.a2) = Re(w)*Re(a2) + Im(w)*Im(a2) | ||
188 | t2 = Im(w'.a2) = Re(w)*Im(a2) - Im(w)*Re(a2) | ||
189 | t5 = Re(w.a3) = Re(w)*Re(a3) - Im(w)*Im(a3) | ||
190 | t6 = Im(w.a3) = Re(w)*Im(a3) + Im(w)*Re(a3) | ||
191 | |||
192 | Then we just output: | ||
193 | a0.re = a0.re + ( t1 + t5 ) | ||
194 | a0.im = a0.im + ( t2 + t6 ) | ||
195 | a1.re = a1.re + ( t2 - t6 ) // since we multiply by -i and i(-i) = 1 | ||
196 | a1.im = a1.im - ( t1 - t5 ) // since we multiply by -i and 1(-i) = -i | ||
197 | a2.re = a0.re - ( t1 + t5 ) | ||
198 | a2.im = a0.im - ( t1 + t5 ) | ||
199 | a3.re = a1.re - ( t2 - t6 ) // since we multiply by +i and i(+i) = -1 | ||
200 | a3.im = a1.im + ( t1 - t5 ) // since we multiply by +i and 1(+i) = i | ||
201 | |||
202 | |||
203 | */ | ||
204 | |||
205 | #ifndef FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM | ||
206 | static inline FFTComplex* TRANSFORM(FFTComplex * z, unsigned int n, FFTSample wre, FFTSample wim) | ||
207 | { | ||
208 | register FFTSample t1,t2,t5,t6,r_re,r_im; | ||
209 | r_re = z[n*2].re; | ||
210 | r_im = z[n*2].im; | ||
211 | XPROD31_R(r_re, r_im, wre, wim, t1,t2); | ||
212 | r_re = z[n*3].re; | ||
213 | r_im = z[n*3].im; | ||
214 | XNPROD31_R(r_re, r_im, wre, wim, t5,t6); | ||
215 | BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]); | ||
216 | return z+1; | ||
217 | } | ||
218 | |||
219 | static inline FFTComplex* TRANSFORM_W01(FFTComplex * z, unsigned int n, const FFTSample * w) | ||
220 | { | ||
221 | register const FFTSample wre=w[0],wim=w[1]; | ||
222 | register FFTSample t1,t2,t5,t6,r_re,r_im; | ||
223 | r_re = z[n*2].re; | ||
224 | r_im = z[n*2].im; | ||
225 | XPROD31_R(r_re, r_im, wre, wim, t1,t2); | ||
226 | r_re = z[n*3].re; | ||
227 | r_im = z[n*3].im; | ||
228 | XNPROD31_R(r_re, r_im, wre, wim, t5,t6); | ||
229 | BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]); | ||
230 | return z+1; | ||
231 | } | ||
232 | |||
233 | static inline FFTComplex* TRANSFORM_W10(FFTComplex * z, unsigned int n, const FFTSample * w) | ||
234 | { | ||
235 | register const FFTSample wim=w[0],wre=w[1]; | ||
236 | register FFTSample t1,t2,t5,t6,r_re,r_im; | ||
237 | r_re = z[n*2].re; | ||
238 | r_im = z[n*2].im; | ||
239 | XPROD31_R(r_re, r_im, wre, wim, t1,t2); | ||
240 | r_re = z[n*3].re; | ||
241 | r_im = z[n*3].im; | ||
242 | XNPROD31_R(r_re, r_im, wre, wim, t5,t6); | ||
243 | BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]); | ||
244 | return z+1; | ||
245 | } | ||
246 | |||
247 | static inline FFTComplex* TRANSFORM_EQUAL(FFTComplex * z, unsigned int n) | ||
248 | { | ||
249 | register FFTSample t1,t2,t5,t6,temp1,temp2; | ||
250 | register FFTSample * my_z = (FFTSample *)(z); | ||
251 | my_z += n*4; | ||
252 | t2 = MULT31(my_z[0], cPI2_8); | ||
253 | temp1 = MULT31(my_z[1], cPI2_8); | ||
254 | my_z += n*2; | ||
255 | temp2 = MULT31(my_z[0], cPI2_8); | ||
256 | t5 = MULT31(my_z[1], cPI2_8); | ||
257 | t1 = ( temp1 + t2 ); | ||
258 | t2 = ( temp1 - t2 ); | ||
259 | t6 = ( temp2 + t5 ); | ||
260 | t5 = ( temp2 - t5 ); | ||
261 | my_z -= n*6; | ||
262 | BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]); | ||
263 | return z+1; | ||
264 | } | ||
265 | |||
266 | static inline FFTComplex* TRANSFORM_ZERO(FFTComplex * z, unsigned int n) | ||
267 | { | ||
268 | FFTSample t1,t2,t5,t6; | ||
269 | t1 = z[n*2].re; | ||
270 | t2 = z[n*2].im; | ||
271 | t5 = z[n*3].re; | ||
272 | t6 = z[n*3].im; | ||
273 | BUTTERFLIES(z[0],z[n],z[n*2],z[n*3]); | ||
274 | return z+1; | ||
275 | } | ||
276 | #endif | ||
277 | |||
278 | /* z[0...8n-1], w[1...2n-1] */ | ||
279 | static void pass(FFTComplex *z_arg, unsigned int STEP_arg, unsigned int n_arg) ICODE_ATTR_TREMOR_MDCT; | ||
280 | static void pass(FFTComplex *z_arg, unsigned int STEP_arg, unsigned int n_arg) | ||
281 | { | ||
282 | register FFTComplex * z = z_arg; | ||
283 | register unsigned int STEP = STEP_arg; | ||
284 | register unsigned int n = n_arg; | ||
285 | |||
286 | register const FFTSample *w = sincos_lookup0+STEP; | ||
287 | /* wre = *(wim+1) . ordering is sin,cos */ | ||
288 | register const FFTSample *w_end = sincos_lookup0+1024; | ||
289 | |||
290 | /* first two are special (well, first one is special, but we need to do pairs) */ | ||
291 | z = TRANSFORM_ZERO(z,n); | ||
292 | z = TRANSFORM_W10(z,n,w); | ||
293 | w += STEP; | ||
294 | /* first pass forwards through sincos_lookup0*/ | ||
295 | do { | ||
296 | z = TRANSFORM_W10(z,n,w); | ||
297 | w += STEP; | ||
298 | z = TRANSFORM_W10(z,n,w); | ||
299 | w += STEP; | ||
300 | } while(LIKELY(w < w_end)); | ||
301 | /* second half: pass backwards through sincos_lookup0*/ | ||
302 | /* wim and wre are now in opposite places so ordering now [0],[1] */ | ||
303 | w_end=sincos_lookup0; | ||
304 | while(LIKELY(w>w_end)) | ||
305 | { | ||
306 | z = TRANSFORM_W01(z,n,w); | ||
307 | w -= STEP; | ||
308 | z = TRANSFORM_W01(z,n,w); | ||
309 | w -= STEP; | ||
310 | } | ||
311 | } | ||
312 | |||
313 | /* what is STEP? | ||
314 | sincos_lookup0 has sin,cos pairs for 1/4 cycle, in 1024 points | ||
315 | so half cycle would be 2048 points | ||
316 | ff_cos_16 has 8 elements corresponding to 4 cos points and 4 sin points | ||
317 | so each of the 4 points pairs corresponds to a 256*2-byte jump in sincos_lookup0 | ||
318 | 8192/16 (from "ff_cos_16") is 512 bytes. | ||
319 | i.e. for fft16, STEP = 8192/16 */ | ||
320 | #define DECL_FFT(n,n2,n4)\ | ||
321 | static void fft##n(FFTComplex *z) ICODE_ATTR_TREMOR_MDCT;\ | ||
322 | static void fft##n(FFTComplex *z)\ | ||
323 | {\ | ||
324 | fft##n2(z);\ | ||
325 | fft##n4(z+n4*2);\ | ||
326 | fft##n4(z+n4*3);\ | ||
327 | pass(z,8192/n,n4);\ | ||
328 | } | ||
329 | |||
330 | #ifndef FFT_FFMPEG_INCL_OPTIMISED_FFT4 | ||
331 | static inline void fft4(FFTComplex *z) | ||
332 | { | ||
333 | FFTSample t1, t2, t3, t4, t5, t6, t7, t8; | ||
334 | |||
335 | BF(t3, t1, z[0].re, z[1].re); // t3=r1-r3 ; t1 = r1+r3 | ||
336 | BF(t8, t6, z[3].re, z[2].re); // t8=r7-r5 ; t6 = r7+r5 | ||
337 | |||
338 | BF(z[2].re, z[0].re, t1, t6); // r5=t1-t6 ; r1 = t1+t6 | ||
339 | |||
340 | BF(t4, t2, z[0].im, z[1].im); // t4=r2-r4 ; t2 = r2+r4 | ||
341 | BF(t7, t5, z[2].im, z[3].im); // t7=r6-r8 ; t5 = r6+r8 | ||
342 | |||
343 | BF(z[3].im, z[1].im, t4, t8); // r8=t4-t8 ; r4 = t4+t8 | ||
344 | BF(z[3].re, z[1].re, t3, t7); // r7=t3-t7 ; r3 = t3+t7 | ||
345 | BF(z[2].im, z[0].im, t2, t5); // r6=t2-t5 ; r2 = t2+t5 | ||
346 | } | ||
347 | #endif | ||
348 | |||
349 | static void fft4_dispatch(FFTComplex *z) | ||
350 | { | ||
351 | fft4(z); | ||
352 | } | ||
353 | |||
354 | #ifndef FFT_FFMPEG_INCL_OPTIMISED_FFT8 | ||
355 | static inline void fft8(FFTComplex *z) | ||
356 | { | ||
357 | fft4(z); | ||
358 | FFTSample t1,t2,t3,t4,t7,t8; | ||
359 | |||
360 | BF(t1, z[5].re, z[4].re, -z[5].re); | ||
361 | BF(t2, z[5].im, z[4].im, -z[5].im); | ||
362 | BF(t3, z[7].re, z[6].re, -z[7].re); | ||
363 | BF(t4, z[7].im, z[6].im, -z[7].im); | ||
364 | BF(t8, t1, t3, t1); | ||
365 | BF(t7, t2, t2, t4); | ||
366 | BF(z[4].re, z[0].re, z[0].re, t1); | ||
367 | BF(z[4].im, z[0].im, z[0].im, t2); | ||
368 | BF(z[6].re, z[2].re, z[2].re, t7); | ||
369 | BF(z[6].im, z[2].im, z[2].im, t8); | ||
370 | |||
371 | z++; | ||
372 | TRANSFORM_EQUAL(z,2); | ||
373 | } | ||
374 | #endif | ||
375 | |||
376 | static void fft8_dispatch(FFTComplex *z) | ||
377 | { | ||
378 | fft8(z); | ||
379 | } | ||
380 | |||
381 | #ifndef CONFIG_SMALL | ||
382 | static void fft16(FFTComplex *z) ICODE_ATTR_TREMOR_MDCT; | ||
383 | static void fft16(FFTComplex *z) | ||
384 | { | ||
385 | fft8(z); | ||
386 | fft4(z+8); | ||
387 | fft4(z+12); | ||
388 | |||
389 | TRANSFORM_ZERO(z,4); | ||
390 | z+=2; | ||
391 | TRANSFORM_EQUAL(z,4); | ||
392 | z-=1; | ||
393 | TRANSFORM(z,4,cPI1_8,cPI3_8); | ||
394 | z+=2; | ||
395 | TRANSFORM(z,4,cPI3_8,cPI1_8); | ||
396 | } | ||
397 | #else | ||
398 | DECL_FFT(16,8,4) | ||
399 | #endif | ||
400 | DECL_FFT(32,16,8) | ||
401 | DECL_FFT(64,32,16) | ||
402 | DECL_FFT(128,64,32) | ||
403 | DECL_FFT(256,128,64) | ||
404 | DECL_FFT(512,256,128) | ||
405 | DECL_FFT(1024,512,256) | ||
406 | DECL_FFT(2048,1024,512) | ||
407 | DECL_FFT(4096,2048,1024) | ||
408 | |||
409 | static void (*fft_dispatch[])(FFTComplex*) = { | ||
410 | fft4_dispatch, fft8_dispatch, fft16, fft32, fft64, fft128, fft256, fft512, fft1024, | ||
411 | fft2048, fft4096 | ||
412 | }; | ||
413 | |||
414 | void ff_fft_calc_c(int nbits, FFTComplex *z) | ||
415 | { | ||
416 | fft_dispatch[nbits-2](z); | ||
417 | } | ||
418 | |||
419 | #if 0 | ||
420 | int main (void) | ||
421 | { | ||
422 | #define PRECISION 16 | ||
423 | #define FFT_SIZE 1024 | ||
424 | #define ftofix32(x) ((fixed32)((x) * (float)(1 << PRECISION) + ((x) < 0 ? -0.5 : 0.5))) | ||
425 | #define itofix32(x) ((x) << PRECISION) | ||
426 | #define fixtoi32(x) ((x) >> PRECISION) | ||
427 | |||
428 | int j; | ||
429 | const long N = FFT_SIZE; | ||
430 | double r[FFT_SIZE] = {0.0}, i[FFT_SIZE] = {0.0}; | ||
431 | long n; | ||
432 | double t; | ||
433 | double amp, phase; | ||
434 | clock_t start, end; | ||
435 | double exec_time = 0; | ||
436 | FFTContext s; | ||
437 | FFTComplex z[FFT_SIZE]; | ||
438 | memset(z, 0, 64*sizeof(FFTComplex)); | ||
439 | |||
440 | /* Generate saw-tooth test data */ | ||
441 | for (n = 0; n < FFT_SIZE; n++) | ||
442 | { | ||
443 | t = (2 * M_PI * n)/N; | ||
444 | /*z[n].re = 1.1 + sin( t) + | ||
445 | 0.5 * sin(2.0 * t) + | ||
446 | (1.0/3.0) * sin(3.0 * t) + | ||
447 | 0.25 * sin(4.0 * t) + | ||
448 | 0.2 * sin(5.0 * t) + | ||
449 | (1.0/6.0) * sin(6.0 * t) + | ||
450 | (1.0/7.0) * sin(7.0 * t) ;*/ | ||
451 | z[n].re = ftofix32(cos(2*M_PI*n/64)); | ||
452 | //printf("z[%d] = %f\n", n, z[n].re); | ||
453 | //getchar(); | ||
454 | } | ||
455 | |||
456 | ff_fft_init(&s, 10, 1); | ||
457 | //start = clock(); | ||
458 | //for(n = 0; n < 1000000; n++) | ||
459 | ff_fft_permute_c(&s, z); | ||
460 | ff_fft_calc_c(&s, z); | ||
461 | //end = clock(); | ||
462 | //exec_time = (((double)end-(double)start)/CLOCKS_PER_SEC); | ||
463 | for(j = 0; j < FFT_SIZE; j++) | ||
464 | { | ||
465 | printf("%8.4f\n", sqrt(pow(fixtof32(z[j].re),2)+ pow(fixtof32(z[j].im), 2))); | ||
466 | //getchar(); | ||
467 | } | ||
468 | printf("muls = %d, adds = %d\n", muls, adds); | ||
469 | //printf(" Time elapsed = %f\n", exec_time); | ||
470 | //ff_fft_end(&s); | ||
471 | |||
472 | } | ||
473 | #endif | ||
diff --git a/apps/codecs/lib/fft-ffmpeg_arm.h b/apps/codecs/lib/fft-ffmpeg_arm.h deleted file mode 100644 index 073ad8ee46..0000000000 --- a/apps/codecs/lib/fft-ffmpeg_arm.h +++ /dev/null | |||
@@ -1,456 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2010 Dave Hooper | ||
11 | * | ||
12 | * ARM optimisations for ffmpeg's fft (used in fft-ffmpeg.c) | ||
13 | * | ||
14 | * This program is free software; you can redistribute it and/or | ||
15 | * modify it under the terms of the GNU General Public License | ||
16 | * as published by the Free Software Foundation; either version 2 | ||
17 | * of the License, or (at your option) any later version. | ||
18 | * | ||
19 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
20 | * KIND, either express or implied. | ||
21 | * | ||
22 | ****************************************************************************/ | ||
23 | |||
24 | #ifdef CPU_ARM | ||
25 | |||
26 | /* Start off with optimised variants of the butterflies that work | ||
27 | nicely on arm */ | ||
28 | /* 1. where y and a share the same variable/register */ | ||
29 | #define BF_OPT(x,y,a,b) {\ | ||
30 | y = a + b;\ | ||
31 | x = y - (b<<1);\ | ||
32 | } | ||
33 | |||
34 | /* 2. where y and b share the same variable/register */ | ||
35 | #define BF_OPT2(x,y,a,b) {\ | ||
36 | x = a - b;\ | ||
37 | y = x + (b<<1);\ | ||
38 | } | ||
39 | |||
40 | /* 3. where y and b share the same variable/register (but y=(-b)) */ | ||
41 | #define BF_OPT2_REV(x,y,a,b) {\ | ||
42 | x = a + b;\ | ||
43 | y = x - (b<<1);\ | ||
44 | } | ||
45 | |||
46 | |||
47 | /* standard BUTTERFLIES package. Note, we actually manually inline this | ||
48 | in all the TRANSFORM macros below anyway */ | ||
49 | #define FFT_FFMPEG_INCL_OPTIMISED_BUTTERFLIES | ||
50 | #define BUTTERFLIES(a0,a1,a2,a3) {\ | ||
51 | {\ | ||
52 | BF_OPT(t1, t5, t5, t1);\ | ||
53 | BF_OPT(t6, t2, t2, t6);\ | ||
54 | BF_OPT(a2.re, a0.re, a0.re, t5);\ | ||
55 | BF_OPT(a2.im, a0.im, a0.im, t2);\ | ||
56 | BF_OPT(a3.re, a1.re, a1.re, t6);\ | ||
57 | BF_OPT(a3.im, a1.im, a1.im, t1);\ | ||
58 | }\ | ||
59 | } | ||
60 | |||
61 | #define FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM | ||
62 | |||
63 | static inline FFTComplex* TRANSFORM( FFTComplex* z, int n, FFTSample wre, FFTSample wim ) | ||
64 | { | ||
65 | register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9"); | ||
66 | z += n*2; /* z[o2] */ | ||
67 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
68 | XPROD31_R(r_re, r_im, wre, wim, t1,t2); | ||
69 | |||
70 | z += n; /* z[o3] */ | ||
71 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
72 | XNPROD31_R(r_re, r_im, wre, wim, t5,t6); | ||
73 | |||
74 | BF_OPT(t1, t5, t5, t1); | ||
75 | BF_OPT(t6, t2, t2, t6); | ||
76 | |||
77 | { | ||
78 | register FFTSample rt0temp asm("r4"); | ||
79 | /*{*/ | ||
80 | /* BF_OPT(t1, t5, t5, t1);*/ | ||
81 | /* BF_OPT(t6, t2, t2, t6);*/ | ||
82 | /* BF_OPT(a2.re, a0.re, a0.re, t5);*/ | ||
83 | /* BF_OPT(a2.im, a0.im, a0.im, t2);*/ | ||
84 | /* BF_OPT(a3.re, a1.re, a1.re, t6);*/ | ||
85 | /* BF_OPT(a3.im, a1.im, a1.im, t1);*/ | ||
86 | /*}*/ | ||
87 | z -= n*3; | ||
88 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
89 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
90 | BF_OPT(rt0temp, r_re, r_re, t5); | ||
91 | BF_OPT(t2, r_im, r_im, t2); | ||
92 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
93 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory" ); | ||
94 | z += n; | ||
95 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
96 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
97 | BF_OPT(t5, r_re, r_re, t6); | ||
98 | BF_OPT(t6, r_im, r_im, t1); | ||
99 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
100 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
101 | z += n; | ||
102 | /* my_z[0] = rt0temp; my_z[1] = t2; */ | ||
103 | asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory"); | ||
104 | } | ||
105 | z += n; | ||
106 | |||
107 | /* my_z[0] = t5; my_z[1] = t6; */ | ||
108 | asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory"); | ||
109 | z -= n*3; | ||
110 | return(z); | ||
111 | } | ||
112 | |||
113 | static inline FFTComplex* TRANSFORM_W01( FFTComplex* z, int n, const FFTSample* w ) | ||
114 | { | ||
115 | register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9"); | ||
116 | |||
117 | /* load wre,wim into t5,t6 */ | ||
118 | asm volatile( "ldmia %[w], {%[wre], %[wim]}\n\t":[wre] "=r" (t5), [wim] "=r" (t6):[w] "r" (w)); | ||
119 | z += n*2; /* z[o2] -- 2n * 2 since complex numbers */ | ||
120 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
121 | XPROD31_R(r_re, r_im, t5 /*wre*/, t6 /*wim*/, t1,t2); | ||
122 | |||
123 | z += n; /* z[o3] */ | ||
124 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
125 | XNPROD31_R(r_re, r_im, t5 /*wre*/, t6 /*wim*/, t5,t6); | ||
126 | |||
127 | BF_OPT(t1, t5, t5, t1); | ||
128 | BF_OPT(t6, t2, t2, t6); | ||
129 | { | ||
130 | register FFTSample rt0temp asm("r4"); | ||
131 | /*{*/ | ||
132 | /* BF_OPT(t1, t5, t5, t1);*/ | ||
133 | /* BF_OPT(t6, t2, t2, t6);*/ | ||
134 | /* BF_OPT(a2.re, a0.re, a0.re, t5);*/ | ||
135 | /* BF_OPT(a2.im, a0.im, a0.im, t2);*/ | ||
136 | /* BF_OPT(a3.re, a1.re, a1.re, t6);*/ | ||
137 | /* BF_OPT(a3.im, a1.im, a1.im, t1);*/ | ||
138 | /*}*/ | ||
139 | z -= n*3; | ||
140 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
141 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
142 | BF_OPT(rt0temp, r_re, r_re, t5); | ||
143 | BF_OPT(t2, r_im, r_im, t2); | ||
144 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
145 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
146 | z += n; | ||
147 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
148 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
149 | BF_OPT(t5, r_re, r_re, t6); | ||
150 | BF_OPT(t6, r_im, r_im, t1); | ||
151 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
152 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
153 | z += n; | ||
154 | /* my_z[0] = rt0temp; my_z[1] = t2; */ | ||
155 | asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory"); | ||
156 | } | ||
157 | z += n; | ||
158 | |||
159 | /* my_z[0] = t5; my_z[1] = t6; */ | ||
160 | asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory"); | ||
161 | z -= n*3; | ||
162 | return(z); | ||
163 | } | ||
164 | |||
165 | static inline FFTComplex* TRANSFORM_W10( FFTComplex* z, int n, const FFTSample* w ) | ||
166 | { | ||
167 | register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9"); | ||
168 | |||
169 | /* load wim,wre into t5,t6 */ | ||
170 | asm volatile( "ldmia %[w], {%[wim], %[wre]}\n\t":[wim] "=r" (t5), [wre] "=r" (t6):[w] "r" (w)); | ||
171 | z += n*2; /* z[o2] -- 2n * 2 since complex numbers */ | ||
172 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
173 | XPROD31_R(r_re, r_im, t6 /*wim*/, t5 /*wre*/, t1,t2); | ||
174 | |||
175 | z += n; /* z[o3] */ | ||
176 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
177 | XNPROD31_R(r_re, r_im, t6 /*wim*/, t5 /*wre*/, t5,t6); | ||
178 | |||
179 | BF_OPT(t1, t5, t5, t1); | ||
180 | BF_OPT(t6, t2, t2, t6); | ||
181 | { | ||
182 | register FFTSample rt0temp asm("r4"); | ||
183 | /*{*/ | ||
184 | /* BF_OPT(t1, t5, t5, t1);*/ | ||
185 | /* BF_OPT(t6, t2, t2, t6);*/ | ||
186 | /* BF_OPT(a2.re, a0.re, a0.re, t5);*/ | ||
187 | /* BF_OPT(a2.im, a0.im, a0.im, t2);*/ | ||
188 | /* BF_OPT(a3.re, a1.re, a1.re, t6);*/ | ||
189 | /* BF_OPT(a3.im, a1.im, a1.im, t1);*/ | ||
190 | /*}*/ | ||
191 | z -= n*3; | ||
192 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
193 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
194 | BF_OPT(rt0temp, r_re, r_re, t5); | ||
195 | BF_OPT(t2, r_im, r_im, t2); | ||
196 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
197 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
198 | z += n; | ||
199 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
200 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
201 | BF_OPT(t5, r_re, r_re, t6); | ||
202 | BF_OPT(t6, r_im, r_im, t1); | ||
203 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
204 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
205 | z += n; | ||
206 | /* my_z[0] = rt0temp; my_z[1] = t2; */ | ||
207 | asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory"); | ||
208 | } | ||
209 | z += n; | ||
210 | |||
211 | /* my_z[0] = t5; my_z[1] = t6; */ | ||
212 | asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory"); | ||
213 | z -= n*3; | ||
214 | return(z); | ||
215 | } | ||
216 | |||
217 | static inline FFTComplex* TRANSFORM_EQUAL( FFTComplex* z, int n ) | ||
218 | { | ||
219 | register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"),r_re asm("r8"),r_im asm("r9"); | ||
220 | |||
221 | z += n*2; /* z[o2] -- 2n * 2 since complex numbers */ | ||
222 | asm volatile( "ldmia %[my_z], {%[t5],%[t6]}\n\t":[t5] "=r" (t5), [t6] "=r" (t6):[my_z] "r" (z)); | ||
223 | z += n; /* z[o3] */ | ||
224 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
225 | |||
226 | /**/ | ||
227 | /*t2 = MULT32(cPI2_8, t5);*/ | ||
228 | /*t1 = MULT31(cPI2_8, t6);*/ | ||
229 | /*t6 = MULT31(cPI2_8, r_re);*/ | ||
230 | /*t5 = MULT32(cPI2_8, r_im);*/ | ||
231 | |||
232 | /*t1 = ( t1 + (t2<<1) );*/ | ||
233 | /*t2 = ( t1 - (t2<<2) );*/ | ||
234 | /*t6 = ( t6 + (t5<<1) );*/ | ||
235 | /*t5 = ( t6 - (t5<<2) );*/ | ||
236 | /**/ | ||
237 | t2 = MULT31(cPI2_8, t5); | ||
238 | t6 = MULT31(cPI2_8, t6); | ||
239 | r_re = MULT31(cPI2_8, r_re); | ||
240 | t5 = MULT31(cPI2_8, r_im); | ||
241 | |||
242 | t1 = ( t6 + t2 ); | ||
243 | t2 = ( t6 - t2 ); | ||
244 | t6 = ( r_re + t5 ); | ||
245 | t5 = ( r_re - t5 ); | ||
246 | |||
247 | BF_OPT(t1, t5, t5, t1); | ||
248 | BF_OPT(t6, t2, t2, t6); | ||
249 | { | ||
250 | register FFTSample rt0temp asm("r4"); | ||
251 | /*{*/ | ||
252 | /* BF_OPT(t1, t5, t5, t1);*/ | ||
253 | /* BF_OPT(t6, t2, t2, t6);*/ | ||
254 | /* BF_OPT(a2.re, a0.re, a0.re, t5);*/ | ||
255 | /* BF_OPT(a2.im, a0.im, a0.im, t2);*/ | ||
256 | /* BF_OPT(a3.re, a1.re, a1.re, t6);*/ | ||
257 | /* BF_OPT(a3.im, a1.im, a1.im, t1);*/ | ||
258 | /*}*/ | ||
259 | z -= n*3; | ||
260 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
261 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
262 | BF_OPT(rt0temp, r_re, r_re, t5); | ||
263 | BF_OPT(t2, r_im, r_im, t2); | ||
264 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
265 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
266 | z += n; | ||
267 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
268 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
269 | BF_OPT(t5, r_re, r_re, t6); | ||
270 | BF_OPT(t6, r_im, r_im, t1); | ||
271 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
272 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
273 | z += n; | ||
274 | /* my_z[0] = rt0temp; my_z[1] = t2; */ | ||
275 | asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory"); | ||
276 | } | ||
277 | z += n; | ||
278 | |||
279 | /* my_z[0] = t5; my_z[1] = t6; */ | ||
280 | asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory"); | ||
281 | z -= n*3; | ||
282 | return(z); | ||
283 | } | ||
284 | |||
285 | static inline FFTComplex* TRANSFORM_ZERO( FFTComplex* z, int n ) | ||
286 | { | ||
287 | register FFTSample t1,t2 asm("r5"),t5 asm("r6"),t6 asm("r7"), r_re asm("r8"), r_im asm("r9"); | ||
288 | |||
289 | z += n*2; /* z[o2] -- 2n * 2 since complex numbers */ | ||
290 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
291 | z += n; /* z[o3] */ | ||
292 | asm volatile( "ldmia %[my_z], {%[t5],%[t6]}\n\t":[t5] "=r" (t5), [t6] "=r" (t6):[my_z] "r" (z)); | ||
293 | |||
294 | BF_OPT(t1, t5, t5, r_re); | ||
295 | BF_OPT(t6, t2, r_im, t6); | ||
296 | { | ||
297 | register FFTSample rt0temp asm("r4"); | ||
298 | /*{*/ | ||
299 | /* BF_OPT(t1, t5, t5, t1);*/ | ||
300 | /* BF_OPT(t6, t2, t2, t6);*/ | ||
301 | /* BF_OPT(a2.re, a0.re, a0.re, t5);*/ | ||
302 | /* BF_OPT(a2.im, a0.im, a0.im, t2);*/ | ||
303 | /* BF_OPT(a3.re, a1.re, a1.re, t6);*/ | ||
304 | /* BF_OPT(a3.im, a1.im, a1.im, t1);*/ | ||
305 | /*}*/ | ||
306 | z -= n*3; | ||
307 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
308 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
309 | BF_OPT(rt0temp, r_re, r_re, t5); | ||
310 | BF_OPT(t2, r_im, r_im, t2); | ||
311 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
312 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
313 | z += n; | ||
314 | /* r_re = my_z[0]; r_im = my_z[1]; */ | ||
315 | asm volatile( "ldmia %[my_z], {%[r_re],%[r_im]}\n\t":[r_re] "=r" (r_re), [r_im] "=r" (r_im):[my_z] "r" (z)); | ||
316 | BF_OPT(t5, r_re, r_re, t6); | ||
317 | BF_OPT(t6, r_im, r_im, t1); | ||
318 | /* my_z[0] = r_re; my_z[1] = r_im; */ | ||
319 | asm volatile( "stmia %[my_z], {%[r_re],%[r_im]}\n\t"::[my_z] "r" (z), [r_re] "r" (r_re), [r_im] "r" (r_im):"memory"); | ||
320 | z += n; | ||
321 | /* my_z[0] = rt0temp; my_z[1] = t2; */ | ||
322 | asm volatile( "stmia %[my_z], {%[rt0temp],%[t2]}\n\t"::[my_z] "r" (z), [rt0temp] "r" (rt0temp), [t2] "r" (t2):"memory"); | ||
323 | } | ||
324 | z += n; | ||
325 | |||
326 | /* my_z[0] = t5; my_z[1] = t6; */ | ||
327 | asm volatile( "stmia %[my_z]!, {%[t5],%[t6]}\n\t":[my_z] "+r" (z) : [t5] "r" (t5), [t6] "r" (t6):"memory"); | ||
328 | z -= n*3; | ||
329 | return(z); | ||
330 | } | ||
331 | |||
332 | #define FFT_FFMPEG_INCL_OPTIMISED_FFT4 | ||
333 | static inline FFTComplex* fft4(FFTComplex * z) | ||
334 | { | ||
335 | FFTSample temp; | ||
336 | |||
337 | /* input[0..7] -> output[0..7] */ | ||
338 | /* load r1=z[0],r2=z[1],...,r8=z[7] */ | ||
339 | asm volatile( | ||
340 | "ldmia %[z], {r1-r8}\n\t" | ||
341 | "add r1,r1,r3\n\t" /* r1 :=t1 */ | ||
342 | "sub r3,r1,r3, lsl #1\n\t" /* r3 :=t3 */ | ||
343 | "sub r7,r7,r5\n\t" /* r10:=t8 */ | ||
344 | "add r5,r7,r5, lsl #1\n\t" /* r5 :=t6 */ | ||
345 | |||
346 | "add r1,r1,r5\n\t" /* r1 = o[0] */ | ||
347 | "sub r5,r1,r5, lsl #1\n\t" /* r5 = o[4] */ | ||
348 | |||
349 | "add r2,r2,r4\n\t" /* r2 :=t2 */ | ||
350 | "sub r4,r2,r4, lsl #1\n\t" /* r9 :=t4 */ | ||
351 | |||
352 | "add %[temp],r6,r8\n\t" /* r10:=t5 */ | ||
353 | "sub r6,r6,r8\n\t" /* r6 :=t7 */ | ||
354 | |||
355 | "sub r8,r4,r7\n\t" /* r8 = o[7]*/ | ||
356 | "add r4,r4,r7\n\t" /* r4 = o[3]*/ | ||
357 | "sub r7,r3,r6\n\t" /* r7 = o[6]*/ | ||
358 | "add r3,r3,r6\n\t" /* r3 = o[2]*/ | ||
359 | "sub r6,r2,%[temp]\n\t" /* r6 = o[5]*/ | ||
360 | "add r2,r2,%[temp]\n\t" /* r2 = o[1]*/ | ||
361 | |||
362 | "stmia %[z]!, {r1-r8}\n\t" | ||
363 | : /* outputs */ [z] "+r" (z), [temp] "=r" (temp) | ||
364 | : /* inputs */ | ||
365 | : /* clobbers */ | ||
366 | "r1","r2","r3","r4","r5","r6","r7","r8","memory" | ||
367 | ); | ||
368 | return z; | ||
369 | } | ||
370 | |||
371 | #define FFT_FFMPEG_INCL_OPTIMISED_FFT8 | ||
372 | /* The chunk of asm below is equivalent to the following: | ||
373 | |||
374 | // first load in z[4].re thru z[7].im into local registers | ||
375 | // ... | ||
376 | BF_OPT2_REV(z[4].re, z[5].re, z[4].re, z[5].re); // x=a+b; y=x-(b<<1) | ||
377 | BF_OPT2_REV(z[4].im, z[5].im, z[4].im, z[5].im); | ||
378 | BF_REV (temp, z[7].re, z[6].re, z[7].re); // x=a+b; y=a-b; | ||
379 | BF_REV (z[6].re, z[7].im, z[6].im, z[7].im); | ||
380 | // save z[7].re and z[7].im as those are complete now | ||
381 | // z[5].re and z[5].im are also complete now but save these later on | ||
382 | |||
383 | BF(z[6].im, z[4].re, temp, z[4].re); // x=a-b; y=a+b | ||
384 | BF_OPT(z[6].re, z[4].im, z[4].im, z[6].re); // y=a+b; x=y-(b<<1) | ||
385 | // now load z[2].re and z[2].im | ||
386 | // ... | ||
387 | BF_OPT(z[6].re, z[2].re, z[2].re, z[6].re); // y=a+b; x=y-(b<<1) | ||
388 | BF_OPT(z[6].im, z[2].im, z[2].im, z[6].im); // y=a+b; x=y-(b<<1) | ||
389 | // Now save z[6].re and z[6].im, along with z[5].re and z[5].im | ||
390 | // for efficiency. Also save z[2].re and z[2].im. | ||
391 | // Now load z[0].re and z[0].im | ||
392 | // ... | ||
393 | |||
394 | BF_OPT(z[4].re, z[0].re, z[0].re, z[4].re); // y=a+b; x=y-(b<<1) | ||
395 | BF_OPT(z[4].im, z[0].im, z[0].im, z[4].im); // y=a+b; x=y-(b<<1) | ||
396 | // Finally save out z[4].re, z[4].im, z[0].re and z[0].im | ||
397 | // ... | ||
398 | */ | ||
399 | static inline void fft8(FFTComplex * z) | ||
400 | { | ||
401 | FFTComplex* m4 = fft4(z); | ||
402 | { | ||
403 | /* note that we increment z_ptr on the final stmia, which | ||
404 | leaves z_ptr pointing to z[1].re ready for the Transform step */ | ||
405 | |||
406 | register FFTSample temp; | ||
407 | |||
408 | asm volatile( | ||
409 | /* read in z[4].re thru z[7].im */ | ||
410 | "ldmia %[z4_ptr]!, {r1-r8}\n\t" | ||
411 | /* (now points one word past &z[7].im) */ | ||
412 | "add r1,r1,r3\n\t" | ||
413 | "sub r3,r1,r3,lsl #1\n\t" | ||
414 | "add r2,r2,r4\n\t" | ||
415 | "sub r4,r2,r4,lsl #1\n\t" | ||
416 | "add %[temp],r5,r7\n\t" | ||
417 | "sub r7,r5,r7\n\t" | ||
418 | "add r5,r6,r8\n\t" | ||
419 | "sub r8,r6,r8\n\t" | ||
420 | |||
421 | "stmdb %[z4_ptr]!, {r7,r8}\n\t" /* write z[7].re,z[7].im straight away */ | ||
422 | /* Note, registers r7 & r8 now free */ | ||
423 | |||
424 | "sub r6,%[temp],r1\n\t" | ||
425 | "add r1,%[temp],r1\n\t" | ||
426 | "add r2,r2,r5\n\t" | ||
427 | "sub r5,r2,r5,lsl #1\n\t" | ||
428 | "add %[temp], %[z_ptr], #16\n\t" /* point to &z[2].re */ | ||
429 | "ldmia %[temp],{r7,r8}\n\t" /* load z[2].re and z[2].im */ | ||
430 | "add r7,r7,r5\n\t" | ||
431 | "sub r5,r7,r5,lsl #1\n\t" | ||
432 | "add r8,r8,r6\n\t" | ||
433 | "sub r6,r8,r6,lsl #1\n\t" | ||
434 | |||
435 | /* write out z[5].re, z[5].im, z[6].re, z[6].im in one go*/ | ||
436 | "stmdb %[z4_ptr]!, {r3-r6}\n\t" | ||
437 | "stmia %[temp],{r7,r8}\n\t" /* write out z[2].re, z[2].im */ | ||
438 | "ldmia %[z_ptr],{r7,r8}\n\t" /* load r[0].re, r[0].im */ | ||
439 | |||
440 | "add r7,r7,r1\n\t" | ||
441 | "sub r1,r7,r1,lsl #1\n\t" | ||
442 | "add r8,r8,r2\n\t" | ||
443 | "sub r2,r8,r2,lsl #1\n\t" | ||
444 | |||
445 | "stmia %[z_ptr]!,{r7,r8}\n\t" /* write out z[0].re, z[0].im */ | ||
446 | "stmdb %[z4_ptr], {r1,r2}\n\t" /* write out z[4].re, z[4].im */ | ||
447 | : [z4_ptr] "+r" (m4), [temp] "=r" (temp), [z_ptr] "+r" (z) | ||
448 | : | ||
449 | : "r1","r2","r3","r4","r5","r6","r7","r8","memory" | ||
450 | ); | ||
451 | } | ||
452 | |||
453 | TRANSFORM_EQUAL(z,2); | ||
454 | } | ||
455 | |||
456 | #endif // CPU_ARM | ||
diff --git a/apps/codecs/lib/fft-ffmpeg_cf.h b/apps/codecs/lib/fft-ffmpeg_cf.h deleted file mode 100644 index a29464a23d..0000000000 --- a/apps/codecs/lib/fft-ffmpeg_cf.h +++ /dev/null | |||
@@ -1,370 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2010 Nils Wallménius | ||
11 | * | ||
12 | * Coldfire v2 optimisations for ffmpeg's fft (used in fft-ffmpeg.c) | ||
13 | * | ||
14 | * This program is free software; you can redistribute it and/or | ||
15 | * modify it under the terms of the GNU General Public License | ||
16 | * as published by the Free Software Foundation; either version 2 | ||
17 | * of the License, or (at your option) any later version. | ||
18 | * | ||
19 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
20 | * KIND, either express or implied. | ||
21 | * | ||
22 | ****************************************************************************/ | ||
23 | |||
24 | #ifdef CPU_COLDFIRE | ||
25 | #define FFT_FFMPEG_INCL_OPTIMISED_FFT4 | ||
26 | static inline void fft4(FFTComplex * z) | ||
27 | { | ||
28 | asm volatile ("movem.l (%[z]), %%d0-%%d7\n\t" | ||
29 | "move.l %%d0, %%a0\n\t" | ||
30 | "add.l %%d2, %%d0\n\t" /* d0 == t1 */ | ||
31 | "neg.l %%d2\n\t" | ||
32 | "add.l %%a0, %%d2\n\t" /* d2 == t3, a0 free */ | ||
33 | "move.l %%d6, %%a0\n\t" | ||
34 | "sub.l %%d4, %%d6\n\t" /* d6 == t8 */ | ||
35 | "add.l %%d4, %%a0\n\t" /* a0 == t6 */ | ||
36 | |||
37 | "move.l %%d0, %%d4\n\t" | ||
38 | "sub.l %%a0, %%d4\n\t" /* z[2].re done */ | ||
39 | "add.l %%a0, %%d0\n\t" /* z[0].re done, a0 free */ | ||
40 | |||
41 | "move.l %%d5, %%a0\n\t" | ||
42 | "sub.l %%d7, %%d5\n\t" /* d5 == t7 */ | ||
43 | "add.l %%d7, %%a0\n\t" /* a0 == t5 */ | ||
44 | |||
45 | "move.l %%d1, %%d7\n\t" | ||
46 | "sub.l %%d3, %%d7\n\t" /* d7 == t4 */ | ||
47 | "add.l %%d3, %%d1\n\t" /* d1 == t2 */ | ||
48 | |||
49 | "move.l %%d7, %%d3\n\t" | ||
50 | "sub.l %%d6, %%d7\n\t" /* z[3].im done */ | ||
51 | "add.l %%d6, %%d3\n\t" /* z[1].im done */ | ||
52 | |||
53 | "move.l %%d2, %%d6\n\t" | ||
54 | "sub.l %%d5, %%d6\n\t" /* z[3].re done */ | ||
55 | "add.l %%d5, %%d2\n\t" /* z[1].re done */ | ||
56 | |||
57 | "move.l %%d1, %%d5\n\t" | ||
58 | "sub.l %%a0, %%d5\n\t" /* z[2].im done */ | ||
59 | "add.l %%a0, %%d1\n\t" /* z[0].im done */ | ||
60 | |||
61 | "movem.l %%d0-%%d7, (%[z])\n\t" | ||
62 | : :[z] "a" (z) | ||
63 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", | ||
64 | "a0", "cc", "memory"); | ||
65 | |||
66 | } | ||
67 | |||
68 | #define FFT_FFMPEG_INCL_OPTIMISED_FFT8 | ||
69 | static inline void fft8(FFTComplex *z) | ||
70 | { | ||
71 | asm volatile ("movem.l (4*8, %[z]), %%d0-%%d7\n\t" | ||
72 | "move.l %%d0, %%a1\n\t" | ||
73 | "add.l %%d2, %%a1\n\t" /* a1 == t1 */ | ||
74 | "sub.l %%d2, %%d0\n\t" /* d0 == z[5].re */ | ||
75 | |||
76 | "move.l %%d1, %%a2\n\t" | ||
77 | "add.l %%d3, %%a2\n\t" /* a2 == t2 */ | ||
78 | "sub.l %%d3, %%d1\n\t" /* d1 == z[5].im */ | ||
79 | |||
80 | "move.l %%d4, %%d2\n\t" | ||
81 | "add.l %%d6, %%d2\n\t" /* d2 == t3 */ | ||
82 | "sub.l %%d6, %%d4\n\t" /* d4 == z[7].re */ | ||
83 | |||
84 | "move.l %%d5, %%d3\n\t" | ||
85 | "add.l %%d7, %%d3\n\t" /* d3 == t4 */ | ||
86 | "sub.l %%d7, %%d5\n\t" /* d5 == z[7].im */ | ||
87 | |||
88 | "move.l %%d2, %%a4\n\t" | ||
89 | "sub.l %%a1, %%a4\n\t" /* a4 == t8 */ | ||
90 | "add.l %%d2, %%a1\n\t" /* a1 == t1, d2 free */ | ||
91 | |||
92 | "move.l %%a2, %%a3\n\t" | ||
93 | "sub.l %%d3, %%a3\n\t" /* a3 == t7 */ | ||
94 | "add.l %%d3, %%a2\n\t" /* a2 == t2, d3 free */ | ||
95 | |||
96 | /* emac block from TRANSFORM_EQUAL, do this now | ||
97 | so we don't need to store and load z[5] and z[7] */ | ||
98 | "move.l %[_cPI2_8], %%d2\n\t" | ||
99 | "mac.l %%d2, %%d0, %%acc0\n\t" | ||
100 | "mac.l %%d2, %%d1, %%acc1\n\t" | ||
101 | "mac.l %%d2, %%d4, %%acc2\n\t" | ||
102 | "mac.l %%d2, %%d5, %%acc3\n\t" | ||
103 | |||
104 | /* fft4, clobbers all d regs and a0 */ | ||
105 | "movem.l (%[z]), %%d0-%%d7\n\t" | ||
106 | "move.l %%d0, %%a0\n\t" | ||
107 | "add.l %%d2, %%d0\n\t" /* d0 == t1 */ | ||
108 | "neg.l %%d2\n\t" | ||
109 | "add.l %%a0, %%d2\n\t" /* d2 == t3, a0 free */ | ||
110 | "move.l %%d6, %%a0\n\t" | ||
111 | "sub.l %%d4, %%d6\n\t" /* d6 == t8 */ | ||
112 | "add.l %%d4, %%a0\n\t" /* a0 == t6 */ | ||
113 | |||
114 | "move.l %%d0, %%d4\n\t" | ||
115 | "sub.l %%a0, %%d4\n\t" /* z[2].re done */ | ||
116 | "add.l %%a0, %%d0\n\t" /* z[0].re done, a0 free */ | ||
117 | |||
118 | "move.l %%d5, %%a0\n\t" | ||
119 | "sub.l %%d7, %%d5\n\t" /* d5 == t7 */ | ||
120 | "add.l %%d7, %%a0\n\t" /* a0 == t5 */ | ||
121 | |||
122 | "move.l %%d1, %%d7\n\t" | ||
123 | "sub.l %%d3, %%d7\n\t" /* d7 == t4 */ | ||
124 | "add.l %%d3, %%d1\n\t" /* d1 == t2 */ | ||
125 | |||
126 | "move.l %%d7, %%d3\n\t" | ||
127 | "sub.l %%d6, %%d7\n\t" /* z[3].im done */ | ||
128 | "add.l %%d6, %%d3\n\t" /* z[1].im done */ | ||
129 | |||
130 | "move.l %%d2, %%d6\n\t" | ||
131 | "sub.l %%d5, %%d6\n\t" /* z[3].re done */ | ||
132 | "add.l %%d5, %%d2\n\t" /* z[1].re done */ | ||
133 | |||
134 | "move.l %%d1, %%d5\n\t" | ||
135 | "sub.l %%a0, %%d5\n\t" /* z[2].im done */ | ||
136 | "add.l %%a0, %%d1\n\t" /* z[0].im done */ | ||
137 | /* end of fft4, but don't store yet */ | ||
138 | |||
139 | "move.l %%d0, %%a0\n\t" | ||
140 | "add.l %%a1, %%d0\n\t" | ||
141 | "sub.l %%a1, %%a0\n\t" /* z[4].re, z[0].re done, a1 free */ | ||
142 | |||
143 | "move.l %%d1, %%a1\n\t" | ||
144 | "add.l %%a2, %%d1\n\t" | ||
145 | "sub.l %%a2, %%a1\n\t" /* z[4].im, z[0].im done, a2 free */ | ||
146 | |||
147 | "move.l %%d4, %%a2\n\t" | ||
148 | "add.l %%a3, %%d4\n\t" | ||
149 | "sub.l %%a3, %%a2\n\t" /* z[6].re, z[2].re done, a3 free */ | ||
150 | |||
151 | "move.l %%d5, %%a3\n\t" | ||
152 | "add.l %%a4, %%d5\n\t" | ||
153 | "sub.l %%a4, %%a3\n\t" /* z[6].im, z[2].im done, a4 free */ | ||
154 | |||
155 | "movem.l %%d0-%%d1, (%[z])\n\t" /* save z[0] */ | ||
156 | "movem.l %%d4-%%d5, (2*8, %[z])\n\t" /* save z[2] */ | ||
157 | "movem.l %%a0-%%a1, (4*8, %[z])\n\t" /* save z[4] */ | ||
158 | "movem.l %%a2-%%a3, (6*8, %[z])\n\t" /* save z[6] */ | ||
159 | |||
160 | /* TRANSFORM_EQUAL */ | ||
161 | "movclr.l %%acc0, %%d0\n\t" | ||
162 | "movclr.l %%acc1, %%d1\n\t" | ||
163 | "movclr.l %%acc2, %%d4\n\t" | ||
164 | "movclr.l %%acc3, %%d5\n\t" | ||
165 | |||
166 | "move.l %%d1, %%a0\n\t" | ||
167 | "add.l %%d0, %%a0\n\t" /* a0 == t1 */ | ||
168 | "sub.l %%d0, %%d1\n\t" /* d1 == t2 */ | ||
169 | |||
170 | "move.l %%d4, %%d0\n\t" | ||
171 | "add.l %%d5, %%d0\n\t" /* d0 == t6 */ | ||
172 | "sub.l %%d5, %%d4\n\t" /* d4 == t5 */ | ||
173 | |||
174 | "move.l %%d4, %%a1\n\t" | ||
175 | "sub.l %%a0, %%a1\n\t" /* a1 == temp1 */ | ||
176 | "add.l %%a0, %%d4\n\t" /* d4 == temp2 */ | ||
177 | |||
178 | "move.l %%d2, %%a2\n\t" | ||
179 | "sub.l %%d4, %%a2\n\t" /* a2 == z[5].re */ | ||
180 | "add.l %%d4, %%d2\n\t" /* z[1].re done */ | ||
181 | |||
182 | "move.l %%d7, %%d5\n\t" | ||
183 | "sub.l %%a1, %%d5\n\t" /* d5 == z[7].im */ | ||
184 | "add.l %%a1, %%d7\n\t" /* z[3].im done */ | ||
185 | |||
186 | "move.l %%d1, %%a0\n\t" | ||
187 | "sub.l %%d0, %%a0\n\t" /* a0 == temp1 */ | ||
188 | "add.l %%d0, %%d1\n\t" /* d1 == temp2 */ | ||
189 | |||
190 | "move.l %%d6, %%d4\n\t" | ||
191 | "sub.l %%a0, %%d4\n\t" /* d4 == z[7].re */ | ||
192 | "add.l %%a0, %%d6\n\t" /* z[3].re done */ | ||
193 | |||
194 | "move.l %%d3, %%a3\n\t" | ||
195 | "sub.l %%d1, %%a3\n\t" /* a3 == z[5].im */ | ||
196 | "add.l %%d1, %%d3\n\t" /* z[1].im done */ | ||
197 | |||
198 | "movem.l %%d2-%%d3, (1*8, %[z])\n\t" /* save z[1] */ | ||
199 | "movem.l %%d6-%%d7, (3*8, %[z])\n\t" /* save z[3] */ | ||
200 | "movem.l %%a2-%%a3, (5*8, %[z])\n\t" /* save z[5] */ | ||
201 | "movem.l %%d4-%%d5, (7*8, %[z])\n\t" /* save z[7] */ | ||
202 | : :[z] "a" (z), [_cPI2_8] "i" (cPI2_8) | ||
203 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", | ||
204 | "a0", "a1", "a2", "a3", "a4", "cc", "memory"); | ||
205 | } | ||
206 | |||
207 | #define FFT_FFMPEG_INCL_OPTIMISED_TRANSFORM | ||
208 | |||
209 | static inline FFTComplex* TRANSFORM(FFTComplex * z, unsigned int n, FFTSample wre, FFTSample wim) | ||
210 | { | ||
211 | asm volatile ("move.l (%[z2]), %%d5\n\t" | ||
212 | "mac.l %%d5, %[wre], (4, %[z2]), %%d4, %%acc0\n\t" | ||
213 | "mac.l %%d4, %[wim], %%acc0\n\t" | ||
214 | "mac.l %%d4, %[wre], (%[z3]), %%d6, %%acc1\n\t" | ||
215 | "msac.l %%d5, %[wim], (4, %[z3]), %%d7, %%acc1\n\t" | ||
216 | "mac.l %%d6, %[wre], (%[z])+, %%d4, %%acc2\n\t" | ||
217 | "msac.l %%d7, %[wim], (%[z])+, %%d5, %%acc2\n\t" | ||
218 | "mac.l %%d7, %[wre], %%acc3\n\t" | ||
219 | "mac.l %%d6, %[wim], %%acc3\n\t" | ||
220 | |||
221 | "movclr.l %%acc0, %[wre]\n\t" /* t1 */ | ||
222 | "movclr.l %%acc2, %[wim]\n\t" /* t5 */ | ||
223 | |||
224 | "move.l %%d4, %%d6\n\t" | ||
225 | "move.l %[wim], %%d7\n\t" | ||
226 | "sub.l %[wre], %[wim]\n\t" /* t5 = t5-t1 */ | ||
227 | "add.l %[wre], %%d7\n\t" | ||
228 | "sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */ | ||
229 | "add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */ | ||
230 | |||
231 | "movclr.l %%acc3, %%d7\n\t" /* t6 */ | ||
232 | "movclr.l %%acc1, %%d3\n\t" /* t2 */ | ||
233 | |||
234 | "move.l %%d3, %[wre]\n\t" | ||
235 | "add.l %%d7, %[wre]\n\t" | ||
236 | "sub.l %%d7, %%d3\n\t" /* t2 = t6-t2 */ | ||
237 | "move.l %%d5, %%d7\n\t" | ||
238 | "sub.l %[wre], %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */ | ||
239 | |||
240 | "movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */ | ||
241 | "add.l %[wre], %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */ | ||
242 | "movem.l %%d4-%%d5, (-8, %[z])\n\t" /* store z0 */ | ||
243 | |||
244 | "movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */ | ||
245 | "move.l %%d4, %%d6\n\t" | ||
246 | |||
247 | "sub.l %%d3, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */ | ||
248 | "add.l %%d3, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */ | ||
249 | |||
250 | "move.l %%d5, %%d7\n\t" | ||
251 | "sub.l %[wim], %%d7\n\t" | ||
252 | "movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */ | ||
253 | "add.l %[wim], %%d5\n\t" | ||
254 | "movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */ | ||
255 | |||
256 | : [wre] "+r" (wre), [wim] "+r" (wim), /* we clobber these after using them */ | ||
257 | [z] "+a" (z) | ||
258 | : [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n]) | ||
259 | : "d3", "d4", "d5", "d6", "d7", "cc", "memory"); | ||
260 | return z; | ||
261 | } | ||
262 | |||
263 | static inline FFTComplex* TRANSFORM_W01(FFTComplex * z, unsigned int n, const FFTSample * w) | ||
264 | { | ||
265 | return TRANSFORM(z, n, w[0], w[1]); | ||
266 | } | ||
267 | |||
268 | static inline FFTComplex* TRANSFORM_W10(FFTComplex * z, unsigned int n, const FFTSample * w) | ||
269 | { | ||
270 | return TRANSFORM(z, n, w[1], w[0]); | ||
271 | } | ||
272 | |||
273 | static inline FFTComplex* TRANSFORM_ZERO(FFTComplex * z, unsigned int n) | ||
274 | { | ||
275 | asm volatile("movem.l (%[z]), %%d4-%%d5\n\t" /* load z0 */ | ||
276 | "move.l %%d4, %%d6\n\t" | ||
277 | "movem.l (%[z2]), %%d2-%%d3\n\t" /* load z2 */ | ||
278 | "movem.l (%[z3]), %%d0-%%d1\n\t" /* load z0 */ | ||
279 | "move.l %%d0, %%d7\n\t" | ||
280 | "sub.l %%d2, %%d0\n\t" | ||
281 | "add.l %%d2, %%d7\n\t" | ||
282 | "sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */ | ||
283 | "add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */ | ||
284 | |||
285 | "move.l %%d5, %%d7\n\t" | ||
286 | "move.l %%d3, %%d2\n\t" | ||
287 | "add.l %%d1, %%d2\n\t" | ||
288 | "sub.l %%d2, %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */ | ||
289 | "movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */ | ||
290 | "add.l %%d2, %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */ | ||
291 | "movem.l %%d4-%%d5, (%[z])\n\t" /* store z0 */ | ||
292 | |||
293 | "movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */ | ||
294 | "move.l %%d4, %%d6\n\t" | ||
295 | "sub.l %%d1, %%d3\n\t" | ||
296 | "sub.l %%d3, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */ | ||
297 | "add.l %%d3, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */ | ||
298 | |||
299 | "move.l %%d5, %%d7\n\t" | ||
300 | "sub.l %%d0, %%d7\n\t" | ||
301 | "movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */ | ||
302 | "add.l %%d0, %%d5\n\t" | ||
303 | |||
304 | "movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */ | ||
305 | |||
306 | : | ||
307 | : [z] "a" (z), [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n]) | ||
308 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory"); | ||
309 | return z+1; | ||
310 | } | ||
311 | |||
312 | static inline FFTComplex* TRANSFORM_EQUAL(FFTComplex * z, unsigned int n) | ||
313 | { | ||
314 | asm volatile ("movem.l (%[z2]), %%d0-%%d1\n\t" | ||
315 | "move.l %[_cPI2_8], %%d2\n\t" | ||
316 | "mac.l %%d0, %%d2, (%[z3]), %%d0, %%acc0\n\t" | ||
317 | "mac.l %%d1, %%d2, (4, %[z3]), %%d1, %%acc1\n\t" | ||
318 | "mac.l %%d0, %%d2, (%[z]), %%d4, %%acc2\n\t" | ||
319 | "mac.l %%d1, %%d2, (4, %[z]), %%d5, %%acc3\n\t" | ||
320 | |||
321 | "movclr.l %%acc0, %%d0\n\t" | ||
322 | "movclr.l %%acc1, %%d1\n\t" | ||
323 | "movclr.l %%acc2, %%d2\n\t" | ||
324 | "movclr.l %%acc3, %%d3\n\t" | ||
325 | |||
326 | "move.l %%d0, %%d7\n\t" | ||
327 | "add.l %%d1, %%d0\n\t" /* d0 == t1 */ | ||
328 | "sub.l %%d7, %%d1\n\t" /* d1 == t2 */ | ||
329 | |||
330 | "move.l %%d3, %%d7\n\t" | ||
331 | "add.l %%d2, %%d3\n\t" /* d3 == t6 */ | ||
332 | "sub.l %%d7, %%d2\n\t" /* d2 == t5 */ | ||
333 | |||
334 | "move.l %%d4, %%d6\n\t" | ||
335 | "move.l %%d2, %%d7\n\t" | ||
336 | "sub.l %%d0, %%d2\n\t" /* t5 = t5-t1 */ | ||
337 | "add.l %%d0, %%d7\n\t" | ||
338 | "sub.l %%d7, %%d6\n\t" /* d6 = a0re - (t5+t1) => a2re */ | ||
339 | "add.l %%d7, %%d4\n\t" /* d4 = a0re + (t5+t1) => a0re */ | ||
340 | |||
341 | "move.l %%d1, %%d0\n\t" | ||
342 | "add.l %%d3, %%d0\n\t" | ||
343 | "sub.l %%d3, %%d1\n\t" /* t2 = t6-t2 */ | ||
344 | "move.l %%d5, %%d7\n\t" | ||
345 | "sub.l %%d0, %%d7\n\t" /* d7 = a0im - (t2+t6) => a2im */ | ||
346 | |||
347 | "movem.l %%d6-%%d7, (%[z2])\n\t" /* store z2 */ | ||
348 | "add.l %%d0, %%d5\n\t" /* d5 = a0im + (t2+t6) => a0im */ | ||
349 | "movem.l %%d4-%%d5, (%[z])\n\t" /* store z0 */ | ||
350 | |||
351 | "movem.l (%[z1]), %%d4-%%d5\n\t" /* load z1 */ | ||
352 | "move.l %%d4, %%d6\n\t" | ||
353 | |||
354 | "sub.l %%d1, %%d6\n\t" /* d6 = a1re - (t2-t6) => a3re */ | ||
355 | "add.l %%d1, %%d4\n\t" /* d4 = a1re + (t2-t6) => a1re */ | ||
356 | |||
357 | "move.l %%d5, %%d7\n\t" | ||
358 | "sub.l %%d2, %%d7\n\t" | ||
359 | "movem.l %%d6-%%d7, (%[z3])\n\t" /* store z3 */ | ||
360 | "add.l %%d2, %%d5\n\t" | ||
361 | "movem.l %%d4-%%d5, (%[z1])\n\t" /* store z1 */ | ||
362 | |||
363 | :: [z] "a" (z), [z1] "a" (&z[n]), [z2] "a" (&z[2*n]), [z3] "a" (&z[3*n]), | ||
364 | [_cPI2_8] "i" (cPI2_8) | ||
365 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory"); | ||
366 | |||
367 | return z+1; | ||
368 | } | ||
369 | |||
370 | #endif /* CPU_COLDIFRE */ | ||
diff --git a/apps/codecs/lib/fft.h b/apps/codecs/lib/fft.h deleted file mode 100644 index 302a3b3996..0000000000 --- a/apps/codecs/lib/fft.h +++ /dev/null | |||
@@ -1,64 +0,0 @@ | |||
1 | /* | ||
2 | * WMA compatible decoder | ||
3 | * Copyright (c) 2002 The FFmpeg Project. | ||
4 | * | ||
5 | * This library is free software; you can redistribute it and/or | ||
6 | * modify it under the terms of the GNU Lesser General Public | ||
7 | * License as published by the Free Software Foundation; either | ||
8 | * version 2 of the License, or (at your option) any later version. | ||
9 | * | ||
10 | * This library is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | * Lesser General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU Lesser General Public | ||
16 | * License along with this library; if not, write to the Free Software | ||
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
18 | */ | ||
19 | #ifndef CODECLIB_FFT_H_INCLUDED | ||
20 | #define CODECLIB_FFT_H_INCLUDED | ||
21 | |||
22 | #include <inttypes.h> | ||
23 | typedef int32_t fixed32; | ||
24 | typedef int64_t fixed64; | ||
25 | |||
26 | #define FFT_FIXED | ||
27 | |||
28 | #ifdef FFT_FIXED | ||
29 | typedef fixed32 FFTSample; | ||
30 | #else /* FFT_FIXED */ | ||
31 | typedef float FFTSample; | ||
32 | #endif /* FFT_FIXED */ | ||
33 | |||
34 | typedef struct FFTComplex { | ||
35 | FFTSample re, im; | ||
36 | } FFTComplex; | ||
37 | |||
38 | typedef struct FFTContext { | ||
39 | int nbits; | ||
40 | int inverse; | ||
41 | uint16_t *revtab; | ||
42 | int mdct_size; /* size of MDCT (i.e. number of input data * 2) */ | ||
43 | int mdct_bits; /* n = 2^nbits */ | ||
44 | /* pre/post rotation tables */ | ||
45 | FFTSample *tcos; | ||
46 | FFTSample *tsin; | ||
47 | void (*fft_permute)(struct FFTContext *s, FFTComplex *z); | ||
48 | void (*fft_calc)(struct FFTContext *s, FFTComplex *z); | ||
49 | void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); | ||
50 | void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input); | ||
51 | void (*mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); | ||
52 | int split_radix; | ||
53 | int permutation; | ||
54 | #define FF_MDCT_PERM_NONE 0 | ||
55 | #define FF_MDCT_PERM_INTERLEAVE 1 | ||
56 | } FFTContext; | ||
57 | |||
58 | // internal api (fft<->mdct) | ||
59 | //int fft_calc_unscaled(FFTContext *s, FFTComplex *z); | ||
60 | //void ff_fft_permute_c(FFTContext *s, FFTComplex *z); // internal only? | ||
61 | void ff_fft_calc_c(int nbits, FFTComplex *z); | ||
62 | |||
63 | #endif // CODECLIB_FFT_H_INCLUDED | ||
64 | |||
diff --git a/apps/codecs/lib/fixedpoint.c b/apps/codecs/lib/fixedpoint.c deleted file mode 100644 index 352e246673..0000000000 --- a/apps/codecs/lib/fixedpoint.c +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | #include "../../fixedpoint.c" | ||
diff --git a/apps/codecs/lib/fixedpoint.h b/apps/codecs/lib/fixedpoint.h deleted file mode 100644 index 1cbd1573bb..0000000000 --- a/apps/codecs/lib/fixedpoint.h +++ /dev/null | |||
@@ -1,49 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2006 Jens Arnold | ||
11 | * | ||
12 | * Fixed point library for plugins | ||
13 | * | ||
14 | * This program is free software; you can redistribute it and/or | ||
15 | * modify it under the terms of the GNU General Public License | ||
16 | * as published by the Free Software Foundation; either version 2 | ||
17 | * of the License, or (at your option) any later version. | ||
18 | * | ||
19 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
20 | * KIND, either express or implied. | ||
21 | * | ||
22 | ****************************************************************************/ | ||
23 | |||
24 | /** CODECS - FIXED POINT MATH ROUTINES - USAGE | ||
25 | * | ||
26 | * - x and y arguments are fixed point integers | ||
27 | * - fracbits is the number of fractional bits in the argument(s) | ||
28 | * - functions return long fixed point integers with the specified number | ||
29 | * of fractional bits unless otherwise specified | ||
30 | * | ||
31 | * Calculate sin and cos of an angle: | ||
32 | * fp_sincos(phase, *cos) | ||
33 | * where phase is a 32 bit unsigned integer with 0 representing 0 | ||
34 | * and 0xFFFFFFFF representing 2*pi, and *cos is the address to | ||
35 | * a long signed integer. Value returned is a long signed integer | ||
36 | * from -0x80000000 to 0x7fffffff, representing -1 to 1 respectively. | ||
37 | * That is, value is a fixed point integer with 31 fractional bits. | ||
38 | * | ||
39 | * Take square root of a fixed point number: | ||
40 | * fp_sqrt(x, fracbits) | ||
41 | * | ||
42 | */ | ||
43 | #ifndef _FIXEDPOINT_H_CODECS | ||
44 | #define _FIXEDPOINT_H_CODECS | ||
45 | |||
46 | long fp_sincos(unsigned long phase, long *cos); | ||
47 | long fp_sqrt(long a, unsigned int fracbits); | ||
48 | |||
49 | #endif | ||
diff --git a/apps/codecs/lib/libcodec.make b/apps/codecs/lib/libcodec.make deleted file mode 100644 index 7aef72f2b1..0000000000 --- a/apps/codecs/lib/libcodec.make +++ /dev/null | |||
@@ -1,37 +0,0 @@ | |||
1 | # __________ __ ___. | ||
2 | # Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
3 | # Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
4 | # Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
5 | # Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
6 | # \/ \/ \/ \/ \/ | ||
7 | # $Id$ | ||
8 | # | ||
9 | |||
10 | CODECLIB := $(CODECDIR)/libcodec.a | ||
11 | CODECLIB_SRC := $(call preprocess, $(APPSDIR)/codecs/lib/SOURCES) | ||
12 | CODECLIB_OBJ := $(call c2obj, $(CODECLIB_SRC)) | ||
13 | OTHER_SRC += $(CODECLIB_SRC) | ||
14 | |||
15 | $(CODECLIB): $(CODECLIB_OBJ) | ||
16 | $(SILENT)$(shell rm -f $@) | ||
17 | $(call PRINTS,AR $(@F))$(AR) rcs $@ $^ >/dev/null | ||
18 | |||
19 | CODECLIBFLAGS = $(filter-out -O%,$(CODECFLAGS)) | ||
20 | |||
21 | ifeq ($(MEMORYSIZE),2) | ||
22 | CODECLIBFLAGS += -Os | ||
23 | else ifeq ($(ARCH),arch_m68k) | ||
24 | CODECLIBFLAGS += -O2 | ||
25 | else | ||
26 | CODECLIBFLAGS += -O1 | ||
27 | endif | ||
28 | |||
29 | # Do not use '-ffunction-sections' when compiling sdl-sim | ||
30 | ifneq ($(findstring sdl-sim, $(APP_TYPE)), sdl-sim) | ||
31 | CODECLIBFLAGS += -ffunction-sections | ||
32 | endif | ||
33 | |||
34 | $(CODECDIR)/lib/%.o: $(ROOTDIR)/apps/codecs/lib/%.c | ||
35 | $(SILENT)mkdir -p $(dir $@) | ||
36 | $(call PRINTS,CC $(subst $(ROOTDIR)/,,$<))$(CC) \ | ||
37 | -I$(dir $<) $(CODECLIBFLAGS) -c $< -o $@ | ||
diff --git a/apps/codecs/lib/mdct.c b/apps/codecs/lib/mdct.c deleted file mode 100644 index 777aec4a55..0000000000 --- a/apps/codecs/lib/mdct.c +++ /dev/null | |||
@@ -1,644 +0,0 @@ | |||
1 | /* | ||
2 | * Fixed Point IMDCT | ||
3 | * Copyright (c) 2002 The FFmpeg Project. | ||
4 | * Copyright (c) 2010 Dave Hooper, Mohamed Tarek, Michael Giacomelli | ||
5 | * | ||
6 | * This library is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * This library is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with this library; if not, write to the Free Software | ||
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
19 | */ | ||
20 | |||
21 | #include "codeclib.h" | ||
22 | #include "mdct.h" | ||
23 | #include "codeclib_misc.h" | ||
24 | #include "mdct_lookup.h" | ||
25 | |||
26 | #ifndef ICODE_ATTR_TREMOR_MDCT | ||
27 | #define ICODE_ATTR_TREMOR_MDCT ICODE_ATTR | ||
28 | #endif | ||
29 | |||
30 | /** | ||
31 | * Compute the middle half of the inverse MDCT of size N = 2^nbits | ||
32 | * thus excluding the parts that can be derived by symmetry | ||
33 | * @param output N/2 samples | ||
34 | * @param input N/2 samples | ||
35 | * | ||
36 | * NOTE - CANNOT CURRENTLY OPERATE IN PLACE (input and output must | ||
37 | * not overlap or intersect at all) | ||
38 | */ | ||
39 | void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input) ICODE_ATTR_TREMOR_MDCT; | ||
40 | void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input) | ||
41 | { | ||
42 | int n8, n4, n2, n, j; | ||
43 | const fixed32 *in1, *in2; | ||
44 | (void)j; | ||
45 | n = 1 << nbits; | ||
46 | |||
47 | n2 = n >> 1; | ||
48 | n4 = n >> 2; | ||
49 | n8 = n >> 3; | ||
50 | |||
51 | FFTComplex *z = (FFTComplex *)output; | ||
52 | |||
53 | /* pre rotation */ | ||
54 | in1 = input; | ||
55 | in2 = input + n2 - 1; | ||
56 | |||
57 | /* revtab comes from the fft; revtab table is sized for N=4096 size fft = 2^12. | ||
58 | The fft is size N/4 so s->nbits-2, so our shift needs to be (12-(nbits-2)) */ | ||
59 | const int revtab_shift = (14- nbits); | ||
60 | |||
61 | /* bitreverse reorder the input and rotate; result here is in OUTPUT ... */ | ||
62 | /* (note that when using the current split radix, the bitreverse ordering is | ||
63 | complex, meaning that this reordering cannot easily be done in-place) */ | ||
64 | /* Using the following pdf, you can see that it is possible to rearrange | ||
65 | the 'classic' pre/post rotate with an alternative one that enables | ||
66 | us to use fewer distinct twiddle factors. | ||
67 | http://www.eurasip.org/Proceedings/Eusipco/Eusipco2006/papers/1568980508.pdf | ||
68 | |||
69 | For prerotation, the factors are just sin,cos(2PI*i/N) | ||
70 | For postrotation, the factors are sin,cos(2PI*(i+1/4)/N) | ||
71 | |||
72 | Therefore, prerotation can immediately reuse the same twiddles as fft | ||
73 | (for postrotation it's still a bit complex, we reuse the fft trig tables | ||
74 | where we can, or a special table for N=2048, or interpolate between | ||
75 | trig tables for N>2048) | ||
76 | */ | ||
77 | const int32_t *T = sincos_lookup0; | ||
78 | const int step = 2<<(12-nbits); | ||
79 | const uint16_t * p_revtab=revtab; | ||
80 | { | ||
81 | const uint16_t * const p_revtab_end = p_revtab + n8; | ||
82 | #ifdef CPU_COLDFIRE | ||
83 | asm volatile ("move.l (%[in2]), %%d0\n\t" | ||
84 | "move.l (%[in1]), %%d1\n\t" | ||
85 | "bra.s 1f\n\t" | ||
86 | "0:\n\t" | ||
87 | "movem.l (%[T]), %%d2-%%d3\n\t" | ||
88 | |||
89 | "addq.l #8, %[in1]\n\t" | ||
90 | "subq.l #8, %[in2]\n\t" | ||
91 | |||
92 | "lea (%[step]*4, %[T]), %[T]\n\t" | ||
93 | |||
94 | "mac.l %%d0, %%d3, (%[T]), %%d4, %%acc0;" | ||
95 | "msac.l %%d1, %%d2, (4, %[T]), %%d5, %%acc0;" | ||
96 | "mac.l %%d1, %%d3, (%[in1]), %%d1, %%acc1;" | ||
97 | "mac.l %%d0, %%d2, (%[in2]), %%d0, %%acc1;" | ||
98 | |||
99 | "addq.l #8, %[in1]\n\t" | ||
100 | "subq.l #8, %[in2]\n\t" | ||
101 | |||
102 | "mac.l %%d0, %%d5, %%acc2;" | ||
103 | "msac.l %%d1, %%d4, (%[p_revtab])+, %%d2, %%acc2;" | ||
104 | "mac.l %%d1, %%d5, (%[in1]), %%d1, %%acc3;" | ||
105 | "mac.l %%d0, %%d4, (%[in2]), %%d0, %%acc3;" | ||
106 | |||
107 | "clr.l %%d3\n\t" | ||
108 | "move.w %%d2, %%d3\n\t" | ||
109 | "eor.l %%d3, %%d2\n\t" | ||
110 | "swap %%d2\n\t" | ||
111 | "lsr.l %[revtab_shift], %%d2\n\t" | ||
112 | |||
113 | "movclr.l %%acc0, %%d4;" | ||
114 | "movclr.l %%acc1, %%d5;" | ||
115 | "lsl.l #3, %%d2\n\t" | ||
116 | "lea (%%d2, %[z]), %%a1\n\t" | ||
117 | "movem.l %%d4-%%d5, (%%a1)\n\t" | ||
118 | |||
119 | "lsr.l %[revtab_shift], %%d3\n\t" | ||
120 | |||
121 | "movclr.l %%acc2, %%d4;" | ||
122 | "movclr.l %%acc3, %%d5;" | ||
123 | "lsl.l #3, %%d3\n\t" | ||
124 | "lea (%%d3, %[z]), %%a1\n\t" | ||
125 | "movem.l %%d4-%%d5, (%%a1)\n\t" | ||
126 | |||
127 | "lea (%[step]*4, %[T]), %[T]\n\t" | ||
128 | |||
129 | "1:\n\t" | ||
130 | "cmp.l %[p_revtab_end], %[p_revtab]\n\t" | ||
131 | "bcs.s 0b\n\t" | ||
132 | : [in1] "+a" (in1), [in2] "+a" (in2), [T] "+a" (T), | ||
133 | [p_revtab] "+a" (p_revtab) | ||
134 | : [z] "a" (z), [step] "d" (step), [revtab_shift] "d" (revtab_shift), | ||
135 | [p_revtab_end] "r" (p_revtab_end) | ||
136 | : "d0", "d1", "d2", "d3", "d4", "d5", "a1", "cc", "memory"); | ||
137 | #else | ||
138 | while(LIKELY(p_revtab < p_revtab_end)) | ||
139 | { | ||
140 | j = (*p_revtab)>>revtab_shift; | ||
141 | XNPROD31(*in2, *in1, T[1], T[0], &z[j].re, &z[j].im ); | ||
142 | T += step; | ||
143 | in1 += 2; | ||
144 | in2 -= 2; | ||
145 | p_revtab++; | ||
146 | j = (*p_revtab)>>revtab_shift; | ||
147 | XNPROD31(*in2, *in1, T[1], T[0], &z[j].re, &z[j].im ); | ||
148 | T += step; | ||
149 | in1 += 2; | ||
150 | in2 -= 2; | ||
151 | p_revtab++; | ||
152 | } | ||
153 | #endif | ||
154 | } | ||
155 | { | ||
156 | const uint16_t * const p_revtab_end = p_revtab + n8; | ||
157 | #ifdef CPU_COLDFIRE | ||
158 | asm volatile ("move.l (%[in2]), %%d0\n\t" | ||
159 | "move.l (%[in1]), %%d1\n\t" | ||
160 | "bra.s 1f\n\t" | ||
161 | "0:\n\t" | ||
162 | "movem.l (%[T]), %%d2-%%d3\n\t" | ||
163 | |||
164 | "addq.l #8, %[in1]\n\t" | ||
165 | "subq.l #8, %[in2]\n\t" | ||
166 | |||
167 | "lea (%[step]*4, %[T]), %[T]\n\t" | ||
168 | |||
169 | "mac.l %%d0, %%d2, (%[T]), %%d4, %%acc0;" | ||
170 | "msac.l %%d1, %%d3, (4, %[T]), %%d5, %%acc0;" | ||
171 | "mac.l %%d1, %%d2, (%[in1]), %%d1, %%acc1;" | ||
172 | "mac.l %%d0, %%d3, (%[in2]), %%d0, %%acc1;" | ||
173 | |||
174 | "addq.l #8, %[in1]\n\t" | ||
175 | "subq.l #8, %[in2]\n\t" | ||
176 | |||
177 | "mac.l %%d0, %%d4, %%acc2;" | ||
178 | "msac.l %%d1, %%d5, (%[p_revtab])+, %%d2, %%acc2;" | ||
179 | "mac.l %%d1, %%d4, (%[in1]), %%d1, %%acc3;" | ||
180 | "mac.l %%d0, %%d5, (%[in2]), %%d0, %%acc3;" | ||
181 | |||
182 | "clr.l %%d3\n\t" | ||
183 | "move.w %%d2, %%d3\n\t" | ||
184 | "eor.l %%d3, %%d2\n\t" | ||
185 | "swap %%d2\n\t" | ||
186 | "lsr.l %[revtab_shift], %%d2\n\t" | ||
187 | |||
188 | "movclr.l %%acc0, %%d4;" | ||
189 | "movclr.l %%acc1, %%d5;" | ||
190 | "lsl.l #3, %%d2\n\t" | ||
191 | "lea (%%d2, %[z]), %%a1\n\t" | ||
192 | "movem.l %%d4-%%d5, (%%a1)\n\t" | ||
193 | |||
194 | "lsr.l %[revtab_shift], %%d3\n\t" | ||
195 | |||
196 | "movclr.l %%acc2, %%d4;" | ||
197 | "movclr.l %%acc3, %%d5;" | ||
198 | "lsl.l #3, %%d3\n\t" | ||
199 | "lea (%%d3, %[z]), %%a1\n\t" | ||
200 | "movem.l %%d4-%%d5, (%%a1)\n\t" | ||
201 | |||
202 | "lea (%[step]*4, %[T]), %[T]\n\t" | ||
203 | |||
204 | "1:\n\t" | ||
205 | "cmp.l %[p_revtab_end], %[p_revtab]\n\t" | ||
206 | "bcs.s 0b\n\t" | ||
207 | : [in1] "+a" (in1), [in2] "+a" (in2), [T] "+a" (T), | ||
208 | [p_revtab] "+a" (p_revtab) | ||
209 | : [z] "a" (z), [step] "d" (-step), [revtab_shift] "d" (revtab_shift), | ||
210 | [p_revtab_end] "r" (p_revtab_end) | ||
211 | : "d0", "d1", "d2", "d3", "d4", "d5", "a1", "cc", "memory"); | ||
212 | #else | ||
213 | while(LIKELY(p_revtab < p_revtab_end)) | ||
214 | { | ||
215 | j = (*p_revtab)>>revtab_shift; | ||
216 | XNPROD31(*in2, *in1, T[0], T[1], &z[j].re, &z[j].im); | ||
217 | T -= step; | ||
218 | in1 += 2; | ||
219 | in2 -= 2; | ||
220 | p_revtab++; | ||
221 | j = (*p_revtab)>>revtab_shift; | ||
222 | XNPROD31(*in2, *in1, T[0], T[1], &z[j].re, &z[j].im); | ||
223 | T -= step; | ||
224 | in1 += 2; | ||
225 | in2 -= 2; | ||
226 | p_revtab++; | ||
227 | } | ||
228 | #endif | ||
229 | } | ||
230 | |||
231 | |||
232 | /* ... and so fft runs in OUTPUT buffer */ | ||
233 | ff_fft_calc_c(nbits-2, z); | ||
234 | |||
235 | /* post rotation + reordering. now keeps the result within the OUTPUT buffer */ | ||
236 | switch( nbits ) | ||
237 | { | ||
238 | default: | ||
239 | { | ||
240 | fixed32 * z1 = (fixed32 *)(&z[0]); | ||
241 | int magic_step = step>>2; | ||
242 | int newstep; | ||
243 | if(n<=1024) | ||
244 | { | ||
245 | T = sincos_lookup0 + magic_step; | ||
246 | newstep = step>>1; | ||
247 | } | ||
248 | else | ||
249 | { | ||
250 | T = sincos_lookup1; | ||
251 | newstep = 2; | ||
252 | } | ||
253 | |||
254 | #ifdef CPU_COLDFIRE | ||
255 | fixed32 * z2 = (fixed32 *)(&z[n4]); | ||
256 | int c = n4; | ||
257 | if (newstep == 2) | ||
258 | { | ||
259 | asm volatile ("movem.l (%[z1]), %%d0-%%d1\n\t" | ||
260 | "addq.l #8, %[z1]\n\t" | ||
261 | "movem.l (%[T]), %%d2-%%d3\n\t" | ||
262 | "addq.l #8, %[T]\n\t" | ||
263 | "bra.s 1f\n\t" | ||
264 | "0:\n\t" | ||
265 | "msac.l %%d1, %%d2, (%[T])+, %%a3, %%acc0\n\t" | ||
266 | "mac.l %%d0, %%d3, (%[T])+, %%a4, %%acc0\n\t" | ||
267 | |||
268 | "msac.l %%d1, %%d3, -(%[z2]), %%d1, %%acc1\n\t" | ||
269 | "msac.l %%d0, %%d2, -(%[z2]), %%d0, %%acc1\n\t" | ||
270 | |||
271 | "msac.l %%d1, %%a4, (%[T])+, %%d2, %%acc2\n\t" | ||
272 | "mac.l %%d0, %%a3, (%[T])+, %%d3, %%acc2\n\t" | ||
273 | "msac.l %%d0, %%a4, (%[z1])+, %%d0, %%acc3\n\t" | ||
274 | "msac.l %%d1, %%a3, (%[z1])+, %%d1, %%acc3\n\t" | ||
275 | |||
276 | "movclr.l %%acc0, %%a3\n\t" | ||
277 | "movclr.l %%acc3, %%a4\n\t" | ||
278 | "movem.l %%a3-%%a4, (-16, %[z1])\n\t" | ||
279 | |||
280 | "movclr.l %%acc1, %%a4\n\t" | ||
281 | "movclr.l %%acc2, %%a3\n\t" | ||
282 | "movem.l %%a3-%%a4, (%[z2])\n\t" | ||
283 | |||
284 | "subq.l #2, %[n]\n\t" | ||
285 | "1:\n\t" | ||
286 | "bhi.s 0b\n\t" | ||
287 | : [z1] "+a" (z1), [z2] "+a" (z2), [T] "+a" (T), [n] "+d" (c) | ||
288 | : | ||
289 | : "d0", "d1", "d2", "d3", "a3", "a4", "cc", "memory"); | ||
290 | } | ||
291 | else | ||
292 | { | ||
293 | asm volatile ("movem.l (%[z1]), %%d0-%%d1\n\t" | ||
294 | "addq.l #8, %[z1]\n\t" | ||
295 | "movem.l (%[T]), %%d2-%%d3\n\t" | ||
296 | "lea (%[newstep]*4, %[T]), %[T]\n\t" | ||
297 | "bra.s 1f\n\t" | ||
298 | "0:\n\t" | ||
299 | "msac.l %%d1, %%d2, (%[T]), %%a3, %%acc0\n\t" | ||
300 | "mac.l %%d0, %%d3, (4, %[T]), %%a4, %%acc0\n\t" | ||
301 | "msac.l %%d1, %%d3, -(%[z2]), %%d1, %%acc1\n\t" | ||
302 | "msac.l %%d0, %%d2, -(%[z2]), %%d0, %%acc1\n\t" | ||
303 | |||
304 | "lea (%[newstep]*4, %[T]), %[T]\n\t" | ||
305 | "msac.l %%d1, %%a4, (%[T]), %%d2, %%acc2\n\t" | ||
306 | "mac.l %%d0, %%a3, (4, %[T]), %%d3, %%acc2\n\t" | ||
307 | "msac.l %%d0, %%a4, (%[z1])+, %%d0, %%acc3\n\t" | ||
308 | "msac.l %%d1, %%a3, (%[z1])+, %%d1, %%acc3\n\t" | ||
309 | |||
310 | "lea (%[newstep]*4, %[T]), %[T]\n\t" | ||
311 | |||
312 | "movclr.l %%acc0, %%a3\n\t" | ||
313 | "movclr.l %%acc3, %%a4\n\t" | ||
314 | "movem.l %%a3-%%a4, (-16, %[z1])\n\t" | ||
315 | |||
316 | "movclr.l %%acc1, %%a4\n\t" | ||
317 | "movclr.l %%acc2, %%a3\n\t" | ||
318 | "movem.l %%a3-%%a4, (%[z2])\n\t" | ||
319 | |||
320 | "subq.l #2, %[n]\n\t" | ||
321 | "1:\n\t" | ||
322 | "bhi.s 0b\n\t" | ||
323 | : [z1] "+a" (z1), [z2] "+a" (z2), [T] "+a" (T), [n] "+d" (c) | ||
324 | : [newstep] "d" (newstep) | ||
325 | : "d0", "d1", "d2", "d3", "a3", "a4", "cc", "memory"); | ||
326 | } | ||
327 | #else | ||
328 | fixed32 * z2 = (fixed32 *)(&z[n4-1]); | ||
329 | while(z1<z2) | ||
330 | { | ||
331 | fixed32 r0,i0,r1,i1; | ||
332 | XNPROD31_R(z1[1], z1[0], T[0], T[1], r0, i1 ); T+=newstep; | ||
333 | XNPROD31_R(z2[1], z2[0], T[1], T[0], r1, i0 ); T+=newstep; | ||
334 | z1[0] = -r0; | ||
335 | z1[1] = -i0; | ||
336 | z2[0] = -r1; | ||
337 | z2[1] = -i1; | ||
338 | z1+=2; | ||
339 | z2-=2; | ||
340 | } | ||
341 | #endif | ||
342 | break; | ||
343 | } | ||
344 | |||
345 | case 12: /* n=4096 */ | ||
346 | { | ||
347 | /* linear interpolation (50:50) between sincos_lookup0 and sincos_lookup1 */ | ||
348 | const int32_t * V = sincos_lookup1; | ||
349 | T = sincos_lookup0; | ||
350 | int32_t t0,t1,v0,v1; | ||
351 | fixed32 * z1 = (fixed32 *)(&z[0]); | ||
352 | fixed32 * z2 = (fixed32 *)(&z[n4-1]); | ||
353 | |||
354 | t0 = T[0]>>1; t1=T[1]>>1; | ||
355 | |||
356 | while(z1<z2) | ||
357 | { | ||
358 | fixed32 r0,i0,r1,i1; | ||
359 | t0 += (v0 = (V[0]>>1)); | ||
360 | t1 += (v1 = (V[1]>>1)); | ||
361 | XNPROD31_R(z1[1], z1[0], t0, t1, r0, i1 ); | ||
362 | T+=2; | ||
363 | v0 += (t0 = (T[0]>>1)); | ||
364 | v1 += (t1 = (T[1]>>1)); | ||
365 | XNPROD31_R(z2[1], z2[0], v1, v0, r1, i0 ); | ||
366 | z1[0] = -r0; | ||
367 | z1[1] = -i0; | ||
368 | z2[0] = -r1; | ||
369 | z2[1] = -i1; | ||
370 | z1+=2; | ||
371 | z2-=2; | ||
372 | V+=2; | ||
373 | } | ||
374 | |||
375 | break; | ||
376 | } | ||
377 | |||
378 | case 13: /* n = 8192 */ | ||
379 | { | ||
380 | /* weight linear interpolation between sincos_lookup0 and sincos_lookup1 | ||
381 | specifically: 25:75 for first twiddle and 75:25 for second twiddle */ | ||
382 | const int32_t * V = sincos_lookup1; | ||
383 | T = sincos_lookup0; | ||
384 | int32_t t0,t1,v0,v1,q0,q1; | ||
385 | fixed32 * z1 = (fixed32 *)(&z[0]); | ||
386 | fixed32 * z2 = (fixed32 *)(&z[n4-1]); | ||
387 | |||
388 | t0 = T[0]; t1=T[1]; | ||
389 | |||
390 | while(z1<z2) | ||
391 | { | ||
392 | fixed32 r0,i0,r1,i1; | ||
393 | v0 = V[0]; v1 = V[1]; | ||
394 | t0 += (q0 = (v0-t0)>>1); | ||
395 | t1 += (q1 = (v1-t1)>>1); | ||
396 | XNPROD31_R(z1[1], z1[0], t0, t1, r0, i1 ); | ||
397 | t0 = v0-q0; | ||
398 | t1 = v1-q1; | ||
399 | XNPROD31_R(z2[1], z2[0], t1, t0, r1, i0 ); | ||
400 | z1[0] = -r0; | ||
401 | z1[1] = -i0; | ||
402 | z2[0] = -r1; | ||
403 | z2[1] = -i1; | ||
404 | z1+=2; | ||
405 | z2-=2; | ||
406 | T+=2; | ||
407 | |||
408 | t0 = T[0]; t1 = T[1]; | ||
409 | v0 += (q0 = (t0-v0)>>1); | ||
410 | v1 += (q1 = (t1-v1)>>1); | ||
411 | XNPROD31_R(z1[1], z1[0], v0, v1, r0, i1 ); | ||
412 | v0 = t0-q0; | ||
413 | v1 = t1-q1; | ||
414 | XNPROD31_R(z2[1], z2[0], v1, v0, r1, i0 ); | ||
415 | z1[0] = -r0; | ||
416 | z1[1] = -i0; | ||
417 | z2[0] = -r1; | ||
418 | z2[1] = -i1; | ||
419 | z1+=2; | ||
420 | z2-=2; | ||
421 | V+=2; | ||
422 | } | ||
423 | |||
424 | break; | ||
425 | } | ||
426 | } | ||
427 | } | ||
428 | |||
429 | /** | ||
430 | * Compute inverse MDCT of size N = 2^nbits | ||
431 | * @param output N samples | ||
432 | * @param input N/2 samples | ||
433 | * "In-place" processing can be achieved provided that: | ||
434 | * [0 .. N/2-1 | N/2 .. N-1 ] | ||
435 | * <----input----> | ||
436 | * <-----------output-----------> | ||
437 | * | ||
438 | * The result of ff_imdct_half is to put the 'half' imdct here | ||
439 | * | ||
440 | * N/2 N-1 | ||
441 | * <--half imdct--> | ||
442 | * | ||
443 | * We want it here for the full imdct: | ||
444 | * N/4 3N/4-1 | ||
445 | * <--------------> | ||
446 | * | ||
447 | * In addition we need to apply two symmetries to get the full imdct: | ||
448 | * | ||
449 | * <AAAAAA> <DDDDDD> | ||
450 | * <BBBBBB><CCCCCC> | ||
451 | * | ||
452 | * D is a reflection of C | ||
453 | * A is a reflection of B (but with sign flipped) | ||
454 | * | ||
455 | * We process the symmetries at the same time as we 'move' the half imdct | ||
456 | * from [N/2,N-1] to [N/4,3N/4-1] | ||
457 | * | ||
458 | * TODO: find a way to make ff_imdct_half put the result in [N/4..3N/4-1] | ||
459 | * This would require being able to use revtab 'inplace' (since the input | ||
460 | * and output of imdct_half would then overlap somewhat) | ||
461 | */ | ||
462 | void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input) ICODE_ATTR_TREMOR_MDCT; | ||
463 | #ifndef CPU_ARM | ||
464 | void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input) | ||
465 | { | ||
466 | const int n = (1<<nbits); | ||
467 | const int n2 = (n>>1); | ||
468 | const int n4 = (n>>2); | ||
469 | |||
470 | /* tell imdct_half to put the output in [N/2..3N/4-1] i.e. output+n2 */ | ||
471 | ff_imdct_half(nbits,output+n2,input); | ||
472 | |||
473 | fixed32 * in_r, * in_r2, * out_r, * out_r2; | ||
474 | |||
475 | /* Copy BBBB to AAAA, reflected and sign-flipped. | ||
476 | Also copy BBBB to its correct destination (from [N/2..3N/4-1] to [N/4..N/2-1]) */ | ||
477 | out_r = output; | ||
478 | out_r2 = output+n2-8; | ||
479 | in_r = output+n2+n4-8; | ||
480 | while(out_r<out_r2) | ||
481 | { | ||
482 | #if defined CPU_COLDFIRE | ||
483 | asm volatile( | ||
484 | "movem.l (%[in_r]), %%d0-%%d7\n\t" | ||
485 | "movem.l %%d0-%%d7, (%[out_r2])\n\t" | ||
486 | "neg.l %%d7\n\t" | ||
487 | "move.l %%d7, (%[out_r])+\n\t" | ||
488 | "neg.l %%d6\n\t" | ||
489 | "move.l %%d6, (%[out_r])+\n\t" | ||
490 | "neg.l %%d5\n\t" | ||
491 | "move.l %%d5, (%[out_r])+\n\t" | ||
492 | "neg.l %%d4\n\t" | ||
493 | "move.l %%d4, (%[out_r])+\n\t" | ||
494 | "neg.l %%d3\n\t" | ||
495 | "move.l %%d3, (%[out_r])+\n\t" | ||
496 | "neg.l %%d2\n\t" | ||
497 | "move.l %%d2, (%[out_r])+\n\t" | ||
498 | "lea.l (-8*4, %[in_r]), %[in_r]\n\t" | ||
499 | "neg.l %%d1\n\t" | ||
500 | "move.l %%d1, (%[out_r])+\n\t" | ||
501 | "lea.l (-8*4, %[out_r2]), %[out_r2]\n\t" | ||
502 | "neg.l %%d0\n\t" | ||
503 | "move.l %%d0, (%[out_r])+\n\t" | ||
504 | : [in_r] "+a" (in_r), [out_r] "+a" (out_r), [out_r2] "+a" (out_r2) | ||
505 | : | ||
506 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory" ); | ||
507 | #else | ||
508 | out_r[0] = -(out_r2[7] = in_r[7]); | ||
509 | out_r[1] = -(out_r2[6] = in_r[6]); | ||
510 | out_r[2] = -(out_r2[5] = in_r[5]); | ||
511 | out_r[3] = -(out_r2[4] = in_r[4]); | ||
512 | out_r[4] = -(out_r2[3] = in_r[3]); | ||
513 | out_r[5] = -(out_r2[2] = in_r[2]); | ||
514 | out_r[6] = -(out_r2[1] = in_r[1]); | ||
515 | out_r[7] = -(out_r2[0] = in_r[0]); | ||
516 | in_r -= 8; | ||
517 | out_r += 8; | ||
518 | out_r2 -= 8; | ||
519 | #endif | ||
520 | } | ||
521 | in_r = output + n2+n4; | ||
522 | in_r2 = output + n-4; | ||
523 | out_r = output + n2; | ||
524 | out_r2 = output + n2 + n4 - 4; | ||
525 | while(in_r<in_r2) | ||
526 | { | ||
527 | #if defined CPU_COLDFIRE | ||
528 | asm volatile( | ||
529 | "movem.l (%[in_r]), %%d0-%%d3\n\t" | ||
530 | "movem.l %%d0-%%d3, (%[out_r])\n\t" | ||
531 | "movem.l (%[in_r2]), %%d4-%%d7\n\t" | ||
532 | "movem.l %%d4-%%d7, (%[out_r2])\n\t" | ||
533 | "move.l %%d0, %%a3\n\t" | ||
534 | "move.l %%d3, %%d0\n\t" | ||
535 | "move.l %%d1, %%d3\n\t" | ||
536 | "movem.l %%d0/%%d2-%%d3/%%a3, (%[in_r2])\n\t" | ||
537 | "move.l %%d7, %%d1\n\t" | ||
538 | "move.l %%d6, %%d2\n\t" | ||
539 | "move.l %%d5, %%d3\n\t" | ||
540 | "movem.l %%d1-%%d4, (%[in_r])\n\t" | ||
541 | "lea.l (4*4, %[in_r]), %[in_r]\n\t" | ||
542 | "lea.l (-4*4, %[in_r2]), %[in_r2]\n\t" | ||
543 | "lea.l (4*4, %[out_r]), %[out_r]\n\t" | ||
544 | "lea.l (-4*4, %[out_r2]), %[out_r2]\n\t" | ||
545 | : [in_r] "+a" (in_r), [in_r2] "+a" (in_r2), | ||
546 | [out_r] "+a" (out_r), [out_r2] "+a" (out_r2) | ||
547 | : | ||
548 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a3", "memory", "cc" ); | ||
549 | #else | ||
550 | register fixed32 t0,t1,t2,t3; | ||
551 | register fixed32 s0,s1,s2,s3; | ||
552 | |||
553 | /* Copy and reflect CCCC to DDDD. Because CCCC is already where | ||
554 | we actually want to put DDDD this is a bit complicated. | ||
555 | * So simultaneously do the following things: | ||
556 | * 1. copy range from [n2+n4 .. n-1] to range[n2 .. n2+n4-1] | ||
557 | * 2. reflect range from [n2+n4 .. n-1] inplace | ||
558 | * | ||
559 | * [ | ] | ||
560 | * ^a -> <- ^b ^c -> <- ^d | ||
561 | * | ||
562 | * #1: copy from ^c to ^a | ||
563 | * #2: copy from ^d to ^b | ||
564 | * #3: swap ^c and ^d in place | ||
565 | */ | ||
566 | /* #1 pt1 : load 4 words from ^c. */ | ||
567 | t0=in_r[0]; t1=in_r[1]; t2=in_r[2]; t3=in_r[3]; | ||
568 | /* #1 pt2 : write to ^a */ | ||
569 | out_r[0]=t0;out_r[1]=t1;out_r[2]=t2;out_r[3]=t3; | ||
570 | /* #2 pt1 : load 4 words from ^d */ | ||
571 | s0=in_r2[0];s1=in_r2[1];s2=in_r2[2];s3=in_r2[3]; | ||
572 | /* #2 pt2 : write to ^b */ | ||
573 | out_r2[0]=s0;out_r2[1]=s1;out_r2[2]=s2;out_r2[3]=s3; | ||
574 | /* #3 pt1 : write words from #2 to ^c */ | ||
575 | in_r[0]=s3;in_r[1]=s2;in_r[2]=s1;in_r[3]=s0; | ||
576 | /* #3 pt2 : write words from #1 to ^d */ | ||
577 | in_r2[0]=t3;in_r2[1]=t2;in_r2[2]=t1;in_r2[3]=t0; | ||
578 | |||
579 | in_r += 4; | ||
580 | in_r2 -= 4; | ||
581 | out_r += 4; | ||
582 | out_r2 -= 4; | ||
583 | #endif | ||
584 | } | ||
585 | } | ||
586 | #else | ||
587 | /* Follows the same structure as the canonical version above */ | ||
588 | void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input) | ||
589 | { | ||
590 | const int n = (1<<nbits); | ||
591 | const int n2 = (n>>1); | ||
592 | const int n4 = (n>>2); | ||
593 | |||
594 | ff_imdct_half(nbits,output+n2,input); | ||
595 | |||
596 | fixed32 * in_r, * in_r2, * out_r, * out_r2; | ||
597 | |||
598 | out_r = output; | ||
599 | out_r2 = output+n2; | ||
600 | in_r = output+n2+n4; | ||
601 | while(out_r<out_r2) | ||
602 | { | ||
603 | asm volatile( | ||
604 | "ldmdb %[in_r]!, {r0-r7}\n\t" | ||
605 | "stmdb %[out_r2]!, {r0-r7}\n\t" | ||
606 | "rsb r8,r0,#0\n\t" | ||
607 | "rsb r0,r7,#0\n\t" | ||
608 | "rsb r7,r1,#0\n\t" | ||
609 | "rsb r1,r6,#0\n\t" | ||
610 | "rsb r6,r2,#0\n\t" | ||
611 | "rsb r2,r5,#0\n\t" | ||
612 | "rsb r5,r3,#0\n\t" | ||
613 | "rsb r3,r4,#0\n\t" | ||
614 | "stmia %[out_r]!, {r0-r3,r5-r8}\n\t" | ||
615 | : [in_r] "+r" (in_r), [out_r] "+r" (out_r), [out_r2] "+r" (out_r2) | ||
616 | : | ||
617 | : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "memory" ); | ||
618 | } | ||
619 | in_r = output + n2+n4; | ||
620 | in_r2 = output + n; | ||
621 | out_r = output + n2; | ||
622 | out_r2 = output + n2 + n4; | ||
623 | while(in_r<in_r2) | ||
624 | { | ||
625 | asm volatile( | ||
626 | "ldmia %[in_r], {r0-r3}\n\t" | ||
627 | "stmia %[out_r]!, {r0-r3}\n\t" | ||
628 | "ldmdb %[in_r2], {r5-r8}\n\t" | ||
629 | "stmdb %[out_r2]!, {r5-r8}\n\t" | ||
630 | "mov r4,r0\n\t" | ||
631 | "mov r0,r3\n\t" | ||
632 | "mov r3,r1\n\t" | ||
633 | "stmdb %[in_r2]!, {r0,r2,r3,r4}\n\t" | ||
634 | "mov r4,r8\n\t" | ||
635 | "mov r8,r5\n\t" | ||
636 | "mov r5,r7\n\t" | ||
637 | "stmia %[in_r]!, {r4,r5,r6,r8}\n\t" | ||
638 | : | ||
639 | [in_r] "+r" (in_r), [in_r2] "+r" (in_r2), [out_r] "+r" (out_r), [out_r2] "+r" (out_r2) | ||
640 | : | ||
641 | : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "memory" ); | ||
642 | } | ||
643 | } | ||
644 | #endif | ||
diff --git a/apps/codecs/lib/mdct.h b/apps/codecs/lib/mdct.h deleted file mode 100644 index 48d1c25a55..0000000000 --- a/apps/codecs/lib/mdct.h +++ /dev/null | |||
@@ -1,139 +0,0 @@ | |||
1 | /* | ||
2 | * WMA compatible decoder | ||
3 | * Copyright (c) 2002 The FFmpeg Project. | ||
4 | * | ||
5 | * This library is free software; you can redistribute it and/or | ||
6 | * modify it under the terms of the GNU Lesser General Public | ||
7 | * License as published by the Free Software Foundation; either | ||
8 | * version 2 of the License, or (at your option) any later version. | ||
9 | * | ||
10 | * This library is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | * Lesser General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU Lesser General Public | ||
16 | * License along with this library; if not, write to the Free Software | ||
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
18 | */ | ||
19 | |||
20 | #ifndef CODECLIB_MDCT_H_INCLUDED | ||
21 | #define CODECLIB_MDCT_H_INCLUDED | ||
22 | |||
23 | //#include "types.h" | ||
24 | #include "fft.h" | ||
25 | |||
26 | void ff_imdct_calc(unsigned int nbits, fixed32 *output, const fixed32 *input); | ||
27 | void ff_imdct_half(unsigned int nbits, fixed32 *output, const fixed32 *input); | ||
28 | |||
29 | #ifdef CPU_ARM | ||
30 | |||
31 | /*Sign-15.16 format */ | ||
32 | #define fixmul32b(x, y) \ | ||
33 | ({ int32_t __hi; \ | ||
34 | uint32_t __lo; \ | ||
35 | int32_t __result; \ | ||
36 | asm ("smull %0, %1, %3, %4\n\t" \ | ||
37 | "mov %2, %1, lsl #1" \ | ||
38 | : "=&r" (__lo), "=&r" (__hi), "=r" (__result) \ | ||
39 | : "%r" (x), "r" (y) \ | ||
40 | : "cc" ); \ | ||
41 | __result; \ | ||
42 | }) | ||
43 | |||
44 | #elif defined(CPU_COLDFIRE) | ||
45 | |||
46 | static inline int32_t fixmul32b(int32_t x, int32_t y) | ||
47 | { | ||
48 | asm ( | ||
49 | "mac.l %[x], %[y], %%acc0 \n" /* multiply */ | ||
50 | "movclr.l %%acc0, %[x] \n" /* get higher half */ | ||
51 | : [x] "+d" (x) | ||
52 | : [y] "d" (y) | ||
53 | ); | ||
54 | return x; | ||
55 | } | ||
56 | |||
57 | #else | ||
58 | |||
59 | static inline fixed32 fixmul32b(fixed32 x, fixed32 y) | ||
60 | { | ||
61 | fixed64 temp; | ||
62 | |||
63 | temp = x; | ||
64 | temp *= y; | ||
65 | |||
66 | temp >>= 31; //16+31-16 = 31 bits | ||
67 | |||
68 | return (fixed32)temp; | ||
69 | } | ||
70 | #endif | ||
71 | |||
72 | |||
73 | #ifdef CPU_ARM | ||
74 | static inline | ||
75 | void CMUL(fixed32 *x, fixed32 *y, | ||
76 | fixed32 a, fixed32 b, | ||
77 | fixed32 t, fixed32 v) | ||
78 | { | ||
79 | /* This version loses one bit of precision. Could be solved at the cost | ||
80 | * of 2 extra cycles if it becomes an issue. */ | ||
81 | int x1, y1, l; | ||
82 | asm( | ||
83 | "smull %[l], %[y1], %[b], %[t] \n" | ||
84 | "smlal %[l], %[y1], %[a], %[v] \n" | ||
85 | "rsb %[b], %[b], #0 \n" | ||
86 | "smull %[l], %[x1], %[a], %[t] \n" | ||
87 | "smlal %[l], %[x1], %[b], %[v] \n" | ||
88 | : [l] "=&r" (l), [x1]"=&r" (x1), [y1]"=&r" (y1), [b] "+r" (b) | ||
89 | : [a] "r" (a), [t] "r" (t), [v] "r" (v) | ||
90 | : "cc" | ||
91 | ); | ||
92 | *x = x1 << 1; | ||
93 | *y = y1 << 1; | ||
94 | } | ||
95 | #elif defined CPU_COLDFIRE | ||
96 | static inline | ||
97 | void CMUL(fixed32 *x, fixed32 *y, | ||
98 | fixed32 a, fixed32 b, | ||
99 | fixed32 t, fixed32 v) | ||
100 | { | ||
101 | asm volatile ("mac.l %[a], %[t], %%acc0;" | ||
102 | "msac.l %[b], %[v], %%acc0;" | ||
103 | "mac.l %[b], %[t], %%acc1;" | ||
104 | "mac.l %[a], %[v], %%acc1;" | ||
105 | "movclr.l %%acc0, %[a];" | ||
106 | "move.l %[a], (%[x]);" | ||
107 | "movclr.l %%acc1, %[a];" | ||
108 | "move.l %[a], (%[y]);" | ||
109 | : [a] "+&r" (a) | ||
110 | : [x] "a" (x), [y] "a" (y), | ||
111 | [b] "r" (b), [t] "r" (t), [v] "r" (v) | ||
112 | : "cc", "memory"); | ||
113 | } | ||
114 | #else | ||
115 | static inline | ||
116 | void CMUL(fixed32 *pre, | ||
117 | fixed32 *pim, | ||
118 | fixed32 are, | ||
119 | fixed32 aim, | ||
120 | fixed32 bre, | ||
121 | fixed32 bim) | ||
122 | { | ||
123 | //int64_t x,y; | ||
124 | fixed32 _aref = are; | ||
125 | fixed32 _aimf = aim; | ||
126 | fixed32 _bref = bre; | ||
127 | fixed32 _bimf = bim; | ||
128 | fixed32 _r1 = fixmul32b(_bref, _aref); | ||
129 | fixed32 _r2 = fixmul32b(_bimf, _aimf); | ||
130 | fixed32 _r3 = fixmul32b(_bref, _aimf); | ||
131 | fixed32 _r4 = fixmul32b(_bimf, _aref); | ||
132 | *pre = _r1 - _r2; | ||
133 | *pim = _r3 + _r4; | ||
134 | |||
135 | } | ||
136 | #endif | ||
137 | |||
138 | |||
139 | #endif // CODECLIB_MDCT_H_INCLUDED | ||
diff --git a/apps/codecs/lib/mdct_lookup.c b/apps/codecs/lib/mdct_lookup.c deleted file mode 100644 index a8ca748206..0000000000 --- a/apps/codecs/lib/mdct_lookup.c +++ /dev/null | |||
@@ -1,872 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2009 Michael Giacomelli | ||
11 | * | ||
12 | * | ||
13 | * | ||
14 | * This program is free software; you can redistribute it and/or | ||
15 | * modify it under the terms of the GNU General Public License | ||
16 | * as published by the Free Software Foundation; either version 2 | ||
17 | * of the License, or (at your option) any later version. | ||
18 | * | ||
19 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
20 | * KIND, either express or implied. | ||
21 | * | ||
22 | ****************************************************************************/ | ||
23 | |||
24 | #ifdef ROCKBOX | ||
25 | #include <codecs/lib/codeclib.h> | ||
26 | #else | ||
27 | #include <stdlib.h> | ||
28 | #include <stdint.h> | ||
29 | #endif /* ROCKBOX */ | ||
30 | |||
31 | /* {sin(2*i*PI/4096, cos(2*i*PI/4096)}, with i = 0 to 512 */ | ||
32 | const int32_t sincos_lookup0[1026] ICONST_ATTR = { | ||
33 | 0x00000000, 0x7fffffff, 0x003243f5, 0x7ffff621, | ||
34 | 0x006487e3, 0x7fffd886, 0x0096cbc1, 0x7fffa72c, | ||
35 | 0x00c90f88, 0x7fff6216, 0x00fb5330, 0x7fff0943, | ||
36 | 0x012d96b1, 0x7ffe9cb2, 0x015fda03, 0x7ffe1c65, | ||
37 | 0x01921d20, 0x7ffd885a, 0x01c45ffe, 0x7ffce093, | ||
38 | 0x01f6a297, 0x7ffc250f, 0x0228e4e2, 0x7ffb55ce, | ||
39 | 0x025b26d7, 0x7ffa72d1, 0x028d6870, 0x7ff97c18, | ||
40 | 0x02bfa9a4, 0x7ff871a2, 0x02f1ea6c, 0x7ff75370, | ||
41 | 0x03242abf, 0x7ff62182, 0x03566a96, 0x7ff4dbd9, | ||
42 | 0x0388a9ea, 0x7ff38274, 0x03bae8b2, 0x7ff21553, | ||
43 | 0x03ed26e6, 0x7ff09478, 0x041f6480, 0x7feeffe1, | ||
44 | 0x0451a177, 0x7fed5791, 0x0483ddc3, 0x7feb9b85, | ||
45 | 0x04b6195d, 0x7fe9cbc0, 0x04e8543e, 0x7fe7e841, | ||
46 | 0x051a8e5c, 0x7fe5f108, 0x054cc7b1, 0x7fe3e616, | ||
47 | 0x057f0035, 0x7fe1c76b, 0x05b137df, 0x7fdf9508, | ||
48 | 0x05e36ea9, 0x7fdd4eec, 0x0615a48b, 0x7fdaf519, | ||
49 | 0x0647d97c, 0x7fd8878e, 0x067a0d76, 0x7fd6064c, | ||
50 | 0x06ac406f, 0x7fd37153, 0x06de7262, 0x7fd0c8a3, | ||
51 | 0x0710a345, 0x7fce0c3e, 0x0742d311, 0x7fcb3c23, | ||
52 | 0x077501be, 0x7fc85854, 0x07a72f45, 0x7fc560cf, | ||
53 | 0x07d95b9e, 0x7fc25596, 0x080b86c2, 0x7fbf36aa, | ||
54 | 0x083db0a7, 0x7fbc040a, 0x086fd947, 0x7fb8bdb8, | ||
55 | 0x08a2009a, 0x7fb563b3, 0x08d42699, 0x7fb1f5fc, | ||
56 | 0x09064b3a, 0x7fae7495, 0x09386e78, 0x7faadf7c, | ||
57 | 0x096a9049, 0x7fa736b4, 0x099cb0a7, 0x7fa37a3c, | ||
58 | 0x09cecf89, 0x7f9faa15, 0x0a00ece8, 0x7f9bc640, | ||
59 | 0x0a3308bd, 0x7f97cebd, 0x0a6522fe, 0x7f93c38c, | ||
60 | 0x0a973ba5, 0x7f8fa4b0, 0x0ac952aa, 0x7f8b7227, | ||
61 | 0x0afb6805, 0x7f872bf3, 0x0b2d7baf, 0x7f82d214, | ||
62 | 0x0b5f8d9f, 0x7f7e648c, 0x0b919dcf, 0x7f79e35a, | ||
63 | 0x0bc3ac35, 0x7f754e80, 0x0bf5b8cb, 0x7f70a5fe, | ||
64 | 0x0c27c389, 0x7f6be9d4, 0x0c59cc68, 0x7f671a05, | ||
65 | 0x0c8bd35e, 0x7f62368f, 0x0cbdd865, 0x7f5d3f75, | ||
66 | 0x0cefdb76, 0x7f5834b7, 0x0d21dc87, 0x7f531655, | ||
67 | 0x0d53db92, 0x7f4de451, 0x0d85d88f, 0x7f489eaa, | ||
68 | 0x0db7d376, 0x7f434563, 0x0de9cc40, 0x7f3dd87c, | ||
69 | 0x0e1bc2e4, 0x7f3857f6, 0x0e4db75b, 0x7f32c3d1, | ||
70 | 0x0e7fa99e, 0x7f2d1c0e, 0x0eb199a4, 0x7f2760af, | ||
71 | 0x0ee38766, 0x7f2191b4, 0x0f1572dc, 0x7f1baf1e, | ||
72 | 0x0f475bff, 0x7f15b8ee, 0x0f7942c7, 0x7f0faf25, | ||
73 | 0x0fab272b, 0x7f0991c4, 0x0fdd0926, 0x7f0360cb, | ||
74 | 0x100ee8ad, 0x7efd1c3c, 0x1040c5bb, 0x7ef6c418, | ||
75 | 0x1072a048, 0x7ef05860, 0x10a4784b, 0x7ee9d914, | ||
76 | 0x10d64dbd, 0x7ee34636, 0x11082096, 0x7edc9fc6, | ||
77 | 0x1139f0cf, 0x7ed5e5c6, 0x116bbe60, 0x7ecf1837, | ||
78 | 0x119d8941, 0x7ec8371a, 0x11cf516a, 0x7ec14270, | ||
79 | 0x120116d5, 0x7eba3a39, 0x1232d979, 0x7eb31e78, | ||
80 | 0x1264994e, 0x7eabef2c, 0x1296564d, 0x7ea4ac58, | ||
81 | 0x12c8106f, 0x7e9d55fc, 0x12f9c7aa, 0x7e95ec1a, | ||
82 | 0x132b7bf9, 0x7e8e6eb2, 0x135d2d53, 0x7e86ddc6, | ||
83 | 0x138edbb1, 0x7e7f3957, 0x13c0870a, 0x7e778166, | ||
84 | 0x13f22f58, 0x7e6fb5f4, 0x1423d492, 0x7e67d703, | ||
85 | 0x145576b1, 0x7e5fe493, 0x148715ae, 0x7e57dea7, | ||
86 | 0x14b8b17f, 0x7e4fc53e, 0x14ea4a1f, 0x7e47985b, | ||
87 | 0x151bdf86, 0x7e3f57ff, 0x154d71aa, 0x7e37042a, | ||
88 | 0x157f0086, 0x7e2e9cdf, 0x15b08c12, 0x7e26221f, | ||
89 | 0x15e21445, 0x7e1d93ea, 0x16139918, 0x7e14f242, | ||
90 | 0x16451a83, 0x7e0c3d29, 0x1676987f, 0x7e0374a0, | ||
91 | 0x16a81305, 0x7dfa98a8, 0x16d98a0c, 0x7df1a942, | ||
92 | 0x170afd8d, 0x7de8a670, 0x173c6d80, 0x7ddf9034, | ||
93 | 0x176dd9de, 0x7dd6668f, 0x179f429f, 0x7dcd2981, | ||
94 | 0x17d0a7bc, 0x7dc3d90d, 0x1802092c, 0x7dba7534, | ||
95 | 0x183366e9, 0x7db0fdf8, 0x1864c0ea, 0x7da77359, | ||
96 | 0x18961728, 0x7d9dd55a, 0x18c7699b, 0x7d9423fc, | ||
97 | 0x18f8b83c, 0x7d8a5f40, 0x192a0304, 0x7d808728, | ||
98 | 0x195b49ea, 0x7d769bb5, 0x198c8ce7, 0x7d6c9ce9, | ||
99 | 0x19bdcbf3, 0x7d628ac6, 0x19ef0707, 0x7d58654d, | ||
100 | 0x1a203e1b, 0x7d4e2c7f, 0x1a517128, 0x7d43e05e, | ||
101 | 0x1a82a026, 0x7d3980ec, 0x1ab3cb0d, 0x7d2f0e2b, | ||
102 | 0x1ae4f1d6, 0x7d24881b, 0x1b161479, 0x7d19eebf, | ||
103 | 0x1b4732ef, 0x7d0f4218, 0x1b784d30, 0x7d048228, | ||
104 | 0x1ba96335, 0x7cf9aef0, 0x1bda74f6, 0x7ceec873, | ||
105 | 0x1c0b826a, 0x7ce3ceb2, 0x1c3c8b8c, 0x7cd8c1ae, | ||
106 | 0x1c6d9053, 0x7ccda169, 0x1c9e90b8, 0x7cc26de5, | ||
107 | 0x1ccf8cb3, 0x7cb72724, 0x1d00843d, 0x7cabcd28, | ||
108 | 0x1d31774d, 0x7ca05ff1, 0x1d6265dd, 0x7c94df83, | ||
109 | 0x1d934fe5, 0x7c894bde, 0x1dc4355e, 0x7c7da505, | ||
110 | 0x1df5163f, 0x7c71eaf9, 0x1e25f282, 0x7c661dbc, | ||
111 | 0x1e56ca1e, 0x7c5a3d50, 0x1e879d0d, 0x7c4e49b7, | ||
112 | 0x1eb86b46, 0x7c4242f2, 0x1ee934c3, 0x7c362904, | ||
113 | 0x1f19f97b, 0x7c29fbee, 0x1f4ab968, 0x7c1dbbb3, | ||
114 | 0x1f7b7481, 0x7c116853, 0x1fac2abf, 0x7c0501d2, | ||
115 | 0x1fdcdc1b, 0x7bf88830, 0x200d888d, 0x7bebfb70, | ||
116 | 0x203e300d, 0x7bdf5b94, 0x206ed295, 0x7bd2a89e, | ||
117 | 0x209f701c, 0x7bc5e290, 0x20d0089c, 0x7bb9096b, | ||
118 | 0x21009c0c, 0x7bac1d31, 0x21312a65, 0x7b9f1de6, | ||
119 | 0x2161b3a0, 0x7b920b89, 0x219237b5, 0x7b84e61f, | ||
120 | 0x21c2b69c, 0x7b77ada8, 0x21f3304f, 0x7b6a6227, | ||
121 | 0x2223a4c5, 0x7b5d039e, 0x225413f8, 0x7b4f920e, | ||
122 | 0x22847de0, 0x7b420d7a, 0x22b4e274, 0x7b3475e5, | ||
123 | 0x22e541af, 0x7b26cb4f, 0x23159b88, 0x7b190dbc, | ||
124 | 0x2345eff8, 0x7b0b3d2c, 0x23763ef7, 0x7afd59a4, | ||
125 | 0x23a6887f, 0x7aef6323, 0x23d6cc87, 0x7ae159ae, | ||
126 | 0x24070b08, 0x7ad33d45, 0x243743fa, 0x7ac50dec, | ||
127 | 0x24677758, 0x7ab6cba4, 0x2497a517, 0x7aa8766f, | ||
128 | 0x24c7cd33, 0x7a9a0e50, 0x24f7efa2, 0x7a8b9348, | ||
129 | 0x25280c5e, 0x7a7d055b, 0x2558235f, 0x7a6e648a, | ||
130 | 0x2588349d, 0x7a5fb0d8, 0x25b84012, 0x7a50ea47, | ||
131 | 0x25e845b6, 0x7a4210d8, 0x26184581, 0x7a332490, | ||
132 | 0x26483f6c, 0x7a24256f, 0x26783370, 0x7a151378, | ||
133 | 0x26a82186, 0x7a05eead, 0x26d809a5, 0x79f6b711, | ||
134 | 0x2707ebc7, 0x79e76ca7, 0x2737c7e3, 0x79d80f6f, | ||
135 | 0x27679df4, 0x79c89f6e, 0x27976df1, 0x79b91ca4, | ||
136 | 0x27c737d3, 0x79a98715, 0x27f6fb92, 0x7999dec4, | ||
137 | 0x2826b928, 0x798a23b1, 0x2856708d, 0x797a55e0, | ||
138 | 0x288621b9, 0x796a7554, 0x28b5cca5, 0x795a820e, | ||
139 | 0x28e5714b, 0x794a7c12, 0x29150fa1, 0x793a6361, | ||
140 | 0x2944a7a2, 0x792a37fe, 0x29743946, 0x7919f9ec, | ||
141 | 0x29a3c485, 0x7909a92d, 0x29d34958, 0x78f945c3, | ||
142 | 0x2a02c7b8, 0x78e8cfb2, 0x2a323f9e, 0x78d846fb, | ||
143 | 0x2a61b101, 0x78c7aba2, 0x2a911bdc, 0x78b6fda8, | ||
144 | 0x2ac08026, 0x78a63d11, 0x2aefddd8, 0x789569df, | ||
145 | 0x2b1f34eb, 0x78848414, 0x2b4e8558, 0x78738bb3, | ||
146 | 0x2b7dcf17, 0x786280bf, 0x2bad1221, 0x7851633b, | ||
147 | 0x2bdc4e6f, 0x78403329, 0x2c0b83fa, 0x782ef08b, | ||
148 | 0x2c3ab2b9, 0x781d9b65, 0x2c69daa6, 0x780c33b8, | ||
149 | 0x2c98fbba, 0x77fab989, 0x2cc815ee, 0x77e92cd9, | ||
150 | 0x2cf72939, 0x77d78daa, 0x2d263596, 0x77c5dc01, | ||
151 | 0x2d553afc, 0x77b417df, 0x2d843964, 0x77a24148, | ||
152 | 0x2db330c7, 0x7790583e, 0x2de2211e, 0x777e5cc3, | ||
153 | 0x2e110a62, 0x776c4edb, 0x2e3fec8b, 0x775a2e89, | ||
154 | 0x2e6ec792, 0x7747fbce, 0x2e9d9b70, 0x7735b6af, | ||
155 | 0x2ecc681e, 0x77235f2d, 0x2efb2d95, 0x7710f54c, | ||
156 | 0x2f29ebcc, 0x76fe790e, 0x2f58a2be, 0x76ebea77, | ||
157 | 0x2f875262, 0x76d94989, 0x2fb5fab2, 0x76c69647, | ||
158 | 0x2fe49ba7, 0x76b3d0b4, 0x30133539, 0x76a0f8d2, | ||
159 | 0x3041c761, 0x768e0ea6, 0x30705217, 0x767b1231, | ||
160 | 0x309ed556, 0x76680376, 0x30cd5115, 0x7654e279, | ||
161 | 0x30fbc54d, 0x7641af3d, 0x312a31f8, 0x762e69c4, | ||
162 | 0x3158970e, 0x761b1211, 0x3186f487, 0x7607a828, | ||
163 | 0x31b54a5e, 0x75f42c0b, 0x31e39889, 0x75e09dbd, | ||
164 | 0x3211df04, 0x75ccfd42, 0x32401dc6, 0x75b94a9c, | ||
165 | 0x326e54c7, 0x75a585cf, 0x329c8402, 0x7591aedd, | ||
166 | 0x32caab6f, 0x757dc5ca, 0x32f8cb07, 0x7569ca99, | ||
167 | 0x3326e2c3, 0x7555bd4c, 0x3354f29b, 0x75419de7, | ||
168 | 0x3382fa88, 0x752d6c6c, 0x33b0fa84, 0x751928e0, | ||
169 | 0x33def287, 0x7504d345, 0x340ce28b, 0x74f06b9e, | ||
170 | 0x343aca87, 0x74dbf1ef, 0x3468aa76, 0x74c7663a, | ||
171 | 0x34968250, 0x74b2c884, 0x34c4520d, 0x749e18cd, | ||
172 | 0x34f219a8, 0x7489571c, 0x351fd918, 0x74748371, | ||
173 | 0x354d9057, 0x745f9dd1, 0x357b3f5d, 0x744aa63f, | ||
174 | 0x35a8e625, 0x74359cbd, 0x35d684a6, 0x74208150, | ||
175 | 0x36041ad9, 0x740b53fb, 0x3631a8b8, 0x73f614c0, | ||
176 | 0x365f2e3b, 0x73e0c3a3, 0x368cab5c, 0x73cb60a8, | ||
177 | 0x36ba2014, 0x73b5ebd1, 0x36e78c5b, 0x73a06522, | ||
178 | 0x3714f02a, 0x738acc9e, 0x37424b7b, 0x73752249, | ||
179 | 0x376f9e46, 0x735f6626, 0x379ce885, 0x73499838, | ||
180 | 0x37ca2a30, 0x7333b883, 0x37f76341, 0x731dc70a, | ||
181 | 0x382493b0, 0x7307c3d0, 0x3851bb77, 0x72f1aed9, | ||
182 | 0x387eda8e, 0x72db8828, 0x38abf0ef, 0x72c54fc1, | ||
183 | 0x38d8fe93, 0x72af05a7, 0x39060373, 0x7298a9dd, | ||
184 | 0x3932ff87, 0x72823c67, 0x395ff2c9, 0x726bbd48, | ||
185 | 0x398cdd32, 0x72552c85, 0x39b9bebc, 0x723e8a20, | ||
186 | 0x39e6975e, 0x7227d61c, 0x3a136712, 0x7211107e, | ||
187 | 0x3a402dd2, 0x71fa3949, 0x3a6ceb96, 0x71e35080, | ||
188 | 0x3a99a057, 0x71cc5626, 0x3ac64c0f, 0x71b54a41, | ||
189 | 0x3af2eeb7, 0x719e2cd2, 0x3b1f8848, 0x7186fdde, | ||
190 | 0x3b4c18ba, 0x716fbd68, 0x3b78a007, 0x71586b74, | ||
191 | 0x3ba51e29, 0x71410805, 0x3bd19318, 0x7129931f, | ||
192 | 0x3bfdfecd, 0x71120cc5, 0x3c2a6142, 0x70fa74fc, | ||
193 | 0x3c56ba70, 0x70e2cbc6, 0x3c830a50, 0x70cb1128, | ||
194 | 0x3caf50da, 0x70b34525, 0x3cdb8e09, 0x709b67c0, | ||
195 | 0x3d07c1d6, 0x708378ff, 0x3d33ec39, 0x706b78e3, | ||
196 | 0x3d600d2c, 0x70536771, 0x3d8c24a8, 0x703b44ad, | ||
197 | 0x3db832a6, 0x7023109a, 0x3de4371f, 0x700acb3c, | ||
198 | 0x3e10320d, 0x6ff27497, 0x3e3c2369, 0x6fda0cae, | ||
199 | 0x3e680b2c, 0x6fc19385, 0x3e93e950, 0x6fa90921, | ||
200 | 0x3ebfbdcd, 0x6f906d84, 0x3eeb889c, 0x6f77c0b3, | ||
201 | 0x3f1749b8, 0x6f5f02b2, 0x3f430119, 0x6f463383, | ||
202 | 0x3f6eaeb8, 0x6f2d532c, 0x3f9a5290, 0x6f1461b0, | ||
203 | 0x3fc5ec98, 0x6efb5f12, 0x3ff17cca, 0x6ee24b57, | ||
204 | 0x401d0321, 0x6ec92683, 0x40487f94, 0x6eaff099, | ||
205 | 0x4073f21d, 0x6e96a99d, 0x409f5ab6, 0x6e7d5193, | ||
206 | 0x40cab958, 0x6e63e87f, 0x40f60dfb, 0x6e4a6e66, | ||
207 | 0x4121589b, 0x6e30e34a, 0x414c992f, 0x6e174730, | ||
208 | 0x4177cfb1, 0x6dfd9a1c, 0x41a2fc1a, 0x6de3dc11, | ||
209 | 0x41ce1e65, 0x6dca0d14, 0x41f93689, 0x6db02d29, | ||
210 | 0x42244481, 0x6d963c54, 0x424f4845, 0x6d7c3a98, | ||
211 | 0x427a41d0, 0x6d6227fa, 0x42a5311b, 0x6d48047e, | ||
212 | 0x42d0161e, 0x6d2dd027, 0x42faf0d4, 0x6d138afb, | ||
213 | 0x4325c135, 0x6cf934fc, 0x4350873c, 0x6cdece2f, | ||
214 | 0x437b42e1, 0x6cc45698, 0x43a5f41e, 0x6ca9ce3b, | ||
215 | 0x43d09aed, 0x6c8f351c, 0x43fb3746, 0x6c748b3f, | ||
216 | 0x4425c923, 0x6c59d0a9, 0x4450507e, 0x6c3f055d, | ||
217 | 0x447acd50, 0x6c242960, 0x44a53f93, 0x6c093cb6, | ||
218 | 0x44cfa740, 0x6bee3f62, 0x44fa0450, 0x6bd3316a, | ||
219 | 0x452456bd, 0x6bb812d1, 0x454e9e80, 0x6b9ce39b, | ||
220 | 0x4578db93, 0x6b81a3cd, 0x45a30df0, 0x6b66536b, | ||
221 | 0x45cd358f, 0x6b4af279, 0x45f7526b, 0x6b2f80fb, | ||
222 | 0x4621647d, 0x6b13fef5, 0x464b6bbe, 0x6af86c6c, | ||
223 | 0x46756828, 0x6adcc964, 0x469f59b4, 0x6ac115e2, | ||
224 | 0x46c9405c, 0x6aa551e9, 0x46f31c1a, 0x6a897d7d, | ||
225 | 0x471cece7, 0x6a6d98a4, 0x4746b2bc, 0x6a51a361, | ||
226 | 0x47706d93, 0x6a359db9, 0x479a1d67, 0x6a1987b0, | ||
227 | 0x47c3c22f, 0x69fd614a, 0x47ed5be6, 0x69e12a8c, | ||
228 | 0x4816ea86, 0x69c4e37a, 0x48406e08, 0x69a88c19, | ||
229 | 0x4869e665, 0x698c246c, 0x48935397, 0x696fac78, | ||
230 | 0x48bcb599, 0x69532442, 0x48e60c62, 0x69368bce, | ||
231 | 0x490f57ee, 0x6919e320, 0x49389836, 0x68fd2a3d, | ||
232 | 0x4961cd33, 0x68e06129, 0x498af6df, 0x68c387e9, | ||
233 | 0x49b41533, 0x68a69e81, 0x49dd282a, 0x6889a4f6, | ||
234 | 0x4a062fbd, 0x686c9b4b, 0x4a2f2be6, 0x684f8186, | ||
235 | 0x4a581c9e, 0x683257ab, 0x4a8101de, 0x68151dbe, | ||
236 | 0x4aa9dba2, 0x67f7d3c5, 0x4ad2a9e2, 0x67da79c3, | ||
237 | 0x4afb6c98, 0x67bd0fbd, 0x4b2423be, 0x679f95b7, | ||
238 | 0x4b4ccf4d, 0x67820bb7, 0x4b756f40, 0x676471c0, | ||
239 | 0x4b9e0390, 0x6746c7d8, 0x4bc68c36, 0x67290e02, | ||
240 | 0x4bef092d, 0x670b4444, 0x4c177a6e, 0x66ed6aa1, | ||
241 | 0x4c3fdff4, 0x66cf8120, 0x4c6839b7, 0x66b187c3, | ||
242 | 0x4c9087b1, 0x66937e91, 0x4cb8c9dd, 0x6675658c, | ||
243 | 0x4ce10034, 0x66573cbb, 0x4d092ab0, 0x66390422, | ||
244 | 0x4d31494b, 0x661abbc5, 0x4d595bfe, 0x65fc63a9, | ||
245 | 0x4d8162c4, 0x65ddfbd3, 0x4da95d96, 0x65bf8447, | ||
246 | 0x4dd14c6e, 0x65a0fd0b, 0x4df92f46, 0x65826622, | ||
247 | 0x4e210617, 0x6563bf92, 0x4e48d0dd, 0x6545095f, | ||
248 | 0x4e708f8f, 0x6526438f, 0x4e984229, 0x65076e25, | ||
249 | 0x4ebfe8a5, 0x64e88926, 0x4ee782fb, 0x64c99498, | ||
250 | 0x4f0f1126, 0x64aa907f, 0x4f369320, 0x648b7ce0, | ||
251 | 0x4f5e08e3, 0x646c59bf, 0x4f857269, 0x644d2722, | ||
252 | 0x4faccfab, 0x642de50d, 0x4fd420a4, 0x640e9386, | ||
253 | 0x4ffb654d, 0x63ef3290, 0x50229da1, 0x63cfc231, | ||
254 | 0x5049c999, 0x63b0426d, 0x5070e92f, 0x6390b34a, | ||
255 | 0x5097fc5e, 0x637114cc, 0x50bf031f, 0x635166f9, | ||
256 | 0x50e5fd6d, 0x6331a9d4, 0x510ceb40, 0x6311dd64, | ||
257 | 0x5133cc94, 0x62f201ac, 0x515aa162, 0x62d216b3, | ||
258 | 0x518169a5, 0x62b21c7b, 0x51a82555, 0x6292130c, | ||
259 | 0x51ced46e, 0x6271fa69, 0x51f576ea, 0x6251d298, | ||
260 | 0x521c0cc2, 0x62319b9d, 0x524295f0, 0x6211557e, | ||
261 | 0x5269126e, 0x61f1003f, 0x528f8238, 0x61d09be5, | ||
262 | 0x52b5e546, 0x61b02876, 0x52dc3b92, 0x618fa5f7, | ||
263 | 0x53028518, 0x616f146c, 0x5328c1d0, 0x614e73da, | ||
264 | 0x534ef1b5, 0x612dc447, 0x537514c2, 0x610d05b7, | ||
265 | 0x539b2af0, 0x60ec3830, 0x53c13439, 0x60cb5bb7, | ||
266 | 0x53e73097, 0x60aa7050, 0x540d2005, 0x60897601, | ||
267 | 0x5433027d, 0x60686ccf, 0x5458d7f9, 0x604754bf, | ||
268 | 0x547ea073, 0x60262dd6, 0x54a45be6, 0x6004f819, | ||
269 | 0x54ca0a4b, 0x5fe3b38d, 0x54efab9c, 0x5fc26038, | ||
270 | 0x55153fd4, 0x5fa0fe1f, 0x553ac6ee, 0x5f7f8d46, | ||
271 | 0x556040e2, 0x5f5e0db3, 0x5585adad, 0x5f3c7f6b, | ||
272 | 0x55ab0d46, 0x5f1ae274, 0x55d05faa, 0x5ef936d1, | ||
273 | 0x55f5a4d2, 0x5ed77c8a, 0x561adcb9, 0x5eb5b3a2, | ||
274 | 0x56400758, 0x5e93dc1f, 0x566524aa, 0x5e71f606, | ||
275 | 0x568a34a9, 0x5e50015d, 0x56af3750, 0x5e2dfe29, | ||
276 | 0x56d42c99, 0x5e0bec6e, 0x56f9147e, 0x5de9cc33, | ||
277 | 0x571deefa, 0x5dc79d7c, 0x5742bc06, 0x5da5604f, | ||
278 | 0x57677b9d, 0x5d8314b1, 0x578c2dba, 0x5d60baa7, | ||
279 | 0x57b0d256, 0x5d3e5237, 0x57d5696d, 0x5d1bdb65, | ||
280 | 0x57f9f2f8, 0x5cf95638, 0x581e6ef1, 0x5cd6c2b5, | ||
281 | 0x5842dd54, 0x5cb420e0, 0x58673e1b, 0x5c9170bf, | ||
282 | 0x588b9140, 0x5c6eb258, 0x58afd6bd, 0x5c4be5b0, | ||
283 | 0x58d40e8c, 0x5c290acc, 0x58f838a9, 0x5c0621b2, | ||
284 | 0x591c550e, 0x5be32a67, 0x594063b5, 0x5bc024f0, | ||
285 | 0x59646498, 0x5b9d1154, 0x598857b2, 0x5b79ef96, | ||
286 | 0x59ac3cfd, 0x5b56bfbd, 0x59d01475, 0x5b3381ce, | ||
287 | 0x59f3de12, 0x5b1035cf, 0x5a1799d1, 0x5aecdbc5, | ||
288 | 0x5a3b47ab, 0x5ac973b5, 0x5a5ee79a, 0x5aa5fda5, | ||
289 | 0x5a82799a, 0x5a82799a | ||
290 | }; | ||
291 | |||
292 | /* {sin((2*i+1)*PI/4096, cos((2*i+1)*PI/4096)}, with i = 0 to 511 */ | ||
293 | const int32_t sincos_lookup1[1024] ICONST_ATTR = { | ||
294 | 0x001921fb, 0x7ffffd88, 0x004b65ee, 0x7fffe9cb, | ||
295 | 0x007da9d4, 0x7fffc251, 0x00afeda8, 0x7fff8719, | ||
296 | 0x00e23160, 0x7fff3824, 0x011474f6, 0x7ffed572, | ||
297 | 0x0146b860, 0x7ffe5f03, 0x0178fb99, 0x7ffdd4d7, | ||
298 | 0x01ab3e97, 0x7ffd36ee, 0x01dd8154, 0x7ffc8549, | ||
299 | 0x020fc3c6, 0x7ffbbfe6, 0x024205e8, 0x7ffae6c7, | ||
300 | 0x027447b0, 0x7ff9f9ec, 0x02a68917, 0x7ff8f954, | ||
301 | 0x02d8ca16, 0x7ff7e500, 0x030b0aa4, 0x7ff6bcf0, | ||
302 | 0x033d4abb, 0x7ff58125, 0x036f8a51, 0x7ff4319d, | ||
303 | 0x03a1c960, 0x7ff2ce5b, 0x03d407df, 0x7ff1575d, | ||
304 | 0x040645c7, 0x7fefcca4, 0x04388310, 0x7fee2e30, | ||
305 | 0x046abfb3, 0x7fec7c02, 0x049cfba7, 0x7feab61a, | ||
306 | 0x04cf36e5, 0x7fe8dc78, 0x05017165, 0x7fe6ef1c, | ||
307 | 0x0533ab20, 0x7fe4ee06, 0x0565e40d, 0x7fe2d938, | ||
308 | 0x05981c26, 0x7fe0b0b1, 0x05ca5361, 0x7fde7471, | ||
309 | 0x05fc89b8, 0x7fdc247a, 0x062ebf22, 0x7fd9c0ca, | ||
310 | 0x0660f398, 0x7fd74964, 0x06932713, 0x7fd4be46, | ||
311 | 0x06c5598a, 0x7fd21f72, 0x06f78af6, 0x7fcf6ce8, | ||
312 | 0x0729bb4e, 0x7fcca6a7, 0x075bea8c, 0x7fc9ccb2, | ||
313 | 0x078e18a7, 0x7fc6df08, 0x07c04598, 0x7fc3dda9, | ||
314 | 0x07f27157, 0x7fc0c896, 0x08249bdd, 0x7fbd9fd0, | ||
315 | 0x0856c520, 0x7fba6357, 0x0888ed1b, 0x7fb7132b, | ||
316 | 0x08bb13c5, 0x7fb3af4e, 0x08ed3916, 0x7fb037bf, | ||
317 | 0x091f5d06, 0x7facac7f, 0x09517f8f, 0x7fa90d8e, | ||
318 | 0x0983a0a7, 0x7fa55aee, 0x09b5c048, 0x7fa1949e, | ||
319 | 0x09e7de6a, 0x7f9dbaa0, 0x0a19fb04, 0x7f99ccf4, | ||
320 | 0x0a4c1610, 0x7f95cb9a, 0x0a7e2f85, 0x7f91b694, | ||
321 | 0x0ab0475c, 0x7f8d8de1, 0x0ae25d8d, 0x7f895182, | ||
322 | 0x0b147211, 0x7f850179, 0x0b4684df, 0x7f809dc5, | ||
323 | 0x0b7895f0, 0x7f7c2668, 0x0baaa53b, 0x7f779b62, | ||
324 | 0x0bdcb2bb, 0x7f72fcb4, 0x0c0ebe66, 0x7f6e4a5e, | ||
325 | 0x0c40c835, 0x7f698461, 0x0c72d020, 0x7f64aabf, | ||
326 | 0x0ca4d620, 0x7f5fbd77, 0x0cd6da2d, 0x7f5abc8a, | ||
327 | 0x0d08dc3f, 0x7f55a7fa, 0x0d3adc4e, 0x7f507fc7, | ||
328 | 0x0d6cda53, 0x7f4b43f2, 0x0d9ed646, 0x7f45f47b, | ||
329 | 0x0dd0d01f, 0x7f409164, 0x0e02c7d7, 0x7f3b1aad, | ||
330 | 0x0e34bd66, 0x7f359057, 0x0e66b0c3, 0x7f2ff263, | ||
331 | 0x0e98a1e9, 0x7f2a40d2, 0x0eca90ce, 0x7f247ba5, | ||
332 | 0x0efc7d6b, 0x7f1ea2dc, 0x0f2e67b8, 0x7f18b679, | ||
333 | 0x0f604faf, 0x7f12b67c, 0x0f923546, 0x7f0ca2e7, | ||
334 | 0x0fc41876, 0x7f067bba, 0x0ff5f938, 0x7f0040f6, | ||
335 | 0x1027d784, 0x7ef9f29d, 0x1059b352, 0x7ef390ae, | ||
336 | 0x108b8c9b, 0x7eed1b2c, 0x10bd6356, 0x7ee69217, | ||
337 | 0x10ef377d, 0x7edff570, 0x11210907, 0x7ed94538, | ||
338 | 0x1152d7ed, 0x7ed28171, 0x1184a427, 0x7ecbaa1a, | ||
339 | 0x11b66dad, 0x7ec4bf36, 0x11e83478, 0x7ebdc0c6, | ||
340 | 0x1219f880, 0x7eb6aeca, 0x124bb9be, 0x7eaf8943, | ||
341 | 0x127d7829, 0x7ea85033, 0x12af33ba, 0x7ea1039b, | ||
342 | 0x12e0ec6a, 0x7e99a37c, 0x1312a230, 0x7e922fd6, | ||
343 | 0x13445505, 0x7e8aa8ac, 0x137604e2, 0x7e830dff, | ||
344 | 0x13a7b1bf, 0x7e7b5fce, 0x13d95b93, 0x7e739e1d, | ||
345 | 0x140b0258, 0x7e6bc8eb, 0x143ca605, 0x7e63e03b, | ||
346 | 0x146e4694, 0x7e5be40c, 0x149fe3fc, 0x7e53d462, | ||
347 | 0x14d17e36, 0x7e4bb13c, 0x1503153a, 0x7e437a9c, | ||
348 | 0x1534a901, 0x7e3b3083, 0x15663982, 0x7e32d2f4, | ||
349 | 0x1597c6b7, 0x7e2a61ed, 0x15c95097, 0x7e21dd73, | ||
350 | 0x15fad71b, 0x7e194584, 0x162c5a3b, 0x7e109a24, | ||
351 | 0x165dd9f0, 0x7e07db52, 0x168f5632, 0x7dff0911, | ||
352 | 0x16c0cef9, 0x7df62362, 0x16f2443e, 0x7ded2a47, | ||
353 | 0x1723b5f9, 0x7de41dc0, 0x17552422, 0x7ddafdce, | ||
354 | 0x17868eb3, 0x7dd1ca75, 0x17b7f5a3, 0x7dc883b4, | ||
355 | 0x17e958ea, 0x7dbf298d, 0x181ab881, 0x7db5bc02, | ||
356 | 0x184c1461, 0x7dac3b15, 0x187d6c82, 0x7da2a6c6, | ||
357 | 0x18aec0db, 0x7d98ff17, 0x18e01167, 0x7d8f4409, | ||
358 | 0x19115e1c, 0x7d85759f, 0x1942a6f3, 0x7d7b93da, | ||
359 | 0x1973ebe6, 0x7d719eba, 0x19a52ceb, 0x7d679642, | ||
360 | 0x19d669fc, 0x7d5d7a74, 0x1a07a311, 0x7d534b50, | ||
361 | 0x1a38d823, 0x7d4908d9, 0x1a6a0929, 0x7d3eb30f, | ||
362 | 0x1a9b361d, 0x7d3449f5, 0x1acc5ef6, 0x7d29cd8c, | ||
363 | 0x1afd83ad, 0x7d1f3dd6, 0x1b2ea43a, 0x7d149ad5, | ||
364 | 0x1b5fc097, 0x7d09e489, 0x1b90d8bb, 0x7cff1af5, | ||
365 | 0x1bc1ec9e, 0x7cf43e1a, 0x1bf2fc3a, 0x7ce94dfb, | ||
366 | 0x1c240786, 0x7cde4a98, 0x1c550e7c, 0x7cd333f3, | ||
367 | 0x1c861113, 0x7cc80a0f, 0x1cb70f43, 0x7cbcccec, | ||
368 | 0x1ce80906, 0x7cb17c8d, 0x1d18fe54, 0x7ca618f3, | ||
369 | 0x1d49ef26, 0x7c9aa221, 0x1d7adb73, 0x7c8f1817, | ||
370 | 0x1dabc334, 0x7c837ad8, 0x1ddca662, 0x7c77ca65, | ||
371 | 0x1e0d84f5, 0x7c6c06c0, 0x1e3e5ee5, 0x7c602fec, | ||
372 | 0x1e6f342c, 0x7c5445e9, 0x1ea004c1, 0x7c4848ba, | ||
373 | 0x1ed0d09d, 0x7c3c3860, 0x1f0197b8, 0x7c3014de, | ||
374 | 0x1f325a0b, 0x7c23de35, 0x1f63178f, 0x7c179467, | ||
375 | 0x1f93d03c, 0x7c0b3777, 0x1fc4840a, 0x7bfec765, | ||
376 | 0x1ff532f2, 0x7bf24434, 0x2025dcec, 0x7be5ade6, | ||
377 | 0x205681f1, 0x7bd9047c, 0x208721f9, 0x7bcc47fa, | ||
378 | 0x20b7bcfe, 0x7bbf7860, 0x20e852f6, 0x7bb295b0, | ||
379 | 0x2118e3dc, 0x7ba59fee, 0x21496fa7, 0x7b989719, | ||
380 | 0x2179f64f, 0x7b8b7b36, 0x21aa77cf, 0x7b7e4c45, | ||
381 | 0x21daf41d, 0x7b710a49, 0x220b6b32, 0x7b63b543, | ||
382 | 0x223bdd08, 0x7b564d36, 0x226c4996, 0x7b48d225, | ||
383 | 0x229cb0d5, 0x7b3b4410, 0x22cd12bd, 0x7b2da2fa, | ||
384 | 0x22fd6f48, 0x7b1feee5, 0x232dc66d, 0x7b1227d3, | ||
385 | 0x235e1826, 0x7b044dc7, 0x238e646a, 0x7af660c2, | ||
386 | 0x23beab33, 0x7ae860c7, 0x23eeec78, 0x7ada4dd8, | ||
387 | 0x241f2833, 0x7acc27f7, 0x244f5e5c, 0x7abdef25, | ||
388 | 0x247f8eec, 0x7aafa367, 0x24afb9da, 0x7aa144bc, | ||
389 | 0x24dfdf20, 0x7a92d329, 0x250ffeb7, 0x7a844eae, | ||
390 | 0x25401896, 0x7a75b74f, 0x25702cb7, 0x7a670d0d, | ||
391 | 0x25a03b11, 0x7a584feb, 0x25d0439f, 0x7a497feb, | ||
392 | 0x26004657, 0x7a3a9d0f, 0x26304333, 0x7a2ba75a, | ||
393 | 0x26603a2c, 0x7a1c9ece, 0x26902b39, 0x7a0d836d, | ||
394 | 0x26c01655, 0x79fe5539, 0x26effb76, 0x79ef1436, | ||
395 | 0x271fda96, 0x79dfc064, 0x274fb3ae, 0x79d059c8, | ||
396 | 0x277f86b5, 0x79c0e062, 0x27af53a6, 0x79b15435, | ||
397 | 0x27df1a77, 0x79a1b545, 0x280edb23, 0x79920392, | ||
398 | 0x283e95a1, 0x79823f20, 0x286e49ea, 0x797267f2, | ||
399 | 0x289df7f8, 0x79627e08, 0x28cd9fc1, 0x79528167, | ||
400 | 0x28fd4140, 0x79427210, 0x292cdc6d, 0x79325006, | ||
401 | 0x295c7140, 0x79221b4b, 0x298bffb2, 0x7911d3e2, | ||
402 | 0x29bb87bc, 0x790179cd, 0x29eb0957, 0x78f10d0f, | ||
403 | 0x2a1a847b, 0x78e08dab, 0x2a49f920, 0x78cffba3, | ||
404 | 0x2a796740, 0x78bf56f9, 0x2aa8ced3, 0x78ae9fb0, | ||
405 | 0x2ad82fd2, 0x789dd5cb, 0x2b078a36, 0x788cf94c, | ||
406 | 0x2b36ddf7, 0x787c0a36, 0x2b662b0e, 0x786b088c, | ||
407 | 0x2b957173, 0x7859f44f, 0x2bc4b120, 0x7848cd83, | ||
408 | 0x2bf3ea0d, 0x7837942b, 0x2c231c33, 0x78264849, | ||
409 | 0x2c52478a, 0x7814e9df, 0x2c816c0c, 0x780378f1, | ||
410 | 0x2cb089b1, 0x77f1f581, 0x2cdfa071, 0x77e05f91, | ||
411 | 0x2d0eb046, 0x77ceb725, 0x2d3db928, 0x77bcfc3f, | ||
412 | 0x2d6cbb10, 0x77ab2ee2, 0x2d9bb5f6, 0x77994f11, | ||
413 | 0x2dcaa9d5, 0x77875cce, 0x2df996a3, 0x7775581d, | ||
414 | 0x2e287c5a, 0x776340ff, 0x2e575af3, 0x77511778, | ||
415 | 0x2e863267, 0x773edb8b, 0x2eb502ae, 0x772c8d3a, | ||
416 | 0x2ee3cbc1, 0x771a2c88, 0x2f128d99, 0x7707b979, | ||
417 | 0x2f41482e, 0x76f5340e, 0x2f6ffb7a, 0x76e29c4b, | ||
418 | 0x2f9ea775, 0x76cff232, 0x2fcd4c19, 0x76bd35c7, | ||
419 | 0x2ffbe95d, 0x76aa670d, 0x302a7f3a, 0x76978605, | ||
420 | 0x30590dab, 0x768492b4, 0x308794a6, 0x76718d1c, | ||
421 | 0x30b61426, 0x765e7540, 0x30e48c22, 0x764b4b23, | ||
422 | 0x3112fc95, 0x76380ec8, 0x31416576, 0x7624c031, | ||
423 | 0x316fc6be, 0x76115f63, 0x319e2067, 0x75fdec60, | ||
424 | 0x31cc7269, 0x75ea672a, 0x31fabcbd, 0x75d6cfc5, | ||
425 | 0x3228ff5c, 0x75c32634, 0x32573a3f, 0x75af6a7b, | ||
426 | 0x32856d5e, 0x759b9c9b, 0x32b398b3, 0x7587bc98, | ||
427 | 0x32e1bc36, 0x7573ca75, 0x330fd7e1, 0x755fc635, | ||
428 | 0x333debab, 0x754bafdc, 0x336bf78f, 0x7537876c, | ||
429 | 0x3399fb85, 0x75234ce8, 0x33c7f785, 0x750f0054, | ||
430 | 0x33f5eb89, 0x74faa1b3, 0x3423d78a, 0x74e63108, | ||
431 | 0x3451bb81, 0x74d1ae55, 0x347f9766, 0x74bd199f, | ||
432 | 0x34ad6b32, 0x74a872e8, 0x34db36df, 0x7493ba34, | ||
433 | 0x3508fa66, 0x747eef85, 0x3536b5be, 0x746a12df, | ||
434 | 0x356468e2, 0x74552446, 0x359213c9, 0x744023bc, | ||
435 | 0x35bfb66e, 0x742b1144, 0x35ed50c9, 0x7415ece2, | ||
436 | 0x361ae2d3, 0x7400b69a, 0x36486c86, 0x73eb6e6e, | ||
437 | 0x3675edd9, 0x73d61461, 0x36a366c6, 0x73c0a878, | ||
438 | 0x36d0d746, 0x73ab2ab4, 0x36fe3f52, 0x73959b1b, | ||
439 | 0x372b9ee3, 0x737ff9ae, 0x3758f5f2, 0x736a4671, | ||
440 | 0x37864477, 0x73548168, 0x37b38a6d, 0x733eaa96, | ||
441 | 0x37e0c7cc, 0x7328c1ff, 0x380dfc8d, 0x7312c7a5, | ||
442 | 0x383b28a9, 0x72fcbb8c, 0x38684c19, 0x72e69db7, | ||
443 | 0x389566d6, 0x72d06e2b, 0x38c278d9, 0x72ba2cea, | ||
444 | 0x38ef821c, 0x72a3d9f7, 0x391c8297, 0x728d7557, | ||
445 | 0x39497a43, 0x7276ff0d, 0x39766919, 0x7260771b, | ||
446 | 0x39a34f13, 0x7249dd86, 0x39d02c2a, 0x72333251, | ||
447 | 0x39fd0056, 0x721c7580, 0x3a29cb91, 0x7205a716, | ||
448 | 0x3a568dd4, 0x71eec716, 0x3a834717, 0x71d7d585, | ||
449 | 0x3aaff755, 0x71c0d265, 0x3adc9e86, 0x71a9bdba, | ||
450 | 0x3b093ca3, 0x71929789, 0x3b35d1a5, 0x717b5fd3, | ||
451 | 0x3b625d86, 0x7164169d, 0x3b8ee03e, 0x714cbbeb, | ||
452 | 0x3bbb59c7, 0x71354fc0, 0x3be7ca1a, 0x711dd220, | ||
453 | 0x3c143130, 0x7106430e, 0x3c408f03, 0x70eea28e, | ||
454 | 0x3c6ce38a, 0x70d6f0a4, 0x3c992ec0, 0x70bf2d53, | ||
455 | 0x3cc5709e, 0x70a7589f, 0x3cf1a91c, 0x708f728b, | ||
456 | 0x3d1dd835, 0x70777b1c, 0x3d49fde1, 0x705f7255, | ||
457 | 0x3d761a19, 0x70475839, 0x3da22cd7, 0x702f2ccd, | ||
458 | 0x3dce3614, 0x7016f014, 0x3dfa35c8, 0x6ffea212, | ||
459 | 0x3e262bee, 0x6fe642ca, 0x3e52187f, 0x6fcdd241, | ||
460 | 0x3e7dfb73, 0x6fb5507a, 0x3ea9d4c3, 0x6f9cbd79, | ||
461 | 0x3ed5a46b, 0x6f841942, 0x3f016a61, 0x6f6b63d8, | ||
462 | 0x3f2d26a0, 0x6f529d40, 0x3f58d921, 0x6f39c57d, | ||
463 | 0x3f8481dd, 0x6f20dc92, 0x3fb020ce, 0x6f07e285, | ||
464 | 0x3fdbb5ec, 0x6eeed758, 0x40074132, 0x6ed5bb10, | ||
465 | 0x4032c297, 0x6ebc8db0, 0x405e3a16, 0x6ea34f3d, | ||
466 | 0x4089a7a8, 0x6e89ffb9, 0x40b50b46, 0x6e709f2a, | ||
467 | 0x40e064ea, 0x6e572d93, 0x410bb48c, 0x6e3daaf8, | ||
468 | 0x4136fa27, 0x6e24175c, 0x416235b2, 0x6e0a72c5, | ||
469 | 0x418d6729, 0x6df0bd35, 0x41b88e84, 0x6dd6f6b1, | ||
470 | 0x41e3abbc, 0x6dbd1f3c, 0x420ebecb, 0x6da336dc, | ||
471 | 0x4239c7aa, 0x6d893d93, 0x4264c653, 0x6d6f3365, | ||
472 | 0x428fbabe, 0x6d551858, 0x42baa4e6, 0x6d3aec6e, | ||
473 | 0x42e584c3, 0x6d20afac, 0x43105a50, 0x6d066215, | ||
474 | 0x433b2585, 0x6cec03af, 0x4365e65b, 0x6cd1947c, | ||
475 | 0x43909ccd, 0x6cb71482, 0x43bb48d4, 0x6c9c83c3, | ||
476 | 0x43e5ea68, 0x6c81e245, 0x44108184, 0x6c67300b, | ||
477 | 0x443b0e21, 0x6c4c6d1a, 0x44659039, 0x6c319975, | ||
478 | 0x449007c4, 0x6c16b521, 0x44ba74bd, 0x6bfbc021, | ||
479 | 0x44e4d71c, 0x6be0ba7b, 0x450f2edb, 0x6bc5a431, | ||
480 | 0x45397bf4, 0x6baa7d49, 0x4563be60, 0x6b8f45c7, | ||
481 | 0x458df619, 0x6b73fdae, 0x45b82318, 0x6b58a503, | ||
482 | 0x45e24556, 0x6b3d3bcb, 0x460c5cce, 0x6b21c208, | ||
483 | 0x46366978, 0x6b0637c1, 0x46606b4e, 0x6aea9cf8, | ||
484 | 0x468a624a, 0x6acef1b2, 0x46b44e65, 0x6ab335f4, | ||
485 | 0x46de2f99, 0x6a9769c1, 0x470805df, 0x6a7b8d1e, | ||
486 | 0x4731d131, 0x6a5fa010, 0x475b9188, 0x6a43a29a, | ||
487 | 0x478546de, 0x6a2794c1, 0x47aef12c, 0x6a0b7689, | ||
488 | 0x47d8906d, 0x69ef47f6, 0x48022499, 0x69d3090e, | ||
489 | 0x482badab, 0x69b6b9d3, 0x48552b9b, 0x699a5a4c, | ||
490 | 0x487e9e64, 0x697dea7b, 0x48a805ff, 0x69616a65, | ||
491 | 0x48d16265, 0x6944da10, 0x48fab391, 0x6928397e, | ||
492 | 0x4923f97b, 0x690b88b5, 0x494d341e, 0x68eec7b9, | ||
493 | 0x49766373, 0x68d1f68f, 0x499f8774, 0x68b5153a, | ||
494 | 0x49c8a01b, 0x689823bf, 0x49f1ad61, 0x687b2224, | ||
495 | 0x4a1aaf3f, 0x685e106c, 0x4a43a5b0, 0x6840ee9b, | ||
496 | 0x4a6c90ad, 0x6823bcb7, 0x4a957030, 0x68067ac3, | ||
497 | 0x4abe4433, 0x67e928c5, 0x4ae70caf, 0x67cbc6c0, | ||
498 | 0x4b0fc99d, 0x67ae54ba, 0x4b387af9, 0x6790d2b6, | ||
499 | 0x4b6120bb, 0x677340ba, 0x4b89badd, 0x67559eca, | ||
500 | 0x4bb24958, 0x6737ecea, 0x4bdacc28, 0x671a2b20, | ||
501 | 0x4c034345, 0x66fc596f, 0x4c2baea9, 0x66de77dc, | ||
502 | 0x4c540e4e, 0x66c0866d, 0x4c7c622d, 0x66a28524, | ||
503 | 0x4ca4aa41, 0x66847408, 0x4ccce684, 0x6666531d, | ||
504 | 0x4cf516ee, 0x66482267, 0x4d1d3b7a, 0x6629e1ec, | ||
505 | 0x4d455422, 0x660b91af, 0x4d6d60df, 0x65ed31b5, | ||
506 | 0x4d9561ac, 0x65cec204, 0x4dbd5682, 0x65b0429f, | ||
507 | 0x4de53f5a, 0x6591b38c, 0x4e0d1c30, 0x657314cf, | ||
508 | 0x4e34ecfc, 0x6554666d, 0x4e5cb1b9, 0x6535a86b, | ||
509 | 0x4e846a60, 0x6516dacd, 0x4eac16eb, 0x64f7fd98, | ||
510 | 0x4ed3b755, 0x64d910d1, 0x4efb4b96, 0x64ba147d, | ||
511 | 0x4f22d3aa, 0x649b08a0, 0x4f4a4f89, 0x647bed3f, | ||
512 | 0x4f71bf2e, 0x645cc260, 0x4f992293, 0x643d8806, | ||
513 | 0x4fc079b1, 0x641e3e38, 0x4fe7c483, 0x63fee4f8, | ||
514 | 0x500f0302, 0x63df7c4d, 0x50363529, 0x63c0043b, | ||
515 | 0x505d5af1, 0x63a07cc7, 0x50847454, 0x6380e5f6, | ||
516 | 0x50ab814d, 0x63613fcd, 0x50d281d5, 0x63418a50, | ||
517 | 0x50f975e6, 0x6321c585, 0x51205d7b, 0x6301f171, | ||
518 | 0x5147388c, 0x62e20e17, 0x516e0715, 0x62c21b7e, | ||
519 | 0x5194c910, 0x62a219aa, 0x51bb7e75, 0x628208a1, | ||
520 | 0x51e22740, 0x6261e866, 0x5208c36a, 0x6241b8ff, | ||
521 | 0x522f52ee, 0x62217a72, 0x5255d5c5, 0x62012cc2, | ||
522 | 0x527c4bea, 0x61e0cff5, 0x52a2b556, 0x61c06410, | ||
523 | 0x52c91204, 0x619fe918, 0x52ef61ee, 0x617f5f12, | ||
524 | 0x5315a50e, 0x615ec603, 0x533bdb5d, 0x613e1df0, | ||
525 | 0x536204d7, 0x611d66de, 0x53882175, 0x60fca0d2, | ||
526 | 0x53ae3131, 0x60dbcbd1, 0x53d43406, 0x60bae7e1, | ||
527 | 0x53fa29ed, 0x6099f505, 0x542012e1, 0x6078f344, | ||
528 | 0x5445eedb, 0x6057e2a2, 0x546bbdd7, 0x6036c325, | ||
529 | 0x54917fce, 0x601594d1, 0x54b734ba, 0x5ff457ad, | ||
530 | 0x54dcdc96, 0x5fd30bbc, 0x5502775c, 0x5fb1b104, | ||
531 | 0x55280505, 0x5f90478a, 0x554d858d, 0x5f6ecf53, | ||
532 | 0x5572f8ed, 0x5f4d4865, 0x55985f20, 0x5f2bb2c5, | ||
533 | 0x55bdb81f, 0x5f0a0e77, 0x55e303e6, 0x5ee85b82, | ||
534 | 0x5608426e, 0x5ec699e9, 0x562d73b2, 0x5ea4c9b3, | ||
535 | 0x565297ab, 0x5e82eae5, 0x5677ae54, 0x5e60fd84, | ||
536 | 0x569cb7a8, 0x5e3f0194, 0x56c1b3a1, 0x5e1cf71c, | ||
537 | 0x56e6a239, 0x5dfade20, 0x570b8369, 0x5dd8b6a7, | ||
538 | 0x5730572e, 0x5db680b4, 0x57551d80, 0x5d943c4e, | ||
539 | 0x5779d65b, 0x5d71e979, 0x579e81b8, 0x5d4f883b, | ||
540 | 0x57c31f92, 0x5d2d189a, 0x57e7afe4, 0x5d0a9a9a, | ||
541 | 0x580c32a7, 0x5ce80e41, 0x5830a7d6, 0x5cc57394, | ||
542 | 0x58550f6c, 0x5ca2ca99, 0x58796962, 0x5c801354, | ||
543 | 0x589db5b3, 0x5c5d4dcc, 0x58c1f45b, 0x5c3a7a05, | ||
544 | 0x58e62552, 0x5c179806, 0x590a4893, 0x5bf4a7d2, | ||
545 | 0x592e5e19, 0x5bd1a971, 0x595265df, 0x5bae9ce7, | ||
546 | 0x59765fde, 0x5b8b8239, 0x599a4c12, 0x5b68596d, | ||
547 | 0x59be2a74, 0x5b452288, 0x59e1faff, 0x5b21dd90, | ||
548 | 0x5a05bdae, 0x5afe8a8b, 0x5a29727b, 0x5adb297d, | ||
549 | 0x5a4d1960, 0x5ab7ba6c, 0x5a70b258, 0x5a943d5e, | ||
550 | }; | ||
551 | |||
552 | /*split radix bit reverse table for FFT of size up to 2048*/ | ||
553 | |||
554 | const uint16_t revtab[1<<12] = { | ||
555 | 0, 3072, 1536, 2816, 768, 3840, 1408, 2432, 384, 3456, 1920, 2752, 704, | ||
556 | 3776, 1216, 2240, 192, 3264, 1728, 3008, 960, 4032, 1376, 2400, 352, 3424, | ||
557 | 1888, 2656, 608, 3680, 1120, 2144, 96, 3168, 1632, 2912, 864, 3936, 1504, | ||
558 | 2528, 480, 3552, 2016, 2736, 688, 3760, 1200, 2224, 176, 3248, 1712, 2992, | ||
559 | 944, 4016, 1328, 2352, 304, 3376, 1840, 2608, 560, 3632, 1072, 2096, 48, | ||
560 | 3120, 1584, 2864, 816, 3888, 1456, 2480, 432, 3504, 1968, 2800, 752, 3824, | ||
561 | 1264, 2288, 240, 3312, 1776, 3056, 1008, 4080, 1368, 2392, 344, 3416, 1880, | ||
562 | 2648, 600, 3672, 1112, 2136, 88, 3160, 1624, 2904, 856, 3928, 1496, 2520, | ||
563 | 472, 3544, 2008, 2712, 664, 3736, 1176, 2200, 152, 3224, 1688, 2968, 920, | ||
564 | 3992, 1304, 2328, 280, 3352, 1816, 2584, 536, 3608, 1048, 2072, 24, 3096, | ||
565 | 1560, 2840, 792, 3864, 1432, 2456, 408, 3480, 1944, 2776, 728, 3800, 1240, | ||
566 | 2264, 216, 3288, 1752, 3032, 984, 4056, 1400, 2424, 376, 3448, 1912, 2680, | ||
567 | 632, 3704, 1144, 2168, 120, 3192, 1656, 2936, 888, 3960, 1528, 2552, 504, | ||
568 | 3576, 2040, 2732, 684, 3756, 1196, 2220, 172, 3244, 1708, 2988, 940, 4012, | ||
569 | 1324, 2348, 300, 3372, 1836, 2604, 556, 3628, 1068, 2092, 44, 3116, 1580, | ||
570 | 2860, 812, 3884, 1452, 2476, 428, 3500, 1964, 2796, 748, 3820, 1260, 2284, | ||
571 | 236, 3308, 1772, 3052, 1004, 4076, 1356, 2380, 332, 3404, 1868, 2636, 588, | ||
572 | 3660, 1100, 2124, 76, 3148, 1612, 2892, 844, 3916, 1484, 2508, 460, 3532, | ||
573 | 1996, 2700, 652, 3724, 1164, 2188, 140, 3212, 1676, 2956, 908, 3980, 1292, | ||
574 | 2316, 268, 3340, 1804, 2572, 524, 3596, 1036, 2060, 12, 3084, 1548, 2828, | ||
575 | 780, 3852, 1420, 2444, 396, 3468, 1932, 2764, 716, 3788, 1228, 2252, 204, | ||
576 | 3276, 1740, 3020, 972, 4044, 1388, 2412, 364, 3436, 1900, 2668, 620, 3692, | ||
577 | 1132, 2156, 108, 3180, 1644, 2924, 876, 3948, 1516, 2540, 492, 3564, 2028, | ||
578 | 2748, 700, 3772, 1212, 2236, 188, 3260, 1724, 3004, 956, 4028, 1340, 2364, | ||
579 | 316, 3388, 1852, 2620, 572, 3644, 1084, 2108, 60, 3132, 1596, 2876, 828, | ||
580 | 3900, 1468, 2492, 444, 3516, 1980, 2812, 764, 3836, 1276, 2300, 252, 3324, | ||
581 | 1788, 3068, 1020, 4092, 1366, 2390, 342, 3414, 1878, 2646, 598, 3670, 1110, | ||
582 | 2134, 86, 3158, 1622, 2902, 854, 3926, 1494, 2518, 470, 3542, 2006, 2710, | ||
583 | 662, 3734, 1174, 2198, 150, 3222, 1686, 2966, 918, 3990, 1302, 2326, 278, | ||
584 | 3350, 1814, 2582, 534, 3606, 1046, 2070, 22, 3094, 1558, 2838, 790, 3862, | ||
585 | 1430, 2454, 406, 3478, 1942, 2774, 726, 3798, 1238, 2262, 214, 3286, 1750, | ||
586 | 3030, 982, 4054, 1398, 2422, 374, 3446, 1910, 2678, 630, 3702, 1142, 2166, | ||
587 | 118, 3190, 1654, 2934, 886, 3958, 1526, 2550, 502, 3574, 2038, 2726, 678, | ||
588 | 3750, 1190, 2214, 166, 3238, 1702, 2982, 934, 4006, 1318, 2342, 294, 3366, | ||
589 | 1830, 2598, 550, 3622, 1062, 2086, 38, 3110, 1574, 2854, 806, 3878, 1446, | ||
590 | 2470, 422, 3494, 1958, 2790, 742, 3814, 1254, 2278, 230, 3302, 1766, 3046, | ||
591 | 998, 4070, 1350, 2374, 326, 3398, 1862, 2630, 582, 3654, 1094, 2118, 70, | ||
592 | 3142, 1606, 2886, 838, 3910, 1478, 2502, 454, 3526, 1990, 2694, 646, 3718, | ||
593 | 1158, 2182, 134, 3206, 1670, 2950, 902, 3974, 1286, 2310, 262, 3334, 1798, | ||
594 | 2566, 518, 3590, 1030, 2054, 6, 3078, 1542, 2822, 774, 3846, 1414, 2438, | ||
595 | 390, 3462, 1926, 2758, 710, 3782, 1222, 2246, 198, 3270, 1734, 3014, 966, | ||
596 | 4038, 1382, 2406, 358, 3430, 1894, 2662, 614, 3686, 1126, 2150, 102, 3174, | ||
597 | 1638, 2918, 870, 3942, 1510, 2534, 486, 3558, 2022, 2742, 694, 3766, 1206, | ||
598 | 2230, 182, 3254, 1718, 2998, 950, 4022, 1334, 2358, 310, 3382, 1846, 2614, | ||
599 | 566, 3638, 1078, 2102, 54, 3126, 1590, 2870, 822, 3894, 1462, 2486, 438, | ||
600 | 3510, 1974, 2806, 758, 3830, 1270, 2294, 246, 3318, 1782, 3062, 1014, 4086, | ||
601 | 1374, 2398, 350, 3422, 1886, 2654, 606, 3678, 1118, 2142, 94, 3166, 1630, | ||
602 | 2910, 862, 3934, 1502, 2526, 478, 3550, 2014, 2718, 670, 3742, 1182, 2206, | ||
603 | 158, 3230, 1694, 2974, 926, 3998, 1310, 2334, 286, 3358, 1822, 2590, 542, | ||
604 | 3614, 1054, 2078, 30, 3102, 1566, 2846, 798, 3870, 1438, 2462, 414, 3486, | ||
605 | 1950, 2782, 734, 3806, 1246, 2270, 222, 3294, 1758, 3038, 990, 4062, 1406, | ||
606 | 2430, 382, 3454, 1918, 2686, 638, 3710, 1150, 2174, 126, 3198, 1662, 2942, | ||
607 | 894, 3966, 1534, 2558, 510, 3582, 2046, 2731, 683, 3755, 1195, 2219, 171, | ||
608 | 3243, 1707, 2987, 939, 4011, 1323, 2347, 299, 3371, 1835, 2603, 555, 3627, | ||
609 | 1067, 2091, 43, 3115, 1579, 2859, 811, 3883, 1451, 2475, 427, 3499, 1963, | ||
610 | 2795, 747, 3819, 1259, 2283, 235, 3307, 1771, 3051, 1003, 4075, 1355, 2379, | ||
611 | 331, 3403, 1867, 2635, 587, 3659, 1099, 2123, 75, 3147, 1611, 2891, 843, | ||
612 | 3915, 1483, 2507, 459, 3531, 1995, 2699, 651, 3723, 1163, 2187, 139, 3211, | ||
613 | 1675, 2955, 907, 3979, 1291, 2315, 267, 3339, 1803, 2571, 523, 3595, 1035, | ||
614 | 2059, 11, 3083, 1547, 2827, 779, 3851, 1419, 2443, 395, 3467, 1931, 2763, | ||
615 | 715, 3787, 1227, 2251, 203, 3275, 1739, 3019, 971, 4043, 1387, 2411, 363, | ||
616 | 3435, 1899, 2667, 619, 3691, 1131, 2155, 107, 3179, 1643, 2923, 875, 3947, | ||
617 | 1515, 2539, 491, 3563, 2027, 2747, 699, 3771, 1211, 2235, 187, 3259, 1723, | ||
618 | 3003, 955, 4027, 1339, 2363, 315, 3387, 1851, 2619, 571, 3643, 1083, 2107, | ||
619 | 59, 3131, 1595, 2875, 827, 3899, 1467, 2491, 443, 3515, 1979, 2811, 763, | ||
620 | 3835, 1275, 2299, 251, 3323, 1787, 3067, 1019, 4091, 1363, 2387, 339, 3411, | ||
621 | 1875, 2643, 595, 3667, 1107, 2131, 83, 3155, 1619, 2899, 851, 3923, 1491, | ||
622 | 2515, 467, 3539, 2003, 2707, 659, 3731, 1171, 2195, 147, 3219, 1683, 2963, | ||
623 | 915, 3987, 1299, 2323, 275, 3347, 1811, 2579, 531, 3603, 1043, 2067, 19, | ||
624 | 3091, 1555, 2835, 787, 3859, 1427, 2451, 403, 3475, 1939, 2771, 723, 3795, | ||
625 | 1235, 2259, 211, 3283, 1747, 3027, 979, 4051, 1395, 2419, 371, 3443, 1907, | ||
626 | 2675, 627, 3699, 1139, 2163, 115, 3187, 1651, 2931, 883, 3955, 1523, 2547, | ||
627 | 499, 3571, 2035, 2723, 675, 3747, 1187, 2211, 163, 3235, 1699, 2979, 931, | ||
628 | 4003, 1315, 2339, 291, 3363, 1827, 2595, 547, 3619, 1059, 2083, 35, 3107, | ||
629 | 1571, 2851, 803, 3875, 1443, 2467, 419, 3491, 1955, 2787, 739, 3811, 1251, | ||
630 | 2275, 227, 3299, 1763, 3043, 995, 4067, 1347, 2371, 323, 3395, 1859, 2627, | ||
631 | 579, 3651, 1091, 2115, 67, 3139, 1603, 2883, 835, 3907, 1475, 2499, 451, | ||
632 | 3523, 1987, 2691, 643, 3715, 1155, 2179, 131, 3203, 1667, 2947, 899, 3971, | ||
633 | 1283, 2307, 259, 3331, 1795, 2563, 515, 3587, 1027, 2051, 3, 3075, 1539, | ||
634 | 2819, 771, 3843, 1411, 2435, 387, 3459, 1923, 2755, 707, 3779, 1219, 2243, | ||
635 | 195, 3267, 1731, 3011, 963, 4035, 1379, 2403, 355, 3427, 1891, 2659, 611, | ||
636 | 3683, 1123, 2147, 99, 3171, 1635, 2915, 867, 3939, 1507, 2531, 483, 3555, | ||
637 | 2019, 2739, 691, 3763, 1203, 2227, 179, 3251, 1715, 2995, 947, 4019, 1331, | ||
638 | 2355, 307, 3379, 1843, 2611, 563, 3635, 1075, 2099, 51, 3123, 1587, 2867, | ||
639 | 819, 3891, 1459, 2483, 435, 3507, 1971, 2803, 755, 3827, 1267, 2291, 243, | ||
640 | 3315, 1779, 3059, 1011, 4083, 1371, 2395, 347, 3419, 1883, 2651, 603, 3675, | ||
641 | 1115, 2139, 91, 3163, 1627, 2907, 859, 3931, 1499, 2523, 475, 3547, 2011, | ||
642 | 2715, 667, 3739, 1179, 2203, 155, 3227, 1691, 2971, 923, 3995, 1307, 2331, | ||
643 | 283, 3355, 1819, 2587, 539, 3611, 1051, 2075, 27, 3099, 1563, 2843, 795, | ||
644 | 3867, 1435, 2459, 411, 3483, 1947, 2779, 731, 3803, 1243, 2267, 219, 3291, | ||
645 | 1755, 3035, 987, 4059, 1403, 2427, 379, 3451, 1915, 2683, 635, 3707, 1147, | ||
646 | 2171, 123, 3195, 1659, 2939, 891, 3963, 1531, 2555, 507, 3579, 2043, 2735, | ||
647 | 687, 3759, 1199, 2223, 175, 3247, 1711, 2991, 943, 4015, 1327, 2351, 303, | ||
648 | 3375, 1839, 2607, 559, 3631, 1071, 2095, 47, 3119, 1583, 2863, 815, 3887, | ||
649 | 1455, 2479, 431, 3503, 1967, 2799, 751, 3823, 1263, 2287, 239, 3311, 1775, | ||
650 | 3055, 1007, 4079, 1359, 2383, 335, 3407, 1871, 2639, 591, 3663, 1103, 2127, | ||
651 | 79, 3151, 1615, 2895, 847, 3919, 1487, 2511, 463, 3535, 1999, 2703, 655, | ||
652 | 3727, 1167, 2191, 143, 3215, 1679, 2959, 911, 3983, 1295, 2319, 271, 3343, | ||
653 | 1807, 2575, 527, 3599, 1039, 2063, 15, 3087, 1551, 2831, 783, 3855, 1423, | ||
654 | 2447, 399, 3471, 1935, 2767, 719, 3791, 1231, 2255, 207, 3279, 1743, 3023, | ||
655 | 975, 4047, 1391, 2415, 367, 3439, 1903, 2671, 623, 3695, 1135, 2159, 111, | ||
656 | 3183, 1647, 2927, 879, 3951, 1519, 2543, 495, 3567, 2031, 2751, 703, 3775, | ||
657 | 1215, 2239, 191, 3263, 1727, 3007, 959, 4031, 1343, 2367, 319, 3391, 1855, | ||
658 | 2623, 575, 3647, 1087, 2111, 63, 3135, 1599, 2879, 831, 3903, 1471, 2495, | ||
659 | 447, 3519, 1983, 2815, 767, 3839, 1279, 2303, 255, 3327, 1791, 3071, 1023, | ||
660 | 4095, 1365, 2389, 341, 3413, 1877, 2645, 597, 3669, 1109, 2133, 85, 3157, | ||
661 | 1621, 2901, 853, 3925, 1493, 2517, 469, 3541, 2005, 2709, 661, 3733, 1173, | ||
662 | 2197, 149, 3221, 1685, 2965, 917, 3989, 1301, 2325, 277, 3349, 1813, 2581, | ||
663 | 533, 3605, 1045, 2069, 21, 3093, 1557, 2837, 789, 3861, 1429, 2453, 405, | ||
664 | 3477, 1941, 2773, 725, 3797, 1237, 2261, 213, 3285, 1749, 3029, 981, 4053, | ||
665 | 1397, 2421, 373, 3445, 1909, 2677, 629, 3701, 1141, 2165, 117, 3189, 1653, | ||
666 | 2933, 885, 3957, 1525, 2549, 501, 3573, 2037, 2725, 677, 3749, 1189, 2213, | ||
667 | 165, 3237, 1701, 2981, 933, 4005, 1317, 2341, 293, 3365, 1829, 2597, 549, | ||
668 | 3621, 1061, 2085, 37, 3109, 1573, 2853, 805, 3877, 1445, 2469, 421, 3493, | ||
669 | 1957, 2789, 741, 3813, 1253, 2277, 229, 3301, 1765, 3045, 997, 4069, 1349, | ||
670 | 2373, 325, 3397, 1861, 2629, 581, 3653, 1093, 2117, 69, 3141, 1605, 2885, | ||
671 | 837, 3909, 1477, 2501, 453, 3525, 1989, 2693, 645, 3717, 1157, 2181, 133, | ||
672 | 3205, 1669, 2949, 901, 3973, 1285, 2309, 261, 3333, 1797, 2565, 517, 3589, | ||
673 | 1029, 2053, 5, 3077, 1541, 2821, 773, 3845, 1413, 2437, 389, 3461, 1925, | ||
674 | 2757, 709, 3781, 1221, 2245, 197, 3269, 1733, 3013, 965, 4037, 1381, 2405, | ||
675 | 357, 3429, 1893, 2661, 613, 3685, 1125, 2149, 101, 3173, 1637, 2917, 869, | ||
676 | 3941, 1509, 2533, 485, 3557, 2021, 2741, 693, 3765, 1205, 2229, 181, 3253, | ||
677 | 1717, 2997, 949, 4021, 1333, 2357, 309, 3381, 1845, 2613, 565, 3637, 1077, | ||
678 | 2101, 53, 3125, 1589, 2869, 821, 3893, 1461, 2485, 437, 3509, 1973, 2805, | ||
679 | 757, 3829, 1269, 2293, 245, 3317, 1781, 3061, 1013, 4085, 1373, 2397, 349, | ||
680 | 3421, 1885, 2653, 605, 3677, 1117, 2141, 93, 3165, 1629, 2909, 861, 3933, | ||
681 | 1501, 2525, 477, 3549, 2013, 2717, 669, 3741, 1181, 2205, 157, 3229, 1693, | ||
682 | 2973, 925, 3997, 1309, 2333, 285, 3357, 1821, 2589, 541, 3613, 1053, 2077, | ||
683 | 29, 3101, 1565, 2845, 797, 3869, 1437, 2461, 413, 3485, 1949, 2781, 733, | ||
684 | 3805, 1245, 2269, 221, 3293, 1757, 3037, 989, 4061, 1405, 2429, 381, 3453, | ||
685 | 1917, 2685, 637, 3709, 1149, 2173, 125, 3197, 1661, 2941, 893, 3965, 1533, | ||
686 | 2557, 509, 3581, 2045, 2729, 681, 3753, 1193, 2217, 169, 3241, 1705, 2985, | ||
687 | 937, 4009, 1321, 2345, 297, 3369, 1833, 2601, 553, 3625, 1065, 2089, 41, | ||
688 | 3113, 1577, 2857, 809, 3881, 1449, 2473, 425, 3497, 1961, 2793, 745, 3817, | ||
689 | 1257, 2281, 233, 3305, 1769, 3049, 1001, 4073, 1353, 2377, 329, 3401, 1865, | ||
690 | 2633, 585, 3657, 1097, 2121, 73, 3145, 1609, 2889, 841, 3913, 1481, 2505, | ||
691 | 457, 3529, 1993, 2697, 649, 3721, 1161, 2185, 137, 3209, 1673, 2953, 905, | ||
692 | 3977, 1289, 2313, 265, 3337, 1801, 2569, 521, 3593, 1033, 2057, 9, 3081, | ||
693 | 1545, 2825, 777, 3849, 1417, 2441, 393, 3465, 1929, 2761, 713, 3785, 1225, | ||
694 | 2249, 201, 3273, 1737, 3017, 969, 4041, 1385, 2409, 361, 3433, 1897, 2665, | ||
695 | 617, 3689, 1129, 2153, 105, 3177, 1641, 2921, 873, 3945, 1513, 2537, 489, | ||
696 | 3561, 2025, 2745, 697, 3769, 1209, 2233, 185, 3257, 1721, 3001, 953, 4025, | ||
697 | 1337, 2361, 313, 3385, 1849, 2617, 569, 3641, 1081, 2105, 57, 3129, 1593, | ||
698 | 2873, 825, 3897, 1465, 2489, 441, 3513, 1977, 2809, 761, 3833, 1273, 2297, | ||
699 | 249, 3321, 1785, 3065, 1017, 4089, 1361, 2385, 337, 3409, 1873, 2641, 593, | ||
700 | 3665, 1105, 2129, 81, 3153, 1617, 2897, 849, 3921, 1489, 2513, 465, 3537, | ||
701 | 2001, 2705, 657, 3729, 1169, 2193, 145, 3217, 1681, 2961, 913, 3985, 1297, | ||
702 | 2321, 273, 3345, 1809, 2577, 529, 3601, 1041, 2065, 17, 3089, 1553, 2833, | ||
703 | 785, 3857, 1425, 2449, 401, 3473, 1937, 2769, 721, 3793, 1233, 2257, 209, | ||
704 | 3281, 1745, 3025, 977, 4049, 1393, 2417, 369, 3441, 1905, 2673, 625, 3697, | ||
705 | 1137, 2161, 113, 3185, 1649, 2929, 881, 3953, 1521, 2545, 497, 3569, 2033, | ||
706 | 2721, 673, 3745, 1185, 2209, 161, 3233, 1697, 2977, 929, 4001, 1313, 2337, | ||
707 | 289, 3361, 1825, 2593, 545, 3617, 1057, 2081, 33, 3105, 1569, 2849, 801, | ||
708 | 3873, 1441, 2465, 417, 3489, 1953, 2785, 737, 3809, 1249, 2273, 225, 3297, | ||
709 | 1761, 3041, 993, 4065, 1345, 2369, 321, 3393, 1857, 2625, 577, 3649, 1089, | ||
710 | 2113, 65, 3137, 1601, 2881, 833, 3905, 1473, 2497, 449, 3521, 1985, 2689, | ||
711 | 641, 3713, 1153, 2177, 129, 3201, 1665, 2945, 897, 3969, 1281, 2305, 257, | ||
712 | 3329, 1793, 2561, 513, 3585, 1025, 2049, 1, 3073, 1537, 2817, 769, 3841, | ||
713 | 1409, 2433, 385, 3457, 1921, 2753, 705, 3777, 1217, 2241, 193, 3265, 1729, | ||
714 | 3009, 961, 4033, 1377, 2401, 353, 3425, 1889, 2657, 609, 3681, 1121, 2145, | ||
715 | 97, 3169, 1633, 2913, 865, 3937, 1505, 2529, 481, 3553, 2017, 2737, 689, | ||
716 | 3761, 1201, 2225, 177, 3249, 1713, 2993, 945, 4017, 1329, 2353, 305, 3377, | ||
717 | 1841, 2609, 561, 3633, 1073, 2097, 49, 3121, 1585, 2865, 817, 3889, 1457, | ||
718 | 2481, 433, 3505, 1969, 2801, 753, 3825, 1265, 2289, 241, 3313, 1777, 3057, | ||
719 | 1009, 4081, 1369, 2393, 345, 3417, 1881, 2649, 601, 3673, 1113, 2137, 89, | ||
720 | 3161, 1625, 2905, 857, 3929, 1497, 2521, 473, 3545, 2009, 2713, 665, 3737, | ||
721 | 1177, 2201, 153, 3225, 1689, 2969, 921, 3993, 1305, 2329, 281, 3353, 1817, | ||
722 | 2585, 537, 3609, 1049, 2073, 25, 3097, 1561, 2841, 793, 3865, 1433, 2457, | ||
723 | 409, 3481, 1945, 2777, 729, 3801, 1241, 2265, 217, 3289, 1753, 3033, 985, | ||
724 | 4057, 1401, 2425, 377, 3449, 1913, 2681, 633, 3705, 1145, 2169, 121, 3193, | ||
725 | 1657, 2937, 889, 3961, 1529, 2553, 505, 3577, 2041, 2733, 685, 3757, 1197, | ||
726 | 2221, 173, 3245, 1709, 2989, 941, 4013, 1325, 2349, 301, 3373, 1837, 2605, | ||
727 | 557, 3629, 1069, 2093, 45, 3117, 1581, 2861, 813, 3885, 1453, 2477, 429, | ||
728 | 3501, 1965, 2797, 749, 3821, 1261, 2285, 237, 3309, 1773, 3053, 1005, 4077, | ||
729 | 1357, 2381, 333, 3405, 1869, 2637, 589, 3661, 1101, 2125, 77, 3149, 1613, | ||
730 | 2893, 845, 3917, 1485, 2509, 461, 3533, 1997, 2701, 653, 3725, 1165, 2189, | ||
731 | 141, 3213, 1677, 2957, 909, 3981, 1293, 2317, 269, 3341, 1805, 2573, 525, | ||
732 | 3597, 1037, 2061, 13, 3085, 1549, 2829, 781, 3853, 1421, 2445, 397, 3469, | ||
733 | 1933, 2765, 717, 3789, 1229, 2253, 205, 3277, 1741, 3021, 973, 4045, 1389, | ||
734 | 2413, 365, 3437, 1901, 2669, 621, 3693, 1133, 2157, 109, 3181, 1645, 2925, | ||
735 | 877, 3949, 1517, 2541, 493, 3565, 2029, 2749, 701, 3773, 1213, 2237, 189, | ||
736 | 3261, 1725, 3005, 957, 4029, 1341, 2365, 317, 3389, 1853, 2621, 573, 3645, | ||
737 | 1085, 2109, 61, 3133, 1597, 2877, 829, 3901, 1469, 2493, 445, 3517, 1981, | ||
738 | 2813, 765, 3837, 1277, 2301, 253, 3325, 1789, 3069, 1021, 4093, 1367, 2391, | ||
739 | 343, 3415, 1879, 2647, 599, 3671, 1111, 2135, 87, 3159, 1623, 2903, 855, | ||
740 | 3927, 1495, 2519, 471, 3543, 2007, 2711, 663, 3735, 1175, 2199, 151, 3223, | ||
741 | 1687, 2967, 919, 3991, 1303, 2327, 279, 3351, 1815, 2583, 535, 3607, 1047, | ||
742 | 2071, 23, 3095, 1559, 2839, 791, 3863, 1431, 2455, 407, 3479, 1943, 2775, | ||
743 | 727, 3799, 1239, 2263, 215, 3287, 1751, 3031, 983, 4055, 1399, 2423, 375, | ||
744 | 3447, 1911, 2679, 631, 3703, 1143, 2167, 119, 3191, 1655, 2935, 887, 3959, | ||
745 | 1527, 2551, 503, 3575, 2039, 2727, 679, 3751, 1191, 2215, 167, 3239, 1703, | ||
746 | 2983, 935, 4007, 1319, 2343, 295, 3367, 1831, 2599, 551, 3623, 1063, 2087, | ||
747 | 39, 3111, 1575, 2855, 807, 3879, 1447, 2471, 423, 3495, 1959, 2791, 743, | ||
748 | 3815, 1255, 2279, 231, 3303, 1767, 3047, 999, 4071, 1351, 2375, 327, 3399, | ||
749 | 1863, 2631, 583, 3655, 1095, 2119, 71, 3143, 1607, 2887, 839, 3911, 1479, | ||
750 | 2503, 455, 3527, 1991, 2695, 647, 3719, 1159, 2183, 135, 3207, 1671, 2951, | ||
751 | 903, 3975, 1287, 2311, 263, 3335, 1799, 2567, 519, 3591, 1031, 2055, 7, | ||
752 | 3079, 1543, 2823, 775, 3847, 1415, 2439, 391, 3463, 1927, 2759, 711, 3783, | ||
753 | 1223, 2247, 199, 3271, 1735, 3015, 967, 4039, 1383, 2407, 359, 3431, 1895, | ||
754 | 2663, 615, 3687, 1127, 2151, 103, 3175, 1639, 2919, 871, 3943, 1511, 2535, | ||
755 | 487, 3559, 2023, 2743, 695, 3767, 1207, 2231, 183, 3255, 1719, 2999, 951, | ||
756 | 4023, 1335, 2359, 311, 3383, 1847, 2615, 567, 3639, 1079, 2103, 55, 3127, | ||
757 | 1591, 2871, 823, 3895, 1463, 2487, 439, 3511, 1975, 2807, 759, 3831, 1271, | ||
758 | 2295, 247, 3319, 1783, 3063, 1015, 4087, 1375, 2399, 351, 3423, 1887, 2655, | ||
759 | 607, 3679, 1119, 2143, 95, 3167, 1631, 2911, 863, 3935, 1503, 2527, 479, | ||
760 | 3551, 2015, 2719, 671, 3743, 1183, 2207, 159, 3231, 1695, 2975, 927, 3999, | ||
761 | 1311, 2335, 287, 3359, 1823, 2591, 543, 3615, 1055, 2079, 31, 3103, 1567, | ||
762 | 2847, 799, 3871, 1439, 2463, 415, 3487, 1951, 2783, 735, 3807, 1247, 2271, | ||
763 | 223, 3295, 1759, 3039, 991, 4063, 1407, 2431, 383, 3455, 1919, 2687, 639, | ||
764 | 3711, 1151, 2175, 127, 3199, 1663, 2943, 895, 3967, 1535, 2559, 511, 3583, | ||
765 | 2047, 2730, 682, 3754, 1194, 2218, 170, 3242, 1706, 2986, 938, 4010, 1322, | ||
766 | 2346, 298, 3370, 1834, 2602, 554, 3626, 1066, 2090, 42, 3114, 1578, 2858, | ||
767 | 810, 3882, 1450, 2474, 426, 3498, 1962, 2794, 746, 3818, 1258, 2282, 234, | ||
768 | 3306, 1770, 3050, 1002, 4074, 1354, 2378, 330, 3402, 1866, 2634, 586, 3658, | ||
769 | 1098, 2122, 74, 3146, 1610, 2890, 842, 3914, 1482, 2506, 458, 3530, 1994, | ||
770 | 2698, 650, 3722, 1162, 2186, 138, 3210, 1674, 2954, 906, 3978, 1290, 2314, | ||
771 | 266, 3338, 1802, 2570, 522, 3594, 1034, 2058, 10, 3082, 1546, 2826, 778, | ||
772 | 3850, 1418, 2442, 394, 3466, 1930, 2762, 714, 3786, 1226, 2250, 202, 3274, | ||
773 | 1738, 3018, 970, 4042, 1386, 2410, 362, 3434, 1898, 2666, 618, 3690, 1130, | ||
774 | 2154, 106, 3178, 1642, 2922, 874, 3946, 1514, 2538, 490, 3562, 2026, 2746, | ||
775 | 698, 3770, 1210, 2234, 186, 3258, 1722, 3002, 954, 4026, 1338, 2362, 314, | ||
776 | 3386, 1850, 2618, 570, 3642, 1082, 2106, 58, 3130, 1594, 2874, 826, 3898, | ||
777 | 1466, 2490, 442, 3514, 1978, 2810, 762, 3834, 1274, 2298, 250, 3322, 1786, | ||
778 | 3066, 1018, 4090, 1362, 2386, 338, 3410, 1874, 2642, 594, 3666, 1106, 2130, | ||
779 | 82, 3154, 1618, 2898, 850, 3922, 1490, 2514, 466, 3538, 2002, 2706, 658, | ||
780 | 3730, 1170, 2194, 146, 3218, 1682, 2962, 914, 3986, 1298, 2322, 274, 3346, | ||
781 | 1810, 2578, 530, 3602, 1042, 2066, 18, 3090, 1554, 2834, 786, 3858, 1426, | ||
782 | 2450, 402, 3474, 1938, 2770, 722, 3794, 1234, 2258, 210, 3282, 1746, 3026, | ||
783 | 978, 4050, 1394, 2418, 370, 3442, 1906, 2674, 626, 3698, 1138, 2162, 114, | ||
784 | 3186, 1650, 2930, 882, 3954, 1522, 2546, 498, 3570, 2034, 2722, 674, 3746, | ||
785 | 1186, 2210, 162, 3234, 1698, 2978, 930, 4002, 1314, 2338, 290, 3362, 1826, | ||
786 | 2594, 546, 3618, 1058, 2082, 34, 3106, 1570, 2850, 802, 3874, 1442, 2466, | ||
787 | 418, 3490, 1954, 2786, 738, 3810, 1250, 2274, 226, 3298, 1762, 3042, 994, | ||
788 | 4066, 1346, 2370, 322, 3394, 1858, 2626, 578, 3650, 1090, 2114, 66, 3138, | ||
789 | 1602, 2882, 834, 3906, 1474, 2498, 450, 3522, 1986, 2690, 642, 3714, 1154, | ||
790 | 2178, 130, 3202, 1666, 2946, 898, 3970, 1282, 2306, 258, 3330, 1794, 2562, | ||
791 | 514, 3586, 1026, 2050, 2, 3074, 1538, 2818, 770, 3842, 1410, 2434, 386, | ||
792 | 3458, 1922, 2754, 706, 3778, 1218, 2242, 194, 3266, 1730, 3010, 962, 4034, | ||
793 | 1378, 2402, 354, 3426, 1890, 2658, 610, 3682, 1122, 2146, 98, 3170, 1634, | ||
794 | 2914, 866, 3938, 1506, 2530, 482, 3554, 2018, 2738, 690, 3762, 1202, 2226, | ||
795 | 178, 3250, 1714, 2994, 946, 4018, 1330, 2354, 306, 3378, 1842, 2610, 562, | ||
796 | 3634, 1074, 2098, 50, 3122, 1586, 2866, 818, 3890, 1458, 2482, 434, 3506, | ||
797 | 1970, 2802, 754, 3826, 1266, 2290, 242, 3314, 1778, 3058, 1010, 4082, 1370, | ||
798 | 2394, 346, 3418, 1882, 2650, 602, 3674, 1114, 2138, 90, 3162, 1626, 2906, | ||
799 | 858, 3930, 1498, 2522, 474, 3546, 2010, 2714, 666, 3738, 1178, 2202, 154, | ||
800 | 3226, 1690, 2970, 922, 3994, 1306, 2330, 282, 3354, 1818, 2586, 538, 3610, | ||
801 | 1050, 2074, 26, 3098, 1562, 2842, 794, 3866, 1434, 2458, 410, 3482, 1946, | ||
802 | 2778, 730, 3802, 1242, 2266, 218, 3290, 1754, 3034, 986, 4058, 1402, 2426, | ||
803 | 378, 3450, 1914, 2682, 634, 3706, 1146, 2170, 122, 3194, 1658, 2938, 890, | ||
804 | 3962, 1530, 2554, 506, 3578, 2042, 2734, 686, 3758, 1198, 2222, 174, 3246, | ||
805 | 1710, 2990, 942, 4014, 1326, 2350, 302, 3374, 1838, 2606, 558, 3630, 1070, | ||
806 | 2094, 46, 3118, 1582, 2862, 814, 3886, 1454, 2478, 430, 3502, 1966, 2798, | ||
807 | 750, 3822, 1262, 2286, 238, 3310, 1774, 3054, 1006, 4078, 1358, 2382, 334, | ||
808 | 3406, 1870, 2638, 590, 3662, 1102, 2126, 78, 3150, 1614, 2894, 846, 3918, | ||
809 | 1486, 2510, 462, 3534, 1998, 2702, 654, 3726, 1166, 2190, 142, 3214, 1678, | ||
810 | 2958, 910, 3982, 1294, 2318, 270, 3342, 1806, 2574, 526, 3598, 1038, 2062, | ||
811 | 14, 3086, 1550, 2830, 782, 3854, 1422, 2446, 398, 3470, 1934, 2766, 718, | ||
812 | 3790, 1230, 2254, 206, 3278, 1742, 3022, 974, 4046, 1390, 2414, 366, 3438, | ||
813 | 1902, 2670, 622, 3694, 1134, 2158, 110, 3182, 1646, 2926, 878, 3950, 1518, | ||
814 | 2542, 494, 3566, 2030, 2750, 702, 3774, 1214, 2238, 190, 3262, 1726, 3006, | ||
815 | 958, 4030, 1342, 2366, 318, 3390, 1854, 2622, 574, 3646, 1086, 2110, 62, | ||
816 | 3134, 1598, 2878, 830, 3902, 1470, 2494, 446, 3518, 1982, 2814, 766, 3838, | ||
817 | 1278, 2302, 254, 3326, 1790, 3070, 1022, 4094, 1364, 2388, 340, 3412, 1876, | ||
818 | 2644, 596, 3668, 1108, 2132, 84, 3156, 1620, 2900, 852, 3924, 1492, 2516, | ||
819 | 468, 3540, 2004, 2708, 660, 3732, 1172, 2196, 148, 3220, 1684, 2964, 916, | ||
820 | 3988, 1300, 2324, 276, 3348, 1812, 2580, 532, 3604, 1044, 2068, 20, 3092, | ||
821 | 1556, 2836, 788, 3860, 1428, 2452, 404, 3476, 1940, 2772, 724, 3796, 1236, | ||
822 | 2260, 212, 3284, 1748, 3028, 980, 4052, 1396, 2420, 372, 3444, 1908, 2676, | ||
823 | 628, 3700, 1140, 2164, 116, 3188, 1652, 2932, 884, 3956, 1524, 2548, 500, | ||
824 | 3572, 2036, 2724, 676, 3748, 1188, 2212, 164, 3236, 1700, 2980, 932, 4004, | ||
825 | 1316, 2340, 292, 3364, 1828, 2596, 548, 3620, 1060, 2084, 36, 3108, 1572, | ||
826 | 2852, 804, 3876, 1444, 2468, 420, 3492, 1956, 2788, 740, 3812, 1252, 2276, | ||
827 | 228, 3300, 1764, 3044, 996, 4068, 1348, 2372, 324, 3396, 1860, 2628, 580, | ||
828 | 3652, 1092, 2116, 68, 3140, 1604, 2884, 836, 3908, 1476, 2500, 452, 3524, | ||
829 | 1988, 2692, 644, 3716, 1156, 2180, 132, 3204, 1668, 2948, 900, 3972, 1284, | ||
830 | 2308, 260, 3332, 1796, 2564, 516, 3588, 1028, 2052, 4, 3076, 1540, 2820, | ||
831 | 772, 3844, 1412, 2436, 388, 3460, 1924, 2756, 708, 3780, 1220, 2244, 196, | ||
832 | 3268, 1732, 3012, 964, 4036, 1380, 2404, 356, 3428, 1892, 2660, 612, 3684, | ||
833 | 1124, 2148, 100, 3172, 1636, 2916, 868, 3940, 1508, 2532, 484, 3556, 2020, | ||
834 | 2740, 692, 3764, 1204, 2228, 180, 3252, 1716, 2996, 948, 4020, 1332, 2356, | ||
835 | 308, 3380, 1844, 2612, 564, 3636, 1076, 2100, 52, 3124, 1588, 2868, 820, | ||
836 | 3892, 1460, 2484, 436, 3508, 1972, 2804, 756, 3828, 1268, 2292, 244, 3316, | ||
837 | 1780, 3060, 1012, 4084, 1372, 2396, 348, 3420, 1884, 2652, 604, 3676, 1116, | ||
838 | 2140, 92, 3164, 1628, 2908, 860, 3932, 1500, 2524, 476, 3548, 2012, 2716, | ||
839 | 668, 3740, 1180, 2204, 156, 3228, 1692, 2972, 924, 3996, 1308, 2332, 284, | ||
840 | 3356, 1820, 2588, 540, 3612, 1052, 2076, 28, 3100, 1564, 2844, 796, 3868, | ||
841 | 1436, 2460, 412, 3484, 1948, 2780, 732, 3804, 1244, 2268, 220, 3292, 1756, | ||
842 | 3036, 988, 4060, 1404, 2428, 380, 3452, 1916, 2684, 636, 3708, 1148, 2172, | ||
843 | 124, 3196, 1660, 2940, 892, 3964, 1532, 2556, 508, 3580, 2044, 2728, 680, | ||
844 | 3752, 1192, 2216, 168, 3240, 1704, 2984, 936, 4008, 1320, 2344, 296, 3368, | ||
845 | 1832, 2600, 552, 3624, 1064, 2088, 40, 3112, 1576, 2856, 808, 3880, 1448, | ||
846 | 2472, 424, 3496, 1960, 2792, 744, 3816, 1256, 2280, 232, 3304, 1768, 3048, | ||
847 | 1000, 4072, 1352, 2376, 328, 3400, 1864, 2632, 584, 3656, 1096, 2120, 72, | ||
848 | 3144, 1608, 2888, 840, 3912, 1480, 2504, 456, 3528, 1992, 2696, 648, 3720, | ||
849 | 1160, 2184, 136, 3208, 1672, 2952, 904, 3976, 1288, 2312, 264, 3336, 1800, | ||
850 | 2568, 520, 3592, 1032, 2056, 8, 3080, 1544, 2824, 776, 3848, 1416, 2440, | ||
851 | 392, 3464, 1928, 2760, 712, 3784, 1224, 2248, 200, 3272, 1736, 3016, 968, | ||
852 | 4040, 1384, 2408, 360, 3432, 1896, 2664, 616, 3688, 1128, 2152, 104, 3176, | ||
853 | 1640, 2920, 872, 3944, 1512, 2536, 488, 3560, 2024, 2744, 696, 3768, 1208, | ||
854 | 2232, 184, 3256, 1720, 3000, 952, 4024, 1336, 2360, 312, 3384, 1848, 2616, | ||
855 | 568, 3640, 1080, 2104, 56, 3128, 1592, 2872, 824, 3896, 1464, 2488, 440, | ||
856 | 3512, 1976, 2808, 760, 3832, 1272, 2296, 248, 3320, 1784, 3064, 1016, 4088, | ||
857 | 1360, 2384, 336, 3408, 1872, 2640, 592, 3664, 1104, 2128, 80, 3152, 1616, | ||
858 | 2896, 848, 3920, 1488, 2512, 464, 3536, 2000, 2704, 656, 3728, 1168, 2192, | ||
859 | 144, 3216, 1680, 2960, 912, 3984, 1296, 2320, 272, 3344, 1808, 2576, 528, | ||
860 | 3600, 1040, 2064, 16, 3088, 1552, 2832, 784, 3856, 1424, 2448, 400, 3472, | ||
861 | 1936, 2768, 720, 3792, 1232, 2256, 208, 3280, 1744, 3024, 976, 4048, 1392, | ||
862 | 2416, 368, 3440, 1904, 2672, 624, 3696, 1136, 2160, 112, 3184, 1648, 2928, | ||
863 | 880, 3952, 1520, 2544, 496, 3568, 2032, 2720, 672, 3744, 1184, 2208, 160, | ||
864 | 3232, 1696, 2976, 928, 4000, 1312, 2336, 288, 3360, 1824, 2592, 544, 3616, | ||
865 | 1056, 2080, 32, 3104, 1568, 2848, 800, 3872, 1440, 2464, 416, 3488, 1952, | ||
866 | 2784, 736, 3808, 1248, 2272, 224, 3296, 1760, 3040, 992, 4064, 1344, 2368, | ||
867 | 320, 3392, 1856, 2624, 576, 3648, 1088, 2112, 64, 3136, 1600, 2880, 832, | ||
868 | 3904, 1472, 2496, 448, 3520, 1984, 2688, 640, 3712, 1152, 2176, 128, 3200, | ||
869 | 1664, 2944, 896, 3968, 1280, 2304, 256, 3328, 1792, 2560, 512, 3584, 1024, | ||
870 | 2048}; | ||
871 | |||
872 | |||
diff --git a/apps/codecs/lib/mdct_lookup.h b/apps/codecs/lib/mdct_lookup.h deleted file mode 100644 index 909b95ddbb..0000000000 --- a/apps/codecs/lib/mdct_lookup.h +++ /dev/null | |||
@@ -1,24 +0,0 @@ | |||
1 | /******************************************************************** | ||
2 | * * | ||
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | ||
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | ||
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | ||
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | ||
8 | * * | ||
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * | ||
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | ||
11 | * * | ||
12 | ******************************************************************** | ||
13 | |||
14 | function: sin,cos lookup tables | ||
15 | |||
16 | ********************************************************************/ | ||
17 | |||
18 | |||
19 | extern const int32_t sincos_lookup0[1026]; | ||
20 | extern const int32_t sincos_lookup1[1024]; | ||
21 | extern const uint16_t revtab[1<<12]; | ||
22 | |||
23 | |||
24 | |||
diff --git a/apps/codecs/lib/osx.dummy.c b/apps/codecs/lib/osx.dummy.c deleted file mode 100644 index e69de29bb2..0000000000 --- a/apps/codecs/lib/osx.dummy.c +++ /dev/null | |||