Update SILK code using the CELT range coder
[opus.git] / src_common / SKP_Silk_NSQ_del_dec.c
similarity index 77%
rename from src/SKP_Silk_NSQ_del_dec.c
rename to src_common/SKP_Silk_NSQ_del_dec.c
index 3601263..f81ad68 100644 (file)
@@ -28,13 +28,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SKP_Silk_main.h"\r
 \r
 typedef struct {\r
-    SKP_int   RandState[ DECISION_DELAY ];\r
+    SKP_int32 RandState[ DECISION_DELAY ];\r
     SKP_int32 Q_Q10[     DECISION_DELAY ];\r
     SKP_int32 Xq_Q10[    DECISION_DELAY ];\r
     SKP_int32 Pred_Q16[  DECISION_DELAY ];\r
     SKP_int32 Shape_Q10[ DECISION_DELAY ];\r
     SKP_int32 Gain_Q16[  DECISION_DELAY ];\r
-    SKP_int32 sLPC_Q14[ MAX_FRAME_LENGTH / NB_SUBFR + NSQ_LPC_BUF_LENGTH ];\r
+    SKP_int32 sAR2_Q14[ MAX_SHAPE_LPC_ORDER ];\r
+    SKP_int32 sLPC_Q14[ MAX_FRAME_LENGTH / MAX_NB_SUBFR + NSQ_LPC_BUF_LENGTH ];\r
     SKP_int32 LF_AR_Q12;\r
     SKP_int32 Seed;\r
     SKP_int32 SeedInit;\r
@@ -68,8 +69,8 @@ SKP_INLINE void SKP_Silk_nsq_del_dec_scale_states(
     SKP_int             nStatesDelayedDecision, /* I    Number of del dec states            */\r
     SKP_int             smpl_buf_idx,           /* I    Index to newest samples in buffers  */\r
     const SKP_int       LTP_scale_Q14,          /* I    LTP state scaling                   */\r
-    const SKP_int32     Gains_Q16[ NB_SUBFR ],  /* I                                        */\r
-    const SKP_int       pitchL[ NB_SUBFR ]      /* I    Pitch lag                           */\r
+    const SKP_int32     Gains_Q16[ MAX_NB_SUBFR ],  /* I                                        */\r
+    const SKP_int       pitchL[ MAX_NB_SUBFR ]      /* I    Pitch lag                           */\r
 );\r
 \r
 /******************************************/\r
@@ -80,7 +81,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
     NSQ_del_dec_struct  psDelDec[],             /* I/O  Delayed decision states             */\r
     SKP_int             sigtype,                /* I    Signal type                         */\r
     const SKP_int32     x_Q10[],                /* I                                        */\r
-    SKP_int             q[],                    /* O                                        */\r
+    SKP_int8            q[],                    /* O                                        */\r
     SKP_int16           xq[],                   /* O                                        */\r
     SKP_int32           sLTP_Q16[],             /* I/O  LTP filter state                    */\r
     const SKP_int16     a_Q12[],                /* I    Short term prediction coefs         */\r
@@ -96,7 +97,8 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
     SKP_int             length,                 /* I    Input length                        */\r
     SKP_int             subfr,                  /* I    Subframe number                     */\r
     SKP_int             shapingLPCOrder,        /* I    Shaping LPC filter order            */\r
-    SKP_int             predictLPCOrder,        /* I    Prediction LPC filter order         */\r
+    SKP_int             predictLPCOrder,        /* I    Prediction filter order             */\r
+    SKP_int             warping_Q16,            /* I                                        */\r
     SKP_int             nStatesDelayedDecision, /* I    Number of states in decision tree   */\r
     SKP_int             *smpl_buf_idx,          /* I    Index to newest samples in buffers  */\r
     SKP_int             decisionDelay           /* I                                        */\r
@@ -107,15 +109,15 @@ void SKP_Silk_NSQ_del_dec(
     SKP_Silk_encoder_control        *psEncCtrlC,                                /* I    Encoder Control                     */\r
     SKP_Silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                           */\r
     const SKP_int16                 x[],                                        /* I    Prefiltered input signal            */\r
-    SKP_int                         q[],                                        /* O    Quantized pulse signal              */\r
+    SKP_int8                        q[],                                        /* O    Quantized pulse signal              */\r
     const SKP_int                   LSFInterpFactor_Q2,                         /* I    LSF interpolation factor in Q2      */\r
     const SKP_int16                 PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Prediction coefs                    */\r
-    const SKP_int16                 LTPCoef_Q14[ LTP_ORDER * NB_SUBFR ],        /* I    LT prediction coefs                 */\r
-    const SKP_int16                 AR2_Q13[ NB_SUBFR * SHAPE_LPC_ORDER_MAX ],  /* I                                        */\r
-    const SKP_int                   HarmShapeGain_Q14[ NB_SUBFR ],              /* I                                        */\r
-    const SKP_int                   Tilt_Q14[ NB_SUBFR ],                       /* I    Spectral tilt                       */\r
-    const SKP_int32                 LF_shp_Q14[ NB_SUBFR ],                     /* I                                        */\r
-    const SKP_int32                 Gains_Q16[ NB_SUBFR ],                      /* I                                        */\r
+    const SKP_int16                 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],        /* I    LT prediction coefs                 */\r
+    const SKP_int16                 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ],  /* I                                        */\r
+    const SKP_int                   HarmShapeGain_Q14[ MAX_NB_SUBFR ],              /* I                                        */\r
+    const SKP_int                   Tilt_Q14[ MAX_NB_SUBFR ],                       /* I    Spectral tilt                       */\r
+    const SKP_int32                 LF_shp_Q14[ MAX_NB_SUBFR ],                     /* I                                        */\r
+    const SKP_int32                 Gains_Q16[ MAX_NB_SUBFR ],                      /* I                                        */\r
     const SKP_int                   Lambda_Q10,                                 /* I                                        */\r
     const SKP_int                   LTP_scale_Q14                               /* I    LTP state scaling                   */\r
 )\r
