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