• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 
12 /*
13  * This header file contains some internal resampling functions.
14  *
15  */
16 
17 #include "webrtc/common_audio/signal_processing/resample_by_2_internal.h"
18 
19 // allpass filter coefficients.
20 static const int16_t kResampleAllpass[2][3] = {
21         {821, 6110, 12382},
22         {3050, 9368, 15063}
23 };
24 
25 //
26 //   decimator
27 // input:  int32_t (shifted 15 positions to the left, + offset 16384) OVERWRITTEN!
28 // output: int16_t (saturated) (of length len/2)
29 // state:  filter state array; length = 8
30 
WebRtcSpl_DownBy2IntToShort(int32_t * in,int32_t len,int16_t * out,int32_t * state)31 void WebRtcSpl_DownBy2IntToShort(int32_t *in, int32_t len, int16_t *out,
32                                  int32_t *state)
33 {
34     int32_t tmp0, tmp1, diff;
35     int32_t i;
36 
37     len >>= 1;
38 
39     // lower allpass filter (operates on even input samples)
40     for (i = 0; i < len; i++)
41     {
42         tmp0 = in[i << 1];
43         diff = tmp0 - state[1];
44         // scale down and round
45         diff = (diff + (1 << 13)) >> 14;
46         tmp1 = state[0] + diff * kResampleAllpass[1][0];
47         state[0] = tmp0;
48         diff = tmp1 - state[2];
49         // scale down and truncate
50         diff = diff >> 14;
51         if (diff < 0)
52             diff += 1;
53         tmp0 = state[1] + diff * kResampleAllpass[1][1];
54         state[1] = tmp1;
55         diff = tmp0 - state[3];
56         // scale down and truncate
57         diff = diff >> 14;
58         if (diff < 0)
59             diff += 1;
60         state[3] = state[2] + diff * kResampleAllpass[1][2];
61         state[2] = tmp0;
62 
63         // divide by two and store temporarily
64         in[i << 1] = (state[3] >> 1);
65     }
66 
67     in++;
68 
69     // upper allpass filter (operates on odd input samples)
70     for (i = 0; i < len; i++)
71     {
72         tmp0 = in[i << 1];
73         diff = tmp0 - state[5];
74         // scale down and round
75         diff = (diff + (1 << 13)) >> 14;
76         tmp1 = state[4] + diff * kResampleAllpass[0][0];
77         state[4] = tmp0;
78         diff = tmp1 - state[6];
79         // scale down and round
80         diff = diff >> 14;
81         if (diff < 0)
82             diff += 1;
83         tmp0 = state[5] + diff * kResampleAllpass[0][1];
84         state[5] = tmp1;
85         diff = tmp0 - state[7];
86         // scale down and truncate
87         diff = diff >> 14;
88         if (diff < 0)
89             diff += 1;
90         state[7] = state[6] + diff * kResampleAllpass[0][2];
91         state[6] = tmp0;
92 
93         // divide by two and store temporarily
94         in[i << 1] = (state[7] >> 1);
95     }
96 
97     in--;
98 
99     // combine allpass outputs
100     for (i = 0; i < len; i += 2)
101     {
102         // divide by two, add both allpass outputs and round
103         tmp0 = (in[i << 1] + in[(i << 1) + 1]) >> 15;
104         tmp1 = (in[(i << 1) + 2] + in[(i << 1) + 3]) >> 15;
105         if (tmp0 > (int32_t)0x00007FFF)
106             tmp0 = 0x00007FFF;
107         if (tmp0 < (int32_t)0xFFFF8000)
108             tmp0 = 0xFFFF8000;
109         out[i] = (int16_t)tmp0;
110         if (tmp1 > (int32_t)0x00007FFF)
111             tmp1 = 0x00007FFF;
112         if (tmp1 < (int32_t)0xFFFF8000)
113             tmp1 = 0xFFFF8000;
114         out[i + 1] = (int16_t)tmp1;
115     }
116 }
117 
118 //
119 //   decimator
120 // input:  int16_t
121 // output: int32_t (shifted 15 positions to the left, + offset 16384) (of length len/2)
122 // state:  filter state array; length = 8
123 
WebRtcSpl_DownBy2ShortToInt(const int16_t * in,int32_t len,int32_t * out,int32_t * state)124 void WebRtcSpl_DownBy2ShortToInt(const int16_t *in,
125                                   int32_t len,
126                                   int32_t *out,
127                                   int32_t *state)
128 {
129     int32_t tmp0, tmp1, diff;
130     int32_t i;
131 
132     len >>= 1;
133 
134     // lower allpass filter (operates on even input samples)
135     for (i = 0; i < len; i++)
136     {
137         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
138         diff = tmp0 - state[1];
139         // scale down and round
140         diff = (diff + (1 << 13)) >> 14;
141         tmp1 = state[0] + diff * kResampleAllpass[1][0];
142         state[0] = tmp0;
143         diff = tmp1 - state[2];
144         // scale down and truncate
145         diff = diff >> 14;
146         if (diff < 0)
147             diff += 1;
148         tmp0 = state[1] + diff * kResampleAllpass[1][1];
149         state[1] = tmp1;
150         diff = tmp0 - state[3];
151         // scale down and truncate
152         diff = diff >> 14;
153         if (diff < 0)
154             diff += 1;
155         state[3] = state[2] + diff * kResampleAllpass[1][2];
156         state[2] = tmp0;
157 
158         // divide by two and store temporarily
159         out[i] = (state[3] >> 1);
160     }
161 
162     in++;
163 
164     // upper allpass filter (operates on odd input samples)
165     for (i = 0; i < len; i++)
166     {
167         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
168         diff = tmp0 - state[5];
169         // scale down and round
170         diff = (diff + (1 << 13)) >> 14;
171         tmp1 = state[4] + diff * kResampleAllpass[0][0];
172         state[4] = tmp0;
173         diff = tmp1 - state[6];
174         // scale down and round
175         diff = diff >> 14;
176         if (diff < 0)
177             diff += 1;
178         tmp0 = state[5] + diff * kResampleAllpass[0][1];
179         state[5] = tmp1;
180         diff = tmp0 - state[7];
181         // scale down and truncate
182         diff = diff >> 14;
183         if (diff < 0)
184             diff += 1;
185         state[7] = state[6] + diff * kResampleAllpass[0][2];
186         state[6] = tmp0;
187 
188         // divide by two and store temporarily
189         out[i] += (state[7] >> 1);
190     }
191 
192     in--;
193 }
194 
195 //
196 //   interpolator
197 // input:  int16_t
198 // output: int32_t (normalized, not saturated) (of length len*2)
199 // state:  filter state array; length = 8
WebRtcSpl_UpBy2ShortToInt(const int16_t * in,int32_t len,int32_t * out,int32_t * state)200 void WebRtcSpl_UpBy2ShortToInt(const int16_t *in, int32_t len, int32_t *out,
201                                int32_t *state)
202 {
203     int32_t tmp0, tmp1, diff;
204     int32_t i;
205 
206     // upper allpass filter (generates odd output samples)
207     for (i = 0; i < len; i++)
208     {
209         tmp0 = ((int32_t)in[i] << 15) + (1 << 14);
210         diff = tmp0 - state[5];
211         // scale down and round
212         diff = (diff + (1 << 13)) >> 14;
213         tmp1 = state[4] + diff * kResampleAllpass[0][0];
214         state[4] = tmp0;
215         diff = tmp1 - state[6];
216         // scale down and truncate
217         diff = diff >> 14;
218         if (diff < 0)
219             diff += 1;
220         tmp0 = state[5] + diff * kResampleAllpass[0][1];
221         state[5] = tmp1;
222         diff = tmp0 - state[7];
223         // scale down and truncate
224         diff = diff >> 14;
225         if (diff < 0)
226             diff += 1;
227         state[7] = state[6] + diff * kResampleAllpass[0][2];
228         state[6] = tmp0;
229 
230         // scale down, round and store
231         out[i << 1] = state[7] >> 15;
232     }
233 
234     out++;
235 
236     // lower allpass filter (generates even output samples)
237     for (i = 0; i < len; i++)
238     {
239         tmp0 = ((int32_t)in[i] << 15) + (1 << 14);
240         diff = tmp0 - state[1];
241         // scale down and round
242         diff = (diff + (1 << 13)) >> 14;
243         tmp1 = state[0] + diff * kResampleAllpass[1][0];
244         state[0] = tmp0;
245         diff = tmp1 - state[2];
246         // scale down and truncate
247         diff = diff >> 14;
248         if (diff < 0)
249             diff += 1;
250         tmp0 = state[1] + diff * kResampleAllpass[1][1];
251         state[1] = tmp1;
252         diff = tmp0 - state[3];
253         // scale down and truncate
254         diff = diff >> 14;
255         if (diff < 0)
256             diff += 1;
257         state[3] = state[2] + diff * kResampleAllpass[1][2];
258         state[2] = tmp0;
259 
260         // scale down, round and store
261         out[i << 1] = state[3] >> 15;
262     }
263 }
264 
265 //
266 //   interpolator
267 // input:  int32_t (shifted 15 positions to the left, + offset 16384)
268 // output: int32_t (shifted 15 positions to the left, + offset 16384) (of length len*2)
269 // state:  filter state array; length = 8
WebRtcSpl_UpBy2IntToInt(const int32_t * in,int32_t len,int32_t * out,int32_t * state)270 void WebRtcSpl_UpBy2IntToInt(const int32_t *in, int32_t len, int32_t *out,
271                              int32_t *state)
272 {
273     int32_t tmp0, tmp1, diff;
274     int32_t i;
275 
276     // upper allpass filter (generates odd output samples)
277     for (i = 0; i < len; i++)
278     {
279         tmp0 = in[i];
280         diff = tmp0 - state[5];
281         // scale down and round
282         diff = (diff + (1 << 13)) >> 14;
283         tmp1 = state[4] + diff * kResampleAllpass[0][0];
284         state[4] = tmp0;
285         diff = tmp1 - state[6];
286         // scale down and truncate
287         diff = diff >> 14;
288         if (diff < 0)
289             diff += 1;
290         tmp0 = state[5] + diff * kResampleAllpass[0][1];
291         state[5] = tmp1;
292         diff = tmp0 - state[7];
293         // scale down and truncate
294         diff = diff >> 14;
295         if (diff < 0)
296             diff += 1;
297         state[7] = state[6] + diff * kResampleAllpass[0][2];
298         state[6] = tmp0;
299 
300         // scale down, round and store
301         out[i << 1] = state[7];
302     }
303 
304     out++;
305 
306     // lower allpass filter (generates even output samples)
307     for (i = 0; i < len; i++)
308     {
309         tmp0 = in[i];
310         diff = tmp0 - state[1];
311         // scale down and round
312         diff = (diff + (1 << 13)) >> 14;
313         tmp1 = state[0] + diff * kResampleAllpass[1][0];
314         state[0] = tmp0;
315         diff = tmp1 - state[2];
316         // scale down and truncate
317         diff = diff >> 14;
318         if (diff < 0)
319             diff += 1;
320         tmp0 = state[1] + diff * kResampleAllpass[1][1];
321         state[1] = tmp1;
322         diff = tmp0 - state[3];
323         // scale down and truncate
324         diff = diff >> 14;
325         if (diff < 0)
326             diff += 1;
327         state[3] = state[2] + diff * kResampleAllpass[1][2];
328         state[2] = tmp0;
329 
330         // scale down, round and store
331         out[i << 1] = state[3];
332     }
333 }
334 
335 //
336 //   interpolator
337 // input:  int32_t (shifted 15 positions to the left, + offset 16384)
338 // output: int16_t (saturated) (of length len*2)
339 // state:  filter state array; length = 8
WebRtcSpl_UpBy2IntToShort(const int32_t * in,int32_t len,int16_t * out,int32_t * state)340 void WebRtcSpl_UpBy2IntToShort(const int32_t *in, int32_t len, int16_t *out,
341                                int32_t *state)
342 {
343     int32_t tmp0, tmp1, diff;
344     int32_t i;
345 
346     // upper allpass filter (generates odd output samples)
347     for (i = 0; i < len; i++)
348     {
349         tmp0 = in[i];
350         diff = tmp0 - state[5];
351         // scale down and round
352         diff = (diff + (1 << 13)) >> 14;
353         tmp1 = state[4] + diff * kResampleAllpass[0][0];
354         state[4] = tmp0;
355         diff = tmp1 - state[6];
356         // scale down and round
357         diff = diff >> 14;
358         if (diff < 0)
359             diff += 1;
360         tmp0 = state[5] + diff * kResampleAllpass[0][1];
361         state[5] = tmp1;
362         diff = tmp0 - state[7];
363         // scale down and truncate
364         diff = diff >> 14;
365         if (diff < 0)
366             diff += 1;
367         state[7] = state[6] + diff * kResampleAllpass[0][2];
368         state[6] = tmp0;
369 
370         // scale down, saturate and store
371         tmp1 = state[7] >> 15;
372         if (tmp1 > (int32_t)0x00007FFF)
373             tmp1 = 0x00007FFF;
374         if (tmp1 < (int32_t)0xFFFF8000)
375             tmp1 = 0xFFFF8000;
376         out[i << 1] = (int16_t)tmp1;
377     }
378 
379     out++;
380 
381     // lower allpass filter (generates even output samples)
382     for (i = 0; i < len; i++)
383     {
384         tmp0 = in[i];
385         diff = tmp0 - state[1];
386         // scale down and round
387         diff = (diff + (1 << 13)) >> 14;
388         tmp1 = state[0] + diff * kResampleAllpass[1][0];
389         state[0] = tmp0;
390         diff = tmp1 - state[2];
391         // scale down and truncate
392         diff = diff >> 14;
393         if (diff < 0)
394             diff += 1;
395         tmp0 = state[1] + diff * kResampleAllpass[1][1];
396         state[1] = tmp1;
397         diff = tmp0 - state[3];
398         // scale down and truncate
399         diff = diff >> 14;
400         if (diff < 0)
401             diff += 1;
402         state[3] = state[2] + diff * kResampleAllpass[1][2];
403         state[2] = tmp0;
404 
405         // scale down, saturate and store
406         tmp1 = state[3] >> 15;
407         if (tmp1 > (int32_t)0x00007FFF)
408             tmp1 = 0x00007FFF;
409         if (tmp1 < (int32_t)0xFFFF8000)
410             tmp1 = 0xFFFF8000;
411         out[i << 1] = (int16_t)tmp1;
412     }
413 }
414 
415 //   lowpass filter
416 // input:  int16_t
417 // output: int32_t (normalized, not saturated)
418 // state:  filter state array; length = 8
WebRtcSpl_LPBy2ShortToInt(const int16_t * in,int32_t len,int32_t * out,int32_t * state)419 void WebRtcSpl_LPBy2ShortToInt(const int16_t* in, int32_t len, int32_t* out,
420                                int32_t* state)
421 {
422     int32_t tmp0, tmp1, diff;
423     int32_t i;
424 
425     len >>= 1;
426 
427     // lower allpass filter: odd input -> even output samples
428     in++;
429     // initial state of polyphase delay element
430     tmp0 = state[12];
431     for (i = 0; i < len; i++)
432     {
433         diff = tmp0 - state[1];
434         // scale down and round
435         diff = (diff + (1 << 13)) >> 14;
436         tmp1 = state[0] + diff * kResampleAllpass[1][0];
437         state[0] = tmp0;
438         diff = tmp1 - state[2];
439         // scale down and truncate
440         diff = diff >> 14;
441         if (diff < 0)
442             diff += 1;
443         tmp0 = state[1] + diff * kResampleAllpass[1][1];
444         state[1] = tmp1;
445         diff = tmp0 - state[3];
446         // scale down and truncate
447         diff = diff >> 14;
448         if (diff < 0)
449             diff += 1;
450         state[3] = state[2] + diff * kResampleAllpass[1][2];
451         state[2] = tmp0;
452 
453         // scale down, round and store
454         out[i << 1] = state[3] >> 1;
455         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
456     }
457     in--;
458 
459     // upper allpass filter: even input -> even output samples
460     for (i = 0; i < len; i++)
461     {
462         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
463         diff = tmp0 - state[5];
464         // scale down and round
465         diff = (diff + (1 << 13)) >> 14;
466         tmp1 = state[4] + diff * kResampleAllpass[0][0];
467         state[4] = tmp0;
468         diff = tmp1 - state[6];
469         // scale down and round
470         diff = diff >> 14;
471         if (diff < 0)
472             diff += 1;
473         tmp0 = state[5] + diff * kResampleAllpass[0][1];
474         state[5] = tmp1;
475         diff = tmp0 - state[7];
476         // scale down and truncate
477         diff = diff >> 14;
478         if (diff < 0)
479             diff += 1;
480         state[7] = state[6] + diff * kResampleAllpass[0][2];
481         state[6] = tmp0;
482 
483         // average the two allpass outputs, scale down and store
484         out[i << 1] = (out[i << 1] + (state[7] >> 1)) >> 15;
485     }
486 
487     // switch to odd output samples
488     out++;
489 
490     // lower allpass filter: even input -> odd output samples
491     for (i = 0; i < len; i++)
492     {
493         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
494         diff = tmp0 - state[9];
495         // scale down and round
496         diff = (diff + (1 << 13)) >> 14;
497         tmp1 = state[8] + diff * kResampleAllpass[1][0];
498         state[8] = tmp0;
499         diff = tmp1 - state[10];
500         // scale down and truncate
501         diff = diff >> 14;
502         if (diff < 0)
503             diff += 1;
504         tmp0 = state[9] + diff * kResampleAllpass[1][1];
505         state[9] = tmp1;
506         diff = tmp0 - state[11];
507         // scale down and truncate
508         diff = diff >> 14;
509         if (diff < 0)
510             diff += 1;
511         state[11] = state[10] + diff * kResampleAllpass[1][2];
512         state[10] = tmp0;
513 
514         // scale down, round and store
515         out[i << 1] = state[11] >> 1;
516     }
517 
518     // upper allpass filter: odd input -> odd output samples
519     in++;
520     for (i = 0; i < len; i++)
521     {
522         tmp0 = ((int32_t)in[i << 1] << 15) + (1 << 14);
523         diff = tmp0 - state[13];
524         // scale down and round
525         diff = (diff + (1 << 13)) >> 14;
526         tmp1 = state[12] + diff * kResampleAllpass[0][0];
527         state[12] = tmp0;
528         diff = tmp1 - state[14];
529         // scale down and round
530         diff = diff >> 14;
531         if (diff < 0)
532             diff += 1;
533         tmp0 = state[13] + diff * kResampleAllpass[0][1];
534         state[13] = tmp1;
535         diff = tmp0 - state[15];
536         // scale down and truncate
537         diff = diff >> 14;
538         if (diff < 0)
539             diff += 1;
540         state[15] = state[14] + diff * kResampleAllpass[0][2];
541         state[14] = tmp0;
542 
543         // average the two allpass outputs, scale down and store
544         out[i << 1] = (out[i << 1] + (state[15] >> 1)) >> 15;
545     }
546 }
547 
548 //   lowpass filter
549 // input:  int32_t (shifted 15 positions to the left, + offset 16384)
550 // output: int32_t (normalized, not saturated)
551 // state:  filter state array; length = 8
WebRtcSpl_LPBy2IntToInt(const int32_t * in,int32_t len,int32_t * out,int32_t * state)552 void WebRtcSpl_LPBy2IntToInt(const int32_t* in, int32_t len, int32_t* out,
553                              int32_t* state)
554 {
555     int32_t tmp0, tmp1, diff;
556     int32_t i;
557 
558     len >>= 1;
559 
560     // lower allpass filter: odd input -> even output samples
561     in++;
562     // initial state of polyphase delay element
563     tmp0 = state[12];
564     for (i = 0; i < len; i++)
565     {
566         diff = tmp0 - state[1];
567         // scale down and round
568         diff = (diff + (1 << 13)) >> 14;
569         tmp1 = state[0] + diff * kResampleAllpass[1][0];
570         state[0] = tmp0;
571         diff = tmp1 - state[2];
572         // scale down and truncate
573         diff = diff >> 14;
574         if (diff < 0)
575             diff += 1;
576         tmp0 = state[1] + diff * kResampleAllpass[1][1];
577         state[1] = tmp1;
578         diff = tmp0 - state[3];
579         // scale down and truncate
580         diff = diff >> 14;
581         if (diff < 0)
582             diff += 1;
583         state[3] = state[2] + diff * kResampleAllpass[1][2];
584         state[2] = tmp0;
585 
586         // scale down, round and store
587         out[i << 1] = state[3] >> 1;
588         tmp0 = in[i << 1];
589     }
590     in--;
591 
592     // upper allpass filter: even input -> even output samples
593     for (i = 0; i < len; i++)
594     {
595         tmp0 = in[i << 1];
596         diff = tmp0 - state[5];
597         // scale down and round
598         diff = (diff + (1 << 13)) >> 14;
599         tmp1 = state[4] + diff * kResampleAllpass[0][0];
600         state[4] = tmp0;
601         diff = tmp1 - state[6];
602         // scale down and round
603         diff = diff >> 14;
604         if (diff < 0)
605             diff += 1;
606         tmp0 = state[5] + diff * kResampleAllpass[0][1];
607         state[5] = tmp1;
608         diff = tmp0 - state[7];
609         // scale down and truncate
610         diff = diff >> 14;
611         if (diff < 0)
612             diff += 1;
613         state[7] = state[6] + diff * kResampleAllpass[0][2];
614         state[6] = tmp0;
615 
616         // average the two allpass outputs, scale down and store
617         out[i << 1] = (out[i << 1] + (state[7] >> 1)) >> 15;
618     }
619 
620     // switch to odd output samples
621     out++;
622 
623     // lower allpass filter: even input -> odd output samples
624     for (i = 0; i < len; i++)
625     {
626         tmp0 = in[i << 1];
627         diff = tmp0 - state[9];
628         // scale down and round
629         diff = (diff + (1 << 13)) >> 14;
630         tmp1 = state[8] + diff * kResampleAllpass[1][0];
631         state[8] = tmp0;
632         diff = tmp1 - state[10];
633         // scale down and truncate
634         diff = diff >> 14;
635         if (diff < 0)
636             diff += 1;
637         tmp0 = state[9] + diff * kResampleAllpass[1][1];
638         state[9] = tmp1;
639         diff = tmp0 - state[11];
640         // scale down and truncate
641         diff = diff >> 14;
642         if (diff < 0)
643             diff += 1;
644         state[11] = state[10] + diff * kResampleAllpass[1][2];
645         state[10] = tmp0;
646 
647         // scale down, round and store
648         out[i << 1] = state[11] >> 1;
649     }
650 
651     // upper allpass filter: odd input -> odd output samples
652     in++;
653     for (i = 0; i < len; i++)
654     {
655         tmp0 = in[i << 1];
656         diff = tmp0 - state[13];
657         // scale down and round
658         diff = (diff + (1 << 13)) >> 14;
659         tmp1 = state[12] + diff * kResampleAllpass[0][0];
660         state[12] = tmp0;
661         diff = tmp1 - state[14];
662         // scale down and round
663         diff = diff >> 14;
664         if (diff < 0)
665             diff += 1;
666         tmp0 = state[13] + diff * kResampleAllpass[0][1];
667         state[13] = tmp1;
668         diff = tmp0 - state[15];
669         // scale down and truncate
670         diff = diff >> 14;
671         if (diff < 0)
672             diff += 1;
673         state[15] = state[14] + diff * kResampleAllpass[0][2];
674         state[14] = tmp0;
675 
676         // average the two allpass outputs, scale down and store
677         out[i << 1] = (out[i << 1] + (state[15] >> 1)) >> 15;
678     }
679 }
680