@@ -129,11 +131,11 @@ void SKP_Silk_NSQ_del_dec(
     SKP_int32   HarmShapeFIRPacked_Q14;\r
     SKP_int     offset_Q10;\r
     SKP_int32   FiltState[ MAX_LPC_ORDER ], RDmin_Q10;\r
-    SKP_int32   x_sc_Q10[ MAX_FRAME_LENGTH / NB_SUBFR ];\r
-    NSQ_del_dec_struct psDelDec[ DEL_DEC_STATES_MAX ];\r
+    SKP_int32   x_sc_Q10[ MAX_SUB_FRAME_LENGTH ];\r
+    NSQ_del_dec_struct psDelDec[ MAX_DEL_DEC_STATES ];\r
     NSQ_del_dec_struct *psDD;\r
 \r
-    subfr_length = psEncC->frame_length / NB_SUBFR;\r
+    subfr_length = psEncC->subfr_length;\r
 \r
     /* Set unvoiced lag to the previous one, overwrite later for voiced */\r
     lag = NSQ->lagPrev;\r
@@ -148,8 +150,9 @@ void SKP_Silk_NSQ_del_dec(
         psDD->SeedInit       = psDD->Seed;\r
         psDD->RD_Q10         = 0;\r
         psDD->LF_AR_Q12      = NSQ->sLF_AR_shp_Q12;\r
-        psDD->Shape_Q10[ 0 ] = NSQ->sLTP_shp_Q10[ psEncC->frame_length - 1 ];\r
+        psDD->Shape_Q10[ 0 ] = NSQ->sLTP_shp_Q10[ psEncC->ltp_mem_length - 1 ];\r
         SKP_memcpy( psDD->sLPC_Q14, NSQ->sLPC_Q14, NSQ_LPC_BUF_LENGTH * sizeof( SKP_int32 ) );\r
+        SKP_memcpy( psDD->sAR2_Q14, NSQ->sAR2_Q14, sizeof( NSQ->sAR2_Q14 ) );\r
     }\r
 \r
     offset_Q10   = SKP_Silk_Quantization_Offsets_Q10[ psEncCtrlC->sigtype ][ psEncCtrlC->QuantOffsetType ];\r
@@ -158,7 +161,7 @@ void SKP_Silk_NSQ_del_dec(
     decisionDelay = SKP_min_int( DECISION_DELAY, subfr_length );\r
     /* For voiced frames limit the decision delay to lower than the pitch lag */\r
     if( psEncCtrlC->sigtype == SIG_TYPE_VOICED ) {\r
-        for( k = 0; k < NB_SUBFR; k++ ) {\r
+        for( k = 0; k < psEncC->nb_subfr; k++ ) {\r
             decisionDelay = SKP_min_int( decisionDelay, psEncCtrlC->pitchL[ k ] - LTP_ORDER / 2 - 1 );\r
         }\r
     }\r
@@ -170,14 +173,14 @@ void SKP_Silk_NSQ_del_dec(
     }\r
 \r
     /* Setup pointers to start of sub frame */\r
-    pxq                   = &NSQ->xq[ psEncC->frame_length ];\r
-    NSQ->sLTP_shp_buf_idx = psEncC->frame_length;\r
-    NSQ->sLTP_buf_idx     = psEncC->frame_length;\r
+    pxq                   = &NSQ->xq[ psEncC->ltp_mem_length ];\r
+    NSQ->sLTP_shp_buf_idx = psEncC->ltp_mem_length;\r
+    NSQ->sLTP_buf_idx     = psEncC->ltp_mem_length;\r
     subfr = 0;\r
-    for( k = 0; k < NB_SUBFR; k++ ) {\r
+    for( k = 0; k < psEncC->nb_subfr; k++ ) {\r
         A_Q12      = &PredCoef_Q12[ ( ( k >> 1 ) | ( 1 - LSF_interpolation_flag ) ) * MAX_LPC_ORDER ];\r
         B_Q14      = &LTPCoef_Q14[ k * LTP_ORDER           ];\r
-        AR_shp_Q13 = &AR2_Q13[     k * SHAPE_LPC_ORDER_MAX ];\r
+        AR_shp_Q13 = &AR2_Q13[     k * MAX_SHAPE_LPC_ORDER ];\r
 \r
         NSQ->rewhite_flag = 0;\r
         if( psEncCtrlC->sigtype == SIG_TYPE_VOICED ) {\r
@@ -220,21 +223,21 @@ void SKP_Silk_NSQ_del_dec(
                 }\r
 \r
                 /* Rewhiten with new A coefs */\r
-                start_idx = psEncC->frame_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;\r
-                start_idx = SKP_LIMIT( start_idx, 0, psEncC->frame_length - psEncC->predictLPCOrder );\r
+                start_idx = psEncC->ltp_mem_length - lag - psEncC->predictLPCOrder - LTP_ORDER / 2;\r
+                start_idx = SKP_LIMIT_int( start_idx, 0, psEncC->ltp_mem_length - psEncC->predictLPCOrder );\r
                 \r
                 SKP_memset( FiltState, 0, psEncC->predictLPCOrder * sizeof( SKP_int32 ) );\r
                 SKP_Silk_MA_Prediction( &NSQ->xq[ start_idx + k * psEncC->subfr_length ], \r
-                    A_Q12, FiltState, sLTP + start_idx, psEncC->frame_length - start_idx, psEncC->predictLPCOrder );\r
+                    A_Q12, FiltState, sLTP + start_idx, psEncC->ltp_mem_length - start_idx, psEncC->predictLPCOrder );\r
 \r
-                NSQ->sLTP_buf_idx = psEncC->frame_length;\r
+                NSQ->sLTP_buf_idx = psEncC->ltp_mem_length;\r
                 NSQ->rewhite_flag = 1;\r
             }\r
         }\r
 \r
         /* Noise shape parameters */\r
         SKP_assert( HarmShapeGain_Q14[ k ] >= 0 );\r
-        HarmShapeFIRPacked_Q14  =                        SKP_RSHIFT( HarmShapeGain_Q14[ k ], 2 );\r
+        HarmShapeFIRPacked_Q14  =                          SKP_RSHIFT( HarmShapeGain_Q14[ k ], 2 );\r
         HarmShapeFIRPacked_Q14 |= SKP_LSHIFT( ( SKP_int32 )SKP_RSHIFT( HarmShapeGain_Q14[ k ], 1 ), 16 );\r
 \r
         SKP_Silk_nsq_del_dec_scale_states( NSQ, psDelDec, x, x_sc_Q10, \r
@@ -244,8 +247,7 @@ void SKP_Silk_NSQ_del_dec(
         SKP_Silk_noise_shape_quantizer_del_dec( NSQ, psDelDec, psEncCtrlC->sigtype, x_sc_Q10, q, pxq, sLTP_Q16,\r
             A_Q12, B_Q14, AR_shp_Q13, lag, HarmShapeFIRPacked_Q14, Tilt_Q14[ k ], LF_shp_Q14[ k ], Gains_Q16[ k ], \r
             Lambda_Q10, offset_Q10, psEncC->subfr_length, subfr++, psEncC->shapingLPCOrder, psEncC->predictLPCOrder, \r
-            psEncC->nStatesDelayedDecision, &smpl_buf_idx, decisionDelay \r
-        );\r
+            psEncCtrlC->warping_Q16, psEncC->nStatesDelayedDecision, &smpl_buf_idx, decisionDelay );\r
         \r
         x   += psEncC->subfr_length;\r
         q   += psEncC->subfr_length;\r
@@ -268,24 +270,27 @@ 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
-        q[   i - decisionDelay ] = ( SKP_int )SKP_RSHIFT( psDD->Q_Q10[ last_smple_idx ], 10 );\r
+        q[   i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT( 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 ], psDD->Gain_Q16[ last_smple_idx ] ), 10 ) );\r
         NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - decisionDelay + i ] = psDD->Shape_Q10[ last_smple_idx ];\r
         sLTP_Q16[          NSQ->sLTP_buf_idx     - decisionDelay + i ] = psDD->Pred_Q16[  last_smple_idx ];\r
-\r
     }\r
     SKP_memcpy( NSQ->sLPC_Q14, &psDD->sLPC_Q14[ psEncC->subfr_length ], NSQ_LPC_BUF_LENGTH * sizeof( SKP_int32 ) );\r
