Addressing multiple LSF-related issues
authorJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Sat, 11 Jun 2011 12:14:35 +0000 (08:14 -0400)
committerJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Sat, 11 Jun 2011 12:18:03 +0000 (08:18 -0400)
- Merged the LPC stabilization from NLSF2A_stable.c into NLSF2A.c
- The bandwidth expansion in NLSF2A() now operates on int32 LPC coefficients in
Q17 domain (instead of int16 Q12 coefficients)
- The function bwexpander_32() has a more precise way of updating the chirp
variable (round to nearest, instead of round down)
- Changed a few variables in NLSF_stabilize() from int16 to int32 to avoid signed
wrap-around (no difference in results as the wrap-around would always be reversed
later)
- The LSF codebook for WB speech has a quantization stepsize of 0.15 (was 0.16).
This doesn't break the bitstream, although it slightly limits quality of signals
encoded with the old version and decoded with the new one (I can't really hear it
and PESQ gives high scores as well).  I does improve handling of tonal signals.
- As discussed: the Q-domain of the poly function is now in Q16 (was Q20)
- As discussed: limiting the LSFs in NLSF_decode() to 0...32767
- The silk_NLSF_DELTA_MIN values were lowered to deal with a possible future situation with less or no input HP filtering.

39 files changed:
silk/fixed/silk_find_LPC_FIX.c
silk/float/silk_find_LPC_FLP.c
silk/float/silk_main_FLP.h
silk/float/silk_wrappers_FLP.c
silk/silk_CNG.c
silk/silk_LPC_inv_pred_gain.c
silk/silk_LPC_stabilize.c [deleted file]
silk/silk_LPC_synthesis_filter.c [deleted file]
silk/silk_LPC_synthesis_order16.c [deleted file]
silk/silk_NLSF2A.c
silk/silk_NLSF2A_stable.c [deleted file]
silk/silk_NLSF_VQ_weights_laroia.c
silk/silk_NLSF_decode.c
silk/silk_NLSF_del_dec_quant.c
silk/silk_NLSF_encode.c
silk/silk_NLSF_stabilize.c
silk/silk_NLSF_unpack.c
silk/silk_PLC.c
silk/silk_SigProc_FIX.h
silk/silk_array_maxabs.c
silk/silk_bwexpander.c
silk/silk_bwexpander_32.c
silk/silk_common.vcxproj
silk/silk_common.vcxproj.filters
silk/silk_control_codec.c
silk/silk_decode_parameters.c
silk/silk_decoder_set_fs.c
silk/silk_define.h
silk/silk_main.h
silk/silk_pitch_analysis_core.c
silk/silk_process_NLSFs.c
silk/silk_resampler.c
silk/silk_schur.c
silk/silk_schur64.c
silk/silk_stereo_find_predictor.c
silk/silk_tables.h
silk/silk_tables_NLSF_CB_NB_MB.c
silk/silk_tables_NLSF_CB_WB.c
silk_sources.mk

