Squashed commit of the following:
[opus.git] / silk / float / SKP_Silk_main_FLP.h
1 /***********************************************************************\r
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
3 Redistribution and use in source and binary forms, with or without \r
4 modification, (subject to the limitations in the disclaimer below) \r
5 are permitted provided that the following conditions are met:\r
6 - Redistributions of source code must retain the above copyright notice,\r
7 this list of conditions and the following disclaimer.\r
8 - Redistributions in binary form must reproduce the above copyright \r
9 notice, this list of conditions and the following disclaimer in the \r
10 documentation and/or other materials provided with the distribution.\r
11 - Neither the name of Skype Limited, nor the names of specific \r
12 contributors, may be used to endorse or promote products derived from \r
13 this software without specific prior written permission.\r
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
26 ***********************************************************************/\r
27 \r
28 #ifndef SKP_SILK_MAIN_FLP_H\r
29 #define SKP_SILK_MAIN_FLP_H\r
30 \r
31 #include "SKP_Silk_SigProc_FLP.h"\r
32 #include "SKP_Silk_SigProc_FIX.h"\r
33 #include "SKP_Silk_structs_FLP.h"\r
34 #include "SKP_Silk_main.h"\r
35 #include "SKP_Silk_define.h"\r
36 #include "SKP_debug.h"\r
37 #include "entenc.h"\r
38 \r
39 #ifdef __cplusplus\r
40 extern "C"\r
41 {\r
42 #endif\r
43 \r
44 /*********************/\r
45 /* Encoder Functions */\r
46 /*********************/\r
47 \r
48 /* Encoder main function */\r
49 SKP_int SKP_Silk_encode_frame_FLP( \r
50     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
51     SKP_int32                       *pnBytesOut,        /*   O  Number of payload bytes;                */\r
52     ec_enc                          *psRangeEnc         /* I/O  compressor data structure                */\r
53 );\r
54 \r
55 /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate           */\r
56 void SKP_Silk_LBRR_encode_FLP(\r
57     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
58     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
59     const SKP_float                 xfw[]               /* I    Input signal                            */\r
60 );\r
61 \r
62 /* Initializes the Silk encoder state */\r
63 SKP_int SKP_Silk_init_encoder(\r
64     SKP_Silk_encoder_state_FLP      *psEnc              /* I/O  Encoder state FLP                       */\r
65 );\r
66 \r
67 /* Control the Silk encoder */\r
68 SKP_int SKP_Silk_control_encoder( \r
69     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Pointer to Silk encoder state FLP       */\r
70     SKP_SILK_SDK_EncControlStruct   *encControl,        /* I:   Control structure                       */\r
71     const SKP_int32                 TargetRate_bps,     /* I    Target max bitrate (bps)                */\r
72     const SKP_int                   allow_bw_switch,    /* I    Flag to allow switching audio bandwidth */\r
73     const SKP_int                   channelNb           /* I    Channel number                          */\r
74 );\r
75 \r
76 /****************/\r
77 /* Prefiltering */\r
78 /****************/\r
79 void SKP_Silk_prefilter_FLP(\r
80     SKP_Silk_encoder_state_FLP          *psEnc,         /* I/O  Encoder state FLP                       */\r
81     const SKP_Silk_encoder_control_FLP  *psEncCtrl,     /* I    Encoder control FLP                     */\r
82           SKP_float                     xw[],           /* O    Weighted signal                         */\r
83     const SKP_float                     x[]             /* I    Speech signal                           */\r
84 );\r
85 \r
86 /**************************/\r
87 /* Noise shaping analysis */\r
88 /**************************/\r
89 /* Compute noise shaping coefficients and initial gain values */\r
90 void SKP_Silk_noise_shape_analysis_FLP(\r
91     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
92     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
93     const SKP_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */\r
94     const SKP_float                 *x                  /* I    Input signal [frame_length + la_shape]  */\r
95 );\r
96 \r
97 /* Autocorrelations for a warped frequency axis */\r
98 void SKP_Silk_warped_autocorrelation_FLP( \r
99           SKP_float                 *corr,              /* O    Result [order + 1]                      */\r
100     const SKP_float                 *input,             /* I    Input data to correlate                 */\r
101     const SKP_float                 warping,            /* I    Warping coefficient                     */\r
102     const SKP_int                   length,             /* I    Length of input                         */\r
103     const SKP_int                   order               /* I    Correlation order (even)                */\r
104 );\r
105 \r
106 /* Calculation of LTP state scaling */\r
107 void SKP_Silk_LTP_scale_ctrl_FLP(\r
108     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
109     SKP_Silk_encoder_control_FLP    *psEncCtrl          /* I/O  Encoder control FLP                     */\r
110 );\r
111 \r
112 /**********************************************/\r
113 /* Prediction Analysis                        */\r
114 /**********************************************/\r
115 /* Find pitch lags */\r
116 void SKP_Silk_find_pitch_lags_FLP(\r
117     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
118     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
119           SKP_float                 res[],              /* O    Residual                                */\r
120     const SKP_float                 x[]                 /* I    Speech signal                           */\r
121 );\r
122 \r
123 /* Find LPC and LTP coefficients */\r
124 void SKP_Silk_find_pred_coefs_FLP(\r
125     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
126     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
127     const SKP_float                 res_pitch[],        /* I    Residual from pitch analysis            */\r
128     const SKP_float                 x[]                 /* I    Speech signal                           */\r
129 );\r
130 \r
131 /* LPC analysis */\r
132 void SKP_Silk_find_LPC_FLP(\r
133           SKP_int16                 NLSF_Q15[],             /* O    NLSFs                                   */\r
134           SKP_int8                  *interpIndex,           /* O    NLSF interp. index for NLSF interp.     */\r
135     const SKP_int16                 prev_NLSFq_Q15[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
136     const SKP_int                   useInterpNLSFs,         /* I    Flag                                    */\r
137     const SKP_int                   firstFrameAfterReset,   /* I    Flag                                    */\r
138     const SKP_int                   LPC_order,              /* I    LPC order                               */\r
139     const SKP_float                 x[],                    /* I    Input signal                            */\r
140     const SKP_int                   subfr_length,           /* I    Subframe length incl preceeding samples */\r
141     const SKP_int                   nb_subfr                /* I:   Number of subframes                     */\r
142 );\r
143 \r
144 /* LTP analysis */\r
145 void SKP_Silk_find_LTP_FLP(\r
146           SKP_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */\r
147           SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */\r
148           SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */\r
149     const SKP_float r_lpc[],                                /* I    LPC residual                            */\r
150     const SKP_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
151     const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */\r
152     const SKP_int   subfr_length,                           /* I    Subframe length                         */\r
153     const SKP_int   nb_subfr,                               /* I    number of subframes                     */\r
154     const SKP_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
155 );\r
156 \r
157 void SKP_Silk_LTP_analysis_filter_FLP(\r
158           SKP_float         *LTP_res,                   /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */\r
159     const SKP_float         *x,                         /* I    Input signal, with preceeding samples       */\r
160     const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe      */\r
161     const SKP_int           pitchL[   MAX_NB_SUBFR ],   /* I    Pitch lags                                  */\r
162     const SKP_float         invGains[ MAX_NB_SUBFR ],   /* I    Inverse quantization gains                  */\r
163     const SKP_int           subfr_length,               /* I    Length of each subframe                     */\r
164     const SKP_int           nb_subfr,                   /* I    number of subframes                         */\r
165     const SKP_int           pre_length                  /* I    Preceeding samples for each subframe        */\r
166 );\r
167 \r
168 /* Calculates residual energies of input subframes where all subframes have LPC_order   */\r
169 /* of preceeding samples                                                                */\r
170 void SKP_Silk_residual_energy_FLP(  \r
171           SKP_float             nrgs[ MAX_NB_SUBFR ],   /* O    Residual energy per subframe            */\r
172     const SKP_float             x[],                    /* I    Input signal                            */\r
173     const SKP_float             a[ 2 ][ MAX_LPC_ORDER ],/* I    AR coefs for each frame half            */\r
174     const SKP_float             gains[],                /* I    Quantization gains                      */\r
175     const SKP_int               subfr_length,           /* I    Subframe length                         */\r
176     const SKP_int               nb_subfr,               /* I    number of subframes                     */\r
177     const SKP_int               LPC_order               /* I    LPC order                               */\r
178 );\r
179 \r
180 /* 16th order LPC analysis filter */\r
181 void SKP_Silk_LPC_analysis_filter_FLP(\r
182           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
183     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
184     const SKP_float                 s[],                /* I    Input signal                            */\r
185     const SKP_int                   length,             /* I    Length of input signal                  */\r
186     const SKP_int                   Order               /* I    LPC order                               */\r
187 );\r
188 \r
189 /* LTP tap quantizer */\r
190 void SKP_Silk_quant_LTP_gains_FLP(\r
191           SKP_float B[ MAX_NB_SUBFR * LTP_ORDER ],              /* I/O  (Un-)quantized LTP gains                */\r
192           SKP_int8  cbk_index[ MAX_NB_SUBFR ],                  /* O    Codebook index                          */\r
193           SKP_int8  *periodicity_index,                         /* O    Periodicity index                       */\r
194     const SKP_float W[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ],  /* I    Error weights                           */\r
195     const SKP_int   mu_Q10,                                     /* I    Mu value (R/D tradeoff)                 */\r
196     const SKP_int   lowComplexity,                              /* I    Flag for low complexity                 */\r
197     const SKP_int   nb_subfr                                    /* I    number of subframes                     */\r
198 );\r
199 \r
200 /******************/\r
201 /* NLSF Quantizer */\r
202 /******************/\r
203 /* Limit, stabilize, and quantize NLSFs */\r
204 void SKP_Silk_process_NLSFs_FLP(\r
205     SKP_Silk_encoder_state          *psEncC,                            /* I/O  Encoder state                               */\r
206     SKP_float                       PredCoef[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */\r
207     SKP_int16                       NLSF_Q15[      MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */\r
208     const SKP_int16                 prev_NLSF_Q15[ MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */\r
209 );\r
210 \r
211 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
212 SKP_float SKP_Silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */\r
213     const SKP_float                 *c,                 /* I    Filter coefficients                     */\r
214           SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */\r
215     const SKP_float                 *wXx,               /* I    Weighted correlation vector             */\r
216     const SKP_float                 wxx,                /* I    Weighted correlation value              */\r
217     const SKP_int                   D                   /* I    Dimension                               */\r
218 );\r
219 \r
220 /* Entropy constrained MATRIX-weighted VQ, for a single input data vector */\r
221 void SKP_Silk_VQ_WMat_EC_FLP(\r
222           SKP_int                   *ind,               /* O    Index of best codebook vector           */\r
223           SKP_float                 *rate_dist,         /* O    Best weighted quant. error + mu * rate  */\r
224     const SKP_float                 *in,                /* I    Input vector to be quantized            */\r
225     const SKP_float                 *W,                 /* I    Weighting matrix                        */\r
226     const SKP_int16                 *cb,                /* I    Codebook                                */\r
227     const SKP_int16                 *cl_Q6,             /* I    Code length for each codebook vector    */\r
228     const SKP_float                 mu,                 /* I    Tradeoff between WSSE and rate          */\r
229     const SKP_int                   L                   /* I    Number of vectors in codebook           */\r
230 );\r
231 \r
232 /* Processing of gains */\r
233 void SKP_Silk_process_gains_FLP(\r
234     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
235     SKP_Silk_encoder_control_FLP    *psEncCtrl          /* I/O  Encoder control FLP                     */\r
236 );\r
237 \r
238 /******************/\r
239 /* Linear Algebra */\r
240 /******************/\r
241 /* Calculates correlation matrix X'*X */\r
242 void SKP_Silk_corrMatrix_FLP(\r
243     const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */\r
244     const SKP_int                   L,                  /* I    Length of vectors                       */\r
245     const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
246           SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */\r
247 );\r
248 \r
249 /* Calculates correlation vector X'*t */\r
250 void SKP_Silk_corrVector_FLP(\r
251     const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */\r
252     const SKP_float                 *t,                 /* I    Target vector [L]                       */\r
253     const SKP_int                   L,                  /* I    Length of vecors                        */\r
254     const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
255           SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */\r
256 );\r
257 \r
258 /* Add noise to matrix diagonal */\r
259 void SKP_Silk_regularize_correlations_FLP(\r
260           SKP_float                 *XX,                /* I/O  Correlation matrices                    */\r
261           SKP_float                 *xx,                /* I/O  Correlation values                      */\r
262     const SKP_float                 noise,              /* I    Noise energy to add                     */\r
263     const SKP_int                   D                   /* I    Dimension of XX                         */\r
264 );\r
265 \r
266 /* Function to solve linear equation Ax = b, where A is an MxM symmetric matrix */\r
267 void SKP_Silk_solve_LDL_FLP(\r
268           SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */\r
269     const SKP_int                   M,                  /* I    Size of matrix                          */\r
270     const SKP_float                 *b,                 /* I    Pointer to b vector                     */\r
271           SKP_float                 *x                  /* O    Pointer to x solution vector            */\r
272 );\r
273 \r
274 /* Apply sine window to signal vector.                                                                  */\r
275 /* Window types:                                                                                        */\r
276 /*  1 -> sine window from 0 to pi/2                                                                     */\r
277 /*  2 -> sine window from pi/2 to pi                                                                    */\r
278 void SKP_Silk_apply_sine_window_FLP(\r
279           SKP_float                 px_win[],           /* O    Pointer to windowed signal              */\r
280     const SKP_float                 px[],               /* I    Pointer to input signal                 */\r
281     const SKP_int                   win_type,           /* I    Selects a window type                   */\r
282     const SKP_int                   length              /* I    Window length, multiple of 4            */\r
283 );\r
284 \r
285 /* Wrappers. Calls flp / fix code */\r
286 \r
287 /* Convert AR filter coefficients to NLSF parameters */\r
288 void SKP_Silk_A2NLSF_FLP( \r
289           SKP_int16                 *NLSF_Q15,          /* O    NLSF vector      [ LPC_order ]          */\r
290     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
291     const SKP_int                   LPC_order           /* I    LPC order                               */\r
292 );\r
293 \r
294 /* Convert NLSF parameters to AR prediction filter coefficients */\r
295 void SKP_Silk_NLSF2A_stable_FLP( \r
296           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
297     const SKP_int16                 *NLSF_Q15,          /* I    NLSF vector      [ LPC_order ]          */\r
298     const SKP_int                   LPC_order           /* I    LPC order                               */\r
299 );\r
300 \r
301 /****************************************/\r
302 /* Floating-point Silk NSQ wrapper      */\r
303 /****************************************/\r
304 void SKP_Silk_NSQ_wrapper_FLP(\r
305     SKP_Silk_encoder_state_FLP      *psEnc,         /* I/O  Encoder state FLP                           */\r
306     SKP_Silk_encoder_control_FLP    *psEncCtrl,     /* I/O  Encoder control FLP                         */\r
307     SideInfoIndices                 *psIndices,     /* I/O  Quantization indices                        */\r
308     SKP_Silk_nsq_state              *psNSQ,         /* I/O  Noise Shaping Quantzation state             */\r
309           SKP_int8                  pulses[],       /* O    Quantized pulse signal                      */\r
310     const SKP_float                 x[]             /* I    Prefiltered input signal                    */\r
311 );\r
312 \r
313 /* using log2() helps the fixed-point conversion */\r
314 SKP_INLINE SKP_float SKP_Silk_log2( double x ) { return ( SKP_float )( 3.32192809488736 * log10( x ) ); }\r
315 \r
316 #ifdef __cplusplus\r
317 }\r
318 #endif\r
319 \r
320 #endif\r