+    SKP_memcpy( NSQ->sAR2_Q14, psDD->sAR2_Q14, sizeof( psDD->sAR2_Q14 ) );\r
 \r
     /* Update states */\r
     NSQ->sLF_AR_shp_Q12    = psDD->LF_AR_Q12;\r
-    NSQ->prev_inv_gain_Q16 = NSQ->prev_inv_gain_Q16;\r
-    NSQ->lagPrev           = psEncCtrlC->pitchL[ NB_SUBFR - 1 ];\r
+    NSQ->lagPrev           = psEncCtrlC->pitchL[ psEncC->nb_subfr - 1 ];\r
 \r
     /* Save quantized speech and noise shaping signals */\r
-    SKP_memcpy( NSQ->xq,           &NSQ->xq[           psEncC->frame_length ], psEncC->frame_length * sizeof( SKP_int16 ) );\r
-    SKP_memcpy( NSQ->sLTP_shp_Q10, &NSQ->sLTP_shp_Q10[ psEncC->frame_length ], psEncC->frame_length * sizeof( SKP_int32 ) );\r
+    SKP_memmove( NSQ->xq,           &NSQ->xq[           psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( SKP_int16 ) );\r
+    SKP_memmove( NSQ->sLTP_shp_Q10, &NSQ->sLTP_shp_Q10[ psEncC->frame_length ], psEncC->ltp_mem_length * sizeof( SKP_int32 ) );\r
 \r
+#ifdef SAVE_ALL_INTERNAL_DATA\r
+    DEBUG_STORE_DATA( sLTP_Q16, &sLTP_Q16[ psEncC->frame_length ], psEncC->frame_length * sizeof( SKP_int32 ) );\r
+    DEBUG_STORE_DATA( xq.dat, &NSQ->xq[ psEncC->ltp_mem_length - psEncC->frame_length], psEncC->frame_length * sizeof( SKP_int16 ) );\r
+#endif\r
 }\r
 \r
 /******************************************/\r
