Squashed commit of the following:
authorKoen Vos <koen.vos@skype.net>
Mon, 28 Feb 2011 21:07:58 +0000 (16:07 -0500)
committerJean-Marc Valin <jean-marc.valin@octasic.com>
Mon, 28 Feb 2011 21:07:58 +0000 (16:07 -0500)
commit 7721daf733c6986cb2c2511c81e6fc14fea1ec6a
Author: Jean-Marc Valin <jean-marc.valin@octasic.com>
Date:   Mon Feb 28 16:00:52 2011 -0500

    Makefile.am update

commit 47dcc4edad849f57240b0c364036a378b5d22a9a
Author: Koen Vos <koen.vos@skype.net>
Date:   Mon Feb 28 15:46:23 2011 -0500

    SILK update (prefill, new LSF quant)

65 files changed:
Makefile.am
interface/SKP_Silk_SDK_API.h
src_FIX/SKP_Silk_control_codec_FIX.c
src_FIX/SKP_Silk_encode_frame_FIX.c
src_FIX/SKP_Silk_find_LPC_FIX.c
src_FIX/SKP_Silk_find_LTP_FIX.c
src_FIX/SKP_Silk_find_pred_coefs_FIX.c
src_FIX/SKP_Silk_init_encoder_FIX.c
src_FIX/SKP_Silk_main_FIX.h
src_FLP/SKP_Silk_control_codec_FLP.c
src_FLP/SKP_Silk_encode_frame_FLP.c
src_FLP/SKP_Silk_find_LPC_FLP.c
src_FLP/SKP_Silk_find_LTP_FLP.c
src_FLP/SKP_Silk_find_pred_coefs_FLP.c
src_FLP/SKP_Silk_init_encoder_FLP.c
src_FLP/SKP_Silk_main_FLP.h
src_FLP/SKP_Silk_wrappers_FLP.c
src_SigProc_FIX/SKP_Silk_A2NLSF.c
src_SigProc_FIX/SKP_Silk_Inlines.h
src_SigProc_FIX/SKP_Silk_NLSF2A.c
src_SigProc_FIX/SKP_Silk_NLSF_VQ_weights_laroia.c
src_SigProc_FIX/SKP_Silk_NLSF_stabilize.c
src_SigProc_FIX/SKP_Silk_SigProc_FIX.h
src_SigProc_FIX/SKP_Silk_inner_prod_aligned.c
src_SigProc_FIX/SKP_Silk_k2a.c
src_SigProc_FIX/SKP_Silk_k2a_Q16.c
src_SigProc_FIX/SKP_Silk_lin2log.c
src_SigProc_FIX/SKP_Silk_log2lin.c
src_SigProc_FIX/SKP_Silk_sort.c
src_SigProc_FIX/src_SigProc_FIX.vcxproj
src_SigProc_FIX/src_SigProc_FIX.vcxproj.filters
src_common/SKP_Silk_HP_variable_cutoff.c
src_common/SKP_Silk_LP_variable_cutoff.c
src_common/SKP_Silk_NLSF2A_stable.c
src_common/SKP_Silk_NLSF_VQ.c [new file with mode: 0644]
src_common/SKP_Silk_NLSF_decode.c [new file with mode: 0644]
src_common/SKP_Silk_NLSF_del_dec_quant.c [new file with mode: 0644]
src_common/SKP_Silk_NLSF_encode.c [new file with mode: 0644]
src_common/SKP_Silk_NLSF_unpack.c [new file with mode: 0644]
src_common/SKP_Silk_NSQ.c
src_common/SKP_Silk_NSQ_del_dec.c
src_common/SKP_Silk_VAD.c
src_common/SKP_Silk_control_audio_bandwidth.c
src_common/SKP_Silk_dec_API.c
src_common/SKP_Silk_decode_core.c
src_common/SKP_Silk_decode_indices.c
src_common/SKP_Silk_decode_parameters.c
src_common/SKP_Silk_decoder_set_fs.c
src_common/SKP_Silk_define.h
src_common/SKP_Silk_enc_API.c
src_common/SKP_Silk_encode_indices.c
src_common/SKP_Silk_interpolate.c
src_common/SKP_Silk_main.h
src_common/SKP_Silk_process_NLSFs.c
src_common/SKP_Silk_setup.h
src_common/SKP_Silk_structs.h
src_common/SKP_Silk_tables.h
src_common/SKP_Silk_tables_NLSF_CB_NB_MB.c [new file with mode: 0644]
src_common/SKP_Silk_tables_NLSF_CB_WB.c [new file with mode: 0644]
src_common/SKP_Silk_tables_other.c
src_common/SKP_Silk_tables_pulses_per_block.c
src_common/SKP_Silk_tuning_parameters.h
src_common/src_common.vcxproj
src_common/src_common.vcxproj.filters
test/Encoder.c

index 78eca82..cd8082e 100644 (file)
@@ -42,17 +42,15 @@ src_common/SKP_Silk_interpolate.c \
 src_common/SKP_Silk_LBRR_embed.c \
 src_common/SKP_Silk_LP_variable_cutoff.c \
 src_common/SKP_Silk_NLSF2A_stable.c \
-src_common/SKP_Silk_NLSF_MSVQ_decode.c \
+src_common/SKP_Silk_NLSF_decode.c \
 src_common/SKP_Silk_NSQ.c \
 src_common/SKP_Silk_NSQ_del_dec.c \
 src_common/SKP_Silk_PLC.c \
 src_common/SKP_Silk_shell_coder.c \
 src_common/SKP_Silk_tables_gain.c \
 src_common/SKP_Silk_tables_LTP.c \
-src_common/SKP_Silk_tables_NLSF_CB0_10.c \
-src_common/SKP_Silk_tables_NLSF_CB0_16.c \
-src_common/SKP_Silk_tables_NLSF_CB1_10.c \
-src_common/SKP_Silk_tables_NLSF_CB1_16.c \
+src_common/SKP_Silk_tables_NLSF_CB_NB_MB.c \
+src_common/SKP_Silk_tables_NLSF_CB_WB.c \
 src_common/SKP_Silk_tables_other.c \
 src_common/SKP_Silk_tables_pitch_lag.c \
 src_common/SKP_Silk_tables_pulses_per_block.c \
@@ -61,12 +59,12 @@ src_common/SKP_Silk_control_audio_bandwidth.c \
 src_common/SKP_Silk_quant_LTP_gains.c \
 src_common/SKP_Silk_VQ_WMat_EC.c \
 src_common/SKP_Silk_HP_variable_cutoff.c \
-src_common/SKP_Silk_NLSF_MSVQ_encode.c \
-src_common/SKP_Silk_NLSF_VQ_rate_distortion.c \
-src_common/SKP_Silk_NLSF_VQ_sum_error.c \
+src_common/SKP_Silk_NLSF_encode.c \
+src_common/SKP_Silk_NLSF_VQ.c \
+src_common/SKP_Silk_NLSF_unpack.c \
+src_common/SKP_Silk_NLSF_del_dec_quant.c \
 src_common/SKP_Silk_process_NLSFs.c \
 src_SigProc_FIX/SKP_Silk_A2NLSF.c \
-src_SigProc_FIX/SKP_Silk_allpass_int.c \
 src_SigProc_FIX/SKP_Silk_ana_filt_bank_1.c \
 src_SigProc_FIX/SKP_Silk_apply_sine_window.c \
 src_SigProc_FIX/SKP_Silk_array_maxabs.c \
@@ -82,8 +80,6 @@ src_SigProc_FIX/SKP_Silk_k2a.c \
 src_SigProc_FIX/SKP_Silk_k2a_Q16.c \
 src_SigProc_FIX/SKP_Silk_lin2log.c \
 src_SigProc_FIX/SKP_Silk_log2lin.c \
-src_SigProc_FIX/SKP_Silk_lowpass_int.c \
-src_SigProc_FIX/SKP_Silk_lowpass_short.c \
 src_SigProc_FIX/SKP_Silk_LPC_analysis_filter.c \
 src_SigProc_FIX/SKP_Silk_LPC_inv_pred_gain.c \
 src_SigProc_FIX/SKP_Silk_LPC_stabilize.c \
@@ -188,7 +184,6 @@ src_common/SKP_Silk_main.h \
 src_common/SKP_Silk_PLC.h \
 src_common/SKP_Silk_structs.h \
 src_common/SKP_Silk_tables.h \
-src_common/SKP_Silk_tables_NLSF_CB.h \
 src_common/SKP_Silk_tuning_parameters.h \
 src_common/SKP_Silk_setup.h \
 src_FIX/SKP_Silk_main_FIX.h \
index 2a7546e..166700b 100644 (file)
@@ -75,26 +75,19 @@ SKP_int SKP_Silk_SDK_QueryEncoder(                      /* O:   Returns error co
     SKP_SILK_SDK_EncControlStruct       *encStatus      /* O:   Encoder Status                                  */\r
 );\r
 \r
-/*****************************/\r
-/* Prefill look-ahead buffer */\r
-/*****************************/\r
-SKP_int SKP_Silk_SDK_Encoder_prefill_buffer( \r
-    void                                *encState,      /* I/O: State                                                       */\r
-    SKP_SILK_SDK_EncControlStruct       *encControl,    /* I:   Control structure                                           */\r
-    const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector  (last part will be used)        */\r
-    SKP_int                             nSamplesIn      /* I:   Number of samples in input vector                           */\r
-);\r
-\r
 /**************************/\r
 /* Encode frame with Silk */\r
 /**************************/\r
+/* Note: if prefillFlag is set, the input must contain 10 ms of audio, irrespective of what                                    */\r
+/* encControl->payloadSize_ms is set to                                                                                                                                                */\r
 SKP_int SKP_Silk_SDK_Encode(                            /* O:   Returns error code                              */\r
     void                                *encState,      /* I/O: State                                           */\r
     SKP_SILK_SDK_EncControlStruct       *encControl,    /* I:   Control status                                  */\r
     const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector                      */\r
     SKP_int                             nSamplesIn,     /* I:   Number of samples in input vector               */\r
     ec_enc                              *psRangeEnc,    /* I/O  Compressor data structure                       */\r
-    SKP_int32                           *nBytesOut      /* I/O: Number of bytes in payload (input: Max bytes)   */\r
+    SKP_int32                           *nBytesOut,     /* I/O: Number of bytes in payload (input: Max bytes)   */\r
+    const SKP_int                       prefillFlag     /* I:   Flag to indicate prefilling buffers no coding   */\r
 );\r
 \r
 /****************************************/\r
@@ -115,6 +108,16 @@ SKP_int SKP_Silk_SDK_InitDecoder(                       /* O:   Returns error co
     void                                *decState       /* I/O: State                                           */\r
 );\r
 \r
+/************************************************************************************************/\r
+/* Prefill LPC synthesis buffer, HP filter and upsampler. Input must be exactly 10 ms of audio. */\r
+/************************************************************************************************/\r
+SKP_int SKP_Silk_SDK_Decoder_prefill_buffers(           /* O:   Returns error code                              */\r
+    void*                               decState,       /* I/O: State                                           */\r
+    SKP_SILK_SDK_DecControlStruct*      decControl,     /* I/O: Control Structure                               */\r
+    const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector  (10 ms)             */\r
+    SKP_int                             nSamplesIn      /* I:   Number of samples in input vector               */\r
+);\r
+\r
 /******************/\r
 /* Decode a frame */\r
 /******************/\r
index 5c92427..b092460 100644 (file)
@@ -55,7 +55,7 @@ SKP_int SKP_Silk_control_encoder_FIX(
 {\r
     SKP_int   fs_kHz, ret = 0;\r
 \r
-    if( psEnc->sCmn.controlled_since_last_payload != 0 ) {\r
+    if( psEnc->sCmn.controlled_since_last_payload != 0 && psEnc->sCmn.prefillFlag == 0 ) {\r
         if( psEnc->sCmn.API_fs_Hz != psEnc->sCmn.prev_API_fs_Hz && psEnc->sCmn.fs_kHz > 0 ) {\r
             /* Change in API sampling rate in the middle of encoding a packet */\r
             ret += SKP_Silk_setup_resamplers( psEnc, psEnc->sCmn.fs_kHz );\r
@@ -176,9 +176,10 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
             ( PacketSize_ms !=  60 ) ) {\r
             ret = SKP_SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;\r
         }\r
-        if( PacketSize_ms == 10 ) {\r
+        if( PacketSize_ms <= 10 ) {\r
             psEnc->sCmn.nFramesPerPacket = 1;\r
-            psEnc->sCmn.nb_subfr = MAX_NB_SUBFR >> 1;\r
+            psEnc->sCmn.nb_subfr = PacketSize_ms == 10 ? 2 : 1;\r
+            psEnc->sCmn.frame_length = SKP_SMULBB( PacketSize_ms, fs_kHz );\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
             if( psEnc->sCmn.fs_kHz == 8 ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
@@ -188,6 +189,7 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
         } else {\r
             psEnc->sCmn.nFramesPerPacket = SKP_DIV32_16( PacketSize_ms, MAX_FRAME_LENGTH_MS );\r
             psEnc->sCmn.nb_subfr = MAX_NB_SUBFR;\r
+            psEnc->sCmn.frame_length = SKP_SMULBB( 20, fs_kHz );\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );\r
             if( psEnc->sCmn.fs_kHz == 8 ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_NB_iCDF;\r
@@ -195,10 +197,13 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_iCDF; \r
             }\r
         }\r
-        psEnc->sCmn.PacketSize_ms = PacketSize_ms;\r
+        psEnc->sCmn.PacketSize_ms  = PacketSize_ms;\r
+        psEnc->sCmn.TargetRate_bps = 0;         /* trigger new SNR computation */\r
     }\r
 \r
     /* Set internal sampling frequency */\r
+    SKP_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );\r
+    SKP_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );\r
     if( psEnc->sCmn.fs_kHz != fs_kHz ) {\r
         /* reset part of the state */\r
         SKP_memset( &psEnc->sShape,               0, sizeof( SKP_Silk_shape_state_FIX ) );\r
@@ -220,42 +225,34 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
 \r
         psEnc->sCmn.fs_kHz = fs_kHz;\r
         if( psEnc->sCmn.fs_kHz == 8 ) {\r
-            psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;\r
-            psEnc->sCmn.psNLSF_CB[ 0 ]  = &SKP_Silk_NLSF_CB0_10;\r
-            psEnc->sCmn.psNLSF_CB[ 1 ]  = &SKP_Silk_NLSF_CB1_10;\r
-            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_NB_iCDF; \r
-            } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             }\r
         } else {\r
-            psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;\r
-            psEnc->sCmn.psNLSF_CB[ 0 ]  = &SKP_Silk_NLSF_CB0_16;\r
-            psEnc->sCmn.psNLSF_CB[ 1 ]  = &SKP_Silk_NLSF_CB1_16;\r
-            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_iCDF; \r
-            } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             }\r
         }\r
+        if( psEnc->sCmn.fs_kHz == 8 || psEnc->sCmn.fs_kHz == 12 ) {\r
+            psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;\r
+            psEnc->sCmn.psNLSF_CB  = &SKP_Silk_NLSF_CB_NB_MB;\r
+        } else {\r
+            psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;\r
+            psEnc->sCmn.psNLSF_CB  = &SKP_Silk_NLSF_CB_WB;\r
+        }\r
         psEnc->sCmn.subfr_length   = SUB_FRAME_LENGTH_MS * fs_kHz;\r
         psEnc->sCmn.frame_length   = SKP_SMULBB( psEnc->sCmn.subfr_length, psEnc->sCmn.nb_subfr );\r
         psEnc->sCmn.ltp_mem_length = SKP_SMULBB( LTP_MEM_LENGTH_MS, fs_kHz ); \r
         psEnc->sCmn.la_pitch       = SKP_SMULBB( LA_PITCH_MS, fs_kHz );\r
         psEnc->sCmn.max_pitch_lag  = SKP_SMULBB( 18, fs_kHz );\r
-        if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+        if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );\r
-        } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-            psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
         } else {\r
-            /* Unsupported number of frames */\r
-            SKP_assert( 0 );\r
+            psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
         }\r
         if( psEnc->sCmn.fs_kHz == 16 ) {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_WB, 9 );\r
@@ -263,12 +260,9 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
         } else if( psEnc->sCmn.fs_kHz == 12 ) {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_MB, 9 );\r
             psEnc->sCmn.pitch_lag_low_bits_iCDF = SKP_Silk_uniform6_iCDF;\r
-        } else if( psEnc->sCmn.fs_kHz == 8 ) {\r
+        } else {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_NB, 9 );\r
             psEnc->sCmn.pitch_lag_low_bits_iCDF = SKP_Silk_uniform4_iCDF;\r
-        } else {\r
-            /* unsupported sampling rate */\r
-            SKP_assert( 0 );\r
         }\r
     }\r
 \r
index 985b114..36c57c7 100644 (file)
@@ -46,7 +46,7 @@ SKP_int SKP_Silk_encode_frame_FIX(
 \r
 TIC(ENCODE_FRAME)\r
 \r
-    if( psEnc->sCmn.nFramesAnalyzed == 0 ) {\r
+    if( psEnc->sCmn.nFramesAnalyzed == 0 && !psEnc->sCmn.prefillFlag && !( psEnc->sCmn.useDTX && psEnc->sCmn.inDTX ) ) {\r
         /* Create space at start of payload for VAD and FEC flags */\r
         SKP_uint8 iCDF[ 2 ] = { 0, 0 };\r
         iCDF[ 0 ] = 256 - SKP_RSHIFT( 256, psEnc->sCmn.nFramesPerPacket + 1 );\r
@@ -105,12 +105,7 @@ TOC(VAD)
     /* High-pass filtering of the input signal */\r
     /*******************************************/\r
 TIC(HP_IN)\r
-#if HIGH_PASS_INPUT\r
-    /* Variable high-pass filter */\r
     SKP_Silk_HP_variable_cutoff( &psEnc->sCmn, x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf, psEnc->sCmn.frame_length );\r
-#else\r
-    SKP_memcpy( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );\r
-#endif\r
 TOC(HP_IN)\r
 \r
 #if SWITCH_TRANSITION_FILTERING\r
@@ -175,6 +170,21 @@ TIC(NSQ)
     }\r
 TOC(NSQ)\r
 \r
+    /* Update input buffer */\r
+    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], \r
+        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_int16 ) );\r
+\r
+    /* Parameters needed for next frame */\r
+    psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];\r
+    psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;\r
+\r
+    /* Exit without entropy coding */\r
+    if( psEnc->sCmn.prefillFlag || ( psEnc->sCmn.useDTX && psEnc->sCmn.inDTX ) ) {\r
+        /* No payload */\r
+        *pnBytesOut = 0;\r
+        return ret;\r
+    }\r
+\r
     /****************************************/\r
     /* Encode Parameters                    */\r
     /****************************************/\r
@@ -199,24 +209,12 @@ TOC(ENCODE_PULSES)
     psEnc->BufferedInChannel_ms -= psEnc->sCmn.PacketSize_ms;\r
     psEnc->BufferedInChannel_ms  = SKP_LIMIT_int( psEnc->BufferedInChannel_ms, 0, 100 );\r
     psEnc->sCmn.prev_nBits = nBits;\r
-\r
-    /****************************************/\r
-    /* Update Buffers and State             */\r
-    /****************************************/\r
-    /* Update input buffer */\r
-    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], \r
-        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_int16 ) );\r
-    \r
-    /* Parameters needed for next frame */\r
-    psEnc->sCmn.prevLag                 = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];\r
-    psEnc->sCmn.prevSignalType          = psEnc->sCmn.indices.signalType;\r
     psEnc->sCmn.first_frame_after_reset = 0;\r
-    psEnc->sCmn.nFramesAnalyzed++;\r
 \r
     /****************************************/\r
     /* Finalize payload                     */\r
     /****************************************/\r
-    if( psEnc->sCmn.nFramesAnalyzed >= psEnc->sCmn.nFramesPerPacket ) {\r
+    if( ++psEnc->sCmn.nFramesAnalyzed >= psEnc->sCmn.nFramesPerPacket ) {\r
         /* Insert VAD flags and FEC flag at beginning of bitstream */\r
         flags = 0;\r
         for( i = 0; i < psEnc->sCmn.nFramesPerPacket; i++ ) {\r
@@ -270,20 +268,19 @@ TOC(ENCODE_FRAME)
         tmp[ 0 ] = (SKP_float)sEncCtrl.current_SNR_dB_Q7 / 128.0f;\r
         DEBUG_STORE_DATA( current_SNR_db.dat,       tmp,                            sizeof( SKP_float ) );\r
         DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType,    sizeof( SKP_int ) );\r
-        tmp[ 0 ] = (SKP_float)psEnc->speech_activity_Q8 / 256.0f;\r
+        tmp[ 0 ] = (SKP_float)psEnc->sCmn.speech_activity_Q8 / 256.0f;\r
         DEBUG_STORE_DATA( speech_activity.dat,      tmp,                            sizeof( SKP_float ) );\r
         for( i = 0; i < VAD_N_BANDS; i++ ) {\r
             tmp[ i ] = (SKP_float)psEnc->sCmn.input_quality_bands_Q15[ i ] / 32768.0f;\r
         }\r
         DEBUG_STORE_DATA( input_quality_bands.dat,  tmp,                            VAD_N_BANDS * sizeof( SKP_float ) );\r
-        DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( SKP_int ) ); \r
-        DEBUG_STORE_DATA( ratelevel.dat,            &psEnc->sCmn.indices.RateLevelIndex,     sizeof( SKP_int ) ); \r
+        DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,         sizeof( SKP_int8) ); \r
         DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,           sizeof( SKP_int16 ) ); \r
         DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,       sizeof( SKP_int8 ) ); \r
-        DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,           sizeof( SKP_int ) ); \r
+        DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,           sizeof( SKP_int8) ); \r
     }\r
 #endif\r
-    return( ret );\r
+    return ret;\r
 }\r
 \r
 /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate  */\r
