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