@@ -296,7 +301,7 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
     NSQ_del_dec_struct  psDelDec[],             /* I/O  Delayed decision states             */\r
     SKP_int             sigtype,                /* I    Signal type                         */\r
     const SKP_int32     x_Q10[],                /* I                                        */\r
-    SKP_int             q[],                    /* O                                        */\r
+    SKP_int8            q[],                    /* O                                        */\r
     SKP_int16           xq[],                   /* O                                        */\r
     SKP_int32           sLTP_Q16[],             /* I/O  LTP filter state                    */\r
     const SKP_int16     a_Q12[],                /* I    Short term prediction coefs         */\r
@@ -312,7 +317,8 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
     SKP_int             length,                 /* I    Input length                        */\r
     SKP_int             subfr,                  /* I    Subframe number                     */\r
     SKP_int             shapingLPCOrder,        /* I    Shaping LPC filter order            */\r
-    SKP_int             predictLPCOrder,        /* I    Prediction LPC filter order         */\r
+    SKP_int             predictLPCOrder,        /* I    Prediction filter order             */\r
+    SKP_int             warping_Q16,            /* I                                        */\r
     SKP_int             nStatesDelayedDecision, /* I    Number of states in decision tree   */\r
     SKP_int             *smpl_buf_idx,          /* I    Index to newest samples in buffers  */\r
     SKP_int             decisionDelay           /* I                                        */\r