index 8b0a96c..bf065db 100644 (file)
@@ -30,14 +30,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Finds LPC vector from correlations, and converts to NLSF */\r
 void SKP_Silk_find_LPC_FIX(\r
-    SKP_int             NLSF_Q15[],             /* O    NLSFs                                                                       */\r
-    SKP_int8            *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation                  */\r
-    const SKP_int       prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                            */\r
-    const SKP_int       useInterpolatedNLSFs,   /* I    Flag                                                                        */\r
-    const SKP_int       LPC_order,              /* I    LPC order                                                                   */\r
-    const SKP_int16     x[],                    /* I    Input signal                                                                */\r
-    const SKP_int       subfr_length,           /* I    Input signal subframe length including preceeding samples                   */\r
-    const SKP_int       nb_subfr                /* I:   Number of subframes                                                         */\r
+    SKP_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
+    SKP_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
+    const SKP_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
+    const SKP_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
+    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
+    const SKP_int                   LPC_order,              /* I    LPC order                                                       */\r
+    const SKP_int16                 x[],                    /* I    Input signal                                                    */\r
+    const SKP_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
+    const SKP_int                   nb_subfr                /* I:   Number of subframes                                             */\r
 )\r
 {\r
     SKP_int     k;\r
@@ -50,7 +51,7 @@ void SKP_Silk_find_LPC_FIX(
     SKP_int32   a_tmp_Q16[ MAX_LPC_ORDER ], res_nrg_interp, res_nrg, res_tmp_nrg, res_nrg_2nd;\r
     SKP_int     res_nrg_interp_Q, res_nrg_Q, res_tmp_nrg_Q, res_nrg_2nd_Q;\r
     SKP_int16   a_tmp_Q12[ MAX_LPC_ORDER ];\r
-    SKP_int     NLSF0_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
     SKP_int16   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
 \r
     /* Default: no interpolation */\r
@@ -59,9 +60,13 @@ void SKP_Silk_find_LPC_FIX(
     /* Burg AR analysis for the full frame */\r
     SKP_Silk_burg_modified( &res_nrg, &res_nrg_Q, a_Q16, x, subfr_length, nb_subfr, SKP_FIX_CONST( FIND_LPC_COND_FAC, 32 ), LPC_order );\r
 \r
-    SKP_Silk_bwexpander_32( a_Q16, LPC_order, SKP_FIX_CONST( FIND_LPC_CHIRP, 16 ) );\r
+    if( firstFrameAfterReset ) {\r
+        SKP_Silk_bwexpander_32( a_Q16, LPC_order, SKP_FIX_CONST( FIND_LPC_CHIRP_FIRST_FRAME, 16 ) );\r
+    } else {\r
+        SKP_Silk_bwexpander_32( a_Q16, LPC_order, SKP_FIX_CONST( FIND_LPC_CHIRP, 16 ) );\r
+    }\r
 \r
-    if( useInterpolatedNLSFs == 1 && nb_subfr == MAX_NB_SUBFR ) {\r
+    if( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) {\r
 \r
         /* Optimal solution for last 10 ms */\r
         SKP_Silk_burg_modified( &res_tmp_nrg, &res_tmp_nrg_Q, a_tmp_Q16, x + ( MAX_NB_SUBFR >> 1 ) * subfr_length, \r
@@ -147,4 +152,6 @@ void SKP_Silk_find_LPC_FIX(
         /* NLSF interpolation is currently inactive, calculate NLSFs from full frame AR coefficients */\r
         SKP_Silk_A2NLSF( NLSF_Q15, a_Q16, LPC_order );\r
     }\r
+\r
+    SKP_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );\r
 }\r
index 014cd08..50aeb56 100644 (file)
@@ -89,7 +89,10 @@ void SKP_Silk_find_LTP_FIX(
         }\r
         SKP_assert( rr[ k ] >= 0 );\r
 \r
-        regu = SKP_SMULWB( rr[ k ] + 1, SKP_FIX_CONST( LTP_DAMPING, 16 ) );\r
+        regu = 1;\r
+        regu = SKP_SMLAWB( regu, rr[ k ], SKP_FIX_CONST( LTP_DAMPING/3, 16 ) );\r
+        regu = SKP_SMLAWB( regu, matrix_ptr( WLTP_ptr, 0, 0, LTP_ORDER ), SKP_FIX_CONST( LTP_DAMPING/3, 16 ) );\r
+        regu = SKP_SMLAWB( regu, matrix_ptr( WLTP_ptr, LTP_ORDER-1, LTP_ORDER-1, LTP_ORDER ), SKP_FIX_CONST( LTP_DAMPING/3, 16 ) );\r
         SKP_Silk_regularize_correlations_FIX( WLTP_ptr, &rr[k], regu, LTP_ORDER );\r
 \r
         SKP_Silk_solve_LDL_FIX( WLTP_ptr, LTP_ORDER, Rr, b_Q16 ); /* WLTP_fix_ptr and Rr_fix_ptr both in Q(-corr_rshifts[k]) */\r
@@ -122,7 +125,7 @@ void SKP_Silk_find_LTP_FIX(
 \r
         SKP_Silk_scale_vector32_Q26_lshift_18( WLTP_ptr, temp32, LTP_ORDER * LTP_ORDER ); /* WLTP_ptr in Q( 18 - corr_rshifts[ k ] ) */\r
         \r
-        w[ k ] = matrix_ptr( WLTP_ptr, ( LTP_ORDER >> 1 ), ( LTP_ORDER >> 1 ), LTP_ORDER ); /* w in Q( 18 - corr_rshifts[ k ] ) */\r
+        w[ k ] = matrix_ptr( WLTP_ptr, LTP_ORDER/2, LTP_ORDER/2, LTP_ORDER ); /* w in Q( 18 - corr_rshifts[ k ] ) */\r
         SKP_assert( w[k] >= 0 );\r
 \r
         r_ptr     += subfr_length;\r
index babc4e8..532a695 100644 (file)
@@ -37,7 +37,7 @@ void SKP_Silk_find_pred_coefs_FIX(
     SKP_int         i;\r
     SKP_int32       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];\r
     SKP_int32       invGains_Q16[ MAX_NB_SUBFR ], local_gains[ MAX_NB_SUBFR ], Wght_Q15[ MAX_NB_SUBFR ];\r
-    SKP_int         NLSF_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
     const SKP_int16 *x_ptr;\r
     SKP_int16       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];\r
     SKP_int32       tmp, min_gain_Q16;\r
@@ -109,7 +109,7 @@ void SKP_Silk_find_pred_coefs_FIX(
     /* LPC_in_pre contains the LTP-filtered input for voiced, and the unfiltered input for unvoiced */\r
     TIC(FIND_LPC)\r
     SKP_Silk_find_LPC_FIX( NLSF_Q15, &psEnc->sCmn.indices.NLSFInterpCoef_Q2, psEnc->sCmn.prev_NLSFq_Q15, \r
-        psEnc->sCmn.useInterpolatedNLSFs * ( 1 - psEnc->sCmn.first_frame_after_reset ), psEnc->sCmn.predictLPCOrder, \r
+        psEnc->sCmn.useInterpolatedNLSFs, psEnc->sCmn.first_frame_after_reset, psEnc->sCmn.predictLPCOrder, \r
         LPC_in_pre, psEnc->sCmn.subfr_length + psEnc->sCmn.predictLPCOrder, psEnc->sCmn.nb_subfr );\r
     TOC(FIND_LPC)\r
 \r
index 1818b19..601414b 100644 (file)
@@ -37,10 +37,8 @@ SKP_int SKP_Silk_init_encoder_FIX(
     /* Clear the entire encoder state */\r
     SKP_memset( psEnc, 0, sizeof( SKP_Silk_encoder_state_FIX ) );\r
 \r
-#if HIGH_PASS_INPUT\r
     psEnc->sCmn.variable_HP_smth1_Q15 = 200844; /* = SKP_Silk_log2(70)_Q0; */\r
     psEnc->sCmn.variable_HP_smth2_Q15 = 200844; /* = SKP_Silk_log2(70)_Q0; */\r
-#endif\r
 \r
     /* Used to deactivate LSF interpolation, fluctuation reduction, pitch prediction */\r
     psEnc->sCmn.first_frame_after_reset = 1;\r
index 004e7d2..e0b7871 100644 (file)
@@ -132,14 +132,15 @@ void SKP_Silk_find_pred_coefs_FIX(
 \r
 /* LPC analysis */\r
 void SKP_Silk_find_LPC_FIX(\r
-    SKP_int             NLSF_Q15[],                 /* O    NLSFs                                                                       */\r
-    SKP_int8            *interpIndex,               /* O    NLSF interpolation index, only used for NLSF interpolation                  */\r
-    const SKP_int       prev_NLSFq_Q15[],           /* I    previous NLSFs, only used for NLSF interpolation                            */\r
-    const SKP_int       useInterpolatedNLSFs,       /* I    Flag                                                                        */\r
-    const SKP_int       LPC_order,                  /* I    LPC order                                                                   */\r
-    const SKP_int16     x[],                        /* I    Input signal                                                                */\r
-    const SKP_int       subfr_length,               /* I    Input signal subframe length including preceeding samples                   */\r
-    const SKP_int       nb_subfr                    /* I:   Number of subframes                                                         */\r
+    SKP_int16                       NLSF_Q15[],             /* O    NLSFs                                                           */\r
+    SKP_int8                        *interpIndex,           /* O    NLSF interpolation index, only used for NLSF interpolation      */\r
+    const SKP_int16                 prev_NLSFq_Q15[],       /* I    previous NLSFs, only used for NLSF interpolation                */\r
+    const SKP_int                   useInterpNLSFs,         /* I    Flag                                                            */\r
+    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                                            */\r
+    const SKP_int                   LPC_order,              /* I    LPC order                                                       */\r
+    const SKP_int16                 x[],                    /* I    Input signal                                                    */\r
+    const SKP_int                   subfr_length,           /* I    Input signal subframe length including preceeding samples       */\r
+    const SKP_int                   nb_subfr                /* I:   Number of subframes                                             */\r
 );\r
 \r
 /* LTP analysis */\r
index 77de4ea..06b3fd2 100644 (file)
@@ -55,7 +55,7 @@ SKP_int SKP_Silk_control_encoder_FLP(
 {\r
     SKP_int   fs_kHz, ret = 0;\r
 \r
-    if( psEnc->sCmn.controlled_since_last_payload != 0 ) {\r
+    if( psEnc->sCmn.controlled_since_last_payload != 0 && psEnc->sCmn.prefillFlag == 0 ) {\r
         if( psEnc->sCmn.API_fs_Hz != psEnc->sCmn.prev_API_fs_Hz && psEnc->sCmn.fs_kHz > 0 ) {\r
             /* Change in API sampling rate in the middle of encoding a packet */\r
             ret += SKP_Silk_setup_resamplers( psEnc, psEnc->sCmn.fs_kHz );\r
@@ -180,10 +180,10 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
             ( PacketSize_ms !=  60 ) ) {\r
             ret = SKP_SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;\r
         }\r
-        if( PacketSize_ms == 10 ) {\r
-            /* Only allowed when the payload buffer is empty */\r
+        if( PacketSize_ms <= 10 ) {\r
             psEnc->sCmn.nFramesPerPacket = 1;\r
-            psEnc->sCmn.nb_subfr = MAX_NB_SUBFR >> 1;\r
+            psEnc->sCmn.nb_subfr = PacketSize_ms == 10 ? 2 : 1;\r
+            psEnc->sCmn.frame_length = PacketSize_ms * fs_kHz;\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
             if( psEnc->sCmn.fs_kHz == 8 ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
@@ -193,6 +193,7 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
         } else {\r
             psEnc->sCmn.nFramesPerPacket = SKP_DIV32_16( PacketSize_ms, MAX_FRAME_LENGTH_MS );\r
             psEnc->sCmn.nb_subfr = MAX_NB_SUBFR;\r
+            psEnc->sCmn.frame_length = 20 * fs_kHz;\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );\r
             if( psEnc->sCmn.fs_kHz == 8 ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_NB_iCDF;\r
@@ -200,10 +201,13 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_iCDF; \r
             }\r
         }\r
-        psEnc->sCmn.PacketSize_ms = PacketSize_ms;\r
+        psEnc->sCmn.PacketSize_ms  = PacketSize_ms;\r
+        psEnc->sCmn.TargetRate_bps = 0;         /* trigger new SNR computation */\r
     }\r
 \r
     /* Set internal sampling frequency */\r
+    SKP_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );\r
+    SKP_assert( psEnc->sCmn.nb_subfr == 2 || psEnc->sCmn.nb_subfr == 4 );\r
     if( psEnc->sCmn.fs_kHz != fs_kHz ) {\r
         /* reset part of the state */\r
         SKP_memset( &psEnc->sShape,               0, sizeof( SKP_Silk_shape_state_FLP ) );\r
@@ -225,42 +229,34 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
 \r
         psEnc->sCmn.fs_kHz = fs_kHz;\r
         if( psEnc->sCmn.fs_kHz == 8 ) {\r
-            psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;\r
-            psEnc->sCmn.psNLSF_CB[ 0 ]  = &SKP_Silk_NLSF_CB0_10;\r
-            psEnc->sCmn.psNLSF_CB[ 1 ]  = &SKP_Silk_NLSF_CB1_10;\r
-            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_NB_iCDF; \r
-            } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             }\r
         } else {\r
-            psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;\r
-            psEnc->sCmn.psNLSF_CB[ 0 ]  = &SKP_Silk_NLSF_CB0_16;\r
-            psEnc->sCmn.psNLSF_CB[ 1 ]  = &SKP_Silk_NLSF_CB1_16;\r
-            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+            if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
                 psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_iCDF; \r
-            } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psEnc->sCmn.pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             }\r
         }\r
+        if( psEnc->sCmn.fs_kHz == 8 || psEnc->sCmn.fs_kHz == 12 ) {\r
+            psEnc->sCmn.predictLPCOrder = MIN_LPC_ORDER;\r
+            psEnc->sCmn.psNLSF_CB  = &SKP_Silk_NLSF_CB_NB_MB;\r
+        } else {\r
+            psEnc->sCmn.predictLPCOrder = MAX_LPC_ORDER;\r
+            psEnc->sCmn.psNLSF_CB  = &SKP_Silk_NLSF_CB_WB;\r
+        }\r
         psEnc->sCmn.subfr_length   = SUB_FRAME_LENGTH_MS * fs_kHz;\r
         psEnc->sCmn.frame_length   = psEnc->sCmn.subfr_length * psEnc->sCmn.nb_subfr;\r
         psEnc->sCmn.ltp_mem_length = LTP_MEM_LENGTH_MS * fs_kHz; \r
         psEnc->sCmn.la_pitch       = LA_PITCH_MS * fs_kHz;\r
         psEnc->sCmn.max_pitch_lag = 18 * fs_kHz;\r
-        if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ){\r
+        if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR ) {\r
             psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS, fs_kHz );\r
-        } else if( psEnc->sCmn.nb_subfr == MAX_NB_SUBFR / 2 ){\r
-            psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
         } else {\r
-            /* Unsupported number of frames */\r
-            SKP_assert( 0 );\r
+            psEnc->sCmn.pitch_LPC_win_length = SKP_SMULBB( FIND_PITCH_LPC_WIN_MS_2_SF, fs_kHz );\r
         }\r
         if( psEnc->sCmn.fs_kHz == 16 ) {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_WB, 9 );\r
@@ -268,12 +264,9 @@ SKP_INLINE SKP_int SKP_Silk_setup_fs(
         } else if( psEnc->sCmn.fs_kHz == 12 ) {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_MB, 9 );\r
             psEnc->sCmn.pitch_lag_low_bits_iCDF = SKP_Silk_uniform6_iCDF;\r
-        } else if( psEnc->sCmn.fs_kHz == 8 ) {\r
+        } else {\r
             psEnc->sCmn.mu_LTP_Q9 = SKP_FIX_CONST( MU_LTP_QUANT_NB, 9 );\r
             psEnc->sCmn.pitch_lag_low_bits_iCDF = SKP_Silk_uniform4_iCDF;\r
-        } else {\r
-            /* unsupported sampling rate */\r
-            SKP_assert( 0 );\r
         }\r
     }\r
 \r
index 5d4d269..8a6d3b4 100644 (file)
@@ -47,7 +47,7 @@ SKP_int SKP_Silk_encode_frame_FLP(
 \r
 TIC(ENCODE_FRAME)\r
 \r
-    if( psEnc->sCmn.nFramesAnalyzed == 0 ) {\r
+    if( psEnc->sCmn.nFramesAnalyzed == 0 && !psEnc->sCmn.prefillFlag && !( psEnc->sCmn.useDTX && psEnc->sCmn.inDTX ) ) {\r
         /* Create space at start of payload for VAD and FEC flags */\r
         SKP_uint8 iCDF[ 2 ] = { 0, 0 };\r
         iCDF[ 0 ] = 256 - SKP_RSHIFT( 256, psEnc->sCmn.nFramesPerPacket + 1 );\r
@@ -106,12 +106,7 @@ TOC(VAD)
     /* High-pass filtering of the input signal */\r
     /*******************************************/\r
 TIC(HP_IN)\r
-#if HIGH_PASS_INPUT\r
-    /* Variable high-pass filter */\r
     SKP_Silk_HP_variable_cutoff( &psEnc->sCmn, pIn_HP, psEnc->sCmn.inputBuf, psEnc->sCmn.frame_length );\r
-#else\r
-    SKP_memcpy( pIn_HP, psEnc->sCmn.inputBuf, psEnc->sCmn.frame_length * sizeof( SKP_int16 ) );\r
-#endif\r
 TOC(HP_IN)\r
 \r
 #if SWITCH_TRANSITION_FILTERING\r
@@ -178,6 +173,21 @@ TIC(NSQ)
     SKP_Silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, &psEnc->sCmn.indices, &psEnc->sCmn.sNSQ, psEnc->sCmn.pulses, xfw );\r
 TOC(NSQ)\r
 \r
+    /* Update input buffer */\r
+    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], \r
+        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_float ) );\r
+\r
+    /* Parameters needed for next frame */\r
+    psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];\r
+    psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;\r
+\r
+    /* Exit without entropy coding */\r
+    if( psEnc->sCmn.prefillFlag || ( psEnc->sCmn.useDTX && psEnc->sCmn.inDTX ) ) {\r
+        /* No payload */\r
+        *pnBytesOut = 0;\r
+        return ret;\r
+    }\r
+\r
     /****************************************/\r
     /* Encode Parameters                    */\r
     /****************************************/\r
@@ -202,24 +212,12 @@ TOC(ENCODE_PULSES)
     psEnc->BufferedInChannel_ms -= psEnc->sCmn.nb_subfr * SUB_FRAME_LENGTH_MS;\r
     psEnc->BufferedInChannel_ms  = SKP_LIMIT_float( psEnc->BufferedInChannel_ms, 0.0f, 100.0f );\r
     psEnc->sCmn.prev_nBits = nBits;\r
-\r
-    /****************************************/\r
-    /* Update Buffers and State             */\r
-    /****************************************/\r
-    /* Update input buffer */\r
-    SKP_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ], \r
-        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( SKP_float ) );\r
-    \r
-    /* Parameters needed for next frame */\r
-    psEnc->sCmn.prevLag                 = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];\r
-    psEnc->sCmn.prevSignalType          = psEnc->sCmn.indices.signalType;\r
     psEnc->sCmn.first_frame_after_reset = 0;\r
-    psEnc->sCmn.nFramesAnalyzed++;\r
 \r
     /****************************************/\r
     /* Finalize payload                     */\r
     /****************************************/\r
