Debian Codegraph @

lib/aviplay/AudioFpHQResampler.cpp

raw
1 //
2 // RealTime High Precision resampling with antialising of the signal
3 //
4 // based on some algorithm from
5 // Digital Image Warping by George Wolberg - page 159
6 //
7 //
8
9 // this code might be a bit more optimized in the future
10 // but its already quite fast for its purpose
11
12 #include "AudioFpHQResampler.h"
13 #include <string.h>
14
15 /**
16 * Real-arithmetic based resampling - giving very precise results - but its rather slow
17 * few lines bellow we have now integer version of this -
18 * this version is used for scaling of more then 16bit precise samples
19 * and is not that much optimized as it serves as an illustration
20 * how is this alghorithm working as the optimized integer version
21 * is probably quite mystique
22 *
23 * NOTE:
24 * these methods are accesing one member behind array
25 * this is not a bug and it is intentional to fill also the last
26 * member in the output field
27 **/
28
29 AVM_BEGIN_NAMESPACE;
30
31 #define PRECTYPE double
32 //#define PRECTYPE float
33
34 #define PREC (15) // use 14bits for floating point part
35 #define PRECSIZE (1L<<PREC)
36 #define PRECINT (-1L<<PREC)
37
38 // implementation of the AudioResampler Interface
39 // floating point high quality version
40 template <class T> class AudioFpHQResamplerStereo : public IAudioResampler
41 {
42 public:
43 virtual uint_t getBitsPerSample() const;
44 virtual void resample(void* out, const void* in, size_t out_count, size_t int_count);
45 };
46
47 template <class T> class AudioFpHQResamplerMono : public IAudioResampler
48 {
49 public:
50 virtual uint_t getBitsPerSample() const;
51 virtual void resample(void* out, const void* in, size_t out_count, size_t in_count);
52 };
53
54 // to be used for 8 & 16 bit samples
55
56 template <class T> class AudioIntHQResamplerStereo : public IAudioResampler
57 {
58 public:
59 virtual uint_t getBitsPerSample() const;
60 virtual void resample(void* out, const void* in, size_t out_count, size_t int_count);
61 };
62
63 template <class T> class AudioIntHQResamplerMono : public IAudioResampler
64 {
65 public:
66 virtual uint_t getBitsPerSample() const;
67 virtual void resample(void* out, const void* in, size_t out_count, size_t in_count);
68 };
69
70 template <class T>
71 void AudioFpHQResamplerMono<T>::resample(void* out, const void* in, size_t OUTlen, size_t INlen)
72 {
73 const T* IN = (const T*) in;
74 T* OUT = (T*) out;
75
76 memset(OUT, 0, OUTlen * sizeof(T));
77
78 PRECTYPE step = (PRECTYPE) OUTlen / (PRECTYPE) (INlen - 1);
79 PRECTYPE x1 = 0.0;
80 for (unsigned u = 0; u <= INlen; u++)
81 {
82 PRECTYPE x0 = x1;
83 x1 += step;
84 /* integer parts */
85 uint_t ix0 = (uint_t) x0;
86 uint_t ix1 = (uint_t) x1;
87
88 if (ix0 == ix1)
89 {
90 OUT[ix0] += (T) (IN[u] * step);
91 continue;
92 }
93
94 OUT[ix0] += (T) (IN[u] * (ix0 + 1 - x0));
95
96 PRECTYPE dl = (IN[u + 1] - IN[u]) / step;
97
98 for (unsigned i = ix0 + 1; i < ix1; i++)
99 OUT[i] = (T) (IN[u] + dl * (i - x0));
100
101 OUT[ix1] += (T) ((x1 - ix1) * (IN[u] + dl * (ix1 - x0)));
102 }
103 OUT[OUTlen - 1] = IN[INlen - 1];
104 }
105
106 template <class T>
107 void AudioFpHQResamplerStereo<T>::resample(void* out, const void* in, size_t OUTlen, size_t INlen)
108 {
109 const T* IN = (const T*) in;
110 T* OUT = (T*) out;
111
112 memset(OUT, 0, OUTlen * sizeof(T) * 2);
113 PRECTYPE step = (PRECTYPE) (OUTlen) / (PRECTYPE) (INlen - 1);
114 //cout << "SIZE " << sizeof(T) << " " << OUTlen << " " << INlen << " step " << step << endl;
115
116 PRECTYPE x1 = 0.0;
117 for (uint_t u = 0; u <= 2*INlen; u += 2)
118 {
119 PRECTYPE x0 = x1;
120 //x1 = u/2 * step;
121 x1 += step;
122 /* integer parts */
123 uint_t ix0 = (uint_t) x0;
124 uint_t ix1 = (uint_t) x1;
125
126 if (ix0 == ix1)
127 {
128 OUT[ix0 * 2] += (T) (IN[u] * step);
129 OUT[ix0 * 2 + 1] += (T) (IN[u + 1] * step);
130 continue;
131 }
132
133 OUT[ix0 * 2] += (T) (IN[u] * (ix0 + 1 - x0));
134 OUT[ix0 * 2 + 1] += (T) (IN[u + 1] * (ix0 + 1 - x0));
135
136 PRECTYPE dl = ((int)IN[u + 2] - (int)IN[u]) / step;
137 PRECTYPE dr = ((int)IN[u + 2 + 1] - (int)IN[u + 1]) / step;
138
139 for (unsigned i = ix0 + 1; i < ix1; i++)
140 {
141 OUT[i * 2] = (T) (IN[u] + dl * (i - x0));
142 OUT[i * 2 + 1] = (T) (IN[u + 1] + dr * (i - x0));
143 }
144
145 OUT[ix1 * 2] += (T) ((x1 - ix1) * (IN[u] + dl * (ix1 - x0)));
146 OUT[ix1 * 2 + 1] += (T) ((x1 - ix1) * (IN[u + 1] + dr * (ix1 - x0)));
147 }
148
149 #if 0
150 for (int i = 0; i < 16; i++)
151 printf(" %d in: %x %x out: %x %x\n", i,
152 IN[2*i], IN[2*i + 1],
153 OUT[2*i], OUT[2*i + 1]);
154
155 for (int i = 16; i >= 0; i--)
156 printf("%d in: %x %x out: %x %x\n", i,
157 IN[2*INlen - 2*i], IN[2*INlen - 2*i + 1],
158 OUT[2*OUTlen - 2*i], OUT[2*OUTlen - 2*i + 1]);
159 #endif
160 }
161
162 template <class T>
163 uint_t AudioFpHQResamplerStereo<T>::getBitsPerSample() const
164 {
165 return sizeof(T) * 8;
166 }
167
168 template <class T>
169 uint_t AudioFpHQResamplerMono<T>::getBitsPerSample() const
170 {
171 return sizeof(T) * 8;
172 }
173
174 /**
175 * Optimized real-arithmetic based resampling which is using integers
176 *
177 * NOTE:
178 * these methods are accesing one member behind array
179 * this is not a bug and it it intencial to fill also the last
180 * member in the output field
181 **/
182
183 template <class T>
184 void AudioIntHQResamplerMono<T>::resample(void* out, const void* in, size_t OUTlen, size_t INlen)
185 {
186 const T* IN = (const T*) in;
187 T* OUT = (T*) out;
188 const T* OUTEND = &OUT[OUTlen];
189 long delta = (OUTlen * PRECSIZE) / (INlen - ((INlen < OUTlen) ? 1 : 0));
190 //int delta = (OUTlen * PRECSIZE) / (INlen + 1);
191 //printf("Delta: %d\n", delta);
192 long frac = -PRECSIZE;
193 long part = 0;
194 long a = 0;
195 for (;;)
196 {
197 frac += delta;
198
199 if (frac >= 0)
200 {
201 long dl;
202 long r = *IN;
203
204 frac -= PRECSIZE;
205
206 a += (PRECSIZE - part) * r;
207 *OUT = (T) (a >> PREC);
208 OUT++;
209 if (OUT >= OUTEND)
210 break;
211
212 dl = ((IN[1] - r) << PREC) / delta;
213 a = r + dl - ((dl * part) >> PREC);
214 while (frac >= 0)
215 {
216 *OUT = (T) a;
217 OUT++;
218 a += dl;
219 frac -= PRECSIZE;
220 }
221
222 part = frac & (PRECSIZE - 1);
223 a *= part;
224 }
225 else
226 {
227 part = frac & (PRECSIZE - 1);
228 a += *IN * delta;
229 }
230
231 IN++;
232 }
233
234 //printf("OUT: %p OUTEND: %p IN: %p INEND: %p\n",
235 // OUT, OUTEND, IN, &((const T*) in)[INlen]);
236 //OUT[-1] = IN[-1];
237 }
238
239 // this version is the same code as above it just goes through every second sample
240 // to save some registers we use this instead of parametrized version
241 // ok I think we could make slightly more complicated template...
242 template <class T>
243 void AudioIntHQResamplerStereo<T>::resample(void* out, const void* in, size_t OUTlen, size_t INlen)
244 {
245 const T* OUTEND = &(((const T*)out)[OUTlen * 2]);
246 long delta = (OUTlen * PRECSIZE) / (INlen - ((INlen < OUTlen) ? 1 : 0));
247
248 // use two loops and skip every second sample - should be faster
249 // than processing two channels at the same time
250 for (int loop = 0; loop < 2; loop++)
251 {
252 const T* IN = (const T*) in;
253 T* OUT = (T*) out;
254 int x1 = 0, ix1 = 0;
255 OUT += loop; // left channel - 0 right channel - 1
256 IN += loop;
257
258
259 long frac = -PRECSIZE;
260 long part = 0;
261 long a = 0;
262 for (;;)
263 {
264 frac += delta;
265
266 if (frac >= 0)
267 {
268 long dl;
269 long r = *IN;
270
271 frac -= PRECSIZE;
272
273 a += (PRECSIZE - part) * r;
274 *OUT = (T) (a >> PREC);
275 OUT += 2;
276
277 if (OUT >= OUTEND)
278 break;
279
280 dl = ((IN[2] - r) << PREC) / delta;
281 a = r + dl - ((dl * part) >> PREC);
282 while (frac >= 0)
283 {
284 *OUT = (T) a;
285 OUT += 2;
286 a += dl;
287 frac -= PRECSIZE;
288 }
289
290 part = frac & (PRECSIZE - 1);
291 a *= part;
292 }
293 else
294 {
295 part = frac & (PRECSIZE - 1);
296 a += *IN * delta;
297 }
298
299 IN += 2;
300 }
301 //OUT[-1] = IN[-1];
302 }
303 }
304
305 template <class T>
306 uint_t AudioIntHQResamplerStereo<T>::getBitsPerSample() const
307 {
308 return sizeof(T) * 8;
309 }
310
311 template <class T>
312 uint_t AudioIntHQResamplerMono<T>::getBitsPerSample() const
313 {
314 return sizeof(T) * 8;
315 }
316
317 IAudioResampler* CreateHQResampler(uint_t channels, uint_t bitsPerSample)
318 {
319 IAudioResampler* r = 0;
320
321 //cout << "Resample " << channels << " " << bitsPerSample << endl;
322
323 // create all the needed instancies
324 switch (channels)
325 {
326 case 1:
327 if (bitsPerSample <= 8)
328 r = new AudioIntHQResamplerMono<unsigned char>;
329 else if (bitsPerSample <= 16)
330 r = new AudioIntHQResamplerMono<short>;
331 else if (bitsPerSample <= 32)
332 r = new AudioFpHQResamplerMono<int>;
333 break;
334 case 2:
335 if (bitsPerSample <= 8)
336 r = new AudioIntHQResamplerStereo<unsigned char>;
337 else if (bitsPerSample <= 16)
338 r = new AudioIntHQResamplerStereo<short>;
339 else if (bitsPerSample <= 32)
340 r = new AudioFpHQResamplerStereo<int>;
341 break;
342 }
343
344 return r;
345 }
346
347 AVM_END_NAMESPACE;