@@ -321,25 +327,16 @@ 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;\r
-    SKP_int32   n_LF_Q10;\r
-    SKP_int32   r_Q10, rr_Q20, rd1_Q10, rd2_Q10, RDmin_Q10, RDmax_Q10;\r
-    SKP_int32   q1_Q10, q2_Q10;\r
-    SKP_int32   Atmp, dither;\r
-    SKP_int32   exc_Q10, LPC_exc_Q10, xq_Q10;\r
-    SKP_int32   tmp, sLF_AR_shp_Q10;\r
-    SKP_int32   *pred_lag_ptr, *shp_lag_ptr;\r
-    SKP_int32   *psLPC_Q14;\r
-    SKP_int32   a_Q12_tmp[ MAX_LPC_ORDER / 2 ], AR_shp_Q13_tmp[ MAX_LPC_ORDER / 2 ];\r
-    NSQ_sample_struct  psSampleState[ DEL_DEC_STATES_MAX ][ 2 ];\r
+    SKP_int32   n_LF_Q10, r_Q10, rr_Q20, 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
+    NSQ_sample_struct  psSampleState[ MAX_DEL_DEC_STATES ][ 2 ];\r
     NSQ_del_dec_struct *psDD;\r
     NSQ_sample_struct  *psSS;\r
 \r
     shp_lag_ptr  = &NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - lag + HARM_SHAPE_FIR_TAPS / 2 ];\r
     pred_lag_ptr = &sLTP_Q16[ NSQ->sLTP_buf_idx - lag + LTP_ORDER / 2 ];\r
-    \r
-    /* Preload LPC coeficients to array on stack. Gives small performance gain */\r
-    SKP_memcpy( a_Q12_tmp, a_Q12, predictLPCOrder * sizeof( SKP_int16 ) );\r
-    SKP_memcpy( AR_shp_Q13_tmp, AR_shp_Q13, shapingLPCOrder * sizeof( SKP_int16 ) );\r
 \r
     for( i = 0; i < length; i++ ) {\r
         /* Perform common calculations used in all states */\r
@@ -384,85 +381,65 @@ SKP_INLINE void SKP_Silk_noise_shape_quantizer_del_dec(
             /* Pointer used in short term prediction and shaping */\r
             psLPC_Q14 = &psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - 1 + i ];\r
             /* Short-term prediction */\r
+            SKP_assert( predictLPCOrder >= 10 );            /* check that unrolling works */\r
             SKP_assert( ( predictLPCOrder  & 1 ) == 0 );    /* check that order is even */\r
             SKP_assert( ( (SKP_int64)a_Q12 & 3 ) == 0 );    /* check that array starts at 4-byte aligned address */\r
-            SKP_assert( predictLPCOrder >= 10 );            /* check that unrolling works */\r
-\r
             /* Partially unrolled */\r
-            Atmp = a_Q12_tmp[ 0 ];          /* read two coefficients at once */\r
-            LPC_pred_Q10 = SKP_SMULWB(               psLPC_Q14[ 0  ], Atmp );\r
-            LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -1 ], Atmp );\r
-            Atmp = a_Q12_tmp[ 1 ];\r
-            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -2 ], Atmp );\r
-            LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -3 ], Atmp );\r
-            Atmp = a_Q12_tmp[ 2 ];\r
-            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -4 ], Atmp );\r
-            LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -5 ], Atmp );\r
-            Atmp = a_Q12_tmp[ 3 ];\r
-            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -6 ], Atmp );\r
-            LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -7 ], Atmp );\r
-            Atmp = a_Q12_tmp[ 4 ];\r
-            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -8 ], Atmp );\r
-            LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -9 ], Atmp );\r
-            for( j = 10; j < predictLPCOrder; j += 2 ) {\r
-                Atmp = a_Q12_tmp[ j >> 1 ]; /* read two coefficients at once */\r
-                LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -j     ], Atmp );\r
-                LPC_pred_Q10 = SKP_SMLAWT( LPC_pred_Q10, psLPC_Q14[ -j - 1 ], Atmp );\r
+            LPC_pred_Q10 = SKP_SMULWB(               psLPC_Q14[  0 ], a_Q12[ 0 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -1 ], a_Q12[ 1 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -2 ], a_Q12[ 2 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -3 ], a_Q12[ 3 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -4 ], a_Q12[ 4 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -5 ], a_Q12[ 5 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -6 ], a_Q12[ 6 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -7 ], a_Q12[ 7 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -8 ], a_Q12[ 8 ] );\r
+            LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -9 ], a_Q12[ 9 ] );\r
+            for( j = 10; j < predictLPCOrder; j ++ ) {\r
+                LPC_pred_Q10 = SKP_SMLAWB( LPC_pred_Q10, psLPC_Q14[ -j ], a_Q12[ j ] );\r
             }\r
 \r
             /* Noise shape feedback */\r
