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