Remove an unreachable block in silk/float/pitch_analysis_core_FLP.c
[opus.git] / silk / float / prefilter_FLP.c
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions are met:
6 - Redistributions of source code must retain the above copyright notice,
7 this list of conditions and the following disclaimer.
8 - Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 - Neither the name of Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include "main_FLP.h"
33 #include "tuning_parameters.h"
34
35 /*
36 * silk_prefilter. Prefilter for finding Quantizer input signal
37 */
38 static inline void silk_prefilt_FLP(
39     silk_prefilter_state_FLP *P,/* I/O state */
40     silk_float st_res[],             /* I */
41     silk_float xw[],                 /* O */
42     silk_float *HarmShapeFIR,        /* I */
43     silk_float Tilt,                 /* I */
44     silk_float LF_MA_shp,            /* I */
45     silk_float LF_AR_shp,            /* I */
46     opus_int   lag,                  /* I */
47     opus_int   length                /* I */
48 );
49
50 void silk_warped_LPC_analysis_filter_FLP(
51           silk_float                 state[],            /* I/O  State [order + 1]                       */
52           silk_float                 res[],              /* O    Residual signal [length]                */
53     const silk_float                 coef[],             /* I    Coefficients [order]                    */
54     const silk_float                 input[],            /* I    Input signal [length]                   */
55     const silk_float                 lambda,             /* I    Warping factor                          */
56     const opus_int                   length,             /* I    Length of input signal                  */
57     const opus_int                   order               /* I    Filter order (even)                     */
58 )
59 {
60     opus_int     n, i;
61     silk_float   acc, tmp1, tmp2;
62
63     /* Order must be even */
64     silk_assert( ( order & 1 ) == 0 );
65
66     for( n = 0; n < length; n++ ) {
67         /* Output of lowpass section */
68         tmp2 = state[ 0 ] + lambda * state[ 1 ];
69         state[ 0 ] = input[ n ];
70         /* Output of allpass section */
71         tmp1 = state[ 1 ] + lambda * ( state[ 2 ] - tmp2 );
72         state[ 1 ] = tmp2;
73         acc = coef[ 0 ] * tmp2;
74         /* Loop over allpass sections */
75         for( i = 2; i < order; i += 2 ) {
76             /* Output of allpass section */
77             tmp2 = state[ i ] + lambda * ( state[ i + 1 ] - tmp1 );
78             state[ i ] = tmp1;
79             acc += coef[ i - 1 ] * tmp1;
80             /* Output of allpass section */
81             tmp1 = state[ i + 1 ] + lambda * ( state[ i + 2 ] - tmp2 );
82             state[ i + 1 ] = tmp2;
83             acc += coef[ i ] * tmp2;
84         }
85         state[ order ] = tmp1;
86         acc += coef[ order - 1 ] * tmp1;
87         res[ n ] = input[ n ] - acc;
88     }
89 }
90
91 /*
92 * silk_prefilter. Main prefilter function
93 */
94 void silk_prefilter_FLP(
95     silk_encoder_state_FLP          *psEnc,         /* I/O  Encoder state FLP                       */
96     const silk_encoder_control_FLP  *psEncCtrl,     /* I    Encoder control FLP                     */
97           silk_float                     xw[],           /* O    Weighted signal                         */
98     const silk_float                     x[]             /* I    Speech signal                           */
99 )
100 {
101     silk_prefilter_state_FLP *P = &psEnc->sPrefilt;
102     opus_int   j, k, lag;
103     silk_float HarmShapeGain, Tilt, LF_MA_shp, LF_AR_shp;
104     silk_float B[ 2 ];
105     const silk_float *AR1_shp;
106     const silk_float *px;
107     silk_float *pxw;
108     silk_float HarmShapeFIR[ 3 ];
109     silk_float st_res[ MAX_SUB_FRAME_LENGTH + MAX_LPC_ORDER ];
110
111     /* Setup pointers */
112     px  = x;
113     pxw = xw;
114     lag = P->lagPrev;
115     for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
116         /* Update Variables that change per sub frame */
117         if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
118             lag = psEncCtrl->pitchL[ k ];
119         }
120
121         /* Noise shape parameters */
122         HarmShapeGain = psEncCtrl->HarmShapeGain[ k ] * ( 1.0f - psEncCtrl->HarmBoost[ k ] );
123         HarmShapeFIR[ 0 ] = 0.25f               * HarmShapeGain;
124         HarmShapeFIR[ 1 ] = 32767.0f / 65536.0f * HarmShapeGain;
125         HarmShapeFIR[ 2 ] = 0.25f               * HarmShapeGain;
126         Tilt      =  psEncCtrl->Tilt[ k ];
127         LF_MA_shp =  psEncCtrl->LF_MA_shp[ k ];
128         LF_AR_shp =  psEncCtrl->LF_AR_shp[ k ];
129         AR1_shp   = &psEncCtrl->AR1[ k * MAX_SHAPE_LPC_ORDER ];
130
131         /* Short term FIR filtering */
132         silk_warped_LPC_analysis_filter_FLP( P->sAR_shp, st_res, AR1_shp, px,
133             (silk_float)psEnc->sCmn.warping_Q16 / 65536.0f, psEnc->sCmn.subfr_length, psEnc->sCmn.shapingLPCOrder );
134
135         /* Reduce (mainly) low frequencies during harmonic emphasis */
136         B[ 0 ] =  psEncCtrl->GainsPre[ k ];
137         B[ 1 ] = -psEncCtrl->GainsPre[ k ] *
138             ( psEncCtrl->HarmBoost[ k ] * HarmShapeGain + INPUT_TILT + psEncCtrl->coding_quality * HIGH_RATE_INPUT_TILT );
139         pxw[ 0 ] = B[ 0 ] * st_res[ 0 ] + B[ 1 ] * P->sHarmHP;
140         for( j = 1; j < psEnc->sCmn.subfr_length; j++ ) {
141             pxw[ j ] = B[ 0 ] * st_res[ j ] + B[ 1 ] * st_res[ j - 1 ];
142         }
143         P->sHarmHP = st_res[ psEnc->sCmn.subfr_length - 1 ];
144
145         silk_prefilt_FLP( P, pxw, pxw, HarmShapeFIR, Tilt, LF_MA_shp, LF_AR_shp, lag, psEnc->sCmn.subfr_length );
146
147         px  += psEnc->sCmn.subfr_length;
148         pxw += psEnc->sCmn.subfr_length;
149     }
150     P->lagPrev = psEncCtrl->pitchL[ psEnc->sCmn.nb_subfr - 1 ];
151 }
152
153 /*
154 * Prefilter for finding Quantizer input signal
155 */
156 static inline void silk_prefilt_FLP(
157     silk_prefilter_state_FLP *P,/* I/O state */
158     silk_float st_res[],                /* I */
159     silk_float xw[],                    /* O */
160     silk_float *HarmShapeFIR,        /* I */
161     silk_float Tilt,                    /* I */
162     silk_float LF_MA_shp,            /* I */
163     silk_float LF_AR_shp,            /* I */
164     opus_int   lag,                    /* I */
165     opus_int   length                /* I */
166 )
167 {
168     opus_int   i;
169     opus_int   idx, LTP_shp_buf_idx;
170     silk_float n_Tilt, n_LF, n_LTP;
171     silk_float sLF_AR_shp, sLF_MA_shp;
172     silk_float *LTP_shp_buf;
173
174     /* To speed up use temp variables instead of using the struct */
175     LTP_shp_buf     = P->sLTP_shp;
176     LTP_shp_buf_idx = P->sLTP_shp_buf_idx;
177     sLF_AR_shp      = P->sLF_AR_shp;
178     sLF_MA_shp      = P->sLF_MA_shp;
179
180     for( i = 0; i < length; i++ ) {
181         if( lag > 0 ) {
182             silk_assert( HARM_SHAPE_FIR_TAPS == 3 );
183             idx = lag + LTP_shp_buf_idx;
184             n_LTP  = LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 - 1) & LTP_MASK ] * HarmShapeFIR[ 0 ];
185             n_LTP += LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2    ) & LTP_MASK ] * HarmShapeFIR[ 1 ];
186             n_LTP += LTP_shp_buf[ ( idx - HARM_SHAPE_FIR_TAPS / 2 + 1) & LTP_MASK ] * HarmShapeFIR[ 2 ];
187         } else {
188             n_LTP = 0;
189         }
190
191         n_Tilt = sLF_AR_shp * Tilt;
192         n_LF   = sLF_AR_shp * LF_AR_shp + sLF_MA_shp * LF_MA_shp;
193
194         sLF_AR_shp = st_res[ i ] - n_Tilt;
195         sLF_MA_shp = sLF_AR_shp - n_LF;
196
197         LTP_shp_buf_idx = ( LTP_shp_buf_idx - 1 ) & LTP_MASK;
198         LTP_shp_buf[ LTP_shp_buf_idx ] = sLF_MA_shp;
199
200         xw[ i ] = sLF_MA_shp - n_LTP;
201     }
202     /* Copy temp variable back to state */
203     P->sLF_AR_shp       = sLF_AR_shp;
204     P->sLF_MA_shp       = sLF_MA_shp;
205     P->sLTP_shp_buf_idx = LTP_shp_buf_idx;
206 }