-            SKP_assert( ( shapingLPCOrder       & 1 ) == 0 );   /* check that order is even */\r
-            SKP_assert( ( (SKP_int64)AR_shp_Q13 & 3 ) == 0 );   /* check that array starts at 4-byte aligned address */\r
-            SKP_assert( shapingLPCOrder >= 12 );                /* check that unrolling works */\r
-            /* NOTE: the code below loads two int16 values in an int32, and multiplies each using the   */\r
-            /* SMLAWB and SMLAWT instructions. On a big-endian CPU the two int16 variables would be     */\r
-            /* loaded in reverse order and the code will give the wrong result. In that case swapping   */\r
-            /* the SMLAWB and SMLAWT instructions should solve the problem.                             */\r
-\r
-            /* Partially unrolled */\r
-            Atmp = AR_shp_Q13_tmp[ 0 ];         /* read two coefficients at once */\r
-            n_AR_Q10 = SKP_SMULWB(           psLPC_Q14[ 0  ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -1 ], Atmp );\r
-            Atmp = AR_shp_Q13_tmp[ 1 ];\r
-            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -2 ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -3 ], Atmp );\r
-            Atmp = AR_shp_Q13_tmp[ 2 ];\r
-            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -4 ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -5 ], Atmp );\r
-            Atmp = AR_shp_Q13_tmp[ 3 ];\r
-            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -6 ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -7 ], Atmp );\r
-            Atmp = AR_shp_Q13_tmp[ 4 ];\r
-            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -8 ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -9 ], Atmp );\r
-            Atmp = AR_shp_Q13_tmp[ 5 ];\r
-            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -10 ], Atmp );\r
-            n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -11 ], Atmp );\r
-            for( j = 12; j < shapingLPCOrder; j += 2 ) {\r
-                Atmp = AR_shp_Q13_tmp[ j >> 1 ];        /* read two coefficients at once */\r
-                n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psLPC_Q14[ -j     ], Atmp );\r
-                n_AR_Q10 = SKP_SMLAWT( n_AR_Q10, psLPC_Q14[ -j - 1 ], Atmp );\r
+            SKP_assert( ( shapingLPCOrder & 1 ) == 0 );   /* check that order is even */\r
+            /* Output of lowpass section */\r
+            tmp2 = SKP_SMLAWB( psLPC_Q14[ 0 ], psDD->sAR2_Q14[ 0 ], warping_Q16 );\r
+            /* Output of allpass section */\r
+            tmp1 = SKP_SMLAWB( psDD->sAR2_Q14[ 0 ], psDD->sAR2_Q14[ 1 ] - tmp2, warping_Q16 );\r
+            psDD->sAR2_Q14[ 0 ] = tmp2;\r
+            n_AR_Q10 = SKP_SMULWB( tmp2, AR_shp_Q13[ 0 ] );\r
+            /* Loop over allpass sections */\r
+            for( j = 2; j < shapingLPCOrder; j += 2 ) {\r
+                /* Output of allpass section */\r
+                tmp2 = SKP_SMLAWB( psDD->sAR2_Q14[ j - 1 ], psDD->sAR2_Q14[ j + 0 ] - tmp1, warping_Q16 );\r
+                psDD->sAR2_Q14[ j - 1 ] = tmp1;\r
+                n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, tmp1, AR_shp_Q13[ j - 1 ] );\r
+                /* Output of allpass section */\r
+                tmp1 = SKP_SMLAWB( psDD->sAR2_Q14[ j + 0 ], psDD->sAR2_Q14[ j + 1 ] - tmp2, warping_Q16 );\r
+                psDD->sAR2_Q14[ j + 0 ] = tmp2;\r
+                n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, tmp2, AR_shp_Q13[ j ] );\r
             }\r
+            psDD->sAR2_Q14[ shapingLPCOrder - 1 ] = tmp1;\r
+            n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, tmp1, AR_shp_Q13[ shapingLPCOrder - 1 ] );\r
+\r
             n_AR_Q10 = SKP_RSHIFT( n_AR_Q10, 1 );           /* Q11 -> Q10 */\r
             n_AR_Q10 = SKP_SMLAWB( n_AR_Q10, psDD->LF_AR_Q12, Tilt_Q14 );\r
 \r
