Eliminate function pointers from the resampler.
[opus.git] / silk / resampler.c
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions are met:
6 - Redistributions of source code must retain the above copyright notice,
7 this list of conditions and the following disclaimer.
8 - Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 - Neither the name of Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 /* Matrix of resampling methods used:
33  *                                        Fs_out (kHz)
34  *                        8      12     16     24     32     44.1   48
35  *
36  *               8        C      UF     U      UF     UF     UF     UF
37  *              12        AF     C      UF     U      UF     UF     UF
38  *              16        D      AF     C      UF     U      UF     UF
39  * Fs_in (kHz)  24        AIF    D      AF     C      UF     UF     U
40  *              32        UF     AF     D      AF     C      UF     UF
41  *              44.1      AMI    AMI    AMI    AMI    AMI    C      UF
42  *              48        DAF    DAF    AF     D      AF     UF     C
43  *
44  * default method: UF
45  *
46  * C   -> Copy (no resampling)
47  * D   -> Allpass-based 2x downsampling
48  * U   -> Allpass-based 2x upsampling
49  * DAF -> Allpass-based 2x downsampling followed by AR2 filter followed by FIR interpolation
50  * UF  -> Allpass-based 2x upsampling followed by FIR interpolation
51  * AMI -> ARMA4 filter followed by FIR interpolation
52  * AF  -> AR2 filter followed by FIR interpolation
53  *
54  * Input signals sampled above 48 kHz are first downsampled to at most 48 kHz.
55  * Output signals sampled above 48 kHz are upsampled from at most 48 kHz.
56  */
57
58 #include "resampler_private.h"
59
60 /* Greatest common divisor */
61 static opus_int32 gcd(
62     opus_int32 a,
63     opus_int32 b
64 )
65 {
66     opus_int32 tmp;
67     while( b > 0 ) {
68         tmp = a - b * silk_DIV32( a, b );
69         a   = b;
70         b   = tmp;
71     }
72     return a;
73 }
74
75 #define USE_silk_resampler_copy (0)
76 #define USE_silk_resampler_private_up2_HQ_wrapper (1)
77 #define USE_silk_resampler_private_IIR_FIR (2)
78 #define USE_silk_resampler_private_down_FIR (3)
79
80 /* Initialize/reset the resampler state for a given pair of input/output sampling rates */
81 opus_int silk_resampler_init(
82     silk_resampler_state_struct    *S,                    /* I/O: Resampler state             */
83     opus_int32                            Fs_Hz_in,    /* I:    Input sampling rate (Hz)    */
84     opus_int32                            Fs_Hz_out    /* I:    Output sampling rate (Hz)    */
85 )
86 {
87     opus_int32 cycleLen, cyclesPerBatch, up2 = 0, down2 = 0;
88
89     /* Clear state */
90     silk_memset( S, 0, sizeof( silk_resampler_state_struct ) );
91
92     /* Input checking */
93     if( Fs_Hz_in < 8000 || Fs_Hz_in >  48000 || Fs_Hz_out < 8000 || Fs_Hz_out >  48000 ) {
94         silk_assert( 0 );
95         return -1;
96     }
97
98     /* Number of samples processed per batch */
99     /* First, try 10 ms frames */
100     S->batchSize = silk_DIV32_16( Fs_Hz_in, 100 );
101     if( ( silk_MUL( S->batchSize, 100 ) != Fs_Hz_in ) || ( Fs_Hz_in % 100 != 0 ) ) {
102         /* No integer number of input or output samples with 10 ms frames, use greatest common divisor */
103         cycleLen = silk_DIV32( Fs_Hz_in, gcd( Fs_Hz_in, Fs_Hz_out ) );
104         cyclesPerBatch = silk_DIV32( RESAMPLER_MAX_BATCH_SIZE_IN, cycleLen );
105         if( cyclesPerBatch == 0 ) {
106             /* cycleLen too big, let's just use the maximum batch size. Some distortion will result. */
107             S->batchSize = RESAMPLER_MAX_BATCH_SIZE_IN;
108             silk_assert( 0 );
109         } else {
110             S->batchSize = silk_MUL( cyclesPerBatch, cycleLen );
111         }
112     }
113
114
115     /* Find resampler with the right sampling ratio */
116     if( Fs_Hz_out > Fs_Hz_in ) {
117         /* Upsample */
118         if( Fs_Hz_out == silk_MUL( Fs_Hz_in, 2 ) ) {                             /* Fs_out : Fs_in = 2 : 1 */
119             /* Special case: directly use 2x upsampler */
120             S->resampler_function = USE_silk_resampler_private_up2_HQ_wrapper;
121         } else {
122             /* Default resampler */
123             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
124             up2 = 1;
125             S->up2_hq = Fs_Hz_in <= 24000;
126         }
127     } else if ( Fs_Hz_out < Fs_Hz_in ) {
128         /* Downsample */
129         if( silk_MUL( Fs_Hz_out, 4 ) == silk_MUL( Fs_Hz_in, 3 ) ) {               /* Fs_out : Fs_in = 3 : 4 */
130             S->FIR_Fracs = 3;
131             S->Coefs = silk_Resampler_3_4_COEFS;
132             S->resampler_function = USE_silk_resampler_private_down_FIR;
133         } else if( silk_MUL( Fs_Hz_out, 3 ) == silk_MUL( Fs_Hz_in, 2 ) ) {        /* Fs_out : Fs_in = 2 : 3 */
134             S->FIR_Fracs = 2;
135             S->Coefs = silk_Resampler_2_3_COEFS;
136             S->resampler_function = USE_silk_resampler_private_down_FIR;
137         } else if( silk_MUL( Fs_Hz_out, 2 ) == Fs_Hz_in ) {                      /* Fs_out : Fs_in = 1 : 2 */
138             S->FIR_Fracs = 1;
139             S->Coefs = silk_Resampler_1_2_COEFS;
140             S->resampler_function = USE_silk_resampler_private_down_FIR;
141         } else if( silk_MUL( Fs_Hz_out, 8 ) == silk_MUL( Fs_Hz_in, 3 ) ) {        /* Fs_out : Fs_in = 3 : 8 */
142             S->FIR_Fracs = 3;
143             S->Coefs = silk_Resampler_3_8_COEFS;
144             S->resampler_function = USE_silk_resampler_private_down_FIR;
145         } else if( silk_MUL( Fs_Hz_out, 3 ) == Fs_Hz_in ) {                      /* Fs_out : Fs_in = 1 : 3 */
146             S->FIR_Fracs = 1;
147             S->Coefs = silk_Resampler_1_3_COEFS;
148             S->resampler_function = USE_silk_resampler_private_down_FIR;
149         } else if( silk_MUL( Fs_Hz_out, 4 ) == Fs_Hz_in ) {                      /* Fs_out : Fs_in = 1 : 4 */
150             S->FIR_Fracs = 1;
151             down2 = 1;
152             S->Coefs = silk_Resampler_1_2_COEFS;
153             S->resampler_function = USE_silk_resampler_private_down_FIR;
154         } else if( silk_MUL( Fs_Hz_out, 6 ) == Fs_Hz_in ) {                      /* Fs_out : Fs_in = 1 : 6 */
155             S->FIR_Fracs = 1;
156             down2 = 1;
157             S->Coefs = silk_Resampler_1_3_COEFS;
158             S->resampler_function = USE_silk_resampler_private_down_FIR;
159         } else if( silk_MUL( Fs_Hz_out, 441 ) == silk_MUL( Fs_Hz_in, 80 ) ) {     /* Fs_out : Fs_in = 80 : 441 */
160             S->Coefs = silk_Resampler_80_441_ARMA4_COEFS;
161             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
162         } else if( silk_MUL( Fs_Hz_out, 441 ) == silk_MUL( Fs_Hz_in, 120 ) ) {    /* Fs_out : Fs_in = 120 : 441 */
163             S->Coefs = silk_Resampler_120_441_ARMA4_COEFS;
164             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
165         } else if( silk_MUL( Fs_Hz_out, 441 ) == silk_MUL( Fs_Hz_in, 160 ) ) {    /* Fs_out : Fs_in = 160 : 441 */
166             S->Coefs = silk_Resampler_160_441_ARMA4_COEFS;
167             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
168         } else if( silk_MUL( Fs_Hz_out, 441 ) == silk_MUL( Fs_Hz_in, 240 ) ) {    /* Fs_out : Fs_in = 240 : 441 */
169             S->Coefs = silk_Resampler_240_441_ARMA4_COEFS;
170             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
171         } else if( silk_MUL( Fs_Hz_out, 441 ) == silk_MUL( Fs_Hz_in, 320 ) ) {    /* Fs_out : Fs_in = 320 : 441 */
172             S->Coefs = silk_Resampler_320_441_ARMA4_COEFS;
173             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
174         } else {
175             /* Default resampler */
176             S->resampler_function = USE_silk_resampler_private_IIR_FIR;
177             up2 = 1;
178             S->up2_hq = Fs_Hz_in <= 24000;
179         }
180     } else {
181         /* Input and output sampling rates are equal: copy */
182         S->resampler_function = USE_silk_resampler_copy;
183     }
184
185     S->input2x = up2 | down2;
186
187     /* Ratio of input/output samples */
188     S->invRatio_Q16 = silk_LSHIFT32( silk_DIV32( silk_LSHIFT32( Fs_Hz_in, 14 + up2 - down2 ), Fs_Hz_out ), 2 );
189     /* Make sure the ratio is rounded up */
190     while( silk_SMULWW( S->invRatio_Q16, silk_LSHIFT32( Fs_Hz_out, down2 ) ) < silk_LSHIFT32( Fs_Hz_in, up2 ) ) {
191         S->invRatio_Q16++;
192     }
193
194     S->magic_number = 123456789;
195
196     return 0;
197 }
198
199 /* Clear the states of all resampling filters, without resetting sampling rate ratio */
200 opus_int silk_resampler_clear(
201     silk_resampler_state_struct    *S            /* I/O: Resampler state             */
202 )
203 {
204     /* Clear state */
205     silk_memset( S->sDown2, 0, sizeof( S->sDown2 ) );
206     silk_memset( S->sIIR,   0, sizeof( S->sIIR ) );
207     silk_memset( S->sFIR,   0, sizeof( S->sFIR ) );
208     return 0;
209 }
210
211 /* Resampler: convert from one sampling rate to another                                 */
212 opus_int silk_resampler(
213     silk_resampler_state_struct    *S,                    /* I/O: Resampler state             */
214     opus_int16                            out[],        /* O:    Output signal                 */
215     const opus_int16                        in[],        /* I:    Input signal                */
216     opus_int32                            inLen        /* I:    Number of input samples        */
217 )
218 {
219     /* Verify that state was initialized and has not been corrupted */
220     if( S->magic_number != 123456789 ) {
221         silk_assert( 0 );
222         return -1;
223     }
224
225     /* Input and output sampling rate are at most 48000 Hz */
226     switch(S->resampler_function) {
227         case USE_silk_resampler_private_up2_HQ_wrapper:
228             silk_resampler_private_up2_HQ_wrapper( S, out, in, inLen );
229             break;
230         case USE_silk_resampler_private_IIR_FIR:
231             silk_resampler_private_IIR_FIR( S, out, in, inLen );
232             break;
233         case USE_silk_resampler_private_down_FIR:
234             silk_resampler_private_down_FIR( S, out, in, inLen );
235             break;
236         default:
237             silk_memcpy( out, in, inLen * sizeof( opus_int16 ) );
238     }
239
240     return 0;
241 }