Mercurial > hg > audiostuff

comparison spandsp-0.0.3/spandsp-0.0.3/tests/bert_tests.c @ 5:f762bf195c4b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import spandsp-0.0.3
author Peter Meerwald <pmeerw@cosy.sbg.ac.at>
date Fri, 25 Jun 2010 16:00:21 +0200
parents
children
comparison
equal deleted inserted replaced
4:26cd8f1ef0b1 5:f762bf195c4b
1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * bert_tests.c - Tests for the BER tester.
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2004 Steve Underwood
9 *
10 * All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2, as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: bert_tests.c,v 1.18 2006/11/19 14:07:26 steveu Exp $
26 */
27
28 /*! \file */
29
30 /*! \page bert_tests_page BERT tests
31 \section bert_tests_page_sec_1 What does it do?
32 These tests exercise each of the BERT standards supported by the BERT module.
33 */
34
35 #ifdef HAVE_CONFIG_H
36 #include "config.h"
37 #endif
38
39 #include <inttypes.h>
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <string.h>
43 #if defined(HAVE_TGMATH_H)
44 #include <tgmath.h>
45 #endif
46 #if defined(HAVE_MATH_H)
47 #include <math.h>
48 #endif
49 #include <assert.h>
50 #include <audiofile.h>
51 #include <tiffio.h>
52
53 #include "spandsp.h"
54
55 /* Use a local random generator, so the results are consistent across platforms */
56 static int my_rand(void)
57 {
58 static int rndnum = 1234567;
59
60 return (rndnum = 1664525U*rndnum + 1013904223U);
61 }
62 /*- End of function --------------------------------------------------------*/
63
64 static void reporter(void *user_data, int reason, bert_results_t *results)
65 {
66 int channel;
67
68 channel = (int) (intptr_t) user_data;
69 switch (reason)
70 {
71 case BERT_REPORT_SYNCED:
72 printf("BERT report synced\n");
73 break;
74 case BERT_REPORT_UNSYNCED:
75 printf("BERT report unsync'ed\n");
76 break;
77 case BERT_REPORT_REGULAR:
78 printf("BERT report regular - %d bits, %d bad bits, %d resyncs\r", results->total_bits, results->bad_bits, results->resyncs);
79 break;
80 case BERT_REPORT_GT_10_2:
81 printf("BERT report > 1 in 10^2\n");
82 break;
83 case BERT_REPORT_LT_10_2:
84 printf("BERT report < 1 in 10^2\n");
85 break;
86 case BERT_REPORT_LT_10_3:
87 printf("BERT report < 1 in 10^3\n");
88 break;
89 case BERT_REPORT_LT_10_4:
90 printf("BERT report < 1 in 10^4\n");
91 break;
92 case BERT_REPORT_LT_10_5:
93 printf("BERT report < 1 in 10^5\n");
94 break;
95 case BERT_REPORT_LT_10_6:
96 printf("BERT report < 1 in 10^6\n");
97 break;
98 case BERT_REPORT_LT_10_7:
99 printf("BERT report < 1 in 10^7\n");
100 break;
101 default:
102 printf("BERT report reason %d\n", reason);
103 break;
104 }
105 }
106 /*- End of function --------------------------------------------------------*/
107
108 int8_t test[0x800000];
109
110 int main(int argc, char *argv[])
111 {
112 bert_state_t tx_bert;
113 bert_state_t rx_bert;
114 bert_state_t bert;
115 bert_results_t bert_results;
116 int i;
117 int bit;
118 int zeros;
119 int max_zeros;
120 int failed;
121
122 bert_init(&tx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
123 bert_init(&rx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
124 for (i = 0; i < 511*2; i++)
125 {
126 bit = bert_get_bit(&tx_bert);
127 bert_put_bit(&rx_bert, bit);
128 }
129 bert_result(&rx_bert, &bert_results);
130 printf("Zeros: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
131 if (bert_results.bad_bits || bert_results.total_bits != 950)
132 {
133 printf("Test failed.\n");
134 exit(2);
135 }
136
137 bert_init(&tx_bert, 0, BERT_PATTERN_ONES, 300, 20);
138 bert_init(&rx_bert, 0, BERT_PATTERN_ONES, 300, 20);
139 for (i = 0; i < 511*2; i++)
140 {
141 bit = bert_get_bit(&tx_bert);
142 bert_put_bit(&rx_bert, bit);
143 }
144 bert_result(&rx_bert, &bert_results);
145 printf("Ones: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
146 if (bert_results.bad_bits || bert_results.total_bits != 950)
147 {
148 printf("Test failed.\n");
149 exit(2);
150 }
151
152 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
153 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
154 for (i = 0; i < 511*2; i++)
155 {
156 bit = bert_get_bit(&tx_bert);
157 bert_put_bit(&rx_bert, bit);
158 }
159 bert_result(&rx_bert, &bert_results);
160 printf("1 to 7: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
161 if (bert_results.bad_bits || bert_results.total_bits != 950)
162 {
163 printf("Test failed.\n");
164 exit(2);
165 }
166
167 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
168 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
169 for (i = 0; i < 511*2; i++)
170 {
171 bit = bert_get_bit(&tx_bert);
172 bert_put_bit(&rx_bert, bit);
173 }
174 bert_result(&rx_bert, &bert_results);
175 printf("1 to 3: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
176 if (bert_results.bad_bits || bert_results.total_bits != 950)
177 {
178 printf("Test failed.\n");
179 exit(2);
180 }
181
182 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
183 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
184 for (i = 0; i < 511*2; i++)
185 {
186 bit = bert_get_bit(&tx_bert);
187 bert_put_bit(&rx_bert, bit);
188 }
189 bert_result(&rx_bert, &bert_results);
190 printf("1 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
191 if (bert_results.bad_bits || bert_results.total_bits != 950)
192 {
193 printf("Test failed.\n");
194 exit(2);
195 }
196
197 bert_init(&tx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
198 bert_init(&rx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
199 for (i = 0; i < 511*2; i++)
200 {
201 bit = bert_get_bit(&tx_bert);
202 bert_put_bit(&rx_bert, bit);
203 }
204 bert_result(&rx_bert, &bert_results);
205 printf("3 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
206 if (bert_results.bad_bits || bert_results.total_bits != 950)
207 {
208 printf("Test failed.\n");
209 exit(2);
210 }
211
212 bert_init(&tx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
213 bert_init(&rx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
214 for (i = 0; i < 511*2; i++)
215 {
216 bit = bert_get_bit(&tx_bert);
217 bert_put_bit(&rx_bert, bit);
218 }
219 bert_result(&rx_bert, &bert_results);
220 printf("7 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
221 if (bert_results.bad_bits || bert_results.total_bits != 950)
222 {
223 printf("Test failed.\n");
224 exit(2);
225 }
226
227 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
228 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
229 for (i = 0; i < 0x200; i++)
230 test[i] = 0;
231 max_zeros = 0;
232 zeros = 0;
233 for (i = 0; i < 511*2; i++)
234 {
235 bit = bert_get_bit(&tx_bert);
236 if (bit)
237 {
238 if (zeros > max_zeros)
239 max_zeros = zeros;
240 zeros = 0;
241 }
242 else
243 {
244 zeros++;
245 }
246 bert_put_bit(&rx_bert, bit);
247 test[tx_bert.tx_reg]++;
248 }
249 failed = FALSE;
250 if (test[0] != 0)
251 {
252 printf("XXX %d %d\n", 0, test[0]);
253 failed = TRUE;
254 }
255 for (i = 1; i < 0x200; i++)
256 {
257 if (test[i] != 2)
258 {
259 printf("XXX %d %d\n", i, test[i]);
260 failed = TRUE;
261 }
262 }
263 bert_result(&rx_bert, &bert_results);
264 printf("O.153(9): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
265 if (bert_results.bad_bits || bert_results.total_bits != 986 || failed)
266 {
267 printf("Test failed.\n");
268 exit(2);
269 }
270
271 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
272 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
273 for (i = 0; i < 0x800; i++)
274 test[i] = 0;
275 max_zeros = 0;
276 zeros = 0;
277 for (i = 0; i < 2047*2; i++)
278 {
279 bit = bert_get_bit(&tx_bert);
280 if (bit)
281 {
282 if (zeros > max_zeros)
283 max_zeros = zeros;
284 zeros = 0;
285 }
286 else
287 {
288 zeros++;
289 }
290 bert_put_bit(&rx_bert, bit);
291 test[tx_bert.tx_reg]++;
292 }
293 failed = FALSE;
294 if (test[0] != 0)
295 {
296 printf("XXX %d %d\n", 0, test[0]);
297 failed = TRUE;
298 }
299 for (i = 1; i < 0x800; i++)
300 {
301 if (test[i] != 2)
302 {
303 printf("XXX %d %d\n", i, test[i]);
304 failed = TRUE;
305 }
306 }
307 bert_result(&rx_bert, &bert_results);
308 printf("O.152(11): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
309 if (bert_results.bad_bits || bert_results.total_bits != 4052 || failed)
310 {
311 printf("Test failed.\n");
312 exit(2);
313 }
314
315 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
316 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
317 for (i = 0; i < 0x8000; i++)
318 test[i] = 0;
319 max_zeros = 0;
320 zeros = 0;
321 for (i = 0; i < 32767*2; i++)
322 {
323 bit = bert_get_bit(&tx_bert);
324 if (bit)
325 {
326 if (zeros > max_zeros)
327 max_zeros = zeros;
328 zeros = 0;
329 }
330 else
331 {
332 zeros++;
333 }
334 bert_put_bit(&rx_bert, bit);
335 test[tx_bert.tx_reg]++;
336 }
337 failed = FALSE;
338 if (test[0] != 0)
339 {
340 printf("XXX %d %d\n", 0, test[0]);
341 failed = TRUE;
342 }
343 for (i = 1; i < 0x8000; i++)
344 {
345 if (test[i] != 2)
346 {
347 printf("XXX %d %d\n", i, test[i]);
348 failed = TRUE;
349 }
350 }
351 bert_result(&rx_bert, &bert_results);
352 printf("O.151(15): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
353 if (bert_results.bad_bits || bert_results.total_bits != 65480 || failed)
354 {
355 printf("Test failed.\n");
356 exit(2);
357 }
358
359 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
360 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
361 for (i = 0; i < 0x100000; i++)
362 test[i] = 0;
363 max_zeros = 0;
364 zeros = 0;
365 for (i = 0; i < 1048575*2; i++)
366 {
367 bit = bert_get_bit(&tx_bert);
368 if (bit)
369 {
370 if (zeros > max_zeros)
371 max_zeros = zeros;
372 zeros = 0;
373 }
374 else
375 {
376 zeros++;
377 }
378 bert_put_bit(&rx_bert, bit);
379 test[tx_bert.tx_reg]++;
380 }
381 failed = FALSE;
382 if (test[0] != 0)
383 {
384 printf("XXX %d %d\n", 0, test[0]);
385 failed = TRUE;
386 }
387 for (i = 1; i < 0x100000; i++)
388 {
389 if (test[i] != 2)
390 printf("XXX %d %d\n", i, test[i]);
391 }
392 bert_result(&rx_bert, &bert_results);
393 printf("O.151(20): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
394 if (bert_results.bad_bits || bert_results.total_bits != 2097066 || failed)
395 {
396 printf("Test failed.\n");
397 exit(2);
398 }
399
400 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
401 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
402 for (i = 0; i < 0x800000; i++)
403 test[i] = 0;
404 max_zeros = 0;
405 zeros = 0;
406 for (i = 0; i < 8388607*2; i++)
407 {
408 bit = bert_get_bit(&tx_bert);
409 if (bit)
410 {
411 if (zeros > max_zeros)
412 max_zeros = zeros;
413 zeros = 0;
414 }
415 else
416 {
417 zeros++;
418 }
419 bert_put_bit(&rx_bert, bit);
420 test[tx_bert.tx_reg]++;
421 }
422 failed = FALSE;
423 if (test[0] != 0)
424 {
425 printf("XXX %d %d\n", 0, test[0]);
426 failed = TRUE;
427 }
428 for (i = 1; i < 0x800000; i++)
429 {
430 if (test[i] != 2)
431 printf("XXX %d %d\n", i, test[i]);
432 }
433 bert_result(&rx_bert, &bert_results);
434 printf("O.151(23): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
435 if (bert_results.bad_bits || bert_results.total_bits != 16777136 || failed)
436 {
437 printf("Test failed.\n");
438 exit(2);
439 }
440
441 bert_init(&tx_bert, 0, BERT_PATTERN_QBF, 300, 20);
442 bert_init(&rx_bert, 0, BERT_PATTERN_QBF, 300, 20);
443 for (i = 0; i < 100000; i++)
444 {
445 bit = bert_get_bit(&tx_bert);
446 bert_put_bit(&rx_bert, bit);
447 }
448 bert_result(&rx_bert, &bert_results);
449 printf("QBF: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
450 if (bert_results.bad_bits || bert_results.total_bits != 100000)
451 {
452 printf("Test failed.\n");
453 exit(2);
454 }
455
456 /* Test the mechanism for categorising the error rate into <10^x bands */
457 /* TODO: The result of this test is not checked automatically */
458 bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
459 bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
460 for (;;)
461 {
462 if ((bit = bert_get_bit(&bert)) == PUTBIT_END_OF_DATA)
463 {
464 bert_result(&bert, &bert_results);
465 printf("Rate test: %d bits, %d bad bits, %d resyncs\n", bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
466 if (bert_results.total_bits != 15000000 - 42
467 ||
468 bert_results.bad_bits != 58
469 ||
470 bert_results.resyncs != 0)
471 {
472 printf("Tests failed\n");
473 exit(2);
474 }
475 break;
476 //bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
477 //bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
478 //continue;
479 }
480 if ((my_rand() & 0x3FFFF) == 0)
481 bit ^= 1;
482 //if ((my_rand() & 0xFFF) == 0)
483 // bert_put_bit(&bert, bit);
484 bert_put_bit(&bert, bit);
485 }
486
487 printf("Tests passed.\n");
488 return 0;
489 }
490 /*- End of function --------------------------------------------------------*/
491 /*- End of file ------------------------------------------------------------*/

Repositories maintained by Peter Meerwald, pmeerw@pmeerw.net.