-            n_LF_Q10   = SKP_LSHIFT( SKP_SMULWB( psDD->Shape_Q10[ *smpl_buf_idx ], LF_shp_Q14 ), 2 ); \r
-            n_LF_Q10   = SKP_SMLAWT( n_LF_Q10, psDD->LF_AR_Q12, LF_shp_Q14 );       \r
+            n_LF_Q10 = SKP_LSHIFT( SKP_SMULWB( psDD->Shape_Q10[ *smpl_buf_idx ], LF_shp_Q14 ), 2 ); \r
+            n_LF_Q10 = SKP_SMLAWT( n_LF_Q10, psDD->LF_AR_Q12, LF_shp_Q14 );       \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
-            tmp   = SKP_SUB32( LTP_pred_Q14, n_LTP_Q14 );                       /* Add Q14 stuff */\r
-            tmp   = SKP_RSHIFT_ROUND( tmp, 4 );                                 /* round to Q10  */\r
-            tmp   = SKP_ADD32( tmp, LPC_pred_Q10 );                             /* add Q10 stuff */ \r
-            tmp   = SKP_SUB32( tmp, n_AR_Q10 );                                 /* subtract Q10 stuff */ \r
-            tmp   = SKP_SUB32( tmp, n_LF_Q10 );                                 /* subtract Q10 stuff */ \r
-            r_Q10 = SKP_SUB32( x_Q10[ i ], tmp );                               /* residual error Q10 */\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( tmp1, n_LF_Q10 );                                /* subtract Q10 stuff */ \r
+            r_Q10 = SKP_SUB32( x_Q10[ i ], tmp1 );                              /* residual error Q10 */\r
             \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( r_Q10, -64 << 10, 64 << 10 );\r
+            r_Q10 = SKP_LIMIT_32( r_Q10, -64 << 10, 64 << 10 );\r
 \r
             /* Find two quantization level candidates and measure their rate-distortion */\r
             if( r_Q10 < -1536 ) {\r
@@ -585,7 +562,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
-            q[  i - decisionDelay ] = ( SKP_int )SKP_RSHIFT( psDD->Q_Q10[ last_smple_idx ], 10 );\r
+            q[  i - decisionDelay ] = ( SKP_int8 )SKP_RSHIFT( 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 ], psDD->Gain_Q16[ last_smple_idx ] ), 10 ) );\r
             NSQ->sLTP_shp_Q10[ NSQ->sLTP_shp_buf_idx - decisionDelay ] = psDD->Shape_Q10[ last_smple_idx ];\r
