Line data Source code
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! */
398 0 : static OPUS_INLINE opus_int32 silk_ROR32( opus_int32 a32, opus_int rot )
399 : {
400 0 : opus_uint32 x = (opus_uint32) a32;
401 0 : opus_uint32 r = (opus_uint32) rot;
402 0 : opus_uint32 m = (opus_uint32) -rot;
403 0 : if( rot == 0 ) {
404 0 : return a32;
405 0 : } else if( rot < 0 ) {
406 0 : return (opus_int32) ((x << m) | (x >> (32 - m)));
407 : } else {
408 0 : 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) */
451 : #define silk_ADD32_ovflw(a, b) ((opus_int32)((opus_uint32)(a) + (opus_uint32)(b)))
452 : /* Subtractss two signed 32-bit values in a way that can overflow, while not relying on undefined behaviour
453 : (just standard two's complement implementation-specific behaviour) */
454 : #define silk_SUB32_ovflw(a, b) ((opus_int32)((opus_uint32)(a) - (opus_uint32)(b)))
455 :
456 : /* Multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode) */
457 : #define silk_MLA_ovflw(a32, b32, c32) silk_ADD32_ovflw((a32), (opus_uint32)(b32) * (opus_uint32)(c32))
458 : #define silk_SMLABB_ovflw(a32, b32, c32) (silk_ADD32_ovflw((a32) , ((opus_int32)((opus_int16)(b32))) * (opus_int32)((opus_int16)(c32))))
459 :
460 : #define silk_DIV32_16(a32, b16) ((opus_int32)((a32) / (b16)))
461 : #define silk_DIV32(a32, b32) ((opus_int32)((a32) / (b32)))
462 :
463 : /* These macros enables checking for overflow in silk_API_Debug.h*/
464 : #define silk_ADD16(a, b) ((a) + (b))
465 : #define silk_ADD32(a, b) ((a) + (b))
466 : #define silk_ADD64(a, b) ((a) + (b))
467 :
468 : #define silk_SUB16(a, b) ((a) - (b))
469 : #define silk_SUB32(a, b) ((a) - (b))
470 : #define silk_SUB64(a, b) ((a) - (b))
471 :
472 : #define silk_SAT8(a) ((a) > silk_int8_MAX ? silk_int8_MAX : \
473 : ((a) < silk_int8_MIN ? silk_int8_MIN : (a)))
474 : #define silk_SAT16(a) ((a) > silk_int16_MAX ? silk_int16_MAX : \
475 : ((a) < silk_int16_MIN ? silk_int16_MIN : (a)))
476 : #define silk_SAT32(a) ((a) > silk_int32_MAX ? silk_int32_MAX : \
477 : ((a) < silk_int32_MIN ? silk_int32_MIN : (a)))
478 :
479 : #define silk_CHECK_FIT8(a) (a)
480 : #define silk_CHECK_FIT16(a) (a)
481 : #define silk_CHECK_FIT32(a) (a)
482 :
483 : #define silk_ADD_SAT16(a, b) (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a), (b) ) )
484 : #define silk_ADD_SAT64(a, b) ((((a) + (b)) & 0x8000000000000000LL) == 0 ? \
485 : ((((a) & (b)) & 0x8000000000000000LL) != 0 ? silk_int64_MIN : (a)+(b)) : \
486 : ((((a) | (b)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a)+(b)) )
487 :
488 : #define silk_SUB_SAT16(a, b) (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a), (b) ) )
489 : #define silk_SUB_SAT64(a, b) ((((a)-(b)) & 0x8000000000000000LL) == 0 ? \
490 : (( (a) & ((b)^0x8000000000000000LL) & 0x8000000000000000LL) ? silk_int64_MIN : (a)-(b)) : \
491 : ((((a)^0x8000000000000000LL) & (b) & 0x8000000000000000LL) ? silk_int64_MAX : (a)-(b)) )
492 :
493 : /* Saturation for positive input values */
494 : #define silk_POS_SAT32(a) ((a) > silk_int32_MAX ? silk_int32_MAX : (a))
495 :
496 : /* Add with saturation for positive input values */
497 : #define silk_ADD_POS_SAT8(a, b) ((((a)+(b)) & 0x80) ? silk_int8_MAX : ((a)+(b)))
498 : #define silk_ADD_POS_SAT16(a, b) ((((a)+(b)) & 0x8000) ? silk_int16_MAX : ((a)+(b)))
499 : #define silk_ADD_POS_SAT32(a, b) ((((opus_uint32)(a)+(opus_uint32)(b)) & 0x80000000) ? silk_int32_MAX : ((a)+(b)))
500 :
501 : #define silk_LSHIFT8(a, shift) ((opus_int8)((opus_uint8)(a)<<(shift))) /* shift >= 0, shift < 8 */
502 : #define silk_LSHIFT16(a, shift) ((opus_int16)((opus_uint16)(a)<<(shift))) /* shift >= 0, shift < 16 */
503 : #define silk_LSHIFT32(a, shift) ((opus_int32)((opus_uint32)(a)<<(shift))) /* shift >= 0, shift < 32 */
504 : #define silk_LSHIFT64(a, shift) ((opus_int64)((opus_uint64)(a)<<(shift))) /* shift >= 0, shift < 64 */
505 : #define silk_LSHIFT(a, shift) silk_LSHIFT32(a, shift) /* shift >= 0, shift < 32 */
506 :
507 : #define silk_RSHIFT8(a, shift) ((a)>>(shift)) /* shift >= 0, shift < 8 */
508 : #define silk_RSHIFT16(a, shift) ((a)>>(shift)) /* shift >= 0, shift < 16 */
509 : #define silk_RSHIFT32(a, shift) ((a)>>(shift)) /* shift >= 0, shift < 32 */
510 : #define silk_RSHIFT64(a, shift) ((a)>>(shift)) /* shift >= 0, shift < 64 */
511 : #define silk_RSHIFT(a, shift) silk_RSHIFT32(a, shift) /* shift >= 0, shift < 32 */
512 :
513 : /* saturates before shifting */
514 : #define silk_LSHIFT_SAT32(a, shift) (silk_LSHIFT32( silk_LIMIT( (a), silk_RSHIFT32( silk_int32_MIN, (shift) ), \
515 : silk_RSHIFT32( silk_int32_MAX, (shift) ) ), (shift) ))
516 :
517 : #define silk_LSHIFT_ovflw(a, shift) ((opus_int32)((opus_uint32)(a) << (shift))) /* shift >= 0, allowed to overflow */
518 : #define silk_LSHIFT_uint(a, shift) ((a) << (shift)) /* shift >= 0 */
519 : #define silk_RSHIFT_uint(a, shift) ((a) >> (shift)) /* shift >= 0 */
520 :
521 : #define silk_ADD_LSHIFT(a, b, shift) ((a) + silk_LSHIFT((b), (shift))) /* shift >= 0 */
522 : #define silk_ADD_LSHIFT32(a, b, shift) silk_ADD32((a), silk_LSHIFT32((b), (shift))) /* shift >= 0 */
523 : #define silk_ADD_LSHIFT_uint(a, b, shift) ((a) + silk_LSHIFT_uint((b), (shift))) /* shift >= 0 */
524 : #define silk_ADD_RSHIFT(a, b, shift) ((a) + silk_RSHIFT((b), (shift))) /* shift >= 0 */
525 : #define silk_ADD_RSHIFT32(a, b, shift) silk_ADD32((a), silk_RSHIFT32((b), (shift))) /* shift >= 0 */
526 : #define silk_ADD_RSHIFT_uint(a, b, shift) ((a) + silk_RSHIFT_uint((b), (shift))) /* shift >= 0 */
527 : #define silk_SUB_LSHIFT32(a, b, shift) silk_SUB32((a), silk_LSHIFT32((b), (shift))) /* shift >= 0 */
528 : #define silk_SUB_RSHIFT32(a, b, shift) silk_SUB32((a), silk_RSHIFT32((b), (shift))) /* shift >= 0 */
529 :
530 : /* Requires that shift > 0 */
531 : #define silk_RSHIFT_ROUND(a, shift) ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
532 : #define silk_RSHIFT_ROUND64(a, shift) ((shift) == 1 ? ((a) >> 1) + ((a) & 1) : (((a) >> ((shift) - 1)) + 1) >> 1)
533 :
534 : /* Number of rightshift required to fit the multiplication */
535 : #define silk_NSHIFT_MUL_32_32(a, b) ( -(31- (32-silk_CLZ32(silk_abs(a)) + (32-silk_CLZ32(silk_abs(b))))) )
536 : #define silk_NSHIFT_MUL_16_16(a, b) ( -(15- (16-silk_CLZ16(silk_abs(a)) + (16-silk_CLZ16(silk_abs(b))))) )
537 :
538 :
539 : #define silk_min(a, b) (((a) < (b)) ? (a) : (b))
540 : #define silk_max(a, b) (((a) > (b)) ? (a) : (b))
541 :
542 : /* Macro to convert floating-point constants to fixed-point */
543 : #define SILK_FIX_CONST( C, Q ) ((opus_int32)((C) * ((opus_int64)1 << (Q)) + 0.5))
544 :
545 : /* silk_min() versions with typecast in the function call */
546 0 : static OPUS_INLINE opus_int silk_min_int(opus_int a, opus_int b)
547 : {
548 0 : return (((a) < (b)) ? (a) : (b));
549 : }
550 : static OPUS_INLINE opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
551 : {
552 : return (((a) < (b)) ? (a) : (b));
553 : }
554 0 : static OPUS_INLINE opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
555 : {
556 0 : return (((a) < (b)) ? (a) : (b));
557 : }
558 : static OPUS_INLINE opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
559 : {
560 : return (((a) < (b)) ? (a) : (b));
561 : }
562 :
563 : /* silk_min() versions with typecast in the function call */
564 0 : static OPUS_INLINE opus_int silk_max_int(opus_int a, opus_int b)
565 : {
566 0 : return (((a) > (b)) ? (a) : (b));
567 : }
568 0 : static OPUS_INLINE opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
569 : {
570 0 : return (((a) > (b)) ? (a) : (b));
571 : }
572 0 : static OPUS_INLINE opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
573 : {
574 0 : return (((a) > (b)) ? (a) : (b));
575 : }
576 : static OPUS_INLINE opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
577 : {
578 : return (((a) > (b)) ? (a) : (b));
579 : }
580 :
581 : #define silk_LIMIT( a, limit1, limit2) ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
582 : : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))
583 :
584 : #define silk_LIMIT_int silk_LIMIT
585 : #define silk_LIMIT_16 silk_LIMIT
586 : #define silk_LIMIT_32 silk_LIMIT
587 :
588 : #define silk_abs(a) (((a) > 0) ? (a) : -(a)) /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN */
589 : #define silk_abs_int(a) (((a) ^ ((a) >> (8 * sizeof(a) - 1))) - ((a) >> (8 * sizeof(a) - 1)))
590 : #define silk_abs_int32(a) (((a) ^ ((a) >> 31)) - ((a) >> 31))
591 : #define silk_abs_int64(a) (((a) > 0) ? (a) : -(a))
592 :
593 : #define silk_sign(a) ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ))
594 :
595 : /* PSEUDO-RANDOM GENERATOR */
596 : /* Make sure to store the result as the seed for the next call (also in between */
597 : /* frames), otherwise result won't be random at all. When only using some of the */
598 : /* bits, take the most significant bits by right-shifting. */
599 : #define RAND_MULTIPLIER 196314165
600 : #define RAND_INCREMENT 907633515
601 : #define silk_RAND(seed) (silk_MLA_ovflw((RAND_INCREMENT), (seed), (RAND_MULTIPLIER)))
602 :
603 : /* Add some multiplication functions that can be easily mapped to ARM. */
604 :
605 : /* silk_SMMUL: Signed top word multiply.
606 : ARMv6 2 instruction cycles.
607 : ARMv3M+ 3 instruction cycles. use SMULL and ignore LSB registers.(except xM)*/
608 : /*#define silk_SMMUL(a32, b32) (opus_int32)silk_RSHIFT(silk_SMLAL(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16)), 16)*/
609 : /* the following seems faster on x86 */
610 : #define silk_SMMUL(a32, b32) (opus_int32)silk_RSHIFT64(silk_SMULL((a32), (b32)), 32)
611 :
612 : #if !defined(OPUS_X86_MAY_HAVE_SSE4_1)
613 : #define silk_burg_modified(res_nrg, res_nrg_Q, A_Q16, x, minInvGain_Q30, subfr_length, nb_subfr, D, arch) \
614 : ((void)(arch), silk_burg_modified_c(res_nrg, res_nrg_Q, A_Q16, x, minInvGain_Q30, subfr_length, nb_subfr, D, arch))
615 :
616 : #define silk_inner_prod16_aligned_64(inVec1, inVec2, len, arch) \
617 : ((void)(arch),silk_inner_prod16_aligned_64_c(inVec1, inVec2, len))
618 : #endif
619 :
620 : #include "Inlines.h"
621 : #include "MacroCount.h"
622 : #include "MacroDebug.h"
623 :
624 : #ifdef OPUS_ARM_INLINE_ASM
625 : #include "arm/SigProc_FIX_armv4.h"
626 : #endif
627 :
628 : #ifdef OPUS_ARM_INLINE_EDSP
629 : #include "arm/SigProc_FIX_armv5e.h"
630 : #endif
631 :
632 : #if defined(MIPSr1_ASM)
633 : #include "mips/sigproc_fix_mipsr1.h"
634 : #endif
635 :
636 :
637 : #ifdef __cplusplus
638 : }
639 : #endif
640 :
641 : #endif /* SILK_SIGPROC_FIX_H */
|
