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