1/*
2 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "signal_processing_library.h"
12#include "gtest/gtest.h"
13
14class SplTest : public testing::Test {
15 protected:
16  virtual ~SplTest() {
17  }
18  void SetUp() {
19  }
20  void TearDown() {
21  }
22};
23
24TEST_F(SplTest, MacroTest) {
25    // Macros with inputs.
26    int A = 10;
27    int B = 21;
28    int a = -3;
29    int b = WEBRTC_SPL_WORD32_MAX;
30    int nr = 2;
31    int d_ptr2 = 0;
32
33    EXPECT_EQ(10, WEBRTC_SPL_MIN(A, B));
34    EXPECT_EQ(21, WEBRTC_SPL_MAX(A, B));
35
36    EXPECT_EQ(3, WEBRTC_SPL_ABS_W16(a));
37    EXPECT_EQ(3, WEBRTC_SPL_ABS_W32(a));
38    EXPECT_EQ(0, WEBRTC_SPL_GET_BYTE(&B, nr));
39    WEBRTC_SPL_SET_BYTE(&d_ptr2, 1, nr);
40    EXPECT_EQ(65536, d_ptr2);
41
42    EXPECT_EQ(-63, WEBRTC_SPL_MUL(a, B));
43    EXPECT_EQ(-2147483645, WEBRTC_SPL_MUL(a, b));
44    EXPECT_EQ(-2147483645u, WEBRTC_SPL_UMUL(a, b));
45    b = WEBRTC_SPL_WORD16_MAX >> 1;
46    EXPECT_EQ(65535u, WEBRTC_SPL_UMUL_RSFT16(a, b));
47    EXPECT_EQ(1073627139u, WEBRTC_SPL_UMUL_16_16(a, b));
48    EXPECT_EQ(16382u, WEBRTC_SPL_UMUL_16_16_RSFT16(a, b));
49    EXPECT_EQ(-49149u, WEBRTC_SPL_UMUL_32_16(a, b));
50    EXPECT_EQ(65535u, WEBRTC_SPL_UMUL_32_16_RSFT16(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    int a32 = WEBRTC_SPL_WORD32_MAX;
64    int a32a = (WEBRTC_SPL_WORD32_MAX >> 16);
65    int a32b = (WEBRTC_SPL_WORD32_MAX & 0x0000ffff);
66    EXPECT_EQ(5, WEBRTC_SPL_MUL_32_32_RSFT32(a32a, a32b, A));
67    EXPECT_EQ(5, WEBRTC_SPL_MUL_32_32_RSFT32BI(a32, A));
68
69    EXPECT_EQ(-49149, WEBRTC_SPL_MUL_16_16(a, b));
70    EXPECT_EQ(-12288, WEBRTC_SPL_MUL_16_16_RSFT(a, b, 2));
71
72    EXPECT_EQ(-12287, WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(a, b, 2));
73    EXPECT_EQ(-1, WEBRTC_SPL_MUL_16_16_RSFT_WITH_FIXROUND(a, b));
74
75    EXPECT_EQ(16380, WEBRTC_SPL_ADD_SAT_W32(a, b));
76    EXPECT_EQ(21, WEBRTC_SPL_SAT(a, A, B));
77    EXPECT_EQ(21, WEBRTC_SPL_SAT(a, B, A));
78    EXPECT_EQ(-49149, WEBRTC_SPL_MUL_32_16(a, b));
79
80    EXPECT_EQ(16386, WEBRTC_SPL_SUB_SAT_W32(a, b));
81    EXPECT_EQ(16380, WEBRTC_SPL_ADD_SAT_W16(a, b));
82    EXPECT_EQ(16386, WEBRTC_SPL_SUB_SAT_W16(a, b));
83
84    EXPECT_TRUE(WEBRTC_SPL_IS_NEG(b));
85
86    // Shifting with negative numbers allowed
87    int shift_amount = 1;  // Workaround compiler warning using variable here.
88    // Positive means left shift
89    EXPECT_EQ(32766, WEBRTC_SPL_SHIFT_W16(a, shift_amount));
90    EXPECT_EQ(32766, WEBRTC_SPL_SHIFT_W32(a, shift_amount));
91
92    // Shifting with negative numbers not allowed
93    // We cannot do casting here due to signed/unsigned problem
94    EXPECT_EQ(8191, WEBRTC_SPL_RSHIFT_W16(a, 1));
95    EXPECT_EQ(32766, WEBRTC_SPL_LSHIFT_W16(a, 1));
96    EXPECT_EQ(8191, WEBRTC_SPL_RSHIFT_W32(a, 1));
97    EXPECT_EQ(32766, WEBRTC_SPL_LSHIFT_W32(a, 1));
98
99    EXPECT_EQ(8191, WEBRTC_SPL_RSHIFT_U16(a, 1));
100    EXPECT_EQ(32766, WEBRTC_SPL_LSHIFT_U16(a, 1));
101    EXPECT_EQ(8191u, WEBRTC_SPL_RSHIFT_U32(a, 1));
102    EXPECT_EQ(32766u, WEBRTC_SPL_LSHIFT_U32(a, 1));
103
104    EXPECT_EQ(1470, WEBRTC_SPL_RAND(A));
105}
106
107TEST_F(SplTest, InlineTest) {
108    WebRtc_Word16 a = 121;
109    WebRtc_Word16 b = -17;
110    WebRtc_Word32 A = 111121;
111    WebRtc_Word32 B = -1711;
112    char bVersion[8];
113
114    EXPECT_EQ(104, WebRtcSpl_AddSatW16(a, b));
115    EXPECT_EQ(138, WebRtcSpl_SubSatW16(a, b));
116
117    EXPECT_EQ(109410, WebRtcSpl_AddSatW32(A, B));
118    EXPECT_EQ(112832, WebRtcSpl_SubSatW32(A, B));
119
120    EXPECT_EQ(17, WebRtcSpl_GetSizeInBits(A));
121    EXPECT_EQ(14, WebRtcSpl_NormW32(A));
122    EXPECT_EQ(4, WebRtcSpl_NormW16(B));
123    EXPECT_EQ(15, WebRtcSpl_NormU32(A));
124
125    EXPECT_EQ(0, WebRtcSpl_get_version(bVersion, 8));
126}
127
128TEST_F(SplTest, MathOperationsTest) {
129    int A = 117;
130    WebRtc_Word32 num = 117;
131    WebRtc_Word32 den = -5;
132    WebRtc_UWord16 denU = 5;
133    EXPECT_EQ(10, WebRtcSpl_Sqrt(A));
134    EXPECT_EQ(10, WebRtcSpl_SqrtFloor(A));
135
136
137    EXPECT_EQ(-91772805, WebRtcSpl_DivResultInQ31(den, num));
138    EXPECT_EQ(-23, WebRtcSpl_DivW32W16ResW16(num, (WebRtc_Word16)den));
139    EXPECT_EQ(-23, WebRtcSpl_DivW32W16(num, (WebRtc_Word16)den));
140    EXPECT_EQ(23u, WebRtcSpl_DivU32U16(num, denU));
141    EXPECT_EQ(0, WebRtcSpl_DivW32HiLow(128, 0, 256));
142}
143
144TEST_F(SplTest, BasicArrayOperationsTest) {
145    const int kVectorSize = 4;
146    int B[] = {4, 12, 133, 1100};
147    WebRtc_UWord8 b8[kVectorSize];
148    WebRtc_Word16 b16[kVectorSize];
149    WebRtc_Word32 b32[kVectorSize];
150
151    WebRtc_UWord8 bTmp8[kVectorSize];
152    WebRtc_Word16 bTmp16[kVectorSize];
153    WebRtc_Word32 bTmp32[kVectorSize];
154
155    WebRtcSpl_MemSetW16(b16, 3, kVectorSize);
156    for (int kk = 0; kk < kVectorSize; ++kk) {
157        EXPECT_EQ(3, b16[kk]);
158    }
159    EXPECT_EQ(kVectorSize, WebRtcSpl_ZerosArrayW16(b16, kVectorSize));
160    for (int kk = 0; kk < kVectorSize; ++kk) {
161        EXPECT_EQ(0, b16[kk]);
162    }
163    EXPECT_EQ(kVectorSize, WebRtcSpl_OnesArrayW16(b16, kVectorSize));
164    for (int kk = 0; kk < kVectorSize; ++kk) {
165        EXPECT_EQ(1, b16[kk]);
166    }
167    WebRtcSpl_MemSetW32(b32, 3, kVectorSize);
168    for (int kk = 0; kk < kVectorSize; ++kk) {
169        EXPECT_EQ(3, b32[kk]);
170    }
171    EXPECT_EQ(kVectorSize, WebRtcSpl_ZerosArrayW32(b32, kVectorSize));
172    for (int kk = 0; kk < kVectorSize; ++kk) {
173        EXPECT_EQ(0, b32[kk]);
174    }
175    EXPECT_EQ(kVectorSize, WebRtcSpl_OnesArrayW32(b32, kVectorSize));
176    for (int kk = 0; kk < kVectorSize; ++kk) {
177        EXPECT_EQ(1, b32[kk]);
178    }
179    for (int kk = 0; kk < kVectorSize; ++kk) {
180        bTmp8[kk] = (WebRtc_Word8)kk;
181        bTmp16[kk] = (WebRtc_Word16)kk;
182        bTmp32[kk] = (WebRtc_Word32)kk;
183    }
184    WEBRTC_SPL_MEMCPY_W8(b8, bTmp8, kVectorSize);
185    for (int kk = 0; kk < kVectorSize; ++kk) {
186        EXPECT_EQ(b8[kk], bTmp8[kk]);
187    }
188    WEBRTC_SPL_MEMCPY_W16(b16, bTmp16, kVectorSize);
189    for (int kk = 0; kk < kVectorSize; ++kk) {
190        EXPECT_EQ(b16[kk], bTmp16[kk]);
191    }
192//    WEBRTC_SPL_MEMCPY_W32(b32, bTmp32, kVectorSize);
193//    for (int kk = 0; kk < kVectorSize; ++kk) {
194//        EXPECT_EQ(b32[kk], bTmp32[kk]);
195//    }
196    EXPECT_EQ(2, WebRtcSpl_CopyFromEndW16(b16, kVectorSize, 2, bTmp16));
197    for (int kk = 0; kk < 2; ++kk) {
198        EXPECT_EQ(kk+2, bTmp16[kk]);
199    }
200
201    for (int kk = 0; kk < kVectorSize; ++kk) {
202        b32[kk] = B[kk];
203        b16[kk] = (WebRtc_Word16)B[kk];
204    }
205    WebRtcSpl_VectorBitShiftW32ToW16(bTmp16, kVectorSize, b32, 1);
206    for (int kk = 0; kk < kVectorSize; ++kk) {
207        EXPECT_EQ((B[kk]>>1), bTmp16[kk]);
208    }
209    WebRtcSpl_VectorBitShiftW16(bTmp16, kVectorSize, b16, 1);
210    for (int kk = 0; kk < kVectorSize; ++kk) {
211        EXPECT_EQ((B[kk]>>1), bTmp16[kk]);
212    }
213    WebRtcSpl_VectorBitShiftW32(bTmp32, kVectorSize, b32, 1);
214    for (int kk = 0; kk < kVectorSize; ++kk) {
215        EXPECT_EQ((B[kk]>>1), bTmp32[kk]);
216    }
217
218    WebRtcSpl_MemCpyReversedOrder(&bTmp16[3], b16, kVectorSize);
219    for (int kk = 0; kk < kVectorSize; ++kk) {
220        EXPECT_EQ(b16[3-kk], bTmp16[kk]);
221    }
222}
223
224TEST_F(SplTest, MinMaxOperationsTest) {
225    const int kVectorSize = 4;
226    int B[] = {4, 12, 133, -1100};
227    WebRtc_Word16 b16[kVectorSize];
228    WebRtc_Word32 b32[kVectorSize];
229
230    for (int kk = 0; kk < kVectorSize; ++kk) {
231        b16[kk] = B[kk];
232        b32[kk] = B[kk];
233    }
234
235    EXPECT_EQ(1100, WebRtcSpl_MaxAbsValueW16(b16, kVectorSize));
236    EXPECT_EQ(1100, WebRtcSpl_MaxAbsValueW32(b32, kVectorSize));
237    EXPECT_EQ(133, WebRtcSpl_MaxValueW16(b16, kVectorSize));
238    EXPECT_EQ(133, WebRtcSpl_MaxValueW32(b32, kVectorSize));
239    EXPECT_EQ(3, WebRtcSpl_MaxAbsIndexW16(b16, kVectorSize));
240    EXPECT_EQ(2, WebRtcSpl_MaxIndexW16(b16, kVectorSize));
241    EXPECT_EQ(2, WebRtcSpl_MaxIndexW32(b32, kVectorSize));
242
243    EXPECT_EQ(-1100, WebRtcSpl_MinValueW16(b16, kVectorSize));
244    EXPECT_EQ(-1100, WebRtcSpl_MinValueW32(b32, kVectorSize));
245    EXPECT_EQ(3, WebRtcSpl_MinIndexW16(b16, kVectorSize));
246    EXPECT_EQ(3, WebRtcSpl_MinIndexW32(b32, kVectorSize));
247
248    EXPECT_EQ(0, WebRtcSpl_GetScalingSquare(b16, kVectorSize, 1));
249}
250
251TEST_F(SplTest, VectorOperationsTest) {
252    const int kVectorSize = 4;
253    int B[] = {4, 12, 133, 1100};
254    WebRtc_Word16 a16[kVectorSize];
255    WebRtc_Word16 b16[kVectorSize];
256    WebRtc_Word32 b32[kVectorSize];
257    WebRtc_Word16 bTmp16[kVectorSize];
258
259    for (int kk = 0; kk < kVectorSize; ++kk) {
260        a16[kk] = B[kk];
261        b16[kk] = B[kk];
262    }
263
264    WebRtcSpl_AffineTransformVector(bTmp16, b16, 3, 7, 2, kVectorSize);
265    for (int kk = 0; kk < kVectorSize; ++kk) {
266        EXPECT_EQ((B[kk]*3+7)>>2, bTmp16[kk]);
267    }
268    WebRtcSpl_ScaleAndAddVectorsWithRound(b16, 3, b16, 2, 2, bTmp16, kVectorSize);
269    for (int kk = 0; kk < kVectorSize; ++kk) {
270        EXPECT_EQ((B[kk]*3+B[kk]*2+2)>>2, bTmp16[kk]);
271    }
272
273    WebRtcSpl_AddAffineVectorToVector(bTmp16, b16, 3, 7, 2, kVectorSize);
274    for (int kk = 0; kk < kVectorSize; ++kk) {
275        EXPECT_EQ(((B[kk]*3+B[kk]*2+2)>>2)+((b16[kk]*3+7)>>2), bTmp16[kk]);
276    }
277
278    WebRtcSpl_CrossCorrelation(b32, b16, bTmp16, kVectorSize, 2, 2, 0);
279    for (int kk = 0; kk < 2; ++kk) {
280        EXPECT_EQ(614236, b32[kk]);
281    }
282//    EXPECT_EQ(, WebRtcSpl_DotProduct(b16, bTmp16, 4));
283    EXPECT_EQ(306962, WebRtcSpl_DotProductWithScale(b16, b16, kVectorSize, 2));
284
285    WebRtcSpl_ScaleVector(b16, bTmp16, 13, kVectorSize, 2);
286    for (int kk = 0; kk < kVectorSize; ++kk) {
287        EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]);
288    }
289    WebRtcSpl_ScaleVectorWithSat(b16, bTmp16, 13, kVectorSize, 2);
290    for (int kk = 0; kk < kVectorSize; ++kk) {
291        EXPECT_EQ((b16[kk]*13)>>2, bTmp16[kk]);
292    }
293    WebRtcSpl_ScaleAndAddVectors(a16, 13, 2, b16, 7, 2, bTmp16, kVectorSize);
294    for (int kk = 0; kk < kVectorSize; ++kk) {
295        EXPECT_EQ(((a16[kk]*13)>>2)+((b16[kk]*7)>>2), bTmp16[kk]);
296    }
297
298    WebRtcSpl_AddVectorsAndShift(bTmp16, a16, b16, kVectorSize, 2);
299    for (int kk = 0; kk < kVectorSize; ++kk) {
300        EXPECT_EQ(B[kk] >> 1, bTmp16[kk]);
301    }
302    WebRtcSpl_ReverseOrderMultArrayElements(bTmp16, a16, &b16[3], kVectorSize, 2);
303    for (int kk = 0; kk < kVectorSize; ++kk) {
304        EXPECT_EQ((a16[kk]*b16[3-kk])>>2, bTmp16[kk]);
305    }
306    WebRtcSpl_ElementwiseVectorMult(bTmp16, a16, b16, kVectorSize, 6);
307    for (int kk = 0; kk < kVectorSize; ++kk) {
308        EXPECT_EQ((a16[kk]*b16[kk])>>6, bTmp16[kk]);
309    }
310
311    WebRtcSpl_SqrtOfOneMinusXSquared(b16, kVectorSize, bTmp16);
312    for (int kk = 0; kk < kVectorSize - 1; ++kk) {
313        EXPECT_EQ(32767, bTmp16[kk]);
314    }
315    EXPECT_EQ(32749, bTmp16[kVectorSize - 1]);
316}
317
318TEST_F(SplTest, EstimatorsTest) {
319    const int kVectorSize = 4;
320    int B[] = {4, 12, 133, 1100};
321    WebRtc_Word16 b16[kVectorSize];
322    WebRtc_Word32 b32[kVectorSize];
323    WebRtc_Word16 bTmp16[kVectorSize];
324
325    for (int kk = 0; kk < kVectorSize; ++kk) {
326        b16[kk] = B[kk];
327        b32[kk] = B[kk];
328    }
329
330    EXPECT_EQ(0, WebRtcSpl_LevinsonDurbin(b32, b16, bTmp16, 2));
331}
332
333TEST_F(SplTest, FilterTest) {
334    const int kVectorSize = 4;
335    WebRtc_Word16 A[] = {1, 2, 33, 100};
336    WebRtc_Word16 A5[] = {1, 2, 33, 100, -5};
337    WebRtc_Word16 B[] = {4, 12, 133, 110};
338    WebRtc_Word16 b16[kVectorSize];
339    WebRtc_Word16 bTmp16[kVectorSize];
340    WebRtc_Word16 bTmp16Low[kVectorSize];
341    WebRtc_Word16 bState[kVectorSize];
342    WebRtc_Word16 bStateLow[kVectorSize];
343
344    WebRtcSpl_ZerosArrayW16(bState, kVectorSize);
345    WebRtcSpl_ZerosArrayW16(bStateLow, kVectorSize);
346
347    for (int kk = 0; kk < kVectorSize; ++kk) {
348        b16[kk] = A[kk];
349    }
350
351    // MA filters
352    WebRtcSpl_FilterMAFastQ12(b16, bTmp16, B, kVectorSize, kVectorSize);
353    for (int kk = 0; kk < kVectorSize; ++kk) {
354        //EXPECT_EQ(aTmp16[kk], bTmp16[kk]);
355    }
356    // AR filters
357    WebRtcSpl_FilterARFastQ12(b16, bTmp16, A, kVectorSize, kVectorSize);
358    for (int kk = 0; kk < kVectorSize; ++kk) {
359//        EXPECT_EQ(aTmp16[kk], bTmp16[kk]);
360    }
361    EXPECT_EQ(kVectorSize, WebRtcSpl_FilterAR(A5,
362                                              5,
363                                              b16,
364                                              kVectorSize,
365                                              bState,
366                                              kVectorSize,
367                                              bStateLow,
368                                              kVectorSize,
369                                              bTmp16,
370                                              bTmp16Low,
371                                              kVectorSize));
372}
373
374TEST_F(SplTest, RandTest) {
375    const int kVectorSize = 4;
376    WebRtc_Word16 BU[] = {3653, 12446, 8525, 30691};
377    WebRtc_Word16 b16[kVectorSize];
378    WebRtc_UWord32 bSeed = 100000;
379
380    EXPECT_EQ(464449057u, WebRtcSpl_IncreaseSeed(&bSeed));
381    EXPECT_EQ(31565, WebRtcSpl_RandU(&bSeed));
382    EXPECT_EQ(-9786, WebRtcSpl_RandN(&bSeed));
383    EXPECT_EQ(kVectorSize, WebRtcSpl_RandUArray(b16, kVectorSize, &bSeed));
384    for (int kk = 0; kk < kVectorSize; ++kk) {
385        EXPECT_EQ(BU[kk], b16[kk]);
386    }
387}
388
389TEST_F(SplTest, SignalProcessingTest) {
390    const int kVectorSize = 4;
391    int A[] = {1, 2, 33, 100};
392    WebRtc_Word16 b16[kVectorSize];
393    WebRtc_Word32 b32[kVectorSize];
394
395    WebRtc_Word16 bTmp16[kVectorSize];
396    WebRtc_Word32 bTmp32[kVectorSize];
397
398    int bScale = 0;
399
400    for (int kk = 0; kk < kVectorSize; ++kk) {
401        b16[kk] = A[kk];
402        b32[kk] = A[kk];
403    }
404
405    EXPECT_EQ(2, WebRtcSpl_AutoCorrelation(b16, kVectorSize, 1, bTmp32, &bScale));
406    WebRtcSpl_ReflCoefToLpc(b16, kVectorSize, bTmp16);
407//    for (int kk = 0; kk < kVectorSize; ++kk) {
408//        EXPECT_EQ(aTmp16[kk], bTmp16[kk]);
409//    }
410    WebRtcSpl_LpcToReflCoef(bTmp16, kVectorSize, b16);
411//    for (int kk = 0; kk < kVectorSize; ++kk) {
412//        EXPECT_EQ(a16[kk], b16[kk]);
413//    }
414    WebRtcSpl_AutoCorrToReflCoef(b32, kVectorSize, bTmp16);
415//    for (int kk = 0; kk < kVectorSize; ++kk) {
416//        EXPECT_EQ(aTmp16[kk], bTmp16[kk]);
417//    }
418    WebRtcSpl_GetHanningWindow(bTmp16, kVectorSize);
419//    for (int kk = 0; kk < kVectorSize; ++kk) {
420//        EXPECT_EQ(aTmp16[kk], bTmp16[kk]);
421//    }
422
423    for (int kk = 0; kk < kVectorSize; ++kk) {
424        b16[kk] = A[kk];
425    }
426    EXPECT_EQ(11094 , WebRtcSpl_Energy(b16, kVectorSize, &bScale));
427    EXPECT_EQ(0, bScale);
428}
429
430TEST_F(SplTest, FFTTest) {
431    WebRtc_Word16 B[] = {1, 2, 33, 100,
432            2, 3, 34, 101,
433            3, 4, 35, 102,
434            4, 5, 36, 103};
435
436    EXPECT_EQ(0, WebRtcSpl_ComplexFFT(B, 3, 1));
437//    for (int kk = 0; kk < 16; ++kk) {
438//        EXPECT_EQ(A[kk], B[kk]);
439//    }
440    EXPECT_EQ(0, WebRtcSpl_ComplexIFFT(B, 3, 1));
441//    for (int kk = 0; kk < 16; ++kk) {
442//        EXPECT_EQ(A[kk], B[kk]);
443//    }
444    WebRtcSpl_ComplexBitReverse(B, 3);
445    for (int kk = 0; kk < 16; ++kk) {
446        //EXPECT_EQ(A[kk], B[kk]);
447    }
448}
449