-    if( psEnc->sCmn.nFramesAnalyzed >= psEnc->sCmn.nFramesPerPacket ) {\r
+    if( ++psEnc->sCmn.nFramesAnalyzed >= psEnc->sCmn.nFramesPerPacket ) {\r
         /* Insert VAD flags and FEC flag at beginning of bitstream */\r
         flags = 0;\r
         for( i = 0; i < psEnc->sCmn.nFramesPerPacket; i++ ) {\r
@@ -248,24 +246,21 @@ TOC(ENCODE_FRAME)
     DEBUG_STORE_DATA( pitchL.dat,               sEncCtrl.pitchL,                                 MAX_NB_SUBFR * sizeof( SKP_int   ) );\r
     DEBUG_STORE_DATA( pitchG_quantized.dat,     sEncCtrl.LTPCoef,            psEnc->sCmn.nb_subfr * LTP_ORDER * sizeof( SKP_float ) );\r
     DEBUG_STORE_DATA( LTPcorr.dat,              &psEnc->LTPCorr,                                                sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( tilt.dat,                 &sEncCtrl.input_tilt,                                           sizeof( SKP_float ) );\r
     DEBUG_STORE_DATA( gains.dat,                sEncCtrl.Gains,                          psEnc->sCmn.nb_subfr * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( gains_indices.dat,        &sEncCtrl.sCmn.GainsIndices,             psEnc->sCmn.nb_subfr * sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( gains_indices.dat,        &psEnc->sCmn.indices.GainsIndices,       psEnc->sCmn.nb_subfr * sizeof( SKP_int8  ) );\r
     DEBUG_STORE_DATA( nBits.dat,                &nBits,                                                         sizeof( SKP_int   ) );\r
     DEBUG_STORE_DATA( current_SNR_db.dat,       &sEncCtrl.current_SNR_dB,                                       sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( quantOffsetType.dat,      &sEncCtrl.sCmn.quantOffsetType,                                 sizeof( SKP_int   ) );\r
-    DEBUG_STORE_DATA( speech_activity_q8.dat,   &psEnc->speech_activity_Q8,                                     sizeof( SKP_in    ) );\r
-    DEBUG_STORE_DATA( input_quality_bands.dat,  sEncCtrl.input_quality_bands,                     VAD_N_BANDS * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( signalType.dat,           &sEncCtrl.sCmn.signalType,                                      sizeof( SKP_int   ) ); \r
-    DEBUG_STORE_DATA( ratelevel.dat,            &sEncCtrl.sCmn.RateLevelIndex,                                  sizeof( SKP_int   ) ); \r
-    DEBUG_STORE_DATA( lag_index.dat,            &sEncCtrl.sCmn.lagIndex,                                        sizeof( SKP_int   ) ); \r
-    DEBUG_STORE_DATA( contour_index.dat,        &sEncCtrl.sCmn.contourIndex,                                    sizeof( SKP_int   ) ); \r
-    DEBUG_STORE_DATA( per_index.dat,            &sEncCtrl.sCmn.PERIndex,                                        sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( quantOffsetType.dat,      &psEnc->sCmn.indices.quantOffsetType,                           sizeof( SKP_int8  ) );\r
+    DEBUG_STORE_DATA( speech_activity_q8.dat,   &psEnc->sCmn.speech_activity_Q8,                                sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( signalType.dat,           &psEnc->sCmn.indices.signalType,                                sizeof( SKP_int8  ) ); \r
+    DEBUG_STORE_DATA( lag_index.dat,            &psEnc->sCmn.indices.lagIndex,                                  sizeof( SKP_int16 ) ); \r
+    DEBUG_STORE_DATA( contour_index.dat,        &psEnc->sCmn.indices.contourIndex,                              sizeof( SKP_int8  ) ); \r
+    DEBUG_STORE_DATA( per_index.dat,            &psEnc->sCmn.indices.PERIndex,                                  sizeof( SKP_int8  ) );\r
     DEBUG_STORE_DATA( PredCoef.dat,             &sEncCtrl.PredCoef[ 1 ],          psEnc->sCmn.predictLPCOrder * sizeof( SKP_float ) );\r
-    DEBUG_STORE_DATA( ltp_scale_idx.dat,        &sEncCtrl.sCmn.LTP_scaleIndex,                                  sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( ltp_scale_idx.dat,        &psEnc->sCmn.indices.LTP_scaleIndex,                            sizeof( SKP_int8   ) );\r
 //  DEBUG_STORE_DATA( xq.dat,                   psEnc->sCmn.sNSQ.xqBuf,                psEnc->sCmn.frame_length * sizeof( SKP_float ) );\r
 #endif\r
-    return( ret );\r
+    return ret;\r
 }\r
 \r
 /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate  */\r
index a3215cf..88392f3 100644 (file)
@@ -29,14 +29,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SKP_Silk_tuning_parameters.h"\r
 \r
 void SKP_Silk_find_LPC_FLP(\r
-          SKP_int                   NLSF_Q15[],         /* O    NLSFs                                   */\r
-          SKP_int8                  *interpIndex,       /* O    NLSF interp. index for NLSF interp.     */\r
-    const SKP_int                   prev_NLSFq_Q15[],   /* I    Previous NLSFs, for NLSF interpolation  */\r
-    const SKP_int                   useInterpNLSFs,     /* I    Flag                                    */\r
-    const SKP_int                   LPC_order,          /* I    LPC order                               */\r
-    const SKP_float                 x[],                /* I    Input signal                            */\r
-    const SKP_int                   subfr_length,       /* I    Subframe length incl preceeding samples */\r
-    const SKP_int                   nb_subfr            /* I:   Number of subframes                     */\r
+          SKP_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
+          SKP_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
+    const SKP_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
+    const SKP_int                   useInterpNLSFs,         /* I    Flag                                    */\r
+    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
+    const SKP_int                   LPC_order,              /* I    LPC order                               */\r
+    const SKP_float                 x[],                    /* I    Input signal                            */\r
+    const SKP_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
+    const SKP_int                   nb_subfr                /* I:   Number of subframes                     */\r
 )\r
 {\r
     SKP_int     k;\r
@@ -44,7 +45,7 @@ void SKP_Silk_find_LPC_FLP(
 \r
     /* Used only for NLSF interpolation */\r
     double      res_nrg, res_nrg_2nd, res_nrg_interp;\r
-    SKP_int     NLSF0_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16   NLSF0_Q15[ MAX_LPC_ORDER ];\r
     SKP_float   a_tmp[ MAX_LPC_ORDER ];\r
     SKP_float   LPC_res[ ( MAX_FRAME_LENGTH + MAX_NB_SUBFR * MAX_LPC_ORDER ) / 2 ];\r
 \r
@@ -54,11 +55,18 @@ void SKP_Silk_find_LPC_FLP(
     /* Burg AR analysis for the full frame */\r
     res_nrg = SKP_Silk_burg_modified_FLP( a, x, subfr_length, nb_subfr, FIND_LPC_COND_FAC, LPC_order );\r
 \r
-    if( useInterpNLSFs == 1 && nb_subfr == MAX_NB_SUBFR ) {\r
+    if( firstFrameAfterReset ) {\r
+        SKP_Silk_bwexpander_FLP( a, LPC_order, FIND_LPC_CHIRP_FIRST_FRAME );\r
+    } else {\r
+        SKP_Silk_bwexpander_FLP( a_tmp, LPC_order, FIND_LPC_CHIRP );\r
+    }\r
+\r
+    if( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) {\r
         /* Optimal solution for last 10 ms; subtract residual energy here, as that's easier than        */\r
         /* adding it to the residual energy of the first 10 ms in each iteration of the search below    */\r
         res_nrg -= SKP_Silk_burg_modified_FLP( a_tmp, x + ( MAX_NB_SUBFR / 2 ) * subfr_length, \r
             subfr_length, MAX_NB_SUBFR / 2, FIND_LPC_COND_FAC, LPC_order );\r
+\r
         SKP_Silk_bwexpander_FLP( a_tmp, LPC_order, FIND_LPC_CHIRP );\r
 \r
         /* Convert to NLSFs */\r
@@ -97,4 +105,5 @@ void SKP_Silk_find_LPC_FLP(
         SKP_Silk_A2NLSF_FLP( NLSF_Q15, a, LPC_order );\r
     }\r
 \r
+    SKP_assert( *interpIndex == 4 || ( useInterpNLSFs && !firstFrameAfterReset && nb_subfr == MAX_NB_SUBFR ) );\r
 }\r
index 1238498..7daf5fb 100644 (file)
@@ -58,7 +58,10 @@ void SKP_Silk_find_LTP_FLP(
         SKP_Silk_corrVector_FLP( lag_ptr, r_ptr, subfr_length, LTP_ORDER, Rr );\r
 \r
         rr[ k ] = ( SKP_float )SKP_Silk_energy_FLP( r_ptr, subfr_length );\r
-        regu = LTP_DAMPING * ( rr[ k ] + 1.0f );\r
+        regu = 1.0f + rr[ k ] + \r
+            matrix_ptr( WLTP_ptr, 0, 0, LTP_ORDER ) + \r
+            matrix_ptr( WLTP_ptr, LTP_ORDER-1, LTP_ORDER-1, LTP_ORDER );\r
+        regu *= LTP_DAMPING / 3;\r
         SKP_Silk_regularize_correlations_FLP( WLTP_ptr, &rr[ k ], regu, LTP_ORDER );\r
         SKP_Silk_solve_LDL_FLP( WLTP_ptr, LTP_ORDER, Rr, b_ptr );\r
 \r
index 761ec5c..00b1cea 100644 (file)
@@ -38,7 +38,7 @@ void SKP_Silk_find_pred_coefs_FLP(
     SKP_int         i;\r
     SKP_float       WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ];\r
     SKP_float       invGains[ MAX_NB_SUBFR ], Wght[ MAX_NB_SUBFR ];\r
-    SKP_int         NLSF_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16       NLSF_Q15[ MAX_LPC_ORDER ];\r
     const SKP_float *x_ptr;\r
     SKP_float       *x_pre_ptr, LPC_in_pre[ MAX_NB_SUBFR * MAX_LPC_ORDER + MAX_FRAME_LENGTH ];\r
 \r
@@ -95,7 +95,7 @@ void SKP_Silk_find_pred_coefs_FLP(
 \r
     /* LPC_in_pre contains the LTP-filtered input for voiced, and the unfiltered input for unvoiced */\r
     SKP_Silk_find_LPC_FLP( NLSF_Q15, &psEnc->sCmn.indices.NLSFInterpCoef_Q2, psEnc->sCmn.prev_NLSFq_Q15, \r
-        psEnc->sCmn.useInterpolatedNLSFs * ( 1 - psEnc->sCmn.first_frame_after_reset ), psEnc->sCmn.predictLPCOrder, \r
+        psEnc->sCmn.useInterpolatedNLSFs, psEnc->sCmn.first_frame_after_reset, psEnc->sCmn.predictLPCOrder, \r
         LPC_in_pre, psEnc->sCmn.subfr_length + psEnc->sCmn.predictLPCOrder, psEnc->sCmn.nb_subfr );\r
 \r
 \r
index e3eb187..1a444d0 100644 (file)
@@ -39,10 +39,8 @@ SKP_int SKP_Silk_init_encoder_FLP(
     /* Clear the entire encoder state */\r
     SKP_memset( psEnc, 0, sizeof( SKP_Silk_encoder_state_FLP ) );\r
 \r
-#if HIGH_PASS_INPUT\r
     psEnc->sCmn.variable_HP_smth1_Q15 = 200844; /* = SKP_Silk_log2(70)_Q0; */\r
     psEnc->sCmn.variable_HP_smth2_Q15 = 200844; /* = SKP_Silk_log2(70)_Q0; */\r
-#endif\r
 \r
     /* Used to deactivate e.g. LSF interpolation and fluctuation reduction */\r
     psEnc->sCmn.first_frame_after_reset = 1;\r
index cbf2077..dda5bf8 100644 (file)
@@ -133,14 +133,15 @@ void SKP_Silk_find_pred_coefs_FLP(
 \r
 /* LPC analysis */\r
 void SKP_Silk_find_LPC_FLP(\r
-          SKP_int                   NLSF_Q15[],         /* O    NLSFs                                   */\r
-          SKP_int8                  *interpIndex,       /* O    NLSF interp. index for NLSF interp.     */\r
-    const SKP_int                   prev_NLSFq_Q15[],   /* I    Previous NLSFs, for NLSF interpolation  */\r
-    const SKP_int                   useInterpNLSFs,     /* I    Flag                                    */\r
-    const SKP_int                   LPC_order,          /* I    LPC order                               */\r
-    const SKP_float                 x[],                /* I    Input signal                            */\r
-    const SKP_int                   subfr_length,       /* I    Subframe length incl preceeding samples */\r
-    const SKP_int                   nb_subfr            /* I:   Number of subframes                     */\r
+          SKP_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
+          SKP_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
+    const SKP_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
+    const SKP_int                   useInterpNLSFs,         /* I    Flag                                    */\r
+    const SKP_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
+    const SKP_int                   LPC_order,              /* I    LPC order                               */\r
+    const SKP_float                 x[],                    /* I    Input signal                            */\r
+    const SKP_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
+    const SKP_int                   nb_subfr                /* I:   Number of subframes                     */\r
 );\r
 \r
 /* LTP analysis */\r
@@ -206,8 +207,8 @@ void SKP_Silk_quant_LTP_gains_FLP(
 void SKP_Silk_process_NLSFs_FLP(\r
     SKP_Silk_encoder_state          *psEncC,                            /* I/O  Encoder state                               */\r
     SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int                         NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int                   prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    SKP_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const SKP_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 );\r
 \r
 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
@@ -288,7 +289,7 @@ void SKP_Silk_apply_sine_window_FLP(
 \r
 /* Convert AR filter coefficients to NLSF parameters */\r
 void SKP_Silk_A2NLSF_FLP( \r
-          SKP_int                   *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
+          SKP_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
 );\r
@@ -296,19 +297,10 @@ void SKP_Silk_A2NLSF_FLP(
 /* Convert NLSF parameters to AR prediction filter coefficients */\r
 void SKP_Silk_NLSF2A_stable_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int                   *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
+    const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
 );\r
 \r
-/* Interpolation function with fixed point rounding */\r
-void SKP_Silk_interpolate_wrapper_FLP(\r
-          SKP_float                 xi[],               /* O    Interpolated vector                     */\r
-    const SKP_float                 x0[],               /* I    First vector                            */\r
-    const SKP_float                 x1[],               /* I    Second vector                           */\r
-    const SKP_float                 ifact,              /* I    Interp. factor, weight on second vector */\r
-    const SKP_int                   d                   /* I    Number of parameters                    */\r
-);\r
-\r
 /****************************************/\r
 /* Floating-point Silk NSQ wrapper      */\r
 /****************************************/\r
index 2347359..9e5b765 100644 (file)
@@ -31,7 +31,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Convert AR filter coefficients to NLSF parameters */\r
 void SKP_Silk_A2NLSF_FLP( \r
-          SKP_int                   *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
+          SKP_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
 )\r
@@ -49,7 +49,7 @@ void SKP_Silk_A2NLSF_FLP(
 /* Convert LSF parameters to AR prediction filter coefficients */\r
 void SKP_Silk_NLSF2A_stable_FLP( \r
           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
-    const SKP_int                   *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
+    const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
     const SKP_int                   LPC_order           /* I    LPC order                               */\r
 )\r
 {\r
@@ -69,8 +69,8 @@ void SKP_Silk_NLSF2A_stable_FLP(
 void SKP_Silk_process_NLSFs_FLP(\r
     SKP_Silk_encoder_state          *psEncC,                            /* I/O  Encoder state                               */\r
     SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int                         NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int                   prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    SKP_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const SKP_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 )\r
 {\r
     SKP_int     i, j;\r
index e2e0e29..592c88c 100644 (file)
@@ -117,7 +117,7 @@ SKP_INLINE void SKP_Silk_A2NLSF_init(
 /* 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 SKP_Silk_A2NLSF(\r
-    SKP_int          *NLSF,                 /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d]    */\r
+    SKP_int16        *NLSF,                 /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d]    */\r
     SKP_int32        *a_Q16,                /* I/O  Monic whitening filter coefficients in Q16 [d]                   */\r
     const SKP_int    d                      /* I    Filter order (must be even)                                      */\r
 )\r
@@ -210,9 +210,9 @@ void SKP_Silk_A2NLSF(
                 ffrac += SKP_DIV32( ylo, SKP_RSHIFT( ylo - yhi, 8 - BIN_DIV_STEPS_A2NLSF_FIX ) );\r
             }\r
 #if OVERSAMPLE_COSINE_TABLE\r
-            NLSF[ root_ix ] = (SKP_int)SKP_min_32( SKP_LSHIFT( (SKP_int32)k, 7 ) + ffrac, SKP_int16_MAX ); \r
+            NLSF[ root_ix ] = (SKP_int16)SKP_min_32( SKP_LSHIFT( (SKP_int32)k, 7 ) + ffrac, SKP_int16_MAX ); \r
 #else\r
-            NLSF[ root_ix ] = (SKP_int)SKP_min_32( SKP_LSHIFT( (SKP_int32)k, 8 ) + ffrac, SKP_int16_MAX ); \r
+            NLSF[ root_ix ] = (SKP_int16)SKP_min_32( SKP_LSHIFT( (SKP_int32)k, 8 ) + ffrac, SKP_int16_MAX ); \r
 #endif\r
 \r
             SKP_assert( NLSF[ root_ix ] >=     0 );\r
@@ -249,9 +249,9 @@ void SKP_Silk_A2NLSF(
                 i++;\r
                 if( i > MAX_ITERATIONS_A2NLSF_FIX ) {\r
                     /* Set NLSFs to white spectrum and exit */\r
-                    NLSF[ 0 ] = SKP_DIV32_16( 1 << 15, d + 1 );\r
+                    NLSF[ 0 ] = (SKP_int16)SKP_DIV32_16( 1 << 15, d + 1 );\r
                     for( k = 1; k < d; k++ ) {\r
-                        NLSF[ k ] = SKP_SMULBB( k + 1, NLSF[ 0 ] );\r
+                        NLSF[ k ] = (SKP_int16)SKP_SMULBB( k + 1, NLSF[ 0 ] );\r
                     }\r
                     return;\r
                 }\r
index 88a2046..43c9d0a 100644 (file)
@@ -205,69 +205,6 @@ SKP_INLINE SKP_int32 SKP_INVERSE32_varQ(    /* O    returns a good approximation
     }\r
 }\r
 \r
-#define SKP_SIN_APPROX_CONST0       (1073735400)\r
-#define SKP_SIN_APPROX_CONST1        (-82778932)\r
-#define SKP_SIN_APPROX_CONST2          (1059577)\r
-#define SKP_SIN_APPROX_CONST3            (-5013)\r
-\r
-/* Sine approximation; an input of 65536 corresponds to 2 * pi */\r
-/* Uses polynomial expansion of the input to the power 0, 2, 4 and 6 */\r
-/* The relative error is below 1e-5 */\r
-SKP_INLINE SKP_int32 SKP_Silk_SIN_APPROX_Q24(        /* O    returns approximately 2^24 * sin(x * 2 * pi / 65536) */\r
-    SKP_int32        x\r
-)\r
-{\r
-    SKP_int y_Q30;\r
-\r
-    /* Keep only bottom 16 bits (the function repeats itself with period 65536) */\r
-    x &= 65535;\r
-\r
-    /* Split range in four quadrants */\r
-    if( x <= 32768 ) {\r
-        if( x < 16384 ) {\r
-            /* Return cos(pi/2 - x) */\r
-            x = 16384 - x;\r
-        } else {\r
-            /* Return cos(x - pi/2) */\r
-            x -= 16384;\r
-        }\r
-        if( x < 1100 ) {\r
-            /* Special case: high accuracy */\r
-            return SKP_SMLAWB( 1 << 24, SKP_MUL( x, x ), -5053 );\r
-        }\r
-        x = SKP_SMULWB( SKP_LSHIFT( x, 8 ), x );        /* contains x^2 in Q20 */\r
-        y_Q30 = SKP_SMLAWB( SKP_SIN_APPROX_CONST2, x, SKP_SIN_APPROX_CONST3 );\r
-        y_Q30 = SKP_SMLAWW( SKP_SIN_APPROX_CONST1, x, y_Q30 );\r
-        y_Q30 = SKP_SMLAWW( SKP_SIN_APPROX_CONST0 + 66, x, y_Q30 );\r
-    } else {\r
-        if( x < 49152 ) {\r
-            /* Return -cos(3*pi/2 - x) */\r
-            x = 49152 - x;\r
-        } else {\r
-            /* Return -cos(x - 3*pi/2) */\r
-            x -= 49152;\r
-        }\r
-        if( x < 1100 ) {\r
-            /* Special case: high accuracy */\r
-            return SKP_SMLAWB( -1 << 24, SKP_MUL( x, x ), 5053 );\r
-        }\r
-        x = SKP_SMULWB( SKP_LSHIFT( x, 8 ), x );        /* contains x^2 in Q20 */\r
-        y_Q30 = SKP_SMLAWB( -SKP_SIN_APPROX_CONST2, x, -SKP_SIN_APPROX_CONST3 );\r
-        y_Q30 = SKP_SMLAWW( -SKP_SIN_APPROX_CONST1, x, y_Q30 );\r
-        y_Q30 = SKP_SMLAWW( -SKP_SIN_APPROX_CONST0, x, y_Q30 );\r
-    }\r
-    return SKP_RSHIFT_ROUND( y_Q30, 6 );\r
-}\r
-\r
-/* Cosine approximation; an input of 65536 corresponds to 2 * pi */\r
-/* The relative error is below 1e-5 */\r
-SKP_INLINE SKP_int32 SKP_Silk_COS_APPROX_Q24(        /* O    returns approximately 2^24 * cos(x * 2 * pi / 65536) */\r
-    SKP_int32        x\r
-)\r
-{\r
-    return SKP_Silk_SIN_APPROX_Q24( x + 16384 );\r
-}\r
-\r
 #ifdef  __cplusplus\r
 }\r
 #endif\r
index 05e3c11..b8b04ca 100644 (file)
@@ -35,7 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* helper function for NLSF2A(..) */\r
 SKP_INLINE void SKP_Silk_NLSF2A_find_poly(\r
-    SKP_int32        *out,        /* o    intermediate polynomial, Q20            */\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
 )\r
@@ -57,8 +57,8 @@ SKP_INLINE void SKP_Silk_NLSF2A_find_poly(
 \r
 /* compute whitening filter coefficients from normalized line spectral frequencies */\r
 void SKP_Silk_NLSF2A(\r
-    SKP_int16       *a,               /* o    monic whitening filter coefficients in Q12,  [d]    */\r
-    const SKP_int    *NLSF,           /* i    normalized line spectral frequencies in Q15, [d]    */\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
 )\r
 {\r
index b1f05ba..e50736b 100644 (file)
@@ -37,8 +37,8 @@ Signal Processing, pp. 641-644, 1991.
 \r
 /* Laroia low complexity NLSF weights */\r
 void SKP_Silk_NLSF_VQ_weights_laroia(\r
-    SKP_int             *pNLSFW_Q5,         /* O: Pointer to input vector weights           [D x 1]     */\r
-    const SKP_int       *pNLSF_Q15,         /* I: Pointer to input vector                   [D x 1]     */ \r
+    SKP_int16           *pNLSFW_Q5,         /* 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
 {\r
@@ -53,25 +53,25 @@ void SKP_Silk_NLSF_VQ_weights_laroia(
     tmp1_int = SKP_DIV32_16( 1 << ( 15 + Q_OUT ), 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_int)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+    pNLSFW_Q5[ 0 ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
     SKP_assert( pNLSFW_Q5[ 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_int)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
+        pNLSFW_Q5[ k ] = (SKP_int16)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\r
         SKP_assert( pNLSFW_Q5[ 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_int)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\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
     }\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_int)SKP_min_int( tmp1_int + tmp2_int, SKP_int16_MAX );\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
 }\r
index 90975f6..1e7def8 100644 (file)
@@ -40,12 +40,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* NLSF stabilizer, for a single input data vector */\r
 void SKP_Silk_NLSF_stabilize(\r
-          SKP_int    *NLSF_Q15,            /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */\r
-    const SKP_int    *NDeltaMin_Q15,       /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
+          SKP_int16  *NLSF_Q15,            /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */\r
+    const SKP_int16  *NDeltaMin_Q15,       /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
     const SKP_int     L                    /* I:    Number of NLSF parameters in the input vector                           */\r
 )\r
 {\r
-    SKP_int   center_freq_Q15, diff_Q15, min_center_Q15, max_center_Q15;\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
@@ -106,7 +106,7 @@ void SKP_Silk_NLSF_stabilize(
             max_center_Q15 -= ( NDeltaMin_Q15[I] - SKP_RSHIFT( NDeltaMin_Q15[I], 1 ) );\r
 \r
             /* Move apart, sorted by value, keeping the same center frequency */\r
-            center_freq_Q15 = SKP_LIMIT_32( SKP_RSHIFT_ROUND( (SKP_int32)NLSF_Q15[I-1] + (SKP_int32)NLSF_Q15[I], 1 ),\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
                 min_center_Q15, max_center_Q15 );\r
             NLSF_Q15[I-1] = center_freq_Q15 - SKP_RSHIFT( NDeltaMin_Q15[I], 1 );\r
             NLSF_Q15[I] = NLSF_Q15[I-1] + NDeltaMin_Q15[I];\r
@@ -119,7 +119,7 @@ void SKP_Silk_NLSF_stabilize(
         /* Insertion sort (fast for already almost sorted arrays):   */\r
         /* Best case:  O(n)   for an already sorted array            */\r
         /* Worst case: O(n^2) for an inversely sorted array          */\r
-        SKP_Silk_insertion_sort_increasing_all_values(&NLSF_Q15[0], L);\r
+        SKP_Silk_insertion_sort_increasing_all_values_int16( &NLSF_Q15[0], L );\r
             \r
         /* First NLSF should be no less than NDeltaMin[0] */\r
         NLSF_Q15[0] = SKP_max_int( NLSF_Q15[0], NDeltaMin_Q15[0] );\r
@@ -136,19 +136,3 @@ void SKP_Silk_NLSF_stabilize(
             NLSF_Q15[i] = SKP_min_int( NLSF_Q15[i], NLSF_Q15[i+1] - NDeltaMin_Q15[i+1] );\r
     }\r
 }\r
-\r
-/* NLSF stabilizer, over multiple input column data vectors */\r
-void SKP_Silk_NLSF_stabilize_multi(\r
-          SKP_int        *NLSF_Q15,        /* I/O:  Unstable/stabilized normalized LSF vectors in Q15 [LxN]                 */\r
-    const SKP_int        *NDeltaMin_Q15,   /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
-    const SKP_int         N,               /* I:    Number of input vectors to be stabilized                                */\r
-    const SKP_int         L                /* I:    NLSF vector dimension                                                   */\r
-)\r
-{\r
-    SKP_int n;\r
-    \r
-    /* loop over input data */\r
-    for( n = 0; n < N; n++ ) {\r
-        SKP_Silk_NLSF_stabilize( &NLSF_Q15[n * L], NDeltaMin_Q15, L );\r
-    }\r
-}\r
index 3569914..bfa8449 100644 (file)
@@ -119,37 +119,6 @@ void SKP_Silk_resampler_down3(
     SKP_int32                           inLen       /* I:   Number of input samples             */\r
 );\r
 \r
-/*! \r
- * First order low-pass filter, with input as SKP_int16, running at 48 kHz \r
- */\r
-void SKP_Silk_lowpass_short(\r
-    const SKP_int16      *in,           /* I:   Q15 48 kHz signal; [len]    */\r
-    SKP_int32            *S,            /* I/O: Q25 state; length = 1       */\r
-    SKP_int32            *out,          /* O:   Q25 48 kHz signal; [len]    */\r
-    const SKP_int32      len            /* O:   Signal length               */\r
-);\r
-\r
-/*! \r
- * First order low-pass filter, with input as SKP_int32, running at 48 kHz \r
- */\r
-void SKP_Silk_lowpass_int(\r
-    const SKP_int32      *in,           /* I:   Q25 48 kHz signal; length = len  */\r
-    SKP_int32            *S,            /* I/O: Q25 state; length = 1            */\r
-    SKP_int32            *out,          /* O:   Q25 48 kHz signal; length = len  */\r
-    const SKP_int32      len            /* I:   Number of samples                */\r
-);\r
-\r
-/*! \r
- * First-order allpass filter \r
- */\r
-void SKP_Silk_allpass_int(\r
-    const SKP_int32      *in,          /* I:   Q25 input signal [len]               */\r
-    SKP_int32            *S,           /* I/O: Q25 state [1]                        */\r
-    SKP_int              A,            /* I:   Q15 coefficient    (0 <= A < 32768)  */\r
-    SKP_int32            *out,         /* O:   Q25 output signal [len]              */\r
-    const SKP_int32      len           /* I:   Number of samples                    */\r
-);\r
-\r
 /*!\r
  * second order ARMA filter; \r
  * slower than biquad() but uses more precise coefficients\r
@@ -373,7 +342,7 @@ void SKP_Silk_LPC_fit(
 /* 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 SKP_Silk_A2NLSF(\r
-    SKP_int            *NLSF,            /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d] */\r
+    SKP_int16          *NLSF,            /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d] */\r
     SKP_int32          *a_Q16,           /* I/O  Monic whitening filter coefficients in Q16 [d]                */\r
     const SKP_int      d                 /* I    Filter order (must be even)                                   */\r
 );\r
@@ -381,7 +350,7 @@ void SKP_Silk_A2NLSF(
 /* compute whitening filter coefficients from normalized line spectral frequencies */\r
 void SKP_Silk_NLSF2A(\r
     SKP_int16          *a,               /* o    monic whitening filter coefficients in Q12,  [d]    */\r
-    const SKP_int      *NLSF,            /* i    normalized line spectral frequencies in Q15, [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
@@ -392,13 +361,6 @@ void SKP_Silk_insertion_sort_increasing(
     const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
 );\r
 \r
-void SKP_Silk_insertion_sort_decreasing(\r
-    SKP_int              *a,            /* I/O:  Unsorted / Sorted vector                */\r
-    SKP_int              *index,        /* O:    Index vector for the sorted elements    */\r
-    const SKP_int        L,             /* I:    Vector length                           */\r
-    const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
-);\r
-\r
 void SKP_Silk_insertion_sort_decreasing_int16(\r
     SKP_int16            *a,            /* I/O:  Unsorted / Sorted vector                */\r
     SKP_int              *index,        /* O:    Index vector for the sorted elements    */\r
@@ -406,30 +368,22 @@ void SKP_Silk_insertion_sort_decreasing_int16(
     const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
 );\r
 \r
-void SKP_Silk_insertion_sort_increasing_all_values(\r
-     SKP_int             *a,            /* I/O:  Unsorted / Sorted vector                */\r
+void SKP_Silk_insertion_sort_increasing_all_values_int16(\r
+     SKP_int16           *a,            /* I/O:  Unsorted / Sorted vector                */\r
      const SKP_int       L              /* I:    Vector length                           */\r
 );\r
 \r
 /* NLSF stabilizer, for a single input data vector */\r
 void SKP_Silk_NLSF_stabilize(\r
-          SKP_int        *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */\r
-    const SKP_int        *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
+          SKP_int16      *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */\r
+    const SKP_int16      *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
     const SKP_int        L               /* I:    Number of NLSF parameters in the input vector                           */\r
 );\r
 \r
-/* NLSF stabilizer, over multiple input column data vectors */\r
-void SKP_Silk_NLSF_stabilize_multi(\r
-          SKP_int        *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vectors in Q15 [LxN]                 */\r
-    const SKP_int        *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
-    const SKP_int        N,              /* I:    Number of input vectors to be stabilized                                */\r
-    const SKP_int        L               /* I:    NLSF vector dimension                                                   */\r
-);\r
-\r
 /* Laroia low complexity NLSF weights */\r
 void SKP_Silk_NLSF_VQ_weights_laroia(\r
-    SKP_int              *pNLSFW_Q5,     /* O:    Pointer to input vector weights            [D x 1]       */\r
-    const SKP_int        *pNLSF_Q15,     /* I:    Pointer to input vector                    [D x 1]       */\r
+    SKP_int16            *pNLSFW_Q5,     /* 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
 \r
index 5469a27..98025c7 100644 (file)
@@ -25,13 +25,6 @@ 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
-/*                                                                                *\r
- * SKP_Silk_inner_prod_aligned.c                                                *\r
- *                                                                                *\r
- *                                                                                *\r
- * Copyright 2008-2010 (c), Skype Limited                                              *\r
- * Date: 080601                                                                   *\r
- *                                                                                */\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 \r
 /* sum= for(i=0;i<len;i++)inVec1[i]*inVec2[i];      ---        inner product    */\r
index 0cb5482..b639ba3 100644 (file)
@@ -25,15 +25,6 @@ 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
-/*                                                                      *\r
- * SKP_Silk_k2a.c                                                     *\r
- *                                                                      *\r
- * Step up function, converts reflection coefficients to prediction     *\r
- * coefficients                                                         *\r
- *                                                                      *\r
- * Copyright 2008 (c), Skype Limited                                    *\r
- * Date: 080103                                                         *\r
- *                                                                      */\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 \r
 /* Step up function, converts reflection coefficients to prediction coefficients */\r
index c59719d..73ae6f0 100644 (file)
@@ -25,15 +25,6 @@ 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
-/*                                                                      *\r
- * SKP_Silk_k2a.c                                                     *\r
- *                                                                      *\r
- * Step up function, converts reflection coefficients to prediction     *\r
- * coefficients                                                         *\r
- *                                                                      *\r
- * Copyright 2008 (c), Skype Limited                                    *\r
- * Date: 080103                                                         *\r
- *                                                                      */\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 \r
 /* Step up function, converts reflection coefficients to prediction coefficients */\r
index 31cb05b..c6241c5 100644 (file)
@@ -25,15 +25,6 @@ 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
-/*                                                                      *\r
- * SKP_Silk_lin2log.c                                                 *\r
- *                                                                      *\r
- * Convert input to a log scale                                         *\r
- * Approximation of 128 * log2()                                        *\r
- *                                                                      *\r
- * Copyright 2006 (c), Skype Limited                                    *\r
- * Date: 060221                                                         *\r
- *                                                                      */\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 /* Approximation of 128 * log2() (very close inverse of approx 2^() below) */\r
 /* Convert input to a log scale    */ \r
index 258627c..50d02d8 100644 (file)
@@ -25,14 +25,6 @@ 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
-/*                                                                      *\r
- * SKP_Silk_log2lin.c                                                 *\r
- *                                                                      *\r
- * Convert input to a linear scale                                      *\r
- *                                                                      *\r
- * Copyright 2006 (c), Skype Limited                                    *\r
- * Date: 060221                                                         *\r
- *                                                                      */\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 \r
 /* Approximation of 2^() (very close inverse of SKP_Silk_lin2log()) */\r
index 76595b9..6f45f15 100644 (file)
@@ -79,52 +79,6 @@ void SKP_Silk_insertion_sort_increasing(
     }\r
 }\r
 \r
-void SKP_Silk_insertion_sort_decreasing(\r
-    SKP_int             *a,             /* I/O: Unsorted / Sorted vector                */\r
-    SKP_int             *index,         /* O:   Index vector for the sorted elements    */\r
-    const SKP_int       L,              /* I:   Vector length                           */\r
-    const SKP_int       K               /* I:   Number of correctly sorted positions    */\r
-)\r
-{\r
-    SKP_int    value;\r
-    SKP_int    i, j;\r
-\r
-    /* Safety checks */\r
-    SKP_assert( K >  0 );\r
-    SKP_assert( L >  0 );\r
-    SKP_assert( L >= K );\r
-\r
-    /* Write start indices in index vector */\r
-    for( i = 0; i < K; i++ ) {\r
-        index[ i ] = i;\r
-    }\r
-\r
-    /* Sort vector elements by value, decreasing order */\r
-    for( i = 1; i < K; i++ ) {\r
-        value = a[ i ];\r
-        for( j = i - 1; ( j >= 0 ) && ( value > a[ j ] ); j-- ) {\r
-            a[ j + 1 ]     = a[ j ];     /* Shift value */\r
-            index[ j + 1 ] = index[ j ]; /* Shift index */\r
-        }\r
-        a[ j + 1 ]     = value; /* Write value */\r
-        index[ j + 1 ] = i;     /* Write index */\r
-    }\r
-\r
-    /* If less than L values are asked for, check the remaining values, */\r
-    /* but only spend CPU to ensure that the K first values are correct */\r
-    for( i = K; i < L; i++ ) {\r
-        value = a[ i ];\r
-        if( value > a[ K - 1 ] ) {\r
-            for( j = K - 2; ( j >= 0 ) && ( value > a[ j ] ); j-- ) {\r
-                a[ j + 1 ]     = a[ j ];     /* Shift value */\r
-                index[ j + 1 ] = index[ j ]; /* Shift index */\r
-            }\r
-            a[ j + 1 ]     = value; /* Write value */\r
-            index[ j + 1 ] = i;     /* Write index */\r
-        }\r
-    }\r
-}\r
-\r
 void SKP_Silk_insertion_sort_decreasing_int16(\r
     SKP_int16           *a,             /* I/O: Unsorted / Sorted vector                */\r
     SKP_int             *index,         /* O:   Index vector for the sorted elements    */\r
@@ -171,8 +125,8 @@ void SKP_Silk_insertion_sort_decreasing_int16(
     }\r
 }\r
 \r
-void SKP_Silk_insertion_sort_increasing_all_values(\r
-    SKP_int             *a,             /* I/O: Unsorted / Sorted vector                */\r
+void SKP_Silk_insertion_sort_increasing_all_values_int16(\r
+    SKP_int16           *a,             /* I/O: Unsorted / Sorted vector                */\r
     const SKP_int       L               /* I:   Vector length                           */\r
 )\r
 {\r
@@ -191,97 +145,3 @@ void SKP_Silk_insertion_sort_increasing_all_values(
         a[ j + 1 ] = value; /* Write value */\r
     }\r
 }\r
-\r
-void SKP_Silk_shell_insertion_sort_increasing(\r
-    SKP_int32           *a,             /* I/O:  Unsorted / Sorted vector               */\r
-    SKP_int             *index,         /* O:    Index vector for the sorted elements   */\r
-    const SKP_int       L,              /* I:    Vector length                          */\r
-    const SKP_int       K               /* I:    Number of correctly sorted positions   */\r
-)\r
-{\r
-    SKP_int32    value, inc_Q16_tmp;\r
-    SKP_int      i, j, inc, idx;\r
-   \r
-    /* Safety checks */\r
-    SKP_assert( K >  0 );\r
-    SKP_assert( L >  0 );\r
-    SKP_assert( L >= K );\r
-    \r
-    /* Calculate initial step size */\r
-    inc_Q16_tmp = SKP_LSHIFT( (SKP_int32)L, 15 );\r
-    inc = SKP_RSHIFT( inc_Q16_tmp, 16 );\r
-\r
-    /* Write start indices in index vector */\r
-    for( i = 0; i < K; i++ ) {\r
-        index[ i ] = i;\r
-    }\r
-\r
-    /* Shell sort first values */\r
-    while( inc > 0 ) {\r
-        for( i = inc; i < K; i++ ) {\r
-            value = a[ i ];\r
-            idx   = index[ i ];\r
-            for( j = i - inc; ( j >= 0 ) && ( value < a[ j ] ); j -= inc ) {\r
-                a[ j + inc ]     = a[ j ];     /* Shift value */\r
-                index[ j + inc ] = index[ j ]; /* Shift index */\r
-            }\r
-            a[ j + inc ]     = value; /* Write value */\r
-            index[ j + inc ] = idx;   /* Write index */\r
-        }\r
-        inc_Q16_tmp = SKP_SMULWB( inc_Q16_tmp, 29789 ); // 29789_Q16 = 2.2^(-1)_Q0\r
-        inc = SKP_RSHIFT_ROUND( inc_Q16_tmp, 16 );\r
-    }\r
-\r
-    /* If less than L values are asked for, check the remaining values, */\r
-    /* but only spend CPU to ensure that the K first values are correct */\r
-    /* Insertion sort remaining values */\r
-    for( i = K; i < L; i++ ) {\r
-        value = a[ i ];\r
-        if( value < a[ K - 1 ] ) {\r
-            for( j = K - 2; ( j >= 0 ) && ( value < a[ j ] ); j-- ) {\r
-                a[ j + 1 ]     = a[ j ];     /* Shift value */\r
-                index[ j + 1 ] = index[ j ]; /* Shift index */\r
-            }\r
-            a[ j + 1 ]     = value; /* Write value */\r
-            index[ j + 1 ] = i;     /* Write index */\r
-        }\r
-    }\r
-}\r
-\r
-void SKP_Silk_shell_sort_increasing_all_values(\r
-    SKP_int32           *a,             /* I/O:  Unsorted / Sorted vector               */\r
-    SKP_int             *index,         /* O:    Index vector for the sorted elements   */\r
-    const SKP_int       L               /* I:    Vector length                          */\r
-)\r
-{\r
-    SKP_int32    value, inc_Q16_tmp;\r
-    SKP_int      i, j, inc, idx;\r
-   \r
-    /* Safety checks */\r
-    SKP_assert( L >  0 );\r
\r
-    /* Calculate initial step size */\r
-    inc_Q16_tmp = SKP_LSHIFT( (SKP_int32)L, 15 );\r
-    inc = SKP_RSHIFT( inc_Q16_tmp, 16 );\r
-\r
-    /* Write start indices in index vector */\r
-    for( i = 0; i < L; i++ ) {\r
-        index[ i ] = i;\r
-    }\r
-\r
-    /* Sort vector elements by value, increasing order */\r
-    while( inc > 0 ) {\r
-        for( i = inc; i < L; i++ ) {\r
-            value = a[ i ];\r
-            idx = index[ i ];\r
-            for( j = i - inc; ( j >= 0 ) && ( value < a[ j ] ); j -= inc ) {\r
-                a[ j + inc ]     = a[ j ];     /* Shift value */\r
-                index[ j + inc ] = index[ j ]; /* Shift index */\r
-            }\r
-            a[ j + inc ] = value;   /* Write value */\r
-            index[ j + inc ] = idx; /* Write index */\r
-        }\r
-        inc_Q16_tmp = SKP_SMULWB( inc_Q16_tmp, 29789 ); // 29789_Q16 = 2.2^(-1)_Q0\r
-        inc = SKP_RSHIFT_ROUND( inc_Q16_tmp, 16 );\r
-    }\r
-}\r
index a6921d3..ca8d789 100644 (file)
@@ -87,7 +87,6 @@
   </ItemGroup>\r
   <ItemGroup>\r
     <ClCompile Include="SKP_Silk_A2NLSF.c" />\r
-    <ClCompile Include="SKP_Silk_allpass_int.c" />\r
     <ClCompile Include="SKP_Silk_ana_filt_bank_1.c" />\r
     <ClCompile Include="SKP_Silk_apply_sine_window.c" />\r
     <ClCompile Include="SKP_Silk_array_maxabs.c" />\r
     <ClCompile Include="SKP_Silk_k2a_Q16.c" />\r
     <ClCompile Include="SKP_Silk_lin2log.c" />\r
     <ClCompile Include="SKP_Silk_log2lin.c" />\r
-    <ClCompile Include="SKP_Silk_lowpass_int.c" />\r
-    <ClCompile Include="SKP_Silk_lowpass_short.c" />\r
     <ClCompile Include="SKP_Silk_LPC_inv_pred_gain.c" />\r
     <ClCompile Include="SKP_Silk_LPC_stabilize.c" />\r
     <ClCompile Include="SKP_Silk_LPC_synthesis_filter.c" />\r
index 2801eb3..13a4e13 100644 (file)
@@ -53,9 +53,6 @@
     <ClCompile Include="SKP_Silk_A2NLSF.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_allpass_int.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="SKP_Silk_ana_filt_bank_1.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
     <ClCompile Include="SKP_Silk_log2lin.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_lowpass_int.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="SKP_Silk_lowpass_short.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="SKP_Silk_LPC_inv_pred_gain.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
index 48daad4..5e7b5b2 100644 (file)
@@ -28,8 +28,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SKP_Silk_main_FIX.h"\r
 #include "SKP_Silk_tuning_parameters.h"\r
 \r
-#if HIGH_PASS_INPUT\r
-\r
 #define SKP_RADIANS_CONSTANT_Q19            1482    // 0.45f * 2.0f * 3.14159265359 / 1000\r
 #define SKP_LOG2_VARIABLE_HP_MIN_FREQ_Q7    809     // log(80) in Q7\r
 \r
@@ -117,5 +115,3 @@ void SKP_Silk_HP_variable_cutoff(
     /********************************/\r
     SKP_Silk_biquad_alt( in, B_Q28, A_Q28, psEncC->In_HP_State, out, frame_length );\r
 }\r
-\r
-#endif // HIGH_PASS_INPUT\r
index 371d35b..57c5939 100644 (file)
@@ -98,9 +98,9 @@ SKP_INLINE void SKP_Silk_LP_interpolate_filter_taps(
 /* Start by setting psEncC->mode <> 0;                      */\r
 /* Deactivate by setting psEncC->mode = 0;                  */\r
 void SKP_Silk_LP_variable_cutoff(\r
-    SKP_Silk_LP_state               *psLP,          /* I/O  LP filter state                     */\r
-    SKP_int16                       *signal,        /* I/O  Low-pass filtered output signal     */\r
-    const SKP_int                   frame_length    /* I    Frame length                        */\r
+    SKP_Silk_LP_state           *psLP,              /* I/O  LP filter state                             */\r
+    SKP_int16                   *signal,            /* I/O  Low-pass filtered output signal             */\r
+    const SKP_int               frame_length        /* I    Frame length                                */\r
 )\r
 {\r
     SKP_int32   B_Q28[ TRANSITION_NB ], A_Q28[ TRANSITION_NA ], fac_Q16 = 0;\r
index 7f79df7..f4de4b4 100644 (file)
@@ -30,7 +30,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /* Convert NLSF parameters to stable AR prediction filter coefficients */\r
 void SKP_Silk_NLSF2A_stable(\r
     SKP_int16                       pAR_Q12[ MAX_LPC_ORDER ],   /* O    Stabilized AR coefs [LPC_order]     */ \r
-    const SKP_int                   pNLSF[ MAX_LPC_ORDER ],     /* I    NLSF vector         [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
diff --git a/src_common/SKP_Silk_NLSF_VQ.c b/src_common/SKP_Silk_NLSF_VQ.c
new file mode 100644 (file)
index 0000000..47e9cfe
--- /dev/null
@@ -0,0 +1,64 @@
+/***********************************************************************\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 "SKP_Silk_main.h"\r
+\r
+/* Compute quantization errors for an LPC_order element input vector for a VQ codebook */\r
+void SKP_Silk_NLSF_VQ(\r
+    SKP_int32                   err_Q26[],              /* O    Quantization errors [K]                     */\r
+    const SKP_int16             in_Q15[],               /* I    Input vectors to be quantized [LPC_order]   */\r
+    const SKP_uint8             pCB_Q8[],               /* I    Codebook vectors [K*LPC_order]              */\r
+    const SKP_int               K,                      /* I    Number of codebook vectors                  */\r
+    const SKP_int               LPC_order               /* I    Number of LPCs                              */\r
+)\r
+{\r
+    SKP_int        i, m;\r
+    SKP_int32      diff_Q15, sum_error_Q30, sum_error_Q26;\r
+\r
+    SKP_assert( LPC_order <= 16 );\r
+    SKP_assert( ( LPC_order & 1 ) == 0 );\r
+\r
+    /* Loop over codebook */\r
+    for( i = 0; i < K; i++ ) {\r
+        sum_error_Q26 = 0;\r
+        for( m = 0; m < LPC_order; m += 2 ) {\r
+            /* Compute weighted squared quantization error for index m */\r
+            diff_Q15 = SKP_SUB_LSHIFT32( in_Q15[ m ], ( SKP_int32 )*pCB_Q8++, 7 ); // range: [ -32767 : 32767 ]\r
+            sum_error_Q30 = SKP_SMULBB( diff_Q15, diff_Q15 );\r
+\r
+            /* Compute weighted squared quantization error for index m + 1 */\r
+            diff_Q15 = SKP_SUB_LSHIFT32( in_Q15[m + 1], ( SKP_int32 )*pCB_Q8++, 7 ); // range: [ -32767 : 32767 ]\r
+            sum_error_Q30 = SKP_SMLABB( sum_error_Q30, diff_Q15, diff_Q15 );\r
+\r
+            sum_error_Q26 = SKP_ADD_RSHIFT32( sum_error_Q26, sum_error_Q30, 4 );\r
+\r
+            SKP_assert( sum_error_Q26 >= 0 );\r
+            SKP_assert( sum_error_Q30 >= 0 );\r
+        }\r
+        err_Q26[ i ] = sum_error_Q26;\r
+    }\r
+}\r
diff --git a/src_common/SKP_Silk_NLSF_decode.c b/src_common/SKP_Silk_NLSF_decode.c
new file mode 100644 (file)
index 0000000..ec8017e
--- /dev/null
@@ -0,0 +1,96 @@
+/***********************************************************************\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 "SKP_Silk_main.h"\r
+\r
+/* Predictive dequantizer for NLSF residuals */\r
+void SKP_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
+    const SKP_int           quant_step_size_Q16,            /* I    Quantization step size                      */\r
+    const SKP_int16         order                           /* I    Number of input values                      */\r
+)\r
+{\r
+    SKP_int     i, out_Q10, pred_Q10;\r
+    \r
+    out_Q10 = 0;\r
+    for( i = order-1; i >= 0; i-- ) {\r
+        pred_Q10 = SKP_RSHIFT( SKP_SMULBB( out_Q10, (SKP_int16)pred_coef_Q8[ i ] ), 8 );\r
+        out_Q10  = SKP_LSHIFT( indices[ i ], 10 );\r
+        if( out_Q10 > 0 ) {\r
+            out_Q10 = SKP_SUB16( out_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+        } else if( out_Q10 < 0 ) {\r
+            out_Q10 = SKP_ADD16( out_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+        }\r
+        out_Q10  = SKP_SMLAWB( pred_Q10, out_Q10, quant_step_size_Q16 );\r
+        x_Q10[ i ] = out_Q10;\r
+    }\r
+}\r
+\r
+\r
+/***********************/\r
+/* NLSF vector decoder */\r
+/***********************/\r
+void SKP_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
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB              /* I    Codebook object                         */\r
+)\r
+{\r
+    SKP_int         i;\r
+    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
+    const SKP_uint8 *pCB_element;\r
+\r
+    /* Decode first stage */\r
+    pCB_element = &psNLSF_CB->CB1_NLSF_Q8[ NLSFIndices[ 0 ] * psNLSF_CB->order ];\r
+    for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+        pNLSF_Q15[ i ] = SKP_LSHIFT( ( SKP_int16 )pCB_element[ i ], 7 );\r
+    }\r
+\r
+    /* Unpack entropy table indices and predictor for current CB1 index */\r
+    SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psNLSF_CB, NLSFIndices[ 0 ] );\r
+\r
+    /* Trellis dequantizer */\r
+    SKP_Silk_NLSF_residual_dequant( res_Q10, &NLSFIndices[ 1 ], pred_Q8, psNLSF_CB->quantStepSize_Q16, psNLSF_CB->order );\r
+\r
+    /* Weights from codebook vector */\r
+    SKP_Silk_NLSF_VQ_weights_laroia( W_tmp_Q5, 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 = SKP_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
+    }\r
+\r
+    /* NLSF stabilization */\r
+    SKP_Silk_NLSF_stabilize( pNLSF_Q15, psNLSF_CB->deltaMin_Q15, psNLSF_CB->order );\r
+}\r
diff --git a/src_common/SKP_Silk_NLSF_del_dec_quant.c b/src_common/SKP_Silk_NLSF_del_dec_quant.c
new file mode 100644 (file)
index 0000000..bf43014
--- /dev/null
@@ -0,0 +1,201 @@
+/***********************************************************************\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 "SKP_Silk_main.h"\r
+\r
+/* Delayed-decision quantizer for NLSF residuals */\r
+SKP_int32 SKP_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
+    const SKP_uint8             pred_coef_Q8[],         /* I    Backward predictor coefs [ order ]          */\r
+    const SKP_int16             ec_ix[],                /* I    Indices to entropy coding tables [ order ]  */\r
+    const SKP_uint8             ec_rates_Q5[],          /* I    Rates []                                    */\r
+    const SKP_int               quant_step_size_Q16,    /* I    Quantization step size                      */\r
+    const SKP_int16             inv_quant_step_size_Q6, /* I    Inverse quantization step size              */\r
+    const SKP_int32             mu_Q20,                 /* I    R/D tradeoff                                */\r
+    const SKP_int16             order                   /* I    Number of input values                      */\r
+)\r
+{\r
+    SKP_int         i, j, nStates, ind_tmp, ind_min_max, ind_max_min, in_Q10, res_Q10;\r
+    SKP_int         pred_Q10, diff_Q10, out0_Q10, out1_Q10, rate0_Q5, rate1_Q5;\r
+    SKP_int32       RD_tmp_Q25, min_Q25, min_max_Q25, max_min_Q25, pred_coef_Q16;\r
+    SKP_int         ind_sort[         NLSF_QUANT_DEL_DEC_STATES ];\r
+    SKP_int8        ind[              NLSF_QUANT_DEL_DEC_STATES ][ MAX_LPC_ORDER ];\r
+    SKP_int16       prev_out_Q10[ 2 * NLSF_QUANT_DEL_DEC_STATES ];\r
+    SKP_int32       RD_Q25[       2 * NLSF_QUANT_DEL_DEC_STATES ];\r
+    SKP_int32       RD_min_Q25[       NLSF_QUANT_DEL_DEC_STATES ];\r
+    SKP_int32       RD_max_Q25[       NLSF_QUANT_DEL_DEC_STATES ];\r
+    const SKP_uint8 *rates_Q5;\r
+    \r
+    SKP_assert( (NLSF_QUANT_DEL_DEC_STATES & (NLSF_QUANT_DEL_DEC_STATES-1)) == 0 );     /* must be power of two */\r
+\r
+    nStates = 1;\r
+    RD_Q25[ 0 ] = 0;\r
+    prev_out_Q10[ 0 ] = 0;\r
+    for( i = order - 1; ; i-- ) {\r
+        rates_Q5 = &ec_rates_Q5[ ec_ix[ i ] ];\r
+        pred_coef_Q16 = SKP_LSHIFT( (SKP_int32)pred_coef_Q8[ i ], 8 );\r
+        in_Q10 = x_Q10[ i ];\r
+        for( j = 0; j < nStates; j++ ) {\r
+            pred_Q10 = SKP_SMULWB( pred_coef_Q16, prev_out_Q10[ j ] );\r
+            res_Q10  = SKP_SUB16( in_Q10, pred_Q10 );\r
+            ind_tmp  = SKP_SMULWB( inv_quant_step_size_Q6, res_Q10 );\r
+            ind_tmp  = SKP_LIMIT( ind_tmp, -NLSF_QUANT_MAX_AMPLITUDE_EXT, NLSF_QUANT_MAX_AMPLITUDE_EXT-1 );\r
+            ind[ j ][ i ] = (SKP_int8)ind_tmp;\r
+\r
+            /* compute outputs for ind_tmp and ind_tmp + 1 */\r
+            out0_Q10 = SKP_LSHIFT( ind_tmp, 10 );\r
+            out1_Q10 = SKP_ADD16( out0_Q10, 1024 );\r
+            if( ind_tmp > 0 ) {\r
+                out0_Q10 = SKP_SUB16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+                out1_Q10 = SKP_SUB16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+            } else if( ind_tmp == 0 ) {\r
+                out1_Q10 = SKP_SUB16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+            } else if( ind_tmp == -1 ) {\r
+                out0_Q10 = SKP_ADD16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+            } else {\r
+                out0_Q10 = SKP_ADD16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+                out1_Q10 = SKP_ADD16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
+            }\r
+            out0_Q10  = SKP_SMULWB( out0_Q10, quant_step_size_Q16 );\r
+            out1_Q10  = SKP_SMULWB( out1_Q10, quant_step_size_Q16 );\r
+            out0_Q10  = SKP_ADD16( out0_Q10, pred_Q10 );\r
+            out1_Q10  = SKP_ADD16( out1_Q10, pred_Q10 );\r
+            prev_out_Q10[ j           ] = out0_Q10;\r
+            prev_out_Q10[ j + nStates ] = out1_Q10;\r
+\r
+            /* compute RD for ind_tmp and ind_tmp + 1 */\r
+            if( ind_tmp + 1 >= NLSF_QUANT_MAX_AMPLITUDE ) {\r
+                if( ind_tmp + 1 == NLSF_QUANT_MAX_AMPLITUDE ) {\r
+                    rate0_Q5 = rates_Q5[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE ];\r
+                    rate1_Q5 = 280;\r
+                } else {\r
+                    rate0_Q5 = SKP_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, 43, ind_tmp );\r
+                    rate1_Q5 = SKP_ADD16( rate0_Q5, 43 ); \r
+                }\r
+            } else if( ind_tmp <= -NLSF_QUANT_MAX_AMPLITUDE ) {\r
+                if( ind_tmp == -NLSF_QUANT_MAX_AMPLITUDE ) {\r
+                    rate0_Q5 = 280;\r
+                    rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ]; \r
+                } else {\r
+                    rate0_Q5 = SKP_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, -43, ind_tmp );\r
+                    rate1_Q5 = SKP_SUB16( rate0_Q5, 43 ); \r
+                }\r
+            } else {\r
+                rate0_Q5 = rates_Q5[ ind_tmp +     NLSF_QUANT_MAX_AMPLITUDE ];\r
+                rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];\r
+            }\r
+            RD_tmp_Q25            = RD_Q25[ j ];\r
+            diff_Q10              = SKP_SUB16( in_Q10, out0_Q10 );\r
+            RD_Q25[ j ]           = SKP_SMLABB( SKP_MLA( RD_tmp_Q25, SKP_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate0_Q5 );\r
+            diff_Q10              = SKP_SUB16( in_Q10, out1_Q10 );\r
+            RD_Q25[ j + nStates ] = SKP_SMLABB( SKP_MLA( RD_tmp_Q25, SKP_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate1_Q5 );\r
+        }\r
+\r
+        if( nStates < NLSF_QUANT_DEL_DEC_STATES ) {\r
+            /* double number of states and copy */\r
+            for( j = 0; j < nStates; j++ ) {\r
+                ind[ j + nStates ][ i ] = ind[ j ][ i ] + 1;\r
+            }\r
+            nStates = SKP_LSHIFT( nStates, 1 );\r
+            for( j = nStates; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
+                ind[ j ][ i ] = ind[ j - nStates ][ i ];\r
+            }\r
+        } else if( i > 0 ) {\r
+            /* sort lower and upper half of RD_Q25, pairwise */\r
+            for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
+                if( RD_Q25[ j ] > RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] ) {\r
+                    RD_max_Q25[ j ]                         = RD_Q25[ j ];\r
+                    RD_min_Q25[ j ]                         = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
+                    RD_Q25[ j ]                             = RD_min_Q25[ j ];\r
+                    RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] = RD_max_Q25[ j ];\r
+                    /* swap prev_out values */\r
+                    out0_Q10 = prev_out_Q10[ j ];\r
+                    prev_out_Q10[ j ] = prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
+                    prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ] = out0_Q10;\r
+                    ind_sort[ j ] = j + NLSF_QUANT_DEL_DEC_STATES;\r
+                } else {\r
+                    RD_min_Q25[ j ] = RD_Q25[ j ];\r
+                    RD_max_Q25[ j ] = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
+                    ind_sort[ j ] = j;\r
+                }\r
+            }\r
+            /* compare the highest RD values of the winning half with the lowest one in the losing half, and copy if necessary */\r
+            /* afterwards ind_sort[] will contain the indices of the NLSF_QUANT_DEL_DEC_STATES winning RD values */\r
+            while( 1 ) {\r
+                min_max_Q25 = SKP_int32_MAX;\r
+                max_min_Q25 = 0;\r
+                ind_min_max = 0;\r
+                ind_max_min = 0;\r
+                for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
+                    if( min_max_Q25 > RD_max_Q25[ j ] ) {\r
+                        min_max_Q25 = RD_max_Q25[ j ];\r
+                        ind_min_max = j;\r
+                    }\r
+                    if( max_min_Q25 < RD_min_Q25[ j ] ) {\r
+                        max_min_Q25 = RD_min_Q25[ j ];\r
+                        ind_max_min = j;\r
+                    }\r
+                }\r
+                if( min_max_Q25 >= max_min_Q25 ) {\r
+                    break;\r
+                }\r
+                /* copy ind_min_max to ind_max_min */\r
+                ind_sort[     ind_max_min ] = ind_sort[     ind_min_max ] ^ NLSF_QUANT_DEL_DEC_STATES;\r
+                RD_Q25[       ind_max_min ] = RD_Q25[       ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];\r
+                prev_out_Q10[ ind_max_min ] = prev_out_Q10[ ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];\r
+                RD_min_Q25[   ind_max_min ] = 0;\r
+                RD_max_Q25[   ind_min_max ] = SKP_int32_MAX;\r
+                SKP_memcpy( ind[ ind_max_min ], ind[ ind_min_max ], MAX_LPC_ORDER * sizeof( SKP_int8 ) );\r
+            }\r
+            /* increment index if it comes from the upper half */\r
+            for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
+                ind[ j ][ i ] += SKP_RSHIFT( ind_sort[ j ], NLSF_QUANT_DEL_DEC_STATES_LOG2 );\r
+            }\r
+        } else {  /* i == 0 */\r
+            /* last sample: find winner, copy indices and return RD value */\r
+            ind_tmp = 0;\r
+            min_Q25 = SKP_int32_MAX;\r
+            for( j = 0; j < 2 * NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
+                if( min_Q25 > RD_Q25[ j ] ) {\r
+                    min_Q25 = RD_Q25[ j ];\r
+                    ind_tmp = j;\r
+                }\r
+            }\r
+            for( j = 0; j < order; j++ ) {\r
+                indices[ j ] = ind[ ind_tmp & ( NLSF_QUANT_DEL_DEC_STATES - 1 ) ][ j ];\r
+                SKP_assert( indices[ j ] >= -NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
+                SKP_assert( indices[ j ] <=  NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
+            }\r
+            indices[ 0 ] += SKP_RSHIFT( ind_tmp, NLSF_QUANT_DEL_DEC_STATES_LOG2 );\r
+            SKP_assert( indices[ 0 ] <= NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
+            SKP_assert( min_Q25 >= 0 );\r
+            return min_Q25;\r
+        }\r
+    }\r
+}\r
diff --git a/src_common/SKP_Silk_NLSF_encode.c b/src_common/SKP_Silk_NLSF_encode.c
new file mode 100644 (file)
index 0000000..965eb3c
--- /dev/null
@@ -0,0 +1,183 @@
+/***********************************************************************\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 "SKP_Silk_main.h"\r
+\r
+#define STORE_LSF_DATA_FOR_TRAINING          0\r
+\r
+/***********************/\r
+/* NLSF vector encoder */\r
+/***********************/\r
+SKP_int32 SKP_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 SKP_Silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
+    const SKP_int16                 *pW_Q5,                 /* 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
+)\r
+{\r
+    SKP_int         i, s, ind1, bestIndex, prob_Q8, bits_q7;\r
+    SKP_int32       W_tmp_Q9;\r
+    SKP_int32       err_Q26[      NLSF_VQ_MAX_VECTORS ];\r
+    SKP_int32       RD_Q25[       NLSF_VQ_MAX_SURVIVORS ];\r
+    SKP_int         tempIndices1[ NLSF_VQ_MAX_SURVIVORS ];\r
+    SKP_int8        tempIndices2[ NLSF_VQ_MAX_SURVIVORS * MAX_LPC_ORDER ];\r
+    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_adj_Q5[     MAX_LPC_ORDER ];\r
+    SKP_uint8       pred_Q8[      MAX_LPC_ORDER ];\r
+    SKP_int16       ec_ix[        MAX_LPC_ORDER ];\r
+    const SKP_uint8 *pCB_element, *iCDF_ptr;\r
+\r
+#if STORE_LSF_DATA_FOR_TRAINING\r
+    SKP_int16       pNLSF_Q15_orig[MAX_LPC_ORDER ];\r
+    DEBUG_STORE_DATA( NLSF.dat,    pNLSF_Q15,    psNLSF_CB->order * sizeof( SKP_int16 ) );\r
+    DEBUG_STORE_DATA( WNLSF.dat,   pW_Q5,        psNLSF_CB->order * sizeof( SKP_int16 ) );\r
+    DEBUG_STORE_DATA( NLSF_mu.dat, &NLSF_mu_Q20,                    sizeof( SKP_int   ) );\r
+    DEBUG_STORE_DATA( sigType.dat, &signalType,                     sizeof( SKP_int   ) );\r
+    SKP_memcpy(pNLSF_Q15_orig, pNLSF_Q15, sizeof( pNLSF_Q15_orig ));\r
+#endif\r
+\r
+    SKP_assert( nSurvivors <= NLSF_VQ_MAX_SURVIVORS );\r
+    SKP_assert( signalType >= 0 && signalType <= 2 );\r
+    SKP_assert( NLSF_mu_Q20 <= 32767 && NLSF_mu_Q20 >= 0 );\r
+\r
+    /* NLSF stabilization */\r
+    SKP_Silk_NLSF_stabilize( pNLSF_Q15, psNLSF_CB->deltaMin_Q15, psNLSF_CB->order );\r
+\r
+    /* First stage: VQ */\r
+    SKP_Silk_NLSF_VQ( err_Q26, pNLSF_Q15, psNLSF_CB->CB1_NLSF_Q8, psNLSF_CB->nVectors, psNLSF_CB->order );\r
+\r
+    /* Sort the quantization errors */\r
+    SKP_Silk_insertion_sort_increasing( err_Q26, tempIndices1, psNLSF_CB->nVectors, nSurvivors );\r
+\r
+    /* Loop over survivors */\r
+    for( s = 0; s < nSurvivors; s++ ) {\r
+        ind1 = tempIndices1[ s ]; \r
+\r
+        /* Residual after first stage */\r
+        pCB_element = &psNLSF_CB->CB1_NLSF_Q8[ ind1 * psNLSF_CB->order ];\r
+        for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+            NLSF_tmp_Q15[ i ] = SKP_LSHIFT16( ( SKP_int16 )pCB_element[ i ], 7 );\r
+            res_Q15[ i ] = pNLSF_Q15[ i ] - NLSF_tmp_Q15[ i ];\r
+        }\r
+\r
+        /* Weights from codebook vector */\r
+        SKP_Silk_NLSF_VQ_weights_laroia( W_tmp_Q5, 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 = SKP_Silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_Q5[ i ], 13 ) );\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
+        }\r
+\r
+        /* Unpack entropy table indices and predictor for current CB1 index */\r
+        SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psNLSF_CB, ind1 );\r
+\r
+        /* Trellis quantizer */\r
+        RD_Q25[ s ] = SKP_Silk_NLSF_del_dec_quant( &tempIndices2[ s * MAX_LPC_ORDER ], res_Q10, W_adj_Q5, pred_Q8, ec_ix, \r
+            psNLSF_CB->ec_Rates_Q5, psNLSF_CB->quantStepSize_Q16, psNLSF_CB->invQuantStepSize_Q6, NLSF_mu_Q20, psNLSF_CB->order );\r
+\r
+        /* Add rate for first stage */\r
+        iCDF_ptr = &psNLSF_CB->CB1_iCDF[ ( signalType >> 1 ) * psNLSF_CB->nVectors ];\r
+        if( ind1 == 0 ) {\r
+            prob_Q8 = 256 - iCDF_ptr[ ind1 ];\r
+        } else {\r
+            prob_Q8 = iCDF_ptr[ ind1 - 1 ] - iCDF_ptr[ ind1 ];\r
+        }\r
+        bits_q7 = ( 8 << 7 ) - SKP_Silk_lin2log( prob_Q8 );\r
+        RD_Q25[ s ] = SKP_SMLABB( RD_Q25[ s ], bits_q7, SKP_RSHIFT( NLSF_mu_Q20, 2 ) );\r
+    }\r
+\r
+    /* Find the lowest rate-distortion error */\r
+    SKP_Silk_insertion_sort_increasing( RD_Q25, &bestIndex, nSurvivors, 1 );\r
+\r
+    NLSFIndices[ 0 ] = ( SKP_int8 )tempIndices1[ bestIndex ];\r
+    SKP_memcpy( &NLSFIndices[ 1 ], &tempIndices2[ bestIndex * MAX_LPC_ORDER ], psNLSF_CB->order * sizeof( SKP_int8 ) );\r
+\r
+    /* Decode */\r
+    SKP_Silk_NLSF_decode( pNLSF_Q15, NLSFIndices, psNLSF_CB );\r
+\r
+#if STORE_LSF_DATA_FOR_TRAINING\r
+    {\r
+               /* code for training the codebooks */\r
+        SKP_int32 RD_dec_Q22, Dist_Q22_dec, Rate_Q7, diff_Q15;\r
+        ind1 = NLSFIndices[ 0 ];\r
+        SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psNLSF_CB, ind1 );\r
+\r
+        pCB_element = &psNLSF_CB->CB1_NLSF_Q8[ ind1 * psNLSF_CB->order ];\r
+        for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+            NLSF_tmp_Q15[ i ] = SKP_LSHIFT16( ( SKP_int16 )pCB_element[ i ], 7 );\r
+        }\r
+        SKP_Silk_NLSF_VQ_weights_laroia( W_tmp_Q5, NLSF_tmp_Q15, psNLSF_CB->order );\r
+        for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+            W_tmp_Q9 = SKP_Silk_SQRT_APPROX( SKP_LSHIFT( ( SKP_int32 )W_tmp_Q5[ i ], 13 ) );\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
+            res_Q15[ i ] = pNLSF_Q15[ 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_resq_q10.dat, &res_Q10[ i ], sizeof( SKP_int16 ) );\r
+        }\r
+\r
+        Dist_Q22_dec = 0;\r
+        for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+            diff_Q15 = pNLSF_Q15_orig[ i ] - pNLSF_Q15[ i ];\r
+            Dist_Q22_dec += ( ( (diff_Q15 >> 5) * (diff_Q15 >> 5) ) * pW_Q5[ i ] ) >> 3;\r
+        }\r
+        iCDF_ptr = &psNLSF_CB->CB1_iCDF[ ( signalType >> 1 ) * psNLSF_CB->nVectors ];\r
+        if( ind1 == 0 ) {\r
+            prob_Q8 = 256 - iCDF_ptr[ ind1 ];\r
+        } else {\r
+            prob_Q8 = iCDF_ptr[ ind1 - 1 ] - iCDF_ptr[ ind1 ];\r
+        }\r
+        Rate_Q7 = ( 8 << 7 ) - SKP_Silk_lin2log( prob_Q8 );\r
+        for( i = 0; i < psNLSF_CB->order; i++ ) {\r
+            Rate_Q7 += ((int)psNLSF_CB->ec_Rates_Q5[ ec_ix[ i ] + SKP_LIMIT( NLSFIndices[ i + 1 ] + NLSF_QUANT_MAX_AMPLITUDE, 0, 2 * NLSF_QUANT_MAX_AMPLITUDE ) ] ) << 2;\r
+            if( SKP_abs( NLSFIndices[ i + 1 ] ) >= NLSF_QUANT_MAX_AMPLITUDE ) {\r
+                Rate_Q7 += 128 << ( SKP_abs( NLSFIndices[ i + 1 ] ) - NLSF_QUANT_MAX_AMPLITUDE );\r
+            }\r
+        }\r
+        RD_dec_Q22 = Dist_Q22_dec + Rate_Q7 * NLSF_mu_Q20 >> 5;\r
+        DEBUG_STORE_DATA( dec_dist_q22.dat, &Dist_Q22_dec, sizeof( SKP_int32 ) );\r
+        DEBUG_STORE_DATA( dec_rate_q7.dat, &Rate_Q7, sizeof( SKP_int32 ) );\r
+        DEBUG_STORE_DATA( dec_rd_q22.dat, &RD_dec_Q22, sizeof( SKP_int32 ) );\r
+    }\r
+    DEBUG_STORE_DATA( NLSF_ind.dat, NLSFIndices, (psNLSF_CB->order+1) * sizeof( SKP_int8 ) );\r
+#endif\r
+\r
+    return RD_Q25[ 0 ];\r
+}\r
diff --git a/src_common/SKP_Silk_NLSF_unpack.c b/src_common/SKP_Silk_NLSF_unpack.c
new file mode 100644 (file)
index 0000000..4dd3a9c
--- /dev/null
@@ -0,0 +1,51 @@
+/***********************************************************************\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 "SKP_Silk_main.h"\r
+\r
+/* Unpack predictor values and indices for entropy coding tables */\r
+void SKP_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
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
+    const SKP_int                   CB1_index               /* I    Index of vector in first LSF codebook   */\r
+) \r
+{\r
+    SKP_int   i;\r
+    SKP_uint8 entry;\r
+    const SKP_uint8 *ec_sel_ptr;\r
+\r
+    ec_sel_ptr = &psNLSF_CB->ec_sel[ CB1_index * psNLSF_CB->order / 2 ];\r
+    for( i = 0; i < psNLSF_CB->order; i += 2 ) {\r
+        entry = *ec_sel_ptr++;\r
+        ec_ix  [ i     ] = SKP_SMULBB( SKP_RSHIFT( entry, 1 ) & 7, 2 * NLSF_QUANT_MAX_AMPLITUDE + 1 );\r
+        pred_Q8[ i     ] = psNLSF_CB->pred_Q8[ i + ( entry & 1 ) * ( psNLSF_CB->order - 1 ) ];\r
+        ec_ix  [ i + 1 ] = SKP_SMULBB( SKP_RSHIFT( entry, 5 ) & 7, 2 * NLSF_QUANT_MAX_AMPLITUDE + 1 );\r
+        pred_Q8[ i + 1 ] = psNLSF_CB->pred_Q8[ i + ( SKP_RSHIFT( entry, 4 ) & 1 ) * ( psNLSF_CB->order - 1 ) + 1 ];\r
+    }\r
+}\r
+\r
index 4aa918f..397c8cf 100644 (file)
@@ -189,8 +189,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer(
 {\r
     SKP_int     i, j;\r
     SKP_int32   LTP_pred_Q14, LPC_pred_Q10, n_AR_Q10, n_LTP_Q14;\r
-    SKP_int32   n_LF_Q10, r_Q10, q_Q0, q_Q10;\r
-    SKP_int32   thr1_Q10, thr2_Q10, thr3_Q10;\r
+    SKP_int32   n_LF_Q10, r_Q10, rr_Q10, q1_Q10, q2_Q10, rd1_Q10, rd2_Q10;\r
     SKP_int32   dither, exc_Q10, LPC_exc_Q10, xq_Q10;\r
     SKP_int32   tmp1, tmp2, sLF_AR_shp_Q10;\r
     SKP_int32   *psLPC_Q14, *shp_lag_ptr, *pred_lag_ptr;\r
@@ -201,12 +200,6 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer(
     /* Setup short term AR state */\r
     psLPC_Q14 = &NSQ->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 ];\r
 \r
-    /* Quantization thresholds */\r
-    thr1_Q10 = SKP_SUB_RSHIFT32( -1536, Lambda_Q10, 1 );\r
-    thr2_Q10 = SKP_SUB_RSHIFT32(  -512, Lambda_Q10, 1 );\r
-    thr2_Q10 = SKP_ADD_RSHIFT32( thr2_Q10, SKP_SMULBB( offset_Q10, Lambda_Q10 ), 10 );\r
-    thr3_Q10 = SKP_ADD_RSHIFT32(   512, Lambda_Q10, 1 );\r
-\r
     for( i = 0; i < length; i++ ) {\r
         /* Generate dither */\r
         NSQ->rand_seed = SKP_RAND( NSQ->rand_seed );\r
@@ -280,46 +273,62 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer(
             n_LTP_Q14 = SKP_LSHIFT( n_LTP_Q14, 6 );\r
             shp_lag_ptr++;\r
 \r
-            tmp1 = SKP_SUB32( LTP_pred_Q14, n_LTP_Q14 );                       /* Add Q14 stuff */\r
-            tmp1 = SKP_RSHIFT( tmp1, 4 );                                      /* convert to Q10  */\r
-            tmp1 = SKP_ADD32( tmp1, LPC_pred_Q10 );                            /* add Q10 stuff */ \r
-            tmp1 = SKP_SUB32( tmp1, n_AR_Q10 );                                /* subtract Q10 stuff */ \r
+            tmp1 = SKP_SUB32( LTP_pred_Q14, n_LTP_Q14 );                        /* Add Q14 stuff */\r
+            tmp1 = SKP_RSHIFT( tmp1, 4 );                                       /* convert to Q10  */\r
+            tmp1 = SKP_ADD32( tmp1, LPC_pred_Q10 );                             /* add Q10 stuff */ \r
+            tmp1 = SKP_SUB32( tmp1, n_AR_Q10 );                                 /* subtract Q10 stuff */ \r
         } else {\r
-            tmp1 = SKP_SUB32( LPC_pred_Q10, n_AR_Q10 );                        /* subtract Q10 stuff */ \r
+            tmp1 = SKP_SUB32( LPC_pred_Q10, n_AR_Q10 );                         /* subtract Q10 stuff */ \r
         }\r
 \r
         /* Input minus prediction plus noise feedback  */\r
         //r = x[ i ] - LTP_pred - LPC_pred + n_AR + n_Tilt + n_LF + n_LTP;\r
-        tmp1  = SKP_SUB32( tmp1, n_LF_Q10 );                                /* subtract Q10 stuff */ \r
+        tmp1  = SKP_SUB32( tmp1, n_LF_Q10 );                                    /* subtract Q10 stuff */ \r
         r_Q10 = SKP_SUB32( x_sc_Q10[ i ], tmp1 );\r
 \r
         /* Flip sign depending on dither */\r
-        r_Q10 = ( r_Q10 ^ dither ) - dither;\r
-        r_Q10 = SKP_SUB32( r_Q10, offset_Q10 );\r
-        r_Q10 = SKP_LIMIT_32( r_Q10, -64 << 10, 64 << 10 );\r
-\r
-        /* Quantize */\r
-        q_Q0 = 0;\r
-        q_Q10 = 0;\r
-        if( r_Q10 < thr2_Q10 ) {\r
-            if( r_Q10 < thr1_Q10 ) {\r
-                q_Q0 = SKP_RSHIFT_ROUND( SKP_ADD_RSHIFT32( r_Q10, Lambda_Q10, 1 ), 10 );\r
-                q_Q10 = SKP_LSHIFT( q_Q0, 10 );\r
-            } else {\r
-                q_Q0 = -1;\r
-                q_Q10 = -1024;\r
-            }\r
-        } else {\r
-            if( r_Q10 > thr3_Q10 ) {\r
-                q_Q0 = SKP_RSHIFT_ROUND( SKP_SUB_RSHIFT32( r_Q10, Lambda_Q10, 1 ), 10 );\r
-                q_Q10 = SKP_LSHIFT( q_Q0, 10 );\r
-            }\r
+        r_Q10 = r_Q10 ^ dither;\r
+        r_Q10 = SKP_LIMIT_32( r_Q10, -31 << 10, 30 << 10 );\r
+\r
+        /* Find two quantization level candidates and measure their rate-distortion */\r
+        q1_Q10 = SKP_SUB32( r_Q10, offset_Q10 );\r
+        q1_Q10 = SKP_RSHIFT( q1_Q10, 10 );\r
+        if( q1_Q10 > 0 ) {\r
+            q1_Q10  = SKP_SUB32( SKP_LSHIFT( q1_Q10, 10 ), QUANT_LEVEL_ADJUST_Q10 );\r
+            q1_Q10  = SKP_ADD32( q1_Q10, offset_Q10 );\r
+            q2_Q10  = SKP_ADD32( q1_Q10, 1024 );\r
+            rd1_Q10 = SKP_SMULBB( q1_Q10, Lambda_Q10 );\r
+            rd2_Q10 = SKP_SMULBB( q2_Q10, Lambda_Q10 );\r
+        } else if( q1_Q10 == 0 ) {\r
+            q1_Q10  = offset_Q10;\r
+            q2_Q10  = SKP_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );\r
+            rd1_Q10 = SKP_SMULBB( q1_Q10, Lambda_Q10 );\r
+            rd2_Q10 = SKP_SMULBB( q2_Q10, Lambda_Q10 );\r
+        } else if( q1_Q10 == -1 ) {\r
+            q2_Q10  = offset_Q10;\r
+            q1_Q10  = SKP_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );\r
+            rd1_Q10 = SKP_SMULBB( -q1_Q10, Lambda_Q10 );\r
+            rd2_Q10 = SKP_SMULBB(  q2_Q10, Lambda_Q10 );\r
+        } else {            /* Q1_Q10 < -1 */\r
+            q1_Q10  = SKP_ADD32( SKP_LSHIFT( q1_Q10, 10 ), QUANT_LEVEL_ADJUST_Q10 );\r
+            q1_Q10  = SKP_ADD32( q1_Q10, offset_Q10 );\r
+            q2_Q10  = SKP_ADD32( q1_Q10, 1024 );\r
+            rd1_Q10 = SKP_SMULBB( -q1_Q10, Lambda_Q10 );\r
+            rd2_Q10 = SKP_SMULBB( -q2_Q10, Lambda_Q10 );\r
         }\r
-        pulses[ i ] = ( SKP_int8 )q_Q0; /* No saturation needed because max is 64 */\r
+        rr_Q10  = SKP_SUB32( r_Q10, q1_Q10 );\r
+        rd1_Q10 = SKP_RSHIFT( SKP_SMLABB( rd1_Q10, rr_Q10, rr_Q10 ), 10 );\r
+        rr_Q10  = SKP_SUB32( r_Q10, q2_Q10 );\r
+        rd2_Q10 = SKP_RSHIFT( SKP_SMLABB( rd2_Q10, rr_Q10, rr_Q10 ), 10 );\r
+\r
+        if( rd2_Q10 < rd1_Q10 ) {\r
+            q1_Q10 = q2_Q10;\r
+        }\r
+\r
+        pulses[ i ] = ( SKP_int8 )SKP_RSHIFT_ROUND( q1_Q10, 10 );\r
 \r
         /* Excitation */\r
-        exc_Q10 = SKP_ADD32( q_Q10, offset_Q10 );\r
-        exc_Q10 = ( exc_Q10 ^ dither ) - dither;\r
+        exc_Q10 = q1_Q10 ^ dither;\r
 \r
         /* Add predictions */\r
         LPC_exc_Q10 = SKP_ADD32( exc_Q10, SKP_RSHIFT_ROUND( LTP_pred_Q14, 4 ) );\r
index eba6f7c..6ef1bd5 100644 (file)
@@ -215,7 +215,7 @@ void SKP_Silk_NSQ_del_dec(
                     last_smple_idx = smpl_buf_idx + decisionDelay;\r
                     for( i = 0; i < decisionDelay; i++ ) {\r
                         last_smple_idx = ( last_smple_idx - 1 ) & DECISION_DELAY_MASK;\r
-                        pulses[   i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT( psDD->Q_Q10[ last_smple_idx ], 10 );\r
+                        pulses[   i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 );\r
                         pxq[ i - decisionDelay ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( \r
                             SKP_SMULWW( psDD->Xq_Q10[ last_smple_idx ], Gains_Q16[ 1 ] ), 10 ) );\r
                         NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - decisionDelay + i ] = psDD->Shape_Q10[ last_smple_idx ];\r
@@ -265,7 +265,7 @@ void SKP_Silk_NSQ_del_dec(
     last_smple_idx = smpl_buf_idx + decisionDelay;\r
     for( i = 0; i < decisionDelay; i++ ) {\r
         last_smple_idx = ( last_smple_idx - 1 ) & DECISION_DELAY_MASK;\r
-        pulses[   i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT( psDD->Q_Q10[ last_smple_idx ], 10 );\r
+        pulses[   i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 );\r
         pxq[ i - decisionDelay ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( \r
             SKP_SMULWW( psDD->Xq_Q10[ last_smple_idx ], Gains_Q16[ psEncC->nb_subfr - 1 ] ), 10 ) );\r
         NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - decisionDelay + i ] = psDD->Shape_Q10[ last_smple_idx ];\r
@@ -324,7 +324,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
     SKP_int     i, j, k, Winner_ind, RDmin_ind, RDmax_ind, last_smple_idx;\r
     SKP_int32   Winner_rand_state;\r
     SKP_int32   LTP_pred_Q14, LPC_pred_Q10, n_AR_Q10, n_LTP_Q14, LTP_Q10;\r
-    SKP_int32   n_LF_Q10, r_Q10, rr_Q20, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10;\r
+    SKP_int32   n_LF_Q10, r_Q10, rr_Q10, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10;\r
     SKP_int32   q1_Q10, q2_Q10, dither, exc_Q10, LPC_exc_Q10, xq_Q10;\r
     SKP_int32   tmp1, tmp2, sLF_AR_shp_Q10;\r
     SKP_int32   *pred_lag_ptr, *shp_lag_ptr, *psLPC_Q14;\r
@@ -434,33 +434,39 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
             r_Q10 = SKP_SUB32( x_Q10[ i ], tmp1 );                              /* residual error Q10 */\r
             \r
             /* Flip sign depending on dither */\r
-            r_Q10 = ( r_Q10 ^ dither ) - dither;\r
-            r_Q10 = SKP_SUB32( r_Q10, offset_Q10 );\r
-            r_Q10 = SKP_LIMIT_32( r_Q10, -64 << 10, 64 << 10 );\r
+            r_Q10 = r_Q10 ^ dither;\r
+            r_Q10 = SKP_LIMIT_32( r_Q10, -31 << 10, 30 << 10 );\r
 \r
             /* Find two quantization level candidates and measure their rate-distortion */\r
-            if( r_Q10 < -1536 ) {\r
-                q1_Q10  = SKP_LSHIFT( SKP_RSHIFT_ROUND( r_Q10, 10 ), 10 );\r
-                r_Q10   = SKP_SUB32( r_Q10, q1_Q10 );\r
-                rd1_Q10 = SKP_RSHIFT( SKP_SMLABB( SKP_MUL( -SKP_ADD32( q1_Q10, offset_Q10 ), Lambda_Q10 ), r_Q10, r_Q10 ), 10 );\r
-                rd2_Q10 = SKP_ADD32( rd1_Q10, 1024 );\r
-                rd2_Q10 = SKP_SUB32( rd2_Q10, SKP_ADD_LSHIFT32( Lambda_Q10, r_Q10, 1 ) );\r
+            q1_Q10 = SKP_SUB32( r_Q10, offset_Q10 );\r
+            q1_Q10 = SKP_RSHIFT( q1_Q10, 10 );\r
+            if( q1_Q10 > 0 ) {\r
+                q1_Q10  = SKP_SUB32( SKP_LSHIFT( q1_Q10, 10 ), QUANT_LEVEL_ADJUST_Q10 );\r
+                q1_Q10  = SKP_ADD32( q1_Q10, offset_Q10 );\r
                 q2_Q10  = SKP_ADD32( q1_Q10, 1024 );\r
-            } else if( r_Q10 > 512 ) {\r
-                q1_Q10  = SKP_LSHIFT( SKP_RSHIFT_ROUND( r_Q10, 10 ), 10 );\r
-                r_Q10   = SKP_SUB32( r_Q10, q1_Q10 );\r
-                rd1_Q10 = SKP_RSHIFT( SKP_SMLABB( SKP_MUL( SKP_ADD32( q1_Q10, offset_Q10 ), Lambda_Q10 ), r_Q10, r_Q10 ), 10 );\r
-                rd2_Q10 = SKP_ADD32( rd1_Q10, 1024 );\r
-                rd2_Q10 = SKP_SUB32( rd2_Q10, SKP_SUB_LSHIFT32( Lambda_Q10, r_Q10, 1 ) );\r
-                q2_Q10  = SKP_SUB32( q1_Q10, 1024 );\r
-            } else {            /* r_Q10 >= -1536 && q1_Q10 <= 512 */\r
-                rr_Q20  = SKP_SMULBB( offset_Q10, Lambda_Q10 );\r
-                rd2_Q10 = SKP_RSHIFT( SKP_SMLABB( rr_Q20, r_Q10, r_Q10 ), 10 );\r
-                rd1_Q10 = SKP_ADD32( rd2_Q10, 1024 );\r
-                rd1_Q10 = SKP_ADD32( rd1_Q10, SKP_SUB_RSHIFT32( SKP_ADD_LSHIFT32( Lambda_Q10, r_Q10, 1 ), rr_Q20, 9 ) );\r
-                q1_Q10  = -1024;\r
-                q2_Q10  = 0;\r
+                rd1_Q10 = SKP_SMULBB( q1_Q10, Lambda_Q10 );\r
+                rd2_Q10 = SKP_SMULBB( q2_Q10, Lambda_Q10 );\r
+            } else if( q1_Q10 == 0 ) {\r
+                q1_Q10  = offset_Q10;\r
+                q2_Q10  = SKP_ADD32( q1_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );\r
+                rd1_Q10 = SKP_SMULBB( q1_Q10, Lambda_Q10 );\r
+                rd2_Q10 = SKP_SMULBB( q2_Q10, Lambda_Q10 );\r
+            } else if( q1_Q10 == -1 ) {\r
+                q2_Q10  = offset_Q10;\r
+                q1_Q10  = SKP_SUB32( q2_Q10, 1024 - QUANT_LEVEL_ADJUST_Q10 );\r
+                rd1_Q10 = SKP_SMULBB( -q1_Q10, Lambda_Q10 );\r
+                rd2_Q10 = SKP_SMULBB(  q2_Q10, Lambda_Q10 );\r
+            } else {            /* Q1_Q10 < -1 */\r
+                q1_Q10  = SKP_ADD32( SKP_LSHIFT( q1_Q10, 10 ), QUANT_LEVEL_ADJUST_Q10 );\r
+                q1_Q10  = SKP_ADD32( q1_Q10, offset_Q10 );\r
+                q2_Q10  = SKP_ADD32( q1_Q10, 1024 );\r
+                rd1_Q10 = SKP_SMULBB( -q1_Q10, Lambda_Q10 );\r
+                rd2_Q10 = SKP_SMULBB( -q2_Q10, Lambda_Q10 );\r
             }\r
+            rr_Q10  = SKP_SUB32( r_Q10, q1_Q10 );\r
+            rd1_Q10 = SKP_RSHIFT( SKP_SMLABB( rd1_Q10, rr_Q10, rr_Q10 ), 10 );\r
+            rr_Q10  = SKP_SUB32( r_Q10, q2_Q10 );\r
+            rd2_Q10 = SKP_RSHIFT( SKP_SMLABB( rd2_Q10, rr_Q10, rr_Q10 ), 10 );\r
 \r
             if( rd1_Q10 < rd2_Q10 ) {\r
                 psSS[ 0 ].RD_Q10 = SKP_ADD32( psDD->RD_Q10, rd1_Q10 ); \r
@@ -477,8 +483,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
             /* Update states for best quantization */\r
 \r
             /* Quantized excitation */\r
-            exc_Q10 = SKP_ADD32( offset_Q10, psSS[ 0 ].Q_Q10 );\r
-            exc_Q10 = ( exc_Q10 ^ dither ) - dither;\r
+            exc_Q10 = psSS[ 0 ].Q_Q10 ^ dither;\r
 \r
             /* Add predictions */\r
             LPC_exc_Q10 = exc_Q10 + SKP_RSHIFT_ROUND( LTP_pred_Q14, 4 );\r
@@ -494,8 +499,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
             /* Update states for second best quantization */\r
 \r
             /* Quantized excitation */\r
-            exc_Q10 = SKP_ADD32( offset_Q10, psSS[ 1 ].Q_Q10 );\r
-            exc_Q10 = ( exc_Q10 ^ dither ) - dither;\r
+            exc_Q10 = psSS[ 1 ].Q_Q10 ^ dither;\r
 \r
             /* Add predictions */\r
             LPC_exc_Q10 = exc_Q10 + SKP_RSHIFT_ROUND( LTP_pred_Q14, 4 );\r
@@ -560,7 +564,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
         /* Write samples from winner to output and long-term filter states */\r
         psDD = &psDelDec[ Winner_ind ];\r
         if( subfr > 0 || i >= decisionDelay ) {\r
-            pulses[  i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT( psDD->Q_Q10[ last_smple_idx ], 10 );\r
+            pulses[  i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT_ROUND( psDD->Q_Q10[ last_smple_idx ], 10 );\r
             xq[ i - decisionDelay ] = ( SKP_int16 )SKP_SAT16( SKP_RSHIFT_ROUND( \r
                 SKP_SMULWW( psDD->Xq_Q10[ last_smple_idx ], delayedGain_Q16[ last_smple_idx ] ), 10 ) );\r
             NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - decisionDelay ] = psDD->Shape_Q10[ last_smple_idx ];\r
@@ -579,7 +583,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
             psDD->Q_Q10[     *smpl_buf_idx ]         = psSS->Q_Q10;\r
             psDD->Pred_Q16[  *smpl_buf_idx ]         = psSS->LPC_exc_Q16;\r
             psDD->Shape_Q10[ *smpl_buf_idx ]         = psSS->sLTP_shp_Q10;\r
-            psDD->Seed                               = SKP_ADD_RSHIFT32( psDD->Seed, psSS->Q_Q10, 10 );\r
+            psDD->Seed                               = SKP_ADD32( psDD->Seed, SKP_RSHIFT_ROUND( psSS->Q_Q10, 10 ) );\r
             psDD->RandState[ *smpl_buf_idx ]         = psDD->Seed;\r
             psDD->RD_Q10                             = psSS->RD_Q10;\r
         }\r
index cecdce2..e929d14 100644 (file)
@@ -241,8 +241,6 @@ SKP_int SKP_Silk_VAD_GetSA_Q8(                      /* O    Return value, 0 if s
     \r
     if( psEncC->frame_length == 10 * psEncC->fs_kHz ) {\r
         smooth_coef_Q16 >>= 1;\r
-    } else {\r
-       SKP_assert( psEncC->frame_length == 20 * psEncC->fs_kHz );\r
     }\r
 \r
     for( b = 0; b < VAD_N_BANDS; b++ ) {\r
index efa482a..552fe07 100644 (file)
@@ -26,6 +26,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***********************************************************************/\r
 \r
 #include "SKP_Silk_main.h"\r
+#include "SKP_Silk_tuning_parameters.h"\r
 \r
 /* Control internal sampling rate */\r
 SKP_int SKP_Silk_control_audio_bandwidth(\r
index a071813..3c626ad 100644 (file)
@@ -56,6 +56,54 @@ SKP_int SKP_Silk_SDK_InitDecoder(
     return ret;\r
 }\r
 \r
+/* Prefill LPC synthesis buffer, HP filter and upsampler. Input must be exactly 10 ms of audio. */\r
+SKP_int SKP_Silk_SDK_Decoder_prefill_buffers(           /* O:   Returns error code                              */\r
+    void*                               decState,       /* I/O: State                                           */\r
+    SKP_SILK_SDK_DecControlStruct*      decControl,     /* I/O: Control Structure                               */\r
+    const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector  (10 ms)             */\r
+    SKP_int                             nSamplesIn      /* I:   Number of samples in input vector               */\r
+)\r
+{\r
+    SKP_int   i, nSamples, ret = 0;\r
+    SKP_Silk_decoder_state *psDec = ( SKP_Silk_decoder_state *)decState;\r
+    SKP_Silk_resampler_state_struct resampler_state;\r
+    SKP_int16 buf[ 10 * MAX_FS_KHZ ];\r
+    SKP_int16 buf_out[ 10 * MAX_API_FS_KHZ ];\r
+    const SKP_int16 *in_ptr;\r
+\r
+    /* Compute some numbers at API sampling rate */\r
+    if( nSamplesIn != SKP_DIV32_16( decControl->API_sampleRate, 100 ) ) {\r
+        return -1;\r
+    }\r
+\r
+    /* Resample input if necessary */\r
+    if( decControl->API_sampleRate != SKP_SMULBB( 1000, psDec->fs_kHz ) ) { \r
+        ret += SKP_Silk_resampler_init( &resampler_state, decControl->API_sampleRate, SKP_SMULBB( 1000, psDec->fs_kHz ) );\r
+        ret += SKP_Silk_resampler( &resampler_state, buf, samplesIn, nSamplesIn );\r
+        in_ptr = buf;\r
+        nSamples = SKP_SMULBB( 10, psDec->fs_kHz );\r
+    } else {\r
+        in_ptr = samplesIn;\r
+        nSamples = nSamplesIn;\r
+    }\r
+\r
+    /* Set synthesis filter state */\r
+    for( i = 0; i < psDec->LPC_order; i++ ) {\r
+        //psDec->sLPC_Q14[ MAX_LPC_ORDER - i ] = SKP_LSHIFT( SKP_SMULWB( psDec->prev_inv_gain_Q16, in_ptr[ nSamples - i ] ), 14 );\r
+    }\r
+\r
+    /* HP filter */\r
+    SKP_Silk_biquad_alt( in_ptr, psDec->HP_B, psDec->HP_A, psDec->HPState, buf, nSamples );\r
+\r
+    /* Output upsampler */\r
+    SKP_Silk_resampler( &psDec->resampler_state, buf_out, buf, nSamples );\r
+\r
+    /* Avoid using LSF interpolation or pitch prediction in first next frame */\r
+    psDec->first_frame_after_reset = 1;\r
+\r
+    return ret;\r
+}\r
+\r
 /* Decode a frame */\r
 SKP_int SKP_Silk_SDK_Decode(\r
     void*                               decState,       /* I/O: State                                           */\r
index 67767c3..ef8c57b 100644 (file)
@@ -40,7 +40,7 @@ void SKP_Silk_decode_core(
     SKP_int   i, j, k, lag = 0, start_idx, sLTP_buf_idx, NLSF_interpolation_flag, signalType;\r
     SKP_int16 *A_Q12, *B_Q14, *pxq, A_Q12_tmp[ MAX_LPC_ORDER ];\r
     SKP_int16 sLTP[ MAX_FRAME_LENGTH ];\r
-    SKP_int32 LTP_pred_Q14, LPC_pred_Q10, Gain_Q16, inv_gain_Q16, inv_gain_Q32, gain_adj_Q16, rand_seed, offset_Q10, dither;\r
+    SKP_int32 LTP_pred_Q14, LPC_pred_Q10, Gain_Q16, inv_gain_Q16, inv_gain_Q32, gain_adj_Q16, rand_seed, offset_Q10;\r
     SKP_int32 *pred_lag_ptr, *pexc_Q10, *pres_Q10;\r
     SKP_int32 res_Q10[ MAX_SUB_FRAME_LENGTH ];\r
     SKP_int32 vec_Q10[ MAX_SUB_FRAME_LENGTH ];\r
@@ -59,17 +59,21 @@ void SKP_Silk_decode_core(
     rand_seed = psDec->indices.Seed;\r
     for( i = 0; i < psDec->frame_length; i++ ) {\r
         rand_seed = SKP_RAND( rand_seed );\r
-        /* dither = rand_seed < 0 ? 0xFFFFFFFF : 0; */\r
-        dither = SKP_RSHIFT( rand_seed, 31 );\r
-\r
-        psDec->exc_Q10[ i ] = SKP_LSHIFT( ( SKP_int32 )pulses[ i ], 10 ) + offset_Q10;\r
-        psDec->exc_Q10[ i ] = ( psDec->exc_Q10[ i ] ^ dither ) - dither;\r
+        psDec->exc_Q10[ i ] = SKP_LSHIFT( ( SKP_int32 )pulses[ i ], 10 );\r
+        if( psDec->exc_Q10[ i ] > 0 ) {\r
+            psDec->exc_Q10[ i ] -= QUANT_LEVEL_ADJUST_Q10;\r
+        } else \r
+        if( psDec->exc_Q10[ i ] < 0 ) {\r
+            psDec->exc_Q10[ i ] += QUANT_LEVEL_ADJUST_Q10;\r
+        }\r
+        psDec->exc_Q10[ i ] += offset_Q10;\r
+        psDec->exc_Q10[ i ] ^= SKP_RSHIFT( rand_seed, 31 );\r
 \r
         rand_seed += pulses[ i ];\r
     }\r
 \r
 #ifdef SAVE_ALL_INTERNAL_DATA\r
-    DEBUG_STORE_DATA( dec_q.dat, q, psDec->frame_length * sizeof( SKP_int ) );\r
+    DEBUG_STORE_DATA( dec_q.dat, pulses, psDec->frame_length * sizeof( SKP_int ) );\r
 #endif\r
 \r
     pexc_Q10 = psDec->exc_Q10;\r
index 95f7ebf..488bbd2 100644 (file)
@@ -37,7 +37,8 @@ void SKP_Silk_decode_indices(
 {\r
     SKP_int   i, k, Ix, condCoding;\r
     SKP_int   decode_absolute_lagIndex, delta_lagIndex;\r
-    const SKP_Silk_NLSF_CB_struct *psNLSF_CB = NULL;\r
+    SKP_int16 ec_ix[ MAX_LPC_ORDER ];\r
+    SKP_uint8 pred_Q8[ MAX_LPC_ORDER ];\r
 \r
     if( FrameIndex > 0 && ( decode_LBRR == 0 || psDec->LBRR_flags[ FrameIndex - 1 ] == 1 ) ) {\r
         condCoding = 1;\r
@@ -77,17 +78,20 @@ void SKP_Silk_decode_indices(
     /**********************/\r
     /* Decode LSF Indices */\r
     /**********************/\r
-    /* Set pointer to LSF VQ CB for the current signal type */\r
-    psNLSF_CB = psDec->psNLSF_CB[ 1 - ( psDec->indices.signalType >> 1 ) ];\r
-\r
-    /* Range decoding of the NLSF path */\r
-    for( i = 0; i < psNLSF_CB->nStages; i++ ) {\r
-        psDec->indices.NLSFIndices[ i ] = (SKP_int8)ec_dec_icdf( psRangeDec, psNLSF_CB->StartPtr[ i ], 8 );\r
+    psDec->indices.NLSFIndices[ 0 ] = (SKP_int8)ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->CB1_iCDF[ ( psDec->indices.signalType >> 1 ) * psDec->psNLSF_CB->nVectors ], 8 );\r
+    SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psDec->psNLSF_CB, psDec->indices.NLSFIndices[ 0 ] );\r
+    SKP_assert( psDec->psNLSF_CB->order == psDec->LPC_order );\r
+    for( i = 0; i < psDec->psNLSF_CB->order; i++ ) {\r
+        Ix = ec_dec_icdf( psRangeDec, &psDec->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
+        if( Ix == 0 ) {\r
+            Ix -= ec_dec_icdf( psRangeDec, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
+        } else if( Ix == 2 * NLSF_QUANT_MAX_AMPLITUDE ) {\r
+            Ix += ec_dec_icdf( psRangeDec, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
+        }\r
+        psDec->indices.NLSFIndices[ i+1 ] = (SKP_int8)( Ix - NLSF_QUANT_MAX_AMPLITUDE );\r
     }\r
-        \r
-    /***********************************/\r
+\r
     /* Decode LSF interpolation factor */\r
-    /***********************************/\r
     if( psDec->nb_subfr == MAX_NB_SUBFR ) {\r
         psDec->indices.NLSFInterpCoef_Q2 = (SKP_int8)ec_dec_icdf( psRangeDec, SKP_Silk_NLSF_interpolation_factor_iCDF, 8 );\r
     } else {\r
index 08157da..5ec8145 100644 (file)
@@ -34,9 +34,8 @@ void SKP_Silk_decode_parameters(
 )\r
 {\r
     SKP_int   i, k, Ix;\r
-    SKP_int   pNLSF_Q15[ MAX_LPC_ORDER ], pNLSF0_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16 pNLSF_Q15[ MAX_LPC_ORDER ], pNLSF0_Q15[ MAX_LPC_ORDER ];\r
     const SKP_int8 *cbk_ptr_Q7;\r
-    const SKP_Silk_NLSF_CB_struct *psNLSF_CB = NULL;\r
     \r
     /* Dequant Gains */\r
     SKP_Silk_gains_dequant( psDecCtrl->Gains_Q16, psDec->indices.GainsIndices, \r
@@ -45,11 +44,7 @@ void SKP_Silk_decode_parameters(
     /****************/\r
     /* Decode NLSFs */\r
     /****************/\r
-    /* Set pointer to NLSF VQ CB for the current signal type */\r
-    psNLSF_CB = psDec->psNLSF_CB[ 1 - (psDec->indices.signalType >> 1) ];\r
-\r
-    /* From the NLSF path, decode an NLSF vector */\r
-    SKP_Silk_NLSF_MSVQ_decode( pNLSF_Q15, psNLSF_CB, psDec->indices.NLSFIndices, psDec->LPC_order );\r
+    SKP_Silk_NLSF_decode( pNLSF_Q15, psDec->indices.NLSFIndices, psDec->psNLSF_CB );\r
 \r
     /* Convert NLSF parameters to AR prediction filter coefficients */\r
     SKP_Silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 1 ], pNLSF_Q15, psDec->LPC_order );\r
@@ -76,7 +71,7 @@ void SKP_Silk_decode_parameters(
             psDec->LPC_order * sizeof( SKP_int16 ) );\r
     }\r
 \r
-    SKP_memcpy( psDec->prevNLSF_Q15, pNLSF_Q15, psDec->LPC_order * sizeof( SKP_int ) );\r
+    SKP_memcpy( psDec->prevNLSF_Q15, pNLSF_Q15, psDec->LPC_order * sizeof( SKP_int16 ) );\r
 \r
     /* After a packet loss do BWE of LPC coefs */\r
     if( psDec->lossCnt ) {\r
index c12e629..7142efc 100644 (file)
@@ -35,6 +35,9 @@ void SKP_Silk_decoder_set_fs(
 {\r
     SKP_int frame_length;\r
     \r
+    SKP_assert( fs_kHz == 8 || fs_kHz == 12 || fs_kHz == 16 );\r
+    SKP_assert( psDec->nb_subfr == MAX_NB_SUBFR || psDec->nb_subfr == MAX_NB_SUBFR/2 );\r
+\r
     psDec->subfr_length = SKP_SMULBB( SUB_FRAME_LENGTH_MS, fs_kHz );\r
     frame_length = SKP_SMULBB( psDec->nb_subfr, psDec->subfr_length );\r
     if( psDec->fs_kHz != fs_kHz || frame_length != psDec->frame_length ) {\r
@@ -42,34 +45,30 @@ void SKP_Silk_decoder_set_fs(
         psDec->frame_length   = frame_length;\r
         psDec->ltp_mem_length = SKP_SMULBB( LTP_MEM_LENGTH_MS, fs_kHz );\r
         if( psDec->fs_kHz == 8 ) {\r
-            psDec->LPC_order = MIN_LPC_ORDER;\r
-            psDec->psNLSF_CB[ 0 ] = &SKP_Silk_NLSF_CB0_10;\r
-            psDec->psNLSF_CB[ 1 ] = &SKP_Silk_NLSF_CB1_10;\r
-            if( psDec->nb_subfr == MAX_NB_SUBFR ){\r
+            if( psDec->nb_subfr == MAX_NB_SUBFR ) {\r
                 psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_NB_iCDF; \r
-            } else if( psDec->nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_NB_iCDF;\r
             }\r
         } else {\r
-            psDec->LPC_order = MAX_LPC_ORDER;\r
-            psDec->psNLSF_CB[ 0 ] = &SKP_Silk_NLSF_CB0_16;\r
-            psDec->psNLSF_CB[ 1 ] = &SKP_Silk_NLSF_CB1_16;\r
-            if( psDec->nb_subfr == MAX_NB_SUBFR ){\r
+            if( psDec->nb_subfr == MAX_NB_SUBFR ) {\r
                 psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_iCDF; \r
-            } else if( psDec->nb_subfr == MAX_NB_SUBFR / 2 ){\r
-                psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             } else {\r
-                /* Unsupported number of frames */\r
-                SKP_assert( 0 );\r
+                psDec->pitch_contour_iCDF = SKP_Silk_pitch_contour_10_ms_iCDF;\r
             }\r
         }\r
+        if( psDec->fs_kHz == 8 || psDec->fs_kHz == 12 ) {\r
+            psDec->LPC_order = MIN_LPC_ORDER;\r
+            psDec->psNLSF_CB = &SKP_Silk_NLSF_CB_NB_MB;\r
+        } else {\r
+            psDec->LPC_order = MAX_LPC_ORDER;\r
+            psDec->psNLSF_CB = &SKP_Silk_NLSF_CB_WB;\r
+        }\r
+\r
         /* Reset part of the decoder state */\r
-        SKP_memset( psDec->sLPC_Q14,     0, MAX_LPC_ORDER      * sizeof( SKP_int32 ) );\r
-        SKP_memset( psDec->outBuf,       0, MAX_FRAME_LENGTH   * sizeof( SKP_int16 ) );\r
-        SKP_memset( psDec->prevNLSF_Q15, 0, MAX_LPC_ORDER      * sizeof( SKP_int )   );\r
+        SKP_memset( psDec->sLPC_Q14,     0,                    sizeof( psDec->sLPC_Q14 ) );\r
+        SKP_memset( psDec->outBuf,       0, MAX_FRAME_LENGTH * sizeof( SKP_int16 ) );\r
+        SKP_memset( psDec->prevNLSF_Q15, 0,                    sizeof( psDec->prevNLSF_Q15 ) );\r
 \r
         psDec->lagPrev                 = 100;\r
         psDec->LastGainIndex           = 10;\r
index 61bbcbd..04b1b1f 100644 (file)
@@ -49,26 +49,17 @@ extern "C"
 /* Limits on bitrate */\r
 #define MIN_TARGET_RATE_BPS                     5000\r
 #define MAX_TARGET_RATE_BPS                     80000\r
-\r
-/* Compensation in bitrate calculations for 10 ms modes */\r
-#define REDUCE_BITRATE_10_MS_BPS                2200\r
-\r
-/* Transition bitrates between modes */\r
-#define WB2MB_BITRATE_BPS                       12000\r
-#define MB2WB_BITRATE_BPS                       16000\r
-#define MB2NB_BITRATE_BPS                        9000\r
-#define NB2MB_BITRATE_BPS                       12000\r
 #define TARGET_RATE_TAB_SZ                      8\r
 \r
-/* DTX settings                                 */\r
-#define NO_SPEECH_FRAMES_BEFORE_DTX             5       /* eq 100 ms */\r
-#define MAX_CONSECUTIVE_DTX                     20      /* eq 400 ms */\r
-\r
 /* LBRR thresholds */\r
 #define LBRR_NB_MIN_RATE_BPS                    9000\r
 #define LBRR_MB_MIN_RATE_BPS                    12000\r
 #define LBRR_WB_MIN_RATE_BPS                    15000\r
 \r
+/* DTX settings                                 */\r
+#define NO_SPEECH_FRAMES_BEFORE_DTX             5       /* eq 100 ms */\r
+#define MAX_CONSECUTIVE_DTX                     20      /* eq 400 ms */\r
+\r
 /* Activate bandwidth transition filtering for mode switching */\r
 #define SWITCH_TRANSITION_FILTERING             1\r
 \r
@@ -130,6 +121,8 @@ extern "C"
 #define OFFSET_UVL_Q10                          100\r
 #define OFFSET_UVH_Q10                          240\r
 \r
+#define QUANT_LEVEL_ADJUST_Q10                  80\r
+\r
 /* Maximum numbers of iterations used to stabilize a LPC vector */\r
 #define MAX_LPC_STABILIZE_ITERATIONS            20\r
 \r
@@ -204,30 +197,13 @@ extern "C"
 /******************/\r
 /* NLSF quantizer */\r
 /******************/\r
-#define NLSF_MSVQ_MAX_CB_STAGES                      10 /* Update manually when changing codebooks      */\r
-#define NLSF_MSVQ_MAX_VECTORS_IN_STAGE               64 /* Update manually when changing codebooks      */\r
-#define NLSF_MSVQ_MAX_VECTORS_IN_STAGE_TWO_TO_END    16 /* Update manually when changing codebooks      */\r
-\r
-#define NLSF_MSVQ_FLUCTUATION_REDUCTION         1\r
-#define MAX_NLSF_MSVQ_SURVIVORS                 16\r
-\r
-#define NLSF_Q_DOMAIN_STAGE_0                   8\r
-#define NLSF_Q_DOMAIN_STAGE_2_TO_LAST           8\r
-\r
-/* Based on above defines, calculate how much memory is necessary to allocate */\r
-#if( NLSF_MSVQ_MAX_VECTORS_IN_STAGE > ( MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_VECTORS_IN_STAGE_TWO_TO_END ) )\r
-#   define NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED_LC_MODE  NLSF_MSVQ_MAX_VECTORS_IN_STAGE\r
-#else\r
-#   define NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED_LC_MODE  MAX_NLSF_MSVQ_SURVIVORS_LC_MODE * NLSF_MSVQ_MAX_VECTORS_IN_STAGE_TWO_TO_END\r
-#endif\r
-\r
-#if( NLSF_MSVQ_MAX_VECTORS_IN_STAGE > ( MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_VECTORS_IN_STAGE_TWO_TO_END ) )\r
-#   define NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED  NLSF_MSVQ_MAX_VECTORS_IN_STAGE\r
-#else\r
-#   define NLSF_MSVQ_TREE_SEARCH_MAX_VECTORS_EVALUATED  MAX_NLSF_MSVQ_SURVIVORS * NLSF_MSVQ_MAX_VECTORS_IN_STAGE_TWO_TO_END\r
-#endif\r
-\r
-#define NLSF_MSVQ_SURV_MAX_REL_RD               0.1f    /* Must be < 0.5                                    */\r
+#define NLSF_VQ_MAX_VECTORS                     32\r
+#define NLSF_VQ_MAX_SURVIVORS                   16\r
+#define NLSF_QUANT_MAX_AMPLITUDE                4\r
+#define NLSF_QUANT_MAX_AMPLITUDE_EXT            10\r
+#define NLSF_QUANT_LEVEL_ADJ                    0.1\r
+#define NLSF_QUANT_DEL_DEC_STATES_LOG2          2\r
+#define NLSF_QUANT_DEL_DEC_STATES               ( 1 << NLSF_QUANT_DEL_DEC_STATES_LOG2 )\r
 \r
 /* Transition filtering for mode switching */\r
 #if SWITCH_TRANSITION_FILTERING\r
index d2b6bac..d0e86c0 100644 (file)
@@ -183,76 +183,6 @@ SKP_int SKP_Silk_SDK_QueryEncoder(
     return ret;\r
 }\r
 \r
-/*****************************/\r
-/* Prefill look-ahead buffer */\r
-/*****************************/\r
-#define MAX_PREFILL_LENGTH_MS       10\r
-SKP_int SKP_Silk_SDK_Encoder_prefill_buffer( \r
-    void                                *encState,      /* I/O: State                                                       */\r
-    SKP_Silk_EncodeControlStruct        *encControl,    /* I:   Control structure                                           */\r
-    const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector  (last part will be used)        */\r
-    SKP_int                             nSamplesIn      /* I:   Number of samples in input vector                           */\r
-)\r
-{\r
-    SKP_int start_ix, offset, nSamples, ret;\r
-    SKP_Silk_encoder_state_Fxx *psEnc = ( SKP_Silk_encoder_state_Fxx* )encState;\r
-    SKP_int16 buf[ MAX_PREFILL_LENGTH_MS * MAX_FS_KHZ ];\r
-    const SKP_int16 *in_ptr;\r
-\r
-    ret = process_enc_control_struct( psEnc, encControl );\r
-\r
-    /* Compute some numbers at API sampling rate */\r
-    start_ix = nSamplesIn - SKP_DIV32_16( psEnc->sCmn.API_fs_Hz, 1000 / MAX_PREFILL_LENGTH_MS );     /* 10 ms */\r
-    if( start_ix < 0 ) {\r
-        offset = -start_ix;\r
-        start_ix = 0;\r
-    } else {\r
-        offset = 0;\r
-    }\r
-    nSamples = nSamplesIn - start_ix;\r
-\r
-    if( psEnc->sCmn.API_fs_Hz != SKP_SMULBB( 1000, psEnc->sCmn.fs_kHz ) ) { \r
-        /* resample input */\r
-        ret += SKP_Silk_resampler( &psEnc->sCmn.resampler_state, buf, samplesIn + start_ix, nSamples );\r
-        in_ptr = buf;\r
-        /* Convert to internal sampling rate */\r
-        offset   = SKP_DIV32( SKP_MUL( offset,   SKP_SMULBB( 1000, psEnc->sCmn.fs_kHz ) ), psEnc->sCmn.API_fs_Hz );\r
-        nSamples = SKP_DIV32( SKP_MUL( nSamples, SKP_SMULBB( 1000, psEnc->sCmn.fs_kHz ) ), psEnc->sCmn.API_fs_Hz );\r
-    } else {\r
-        in_ptr = samplesIn + start_ix;\r
-    }\r
-\r
-#if HIGH_PASS_INPUT\r
-    /* Variable high-pass filter */\r
-    SKP_Silk_HP_variable_cutoff( &psEnc->sCmn, buf, in_ptr, nSamples );\r
-#else\r
-    SKP_memcpy( buf, in_ptr, nSamples * sizeof( SKP_int16 ) );\r
-#endif\r
-\r
-#if SWITCH_TRANSITION_FILTERING\r
-    /* Ensure smooth bandwidth transitions */\r
-    SKP_Silk_LP_variable_cutoff( &psEnc->sCmn.sLP, buf, nSamples );\r
-#endif\r
-\r
-#if FIXED_POINT \r
-{\r
-    SKP_int16 *buf_ptr = psEnc->x_buf + psEnc->sCmn.ltp_mem_length + ( LA_SHAPE_MS - MAX_PREFILL_LENGTH_MS ) * psEnc->sCmn.fs_kHz + offset;\r
-    SKP_memcpy( buf_ptr, buf, nSamples * sizeof( SKP_int16 ) );\r
-}\r
-#else\r
-{\r
-    SKP_float *buf_ptr;\r
-    buf_ptr = psEnc->x_buf + psEnc->sCmn.ltp_mem_length + ( LA_SHAPE_MS - MAX_PREFILL_LENGTH_MS ) * psEnc->sCmn.fs_kHz + offset;\r
-    SKP_short2float_array( buf_ptr, buf, nSamples );\r
-}\r
-#endif\r
-\r
-    /* Avoid using LSF interpolation or pitch prediction in first next frame */\r
-    psEnc->sCmn.first_frame_after_reset = 1;\r
-\r
-    return ret;\r
-}\r
-\r
 /**************************/\r
 /* Encode frame with Silk */\r
 /**************************/\r
@@ -262,28 +192,47 @@ SKP_int SKP_Silk_SDK_Encode(
     const SKP_int16                     *samplesIn,     /* I:   Speech sample input vector                      */\r
     SKP_int                             nSamplesIn,     /* I:   Number of samples in input vector               */\r
     ec_enc                              *psRangeEnc,    /* I/O  Compressor data structure                       */\r
-    SKP_int32                           *nBytesOut      /* I/O: Number of bytes in payload (input: Max bytes)   */\r
+    SKP_int32                           *nBytesOut,     /* I/O: Number of bytes in payload (input: Max bytes)   */\r
+    const SKP_int                       prefillFlag     /* I:   Flag to indicate prefilling buffers no coding   */\r
 )\r
 {\r
-    SKP_int   ret;\r
-    SKP_int   nSamplesToBuffer, input_10ms, nSamplesFromInput = 0;\r
+    SKP_int   tmp_payloadSize_ms, tmp_complexity, ret = 0;\r
+    SKP_int   nSamplesToBuffer, nBlocksOf10ms, nSamplesFromInput = 0;\r
     SKP_Silk_encoder_state_Fxx *psEnc = ( SKP_Silk_encoder_state_Fxx* )encState;\r
 \r
     ret = process_enc_control_struct( psEnc, encControl );\r
 \r
-    /* Only accept input lengths that are a multiple of 10 ms */\r
-    input_10ms = SKP_DIV32( 100 * nSamplesIn, psEnc->sCmn.API_fs_Hz );\r
-    if( input_10ms * psEnc->sCmn.API_fs_Hz != 100 * nSamplesIn || nSamplesIn < 0 ) {\r
-        ret = SKP_SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
-        SKP_assert( 0 );\r
-        return( ret );\r
-    }\r
-\r
-    /* Make sure no more than one packet can be produced */\r
-    if( 1000 * (SKP_int32)nSamplesIn > psEnc->sCmn.PacketSize_ms * psEnc->sCmn.API_fs_Hz ) {\r
-        ret = SKP_SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
-        SKP_assert( 0 );\r
-        return( ret );\r
+    nBlocksOf10ms = SKP_DIV32( 100 * nSamplesIn, psEnc->sCmn.API_fs_Hz );\r
+    if( prefillFlag ) {\r
+        /* Only accept input length of 10 ms */\r
+        if( nBlocksOf10ms != 1 ) {\r
+            ret = SKP_SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
+            SKP_assert( 0 );\r
+            return( ret );\r
+        }\r
+        /* Reset Encoder */\r
+        if( ret = SKP_Silk_init_encoder_Fxx( psEnc ) ) {\r
+            SKP_assert( 0 );\r
+        }\r
+        tmp_payloadSize_ms = encControl->payloadSize_ms;\r
+        encControl->payloadSize_ms = 10;\r
+        tmp_complexity = encControl->complexity;\r
+        encControl->complexity = 0;\r
+        ret = process_enc_control_struct( psEnc, encControl );\r
+        psEnc->sCmn.prefillFlag = 1;\r
+    } else {\r
+        /* Only accept input lengths that are a multiple of 10 ms */\r
+        if( nBlocksOf10ms * psEnc->sCmn.API_fs_Hz != 100 * nSamplesIn || nSamplesIn < 0 ) {\r
+            ret = SKP_SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
+            SKP_assert( 0 );\r
+            return( ret );\r
+        }\r
+        /* Make sure no more than one packet can be produced */\r
+        if( 1000 * (SKP_int32)nSamplesIn > psEnc->sCmn.PacketSize_ms * psEnc->sCmn.API_fs_Hz ) {\r
+            ret = SKP_SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;\r
+            SKP_assert( 0 );\r
+            return( ret );\r
+        }\r
     }\r
 \r
     /* Input buffering/resampling and encoding */\r
@@ -295,7 +244,7 @@ SKP_int SKP_Silk_SDK_Encode(
             /* Copy to buffer */\r
             SKP_memcpy( &psEnc->sCmn.inputBuf[ psEnc->sCmn.inputBufIx ], samplesIn, nSamplesFromInput * sizeof( SKP_int16 ) );\r
         } else {  \r
-            nSamplesToBuffer  = SKP_min( nSamplesToBuffer, 10 * input_10ms * psEnc->sCmn.fs_kHz );\r
+            nSamplesToBuffer  = SKP_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->sCmn.fs_kHz );\r
             nSamplesFromInput = SKP_DIV32_16( nSamplesToBuffer * psEnc->sCmn.API_fs_Hz, psEnc->sCmn.fs_kHz * 1000 );\r
             /* Resample and write to buffer */\r
             ret += SKP_Silk_resampler( &psEnc->sCmn.resampler_state, &psEnc->sCmn.inputBuf[ psEnc->sCmn.inputBufIx ], samplesIn, nSamplesFromInput );\r
@@ -323,9 +272,11 @@ SKP_int SKP_Silk_SDK_Encode(
         }\r
     }\r
 \r
-    if( psEnc->sCmn.useDTX && psEnc->sCmn.inDTX ) {\r
-        /* DTX */\r
-        *nBytesOut = 0;\r
+    if( prefillFlag ) {\r
+        encControl->payloadSize_ms = tmp_payloadSize_ms;\r
+        encControl->complexity = tmp_complexity;\r
+        ret = process_enc_control_struct( psEnc, encControl );\r
+        psEnc->sCmn.prefillFlag = 0;\r
     }\r
 \r
     return ret;\r
index ebeb3bf..8962095 100644 (file)
@@ -39,8 +39,13 @@ void SKP_Silk_encode_indices(
 {\r
     SKP_int   i, k, condCoding, typeOffset;\r
     SKP_int   encode_absolute_lagIndex, delta_lagIndex;\r
-    const SKP_Silk_NLSF_CB_struct *psNLSF_CB;\r
+    SKP_int16 ec_ix[ MAX_LPC_ORDER ];\r
+    SKP_uint8 pred_Q8[ MAX_LPC_ORDER ];\r
     const SideInfoIndices *psIndices;\r
+#if SAVE_ALL_INTERNAL_DATA\r
+    SKP_int nBytes_lagIndex, nBytes_contourIndex, nBytes_LTP;\r
+    SKP_int nBytes_after, nBytes_before;\r
+#endif\r
 \r
     if( FrameIndex > 0 && ( encode_LBRR == 0 || psEncC->LBRR_flags[ FrameIndex - 1 ] == 1 ) ) {\r
         condCoding = 1;\r
@@ -54,11 +59,6 @@ void SKP_Silk_encode_indices(
          psIndices = &psEncC->indices;\r
     }\r
 \r
-#ifdef SAVE_ALL_INTERNAL_DATA\r
-    SKP_int nBytes_lagIndex, nBytes_contourIndex, nBytes_LTP;\r
-    SKP_int nBytes_after, nBytes_before;\r
-#endif\r
-\r
     /*******************************************/\r
     /* Encode signal type and quantizer offset */\r
     /*******************************************/\r
@@ -107,22 +107,30 @@ void SKP_Silk_encode_indices(
 #ifdef SAVE_ALL_INTERNAL_DATA\r
     nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
 #endif\r
-    /* Range encoding of the NLSF path */\r
-    psNLSF_CB = psEncC->psNLSF_CB[ 1 - ( psIndices->signalType >> 1 ) ];\r
-    for( i = 0; i < psNLSF_CB->nStages; i++ ) {\r
-        SKP_assert( 0 <= psIndices->NLSFIndices[ i ] && psIndices->NLSFIndices[ i ] < psNLSF_CB->CBStages[ i ].nVectors );\r
-        ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ i ], psNLSF_CB->StartPtr[ i ], 8 );\r
+    ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ 0 ], &psEncC->psNLSF_CB->CB1_iCDF[ ( psIndices->signalType >> 1 ) * psEncC->psNLSF_CB->nVectors ], 8 );\r
+    SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psEncC->psNLSF_CB, psIndices->NLSFIndices[ 0 ] );\r
+    SKP_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder );\r
+    for( i = 0; i < psEncC->psNLSF_CB->order; i++ ) {\r
+        if( psIndices->NLSFIndices[ i+1 ] >= NLSF_QUANT_MAX_AMPLITUDE ) {\r
+            ec_enc_icdf( psRangeEnc, 2 * NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
+            ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ i+1 ] - NLSF_QUANT_MAX_AMPLITUDE, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
+        } else if( psIndices->NLSFIndices[ i+1 ] <= -NLSF_QUANT_MAX_AMPLITUDE ) {\r
+            ec_enc_icdf( psRangeEnc, 0, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
+            ec_enc_icdf( psRangeEnc, -psIndices->NLSFIndices[ i+1 ] - NLSF_QUANT_MAX_AMPLITUDE, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
+        } else {\r
+            ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ i+1 ] + NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
+        }\r
     }\r
 \r
+    /* Encode NLSF interpolation factor */\r
     if( psEncC->nb_subfr == MAX_NB_SUBFR ) {\r
-        /* Encode NLSF interpolation factor */\r
         SKP_assert( psEncC->useInterpolatedNLSFs == 1 || psIndices->NLSFInterpCoef_Q2 == ( 1 << 2 ) );\r
         SKP_assert( psIndices->NLSFInterpCoef_Q2 >= 0 && psIndices->NLSFInterpCoef_Q2 < 5 );\r
         ec_enc_icdf( psRangeEnc, psIndices->NLSFInterpCoef_Q2, SKP_Silk_NLSF_interpolation_factor_iCDF, 8 );\r
     }\r
 \r
 #ifdef SAVE_ALL_INTERNAL_DATA\r
-    DEBUG_STORE_DATA( lsf_interpol.dat, &psEncCtrlC->NLSFInterpCoef_Q2, sizeof(int) );\r
+    DEBUG_STORE_DATA( lsf_interpol.dat, &psIndices->NLSFInterpCoef_Q2, sizeof(int) );\r
     nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
     nBytes_after -= nBytes_before; // bytes just added\r
     DEBUG_STORE_DATA( nBytes_LSF.dat, &nBytes_after, sizeof( SKP_int ) );\r
index 73d0eca..aee9eff 100644 (file)
@@ -29,9 +29,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 /* Interpolate two vectors */\r
 void SKP_Silk_interpolate(\r
-    SKP_int                         xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
-    const SKP_int                   x0[ MAX_LPC_ORDER ],    /* I    first vector                            */\r
-    const SKP_int                   x1[ MAX_LPC_ORDER ],    /* I    second vector                           */\r
+    SKP_int16                       xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
+    const SKP_int16                 x0[ MAX_LPC_ORDER ],    /* I    first vector                            */\r
+    const SKP_int16                 x1[ MAX_LPC_ORDER ],    /* I    second vector                           */\r
     const SKP_int                   ifact_Q2,               /* I    interp. factor, weight on 2nd vector    */\r
     const SKP_int                   d                       /* I    number of parameters                    */\r
 )\r
@@ -42,6 +42,6 @@ void SKP_Silk_interpolate(
     SKP_assert( ifact_Q2 <= 4 );\r
 \r
     for( i = 0; i < d; i++ ) {\r
-        xi[ i ] = ( SKP_int )( ( SKP_int32 )x0[ i ] + SKP_RSHIFT( SKP_MUL( ( SKP_int32 )x1[ i ] - ( SKP_int32 )x0[ i ], ifact_Q2 ), 2 ) );\r
+        xi[ i ] = ( SKP_int16 )SKP_ADD_RSHIFT( x0[ i ], SKP_SMULBB( x1[ i ] - x0[ i ], ifact_Q2 ), 2 );\r
     }\r
 }\r
index 95252ea..9f1eee4 100644 (file)
@@ -122,17 +122,17 @@ void SKP_Silk_gains_dequant(
 /* Convert NLSF parameters to stable AR prediction filter coefficients */\r
 void SKP_Silk_NLSF2A_stable(\r
     SKP_int16                   pAR_Q12[ MAX_LPC_ORDER ],   /* O    Stabilized AR coefs [LPC_order]     */ \r
-    const SKP_int               pNLSF[ MAX_LPC_ORDER ],     /* I    NLSF vector         [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 SKP_Silk_interpolate(\r
-    SKP_int                     xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
-    const SKP_int               x0[ MAX_LPC_ORDER ],    /* I    first vector                            */\r
-    const SKP_int               x1[ MAX_LPC_ORDER ],    /* I    second vector                           */\r
-    const SKP_int               ifact_Q2,               /* I    interp. factor, weight on 2nd vector    */\r
-    const SKP_int               d                       /* I    number of parameters                    */\r
+    SKP_int16                       xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
+    const SKP_int16                 x0[ MAX_LPC_ORDER ],    /* I    first vector                            */\r
+    const SKP_int16                 x1[ MAX_LPC_ORDER ],    /* I    second vector                           */\r
+    const SKP_int                   ifact_Q2,               /* I    interp. factor, weight on 2nd vector    */\r
+    const SKP_int                   d                       /* I    number of parameters                    */\r
 );\r
 \r
 /* LTP tap quantizer */\r
@@ -232,7 +232,7 @@ void SKP_Silk_HP_variable_cutoff(
 /* Start by setting transition_frame_no = 1;                */\r
 void SKP_Silk_LP_variable_cutoff(\r
     SKP_Silk_LP_state           *psLP,              /* I/O  LP filter state                             */\r
-    SKP_int16                       *signal,        /* I/O  Low-pass filtered output signal     */\r
+    SKP_int16                   *signal,            /* I/O  Low-pass filtered output signal             */\r
     const SKP_int               frame_length        /* I    Frame length                                */\r
 );\r
 #endif\r
@@ -246,51 +246,62 @@ void SKP_Silk_LBRR_embed(
 /******************/\r
 /* NLSF Quantizer */\r
 /******************/\r
-/* Limit, stabilize, convert and quantize NLSFs.    */ \r
+/* Limit, stabilize, convert and quantize NLSFs */ \r
 void SKP_Silk_process_NLSFs(\r
     SKP_Silk_encoder_state          *psEncC,                                /* I/O  Encoder state                               */\r
     SKP_int16                       PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int                         pNLSF_Q15[         MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int                   prev_NLSFq_Q15[    MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    SKP_int16                       pNLSF_Q15[         MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const SKP_int16                 prev_NLSFq_Q15[    MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 );\r
 \r
-/* NLSF vector encoder */\r
-void SKP_Silk_NLSF_MSVQ_encode(\r
-          SKP_int8                  *NLSFIndices,           /* O    Codebook path vector [ CB_STAGES ]      */\r
-          SKP_int                   *pNLSF_Q15,             /* I/O  Quantized NLSF vector [ LPC_ORDER ]     */\r
+SKP_int32 SKP_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 SKP_Silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
-    const SKP_int                   *pNLSF_q_Q15_prev,      /* I    Prev. quantized NLSF vector [LPC_ORDER] */\r
-    const SKP_int                   *pW_Q5,                 /* I    NLSF weight vector [ LPC_ORDER ]        */\r
-    const SKP_int                   NLSF_mu_Q15,            /* I    Rate weight for the RD optimization     */\r
-    const SKP_int                   NLSF_mu_fluc_red_Q16,   /* I    Fluctuation reduction error weight      */\r
-    const SKP_int                   NLSF_MSVQ_Survivors,    /* I    Max survivors from each stage           */\r
-    const SKP_int                   LPC_order,              /* I    LPC order                               */\r
-    const SKP_int                   deactivate_fluc_red     /* I    Deactivate fluctuation reduction        */\r
-);\r
-\r
-/* Rate-Distortion calculations for multiple input data vectors */\r
-void SKP_Silk_NLSF_VQ_rate_distortion(\r
-    SKP_int32                       *pRD_Q19,           /* O    Rate-distortion values [psNLSF_CBS->nVectors*N] */\r
-    const SKP_Silk_NLSF_CBS         *psNLSF_CBS,        /* I    NLSF codebook stage struct                      */\r
-    const SKP_int16                 *in_Q15,            /* I    Input vectors to be quantized                   */\r
-    const SKP_int                   *w_Q5,              /* I    Weight vector                                   */\r
-    const SKP_int32                 *rate_acc_Q4,       /* I    Accumulated rates from previous stage           */\r
-    const SKP_int                   mu_Q15,             /* I    Weight between weighted error and rate          */\r
-    const SKP_int                   N,                  /* I    Number of input vectors to be quantized         */\r
-    const SKP_int                   stage,              /* I    Stage number                                    */\r
-    const SKP_int                   LPC_order           /* I    LPC order                                       */\r
-);\r
-\r
-/* Compute weighted quantization errors for an LPC_order element input vector, over one codebook stage */\r
-void SKP_Silk_NLSF_VQ_sum_error(\r
-    SKP_int32                       *err_Q19,           /* O    Weighted quantization errors  [N*K]         */\r
-    const SKP_int16                 *in_Q15,            /* I    Input vectors to be quantized [N*LPC_order] */\r
-    const SKP_int                   *w_Q5,              /* I    Weighting vectors             [N*LPC_order] */\r
-    const SKP_int8                  *pCB_Q9,            /* I    Codebook vectors              [K*LPC_order] */\r
-    const SKP_int                   N,                  /* I    Number of input vectors                     */\r
-    const SKP_int                   K,                  /* I    Number of codebook vectors                  */\r
-    const SKP_int                   stage,              /* I    Stage number                                */\r
-    const SKP_int                   LPC_order           /* I    Number of LPCs                              */\r
+    const SKP_int16                 *pW_Q5,                 /* 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
+);\r
+\r
+/* Compute quantization errors for an LPC_order element input vector for a VQ codebook */\r
+void SKP_Silk_NLSF_VQ(\r
+    SKP_int32                   err_Q26[],              /* O    Quantization errors [K]                     */\r
+    const SKP_int16             in_Q15[],               /* I    Input vectors to be quantized [LPC_order]   */\r
+    const SKP_uint8             pCB_Q8[],               /* I    Codebook vectors [K*LPC_order]              */\r
+    const SKP_int               K,                      /* I    Number of codebook vectors                  */\r
+    const SKP_int               LPC_order               /* I    Number of LPCs                              */\r
+);\r
+\r
+/* Delayed-decision quantizer for NLSF residuals */\r
+SKP_int32 SKP_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
+    const SKP_uint8             pred_coef_Q8[],         /* I    Backward predictor coefs [ order ]          */\r
+    const SKP_int16             ec_ix[],                /* I    Indices to entropy coding tables [ order ]  */\r
+    const SKP_uint8             ec_rates_Q5[],          /* I    Rates []                                    */\r
+    const SKP_int               quant_step_size_Q16,    /* I    Quantization step size                      */\r
+    const SKP_int16             inv_quant_step_size_Q6, /* I    Inverse quantization step size              */\r
+    const SKP_int32             mu_Q20,                 /* I    R/D tradeoff                                */\r
+    const SKP_int16             order                   /* I    Number of input values                      */\r
+);\r
+\r
+/* Unpack predictor values and indices for entropy coding tables */\r
+void SKP_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
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB,             /* I    Codebook object                         */\r
+    const SKP_int                   CB1_index               /* I    Index of vector in first LSF codebook   */\r
+);\r
+\r
+/***********************/\r
+/* NLSF vector decoder */\r
+/***********************/\r
+void SKP_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
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB              /* I    Codebook object                         */\r
 );\r
 \r
 /****************************************************/\r
@@ -326,7 +337,7 @@ SKP_int SKP_Silk_decode_frame(
     SKP_int                     lostFlag            /* I    0: no loss, 1 loss, 2 decode fec            */\r
 );\r
 \r
-/* Decode LBRR side info and excitation    */\r
+/* Decode LBRR side info and excitation */\r
 void SKP_Silk_LBRR_extract(\r
     SKP_Silk_decoder_state      *psDec,             /* I/O  State                                       */\r
     ec_dec                      *psRangeDec         /* I/O  Compressor data structure                   */\r
@@ -354,14 +365,6 @@ void SKP_Silk_decode_core(
     const SKP_int               pulses[ MAX_FRAME_LENGTH ]          /* I    Pulse signal                */\r
 );\r
 \r
-/* NLSF vector decoder */\r
-void SKP_Silk_NLSF_MSVQ_decode(\r
-    SKP_int                         *pNLSF_Q15,     /* O    Pointer to decoded output [LPC_ORDER x 1]   */\r
-    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB,     /* I    Pointer to NLSF codebook struct             */\r
-    const SKP_int8                  *NLSFIndices,   /* I    Pointer to NLSF indices [nStages x 1]       */\r
-    const SKP_int                   LPC_order       /* I    LPC order                                   */\r
-);\r
-\r
 /* Decode quantization indices of excitation (Shell coding) */\r
 void SKP_Silk_decode_pulses(\r
     ec_dec                          *psRangeDec,        /* I/O  Compressor data structure                   */\r
@@ -380,7 +383,7 @@ void SKP_Silk_CNG_Reset(
     SKP_Silk_decoder_state      *psDec              /* I/O  Decoder state                               */\r
 );\r
 \r
-/* Updates CNG estimate, and applies the CNG when packet was lost   */\r
+/* Updates CNG estimate, and applies the CNG when packet was lost */\r
 void SKP_Silk_CNG(\r
     SKP_Silk_decoder_state      *psDec,             /* I/O  Decoder state                               */\r
     SKP_Silk_decoder_control    *psDecCtrl,         /* I/O  Decoder control                             */\r
index 6c3c931..229709f 100644 (file)
@@ -27,21 +27,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 #include "SKP_Silk_main.h"\r
 \r
-/* Limit, stabilize, convert and quantize NLSFs.    */ \r
+/* Limit, stabilize, convert and quantize NLSFs */ \r
 void SKP_Silk_process_NLSFs(\r
     SKP_Silk_encoder_state          *psEncC,                                /* I/O  Encoder state                               */\r
     SKP_int16                       PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
-    SKP_int                         pNLSF_Q15[         MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
-    const SKP_int                   prev_NLSFq_Q15[    MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
+    SKP_int16                       pNLSF_Q15[         MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
+    const SKP_int16                 prev_NLSFq_Q15[    MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
 )\r
 {\r
     SKP_int     i, doInterpolate;\r
-    SKP_int     pNLSFW_Q5[ MAX_LPC_ORDER ];\r
-    SKP_int     NLSF_mu_Q15, NLSF_mu_fluc_red_Q16;\r
+    SKP_int16   pNLSFW_Q5[ MAX_LPC_ORDER ];\r
+    SKP_int     NLSF_mu_Q20;\r
     SKP_int32   i_sqr_Q15;\r
-    SKP_int     pNLSF0_temp_Q15[ MAX_LPC_ORDER ];\r
-    SKP_int     pNLSFW0_temp_Q5[ MAX_LPC_ORDER ];\r
-    const SKP_Silk_NLSF_CB_struct *psNLSF_CB;\r
+    SKP_int16   pNLSF0_temp_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16   pNLSFW0_temp_Q5[ MAX_LPC_ORDER ];\r
 \r
     SKP_assert( psEncC->speech_activity_Q8 >=   0 );\r
     SKP_assert( psEncC->speech_activity_Q8 <= SKP_FIX_CONST( 1.0, 8 ) );\r
@@ -49,23 +48,11 @@ void SKP_Silk_process_NLSFs(
     /***********************/\r
     /* Calculate mu values */\r
     /***********************/\r
-    if( psEncC->indices.signalType == TYPE_VOICED ) {\r
-        /* NLSF_mu           = 0.002f - 0.001f * psEnc->speech_activity; */\r
-        /* NLSF_mu_fluc_red  = 0.1f   - 0.05f  * psEnc->speech_activity; */\r
-        NLSF_mu_Q15          = SKP_SMLAWB( SKP_FIX_CONST( 0.002, 15 ), SKP_FIX_CONST( -0.001, 23 ), psEncC->speech_activity_Q8 );\r
-        NLSF_mu_fluc_red_Q16 = SKP_SMLAWB( SKP_FIX_CONST( 0.1,   16 ), SKP_FIX_CONST( -0.05,  24 ), psEncC->speech_activity_Q8 );\r
-    } else { \r
-        /* NLSF_mu           = 0.005f - 0.004f * psEnc->speech_activity; */\r
-        /* NLSF_mu_fluc_red  = 0.2f   - 0.1f   * psEnc->speech_activity - 0.1f * psEncCtrl->sparseness; */\r
-        NLSF_mu_Q15          = SKP_SMLAWB( SKP_FIX_CONST( 0.005, 15 ), SKP_FIX_CONST( -0.004, 23 ), psEncC->speech_activity_Q8 );\r
-        NLSF_mu_fluc_red_Q16 = SKP_SMLAWB( SKP_FIX_CONST( 0.15,  16 ), SKP_FIX_CONST( -0.1,   24 ), psEncC->speech_activity_Q8 ); \r
-    }\r
-    SKP_assert( NLSF_mu_Q15          >= 0 );\r
-    SKP_assert( NLSF_mu_Q15          <= SKP_FIX_CONST( 0.005, 15 ) );\r
-    SKP_assert( NLSF_mu_fluc_red_Q16 >= 0 );\r
-    SKP_assert( NLSF_mu_fluc_red_Q16 <= SKP_FIX_CONST( 0.15, 16 ) );\r
+    /* NLSF_mu  = 0.003 - 0.0015 * psEnc->speech_activity; */\r
+    NLSF_mu_Q20 = SKP_SMLAWB( SKP_FIX_CONST( 0.003, 20 ), SKP_FIX_CONST( -0.0015, 28 ), psEncC->speech_activity_Q8 );\r
 \r
-    NLSF_mu_Q15 = SKP_max( NLSF_mu_Q15, 1 );\r
+    SKP_assert( NLSF_mu_Q20 >  0 );\r
+    SKP_assert( NLSF_mu_Q20 <= SKP_FIX_CONST( 0.003, 20 ) );\r
 \r
     /* Calculate NLSF weights */\r
     SKP_Silk_NLSF_VQ_weights_laroia( pNLSFW_Q5, pNLSF_Q15, psEncC->predictLPCOrder );\r
@@ -89,14 +76,10 @@ void SKP_Silk_process_NLSFs(
         }\r
     }\r
 \r
-    /* Set pointer to the NLSF codebook for the current signal type and LPC order */\r
-    psNLSF_CB = psEncC->psNLSF_CB[ 1 - ( psEncC->indices.signalType >> 1 ) ];\r
-\r
-    /* Quantize NLSF parameters given the trained NLSF codebooks */\r
-    TIC(MSVQ_encode_FIX)\r
-    SKP_Silk_NLSF_MSVQ_encode( psEncC->indices.NLSFIndices, pNLSF_Q15, psNLSF_CB, prev_NLSFq_Q15, pNLSFW_Q5, NLSF_mu_Q15, \r
-        NLSF_mu_fluc_red_Q16, psEncC->NLSF_MSVQ_Survivors, psEncC->predictLPCOrder, psEncC->first_frame_after_reset );\r
-    TOC(MSVQ_encode_FIX)\r
+    TIC(NLSF_encode)\r
+    SKP_Silk_NLSF_encode( psEncC->indices.NLSFIndices, pNLSF_Q15, psEncC->psNLSF_CB, pNLSFW_Q5, \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
     SKP_Silk_NLSF2A_stable( PredCoef_Q12[ 1 ], pNLSF_Q15, psEncC->predictLPCOrder );\r
index d1233cd..4017e23 100644 (file)
@@ -105,7 +105,7 @@ SKP_INLINE SKP_int SKP_Silk_setup_complexity(
     SKP_assert( psEncC->warping_Q16             <= 32767                    );\r
     SKP_assert( psEncC->la_shape                <= LA_SHAPE_MAX             );\r
     SKP_assert( psEncC->shapeWinLength          <= SHAPE_LPC_WIN_MAX        );\r
-    SKP_assert( psEncC->NLSF_MSVQ_Survivors     <= MAX_NLSF_MSVQ_SURVIVORS  );\r
+    SKP_assert( psEncC->NLSF_MSVQ_Survivors     <= NLSF_VQ_MAX_SURVIVORS    );\r
 \r
     return( ret );\r
 }\r
index 1bcd108..c001687 100644 (file)
@@ -28,6 +28,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef SKP_SILK_STRUCTS_H\r
 #define SKP_SILK_STRUCTS_H\r
 \r
+#include "config.h"\r
+\r
 #include "SKP_Silk_typedef.h"\r
 #include "SKP_Silk_SigProc_FIX.h"\r
 #include "SKP_Silk_define.h"\r
@@ -79,29 +81,25 @@ typedef struct {
     SKP_int                     mode;                       /* Operating mode, <0: switch down, >0: switch up; 0: do nothing */\r
 } SKP_Silk_LP_state;\r
 \r
-/* Structure for one stage of MSVQ */\r
-typedef struct {\r
-    const SKP_int32             nVectors;\r
-    const SKP_int8              *CB_NLSF_Q8;\r
-    const SKP_uint8             *Rates_Q4;\r
-} SKP_Silk_NLSF_CBS;\r
-\r
-/* Structure containing NLSF MSVQ codebook */\r
+/* Structure containing NLSF codebook */\r
 typedef struct {\r
-    const SKP_int32             nStages;\r
-\r
-    /* Fields for (de)quantizing */\r
-    const SKP_Silk_NLSF_CBS     *CBStages;\r
-    const SKP_int               *NDeltaMin_Q15;\r
-\r
-    /* Fields for range (de)coding */\r
-    const SKP_uint8 * const     *StartPtr;\r
+    const SKP_int16             nVectors;\r
+    const SKP_int16             order;\r
+    const SKP_int16             quantStepSize_Q16;\r
+    const SKP_int16             invQuantStepSize_Q6;\r
+    const SKP_uint8             *CB1_NLSF_Q8;\r
+    const SKP_uint8             *CB1_iCDF;\r
+    const SKP_uint8             *pred_Q8;\r
+    const SKP_uint8             *ec_sel;\r
+    const SKP_uint8             *ec_iCDF;\r
+    const SKP_uint8             *ec_Rates_Q5;\r
+    const SKP_int16             *deltaMin_Q15;\r
 } SKP_Silk_NLSF_CB_struct;\r
 \r
 typedef struct {\r
     SKP_int8        GainsIndices[ MAX_NB_SUBFR ];\r
     SKP_int8        LTPIndex[ MAX_NB_SUBFR ];\r
-    SKP_int8        NLSFIndices[ NLSF_MSVQ_MAX_CB_STAGES ];\r
+    SKP_int8        NLSFIndices[ MAX_LPC_ORDER + 1 ];\r
     SKP_int16       lagIndex;\r
     SKP_int8        contourIndex;\r
     SKP_int8        signalType;\r
@@ -116,15 +114,13 @@ typedef struct {
 /* Encoder state                */\r
 /********************************/\r
 typedef struct {\r
-#if HIGH_PASS_INPUT\r
     SKP_int32                       In_HP_State[ 2 ];               /* High pass filter state                                               */\r
     SKP_int32                       variable_HP_smth1_Q15;          /* State of first smoother                                              */\r
     SKP_int32                       variable_HP_smth2_Q15;          /* State of second smoother                                             */\r
-#endif\r
     SKP_Silk_LP_state               sLP;                            /* Low pass filter state                                                */\r
     SKP_Silk_VAD_state              sVAD;                           /* Voice activity detector state                                        */\r
     SKP_Silk_nsq_state              sNSQ;                           /* Noise Shape Quantizer State                                          */\r
-    SKP_int                         prev_NLSFq_Q15[ MAX_LPC_ORDER ];/* Previously quantized NLSF vector                                     */\r
+    SKP_int16                       prev_NLSFq_Q15[ MAX_LPC_ORDER ];/* Previously quantized NLSF vector                                     */\r
     SKP_int                         speech_activity_Q8;             /* Speech activity                                                      */\r
     SKP_int8                        LBRRprevLastGainIndex;\r
     SKP_int8                        prevSignalType;\r
@@ -163,9 +159,10 @@ typedef struct {
        SKP_int                         warping_Q16;                    /* Warping parameter for warped noise shaping                           */\r
     SKP_int                         useCBR;                         /* Flag to enable constant bitrate                                      */\r
     SKP_int                         prev_nBits;                     /* Use to track bits used by each frame in packet                       */\r
+    SKP_int                         prefillFlag;                    /* Flag to indicate that only buffers are prefilled, no coding          */\r
     const SKP_uint8                 *pitch_lag_low_bits_iCDF;       /* Pointer to iCDF table for low bits of pitch lag index                */\r
     const SKP_uint8                 *pitch_contour_iCDF;            /* Pointer to iCDF table for pitch contour index                        */\r
-    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB[ 2 ];                /* Pointers to voiced/unvoiced NLSF codebooks                           */\r
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB;                     /* Pointer to NLSF codebook                                             */\r
     SKP_int                         input_quality_bands_Q15[ VAD_N_BANDS ];\r
     SKP_int                         input_tilt_Q15;\r
 \r
@@ -223,7 +220,7 @@ typedef struct {
 /* Struct for CNG */\r
 typedef struct {\r
     SKP_int32   CNG_exc_buf_Q10[ MAX_FRAME_LENGTH ];\r
-    SKP_int     CNG_smth_NLSF_Q15[ MAX_LPC_ORDER ];\r
+    SKP_int16   CNG_smth_NLSF_Q15[ MAX_LPC_ORDER ];\r
     SKP_int32   CNG_synth_state[ MAX_LPC_ORDER ];\r
     SKP_int32   CNG_smth_Gain_Q16;\r
     SKP_int32   rand_seed;\r
@@ -251,7 +248,7 @@ typedef struct {
     SKP_int         subfr_length;                               /* Subframe length (samples)                                            */\r
     SKP_int         ltp_mem_length;                             /* Length of LTP memory                                                 */\r
     SKP_int         LPC_order;                                  /* LPC order                                                            */\r
-    SKP_int         prevNLSF_Q15[ MAX_LPC_ORDER ];              /* Used to interpolate LSFs                                             */\r
+    SKP_int16       prevNLSF_Q15[ MAX_LPC_ORDER ];              /* Used to interpolate LSFs                                             */\r
     SKP_int         first_frame_after_reset;                    /* Flag for deactivating NLSF interp. and fluc. reduction after resets  */\r
     const SKP_uint8 *pitch_lag_low_bits_iCDF;                   /* Pointer to iCDF table for low bits of pitch lag index                */\r
     const SKP_uint8 *pitch_contour_iCDF;                        /* Pointer to iCDF table for pitch contour index                        */\r
@@ -270,7 +267,7 @@ typedef struct {
 \r
     SKP_Silk_resampler_state_struct resampler_state;\r
 \r
-    const SKP_Silk_NLSF_CB_struct *psNLSF_CB[ 2 ];      /* Pointers to voiced/unvoiced NLSF codebooks */\r
+    const SKP_Silk_NLSF_CB_struct   *psNLSF_CB;                 /* Pointer to NLSF codebook                                             */\r
 \r
     /* Quantization indices */\r
     SideInfoIndices indices;\r
index 6764472..c15c305 100644 (file)
@@ -73,6 +73,8 @@ extern const SKP_uint8  SKP_Silk_uniform4_iCDF[   4 ];
 extern const SKP_uint8  SKP_Silk_uniform6_iCDF[   6 ];                                              /*   6 */\r
 extern const SKP_uint8  SKP_Silk_uniform8_iCDF[   8 ];                                              /*   8 */\r
 \r
+extern const SKP_uint8 SKP_Silk_NLSF_EXT_iCDF[ 7 ];                                                 /*   7 */\r
+\r
 extern const SKP_uint8  SKP_Silk_LTP_per_index_iCDF[ 3 ];                                           /*   3 */\r
 extern const SKP_uint8  * const SKP_Silk_LTP_gain_iCDF_ptrs[ NB_LTP_CBKS ];                         /*   3 */\r
 extern const SKP_uint8  * const SKP_Silk_LTP_gain_BITS_Q5_ptrs[ NB_LTP_CBKS ];                      /*   3 */\r
@@ -90,9 +92,8 @@ extern const SKP_uint8 * const SKP_Silk_LBRR_flags_iCDF_ptr[2];
 \r
 extern const SKP_uint8  SKP_Silk_NLSF_interpolation_factor_iCDF[ 5 ];                               /*   5 */\r
 \r
-/* NLSF codebooks */\r
-extern const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB0_16, SKP_Silk_NLSF_CB1_16;\r
-extern const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB0_10, SKP_Silk_NLSF_CB1_10;\r
+extern const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB_WB;\r
+extern const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB_NB_MB;\r
 \r
 /* Piece-wise linear mapping from bitrate in kbps to coding quality in dB SNR */\r
 extern const SKP_int32  TargetRate_table_NB[  TARGET_RATE_TAB_SZ ];\r
diff --git a/src_common/SKP_Silk_tables_NLSF_CB_NB_MB.c b/src_common/SKP_Silk_tables_NLSF_CB_NB_MB.c
new file mode 100644 (file)
index 0000000..48a84ae
--- /dev/null
@@ -0,0 +1,155 @@
+/***********************************************************************\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 "SKP_Silk_structs.h"\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB1_NB_MB_Q8[ 320 ] = {\r
+           12,     35,     60,     83,    108,    132,    157,    180,\r
+          206,    228,     15,     32,     55,     77,    101,    125,\r
+          151,    175,    201,    225,     19,     42,     66,     89,\r
+          114,    137,    162,    184,    209,    230,     12,     25,\r
+           50,     72,     97,    120,    147,    172,    200,    223,\r
+           26,     44,     69,     90,    114,    135,    159,    180,\r
+          205,    225,     13,     22,     53,     80,    106,    130,\r
+          156,    180,    205,    228,     15,     25,     44,     64,\r
+           90,    115,    142,    168,    196,    222,     19,     24,\r
+           62,     82,    100,    120,    145,    168,    190,    214,\r
+           22,     31,     50,     79,    103,    120,    151,    170,\r
+          203,    227,     21,     29,     45,     65,    106,    124,\r
+          150,    171,    196,    224,     30,     49,     75,     97,\r
+          121,    142,    165,    186,    209,    229,     19,     25,\r
+           52,     70,     93,    116,    143,    166,    192,    219,\r
+           26,     34,     62,     75,     97,    118,    145,    167,\r
+          194,    217,     25,     33,     56,     70,     91,    113,\r
+          143,    165,    196,    223,     21,     34,     51,     72,\r
+           97,    117,    145,    171,    196,    222,     20,     29,\r
+           50,     67,     90,    117,    144,    168,    197,    221,\r
+           22,     31,     48,     66,     95,    117,    146,    168,\r
+          196,    222,     24,     33,     51,     77,    116,    134,\r
+          158,    180,    200,    224,     21,     28,     70,     87,\r
+          106,    124,    149,    170,    194,    217,     26,     33,\r
+           53,     64,     83,    117,    152,    173,    204,    225,\r
+           27,     34,     65,     95,    108,    129,    155,    174,\r
+          210,    225,     20,     26,     72,     99,    113,    131,\r
+          154,    176,    200,    219,     34,     43,     61,     78,\r
+           93,    114,    155,    177,    205,    229,     23,     29,\r
+           54,     97,    124,    138,    163,    179,    209,    229,\r
+           30,     38,     56,     89,    118,    129,    158,    178,\r
+          200,    231,     21,     29,     49,     63,     85,    111,\r
+          142,    163,    193,    222,     27,     48,     77,    103,\r
+          133,    158,    179,    196,    215,    232,     29,     47,\r
+           74,     99,    124,    151,    176,    198,    220,    237,\r
+           33,     42,     61,     76,     93,    121,    155,    174,\r
+          207,    225,     29,     53,     87,    112,    136,    154,\r
+          170,    188,    208,    227,     24,     30,     52,     84,\r
+          131,    150,    166,    186,    203,    229,     37,     48,\r
+           64,     84,    104,    118,    156,    177,    201,    230\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB1_iCDF_NB_MB[ 64 ] = {\r
+          212,    178,    148,    129,    108,     96,     85,     82,\r
+           79,     77,     61,     59,     57,     56,     51,     49,\r
+           48,     45,     42,     41,     40,     38,     36,     34,\r
+           31,     30,     21,     12,     10,      3,      1,      0,\r
+          255,    245,    244,    236,    233,    225,    217,    203,\r
+          190,    176,    175,    161,    149,    136,    125,    114,\r
+          102,     91,     81,     71,     60,     52,     43,     35,\r
+           28,     20,     19,     18,     12,     11,      5,      0\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_SELECT_NB_MB[ 160 ] = {\r
+           16,      0,      0,      0,      0,     99,     66,     36,\r
+           36,     34,     36,     34,     34,     34,     34,     83,\r
+           69,     36,     52,     34,    116,    102,     70,     68,\r
+           68,    176,    102,     68,     68,     34,     65,     85,\r
+           68,     84,     36,    116,    141,    152,    139,    170,\r
+          132,    187,    184,    216,    137,    132,    249,    168,\r
+          185,    139,    104,    102,    100,     68,     68,    178,\r
+          218,    185,    185,    170,    244,    216,    187,    187,\r
+          170,    244,    187,    187,    219,    138,    103,    155,\r
+          184,    185,    137,    116,    183,    155,    152,    136,\r
+          132,    217,    184,    184,    170,    164,    217,    171,\r
+          155,    139,    244,    169,    184,    185,    170,    164,\r
+          216,    223,    218,    138,    214,    143,    188,    218,\r
+          168,    244,    141,    136,    155,    170,    168,    138,\r
+          220,    219,    139,    164,    219,    202,    216,    137,\r
+          168,    186,    246,    185,    139,    116,    185,    219,\r
+          185,    138,    100,    100,    134,    100,    102,     34,\r
+           68,     68,    100,     68,    168,    203,    221,    218,\r
+          168,    167,    154,    136,    104,     70,    164,    246,\r
+          171,    137,    139,    137,    155,    218,    219,    139\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_iCDF_NB_MB[ 72 ] = {\r
+          255,    254,    253,    238,     14,      3,      2,      1,\r
+            0,    255,    254,    252,    218,     35,      3,      2,\r
+            1,      0,    255,    254,    250,    208,     59,      4,\r
+            2,      1,      0,    255,    254,    246,    194,     71,\r
+           10,      2,      1,      0,    255,    252,    236,    183,\r
+           82,      8,      2,      1,      0,    255,    252,    235,\r
+          180,     90,     17,      2,      1,      0,    255,    248,\r
+          224,    171,     97,     30,      4,      1,      0,    255,\r
+          254,    236,    173,     95,     37,      7,      1,      0\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_BITS_NB_MB_Q5[ 72 ] = {\r
+          255,    255,    255,    131,      6,    145,    255,    255,\r
+          255,    255,    255,    236,     93,     15,     96,    255,\r
+          255,    255,    255,    255,    194,     83,     25,     71,\r
+          221,    255,    255,    255,    255,    162,     73,     34,\r
+           66,    162,    255,    255,    255,    210,    126,     73,\r
+           43,     57,    173,    255,    255,    255,    201,    125,\r
+           71,     48,     58,    130,    255,    255,    255,    166,\r
+          110,     73,     57,     62,    104,    210,    255,    255,\r
+          251,    123,     65,     55,     68,    100,    171,    255\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_PRED_NB_MB_Q8[ 18 ] = {\r
+          179,    138,    140,    148,    151,    149,    153,    151,\r
+          163,    116,     67,     82,     59,     92,     72,    100,\r
+           89,     92\r
+};\r
+\r
+const SKP_int16 SKP_Silk_NLSF_DELTA_MIN_NB_MB_Q15[ 11 ] = {\r
+          322,      3,      6,      3,      3,      3,      4,      3,\r
+            3,      3,    461\r
+};\r
+\r
+const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB_NB_MB =\r
+{\r
+    32,\r
+    10,\r
+    SKP_FIX_CONST( 0.18, 16 ),\r
+    SKP_FIX_CONST( 1.0 / 0.18, 6 ),\r
+    SKP_Silk_NLSF_CB1_NB_MB_Q8,\r
+    SKP_Silk_NLSF_CB1_iCDF_NB_MB,\r
+    SKP_Silk_NLSF_PRED_NB_MB_Q8,\r
+    SKP_Silk_NLSF_CB2_SELECT_NB_MB,\r
+    SKP_Silk_NLSF_CB2_iCDF_NB_MB,\r
+    SKP_Silk_NLSF_CB2_BITS_NB_MB_Q5,\r
+    SKP_Silk_NLSF_DELTA_MIN_NB_MB_Q15,\r
+};\r
diff --git a/src_common/SKP_Silk_tables_NLSF_CB_WB.c b/src_common/SKP_Silk_tables_NLSF_CB_WB.c
new file mode 100644 (file)
index 0000000..d2e1945
--- /dev/null
@@ -0,0 +1,193 @@
+/***********************************************************************\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 "SKP_Silk_structs.h"\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB1_WB_Q8[ 512 ] = {\r
+            7,     23,     38,     54,     69,     85,    100,    116,\r
+          131,    147,    162,    178,    193,    208,    223,    239,\r
+           13,     25,     41,     55,     69,     83,     98,    112,\r
+          127,    142,    157,    171,    187,    203,    220,    236,\r
+           15,     21,     34,     51,     61,     78,     92,    106,\r
+          126,    136,    152,    167,    185,    205,    225,    240,\r
+           10,     21,     36,     50,     63,     79,     95,    110,\r
+          126,    141,    157,    173,    189,    205,    221,    237,\r
+           17,     20,     37,     51,     59,     78,     89,    107,\r
+          123,    134,    150,    164,    184,    205,    224,    240,\r
+           10,     15,     32,     51,     67,     81,     96,    112,\r
+          129,    142,    158,    173,    189,    204,    220,    236,\r
+            8,     21,     37,     51,     65,     79,     98,    113,\r
+          126,    138,    155,    168,    179,    192,    209,    218,\r
+           12,     15,     34,     55,     63,     78,     87,    108,\r
+          118,    131,    148,    167,    185,    203,    219,    236,\r
+           16,     19,     32,     36,     56,     79,     91,    108,\r
+          118,    136,    154,    171,    186,    204,    220,    237,\r
+           11,     28,     43,     58,     74,     89,    105,    120,\r
+          135,    150,    165,    180,    196,    211,    226,    241,\r
+            6,     16,     33,     46,     60,     75,     92,    107,\r
+          123,    137,    156,    169,    185,    199,    214,    225,\r
+           11,     19,     30,     44,     57,     74,     89,    105,\r
+          121,    135,    152,    169,    186,    202,    218,    234,\r
+           12,     19,     29,     46,     57,     71,     88,    100,\r
+          120,    132,    148,    165,    182,    199,    216,    233,\r
+           17,     23,     35,     46,     56,     77,     92,    106,\r
+          123,    134,    152,    167,    185,    204,    222,    237,\r
+           14,     17,     45,     53,     63,     75,     89,    107,\r
+          115,    132,    151,    171,    188,    206,    221,    240,\r
+            9,     16,     29,     40,     56,     71,     88,    103,\r
+          119,    137,    154,    171,    189,    205,    222,    237,\r
+           16,     19,     36,     48,     57,     76,     87,    105,\r
+          118,    132,    150,    167,    185,    202,    218,    236,\r
+           12,     17,     29,     54,     71,     81,     94,    104,\r
+          126,    136,    149,    164,    182,    201,    221,    237,\r
+           15,     28,     47,     62,     79,     97,    115,    129,\r
+          142,    155,    168,    180,    194,    208,    223,    238,\r
+            8,     14,     30,     45,     62,     78,     94,    111,\r
+          127,    143,    159,    175,    192,    207,    223,    239,\r
+           17,     30,     49,     62,     79,     92,    107,    119,\r
+          132,    145,    160,    174,    190,    204,    220,    235,\r
+           14,     19,     36,     45,     61,     76,     91,    108,\r
+          121,    138,    154,    172,    189,    205,    222,    238,\r
+           12,     18,     31,     45,     60,     76,     91,    107,\r
+          123,    138,    154,    171,    187,    204,    221,    236,\r
+           13,     17,     31,     43,     53,     70,     83,    103,\r
+          114,    131,    149,    167,    185,    203,    220,    237,\r
+           17,     22,     35,     42,     58,     78,     93,    110,\r
+          125,    139,    155,    170,    188,    206,    224,    240,\r
+            8,     15,     34,     50,     67,     83,     99,    115,\r
+          131,    146,    162,    178,    193,    209,    224,    239,\r
+           13,     16,     41,     66,     73,     86,     95,    111,\r
+          128,    137,    150,    163,    183,    206,    225,    241,\r
+           17,     25,     37,     52,     63,     75,     92,    102,\r
+          119,    132,    144,    160,    175,    191,    212,    231,\r
+           19,     31,     49,     65,     83,    100,    117,    133,\r
+          147,    161,    174,    187,    200,    213,    227,    242,\r
+           18,     31,     52,     68,     88,    103,    117,    126,\r
+          138,    149,    163,    177,    192,    207,    223,    239,\r
+           16,     29,     47,     61,     76,     90,    106,    119,\r
+          133,    147,    161,    176,    193,    209,    224,    240,\r
+           15,     21,     35,     50,     61,     73,     86,     97,\r
+          110,    119,    129,    141,    175,    198,    218,    237\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB1_iCDF_WB[ 64 ] = {\r
+          225,    204,    201,    184,    183,    175,    158,    154,\r
+          153,    135,    119,    115,    113,    110,    109,     99,\r
+           98,     95,     79,     68,     52,     50,     48,     45,\r
+           43,     32,     31,     27,     18,     10,      3,      0,\r
+          255,    251,    235,    230,    212,    201,    196,    182,\r
+          167,    166,    163,    151,    138,    124,    110,    104,\r
+           90,     78,     76,     70,     69,     57,     45,     34,\r
+           24,     21,     11,      6,      5,      4,      3,      0\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_SELECT_WB[ 256 ] = {\r
+            0,      0,      0,      0,      0,      0,      0,      1,\r
+          100,    102,    102,     68,     68,     36,     34,     96,\r
+          164,    107,    158,    185,    180,    185,    139,    102,\r
+           64,     66,     36,     34,     34,      0,      1,     32,\r
+          208,    139,    141,    191,    152,    185,    155,    104,\r
+           96,    171,    104,    166,    102,    102,    102,    132,\r
+            1,      0,      0,      0,      0,     16,     16,      0,\r
+           80,    109,     78,    107,    185,    139,    103,    101,\r
+          208,    212,    141,    139,    173,    153,    123,    103,\r
+           36,      0,      0,      0,      0,      0,      0,      1,\r
+           48,      0,      0,      0,      0,      0,      0,     32,\r
+           68,    135,    123,    119,    119,    103,     69,     98,\r
+           68,    103,    120,    118,    118,    102,     71,     98,\r
+          134,    136,    157,    184,    182,    153,    139,    134,\r
+          208,    168,    248,     75,    189,    143,    121,    107,\r
+           32,     49,     34,     34,     34,      0,     17,      2,\r
+          210,    235,    139,    123,    185,    137,    105,    134,\r
+           98,    135,    104,    182,    100,    183,    171,    134,\r
+          100,     70,     68,     70,     66,     66,     34,    131,\r
+           64,    166,    102,     68,     36,      2,      1,      0,\r
+          134,    166,    102,     68,     34,     34,     66,    132,\r
+          212,    246,    158,    139,    107,    107,     87,    102,\r
+          100,    219,    125,    122,    137,    118,    103,    132,\r
+          114,    135,    137,    105,    171,    106,     50,     34,\r
+          164,    214,    141,    143,    185,    151,    121,    103,\r
+          192,     34,      0,      0,      0,      0,      0,      1,\r
+          208,    109,     74,    187,    134,    249,    159,    137,\r
+          102,    110,    154,    118,     87,    101,    119,    101,\r
+            0,      2,      0,     36,     36,     66,     68,     35,\r
+           96,    164,    102,    100,     36,      0,      2,     33,\r
+          167,    138,    174,    102,    100,     84,      2,      2,\r
+          100,    107,    120,    119,     36,    197,     24,      0\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_iCDF_WB[ 72 ] = {\r
+          255,    254,    253,    244,     12,      3,      2,      1,\r
+            0,    255,    254,    252,    224,     38,      3,      2,\r
+            1,      0,    255,    254,    251,    209,     57,      4,\r
+            2,      1,      0,    255,    254,    244,    195,     69,\r
+            4,      2,      1,      0,    255,    251,    232,    184,\r
+           84,      7,      2,      1,      0,    255,    254,    240,\r
+          186,     86,     14,      2,      1,      0,    255,    254,\r
+          239,    178,     91,     30,      5,      1,      0,    255,\r
+          248,    227,    177,    100,     19,      2,      1,      0\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_CB2_BITS_WB_Q5[ 72 ] = {\r
+          255,    255,    255,    156,      4,    154,    255,    255,\r
+          255,    255,    255,    227,    102,     15,     92,    255,\r
+          255,    255,    255,    255,    213,     83,     24,     72,\r
+          236,    255,    255,    255,    255,    150,     76,     33,\r
+           63,    214,    255,    255,    255,    190,    121,     77,\r
+           43,     55,    185,    255,    255,    255,    245,    137,\r
+           71,     43,     59,    139,    255,    255,    255,    255,\r
+          131,     66,     50,     66,    107,    194,    255,    255,\r
+          166,    116,     76,     55,     53,    125,    255,    255\r
+};\r
+\r
+const SKP_uint8 SKP_Silk_NLSF_PRED_WB_Q8[ 30 ] = {\r
+          175,    148,    160,    176,    178,    173,    174,    164,\r
+          177,    174,    196,    182,    198,    192,    182,     68,\r
+           62,     66,     60,     72,    117,     85,     90,    118,\r
+          136,    151,    142,    160,    142,    155\r
+};\r
+\r
+const SKP_int16 SKP_Silk_NLSF_DELTA_MIN_WB_Q15[ 17 ] = {\r
+          121,      3,     42,      3,      3,      3,      5,     14,\r
+           14,     10,     11,      3,      8,      9,      7,      3,\r
+          347\r
+};\r
+\r
+const SKP_Silk_NLSF_CB_struct SKP_Silk_NLSF_CB_WB =\r
+{\r
+    32,\r
+    16,\r
+    SKP_FIX_CONST( 0.16, 16 ),\r
+    SKP_FIX_CONST( 1.0 / 0.16, 6 ),\r
+    SKP_Silk_NLSF_CB1_WB_Q8,\r
+    SKP_Silk_NLSF_CB1_iCDF_WB,\r
+    SKP_Silk_NLSF_PRED_WB_Q8,\r
+    SKP_Silk_NLSF_CB2_SELECT_WB,\r
+    SKP_Silk_NLSF_CB2_iCDF_WB,\r
+    SKP_Silk_NLSF_CB2_BITS_WB_Q5,\r
+    SKP_Silk_NLSF_DELTA_MIN_WB_Q15,\r
+};\r
index 21a03c7..41960e7 100644 (file)
@@ -36,16 +36,16 @@ extern "C"
 \r
 /* Piece-wise linear mapping from bitrate in kbps to coding quality in dB SNR */\r
 const SKP_int32 TargetRate_table_NB[ TARGET_RATE_TAB_SZ ] = {\r
-    0,      8000,   9000,   11000,  13000,  17500,  25000,  MAX_TARGET_RATE_BPS\r
+    0,      8000,   9400,   11500,  13500,  17500,  25000,  MAX_TARGET_RATE_BPS\r
 };\r
 const SKP_int32 TargetRate_table_MB[ TARGET_RATE_TAB_SZ ] = {\r
-    0,      10000,  12000,  14000,  17000,  23000,  33500,  MAX_TARGET_RATE_BPS\r
+    0,      9000,   11800,  14200,  17700,  23700,  34400,  MAX_TARGET_RATE_BPS\r
 };\r
 const SKP_int32 TargetRate_table_WB[ TARGET_RATE_TAB_SZ ] = {\r
-    0,      11000,  14000,  17000,  21000,  27500,  41500,  MAX_TARGET_RATE_BPS\r
+    0,      10500,  14000,  17000,  21300,  28000,  41500,  MAX_TARGET_RATE_BPS\r
 };\r
 const SKP_int16 SNR_table_Q1[ TARGET_RATE_TAB_SZ ] = {\r
-    19,     31,     35,     39,     44,     50,     60,     80\r
+    19,     29,     35,     39,     44,     50,     60,     80\r
 };\r
 \r
 /* Decoder high-pass filter coefficients, -6 dB @ 50 Hz, 0.05 dB ripple */\r
@@ -97,6 +97,8 @@ const SKP_uint8 SKP_Silk_uniform4_iCDF[ 4 ] = { 192, 128, 64, 0 };
 const SKP_uint8 SKP_Silk_uniform6_iCDF[ 6 ] = { 213, 171, 128, 85, 43, 0 };\r
 const SKP_uint8 SKP_Silk_uniform8_iCDF[ 8 ] = { 224, 192, 160, 128, 96, 64, 32, 0 };\r
 \r
+const SKP_uint8 SKP_Silk_NLSF_EXT_iCDF[ 7 ] = { 100, 40, 16, 7, 3, 1, 0 };\r
+\r
 #if SWITCH_TRANSITION_FILTERING\r
 /*  Elliptic/Cauer filters designed with 0.1 dB passband ripple, \r
         80 dB minimum stopband attenuation, and\r
index 74f55fc..0251854 100644 (file)
@@ -27,12 +27,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \r
 #include "SKP_Silk_tables.h"\r
 \r
-const SKP_uint8 SKP_Silk_max_pulses_table[4] = {\r
+const SKP_uint8 SKP_Silk_max_pulses_table[ 4 ] = {\r
             8,     10,     12,     16\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_pulses_per_block_iCDF[10][18] = \r
-{\r
+const SKP_uint8 SKP_Silk_pulses_per_block_iCDF[ 10 ][ 18 ] = {\r
 {\r
           125,     51,     26,     18,     15,     12,     11,     10,\r
             9,      8,      7,      6,      5,      4,      3,      2,\r
@@ -85,8 +84,7 @@ const SKP_uint8 SKP_Silk_pulses_per_block_iCDF[10][18] =
 }\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_pulses_per_block_BITS_Q5[9][18] = \r
-{\r
+const SKP_uint8 SKP_Silk_pulses_per_block_BITS_Q5[ 9 ][ 18 ] = {\r
 {\r
            31,     57,    107,    160,    205,    205,    255,    255,\r
           255,    255,    255,    255,    255,    255,    255,    255,\r
@@ -134,7 +132,7 @@ const SKP_uint8 SKP_Silk_pulses_per_block_BITS_Q5[9][18] =
 }\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_rate_levels_iCDF[2][9] = \r
+const SKP_uint8 SKP_Silk_rate_levels_iCDF[ 2 ][ 9 ] = \r
 {\r
 {\r
           241,    190,    178,    132,     87,     74,     41,     14,\r
@@ -146,7 +144,7 @@ const SKP_uint8 SKP_Silk_rate_levels_iCDF[2][9] =
 }\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_rate_levels_BITS_Q5[2][9] = \r
+const SKP_uint8 SKP_Silk_rate_levels_BITS_Q5[ 2 ][ 9 ] = \r
 {\r
 {\r
           131,     74,    141,     79,     80,    138,     95,    104,\r
@@ -158,7 +156,7 @@ const SKP_uint8 SKP_Silk_rate_levels_BITS_Q5[2][9] =
 }\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_shell_code_table0[44] = {\r
+const SKP_uint8 SKP_Silk_shell_code_table0[ 44 ] = {\r
           128,      0,    214,     42,      0,    235,    128,     21,\r
             0,    244,    184,     72,     11,      0,    248,    214,\r
           128,     42,      7,      0,    248,    225,    170,     80,\r
@@ -167,7 +165,7 @@ const SKP_uint8 SKP_Silk_shell_code_table0[44] = {
            35,     15,      5,      0\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_shell_code_table1[65] = {\r
+const SKP_uint8 SKP_Silk_shell_code_table1[ 65 ] = {\r
           129,      0,    207,     50,      0,    236,    129,     20,\r
             0,    245,    185,     72,     10,      0,    249,    213,\r
           129,     42,      6,      0,    250,    226,    169,     87,\r
@@ -179,7 +177,7 @@ const SKP_uint8 SKP_Silk_shell_code_table1[65] = {
             0\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_shell_code_table2[90] = {\r
+const SKP_uint8 SKP_Silk_shell_code_table2[ 90 ] = {\r
           129,      0,    203,     54,      0,    234,    129,     23,\r
             0,    245,    184,     73,     10,      0,    250,    215,\r
           129,     41,      5,      0,    252,    232,    173,     86,\r
@@ -194,7 +192,7 @@ const SKP_uint8 SKP_Silk_shell_code_table2[90] = {
             1,      0\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_shell_code_table3[152] = {\r
+const SKP_uint8 SKP_Silk_shell_code_table3[ 152 ] = {\r
           130,      0,    200,     58,      0,    231,    130,     26,\r
             0,    244,    184,     76,     12,      0,    249,    214,\r
           130,     43,      6,      0,    252,    232,    173,     87,\r
@@ -216,13 +214,13 @@ const SKP_uint8 SKP_Silk_shell_code_table3[152] = {
            76,     42,     18,      4,      3,      2,      1,      0\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_shell_code_table_offsets[17] = {\r
+const SKP_uint8 SKP_Silk_shell_code_table_offsets[ 17 ] = {\r
             0,      0,      2,      5,      9,     14,     20,     27,\r
            35,     44,     54,     65,     77,     90,    104,    119,\r
           135\r
 };\r
 \r
-const SKP_uint8 SKP_Silk_sign_iCDF[36] = {\r
+const SKP_uint8 SKP_Silk_sign_iCDF[ 36 ] = {\r
            49,     67,     77,     82,     93,     99,     11,     18,\r
            24,     31,     36,     45,     46,     66,     78,     87,\r
            94,    104,     14,     21,     32,     42,     51,     66,\r
index c823534..dc52ba7 100644 (file)
@@ -50,10 +50,11 @@ extern "C"
 /* LPC analysis defines: regularization and bandwidth expansion */\r
 #define FIND_LPC_COND_FAC                               2.5e-5f\r
 #define FIND_LPC_CHIRP                                  0.99995f\r
+#define FIND_LPC_CHIRP_FIRST_FRAME                      0.96f\r
 \r
 /* LTP analysis defines */\r
 #define FIND_LTP_COND_FAC                               1e-5f\r
-#define LTP_DAMPING                                     0.001f\r
+#define LTP_DAMPING                                     0.01f\r
 #define LTP_SMOOTHING                                   0.1f\r
 \r
 /* LTP quantization settings */\r
@@ -148,13 +149,22 @@ extern "C"
 #define SUBFR_SMTH_COEF                                 0.4f\r
 \r
 /* parameters defining the R/D tradeoff in the residual quantizer */\r
-#define LAMBDA_OFFSET                                   1.2f\r
+#define LAMBDA_OFFSET                                   1.3f\r
 #define LAMBDA_SPEECH_ACT                               -0.3f\r
 #define LAMBDA_DELAYED_DECISIONS                        -0.05f\r
 #define LAMBDA_INPUT_QUALITY                            -0.2f\r
 #define LAMBDA_CODING_QUALITY                           -0.1f\r
 #define LAMBDA_QUANT_OFFSET                             1.5f\r
 \r
+/* Compensation in bitrate calculations for 10 ms modes */\r
+#define REDUCE_BITRATE_10_MS_BPS                        2200\r
+\r
+/* Transition bitrates between modes */\r
+#define WB2MB_BITRATE_BPS                               12600\r
+#define MB2WB_BITRATE_BPS                               15600\r
+#define MB2NB_BITRATE_BPS                               9600\r
+#define NB2MB_BITRATE_BPS                               12600\r
+\r
 #ifdef __cplusplus\r
 }\r
 #endif\r
index ce04adb..e0e2bdc 100644 (file)
@@ -80,7 +80,6 @@
     <ClInclude Include="SKP_Silk_setup.h" />\r
     <ClInclude Include="SKP_Silk_structs.h" />\r
     <ClInclude Include="SKP_Silk_tables.h" />\r
-    <ClInclude Include="SKP_Silk_tables_NLSF_CB.h" />\r
     <ClInclude Include="SKP_Silk_tuning_parameters.h" />\r
   </ItemGroup>\r
   <ItemGroup>\r
     <ClCompile Include="SKP_Silk_LBRR_embed.c" />\r
     <ClCompile Include="SKP_Silk_LP_variable_cutoff.c" />\r
     <ClCompile Include="SKP_Silk_NLSF2A_stable.c" />\r
-    <ClCompile Include="SKP_Silk_NLSF_MSVQ_decode.c" />\r
-    <ClCompile Include="SKP_Silk_NLSF_MSVQ_encode.c" />\r
-    <ClCompile Include="SKP_Silk_NLSF_VQ_rate_distortion.c" />\r
-    <ClCompile Include="SKP_Silk_NLSF_VQ_sum_error.c" />\r
+    <ClCompile Include="SKP_Silk_NLSF_decode.c" />\r
+    <ClCompile Include="SKP_Silk_NLSF_del_dec_quant.c" />\r
+    <ClCompile Include="SKP_Silk_NLSF_encode.c" />\r
+    <ClCompile Include="SKP_Silk_NLSF_unpack.c" />\r
+    <ClCompile Include="SKP_Silk_NLSF_VQ.c" />\r
     <ClCompile Include="SKP_Silk_NSQ.c" />\r
     <ClCompile Include="SKP_Silk_NSQ_del_dec.c" />\r
     <ClCompile Include="SKP_Silk_PLC.c" />\r
     <ClCompile Include="SKP_Silk_shell_coder.c" />\r
     <ClCompile Include="SKP_Silk_tables_gain.c" />\r
     <ClCompile Include="SKP_Silk_tables_LTP.c" />\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB0_10.c" />\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB0_16.c" />\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB1_10.c" />\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB1_16.c" />\r
+    <ClCompile Include="SKP_Silk_tables_NLSF_CB_NB_MB.c" />\r
+    <ClCompile Include="SKP_Silk_tables_NLSF_CB_WB.c" />\r
     <ClCompile Include="SKP_Silk_tables_other.c" />\r
     <ClCompile Include="SKP_Silk_tables_pitch_lag.c" />\r
     <ClCompile Include="SKP_Silk_tables_pulses_per_block.c" />\r
index 107d02d..acce7ae 100644 (file)
@@ -36,9 +36,6 @@
     <ClInclude Include="SKP_Silk_tuning_parameters.h">\r
       <Filter>Header Files</Filter>\r
     </ClInclude>\r
-    <ClInclude Include="SKP_Silk_tables_NLSF_CB.h">\r
-      <Filter>Header Files</Filter>\r
-    </ClInclude>\r
     <ClInclude Include="SKP_Silk_setup.h">\r
       <Filter>Header Files</Filter>\r
     </ClInclude>\r
@@ -86,9 +83,6 @@
     <ClCompile Include="SKP_Silk_LP_variable_cutoff.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_NLSF_MSVQ_decode.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="SKP_Silk_NLSF2A_stable.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
     <ClCompile Include="SKP_Silk_tables_LTP.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB0_10.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB0_16.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB1_10.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
-    <ClCompile Include="SKP_Silk_tables_NLSF_CB1_16.c">\r
-      <Filter>Source Files</Filter>\r
-    </ClCompile>\r
     <ClCompile Include="SKP_Silk_tables_other.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
     <ClCompile Include="SKP_Silk_LBRR_embed.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_NLSF_VQ_rate_distortion.c">\r
+    <ClCompile Include="SKP_Silk_process_NLSFs.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_process_NLSFs.c">\r
+    <ClCompile Include="SKP_Silk_HP_variable_cutoff.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_NLSF_VQ_sum_error.c">\r
+    <ClCompile Include="SKP_Silk_NLSF_encode.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_NLSF_MSVQ_encode.c">\r
+    <ClCompile Include="SKP_Silk_NLSF_decode.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
-    <ClCompile Include="SKP_Silk_HP_variable_cutoff.c">\r
+    <ClCompile Include="SKP_Silk_tables_NLSF_CB_WB.c">\r
+      <Filter>Source Files</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="SKP_Silk_NLSF_unpack.c">\r
+      <Filter>Source Files</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="SKP_Silk_tables_NLSF_CB_NB_MB.c">\r
+      <Filter>Source Files</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="SKP_Silk_NLSF_VQ.c">\r
+      <Filter>Source Files</Filter>\r
+    </ClCompile>\r
+    <ClCompile Include="SKP_Silk_NLSF_del_dec_quant.c">\r
       <Filter>Source Files</Filter>\r
     </ClCompile>\r
   </ItemGroup>\r
index 3e06a47..ef344b1 100644 (file)
@@ -254,7 +254,7 @@ int main( int argc, char* argv[] )
         nBytes = MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES;\r
 \r
         /* Silk Encoder */\r
-        ret = SKP_Silk_SDK_Encode( psEnc, &encControl, in, (SKP_int16)counter, &range_enc_celt_state, &nBytes );\r
+        ret = SKP_Silk_SDK_Encode( psEnc, &encControl, in, (SKP_int16)counter, &range_enc_celt_state, &nBytes, 0 );\r
         if( ret ) {\r
             printf( "\nSKP_Silk_Encode returned %d", ret );\r
             break;\r