Eliminate some unreachable cases from the cwrs code and fixup the
[opus.git] / silk / silk_SigProc_FIX.h
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions are met:
6 - Redistributions of source code must retain the above copyright notice,
7 this list of conditions and the following disclaimer.
8 - Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 - Neither the name of Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifndef _SILK_SIGPROC_FIX_H_
29 #define _SILK_SIGPROC_FIX_H_
30
31 #ifdef  __cplusplus
32 extern "C"
33 {
34 #endif
35
36 //#define SKP_MACRO_COUNT           /* Used to enable WMOPS counting */
37
38 #define SILK_MAX_ORDER_LPC            16                        /* max order of the LPC analysis in schur() and k2a()    */
39
40 #include <stdlib.h>                                             /* for abs() */
41 #include <string.h>                                             /* for memset(), memcpy(), memmove() */
42 #include "silk_typedef.h"
43 #include "silk_resampler_structs.h"
44 #include "silk_macros.h"
45
46
47 /********************************************************************/
48 /*                    SIGNAL PROCESSING FUNCTIONS                   */
49 /********************************************************************/
50
51 /*!
52  * Initialize/reset the resampler state for a given pair of input/output sampling rates
53 */
54 opus_int silk_resampler_init(
55     silk_resampler_state_struct            *S,         /* I/O: Resampler state             */
56     opus_int32                            Fs_Hz_in,    /* I:    Input sampling rate (Hz)    */
57     opus_int32                            Fs_Hz_out    /* I:    Output sampling rate (Hz)    */
58 );
59
60 /*!
61  * Clear the states of all resampling filters, without resetting sampling rate ratio
62  */
63 opus_int silk_resampler_clear(
64     silk_resampler_state_struct            *S          /* I/O: Resampler state             */
65 );
66
67 /*!
68  * Resampler: convert from one sampling rate to another
69  */
70 opus_int silk_resampler(
71     silk_resampler_state_struct            *S,         /* I/O: Resampler state             */
72     opus_int16                            out[],        /* O:    Output signal                 */
73     const opus_int16                        in[],        /* I:    Input signal                */
74     opus_int32                            inLen        /* I:    Number of input samples        */
75 );
76
77 /*!
78  Upsample 2x, low quality
79  */
80 void silk_resampler_up2(
81     opus_int32                           *S,         /* I/O: State vector [ 2 ]                  */
82     opus_int16                           *out,       /* O:   Output signal [ 2 * len ]           */
83     const opus_int16                     *in,        /* I:   Input signal [ len ]                */
84     opus_int32                           len         /* I:   Number of input samples             */
85 );
86
87 /*!
88 * Downsample 2x, mediocre quality
89 */
90 void silk_resampler_down2(
91     opus_int32                           *S,         /* I/O: State vector [ 2 ]                  */
92     opus_int16                           *out,       /* O:   Output signal [ len ]               */
93     const opus_int16                     *in,        /* I:   Input signal [ floor(len/2) ]       */
94     opus_int32                           inLen       /* I:   Number of input samples             */
95 );
96
97
98 /*!
99  * Downsample by a factor 2/3, low quality
100 */
101 void silk_resampler_down2_3(
102     opus_int32                           *S,         /* I/O: State vector [ 6 ]                  */
103     opus_int16                           *out,       /* O:   Output signal [ floor(2*inLen/3) ]  */
104     const opus_int16                     *in,        /* I:   Input signal [ inLen ]              */
105     opus_int32                           inLen       /* I:   Number of input samples             */
106 );
107
108 /*!
109  * Downsample by a factor 3, low quality
110 */
111 void silk_resampler_down3(
112     opus_int32                           *S,         /* I/O: State vector [ 8 ]                  */
113     opus_int16                           *out,       /* O:   Output signal [ floor(inLen/3) ]    */
114     const opus_int16                     *in,        /* I:   Input signal [ inLen ]              */
115     opus_int32                           inLen       /* I:   Number of input samples             */
116 );
117
118 /*!
119  * second order ARMA filter;
120  * slower than biquad() but uses more precise coefficients
121  * can handle (slowly) varying coefficients
122  */
123 void silk_biquad_alt(
124     const opus_int16     *in,           /* I:    input signal                 */
125     const opus_int32     *B_Q28,        /* I:    MA coefficients [3]          */
126     const opus_int32     *A_Q28,        /* I:    AR coefficients [2]          */
127     opus_int32           *S,            /* I/O:  State vector [2]             */
128     opus_int16           *out,          /* O:    output signal                */
129     const opus_int32     len            /* I:    signal length (must be even) */
130 );
131
132 /* Variable order MA prediction error filter. */
133 void silk_LPC_analysis_filter(
134     opus_int16            *out,         /* O:   Output signal                               */
135     const opus_int16      *in,          /* I:   Input signal                                */
136     const opus_int16      *B,           /* I:   MA prediction coefficients, Q12 [order]     */
137     const opus_int32      len,          /* I:   Signal length                               */
138     const opus_int32      Order         /* I:   Filter order                                */
139 );
140
141 /* Chirp (bandwidth expand) LP AR filter */
142 void silk_bwexpander(
143     opus_int16            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */
144     const opus_int        d,            /* I    Length of ar                                    */
145     opus_int32            chirp_Q16     /* I    Chirp factor (typically in the range 0 to 1)    */
146 );
147
148 /* Chirp (bandwidth expand) LP AR filter */
149 void silk_bwexpander_32(
150     opus_int32            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */
151     const opus_int        d,            /* I    Length of ar                                    */
152     opus_int32            chirp_Q16     /* I    Chirp factor in Q16                             */
153 );
154
155 /* Compute inverse of LPC prediction gain, and                           */
156 /* test if LPC coefficients are stable (all poles within unit circle)    */
157 opus_int silk_LPC_inverse_pred_gain(     /* O:  Returns 1 if unstable, otherwise 0          */
158     opus_int32            *invGain_Q30,  /* O:  Inverse prediction gain, Q30 energy domain  */
159     const opus_int16      *A_Q12,        /* I:  Prediction coefficients, Q12 [order]        */
160     const opus_int        order          /* I:  Prediction order                            */
161 );
162
163 opus_int silk_LPC_inverse_pred_gain_Q24( /* O:   Returns 1 if unstable, otherwise 0      */
164     opus_int32           *invGain_Q30,   /* O:   Inverse prediction gain, Q30 energy domain  */
165     const opus_int32     *A_Q24,         /* I:   Prediction coefficients, Q24 [order]        */
166     const opus_int       order           /* I:   Prediction order                            */
167 );
168
169 /* split signal in two decimated bands using first-order allpass filters */
170 void silk_ana_filt_bank_1(
171     const opus_int16      *in,           /* I:   Input signal [N]        */
172     opus_int32            *S,            /* I/O: State vector [2]        */
173     opus_int16            *outL,         /* O:   Low band [N/2]          */
174     opus_int16            *outH,         /* O:   High band [N/2]         */
175     const opus_int32      N              /* I:   Number of input samples */
176 );
177
178 /********************************************************************/
179 /*                        SCALAR FUNCTIONS                          */
180 /********************************************************************/
181
182 /* approximation of 128 * log2() (exact inverse of approx 2^() below) */
183 /* convert input to a log scale    */
184 opus_int32 silk_lin2log(const opus_int32 inLin);        /* I: input in linear scale        */
185
186 /* Approximation of a sigmoid function */
187 opus_int silk_sigm_Q15(opus_int in_Q5);
188
189 /* approximation of 2^() (exact inverse of approx log2() above) */
190 /* convert input to a linear scale    */
191 opus_int32 silk_log2lin(const opus_int32 inLog_Q7);    /* I: input on log scale */
192
193 /* Function that returns the maximum absolut value of the input vector */
194 opus_int16 silk_int16_array_maxabs(      /* O   Maximum absolute value, max: 2^15-1   */
195     const opus_int16     *vec,           /* I   Input vector  [len]                   */
196     const opus_int32     len             /* I   Length of input vector                */
197 );
198
199 /* Compute number of bits to right shift the sum of squares of a vector    */
200 /* of int16s to make it fit in an int32                                    */
201 void silk_sum_sqr_shift(
202     opus_int32           *energy,        /* O   Energy of x, after shifting to the right            */
203     opus_int             *shift,         /* O   Number of bits right shift applied to energy        */
204     const opus_int16     *x,             /* I   Input vector                                        */
205     opus_int             len             /* I   Length of input vector                              */
206 );
207
208 /* Calculates the reflection coefficients from the correlation sequence    */
209 /* Faster than schur64(), but much less accurate.                          */
210 /* uses SMLAWB(), requiring armv5E and higher.                             */
211 opus_int32 silk_schur(                   /* O:    Returns residual energy                   */
212     opus_int16           *rc_Q15,        /* O:    reflection coefficients [order] Q15       */
213     const opus_int32     *c,             /* I:    correlations [order+1]                    */
214     const opus_int32     order           /* I:    prediction order                          */
215 );;
216
217 /* Calculates the reflection coefficients from the correlation sequence    */
218 /* Slower than schur(), but more accurate.                                 */
219 /* Uses SMULL(), available on armv4                                        */
220 opus_int32 silk_schur64(                 /* O:  returns residual energy                     */
221     opus_int32           rc_Q16[],       /* O:  Reflection coefficients [order] Q16         */
222     const opus_int32     c[],            /* I:  Correlations [order+1]                      */
223     opus_int32           order           /* I:  Prediction order                            */
224 );
225
226 /* Step up function, converts reflection coefficients to prediction coefficients */
227 void silk_k2a(
228     opus_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */
229     const opus_int16     *rc_Q15,        /* I:  Reflection coefficients [order] Q15         */
230     const opus_int32     order           /* I:  Prediction order                            */
231 );
232
233 /* Step up function, converts reflection coefficients to prediction coefficients */
234 void silk_k2a_Q16(
235     opus_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */
236     const opus_int32     *rc_Q16,        /* I:  Reflection coefficients [order] Q16         */
237     const opus_int32     order           /* I:  Prediction order                            */
238 );
239
240 /* Apply sine window to signal vector.                                      */
241 /* Window types:                                                            */
242 /*    1 -> sine window from 0 to pi/2                                       */
243 /*    2 -> sine window from pi/2 to pi                                      */
244 /* every other sample of window is linearly interpolated, for speed         */
245 void silk_apply_sine_window(
246     opus_int16           px_win[],       /* O  Pointer to windowed signal                  */
247     const opus_int16     px[],           /* I  Pointer to input signal                     */
248     const opus_int       win_type,       /* I  Selects a window type                       */
249     const opus_int       length          /* I  Window length, multiple of 4                */
250 );
251
252 /* Compute autocorrelation */
253 void silk_autocorr(
254     opus_int32           *results,       /* O  Result (length correlationCount)            */
255     opus_int             *scale,         /* O  Scaling of the correlation vector           */
256     const opus_int16     *inputData,     /* I  Input data to correlate                     */
257     const opus_int       inputDataSize,  /* I  Length of input                             */
258     const opus_int       correlationCount /* I  Number of correlation taps to compute      */
259 );
260
261 /* Pitch estimator */
262 #define SILK_PE_MIN_COMPLEX        0
263 #define SILK_PE_MID_COMPLEX        1
264 #define SILK_PE_MAX_COMPLEX        2
265
266 void silk_decode_pitch(
267     opus_int16       lagIndex,                        /* I                             */
268     opus_int8        contourIndex,                    /* O                             */
269     opus_int         pitch_lags[],                    /* O 4 pitch values              */
270     const opus_int   Fs_kHz,                          /* I sampling frequency (kHz)    */
271     const opus_int   nb_subfr                         /* I number of sub frames        */
272 );
273
274 opus_int silk_pitch_analysis_core(        /* O    Voicing estimate: 0 voiced, 1 unvoiced                     */
275     const opus_int16  *signal,            /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                 */
276     opus_int          *pitch_out,         /* O    4 pitch lag values                                         */
277     opus_int16        *lagIndex,          /* O    Lag Index                                                  */
278     opus_int8         *contourIndex,      /* O    Pitch contour Index                                        */
279     opus_int          *LTPCorr_Q15,       /* I/O  Normalized correlation; input: value from previous frame   */
280     opus_int          prevLag,            /* I    Last lag of previous frame; set to zero is unvoiced        */
281     const opus_int32  search_thres1_Q16,  /* I    First stage threshold for lag candidates 0 - 1             */
282     const opus_int    search_thres2_Q15,  /* I    Final threshold for lag candidates 0 - 1                   */
283     const opus_int    Fs_kHz,             /* I    Sample frequency (kHz)                                     */
284     const opus_int    complexity,         /* I    Complexity setting, 0-2, where 2 is highest                */
285     const opus_int    nb_subfr            /* I    number of 5 ms subframes                                   */
286 );
287
288 /* Compute Normalized Line Spectral Frequencies (NLSFs) from whitening filter coefficients      */
289 /* If not all roots are found, the a_Q16 coefficients are bandwidth expanded until convergence. */
290 void silk_A2NLSF(
291     opus_int16          *NLSF,            /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d] */
292     opus_int32          *a_Q16,           /* I/O  Monic whitening filter coefficients in Q16 [d]                */
293     const opus_int      d                 /* I    Filter order (must be even)                                   */
294 );
295
296 /* compute whitening filter coefficients from normalized line spectral frequencies */
297 void silk_NLSF2A(
298     opus_int16        *a_Q12,            /* O    monic whitening filter coefficients in Q12,  [ d ]  */
299     const opus_int16  *NLSF,             /* I    normalized line spectral frequencies in Q15, [ d ]  */
300     const opus_int    d                  /* I    filter order (should be even)                       */
301 );
302
303 void silk_insertion_sort_increasing(
304     opus_int32            *a,            /* I/O   Unsorted / Sorted vector                */
305     opus_int              *idx,          /* O:    Index vector for the sorted elements    */
306     const opus_int        L,             /* I:    Vector length                           */
307     const opus_int        K              /* I:    Number of correctly sorted positions    */
308 );
309
310 void silk_insertion_sort_decreasing_int16(
311     opus_int16            *a,            /* I/O:  Unsorted / Sorted vector                */
312     opus_int              *idx,          /* O:    Index vector for the sorted elements    */
313     const opus_int        L,             /* I:    Vector length                           */
314     const opus_int        K              /* I:    Number of correctly sorted positions    */
315 );
316
317 void silk_insertion_sort_increasing_all_values_int16(
318      opus_int16           *a,            /* I/O:  Unsorted / Sorted vector                */
319      const opus_int       L              /* I:    Vector length                           */
320 );
321
322 /* NLSF stabilizer, for a single input data vector */
323 void silk_NLSF_stabilize(
324           opus_int16      *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */
325     const opus_int16      *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */
326     const opus_int        L               /* I:    Number of NLSF parameters in the input vector                           */
327 );
328
329 /* Laroia low complexity NLSF weights */
330 void silk_NLSF_VQ_weights_laroia(
331     opus_int16            *pNLSFW_Q_OUT,  /* O:    Pointer to input vector weights            [D x 1]       */
332     const opus_int16      *pNLSF_Q15,     /* I:    Pointer to input vector                    [D x 1]       */
333     const opus_int        D               /* I:    Input vector dimension (even)                            */
334 );
335
336 /* Compute reflection coefficients from input signal */
337 void silk_burg_modified(
338     opus_int32            *res_nrg,           /* O   residual energy                                                 */
339     opus_int              *res_nrgQ,          /* O   residual energy Q value                                         */
340     opus_int32            A_Q16[],            /* O   prediction coefficients (length order)                          */
341     const opus_int16      x[],                /* I   input signal, length: nb_subfr * ( D + subfr_length )           */
342     const opus_int        subfr_length,       /* I   input signal subframe length (including D preceeding samples)   */
343     const opus_int        nb_subfr,           /* I   number of subframes stacked in x                                */
344     const opus_int32      WhiteNoiseFrac_Q32, /* I   fraction added to zero-lag autocorrelation                      */
345     const opus_int        D                   /* I   order                                                           */
346 );
347
348 /* Copy and multiply a vector by a constant */
349 void silk_scale_copy_vector16(
350     opus_int16            *data_out,
351     const opus_int16      *data_in,
352     opus_int32            gain_Q16,           /* I:   gain in Q16   */
353     const opus_int        dataSize            /* I:   length        */
354 );
355
356 /* Some for the LTP related function requires Q26 to work.*/
357 void silk_scale_vector32_Q26_lshift_18(
358     opus_int32            *data1,             /* I/O: Q0/Q18        */
359     opus_int32            gain_Q26,           /* I:   Q26           */
360     opus_int              dataSize            /* I:   length        */
361 );
362
363 /********************************************************************/
364 /*                        INLINE ARM MATH                             */
365 /********************************************************************/
366
367 /*    return sum(inVec1[i]*inVec2[i])    */
368 opus_int32 silk_inner_prod_aligned(
369     const opus_int16 *const  inVec1,     /*    I input vector 1    */
370     const opus_int16 *const  inVec2,     /*    I input vector 2    */
371     const opus_int           len         /*    I vector lengths    */
372 );
373
374 opus_int32 silk_inner_prod_aligned_scale(
375     const opus_int16 *const  inVec1,     /*    I input vector 1          */
376     const opus_int16 *const  inVec2,     /*    I input vector 2          */
377     const opus_int           scale,      /*    I number of bits to shift */
378     const opus_int           len         /*    I vector lengths          */
379 );
380
381 opus_int64 silk_inner_prod16_aligned_64(
382     const opus_int16         *inVec1,    /*    I input vector 1    */
383     const opus_int16         *inVec2,    /*    I input vector 2    */
384     const opus_int           len         /*    I vector lengths    */
385 );
386
387 /********************************************************************/
388 /*                                MACROS                            */
389 /********************************************************************/
390
391 /* Rotate a32 right by 'rot' bits. Negative rot values result in rotating
392    left. Output is 32bit int.
393    Note: contemporary compilers recognize the C expression below and
394    compile it into a 'ror' instruction if available. No need for inline ASM! */
395 SKP_INLINE opus_int32 silk_ROR32( opus_int32 a32, opus_int rot )
396 {
397     opus_uint32 x = (opus_uint32) a32;
398     opus_uint32 r = (opus_uint32) rot;
399     opus_uint32 m = (opus_uint32) -rot;
400     if(rot <= 0)
401         return (opus_int32) ((x << m) | (x >> (32 - m)));
402     else
403         return (opus_int32) ((x << (32 - r)) | (x >> r));
404 }
405
406 /* Allocate opus_int16 alligned to 4-byte memory address */
407 #if EMBEDDED_ARM
408 #define SKP_DWORD_ALIGN __attribute__((aligned(4)))
409 #else
410 #define SKP_DWORD_ALIGN
411 #endif
412
413 /* Useful Macros that can be adjusted to other platforms */
414 #define SKP_memcpy(a, b, c)                memcpy((a), (b), (c))    /* Dest, Src, ByteCount */
415 #define SKP_memset(a, b, c)                memset((a), (b), (c))    /* Dest, value, ByteCount */
416 #define SKP_memmove(a, b, c)               memmove((a), (b), (c))   /* Dest, Src, ByteCount */
417 /* fixed point macros */
418
419 // (a32 * b32) output have to be 32bit int
420 #define SKP_MUL(a32, b32)                  ((a32) * (b32))
421
422 // (a32 * b32) output have to be 32bit uint
423 #define SKP_MUL_uint(a32, b32)             SKP_MUL(a32, b32)
424
425 // a32 + (b32 * c32) output have to be 32bit int
426 #define SKP_MLA(a32, b32, c32)             SKP_ADD32((a32),((b32) * (c32)))
427
428 // a32 + (b32 * c32) output have to be 32bit uint
429 #define SKP_MLA_uint(a32, b32, c32)        SKP_MLA(a32, b32, c32)
430
431 // ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int
432 #define SKP_SMULTT(a32, b32)               (((a32) >> 16) * ((b32) >> 16))
433
434 // a32 + ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int
435 #define SKP_SMLATT(a32, b32, c32)          SKP_ADD32((a32),((b32) >> 16) * ((c32) >> 16))
436
437 #define SKP_SMLALBB(a64, b16, c16)         SKP_ADD64((a64),(opus_int64)((opus_int32)(b16) * (opus_int32)(c16)))
438
439 // (a32 * b32)
440 #define SKP_SMULL(a32, b32)                ((opus_int64)(a32) * /*(opus_int64)*/(b32))
441
442 // multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode)
443 #define SKP_MLA_ovflw(a32, b32, c32)       SKP_MLA(a32, b32, c32)
444 #ifndef SKP_SMLABB_ovflw
445 #    define SKP_SMLABB_ovflw(a32, b32, c32)    SKP_SMLABB(a32, b32, c32)
446 #endif
447 #define SKP_SMLABT_ovflw(a32, b32, c32)    SKP_SMLABT(a32, b32, c32)
448 #define SKP_SMLATT_ovflw(a32, b32, c32)    SKP_SMLATT(a32, b32, c32)
449 #define SKP_SMLAWB_ovflw(a32, b32, c32)    SKP_SMLAWB(a32, b32, c32)
450 #define SKP_SMLAWT_ovflw(a32, b32, c32)    SKP_SMLAWT(a32, b32, c32)
451
452 #define SKP_DIV32_16(a32, b16)             ((opus_int32)((a32) / (b16)))
453 #define SKP_DIV32(a32, b32)                ((opus_int32)((a32) / (b32)))
454
455 // These macros enables checking for overflow in silk_API_Debug.h
456 #define SKP_ADD16(a, b)                    ((a) + (b))
457 #define SKP_ADD32(a, b)                    ((a) + (b))
458 #define SKP_ADD64(a, b)                    ((a) + (b))
459
460 #define SKP_SUB16(a, b)                    ((a) - (b))
461 #define SKP_SUB32(a, b)                    ((a) - (b))
462 #define SKP_SUB64(a, b)                    ((a) - (b))
463
464 #define SKP_SAT8(a)                        ((a) > SKP_int8_MAX ? SKP_int8_MAX  : \
465                                            ((a) < SKP_int8_MIN ? SKP_int8_MIN  : (a)))
466 #define SKP_SAT16(a)                       ((a) > SKP_int16_MAX ? SKP_int16_MAX : \
467                                            ((a) < SKP_int16_MIN ? SKP_int16_MIN : (a)))
468 #define SKP_SAT32(a)                       ((a) > SKP_int32_MAX ? SKP_int32_MAX : \
469                                            ((a) < SKP_int32_MIN ? SKP_int32_MIN : (a)))
470
471 #define SKP_CHECK_FIT8(a)                  (a)
472 #define SKP_CHECK_FIT16(a)                 (a)
473 #define SKP_CHECK_FIT32(a)                 (a)
474
475 #define SKP_ADD_SAT16(a, b)                (opus_int16)SKP_SAT16( SKP_ADD32( (opus_int32)(a), (b) ) )
476 #define SKP_ADD_SAT64(a, b)                ((((a) + (b)) & 0x8000000000000000LL) == 0 ?                            \
477                                            ((((a) & (b)) & 0x8000000000000000LL) != 0 ? SKP_int64_MIN : (a)+(b)) :    \
478                                            ((((a) | (b)) & 0x8000000000000000LL) == 0 ? SKP_int64_MAX : (a)+(b)) )
479
480 #define SKP_SUB_SAT16(a, b)                (opus_int16)SKP_SAT16( SKP_SUB32( (opus_int32)(a), (b) ) )
481 #define SKP_SUB_SAT64(a, b)                ((((a)-(b)) & 0x8000000000000000LL) == 0 ?                                                    \
482                                            (( (a) & ((b)^0x8000000000000000LL) & 0x8000000000000000LL) ? SKP_int64_MIN : (a)-(b)) :    \
483                                            ((((a)^0x8000000000000000LL) & (b)  & 0x8000000000000000LL) ? SKP_int64_MAX : (a)-(b)) )
484
485 /* Saturation for positive input values */
486 #define SKP_POS_SAT32(a)                   ((a) > SKP_int32_MAX ? SKP_int32_MAX : (a))
487
488 /* Add with saturation for positive input values */
489 #define SKP_ADD_POS_SAT8(a, b)             ((((a)+(b)) & 0x80)                 ? SKP_int8_MAX  : ((a)+(b)))
490 #define SKP_ADD_POS_SAT16(a, b)            ((((a)+(b)) & 0x8000)               ? SKP_int16_MAX : ((a)+(b)))
491 #define SKP_ADD_POS_SAT32(a, b)            ((((a)+(b)) & 0x80000000)           ? SKP_int32_MAX : ((a)+(b)))
492 #define SKP_ADD_POS_SAT64(a, b)            ((((a)+(b)) & 0x8000000000000000LL) ? SKP_int64_MAX : ((a)+(b)))
493
494 #define SKP_LSHIFT8(a, shift)              ((a)<<(shift))                // shift >= 0, shift < 8
495 #define SKP_LSHIFT16(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 16
496 #define SKP_LSHIFT32(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 32
497 #define SKP_LSHIFT64(a, shift)             ((a)<<(shift))                // shift >= 0, shift < 64
498 #define SKP_LSHIFT(a, shift)               SKP_LSHIFT32(a, shift)        // shift >= 0, shift < 32
499
500 #define SKP_RSHIFT8(a, shift)              ((a)>>(shift))                // shift >= 0, shift < 8
501 #define SKP_RSHIFT16(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 16
502 #define SKP_RSHIFT32(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 32
503 #define SKP_RSHIFT64(a, shift)             ((a)>>(shift))                // shift >= 0, shift < 64
504 #define SKP_RSHIFT(a, shift)               SKP_RSHIFT32(a, shift)        // shift >= 0, shift < 32
505
506 /* saturates before shifting */
507 #define SKP_LSHIFT_SAT16(a, shift)         (SKP_LSHIFT16( SKP_LIMIT( (a), SKP_RSHIFT16( SKP_int16_MIN, (shift) ),    \
508                                                                           SKP_RSHIFT16( SKP_int16_MAX, (shift) ) ), (shift) ))
509 #define SKP_LSHIFT_SAT32(a, shift)         (SKP_LSHIFT32( SKP_LIMIT( (a), SKP_RSHIFT32( SKP_int32_MIN, (shift) ),    \
510                                                                           SKP_RSHIFT32( SKP_int32_MAX, (shift) ) ), (shift) ))
511
512 #define SKP_LSHIFT_ovflw(a, shift)        ((a)<<(shift))        // shift >= 0, allowed to overflow
513 #define SKP_LSHIFT_uint(a, shift)         ((a)<<(shift))        // shift >= 0
514 #define SKP_RSHIFT_uint(a, shift)         ((a)>>(shift))        // shift >= 0
515
516 #define SKP_ADD_LSHIFT(a, b, shift)       ((a) + SKP_LSHIFT((b), (shift)))            // shift >= 0
517 #define SKP_ADD_LSHIFT32(a, b, shift)     SKP_ADD32((a), SKP_LSHIFT32((b), (shift)))    // shift >= 0
518 #define SKP_ADD_LSHIFT_uint(a, b, shift)  ((a) + SKP_LSHIFT_uint((b), (shift)))        // shift >= 0
519 #define SKP_ADD_RSHIFT(a, b, shift)       ((a) + SKP_RSHIFT((b), (shift)))            // shift >= 0
520 #define SKP_ADD_RSHIFT32(a, b, shift)     SKP_ADD32((a), SKP_RSHIFT32((b), (shift)))    // shift >= 0
521 #define SKP_ADD_RSHIFT_uint(a, b, shift)  ((a) + SKP_RSHIFT_uint((b), (shift)))        // shift >= 0
522 #define SKP_SUB_LSHIFT32(a, b, shift)     SKP_SUB32((a), SKP_LSHIFT32((b), (shift)))    // shift >= 0
523 #define SKP_SUB_RSHIFT32(a, b, shift)     SKP_SUB32((a), SKP_RSHIFT32((b), (shift)))    // shift >= 0
524
525 /* Requires that shift > 0 */
526 #define SKP_RSHIFT_ROUND(a, shift)        ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
527 #define SKP_RSHIFT_ROUND64(a, shift)      ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
528
529 /* Number of rightshift required to fit the multiplication */
530 #define SKP_NSHIFT_MUL_32_32(a, b)        ( -(31- (32-silk_CLZ32(SKP_abs(a)) + (32-silk_CLZ32(SKP_abs(b))))) )
531 #define SKP_NSHIFT_MUL_16_16(a, b)        ( -(15- (16-silk_CLZ16(SKP_abs(a)) + (16-silk_CLZ16(SKP_abs(b))))) )
532
533
534 #define SKP_min(a, b)                     (((a) < (b)) ? (a) : (b))
535 #define SKP_max(a, b)                     (((a) > (b)) ? (a) : (b))
536
537 /* Macro to convert floating-point constants to fixed-point */
538 #define SILK_FIX_CONST( C, Q )           ((opus_int32)((C) * ((opus_int64)1 << (Q)) + 0.5))
539
540 /* SKP_min() versions with typecast in the function call */
541 SKP_INLINE opus_int SKP_min_int(opus_int a, opus_int b)
542 {
543     return (((a) < (b)) ? (a) : (b));
544 }
545 SKP_INLINE opus_int16 SKP_min_16(opus_int16 a, opus_int16 b)
546 {
547     return (((a) < (b)) ? (a) : (b));
548 }
549 SKP_INLINE opus_int32 SKP_min_32(opus_int32 a, opus_int32 b)
550 {
551     return (((a) < (b)) ? (a) : (b));
552 }
553 SKP_INLINE opus_int64 SKP_min_64(opus_int64 a, opus_int64 b)
554 {
555     return (((a) < (b)) ? (a) : (b));
556 }
557
558 /* SKP_min() versions with typecast in the function call */
559 SKP_INLINE opus_int SKP_max_int(opus_int a, opus_int b)
560 {
561     return (((a) > (b)) ? (a) : (b));
562 }
563 SKP_INLINE opus_int16 SKP_max_16(opus_int16 a, opus_int16 b)
564 {
565     return (((a) > (b)) ? (a) : (b));
566 }
567 SKP_INLINE opus_int32 SKP_max_32(opus_int32 a, opus_int32 b)
568 {
569     return (((a) > (b)) ? (a) : (b));
570 }
571 SKP_INLINE opus_int64 SKP_max_64(opus_int64 a, opus_int64 b)
572 {
573     return (((a) > (b)) ? (a) : (b));
574 }
575
576 #define SKP_LIMIT( a, limit1, limit2)    ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
577                                                              : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))
578
579 #define SKP_LIMIT_int SKP_LIMIT
580 #define SKP_LIMIT_16 SKP_LIMIT
581 #define SKP_LIMIT_32 SKP_LIMIT
582
583 //#define SKP_non_neg(a)                 ((a) & ((-(a)) >> (8 * sizeof(a) - 1)))   /* doesn't seem faster than SKP_max(0, a);
584
585 #define SKP_abs(a)                       (((a) >  0)  ? (a) : -(a))            // Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN
586 #define SKP_abs_int(a)                   (((a) ^ ((a) >> (8 * sizeof(a) - 1))) - ((a) >> (8 * sizeof(a) - 1)))
587 #define SKP_abs_int32(a)                 (((a) ^ ((a) >> 31)) - ((a) >> 31))
588 #define SKP_abs_int64(a)                 (((a) >  0)  ? (a) : -(a))
589
590 #define SKP_sign(a)                      ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ))
591
592 #define SKP_sqrt(a)                      (sqrt(a))
593
594 /* PSEUDO-RANDOM GENERATOR                                                          */
595 /* Make sure to store the result as the seed for the next call (also in between     */
596 /* frames), otherwise result won't be random at all. When only using some of the    */
597 /* bits, take the most significant bits by right-shifting.                          */
598 #define SKP_RAND(seed)                   (SKP_MLA_ovflw(907633515, (seed), 196314165))
599
600 // Add some multiplication functions that can be easily mapped to ARM.
601
602 //    SKP_SMMUL: Signed top word multiply.
603 //        ARMv6        2 instruction cycles.
604 //        ARMv3M+        3 instruction cycles. use SMULL and ignore LSB registers.(except xM)
605 //#define SKP_SMMUL(a32, b32)            (opus_int32)SKP_RSHIFT(SKP_SMLAL(SKP_SMULWB((a32), (b32)), (a32), SKP_RSHIFT_ROUND((b32), 16)), 16)
606 // the following seems faster on x86
607 #define SKP_SMMUL(a32, b32)              (opus_int32)SKP_RSHIFT64(SKP_SMULL((a32), (b32)), 32)
608
609 #include "silk_Inlines.h"
610 #include "silk_MacroCount.h"
611 #include "silk_MacroDebug.h"
612
613 #ifdef  __cplusplus
614 }
615 #endif
616
617 #endif