occasional false recognition of a fast modem when its really the V.21 modem.
This was sometimes messing up T.38 gateway operation.
#if !defined(_SPANDSP_DDS_H_)
#define _SPANDSP_DDS_H_
+#define DDS_PHASE_RATE(frequency) (int32_t) ((frequency)*65536.0f*65536.0f/SAMPLE_RATE)
+#define DDS_PHASE(angle) (int32_t) ((uint32_t) (((angle < 0.0f) ? (360.0f + angle) : angle)*65536.0f*65536.0f/360.0f))
+
#if defined(__cplusplus)
extern "C"
{
/* Target length for the equalizer is about 63 taps, to deal with the worst stuff
in V.56bis. */
/*! The length of the equalizer buffer */
-//#define V17_EQUALIZER_LEN 33
-#define V17_EQUALIZER_LEN 17
+#define V17_EQUALIZER_LEN 33
+
/*! Samples before the target position in the equalizer buffer */
-//#define V17_EQUALIZER_PRE_LEN 16
-#define V17_EQUALIZER_PRE_LEN 8
+#define V17_EQUALIZER_PRE_LEN 16
/*! The number of taps in the pulse shaping/bandpass filter */
#define V17_RX_FILTER_STEPS 27
routine. */
void *qam_user_data;
-#if defined(SPANDSP_USE_FIXED_POINTx)
+#if defined(SPANDSP_USE_FIXED_POINT)
/*! \brief The scaling factor assessed by the AGC algorithm. */
int16_t agc_scaling;
/*! \brief The previous value of agc_scaling, needed to reuse old training. */
This is only for performance analysis purposes. */
int total_baud_timing_correction;
- /*! \brief Starting phase angles for the coarse carrier aquisition step. */
- int32_t start_angles[2];
- /*! \brief History list of phase angles for the coarse carrier aquisition step. */
- int32_t angles[16];
+ /*! \brief The previous symbol phase angles for the coarse carrier aquisition step. */
+ int32_t last_angles[2];
+ /*! \brief History list of phase angle differences for the coarse carrier aquisition step. */
+ int32_t diff_angles[16];
/*! \brief A pointer to the current space map. There is a space map for
each trellis state. */
int full_path_to_past_state_locations[V17_TRELLIS_STORAGE_DEPTH][8];
/*! \brief The trellis. */
int past_state_locations[V17_TRELLIS_STORAGE_DEPTH][8];
-#if defined(SPANDSP_USE_FIXED_POINTx)
+#if defined(SPANDSP_USE_FIXED_POINT)
/*! \brief Euclidean distances (actually the squares of the distances)
from the last states of the trellis. */
uint32_t distances[8];
This is only for performance analysis purposes. */
int total_baud_timing_correction;
- /*! \brief Starting phase angles for the coarse carrier aquisition step. */
- int32_t start_angles[2];
- /*! \brief History list of phase angles for the coarse carrier aquisition step. */
- int32_t angles[16];
+ /*! \brief The previous symbol phase angles for the coarse carrier aquisition step. */
+ int32_t last_angles[2];
+ /*! \brief History list of phase angle differences for the coarse carrier aquisition step. */
+ int32_t diff_angles[16];
+
/*! \brief Error and flow logging control */
logging_state_t logging;
};
This is only for performance analysis purposes. */
int total_baud_timing_correction;
- /*! \brief Starting phase angles for the coarse carrier aquisition step. */
- int32_t start_angles[2];
- /*! \brief History list of phase angles for the coarse carrier aquisition step. */
- int32_t angles[16];
+ /*! \brief The previous symbol phase angles for the coarse carrier aquisition step. */
+ int32_t last_angles[2];
+ /*! \brief History list of phase angle differences for the coarse carrier aquisition step. */
+ int32_t diff_angles[16];
/*! \brief The position of the current symbol in the constellation, used for
differential decoding. */
if (++s->training_count >= 100)
{
/* Record the current phase angle */
- s->angles[0] =
- s->start_angles[0] = arctan2(z.im, z.re);
s->training_stage = TRAINING_STAGE_LOG_PHASE;
+ vec_zeroi32(s->diff_angles, 16);
+ s->last_angles[0] = arctan2(z.im, z.re);
#if defined(SPANDSP_USE_FIXED_POINTx)
if (s->agc_scaling_save == 0)
s->agc_scaling_save = s->agc_scaling;
/* We should already know the accurate carrier frequency. All we need to sort
out is the phase. */
/* Check if we just saw A or B */
- if ((uint32_t) (angle - s->start_angles[0]) < 0x80000000U)
+ if ((uint32_t) (angle - s->last_angles[0]) < 0x80000000U)
{
- angle = s->start_angles[0];
- s->angles[0] = 0xC0000000 + 219937506;
- s->angles[1] = 0x80000000 + 219937506;
+ angle = s->last_angles[0];
+ s->last_angles[0] = 0xC0000000 + 219937506;
+ s->last_angles[1] = 0x80000000 + 219937506;
}
else
{
- s->angles[0] = 0x80000000 + 219937506;
- s->angles[1] = 0xC0000000 + 219937506;
+ s->last_angles[0] = 0x80000000 + 219937506;
+ s->last_angles[1] = 0xC0000000 + 219937506;
}
/* Make a step shift in the phase, to pull it into line. We need to rotate the equalizer
buffer, as well as the carrier phase, for this to play out nicely. */
}
else
{
- s->angles[1] =
- s->start_angles[1] = angle;
+ s->last_angles[1] = angle;
s->training_stage = TRAINING_STAGE_WAIT_FOR_CDBA;
}
break;
angle = arctan2(z.im, z.re);
/* Look for the initial ABAB sequence to display a phase reversal, which will
signal the start of the scrambled CDBA segment */
- ang = angle - s->angles[(s->training_count - 1) & 0xF];
- s->angles[(s->training_count + 1) & 0xF] = angle;
-
- /* Do a coarse frequency adjustment about half way through the reversals, as if we wait until
- the end, we might have rotated too far to correct properly. */
- if (s->training_count == 100)
- {
- i = s->training_count;
- j = i & 0xF;
- ang = (s->angles[j] - s->start_angles[0])/i
- + (s->angles[j | 0x1] - s->start_angles[1])/i;
- s->carrier_phase_rate += 3*(ang/20);
- //span_log(&s->logging, SPAN_LOG_FLOW, "Angles %x, %x, %x, %x, dist %d\n", s->angles[j], s->start_angles[0], s->angles[j | 0x1], s->start_angles[1], i);
-
- s->start_angles[0] = s->angles[j];
- s->start_angles[1] = s->angles[j | 0x1];
- //span_log(&s->logging, SPAN_LOG_FLOW, "%d %d %d %d %d\n", s->angles[s->training_count & 0xF], s->start_angles[0], s->angles[(s->training_count | 0x1) & 0xF], s->start_angles[1], s->training_count);
- span_log(&s->logging, SPAN_LOG_FLOW, "First coarse carrier frequency %7.2f (%d)\n", dds_frequencyf(s->carrier_phase_rate), s->training_count);
-
- }
- if ((ang > 0x40000000 || ang < -0x40000000) && s->training_count >= 13)
+ i = s->training_count + 1;
+ ang = angle - s->last_angles[i & 1];
+ s->last_angles[i & 1] = angle;
+ s->diff_angles[i & 0xF] = s->diff_angles[(i - 2) & 0xF] + (ang >> 4);
+ if ((ang > DDS_PHASE(90.0f) || ang < DDS_PHASE(-90.0f)) && s->training_count >= 13)
{
span_log(&s->logging, SPAN_LOG_FLOW, "We seem to have a reversal at symbol %d\n", s->training_count);
/* We seem to have a phase reversal */
/* Slam the carrier frequency into line, based on the total phase drift over the last
section. Use the shift from the odd bits and the shift from the even bits to get
better jitter suppression. */
- /* TODO: We are supposed to deal with frequancy errors up to +-8Hz. Over 200+
- symbols that is more than half a cycle. We get confused an do crazy things.
- We can only cope with errors up to 5Hz right now. We need to implement
- greater tolerance to be compliant, although it doesn't really matter much
- these days. */
/* Step back a few symbols so we don't get ISI distorting things. */
i = (s->training_count - 8) & ~1;
/* Avoid the possibility of a divide by zero */
- if (i - 100 + 8)
+ if (i > 1)
{
j = i & 0xF;
- ang = (s->angles[j] - s->start_angles[0])/(i - 100 + 8)
- + (s->angles[j | 0x1] - s->start_angles[1])/(i - 100 + 8);
- s->carrier_phase_rate += 3*(ang/20);
- span_log(&s->logging, SPAN_LOG_FLOW, "Angles %x, %x, %x, %x, dist %d\n", s->angles[j], s->start_angles[0], s->angles[j | 0x1], s->start_angles[1], i);
+ ang = (s->diff_angles[j] + s->diff_angles[j | 0x1])/(i - 1);
+ s->carrier_phase_rate += 3*16*(ang/20);
+ span_log(&s->logging, SPAN_LOG_FLOW, "Angles %x, %x, dist %d\n", s->last_angles[0], s->last_angles[1], i);
}
- //span_log(&s->logging, SPAN_LOG_FLOW, "%d %d %d %d %d\n", s->angles[s->training_count & 0xF], s->start_angles[0], s->angles[(s->training_count | 0x1) & 0xF], s->start_angles[1], s->training_count);
- span_log(&s->logging, SPAN_LOG_FLOW, "Second coarse carrier frequency %7.2f (%d)\n", dds_frequencyf(s->carrier_phase_rate), s->training_count);
+ span_log(&s->logging, SPAN_LOG_FLOW, "Coarse carrier frequency %7.2f (%d)\n", dds_frequencyf(s->carrier_phase_rate), s->training_count);
/* Check if the carrier frequency is plausible */
- if (s->carrier_phase_rate < dds_phase_ratef(CARRIER_NOMINAL_FREQ - 20.0f)
+ if (s->carrier_phase_rate < DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ - 20.0f)
||
- s->carrier_phase_rate > dds_phase_ratef(CARRIER_NOMINAL_FREQ + 20.0f))
+ s->carrier_phase_rate > DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ + 20.0f))
{
span_log(&s->logging, SPAN_LOG_FLOW, "Training failed (sequence failed)\n");
/* Park this modem */
/* Look for the initial ABAB sequence to display a phase reversal, which will
signal the start of the scrambled CDBA segment */
angle = arctan2(z.im, z.re);
- ang = angle - s->angles[s->training_count & 1];
- if (ang > 0x40000000 || ang < -0x40000000)
+ ang = angle - s->last_angles[s->training_count & 1];
+ if (ang > DDS_PHASE(90.0f) || ang < DDS_PHASE(-90.0f))
{
/* We seem to have a phase reversal */
/* We have just seen the first symbol of the scrambled sequence, so skip it. */
#endif
if (short_train != 2)
s->short_train = short_train;
- memset(s->start_angles, 0, sizeof(s->start_angles));
- memset(s->angles, 0, sizeof(s->angles));
+ memset(s->last_angles, 0, sizeof(s->last_angles));
+ memset(s->diff_angles, 0, sizeof(s->diff_angles));
/* Initialise the TCM decoder parameters. */
/* The accumulated distance vectors are set so state zero starts
}
else
{
- s->carrier_phase_rate = dds_phase_ratef(CARRIER_NOMINAL_FREQ);
+ s->carrier_phase_rate = DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ);
equalizer_reset(s);
#if defined(SPANDSP_USE_FIXED_POINTx)
s->agc_scaling_save = 0;
s->short_train = FALSE;
s->scrambler_tap = 18 - 1;
v17_rx_signal_cutoff(s, -45.5f);
- s->carrier_phase_rate_save = dds_phase_ratef(CARRIER_NOMINAL_FREQ);
+ s->carrier_phase_rate_save = DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ);
v17_rx_restart(s, bit_rate, s->short_train);
return s;
}
s->rx.training_count = 0;
s->rx.signal_present = FALSE;
- s->rx.carrier_phase_rate = dds_phase_ratef((s->calling_party) ? 2400.0f : 1200.0f);
+ s->rx.carrier_phase_rate = (s->calling_party) ? DDS_PHASE_RATE(2400.0f) : DDS_PHASE_RATE(1200.0f);
s->rx.carrier_phase = 0;
power_meter_init(&s->rx.rx_power, 5);
v22bis_rx_signal_cutoff(s, -45.5f);
{
s->gardner_step = 32;
s->training_stage = TRAINING_STAGE_LOG_PHASE;
- s->angles[0] =
- s->start_angles[0] = arctan2(z.im, z.re);
+ vec_zeroi32(s->diff_angles, 16);
+ s->last_angles[0] = arctan2(z.im, z.re);
}
break;
case TRAINING_STAGE_LOG_PHASE:
/* Record the current alternate phase angle */
target = &zero;
- s->angles[1] =
- s->start_angles[1] = arctan2(z.im, z.re);
+ s->last_angles[1] = arctan2(z.im, z.re);
s->training_count = 1;
s->training_stage = TRAINING_STAGE_WAIT_FOR_HOP;
break;
angle = arctan2(z.im, z.re);
/* Look for the initial ABAB sequence to display a phase reversal, which will
signal the start of the scrambled ABAB segment */
- ang = angle - s->angles[(s->training_count - 1) & 0xF];
- s->angles[(s->training_count + 1) & 0xF] = angle;
- if ((ang > 0x20000000 || ang < -0x20000000) && s->training_count >= 3)
+ i = s->training_count + 1;
+ ang = angle - s->last_angles[i & 1];
+ s->last_angles[i & 1] = angle;
+ s->diff_angles[i & 0xF] = s->diff_angles[(i - 2) & 0xF] + (ang >> 4);
+ if ((ang > DDS_PHASE(45.0f) || ang < DDS_PHASE(-45.0f)) && s->training_count >= 13)
{
/* We seem to have a phase reversal */
/* Slam the carrier frequency into line, based on the total phase drift over the last
/* Step back a few symbols so we don't get ISI distorting things. */
i = (s->training_count - 8) & ~1;
/* Avoid the possibility of a divide by zero */
- if (i)
+ if (i > 1)
{
j = i & 0xF;
- ang = (s->angles[j] - s->start_angles[0])/i + (s->angles[j | 0x1] - s->start_angles[1])/i;
+ ang = (s->diff_angles[j] + s->diff_angles[j | 0x1])/(i - 1);
if (s->bit_rate == 4800)
- s->carrier_phase_rate += ang/10;
+ s->carrier_phase_rate += 16*(ang/10);
else
- s->carrier_phase_rate += 3*(ang/40);
+ s->carrier_phase_rate += 3*16*(ang/40);
}
span_log(&s->logging, SPAN_LOG_FLOW, "Coarse carrier frequency %7.2f (%d)\n", dds_frequencyf(s->carrier_phase_rate), s->training_count);
/* Check if the carrier frequency is plausible */
- if (s->carrier_phase_rate < dds_phase_ratef(CARRIER_NOMINAL_FREQ - 20.0f)
+ if (s->carrier_phase_rate < DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ - 20.0f)
||
- s->carrier_phase_rate > dds_phase_ratef(CARRIER_NOMINAL_FREQ + 20.0f))
+ s->carrier_phase_rate > DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ + 20.0f))
{
span_log(&s->logging, SPAN_LOG_FLOW, "Training failed (sequence failed)\n");
/* Park this modem */
}
else
{
- s->carrier_phase_rate = dds_phase_ratef(CARRIER_NOMINAL_FREQ);
+ s->carrier_phase_rate = DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ);
#if defined(SPANDSP_USE_FIXED_POINT)
s->agc_scaling = (float) (1024.0f*FP_FACTOR)*1.414f/283.0f;
#else
{
/* Record the current phase angle */
s->training_stage = TRAINING_STAGE_LOG_PHASE;
- s->angles[0] =
- s->start_angles[0] = arctan2(z.im, z.re);
+ vec_zeroi32(s->diff_angles, 16);
+ s->last_angles[0] = arctan2(z.im, z.re);
#if defined(SPANDSP_USE_FIXED_POINT)
if (s->agc_scaling_save == 0)
s->agc_scaling_save = s->agc_scaling;
case TRAINING_STAGE_LOG_PHASE:
/* Record the current alternate phase angle */
target = &zero;
- s->angles[1] =
- s->start_angles[1] = arctan2(z.im, z.re);
+ s->last_angles[1] = arctan2(z.im, z.re);
s->training_count = 1;
s->training_stage = TRAINING_STAGE_WAIT_FOR_CDCD;
break;
angle = arctan2(z.im, z.re);
/* Look for the initial ABAB sequence to display a phase reversal, which will
signal the start of the scrambled CDCD segment */
- ang = angle - s->angles[(s->training_count - 1) & 0xF];
- s->angles[(s->training_count + 1) & 0xF] = angle;
- if ((ang > 0x20000000 || ang < -0x20000000) && s->training_count >= 13)
+ i = s->training_count + 1;
+ ang = angle - s->last_angles[i & 1];
+ s->last_angles[i & 1] = angle;
+ s->diff_angles[i & 0xF] = s->diff_angles[(i - 2) & 0xF] + (ang >> 4);
+ if ((ang > DDS_PHASE(45.0f) || ang < DDS_PHASE(-45.0f)) && s->training_count >= 13)
{
/* We seem to have a phase reversal */
/* Slam the carrier frequency into line, based on the total phase drift over the last
/* Step back a few symbols so we don't get ISI distorting things. */
i = (s->training_count - 8) & ~1;
/* Avoid the possibility of a divide by zero */
- if (i)
+ if (i > 1)
{
j = i & 0xF;
- ang = (s->angles[j] - s->start_angles[0])/i + (s->angles[j | 0x1] - s->start_angles[1])/i;
- s->carrier_phase_rate += 3*(ang/20);
+ ang = (s->diff_angles[j] + s->diff_angles[j | 0x1])/(i - 1);
+ s->carrier_phase_rate += 3*16*(ang/20);
}
span_log(&s->logging, SPAN_LOG_FLOW, "Coarse carrier frequency %7.2f\n", dds_frequencyf(s->carrier_phase_rate));
/* Check if the carrier frequency is plausible */
- if (s->carrier_phase_rate < dds_phase_ratef(CARRIER_NOMINAL_FREQ - 20.0f)
+ if (s->carrier_phase_rate < DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ - 20.0f)
||
- s->carrier_phase_rate > dds_phase_ratef(CARRIER_NOMINAL_FREQ + 20.0f))
+ s->carrier_phase_rate > DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ + 20.0f))
{
span_log(&s->logging, SPAN_LOG_FLOW, "Training failed (sequence failed)\n");
/* Park this modem */
}
else
{
- s->carrier_phase_rate = dds_phase_ratef(CARRIER_NOMINAL_FREQ);
+ s->carrier_phase_rate = DDS_PHASE_RATE(CARRIER_NOMINAL_FREQ);
equalizer_reset(s);
#if defined(SPANDSP_USE_FIXED_POINT)
s->agc_scaling_save = 0;
projects / thirdparty / freeswitch.git / commitdiff
