1/* 2 * Copyright (c) 2012 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#include "testing/gtest/include/gtest/gtest.h" 12#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h" 13 14static const int kVector16Size = 9; 15static const int16_t vector16[kVector16Size] = {1, -15511, 4323, 1963, 16 WEBRTC_SPL_WORD16_MAX, 0, WEBRTC_SPL_WORD16_MIN + 5, -3333, 345}; 17 18class SplTest : public testing::Test { 19 protected: 20 SplTest() { 21 WebRtcSpl_Init(); 22 } 23 virtual ~SplTest() { 24 } 25}; 26 27TEST_F(SplTest, MacroTest) { 28 // Macros with inputs. 29 int A = 10; 30 int B = 21; 31 int a = -3; 32 int b = WEBRTC_SPL_WORD32_MAX; 33 34 EXPECT_EQ(10, WEBRTC_SPL_MIN(A, B)); 35 EXPECT_EQ(21, WEBRTC_SPL_MAX(A, B)); 36 37 EXPECT_EQ(3, WEBRTC_SPL_ABS_W16(a)); 38 EXPECT_EQ(3, WEBRTC_SPL_ABS_W32(a)); 39 40 EXPECT_EQ(-63, WEBRTC_SPL_MUL(a, B)); 41 EXPECT_EQ(-2147483645, WEBRTC_SPL_MUL(a, b)); 42 EXPECT_EQ(2147483651u, WEBRTC_SPL_UMUL(a, b)); 43 b = WEBRTC_SPL_WORD16_MAX >> 1; 44 EXPECT_EQ(1073627139u, WEBRTC_SPL_UMUL_16_16(a, b)); 45 EXPECT_EQ(4294918147u, WEBRTC_SPL_UMUL_32_16(a, b)); 46 EXPECT_EQ(-49149, WEBRTC_SPL_MUL_16_U16(a, b)); 47 48 a = b; 49 b = -3; 50 51 EXPECT_EQ(-1, WEBRTC_SPL_MUL_16_32_RSFT16(a, b)); 52 EXPECT_EQ(-1, WEBRTC_SPL_MUL_16_32_RSFT15(a, b)); 53 EXPECT_EQ(-3, WEBRTC_SPL_MUL_16_32_RSFT14(a, b)); 54 EXPECT_EQ(-24, WEBRTC_SPL_MUL_16_32_RSFT11(a, b)); 55 56 EXPECT_EQ(-12288, WEBRTC_SPL_MUL_16_16_RSFT(a, b, 2)); 57 EXPECT_EQ(-12287, WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(a, b, 2)); 58 59 EXPECT_EQ(21, WEBRTC_SPL_SAT(a, A, B)); 60 EXPECT_EQ(21, WEBRTC_SPL_SAT(a, B, A)); 61 62 // Shifting with negative numbers allowed 63 int shift_amount = 1; // Workaround compiler warning using variable here. 64 // Positive means left shift 65 EXPECT_EQ(32766, WEBRTC_SPL_SHIFT_W32(a, shift_amount)); 66 67 // Shifting with negative numbers not allowed 68 // We cannot do casting here due to signed/unsigned problem 69 EXPECT_EQ(8191, WEBRTC_SPL_RSHIFT_W16(a, 1)); 70 EXPECT_EQ(32766, WEBRTC_SPL_LSHIFT_W16(a, 1)); 71 EXPECT_EQ(8191, WEBRTC_SPL_RSHIFT_W32(a, 1)); 72 EXPECT_EQ(32766, WEBRTC_SPL_LSHIFT_W32(a, 1)); 73 74 EXPECT_EQ(8191u, WEBRTC_SPL_RSHIFT_U32(a, 1)); 75 EXPECT_EQ(32766u, WEBRTC_SPL_LSHIFT_U32(a, 1)); 76 77 EXPECT_EQ(1470, WEBRTC_SPL_RAND(A)); 78 79 EXPECT_EQ(-49149, WEBRTC_SPL_MUL_16_16(a, b)); 80 EXPECT_EQ(1073676289, WEBRTC_SPL_MUL_16_16(WEBRTC_SPL_WORD16_MAX, 81 WEBRTC_SPL_WORD16_MAX)); 82 EXPECT_EQ(1073709055, WEBRTC_SPL_MUL_16_32_RSFT16(WEBRTC_SPL_WORD16_MAX, 83 WEBRTC_SPL_WORD32_MAX)); 84 EXPECT_EQ(1073741824, WEBRTC_SPL_MUL_16_32_RSFT16(WEBRTC_SPL_WORD16_MIN, 85 WEBRTC_SPL_WORD32_MIN)); 86#ifdef WEBRTC_ARCH_ARM_V7 87 EXPECT_EQ(-1073741824, 88 WEBRTC_SPL_MUL_16_32_RSFT16(WEBRTC_SPL_WORD16_MIN, 89 WEBRTC_SPL_WORD32_MAX)); 90#else 91 EXPECT_EQ(-1073741823, 92 WEBRTC_SPL_MUL_16_32_RSFT16(WEBRTC_SPL_WORD16_MIN, 93 WEBRTC_SPL_WORD32_MAX)); 94#endif 95} 96 97TEST_F(SplTest, InlineTest) { 98 int16_t a16 = 121; 99 int16_t b16 = -17; 100 int32_t a32 = 111121; 101 int32_t b32 = -1711; 102 char bVersion[8]; 103 104 EXPECT_EQ(17, WebRtcSpl_GetSizeInBits(a32)); 105 106 EXPECT_EQ(0, WebRtcSpl_NormW32(0)); 107 EXPECT_EQ(31, WebRtcSpl_NormW32(-1)); 108 EXPECT_EQ(0, WebRtcSpl_NormW32(WEBRTC_SPL_WORD32_MIN)); 109 EXPECT_EQ(14, WebRtcSpl_NormW32(a32)); 110 111 EXPECT_EQ(0, WebRtcSpl_NormW16(0)); 112 EXPECT_EQ(15, WebRtcSpl_NormW16(-1)); 113 EXPECT_EQ(0, WebRtcSpl_NormW16(WEBRTC_SPL_WORD16_MIN)); 114 EXPECT_EQ(4, WebRtcSpl_NormW16(b32)); 115 116 EXPECT_EQ(0, WebRtcSpl_NormU32(0u)); 117 EXPECT_EQ(0, WebRtcSpl_NormU32(0xffffffff)); 118 EXPECT_EQ(15, WebRtcSpl_NormU32(static_cast<uint32_t>(a32))); 119 120 EXPECT_EQ(104, WebRtcSpl_AddSatW16(a16, b16)); 121 EXPECT_EQ(138, WebRtcSpl_SubSatW16(a16, b16)); 122 123 EXPECT_EQ(109410, WebRtcSpl_AddSatW32(a32, b32)); 124 EXPECT_EQ(112832, WebRtcSpl_SubSatW32(a32, b32)); 125 126 a32 = 0x80000000; 127 b32 = 0x80000000; 128 // Cast to signed int to avoid compiler complaint on gtest.h. 129 EXPECT_EQ(static_cast<int>(0x80000000), WebRtcSpl_AddSatW32(a32, b32)); 130 a32 = 0x7fffffff; 131 b32 = 0x7fffffff; 132 EXPECT_EQ(0x7fffffff, WebRtcSpl_AddSatW32(a32, b32)); 133 a32 = 0; 134 b32 = 0x80000000; 135 EXPECT_EQ(0x7fffffff, WebRtcSpl_SubSatW32(a32, b32)); 136 a32 = 0x7fffffff; 137 b32 = 0x80000000; 138 EXPECT_EQ(0x7fffffff, WebRtcSpl_SubSatW32(a32, b32)); 139 a32 = 0x80000000; 140 b32 = 0x7fffffff; 141 EXPECT_EQ(static_cast<int>(0x80000000), WebRtcSpl_SubSatW32(a32, b32)); 142 143 EXPECT_EQ(0, WebRtcSpl_get_version(bVersion, 8)); 144} 145 146TEST_F(SplTest, MathOperationsTest) { 147 int A = 1134567892; 148 int32_t num = 117; 149 int32_t den = -5; 150 uint16_t denU = 5; 151 EXPECT_EQ(33700, WebRtcSpl_Sqrt(A)); 152 EXPECT_EQ(33683, WebRtcSpl_SqrtFloor(A)); 153 154 155 EXPECT_EQ(-91772805, WebRtcSpl_DivResultInQ31(den, num)); 156 EXPECT_EQ(-23, WebRtcSpl_DivW32W16ResW16(num, (int16_t)den)); 157 EXPECT_EQ(-23, WebRtcSpl_DivW32W16(num, (int16_t)den)); 158 EXPECT_EQ(23u, WebRtcSpl_DivU32U16(num, denU)); 159 EXPECT_EQ(0, WebRtcSpl_DivW32HiLow(128, 0, 256)); 160} 161 162TEST_F(SplTest, BasicArrayOperationsTest) { 163 const int kVectorSize = 4; 164 int B[] = {4, 12, 133, 1100}; 165 int16_t b16[kVectorSize]; 166 int32_t b32[kVectorSize]; 167 168 int16_t bTmp16[kVectorSize]; 169 int32_t bTmp32[kVectorSize]; 170 171 WebRtcSpl_MemSetW16(b16, 3, kVectorSize); 172 for (int kk = 0; kk < kVectorSize; ++kk) { 173 EXPECT_EQ(3, b16[kk]); 174 } 175 WebRtcSpl_ZerosArrayW16(b16, kVectorSize); 176 for (int kk = 0; kk < kVectorSize; ++kk) { 177 EXPECT_EQ(0, b16[kk]); 178 } 179 WebRtcSpl_MemSetW32(b32, 3, kVectorSize); 180 for (int kk = 0; kk < kVectorSize; ++kk) { 181 EXPECT_EQ(3, b32[kk]); 182 } 183 WebRtcSpl_ZerosArrayW32(b32, kVectorSize); 184 for (int kk = 0; kk < kVectorSize; ++kk) { 185 EXPECT_EQ(0, b32[kk]); 186 } 187 for (int kk = 0; kk < kVectorSize; ++kk) { 188 bTmp16[kk] = (int16_t)kk; 189 bTmp32[kk] = (int32_t)kk; 190 } 191 WEBRTC_SPL_MEMCPY_W16(b16, bTmp16, kVectorSize); 192 for (int kk = 0; kk < kVectorSize; ++kk) { 193 EXPECT_EQ(b16[kk], bTmp16[kk]); 194 } 195// WEBRTC_SPL_MEMCPY_W32(b32, bTmp32, kVectorSize); 196// for (int kk = 0; kk < kVectorSize; ++kk) { 197// EXPECT_EQ(b32[kk], bTmp32[kk]); 198// } 199 WebRtcSpl_CopyFromEndW16(b16, kVectorSize, 2, bTmp16); 200 for (int kk = 0; kk < 2; ++kk) { 201 EXPECT_EQ(kk+2, bTmp16[kk]); 202 } 203 204 for (int kk = 0; kk < kVectorSize; ++kk) { 205 b32[kk] = B[kk]; 206 b16[kk] = (int16_t)B[kk]; 207 } 208 WebRtcSpl_VectorBitShiftW32ToW16(bTmp16, kVectorSize, b32, 1); 209 for (int kk = 0; kk < kVectorSize; ++kk) { 210 EXPECT_EQ((B[kk]>>1), bTmp16[kk]); 211 } 212 WebRtcSpl_VectorBitShiftW16(bTmp16, kVectorSize, b16, 1); 213 for (int kk = 0; kk < kVectorSize; ++kk) { 214 EXPECT_EQ((B[kk]>>1), bTmp16[kk]); 215 } 216 WebRtcSpl_VectorBitShiftW32(bTmp32, kVectorSize, b32, 1); 217 for (int kk = 0; kk < kVectorSize; ++kk) { 218 EXPECT_EQ((B[kk]>>1), bTmp32[kk]); 219 } 220 221 WebRtcSpl_MemCpyReversedOrder(&bTmp16[3], b16, kVectorSize); 222 for (int kk = 0; kk < kVectorSize; ++kk) { 223 EXPECT_EQ(b16[3-kk], bTmp16[kk]); 224 } 225} 226 227TEST_F(SplTest, ExeptionsHandlingMinMaxOperationsTest) { 228 // Test how the functions handle exceptional cases. 229 const int kVectorSize = 2; 230 int16_t vector16[kVectorSize] = {0}; 231 int32_t vector32[kVectorSize] = {0}; 232 233 EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW16(vector16, 0)); 234 EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW16(NULL, kVectorSize)); 235 EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, WebRtcSpl_MaxValueW16(vector16, 0)); 236 EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, WebRtcSpl_MaxValueW16(NULL, kVectorSize)); 237 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, WebRtcSpl_MinValueW16(vector16, 0)); 238 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, WebRtcSpl_MinValueW16(NULL, kVectorSize)); 239 EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW32(vector32, 0)); 240 EXPECT_EQ(-1, WebRtcSpl_MaxAbsValueW32(NULL, kVectorSize)); 241 EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, WebRtcSpl_MaxValueW32(vector32, 0)); 242 EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, WebRtcSpl_MaxValueW32(NULL, kVectorSize)); 243 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, WebRtcSpl_MinValueW32(vector32, 0)); 244 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, WebRtcSpl_MinValueW32(NULL, kVectorSize)); 245 EXPECT_EQ(-1, WebRtcSpl_MaxAbsIndexW16(vector16, 0)); 246 EXPECT_EQ(-1, WebRtcSpl_MaxAbsIndexW16(NULL, kVectorSize)); 247 EXPECT_EQ(-1, WebRtcSpl_MaxIndexW16(vector16, 0)); 248 EXPECT_EQ(-1, WebRtcSpl_MaxIndexW16(NULL, kVectorSize)); 249 EXPECT_EQ(-1, WebRtcSpl_MaxIndexW32(vector32, 0)); 250 EXPECT_EQ(-1, WebRtcSpl_MaxIndexW32(NULL, kVectorSize)); 251 EXPECT_EQ(-1, WebRtcSpl_MinIndexW16(vector16, 0)); 252 EXPECT_EQ(-1, WebRtcSpl_MinIndexW16(NULL, kVectorSize)); 253 EXPECT_EQ(-1, WebRtcSpl_MinIndexW32(vector32, 0)); 254 EXPECT_EQ(-1, WebRtcSpl_MinIndexW32(NULL, kVectorSize)); 255} 256 257TEST_F(SplTest, MinMaxOperationsTest) { 258 const int kVectorSize = 17; 259 260 // Vectors to test the cases where minimum values have to be caught 261 // outside of the unrolled loops in ARM-Neon. 262 int16_t vector16[kVectorSize] = {-1, 7485, 0, 3333, 263 -18283, 0, 12334, -29871, 988, -3333, 264 345, -456, 222, 999, 888, 8774, WEBRTC_SPL_WORD16_MIN}; 265 int32_t vector32[kVectorSize] = {-1, 0, 283211, 3333, 266 8712345, 0, -3333, 89345, -374585456, 222, 999, 122345334, 267 -12389756, -987329871, 888, -2, WEBRTC_SPL_WORD32_MIN}; 268 269 EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, 270 WebRtcSpl_MinValueW16(vector16, kVectorSize)); 271 EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, 272 WebRtcSpl_MinValueW32(vector32, kVectorSize)); 273 EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW16(vector16, kVectorSize)); 274 EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MinIndexW32(vector32, kVectorSize)); 275 276 // Test the cases where maximum values have to be caught 277 // outside of the unrolled loops in ARM-Neon. 278 vector16[kVectorSize - 1] = WEBRTC_SPL_WORD16_MAX; 279 vector32[kVectorSize - 1] = WEBRTC_SPL_WORD32_MAX; 280 281 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, 282 WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize)); 283 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, 284 WebRtcSpl_MaxValueW16(vector16, kVectorSize)); 285 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, 286 WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize)); 287 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, 288 WebRtcSpl_MaxValueW32(vector32, kVectorSize)); 289 EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize)); 290 EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW16(vector16, kVectorSize)); 291 EXPECT_EQ(kVectorSize - 1, WebRtcSpl_MaxIndexW32(vector32, kVectorSize)); 292 293 // Test the cases where multiple maximum and minimum values are present. 294 vector16[1] = WEBRTC_SPL_WORD16_MAX; 295 vector16[6] = WEBRTC_SPL_WORD16_MIN; 296 vector16[11] = WEBRTC_SPL_WORD16_MIN; 297 vector32[1] = WEBRTC_SPL_WORD32_MAX; 298 vector32[6] = WEBRTC_SPL_WORD32_MIN; 299 vector32[11] = WEBRTC_SPL_WORD32_MIN; 300 301 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, 302 WebRtcSpl_MaxAbsValueW16(vector16, kVectorSize)); 303 EXPECT_EQ(WEBRTC_SPL_WORD16_MAX, 304 WebRtcSpl_MaxValueW16(vector16, kVectorSize)); 305 EXPECT_EQ(WEBRTC_SPL_WORD16_MIN, 306 WebRtcSpl_MinValueW16(vector16, kVectorSize)); 307 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, 308 WebRtcSpl_MaxAbsValueW32(vector32, kVectorSize)); 309 EXPECT_EQ(WEBRTC_SPL_WORD32_MAX, 310 WebRtcSpl_MaxValueW32(vector32, kVectorSize)); 311 EXPECT_EQ(WEBRTC_SPL_WORD32_MIN, 312 WebRtcSpl_MinValueW32(vector32, kVectorSize)); 313 EXPECT_EQ(6, WebRtcSpl_MaxAbsIndexW16(vector16, kVectorSize)); 314 EXPECT_EQ(1, WebRtcSpl_MaxIndexW16(vector16, kVectorSize)); 315 EXPECT_EQ(1, WebRtcSpl_MaxIndexW32(vector32, kVectorSize)); 316 EXPECT_EQ(6, WebRtcSpl_MinIndexW16(vector16, kVectorSize)); 317 EXPECT_EQ(6, WebRtcSpl_MinIndexW32(vector32, kVectorSize)); 318} 319 320TEST_F(SplTest, VectorOperationsTest) { 321 const int kVectorSize = 4; 322 int B[] = {4, 12, 133, 1100}; 323 int16_t a16[kVectorSize]; 324 int16_t b16[kVectorSize]; 325 int16_t bTmp16[kVectorSize]; 326 327 for (int kk = 0; kk < kVectorSize; ++kk) { 328 a16[kk] = B[kk]; 329 b16[kk] = B[kk]; 330 } 331 332 WebRtcSpl_AffineTransformVector(bTmp16, b16, 3, 7, 2, kVectorSize); 333 for (int kk = 0; kk < kVectorSize; ++kk) { 334 EXPECT_EQ((B[kk]*3+7)>>2, bTmp16[kk]); 335 } 336 WebRtcSpl_ScaleAndAddVectorsWithRound(b16, 3, b16, 2, 2, bTmp16, kVectorSize); 337 for (int kk = 0; kk < kVectorSize; ++kk) { 338 EXPECT_EQ((B[kk]*3+B[kk]*2+2)>>2, bTmp16[kk]); 339 } 340 341 WebRtcSpl_AddAffineVectorToVector(bTmp16, b16, 3, 7, 2, kVectorSize); 342 for (int kk = 0; kk < kVectorSize; ++kk) { 343 EXPECT_EQ(((B[kk]*3+B[kk]*2+2)>>2)+((b16[kk]*3+7)>>2), bTmp16[kk]); 344 } 345 346 WebRtcSpl_ScaleVector(b16, bTmp16, 13, kVectorSize, 2); 347 for (int kk = 0; kk < kVectorSize; ++kk) { 348 EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]); 349 } 350 WebRtcSpl_ScaleVectorWithSat(b16, bTmp16, 13, kVectorSize, 2); 351 for (int kk = 0; kk < kVectorSize; ++kk) { 352 EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]); 353 } 354 WebRtcSpl_ScaleAndAddVectors(a16, 13, 2, b16, 7, 2, bTmp16, kVectorSize); 355 for (int kk = 0; kk < kVectorSize; ++kk) { 356 EXPECT_EQ(((a16[kk]*13)>>2)+((b16[kk]*7)>>2), bTmp16[kk]); 357 } 358 359 WebRtcSpl_AddVectorsAndShift(bTmp16, a16, b16, kVectorSize, 2); 360 for (int kk = 0; kk < kVectorSize; ++kk) { 361 EXPECT_EQ(B[kk] >> 1, bTmp16[kk]); 362 } 363 WebRtcSpl_ReverseOrderMultArrayElements(bTmp16, a16, &b16[3], kVectorSize, 2); 364 for (int kk = 0; kk < kVectorSize; ++kk) { 365 EXPECT_EQ((a16[kk]*b16[3-kk])>>2, bTmp16[kk]); 366 } 367 WebRtcSpl_ElementwiseVectorMult(bTmp16, a16, b16, kVectorSize, 6); 368 for (int kk = 0; kk < kVectorSize; ++kk) { 369 EXPECT_EQ((a16[kk]*b16[kk])>>6, bTmp16[kk]); 370 } 371 372 WebRtcSpl_SqrtOfOneMinusXSquared(b16, kVectorSize, bTmp16); 373 for (int kk = 0; kk < kVectorSize - 1; ++kk) { 374 EXPECT_EQ(32767, bTmp16[kk]); 375 } 376 EXPECT_EQ(32749, bTmp16[kVectorSize - 1]); 377 378 EXPECT_EQ(0, WebRtcSpl_GetScalingSquare(b16, kVectorSize, 1)); 379} 380 381TEST_F(SplTest, EstimatorsTest) { 382 const int kVectorSize = 4; 383 int B[] = {4, 12, 133, 1100}; 384 int16_t b16[kVectorSize]; 385 int32_t b32[kVectorSize]; 386 int16_t bTmp16[kVectorSize]; 387 388 for (int kk = 0; kk < kVectorSize; ++kk) { 389 b16[kk] = B[kk]; 390 b32[kk] = B[kk]; 391 } 392 393 EXPECT_EQ(0, WebRtcSpl_LevinsonDurbin(b32, b16, bTmp16, 2)); 394} 395 396TEST_F(SplTest, FilterTest) { 397 const int kVectorSize = 4; 398 const int kFilterOrder = 3; 399 int16_t A[] = {1, 2, 33, 100}; 400 int16_t A5[] = {1, 2, 33, 100, -5}; 401 int16_t B[] = {4, 12, 133, 110}; 402 int16_t data_in[kVectorSize]; 403 int16_t data_out[kVectorSize]; 404 int16_t bTmp16Low[kVectorSize]; 405 int16_t bState[kVectorSize]; 406 int16_t bStateLow[kVectorSize]; 407 408 WebRtcSpl_ZerosArrayW16(bState, kVectorSize); 409 WebRtcSpl_ZerosArrayW16(bStateLow, kVectorSize); 410 411 for (int kk = 0; kk < kVectorSize; ++kk) { 412 data_in[kk] = A[kk]; 413 data_out[kk] = 0; 414 } 415 416 // MA filters. 417 // Note that the input data has |kFilterOrder| states before the actual 418 // data (one sample). 419 WebRtcSpl_FilterMAFastQ12(&data_in[kFilterOrder], data_out, B, 420 kFilterOrder + 1, 1); 421 EXPECT_EQ(0, data_out[0]); 422 // AR filters. 423 // Note that the output data has |kFilterOrder| states before the actual 424 // data (one sample). 425 WebRtcSpl_FilterARFastQ12(data_in, &data_out[kFilterOrder], A, 426 kFilterOrder + 1, 1); 427 EXPECT_EQ(0, data_out[kFilterOrder]); 428 429 EXPECT_EQ(kVectorSize, WebRtcSpl_FilterAR(A5, 430 5, 431 data_in, 432 kVectorSize, 433 bState, 434 kVectorSize, 435 bStateLow, 436 kVectorSize, 437 data_out, 438 bTmp16Low, 439 kVectorSize)); 440} 441 442TEST_F(SplTest, RandTest) { 443 const int kVectorSize = 4; 444 int16_t BU[] = {3653, 12446, 8525, 30691}; 445 int16_t b16[kVectorSize]; 446 uint32_t bSeed = 100000; 447 448 EXPECT_EQ(7086, WebRtcSpl_RandU(&bSeed)); 449 EXPECT_EQ(31565, WebRtcSpl_RandU(&bSeed)); 450 EXPECT_EQ(-9786, WebRtcSpl_RandN(&bSeed)); 451 EXPECT_EQ(kVectorSize, WebRtcSpl_RandUArray(b16, kVectorSize, &bSeed)); 452 for (int kk = 0; kk < kVectorSize; ++kk) { 453 EXPECT_EQ(BU[kk], b16[kk]); 454 } 455} 456 457TEST_F(SplTest, DotProductWithScaleTest) { 458 EXPECT_EQ(605362796, WebRtcSpl_DotProductWithScale(vector16, 459 vector16, kVector16Size, 2)); 460} 461 462TEST_F(SplTest, CrossCorrelationTest) { 463 // Note the function arguments relation specificed by API. 464 const int kCrossCorrelationDimension = 3; 465 const int kShift = 2; 466 const int kStep = 1; 467 const int kSeqDimension = 6; 468 469 const int16_t kVector16[kVector16Size] = {1, 4323, 1963, 470 WEBRTC_SPL_WORD16_MAX, WEBRTC_SPL_WORD16_MIN + 5, -3333, -876, 8483, 142}; 471 int32_t vector32[kCrossCorrelationDimension] = {0}; 472 473 WebRtcSpl_CrossCorrelation(vector32, vector16, kVector16, kSeqDimension, 474 kCrossCorrelationDimension, kShift, kStep); 475 476 // WebRtcSpl_CrossCorrelationC() and WebRtcSpl_CrossCorrelationNeon() 477 // are not bit-exact. 478 const int32_t kExpected[kCrossCorrelationDimension] = 479 {-266947903, -15579555, -171282001}; 480 const int32_t* expected = kExpected; 481#if !defined(MIPS32_LE) 482 const int32_t kExpectedNeon[kCrossCorrelationDimension] = 483 {-266947901, -15579553, -171281999}; 484 if (WebRtcSpl_CrossCorrelation != WebRtcSpl_CrossCorrelationC) { 485 expected = kExpectedNeon; 486 } 487#endif 488 for (int i = 0; i < kCrossCorrelationDimension; ++i) { 489 EXPECT_EQ(expected[i], vector32[i]); 490 } 491} 492 493TEST_F(SplTest, AutoCorrelationTest) { 494 int scale = 0; 495 int32_t vector32[kVector16Size]; 496 const int32_t expected[kVector16Size] = {302681398, 14223410, -121705063, 497 -85221647, -17104971, 61806945, 6644603, -669329, 43}; 498 499 EXPECT_EQ(-1, WebRtcSpl_AutoCorrelation(vector16, 500 kVector16Size, kVector16Size + 1, vector32, &scale)); 501 EXPECT_EQ(kVector16Size, WebRtcSpl_AutoCorrelation(vector16, 502 kVector16Size, kVector16Size - 1, vector32, &scale)); 503 EXPECT_EQ(3, scale); 504 for (int i = 0; i < kVector16Size; ++i) { 505 EXPECT_EQ(expected[i], vector32[i]); 506 } 507} 508 509TEST_F(SplTest, SignalProcessingTest) { 510 const int kVectorSize = 4; 511 int A[] = {1, 2, 33, 100}; 512 const int16_t kHanning[4] = { 2399, 8192, 13985, 16384 }; 513 int16_t b16[kVectorSize]; 514 515 int16_t bTmp16[kVectorSize]; 516 517 int bScale = 0; 518 519 for (int kk = 0; kk < kVectorSize; ++kk) { 520 b16[kk] = A[kk]; 521 } 522 523 // TODO(bjornv): Activate the Reflection Coefficient tests when refactoring. 524// WebRtcSpl_ReflCoefToLpc(b16, kVectorSize, bTmp16); 525//// for (int kk = 0; kk < kVectorSize; ++kk) { 526//// EXPECT_EQ(aTmp16[kk], bTmp16[kk]); 527//// } 528// WebRtcSpl_LpcToReflCoef(bTmp16, kVectorSize, b16); 529//// for (int kk = 0; kk < kVectorSize; ++kk) { 530//// EXPECT_EQ(a16[kk], b16[kk]); 531//// } 532// WebRtcSpl_AutoCorrToReflCoef(b32, kVectorSize, bTmp16); 533//// for (int kk = 0; kk < kVectorSize; ++kk) { 534//// EXPECT_EQ(aTmp16[kk], bTmp16[kk]); 535//// } 536 537 WebRtcSpl_GetHanningWindow(bTmp16, kVectorSize); 538 for (int kk = 0; kk < kVectorSize; ++kk) { 539 EXPECT_EQ(kHanning[kk], bTmp16[kk]); 540 } 541 542 for (int kk = 0; kk < kVectorSize; ++kk) { 543 b16[kk] = A[kk]; 544 } 545 EXPECT_EQ(11094 , WebRtcSpl_Energy(b16, kVectorSize, &bScale)); 546 EXPECT_EQ(0, bScale); 547} 548 549TEST_F(SplTest, FFTTest) { 550 int16_t B[] = {1, 2, 33, 100, 551 2, 3, 34, 101, 552 3, 4, 35, 102, 553 4, 5, 36, 103}; 554 555 EXPECT_EQ(0, WebRtcSpl_ComplexFFT(B, 3, 1)); 556// for (int kk = 0; kk < 16; ++kk) { 557// EXPECT_EQ(A[kk], B[kk]); 558// } 559 EXPECT_EQ(0, WebRtcSpl_ComplexIFFT(B, 3, 1)); 560// for (int kk = 0; kk < 16; ++kk) { 561// EXPECT_EQ(A[kk], B[kk]); 562// } 563 WebRtcSpl_ComplexBitReverse(B, 3); 564 for (int kk = 0; kk < 16; ++kk) { 565 //EXPECT_EQ(A[kk], B[kk]); 566 } 567} 568 569TEST_F(SplTest, Resample48WithSaturationTest) { 570 // The test resamples 3*kBlockSize number of samples to 2*kBlockSize number 571 // of samples. 572 const int kBlockSize = 16; 573 574 // Saturated input vector of 48 samples. 575 const int32_t kVectorSaturated[3 * kBlockSize + 7] = { 576 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, 577 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, 578 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, 579 32767, 32767, 32767, 32767, 32767, 32767, 32767, 32767, 580 32767, 32767, 32767, 32767, 32767, 32767, 32767, 32767, 581 32767, 32767, 32767, 32767, 32767, 32767, 32767, 32767, 582 32767, 32767, 32767, 32767, 32767, 32767, 32767 583 }; 584 585 // All values in |out_vector| should be |kRefValue32kHz|. 586 const int32_t kRefValue32kHz1 = -1077493760; 587 const int32_t kRefValue32kHz2 = 1077493645; 588 589 // After bit shift with saturation, |out_vector_w16| is saturated. 590 591 const int16_t kRefValue16kHz1 = -32768; 592 const int16_t kRefValue16kHz2 = 32767; 593 // Vector for storing output. 594 int32_t out_vector[2 * kBlockSize]; 595 int16_t out_vector_w16[2 * kBlockSize]; 596 597 WebRtcSpl_Resample48khzTo32khz(kVectorSaturated, out_vector, kBlockSize); 598 WebRtcSpl_VectorBitShiftW32ToW16(out_vector_w16, 2 * kBlockSize, out_vector, 599 15); 600 601 // Comparing output values against references. The values at position 602 // 12-15 are skipped to account for the filter lag. 603 for (int i = 0; i < 12; ++i) { 604 EXPECT_EQ(kRefValue32kHz1, out_vector[i]); 605 EXPECT_EQ(kRefValue16kHz1, out_vector_w16[i]); 606 } 607 for (int i = 16; i < 2 * kBlockSize; ++i) { 608 EXPECT_EQ(kRefValue32kHz2, out_vector[i]); 609 EXPECT_EQ(kRefValue16kHz2, out_vector_w16[i]); 610 } 611} 612