edb307f8cc7bce4f0d3ebfb8f73432ea639987b7
[opus.git] / 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 silk_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 "typedef.h"
43 #include "resampler_structs.h"
44 #include "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     int stride
131 );
132
133 /* Variable order MA prediction error filter. */
134 void silk_LPC_analysis_filter(
135     opus_int16            *out,         /* O:   Output signal                               */
136     const opus_int16      *in,          /* I:   Input signal                                */
137     const opus_int16      *B,           /* I:   MA prediction coefficients, Q12 [order]     */
138     const opus_int32      len,          /* I:   Signal length                               */
139     const opus_int32      Order         /* I:   Filter order                                */
140 );
141
142 /* Chirp (bandwidth expand) LP AR filter */
143 void silk_bwexpander(
144     opus_int16            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */
145     const opus_int        d,            /* I    Length of ar                                    */
146     opus_int32            chirp_Q16     /* I    Chirp factor (typically in the range 0 to 1)    */
147 );
148
149 /* Chirp (bandwidth expand) LP AR filter */
150 void silk_bwexpander_32(
151     opus_int32            *ar,          /* I/O  AR filter to be expanded (without leading 1)    */
152     const opus_int        d,            /* I    Length of ar                                    */
153     opus_int32            chirp_Q16     /* I    Chirp factor in Q16                             */
154 );
155
156 /* Compute inverse of LPC prediction gain, and                           */
157 /* test if LPC coefficients are stable (all poles within unit circle)    */
158 opus_int silk_LPC_inverse_pred_gain(     /* O:  Returns 1 if unstable, otherwise 0          */
159     opus_int32            *invGain_Q30,  /* O:  Inverse prediction gain, Q30 energy domain  */
160     const opus_int16      *A_Q12,        /* I:  Prediction coefficients, Q12 [order]        */
161     const opus_int        order          /* I:  Prediction order                            */
162 );
163
164 opus_int silk_LPC_inverse_pred_gain_Q24( /* O:   Returns 1 if unstable, otherwise 0      */
165     opus_int32           *invGain_Q30,   /* O:   Inverse prediction gain, Q30 energy domain  */
166     const opus_int32     *A_Q24,         /* I:   Prediction coefficients, Q24 [order]        */
167     const opus_int       order           /* I:   Prediction order                            */
168 );
169
170 /* split signal in two decimated bands using first-order allpass filters */
171 void silk_ana_filt_bank_1(
172     const opus_int16      *in,           /* I:   Input signal [N]        */
173     opus_int32            *S,            /* I/O: State vector [2]        */
174     opus_int16            *outL,         /* O:   Low band [N/2]          */
175     opus_int16            *outH,         /* O:   High band [N/2]         */
176     const opus_int32      N              /* I:   Number of input samples */
177 );
178
179 /********************************************************************/
180 /*                        SCALAR FUNCTIONS                          */
181 /********************************************************************/
182
183 /* approximation of 128 * log2() (exact inverse of approx 2^() below) */
184 /* convert input to a log scale    */
185 opus_int32 silk_lin2log(const opus_int32 inLin);        /* I: input in linear scale        */
186
187 /* Approximation of a sigmoid function */
188 opus_int silk_sigm_Q15(opus_int in_Q5);
189
190 /* approximation of 2^() (exact inverse of approx log2() above) */
191 /* convert input to a linear scale    */
192 opus_int32 silk_log2lin(const opus_int32 inLog_Q7);    /* I: input on log scale */
193
194 /* Function that returns the maximum absolut value of the input vector */
195 opus_int16 silk_int16_array_maxabs(      /* O   Maximum absolute value, max: 2^15-1   */
196     const opus_int16     *vec,           /* I   Input vector  [len]                   */
197     const opus_int32     len             /* I   Length of input vector                */
198 );
199
200 /* Compute number of bits to right shift the sum of squares of a vector    */
201 /* of int16s to make it fit in an int32                                    */
202 void silk_sum_sqr_shift(
203     opus_int32           *energy,        /* O   Energy of x, after shifting to the right            */
204     opus_int             *shift,         /* O   Number of bits right shift applied to energy        */
205     const opus_int16     *x,             /* I   Input vector                                        */
206     opus_int             len             /* I   Length of input vector                              */
207 );
208
209 /* Calculates the reflection coefficients from the correlation sequence    */
210 /* Faster than schur64(), but much less accurate.                          */
211 /* uses SMLAWB(), requiring armv5E and higher.                             */
212 opus_int32 silk_schur(                   /* O:    Returns residual energy                   */
213     opus_int16           *rc_Q15,        /* O:    reflection coefficients [order] Q15       */
214     const opus_int32     *c,             /* I:    correlations [order+1]                    */
215     const opus_int32     order           /* I:    prediction order                          */
216 );
217
218 /* Calculates the reflection coefficients from the correlation sequence    */
219 /* Slower than schur(), but more accurate.                                 */
220 /* Uses SMULL(), available on armv4                                        */
221 opus_int32 silk_schur64(                 /* O:  returns residual energy                     */
222     opus_int32           rc_Q16[],       /* O:  Reflection coefficients [order] Q16         */
223     const opus_int32     c[],            /* I:  Correlations [order+1]                      */
224     opus_int32           order           /* I:  Prediction order                            */
225 );
226
227 /* Step up function, converts reflection coefficients to prediction coefficients */
228 void silk_k2a(
229     opus_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */
230     const opus_int16     *rc_Q15,        /* I:  Reflection coefficients [order] Q15         */
231     const opus_int32     order           /* I:  Prediction order                            */
232 );
233
234 /* Step up function, converts reflection coefficients to prediction coefficients */
235 void silk_k2a_Q16(
236     opus_int32           *A_Q24,         /* O:  Prediction coefficients [order] Q24         */
237     const opus_int32     *rc_Q16,        /* I:  Reflection coefficients [order] Q16         */
238     const opus_int32     order           /* I:  Prediction order                            */
239 );
240
241 /* Apply sine window to signal vector.                                      */
242 /* Window types:                                                            */
243 /*    1 -> sine window from 0 to pi/2                                       */
244 /*    2 -> sine window from pi/2 to pi                                      */
245 /* every other sample of window is linearly interpolated, for speed         */
246 void silk_apply_sine_window(
247     opus_int16           px_win[],       /* O  Pointer to windowed signal                  */
248     const opus_int16     px[],           /* I  Pointer to input signal                     */
249     const opus_int       win_type,       /* I  Selects a window type                       */
250     const opus_int       length          /* I  Window length, multiple of 4                */
251 );
252
253 /* Compute autocorrelation */
254 void silk_autocorr(
255     opus_int32           *results,       /* O  Result (length correlationCount)            */
256     opus_int             *scale,         /* O  Scaling of the correlation vector           */
257     const opus_int16     *inputData,     /* I  Input data to correlate                     */
258     const opus_int       inputDataSize,  /* I  Length of input                             */
259     const opus_int       correlationCount /* I  Number of correlation taps to compute      */
260 );
261
262 /* Pitch estimator */
263 #define SILK_PE_MIN_COMPLEX        0
264 #define SILK_PE_MID_COMPLEX        1
265 #define SILK_PE_MAX_COMPLEX        2
266
267 void silk_decode_pitch(
268     opus_int16       lagIndex,                        /* I                             */
269     opus_int8        contourIndex,                    /* O                             */
270     opus_int         pitch_lags[],                    /* O 4 pitch values              */
271     const opus_int   Fs_kHz,                          /* I sampling frequency (kHz)    */
272     const opus_int   nb_subfr                         /* I number of sub frames        */
273 );
274
275 opus_int silk_pitch_analysis_core(        /* O    Voicing estimate: 0 voiced, 1 unvoiced                     */
276     const opus_int16  *signal,            /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                 */
277     opus_int          *pitch_out,         /* O    4 pitch lag values                                         */
278     opus_int16        *lagIndex,          /* O    Lag Index                                                  */
279     opus_int8         *contourIndex,      /* O    Pitch contour Index                                        */
280     opus_int          *LTPCorr_Q15,       /* I/O  Normalized correlation; input: value from previous frame   */
281     opus_int          prevLag,            /* I    Last lag of previous frame; set to zero is unvoiced        */
282     const opus_int32  search_thres1_Q16,  /* I    First stage threshold for lag candidates 0 - 1             */
283     const opus_int    search_thres2_Q15,  /* I    Final threshold for lag candidates 0 - 1                   */
284     const opus_int    Fs_kHz,             /* I    Sample frequency (kHz)                                     */
285     const opus_int    complexity,         /* I    Complexity setting, 0-2, where 2 is highest                */
286     const opus_int    nb_subfr            /* I    number of 5 ms subframes                                   */
287 );
288
289 /* Compute Normalized Line Spectral Frequencies (NLSFs) from whitening filter coefficients      */
290 /* If not all roots are found, the a_Q16 coefficients are bandwidth expanded until convergence. */
291 void silk_A2NLSF(
292     opus_int16          *NLSF,            /* O    Normalized Line Spectral Frequencies, Q15 (0 - (2^15-1)), [d] */
293     opus_int32          *a_Q16,           /* I/O  Monic whitening filter coefficients in Q16 [d]                */
294     const opus_int      d                 /* I    Filter order (must be even)                                   */
295 );
296
297 /* compute whitening filter coefficients from normalized line spectral frequencies */
298 void silk_NLSF2A(
299     opus_int16        *a_Q12,            /* O    monic whitening filter coefficients in Q12,  [ d ]  */
300     const opus_int16  *NLSF,             /* I    normalized line spectral frequencies in Q15, [ d ]  */
301     const opus_int    d                  /* I    filter order (should be even)                       */
302 );
303
304 void silk_insertion_sort_increasing(
305     opus_int32            *a,            /* I/O   Unsorted / Sorted vector                */
306     opus_int              *idx,          /* O:    Index vector for the sorted elements    */
307     const opus_int        L,             /* I:    Vector length                           */
308     const opus_int        K              /* I:    Number of correctly sorted positions    */
309 );
310
311 void silk_insertion_sort_decreasing_int16(
312     opus_int16            *a,            /* I/O:  Unsorted / Sorted vector                */
313     opus_int              *idx,          /* O:    Index vector for the sorted elements    */
314     const opus_int        L,             /* I:    Vector length                           */
315     const opus_int        K              /* I:    Number of correctly sorted positions    */
316 );
317
318 void silk_insertion_sort_increasing_all_values_int16(
319      opus_int16           *a,            /* I/O:  Unsorted / Sorted vector                */
320      const opus_int       L              /* I:    Vector length                           */
321 );
322
323 /* NLSF stabilizer, for a single input data vector */
324 void silk_NLSF_stabilize(
325           opus_int16      *NLSF_Q15,      /* I/O:  Unstable/stabilized normalized LSF vector in Q15 [L]                    */
326     const opus_int16      *NDeltaMin_Q15, /* I:    Normalized delta min vector in Q15, NDeltaMin_Q15[L] must be >= 1 [L+1] */
327     const opus_int        L               /* I:    Number of NLSF parameters in the input vector                           */
328 );
329
330 /* Laroia low complexity NLSF weights */
331 void silk_NLSF_VQ_weights_laroia(
332     opus_int16            *pNLSFW_Q_OUT,  /* O:    Pointer to input vector weights            [D x 1]       */
333     const opus_int16      *pNLSF_Q15,     /* I:    Pointer to input vector                    [D x 1]       */
334     const opus_int        D               /* I:    Input vector dimension (even)                            */
335 );
336
337 /* Compute reflection coefficients from input signal */
338 void silk_burg_modified(
339     opus_int32            *res_nrg,           /* O   residual energy                                                 */
340     opus_int              *res_nrgQ,          /* O   residual energy Q value                                         */
341     opus_int32            A_Q16[],            /* O   prediction coefficients (length order)                          */
342     const opus_int16      x[],                /* I   input signal, length: nb_subfr * ( D + subfr_length )           */
343     const opus_int        subfr_length,       /* I   input signal subframe length (including D preceeding samples)   */
344     const opus_int        nb_subfr,           /* I   number of subframes stacked in x                                */
345     const opus_int32      WhiteNoiseFrac_Q32, /* I   fraction added to zero-lag autocorrelation                      */
346     const opus_int        D                   /* I   order                                                           */
347 );
348
349 /* Copy and multiply a vector by a constant */
350 void silk_scale_copy_vector16(
351     opus_int16            *data_out,
352     const opus_int16      *data_in,
353     opus_int32            gain_Q16,           /* I:   gain in Q16   */
354     const opus_int        dataSize            /* I:   length        */
355 );
356
357 /* Some for the LTP related function requires Q26 to work.*/
358 void silk_scale_vector32_Q26_lshift_18(
359     opus_int32            *data1,             /* I/O: Q0/Q18        */
360     opus_int32            gain_Q26,           /* I:   Q26           */
361     opus_int              dataSize            /* I:   length        */
362 );
363
364 /********************************************************************/
365 /*                        INLINE ARM MATH                             */
366 /********************************************************************/
367
368 /*    return sum(inVec1[i]*inVec2[i])    */
369 opus_int32 silk_inner_prod_aligned(
370     const opus_int16 *const  inVec1,     /*    I input vector 1    */
371     const opus_int16 *const  inVec2,     /*    I input vector 2    */
372     const opus_int           len         /*    I vector lengths    */
373 );
374
375 opus_int32 silk_inner_prod_aligned_scale(
376     const opus_int16 *const  inVec1,     /*    I input vector 1          */
377     const opus_int16 *const  inVec2,     /*    I input vector 2          */
378     const opus_int           scale,      /*    I number of bits to shift */
379     const opus_int           len         /*    I vector lengths          */
380 );
381
382 opus_int64 silk_inner_prod16_aligned_64(
383     const opus_int16         *inVec1,    /*    I input vector 1    */
384     const opus_int16         *inVec2,    /*    I input vector 2    */
385     const opus_int           len         /*    I vector lengths    */
386 );
387
388 /********************************************************************/
389 /*                                MACROS                            */
390 /********************************************************************/
391
392 /* Rotate a32 right by 'rot' bits. Negative rot values result in rotating
393    left. Output is 32bit int.
394    Note: contemporary compilers recognize the C expression below and
395    compile it into a 'ror' instruction if available. No need for inline ASM! */
396 static inline opus_int32 silk_ROR32( opus_int32 a32, opus_int rot )
397 {
398     opus_uint32 x = (opus_uint32) a32;
399     opus_uint32 r = (opus_uint32) rot;
400     opus_uint32 m = (opus_uint32) -rot;
401     if (rot==0)
402        return a32;
403     else if(rot < 0)
404         return (opus_int32) ((x << m) | (x >> (32 - m)));
405     else
406         return (opus_int32) ((x << (32 - r)) | (x >> r));
407 }
408
409 /* Allocate opus_int16 alligned to 4-byte memory address */
410 #if EMBEDDED_ARM
411 #define silk_DWORD_ALIGN __attribute__((aligned(4)))
412 #else
413 #define silk_DWORD_ALIGN
414 #endif
415
416 /* Useful Macros that can be adjusted to other platforms */
417 #define silk_memcpy(a, b, c)                memcpy((a), (b), (c))    /* Dest, Src, ByteCount */
418 #define silk_memset(a, b, c)                memset((a), (b), (c))    /* Dest, value, ByteCount */
419 #define silk_memmove(a, b, c)               memmove((a), (b), (c))   /* Dest, Src, ByteCount */
420 /* fixed point macros */
421
422 /* (a32 * b32) output have to be 32bit int */
423 #define silk_MUL(a32, b32)                  ((a32) * (b32))
424
425 /* (a32 * b32) output have to be 32bit uint */
426 #define silk_MUL_uint(a32, b32)             silk_MUL(a32, b32)
427
428 /* a32 + (b32 * c32) output have to be 32bit int */
429 #define silk_MLA(a32, b32, c32)             silk_ADD32((a32),((b32) * (c32)))
430
431 /* a32 + (b32 * c32) output have to be 32bit uint */
432 #define silk_MLA_uint(a32, b32, c32)        silk_MLA(a32, b32, c32)
433
434 /* ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int */
435 #define silk_SMULTT(a32, b32)               (((a32) >> 16) * ((b32) >> 16))
436
437 /* a32 + ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int */
438 #define silk_SMLATT(a32, b32, c32)          silk_ADD32((a32),((b32) >> 16) * ((c32) >> 16))
439
440 #define silk_SMLALBB(a64, b16, c16)         silk_ADD64((a64),(opus_int64)((opus_int32)(b16) * (opus_int32)(c16)))
441
442 /* (a32 * b32) */
443 #define silk_SMULL(a32, b32)                ((opus_int64)(a32) * /*(opus_int64)*/(b32))
444
445 /* Adds two signed 32-bit values in a way that can overflow, while not relying on undefined behaviour
446    (just standard two's complement implementation-specific behaviour) */
447 #define silk_ADD32_ovflw(a, b)              ((opus_int32)((opus_uint32)(a) + (opus_uint32)(b)))
448
449 /* Multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode)*/
450 #define silk_MLA_ovflw(a32, b32, c32)       silk_ADD32_ovflw((a32), (opus_uint32)(b32) * (opus_uint32)(c32))
451 #ifndef silk_SMLABB_ovflw
452 #    define silk_SMLABB_ovflw(a32, b32, c32)    silk_ADD32_ovflw((a32), (opus_int32)((opus_int16)(b32)) * (opus_int32)((opus_int16)(c32)))
453 #endif
454
455 #define silk_DIV32_16(a32, b16)             ((opus_int32)((a32) / (b16)))
456 #define silk_DIV32(a32, b32)                ((opus_int32)((a32) / (b32)))
457
458 /* These macros enables checking for overflow in silk_API_Debug.h*/
459 #define silk_ADD16(a, b)                    ((a) + (b))
460 #define silk_ADD32(a, b)                    ((a) + (b))
461 #define silk_ADD64(a, b)                    ((a) + (b))
462
463 #define silk_SUB16(a, b)                    ((a) - (b))
464 #define silk_SUB32(a, b)                    ((a) - (b))
465 #define silk_SUB64(a, b)                    ((a) - (b))
466
467 #define silk_SAT8(a)                        ((a) > silk_int8_MAX ? silk_int8_MAX  : \
468                                            ((a) < silk_int8_MIN ? silk_int8_MIN  : (a)))
469 #define silk_SAT16(a)                       ((a) > silk_int16_MAX ? silk_int16_MAX : \
470                                            ((a) < silk_int16_MIN ? silk_int16_MIN : (a)))
471 #define silk_SAT32(a)                       ((a) > silk_int32_MAX ? silk_int32_MAX : \
472                                            ((a) < silk_int32_MIN ? silk_int32_MIN : (a)))
473
474 #define silk_CHECK_FIT8(a)                  (a)
475 #define silk_CHECK_FIT16(a)                 (a)
476 #define silk_CHECK_FIT32(a)                 (a)
477
478 #define silk_ADD_SAT16(a, b)                (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a), (b) ) )
479 #define silk_ADD_SAT64(a, b)                ((((a) + (b)) & 0x8000000000000000LL) == 0 ?                            \
480                                            ((((a) & (b)) & 0x8000000000000000LL) != 0 ? silk_int64_MIN : (a)+(b)) :    \
481                                            ((((a) | (b)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a)+(b)) )
482
483 #define silk_SUB_SAT16(a, b)                (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a), (b) ) )
484 #define silk_SUB_SAT64(a, b)                ((((a)-(b)) & 0x8000000000000000LL) == 0 ?                                                    \
485                                            (( (a) & ((b)^0x8000000000000000LL) & 0x8000000000000000LL) ? silk_int64_MIN : (a)-(b)) :    \
486                                            ((((a)^0x8000000000000000LL) & (b)  & 0x8000000000000000LL) ? silk_int64_MAX : (a)-(b)) )
487
488 /* Saturation for positive input values */
489 #define silk_POS_SAT32(a)                   ((a) > silk_int32_MAX ? silk_int32_MAX : (a))
490
491 /* Add with saturation for positive input values */
492 #define silk_ADD_POS_SAT8(a, b)             ((((a)+(b)) & 0x80)                 ? silk_int8_MAX  : ((a)+(b)))
493 #define silk_ADD_POS_SAT16(a, b)            ((((a)+(b)) & 0x8000)               ? silk_int16_MAX : ((a)+(b)))
494 #define silk_ADD_POS_SAT32(a, b)            ((((a)+(b)) & 0x80000000)           ? silk_int32_MAX : ((a)+(b)))
495 #define silk_ADD_POS_SAT64(a, b)            ((((a)+(b)) & 0x8000000000000000LL) ? silk_int64_MAX : ((a)+(b)))
496
497 #define silk_LSHIFT8(a, shift)              ((opus_int8)((opus_uint8)(a)<<(shift)))                /* shift >= 0, shift < 8  */
498 #define silk_LSHIFT16(a, shift)             ((opus_int16)((opus_uint16)(a)<<(shift)))                /* shift >= 0, shift < 16 */
499 #define silk_LSHIFT32(a, shift)             ((opus_int32)((opus_uint32)(a)<<(shift)))                /* shift >= 0, shift < 32 */
500 #define silk_LSHIFT64(a, shift)             ((opus_int64)((opus_uint64)(a)<<(shift)))                /* shift >= 0, shift < 64 */
501 #define silk_LSHIFT(a, shift)               silk_LSHIFT32(a, shift)        /* shift >= 0, shift < 32 */
502
503 #define silk_RSHIFT8(a, shift)              ((a)>>(shift))                /* shift >= 0, shift < 8  */
504 #define silk_RSHIFT16(a, shift)             ((a)>>(shift))                /* shift >= 0, shift < 16 */
505 #define silk_RSHIFT32(a, shift)             ((a)>>(shift))                /* shift >= 0, shift < 32 */
506 #define silk_RSHIFT64(a, shift)             ((a)>>(shift))                /* shift >= 0, shift < 64 */
507 #define silk_RSHIFT(a, shift)               silk_RSHIFT32(a, shift)        /* shift >= 0, shift < 32 */
508
509 /* saturates before shifting */
510 #define silk_LSHIFT_SAT16(a, shift)         (silk_LSHIFT16( silk_LIMIT( (a), silk_RSHIFT16( silk_int16_MIN, (shift) ),    \
511                                                                           silk_RSHIFT16( silk_int16_MAX, (shift) ) ), (shift) ))
512 #define silk_LSHIFT_SAT32(a, shift)         (silk_LSHIFT32( silk_LIMIT( (a), silk_RSHIFT32( silk_int32_MIN, (shift) ),    \
513                                                                           silk_RSHIFT32( silk_int32_MAX, (shift) ) ), (shift) ))
514
515 #define silk_LSHIFT_uint(a, shift)         ((a)<<(shift))        /* shift >= 0 */
516 #define silk_RSHIFT_uint(a, shift)         ((a)>>(shift))        /* shift >= 0 */
517
518 #define silk_ADD_LSHIFT(a, b, shift)       ((a) + silk_LSHIFT((b), (shift)))             /* shift >= 0 */
519 #define silk_ADD_LSHIFT32(a, b, shift)     silk_ADD32((a), silk_LSHIFT32((b), (shift)))   /* shift >= 0 */
520 #define silk_ADD_LSHIFT_uint(a, b, shift)  ((a) + silk_LSHIFT_uint((b), (shift)))        /* shift >= 0 */
521 #define silk_ADD_RSHIFT(a, b, shift)       ((a) + silk_RSHIFT((b), (shift)))             /* shift >= 0 */
522 #define silk_ADD_RSHIFT32(a, b, shift)     silk_ADD32((a), silk_RSHIFT32((b), (shift)))   /* shift >= 0 */
523 #define silk_ADD_RSHIFT_uint(a, b, shift)  ((a) + silk_RSHIFT_uint((b), (shift)))        /* shift >= 0 */
524 #define silk_SUB_LSHIFT32(a, b, shift)     silk_SUB32((a), silk_LSHIFT32((b), (shift)))   /* shift >= 0 */
525 #define silk_SUB_RSHIFT32(a, b, shift)     silk_SUB32((a), silk_RSHIFT32((b), (shift)))   /* shift >= 0 */
526
527 /* Requires that shift > 0 */
528 #define silk_RSHIFT_ROUND(a, shift)        ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
529 #define silk_RSHIFT_ROUND64(a, shift)      ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
530
531 /* Number of rightshift required to fit the multiplication */
532 #define silk_NSHIFT_MUL_32_32(a, b)        ( -(31- (32-silk_CLZ32(silk_abs(a)) + (32-silk_CLZ32(silk_abs(b))))) )
533 #define silk_NSHIFT_MUL_16_16(a, b)        ( -(15- (16-silk_CLZ16(silk_abs(a)) + (16-silk_CLZ16(silk_abs(b))))) )
534
535
536 #define silk_min(a, b)                     (((a) < (b)) ? (a) : (b))
537 #define silk_max(a, b)                     (((a) > (b)) ? (a) : (b))
538
539 /* Macro to convert floating-point constants to fixed-point */
540 #define SILK_FIX_CONST( C, Q )           ((opus_int32)((C) * ((opus_int64)1 << (Q)) + 0.5))
541
542 /* silk_min() versions with typecast in the function call */
543 static inline opus_int silk_min_int(opus_int a, opus_int b)
544 {
545     return (((a) < (b)) ? (a) : (b));
546 }
547 static inline opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
548 {
549     return (((a) < (b)) ? (a) : (b));
550 }
551 static inline opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
552 {
553     return (((a) < (b)) ? (a) : (b));
554 }
555 static inline opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
556 {
557     return (((a) < (b)) ? (a) : (b));
558 }
559
560 /* silk_min() versions with typecast in the function call */
561 static inline opus_int silk_max_int(opus_int a, opus_int b)
562 {
563     return (((a) > (b)) ? (a) : (b));
564 }
565 static inline opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
566 {
567     return (((a) > (b)) ? (a) : (b));
568 }
569 static inline opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
570 {
571     return (((a) > (b)) ? (a) : (b));
572 }
573 static inline opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
574 {
575     return (((a) > (b)) ? (a) : (b));
576 }
577
578 #define silk_LIMIT( a, limit1, limit2)    ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
579                                                              : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))
580
581 #define silk_LIMIT_int silk_LIMIT
582 #define silk_LIMIT_16 silk_LIMIT
583 #define silk_LIMIT_32 silk_LIMIT
584
585 /*#define silk_non_neg(a)                 ((a) & ((-(a)) >> (8 * sizeof(a) - 1)))*/   /* doesn't seem faster than silk_max(0, a);*/
586
587 #define silk_abs(a)                       (((a) >  0)  ? (a) : -(a))            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN */
588 #define silk_abs_int(a)                   (((a) ^ ((a) >> (8 * sizeof(a) - 1))) - ((a) >> (8 * sizeof(a) - 1)))
589 #define silk_abs_int32(a)                 (((a) ^ ((a) >> 31)) - ((a) >> 31))
590 #define silk_abs_int64(a)                 (((a) >  0)  ? (a) : -(a))
591
592 #define silk_sign(a)                      ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ))
593
594 #define silk_sqrt(a)                      (sqrt(a))
595
596 /* PSEUDO-RANDOM GENERATOR                                                          */
597 /* Make sure to store the result as the seed for the next call (also in between     */
598 /* frames), otherwise result won't be random at all. When only using some of the    */
599 /* bits, take the most significant bits by right-shifting.                          */
600 #define silk_RAND(seed)                   (silk_MLA_ovflw(907633515, (seed), 196314165))
601
602 /*  Add some multiplication functions that can be easily mapped to ARM. */
603
604 /*    silk_SMMUL: Signed top word multiply.
605           ARMv6        2 instruction cycles.
606           ARMv3M+        3 instruction cycles. use SMULL and ignore LSB registers.(except xM)*/
607 /*#define silk_SMMUL(a32, b32)            (opus_int32)silk_RSHIFT(silk_SMLAL(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16)), 16)*/
608 /* the following seems faster on x86 */
609 #define silk_SMMUL(a32, b32)              (opus_int32)silk_RSHIFT64(silk_SMULL((a32), (b32)), 32)
610
611 #include "Inlines.h"
612 #include "MacroCount.h"
613 #include "MacroDebug.h"
614
615 #ifdef  __cplusplus
616 }
617 #endif
618
619 #endif