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