1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program 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
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 **
19 ** Any non-GPL usage of this software or parts of this software is strictly
20 ** forbidden.
21 **
22 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
24 **
25 ** Commercial non-GPL licensing of this software is possible.
26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27 **
28 ** $Id: fixed.h,v 1.32 2007/11/01 12:33:30 menno Exp $
29 **/
30
31 #ifndef __FIXED_H__
32 #define __FIXED_H__
33
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37
38 #if defined(_WIN32_WCE) && defined(_ARM_)
39 #include <cmnintrin.h>
40 #endif
41
42
43 #define COEF_BITS 28
44 #define COEF_PRECISION (1 << COEF_BITS)
45 #define REAL_BITS 14 // MAXIMUM OF 14 FOR FIXED POINT SBR
46 #define REAL_PRECISION (1 << REAL_BITS)
47
48 /* FRAC is the fractional only part of the fixed point number [0.0..1.0) */
49 #define FRAC_SIZE 32 /* frac is a 32 bit integer */
50 #define FRAC_BITS 31
51 #define FRAC_PRECISION ((uint32_t)(1 << FRAC_BITS))
52 #define FRAC_MAX 0x7FFFFFFF
53
54 typedef int32_t real_t;
55
56
57 #define REAL_CONST(A) (((A) >= 0) ? ((real_t)((A)*(REAL_PRECISION)+0.5)) : ((real_t)((A)*(REAL_PRECISION)-0.5)))
58 #define COEF_CONST(A) (((A) >= 0) ? ((real_t)((A)*(COEF_PRECISION)+0.5)) : ((real_t)((A)*(COEF_PRECISION)-0.5)))
59 #define FRAC_CONST(A) (((A) == 1.00) ? ((real_t)FRAC_MAX) : (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5))))
60 //#define FRAC_CONST(A) (((A) >= 0) ? ((real_t)((A)*(FRAC_PRECISION)+0.5)) : ((real_t)((A)*(FRAC_PRECISION)-0.5)))
61
62 #define Q2_BITS 22
63 #define Q2_PRECISION (1 << Q2_BITS)
64 #define Q2_CONST(A) (((A) >= 0) ? ((real_t)((A)*(Q2_PRECISION)+0.5)) : ((real_t)((A)*(Q2_PRECISION)-0.5)))
65
66 #if defined(_WIN32) && !defined(_WIN32_WCE)
67
68 /* multiply with real shift */
MUL_R(real_t A,real_t B)69 static INLINE real_t MUL_R(real_t A, real_t B)
70 {
71 _asm {
72 mov eax,A
73 imul B
74 shrd eax,edx,REAL_BITS
75 }
76 }
77
78 /* multiply with coef shift */
MUL_C(real_t A,real_t B)79 static INLINE real_t MUL_C(real_t A, real_t B)
80 {
81 _asm {
82 mov eax,A
83 imul B
84 shrd eax,edx,COEF_BITS
85 }
86 }
87
MUL_Q2(real_t A,real_t B)88 static INLINE real_t MUL_Q2(real_t A, real_t B)
89 {
90 _asm {
91 mov eax,A
92 imul B
93 shrd eax,edx,Q2_BITS
94 }
95 }
96
MUL_SHIFT6(real_t A,real_t B)97 static INLINE real_t MUL_SHIFT6(real_t A, real_t B)
98 {
99 _asm {
100 mov eax,A
101 imul B
102 shrd eax,edx,6
103 }
104 }
105
MUL_SHIFT23(real_t A,real_t B)106 static INLINE real_t MUL_SHIFT23(real_t A, real_t B)
107 {
108 _asm {
109 mov eax,A
110 imul B
111 shrd eax,edx,23
112 }
113 }
114
115 #if 1
_MulHigh(real_t A,real_t B)116 static INLINE real_t _MulHigh(real_t A, real_t B)
117 {
118 _asm {
119 mov eax,A
120 imul B
121 mov eax,edx
122 }
123 }
124
125 /* multiply with fractional shift */
MUL_F(real_t A,real_t B)126 static INLINE real_t MUL_F(real_t A, real_t B)
127 {
128 return _MulHigh(A,B) << (FRAC_SIZE-FRAC_BITS);
129 }
130
131 /* Complex multiplication */
ComplexMult(real_t * y1,real_t * y2,real_t x1,real_t x2,real_t c1,real_t c2)132 static INLINE void ComplexMult(real_t *y1, real_t *y2,
133 real_t x1, real_t x2, real_t c1, real_t c2)
134 {
135 *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2))<<(FRAC_SIZE-FRAC_BITS);
136 *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2))<<(FRAC_SIZE-FRAC_BITS);
137 }
138 #else
MUL_F(real_t A,real_t B)139 static INLINE real_t MUL_F(real_t A, real_t B)
140 {
141 _asm {
142 mov eax,A
143 imul B
144 shrd eax,edx,FRAC_BITS
145 }
146 }
147
148 /* Complex multiplication */
ComplexMult(real_t * y1,real_t * y2,real_t x1,real_t x2,real_t c1,real_t c2)149 static INLINE void ComplexMult(real_t *y1, real_t *y2,
150 real_t x1, real_t x2, real_t c1, real_t c2)
151 {
152 *y1 = MUL_F(x1, c1) + MUL_F(x2, c2);
153 *y2 = MUL_F(x2, c1) - MUL_F(x1, c2);
154 }
155 #endif
156
157 #elif defined(__GNUC__) && defined (__arm__)
158
159 /* taken from MAD */
160 #define arm_mul(x, y, SCALEBITS) \
161 ({ \
162 uint32_t __hi; \
163 uint32_t __lo; \
164 uint32_t __result; \
165 asm("smull %0, %1, %3, %4\n\t" \
166 "movs %0, %0, lsr %5\n\t" \
167 "adc %2, %0, %1, lsl %6" \
168 : "=&r" (__lo), "=&r" (__hi), "=r" (__result) \
169 : "%r" (x), "r" (y), \
170 "M" (SCALEBITS), "M" (32 - (SCALEBITS)) \
171 : "cc"); \
172 __result; \
173 })
174
MUL_R(real_t A,real_t B)175 static INLINE real_t MUL_R(real_t A, real_t B)
176 {
177 return arm_mul(A, B, REAL_BITS);
178 }
179
MUL_C(real_t A,real_t B)180 static INLINE real_t MUL_C(real_t A, real_t B)
181 {
182 return arm_mul(A, B, COEF_BITS);
183 }
184
MUL_Q2(real_t A,real_t B)185 static INLINE real_t MUL_Q2(real_t A, real_t B)
186 {
187 return arm_mul(A, B, Q2_BITS);
188 }
189
MUL_SHIFT6(real_t A,real_t B)190 static INLINE real_t MUL_SHIFT6(real_t A, real_t B)
191 {
192 return arm_mul(A, B, 6);
193 }
194
MUL_SHIFT23(real_t A,real_t B)195 static INLINE real_t MUL_SHIFT23(real_t A, real_t B)
196 {
197 return arm_mul(A, B, 23);
198 }
199
_MulHigh(real_t x,real_t y)200 static INLINE real_t _MulHigh(real_t x, real_t y)
201 {
202 uint32_t __lo;
203 uint32_t __hi;
204 asm("smull\t%0, %1, %2, %3"
205 : "=&r"(__lo),"=&r"(__hi)
206 : "%r"(x),"r"(y)
207 : "cc");
208 return __hi;
209 }
210
MUL_F(real_t A,real_t B)211 static INLINE real_t MUL_F(real_t A, real_t B)
212 {
213 return _MulHigh(A, B) << (FRAC_SIZE-FRAC_BITS);
214 }
215
216 /* Complex multiplication */
ComplexMult(real_t * y1,real_t * y2,real_t x1,real_t x2,real_t c1,real_t c2)217 static INLINE void ComplexMult(real_t *y1, real_t *y2,
218 real_t x1, real_t x2, real_t c1, real_t c2)
219 {
220 int32_t tmp, yt1, yt2;
221 asm("smull %0, %1, %4, %6\n\t"
222 "smlal %0, %1, %5, %7\n\t"
223 "rsb %3, %4, #0\n\t"
224 "smull %0, %2, %5, %6\n\t"
225 "smlal %0, %2, %3, %7"
226 : "=&r" (tmp), "=&r" (yt1), "=&r" (yt2), "=r" (x1)
227 : "3" (x1), "r" (x2), "r" (c1), "r" (c2)
228 : "cc" );
229 *y1 = yt1 << (FRAC_SIZE-FRAC_BITS);
230 *y2 = yt2 << (FRAC_SIZE-FRAC_BITS);
231 }
232
233 #else
234
235 /* multiply with real shift */
236 #define MUL_R(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (REAL_BITS-1))) >> REAL_BITS)
237 /* multiply with coef shift */
238 #define MUL_C(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (COEF_BITS-1))) >> COEF_BITS)
239 /* multiply with fractional shift */
240 #if defined(_WIN32_WCE) && defined(_ARM_)
241 /* eVC for PocketPC has an intrinsic function that returns only the high 32 bits of a 32x32 bit multiply */
MUL_F(real_t A,real_t B)242 static INLINE real_t MUL_F(real_t A, real_t B)
243 {
244 return _MulHigh(A,B) << (32-FRAC_BITS);
245 }
246 #else
247 #ifdef __BFIN__
248 #define _MulHigh(X,Y) ({ int __xxo; \
249 asm ( \
250 "a1 = %2.H * %1.L (IS,M);\n\t" \
251 "a0 = %1.H * %2.H, a1+= %1.H * %2.L (IS,M);\n\t"\
252 "a1 = a1 >>> 16;\n\t" \
253 "%0 = (a0 += a1);\n\t" \
254 : "=d" (__xxo) : "d" (X), "d" (Y) : "A0","A1"); __xxo; })
255
256 #define MUL_F(X,Y) ({ int __xxo; \
257 asm ( \
258 "a1 = %2.H * %1.L (M);\n\t" \
259 "a0 = %1.H * %2.H, a1+= %1.H * %2.L (M);\n\t" \
260 "a1 = a1 >>> 16;\n\t" \
261 "%0 = (a0 += a1);\n\t" \
262 : "=d" (__xxo) : "d" (X), "d" (Y) : "A0","A1"); __xxo; })
263 #else
264 #define _MulHigh(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (FRAC_SIZE-1))) >> FRAC_SIZE)
265 #define MUL_F(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (FRAC_BITS-1))) >> FRAC_BITS)
266 #endif
267 #endif
268 #define MUL_Q2(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (Q2_BITS-1))) >> Q2_BITS)
269 #define MUL_SHIFT6(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (6-1))) >> 6)
270 #define MUL_SHIFT23(A,B) (real_t)(((int64_t)(A)*(int64_t)(B)+(1 << (23-1))) >> 23)
271
272 /* Complex multiplication */
ComplexMult(real_t * y1,real_t * y2,real_t x1,real_t x2,real_t c1,real_t c2)273 static INLINE void ComplexMult(real_t *y1, real_t *y2,
274 real_t x1, real_t x2, real_t c1, real_t c2)
275 {
276 *y1 = (_MulHigh(x1, c1) + _MulHigh(x2, c2))<<(FRAC_SIZE-FRAC_BITS);
277 *y2 = (_MulHigh(x2, c1) - _MulHigh(x1, c2))<<(FRAC_SIZE-FRAC_BITS);
278 }
279
280 #endif
281
282
283
284 #ifdef __cplusplus
285 }
286 #endif
287 #endif
288