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