diff options
Diffstat (limited to 'silk/SKP_Silk_resampler.c')
| m--------- | silk | 6 | ||||
| -rw-r--r-- | silk/SKP_Silk_resampler.c | 323 |
2 files changed, 323 insertions, 6 deletions
diff --git a/silk b/silk deleted file mode 160000 -Subproject 8a8b76efeeccaccf402b0b2b4e469980d0a4831 diff --git a/silk/SKP_Silk_resampler.c b/silk/SKP_Silk_resampler.c new file mode 100644 index 00000000..980f81fe --- /dev/null +++ b/silk/SKP_Silk_resampler.c @@ -0,0 +1,323 @@ +/***********************************************************************
+Copyright (c) 2006-2011, Skype Limited. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, (subject to the limitations in the disclaimer below)
+are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+- Neither the name of Skype Limited, nor the names of specific
+contributors, may be used to endorse or promote products derived from
+this software without specific prior written permission.
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************/
+
+/* *
+ * File Name: SKP_Silk_resampler.c *
+ * *
+ * Description: Interface to collection of resamplers *
+ * *
+ * Copyright 2010 (c), Skype Limited *
+ * All rights reserved. *
+ * */
+
+/* Matrix of resampling methods used:
+ * Fs_out (kHz)
+ * 8 12 16 24 32 44.1 48
+ *
+ * 8 C UF U UF UF UF UF
+ * 12 AF C UF U UF UF UF
+ * 16 D AF C UF U UF UF
+ * Fs_in (kHz) 24 AIF D AF C UF UF U
+ * 32 UF AF D AF C UF UF
+ * 44.1 AMI AMI AMI AMI AMI C UF
+ * 48 DAF DAF AF D AF UF C
+ *
+ * default method: UF
+ *
+ * C -> Copy (no resampling)
+ * D -> Allpass-based 2x downsampling
+ * U -> Allpass-based 2x upsampling
+ * DAF -> Allpass-based 2x downsampling followed by AR2 filter followed by FIR interpolation
+ * UF -> Allpass-based 2x upsampling followed by FIR interpolation
+ * AMI -> ARMA4 filter followed by FIR interpolation
+ * AF -> AR2 filter followed by FIR interpolation
+ *
+ * Input signals sampled above 48 kHz are first downsampled to at most 48 kHz.
+ * Output signals sampled above 48 kHz are upsampled from at most 48 kHz.
+ */
+
+#include "SKP_Silk_resampler_private.h"
+
+/* Greatest common divisor */
+static SKP_int32 gcd(
+ SKP_int32 a,
+ SKP_int32 b
+)
+{
+ SKP_int32 tmp;
+ while( b > 0 ) {
+ tmp = a - b * SKP_DIV32( a, b );
+ a = b;
+ b = tmp;
+ }
+ return a;
+}
+
+/* Initialize/reset the resampler state for a given pair of input/output sampling rates */
+SKP_int SKP_Silk_resampler_init(
+ SKP_Silk_resampler_state_struct *S, /* I/O: Resampler state */
+ SKP_int32 Fs_Hz_in, /* I: Input sampling rate (Hz) */
+ SKP_int32 Fs_Hz_out /* I: Output sampling rate (Hz) */
+)
+{
+ SKP_int32 cycleLen, cyclesPerBatch, up2 = 0, down2 = 0;
+
+ /* Clear state */
+ SKP_memset( S, 0, sizeof( SKP_Silk_resampler_state_struct ) );
+
+ /* Input checking */
+#if RESAMPLER_SUPPORT_ABOVE_48KHZ
+ if( Fs_Hz_in < 8000 || Fs_Hz_in > 192000 || Fs_Hz_out < 8000 || Fs_Hz_out > 192000 ) {
+#else
+ if( Fs_Hz_in < 8000 || Fs_Hz_in > 48000 || Fs_Hz_out < 8000 || Fs_Hz_out > 48000 ) {
+#endif
+ SKP_assert( 0 );
+ return -1;
+ }
+
+#if RESAMPLER_SUPPORT_ABOVE_48KHZ
+ /* Determine pre downsampling and post upsampling */
+ if( Fs_Hz_in > 96000 ) {
+ S->nPreDownsamplers = 2;
+ S->down_pre_function = SKP_Silk_resampler_private_down4;
+ } else if( Fs_Hz_in > 48000 ) {
+ S->nPreDownsamplers = 1;
+ S->down_pre_function = SKP_Silk_resampler_down2;
+ } else {
+ S->nPreDownsamplers = 0;
+ S->down_pre_function = NULL;
+ }
+
+ if( Fs_Hz_out > 96000 ) {
+ S->nPostUpsamplers = 2;
+ S->up_post_function = SKP_Silk_resampler_private_up4;
+ } else if( Fs_Hz_out > 48000 ) {
+ S->nPostUpsamplers = 1;
+ S->up_post_function = SKP_Silk_resampler_up2;
+ } else {
+ S->nPostUpsamplers = 0;
+ S->up_post_function = NULL;
+ }
+
+ if( S->nPreDownsamplers + S->nPostUpsamplers > 0 ) {
+ /* Ratio of output/input samples */
+ S->ratio_Q16 = SKP_LSHIFT32( SKP_DIV32( SKP_LSHIFT32( Fs_Hz_out, 13 ), Fs_Hz_in ), 3 );
+ /* Make sure the ratio is rounded up */
+ while( SKP_SMULWW( S->ratio_Q16, Fs_Hz_in ) < Fs_Hz_out ) S->ratio_Q16++;
+
+ /* Batch size is 10 ms */
+ S->batchSizePrePost = SKP_DIV32_16( Fs_Hz_in, 100 );
+
+ /* Convert sampling rate to those after pre-downsampling and before post-upsampling */
+ Fs_Hz_in = SKP_RSHIFT( Fs_Hz_in, S->nPreDownsamplers );
+ Fs_Hz_out = SKP_RSHIFT( Fs_Hz_out, S->nPostUpsamplers );
+ }
+#endif
+
+ /* Number of samples processed per batch */
+ /* First, try 10 ms frames */
+ S->batchSize = SKP_DIV32_16( Fs_Hz_in, 100 );
+ if( ( SKP_MUL( S->batchSize, 100 ) != Fs_Hz_in ) || ( Fs_Hz_in % 100 != 0 ) ) {
+ /* No integer number of input or output samples with 10 ms frames, use greatest common divisor */
+ cycleLen = SKP_DIV32( Fs_Hz_in, gcd( Fs_Hz_in, Fs_Hz_out ) );
+ cyclesPerBatch = SKP_DIV32( RESAMPLER_MAX_BATCH_SIZE_IN, cycleLen );
+ if( cyclesPerBatch == 0 ) {
+ /* cycleLen too big, let's just use the maximum batch size. Some distortion will result. */
+ S->batchSize = RESAMPLER_MAX_BATCH_SIZE_IN;
+ SKP_assert( 0 );
+ } else {
+ S->batchSize = SKP_MUL( cyclesPerBatch, cycleLen );
+ }
+ }
+
+
+ /* Find resampler with the right sampling ratio */
+ if( Fs_Hz_out > Fs_Hz_in ) {
+ /* Upsample */
+ if( Fs_Hz_out == SKP_MUL( Fs_Hz_in, 2 ) ) { /* Fs_out : Fs_in = 2 : 1 */
+ /* Special case: directly use 2x upsampler */
+ S->resampler_function = SKP_Silk_resampler_private_up2_HQ_wrapper;
+ } else {
+ /* Default resampler */
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ up2 = 1;
+ if( Fs_Hz_in > 24000 ) {
+ /* Low-quality all-pass upsampler */
+ S->up2_function = SKP_Silk_resampler_up2;
+ } else {
+ /* High-quality all-pass upsampler */
+ S->up2_function = SKP_Silk_resampler_private_up2_HQ;
+ }
+ }
+ } else if ( Fs_Hz_out < Fs_Hz_in ) {
+ /* Downsample */
+ if( SKP_MUL( Fs_Hz_out, 4 ) == SKP_MUL( Fs_Hz_in, 3 ) ) { /* Fs_out : Fs_in = 3 : 4 */
+ S->FIR_Fracs = 3;
+ S->Coefs = SKP_Silk_Resampler_3_4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 3 ) == SKP_MUL( Fs_Hz_in, 2 ) ) { /* Fs_out : Fs_in = 2 : 3 */
+ S->FIR_Fracs = 2;
+ S->Coefs = SKP_Silk_Resampler_2_3_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 2 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 2 */
+ S->FIR_Fracs = 1;
+ S->Coefs = SKP_Silk_Resampler_1_2_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 8 ) == SKP_MUL( Fs_Hz_in, 3 ) ) { /* Fs_out : Fs_in = 3 : 8 */
+ S->FIR_Fracs = 3;
+ S->Coefs = SKP_Silk_Resampler_3_8_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 3 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 3 */
+ S->FIR_Fracs = 1;
+ S->Coefs = SKP_Silk_Resampler_1_3_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 4 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 4 */
+ S->FIR_Fracs = 1;
+ down2 = 1;
+ S->Coefs = SKP_Silk_Resampler_1_2_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 6 ) == Fs_Hz_in ) { /* Fs_out : Fs_in = 1 : 6 */
+ S->FIR_Fracs = 1;
+ down2 = 1;
+ S->Coefs = SKP_Silk_Resampler_1_3_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_down_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 441 ) == SKP_MUL( Fs_Hz_in, 80 ) ) { /* Fs_out : Fs_in = 80 : 441 */
+ S->Coefs = SKP_Silk_Resampler_80_441_ARMA4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 441 ) == SKP_MUL( Fs_Hz_in, 120 ) ) { /* Fs_out : Fs_in = 120 : 441 */
+ S->Coefs = SKP_Silk_Resampler_120_441_ARMA4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 441 ) == SKP_MUL( Fs_Hz_in, 160 ) ) { /* Fs_out : Fs_in = 160 : 441 */
+ S->Coefs = SKP_Silk_Resampler_160_441_ARMA4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 441 ) == SKP_MUL( Fs_Hz_in, 240 ) ) { /* Fs_out : Fs_in = 240 : 441 */
+ S->Coefs = SKP_Silk_Resampler_240_441_ARMA4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ } else if( SKP_MUL( Fs_Hz_out, 441 ) == SKP_MUL( Fs_Hz_in, 320 ) ) { /* Fs_out : Fs_in = 320 : 441 */
+ S->Coefs = SKP_Silk_Resampler_320_441_ARMA4_COEFS;
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ } else {
+ /* Default resampler */
+ S->resampler_function = SKP_Silk_resampler_private_IIR_FIR;
+ up2 = 1;
+ if( Fs_Hz_in > 24000 ) {
+ /* Low-quality all-pass upsampler */
+ S->up2_function = SKP_Silk_resampler_up2;
+ } else {
+ /* High-quality all-pass upsampler */
+ S->up2_function = SKP_Silk_resampler_private_up2_HQ;
+ }
+ }
+ } else {
+ /* Input and output sampling rates are equal: copy */
+ S->resampler_function = SKP_Silk_resampler_private_copy;
+ }
+
+ S->input2x = up2 | down2;
+
+ /* Ratio of input/output samples */
+ S->invRatio_Q16 = SKP_LSHIFT32( SKP_DIV32( SKP_LSHIFT32( Fs_Hz_in, 14 + up2 - down2 ), Fs_Hz_out ), 2 );
+ /* Make sure the ratio is rounded up */
+ while( SKP_SMULWW( S->invRatio_Q16, SKP_LSHIFT32( Fs_Hz_out, down2 ) ) < SKP_LSHIFT32( Fs_Hz_in, up2 ) ) {
+ S->invRatio_Q16++;
+ }
+
+ S->magic_number = 123456789;
+
+ return 0;
+}
+
+/* Clear the states of all resampling filters, without resetting sampling rate ratio */
+SKP_int SKP_Silk_resampler_clear(
+ SKP_Silk_resampler_state_struct *S /* I/O: Resampler state */
+)
+{
+ /* Clear state */
+ SKP_memset( S->sDown2, 0, sizeof( S->sDown2 ) );
+ SKP_memset( S->sIIR, 0, sizeof( S->sIIR ) );
+ SKP_memset( S->sFIR, 0, sizeof( S->sFIR ) );
+#if RESAMPLER_SUPPORT_ABOVE_48KHZ
+ SKP_memset( S->sDownPre, 0, sizeof( S->sDownPre ) );
+ SKP_memset( S->sUpPost, 0, sizeof( S->sUpPost ) );
+#endif
+ return 0;
+}
+
+/* Resampler: convert from one sampling rate to another */
+SKP_int SKP_Silk_resampler(
+ SKP_Silk_resampler_state_struct *S, /* I/O: Resampler state */
+ SKP_int16 out[], /* O: Output signal */
+ const SKP_int16 in[], /* I: Input signal */
+ SKP_int32 inLen /* I: Number of input samples */
+)
+{
+ /* Verify that state was initialized and has not been corrupted */
+ if( S->magic_number != 123456789 ) {
+ SKP_assert( 0 );
+ return -1;
+ }
+
+#if RESAMPLER_SUPPORT_ABOVE_48KHZ
+ if( S->nPreDownsamplers + S->nPostUpsamplers > 0 ) {
+ /* The input and/or output sampling rate is above 48000 Hz */
+ SKP_int32 nSamplesIn, nSamplesOut;
+ SKP_int16 in_buf[ 480 ], out_buf[ 480 ];
+
+ while( inLen > 0 ) {
+ /* Number of input and output samples to process */
+ nSamplesIn = SKP_min( inLen, S->batchSizePrePost );
+ nSamplesOut = SKP_SMULWB( S->ratio_Q16, nSamplesIn );
+
+ SKP_assert( SKP_RSHIFT32( nSamplesIn, S->nPreDownsamplers ) <= 480 );
+ SKP_assert( SKP_RSHIFT32( nSamplesOut, S->nPostUpsamplers ) <= 480 );
+
+ if( S->nPreDownsamplers > 0 ) {
+ S->down_pre_function( S->sDownPre, in_buf, in, nSamplesIn );
+ if( S->nPostUpsamplers > 0 ) {
+ S->resampler_function( S, out_buf, in_buf, SKP_RSHIFT32( nSamplesIn, S->nPreDownsamplers ) );
+ S->up_post_function( S->sUpPost, out, out_buf, SKP_RSHIFT32( nSamplesOut, S->nPostUpsamplers ) );
+ } else {
+ S->resampler_function( S, out, in_buf, SKP_RSHIFT32( nSamplesIn, S->nPreDownsamplers ) );
+ }
+ } else {
+ S->resampler_function( S, out_buf, in, SKP_RSHIFT32( nSamplesIn, S->nPreDownsamplers ) );
+ S->up_post_function( S->sUpPost, out, out_buf, SKP_RSHIFT32( nSamplesOut, S->nPostUpsamplers ) );
+ }
+
+ in += nSamplesIn;
+ out += nSamplesOut;
+ inLen -= nSamplesIn;
+ }
+ } else
+#endif
+ {
+ /* Input and output sampling rate are at most 48000 Hz */
+ S->resampler_function( S, out, in, inLen );
+ }
+
+ return 0;
+}
|