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