cannam@154: /*********************************************************************** cannam@154: Copyright (c) 2006-2011, Skype Limited. All rights reserved. cannam@154: Redistribution and use in source and binary forms, with or without cannam@154: modification, are permitted provided that the following conditions cannam@154: are met: cannam@154: - Redistributions of source code must retain the above copyright notice, cannam@154: this list of conditions and the following disclaimer. cannam@154: - Redistributions in binary form must reproduce the above copyright cannam@154: notice, this list of conditions and the following disclaimer in the cannam@154: documentation and/or other materials provided with the distribution. cannam@154: - Neither the name of Internet Society, IETF or IETF Trust, nor the cannam@154: names of specific contributors, may be used to endorse or promote cannam@154: products derived from this software without specific prior written cannam@154: permission. cannam@154: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" cannam@154: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE cannam@154: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE cannam@154: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE cannam@154: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR cannam@154: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF cannam@154: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS cannam@154: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN cannam@154: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) cannam@154: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE cannam@154: POSSIBILITY OF SUCH DAMAGE. cannam@154: ***********************************************************************/ cannam@154: cannam@154: #ifdef HAVE_CONFIG_H cannam@154: #include "config.h" cannam@154: #endif cannam@154: cannam@154: /* cannam@154: * Matrix of resampling methods used: cannam@154: * Fs_out (kHz) cannam@154: * 8 12 16 24 48 cannam@154: * cannam@154: * 8 C UF U UF UF cannam@154: * 12 AF C UF U UF cannam@154: * Fs_in (kHz) 16 D AF C UF UF cannam@154: * 24 AF D AF C U cannam@154: * 48 AF AF AF D C cannam@154: * cannam@154: * C -> Copy (no resampling) cannam@154: * D -> Allpass-based 2x downsampling cannam@154: * U -> Allpass-based 2x upsampling cannam@154: * UF -> Allpass-based 2x upsampling followed by FIR interpolation cannam@154: * AF -> AR2 filter followed by FIR interpolation cannam@154: */ cannam@154: cannam@154: #include "resampler_private.h" cannam@154: cannam@154: /* Tables with delay compensation values to equalize total delay for different modes */ cannam@154: static const opus_int8 delay_matrix_enc[ 5 ][ 3 ] = { cannam@154: /* in \ out 8 12 16 */ cannam@154: /* 8 */ { 6, 0, 3 }, cannam@154: /* 12 */ { 0, 7, 3 }, cannam@154: /* 16 */ { 0, 1, 10 }, cannam@154: /* 24 */ { 0, 2, 6 }, cannam@154: /* 48 */ { 18, 10, 12 } cannam@154: }; cannam@154: cannam@154: static const opus_int8 delay_matrix_dec[ 3 ][ 5 ] = { cannam@154: /* in \ out 8 12 16 24 48 */ cannam@154: /* 8 */ { 4, 0, 2, 0, 0 }, cannam@154: /* 12 */ { 0, 9, 4, 7, 4 }, cannam@154: /* 16 */ { 0, 3, 12, 7, 7 } cannam@154: }; cannam@154: cannam@154: /* Simple way to make [8000, 12000, 16000, 24000, 48000] to [0, 1, 2, 3, 4] */ cannam@154: #define rateID(R) ( ( ( ((R)>>12) - ((R)>16000) ) >> ((R)>24000) ) - 1 ) cannam@154: cannam@154: #define USE_silk_resampler_copy (0) cannam@154: #define USE_silk_resampler_private_up2_HQ_wrapper (1) cannam@154: #define USE_silk_resampler_private_IIR_FIR (2) cannam@154: #define USE_silk_resampler_private_down_FIR (3) cannam@154: cannam@154: /* Initialize/reset the resampler state for a given pair of input/output sampling rates */ cannam@154: opus_int silk_resampler_init( cannam@154: silk_resampler_state_struct *S, /* I/O Resampler state */ cannam@154: opus_int32 Fs_Hz_in, /* I Input sampling rate (Hz) */ cannam@154: opus_int32 Fs_Hz_out, /* I Output sampling rate (Hz) */ cannam@154: opus_int forEnc /* I If 1: encoder; if 0: decoder */ cannam@154: ) cannam@154: { cannam@154: opus_int up2x; cannam@154: cannam@154: /* Clear state */ cannam@154: silk_memset( S, 0, sizeof( silk_resampler_state_struct ) ); cannam@154: cannam@154: /* Input checking */ cannam@154: if( forEnc ) { cannam@154: if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 && Fs_Hz_in != 24000 && Fs_Hz_in != 48000 ) || cannam@154: ( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 ) ) { cannam@154: celt_assert( 0 ); cannam@154: return -1; cannam@154: } cannam@154: S->inputDelay = delay_matrix_enc[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ]; cannam@154: } else { cannam@154: if( ( Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 ) || cannam@154: ( Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 && Fs_Hz_out != 24000 && Fs_Hz_out != 48000 ) ) { cannam@154: celt_assert( 0 ); cannam@154: return -1; cannam@154: } cannam@154: S->inputDelay = delay_matrix_dec[ rateID( Fs_Hz_in ) ][ rateID( Fs_Hz_out ) ]; cannam@154: } cannam@154: cannam@154: S->Fs_in_kHz = silk_DIV32_16( Fs_Hz_in, 1000 ); cannam@154: S->Fs_out_kHz = silk_DIV32_16( Fs_Hz_out, 1000 ); cannam@154: cannam@154: /* Number of samples processed per batch */ cannam@154: S->batchSize = S->Fs_in_kHz * RESAMPLER_MAX_BATCH_SIZE_MS; cannam@154: cannam@154: /* Find resampler with the right sampling ratio */ cannam@154: up2x = 0; cannam@154: if( Fs_Hz_out > Fs_Hz_in ) { cannam@154: /* Upsample */ cannam@154: if( Fs_Hz_out == silk_MUL( Fs_Hz_in, 2 ) ) { /* Fs_out : Fs_in = 2 : 1 */ cannam@154: /* Special case: directly use 2x upsampler */ cannam@154: S->resampler_function = USE_silk_resampler_private_up2_HQ_wrapper; cannam@154: } else { cannam@154: /* Default resampler */ cannam@154: S->resampler_function = USE_silk_resampler_private_IIR_FIR; cannam@154: up2x = 1; cannam@154: } cannam@154: } else if ( Fs_Hz_out < Fs_Hz_in ) { cannam@154: /* Downsample */ cannam@154: S->resampler_function = USE_silk_resampler_private_down_FIR; cannam@154: if( silk_MUL( Fs_Hz_out, 4 ) == silk_MUL( Fs_Hz_in, 3 ) ) { /* Fs_out : Fs_in = 3 : 4 */ cannam@154: S->FIR_Fracs = 3; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR0; cannam@154: S->Coefs = silk_Resampler_3_4_COEFS; cannam@154: } else if( silk_MUL( Fs_Hz_out, 3 ) == silk_MUL( Fs_Hz_in, 2 ) ) { /* Fs_out : Fs_in = 2 : 3 */ cannam@154: S->FIR_Fracs = 2; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR0; cannam@154: S->Coefs = silk_Resampler_2_3_COEFS; cannam@154: } else if( silk_MUL( Fs_Hz_out, 2 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 2 */ cannam@154: S->FIR_Fracs = 1; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR1; cannam@154: S->Coefs = silk_Resampler_1_2_COEFS; cannam@154: } else if( silk_MUL( Fs_Hz_out, 3 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 3 */ cannam@154: S->FIR_Fracs = 1; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR2; cannam@154: S->Coefs = silk_Resampler_1_3_COEFS; cannam@154: } else if( silk_MUL( Fs_Hz_out, 4 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 4 */ cannam@154: S->FIR_Fracs = 1; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR2; cannam@154: S->Coefs = silk_Resampler_1_4_COEFS; cannam@154: } else if( silk_MUL( Fs_Hz_out, 6 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 6 */ cannam@154: S->FIR_Fracs = 1; cannam@154: S->FIR_Order = RESAMPLER_DOWN_ORDER_FIR2; cannam@154: S->Coefs = silk_Resampler_1_6_COEFS; cannam@154: } else { cannam@154: /* None available */ cannam@154: celt_assert( 0 ); cannam@154: return -1; cannam@154: } cannam@154: } else { cannam@154: /* Input and output sampling rates are equal: copy */ cannam@154: S->resampler_function = USE_silk_resampler_copy; cannam@154: } cannam@154: cannam@154: /* Ratio of input/output samples */ cannam@154: S->invRatio_Q16 = silk_LSHIFT32( silk_DIV32( silk_LSHIFT32( Fs_Hz_in, 14 + up2x ), Fs_Hz_out ), 2 ); cannam@154: /* Make sure the ratio is rounded up */ cannam@154: while( silk_SMULWW( S->invRatio_Q16, Fs_Hz_out ) < silk_LSHIFT32( Fs_Hz_in, up2x ) ) { cannam@154: S->invRatio_Q16++; cannam@154: } cannam@154: cannam@154: return 0; cannam@154: } cannam@154: cannam@154: /* Resampler: convert from one sampling rate to another */ cannam@154: /* Input and output sampling rate are at most 48000 Hz */ cannam@154: opus_int silk_resampler( cannam@154: silk_resampler_state_struct *S, /* I/O Resampler state */ cannam@154: opus_int16 out[], /* O Output signal */ cannam@154: const opus_int16 in[], /* I Input signal */ cannam@154: opus_int32 inLen /* I Number of input samples */ cannam@154: ) cannam@154: { cannam@154: opus_int nSamples; cannam@154: cannam@154: /* Need at least 1 ms of input data */ cannam@154: celt_assert( inLen >= S->Fs_in_kHz ); cannam@154: /* Delay can't exceed the 1 ms of buffering */ cannam@154: celt_assert( S->inputDelay <= S->Fs_in_kHz ); cannam@154: cannam@154: nSamples = S->Fs_in_kHz - S->inputDelay; cannam@154: cannam@154: /* Copy to delay buffer */ cannam@154: silk_memcpy( &S->delayBuf[ S->inputDelay ], in, nSamples * sizeof( opus_int16 ) ); cannam@154: cannam@154: switch( S->resampler_function ) { cannam@154: case USE_silk_resampler_private_up2_HQ_wrapper: cannam@154: silk_resampler_private_up2_HQ_wrapper( S, out, S->delayBuf, S->Fs_in_kHz ); cannam@154: silk_resampler_private_up2_HQ_wrapper( S, &out[ S->Fs_out_kHz ], &in[ nSamples ], inLen - S->Fs_in_kHz ); cannam@154: break; cannam@154: case USE_silk_resampler_private_IIR_FIR: cannam@154: silk_resampler_private_IIR_FIR( S, out, S->delayBuf, S->Fs_in_kHz ); cannam@154: silk_resampler_private_IIR_FIR( S, &out[ S->Fs_out_kHz ], &in[ nSamples ], inLen - S->Fs_in_kHz ); cannam@154: break; cannam@154: case USE_silk_resampler_private_down_FIR: cannam@154: silk_resampler_private_down_FIR( S, out, S->delayBuf, S->Fs_in_kHz ); cannam@154: silk_resampler_private_down_FIR( S, &out[ S->Fs_out_kHz ], &in[ nSamples ], inLen - S->Fs_in_kHz ); cannam@154: break; cannam@154: default: cannam@154: silk_memcpy( out, S->delayBuf, S->Fs_in_kHz * sizeof( opus_int16 ) ); cannam@154: silk_memcpy( &out[ S->Fs_out_kHz ], &in[ nSamples ], ( inLen - S->Fs_in_kHz ) * sizeof( opus_int16 ) ); cannam@154: } cannam@154: cannam@154: /* Copy to delay buffer */ cannam@154: silk_memcpy( S->delayBuf, &in[ inLen - S->inputDelay ], S->inputDelay * sizeof( opus_int16 ) ); cannam@154: cannam@154: return 0; cannam@154: }