1/* 2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12/* 13 * This header file includes all of the fix point signal processing library (SPL) function 14 * descriptions and declarations. 15 * For specific function calls, see bottom of file. 16 */ 17 18#ifndef WEBRTC_SPL_SIGNAL_PROCESSING_LIBRARY_H_ 19#define WEBRTC_SPL_SIGNAL_PROCESSING_LIBRARY_H_ 20 21#include <string.h> 22#include "typedefs.h" 23 24#ifdef ARM_WINM 25#include <Armintr.h> // intrinsic file for windows mobile 26#endif 27 28#ifdef WEBRTC_ANDROID 29#define WEBRTC_SPL_INLINE_CALLS 30#define SPL_NO_DOUBLE_IMPLEMENTATIONS 31#endif 32 33// Macros specific for the fixed point implementation 34#define WEBRTC_SPL_WORD16_MAX 32767 35#define WEBRTC_SPL_WORD16_MIN -32768 36#define WEBRTC_SPL_WORD32_MAX (WebRtc_Word32)0x7fffffff 37#define WEBRTC_SPL_WORD32_MIN (WebRtc_Word32)0x80000000 38#define WEBRTC_SPL_MAX_LPC_ORDER 14 39#define WEBRTC_SPL_MAX_SEED_USED 0x80000000L 40#define WEBRTC_SPL_MIN(A, B) (A < B ? A : B) // Get min value 41#define WEBRTC_SPL_MAX(A, B) (A > B ? A : B) // Get max value 42#define WEBRTC_SPL_ABS_W16(a)\ 43 (((WebRtc_Word16)a >= 0) ? ((WebRtc_Word16)a) : -((WebRtc_Word16)a)) 44#define WEBRTC_SPL_ABS_W32(a)\ 45 (((WebRtc_Word32)a >= 0) ? ((WebRtc_Word32)a) : -((WebRtc_Word32)a)) 46 47#if (defined WEBRTC_TARGET_PC)||(defined __TARGET_XSCALE) 48#define WEBRTC_SPL_GET_BYTE(a, nr) (((WebRtc_Word8 *)a)[nr]) 49#define WEBRTC_SPL_SET_BYTE(d_ptr, val, index) \ 50 (((WebRtc_Word8 *)d_ptr)[index] = (val)) 51#elif defined WEBRTC_BIG_ENDIAN 52#define WEBRTC_SPL_GET_BYTE(a, nr)\ 53 ((((WebRtc_Word16 *)a)[nr >> 1]) >> (((nr + 1) & 0x1) * 8) & 0x00ff) 54#define WEBRTC_SPL_SET_BYTE(d_ptr, val, index) \ 55 ((WebRtc_Word16 *)d_ptr)[index >> 1] = \ 56 ((((WebRtc_Word16 *)d_ptr)[index >> 1]) \ 57 & (0x00ff << (8 * ((index) & 0x1)))) | (val << (8 * ((index + 1) & 0x1))) 58#else 59#define WEBRTC_SPL_GET_BYTE(a,nr) \ 60 ((((WebRtc_Word16 *)(a))[(nr) >> 1]) >> (((nr) & 0x1) * 8) & 0x00ff) 61#define WEBRTC_SPL_SET_BYTE(d_ptr, val, index) \ 62 ((WebRtc_Word16 *)(d_ptr))[(index) >> 1] = \ 63 ((((WebRtc_Word16 *)(d_ptr))[(index) >> 1]) \ 64 & (0x00ff << (8 * (((index) + 1) & 0x1)))) | \ 65 ((val) << (8 * ((index) & 0x1))) 66#endif 67 68#ifndef WEBRTC_ANDROID 69#define WEBRTC_SPL_MUL(a, b) \ 70 ((WebRtc_Word32) ((WebRtc_Word32)(a) * (WebRtc_Word32)(b))) 71#endif 72 73#define WEBRTC_SPL_UMUL(a, b) \ 74 ((WebRtc_UWord32) ((WebRtc_UWord32)(a) * (WebRtc_UWord32)(b))) 75#define WEBRTC_SPL_UMUL_RSFT16(a, b)\ 76 ((WebRtc_UWord32) ((WebRtc_UWord32)(a) * (WebRtc_UWord32)(b)) >> 16) 77#define WEBRTC_SPL_UMUL_16_16(a, b)\ 78 ((WebRtc_UWord32) (WebRtc_UWord16)(a) * (WebRtc_UWord16)(b)) 79#define WEBRTC_SPL_UMUL_16_16_RSFT16(a, b)\ 80 (((WebRtc_UWord32) (WebRtc_UWord16)(a) * (WebRtc_UWord16)(b)) >> 16) 81#define WEBRTC_SPL_UMUL_32_16(a, b)\ 82 ((WebRtc_UWord32) ((WebRtc_UWord32)(a) * (WebRtc_UWord16)(b))) 83#define WEBRTC_SPL_UMUL_32_16_RSFT16(a, b)\ 84 ((WebRtc_UWord32) ((WebRtc_UWord32)(a) * (WebRtc_UWord16)(b)) >> 16) 85#define WEBRTC_SPL_MUL_16_U16(a, b)\ 86 ((WebRtc_Word32)(WebRtc_Word16)(a) * (WebRtc_UWord16)(b)) 87#define WEBRTC_SPL_DIV(a, b) \ 88 ((WebRtc_Word32) ((WebRtc_Word32)(a) / (WebRtc_Word32)(b))) 89#define WEBRTC_SPL_UDIV(a, b) \ 90 ((WebRtc_UWord32) ((WebRtc_UWord32)(a) / (WebRtc_UWord32)(b))) 91 92#define WEBRTC_SPL_MUL_16_32_RSFT11(a, b)\ 93 ((WEBRTC_SPL_MUL_16_16(a, (b) >> 16) << 5) \ 94 + (((WEBRTC_SPL_MUL_16_U16(a, (WebRtc_UWord16)(b)) >> 1) + 0x0200) >> 10)) 95#define WEBRTC_SPL_MUL_16_32_RSFT14(a, b)\ 96 ((WEBRTC_SPL_MUL_16_16(a, (b) >> 16) << 2) \ 97 + (((WEBRTC_SPL_MUL_16_U16(a, (WebRtc_UWord16)(b)) >> 1) + 0x1000) >> 13)) 98#define WEBRTC_SPL_MUL_16_32_RSFT15(a, b) \ 99 ((WEBRTC_SPL_MUL_16_16(a, (b) >> 16) << 1) \ 100 + (((WEBRTC_SPL_MUL_16_U16(a, (WebRtc_UWord16)(b)) >> 1) + 0x2000) >> 14)) 101 102#ifndef WEBRTC_ANDROID 103#define WEBRTC_SPL_MUL_16_32_RSFT16(a, b) \ 104 (WEBRTC_SPL_MUL_16_16(a, b >> 16) \ 105 + ((WEBRTC_SPL_MUL_16_16(a, (b & 0xffff) >> 1) + 0x4000) >> 15)) 106#define WEBRTC_SPL_MUL_32_32_RSFT32(a32a, a32b, b32) \ 107 ((WebRtc_Word32)(WEBRTC_SPL_MUL_16_32_RSFT16(a32a, b32) \ 108 + (WEBRTC_SPL_MUL_16_32_RSFT16(a32b, b32) >> 16))) 109#define WEBRTC_SPL_MUL_32_32_RSFT32BI(a32, b32) \ 110 ((WebRtc_Word32)(WEBRTC_SPL_MUL_16_32_RSFT16(( \ 111 (WebRtc_Word16)(a32 >> 16)), b32) + \ 112 (WEBRTC_SPL_MUL_16_32_RSFT16(( \ 113 (WebRtc_Word16)((a32 & 0x0000FFFF) >> 1)), b32) >> 15))) 114#endif 115 116#ifdef ARM_WINM 117#define WEBRTC_SPL_MUL_16_16(a, b) \ 118 _SmulLo_SW_SL((WebRtc_Word16)(a), (WebRtc_Word16)(b)) 119#elif !defined (WEBRTC_ANDROID) 120#define WEBRTC_SPL_MUL_16_16(a, b) \ 121 ((WebRtc_Word32) (((WebRtc_Word16)(a)) * ((WebRtc_Word16)(b)))) 122#endif 123 124#define WEBRTC_SPL_MUL_16_16_RSFT(a, b, c) \ 125 (WEBRTC_SPL_MUL_16_16(a, b) >> (c)) 126 127#define WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(a, b, c) \ 128 ((WEBRTC_SPL_MUL_16_16(a, b) + ((WebRtc_Word32) \ 129 (((WebRtc_Word32)1) << ((c) - 1)))) >> (c)) 130#define WEBRTC_SPL_MUL_16_16_RSFT_WITH_FIXROUND(a, b)\ 131 ((WEBRTC_SPL_MUL_16_16(a, b) + ((WebRtc_Word32) (1 << 14))) >> 15) 132 133// C + the 32 most significant bits of A * B 134#define WEBRTC_SPL_SCALEDIFF32(A, B, C) \ 135 (C + (B >> 16) * A + (((WebRtc_UWord32)(0x0000FFFF & B) * A) >> 16)) 136 137#define WEBRTC_SPL_ADD_SAT_W32(a, b) WebRtcSpl_AddSatW32(a, b) 138#define WEBRTC_SPL_SAT(a, b, c) (b > a ? a : b < c ? c : b) 139#define WEBRTC_SPL_MUL_32_16(a, b) ((a) * (b)) 140 141#define WEBRTC_SPL_SUB_SAT_W32(a, b) WebRtcSpl_SubSatW32(a, b) 142#define WEBRTC_SPL_ADD_SAT_W16(a, b) WebRtcSpl_AddSatW16(a, b) 143#define WEBRTC_SPL_SUB_SAT_W16(a, b) WebRtcSpl_SubSatW16(a, b) 144 145// We cannot do casting here due to signed/unsigned problem 146#define WEBRTC_SPL_IS_NEG(a) ((a) & 0x80000000) 147// Shifting with negative numbers allowed 148// Positive means left shift 149#define WEBRTC_SPL_SHIFT_W16(x, c) \ 150 (((c) >= 0) ? ((x) << (c)) : ((x) >> (-(c)))) 151#define WEBRTC_SPL_SHIFT_W32(x, c) \ 152 (((c) >= 0) ? ((x) << (c)) : ((x) >> (-(c)))) 153 154// Shifting with negative numbers not allowed 155// We cannot do casting here due to signed/unsigned problem 156#define WEBRTC_SPL_RSHIFT_W16(x, c) ((x) >> (c)) 157#define WEBRTC_SPL_LSHIFT_W16(x, c) ((x) << (c)) 158#define WEBRTC_SPL_RSHIFT_W32(x, c) ((x) >> (c)) 159#define WEBRTC_SPL_LSHIFT_W32(x, c) ((x) << (c)) 160 161#define WEBRTC_SPL_RSHIFT_U16(x, c) ((WebRtc_UWord16)(x) >> (c)) 162#define WEBRTC_SPL_LSHIFT_U16(x, c) ((WebRtc_UWord16)(x) << (c)) 163#define WEBRTC_SPL_RSHIFT_U32(x, c) ((WebRtc_UWord32)(x) >> (c)) 164#define WEBRTC_SPL_LSHIFT_U32(x, c) ((WebRtc_UWord32)(x) << (c)) 165 166#define WEBRTC_SPL_VNEW(t, n) (t *) malloc (sizeof (t) * (n)) 167#define WEBRTC_SPL_FREE free 168 169#define WEBRTC_SPL_RAND(a)\ 170 ((WebRtc_Word16)(WEBRTC_SPL_MUL_16_16_RSFT((a), 18816, 7) & 0x00007fff)) 171 172#ifdef __cplusplus 173extern "C" 174{ 175#endif 176 177#define WEBRTC_SPL_MEMCPY_W8(v1, v2, length) \ 178 memcpy(v1, v2, (length) * sizeof(char)) 179#define WEBRTC_SPL_MEMCPY_W16(v1, v2, length) \ 180 memcpy(v1, v2, (length) * sizeof(WebRtc_Word16)) 181 182#define WEBRTC_SPL_MEMMOVE_W16(v1, v2, length) \ 183 memmove(v1, v2, (length) * sizeof(WebRtc_Word16)) 184 185// Trigonometric tables used for quick lookup 186// default declarations 187extern WebRtc_Word16 WebRtcSpl_kCosTable[]; 188extern WebRtc_Word16 WebRtcSpl_kSinTable[]; 189extern WebRtc_Word16 WebRtcSpl_kSinTable1024[]; 190// Hanning table 191extern WebRtc_Word16 WebRtcSpl_kHanningTable[]; 192// Random table 193extern WebRtc_Word16 WebRtcSpl_kRandNTable[]; 194 195#ifndef WEBRTC_SPL_INLINE_CALLS 196WebRtc_Word16 WebRtcSpl_AddSatW16(WebRtc_Word16 var1, WebRtc_Word16 var2); 197WebRtc_Word16 WebRtcSpl_SubSatW16(WebRtc_Word16 var1, WebRtc_Word16 var2); 198WebRtc_Word32 WebRtcSpl_AddSatW32(WebRtc_Word32 var1, WebRtc_Word32 var2); 199WebRtc_Word32 WebRtcSpl_SubSatW32(WebRtc_Word32 var1, WebRtc_Word32 var2); 200WebRtc_Word16 WebRtcSpl_GetSizeInBits(WebRtc_UWord32 value); 201int WebRtcSpl_NormW32(WebRtc_Word32 value); 202int WebRtcSpl_NormW16(WebRtc_Word16 value); 203int WebRtcSpl_NormU32(WebRtc_UWord32 value); 204#else 205#include "spl_inl.h" 206#endif 207 208// Get SPL Version 209WebRtc_Word16 WebRtcSpl_get_version(char* version, 210 WebRtc_Word16 length_in_bytes); 211 212int WebRtcSpl_GetScalingSquare(WebRtc_Word16* in_vector, 213 int in_vector_length, 214 int times); 215 216// Copy and set operations. Implementation in copy_set_operations.c. 217// Descriptions at bottom of file. 218void WebRtcSpl_MemSetW16(WebRtc_Word16* vector, 219 WebRtc_Word16 set_value, 220 int vector_length); 221void WebRtcSpl_MemSetW32(WebRtc_Word32* vector, 222 WebRtc_Word32 set_value, 223 int vector_length); 224void WebRtcSpl_MemCpyReversedOrder(WebRtc_Word16* out_vector, 225 WebRtc_Word16* in_vector, 226 int vector_length); 227WebRtc_Word16 WebRtcSpl_CopyFromEndW16(G_CONST WebRtc_Word16* in_vector, 228 WebRtc_Word16 in_vector_length, 229 WebRtc_Word16 samples, 230 WebRtc_Word16* out_vector); 231WebRtc_Word16 WebRtcSpl_ZerosArrayW16(WebRtc_Word16* vector, 232 WebRtc_Word16 vector_length); 233WebRtc_Word16 WebRtcSpl_ZerosArrayW32(WebRtc_Word32* vector, 234 WebRtc_Word16 vector_length); 235WebRtc_Word16 WebRtcSpl_OnesArrayW16(WebRtc_Word16* vector, 236 WebRtc_Word16 vector_length); 237WebRtc_Word16 WebRtcSpl_OnesArrayW32(WebRtc_Word32* vector, 238 WebRtc_Word16 vector_length); 239// End: Copy and set operations. 240 241// Minimum and maximum operations. Implementation in min_max_operations.c. 242// Descriptions at bottom of file. 243WebRtc_Word16 WebRtcSpl_MaxAbsValueW16(G_CONST WebRtc_Word16* vector, 244 WebRtc_Word16 length); 245WebRtc_Word32 WebRtcSpl_MaxAbsValueW32(G_CONST WebRtc_Word32* vector, 246 WebRtc_Word16 length); 247WebRtc_Word16 WebRtcSpl_MinValueW16(G_CONST WebRtc_Word16* vector, 248 WebRtc_Word16 length); 249WebRtc_Word32 WebRtcSpl_MinValueW32(G_CONST WebRtc_Word32* vector, 250 WebRtc_Word16 length); 251WebRtc_Word16 WebRtcSpl_MaxValueW16(G_CONST WebRtc_Word16* vector, 252 WebRtc_Word16 length); 253 254WebRtc_Word16 WebRtcSpl_MaxAbsIndexW16(G_CONST WebRtc_Word16* vector, 255 WebRtc_Word16 length); 256WebRtc_Word32 WebRtcSpl_MaxValueW32(G_CONST WebRtc_Word32* vector, 257 WebRtc_Word16 length); 258WebRtc_Word16 WebRtcSpl_MinIndexW16(G_CONST WebRtc_Word16* vector, 259 WebRtc_Word16 length); 260WebRtc_Word16 WebRtcSpl_MinIndexW32(G_CONST WebRtc_Word32* vector, 261 WebRtc_Word16 length); 262WebRtc_Word16 WebRtcSpl_MaxIndexW16(G_CONST WebRtc_Word16* vector, 263 WebRtc_Word16 length); 264WebRtc_Word16 WebRtcSpl_MaxIndexW32(G_CONST WebRtc_Word32* vector, 265 WebRtc_Word16 length); 266// End: Minimum and maximum operations. 267 268// Vector scaling operations. Implementation in vector_scaling_operations.c. 269// Description at bottom of file. 270void WebRtcSpl_VectorBitShiftW16(WebRtc_Word16* out_vector, 271 WebRtc_Word16 vector_length, 272 G_CONST WebRtc_Word16* in_vector, 273 WebRtc_Word16 right_shifts); 274void WebRtcSpl_VectorBitShiftW32(WebRtc_Word32* out_vector, 275 WebRtc_Word16 vector_length, 276 G_CONST WebRtc_Word32* in_vector, 277 WebRtc_Word16 right_shifts); 278void WebRtcSpl_VectorBitShiftW32ToW16(WebRtc_Word16* out_vector, 279 WebRtc_Word16 vector_length, 280 G_CONST WebRtc_Word32* in_vector, 281 WebRtc_Word16 right_shifts); 282 283void WebRtcSpl_ScaleVector(G_CONST WebRtc_Word16* in_vector, 284 WebRtc_Word16* out_vector, 285 WebRtc_Word16 gain, 286 WebRtc_Word16 vector_length, 287 WebRtc_Word16 right_shifts); 288void WebRtcSpl_ScaleVectorWithSat(G_CONST WebRtc_Word16* in_vector, 289 WebRtc_Word16* out_vector, 290 WebRtc_Word16 gain, 291 WebRtc_Word16 vector_length, 292 WebRtc_Word16 right_shifts); 293void WebRtcSpl_ScaleAndAddVectors(G_CONST WebRtc_Word16* in_vector1, 294 WebRtc_Word16 gain1, int right_shifts1, 295 G_CONST WebRtc_Word16* in_vector2, 296 WebRtc_Word16 gain2, int right_shifts2, 297 WebRtc_Word16* out_vector, 298 int vector_length); 299// End: Vector scaling operations. 300 301// iLBC specific functions. Implementations in ilbc_specific_functions.c. 302// Description at bottom of file. 303void WebRtcSpl_ScaleAndAddVectorsWithRound(WebRtc_Word16* in_vector1, 304 WebRtc_Word16 scale1, 305 WebRtc_Word16* in_vector2, 306 WebRtc_Word16 scale2, 307 WebRtc_Word16 right_shifts, 308 WebRtc_Word16* out_vector, 309 WebRtc_Word16 vector_length); 310void WebRtcSpl_ReverseOrderMultArrayElements(WebRtc_Word16* out_vector, 311 G_CONST WebRtc_Word16* in_vector, 312 G_CONST WebRtc_Word16* window, 313 WebRtc_Word16 vector_length, 314 WebRtc_Word16 right_shifts); 315void WebRtcSpl_ElementwiseVectorMult(WebRtc_Word16* out_vector, 316 G_CONST WebRtc_Word16* in_vector, 317 G_CONST WebRtc_Word16* window, 318 WebRtc_Word16 vector_length, 319 WebRtc_Word16 right_shifts); 320void WebRtcSpl_AddVectorsAndShift(WebRtc_Word16* out_vector, 321 G_CONST WebRtc_Word16* in_vector1, 322 G_CONST WebRtc_Word16* in_vector2, 323 WebRtc_Word16 vector_length, 324 WebRtc_Word16 right_shifts); 325void WebRtcSpl_AddAffineVectorToVector(WebRtc_Word16* out_vector, 326 WebRtc_Word16* in_vector, 327 WebRtc_Word16 gain, 328 WebRtc_Word32 add_constant, 329 WebRtc_Word16 right_shifts, 330 int vector_length); 331void WebRtcSpl_AffineTransformVector(WebRtc_Word16* out_vector, 332 WebRtc_Word16* in_vector, 333 WebRtc_Word16 gain, 334 WebRtc_Word32 add_constant, 335 WebRtc_Word16 right_shifts, 336 int vector_length); 337// End: iLBC specific functions. 338 339// Signal processing operations. Descriptions at bottom of this file. 340int WebRtcSpl_AutoCorrelation(G_CONST WebRtc_Word16* vector, 341 int vector_length, int order, 342 WebRtc_Word32* result_vector, 343 int* scale); 344WebRtc_Word16 WebRtcSpl_LevinsonDurbin(WebRtc_Word32* auto_corr, 345 WebRtc_Word16* lpc_coef, 346 WebRtc_Word16* refl_coef, 347 WebRtc_Word16 order); 348void WebRtcSpl_ReflCoefToLpc(G_CONST WebRtc_Word16* refl_coef, 349 int use_order, 350 WebRtc_Word16* lpc_coef); 351void WebRtcSpl_LpcToReflCoef(WebRtc_Word16* lpc_coef, 352 int use_order, 353 WebRtc_Word16* refl_coef); 354void WebRtcSpl_AutoCorrToReflCoef(G_CONST WebRtc_Word32* auto_corr, 355 int use_order, 356 WebRtc_Word16* refl_coef); 357void WebRtcSpl_CrossCorrelation(WebRtc_Word32* cross_corr, 358 WebRtc_Word16* vector1, 359 WebRtc_Word16* vector2, 360 WebRtc_Word16 dim_vector, 361 WebRtc_Word16 dim_cross_corr, 362 WebRtc_Word16 right_shifts, 363 WebRtc_Word16 step_vector2); 364void WebRtcSpl_GetHanningWindow(WebRtc_Word16* window, WebRtc_Word16 size); 365void WebRtcSpl_SqrtOfOneMinusXSquared(WebRtc_Word16* in_vector, 366 int vector_length, 367 WebRtc_Word16* out_vector); 368// End: Signal processing operations. 369 370// Randomization functions. Implementations collected in randomization_functions.c and 371// descriptions at bottom of this file. 372WebRtc_UWord32 WebRtcSpl_IncreaseSeed(WebRtc_UWord32* seed); 373WebRtc_Word16 WebRtcSpl_RandU(WebRtc_UWord32* seed); 374WebRtc_Word16 WebRtcSpl_RandN(WebRtc_UWord32* seed); 375WebRtc_Word16 WebRtcSpl_RandUArray(WebRtc_Word16* vector, 376 WebRtc_Word16 vector_length, 377 WebRtc_UWord32* seed); 378// End: Randomization functions. 379 380// Math functions 381WebRtc_Word32 WebRtcSpl_Sqrt(WebRtc_Word32 value); 382WebRtc_Word32 WebRtcSpl_SqrtFloor(WebRtc_Word32 value); 383 384// Divisions. Implementations collected in division_operations.c and 385// descriptions at bottom of this file. 386WebRtc_UWord32 WebRtcSpl_DivU32U16(WebRtc_UWord32 num, WebRtc_UWord16 den); 387WebRtc_Word32 WebRtcSpl_DivW32W16(WebRtc_Word32 num, WebRtc_Word16 den); 388WebRtc_Word16 WebRtcSpl_DivW32W16ResW16(WebRtc_Word32 num, WebRtc_Word16 den); 389WebRtc_Word32 WebRtcSpl_DivResultInQ31(WebRtc_Word32 num, WebRtc_Word32 den); 390WebRtc_Word32 WebRtcSpl_DivW32HiLow(WebRtc_Word32 num, WebRtc_Word16 den_hi, 391 WebRtc_Word16 den_low); 392// End: Divisions. 393 394WebRtc_Word32 WebRtcSpl_Energy(WebRtc_Word16* vector, 395 int vector_length, 396 int* scale_factor); 397 398WebRtc_Word32 WebRtcSpl_DotProductWithScale(WebRtc_Word16* vector1, 399 WebRtc_Word16* vector2, 400 int vector_length, 401 int scaling); 402 403// Filter operations. 404int WebRtcSpl_FilterAR(G_CONST WebRtc_Word16* ar_coef, int ar_coef_length, 405 G_CONST WebRtc_Word16* in_vector, int in_vector_length, 406 WebRtc_Word16* filter_state, int filter_state_length, 407 WebRtc_Word16* filter_state_low, 408 int filter_state_low_length, WebRtc_Word16* out_vector, 409 WebRtc_Word16* out_vector_low, int out_vector_low_length); 410 411void WebRtcSpl_FilterMAFastQ12(WebRtc_Word16* in_vector, 412 WebRtc_Word16* out_vector, 413 WebRtc_Word16* ma_coef, 414 WebRtc_Word16 ma_coef_length, 415 WebRtc_Word16 vector_length); 416void WebRtcSpl_FilterARFastQ12(WebRtc_Word16* in_vector, 417 WebRtc_Word16* out_vector, 418 WebRtc_Word16* ar_coef, 419 WebRtc_Word16 ar_coef_length, 420 WebRtc_Word16 vector_length); 421int WebRtcSpl_DownsampleFast(WebRtc_Word16* in_vector, 422 WebRtc_Word16 in_vector_length, 423 WebRtc_Word16* out_vector, 424 WebRtc_Word16 out_vector_length, 425 WebRtc_Word16* ma_coef, 426 WebRtc_Word16 ma_coef_length, 427 WebRtc_Word16 factor, 428 WebRtc_Word16 delay); 429// End: Filter operations. 430 431// FFT operations 432int WebRtcSpl_ComplexFFT(WebRtc_Word16 vector[], int stages, int mode); 433int WebRtcSpl_ComplexIFFT(WebRtc_Word16 vector[], int stages, int mode); 434#if (defined ARM9E_GCC) || (defined ARM_WINM) || (defined ANDROID_AECOPT) 435int WebRtcSpl_ComplexFFT2(WebRtc_Word16 in_vector[], 436 WebRtc_Word16 out_vector[], 437 int stages, int mode); 438int WebRtcSpl_ComplexIFFT2(WebRtc_Word16 in_vector[], 439 WebRtc_Word16 out_vector[], 440 int stages, int mode); 441#endif 442void WebRtcSpl_ComplexBitReverse(WebRtc_Word16 vector[], int stages); 443// End: FFT operations 444 445/************************************************************ 446 * 447 * RESAMPLING FUNCTIONS AND THEIR STRUCTS ARE DEFINED BELOW 448 * 449 ************************************************************/ 450 451/******************************************************************* 452 * resample.c 453 * 454 * Includes the following resampling combinations 455 * 22 kHz -> 16 kHz 456 * 16 kHz -> 22 kHz 457 * 22 kHz -> 8 kHz 458 * 8 kHz -> 22 kHz 459 * 460 ******************************************************************/ 461 462// state structure for 22 -> 16 resampler 463typedef struct 464{ 465 WebRtc_Word32 S_22_44[8]; 466 WebRtc_Word32 S_44_32[8]; 467 WebRtc_Word32 S_32_16[8]; 468} WebRtcSpl_State22khzTo16khz; 469 470void WebRtcSpl_Resample22khzTo16khz(const WebRtc_Word16* in, 471 WebRtc_Word16* out, 472 WebRtcSpl_State22khzTo16khz* state, 473 WebRtc_Word32* tmpmem); 474 475void WebRtcSpl_ResetResample22khzTo16khz(WebRtcSpl_State22khzTo16khz* state); 476 477// state structure for 16 -> 22 resampler 478typedef struct 479{ 480 WebRtc_Word32 S_16_32[8]; 481 WebRtc_Word32 S_32_22[8]; 482} WebRtcSpl_State16khzTo22khz; 483 484void WebRtcSpl_Resample16khzTo22khz(const WebRtc_Word16* in, 485 WebRtc_Word16* out, 486 WebRtcSpl_State16khzTo22khz* state, 487 WebRtc_Word32* tmpmem); 488 489void WebRtcSpl_ResetResample16khzTo22khz(WebRtcSpl_State16khzTo22khz* state); 490 491// state structure for 22 -> 8 resampler 492typedef struct 493{ 494 WebRtc_Word32 S_22_22[16]; 495 WebRtc_Word32 S_22_16[8]; 496 WebRtc_Word32 S_16_8[8]; 497} WebRtcSpl_State22khzTo8khz; 498 499void WebRtcSpl_Resample22khzTo8khz(const WebRtc_Word16* in, WebRtc_Word16* out, 500 WebRtcSpl_State22khzTo8khz* state, 501 WebRtc_Word32* tmpmem); 502 503void WebRtcSpl_ResetResample22khzTo8khz(WebRtcSpl_State22khzTo8khz* state); 504 505// state structure for 8 -> 22 resampler 506typedef struct 507{ 508 WebRtc_Word32 S_8_16[8]; 509 WebRtc_Word32 S_16_11[8]; 510 WebRtc_Word32 S_11_22[8]; 511} WebRtcSpl_State8khzTo22khz; 512 513void WebRtcSpl_Resample8khzTo22khz(const WebRtc_Word16* in, WebRtc_Word16* out, 514 WebRtcSpl_State8khzTo22khz* state, 515 WebRtc_Word32* tmpmem); 516 517void WebRtcSpl_ResetResample8khzTo22khz(WebRtcSpl_State8khzTo22khz* state); 518 519/******************************************************************* 520 * resample_fractional.c 521 * Functions for internal use in the other resample functions 522 * 523 * Includes the following resampling combinations 524 * 48 kHz -> 32 kHz 525 * 32 kHz -> 24 kHz 526 * 44 kHz -> 32 kHz 527 * 528 ******************************************************************/ 529 530void WebRtcSpl_Resample48khzTo32khz(const WebRtc_Word32* In, WebRtc_Word32* Out, 531 const WebRtc_Word32 K); 532 533void WebRtcSpl_Resample32khzTo24khz(const WebRtc_Word32* In, WebRtc_Word32* Out, 534 const WebRtc_Word32 K); 535 536void WebRtcSpl_Resample44khzTo32khz(const WebRtc_Word32* In, WebRtc_Word32* Out, 537 const WebRtc_Word32 K); 538 539/******************************************************************* 540 * resample_48khz.c 541 * 542 * Includes the following resampling combinations 543 * 48 kHz -> 16 kHz 544 * 16 kHz -> 48 kHz 545 * 48 kHz -> 8 kHz 546 * 8 kHz -> 48 kHz 547 * 548 ******************************************************************/ 549 550typedef struct 551{ 552 WebRtc_Word32 S_48_48[16]; 553 WebRtc_Word32 S_48_32[8]; 554 WebRtc_Word32 S_32_16[8]; 555} WebRtcSpl_State48khzTo16khz; 556 557void WebRtcSpl_Resample48khzTo16khz(const WebRtc_Word16* in, WebRtc_Word16* out, 558 WebRtcSpl_State48khzTo16khz* state, 559 WebRtc_Word32* tmpmem); 560 561void WebRtcSpl_ResetResample48khzTo16khz(WebRtcSpl_State48khzTo16khz* state); 562 563typedef struct 564{ 565 WebRtc_Word32 S_16_32[8]; 566 WebRtc_Word32 S_32_24[8]; 567 WebRtc_Word32 S_24_48[8]; 568} WebRtcSpl_State16khzTo48khz; 569 570void WebRtcSpl_Resample16khzTo48khz(const WebRtc_Word16* in, WebRtc_Word16* out, 571 WebRtcSpl_State16khzTo48khz* state, 572 WebRtc_Word32* tmpmem); 573 574void WebRtcSpl_ResetResample16khzTo48khz(WebRtcSpl_State16khzTo48khz* state); 575 576typedef struct 577{ 578 WebRtc_Word32 S_48_24[8]; 579 WebRtc_Word32 S_24_24[16]; 580 WebRtc_Word32 S_24_16[8]; 581 WebRtc_Word32 S_16_8[8]; 582} WebRtcSpl_State48khzTo8khz; 583 584void WebRtcSpl_Resample48khzTo8khz(const WebRtc_Word16* in, WebRtc_Word16* out, 585 WebRtcSpl_State48khzTo8khz* state, 586 WebRtc_Word32* tmpmem); 587 588void WebRtcSpl_ResetResample48khzTo8khz(WebRtcSpl_State48khzTo8khz* state); 589 590typedef struct 591{ 592 WebRtc_Word32 S_8_16[8]; 593 WebRtc_Word32 S_16_12[8]; 594 WebRtc_Word32 S_12_24[8]; 595 WebRtc_Word32 S_24_48[8]; 596} WebRtcSpl_State8khzTo48khz; 597 598void WebRtcSpl_Resample8khzTo48khz(const WebRtc_Word16* in, WebRtc_Word16* out, 599 WebRtcSpl_State8khzTo48khz* state, 600 WebRtc_Word32* tmpmem); 601 602void WebRtcSpl_ResetResample8khzTo48khz(WebRtcSpl_State8khzTo48khz* state); 603 604/******************************************************************* 605 * resample_by_2.c 606 * 607 * Includes down and up sampling by a factor of two. 608 * 609 ******************************************************************/ 610 611void WebRtcSpl_DownsampleBy2(const WebRtc_Word16* in, const WebRtc_Word16 len, 612 WebRtc_Word16* out, WebRtc_Word32* filtState); 613 614void WebRtcSpl_UpsampleBy2(const WebRtc_Word16* in, WebRtc_Word16 len, WebRtc_Word16* out, 615 WebRtc_Word32* filtState); 616 617/************************************************************ 618 * END OF RESAMPLING FUNCTIONS 619 ************************************************************/ 620void WebRtcSpl_AnalysisQMF(const WebRtc_Word16* in_data, 621 WebRtc_Word16* low_band, 622 WebRtc_Word16* high_band, 623 WebRtc_Word32* filter_state1, 624 WebRtc_Word32* filter_state2); 625void WebRtcSpl_SynthesisQMF(const WebRtc_Word16* low_band, 626 const WebRtc_Word16* high_band, 627 WebRtc_Word16* out_data, 628 WebRtc_Word32* filter_state1, 629 WebRtc_Word32* filter_state2); 630 631#ifdef __cplusplus 632} 633#endif // __cplusplus 634#endif // WEBRTC_SPL_SIGNAL_PROCESSING_LIBRARY_H_ 635 636// 637// WebRtcSpl_AddSatW16(...) 638// WebRtcSpl_AddSatW32(...) 639// 640// Returns the result of a saturated 16-bit, respectively 32-bit, addition of 641// the numbers specified by the |var1| and |var2| parameters. 642// 643// Input: 644// - var1 : Input variable 1 645// - var2 : Input variable 2 646// 647// Return value : Added and saturated value 648// 649 650// 651// WebRtcSpl_SubSatW16(...) 652// WebRtcSpl_SubSatW32(...) 653// 654// Returns the result of a saturated 16-bit, respectively 32-bit, subtraction 655// of the numbers specified by the |var1| and |var2| parameters. 656// 657// Input: 658// - var1 : Input variable 1 659// - var2 : Input variable 2 660// 661// Returned value : Subtracted and saturated value 662// 663 664// 665// WebRtcSpl_GetSizeInBits(...) 666// 667// Returns the # of bits that are needed at the most to represent the number 668// specified by the |value| parameter. 669// 670// Input: 671// - value : Input value 672// 673// Return value : Number of bits needed to represent |value| 674// 675 676// 677// WebRtcSpl_NormW32(...) 678// 679// Norm returns the # of left shifts required to 32-bit normalize the 32-bit 680// signed number specified by the |value| parameter. 681// 682// Input: 683// - value : Input value 684// 685// Return value : Number of bit shifts needed to 32-bit normalize |value| 686// 687 688// 689// WebRtcSpl_NormW16(...) 690// 691// Norm returns the # of left shifts required to 16-bit normalize the 16-bit 692// signed number specified by the |value| parameter. 693// 694// Input: 695// - value : Input value 696// 697// Return value : Number of bit shifts needed to 32-bit normalize |value| 698// 699 700// 701// WebRtcSpl_NormU32(...) 702// 703// Norm returns the # of left shifts required to 32-bit normalize the unsigned 704// 32-bit number specified by the |value| parameter. 705// 706// Input: 707// - value : Input value 708// 709// Return value : Number of bit shifts needed to 32-bit normalize |value| 710// 711 712// 713// WebRtcSpl_GetScalingSquare(...) 714// 715// Returns the # of bits required to scale the samples specified in the 716// |in_vector| parameter so that, if the squares of the samples are added the 717// # of times specified by the |times| parameter, the 32-bit addition will not 718// overflow (result in WebRtc_Word32). 719// 720// Input: 721// - in_vector : Input vector to check scaling on 722// - in_vector_length : Samples in |in_vector| 723// - times : Number of additions to be performed 724// 725// Return value : Number of right bit shifts needed to avoid 726// overflow in the addition calculation 727// 728 729// 730// WebRtcSpl_MemSetW16(...) 731// 732// Sets all the values in the WebRtc_Word16 vector |vector| of length 733// |vector_length| to the specified value |set_value| 734// 735// Input: 736// - vector : Pointer to the WebRtc_Word16 vector 737// - set_value : Value specified 738// - vector_length : Length of vector 739// 740 741// 742// WebRtcSpl_MemSetW32(...) 743// 744// Sets all the values in the WebRtc_Word32 vector |vector| of length 745// |vector_length| to the specified value |set_value| 746// 747// Input: 748// - vector : Pointer to the WebRtc_Word16 vector 749// - set_value : Value specified 750// - vector_length : Length of vector 751// 752 753// 754// WebRtcSpl_MemCpyReversedOrder(...) 755// 756// Copies all the values from the source WebRtc_Word16 vector |in_vector| to a 757// destination WebRtc_Word16 vector |out_vector|. It is done in reversed order, 758// meaning that the first sample of |in_vector| is copied to the last sample of 759// the |out_vector|. The procedure continues until the last sample of 760// |in_vector| has been copied to the first sample of |out_vector|. This 761// creates a reversed vector. Used in e.g. prediction in iLBC. 762// 763// Input: 764// - in_vector : Pointer to the first sample in a WebRtc_Word16 vector 765// of length |length| 766// - vector_length : Number of elements to copy 767// 768// Output: 769// - out_vector : Pointer to the last sample in a WebRtc_Word16 vector 770// of length |length| 771// 772 773// 774// WebRtcSpl_CopyFromEndW16(...) 775// 776// Copies the rightmost |samples| of |in_vector| (of length |in_vector_length|) 777// to the vector |out_vector|. 778// 779// Input: 780// - in_vector : Input vector 781// - in_vector_length : Number of samples in |in_vector| 782// - samples : Number of samples to extract (from right side) 783// from |in_vector| 784// 785// Output: 786// - out_vector : Vector with the requested samples 787// 788// Return value : Number of copied samples in |out_vector| 789// 790 791// 792// WebRtcSpl_ZerosArrayW16(...) 793// WebRtcSpl_ZerosArrayW32(...) 794// 795// Inserts the value "zero" in all positions of a w16 and a w32 vector 796// respectively. 797// 798// Input: 799// - vector_length : Number of samples in vector 800// 801// Output: 802// - vector : Vector containing all zeros 803// 804// Return value : Number of samples in vector 805// 806 807// 808// WebRtcSpl_OnesArrayW16(...) 809// WebRtcSpl_OnesArrayW32(...) 810// 811// Inserts the value "one" in all positions of a w16 and a w32 vector 812// respectively. 813// 814// Input: 815// - vector_length : Number of samples in vector 816// 817// Output: 818// - vector : Vector containing all ones 819// 820// Return value : Number of samples in vector 821// 822 823// 824// WebRtcSpl_MinValueW16(...) 825// WebRtcSpl_MinValueW32(...) 826// 827// Returns the minimum value of a vector 828// 829// Input: 830// - vector : Input vector 831// - vector_length : Number of samples in vector 832// 833// Return value : Minimum sample value in vector 834// 835 836// 837// WebRtcSpl_MaxValueW16(...) 838// WebRtcSpl_MaxValueW32(...) 839// 840// Returns the maximum value of a vector 841// 842// Input: 843// - vector : Input vector 844// - vector_length : Number of samples in vector 845// 846// Return value : Maximum sample value in vector 847// 848 849// 850// WebRtcSpl_MaxAbsValueW16(...) 851// WebRtcSpl_MaxAbsValueW32(...) 852// 853// Returns the largest absolute value of a vector 854// 855// Input: 856// - vector : Input vector 857// - vector_length : Number of samples in vector 858// 859// Return value : Maximum absolute value in vector 860// 861 862// 863// WebRtcSpl_MaxAbsIndexW16(...) 864// 865// Returns the vector index to the largest absolute value of a vector 866// 867// Input: 868// - vector : Input vector 869// - vector_length : Number of samples in vector 870// 871// Return value : Index to maximum absolute value in vector 872// 873 874// 875// WebRtcSpl_MinIndexW16(...) 876// WebRtcSpl_MinIndexW32(...) 877// 878// Returns the vector index to the minimum sample value of a vector 879// 880// Input: 881// - vector : Input vector 882// - vector_length : Number of samples in vector 883// 884// Return value : Index to minimum sample value in vector 885// 886 887// 888// WebRtcSpl_MaxIndexW16(...) 889// WebRtcSpl_MaxIndexW32(...) 890// 891// Returns the vector index to the maximum sample value of a vector 892// 893// Input: 894// - vector : Input vector 895// - vector_length : Number of samples in vector 896// 897// Return value : Index to maximum sample value in vector 898// 899 900// 901// WebRtcSpl_VectorBitShiftW16(...) 902// WebRtcSpl_VectorBitShiftW32(...) 903// 904// Bit shifts all the values in a vector up or downwards. Different calls for 905// WebRtc_Word16 and WebRtc_Word32 vectors respectively. 906// 907// Input: 908// - vector_length : Length of vector 909// - in_vector : Pointer to the vector that should be bit shifted 910// - right_shifts : Number of right bit shifts (negative value gives left 911// shifts) 912// 913// Output: 914// - out_vector : Pointer to the result vector (can be the same as 915// |in_vector|) 916// 917 918// 919// WebRtcSpl_VectorBitShiftW32ToW16(...) 920// 921// Bit shifts all the values in a WebRtc_Word32 vector up or downwards and 922// stores the result as a WebRtc_Word16 vector 923// 924// Input: 925// - vector_length : Length of vector 926// - in_vector : Pointer to the vector that should be bit shifted 927// - right_shifts : Number of right bit shifts (negative value gives left 928// shifts) 929// 930// Output: 931// - out_vector : Pointer to the result vector (can be the same as 932// |in_vector|) 933// 934 935// 936// WebRtcSpl_ScaleVector(...) 937// 938// Performs the vector operation: 939// out_vector[k] = (gain*in_vector[k])>>right_shifts 940// 941// Input: 942// - in_vector : Input vector 943// - gain : Scaling gain 944// - vector_length : Elements in the |in_vector| 945// - right_shifts : Number of right bit shifts applied 946// 947// Output: 948// - out_vector : Output vector (can be the same as |in_vector|) 949// 950 951// 952// WebRtcSpl_ScaleVectorWithSat(...) 953// 954// Performs the vector operation: 955// out_vector[k] = SATURATE( (gain*in_vector[k])>>right_shifts ) 956// 957// Input: 958// - in_vector : Input vector 959// - gain : Scaling gain 960// - vector_length : Elements in the |in_vector| 961// - right_shifts : Number of right bit shifts applied 962// 963// Output: 964// - out_vector : Output vector (can be the same as |in_vector|) 965// 966 967// 968// WebRtcSpl_ScaleAndAddVectors(...) 969// 970// Performs the vector operation: 971// out_vector[k] = (gain1*in_vector1[k])>>right_shifts1 972// + (gain2*in_vector2[k])>>right_shifts2 973// 974// Input: 975// - in_vector1 : Input vector 1 976// - gain1 : Gain to be used for vector 1 977// - right_shifts1 : Right bit shift to be used for vector 1 978// - in_vector2 : Input vector 2 979// - gain2 : Gain to be used for vector 2 980// - right_shifts2 : Right bit shift to be used for vector 2 981// - vector_length : Elements in the input vectors 982// 983// Output: 984// - out_vector : Output vector 985// 986 987// 988// WebRtcSpl_ScaleAndAddVectorsWithRound(...) 989// 990// Performs the vector operation: 991// 992// out_vector[k] = ((scale1*in_vector1[k]) + (scale2*in_vector2[k]) 993// + round_value) >> right_shifts 994// 995// where: 996// 997// round_value = (1<<right_shifts)>>1 998// 999// Input: 1000// - in_vector1 : Input vector 1 1001// - scale1 : Gain to be used for vector 1 1002// - in_vector2 : Input vector 2 1003// - scale2 : Gain to be used for vector 2 1004// - right_shifts : Number of right bit shifts to be applied 1005// - vector_length : Number of elements in the input vectors 1006// 1007// Output: 1008// - out_vector : Output vector 1009// 1010 1011// 1012// WebRtcSpl_ReverseOrderMultArrayElements(...) 1013// 1014// Performs the vector operation: 1015// out_vector[n] = (in_vector[n]*window[-n])>>right_shifts 1016// 1017// Input: 1018// - in_vector : Input vector 1019// - window : Window vector (should be reversed). The pointer 1020// should be set to the last value in the vector 1021// - right_shifts : Number of right bit shift to be applied after the 1022// multiplication 1023// - vector_length : Number of elements in |in_vector| 1024// 1025// Output: 1026// - out_vector : Output vector (can be same as |in_vector|) 1027// 1028 1029// 1030// WebRtcSpl_ElementwiseVectorMult(...) 1031// 1032// Performs the vector operation: 1033// out_vector[n] = (in_vector[n]*window[n])>>right_shifts 1034// 1035// Input: 1036// - in_vector : Input vector 1037// - window : Window vector. 1038// - right_shifts : Number of right bit shift to be applied after the 1039// multiplication 1040// - vector_length : Number of elements in |in_vector| 1041// 1042// Output: 1043// - out_vector : Output vector (can be same as |in_vector|) 1044// 1045 1046// 1047// WebRtcSpl_AddVectorsAndShift(...) 1048// 1049// Performs the vector operation: 1050// out_vector[k] = (in_vector1[k] + in_vector2[k])>>right_shifts 1051// 1052// Input: 1053// - in_vector1 : Input vector 1 1054// - in_vector2 : Input vector 2 1055// - right_shifts : Number of right bit shift to be applied after the 1056// multiplication 1057// - vector_length : Number of elements in |in_vector1| and |in_vector2| 1058// 1059// Output: 1060// - out_vector : Output vector (can be same as |in_vector1|) 1061// 1062 1063// 1064// WebRtcSpl_AddAffineVectorToVector(...) 1065// 1066// Adds an affine transformed vector to another vector |out_vector|, i.e, 1067// performs 1068// out_vector[k] += (in_vector[k]*gain+add_constant)>>right_shifts 1069// 1070// Input: 1071// - in_vector : Input vector 1072// - gain : Gain value, used to multiply the in vector with 1073// - add_constant : Constant value to add (usually 1<<(right_shifts-1), 1074// but others can be used as well 1075// - right_shifts : Number of right bit shifts (0-16) 1076// - vector_length : Number of samples in |in_vector| and |out_vector| 1077// 1078// Output: 1079// - out_vector : Vector with the output 1080// 1081 1082// 1083// WebRtcSpl_AffineTransformVector(...) 1084// 1085// Affine transforms a vector, i.e, performs 1086// out_vector[k] = (in_vector[k]*gain+add_constant)>>right_shifts 1087// 1088// Input: 1089// - in_vector : Input vector 1090// - gain : Gain value, used to multiply the in vector with 1091// - add_constant : Constant value to add (usually 1<<(right_shifts-1), 1092// but others can be used as well 1093// - right_shifts : Number of right bit shifts (0-16) 1094// - vector_length : Number of samples in |in_vector| and |out_vector| 1095// 1096// Output: 1097// - out_vector : Vector with the output 1098// 1099 1100// 1101// WebRtcSpl_AutoCorrelation(...) 1102// 1103// A 32-bit fix-point implementation of auto-correlation computation 1104// 1105// Input: 1106// - vector : Vector to calculate autocorrelation upon 1107// - vector_length : Length (in samples) of |vector| 1108// - order : The order up to which the autocorrelation should be 1109// calculated 1110// 1111// Output: 1112// - result_vector : auto-correlation values (values should be seen 1113// relative to each other since the absolute values 1114// might have been down shifted to avoid overflow) 1115// 1116// - scale : The number of left shifts required to obtain the 1117// auto-correlation in Q0 1118// 1119// Return value : Number of samples in |result_vector|, i.e., (order+1) 1120// 1121 1122// 1123// WebRtcSpl_LevinsonDurbin(...) 1124// 1125// A 32-bit fix-point implementation of the Levinson-Durbin algorithm that 1126// does NOT use the 64 bit class 1127// 1128// Input: 1129// - auto_corr : Vector with autocorrelation values of length >= 1130// |use_order|+1 1131// - use_order : The LPC filter order (support up to order 20) 1132// 1133// Output: 1134// - lpc_coef : lpc_coef[0..use_order] LPC coefficients in Q12 1135// - refl_coef : refl_coef[0...use_order-1]| Reflection coefficients in 1136// Q15 1137// 1138// Return value : 1 for stable 0 for unstable 1139// 1140 1141// 1142// WebRtcSpl_ReflCoefToLpc(...) 1143// 1144// Converts reflection coefficients |refl_coef| to LPC coefficients |lpc_coef|. 1145// This version is a 16 bit operation. 1146// 1147// NOTE: The 16 bit refl_coef -> lpc_coef conversion might result in a 1148// "slightly unstable" filter (i.e., a pole just outside the unit circle) in 1149// "rare" cases even if the reflection coefficients are stable. 1150// 1151// Input: 1152// - refl_coef : Reflection coefficients in Q15 that should be converted 1153// to LPC coefficients 1154// - use_order : Number of coefficients in |refl_coef| 1155// 1156// Output: 1157// - lpc_coef : LPC coefficients in Q12 1158// 1159 1160// 1161// WebRtcSpl_LpcToReflCoef(...) 1162// 1163// Converts LPC coefficients |lpc_coef| to reflection coefficients |refl_coef|. 1164// This version is a 16 bit operation. 1165// The conversion is implemented by the step-down algorithm. 1166// 1167// Input: 1168// - lpc_coef : LPC coefficients in Q12, that should be converted to 1169// reflection coefficients 1170// - use_order : Number of coefficients in |lpc_coef| 1171// 1172// Output: 1173// - refl_coef : Reflection coefficients in Q15. 1174// 1175 1176// 1177// WebRtcSpl_AutoCorrToReflCoef(...) 1178// 1179// Calculates reflection coefficients (16 bit) from auto-correlation values 1180// 1181// Input: 1182// - auto_corr : Auto-correlation values 1183// - use_order : Number of coefficients wanted be calculated 1184// 1185// Output: 1186// - refl_coef : Reflection coefficients in Q15. 1187// 1188 1189// 1190// WebRtcSpl_CrossCorrelation(...) 1191// 1192// Calculates the cross-correlation between two sequences |vector1| and 1193// |vector2|. |vector1| is fixed and |vector2| slides as the pointer is 1194// increased with the amount |step_vector2| 1195// 1196// Input: 1197// - vector1 : First sequence (fixed throughout the correlation) 1198// - vector2 : Second sequence (slides |step_vector2| for each 1199// new correlation) 1200// - dim_vector : Number of samples to use in the cross-correlation 1201// - dim_cross_corr : Number of cross-correlations to calculate (the 1202// start position for |vector2| is updated for each 1203// new one) 1204// - right_shifts : Number of right bit shifts to use. This will 1205// become the output Q-domain. 1206// - step_vector2 : How many (positive or negative) steps the 1207// |vector2| pointer should be updated for each new 1208// cross-correlation value. 1209// 1210// Output: 1211// - cross_corr : The cross-correlation in Q(-right_shifts) 1212// 1213 1214// 1215// WebRtcSpl_GetHanningWindow(...) 1216// 1217// Creates (the first half of) a Hanning window. Size must be at least 1 and 1218// at most 512. 1219// 1220// Input: 1221// - size : Length of the requested Hanning window (1 to 512) 1222// 1223// Output: 1224// - window : Hanning vector in Q14. 1225// 1226 1227// 1228// WebRtcSpl_SqrtOfOneMinusXSquared(...) 1229// 1230// Calculates y[k] = sqrt(1 - x[k]^2) for each element of the input vector 1231// |in_vector|. Input and output values are in Q15. 1232// 1233// Inputs: 1234// - in_vector : Values to calculate sqrt(1 - x^2) of 1235// - vector_length : Length of vector |in_vector| 1236// 1237// Output: 1238// - out_vector : Output values in Q15 1239// 1240 1241// 1242// WebRtcSpl_IncreaseSeed(...) 1243// 1244// Increases the seed (and returns the new value) 1245// 1246// Input: 1247// - seed : Seed for random calculation 1248// 1249// Output: 1250// - seed : Updated seed value 1251// 1252// Return value : The new seed value 1253// 1254 1255// 1256// WebRtcSpl_RandU(...) 1257// 1258// Produces a uniformly distributed value in the WebRtc_Word16 range 1259// 1260// Input: 1261// - seed : Seed for random calculation 1262// 1263// Output: 1264// - seed : Updated seed value 1265// 1266// Return value : Uniformly distributed value in the range 1267// [Word16_MIN...Word16_MAX] 1268// 1269 1270// 1271// WebRtcSpl_RandN(...) 1272// 1273// Produces a normal distributed value in the WebRtc_Word16 range 1274// 1275// Input: 1276// - seed : Seed for random calculation 1277// 1278// Output: 1279// - seed : Updated seed value 1280// 1281// Return value : N(0,1) value in the Q13 domain 1282// 1283 1284// 1285// WebRtcSpl_RandUArray(...) 1286// 1287// Produces a uniformly distributed vector with elements in the WebRtc_Word16 1288// range 1289// 1290// Input: 1291// - vector_length : Samples wanted in the vector 1292// - seed : Seed for random calculation 1293// 1294// Output: 1295// - vector : Vector with the uniform values 1296// - seed : Updated seed value 1297// 1298// Return value : Number of samples in vector, i.e., |vector_length| 1299// 1300 1301// 1302// WebRtcSpl_Sqrt(...) 1303// 1304// Returns the square root of the input value |value|. The precision of this 1305// function is integer precision, i.e., sqrt(8) gives 2 as answer. 1306// If |value| is a negative number then 0 is returned. 1307// 1308// Algorithm: 1309// 1310// A sixth order Taylor Series expansion is used here to compute the square 1311// root of a number y^0.5 = (1+x)^0.5 1312// where 1313// x = y-1 1314// = 1+(x/2)-0.5*((x/2)^2+0.5*((x/2)^3-0.625*((x/2)^4+0.875*((x/2)^5) 1315// 0.5 <= x < 1 1316// 1317// Input: 1318// - value : Value to calculate sqrt of 1319// 1320// Return value : Result of the sqrt calculation 1321// 1322 1323// 1324// WebRtcSpl_SqrtFloor(...) 1325// 1326// Returns the square root of the input value |value|. The precision of this 1327// function is rounding down integer precision, i.e., sqrt(8) gives 2 as answer. 1328// If |value| is a negative number then 0 is returned. 1329// 1330// Algorithm: 1331// 1332// An iterative 4 cylce/bit routine 1333// 1334// Input: 1335// - value : Value to calculate sqrt of 1336// 1337// Return value : Result of the sqrt calculation 1338// 1339 1340// 1341// WebRtcSpl_DivU32U16(...) 1342// 1343// Divides a WebRtc_UWord32 |num| by a WebRtc_UWord16 |den|. 1344// 1345// If |den|==0, (WebRtc_UWord32)0xFFFFFFFF is returned. 1346// 1347// Input: 1348// - num : Numerator 1349// - den : Denominator 1350// 1351// Return value : Result of the division (as a WebRtc_UWord32), i.e., the 1352// integer part of num/den. 1353// 1354 1355// 1356// WebRtcSpl_DivW32W16(...) 1357// 1358// Divides a WebRtc_Word32 |num| by a WebRtc_Word16 |den|. 1359// 1360// If |den|==0, (WebRtc_Word32)0x7FFFFFFF is returned. 1361// 1362// Input: 1363// - num : Numerator 1364// - den : Denominator 1365// 1366// Return value : Result of the division (as a WebRtc_Word32), i.e., the 1367// integer part of num/den. 1368// 1369 1370// 1371// WebRtcSpl_DivW32W16ResW16(...) 1372// 1373// Divides a WebRtc_Word32 |num| by a WebRtc_Word16 |den|, assuming that the 1374// result is less than 32768, otherwise an unpredictable result will occur. 1375// 1376// If |den|==0, (WebRtc_Word16)0x7FFF is returned. 1377// 1378// Input: 1379// - num : Numerator 1380// - den : Denominator 1381// 1382// Return value : Result of the division (as a WebRtc_Word16), i.e., the 1383// integer part of num/den. 1384// 1385 1386// 1387// WebRtcSpl_DivResultInQ31(...) 1388// 1389// Divides a WebRtc_Word32 |num| by a WebRtc_Word16 |den|, assuming that the 1390// absolute value of the denominator is larger than the numerator, otherwise 1391// an unpredictable result will occur. 1392// 1393// Input: 1394// - num : Numerator 1395// - den : Denominator 1396// 1397// Return value : Result of the division in Q31. 1398// 1399 1400// 1401// WebRtcSpl_DivW32HiLow(...) 1402// 1403// Divides a WebRtc_Word32 |num| by a denominator in hi, low format. The 1404// absolute value of the denominator has to be larger (or equal to) the 1405// numerator. 1406// 1407// Input: 1408// - num : Numerator 1409// - den_hi : High part of denominator 1410// - den_low : Low part of denominator 1411// 1412// Return value : Divided value in Q31 1413// 1414 1415// 1416// WebRtcSpl_Energy(...) 1417// 1418// Calculates the energy of a vector 1419// 1420// Input: 1421// - vector : Vector which the energy should be calculated on 1422// - vector_length : Number of samples in vector 1423// 1424// Output: 1425// - scale_factor : Number of left bit shifts needed to get the physical 1426// energy value, i.e, to get the Q0 value 1427// 1428// Return value : Energy value in Q(-|scale_factor|) 1429// 1430 1431// 1432// WebRtcSpl_FilterAR(...) 1433// 1434// Performs a 32-bit AR filtering on a vector in Q12 1435// 1436// Input: 1437// - ar_coef : AR-coefficient vector (values in Q12), 1438// ar_coef[0] must be 4096. 1439// - ar_coef_length : Number of coefficients in |ar_coef|. 1440// - in_vector : Vector to be filtered. 1441// - in_vector_length : Number of samples in |in_vector|. 1442// - filter_state : Current state (higher part) of the filter. 1443// - filter_state_length : Length (in samples) of |filter_state|. 1444// - filter_state_low : Current state (lower part) of the filter. 1445// - filter_state_low_length : Length (in samples) of |filter_state_low|. 1446// - out_vector_low_length : Maximum length (in samples) of 1447// |out_vector_low|. 1448// 1449// Output: 1450// - filter_state : Updated state (upper part) vector. 1451// - filter_state_low : Updated state (lower part) vector. 1452// - out_vector : Vector containing the upper part of the 1453// filtered values. 1454// - out_vector_low : Vector containing the lower part of the 1455// filtered values. 1456// 1457// Return value : Number of samples in the |out_vector|. 1458// 1459 1460// 1461// WebRtcSpl_FilterMAFastQ12(...) 1462// 1463// Performs a MA filtering on a vector in Q12 1464// 1465// Input: 1466// - in_vector : Input samples (state in positions 1467// in_vector[-order] .. in_vector[-1]) 1468// - ma_coef : Filter coefficients (in Q12) 1469// - ma_coef_length : Number of B coefficients (order+1) 1470// - vector_length : Number of samples to be filtered 1471// 1472// Output: 1473// - out_vector : Filtered samples 1474// 1475 1476// 1477// WebRtcSpl_FilterARFastQ12(...) 1478// 1479// Performs a AR filtering on a vector in Q12 1480// 1481// Input: 1482// - in_vector : Input samples 1483// - out_vector : State information in positions 1484// out_vector[-order] .. out_vector[-1] 1485// - ar_coef : Filter coefficients (in Q12) 1486// - ar_coef_length : Number of B coefficients (order+1) 1487// - vector_length : Number of samples to be filtered 1488// 1489// Output: 1490// - out_vector : Filtered samples 1491// 1492 1493// 1494// WebRtcSpl_DownsampleFast(...) 1495// 1496// Performs a MA down sampling filter on a vector 1497// 1498// Input: 1499// - in_vector : Input samples (state in positions 1500// in_vector[-order] .. in_vector[-1]) 1501// - in_vector_length : Number of samples in |in_vector| to be filtered. 1502// This must be at least 1503// |delay| + |factor|*(|out_vector_length|-1) + 1) 1504// - out_vector_length : Number of down sampled samples desired 1505// - ma_coef : Filter coefficients (in Q12) 1506// - ma_coef_length : Number of B coefficients (order+1) 1507// - factor : Decimation factor 1508// - delay : Delay of filter (compensated for in out_vector) 1509// 1510// Output: 1511// - out_vector : Filtered samples 1512// 1513// Return value : 0 if OK, -1 if |in_vector| is too short 1514// 1515 1516// 1517// WebRtcSpl_DotProductWithScale(...) 1518// 1519// Calculates the dot product between two (WebRtc_Word16) vectors 1520// 1521// Input: 1522// - vector1 : Vector 1 1523// - vector2 : Vector 2 1524// - vector_length : Number of samples used in the dot product 1525// - scaling : The number of right bit shifts to apply on each term 1526// during calculation to avoid overflow, i.e., the 1527// output will be in Q(-|scaling|) 1528// 1529// Return value : The dot product in Q(-scaling) 1530// 1531 1532// 1533// WebRtcSpl_ComplexIFFT(...) 1534// 1535// Complex Inverse FFT 1536// 1537// Computes an inverse complex 2^|stages|-point FFT on the input vector, which 1538// is in bit-reversed order. The original content of the vector is destroyed in 1539// the process, since the input is overwritten by the output, normal-ordered, 1540// FFT vector. With X as the input complex vector, y as the output complex 1541// vector and with M = 2^|stages|, the following is computed: 1542// 1543// M-1 1544// y(k) = sum[X(i)*[cos(2*pi*i*k/M) + j*sin(2*pi*i*k/M)]] 1545// i=0 1546// 1547// The implementations are optimized for speed, not for code size. It uses the 1548// decimation-in-time algorithm with radix-2 butterfly technique. 1549// 1550// Input: 1551// - vector : In pointer to complex vector containing 2^|stages| 1552// real elements interleaved with 2^|stages| imaginary 1553// elements. 1554// [ReImReImReIm....] 1555// The elements are in Q(-scale) domain, see more on Return 1556// Value below. 1557// 1558// - stages : Number of FFT stages. Must be at least 3 and at most 10, 1559// since the table WebRtcSpl_kSinTable1024[] is 1024 1560// elements long. 1561// 1562// - mode : This parameter gives the user to choose how the FFT 1563// should work. 1564// mode==0: Low-complexity and Low-accuracy mode 1565// mode==1: High-complexity and High-accuracy mode 1566// 1567// Output: 1568// - vector : Out pointer to the FFT vector (the same as input). 1569// 1570// Return Value : The scale value that tells the number of left bit shifts 1571// that the elements in the |vector| should be shifted with 1572// in order to get Q0 values, i.e. the physically correct 1573// values. The scale parameter is always 0 or positive, 1574// except if N>1024 (|stages|>10), which returns a scale 1575// value of -1, indicating error. 1576// 1577 1578#if (defined ARM9E_GCC) || (defined ARM_WINM) || (defined ANDROID_AECOPT) 1579// 1580// WebRtcSpl_ComplexIFFT2(...) 1581// 1582// Complex or Real inverse FFT, for ARM processor only 1583// 1584// Computes a 2^|stages|-point FFT on the input vector, which can be or not be 1585// in bit-reversed order. If it is bit-reversed, the original content of the 1586// vector could be overwritten by the output by setting the first two arguments 1587// the same. With X as the input complex vector, y as the output complex vector 1588// and with M = 2^|stages|, the following is computed: 1589// 1590// M-1 1591// y(k) = sum[X(i)*[cos(2*pi*i*k/M) + j*sin(2*pi*i*k/M)]] 1592// i=0 1593// 1594// The implementations are optimized for speed, not for code size. It uses the 1595// decimation-in-time algorithm with radix-2 butterfly technique. 1596// 1597// Arguments: 1598// - in_vector : In pointer to complex vector containing 2^|stages| 1599// real elements interleaved with 2^|stages| imaginary 1600// elements. [ReImReImReIm....] 1601// The elements are in Q(-scale) domain. 1602// - out_vector : Output pointer to vector containing 2^|stages| real 1603// elements interleaved with 2^|stages| imaginary 1604// elements. [ReImReImReIm....] 1605// The output is in the Q0 domain. 1606// - stages : Number of FFT stages. Must be at least 3 and at most 1607// 10. 1608// - mode : Dummy input. 1609// 1610// Return value : The scale parameter is always 0, except if N>1024, 1611// which returns a scale value of -1, indicating error. 1612// 1613#endif 1614 1615// 1616// WebRtcSpl_ComplexFFT(...) 1617// 1618// Complex FFT 1619// 1620// Computes a complex 2^|stages|-point FFT on the input vector, which is in 1621// bit-reversed order. The original content of the vector is destroyed in 1622// the process, since the input is overwritten by the output, normal-ordered, 1623// FFT vector. With x as the input complex vector, Y as the output complex 1624// vector and with M = 2^|stages|, the following is computed: 1625// 1626// M-1 1627// Y(k) = 1/M * sum[x(i)*[cos(2*pi*i*k/M) + j*sin(2*pi*i*k/M)]] 1628// i=0 1629// 1630// The implementations are optimized for speed, not for code size. It uses the 1631// decimation-in-time algorithm with radix-2 butterfly technique. 1632// 1633// This routine prevents overflow by scaling by 2 before each FFT stage. This is 1634// a fixed scaling, for proper normalization - there will be log2(n) passes, so 1635// this results in an overall factor of 1/n, distributed to maximize arithmetic 1636// accuracy. 1637// 1638// Input: 1639// - vector : In pointer to complex vector containing 2^|stages| real 1640// elements interleaved with 2^|stages| imaginary elements. 1641// [ReImReImReIm....] 1642// The output is in the Q0 domain. 1643// 1644// - stages : Number of FFT stages. Must be at least 3 and at most 10, 1645// since the table WebRtcSpl_kSinTable1024[] is 1024 1646// elements long. 1647// 1648// - mode : This parameter gives the user to choose how the FFT 1649// should work. 1650// mode==0: Low-complexity and Low-accuracy mode 1651// mode==1: High-complexity and High-accuracy mode 1652// 1653// Output: 1654// - vector : The output FFT vector is in the Q0 domain. 1655// 1656// Return value : The scale parameter is always 0, except if N>1024, 1657// which returns a scale value of -1, indicating error. 1658// 1659 1660#if (defined ARM9E_GCC) || (defined ARM_WINM) || (defined ANDROID_AECOPT) 1661// 1662// WebRtcSpl_ComplexFFT2(...) 1663// 1664// Complex or Real FFT, for ARM processor only 1665// 1666// Computes a 2^|stages|-point FFT on the input vector, which can be or not be 1667// in bit-reversed order. If it is bit-reversed, the original content of the 1668// vector could be overwritten by the output by setting the first two arguments 1669// the same. With x as the input complex vector, Y as the output complex vector 1670// and with M = 2^|stages|, the following is computed: 1671// 1672// M-1 1673// Y(k) = 1/M * sum[x(i)*[cos(2*pi*i*k/M) + j*sin(2*pi*i*k/M)]] 1674// i=0 1675// 1676// The implementations are optimized for speed, not for code size. It uses the 1677// decimation-in-time algorithm with radix-2 butterfly technique. 1678// 1679// Arguments: 1680// - in_vector : In pointer to complex vector containing 2^|stages| 1681// real elements interleaved with 2^|stages| imaginary 1682// elements. [ReImReImReIm....] 1683// - out_vector : Output pointer to vector containing 2^|stages| real 1684// elements interleaved with 2^|stages| imaginary 1685// elements. [ReImReImReIm....] 1686// The output is in the Q0 domain. 1687// - stages : Number of FFT stages. Must be at least 3 and at most 1688// 10. 1689// - mode : Dummy input 1690// 1691// Return value : The scale parameter is always 0, except if N>1024, 1692// which returns a scale value of -1, indicating error. 1693// 1694#endif 1695 1696// 1697// WebRtcSpl_ComplexBitReverse(...) 1698// 1699// Complex Bit Reverse 1700// 1701// This function bit-reverses the position of elements in the complex input 1702// vector into the output vector. 1703// 1704// If you bit-reverse a linear-order array, you obtain a bit-reversed order 1705// array. If you bit-reverse a bit-reversed order array, you obtain a 1706// linear-order array. 1707// 1708// Input: 1709// - vector : In pointer to complex vector containing 2^|stages| real 1710// elements interleaved with 2^|stages| imaginary elements. 1711// [ReImReImReIm....] 1712// - stages : Number of FFT stages. Must be at least 3 and at most 10, 1713// since the table WebRtcSpl_kSinTable1024[] is 1024 1714// elements long. 1715// 1716// Output: 1717// - vector : Out pointer to complex vector in bit-reversed order. 1718// The input vector is over written. 1719// 1720 1721// 1722// WebRtcSpl_AnalysisQMF(...) 1723// 1724// Splits a 0-2*F Hz signal into two sub bands: 0-F Hz and F-2*F Hz. The 1725// current version has F = 8000, therefore, a super-wideband audio signal is 1726// split to lower-band 0-8 kHz and upper-band 8-16 kHz. 1727// 1728// Input: 1729// - in_data : Wide band speech signal, 320 samples (10 ms) 1730// 1731// Input & Output: 1732// - filter_state1 : Filter state for first All-pass filter 1733// - filter_state2 : Filter state for second All-pass filter 1734// 1735// Output: 1736// - low_band : Lower-band signal 0-8 kHz band, 160 samples (10 ms) 1737// - high_band : Upper-band signal 8-16 kHz band (flipped in frequency 1738// domain), 160 samples (10 ms) 1739// 1740 1741// 1742// WebRtcSpl_SynthesisQMF(...) 1743// 1744// Combines the two sub bands (0-F and F-2*F Hz) into a signal of 0-2*F 1745// Hz, (current version has F = 8000 Hz). So the filter combines lower-band 1746// (0-8 kHz) and upper-band (8-16 kHz) channels to obtain super-wideband 0-16 1747// kHz audio. 1748// 1749// Input: 1750// - low_band : The signal with the 0-8 kHz band, 160 samples (10 ms) 1751// - high_band : The signal with the 8-16 kHz band, 160 samples (10 ms) 1752// 1753// Input & Output: 1754// - filter_state1 : Filter state for first All-pass filter 1755// - filter_state2 : Filter state for second All-pass filter 1756// 1757// Output: 1758// - out_data : Super-wideband speech signal, 0-16 kHz 1759// 1760 1761// WebRtc_Word16 WebRtcSpl_get_version(...) 1762// 1763// This function gives the version string of the Signal Processing Library. 1764// 1765// Input: 1766// - length_in_bytes : The size of Allocated space (in Bytes) where 1767// the version number is written to (in string format). 1768// 1769// Output: 1770// - version : Pointer to a buffer where the version number is written to. 1771// 1772