ben.carrasco/freeswitch
1
0 Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2026-11-14 13:28:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

update to snapshot spandsp-20090421

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@13086 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris committed 2009-04-20 18:33:33 +00:00
1 parent 900f820810
commit 4281523a8f
104 files changed
+4309 -1620
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

libs/spandsp/src/bert.c
+92 -89
View File
@@ -22,7 +22,7 @@
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id: bert.c,v 1.32 2009/02/10 13:06:46 steveu Exp $
* $Id: bert.c,v 1.33 2009/04/14 16:04:53 steveu Exp $
*/
#if defined(HAVE_CONFIG_H)
@@ -44,6 +44,8 @@
#include "spandsp/private/logging.h"
#include "spandsp/private/bert.h"
#define MEASUREMENT_STEP 100
static const char *qbf = "VoyeZ Le BricK GeanT QuE J'ExaminE PreS Du WharF 123 456 7890 + - * : = $ % ( )"
"ThE QuicK BrowN FoX JumpS OveR ThE LazY DoG 123 456 7890 + - * : = $ % ( )";
@@ -80,53 +82,53 @@ SPAN_DECLARE(int) bert_get_bit(bert_state_t *s)
{
int bit;
if (s->limit && s->tx_bits >= s->limit)
if (s->limit && s->tx.bits >= s->limit)
return SIG_STATUS_END_OF_DATA;
bit = 0;
switch (s->pattern_class)
{
case 0:
bit = s->tx_reg & 1;
s->tx_reg = (s->tx_reg >> 1) | ((s->tx_reg & 1) << s->shift2);
bit = s->tx.reg & 1;
s->tx.reg = (s->tx.reg >> 1) | ((s->tx.reg & 1) << s->shift2);
break;
case 1:
bit = s->tx_reg & 1;
s->tx_reg = (s->tx_reg >> 1) | (((s->tx_reg ^ (s->tx_reg >> s->shift)) & 1) << s->shift2);
bit = s->tx.reg & 1;
s->tx.reg = (s->tx.reg >> 1) | (((s->tx.reg ^ (s->tx.reg >> s->shift)) & 1) << s->shift2);
if (s->max_zeros)
{
/* This generator suppresses runs >s->max_zeros */
if (bit)
{
if (++s->tx_zeros > s->max_zeros)
if (++s->tx.zeros > s->max_zeros)
{
s->tx_zeros = 0;
s->tx.zeros = 0;
bit ^= 1;
}
}
else
{
s->tx_zeros = 0;
s->tx.zeros = 0;
}
}
bit ^= s->invert;
break;
case 2:
if (s->tx_step_bit == 0)
if (s->tx.step_bit == 0)
{
s->tx_step_bit = 7;
s->tx_reg = qbf[s->tx_step++];
if (s->tx_reg == 0)
s->tx.step_bit = 7;
s->tx.reg = qbf[s->tx.step++];
if (s->tx.reg == 0)
{
s->tx_reg = 'V';
s->tx_step = 1;
s->tx.reg = 'V';
s->tx.step = 1;
}
}
bit = s->tx_reg & 1;
s->tx_reg >>= 1;
s->tx_step_bit--;
bit = s->tx.reg & 1;
s->tx.reg >>= 1;
s->tx.step_bit--;
break;
}
s->tx_bits++;
s->tx.bits++;
return bit;
}
/*- End of function --------------------------------------------------------*/
@@ -192,58 +194,58 @@ SPAN_DECLARE(void) bert_put_bit(bert_state_t *s, int bit)
return;
}
bit = (bit & 1) ^ s->invert;
s->rx_bits++;
s->rx.bits++;
switch (s->pattern_class)
{
case 0:
if (s->resync)
if (s->rx.resync)
{
s->rx_reg = (s->rx_reg >> 1) | (bit << s->shift2);
s->ref_reg = (s->ref_reg >> 1) | ((s->ref_reg & 1) << s->shift2);
if (s->rx_reg == s->ref_reg)
s->rx.reg = (s->rx.reg >> 1) | (bit << s->shift2);
s->rx.ref_reg = (s->rx.ref_reg >> 1) | ((s->rx.ref_reg & 1) << s->shift2);
if (s->rx.reg == s->rx.ref_reg)
{
if (++s->resync > s->resync_time)
if (++s->rx.resync > s->resync_time)
{
s->resync = 0;
s->rx.resync = 0;
if (s->reporter)
s->reporter(s->user_data, BERT_REPORT_SYNCED, &s->results);
}
}
else
{
s->resync = 2;
s->ref_reg = s->master_reg;
s->rx.resync = 2;
s->rx.ref_reg = s->rx.master_reg;
}
}
else
{
s->results.total_bits++;
if ((bit ^ s->ref_reg) & 1)
if ((bit ^ s->rx.ref_reg) & 1)
s->results.bad_bits++;
s->ref_reg = (s->ref_reg >> 1) | ((s->ref_reg & 1) << s->shift2);
s->rx.ref_reg = (s->rx.ref_reg >> 1) | ((s->rx.ref_reg & 1) << s->shift2);
}
break;
case 1:
if (s->resync)
if (s->rx.resync)
{
/* If we get a reasonable period for which we correctly predict the
next bit, we must be in sync. */
/* Don't worry about max. zeros tests when resyncing.
It might just extend the resync time a little. Trying
to include the test might affect robustness. */
if (bit == (int) ((s->rx_reg >> s->shift) & 1))
if (bit == (int) ((s->rx.reg >> s->shift) & 1))
{
if (++s->resync > s->resync_time)
if (++s->rx.resync > s->resync_time)
{
s->resync = 0;
s->rx.resync = 0;
if (s->reporter)
s->reporter(s->user_data, BERT_REPORT_SYNCED, &s->results);
}
}
else
{
s->resync = 2;
s->rx_reg ^= s->mask;
s->rx.resync = 2;
s->rx.reg ^= s->mask;
}
}
else
@@ -252,73 +254,73 @@ SPAN_DECLARE(void) bert_put_bit(bert_state_t *s, int bit)
if (s->max_zeros)
{
/* This generator suppresses runs >s->max_zeros */
if ((s->rx_reg & s->mask))
if ((s->rx.reg & s->mask))
{
if (++s->rx_zeros > s->max_zeros)
if (++s->rx.zeros > s->max_zeros)
{
s->rx_zeros = 0;
s->rx.zeros = 0;
bit ^= 1;
}
}
else
{
s->rx_zeros = 0;
s->rx.zeros = 0;
}
}
if (bit != (int) ((s->rx_reg >> s->shift) & 1))
if (bit != (int) ((s->rx.reg >> s->shift) & 1))
{
s->results.bad_bits++;
s->resync_bad_bits++;
s->rx.resync_bad_bits++;
s->decade_bad[2][s->decade_ptr[2]]++;
}
if (--s->step <= 0)
if (--s->rx.measurement_step <= 0)
{
/* Every hundred bits we need to do the error rate measurement */
s->step = 100;
s->rx.measurement_step = MEASUREMENT_STEP;
assess_error_rate(s);
}
if (--s->resync_cnt <= 0)
if (--s->rx.resync_cnt <= 0)
{
/* Check if there were enough bad bits during this period to
justify a resync. */
if (s->resync_bad_bits >= (s->resync_len*s->resync_percent)/100)
if (s->rx.resync_bad_bits >= (s->rx.resync_len*s->rx.resync_percent)/100)
{
s->resync = 1;
s->rx.resync = 1;
s->results.resyncs++;
if (s->reporter)
s->reporter(s->user_data, BERT_REPORT_UNSYNCED, &s->results);
}
s->resync_cnt = s->resync_len;
s->resync_bad_bits = 0;
s->rx.resync_cnt = s->rx.resync_len;
s->rx.resync_bad_bits = 0;
}
}
s->rx_reg = (s->rx_reg >> 1) | (((s->rx_reg ^ (s->rx_reg >> s->shift)) & 1) << s->shift2);
s->rx.reg = (s->rx.reg >> 1) | (((s->rx.reg ^ (s->rx.reg >> s->shift)) & 1) << s->shift2);
break;
case 2:
s->rx_reg = (s->rx_reg >> 1) | (bit << 6);
s->rx.reg = (s->rx.reg >> 1) | (bit << 6);
/* TODO: There is no mechanism for synching yet. This only works if things start in sync. */
if (++s->rx_step_bit == 7)
if (++s->rx.step_bit == 7)
{
s->rx_step_bit = 0;
if ((int) s->rx_reg != qbf[s->rx_step])
s->rx.step_bit = 0;
if ((int) s->rx.reg != qbf[s->rx.step])
{
/* We need to work out the number of actual bad bits here. We need to look at the
error rate, and see it a resync is needed. etc. */
s->results.bad_bits++;
}
if (qbf[++s->rx_step] == '\0')
s->rx_step = 0;
if (qbf[++s->rx.step] == '\0')
s->rx.step = 0;
}
s->results.total_bits++;
break;
}
if (s->report_frequency > 0)
{
if (--s->report_countdown <= 0)
if (--s->rx.report_countdown <= 0)
{
if (s->reporter)
s->reporter(s->user_data, BERT_REPORT_REGULAR, &s->results);
s->report_countdown = s->report_frequency;
s->rx.report_countdown = s->report_frequency;
}
}
}
@@ -339,7 +341,7 @@ SPAN_DECLARE(void) bert_set_report(bert_state_t *s, int freq, bert_report_func_t
s->reporter = reporter;
s->user_data = user_data;
s->report_countdown = s->report_frequency;
s->rx.report_countdown = s->report_frequency;
}
/*- End of function --------------------------------------------------------*/
@@ -366,47 +368,47 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
switch (s->pattern)
{
case BERT_PATTERN_ZEROS:
s->tx_reg = 0;
s->tx.reg = 0;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_ONES:
s->tx_reg = ~((uint32_t) 0);
s->tx.reg = ~((uint32_t) 0);
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_7_TO_1:
s->tx_reg = 0xFEFEFEFE;
s->tx.reg = 0xFEFEFEFE;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_3_TO_1:
s->tx_reg = 0xEEEEEEEE;
s->tx.reg = 0xEEEEEEEE;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_1_TO_1:
s->tx_reg = 0xAAAAAAAA;
s->tx.reg = 0xAAAAAAAA;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_1_TO_3:
s->tx_reg = 0x11111111;
s->tx.reg = 0x11111111;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_1_TO_7:
s->tx_reg = 0x01010101;
s->tx.reg = 0x01010101;
s->shift2 = 31;
s->pattern_class = 0;
break;
case BERT_PATTERN_QBF:
s->tx_reg = 0;
s->tx.reg = 0;
s->pattern_class = 2;
break;
case BERT_PATTERN_ITU_O151_23:
s->pattern_class = 1;
s->tx_reg = 0x7FFFFF;
s->tx.reg = 0x7FFFFF;
s->mask = 0x20;
s->shift = 5;
s->shift2 = 22;
@@ -416,7 +418,7 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
break;
case BERT_PATTERN_ITU_O151_20:
s->pattern_class = 1;
s->tx_reg = 0xFFFFF;
s->tx.reg = 0xFFFFF;
s->mask = 0x8;
s->shift = 3;
s->shift2 = 19;
@@ -426,7 +428,7 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
break;
case BERT_PATTERN_ITU_O151_15:
s->pattern_class = 1;
s->tx_reg = 0x7FFF;
s->tx.reg = 0x7FFF;
s->mask = 0x2;
s->shift = 1;
s->shift2 = 14;
@@ -436,7 +438,7 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
break;
case BERT_PATTERN_ITU_O152_11:
s->pattern_class = 1;
s->tx_reg = 0x7FF;
s->tx.reg = 0x7FF;
s->mask = 0x4;
s->shift = 2;
s->shift2 = 10;
@@ -446,7 +448,7 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
break;
case BERT_PATTERN_ITU_O153_9:
s->pattern_class = 1;
s->tx_reg = 0x1FF;
s->tx.reg = 0x1FF;
s->mask = 0x10;
s->shift = 4;
s->shift2 = 8;
@@ -455,28 +457,29 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
s->max_zeros = 0;
break;
}
s->tx_bits = 0;
s->tx_step = 0;
s->tx_step_bit = 0;
s->tx_zeros = 0;
s->tx.bits = 0;
s->tx.step = 0;
s->tx.step_bit = 0;
s->tx.zeros = 0;
s->rx_reg = s->tx_reg;
s->ref_reg = s->rx_reg;
s->master_reg = s->ref_reg;
s->rx_bits = 0;
s->rx_step = 0;
s->rx_step_bit = 0;
s->rx.reg = s->tx.reg;
s->rx.ref_reg = s->rx.reg;
s->rx.master_reg = s->rx.ref_reg;
s->rx.bits = 0;
s->rx.step = 0;
s->rx.step_bit = 0;
s->rx.resync = 1;
s->rx.resync_cnt = resync_len;
s->rx.resync_bad_bits = 0;
s->rx.resync_len = resync_len;
s->rx.resync_percent = resync_percent;
s->resync = 1;
s->resync_cnt = resync_len;
s->resync_bad_bits = 0;
s->resync_len = resync_len;
s->resync_percent = resync_percent;
s->results.total_bits = 0;
s->results.bad_bits = 0;
s->results.resyncs = 0;
s->report_countdown = 0;
s->rx.report_countdown = 0;
for (i = 0; i < 8; i++)
{
@@ -485,7 +488,7 @@ SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern,
s->decade_ptr[i] = 0;
}
s->error_rate = 8;
s->step = 100;
s->rx.measurement_step = MEASUREMENT_STEP;
span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
span_log_set_protocol(&s->logging, "BERT");