@@ -629,15 +606,15 @@ SKP_INLINE void SKP_Silk_nsq_del_dec_scale_states(
     SKP_int             nStatesDelayedDecision, /* I    Number of del dec states            */\r
     SKP_int             smpl_buf_idx,           /* I    Index to newest samples in buffers  */\r
     const SKP_int       LTP_scale_Q14,          /* I    LTP state scaling                   */\r
-    const SKP_int32     Gains_Q16[ NB_SUBFR ],  /* I                                        */\r
-    const SKP_int       pitchL[ NB_SUBFR ]      /* I    Pitch lag                           */\r
+    const SKP_int32     Gains_Q16[ MAX_NB_SUBFR ],  /* I                                        */\r
+    const SKP_int       pitchL[ MAX_NB_SUBFR ]      /* I    Pitch lag                           */\r
 )\r
 {\r
     SKP_int            i, k, scale_length, lag;\r
     SKP_int32          inv_gain_Q16, gain_adj_Q16, inv_gain_Q32;\r
     NSQ_del_dec_struct *psDD;\r
 \r
-    inv_gain_Q16 = SKP_DIV32( SKP_int32_MAX, SKP_RSHIFT( Gains_Q16[ subfr ], 1 ) );\r
+    inv_gain_Q16 = SKP_INVERSE32_varQ( SKP_max( Gains_Q16[ subfr ], 1 ), 32 );\r
     inv_gain_Q16 = SKP_min( inv_gain_Q16, SKP_int16_MAX );\r
     lag          = pitchL[ subfr ];\r
     /* After rewhitening the LTP state is un-scaled. So scale with inv_gain_Q16 */\r
@@ -667,6 +644,9 @@ SKP_INLINE void SKP_Silk_nsq_del_dec_scale_states(
             for( i = 0; i < NSQ_LPC_BUF_LENGTH; i++ ) {\r
                 psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - i - 1 ] = SKP_SMULWW( gain_adj_Q16, psDD->sLPC_Q14[ NSQ_LPC_BUF_LENGTH - i - 1 ] );\r
             }\r
+            for( i = 0; i < MAX_SHAPE_LPC_ORDER; i++ ) {\r
+                psDD->sAR2_Q14[ i ] = SKP_SMULWW( gain_adj_Q16, psDD->sAR2_Q14[ i ] );\r
+            }\r
             for( i = 0; i < DECISION_DELAY; i++ ) {\r
                 psDD->Pred_Q16[  i ] = SKP_SMULWW( gain_adj_Q16, psDD->Pred_Q16[  i ] );\r
                 psDD->Shape_Q10[ i ] = SKP_SMULWW( gain_adj_Q16, psDD->Shape_Q10[ i ] );\r
@@ -676,8 +656,8 @@ SKP_INLINE void SKP_Silk_nsq_del_dec_scale_states(
         /* Scale long term shaping state */\r
 \r
         /* Calculate length to be scaled, Worst case: Next frame is voiced with max lag */\r
-        scale_length = length * NB_SUBFR;                                               /* aprox max lag */\r
-        scale_length = scale_length - SKP_SMULBB( NB_SUBFR - ( subfr + 1 ), length );   /* subtract samples that will be too old in next frame */\r
+        scale_length = length * MAX_NB_SUBFR;                                               /* aprox max lag */\r
+        scale_length = scale_length - SKP_SMULBB( MAX_NB_SUBFR - ( subfr + 1 ), length );   /* subtract samples that will be too old in next frame */\r
         scale_length = SKP_max_int( scale_length, lag + LTP_ORDER );                    /* make sure to scale whole pitch period if voiced */\r
 \r
         for( i = NSQ->sLTP_shp_buf_idx - scale_length; i < NSQ->sLTP_shp_buf_idx; i++ ) {\r
@@ -708,12 +688,12 @@ SKP_INLINE void SKP_Silk_copy_del_dec_state(
     SKP_int             LPC_state_idx           /* I    Index to LPC buffer                 */\r
 )\r
 {\r
-    SKP_memcpy( DD_dst->RandState, DD_src->RandState,   DECISION_DELAY * sizeof( SKP_int   ) );\r
-    SKP_memcpy( DD_dst->Q_Q10,     DD_src->Q_Q10,       DECISION_DELAY * sizeof( SKP_int32 ) );\r
-    SKP_memcpy( DD_dst->Pred_Q16,  DD_src->Pred_Q16,    DECISION_DELAY * sizeof( SKP_int32 ) );\r
-    SKP_memcpy( DD_dst->Shape_Q10, DD_src->Shape_Q10,   DECISION_DELAY * sizeof( SKP_int32 ) );\r
-    SKP_memcpy( DD_dst->Xq_Q10,    DD_src->Xq_Q10,      DECISION_DELAY * sizeof( SKP_int32 ) );\r
-\r
+    SKP_memcpy( DD_dst->RandState, DD_src->RandState, sizeof( DD_src->RandState ) );\r
+    SKP_memcpy( DD_dst->Q_Q10,     DD_src->Q_Q10,     sizeof( DD_src->Q_Q10     ) );\r
+    SKP_memcpy( DD_dst->Pred_Q16,  DD_src->Pred_Q16,  sizeof( DD_src->Pred_Q16  ) );\r
+    SKP_memcpy( DD_dst->Shape_Q10, DD_src->Shape_Q10, sizeof( DD_src->Shape_Q10 ) );\r
+    SKP_memcpy( DD_dst->Xq_Q10,    DD_src->Xq_Q10,    sizeof( DD_src->Xq_Q10    ) );\r
+    SKP_memcpy( DD_dst->sAR2_Q14,  DD_src->sAR2_Q14,  sizeof( DD_src->sAR2_Q14  ) );\r
     SKP_memcpy( &DD_dst->sLPC_Q14[ LPC_state_idx ], &DD_src->sLPC_Q14[ LPC_state_idx ], NSQ_LPC_BUF_LENGTH * sizeof( SKP_int32 ) );\r
     DD_dst->LF_AR_Q12 = DD_src->LF_AR_Q12;\r
     DD_dst->Seed      = DD_src->Seed;\r