43f9ffac60930d729b775e47b3ddc54f3e4a463d
[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, are permitted provided that the following conditions
5 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 Internet Society, IETF or IETF Trust, nor the
12 names of specific contributors, may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 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            24            /* max order of the LPC analysis in schur() and k2a() */
39
40 #include <string.h>                                 /* for memset(), memcpy(), memmove() */
41 #include "typedef.h"
42 #include "resampler_structs.h"
43 #include "macros.h"
44 #include "cpu_support.h"
45
46 #if defined(OPUS_X86_MAY_HAVE_SSE4_1)
47 #include "x86/SigProc_FIX_sse.h"
48 #endif
49
50 #if (defined(OPUS_ARM_ASM) || defined(OPUS_ARM_MAY_HAVE_NEON_INTR))
51 #include "arm/LPC_inv_pred_gain_arm.h"
52 #endif
53
54 /********************************************************************/
55 /*                    SIGNAL PROCESSING FUNCTIONS                   */
56 /********************************************************************/
57
58 /*!
59  * Initialize/reset the resampler state for a given pair of input/output sampling rates
60 */
61 opus_int silk_resampler_init(
62     silk_resampler_state_struct *S,                 /* I/O  Resampler state                                             */
63     opus_int32                  Fs_Hz_in,           /* I    Input sampling rate (Hz)                                    */
64     opus_int32                  Fs_Hz_out,          /* I    Output sampling rate (Hz)                                   */
65     opus_int                    forEnc              /* I    If 1: encoder; if 0: decoder                                */
66 );
67
68 /*!
69  * Resampler: convert from one sampling rate to another
70  */
71 opus_int silk_resampler(
72     silk_resampler_state_struct *S,                 /* I/O  Resampler state                                             */
73     opus_int16                  out[],              /* O    Output signal                                               */
74     const opus_int16            in[],               /* I    Input signal                                                */
75     opus_int32                  inLen               /* I    Number of input samples                                     */
76 );
77
78 /*!
79 * Downsample 2x, mediocre quality
80 */
81 void silk_resampler_down2(
82     opus_int32                  *S,                 /* I/O  State vector [ 2 ]                                          */
83     opus_int16                  *out,               /* O    Output signal [ len ]                                       */
84     const opus_int16            *in,                /* I    Input signal [ floor(len/2) ]                               */
85     opus_int32                  inLen               /* I    Number of input samples                                     */
86 );
87
88 /*!
89  * Downsample by a factor 2/3, low quality
90 */
91 void silk_resampler_down2_3(
92     opus_int32                  *S,                 /* I/O  State vector [ 6 ]                                          */
93     opus_int16                  *out,               /* O    Output signal [ floor(2*inLen/3) ]                          */
94     const opus_int16            *in,                /* I    Input signal [ inLen ]                                      */
95     opus_int32                  inLen               /* I    Number of input samples                                     */
96 );
97
98 /*!
99  * second order ARMA filter;
100  * slower than biquad() but uses more precise coefficients
101  * can handle (slowly) varying coefficients
102  */
103 void silk_biquad_alt_stride1(
104     const opus_int16            *in,                /* I     input signal                                               */
105     const opus_int32            *B_Q28,             /* I     MA coefficients [3]                                        */
106     const opus_int32            *A_Q28,             /* I     AR coefficients [2]                                        */
107     opus_int32                  *S,                 /* I/O   State vector [2]                                           */
108     opus_int16                  *out,               /* O     output signal                                              */
109     const opus_int32            len                 /* I     signal length (must be even)                               */
110 );
111
112 void silk_biquad_alt_stride2(
113     const opus_int16            *in,                /* I     input signal                                               */
114     const opus_int32            *B_Q28,             /* I     MA coefficients [3]                                        */
115     const opus_int32            *A_Q28,             /* I     AR coefficients [2]                                        */
116     opus_int32                  *S,                 /* I/O   State vector [4]                                           */
117     opus_int16                  *out,               /* O     output signal                                              */
118     const opus_int32            len                 /* I     signal length (must be even)                               */
119 );
120
121 /* Variable order MA prediction error filter. */
122 void silk_LPC_analysis_filter(
123     opus_int16                  *out,               /* O    Output signal                                               */
124     const opus_int16            *in,                /* I    Input signal                                                */
125     const opus_int16            *B,                 /* I    MA prediction coefficients, Q12 [order]                     */
126     const opus_int32            len,                /* I    Signal length                                               */
127     const opus_int32            d,                  /* I    Filter order                                                */
128     int                         arch                /* I    Run-time architecture                                       */
129 );
130
131 /* Chirp (bandwidth expand) LP AR filter */
132 void silk_bwexpander(
133     opus_int16                  *ar,                /* I/O  AR filter to be expanded (without leading 1)                */
134     const opus_int              d,                  /* I    Length of ar                                                */
135     opus_int32                  chirp_Q16           /* I    Chirp factor (typically in the range 0 to 1)                */
136 );
137
138 /* Chirp (bandwidth expand) LP AR filter */
139 void silk_bwexpander_32(
140     opus_int32                  *ar,                /* I/O  AR filter to be expanded (without leading 1)                */
141     const opus_int              d,                  /* I    Length of ar                                                */
142     opus_int32                  chirp_Q16           /* I    Chirp factor in Q16                                         */
143 );
144
145 /* Compute inverse of LPC prediction gain, and                           */
146 /* test if LPC coefficients are stable (all poles within unit circle)    */
147 opus_int32 silk_LPC_inverse_pred_gain_c(            /* O   Returns inverse prediction gain in energy domain, Q30        */
148     const opus_int16            *A_Q12,             /* I   Prediction coefficients, Q12 [order]                         */
149     const opus_int              order               /* I   Prediction order                                             */
150 );
151
152 /* Split signal in two decimated bands using first-order allpass filters */
153 void silk_ana_filt_bank_1(
154     const opus_int16            *in,                /* I    Input signal [N]                                            */
155     opus_int32                  *S,                 /* I/O  State vector [2]                                            */
156     opus_int16                  *outL,              /* O    Low band [N/2]                                              */
157     opus_int16                  *outH,              /* O    High band [N/2]                                             */
158     const opus_int32            N                   /* I    Number of input samples                                     */
159 );
160
161 #if !defined(OVERRIDE_silk_LPC_inverse_pred_gain)
162 #define silk_LPC_inverse_pred_gain(A_Q12, order, arch)     ((void)(arch), silk_LPC_inverse_pred_gain_c(A_Q12, order))
163 #endif
164
165 /********************************************************************/
166 /*                        SCALAR FUNCTIONS                          */
167 /********************************************************************/
168
169 /* Approximation of 128 * log2() (exact inverse of approx 2^() below) */
170 /* Convert input to a log scale    */
171 opus_int32 silk_lin2log(
172     const opus_int32            inLin               /* I  input in linear scale                                         */
173 );
174
175 /* Approximation of a sigmoid function */
176 opus_int silk_sigm_Q15(
177     opus_int                    in_Q5               /* I                                                                */
178 );
179
180 /* Approximation of 2^() (exact inverse of approx log2() above) */
181 /* Convert input to a linear scale */
182 opus_int32 silk_log2lin(
183     const opus_int32            inLog_Q7            /* I  input on log scale                                            */
184 );
185
186 /* Compute number of bits to right shift the sum of squares of a vector    */
187 /* of int16s to make it fit in an int32                                    */
188 void silk_sum_sqr_shift(
189     opus_int32                  *energy,            /* O   Energy of x, after shifting to the right                     */
190     opus_int                    *shift,             /* O   Number of bits right shift applied to energy                 */
191     const opus_int16            *x,                 /* I   Input vector                                                 */
192     opus_int                    len                 /* I   Length of input vector                                       */
193 );
194
195 /* Calculates the reflection coefficients from the correlation sequence    */
196 /* Faster than schur64(), but much less accurate.                          */
197 /* uses SMLAWB(), requiring armv5E and higher.                             */
198 opus_int32 silk_schur(                              /* O    Returns residual energy                                     */
199     opus_int16                  *rc_Q15,            /* O    reflection coefficients [order] Q15                         */
200     const opus_int32            *c,                 /* I    correlations [order+1]                                      */
201     const opus_int32            order               /* I    prediction order                                            */
202 );
203
204 /* Calculates the reflection coefficients from the correlation sequence    */
205 /* Slower than schur(), but more accurate.                                 */
206 /* Uses SMULL(), available on armv4                                        */
207 opus_int32 silk_schur64(                            /* O    returns residual energy                                     */
208     opus_int32                  rc_Q16[],           /* O    Reflection coefficients [order] Q16                         */
209     const opus_int32            c[],                /* I    Correlations [order+1]                                      */
210     opus_int32                  order               /* I    Prediction order                                            */
211 );
212
213 /* Step up function, converts reflection coefficients to prediction coefficients */
214 void silk_k2a(
215     opus_int32                  *A_Q24,             /* O    Prediction coefficients [order] Q24                         */
216     const opus_int16            *rc_Q15,            /* I    Reflection coefficients [order] Q15                         */
217     const opus_int32            order               /* I    Prediction order                                            */
218 );
219
220 /* Step up function, converts reflection coefficients to prediction coefficients */
221 void silk_k2a_Q16(
222     opus_int32                  *A_Q24,             /* O    Prediction coefficients [order] Q24                         */
223     const opus_int32            *rc_Q16,            /* I    Reflection coefficients [order] Q16                         */
224     const opus_int32            order               /* I    Prediction order                                            */
225 );
226
227 /* Apply sine window to signal vector.                              */
228 /* Window types:                                                    */
229 /*    1 -> sine window from 0 to pi/2                               */
230 /*    2 -> sine window from pi/2 to pi                              */
231 /* every other sample of window is linearly interpolated, for speed */
232 void silk_apply_sine_window(
233     opus_int16                  px_win[],           /* O    Pointer to windowed signal                                  */
234     const opus_int16            px[],               /* I    Pointer to input signal                                     */
235     const opus_int              win_type,           /* I    Selects a window type                                       */
236     const opus_int              length              /* I    Window length, multiple of 4                                */
237 );
238
239 /* Compute autocorrelation */
240 void silk_autocorr(
241     opus_int32                  *results,           /* O    Result (length correlationCount)                            */
242     opus_int                    *scale,             /* O    Scaling of the correlation vector                           */
243     const opus_int16            *inputData,         /* I    Input data to correlate                                     */
244     const opus_int              inputDataSize,      /* I    Length of input                                             */
245     const opus_int              correlationCount,   /* I    Number of correlation taps to compute                       */
246     int                         arch                /* I    Run-time architecture                                       */
247 );
248
249 void silk_decode_pitch(
250     opus_int16                  lagIndex,           /* I                                                                */
251     opus_int8                   contourIndex,       /* O                                                                */
252     opus_int                    pitch_lags[],       /* O    4 pitch values                                              */
253     const opus_int              Fs_kHz,             /* I    sampling frequency (kHz)                                    */
254     const opus_int              nb_subfr            /* I    number of sub frames                                        */
255 );
256
257 opus_int silk_pitch_analysis_core(                  /* O    Voicing estimate: 0 voiced, 1 unvoiced                      */
258     const opus_int16            *frame,             /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                  */
259     opus_int                    *pitch_out,         /* O    4 pitch lag values                                          */
260     opus_int16                  *lagIndex,          /* O    Lag Index                                                   */
261     opus_int8                   *contourIndex,      /* O    Pitch contour Index                                         */
262     opus_int                    *LTPCorr_Q15,       /* I/O  Normalized correlation; input: value from previous frame    */
263     opus_int                    prevLag,            /* I    Last lag of previous frame; set to zero is unvoiced         */
264     const opus_int32            search_thres1_Q16,  /* I    First stage threshold for lag candidates 0 - 1              */
265     const opus_int              search_thres2_Q13,  /* I    Final threshold for lag candidates 0 - 1                    */
266     const opus_int              Fs_kHz,             /* I    Sample frequency (kHz)                                      */
267     const opus_int              complexity,         /* I    Complexity setting, 0-2, where 2 is highest                 */
268     const opus_int              nb_subfr,           /* I    number of 5 ms subframes                                    */
269     int                         arch                /* I    Run-time architecture                                       */
270 );
271
272 /* Compute Normalized Line Spectral Frequencies (NLSFs) from whitening filter coefficients      */
273 /* If not all roots are found, the a_Q16 coefficients are bandwidth expanded until convergence. */
274 void silk_A2NLSF(
275     opus_int16                  *NLSF,              /* O    Normalized Line Spectral Frequencies in Q15 (0..2^15-1) [d] */
276     opus_int32                  *a_Q16,             /* I/O  Monic whitening filter coefficients in Q16 [d]              */
277     const opus_int              d                   /* I    Filter order (must be even)                                 */
278 );
279
280 /* compute whitening filter coefficients from normalized line spectral frequencies */
281 void silk_NLSF2A(
282     opus_int16                  *a_Q12,             /* O    monic whitening filter coefficients in Q12,  [ d ]          */
283     const opus_int16            *NLSF,              /* I    normalized line spectral frequencies in Q15, [ d ]          */
284     const opus_int              d,                  /* I    filter order (should be even)                               */
285     int                         arch                /* I    Run-time architecture                                       */
286 );
287
288 /* Convert int32 coefficients to int16 coefs and make sure there's no wrap-around */
289 void silk_LPC_fit(
290     opus_int16                  *a_QOUT,            /* O    Output signal                                               */
291     opus_int32                  *a_QIN,             /* I/O  Input signal                                                */
292     const opus_int              QOUT,               /* I    Input Q domain                                              */
293     const opus_int              QIN,                /* I    Input Q domain                                              */
294     const opus_int              d                   /* I    Filter order                                                */
295 );
296
297 void silk_insertion_sort_increasing(
298     opus_int32                  *a,                 /* I/O   Unsorted / Sorted vector                                   */
299     opus_int                    *idx,               /* O     Index vector for the sorted elements                       */
300     const opus_int              L,                  /* I     Vector length                                              */
301     const opus_int              K                   /* I     Number of correctly sorted positions                       */
302 );
303
304 void silk_insertion_sort_decreasing_int16(
305     opus_int16                  *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_increasing_all_values_int16(
312      opus_int16                 *a,                 /* I/O   Unsorted / Sorted vector                                   */
313      const opus_int             L                   /* I     Vector length                                              */
314 );
315
316 /* NLSF stabilizer, for a single input data vector */
317 void silk_NLSF_stabilize(
318           opus_int16            *NLSF_Q15,          /* I/O   Unstable/stabilized normalized LSF vector in Q15 [L]       */
319     const opus_int16            *NDeltaMin_Q15,     /* I     Min distance vector, NDeltaMin_Q15[L] must be >= 1 [L+1]   */
320     const opus_int              L                   /* I     Number of NLSF parameters in the input vector              */
321 );
322
323 /* Laroia low complexity NLSF weights */
324 void silk_NLSF_VQ_weights_laroia(
325     opus_int16                  *pNLSFW_Q_OUT,      /* O     Pointer to input vector weights [D]                        */
326     const opus_int16            *pNLSF_Q15,         /* I     Pointer to input vector         [D]                        */
327     const opus_int              D                   /* I     Input vector dimension (even)                              */
328 );
329
330 /* Compute reflection coefficients from input signal */
331 void silk_burg_modified_c(
332     opus_int32                  *res_nrg,           /* O    Residual energy                                             */
333     opus_int                    *res_nrg_Q,         /* O    Residual energy Q value                                     */
334     opus_int32                  A_Q16[],            /* O    Prediction coefficients (length order)                      */
335     const opus_int16            x[],                /* I    Input signal, length: nb_subfr * ( D + subfr_length )       */
336     const opus_int32            minInvGain_Q30,     /* I    Inverse of max prediction gain                              */
337     const opus_int              subfr_length,       /* I    Input signal subframe length (incl. D preceding samples)    */
338     const opus_int              nb_subfr,           /* I    Number of subframes stacked in x                            */
339     const opus_int              D,                  /* I    Order                                                       */
340     int                         arch                /* I    Run-time architecture                                       */
341 );
342
343 /* Copy and multiply a vector by a constant */
344 void silk_scale_copy_vector16(
345     opus_int16                  *data_out,
346     const opus_int16            *data_in,
347     opus_int32                  gain_Q16,           /* I    Gain in Q16                                                 */
348     const opus_int              dataSize            /* I    Length                                                      */
349 );
350
351 /* Some for the LTP related function requires Q26 to work.*/
352 void silk_scale_vector32_Q26_lshift_18(
353     opus_int32                  *data1,             /* I/O  Q0/Q18                                                      */
354     opus_int32                  gain_Q26,           /* I    Q26                                                         */
355     opus_int                    dataSize            /* I    length                                                      */
356 );
357
358 /********************************************************************/
359 /*                        INLINE ARM MATH                           */
360 /********************************************************************/
361
362 /*    return sum( inVec1[i] * inVec2[i] ) */
363
364 opus_int32 silk_inner_prod_aligned(
365     const opus_int16 *const     inVec1,             /*    I input vector 1                                              */
366     const opus_int16 *const     inVec2,             /*    I input vector 2                                              */
367     const opus_int              len,                /*    I vector lengths                                              */
368     int                         arch                /*    I Run-time architecture                                       */
369 );
370
371
372 opus_int32 silk_inner_prod_aligned_scale(
373     const opus_int16 *const     inVec1,             /*    I input vector 1                                              */
374     const opus_int16 *const     inVec2,             /*    I input vector 2                                              */
375     const opus_int              scale,              /*    I number of bits to shift                                     */
376     const opus_int              len                 /*    I vector lengths                                              */
377 );
378
379 opus_int64 silk_inner_prod16_aligned_64_c(
380     const opus_int16            *inVec1,            /*    I input vector 1                                              */
381     const opus_int16            *inVec2,            /*    I input vector 2                                              */
382     const opus_int              len                 /*    I vector lengths                                              */
383 );
384
385 /********************************************************************/
386 /*                                MACROS                            */
387 /********************************************************************/
388
389 /* Rotate a32 right by 'rot' bits. Negative rot values result in rotating
390    left. Output is 32bit int.
391    Note: contemporary compilers recognize the C expression below and
392    compile it into a 'ror' instruction if available. No need for OPUS_INLINE ASM! */
393 static OPUS_INLINE opus_int32 silk_ROR32( opus_int32 a32, opus_int rot )
394 {
395     opus_uint32 x = (opus_uint32) a32;
396     opus_uint32 r = (opus_uint32) rot;
397     opus_uint32 m = (opus_uint32) -rot;
398     if( rot == 0 ) {
399         return a32;
400     } else 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
407 /* Allocate opus_int16 aligned to 4-byte memory address */
408 #if EMBEDDED_ARM
409 #define silk_DWORD_ALIGN __attribute__((aligned(4)))
410 #else
411 #define silk_DWORD_ALIGN
412 #endif
413
414 /* Useful Macros that can be adjusted to other platforms */
415 #define silk_memcpy(dest, src, size)        memcpy((dest), (src), (size))
416 #define silk_memset(dest, src, size)        memset((dest), (src), (size))
417 #define silk_memmove(dest, src, size)       memmove((dest), (src), (size))
418
419 /* Fixed point macros */
420
421 /* (a32 * b32) output have to be 32bit int */
422 #define silk_MUL(a32, b32)                  ((a32) * (b32))
423
424 /* (a32 * b32) output have to be 32bit uint */
425 #define silk_MUL_uint(a32, b32)             silk_MUL(a32, b32)
426
427 /* a32 + (b32 * c32) output have to be 32bit int */
428 #define silk_MLA(a32, b32, c32)             silk_ADD32((a32),((b32) * (c32)))
429
430 /* a32 + (b32 * c32) output have to be 32bit uint */
431 #define silk_MLA_uint(a32, b32, c32)        silk_MLA(a32, b32, c32)
432
433 /* ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int */
434 #define silk_SMULTT(a32, b32)               (((a32) >> 16) * ((b32) >> 16))
435
436 /* a32 + ((a32 >> 16)  * (b32 >> 16)) output have to be 32bit int */
437 #define silk_SMLATT(a32, b32, c32)          silk_ADD32((a32),((b32) >> 16) * ((c32) >> 16))
438
439 #define silk_SMLALBB(a64, b16, c16)         silk_ADD64((a64),(opus_int64)((opus_int32)(b16) * (opus_int32)(c16)))
440
441 /* (a32 * b32) */
442 #define silk_SMULL(a32, b32)                ((opus_int64)(a32) * /*(opus_int64)*/(b32))
443
444 /* Adds two signed 32-bit values in a way that can overflow, while not relying on undefined behaviour
445    (just standard two's complement implementation-specific behaviour) */
446 #define silk_ADD32_ovflw(a, b)              ((opus_int32)((opus_uint32)(a) + (opus_uint32)(b)))
447 /* Subtractss two signed 32-bit values in a way that can overflow, while not relying on undefined behaviour
448    (just standard two's complement implementation-specific behaviour) */
449 #define silk_SUB32_ovflw(a, b)              ((opus_int32)((opus_uint32)(a) - (opus_uint32)(b)))
450
451 /* Multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode) */
452 #define silk_MLA_ovflw(a32, b32, c32)       silk_ADD32_ovflw((a32), (opus_uint32)(b32) * (opus_uint32)(c32))
453 #define silk_SMLABB_ovflw(a32, b32, c32)    (silk_ADD32_ovflw((a32) , ((opus_int32)((opus_int16)(b32))) * (opus_int32)((opus_int16)(c32))))
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)            ((((opus_uint32)(a)+(opus_uint32)(b)) & 0x80000000) ? silk_int32_MAX : ((a)+(b)))
495
496 #define silk_LSHIFT8(a, shift)              ((opus_int8)((opus_uint8)(a)<<(shift)))         /* shift >= 0, shift < 8  */
497 #define silk_LSHIFT16(a, shift)             ((opus_int16)((opus_uint16)(a)<<(shift)))       /* shift >= 0, shift < 16 */
498 #define silk_LSHIFT32(a, shift)             ((opus_int32)((opus_uint32)(a)<<(shift)))       /* shift >= 0, shift < 32 */
499 #define silk_LSHIFT64(a, shift)             ((opus_int64)((opus_uint64)(a)<<(shift)))       /* shift >= 0, shift < 64 */
500 #define silk_LSHIFT(a, shift)               silk_LSHIFT32(a, shift)                         /* shift >= 0, shift < 32 */
501
502 #define silk_RSHIFT8(a, shift)              ((a)>>(shift))                                  /* shift >= 0, shift < 8  */
503 #define silk_RSHIFT16(a, shift)             ((a)>>(shift))                                  /* shift >= 0, shift < 16 */
504 #define silk_RSHIFT32(a, shift)             ((a)>>(shift))                                  /* shift >= 0, shift < 32 */
505 #define silk_RSHIFT64(a, shift)             ((a)>>(shift))                                  /* shift >= 0, shift < 64 */
506 #define silk_RSHIFT(a, shift)               silk_RSHIFT32(a, shift)                         /* shift >= 0, shift < 32 */
507
508 /* saturates before shifting */
509 #define silk_LSHIFT_SAT32(a, shift)         (silk_LSHIFT32( silk_LIMIT( (a), silk_RSHIFT32( silk_int32_MIN, (shift) ), \
510                                                     silk_RSHIFT32( silk_int32_MAX, (shift) ) ), (shift) ))
511
512 #define silk_LSHIFT_ovflw(a, shift)         ((opus_int32)((opus_uint32)(a) << (shift)))     /* shift >= 0, allowed to overflow */
513 #define silk_LSHIFT_uint(a, shift)          ((a) << (shift))                                /* shift >= 0 */
514 #define silk_RSHIFT_uint(a, shift)          ((a) >> (shift))                                /* shift >= 0 */
515
516 #define silk_ADD_LSHIFT(a, b, shift)        ((a) + silk_LSHIFT((b), (shift)))               /* shift >= 0 */
517 #define silk_ADD_LSHIFT32(a, b, shift)      silk_ADD32((a), silk_LSHIFT32((b), (shift)))    /* shift >= 0 */
518 #define silk_ADD_LSHIFT_uint(a, b, shift)   ((a) + silk_LSHIFT_uint((b), (shift)))          /* shift >= 0 */
519 #define silk_ADD_RSHIFT(a, b, shift)        ((a) + silk_RSHIFT((b), (shift)))               /* shift >= 0 */
520 #define silk_ADD_RSHIFT32(a, b, shift)      silk_ADD32((a), silk_RSHIFT32((b), (shift)))    /* shift >= 0 */
521 #define silk_ADD_RSHIFT_uint(a, b, shift)   ((a) + silk_RSHIFT_uint((b), (shift)))          /* shift >= 0 */
522 #define silk_SUB_LSHIFT32(a, b, shift)      silk_SUB32((a), silk_LSHIFT32((b), (shift)))    /* shift >= 0 */
523 #define silk_SUB_RSHIFT32(a, b, shift)      silk_SUB32((a), silk_RSHIFT32((b), (shift)))    /* shift >= 0 */
524
525 /* Requires that shift > 0 */
526 #define silk_RSHIFT_ROUND(a, shift)         ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
527 #define silk_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 silk_NSHIFT_MUL_32_32(a, b)         ( -(31- (32-silk_CLZ32(silk_abs(a)) + (32-silk_CLZ32(silk_abs(b))))) )
531 #define silk_NSHIFT_MUL_16_16(a, b)         ( -(15- (16-silk_CLZ16(silk_abs(a)) + (16-silk_CLZ16(silk_abs(b))))) )
532
533
534 #define silk_min(a, b)                      (((a) < (b)) ? (a) : (b))
535 #define silk_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 /* silk_min() versions with typecast in the function call */
541 static OPUS_INLINE opus_int silk_min_int(opus_int a, opus_int b)
542 {
543     return (((a) < (b)) ? (a) : (b));
544 }
545 static OPUS_INLINE opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
546 {
547     return (((a) < (b)) ? (a) : (b));
548 }
549 static OPUS_INLINE opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
550 {
551     return (((a) < (b)) ? (a) : (b));
552 }
553 static OPUS_INLINE opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
554 {
555     return (((a) < (b)) ? (a) : (b));
556 }
557
558 /* silk_min() versions with typecast in the function call */
559 static OPUS_INLINE opus_int silk_max_int(opus_int a, opus_int b)
560 {
561     return (((a) > (b)) ? (a) : (b));
562 }
563 static OPUS_INLINE opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
564 {
565     return (((a) > (b)) ? (a) : (b));
566 }
567 static OPUS_INLINE opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
568 {
569     return (((a) > (b)) ? (a) : (b));
570 }
571 static OPUS_INLINE opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
572 {
573     return (((a) > (b)) ? (a) : (b));
574 }
575
576 #define silk_LIMIT( a, limit1, limit2)      ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
577                                                                  : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))
578
579 #define silk_LIMIT_int                      silk_LIMIT
580 #define silk_LIMIT_16                       silk_LIMIT
581 #define silk_LIMIT_32                       silk_LIMIT
582
583 #define silk_abs(a)                         (((a) >  0)  ? (a) : -(a))            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN */
584 #define silk_abs_int(a)                     (((a) ^ ((a) >> (8 * sizeof(a) - 1))) - ((a) >> (8 * sizeof(a) - 1)))
585 #define silk_abs_int32(a)                   (((a) ^ ((a) >> 31)) - ((a) >> 31))
586 #define silk_abs_int64(a)                   (((a) >  0)  ? (a) : -(a))
587
588 #define silk_sign(a)                        ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ))
589
590 /* PSEUDO-RANDOM GENERATOR                                                          */
591 /* Make sure to store the result as the seed for the next call (also in between     */
592 /* frames), otherwise result won't be random at all. When only using some of the    */
593 /* bits, take the most significant bits by right-shifting.                          */
594 #define RAND_MULTIPLIER                     196314165
595 #define RAND_INCREMENT                      907633515
596 #define silk_RAND(seed)                     (silk_MLA_ovflw((RAND_INCREMENT), (seed), (RAND_MULTIPLIER)))
597
598 /*  Add some multiplication functions that can be easily mapped to ARM. */
599
600 /*    silk_SMMUL: Signed top word multiply.
601           ARMv6        2 instruction cycles.
602           ARMv3M+      3 instruction cycles. use SMULL and ignore LSB registers.(except xM)*/
603 /*#define silk_SMMUL(a32, b32)                (opus_int32)silk_RSHIFT(silk_SMLAL(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16)), 16)*/
604 /* the following seems faster on x86 */
605 #define silk_SMMUL(a32, b32)                (opus_int32)silk_RSHIFT64(silk_SMULL((a32), (b32)), 32)
606
607 #if !defined(OPUS_X86_MAY_HAVE_SSE4_1)
608 #define silk_burg_modified(res_nrg, res_nrg_Q, A_Q16, x, minInvGain_Q30, subfr_length, nb_subfr, D, arch) \
609     ((void)(arch), silk_burg_modified_c(res_nrg, res_nrg_Q, A_Q16, x, minInvGain_Q30, subfr_length, nb_subfr, D, arch))
610
611 #define silk_inner_prod16_aligned_64(inVec1, inVec2, len, arch) \
612     ((void)(arch),silk_inner_prod16_aligned_64_c(inVec1, inVec2, len))
613 #endif
614
615 #include "Inlines.h"
616 #include "MacroCount.h"
617 #include "MacroDebug.h"
618
619 #ifdef OPUS_ARM_INLINE_ASM
620 #include "arm/SigProc_FIX_armv4.h"
621 #endif
622
623 #ifdef OPUS_ARM_INLINE_EDSP
624 #include "arm/SigProc_FIX_armv5e.h"
625 #endif
626
627 #if defined(MIPSr1_ASM)
628 #include "mips/sigproc_fix_mipsr1.h"
629 #endif
630
631
632 #ifdef  __cplusplus
633 }
634 #endif
635
636 #endif /* SILK_SIGPROC_FIX_H */