SILK update with LBRR and some bugfixes
[opus.git] / src_SigProc_FIX / SKP_Silk_SigProc_FIX.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 \r
29 #ifndef _SKP_SILK_SIGPROC_FIX_H_\r
30 #define _SKP_SILK_SIGPROC_FIX_H_\r
31 \r
32 #ifdef  __cplusplus\r
33 extern "C"\r
34 {\r
35 #endif\r
36 \r
37 //#define SKP_MACRO_COUNT /* Used to enable WMOPS counting */\r
38 \r
39 #define SKP_Silk_MAX_ORDER_LPC            16                    /* max order of the LPC analysis in schur() and k2a()    */\r
40 #define SKP_Silk_MAX_CORRELATION_LENGTH   640                   /* max input length to the correlation                   */\r
41 #include "SKP_Silk_typedef.h"\r
42 #include <string.h>\r
43 #include <stdlib.h>                                            /* for abs() */\r
44 #include "SKP_Silk_resampler_structs.h"\r
45 \r
46 #       include "SKP_Silk_macros.h"\r
47 \r
48 \r
49 \r
50 /********************************************************************/\r
51 /*                    SIGNAL PROCESSING FUNCTIONS                   */\r
52 /********************************************************************/\r
53 \r
54 /*!\r
55  * Initialize/reset the resampler state for a given pair of input/output sampling rates \r
56 */\r
57 SKP_int SKP_Silk_resampler_init( \r
58         SKP_Silk_resampler_state_struct *S,                     /* I/O: Resampler state                         */\r
59         SKP_int32                                                       Fs_Hz_in,       /* I:   Input sampling rate (Hz)        */\r
60         SKP_int32                                                       Fs_Hz_out       /* I:   Output sampling rate (Hz)       */\r
61 );\r
62 \r
63 \r
64 /*!\r
65  * Clear the states of all resampling filters, without resetting sampling rate ratio \r
66  */\r
67 SKP_int SKP_Silk_resampler_clear( \r
68         SKP_Silk_resampler_state_struct *S                      /* I/O: Resampler state                         */\r
69 );\r
70 \r
71 /*!\r
72  * Resampler: convert from one sampling rate to another\r
73  */\r
74 SKP_int SKP_Silk_resampler( \r
75         SKP_Silk_resampler_state_struct *S,                     /* I/O: Resampler state                         */\r
76         SKP_int16                                                       out[],      /* O:       Output signal                           */\r
77         const SKP_int16                                         in[],       /* I:       Input signal                            */\r
78         SKP_int32                                                       inLen       /* I:       Number of input samples         */\r
79 );\r
80 \r
81 /*!\r
82  Upsample 2x, low quality \r
83  */\r
84 void SKP_Silk_resampler_up2(\r
85     SKP_int32                           *S,         /* I/O: State vector [ 2 ]                  */\r
86     SKP_int16                           *out,       /* O:   Output signal [ 2 * len ]           */\r
87     const SKP_int16                     *in,        /* I:   Input signal [ len ]                */\r
88     SKP_int32                           len         /* I:   Number of input samples             */\r
89 );\r
90 \r
91 /*!\r
92 * Downsample 2x, mediocre quality \r
93 */\r
94 void SKP_Silk_resampler_down2(\r
95     SKP_int32                           *S,         /* I/O: State vector [ 2 ]                  */\r
96     SKP_int16                           *out,       /* O:   Output signal [ len ]               */\r
97     const SKP_int16                     *in,        /* I:   Input signal [ floor(len/2) ]       */\r
98     SKP_int32                           inLen       /* I:   Number of input samples             */\r
99 );\r
100 \r
101 \r
102 /*!\r
103  * Downsample by a factor 2/3, low quality\r
104 */\r
105 void SKP_Silk_resampler_down2_3(\r
106     SKP_int32                           *S,         /* I/O: State vector [ 6 ]                  */\r
107     SKP_int16                           *out,       /* O:   Output signal [ floor(2*inLen/3) ]  */\r
108     const SKP_int16                     *in,        /* I:   Input signal [ inLen ]              */\r
109     SKP_int32                           inLen       /* I:   Number of input samples             */\r
110 );\r
111 \r
112 /*!\r
113  * Downsample by a factor 3, low quality\r
114 */\r
115 void SKP_Silk_resampler_down3(\r
116     SKP_int32                           *S,         /* I/O: State vector [ 8 ]                  */\r
117     SKP_int16                           *out,       /* O:   Output signal [ floor(inLen/3) ]    */\r
118     const SKP_int16                     *in,        /* I:   Input signal [ inLen ]              */\r
119     SKP_int32                           inLen       /* I:   Number of input samples             */\r
120 );\r
121 \r
122 /*! \r
123  * First order low-pass filter, with input as SKP_int16, running at 48 kHz \r
124  */\r
125 void SKP_Silk_lowpass_short(\r
126     const SKP_int16      *in,           /* I:   Q15 48 kHz signal; [len]    */\r
127     SKP_int32            *S,            /* I/O: Q25 state; length = 1       */\r
128     SKP_int32            *out,          /* O:   Q25 48 kHz signal; [len]    */\r
129     const SKP_int32      len            /* O:   Signal length               */\r
130 );\r
131 \r
132 /*! \r
133  * First order low-pass filter, with input as SKP_int32, running at 48 kHz \r
134  */\r
135 void SKP_Silk_lowpass_int(\r
136     const SKP_int32      *in,           /* I:   Q25 48 kHz signal; length = len  */\r
137     SKP_int32            *S,            /* I/O: Q25 state; length = 1            */\r
138     SKP_int32            *out,          /* O:   Q25 48 kHz signal; length = len  */\r
139     const SKP_int32      len            /* I:   Number of samples                */\r
140 );\r
141 \r
142 /*! \r
143  * First-order allpass filter \r
144  */\r
145 void SKP_Silk_allpass_int(\r
146     const SKP_int32      *in,          /* I:   Q25 input signal [len]               */\r
147     SKP_int32            *S,           /* I/O: Q25 state [1]                        */\r
148     SKP_int              A,            /* I:   Q15 coefficient    (0 <= A < 32768)  */\r
149     SKP_int32            *out,         /* O:   Q25 output signal [len]              */\r
150     const SKP_int32      len           /* I:   Number of samples                    */\r
151 );\r
152 \r
153 /*!\r
154  * second order ARMA filter; \r
155  * slower than biquad() but uses more precise coefficients\r
156  * can handle (slowly) varying coefficients \r
157  */\r
158 void SKP_Silk_biquad_alt(\r
159     const SKP_int16     *in,           /* I:    input signal                 */\r
160     const SKP_int32     *B_Q28,        /* I:    MA coefficients [3]          */\r
161     const SKP_int32     *A_Q28,        /* I:    AR coefficients [2]          */\r
162     SKP_int32           *S,            /* I/O: state vector [2]              */\r
163     SKP_int16           *out,          /* O:    output signal                */\r
164     const SKP_int32     len            /* I:    signal length (must be even) */\r
165 );\r
166 \r
167 /*! \r
168  * variable order MA filter. Prediction error filter implementation. Coeficients negated and starting with coef to x[n - 1]\r
169  */\r
170 void SKP_Silk_MA_Prediction(\r
171     const SKP_int16      *in,          /* I:   Input signal                                */\r
172     const SKP_int16      *B,           /* I:   MA prediction coefficients, Q12 [order]     */\r
173     SKP_int32            *S,           /* I/O: State vector [order]                        */\r
174     SKP_int16            *out,         /* O:   Output signal                               */\r
175     const SKP_int32      len,          /* I:   Signal length                               */\r
176     const SKP_int32      order         /* I:  Filter order                                 */\r
177 );\r
178 \r
179 /*!\r
180  * 16th order AR filter for LPC synthesis, coefficients are in Q12\r
181  */\r
182 void SKP_Silk_LPC_synthesis_order16(\r
183     const SKP_int16      *in,          /* I:   excitation signal                            */\r
184     const SKP_int16      *A_Q12,       /* I:   AR coefficients [16], between -8_Q0 and 8_Q0 */\r
185     const SKP_int32      Gain_Q26,     /* I:   gain                                         */\r
186           SKP_int32      *S,           /* I/O: state vector [16]                            */\r
187           SKP_int16      *out,         /* O:   output signal                                */\r
188     const SKP_int32      len           /* I:   signal length, must be multiple of 16        */\r
189 );\r
190 \r
191 /* variable order MA prediction error filter. */\r
192 /* Inverse filter of SKP_Silk_LPC_synthesis_filter */\r
193 void SKP_Silk_LPC_analysis_filter(\r
194     SKP_int16            *out,         /* O:   Output signal                               */\r
195     const SKP_int16      *in,          /* I:   Input signal                                */\r
196     const SKP_int16      *B,           /* I:   MA prediction coefficients, Q12 [order]     */\r
197     const SKP_int32      len,          /* I:   Signal length                               */\r
198     const SKP_int32      Order         /* I:   Filter order                                */\r
199 );\r
200 \r
201 /* even order AR filter */\r
202 void SKP_Silk_LPC_synthesis_filter(\r
203     const SKP_int16      *in,          /* I:   excitation signal                               */\r
204     const SKP_int16      *A_Q12,       /* I:   AR coefficients [Order], between -8_Q0 and 8_Q0 */\r
205     const SKP_int32      Gain_Q26,     /* I:   gain                                            */\r
206     SKP_int32            *S,           /* I/O: state vector [Order]                            */\r
207     SKP_int16            *out,         /* O:   output signal                                   */\r
208     const SKP_int32      len,          /* I:   signal length                                   */\r
209     const SKP_int        Order         /* I:   filter order, must be even                      */\r
210 );\r
211 \r
212 /* Chirp (bandwidth expand) LP AR filter */\r
213 void SKP_Silk_bwexpander( \r
214     SKP_int16            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */\r
215     const SKP_int        d,            /* I    Length of ar                                    */\r
216     SKP_int32            chirp_Q16     /* I    Chirp factor (typically in the range 0 to 1)    */\r
217 );\r
218 \r
219 /* Chirp (bandwidth expand) LP AR filter */\r
220 void SKP_Silk_bwexpander_32( \r
221     SKP_int32            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */\r
222     const SKP_int        d,            /* I    Length of ar                                    */\r
223     SKP_int32            chirp_Q16     /* I    Chirp factor in Q16                             */\r
224 );\r
225 \r
226 /* Compute inverse of LPC prediction gain, and                           */\r
227 /* test if LPC coefficients are stable (all poles within unit circle)    */\r
228 SKP_int SKP_Silk_LPC_inverse_pred_gain( /* O:  Returns 1 if unstable, otherwise 0          */\r
229     SKP_int32            *invGain_Q30,  /* O:  Inverse prediction gain, Q30 energy domain  */\r
230     const SKP_int16      *A_Q12,        /* I:  Prediction coefficients, Q12 [order]        */\r
231     const SKP_int        order          /* I:  Prediction order                            */\r
232 );\r
233 \r
234 SKP_int SKP_Silk_LPC_inverse_pred_gain_Q24( /* O:   Returns 1 if unstable, otherwise 0      */\r
235     SKP_int32           *invGain_Q30,   /* O:   Inverse prediction gain, Q30 energy domain  */\r
236     const SKP_int32     *A_Q24,         /* I:   Prediction coefficients, Q24 [order]        */\r
237     const SKP_int       order           /* I:   Prediction order                            */\r
238 );\r
239 \r
240 /* split signal in two decimated bands using first-order allpass filters */\r
241 void SKP_Silk_ana_filt_bank_1(\r
242     const SKP_int16      *in,           /* I:   Input signal [N]        */\r
243     SKP_int32            *S,            /* I/O: State vector [2]        */\r
244     SKP_int16            *outL,         /* O:   Low band [N/2]          */\r
245     SKP_int16            *outH,         /* O:   High band [N/2]         */\r
246     SKP_int32            *scratch,      /* I:   Scratch memory [3*N/2]  */\r
247     const SKP_int32      N              /* I:   Number of input samples */\r
248 );\r
249 \r
250 /********************************************************************/\r
251 /*                        SCALAR FUNCTIONS                            */\r
252 /********************************************************************/\r
253 \r
254 /* approximation of 128 * log2() (exact inverse of approx 2^() below) */\r
255 /* convert input to a log scale    */\r
256 SKP_int32 SKP_Silk_lin2log(const SKP_int32 inLin);        /* I: input in linear scale        */\r
257 \r
258 /* Approximation of a sigmoid function */\r
259 SKP_int SKP_Silk_sigm_Q15(SKP_int in_Q5);\r
260 \r
261 /* approximation of 2^() (exact inverse of approx log2() above) */\r
262 /* convert input to a linear scale    */ \r
263 SKP_int32 SKP_Silk_log2lin(const SKP_int32 inLog_Q7);    /* I: input on log scale */ \r
264 \r
265 /* Function that returns the maximum absolut value of the input vector */\r
266 SKP_int16 SKP_Silk_int16_array_maxabs(  /* O   Maximum absolute value, max: 2^15-1   */\r
267     const SKP_int16     *vec,           /* I   Input vector  [len]                   */ \r
268     const SKP_int32     len             /* I   Length of input vector                */\r
269 );\r
270 \r
271 /* Compute number of bits to right shift the sum of squares of a vector    */\r
272 /* of int16s to make it fit in an int32                                    */\r
273 void SKP_Silk_sum_sqr_shift(\r
274     SKP_int32           *energy,        /* O   Energy of x, after shifting to the right            */\r
275     SKP_int             *shift,         /* O   Number of bits right shift applied to energy        */\r
276     const SKP_int16     *x,             /* I   Input vector                                        */\r
277     SKP_int             len             /* I   Length of input vector                              */\r
278 );\r
279 \r
280 /* Calculates the reflection coefficients from the correlation sequence    */\r
281 /* Faster than schur64(), but much less accurate.                          */\r
282 /* uses SMLAWB(), requiring armv5E and higher.                             */ \r
283 SKP_int32 SKP_Silk_schur(               /* O:    Returns residual energy                   */\r
284     SKP_int16           *rc_Q15,        /* O:    reflection coefficients [order] Q15       */\r
285     const SKP_int32     *c,             /* I:    correlations [order+1]                    */\r
286     const SKP_int32     order           /* I:    prediction order                          */\r
287 );;\r
288 \r
289 /* Calculates the reflection coefficients from the correlation sequence    */\r
290 /* Slower than schur(), but more accurate.                                 */\r
291 /* Uses SMULL(), available on armv4                                        */\r
292 SKP_int32 SKP_Silk_schur64(             /* O:  returns residual energy                     */\r
293     SKP_int32           rc_Q16[],       /* O:  Reflection coefficients [order] Q16         */\r
294     const SKP_int32     c[],            /* I:  Correlations [order+1]                      */\r
295     SKP_int32           order           /* I:  Prediction order                            */\r
296 );\r
297 \r
298 /* Step up function, converts reflection coefficients to prediction coefficients */\r
299 void SKP_Silk_k2a(\r
300     SKP_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */\r
301     const SKP_int16     *rc_Q15,        /* I:  Reflection coefficients [order] Q15         */\r
302     const SKP_int32     order           /* I:  Prediction order                            */\r
303 );\r
304 \r
305 /* Step up function, converts reflection coefficients to prediction coefficients */\r
306 void SKP_Silk_k2a_Q16(\r
307     SKP_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */\r
308     const SKP_int32     *rc_Q16,        /* I:  Reflection coefficients [order] Q16         */\r
309     const SKP_int32     order           /* I:  Prediction order                            */\r
310 );\r
311 \r
312 /* Apply sine window to signal vector.                                      */\r
313 /* Window types:                                                            */\r
314 /*    1 -> sine window from 0 to pi/2                                       */\r
315 /*    2 -> sine window from pi/2 to pi                                      */\r
316 /* every other sample of window is linearly interpolated, for speed         */\r
317 void SKP_Silk_apply_sine_window(\r
318     SKP_int16           px_win[],       /* O  Pointer to windowed signal                  */\r
319     const SKP_int16     px[],           /* I  Pointer to input signal                     */\r
320     const SKP_int       win_type,       /* I  Selects a window type                       */\r
321     const SKP_int       length          /* I  Window length, multiple of 4                */\r
322 );\r
323 \r
324 /* Compute autocorrelation */\r
325 void SKP_Silk_autocorr( \r
326     SKP_int32           *results,       /* O  Result (length correlationCount)            */\r
327     SKP_int             *scale,         /* O  Scaling of the correlation vector           */\r
328     const SKP_int16     *inputData,     /* I  Input data to correlate                     */\r
329     const SKP_int       inputDataSize,  /* I  Length of input                             */\r
330     const SKP_int       correlationCount /* I  Number of correlation taps to compute      */\r
331 );\r
332 \r
333 /* Pitch estimator */\r
334 #define SKP_Silk_PE_MIN_COMPLEX        0\r
335 #define SKP_Silk_PE_MID_COMPLEX        1\r
336 #define SKP_Silk_PE_MAX_COMPLEX        2\r
337 \r
338 void SKP_Silk_decode_pitch(\r
339     SKP_int16       lagIndex,                        /* I                             */\r
340     SKP_int8        contourIndex,                    /* O                             */\r
341     SKP_int         pitch_lags[],                    /* O 4 pitch values              */\r
342     const SKP_int   Fs_kHz,                          /* I sampling frequency (kHz)    */\r
343     const SKP_int   nb_subfr                         /* I number of sub frames        */\r
344 );\r
345 \r
346 SKP_int SKP_Silk_pitch_analysis_core(    /* O    Voicing estimate: 0 voiced, 1 unvoiced                     */\r
347     const SKP_int16  *signal,            /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                 */\r
348     SKP_int          *pitch_out,         /* O    4 pitch lag values                                         */\r
349     SKP_int16        *lagIndex,          /* O    Lag Index                                                  */\r
350     SKP_int8         *contourIndex,      /* O    Pitch contour Index                                        */\r
351     SKP_int          *LTPCorr_Q15,       /* I/O  Normalized correlation; input: value from previous frame   */\r
352     SKP_int          prevLag,            /* I    Last lag of previous frame; set to zero is unvoiced        */\r
353     const SKP_int32  search_thres1_Q16,  /* I    First stage threshold for lag candidates 0 - 1             */\r
354     const SKP_int    search_thres2_Q15,  /* I    Final threshold for lag candidates 0 - 1                   */\r
355     const SKP_int    Fs_kHz,             /* I    Sample frequency (kHz)                                     */\r
356     const SKP_int    complexity,         /* I    Complexity setting, 0-2, where 2 is highest                */\r
357     const SKP_int    nb_subfr            /* I    number of 5 ms subframes                                   */\r
358 );\r
359 \r
360 /* parameter defining the size and accuracy of the piecewise linear    */\r
361 /* cosine approximatin table.                                        */\r
362 \r
363 #define LSF_COS_TAB_SZ_FIX      128\r
364 /* rom table with cosine values */\r
365 extern const SKP_int SKP_Silk_LSFCosTab_FIX_Q12[ LSF_COS_TAB_SZ_FIX + 1 ];\r
366 \r
367 void SKP_Silk_LPC_fit(\r
368           SKP_int16    *a_QQ,            /* O    stabilized LPC vector, Q(24-rshift) [L]        */\r
369           SKP_int32    *a_Q24,           /* I    LPC vector [L]                                 */\r
370     const SKP_int      QQ,               /* I    Q domain of output LPC vector                  */\r
371     const SKP_int      L                 /* I    Number of LPC parameters in the input vector   */\r
372 );\r
373 \r
374 /* Compute Normalized Line Spectral Frequencies (NLSFs) from whitening filter coefficients      */\r
375 /* If not all roots are found, the a_Q16 coefficients are bandwidth expanded until convergence. */\r
376 void SKP_Silk_A2NLSF(\r
377     SKP_int            *NLSF,            /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d] */\r
378     SKP_int32          *a_Q16,           /* I/O  Monic whitening filter coefficients in Q16 [d]                */\r
379     const SKP_int      d                 /* I    Filter order (must be even)                                   */\r
380 );\r
381 \r
382 /* compute whitening filter coefficients from normalized line spectral frequencies */\r
383 void SKP_Silk_NLSF2A(\r
384     SKP_int16          *a,               /* o    monic whitening filter coefficients in Q12,  [d]    */\r
385     const SKP_int      *NLSF,            /* i    normalized line spectral frequencies in Q15, [d]    */\r
386     const SKP_int      d                 /* i    filter order (should be even)                       */\r
387 );\r
388 \r
389 void SKP_Silk_insertion_sort_increasing(\r
390     SKP_int32            *a,            /* I/O   Unsorted / Sorted vector                */\r
391     SKP_int              *index,        /* O:    Index vector for the sorted elements    */\r
392     const SKP_int        L,             /* I:    Vector length                           */\r
393     const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
394 );\r
395 \r
396 void SKP_Silk_insertion_sort_decreasing(\r
397     SKP_int              *a,            /* I/O:  Unsorted / Sorted vector                */\r
398     SKP_int              *index,        /* O:    Index vector for the sorted elements    */\r
399     const SKP_int        L,             /* I:    Vector length                           */\r
400     const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
401 );\r
402 \r
403 void SKP_Silk_insertion_sort_decreasing_int16(\r
404     SKP_int16            *a,            /* I/O:  Unsorted / Sorted vector                */\r
405     SKP_int              *index,        /* O:    Index vector for the sorted elements    */\r
406     const SKP_int        L,             /* I:    Vector length                           */\r
407     const SKP_int        K              /* I:    Number of correctly sorted positions    */\r
408 );\r
409 \r
410 void SKP_Silk_insertion_sort_increasing_all_values(\r
411      SKP_int             *a,            /* I/O:  Unsorted / Sorted vector                */\r
412      const SKP_int       L              /* I:    Vector length                           */\r
413 );\r
414 \r
415 /* NLSF stabilizer, for a single input data vector */\r
416 void SKP_Silk_NLSF_stabilize(\r
417           SKP_int        *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */\r
418     const SKP_int        *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
419     const SKP_int        L               /* I:    Number of NLSF parameters in the input vector                           */\r
420 );\r
421 \r
422 /* NLSF stabilizer, over multiple input column data vectors */\r
423 void SKP_Silk_NLSF_stabilize_multi(\r
424           SKP_int        *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vectors in Q15 [LxN]                 */\r
425     const SKP_int        *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */\r
426     const SKP_int        N,              /* I:    Number of input vectors to be stabilized                                */\r
427     const SKP_int        L               /* I:    NLSF vector dimension                                                   */\r
428 );\r
429 \r
430 /* Laroia low complexity NLSF weights */\r
431 void SKP_Silk_NLSF_VQ_weights_laroia(\r
432     SKP_int              *pNLSFW_Q6,     /* O:    Pointer to input vector weights            [D x 1]       */\r
433     const SKP_int        *pNLSF_Q15,     /* I:    Pointer to input vector                    [D x 1]       */\r
434     const SKP_int        D               /* I:    Input vector dimension (even)                            */\r
435 );\r
436 \r
437 /* Compute reflection coefficients from input signal */\r
438 void SKP_Silk_burg_modified(        \r
439     SKP_int32            *res_nrg,           /* O   residual energy                                                 */\r
440     SKP_int              *res_nrgQ,          /* O   residual energy Q value                                         */\r
441     SKP_int32            A_Q16[],            /* O   prediction coefficients (length order)                          */\r
442     const SKP_int16      x[],                /* I   input signal, length: nb_subfr * ( D + subfr_length )           */\r
443     const SKP_int        subfr_length,       /* I   input signal subframe length (including D preceeding samples)   */\r
444     const SKP_int        nb_subfr,           /* I   number of subframes stacked in x                                */\r
445     const SKP_int32      WhiteNoiseFrac_Q32, /* I   fraction added to zero-lag autocorrelation                      */\r
446     const SKP_int        D                   /* I   order                                                           */\r
447 );\r
448 \r
449 /* Multiply a vector by a constant */\r
450 void SKP_Silk_scale_vector16_Q14( \r
451     SKP_int16            *data1, \r
452     SKP_int              gain_Q14,           /* Gain in Q14 */ \r
453     SKP_int              dataSize\r
454 );\r
455 \r
456 /* Copy and multiply a vector by a constant */\r
457 void SKP_Silk_scale_copy_vector16( \r
458     SKP_int16            *data_out, \r
459     const SKP_int16      *data_in, \r
460     SKP_int32            gain_Q16,           /* I:   gain in Q16   */\r
461     const SKP_int        dataSize            /* I:   length        */\r
462 );\r
463 \r
464 void SKP_Silk_scale_vector32_16_Q14( \r
465     SKP_int32            *data1,             /* I/O: Q0/Q0         */\r
466     SKP_int              gain_Q14,           /* I:   Q14           */\r
467     SKP_int              dataSize            /* I:   length        */\r
468 );\r
469 \r
470 /* Multiply a vector by a constant, does not saturate output data */\r
471 void SKP_Silk_scale_vector32_Q16( \r
472     SKP_int32            *data1,             /* I/O: Q0/Q0         */\r
473     SKP_int32            gain_Q16,           /* I:   gain in Q16 ( SKP_int16_MIN <= gain_Q16 <= SKP_int16_MAX + 65536 ) */\r
474     const SKP_int        dataSize            /* I:   length        */\r
475 );\r
476 \r
477 /* Some for the LTP related function requires Q26 to work.*/\r
478 void SKP_Silk_scale_vector32_Q26_lshift_18( \r
479     SKP_int32            *data1,             /* I/O: Q0/Q18        */\r
480     SKP_int32            gain_Q26,           /* I:   Q26           */\r
481     SKP_int              dataSize            /* I:   length        */\r
482 );\r
483 \r
484 /********************************************************************/\r
485 /*                        INLINE ARM MATH                             */\r
486 /********************************************************************/\r
487 \r
488 /*    return sum(inVec1[i]*inVec2[i])    */\r
489 /*    inVec1 and inVec2 should be increasing ordered, and starting address should be 4 byte aligned. (a factor of 4)*/\r
490 SKP_int32 SKP_Silk_inner_prod_aligned(\r
491     const SKP_int16* const inVec1,           /* I   input vector 1    */ \r
492     const SKP_int16* const inVec2,           /* I   input vector 2    */\r
493     const SKP_int          len               /* I   vector lengths    */\r
494 );\r
495 \r
496 SKP_int32 SKP_Silk_inner_prod16_aligned_sat(\r
497     const SKP_int16* const inVec1,           /* I   input vector 1  */\r
498     const SKP_int16* const inVec2,           /* I   input vector 2  */\r
499     const SKP_int          len               /* I   vector lengths  */\r
500 );\r
501 \r
502 SKP_int64 SKP_Silk_inner_prod_aligned_64(\r
503     const SKP_int32        *inVec1,          /* I   input vector 1    */\r
504     const SKP_int32        *inVec2,          /* I   input vector 2    */\r
505     const SKP_int          len               /* I   vector lengths    */\r
506 );\r
507 \r
508 SKP_int64 SKP_Silk_inner_prod16_aligned_64(\r
509     const SKP_int16        *inVec1,          /* I   input vector 1    */\r
510     const SKP_int16        *inVec2,          /* I   input vector 2    */\r
511     const SKP_int          len               /* I   vector lengths    */\r
512 );\r
513 /********************************************************************/\r
514 /*                                MACROS                            */\r
515 /********************************************************************/\r
516 \r
517 /* Rotate a32 right by 'rot' bits. Negative rot values result in rotating\r
518    left. Output is 32bit int.\r
519    Note: contemporary compilers recognize the C expression below and\r
520    compile it into a 'ror' instruction if available. No need for inline ASM! */\r
521 SKP_INLINE SKP_int32 SKP_ROR32( SKP_int32 a32, SKP_int rot )\r
522 {\r
523     SKP_uint32 x = (SKP_uint32) a32;\r
524     SKP_uint32 r = (SKP_uint32) rot;\r
525     SKP_uint32 m = (SKP_uint32) -rot;\r
526     if(rot <= 0)\r
527         return (SKP_int32) ((x << m) | (x >> (32 - m)));\r
528     else\r
529         return (SKP_int32) ((x << (32 - r)) | (x >> r));\r
530 }\r
531 \r
532 /* Allocate SKP_int16 alligned to 4-byte memory address */\r
533 #if EMBEDDED_ARM\r
534 #define SKP_DWORD_ALIGN __attribute__((aligned(4)))\r
535 #else\r
536 #define SKP_DWORD_ALIGN\r
537 #endif\r
538 \r
539 /* Useful Macros that can be adjusted to other platforms */\r
540 #define SKP_memcpy(a, b, c)                memcpy((a), (b), (c))    /* Dest, Src, ByteCount */\r
541 #define SKP_memset(a, b, c)                memset((a), (b), (c))    /* Dest, value, ByteCount */\r
542 #define SKP_memmove(a, b, c)               memmove((a), (b), (c))   /* Dest, Src, ByteCount */\r
543 /* fixed point macros */\r
544 \r
545 // (a32 * b32) output have to be 32bit int\r
546 #define SKP_MUL(a32, b32)                  ((a32) * (b32))\r
547 \r
548 // (a32 * b32) output have to be 32bit uint\r
549 #define SKP_MUL_uint(a32, b32)             SKP_MUL(a32, b32)\r
550 \r
551 // a32 + (b32 * c32) output have to be 32bit int\r
552 #define SKP_MLA(a32, b32, c32)             SKP_ADD32((a32),((b32) * (c32)))\r
553 \r
554 // a32 + (b32 * c32) output have to be 32bit uint\r
555 #define SKP_MLA_uint(a32, b32, c32)        SKP_MLA(a32, b32, c32)\r
556 \r
557 // ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int\r
558 #define SKP_SMULTT(a32, b32)               (((a32) >> 16) * ((b32) >> 16))\r
559 \r
560 // a32 + ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int\r
561 #define SKP_SMLATT(a32, b32, c32)          SKP_ADD32((a32),((b32) >> 16) * ((c32) >> 16))\r
562 \r
563 #define SKP_SMLALBB(a64, b16, c16)         SKP_ADD64((a64),(SKP_int64)((SKP_int32)(b16) * (SKP_int32)(c16)))\r
564 \r
565 // (a32 * b32)\r
566 #define SKP_SMULL(a32, b32)                ((SKP_int64)(a32) * /*(SKP_int64)*/(b32))\r
567 \r
568 // multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode)\r
569 #define SKP_MLA_ovflw(a32, b32, c32)       SKP_MLA(a32, b32, c32)\r
570 #ifndef SKP_SMLABB_ovflw\r
571 #    define SKP_SMLABB_ovflw(a32, b32, c32)    SKP_SMLABB(a32, b32, c32)\r
572 #endif\r
573 #define SKP_SMLABT_ovflw(a32, b32, c32)    SKP_SMLABT(a32, b32, c32)\r
574 #define SKP_SMLATT_ovflw(a32, b32, c32)    SKP_SMLATT(a32, b32, c32)\r
575 #define SKP_SMLAWB_ovflw(a32, b32, c32)    SKP_SMLAWB(a32, b32, c32)\r
576 #define SKP_SMLAWT_ovflw(a32, b32, c32)    SKP_SMLAWT(a32, b32, c32)\r
577 \r
578 #define SKP_DIV64_32(a64, b32)             ((a64)/(b32))        /* TODO: rewrite it as a set of SKP_DIV32.*/\r
579 \r
580 #define SKP_DIV32_16(a32, b16)             ((SKP_int32)((a32) / (b16)))\r
581 #define SKP_DIV32(a32, b32)                ((SKP_int32)((a32) / (b32)))\r
582 \r
583 // These macros enables checking for overflow in SKP_Silk_API_Debug.h\r
584 #define SKP_ADD16(a, b)                    ((a) + (b))\r
585 #define SKP_ADD32(a, b)                    ((a) + (b))\r
586 #define SKP_ADD64(a, b)                    ((a) + (b))\r
587 \r
588 #define SKP_SUB16(a, b)                    ((a) - (b))\r
589 #define SKP_SUB32(a, b)                    ((a) - (b))\r
590 #define SKP_SUB64(a, b)                    ((a) - (b))\r
591 \r
592 #define SKP_SAT8(a)                        ((a) > SKP_int8_MAX ? SKP_int8_MAX  : \\r
593                                            ((a) < SKP_int8_MIN ? SKP_int8_MIN  : (a)))\r
594 #define SKP_SAT16(a)                       ((a) > SKP_int16_MAX ? SKP_int16_MAX : \\r
595                                            ((a) < SKP_int16_MIN ? SKP_int16_MIN : (a)))\r
596 #define SKP_SAT32(a)                       ((a) > SKP_int32_MAX ? SKP_int32_MAX : \\r
597                                            ((a) < SKP_int32_MIN ? SKP_int32_MIN : (a)))\r
598 \r
599 #define SKP_CHECK_FIT8(a)                  (a)\r
600 #define SKP_CHECK_FIT16(a)                 (a)\r
601 #define SKP_CHECK_FIT32(a)                 (a)\r
602 \r
603 #define SKP_ADD_SAT16(a, b)                (SKP_int16)SKP_SAT16( SKP_ADD32( (SKP_int32)(a), (b) ) )\r
604 #define SKP_ADD_SAT64(a, b)                ((((a) + (b)) & 0x8000000000000000LL) == 0 ?                            \\r
605                                            ((((a) & (b)) & 0x8000000000000000LL) != 0 ? SKP_int64_MIN : (a)+(b)) :    \\r
606                                            ((((a) | (b)) & 0x8000000000000000LL) == 0 ? SKP_int64_MAX : (a)+(b)) )\r
607 \r
608 #define SKP_SUB_SAT16(a, b)                (SKP_int16)SKP_SAT16( SKP_SUB32( (SKP_int32)(a), (b) ) )\r
609 #define SKP_SUB_SAT64(a, b)                ((((a)-(b)) & 0x8000000000000000LL) == 0 ?                                                    \\r
610                                            (( (a) & ((b)^0x8000000000000000LL) & 0x8000000000000000LL) ? SKP_int64_MIN : (a)-(b)) :    \\r
611                                            ((((a)^0x8000000000000000LL) & (b)  & 0x8000000000000000LL) ? SKP_int64_MAX : (a)-(b)) )\r
612 \r
613 /* Saturation for positive input values */ \r
614 #define SKP_POS_SAT32(a)                   ((a) > SKP_int32_MAX ? SKP_int32_MAX : (a))\r
615 \r
616 /* Add with saturation for positive input values */ \r
617 #define SKP_ADD_POS_SAT8(a, b)             ((((a)+(b)) & 0x80)                 ? SKP_int8_MAX  : ((a)+(b)))\r
618 #define SKP_ADD_POS_SAT16(a, b)            ((((a)+(b)) & 0x8000)               ? SKP_int16_MAX : ((a)+(b)))\r
619 #define SKP_ADD_POS_SAT32(a, b)            ((((a)+(b)) & 0x80000000)           ? SKP_int32_MAX : ((a)+(b)))\r
620 #define SKP_ADD_POS_SAT64(a, b)            ((((a)+(b)) & 0x8000000000000000LL) ? SKP_int64_MAX : ((a)+(b)))\r
621 \r
622 #define SKP_LSHIFT8(a, shift)              ((a)<<(shift))                // shift >= 0, shift < 8\r
623 #define SKP_LSHIFT16(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 16\r
624 #define SKP_LSHIFT32(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 32\r
625 #define SKP_LSHIFT64(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 64\r
626 #define SKP_LSHIFT(a, shift)               SKP_LSHIFT32(a, shift)        // shift >= 0, shift < 32\r
627 \r
628 #define SKP_RSHIFT8(a, shift)              ((a)>>(shift))                // shift >= 0, shift < 8\r
629 #define SKP_RSHIFT16(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 16\r
630 #define SKP_RSHIFT32(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 32\r
631 #define SKP_RSHIFT64(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 64\r
632 #define SKP_RSHIFT(a, shift)               SKP_RSHIFT32(a, shift)        // shift >= 0, shift < 32\r
633 \r
634 /* saturates before shifting */\r
635 #define SKP_LSHIFT_SAT16(a, shift)         (SKP_LSHIFT16( SKP_LIMIT( (a), SKP_RSHIFT16( SKP_int16_MIN, (shift) ),    \\r
636                                                                           SKP_RSHIFT16( SKP_int16_MAX, (shift) ) ), (shift) ))\r
637 #define SKP_LSHIFT_SAT32(a, shift)         (SKP_LSHIFT32( SKP_LIMIT( (a), SKP_RSHIFT32( SKP_int32_MIN, (shift) ),    \\r
638                                                                           SKP_RSHIFT32( SKP_int32_MAX, (shift) ) ), (shift) ))\r
639 \r
640 #define SKP_LSHIFT_ovflw(a, shift)        ((a)<<(shift))        // shift >= 0, allowed to overflow\r
641 #define SKP_LSHIFT_uint(a, shift)         ((a)<<(shift))        // shift >= 0\r
642 #define SKP_RSHIFT_uint(a, shift)         ((a)>>(shift))        // shift >= 0\r
643 \r
644 #define SKP_ADD_LSHIFT(a, b, shift)       ((a) + SKP_LSHIFT((b), (shift)))            // shift >= 0\r
645 #define SKP_ADD_LSHIFT32(a, b, shift)     SKP_ADD32((a), SKP_LSHIFT32((b), (shift)))    // shift >= 0\r
646 #define SKP_ADD_LSHIFT_uint(a, b, shift)  ((a) + SKP_LSHIFT_uint((b), (shift)))        // shift >= 0\r
647 #define SKP_ADD_RSHIFT(a, b, shift)       ((a) + SKP_RSHIFT((b), (shift)))            // shift >= 0\r
648 #define SKP_ADD_RSHIFT32(a, b, shift)     SKP_ADD32((a), SKP_RSHIFT32((b), (shift)))    // shift >= 0\r
649 #define SKP_ADD_RSHIFT_uint(a, b, shift)  ((a) + SKP_RSHIFT_uint((b), (shift)))        // shift >= 0\r
650 #define SKP_SUB_LSHIFT32(a, b, shift)     SKP_SUB32((a), SKP_LSHIFT32((b), (shift)))    // shift >= 0\r
651 #define SKP_SUB_RSHIFT32(a, b, shift)     SKP_SUB32((a), SKP_RSHIFT32((b), (shift)))    // shift >= 0\r
652 \r
653 /* Requires that shift > 0 */\r
654 #define SKP_RSHIFT_ROUND(a, shift)        ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)\r
655 #define SKP_RSHIFT_ROUND64(a, shift)      ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)\r
656 \r
657 /* Number of rightshift required to fit the multiplication */\r
658 #define SKP_NSHIFT_MUL_32_32(a, b)        ( -(31- (32-SKP_Silk_CLZ32(SKP_abs(a)) + (32-SKP_Silk_CLZ32(SKP_abs(b))))) )\r
659 #define SKP_NSHIFT_MUL_16_16(a, b)        ( -(15- (16-SKP_Silk_CLZ16(SKP_abs(a)) + (16-SKP_Silk_CLZ16(SKP_abs(b))))) )\r
660 \r
661 \r
662 #define SKP_min(a, b)                     (((a) < (b)) ? (a) : (b)) \r
663 #define SKP_max(a, b)                     (((a) > (b)) ? (a) : (b))\r
664 \r
665 /* Macro to convert floating-point constants to fixed-point */\r
666 #define SKP_FIX_CONST( C, Q )           ((SKP_int32)((C) * ((SKP_int64)1 << (Q)) + 0.5))\r
667 \r
668 /* SKP_min() versions with typecast in the function call */\r
669 SKP_INLINE SKP_int SKP_min_int(SKP_int a, SKP_int b)\r
670 {\r
671     return (((a) < (b)) ? (a) : (b));\r
672 }\r
673 SKP_INLINE SKP_int16 SKP_min_16(SKP_int16 a, SKP_int16 b)\r
674 {\r
675     return (((a) < (b)) ? (a) : (b));\r
676 }\r
677 SKP_INLINE SKP_int32 SKP_min_32(SKP_int32 a, SKP_int32 b)\r
678 {\r
679     return (((a) < (b)) ? (a) : (b));\r
680 }\r
681 SKP_INLINE SKP_int64 SKP_min_64(SKP_int64 a, SKP_int64 b)\r
682 {\r
683     return (((a) < (b)) ? (a) : (b));\r
684 }\r
685 \r
686 /* SKP_min() versions with typecast in the function call */\r
687 SKP_INLINE SKP_int SKP_max_int(SKP_int a, SKP_int b)\r
688 {\r
689     return (((a) > (b)) ? (a) : (b));\r
690 }\r
691 SKP_INLINE SKP_int16 SKP_max_16(SKP_int16 a, SKP_int16 b)\r
692 {\r
693     return (((a) > (b)) ? (a) : (b));\r
694 }\r
695 SKP_INLINE SKP_int32 SKP_max_32(SKP_int32 a, SKP_int32 b)\r
696 {\r
697     return (((a) > (b)) ? (a) : (b));\r
698 }\r
699 SKP_INLINE SKP_int64 SKP_max_64(SKP_int64 a, SKP_int64 b)\r
700 {\r
701     return (((a) > (b)) ? (a) : (b));\r
702 }\r
703 \r
704 #define SKP_LIMIT( a, limit1, limit2)    ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \\r
705                                                              : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))\r
706 \r
707 #define SKP_LIMIT_int SKP_LIMIT\r
708 #define SKP_LIMIT_16 SKP_LIMIT\r
709 #define SKP_LIMIT_32 SKP_LIMIT\r
710 \r
711 //#define SKP_non_neg(a)                 ((a) & ((-(a)) >> (8 * sizeof(a) - 1)))   /* doesn't seem faster than SKP_max(0, a);\r
712 \r
713 #define SKP_abs(a)                       (((a) >  0)  ? (a) : -(a))            // Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN\r
714 #define SKP_abs_int(a)                   (((a) ^ ((a) >> (8 * sizeof(a) - 1))) - ((a) >> (8 * sizeof(a) - 1)))\r
715 #define SKP_abs_int32(a)                 (((a) ^ ((a) >> 31)) - ((a) >> 31))\r
716 #define SKP_abs_int64(a)                 (((a) >  0)  ? (a) : -(a))    \r
717 \r
718 #define SKP_sign(a)                      ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ))\r
719 \r
720 #define SKP_sqrt(a)                      (sqrt(a)) \r
721 \r
722 /* PSEUDO-RANDOM GENERATOR                                                          */\r
723 /* Make sure to store the result as the seed for the next call (also in between     */\r
724 /* frames), otherwise result won't be random at all. When only using some of the    */\r
725 /* bits, take the most significant bits by right-shifting.                          */\r
726 #define SKP_RAND(seed)                   (SKP_MLA_ovflw(907633515, (seed), 196314165))\r
727 \r
728 // Add some multiplication functions that can be easily mapped to ARM.\r
729 \r
730 //    SKP_SMMUL: Signed top word multiply. \r
731 //        ARMv6        2 instruction cycles. \r
732 //        ARMv3M+        3 instruction cycles. use SMULL and ignore LSB registers.(except xM) \r
733 //#define SKP_SMMUL(a32, b32)            (SKP_int32)SKP_RSHIFT(SKP_SMLAL(SKP_SMULWB((a32), (b32)), (a32), SKP_RSHIFT_ROUND((b32), 16)), 16)\r
734 // the following seems faster on x86\r
735 #define SKP_SMMUL(a32, b32)              (SKP_int32)SKP_RSHIFT64(SKP_SMULL((a32), (b32)), 32)\r
736 \r
737 #include "SKP_Silk_Inlines.h"\r
738 #include "SKP_Silk_MacroCount.h"\r
739 #include "SKP_Silk_MacroDebug.h"\r
740 \r
741 #ifdef  __cplusplus\r
742 }\r
743 #endif\r
744 \r
745 #endif\r