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 _V_RANDOM_H_ |
|
19 #define _V_RANDOM_H_ |
|
20 #include "ivorbiscodec.h" |
|
21 #include "os.h" |
|
22 |
|
23 #include "asm_arm.h" |
|
24 #include <stdlib.h> /* for abs() */ |
|
25 |
|
26 #ifndef _V_WIDE_MATH |
|
27 #define _V_WIDE_MATH |
|
28 |
|
29 #ifndef _LOW_ACCURACY_ |
|
30 /* 64 bit multiply */ |
|
31 |
|
32 #if !(defined WIN32 && defined WINCE) |
|
33 #include <sys/types.h> |
|
34 #endif |
|
35 |
|
36 #if BYTE_ORDER==LITTLE_ENDIAN |
|
37 union magic { |
|
38 struct { |
|
39 ogg_int32_t lo; |
|
40 ogg_int32_t hi; |
|
41 } halves; |
|
42 ogg_int64_t whole; |
|
43 }; |
|
44 #endif |
|
45 |
|
46 #if BYTE_ORDER==BIG_ENDIAN |
|
47 /*union magic { |
|
48 struct { |
|
49 ogg_int32_t hi; |
|
50 ogg_int32_t lo; |
|
51 } halves; |
|
52 ogg_int64_t whole; |
|
53 };*/ |
|
54 #endif |
|
55 |
|
56 STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { |
|
57 union magic magic; |
|
58 magic.whole = (ogg_int64_t)x * y; |
|
59 return magic.halves.hi; |
|
60 } |
|
61 |
|
62 STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { |
|
63 return MULT32(x,y)<<1; |
|
64 } |
|
65 |
|
66 STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { |
|
67 union magic magic; |
|
68 magic.whole = (ogg_int64_t)x * y; |
|
69 return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17); |
|
70 } |
|
71 |
|
72 #else |
|
73 /* 32 bit multiply, more portable but less accurate */ |
|
74 |
|
75 /* |
|
76 * Note: Precision is biased towards the first argument therefore ordering |
|
77 * is important. Shift values were chosen for the best sound quality after |
|
78 * many listening tests. |
|
79 */ |
|
80 |
|
81 /* |
|
82 * For MULT32 and MULT31: The second argument is always a lookup table |
|
83 * value already preshifted from 31 to 8 bits. We therefore take the |
|
84 * opportunity to save on text space and use unsigned char for those |
|
85 * tables in this case. |
|
86 */ |
|
87 |
|
88 STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { |
|
89 return (x >> 9) * y; /* y preshifted >>23 */ |
|
90 } |
|
91 |
|
92 STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { |
|
93 return (x >> 8) * y; /* y preshifted >>23 */ |
|
94 } |
|
95 |
|
96 STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { |
|
97 return (x >> 6) * y; /* y preshifted >>9 */ |
|
98 } |
|
99 |
|
100 #endif |
|
101 |
|
102 /* |
|
103 * This should be used as a memory barrier, forcing all cached values in |
|
104 * registers to wr writen back to memory. Might or might not be beneficial |
|
105 * depending on the architecture and compiler. |
|
106 */ |
|
107 #define MB() |
|
108 |
|
109 /* |
|
110 * The XPROD functions are meant to optimize the cross products found all |
|
111 * over the place in mdct.c by forcing memory operation ordering to avoid |
|
112 * unnecessary register reloads as soon as memory is being written to. |
|
113 * However this is only beneficial on CPUs with a sane number of general |
|
114 * purpose registers which exclude the Intel x86. On Intel, better let the |
|
115 * compiler actually reload registers directly from original memory by using |
|
116 * macros. |
|
117 */ |
|
118 |
|
119 #ifdef __i386__ |
|
120 |
|
121 #define XPROD32(_a, _b, _t, _v, _x, _y) \ |
|
122 { *(_x)=MULT32(_a,_t)+MULT32(_b,_v); \ |
|
123 *(_y)=MULT32(_b,_t)-MULT32(_a,_v); } |
|
124 #define XPROD31(_a, _b, _t, _v, _x, _y) \ |
|
125 { *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \ |
|
126 *(_y)=MULT31(_b,_t)-MULT31(_a,_v); } |
|
127 #define XNPROD31(_a, _b, _t, _v, _x, _y) \ |
|
128 { *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \ |
|
129 *(_y)=MULT31(_b,_t)+MULT31(_a,_v); } |
|
130 |
|
131 #else |
|
132 |
|
133 STIN void XPROD32(ogg_int32_t a, ogg_int32_t b, |
|
134 ogg_int32_t t, ogg_int32_t v, |
|
135 ogg_int32_t *x, ogg_int32_t *y) |
|
136 { |
|
137 *x = MULT32(a, t) + MULT32(b, v); |
|
138 *y = MULT32(b, t) - MULT32(a, v); |
|
139 } |
|
140 |
|
141 STIN void XPROD31(ogg_int32_t a, ogg_int32_t b, |
|
142 ogg_int32_t t, ogg_int32_t v, |
|
143 ogg_int32_t *x, ogg_int32_t *y) |
|
144 { |
|
145 *x = MULT31(a, t) + MULT31(b, v); |
|
146 *y = MULT31(b, t) - MULT31(a, v); |
|
147 } |
|
148 |
|
149 STIN void XNPROD31(ogg_int32_t a, ogg_int32_t b, |
|
150 ogg_int32_t t, ogg_int32_t v, |
|
151 ogg_int32_t *x, ogg_int32_t *y) |
|
152 { |
|
153 *x = MULT31(a, t) - MULT31(b, v); |
|
154 *y = MULT31(b, t) + MULT31(a, v); |
|
155 } |
|
156 |
|
157 #endif |
|
158 |
|
159 #endif |
|
160 |
|
161 #ifndef _V_CLIP_MATH |
|
162 #define _V_CLIP_MATH |
|
163 |
|
164 STIN ogg_int32_t CLIP_TO_15(ogg_int32_t x) { |
|
165 int ret=x; |
|
166 ret-= ((x<=32767)-1)&(x-32767); |
|
167 ret-= ((x>=-32768)-1)&(x+32768); |
|
168 return(ret); |
|
169 } |
|
170 |
|
171 #endif |
|
172 |
|
173 STIN ogg_int32_t VFLOAT_MULT(ogg_int32_t a,ogg_int32_t ap, |
|
174 ogg_int32_t b,ogg_int32_t bp, |
|
175 ogg_int32_t *p){ |
|
176 if(a && b){ |
|
177 #ifndef _LOW_ACCURACY_ |
|
178 *p=ap+bp+32; |
|
179 return MULT32(a,b); |
|
180 #else |
|
181 *p=ap+bp+31; |
|
182 return (a>>15)*(b>>16); |
|
183 #endif |
|
184 }else |
|
185 return 0; |
|
186 } |
|
187 |
|
188 int _ilog(unsigned int); |
|
189 |
|
190 STIN ogg_int32_t VFLOAT_MULTI(ogg_int32_t a,ogg_int32_t ap, |
|
191 ogg_int32_t i, |
|
192 ogg_int32_t *p){ |
|
193 |
|
194 int ip=_ilog(abs(i))-31; |
|
195 return VFLOAT_MULT(a,ap,i<<-ip,ip,p); |
|
196 } |
|
197 |
|
198 STIN ogg_int32_t VFLOAT_ADD(ogg_int32_t a,ogg_int32_t ap, |
|
199 ogg_int32_t b,ogg_int32_t bp, |
|
200 ogg_int32_t *p){ |
|
201 |
|
202 if(!a){ |
|
203 *p=bp; |
|
204 return b; |
|
205 }else if(!b){ |
|
206 *p=ap; |
|
207 return a; |
|
208 } |
|
209 |
|
210 /* yes, this can leak a bit. */ |
|
211 if(ap>bp){ |
|
212 int shift=ap-bp+1; |
|
213 *p=ap+1; |
|
214 a>>=1; |
|
215 if(shift<32){ |
|
216 b=(b+(1<<(shift-1)))>>shift; |
|
217 }else{ |
|
218 b=0; |
|
219 } |
|
220 }else{ |
|
221 int shift=bp-ap+1; |
|
222 *p=bp+1; |
|
223 b>>=1; |
|
224 if(shift<32){ |
|
225 a=(a+(1<<(shift-1)))>>shift; |
|
226 }else{ |
|
227 a=0; |
|
228 } |
|
229 } |
|
230 |
|
231 a+=b; |
|
232 if((a&0xc0000000)==0xc0000000 || |
|
233 (a&0xc0000000)==0){ |
|
234 a<<=1; |
|
235 (*p)--; |
|
236 } |
|
237 return(a); |
|
238 } |
|
239 |
|
240 #endif |
|
241 |
|
242 |
|
243 |
|
244 |
|