1 #include "BIQUADF16.h"
2 #include <stdio.h>
3 #include "Error.h"
4 
5 #define SNR_THRESHOLD 27
6 
7 /*
8 
9 Reference patterns are generated with
10 a double precision computation.
11 
12 */
13 #define REL_ERROR (5.0e-2)
14 #define ABS_ERROR (1.0e-1)
15 
test_biquad_cascade_df1_ref()16     void BIQUADF16::test_biquad_cascade_df1_ref()
17     {
18 
19 
20         float16_t *statep = state.ptr();
21         float16_t *debugstatep = debugstate.ptr();
22 
23         const float16_t *coefsp = coefs.ptr();
24 
25         const float16_t *inputp = inputs.ptr();
26         float16_t *outp = output.ptr();
27 
28         #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
29         arm_biquad_mod_coef_f16 *coefsmodp = (arm_biquad_mod_coef_f16*)vecCoefs.ptr();
30         #endif
31 
32         int blockSize;
33 
34 
35 
36         /*
37 
38         Python script is generating different tests with
39         different blockSize and numTaps.
40 
41         We loop on those configs.
42 
43         */
44 
45            blockSize = inputs.nbSamples() >> 1;
46 
47 
48            /*
49 
50            The filter is initialized with the coefs, blockSize and numTaps.
51 
52            */
53 #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
54            arm_biquad_cascade_df1_mve_init_f16(&this->Sdf1,3,coefsp,coefsmodp,statep);
55 #else
56            arm_biquad_cascade_df1_init_f16(&this->Sdf1,3,coefsp,statep);
57 #endif
58 
59            /*
60 
61            Python script is filtering a 2*blockSize number of samples.
62            We do the same filtering in two pass to check (indirectly that
63            the state management of the fir is working.)
64 
65            */
66 
67            arm_biquad_cascade_df1_f16(&this->Sdf1,inputp,outp,blockSize);
68 
69            memcpy(debugstatep,statep,3*4*sizeof(float16_t));
70            debugstatep += 3*4;
71 
72            outp += blockSize;
73 
74            inputp += blockSize;
75            arm_biquad_cascade_df1_f16(&this->Sdf1,inputp,outp,blockSize);
76            outp += blockSize;
77 
78            memcpy(debugstatep,statep,3*4*sizeof(float16_t));
79            debugstatep += 3*4;
80 
81            ASSERT_EMPTY_TAIL(output);
82 
83            ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
84 
85            ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
86 
87 
88     }
89 
test_biquad_cascade_df2T_ref()90     void BIQUADF16::test_biquad_cascade_df2T_ref()
91     {
92 
93 
94         float16_t *statep = state.ptr();
95 
96 
97         float16_t *coefsp = coefs.ptr();
98 
99         const float16_t *inputp = inputs.ptr();
100         float16_t *outp = output.ptr();
101 
102         int blockSize;
103 
104 
105 
106         /*
107 
108         Python script is generating different tests with
109         different blockSize and numTaps.
110 
111         We loop on those configs.
112 
113         */
114 
115            blockSize = inputs.nbSamples() >> 1;
116 
117            /*
118 
119            The filter is initialized with the coefs, blockSize and numTaps.
120 
121            */
122 
123            arm_biquad_cascade_df2T_init_f16(&this->Sdf2T,3,coefsp,statep);
124 
125 
126 
127            /*
128 
129            Python script is filtering a 2*blockSize number of samples.
130            We do the same filtering in two pass to check (indirectly that
131            the state management of the fir is working.)
132 
133            */
134 
135            arm_biquad_cascade_df2T_f16(&this->Sdf2T,inputp,outp,blockSize);
136            outp += blockSize;
137 
138 
139            inputp += blockSize;
140            arm_biquad_cascade_df2T_f16(&this->Sdf2T,inputp,outp,blockSize);
141            outp += blockSize;
142 
143 
144            ASSERT_EMPTY_TAIL(output);
145 
146            ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
147 
148            ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
149 
150 
151     }
152 
test_biquad_cascade_df1_rand()153     void BIQUADF16::test_biquad_cascade_df1_rand()
154     {
155 
156 
157         float16_t *statep = state.ptr();
158 
159         const float16_t *coefsp = coefs.ptr();
160         const int16_t *configsp = configs.ptr();
161 
162         const float16_t *inputp = inputs.ptr();
163         float16_t *outp = output.ptr();
164 
165         #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
166         arm_biquad_mod_coef_f16 *coefsmodp = (arm_biquad_mod_coef_f16*)vecCoefs.ptr();
167         #endif
168 
169         int blockSize;
170         int numStages;
171         unsigned long i;
172 
173 
174 
175         for(i=0;i < configs.nbSamples(); i+=2)
176         {
177         /*
178 
179         Python script is generating different tests with
180         different blockSize and numTaps.
181 
182         We loop on those configs.
183 
184         */
185 
186 
187            numStages = configsp[0];
188            blockSize = configsp[1];
189 
190            configsp += 2;
191 
192            /*
193 
194            The filter is initialized with the coefs, blockSize and numTaps.
195 
196            */
197 #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
198            arm_biquad_cascade_df1_mve_init_f16(&this->Sdf1,numStages,coefsp,coefsmodp,statep);
199 #else
200            arm_biquad_cascade_df1_init_f16(&this->Sdf1,numStages,coefsp,statep);
201 #endif
202 
203 
204            /*
205 
206            Python script is filtering a 2*blockSize number of samples.
207            We do the same filtering in two pass to check (indirectly that
208            the state management of the fir is working.)
209 
210            */
211 
212            arm_biquad_cascade_df1_f16(&this->Sdf1,inputp,outp,blockSize);
213 
214            inputp += blockSize;
215            outp += blockSize;
216            coefsp += numStages * 5;
217 
218 
219 
220         }
221 
222            ASSERT_EMPTY_TAIL(output);
223            ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
224            ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
225 
226 
227     }
228 
test_biquad_cascade_df2T_rand()229     void BIQUADF16::test_biquad_cascade_df2T_rand()
230     {
231 
232 
233         float16_t *statep = state.ptr();
234         const int16_t *configsp = configs.ptr();
235 
236 
237         float16_t *coefsp = coefs.ptr();
238 
239         const float16_t *inputp = inputs.ptr();
240         float16_t *outp = output.ptr();
241 
242         int blockSize;
243         int numStages;
244 
245         unsigned long i;
246 
247 
248 
249         for(i=0;i < configs.nbSamples(); i+=2)
250         {
251 
252         /*
253 
254         Python script is generating different tests with
255         different blockSize and numTaps.
256 
257         We loop on those configs.
258 
259         */
260 
261            numStages = configsp[0];
262            blockSize = configsp[1];
263 
264            configsp += 2;
265 
266 
267 
268            /*
269 
270            The filter is initialized with the coefs, blockSize and numTaps.
271 
272            */
273 
274            arm_biquad_cascade_df2T_init_f16(&this->Sdf2T,numStages,coefsp,statep);
275 
276            coefsp += numStages * 5;
277 
278            /*
279 
280            Python script is filtering a 2*blockSize number of samples.
281            We do the same filtering in two pass to check (indirectly that
282            the state management of the fir is working.)
283 
284            */
285 
286            arm_biquad_cascade_df2T_f16(&this->Sdf2T,inputp,outp,blockSize);
287            outp += blockSize;
288            inputp += blockSize;
289 
290         }
291 
292            ASSERT_EMPTY_TAIL(output);
293 
294            ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
295 
296            ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
297 
298 
299     }
300 
test_biquad_cascade_stereo_df2T_rand()301     void BIQUADF16::test_biquad_cascade_stereo_df2T_rand()
302     {
303 
304 
305         float16_t *statep = state.ptr();
306         const int16_t *configsp = configs.ptr();
307 
308         const float16_t *coefsp = coefs.ptr();
309 
310 
311         const float16_t *inputp = inputs.ptr();
312         float16_t *outp = output.ptr();
313 
314         int blockSize;
315         int numStages;
316 
317         unsigned long i;
318 
319 
320 
321         for(i=0;i < configs.nbSamples(); i+=2)
322         {
323 
324         /*
325 
326         Python script is generating different tests with
327         different blockSize and numTaps.
328 
329         We loop on those configs.
330 
331         */
332 
333            numStages = configsp[0];
334            blockSize = configsp[1];
335 
336            configsp += 2;
337 
338 
339 
340            /*
341 
342            The filter is initialized with the coefs, blockSize and numTaps.
343 
344            */
345            arm_biquad_cascade_stereo_df2T_init_f16(&this->SStereodf2T,numStages,coefsp,statep);
346 
347            coefsp += numStages * 5;
348 
349            /*
350 
351            Python script is filtering a 2*blockSize number of samples.
352            We do the same filtering in two pass to check (indirectly that
353            the state management of the fir is working.)
354 
355            */
356 
357            arm_biquad_cascade_stereo_df2T_f16(&this->SStereodf2T,inputp,outp,blockSize);
358            outp += 2*blockSize;
359            inputp += 2*blockSize;
360 
361         }
362 
363            ASSERT_EMPTY_TAIL(output);
364 
365            ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
366 
367            ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
368 
369 
370     }
371 
setUp(Testing::testID_t id,std::vector<Testing::param_t> & params,Client::PatternMgr * mgr)372     void BIQUADF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
373     {
374 
375        (void)params;
376        switch(id)
377        {
378         case BIQUADF16::TEST_BIQUAD_CASCADE_DF1_REF_1:
379             debugstate.create(2*64,BIQUADF16::STATE_F16_ID,mgr);
380 
381             inputs.reload(BIQUADF16::BIQUADINPUTS_F16_ID,mgr);
382             coefs.reload(BIQUADF16::BIQUADCOEFS_F16_ID,mgr);
383             ref.reload(BIQUADF16::BIQUADREFS_F16_ID,mgr);
384             #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
385             /* Max num stages is 47 in Python script */
386             vecCoefs.create(96*47,BIQUADF16::OUT_F16_ID,mgr);
387             #endif
388         break;
389 
390         case BIQUADF16::TEST_BIQUAD_CASCADE_DF2T_REF_2:
391            vecCoefs.create(64,BIQUADF16::OUT_F16_ID,mgr);
392 
393            inputs.reload(BIQUADF16::BIQUADINPUTS_F16_ID,mgr);
394            coefs.reload(BIQUADF16::BIQUADCOEFS_F16_ID,mgr);
395            ref.reload(BIQUADF16::BIQUADREFS_F16_ID,mgr);
396         break;
397 
398         case BIQUADF16::TEST_BIQUAD_CASCADE_DF1_RAND_3:
399 
400             inputs.reload(BIQUADF16::ALLBIQUADINPUTS_F16_ID,mgr);
401             coefs.reload(BIQUADF16::ALLBIQUADCOEFS_F16_ID,mgr);
402             ref.reload(BIQUADF16::ALLBIQUADREFS_F16_ID,mgr);
403             configs.reload(BIQUADF16::ALLBIQUADCONFIGS_S16_ID,mgr);
404             #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
405             /* Max num stages is 47 in Python script */
406             vecCoefs.create(96*47,BIQUADF16::OUT_F16_ID,mgr);
407             #endif
408         break;
409 
410         case BIQUADF16::TEST_BIQUAD_CASCADE_DF2T_RAND_4:
411            vecCoefs.create(512,BIQUADF16::OUT_F16_ID,mgr);
412 
413            inputs.reload(BIQUADF16::ALLBIQUADINPUTS_F16_ID,mgr);
414            coefs.reload(BIQUADF16::ALLBIQUADCOEFS_F16_ID,mgr);
415            ref.reload(BIQUADF16::ALLBIQUADREFS_F16_ID,mgr);
416            configs.reload(BIQUADF16::ALLBIQUADCONFIGS_S16_ID,mgr);
417         break;
418 
419         case BIQUADF16::TEST_BIQUAD_CASCADE_STEREO_DF2T_RAND_5:
420 
421            inputs.reload(BIQUADF16::ALLBIQUADSTEREOINPUTS_F16_ID,mgr);
422            coefs.reload(BIQUADF16::ALLBIQUADCOEFS_F16_ID,mgr);
423            ref.reload(BIQUADF16::ALLBIQUADSTEREOREFS_F16_ID,mgr);
424            configs.reload(BIQUADF16::ALLBIQUADCONFIGS_S16_ID,mgr);
425         break;
426 
427        }
428 
429 
430 
431 
432        output.create(ref.nbSamples(),BIQUADF16::OUT_F16_ID,mgr);
433 
434        state.create(128,BIQUADF16::STATE_F16_ID,mgr);
435 
436 
437     }
438 
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)439     void BIQUADF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
440     {
441         (void)id;
442         output.dump(mgr);
443         switch(id)
444         {
445             case BIQUADF16::TEST_BIQUAD_CASCADE_DF1_REF_1:
446                debugstate.dump(mgr);
447             break;
448         }
449     }
450