SILK update
[opus.git] / src_FLP / SKP_Silk_main_FLP.h
1 /***********************************************************************\r
2 Copyright (c) 2006-2010, 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_tables_FLP.h"\r
35 #include "SKP_Silk_main.h"\r
36 #include "SKP_Silk_define.h"\r
37 #include "SKP_debug.h"\r
38 #include "entenc.h"\r
39 \r
40 /* uncomment to compile without SSE optimizations */\r
41 //#undef SKP_USE_SSE\r
42 \r
43 #ifdef __cplusplus\r
44 extern "C"\r
45 {\r
46 #endif\r
47 \r
48 /*********************/\r
49 /* Encoder Functions */\r
50 /*********************/\r
51 \r
52 /* High-pass filter with cutoff frequency adaptation based on pitch lag statistics */\r
53 void SKP_Silk_HP_variable_cutoff_FLP(\r
54     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
55     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
56           SKP_int16                 *out,               /* O    High-pass filtered output signal        */\r
57     const SKP_int16                 *in                 /* I    Input signal                            */\r
58 );\r
59 \r
60 /* Encoder main function */\r
61 SKP_int SKP_Silk_encode_frame_FLP( \r
62     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
63     SKP_int32                       *pnBytesOut,        /* I/O  Number of payload bytes;                */\r
64                                                         /*      input: max length; output: used         */\r
65     ec_enc                          *psRangeEnc,        /* I/O  compressor data structure                */\r
66     const SKP_int16                 *pIn                /* I    Input speech frame                      */\r
67 );\r
68 \r
69 /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate           */\r
70 void SKP_Silk_LBRR_encode_FLP(\r
71     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
72     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
73           SKP_uint8                 *pCode,             /* O    Payload                                 */\r
74           SKP_int32                 *pnBytesOut,        /* I/O  Payload bytes; in: max; out: used       */\r
75     const SKP_float                 xfw[]               /* I    Input signal                            */\r
76 );\r
77 \r
78 /* Initializes the Silk encoder state */\r
79 SKP_int SKP_Silk_init_encoder_FLP(\r
80     SKP_Silk_encoder_state_FLP      *psEnc              /* I/O  Encoder state FLP                       */\r
81 );\r
82 \r
83 /* Control the Silk encoder */\r
84 SKP_int SKP_Silk_control_encoder_FLP( \r
85     SKP_Silk_encoder_state_FLP  *psEnc,                 /* I/O  Pointer to Silk encoder state FLP       */\r
86     const SKP_int               PacketSize_ms,          /* I    Packet length (ms)                      */\r
87     const SKP_int32             TargetRate_bps,         /* I    Target max bitrate (bps)                */\r
88     const SKP_int               PacketLoss_perc,        /* I    Packet loss rate (in percent)           */\r
89     const SKP_int               Complexity              /* I    Complexity (0->low; 1->medium; 2->high) */\r
90 );\r
91 \r
92 /****************/\r
93 /* Prefiltering */\r
94 /****************/\r
95 void SKP_Silk_prefilter_FLP(\r
96     SKP_Silk_encoder_state_FLP          *psEnc,         /* I/O  Encoder state FLP                       */\r
97     const SKP_Silk_encoder_control_FLP  *psEncCtrl,     /* I    Encoder control FLP                     */\r
98           SKP_float                     xw[],           /* O    Weighted signal                         */\r
99     const SKP_float                     x[]             /* I    Speech signal                           */\r
100 );\r
101 \r
102 /**************************/\r
103 /* Noise shaping analysis */\r
104 /**************************/\r
105 /* Compute noise shaping coefficients and initial gain values */\r
106 void SKP_Silk_noise_shape_analysis_FLP(\r
107     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
108     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
109     const SKP_float                 *pitch_res,         /* I    LPC residual from pitch analysis        */\r
110     const SKP_float                 *x                  /* I    Input signal [frame_length + la_shape]  */\r
111 );\r
112 \r
113 /* Autocorrelations for a warped frequency axis */\r
114 void SKP_Silk_warped_autocorrelation_FLP( \r
115           SKP_float                 *corr,              /* O    Result [order + 1]                      */\r
116     const SKP_float                 *input,             /* I    Input data to correlate                 */\r
117     const SKP_float                 warping,            /* I    Warping coefficient                     */\r
118     const SKP_int                   length,             /* I    Length of input                         */\r
119     const SKP_int                   order               /* I    Correlation order (even)                */\r
120 );\r
121 \r
122 /* Control low bitrate redundancy usage */\r
123 void SKP_Silk_LBRR_ctrl_FLP(\r
124     SKP_Silk_encoder_state_FLP      *psEnc,             /* I    Encoder state FLP                       */\r
125     SKP_Silk_encoder_control        *psEncCtrlC         /* I/O  Encoder control                         */\r
126 );\r
127 \r
128 /* Calculation of LTP state scaling */\r
129 void SKP_Silk_LTP_scale_ctrl_FLP(\r
130     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
131     SKP_Silk_encoder_control_FLP    *psEncCtrl          /* I/O  Encoder control FLP                     */\r
132 );\r
133 \r
134 /**********************************************/\r
135 /* Prediction Analysis                        */\r
136 /**********************************************/\r
137 /* Find pitch lags */\r
138 void SKP_Silk_find_pitch_lags_FLP(\r
139     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
140     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
141           SKP_float                 res[],              /* O    Residual                                */\r
142     const SKP_float                 x[]                 /* I    Speech signal                           */\r
143 );\r
144 \r
145 /* Find LPC and LTP coefficients */\r
146 void SKP_Silk_find_pred_coefs_FLP(\r
147     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
148     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
149     const SKP_float                 res_pitch[]         /* I    Residual from pitch analysis            */\r
150 );\r
151 \r
152 /* LPC analysis */\r
153 void SKP_Silk_find_LPC_FLP(\r
154           SKP_float                 NLSF[],             /* O    NLSFs                                   */\r
155           SKP_int                   *interpIndex,       /* O    NLSF interp. index for NLSF interp.     */\r
156     const SKP_float                 prev_NLSFq[],       /* I    Previous NLSFs, for NLSF interpolation  */\r
157     const SKP_int                   useInterpNLSFs,     /* I    Flag                                    */\r
158     const SKP_int                   LPC_order,          /* I    LPC order                               */\r
159     const SKP_float                 x[],                /* I    Input signal                            */\r
160     const SKP_int                   subfr_length,       /* I    Subframe length incl preceeding samples */\r
161     const SKP_int                   nb_subfr            /* I:   Number of subframes                     */\r
162 );\r
163 \r
164 /* LTP analysis */\r
165 void SKP_Silk_find_LTP_FLP(\r
166           SKP_float b[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    LTP coefs                               */\r
167           SKP_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O    Weight for LTP quantization       */\r
168           SKP_float *LTPredCodGain,                         /* O    LTP coding gain                         */\r
169     const SKP_float r_lpc[],                                /* I    LPC residual                            */\r
170     const SKP_int   lag[  MAX_NB_SUBFR ],                   /* I    LTP lags                                */\r
171     const SKP_float Wght[ MAX_NB_SUBFR ],                   /* I    Weights                                 */\r
172     const SKP_int   subfr_length,                           /* I    Subframe length                         */\r
173     const SKP_int   nb_subfr,                               /* I    number of subframes                     */\r
174     const SKP_int   mem_offset                              /* I    Number of samples in LTP memory         */\r
175 );\r
176 \r
177 void SKP_Silk_LTP_analysis_filter_FLP(\r
178           SKP_float         *LTP_res,                   /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */\r
179     const SKP_float         *x,                         /* I    Input signal, with preceeding samples       */\r
180     const SKP_float         B[ LTP_ORDER * MAX_NB_SUBFR ],  /* I    LTP coefficients for each subframe      */\r
181     const SKP_int           pitchL[   MAX_NB_SUBFR ],   /* I    Pitch lags                                  */\r
182     const SKP_float         invGains[ MAX_NB_SUBFR ],   /* I    Inverse quantization gains                  */\r
183     const SKP_int           subfr_length,               /* I    Length of each subframe                     */\r
184     const SKP_int           nb_subfr,                   /* I    number of subframes                         */\r
185     const SKP_int           pre_length                  /* I    Preceeding samples for each subframe        */\r
186 );\r
187 \r
188 /* Calculates residual energies of input subframes where all subframes have LPC_order   */\r
189 /* of preceeding samples                                                                */\r
190 void SKP_Silk_residual_energy_FLP(  \r
191           SKP_float             nrgs[ MAX_NB_SUBFR ],   /* O    Residual energy per subframe            */\r
192     const SKP_float             x[],                    /* I    Input signal                            */\r
193     const SKP_float             a[ 2 ][ MAX_LPC_ORDER ],/* I    AR coefs for each frame half            */\r
194     const SKP_float             gains[],                /* I    Quantization gains                      */\r
195     const SKP_int               subfr_length,           /* I    Subframe length                         */\r
196     const SKP_int               nb_subfr,               /* I    number of subframes                     */\r
197     const SKP_int               LPC_order               /* I    LPC order                               */\r
198 );\r
199 \r
200 /* 16th order LPC analysis filter */\r
201 void SKP_Silk_LPC_analysis_filter_FLP(\r
202           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
203     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
204     const SKP_float                 s[],                /* I    Input signal                            */\r
205     const SKP_int                   length,             /* I    Length of input signal                  */\r
206     const SKP_int                   Order               /* I    LPC order                               */\r
207 );\r
208 \r
209 /* 16th order LPC analysis filter, does not write first 16 samples */\r
210 void SKP_Silk_LPC_analysis_filter16_FLP(\r
211           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
212     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
213     const SKP_float                 s[],                /* I    Input signal                            */\r
214     const SKP_int                   length              /* I    Length of input signal                  */\r
215 );\r
216 \r
217 /* 12th order LPC analysis filter, does not write first 12 samples */\r
218 void SKP_Silk_LPC_analysis_filter12_FLP(\r
219           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
220     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
221     const SKP_float                 s[],                /* I    Input signal                            */\r
222     const SKP_int                   length              /* I    Length of input signal                  */\r
223 );\r
224 \r
225 /* 10th order LPC analysis filter, does not write first 10 samples */\r
226 void SKP_Silk_LPC_analysis_filter10_FLP(\r
227           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
228     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
229     const SKP_float                 s[],                /* I    Input signal                            */\r
230     const SKP_int                   length              /* I    Length of input signal                  */\r
231 );\r
232 \r
233 /* 8th order LPC analysis filter, does not write first 8 samples */\r
234 void SKP_Silk_LPC_analysis_filter8_FLP(\r
235           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
236     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
237     const SKP_float                 s[],                /* I    Input signal                            */\r
238     const SKP_int                   length              /* I    Length of input signal                  */\r
239 );\r
240 \r
241 /* 6th order LPC analysis filter, does not write first 6 samples */\r
242 void SKP_Silk_LPC_analysis_filter6_FLP(\r
243           SKP_float                 r_LPC[],            /* O    LPC residual signal                     */\r
244     const SKP_float                 PredCoef[],         /* I    LPC coefficients                        */\r
245     const SKP_float                 s[],                /* I    Input signal                            */\r
246     const SKP_int                   length              /* I    Length of input signal                  */\r
247 );\r
248 \r
249 /* LTP tap quantizer */\r
250 void SKP_Silk_quant_LTP_gains_FLP(\r
251           SKP_float B[ MAX_NB_SUBFR * LTP_ORDER ],          /* I/O  (Un-)quantized LTP gains                */\r
252           SKP_int   cbk_index[ MAX_NB_SUBFR ],              /* O    Codebook index                          */\r
253           SKP_int   *periodicity_index,                     /* O    Periodicity index                       */\r
254     const SKP_float W[ MAX_NB_SUBFR*LTP_ORDER*LTP_ORDER ],  /* I    Error weights                           */\r
255     const SKP_float mu,                                     /* I    Mu value (R/D tradeoff)                 */\r
256     const SKP_int   lowComplexity,                          /* I    Flag for low complexity                 */\r
257     const SKP_int   nb_subfr                                /* I    number of subframes                     */\r
258 );\r
259 \r
260 /******************/\r
261 /* NLSF Quantizer */\r
262 /******************/\r
263 /* Limit, stabilize, and quantize NLSFs */\r
264 void SKP_Silk_process_NLSFs_FLP(\r
265     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
266     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
267     SKP_float                       *pNLSF              /* I/O  NLSFs (quantized output)                */\r
268 );\r
269 \r
270 /* NLSF vector encoder */\r
271 void SKP_Silk_NLSF_MSVQ_encode_FLP(\r
272           SKP_int                   *NLSFIndices,       /* O    Codebook path vector [ CB_STAGES ]      */\r
273           SKP_float                 *pNLSF,             /* I/O  Quantized NLSF vector [ LPC_ORDER ]     */\r
274     const SKP_Silk_NLSF_CB_FLP      *psNLSF_CB_FLP,     /* I    Codebook object                         */\r
275     const SKP_float                 *pNLSF_q_prev,      /* I    Prev. quantized NLSF vector [LPC_ORDER] */\r
276     const SKP_float                 *pW,                /* I    NLSF weight vector [ LPC_ORDER ]        */\r
277     const SKP_float                 NLSF_mu,            /* I    Rate weight for the RD optimization     */\r
278     const SKP_float                 NLSF_mu_fluc_red,   /* I    Fluctuation reduction error weight      */\r
279     const SKP_int                   NLSF_MSVQ_Survivors,/* I    Max survivors from each stage           */\r
280     const SKP_int                   LPC_order,          /* I    LPC order                               */\r
281     const SKP_int                   deactivate_fluc_red /* I    Deactivate fluctuation reduction        */\r
282 );\r
283 \r
284 /* Rate-Distortion calculations for multiple input data vectors */\r
285 void SKP_Silk_NLSF_VQ_rate_distortion_FLP(\r
286           SKP_float             *pRD,               /* O   Rate-distortion values [psNLSF_CBS_FLP->nVectors*N] */\r
287     const SKP_Silk_NLSF_CBS_FLP *psNLSF_CBS_FLP,    /* I   NLSF codebook stage struct                          */\r
288     const SKP_float             *in,                /* I   Input vectors to be quantized                       */\r
289     const SKP_float             *w,                 /* I   Weight vector                                       */\r
290     const SKP_float             *rate_acc,          /* I   Accumulated rates from previous stage               */\r
291     const SKP_float             mu,                 /* I   Weight between weighted error and rate              */\r
292     const SKP_int               N,                  /* I   Number of input vectors to be quantized             */\r
293     const SKP_int               LPC_order           /* I   LPC order                                           */\r
294 );\r
295 \r
296 /* Compute weighted quantization errors for an LPC_order element input vector, over one codebook stage */\r
297 void SKP_Silk_NLSF_VQ_sum_error_FLP(\r
298           SKP_float                 *err,               /* O    Weighted quantization errors [ N * K ]  */\r
299     const SKP_float                 *in,                /* I    Input vectors [ N * LPC_order ]         */\r
300     const SKP_float                 *w,                 /* I    Weighting vectors [ N * LPC_order ]     */\r
301     const SKP_float                 *pCB,               /* I    Codebook vectors [ K * LPC_order ]      */\r
302     const SKP_int                   N,                  /* I    Number of input vectors                 */\r
303     const SKP_int                   K,                  /* I    Number of codebook vectors              */\r
304     const SKP_int                   LPC_order           /* I    LPC order                               */\r
305 );\r
306 \r
307 /* NLSF vector decoder */\r
308 void SKP_Silk_NLSF_MSVQ_decode_FLP(\r
309           SKP_float                 *pNLSF,             /* O    Decoded output vector [ LPC_ORDER ]     */\r
310     const SKP_Silk_NLSF_CB_FLP      *psNLSF_CB_FLP,     /* I    NLSF codebook struct                    */  \r
311     const SKP_int                   *NLSFIndices,       /* I    NLSF indices [ nStages ]                */\r
312     const SKP_int                   LPC_order           /* I    LPC order used                          */\r
313 );\r
314 \r
315 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */\r
316 SKP_float SKP_Silk_residual_energy_covar_FLP(           /* O    Weighted residual energy                */\r
317     const SKP_float                 *c,                 /* I    Filter coefficients                     */\r
318           SKP_float                 *wXX,               /* I/O  Weighted correlation matrix, reg. out   */\r
319     const SKP_float                 *wXx,               /* I    Weighted correlation vector             */\r
320     const SKP_float                 wxx,                /* I    Weighted correlation value              */\r
321     const SKP_int                   D                   /* I    Dimension                               */\r
322 );\r
323 \r
324 /* Entropy constrained MATRIX-weighted VQ, for a single input data vector */\r
325 void SKP_Silk_VQ_WMat_EC_FLP(\r
326           SKP_int                   *ind,               /* O    Index of best codebook vector           */\r
327           SKP_float                 *rate_dist,         /* O    Best weighted quant. error + mu * rate  */\r
328     const SKP_float                 *in,                /* I    Input vector to be quantized            */\r
329     const SKP_float                 *W,                 /* I    Weighting matrix                        */\r
330     const SKP_int16                 *cb,                /* I    Codebook                                */\r
331     const SKP_int16                 *cl_Q6,             /* I    Code length for each codebook vector    */\r
332     const SKP_float                 mu,                 /* I    Tradeoff between WSSE and rate          */\r
333     const SKP_int                   L                   /* I    Number of vectors in codebook           */\r
334 );\r
335 \r
336 /* Processing of gains */\r
337 void SKP_Silk_process_gains_FLP(\r
338     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
339     SKP_Silk_encoder_control_FLP    *psEncCtrl          /* I/O  Encoder control FLP                     */\r
340 );\r
341 \r
342 /******************/\r
343 /* Linear Algebra */\r
344 /******************/\r
345 /* Calculates correlation matrix X'*X */\r
346 void SKP_Silk_corrMatrix_FLP(\r
347     const SKP_float                 *x,                 /* I    x vector [ L+order-1 ] used to create X */\r
348     const SKP_int                   L,                  /* I    Length of vectors                       */\r
349     const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
350           SKP_float                 *XX                 /* O    X'*X correlation matrix [order x order] */\r
351 );\r
352 \r
353 /* Calculates correlation vector X'*t */\r
354 void SKP_Silk_corrVector_FLP(\r
355     const SKP_float                 *x,                 /* I    x vector [L+order-1] used to create X   */\r
356     const SKP_float                 *t,                 /* I    Target vector [L]                       */\r
357     const SKP_int                   L,                  /* I    Length of vecors                        */\r
358     const SKP_int                   Order,              /* I    Max lag for correlation                 */\r
359           SKP_float                 *Xt                 /* O    X'*t correlation vector [order]         */\r
360 );\r
361 \r
362 /* Add noise to matrix diagonal */\r
363 void SKP_Silk_regularize_correlations_FLP(\r
364           SKP_float                 *XX,                /* I/O  Correlation matrices                    */\r
365           SKP_float                 *xx,                /* I/O  Correlation values                      */\r
366     const SKP_float                 noise,              /* I    Noise energy to add                     */\r
367     const SKP_int                   D                   /* I    Dimension of XX                         */\r
368 );\r
369 \r
370 /* Function to solve linear equation Ax = b, where A is an MxM symmetric matrix */\r
371 void SKP_Silk_solve_LDL_FLP(\r
372           SKP_float                 *A,                 /* I/O  Symmetric square matrix, out: reg.      */\r
373     const SKP_int                   M,                  /* I    Size of matrix                          */\r
374     const SKP_float                 *b,                 /* I    Pointer to b vector                     */\r
375           SKP_float                 *x                  /* O    Pointer to x solution vector            */\r
376 );\r
377 \r
378 /* Apply sine window to signal vector.                                                                  */\r
379 /* Window types:                                                                                        */\r
380 /*  1 -> sine window from 0 to pi/2                                                                     */\r
381 /*  2 -> sine window from pi/2 to pi                                                                    */\r
382 void SKP_Silk_apply_sine_window_FLP(\r
383           SKP_float                 px_win[],           /* O    Pointer to windowed signal              */\r
384     const SKP_float                 px[],               /* I    Pointer to input signal                 */\r
385     const SKP_int                   win_type,           /* I    Selects a window type                   */\r
386     const SKP_int                   length              /* I    Window length, multiple of 4            */\r
387 );\r
388 \r
389 /* Wrappers. Calls flp / fix code */\r
390 \r
391 /* Convert AR filter coefficients to NLSF parameters */\r
392 void SKP_Silk_A2NLSF_FLP( \r
393           SKP_float                 *pNLSF,             /* O    NLSF vector      [ LPC_order ]          */\r
394     const SKP_float                 *pAR,               /* I    LPC coefficients [ LPC_order ]          */\r
395     const SKP_int                   LPC_order           /* I    LPC order                               */\r
396 );\r
397 \r
398 /* Convert NLSF parameters to AR prediction filter coefficients */\r
399 void SKP_Silk_NLSF2A_stable_FLP( \r
400           SKP_float                 *pAR,               /* O    LPC coefficients [ LPC_order ]          */\r
401     const SKP_float                 *pNLSF,             /* I    NLSF vector      [ LPC_order ]          */\r
402     const SKP_int                   LPC_order           /* I    LPC order                               */\r
403 );\r
404 \r
405 /* NLSF stabilizer, for a single input data vector */\r
406 void SKP_Silk_NLSF_stabilize_FLP(\r
407           SKP_float                 *pNLSF,             /* I/O  (Un)stable NLSF vector [ LPC_order ]    */\r
408     const SKP_float                 *pNDelta_min,       /* I    Normalized delta min vector[LPC_order+1]*/\r
409     const SKP_int                   LPC_order           /* I    LPC order                               */\r
410 );\r
411 \r
412 /* Interpolation function with fixed point rounding */\r
413 void SKP_Silk_interpolate_wrapper_FLP(\r
414           SKP_float                 xi[],               /* O    Interpolated vector                     */\r
415     const SKP_float                 x0[],               /* I    First vector                            */\r
416     const SKP_float                 x1[],               /* I    Second vector                           */\r
417     const SKP_float                 ifact,              /* I    Interp. factor, weight on second vector */\r
418     const SKP_int                   d                   /* I    Number of parameters                    */\r
419 );\r
420 \r
421 /****************************************/\r
422 /* Floating-point Silk VAD wrapper      */\r
423 /****************************************/\r
424 SKP_int SKP_Silk_VAD_FLP(\r
425     SKP_Silk_encoder_state_FLP      *psEnc,             /* I/O  Encoder state FLP                       */\r
426     SKP_Silk_encoder_control_FLP    *psEncCtrl,         /* I/O  Encoder control FLP                     */\r
427     const SKP_int16                 *pIn                /* I    Input signal                            */\r
428 );\r
429 \r
430 /****************************************/\r
431 /* Floating-point Silk NSQ wrapper      */\r
432 /****************************************/\r
433 void SKP_Silk_NSQ_wrapper_FLP(\r
434     SKP_Silk_encoder_state_FLP      *psEnc,         /* I/O  Encoder state FLP                           */\r
435     SKP_Silk_encoder_control_FLP    *psEncCtrl,     /* I/O  Encoder control FLP                         */\r
436     const SKP_float                 x[],            /* I    Prefiltered input signal                    */\r
437           SKP_int8                  q[],            /* O    Quantized pulse signal                      */\r
438     const SKP_int                   useLBRR         /* I    LBRR flag                                   */\r
439 );\r
440 \r
441 /* using log2() helps the fixed-point conversion */\r
442 SKP_INLINE SKP_float SKP_Silk_log2( double x ) { return ( SKP_float )( 3.32192809488736 * log10( x ) ); }\r
443 \r
444 #ifdef __cplusplus\r
445 }\r
446 #endif\r
447 \r
448 #endif\r