index 01d8246..97bf1c9 100644 (file)
@@ -97,7 +97,7 @@ void silk_find_LPC_FIX(
             silk_interpolate( NLSF0_Q15, prev_NLSFq_Q15, NLSF_Q15, k, LPC_order );\r
 \r
             /* Convert to LPC for residual energy evaluation */\r
-            silk_NLSF2A_stable( a_tmp_Q12, NLSF0_Q15, LPC_order );\r
+            silk_NLSF2A( a_tmp_Q12, NLSF0_Q15, LPC_order );\r
 \r
             /* Calculate residual energy with NLSF interpolation */\r
             silk_LPC_analysis_filter( LPC_res, x, a_tmp_Q12, 2 * subfr_length, LPC_order );\r
index d0f5295..1ad3c1c 100644 (file)
@@ -79,7 +79,7 @@ void silk_find_LPC_FLP(
             silk_interpolate( NLSF0_Q15, prev_NLSFq_Q15, NLSF_Q15, k, LPC_order );\r
 \r
             /* Convert to LPC for residual energy evaluation */\r
-            silk_NLSF2A_stable_FLP( a_tmp, NLSF0_Q15, LPC_order );\r
+            silk_NLSF2A_FLP( a_tmp, NLSF0_Q15, LPC_order );\r
 \r
             /* Calculate residual energy with LSF interpolation */\r
             silk_LPC_analysis_filter_FLP( LPC_res, a_tmp, x, 2 * subfr_length, LPC_order );\r
index 5d03f0c..d1f7021 100644 (file)
@@ -291,7 +291,7 @@ void silk_apply_sine_window_FLP(
     const SKP_int                   length              /* I    Window length, multiple of 4            */\r
 );\r
 \r
-/* Wrappers. Calls flp / fix code */\r
+/* Wrapper functions. Call flp / fix code */\r
 \r
 /* Convert AR filter coefficients to NLSF parameters */\r
 void silk_A2NLSF_FLP( \r
@@ -301,7 +301,7 @@ void silk_A2NLSF_FLP(
 );\r
 \r
 /* Convert NLSF parameters to AR prediction filter coefficients */\r
-void silk_NLSF2A_stable_FLP( \r
+void silk_NLSF2A_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
     const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
index 27a71e5..040d5d9 100644 (file)
@@ -47,7 +47,7 @@ void silk_A2NLSF_FLP(
 }\r
 \r
 /* Convert LSF parameters to AR prediction filter coefficients */\r
-void silk_NLSF2A_stable_FLP( \r
+void silk_NLSF2A_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
     const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
@@ -56,7 +56,7 @@ void silk_NLSF2A_stable_FLP(
     SKP_int   i;\r
     SKP_int16 a_fix_Q12[ MAX_LPC_ORDER ];\r
 \r
-    silk_NLSF2A_stable( a_fix_Q12, NLSF_Q15, LPC_order );\r
+    silk_NLSF2A( a_fix_Q12, NLSF_Q15, LPC_order );\r
 \r
     for( i = 0; i < LPC_order; i++ ) {\r
         pAR[ i ] = ( SKP_float )a_fix_Q12[ i ] * ( 1.0f / 4096.0f );\r
index 209e2d1..eb8654f 100644 (file)
@@ -29,7 +29,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Generates excitation for CNG LPC synthesis */\r
 SKP_INLINE void silk_CNG_exc(\r
-    SKP_int16                       residual[],         /* O    CNG residual signal Q0                      */\r
+    SKP_int32                       residual_Q10[],     /* O    CNG residual signal Q10                     */\r
     SKP_int32                       exc_buf_Q10[],      /* I    Random samples buffer Q10                   */\r
     SKP_int32                       Gain_Q16,           /* I    Gain to apply                               */\r
     SKP_int                         length,             /* I    Length                                      */\r
@@ -50,7 +50,7 @@ SKP_INLINE void silk_CNG_exc(
         idx = ( SKP_int )( SKP_RSHIFT( seed, 24 ) & exc_mask );\r
         SKP_assert( idx >= 0 );\r
         SKP_assert( idx <= CNG_BUF_MASK_MAX );\r
-        residual[ i ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( SKP_SMULWW( exc_buf_Q10[ idx ], Gain_Q16 ), 10 ) );\r
+        residual_Q10[ i ] = ( SKP_int16 )SKP_SAT16( SKP_SMULWW( exc_buf_Q10[ idx ], Gain_Q16 ) );\r
     }\r
     *rand_seed = seed;\r
 }\r
@@ -73,18 +73,17 @@ void silk_CNG_Reset(
 \r
 /* Updates CNG estimate, and applies the CNG when packet was lost   */\r
 void silk_CNG(\r
-    silk_decoder_state      *psDec,             /* I/O  Decoder state                               */\r
-    silk_decoder_control    *psDecCtrl,         /* I/O  Decoder control                             */\r
+    silk_decoder_state          *psDec,             /* I/O  Decoder state                               */\r
+    silk_decoder_control        *psDecCtrl,         /* I/O  Decoder control                             */\r
     SKP_int16                   signal[],           /* I/O  Signal                                      */\r
     SKP_int                     length              /* I    Length of residual                          */\r
 )\r
 {\r
-    SKP_int   i, subfr;\r
-    SKP_int32 tmp_32, Gain_Q26, max_Gain_Q16;\r
-    SKP_int16 LPC_buf[ MAX_LPC_ORDER ];\r
-    SKP_int16 CNG_sig[ MAX_FRAME_LENGTH ];\r
-    silk_CNG_struct *psCNG;\r
-    psCNG = &psDec->sCNG;\r
+    SKP_int   i, j, subfr;\r
+    SKP_int32 sum_Q6, max_Gain_Q16;\r
+    SKP_int16 A_Q12[ MAX_LPC_ORDER ];\r
+    SKP_int32 CNG_sig_Q10[ MAX_FRAME_LENGTH + MAX_LPC_ORDER ];\r
+    silk_CNG_struct *psCNG = &psDec->sCNG;\r
 \r
     if( psDec->fs_kHz != psCNG->fs_kHz ) {\r
         /* Reset state */\r
@@ -118,31 +117,39 @@ void silk_CNG(
         }\r
     }\r
 \r
-    /* Add CNG when packet is lost and / or when low speech activity */\r
+    /* Add CNG when packet is lost or during DTX */\r
     if( psDec->lossCnt ) {\r
 \r
         /* Generate CNG excitation */\r
-        silk_CNG_exc( CNG_sig, psCNG->CNG_exc_buf_Q10, \r
-                psCNG->CNG_smth_Gain_Q16, length, &psCNG->rand_seed );\r
+        silk_CNG_exc( CNG_sig_Q10 + MAX_LPC_ORDER, psCNG->CNG_exc_buf_Q10, psCNG->CNG_smth_Gain_Q16, length, &psCNG->rand_seed );\r
 \r
         /* Convert CNG NLSF to filter representation */\r
-        silk_NLSF2A_stable( LPC_buf, psCNG->CNG_smth_NLSF_Q15, psDec->LPC_order );\r
+        silk_NLSF2A( A_Q12, psCNG->CNG_smth_NLSF_Q15, psDec->LPC_order );\r
 \r
-        Gain_Q26 = ( SKP_int32 )1 << 26; /* 1.0 */\r
-        \r
         /* Generate CNG signal, by synthesis filtering */\r
-        if( psDec->LPC_order == 16 ) {\r
-            silk_LPC_synthesis_order16( CNG_sig, LPC_buf, \r
-                Gain_Q26, psCNG->CNG_synth_state, CNG_sig, length );\r
-        } else {\r
-            silk_LPC_synthesis_filter( CNG_sig, LPC_buf, \r
-                Gain_Q26, psCNG->CNG_synth_state, CNG_sig, length, psDec->LPC_order );\r
-        }\r
-        /* Mix with signal */\r
+        SKP_memcpy( CNG_sig_Q10, psCNG->CNG_synth_state, MAX_LPC_ORDER * sizeof( SKP_int32 ) );\r
         for( i = 0; i < length; i++ ) {\r
-            tmp_32 = signal[ i ] + CNG_sig[ i ];\r
-            signal[ i ] = SKP_SAT16( tmp_32 );\r
+            /* Partially unrolled */\r
+            sum_Q6 = SKP_SMULWB(         CNG_sig_Q10[ MAX_LPC_ORDER + i -  1 ], A_Q12[ 0 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  2 ], A_Q12[ 1 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  3 ], A_Q12[ 2 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  4 ], A_Q12[ 3 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  5 ], A_Q12[ 4 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  6 ], A_Q12[ 5 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  7 ], A_Q12[ 6 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  8 ], A_Q12[ 7 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i -  9 ], A_Q12[ 8 ] );\r
+            sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i - 10 ], A_Q12[ 9 ] );\r
+            for( j = 10; j < psDec->LPC_order; j++ ) {\r
+                sum_Q6 = SKP_SMLAWB( sum_Q6, CNG_sig_Q10[ MAX_LPC_ORDER + i - j - 1 ], A_Q12[ j ] );\r
+            }\r
+\r
+            /* Update states */\r
+            CNG_sig_Q10[ MAX_LPC_ORDER + i ] = SKP_ADD_LSHIFT( CNG_sig_Q10[ MAX_LPC_ORDER + i ], sum_Q6, 4 );\r
+\r
+            signal[ i ] = SKP_ADD_SAT16( signal[ i ], SKP_RSHIFT_ROUND( sum_Q6, 6 ) );\r
         }\r
+        SKP_memcpy( psCNG->CNG_synth_state, &CNG_sig_Q10[ length ], MAX_LPC_ORDER * sizeof( SKP_int32 ) );\r
     } else {\r
         SKP_memset( psCNG->CNG_synth_state, 0, psDec->LPC_order *  sizeof( SKP_int32 ) );\r
     }\r
index 08575d7..39c17ff 100644 (file)
@@ -103,7 +103,7 @@ static SKP_int LPC_inverse_pred_gain_QA(        /* O:   Returns 1 if unstable, o
 }\r
 \r
 /* For input in Q12 domain */\r
-SKP_int silk_LPC_inverse_pred_gain(       /* O:   Returns 1 if unstable, otherwise 0          */\r
+SKP_int silk_LPC_inverse_pred_gain(             /* O:   Returns 1 if unstable, otherwise 0          */\r
     SKP_int32           *invGain_Q30,           /* O:   Inverse prediction gain, Q30 energy domain  */\r
     const SKP_int16     *A_Q12,                 /* I:   Prediction coefficients, Q12 [order]        */\r
     const SKP_int       order                   /* I:   Prediction order                            */\r
@@ -123,29 +123,8 @@ SKP_int silk_LPC_inverse_pred_gain(       /* O:   Returns 1 if unstable, otherwi
     return LPC_inverse_pred_gain_QA( invGain_Q30, Atmp_QA, order );\r
 }\r
 \r
-/* For input in Q13 domain */\r
-SKP_int silk_LPC_inverse_pred_gain_Q13(   /* O:   Returns 1 if unstable, otherwise 0          */\r
-    SKP_int32           *invGain_Q30,           /* O:   Inverse prediction gain, Q30 energy domain  */\r
-    const SKP_int16     *A_Q13,                 /* I:   Prediction coefficients, Q13 [order]        */\r
-    const SKP_int       order                   /* I:   Prediction order                            */\r
-)\r
-{\r
-    SKP_int   k;\r
-    SKP_int32 Atmp_QA[ 2 ][ SILK_MAX_ORDER_LPC ];\r
-    SKP_int32 *Anew_QA;\r
-\r
-    Anew_QA = Atmp_QA[ order & 1 ];\r
-\r
-    /* Increase Q domain of the AR coefficients */\r
-    for( k = 0; k < order; k++ ) {\r
-        Anew_QA[ k ] = SKP_LSHIFT( (SKP_int32)A_Q13[ k ], QA - 13 );\r
-    }\r
-\r
-    return LPC_inverse_pred_gain_QA( invGain_Q30, Atmp_QA, order );\r
-}\r
-\r
 /* For input in Q24 domain */\r
-SKP_int silk_LPC_inverse_pred_gain_Q24(   /* O:   Returns 1 if unstable, otherwise 0          */\r
+SKP_int silk_LPC_inverse_pred_gain_Q24(         /* O:   Returns 1 if unstable, otherwise 0          */\r
     SKP_int32           *invGain_Q30,           /* O:   Inverse prediction gain, Q30 energy domain  */\r
     const SKP_int32     *A_Q24,                 /* I:   Prediction coefficients, Q24 [order]        */\r
     const SKP_int       order                   /* I:   Prediction order                            */\r
diff --git a/silk/silk_LPC_stabilize.c b/silk/silk_LPC_stabilize.c
deleted file mode 100644 (file)
index ca1a115..0000000
+++ /dev/null
@@ -1,134 +0,0 @@
-/***********************************************************************\r
-Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
-Redistribution and use in source and binary forms, with or without \r
-modification, (subject to the limitations in the disclaimer below) \r
-are permitted provided that the following conditions are met:\r
-- Redistributions of source code must retain the above copyright notice,\r
-this list of conditions and the following disclaimer.\r
-- Redistributions in binary form must reproduce the above copyright \r
-notice, this list of conditions and the following disclaimer in the \r
-documentation and/or other materials provided with the distribution.\r
-- Neither the name of Skype Limited, nor the names of specific \r
-contributors, may be used to endorse or promote products derived from \r
-this software without specific prior written permission.\r
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
-BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
-CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-***********************************************************************/\r
-\r
-#include "silk_typedef.h"\r
-#include "silk_SigProc_FIX.h"\r
-\r
-#define LPC_STABILIZE_LPC_MAX_ABS_VALUE_Q16     ( ( (SKP_int32)SKP_int16_MAX ) << 4 )\r
-\r
-/* LPC stabilizer, for a single input data vector */\r
-void silk_LPC_stabilize(\r
-    SKP_int16       *a_Q12,         /* O    stabilized LPC vector [L]                       */\r
-    SKP_int32       *a_Q16,         /* I    LPC vector [L]                                  */\r
-    const SKP_int32  bwe_Q16,       /* I    Bandwidth expansion factor                      */\r
-    const SKP_int    L              /* I    Number of LPC parameters in the input vector    */\r
-)\r
-{\r
-    SKP_int32   maxabs, absval, sc_Q16;\r
-    SKP_int     i, idx = 0;\r
-    SKP_int32   invGain_Q30;\r
-\r
-    silk_bwexpander_32( a_Q16, L, bwe_Q16 );\r
-\r
-    /***************************/\r
-    /* Limit range of the LPCs */\r
-    /***************************/\r
-    /* Limit the maximum absolute value of the prediction coefficients */\r
-    while( SKP_TRUE ) {\r
-        /* Find maximum absolute value and its index */\r
-        maxabs = SKP_int32_MIN;\r
-        for( i = 0; i < L; i++ ) {\r
-            absval = SKP_abs( a_Q16[ i ] );\r
-            if( absval > maxabs ) {\r
-                maxabs = absval;\r
-                idx    = i;\r
-            }\r
-        }\r
-    \r
-        if( maxabs >= LPC_STABILIZE_LPC_MAX_ABS_VALUE_Q16 ) {\r
-            /* Reduce magnitude of prediction coefficients */\r
-            sc_Q16 = SKP_DIV32( SKP_int32_MAX, SKP_RSHIFT( maxabs, 4 ) );\r
-            sc_Q16 = 65536 - sc_Q16;\r
-            sc_Q16 = SKP_DIV32( sc_Q16, idx + 1 );\r
-            sc_Q16 = 65536 - sc_Q16;\r
-            sc_Q16 = SKP_LSHIFT( SKP_SMULWB( sc_Q16, 32604 ), 1 ); // 0.995 in Q16\r
-            silk_bwexpander_32( a_Q16, L, sc_Q16 );\r
-        } else {\r
-            break;\r
-        }\r
-    }\r
-\r
-    /* Convert to 16 bit Q12 */\r
-    for( i = 0; i < L; i++ ) {\r
-        a_Q12[ i ] = (SKP_int16)SKP_RSHIFT_ROUND( a_Q16[ i ], 4 );\r
-    }\r
-\r
-    /**********************/\r
-    /* Ensure stable LPCs */\r
-    /**********************/\r
-    while( silk_LPC_inverse_pred_gain( &invGain_Q30, a_Q12, L ) == 1 ) {\r
-        silk_bwexpander( a_Q12, L, 65339 ); // 0.997 in Q16\r
-    }\r
-}\r
-\r
-void silk_LPC_fit(\r
-    SKP_int16       *a_QQ,          /* O    Stabilized LPC vector, Q(24-rshift) [L]         */\r
-    SKP_int32       *a_Q24,         /* I    LPC vector [L]                                  */\r
-    const SKP_int    QQ,            /* I    Q domain of output LPC vector                   */\r
-    const SKP_int    L              /* I    Number of LPC parameters in the input vector    */\r
-)\r
-{\r
-    SKP_int     i, rshift, idx = 0;\r
-    SKP_int32   maxabs, absval, sc_Q16;\r
-\r
-    rshift = 24 - QQ;\r
-\r
-    /***************************/\r
-    /* Limit range of the LPCs */\r
-    /***************************/\r
-    /* Limit the maximum absolute value of the prediction coefficients */\r
-    while( SKP_TRUE ) {\r
-        /* Find maximum absolute value and its index; assumes stable coefficients   */\r
-        /* so that only the first half need to be tested                            */\r
-        maxabs = SKP_int32_MIN;\r
-        for( i = 1; i < L / 2; i++ ) {\r
-            absval = SKP_abs( a_Q24[ i ] );\r
-            if( absval > maxabs ) {\r
-                maxabs = absval;\r
-                idx    = i;\r
-            }\r
-        }\r
-    \r
-        maxabs = SKP_RSHIFT( maxabs, rshift );\r
-        if( maxabs >= SKP_int16_MAX ) {\r
-            /* Reduce magnitude of prediction coefficients */\r
-            maxabs = SKP_min( maxabs, 98369 ); // ( SKP_int32_MAX / ( 65470 >> 2 ) ) + SKP_int16_MAX = 98369\r
-            sc_Q16 = 65470 - SKP_DIV32( SKP_MUL( 65470 >> 2, maxabs - SKP_int16_MAX ), \r
-                                        SKP_RSHIFT32( SKP_MUL( maxabs, idx + 1), 2 ) );\r
-            silk_bwexpander_32( a_Q24, L, sc_Q16 );\r
-        } else {\r
-            break;\r
-        }\r
-    }\r
-\r
-    /* Convert to 16 bit Q(24-rshift) */\r
-    SKP_assert( rshift > 0  );\r
-    SKP_assert( rshift < 31 );\r
-    for( i = 0; i < L; i++ ) {\r
-        a_QQ[ i ] = (SKP_int16)SKP_RSHIFT_ROUND( a_Q24[ i ], rshift );\r
-    }\r
-}\r
diff --git a/silk/silk_LPC_synthesis_filter.c b/silk/silk_LPC_synthesis_filter.c
deleted file mode 100644 (file)
index 5f95a18..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-/***********************************************************************\r
-Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
-Redistribution and use in source and binary forms, with or without \r
-modification, (subject to the limitations in the disclaimer below) \r
-are permitted provided that the following conditions are met:\r
-- Redistributions of source code must retain the above copyright notice,\r
-this list of conditions and the following disclaimer.\r
-- Redistributions in binary form must reproduce the above copyright \r
-notice, this list of conditions and the following disclaimer in the \r
-documentation and/or other materials provided with the distribution.\r
-- Neither the name of Skype Limited, nor the names of specific \r
-contributors, may be used to endorse or promote products derived from \r
-this software without specific prior written permission.\r
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
-BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
-CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-***********************************************************************/\r
-\r
-/*                                                                      *\r
- * silk_LPC_synthesis_filter.c                                    *\r
- * Coefficients are in Q12                                              *\r
- *                                                                      *\r
- * even order AR filter                                                 *\r
- *                                                                      */\r
-#include "silk_SigProc_FIX.h"\r
-\r
-/* even order AR filter */\r
-void silk_LPC_synthesis_filter(\r
-    const SKP_int16 *in,        /* I:   excitation signal */\r
-    const SKP_int16 *A_Q12,     /* I:   AR coefficients [Order], between -8_Q0 and 8_Q0 */\r
-    const SKP_int32 Gain_Q26,   /* I:   gain */\r
-    SKP_int32 *S,               /* I/O: state vector [Order] */\r
-    SKP_int16 *out,             /* O:   output signal */\r
-    const SKP_int32 len,        /* I:   signal length */\r
-    const SKP_int Order         /* I:   filter order, must be even */\r
-)\r
-{\r
-    SKP_int   k, j, idx, Order_half = SKP_RSHIFT( Order, 1 );\r
-    SKP_int32 SA, SB, out32_Q10, out32;\r
-\r
-    /* Order must be even */\r
-    SKP_assert( 2 * Order_half == Order );\r
-\r
-    /* S[] values are in Q14 */\r
-    for( k = 0; k < len; k++ ) {\r
-        SA = S[ Order - 1 ];\r
-        out32_Q10 = 0;\r
-        for( j = 0; j < ( Order_half - 1 ); j++ ) {\r
-            idx = SKP_SMULBB( 2, j ) + 1;\r
-            SB = S[ Order - 1 - idx ];\r
-            S[ Order - 1 - idx ] = SA;\r
-            out32_Q10 = SKP_SMLAWB( out32_Q10, SA, A_Q12[ ( j << 1 ) ] );\r
-            out32_Q10 = SKP_SMLAWB( out32_Q10, SB, A_Q12[ ( j << 1 ) + 1 ] );\r
-            SA = S[ Order - 2 - idx ];\r
-            S[ Order - 2 - idx ] = SB;\r
-        }\r
-\r
-        /* unrolled loop: epilog */\r
-        SB = S[ 0 ];\r
-        S[ 0 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB( out32_Q10, SA, A_Q12[ Order - 2 ] );\r
-        out32_Q10 = SKP_SMLAWB( out32_Q10, SB, A_Q12[ Order - 1 ] );\r
-        /* apply gain to excitation signal and add to prediction */\r
-        out32_Q10 = SKP_ADD_SAT32( out32_Q10, SKP_SMULWB( Gain_Q26, in[ k ] ) );\r
-\r
-        /* scale to Q0 */\r
-        out32 = SKP_RSHIFT_ROUND( out32_Q10, 10 );\r
-\r
-        /* saturate output */\r
-        out[ k ] = ( SKP_int16 )SKP_SAT16( out32 );\r
-\r
-        /* move result into delay line */\r
-        S[ Order - 1 ] = SKP_LSHIFT_SAT32( out32_Q10, 4 );\r
-    }\r
-}\r
diff --git a/silk/silk_LPC_synthesis_order16.c b/silk/silk_LPC_synthesis_order16.c
deleted file mode 100644 (file)
index f35b9a9..0000000
+++ /dev/null
@@ -1,122 +0,0 @@
-/***********************************************************************\r
-Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
-Redistribution and use in source and binary forms, with or without \r
-modification, (subject to the limitations in the disclaimer below) \r
-are permitted provided that the following conditions are met:\r
-- Redistributions of source code must retain the above copyright notice,\r
-this list of conditions and the following disclaimer.\r
-- Redistributions in binary form must reproduce the above copyright \r
-notice, this list of conditions and the following disclaimer in the \r
-documentation and/or other materials provided with the distribution.\r
-- Neither the name of Skype Limited, nor the names of specific \r
-contributors, may be used to endorse or promote products derived from \r
-this software without specific prior written permission.\r
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
-BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
-CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-***********************************************************************/\r
-\r
-/*                                                                      *\r
- * silk_LPC_synthesis_order16.c                                   *\r
- * Coefficients are in Q12                                              *\r
- *                                                                      *\r
- * 16th order AR filter                                                 *\r
- *                                                                      */\r
-#include "silk_SigProc_FIX.h"\r
-\r
-/* 16th order AR filter */\r
-void silk_LPC_synthesis_order16(const SKP_int16 *in,          /* I:   excitation signal */\r
-                                      const SKP_int16 *A_Q12,       /* I:   AR coefficients [16], between -8_Q0 and 8_Q0 */\r
-                                      const SKP_int32 Gain_Q26,     /* I:   gain */\r
-                                      SKP_int32 *S,                 /* I/O: state vector [16] */\r
-                                      SKP_int16 *out,               /* O:   output signal */\r
-                                      const SKP_int32 len           /* I:   signal length, must be multiple of 16 */\r
-)\r
-{\r
-    SKP_int   k;\r
-    SKP_int32 SA, SB, out32_Q10, out32;\r
-    for( k = 0; k < len; k++ ) {\r
-        /* unrolled loop: prolog */\r
-        /* multiply-add two prediction coefficients per iteration */\r
-        SA = S[ 15 ];\r
-        SB = S[ 14 ];\r
-        S[ 14 ] = SA;\r
-        out32_Q10 = SKP_SMULWB(                  SA, A_Q12[ 0 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 1 ] );\r
-        SA = S[ 13 ];\r
-        S[ 13 ] = SB;\r
-\r
-        /* unrolled loop: main loop */\r
-        SB = S[ 12 ];\r
-        S[ 12 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 2 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 3 ] );\r
-        SA = S[ 11 ];\r
-        S[ 11 ] = SB;\r
-\r
-        SB = S[ 10 ];\r
-        S[ 10 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 4 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 5 ] );\r
-        SA = S[ 9 ];\r
-        S[ 9 ] = SB;\r
-\r
-        SB = S[ 8 ];\r
-        S[ 8 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 6 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 7 ] );\r
-        SA = S[ 7 ];\r
-        S[ 7 ] = SB;\r
-\r
-        SB = S[ 6 ];\r
-        S[ 6 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 8 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 9 ] );\r
-        SA = S[ 5 ];\r
-        S[ 5 ] = SB;\r
-\r
-        SB = S[ 4 ];\r
-        S[ 4 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 10 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 11 ] );\r
-        SA = S[ 3 ];\r
-        S[ 3 ] = SB;\r
-\r
-        SB = S[ 2 ];\r
-        S[ 2 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 12 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 13 ] );\r
-        SA = S[ 1 ];\r
-        S[ 1 ] = SB;\r
-\r
-        /* unrolled loop: epilog */\r
-        SB = S[ 0 ];\r
-        S[ 0 ] = SA;\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SA, A_Q12[ 14 ] );\r
-        out32_Q10 = SKP_SMLAWB_ovflw( out32_Q10, SB, A_Q12[ 15 ] );\r
-\r
-        /* unrolled loop: end */\r
-        /* apply gain to excitation signal and add to prediction */\r
-        out32_Q10 = SKP_ADD_SAT32( out32_Q10, SKP_SMULWB( Gain_Q26, in[ k ] ) );\r
-\r
-        /* scale to Q0 */\r
-        out32 = SKP_RSHIFT_ROUND( out32_Q10, 10 );\r
-\r
-        /* saturate output */\r
-        out[ k ] = ( SKP_int16 )SKP_SAT16( out32 );\r
-\r
-        /* move result into delay line */\r
-        S[ 15 ] = SKP_LSHIFT_SAT32( out32_Q10, 4 );\r
-    }\r
-}\r
-\r
-\r
index 21251cf..37e2e6e 100644 (file)
@@ -34,23 +34,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_SigProc_FIX.h"\r
 #include "silk_tables.h"\r
 \r
+#define QA      16\r
+\r
 /* helper function for NLSF2A(..) */\r
 SKP_INLINE void silk_NLSF2A_find_poly(\r
-    SKP_int32          *out,      /* o    intermediate polynomial, Q20            */\r
-    const SKP_int32    *cLSF,     /* i    vector of interleaved 2*cos(LSFs), Q20  */\r
-    SKP_int            dd         /* i    polynomial order (= 1/2 * filter order) */\r
+    SKP_int32          *out,      /* O    intermediate polynomial, QA [dd+1]        */\r
+    const SKP_int32    *cLSF,     /* I    vector of interleaved 2*cos(LSFs), QA [d] */\r
+    SKP_int            dd         /* I    polynomial order (= 1/2 * filter order)   */\r
 )\r
 {\r
-    SKP_int        k, n;\r
-    SKP_int32    ftmp;\r
+    SKP_int   k, n;\r
+    SKP_int32 ftmp;\r
 \r
-    out[0] = SKP_LSHIFT( 1, 20 );\r
+    out[0] = SKP_LSHIFT( 1, QA );\r
     out[1] = -cLSF[0];\r
     for( k = 1; k < dd; k++ ) {\r
-        ftmp = cLSF[2*k];            // Q20\r
-        out[k+1] = SKP_LSHIFT( out[k-1], 1 ) - (SKP_int32)SKP_RSHIFT_ROUND64( SKP_SMULL( ftmp, out[k] ), 20 );\r
+        ftmp = cLSF[2*k];            // QA\r
+        out[k+1] = SKP_LSHIFT( out[k-1], 1 ) - (SKP_int32)SKP_RSHIFT_ROUND64( SKP_SMULL( ftmp, out[k] ), QA );\r
         for( n = k; n > 1; n-- ) {\r
-            out[n] += out[n-2] - (SKP_int32)SKP_RSHIFT_ROUND64( SKP_SMULL( ftmp, out[n-1] ), 20 );\r
+            out[n] += out[n-2] - (SKP_int32)SKP_RSHIFT_ROUND64( SKP_SMULL( ftmp, out[n-1] ), QA );\r
         }\r
         out[1] -= ftmp;\r
     }\r
@@ -58,24 +60,21 @@ SKP_INLINE void silk_NLSF2A_find_poly(
 \r
 /* compute whitening filter coefficients from normalized line spectral frequencies */\r
 void silk_NLSF2A(\r
-    SKP_int16        *a,              /* o    monic whitening filter coefficients in Q12,  [d]    */\r
-    const SKP_int16  *NLSF,           /* i    normalized line spectral frequencies in Q15, [d]    */\r
-    const SKP_int    d                /* i    filter order (should be even)                       */\r
+    SKP_int16        *a_Q12,            /* O    monic whitening filter coefficients in Q12,  [ d ]  */\r
+    const SKP_int16  *NLSF,             /* I    normalized line spectral frequencies in Q15, [ d ]  */\r
+    const SKP_int    d                  /* I    filter order (should be even)                       */\r
 )\r
 {\r
-    SKP_int k, i, dd;\r
-    SKP_int32 cos_LSF_Q20[SILK_MAX_ORDER_LPC];\r
-    SKP_int32 P[SILK_MAX_ORDER_LPC/2+1], Q[SILK_MAX_ORDER_LPC/2+1];\r
-    SKP_int32 Ptmp, Qtmp;\r
-    SKP_int32 f_int;\r
-    SKP_int32 f_frac;\r
-    SKP_int32 cos_val, delta;\r
-    SKP_int32 a_int32[SILK_MAX_ORDER_LPC];\r
-    SKP_int32 maxabs, absval, idx=0, sc_Q16; \r
+    SKP_int   k, i, dd;\r
+    SKP_int32 cos_LSF_QA[ SILK_MAX_ORDER_LPC ];\r
+    SKP_int32 P[ SILK_MAX_ORDER_LPC / 2 + 1 ], Q[ SILK_MAX_ORDER_LPC / 2 + 1 ];\r
+    SKP_int32 Ptmp, Qtmp, f_int, f_frac, cos_val, delta;\r
+    SKP_int32 a32_QA1[ SILK_MAX_ORDER_LPC ];\r
+    SKP_int32 maxabs, absval, idx=0, sc_Q16, invGain_Q30; \r
 \r
     SKP_assert( LSF_COS_TAB_SZ_FIX == 128 );\r
 \r
-    /* convert LSFs to 2*cos(LSF(i)), using piecewise linear curve from table */\r
+    /* convert LSFs to 2*cos(LSF), using piecewise linear curve from table */\r
     for( k = 0; k < d; k++ ) {\r
         SKP_assert(NLSF[k] >= 0 );\r
         SKP_assert(NLSF[k] <= 32767 );\r
@@ -94,59 +93,79 @@ void silk_NLSF2A(
         delta   = silk_LSFCosTab_FIX_Q12[ f_int + 1 ] - cos_val;  /* Q12, with a range of 0..200 */\r
 \r
         /* Linear interpolation */\r
-        cos_LSF_Q20[k] = SKP_LSHIFT( cos_val, 8 ) + SKP_MUL( delta, f_frac ); /* Q20 */\r
+        cos_LSF_QA[k] = SKP_RSHIFT_ROUND( SKP_LSHIFT( cos_val, 8 ) + SKP_MUL( delta, f_frac ), 20 - QA ); /* QA */\r
     }\r
     \r
     dd = SKP_RSHIFT( d, 1 );\r
 \r
     /* generate even and odd polynomials using convolution */\r
-    silk_NLSF2A_find_poly( P, &cos_LSF_Q20[0], dd );\r
-    silk_NLSF2A_find_poly( Q, &cos_LSF_Q20[1], dd );\r
+    silk_NLSF2A_find_poly( P, &cos_LSF_QA[ 0 ], dd );\r
+    silk_NLSF2A_find_poly( Q, &cos_LSF_QA[ 1 ], dd );\r
 \r
     /* convert even and odd polynomials to SKP_int32 Q12 filter coefs */\r
     for( k = 0; k < dd; k++ ) {\r
-        Ptmp = P[k+1] + P[k];\r
-        Qtmp = Q[k+1] - Q[k];\r
+        Ptmp = P[ k+1 ] + P[ k ];\r
+        Qtmp = Q[ k+1 ] - Q[ k ];\r
 \r
         /* the Ptmp and Qtmp values at this stage need to fit in int32 */\r
-\r
-        a_int32[k]     = -SKP_RSHIFT_ROUND( Ptmp + Qtmp, 9 ); /* Q20 -> Q12 */\r
-        a_int32[d-k-1] =  SKP_RSHIFT_ROUND( Qtmp - Ptmp, 9 ); /* Q20 -> Q12 */\r
+        a32_QA1[ k ]     = -Qtmp - Ptmp;        /* QA+1 */\r
+        a32_QA1[ d-k-1 ] =  Qtmp - Ptmp;        /* QA+1 */\r
     }\r
 \r
-    /* Limit the maximum absolute value of the prediction coefficients */\r
+    /* Limit the maximum absolute value of the prediction coefficients, so that they'll fit in int16 */\r
     for( i = 0; i < 10; i++ ) {\r
         /* Find maximum absolute value and its index */\r
         maxabs = 0;\r
         for( k = 0; k < d; k++ ) {\r
-            absval = SKP_abs( a_int32[k] );\r
+            absval = SKP_abs( a32_QA1[k] );\r
             if( absval > maxabs ) {\r
                 maxabs = absval;\r
-                idx       = k;\r
+                idx    = k;\r
             }    \r
         }\r
+        maxabs = SKP_RSHIFT_ROUND( maxabs, QA + 1 - 12 );       /* QA+1 -> Q12 */\r
     \r
         if( maxabs > SKP_int16_MAX ) {    \r
             /* Reduce magnitude of prediction coefficients */\r
-            maxabs = SKP_min( maxabs, 98369 ); // ( SKP_int32_MAX / ( 65470 >> 2 ) ) + SKP_int16_MAX = 98369 \r
-            sc_Q16 = 65470 - SKP_DIV32( SKP_MUL( 65470 >> 2, maxabs - SKP_int16_MAX ), \r
+            maxabs = SKP_min( maxabs, 163838 );  /* ( SKP_int32_MAX >> 14 ) + SKP_int16_MAX = 163838 */\r
+            sc_Q16 = SILK_FIX_CONST( 0.999, 16 ) - SKP_DIV32( SKP_LSHIFT( maxabs - SKP_int16_MAX, 14 ), \r
                                         SKP_RSHIFT32( SKP_MUL( maxabs, idx + 1), 2 ) );\r
-            silk_bwexpander_32( a_int32, d, sc_Q16 );\r
+            silk_bwexpander_32( a32_QA1, d, sc_Q16 );\r
         } else {\r
             break;\r
         }\r
     }    \r
 \r
-    /* Reached the last iteration */\r
     if( i == 10 ) {\r
-        SKP_assert(0);\r
+        /* Reached the last iteration, clip the coefficients */\r
+        for( k = 0; k < d; k++ ) {\r
+            a_Q12[ k ] = (SKP_int16)SKP_SAT16( SKP_RSHIFT_ROUND( a32_QA1[ k ], QA + 1 - 12 ) ); /* QA+1 -> Q12 */\r
+            a32_QA1[ k ] = SKP_LSHIFT( (SKP_int32)a_Q12[ k ], QA + 1 - 12 );\r
+        }\r
+    } else {\r
         for( k = 0; k < d; k++ ) {\r
-            a_int32[k] = SKP_SAT16( a_int32[k] ); \r
+            a_Q12[ k ] = (SKP_int16)SKP_RSHIFT_ROUND( a32_QA1[ k ], QA + 1 - 12 );       /* QA+1 -> Q12 */\r
         }\r
     }\r
 \r
-    /* Return as SKP_int16 Q12 coefficients */\r
-    for( k = 0; k < d; k++ ) {\r
-        a[k] = (SKP_int16)a_int32[k];\r
+    for( i = 1; i < MAX_LPC_STABILIZE_ITERATIONS; i++ ) {\r
+        if( silk_LPC_inverse_pred_gain( &invGain_Q30, a_Q12, d ) == 1 ) {\r
+            /* Prediction coefficients are (too close to) unstable; apply bandwidth expansion   */\r
+            /* on the unscaled coefficients, convert to Q12 and measure again                   */\r
+            silk_bwexpander_32( a32_QA1, d, 65536 - SKP_SMULBB( 9 + i, i ) );              /* 10_Q16 = 0.00015 */\r
+            for( k = 0; k < d; k++ ) {\r
+                a_Q12[ k ] = (SKP_int16)SKP_RSHIFT_ROUND( a32_QA1[ k ], QA + 1 - 12 );  /* QA+1 -> Q12 */\r
+            }\r
+        } else {\r
+            break;\r
+        }\r
+    }\r
+\r
+    if( i == MAX_LPC_STABILIZE_ITERATIONS ) {\r
+        /* Reached the last iteration, set coefficients to zero */\r
+        for( k = 0; k < d; k++ ) {\r
+            a_Q12[ k ] = 0;\r
+        }\r
     }\r
 }\r
+\r
diff --git a/silk/silk_NLSF2A_stable.c b/silk/silk_NLSF2A_stable.c
deleted file mode 100644 (file)
index b4b59ba..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-/***********************************************************************\r
-Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
-Redistribution and use in source and binary forms, with or without \r
-modification, (subject to the limitations in the disclaimer below) \r
-are permitted provided that the following conditions are met:\r
-- Redistributions of source code must retain the above copyright notice,\r
-this list of conditions and the following disclaimer.\r
-- Redistributions in binary form must reproduce the above copyright \r
-notice, this list of conditions and the following disclaimer in the \r
-documentation and/or other materials provided with the distribution.\r
-- Neither the name of Skype Limited, nor the names of specific \r
-contributors, may be used to endorse or promote products derived from \r
-this software without specific prior written permission.\r
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
-BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
-CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-***********************************************************************/\r
-\r
-#include "silk_main.h"\r
-\r
-/* Convert NLSF parameters to stable AR prediction filter coefficients */\r
-void silk_NLSF2A_stable(\r
-    SKP_int16                       pAR_Q12[ MAX_LPC_ORDER ],   /* O    Stabilized AR coefs [LPC_order]     */ \r
-    const SKP_int16                 pNLSF[ MAX_LPC_ORDER ],     /* I    NLSF vector         [LPC_order]     */\r
-    const SKP_int                   LPC_order                   /* I    LPC/LSF order                       */\r
-)\r
-{\r
-    SKP_int   i;\r
-    SKP_int32 invGain_Q30;\r
-\r
-    silk_NLSF2A( pAR_Q12, pNLSF, LPC_order );\r
-\r
-    /* Ensure stable LPCs */\r
-    for( i = 0; i < MAX_LPC_STABILIZE_ITERATIONS; i++ ) {\r
-        if( silk_LPC_inverse_pred_gain( &invGain_Q30, pAR_Q12, LPC_order ) == 1 ) {\r
-            silk_bwexpander( pAR_Q12, LPC_order, 65536 - SKP_SMULBB( 10 + i, i ) );            /* 10_Q16 = 0.00015 */\r
-        } else {\r
-            break;\r
-        }\r
-    }\r
-\r
-    /* Reached the last iteration */\r
-    if( i == MAX_LPC_STABILIZE_ITERATIONS ) {\r
-        for( i = 0; i < LPC_order; i++ ) {\r
-            pAR_Q12[ i ] = 0;\r
-        }\r
-    }\r
-}\r
index 218f521..2e59e7c 100644 (file)
@@ -25,6 +25,7 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
 ***********************************************************************/\r
 \r
+#include "silk_define.h"\r
 #include "silk_SigProc_FIX.h"\r
 \r
 /* \r
@@ -33,11 +34,9 @@ Parameters Using Structured Vector Quantization", Proc. IEEE Int. Conf. Acoust.,
 Signal Processing, pp. 641-644, 1991.\r
 */\r
 \r
-#define Q_OUT                       5\r
-\r
 /* Laroia low complexity NLSF weights */\r
 void silk_NLSF_VQ_weights_laroia(\r
-    SKP_int16           *pNLSFW_Q5,         /* O: Pointer to input vector weights           [D x 1]     */\r
+    SKP_int16           *pNLSFW_Q_OUT,      /* O: Pointer to input vector weights           [D x 1]     */\r
     const SKP_int16     *pNLSF_Q15,         /* I: Pointer to input vector                   [D x 1]     */ \r
     const SKP_int       D                   /* I: Input vector dimension (even)                         */\r
 )\r
@@ -50,28 +49,28 @@ void silk_NLSF_VQ_weights_laroia(
     \r
     /* First value */\r
     tmp1_int = SKP_max_int( pNLSF_Q15[ 0 ], 1 );\r
-    tmp1_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), tmp1_int );\r
+    tmp1_int = SKP_DIV32_16( 1 << ( 15 + NLSF_W_Q ), tmp1_int );\r
     tmp2_int = SKP_max_int( pNLSF_Q15[ 1 ] - pNLSF_Q15[ 0 ], 1 );\r
-    tmp2_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), tmp2_int );\r
-    pNLSFW_Q5[ 0 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
-    SKP_assert( pNLSFW_Q5[ 0 ] > 0 );\r
+    tmp2_int = SKP_DIV32_16( 1 << ( 15 + NLSF_W_Q ), tmp2_int );\r
+    pNLSFW_Q_OUT[ 0 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+    SKP_assert( pNLSFW_Q_OUT[ 0 ] > 0 );\r
     \r
     /* Main loop */\r
     for( k = 1; k < D - 1; k += 2 ) {\r
         tmp1_int = SKP_max_int( pNLSF_Q15[ k + 1 ] - pNLSF_Q15[ k ], 1 );\r
-        tmp1_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), tmp1_int );\r
-        pNLSFW_Q5[ k ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
-        SKP_assert( pNLSFW_Q5[ k ] > 0 );\r
+        tmp1_int = SKP_DIV32_16( 1 << ( 15 + NLSF_W_Q ), tmp1_int );\r
+        pNLSFW_Q_OUT[ k ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+        SKP_assert( pNLSFW_Q_OUT[ k ] > 0 );\r
 \r
         tmp2_int = SKP_max_int( pNLSF_Q15[ k + 2 ] - pNLSF_Q15[ k + 1 ], 1 );\r
-        tmp2_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), tmp2_int );\r
-        pNLSFW_Q5[ k + 1 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
-        SKP_assert( pNLSFW_Q5[ k + 1 ] > 0 );\r
+        tmp2_int = SKP_DIV32_16( 1 << ( 15 + NLSF_W_Q ), tmp2_int );\r
+        pNLSFW_Q_OUT[ k + 1 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+        SKP_assert( pNLSFW_Q_OUT[ k + 1 ] > 0 );\r
     }\r
     \r
     /* Last value */\r
     tmp1_int = SKP_max_int( ( 1 << 15 ) - pNLSF_Q15[ D - 1 ], 1 );\r
-    tmp1_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), tmp1_int );\r
-    pNLSFW_Q5[ D - 1 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
-    SKP_assert( pNLSFW_Q5[ D - 1 ] > 0 );\r
+    tmp1_int = SKP_DIV32_16( 1 << ( 15 + NLSF_W_Q ), tmp1_int );\r
+    pNLSFW_Q_OUT[ D - 1 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+    SKP_assert( pNLSFW_Q_OUT[ D - 1 ] > 0 );\r
 }\r
index 8951764..2c2a497 100644 (file)
@@ -28,7 +28,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main.h"\r
 \r
 /* Predictive dequantizer for NLSF residuals */\r
-void silk_NLSF_residual_dequant(                        /* O    Returns RD value in Q30                     */\r
+void silk_NLSF_residual_dequant(                            /* O    Returns RD value in Q30                     */\r
           SKP_int16         x_Q10[],                        /* O    Output [ order ]                            */\r
     const SKP_int8          indices[],                      /* I    Quantization indices [ order ]              */\r
     const SKP_uint8         pred_coef_Q8[],                 /* I    Backward predictor coefs [ order ]          */\r
@@ -57,8 +57,8 @@ void silk_NLSF_residual_dequant(                        /* O    Returns RD value
 /* NLSF vector decoder */\r
 /***********************/\r
 void silk_NLSF_decode(\r
-          SKP_int16                 *pNLSF_Q15,             /* O    Quantized NLSF vector [ LPC_ORDER ]     */\r
-          SKP_int8                  *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */\r
+          SKP_int16             *pNLSF_Q15,             /* O    Quantized NLSF vector [ LPC_ORDER ]     */\r
+          SKP_int8              *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */\r
     const silk_NLSF_CB_struct   *psNLSF_CB              /* I    Codebook object                         */\r
 )\r
 {\r
@@ -66,8 +66,8 @@ void silk_NLSF_decode(
     SKP_uint8       pred_Q8[  MAX_LPC_ORDER ];\r
     SKP_int16       ec_ix[    MAX_LPC_ORDER ];\r
     SKP_int16       res_Q10[  MAX_LPC_ORDER ];\r
-    SKP_int16       W_tmp_Q5[ MAX_LPC_ORDER ];\r
-    SKP_int32       W_tmp_Q9;\r
+    SKP_int16       W_tmp_QW[ MAX_LPC_ORDER ];\r
+    SKP_int32       W_tmp_Q9, NLSF_Q15_tmp;\r
     const SKP_uint8 *pCB_element;\r
 \r
     /* Decode first stage */\r
@@ -83,12 +83,13 @@ void silk_NLSF_decode(
     silk_NLSF_residual_dequant( res_Q10, &NLSFIndices[ 1 ], pred_Q8, psNLSF_CB->quantStepSize_Q16, psNLSF_CB->order );\r
 \r
     /* Weights from codebook vector */\r
-    silk_NLSF_VQ_weights_laroia( W_tmp_Q5, pNLSF_Q15, psNLSF_CB->order );\r
+    silk_NLSF_VQ_weights_laroia( W_tmp_QW, pNLSF_Q15, psNLSF_CB->order );\r
 \r
     /* Apply inverse square-rooted weights and add to output */\r
     for( i = 0; i < psNLSF_CB->order; i++ ) {\r
-        W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_Q5[ i ], 13 ) );\r
-        pNLSF_Q15[ i ] = SKP_ADD16( pNLSF_Q15[ i ], (SKP_int16)SKP_DIV32_16( SKP_LSHIFT( ( SKP_int32 )res_Q10[ i ], 14 ), W_tmp_Q9 ) );\r
+        W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_QW[ i ], 18 - NLSF_W_Q ) );\r
+        NLSF_Q15_tmp = SKP_ADD32( pNLSF_Q15[ i ], SKP_DIV32_16( SKP_LSHIFT( ( SKP_int32 )res_Q10[ i ], 14 ), W_tmp_Q9 ) );\r
+        pNLSF_Q15[ i ] = (SKP_int16)SKP_LIMIT( NLSF_Q15_tmp, 0, 32767 );\r
     }\r
 \r
     /* NLSF stabilization */\r
index 85c6cc3..8361fd6 100644 (file)
@@ -28,7 +28,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main.h"\r
 \r
 /* Delayed-decision quantizer for NLSF residuals */\r
-SKP_int32 silk_NLSF_del_dec_quant(                  /* O    Returns RD value in Q25                     */\r
+SKP_int32 silk_NLSF_del_dec_quant(                      /* O    Returns RD value in Q25                     */\r
     SKP_int8                    indices[],              /* O    Quantization indices [ order ]              */\r
     const SKP_int16             x_Q10[],                /* I    Input [ order ]                             */\r
     const SKP_int16             w_Q5[],                 /* I    Weights [ order ]                           */\r
index f0cfba3..a0e364a 100644 (file)
@@ -32,11 +32,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /***********************/\r
 /* NLSF vector encoder */\r
 /***********************/\r
-SKP_int32 silk_NLSF_encode(                             /* O    Returns RD value in Q25                 */\r
+SKP_int32 silk_NLSF_encode(                                 /* O    Returns RD value in Q25                 */\r
           SKP_int8                  *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */\r
           SKP_int16                 *pNLSF_Q15,             /* I/O  Quantized NLSF vector [ LPC_ORDER ]     */\r
-    const silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
-    const SKP_int16                 *pW_Q5,                 /* I    NLSF weight vector [ LPC_ORDER ]        */\r
+    const silk_NLSF_CB_struct       *psNLSF_CB,             /* I    Codebook object                         */\r
+    const SKP_int16                 *pW_QW,                 /* I    NLSF weight vector [ LPC_ORDER ]        */\r
     const SKP_int                   NLSF_mu_Q20,            /* I    Rate weight for the RD optimization     */\r
     const SKP_int                   nSurvivors,             /* I    Max survivors after first stage         */\r
     const SKP_int                   signalType              /* I    Signal type: 0/1/2                      */\r
@@ -51,7 +51,7 @@ SKP_int32 silk_NLSF_encode(                             /* O    Returns RD value
     SKP_int16       res_Q15[      MAX_LPC_ORDER ];\r
     SKP_int16       res_Q10[      MAX_LPC_ORDER ];\r
     SKP_int16       NLSF_tmp_Q15[ MAX_LPC_ORDER ];\r
-    SKP_int16       W_tmp_Q5[     MAX_LPC_ORDER ];\r
+    SKP_int16       W_tmp_QW[     MAX_LPC_ORDER ];\r
     SKP_int16       W_adj_Q5[     MAX_LPC_ORDER ];\r
     SKP_uint8       pred_Q8[      MAX_LPC_ORDER ];\r
     SKP_int16       ec_ix[        MAX_LPC_ORDER ];\r
@@ -91,17 +91,17 @@ SKP_int32 silk_NLSF_encode(                             /* O    Returns RD value
         }\r
 \r
         /* Weights from codebook vector */\r
-        silk_NLSF_VQ_weights_laroia( W_tmp_Q5, NLSF_tmp_Q15, psNLSF_CB->order );\r
+        silk_NLSF_VQ_weights_laroia( W_tmp_QW, NLSF_tmp_Q15, psNLSF_CB->order );\r
 \r
         /* Apply square-rooted weights */\r
         for( i = 0; i < psNLSF_CB->order; i++ ) {\r
-            W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_Q5[ i ], 13 ) );\r
+            W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_QW[ i ], 18 - NLSF_W_Q ) );\r
             res_Q10[ i ] = ( SKP_int16 )SKP_RSHIFT( SKP_SMULBB( res_Q15[ i ], W_tmp_Q9 ), 14 );\r
         }\r
 \r
         /* Modify input weights accordingly */\r
         for( i = 0; i < psNLSF_CB->order; i++ ) {\r
-            W_adj_Q5[ i ] = SKP_DIV32_16( SKP_LSHIFT( ( SKP_int32 )pW_Q5[ i ], 5 ), W_tmp_Q5[ i ] );\r
+            W_adj_Q5[ i ] = SKP_DIV32_16( SKP_LSHIFT( ( SKP_int32 )pW_QW[ i ], 5 ), W_tmp_QW[ i ] );\r
         }\r
 \r
         /* Unpack entropy table indices and predictor for current CB1 index */\r
@@ -142,9 +142,9 @@ SKP_int32 silk_NLSF_encode(                             /* O    Returns RD value
         for( i = 0; i < psNLSF_CB->order; i++ ) {\r
             NLSF_tmp_Q15[ i ] = SKP_LSHIFT16( ( SKP_int16 )pCB_element[ i ], 7 );\r
         }\r
-        silk_NLSF_VQ_weights_laroia( W_tmp_Q5, NLSF_tmp_Q15, psNLSF_CB->order );\r
+        silk_NLSF_VQ_weights_laroia( W_tmp_QW, NLSF_tmp_Q15, psNLSF_CB->order );\r
         for( i = 0; i < psNLSF_CB->order; i++ ) {\r
-            W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_Q5[ i ], 13 ) );\r
+            W_tmp_Q9 = silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_QW[ i ], 18 - NLSF_W_Q ) );\r
             res_Q15[ i ] = pNLSF_Q15_orig[ i ] - NLSF_tmp_Q15[ i ];\r
             res_Q10[ i ] = (SKP_int16)SKP_RSHIFT( SKP_SMULBB( res_Q15[ i ], W_tmp_Q9 ), 14 );\r
             DEBUG_STORE_DATA( NLSF_res_q10.dat, &res_Q10[ i ], sizeof( SKP_int16 ) );\r
index 45f71cd..d9f002c 100644 (file)
@@ -33,6 +33,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /*     Euclidean distance to input vector                   */\r
 /* - Output are sorted NLSF coefficients                    */\r
 /*                                                          */\r
+\r
 #include "silk_SigProc_FIX.h"\r
 \r
 /* Constant Definitions */\r
@@ -45,10 +46,9 @@ void silk_NLSF_stabilize(
     const SKP_int     L                    /* I:    Number of NLSF parameters in the input vector                           */\r
 )\r
 {\r
-    SKP_int16 center_freq_Q15, diff_Q15, min_center_Q15, max_center_Q15;\r
-    SKP_int32 min_diff_Q15;\r
-    SKP_int   loops;\r
-    SKP_int   i, I=0, k;\r
+    SKP_int   i, I=0, k, loops;\r
+    SKP_int16 center_freq_Q15;\r
+    SKP_int32 diff_Q15, min_diff_Q15, min_center_Q15, max_center_Q15;\r
 \r
     /* This is necessary to ensure an output within range of a SKP_int16 */\r
     SKP_assert( NDeltaMin_Q15[L] >= 1 );\r
@@ -69,7 +69,7 @@ void silk_NLSF_stabilize(
             }\r
         }\r
         /* Last element */\r
-        diff_Q15 = (1<<15) - ( NLSF_Q15[L-1] + NDeltaMin_Q15[L] );\r
+        diff_Q15 = ( 1 << 15 ) - ( NLSF_Q15[L-1] + NDeltaMin_Q15[L] );\r
         if( diff_Q15 < min_diff_Q15 ) {\r
             min_diff_Q15 = diff_Q15;\r
             I = L;\r
@@ -88,7 +88,7 @@ void silk_NLSF_stabilize(
         \r
         } else if( I == L) {\r
             /* Move away from higher limit */\r
-            NLSF_Q15[L-1] = (1<<15) - NDeltaMin_Q15[L];\r
+            NLSF_Q15[L-1] = ( 1 << 15 ) - NDeltaMin_Q15[L];\r
         \r
         } else {\r
             /* Find the lower extreme for the location of the current center frequency */ \r
@@ -99,11 +99,11 @@ void silk_NLSF_stabilize(
             min_center_Q15 += SKP_RSHIFT( NDeltaMin_Q15[I], 1 );\r
 \r
             /* Find the upper extreme for the location of the current center frequency */\r
-            max_center_Q15 = (1<<15);\r
+            max_center_Q15 = 1 << 15;\r
             for( k = L; k > I; k-- ) {\r
                 max_center_Q15 -= NDeltaMin_Q15[k];\r
             }\r
-            max_center_Q15 -= ( NDeltaMin_Q15[I] - SKP_RSHIFT( NDeltaMin_Q15[I], 1 ) );\r
+            max_center_Q15 -= SKP_RSHIFT( NDeltaMin_Q15[I], 1 );\r
 \r
             /* Move apart, sorted by value, keeping the same center frequency */\r
             center_freq_Q15 = (SKP_int16)SKP_LIMIT_32( SKP_RSHIFT_ROUND( (SKP_int32)NLSF_Q15[I-1] + (SKP_int32)NLSF_Q15[I], 1 ),\r
index 557277b..937a1b8 100644 (file)
@@ -29,10 +29,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Unpack predictor values and indices for entropy coding tables */\r
 void silk_NLSF_unpack(\r
-          SKP_int16                 ec_ix[],                /* O    Indices to entropy tales [ LPC_ORDER ]  */\r
-          SKP_uint8                 pred_Q8[],              /* O    LSF predictor [ LPC_ORDER ]             */\r
+          SKP_int16             ec_ix[],                /* O    Indices to entropy tales [ LPC_ORDER ]  */\r
+          SKP_uint8             pred_Q8[],              /* O    LSF predictor [ LPC_ORDER ]             */\r
     const silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
-    const SKP_int                   CB1_index               /* I    Index of vector in first LSF codebook   */\r
+    const SKP_int               CB1_index               /* I    Index of vector in first LSF codebook   */\r
 ) \r
 {\r
     SKP_int   i;\r
index 478f429..594eb76 100644 (file)
@@ -41,8 +41,8 @@ void silk_PLC_Reset(
 }\r
 \r
 void silk_PLC(\r
-    silk_decoder_state      *psDec,             /* I Decoder state          */\r
-    silk_decoder_control    *psDecCtrl,         /* I Decoder control        */\r
+    silk_decoder_state          *psDec,             /* I Decoder state          */\r
+    silk_decoder_control        *psDecCtrl,         /* I Decoder control        */\r
     SKP_int16                   signal[],           /* O Concealed signal       */\r
     SKP_int                     length,             /* I length of residual     */\r
     SKP_int                     lost                /* I Loss flag              */\r
@@ -73,8 +73,8 @@ void silk_PLC(
 /* Update state of PLC                            */\r
 /**************************************************/\r
 void silk_PLC_update(\r
-    silk_decoder_state      *psDec,             /* (I/O) Decoder state          */\r
-    silk_decoder_control    *psDecCtrl,         /* (I/O) Decoder control        */\r
+    silk_decoder_state          *psDec,             /* (I/O) Decoder state          */\r
+    silk_decoder_control        *psDecCtrl,         /* (I/O) Decoder control        */\r
     SKP_int16                   signal[],\r
     SKP_int                     length\r
 )\r
@@ -147,8 +147,8 @@ void silk_PLC_update(
 }\r
 \r
 void silk_PLC_conceal(\r
-    silk_decoder_state      *psDec,             /* I/O Decoder state */\r
-    silk_decoder_control    *psDecCtrl,         /* I/O Decoder control */\r
+    silk_decoder_state          *psDec,             /* I/O Decoder state */\r
+    silk_decoder_control        *psDecCtrl,         /* I/O Decoder control */\r
     SKP_int16                   signal[],           /* O concealed signal */\r
     SKP_int                     length              /* I length of residual */\r
 )\r
@@ -329,8 +329,8 @@ void silk_PLC_conceal(
 \r
 /* Glues concealed frames with new good recieved frames             */\r
 void silk_PLC_glue_frames(\r
-    silk_decoder_state      *psDec,             /* I/O decoder state    */\r
-    silk_decoder_control    *psDecCtrl,         /* I/O Decoder control  */\r
+    silk_decoder_state          *psDec,             /* I/O decoder state    */\r
+    silk_decoder_control        *psDecCtrl,         /* I/O Decoder control  */\r
     SKP_int16                   signal[],           /* I/O signal           */\r
     SKP_int                     length              /* I length of residual */\r
 )\r
index 79e6259..a0059e7 100644 (file)
@@ -129,32 +129,7 @@ void silk_biquad_alt(
     const SKP_int32     len            /* I:    signal length (must be even) */\r
 );\r
 \r
-/*! \r
- * variable order MA filter. Prediction error filter implementation. Coeficients negated and starting with coef to x[n - 1]\r
- */\r
-void silk_MA_Prediction(\r
-    const SKP_int16      *in,          /* I:   Input signal                                */\r
-    const SKP_int16      *B,           /* I:   MA prediction coefficients, Q12 [order]     */\r
-    SKP_int32            *S,           /* I/O: State vector [order]                        */\r
-    SKP_int16            *out,         /* O:   Output signal                               */\r
-    const SKP_int32      len,          /* I:   Signal length                               */\r
-    const SKP_int32      order         /* I:   Filter order                                */\r
-);\r
-\r
-/*!\r
- * 16th order AR filter for LPC synthesis, coefficients are in Q12\r
- */\r
-void silk_LPC_synthesis_order16(\r
-    const SKP_int16      *in,          /* I:   excitation signal                            */\r
-    const SKP_int16      *A_Q12,       /* I:   AR coefficients [16], between -8_Q0 and 8_Q0 */\r
-    const SKP_int32      Gain_Q26,     /* I:   gain                                         */\r
-          SKP_int32      *S,           /* I/O: state vector [16]                            */\r
-          SKP_int16      *out,         /* O:   output signal                                */\r
-    const SKP_int32      len           /* I:   signal length, must be multiple of 16        */\r
-);\r
-\r
-/* variable order MA prediction error filter. */\r
-/* Inverse filter of silk_LPC_synthesis_filter */\r
+/* Variable order MA prediction error filter. */\r
 void silk_LPC_analysis_filter(\r
     SKP_int16            *out,         /* O:   Output signal                               */\r
     const SKP_int16      *in,          /* I:   Input signal                                */\r
@@ -163,17 +138,6 @@ void silk_LPC_analysis_filter(
     const SKP_int32      Order         /* I:   Filter order                                */\r
 );\r
 \r
-/* even order AR filter */\r
-void silk_LPC_synthesis_filter(\r
-    const SKP_int16      *in,          /* I:   excitation signal                               */\r
-    const SKP_int16      *A_Q12,       /* I:   AR coefficients [Order], between -8_Q0 and 8_Q0 */\r
-    const SKP_int32      Gain_Q26,     /* I:   gain                                            */\r
-    SKP_int32            *S,           /* I/O: state vector [Order]                            */\r
-    SKP_int16            *out,         /* O:   output signal                                   */\r
-    const SKP_int32      len,          /* I:   signal length                                   */\r
-    const SKP_int        Order         /* I:   filter order, must be even                      */\r
-);\r
-\r
 /* Chirp (bandwidth expand) LP AR filter */\r
 void silk_bwexpander( \r
     SKP_int16            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */\r
@@ -212,7 +176,7 @@ void silk_ana_filt_bank_1(
 );\r
 \r
 /********************************************************************/\r
-/*                        SCALAR FUNCTIONS                            */\r
+/*                        SCALAR FUNCTIONS                          */\r
 /********************************************************************/\r
 \r
 /* approximation of 128 * log2() (exact inverse of approx 2^() below) */\r
@@ -321,13 +285,6 @@ SKP_int silk_pitch_analysis_core(        /* O    Voicing estimate: 0 voiced, 1 u
     const SKP_int    nb_subfr            /* I    number of 5 ms subframes                                   */\r
 );\r
 \r
-void silk_LPC_fit(\r
-          SKP_int16    *a_QQ,            /* O    stabilized LPC vector, Q(24-rshift) [L]        */\r
-          SKP_int32    *a_Q24,           /* I    LPC vector [L]                                 */\r
-    const SKP_int      QQ,               /* I    Q domain of output LPC vector                  */\r
-    const SKP_int      L                 /* I    Number of LPC parameters in the input vector   */\r
-);\r
-\r
 /* Compute Normalized Line Spectral Frequencies (NLSFs) from whitening filter coefficients      */\r
 /* If not all roots are found, the a_Q16 coefficients are bandwidth expanded until convergence. */\r
 void silk_A2NLSF(\r
@@ -338,9 +295,9 @@ void silk_A2NLSF(
 \r
 /* compute whitening filter coefficients from normalized line spectral frequencies */\r
 void silk_NLSF2A(\r
-    SKP_int16          *a,               /* o    monic whitening filter coefficients in Q12,  [d]    */\r
-    const SKP_int16    *NLSF,            /* i    normalized line spectral frequencies in Q15, [d]    */\r
-    const SKP_int      d                 /* i    filter order (should be even)                       */\r
+    SKP_int16        *a_Q12,            /* O    monic whitening filter coefficients in Q12,  [ d ]  */\r
+    const SKP_int16  *NLSF,             /* I    normalized line spectral frequencies in Q15, [ d ]  */\r
+    const SKP_int    d                  /* I    filter order (should be even)                       */\r
 );\r
 \r
 void silk_insertion_sort_increasing(\r
@@ -371,7 +328,7 @@ void silk_NLSF_stabilize(
 \r
 /* Laroia low complexity NLSF weights */\r
 void silk_NLSF_VQ_weights_laroia(\r
-    SKP_int16            *pNLSFW_Q5,     /* O:    Pointer to input vector weights            [D x 1]       */\r
+    SKP_int16            *pNLSFW_Q_OUT,  /* O:    Pointer to input vector weights            [D x 1]       */\r
     const SKP_int16      *pNLSF_Q15,     /* I:    Pointer to input vector                    [D x 1]       */\r
     const SKP_int        D               /* I:    Input vector dimension (even)                            */\r
 );\r
index 8fd5911..41dbcfd 100644 (file)
@@ -28,7 +28,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_SigProc_FIX.h"\r
 \r
 /* Function that returns the maximum absolut value of the input vector */\r
-SKP_int16 silk_int16_array_maxabs(    /* O    Maximum absolute value, max: 2^15-1   */\r
+SKP_int16 silk_int16_array_maxabs(          /* O    Maximum absolute value, max: 2^15-1   */\r
     const SKP_int16        *vec,            /* I    Input vector  [len]                   */\r
     const SKP_int32        len              /* I    Length of input vector                */\r
 )                    \r
index 8131ffa..ca6fb46 100644 (file)
@@ -35,11 +35,9 @@ void silk_bwexpander(
 )\r
 {\r
     SKP_int   i;\r
-    SKP_int32 chirp_minus_one_Q16;\r
+    SKP_int32 chirp_minus_one_Q16 = chirp_Q16 - 65536;\r
 \r
-    chirp_minus_one_Q16 = chirp_Q16 - 65536;\r
-\r
-    /* NB: Dont use SKP_SMULWB, instead of SKP_RSHIFT_ROUND( SKP_MUL() , 16 ), below. */\r
+    /* NB: Dont use SKP_SMULWB, instead of SKP_RSHIFT_ROUND( SKP_MUL(), 16 ), below.  */\r
     /* Bias in SKP_SMULWB can lead to unstable filters                                */\r
     for( i = 0; i < d - 1; i++ ) {\r
         ar[ i ]    = (SKP_int16)SKP_RSHIFT_ROUND( SKP_MUL( chirp_Q16, ar[ i ]             ), 16 );\r
index 8e70ade..e2bfada 100644 (file)
@@ -29,18 +29,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Chirp (bandwidth expand) LP AR filter */\r
 void silk_bwexpander_32( \r
-    SKP_int32        *ar,      /* I/O    AR filter to be expanded (without leading 1)    */\r
-    const SKP_int    d,        /* I    Length of ar                                      */\r
-    SKP_int32        chirp_Q16 /* I    Chirp factor in Q16                               */\r
+    SKP_int32        *ar,       /* I/O  AR filter to be expanded (without leading 1)    */\r
+    const SKP_int    d,         /* I    Length of ar                                    */\r
+    SKP_int32        chirp_Q16  /* I    Chirp factor in Q16                             */\r
 )\r
 {\r
     SKP_int   i;\r
-    SKP_int32 tmp_chirp_Q16;\r
+    SKP_int32 chirp_minus_one_Q16 = chirp_Q16 - 65536;\r
 \r
-    tmp_chirp_Q16 = chirp_Q16;\r
     for( i = 0; i < d - 1; i++ ) {\r
-        ar[ i ]       = SKP_SMULWW( ar[ i ],   tmp_chirp_Q16 );\r
-        tmp_chirp_Q16 = SKP_SMULWW( chirp_Q16, tmp_chirp_Q16 );\r
+        ar[ i ]    = SKP_SMULWW( chirp_Q16, ar[ i ] );\r
+        chirp_Q16 += SKP_RSHIFT_ROUND( SKP_MUL( chirp_Q16, chirp_minus_one_Q16 ), 16 );\r
     }\r
-    ar[ d - 1 ] = SKP_SMULWW( ar[ d - 1 ], tmp_chirp_Q16 );\r
+    ar[ d - 1 ] = SKP_SMULWW( chirp_Q16, ar[ d - 1 ] );\r
 }\r
+\r
index 0a18f9d..bf95ad7 100644 (file)
     <ClCompile Include="silk_log2lin.c" />\r
     <ClCompile Include="silk_LPC_analysis_filter.c" />\r
     <ClCompile Include="silk_LPC_inv_pred_gain.c" />\r
-    <ClCompile Include="silk_LPC_stabilize.c" />\r
-    <ClCompile Include="silk_LPC_synthesis_filter.c" />\r
-    <ClCompile Include="silk_LPC_synthesis_order16.c" />\r
     <ClCompile Include="silk_LP_variable_cutoff.c" />\r
     <ClCompile Include="silk_table_LSF_cos.c" />\r
     <ClCompile Include="silk_NLSF2A.c" />\r
-    <ClCompile Include="silk_NLSF2A_stable.c" />\r
     <ClCompile Include="silk_NLSF_decode.c" />\r
     <ClCompile Include="silk_NLSF_del_dec_quant.c" />\r
     <ClCompile Include="silk_NLSF_encode.c" />\r
index 455efe8..0068ec8 100644 (file)
     <ClCompile Include="silk_LPC_inv_pred_gain.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="silk_LPC_stabilize.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="silk_LPC_synthesis_filter.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="silk_LPC_synthesis_order16.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="silk_table_LSF_cos.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
     <ClCompile Include="silk_NLSF2A.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="silk_NLSF2A_stable.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="silk_NLSF_decode.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
index cbcfad0..e7e3023 100644 (file)
@@ -349,7 +349,7 @@ SKP_int silk_setup_complexity(
         psEncC->nStatesDelayedDecision          = 2;\r
         psEncC->useInterpolatedNLSFs            = 0;\r
         psEncC->LTPQuantLowComplexity           = 0;\r
-        psEncC->NLSF_MSVQ_Survivors             = 6;\r
+        psEncC->NLSF_MSVQ_Survivors             = 8;\r
         psEncC->warping_Q16                     = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );\r
     } else if( Complexity < 8 ) {\r
         psEncC->pitchEstimationComplexity       = SILK_PE_MID_COMPLEX;\r
@@ -360,7 +360,7 @@ SKP_int silk_setup_complexity(
         psEncC->nStatesDelayedDecision          = 3;\r
         psEncC->useInterpolatedNLSFs            = 0;\r
         psEncC->LTPQuantLowComplexity           = 0;\r
-        psEncC->NLSF_MSVQ_Survivors             = 8;\r
+        psEncC->NLSF_MSVQ_Survivors             = 16;\r
         psEncC->warping_Q16                     = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );\r
     } else {\r
         psEncC->pitchEstimationComplexity       = SILK_PE_MAX_COMPLEX;\r
@@ -371,7 +371,7 @@ SKP_int silk_setup_complexity(
         psEncC->nStatesDelayedDecision          = MAX_DEL_DEC_STATES;\r
         psEncC->useInterpolatedNLSFs            = 1;\r
         psEncC->LTPQuantLowComplexity           = 0;\r
-        psEncC->NLSF_MSVQ_Survivors             = 16;\r
+        psEncC->NLSF_MSVQ_Survivors             = 32;\r
         psEncC->warping_Q16                     = psEncC->fs_kHz * SILK_FIX_CONST( WARPING_MULTIPLIER, 16 );\r
     }\r
 \r
index 1268f46..fc8c809 100644 (file)
@@ -47,7 +47,7 @@ void silk_decode_parameters(
     silk_NLSF_decode( pNLSF_Q15, psDec->indices.NLSFIndices, psDec->psNLSF_CB );\r
 \r
     /* Convert NLSF parameters to AR prediction filter coefficients */\r
-    silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 1 ], pNLSF_Q15, psDec->LPC_order );\r
+    silk_NLSF2A( psDecCtrl->PredCoef_Q12[ 1 ], pNLSF_Q15, psDec->LPC_order );\r
     \r
     /* If just reset, e.g., because internal Fs changed, do not allow interpolation */\r
     /* improves the case of packet loss in the first frame after a switch           */\r
@@ -64,7 +64,7 @@ void silk_decode_parameters(
         }\r
 \r
         /* Convert NLSF parameters to AR prediction filter coefficients */\r
-        silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 0 ], pNLSF0_Q15, psDec->LPC_order );\r
+        silk_NLSF2A( psDecCtrl->PredCoef_Q12[ 0 ], pNLSF0_Q15, psDec->LPC_order );\r
     } else {\r
         /* Copy LPC coefficients for first half from second half */\r
         SKP_memcpy( psDecCtrl->PredCoef_Q12[ 0 ], psDecCtrl->PredCoef_Q12[ 1 ], \r
index 9d0710c..66eb201 100644 (file)
@@ -29,7 +29,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Set decoder sampling rate */\r
 void silk_decoder_set_fs(\r
-    silk_decoder_state          *psDec,             /* I/O  Decoder state pointer                       */\r
+    silk_decoder_state              *psDec,             /* I/O  Decoder state pointer                       */\r
     SKP_int                         fs_kHz              /* I    Sampling frequency (kHz)                    */\r
 )\r
 {\r
index 716abde..7bc8a15 100644 (file)
@@ -205,8 +205,9 @@ extern "C"
 /******************/\r
 /* NLSF quantizer */\r
 /******************/\r
+#define NLSF_W_Q                                2\r
 #define NLSF_VQ_MAX_VECTORS                     32\r
-#define NLSF_VQ_MAX_SURVIVORS                   16\r
+#define NLSF_VQ_MAX_SURVIVORS                   32\r
 #define NLSF_QUANT_MAX_AMPLITUDE                4\r
 #define NLSF_QUANT_MAX_AMPLITUDE_EXT            10\r
 #define NLSF_QUANT_LEVEL_ADJ                    0.1\r
index 582fede..fde1361 100644 (file)
@@ -183,13 +183,6 @@ void silk_gains_dequant(
     const SKP_int                   nb_subfr                    /* I    number of subframes                     */\r
 );\r
 \r
-/* Convert NLSF parameters to stable AR prediction filter coefficients */\r
-void silk_NLSF2A_stable(\r
-    SKP_int16                       pAR_Q12[ MAX_LPC_ORDER ],   /* O    Stabilized AR coefs [LPC_order]     */ \r
-    const SKP_int16                 pNLSF[ MAX_LPC_ORDER ],     /* I    NLSF vector         [LPC_order]     */\r
-    const SKP_int                   LPC_order                   /* I    LPC/LSF order                       */\r
-);\r
-\r
 /* Interpolate two vectors */\r
 void silk_interpolate(\r
     SKP_int16                       xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
@@ -306,7 +299,7 @@ SKP_int32 silk_NLSF_encode(                                 /* O    Returns RD v
           SKP_int8                  *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */\r
           SKP_int16                 *pNLSF_Q15,             /* I/O  Quantized NLSF vector [ LPC_ORDER ]     */\r
     const silk_NLSF_CB_struct       *psNLSF_CB,             /* I    Codebook object                         */\r
-    const SKP_int16                 *pW_Q5,                 /* I    NLSF weight vector [ LPC_ORDER ]        */\r
+    const SKP_int16                 *pW_QW,                 /* I    NLSF weight vector [ LPC_ORDER ]        */\r
     const SKP_int                   NLSF_mu_Q20,            /* I    Rate weight for the RD optimization     */\r
     const SKP_int                   nSurvivors,             /* I    Max survivors after first stage         */\r
     const SKP_int                   signalType              /* I    Signal type: 0/1/2                      */\r
index ef4569f..39f69aa 100644 (file)
@@ -64,7 +64,7 @@ SKP_int32 silk_P_Ana_find_scaling(
 /*************************************************************/\r
 /*      FIXED POINT CORE PITCH ANALYSIS FUNCTION             */\r
 /*************************************************************/\r
-SKP_int silk_pitch_analysis_core(    /* O    Voicing estimate: 0 voiced, 1 unvoiced                     */\r
+SKP_int silk_pitch_analysis_core(        /* O    Voicing estimate: 0 voiced, 1 unvoiced                     */\r
     const SKP_int16  *signal,            /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                 */\r
     SKP_int          *pitch_out,         /* O    4 pitch lag values                                         */\r
     SKP_int16        *lagIndex,          /* O    Lag Index                                                  */\r
index aa4ead4..392e8a3 100644 (file)
@@ -36,11 +36,11 @@ void silk_process_NLSFs(
 )\r
 {\r
     SKP_int     i, doInterpolate;\r
-    SKP_int16   pNLSFW_Q5[ MAX_LPC_ORDER ];\r
     SKP_int     NLSF_mu_Q20;\r
     SKP_int32   i_sqr_Q15;\r
     SKP_int16   pNLSF0_temp_Q15[ MAX_LPC_ORDER ];\r
-    SKP_int16   pNLSFW0_temp_Q5[ MAX_LPC_ORDER ];\r
+    SKP_int16   pNLSFW_QW[ MAX_LPC_ORDER ];\r
+    SKP_int16   pNLSFW0_temp_QW[ MAX_LPC_ORDER ];\r
 \r
     SKP_assert( psEncC->speech_activity_Q8 >=   0 );\r
     SKP_assert( psEncC->speech_activity_Q8 <= SILK_FIX_CONST( 1.0, 8 ) );\r
@@ -49,7 +49,7 @@ void silk_process_NLSFs(
     /* Calculate mu values */\r
     /***********************/\r
     /* NLSF_mu  = 0.003 - 0.0015 * psEnc->speech_activity; */\r
-    NLSF_mu_Q20 = SKP_SMLAWB( SILK_FIX_CONST( 0.003, 20 ), SILK_FIX_CONST( -0.0015, 28 ), psEncC->speech_activity_Q8 );\r
+    NLSF_mu_Q20 = SKP_SMLAWB( SILK_FIX_CONST( 0.0025, 20 ), SILK_FIX_CONST( -0.001, 28 ), psEncC->speech_activity_Q8 );\r
     if( psEncC->nb_subfr == 2 ) {\r
         /* Multiply by 1.5 for 10 ms packets */\r
         NLSF_mu_Q20 = SKP_ADD_RSHIFT( NLSF_mu_Q20, NLSF_mu_Q20, 1 );\r
@@ -59,7 +59,7 @@ void silk_process_NLSFs(
     SKP_assert( NLSF_mu_Q20 <= SILK_FIX_CONST( 0.0045, 20 ) );\r
 \r
     /* Calculate NLSF weights */\r
-    silk_NLSF_VQ_weights_laroia( pNLSFW_Q5, pNLSF_Q15, psEncC->predictLPCOrder );\r
+    silk_NLSF_VQ_weights_laroia( pNLSFW_QW, pNLSF_Q15, psEncC->predictLPCOrder );\r
 \r
     /* Update NLSF weights for interpolated NLSFs */\r
     doInterpolate = ( psEncC->useInterpolatedNLSFs == 1 ) && ( psEncC->indices.NLSFInterpCoef_Q2 < 4 );\r
@@ -69,24 +69,24 @@ void silk_process_NLSFs(
             psEncC->indices.NLSFInterpCoef_Q2, psEncC->predictLPCOrder );\r
 \r
         /* Calculate first half NLSF weights for the interpolated NLSFs */\r
-        silk_NLSF_VQ_weights_laroia( pNLSFW0_temp_Q5, pNLSF0_temp_Q15, psEncC->predictLPCOrder );\r
+        silk_NLSF_VQ_weights_laroia( pNLSFW0_temp_QW, pNLSF0_temp_Q15, psEncC->predictLPCOrder );\r
 \r
         /* Update NLSF weights with contribution from first half */\r
         i_sqr_Q15 = SKP_LSHIFT( SKP_SMULBB( psEncC->indices.NLSFInterpCoef_Q2, psEncC->indices.NLSFInterpCoef_Q2 ), 11 );\r
         for( i = 0; i < psEncC->predictLPCOrder; i++ ) {\r
-            pNLSFW_Q5[ i ] = SKP_SMLAWB( SKP_RSHIFT( pNLSFW_Q5[ i ], 1 ), pNLSFW0_temp_Q5[ i ], i_sqr_Q15 );\r
-            SKP_assert( pNLSFW_Q5[ i ] <= SKP_int16_MAX );\r
-            SKP_assert( pNLSFW_Q5[ i ] >= 1 );\r
+            pNLSFW_QW[ i ] = SKP_SMLAWB( SKP_RSHIFT( pNLSFW_QW[ i ], 1 ), pNLSFW0_temp_QW[ i ], i_sqr_Q15 );\r
+            SKP_assert( pNLSFW_QW[ i ] <= SKP_int16_MAX );\r
+            SKP_assert( pNLSFW_QW[ i ] >= 1 );\r
         }\r
     }\r
 \r
     TIC(NLSF_encode)\r
-    silk_NLSF_encode( psEncC->indices.NLSFIndices, pNLSF_Q15, psEncC->psNLSF_CB, pNLSFW_Q5\r
+    silk_NLSF_encode( psEncC->indices.NLSFIndices, pNLSF_Q15, psEncC->psNLSF_CB, pNLSFW_QW\r
         NLSF_mu_Q20, psEncC->NLSF_MSVQ_Survivors, psEncC->indices.signalType );\r
     TOC(NLSF_encode)\r
 \r
     /* Convert quantized NLSFs back to LPC coefficients */\r
-    silk_NLSF2A_stable( PredCoef_Q12[ 1 ], pNLSF_Q15, psEncC->predictLPCOrder );\r
+    silk_NLSF2A( PredCoef_Q12[ 1 ], pNLSF_Q15, psEncC->predictLPCOrder );\r
 \r
     if( doInterpolate ) {\r
         /* Calculate the interpolated, quantized LSF vector for the first half */\r
@@ -94,7 +94,7 @@ void silk_process_NLSFs(
             psEncC->indices.NLSFInterpCoef_Q2, psEncC->predictLPCOrder );\r
 \r
         /* Convert back to LPC coefficients */\r
-        silk_NLSF2A_stable( PredCoef_Q12[ 0 ], pNLSF0_temp_Q15, psEncC->predictLPCOrder );\r
+        silk_NLSF2A( PredCoef_Q12[ 0 ], pNLSF0_temp_Q15, psEncC->predictLPCOrder );\r
 \r
     } else {\r
         /* Copy LPC coefficients for first half from second half */\r
index fa78fc9..232c172 100644 (file)
@@ -70,7 +70,7 @@ static SKP_int32 gcd(
 \r
 /* Initialize/reset the resampler state for a given pair of input/output sampling rates */\r
 SKP_int silk_resampler_init( \r
-       silk_resampler_state_struct     *S,                 /* I/O: Resampler state                     */\r
+       silk_resampler_state_struct     *S,                         /* I/O: Resampler state                     */\r
        SKP_int32                                                       Fs_Hz_in,       /* I:   Input sampling rate (Hz)        */\r
        SKP_int32                                                       Fs_Hz_out       /* I:   Output sampling rate (Hz)       */\r
 )\r
@@ -260,7 +260,7 @@ SKP_int silk_resampler_clear(
 \r
 /* Resampler: convert from one sampling rate to another                                 */\r
 SKP_int silk_resampler( \r
-       silk_resampler_state_struct     *S,                 /* I/O: Resampler state                     */\r
+       silk_resampler_state_struct     *S,                         /* I/O: Resampler state                     */\r
        SKP_int16                                                       out[],      /* O:       Output signal                           */\r
        const SKP_int16                                         in[],       /* I:       Input signal                            */\r
        SKP_int32                                                       inLen       /* I:       Number of input samples         */\r
index 7851d41..b8fdc37 100644 (file)
@@ -29,7 +29,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Faster than schur64(), but much less accurate.                       */\r
 /* uses SMLAWB(), requiring armv5E and higher.                          */ \r
-SKP_int32 silk_schur(                     /* O:    Returns residual energy                     */\r
+SKP_int32 silk_schur(                           /* O:    Returns residual energy                     */\r
     SKP_int16            *rc_Q15,               /* O:    reflection coefficients [order] Q15         */\r
     const SKP_int32      *c,                    /* I:    correlations [order+1]                      */\r
     const SKP_int32      order                  /* I:    prediction order                            */\r
index a830f4a..b6e854a 100644 (file)
@@ -29,7 +29,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Slower than schur(), but more accurate.                              */\r
 /* Uses SMULL(), available on armv4                                     */ \r
-SKP_int32 silk_schur64(                      /* O:    Returns residual energy                     */\r
+SKP_int32 silk_schur64(                          /* O:    Returns residual energy                     */\r
     SKP_int32            rc_Q16[],               /* O:    Reflection coefficients [order] Q16         */\r
     const SKP_int32      c[],                    /* I:    Correlations [order+1]                      */\r
     SKP_int32            order                   /* I:    Prediction order                            */\r
index a36a3b9..e9ab376 100644 (file)
@@ -28,7 +28,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "silk_main.h"\r
 \r
 /* Find least-squares prediction gain for one signal based on another and quantize it */\r
-SKP_int32 silk_stereo_find_predictor(               /* O    Returns predictor in Q13                    */\r
+SKP_int32 silk_stereo_find_predictor(                   /* O    Returns predictor in Q13                    */\r
     SKP_int32           *ratio_Q14,                     /* O    Ratio of residual and mid energies          */\r
     const SKP_int16     x[],                            /* I    Basis signal                                */\r
     const SKP_int16     y[],                            /* I    Target signal                               */\r
index 85456ad..9c80e14 100644 (file)
@@ -90,7 +90,7 @@ extern const SKP_int16  silk_stereo_pred_quant_Q13[ STEREO_QUANT_TAB_SIZE ];
 extern const SKP_uint8  silk_stereo_pred_joint_iCDF[ 25 ];                                      /*  25 */\r
 extern const SKP_uint8  silk_stereo_only_code_mid_iCDF[ 2 ];                                    /*   2 */\r
 \r
-extern const SKP_uint8 * const silk_LBRR_flags_iCDF_ptr[ 2 ];                                   /*  10 */\r
+extern const SKP_uint8  * const silk_LBRR_flags_iCDF_ptr[ 2 ];                                   /*  10 */\r
 \r
 extern const SKP_uint8  silk_NLSF_interpolation_factor_iCDF[ 5 ];                               /*   5 */\r
 \r
index 5322531..c574289 100644 (file)
@@ -135,7 +135,7 @@ const SKP_uint8 silk_NLSF_PRED_NB_MB_Q8[ 18 ] = {
 };\r
 \r
 const SKP_int16 silk_NLSF_DELTA_MIN_NB_MB_Q15[ 11 ] = {\r
-          322,      3,      6,      3,      3,      3,      4,      3,\r
+          250,      3,      6,      3,      3,      3,      4,      3,\r
             3,      3,    461\r
 };\r
 \r
index afa40f7..3d3b4e6 100644 (file)
@@ -172,7 +172,7 @@ const SKP_uint8 silk_NLSF_PRED_WB_Q8[ 30 ] = {
 };\r
 \r
 const SKP_int16 silk_NLSF_DELTA_MIN_WB_Q15[ 17 ] = {\r
-          121,      3,     42,      3,      3,      3,      5,     14,\r
+       100,      3,     40,      3,      3,      3,      5,     14,\r
            14,     10,     11,      3,      8,      9,      7,      3,\r
           347\r
 };\r
@@ -181,8 +181,8 @@ const silk_NLSF_CB_struct silk_NLSF_CB_WB =
 {\r
     32,\r
     16,\r
-    SILK_FIX_CONST( 0.16, 16 ),\r
-    SILK_FIX_CONST( 1.0 / 0.16, 6 ),\r
+    SILK_FIX_CONST( 0.15, 16 ),\r
+    SILK_FIX_CONST( 1.0 / 0.15, 6 ),\r
     silk_NLSF_CB1_WB_Q8,\r
     silk_NLSF_CB1_iCDF_WB,\r
     silk_NLSF_PRED_WB_Q8,\r
@@ -191,3 +191,4 @@ const silk_NLSF_CB_struct silk_NLSF_CB_WB =
     silk_NLSF_CB2_BITS_WB_Q5,\r
     silk_NLSF_DELTA_MIN_WB_Q15,\r
 };\r
+\r
index bb523c3..a263c7c 100644 (file)
@@ -15,7 +15,6 @@ silk/silk_encode_pulses.c \
 silk/silk_gain_quant.c \
 silk/silk_interpolate.c \
 silk/silk_LP_variable_cutoff.c \
-silk/silk_NLSF2A_stable.c \
 silk/silk_NLSF_decode.c \
 silk/silk_NSQ.c \
 silk/silk_NSQ_del_dec.c \
@@ -62,9 +61,6 @@ silk/silk_lin2log.c \
 silk/silk_log2lin.c \
 silk/silk_LPC_analysis_filter.c \
 silk/silk_LPC_inv_pred_gain.c \
-silk/silk_LPC_stabilize.c \
-silk/silk_LPC_synthesis_filter.c \
-silk/silk_LPC_synthesis_order16.c \
 silk/silk_table_LSF_cos.c \
 silk/silk_NLSF2A.c \
 silk/silk_NLSF_stabilize.c \