src/third_party/webrtc/common_audio/signal_processing/signal_processing_unittest.cc

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