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
14 class SplTest : public testing::Test {
15 protected:
~SplTest()16 virtual ~SplTest() {
17 }
SetUp()18 void SetUp() {
19 }
TearDown()20 void TearDown() {
21 }
22 };
23
TEST_F(SplTest,MacroTest)24 TEST_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
TEST_F(SplTest,InlineTest)107 TEST_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
TEST_F(SplTest,MathOperationsTest)128 TEST_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
TEST_F(SplTest,BasicArrayOperationsTest)144 TEST_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
TEST_F(SplTest,MinMaxOperationsTest)224 TEST_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
TEST_F(SplTest,VectorOperationsTest)251 TEST_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
TEST_F(SplTest,EstimatorsTest)318 TEST_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
TEST_F(SplTest,FilterTest)333 TEST_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
TEST_F(SplTest,RandTest)374 TEST_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
TEST_F(SplTest,SignalProcessingTest)389 TEST_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
TEST_F(SplTest,FFTTest)430 TEST_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