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