static void vparms(int32_t vwin[],
float *inbuf,
float *lpbuf,
const int32_t buflim[],
int32_t half,
float *dither,
int32_t *mintau,
int32_t *zc,
int32_t *lbe,
int32_t *fbe,
float *qs,
float *rc1,
float *ar_b,
float *ar_f)
{
int32_t inbuf_offset;
int32_t lpbuf_offset;
int32_t vlen;
int32_t stop;
int32_t i;
int32_t start;
float r1;
float r2;
float e_pre;
float ap_rms;
float e_0;
float oldsgn;
float lp_rms;
float e_b;
float e_f;
float r_b;
float r_f;
float e0ap;
/* Calculate zero crossings (ZC) and several energy and correlation */
/* measures on low band and full band speech. Each measure is taken */
/* over either the first or the second half of the voicing window, */
/* depending on the variable HALF. */
lpbuf_offset = buflim[2];
lpbuf -= lpbuf_offset;
inbuf_offset = buflim[0];
inbuf -= inbuf_offset;
lp_rms = 0.0f;
ap_rms = 0.0f;
e_pre = 0.0f;
e0ap = 0.0f;
*rc1 = 0.0f;
e_0 = 0.0f;
e_b = 0.0f;
e_f = 0.0f;
r_f = 0.0f;
r_b = 0.0f;
*zc = 0;
vlen = vwin[1] - vwin[0] + 1;
start = vwin[0] + half*vlen/2 + 1;
stop = start + vlen/2 - 1;
/* I'll use the symbol HVL in the table below to represent the value */
/* VLEN/2. Note that if VLEN is odd, then HVL should be rounded down, */
/* i.e., HVL = (VLEN-1)/2. */
/* HALF START STOP */
/* 1 VWIN(1)+1 VWIN(1)+HVL */
/* 2 VWIN(1)+HVL+1 VWIN(1)+2*HVL */
oldsgn = r_sign(1.0f, inbuf[start - 1] - *dither);
for (i = start; i <= stop; i++)
{
lp_rms += fabsf(lpbuf[i]);
ap_rms += fabsf(inbuf[i]);
e_pre += fabsf(inbuf[i] - inbuf[i - 1]);
r1 = inbuf[i];
e0ap += r1*r1;
*rc1 += inbuf[i]*inbuf[i - 1];
r1 = lpbuf[i];
e_0 += r1*r1;
r1 = lpbuf[i - *mintau];
e_b += r1*r1;
r1 = lpbuf[i + *mintau];
e_f += r1*r1;
r_f += lpbuf[i]*lpbuf[i + *mintau];
r_b += lpbuf[i]*lpbuf[i - *mintau];
r1 = inbuf[i] + *dither;
if (r_sign(1.0f, r1) != oldsgn)
{
++(*zc);
oldsgn = -oldsgn;
}
*dither = -(*dither);
}
/* Normalized short-term autocovariance coefficient at unit sample delay */
*rc1 /= max(e0ap, 1.0f);
/* Ratio of the energy of the first difference signal (6 dB/oct preemphasis)*/
/* to the energy of the full band signal */
/* Computing MAX */
r1 = ap_rms*2.0f;
*qs = e_pre/max(r1, 1.0f);
/* aR_b is the product of the forward and reverse prediction gains, */
/* looking backward in time (the causal case). */
*ar_b = r_b/max(e_b, 1.0f)*(r_b/max(e_0, 1.0f));
/* aR_f is the same as aR_b, but looking forward in time (non causal case).*/
*ar_f = r_f/max(e_f, 1.0f)*(r_f/max(e_0, 1.0f));
/* Normalize ZC, LBE, and FBE to old fixed window length of 180. */
/* (The fraction 90/VLEN has a range of 0.58 to 1) */
r2 = (float) (*zc << 1);
*zc = lfastrintf(r2*(90.0f/vlen));
r1 = lp_rms/4*(90.0f/vlen);
*lbe = min(lfastrintf(r1), 32767);
r1 = ap_rms/4*(90.0f/vlen);
*fbe = min(lfastrintf(r1), 32767);
}
void lpc10_voicing(lpc10_encode_state_t *s,
int32_t vwin[],
float *inbuf,
float *lpbuf,
const int32_t buflim[],
int32_t half,
float *minamd,
float *maxamd,
int32_t *mintau,
float ivrc[],
int32_t obound[])
{
static const float vdc[100] =
{
0.0f, 1714.0f, -110.0f, 334.0f, -4096.0f, -654.0f, 3752.0f, 3769.0f, 0.0f, 1181.0f,
0.0f, 874.0f, -97.0f, 300.0f, -4096.0f, -1021.0f, 2451.0f, 2527.0f, 0.0f, -500.0f,
0.0f, 510.0f, -70.0f, 250.0f, -4096.0f, -1270.0f, 2194.0f, 2491.0f, 0.0f, -1500.0f,
0.0f, 500.0f, -10.0f, 200.0f, -4096.0f, -1300.0f, 2.0e3f, 2.0e3f, 0.0f, -2.0e3f,
0.0f, 500.0f, 0.0f, 0.0f, -4096.0f, -1300.0f, 2.0e3f, 2.0e3f, 0.0f, -2500.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
};
static const int nvdcl = 5;
static const float vdcl[10] =
{
600.0f, 450.0f, 300.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
};
int32_t inbuf_offset;
int32_t lpbuf_offset;
int32_t i1;
float r1;
float r2;
float ar_b;
float ar_f;
int32_t snrl;
int32_t i;
float value[9];
int32_t zc;
int ot;
float qs;
int32_t vstate;
float rc1;
int32_t fbe;
int32_t lbe;
float snr2;
#if (_MSC_VER >= 1400)
__analysis_assume(half >= 0 && half < 2);
#endif
inbuf_offset = 0;
lpbuf_offset = 0;
if (inbuf)
{
inbuf_offset = buflim[0];
inbuf -= inbuf_offset;
}
if (lpbuf)
{
lpbuf_offset = buflim[2];
lpbuf -= lpbuf_offset;
}
/* Voicing Decision Parameter vector (* denotes zero coefficient): */
/* * MAXMIN */
/* LBE/LBVE */
/* ZC */
/* RC1 */
/* QS */
/* IVRC2 */
/* aR_B */
/* aR_F */
/* * LOG(LBE/LBVE) */
/* Define 2-D voicing decision coefficient vector according to the voicing */
/* parameter order above. Each row (VDC vector) is optimized for a specific */
/* SNR. The last element of the vector is the constant. */
/* E ZC RC1 Qs IVRC2 aRb aRf c */
/* The VOICE array contains the result of the linear discriminant function*/
/* (analog values). The VOIBUF array contains the hard-limited binary */
/* voicing decisions. The VOICE and VOIBUF arrays, according to FORTRAN */
/* memory allocation, are addressed as: */
/* (half-frame number, future-frame number) */
/* | Past | Present | Future1 | Future2 | */
/* | 1,0 | 2,0 | 1,1 | 2,1 | 1,2 | 2,2 | 1,3 | 2,3 | ---> time */
/* Update linear discriminant function history each frame: */
if (half == 0)
{
s->voice[0][0] = s->voice[1][0];
s->voice[0][1] = s->voice[1][1];
s->voice[1][0] = s->voice[2][0];
s->voice[1][1] = s->voice[2][1];
s->maxmin = *maxamd / max(*minamd, 1.0f);
}
/* Calculate voicing parameters twice per frame */
vparms(vwin,
&inbuf[inbuf_offset],
&lpbuf[lpbuf_offset],
buflim,
half,
&s->dither,
mintau,
&zc,
&lbe,
&fbe,
&qs,
&rc1,
&ar_b,
&ar_f);
/* Estimate signal-to-noise ratio to select the appropriate VDC vector. */
/* The SNR is estimated as the running average of the ratio of the */
/* running average full-band voiced energy to the running average */
/* full-band unvoiced energy. SNR filter has gain of 63. */
r1 = (s->snr + s->fbve/(float) max(s->fbue, 1))*63/64.0f;
s->snr = (float) lfastrintf(r1);
snr2 = s->snr*s->fbue/max(s->lbue, 1);
/* Quantize SNR to SNRL according to VDCL thresholds. */
i1 = nvdcl - 1;
for (snrl = 0; snrl < i1; snrl++)
{
if (snr2 > vdcl[snrl])
break;
}
/* (Note: SNRL = NVDCL here) */
/* Linear discriminant voicing parameters: */
value[0] = s->maxmin;
value[1] = (float) lbe/max(s->lbve, 1);
value[2] = (float) zc;
value[3] = rc1;
value[4] = qs;
value[5] = ivrc[1];
value[6] = ar_b;
value[7] = ar_f;
/* Evaluation of linear discriminant function: */
s->voice[2][half] = vdc[snrl*10 + 9];
for (i = 0; i < 8; i++)
s->voice[2][half] += vdc[snrl*10 + i]*value[i];
/* Classify as voiced if discriminant > 0, otherwise unvoiced */
/* Voicing decision for current half-frame: 1 = Voiced; 0 = Unvoiced */
s->voibuf[3][half] = (s->voice[2][half] > 0.0f) ? 1 : 0;
/* Skip voicing decision smoothing in first half-frame: */
/* Give a value to VSTATE, so that trace statements below will print */
/* a consistent value from one call to the next when HALF .EQ. 1. */
/* The value of VSTATE is not used for any other purpose when this is */
/* true. */
vstate = -1;
if (half != 0)
{
/* Voicing decision smoothing rules (override of linear combination): */
/* Unvoiced half-frames: At least two in a row. */
/* -------------------- */
/* Voiced half-frames: At least two in a row in one frame. */
/* ------------------- Otherwise at least three in a row. */
/* (Due to the way transition frames are encoded) */
/* In many cases, the discriminant function determines how to smooth. */
/* In the following chart, the decisions marked with a * may be overridden. */
/* Voicing override of transitions at onsets: */
/* If a V/UV or UV/V voicing decision transition occurs within one-half */
/* frame of an onset bounding a voicing window, then the transition is */
/* moved to occur at the onset. */
/* P 1F */
/* ----- ----- */
/* 0 0 0 0 */
/* 0 0 0* 1 (If there is an onset there) */
/* 0 0 1* 0* (Based on 2F and discriminant distance) */
/* 0 0 1 1 */
/* 0 1* 0 0 (Always) */
/* 0 1* 0* 1 (Based on discriminant distance) */
/* 0* 1 1 0* (Based on past, 2F, and discriminant distance) */
/* 0 1* 1 1 (If there is an onset there) */
/* 1 0* 0 0 (If there is an onset there) */
/* 1 0 0 1 */
/* 1 0* 1* 0 (Based on discriminant distance) */
/* 1 0* 1 1 (Always) */
/* 1 1 0 0 */
/* 1 1 0* 1* (Based on 2F and discriminant distance) */
/* 1 1 1* 0 (If there is an onset there) */
/* 1 1 1 1 */
/* Determine if there is an onset transition between P and 1F. */
/* OT (Onset Transition) is true if there is an onset between */
/* P and 1F but not after 1F. */
ot = ((obound[0] & 2) != 0 || obound[1] == 1) && (obound[2] & 1) == 0;
/* Multi-way dispatch on voicing decision history: */
vstate = (s->voibuf[1][0] << 3) + (s->voibuf[1][1] << 2) + (s->voibuf[2][0] << 1) + s->voibuf[2][1];
switch (vstate + 1)
{
case 2:
if (ot && s->voibuf[3][0] == 1)
s->voibuf[2][0] = 1;
break;
case 3:
if (s->voibuf[3][0] == 0 || s->voice[1][0] < -s->voice[1][1])
s->voibuf[2][0] = 0;
else
s->voibuf[2][1] = 1;
break;
case 5:
s->voibuf[1][1] = 0;
break;
case 6:
if (s->voice[0][1] < -s->voice[1][0])
s->voibuf[1][1] = 0;
else
s->voibuf[2][0] = 1;
break;
case 7:
if (s->voibuf[0][0] == 1 || s->voibuf[3][0] == 1 || s->voice[1][1] > s->voice[0][0])
s->voibuf[2][1] = 1;
else
s->voibuf[1][0] = 1;
break;
case 8:
if (ot)
s->voibuf[1][1] = 0;
break;
case 9:
if (ot)
s->voibuf[1][1] = 1;
break;
case 11:
if (s->voice[1][0] < -s->voice[0][1])
s->voibuf[2][0] = 0;
else
s->voibuf[1][1] = 1;
break;
case 12:
s->voibuf[1][1] = 1;
break;
case 14:
if (s->voibuf[3][0] == 0 && s->voice[1][1] < -s->voice[1][0])
s->voibuf[2][1] = 0;
else
s->voibuf[2][0] = 1;
break;
case 15:
if (ot && s->voibuf[3][0] == 0)
s->voibuf[2][0] = 0;
break;
}
}
/* During unvoiced half-frames, update the low band and full band unvoiced*/
/* energy estimates (LBUE and FBUE) and also the zero crossing */
/* threshold (DITHER). (The input to the unvoiced energy filters is */
/* restricted to be less than 10dB above the previous inputs of the */
/* filters.) */
/* During voiced half-frames, update the low-pass (LBVE) and all-pass */
/* (FBVE) voiced energy estimates. */
if (s->voibuf[3][half] == 0)
{
r1 = (s->sfbue*63 + (min(fbe, s->ofbue*3) << 3))/64.0f;
s->sfbue = lfastrintf(r1);
s->fbue = s->sfbue/8;
s->ofbue = fbe;
r1 = (s->slbue*63 + (min(lbe, s->olbue*3) << 3))/64.0f;
s->slbue = lfastrintf(r1);
s->lbue = s->slbue/8;
s->olbue = lbe;
}
else
{
s->lbve = lfastrintf((s->lbve*63 + lbe)/64.0f);
s->fbve = lfastrintf((s->fbve*63 + fbe)/64.0f);
}
/* Set dither threshold to yield proper zero crossing rates in the */
/* presence of low frequency noise and low level signal input. */
/* NOTE: The divisor is a function of REF, the expected energies. */
/* Computing MIN */
/* Computing MAX */
r2 = sqrtf((float) (s->lbue*s->lbve))*64/3000;
r1 = max(r2, 1.0f);
s->dither = min(r1, 20.0f);
/* Voicing decisions are returned in VOIBUF. */
}
SPAN_DECLARE(int) dtmf_rx(dtmf_rx_state_t *s, const int16_t amp[], int samples)
{
#if defined(SPANDSP_USE_FIXED_POINT)
int32_t row_energy[4];
int32_t col_energy[4];
int16_t xamp;
float famp;
#else
float row_energy[4];
float col_energy[4];
float xamp;
float famp;
#endif
float v1;
int i;
int j;
int sample;
int best_row;
int best_col;
int limit;
uint8_t hit;
hit = 0;
for (sample = 0; sample < samples; sample = limit)
{
/* The block length is optimised to meet the DTMF specs. */
if ((samples - sample) >= (DTMF_SAMPLES_PER_BLOCK - s->current_sample))
limit = sample + (DTMF_SAMPLES_PER_BLOCK - s->current_sample);
else
limit = samples;
/* The following unrolled loop takes only 35% (rough estimate) of the
time of a rolled loop on the machine on which it was developed */
for (j = sample; j < limit; j++)
{
xamp = amp[j];
if (s->filter_dialtone)
{
famp = xamp;
/* Sharp notches applied at 350Hz and 440Hz - the two common dialtone frequencies.
These are rather high Q, to achieve the required narrowness, without using lots of
sections. */
v1 = 0.98356f*famp + 1.8954426f*s->z350[0] - 0.9691396f*s->z350[1];
famp = v1 - 1.9251480f*s->z350[0] + s->z350[1];
s->z350[1] = s->z350[0];
s->z350[0] = v1;
v1 = 0.98456f*famp + 1.8529543f*s->z440[0] - 0.9691396f*s->z440[1];
famp = v1 - 1.8819938f*s->z440[0] + s->z440[1];
s->z440[1] = s->z440[0];
s->z440[0] = v1;
xamp = famp;
}
xamp = goertzel_preadjust_amp(xamp);
#if defined(SPANDSP_USE_FIXED_POINT)
s->energy += ((int32_t) xamp*xamp);
#else
s->energy += xamp*xamp;
#endif
goertzel_samplex(&s->row_out[0], xamp);
goertzel_samplex(&s->col_out[0], xamp);
goertzel_samplex(&s->row_out[1], xamp);
goertzel_samplex(&s->col_out[1], xamp);
goertzel_samplex(&s->row_out[2], xamp);
goertzel_samplex(&s->col_out[2], xamp);
goertzel_samplex(&s->row_out[3], xamp);
goertzel_samplex(&s->col_out[3], xamp);
}
if (s->duration < INT_MAX - (limit - sample))
s->duration += (limit - sample);
s->current_sample += (limit - sample);
if (s->current_sample < DTMF_SAMPLES_PER_BLOCK)
continue;
/* We are at the end of a DTMF detection block */
/* Find the peak row and the peak column */
row_energy[0] = goertzel_result(&s->row_out[0]);
best_row = 0;
col_energy[0] = goertzel_result(&s->col_out[0]);
best_col = 0;
for (i = 1; i < 4; i++)
{
row_energy[i] = goertzel_result(&s->row_out[i]);
if (row_energy[i] > row_energy[best_row])
best_row = i;
col_energy[i] = goertzel_result(&s->col_out[i]);
if (col_energy[i] > col_energy[best_col])
best_col = i;
}
hit = 0;
/* Basic signal level test and the twist test */
if (row_energy[best_row] >= s->threshold
&&
col_energy[best_col] >= s->threshold)
{
if (col_energy[best_col] < row_energy[best_row]*s->reverse_twist
&&
col_energy[best_col]*s->normal_twist > row_energy[best_row])
{
/* Relative peak test ... */
for (i = 0; i < 4; i++)
{
if ((i != best_col && col_energy[i]*DTMF_RELATIVE_PEAK_COL > col_energy[best_col])
||
(i != best_row && row_energy[i]*DTMF_RELATIVE_PEAK_ROW > row_energy[best_row]))
{
break;
}
}
/* ... and fraction of total energy test */
if (i >= 4
&&
(row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY*s->energy)
{
/* Got a hit */
hit = dtmf_positions[(best_row << 2) + best_col];
}
}
if (span_log_test(&s->logging, SPAN_LOG_FLOW))
{
/* Log information about the quality of the signal, to aid analysis of detection problems */
/* Logging at this point filters the total no-hoper frames out of the log, and leaves
anything which might feasibly be a DTMF digit. The log will then contain a list of the
total, row and coloumn power levels for detailed analysis of detection problems. */
span_log(&s->logging,
SPAN_LOG_FLOW,
"Potentially '%c' - total %.2fdB, row %.2fdB, col %.2fdB, duration %d - %s\n",
dtmf_positions[(best_row << 2) + best_col],
log10f(s->energy)*10.0f - DTMF_POWER_OFFSET + DBM0_MAX_POWER,
log10f(row_energy[best_row]/DTMF_TO_TOTAL_ENERGY)*10.0f - DTMF_POWER_OFFSET + DBM0_MAX_POWER,
log10f(col_energy[best_col]/DTMF_TO_TOTAL_ENERGY)*10.0f - DTMF_POWER_OFFSET + DBM0_MAX_POWER,
s->duration,
(hit) ? "hit" : "miss");
}
}
/* The logic in the next test should ensure the following for different successive hit patterns:
-----ABB = start of digit B.
----B-BB = start of digit B
----A-BB = start of digit B
BBBBBABB = still in digit B.
BBBBBB-- = end of digit B
BBBBBBC- = end of digit B
BBBBACBB = B ends, then B starts again.
BBBBBBCC = B ends, then C starts.
BBBBBCDD = B ends, then D starts.
This can work with:
- Back to back differing digits. Back-to-back digits should
not happen. The spec. says there should be a gap between digits.
However, many real phones do not impose a gap, and rolling across
the keypad can produce little or no gap.
- It tolerates nasty phones that give a very wobbly start to a digit.
- VoIP can give sample slips. The phase jumps that produces will cause
the block it is in to give no detection. This logic will ride over a
single missed block, and not falsely declare a second digit. If the
hiccup happens in the wrong place on a minimum length digit, however
we would still fail to detect that digit. Could anything be done to
deal with that? Packet loss is clearly a no-go zone.
Note this is only relevant to VoIP using A-law, u-law or similar.
Low bit rate codecs scramble DTMF too much for it to be recognised,
and often slip in units larger than a sample. */
if (hit != s->in_digit && s->last_hit != s->in_digit)
{
/* We have two successive indications that something has changed. */
/* To declare digit on, the hits must agree. Otherwise we declare tone off. */
hit = (hit && hit == s->last_hit) ? hit : 0;
if (s->realtime_callback)
{
/* Avoid reporting multiple no digit conditions on flaky hits */
if (s->in_digit || hit)
{
i = (s->in_digit && !hit) ? -99 : lfastrintf(log10f(s->energy)*10.0f - DTMF_POWER_OFFSET + DBM0_MAX_POWER);
s->realtime_callback(s->realtime_callback_data, hit, i, s->duration);
s->duration = 0;
}
}
else
{
if (hit)
{
if (s->current_digits < MAX_DTMF_DIGITS)
{
s->digits[s->current_digits++] = (char) hit;
s->digits[s->current_digits] = '\0';
if (s->digits_callback)
{
s->digits_callback(s->digits_callback_data, s->digits, s->current_digits);
s->current_digits = 0;
}
}
else
{
s->lost_digits++;
}
}
}
s->in_digit = hit;
}
s->last_hit = hit;
#if defined(SPANDSP_USE_FIXED_POINT)
s->energy = 0;
#else
s->energy = 0.0f;
#endif
s->current_sample = 0;
}
if (s->current_digits && s->digits_callback)
{
s->digits_callback(s->digits_callback_data, s->digits, s->current_digits);
s->digits[0] = '\0';
s->current_digits = 0;
}
return 0;
}
SPAN_DECLARE_NONSTD(int) tone_gen(tone_gen_state_t *s, int16_t amp[], int max_samples)
{
int samples;
int limit;
#if defined(SPANDSP_USE_FIXED_POINT)
int16_t xamp;
#else
float xamp;
#endif
int i;
if (s->current_section < 0)
return 0;
for (samples = 0; samples < max_samples; )
{
limit = samples + s->duration[s->current_section] - s->current_position;
if (limit > max_samples)
limit = max_samples;
s->current_position += (limit - samples);
if (s->current_section & 1)
{
/* A silent section */
for ( ; samples < limit; samples++)
amp[samples] = 0;
}
else
{
if (s->tone[0].phase_rate < 0)
{
/* Modulated tone */
for ( ; samples < limit; samples++)
{
/* There must be two, and only two, tones */
#if defined(SPANDSP_USE_FIXED_POINT)
xamp = ((int32_t) dds_mod(&s->phase[0], -s->tone[0].phase_rate, s->tone[0].gain, 0)
*(32767 + (int32_t) dds_mod(&s->phase[1], s->tone[1].phase_rate, s->tone[1].gain, 0))) >> 15;
amp[samples] = xamp;
#else
xamp = dds_modf(&s->phase[0], -s->tone[0].phase_rate, s->tone[0].gain, 0)
*(1.0f + dds_modf(&s->phase[1], s->tone[1].phase_rate, s->tone[1].gain, 0));
amp[samples] = (int16_t) lfastrintf(xamp);
#endif
}
}
else
{
for ( ; samples < limit; samples++)
{
#if defined(SPANDSP_USE_FIXED_POINT)
xamp = 0;
#else
xamp = 0.0f;
#endif
for (i = 0; i < 4; i++)
{
if (s->tone[i].phase_rate == 0)
break;
#if defined(SPANDSP_USE_FIXED_POINT)
xamp += dds_mod(&s->phase[i], s->tone[i].phase_rate, s->tone[i].gain, 0);
#else
xamp += dds_modf(&s->phase[i], s->tone[i].phase_rate, s->tone[i].gain, 0);
#endif
}
/* Saturation of the answer is the right thing at this point.
However, we are normally generating well controlled tones,
that cannot clip. So, the overhead of doing saturation is
a waste of valuable time. */
#if defined(SPANDSP_USE_FIXED_POINT)
amp[samples] = xamp;
#else
amp[samples] = (int16_t) lfastrintf(xamp);
#endif
}
}
}
if (s->current_position >= s->duration[s->current_section])
{
s->current_position = 0;
if (++s->current_section > 3 || s->duration[s->current_section] == 0)
{
if (!s->repeat)
{
/* Force a quick exit */
s->current_section = -1;
break;
}
s->current_section = 0;
}
}
}
SPAN_DECLARE(int) modem_connect_tones_rx(modem_connect_tones_rx_state_t *s, const int16_t amp[], int len)
{
int i;
int16_t notched;
float v1;
float famp;
switch (s->tone_type)
{
case MODEM_CONNECT_TONES_FAX_CNG:
for (i = 0; i < len; i++)
{
/* A Cauer notch at 1100Hz, spread just wide enough to meet our detection bandwidth
criteria. */
famp = amp[i];
v1 = 0.792928f*famp + 1.0018744927985f*s->z1 - 0.54196833412465f*s->z2;
famp = v1 - 1.2994747954630f*s->z1 + s->z2;
s->z2 = s->z1;
s->z1 = v1;
notched = (int16_t) lfastrintf(famp);
/* Estimate the overall energy in the channel, and the energy in
the notch (i.e. overall channel energy - tone energy => noise).
Use abs instead of multiply for speed (is it really faster?). */
s->channel_level += ((abs(amp[i]) - s->channel_level) >> 5);
s->notch_level += ((abs(notched) - s->notch_level) >> 5);
if (s->channel_level > 70 && s->notch_level*6 < s->channel_level)
{
/* There is adequate energy in the channel, and it is mostly at 1100Hz. */
if (s->tone_present != MODEM_CONNECT_TONES_FAX_CNG)
{
if (++s->tone_cycle_duration >= ms_to_samples(415))
report_tone_state(s, MODEM_CONNECT_TONES_FAX_CNG, lfastrintf(log10f(s->channel_level/32768.0f)*20.0f + DBM0_MAX_POWER + 0.8f));
}
}
else
{
/* If the signal looks wrong, even for a moment, we consider this the
end of the tone. */
if (s->tone_present == MODEM_CONNECT_TONES_FAX_CNG)
report_tone_state(s, MODEM_CONNECT_TONES_NONE, -99);
s->tone_cycle_duration = 0;
}
}
break;
case MODEM_CONNECT_TONES_FAX_CED_OR_PREAMBLE:
/* Also look for V.21 preamble. A lot of machines don't send the 2100Hz burst. It
might also not be seen all the way through the channel, due to switching delays. */
fsk_rx(&(s->v21rx), amp, len);
/* Now fall through and look for a 2100Hz tone */
case MODEM_CONNECT_TONES_ANS:
for (i = 0; i < len; i++)
{
/* A Cauer notch at 2100Hz, spread just wide enough to meet our detection bandwidth
criteria. */
/* This is actually centred at 2095Hz, but gets the balance we want, due
to the asymmetric walls of the notch */
famp = amp[i];
v1 = 0.76000f*famp - 0.1183852f*s->z1 - 0.5104039f*s->z2;
famp = v1 + 0.1567596f*s->z1 + s->z2;
s->z2 = s->z1;
s->z1 = v1;
notched = (int16_t) lfastrintf(famp);
/* Estimate the overall energy in the channel, and the energy in
the notch (i.e. overall channel energy - tone energy => noise).
Use abs instead of multiply for speed (is it really faster?).
Damp the overall energy a little more for a stable result.
Damp the notch energy a little less, so we don't damp out the
blip every time the phase reverses */
s->channel_level += ((abs(amp[i]) - s->channel_level) >> 5);
s->notch_level += ((abs(notched) - s->notch_level) >> 4);
/* This should cut off at about -43dBm0 */
if (s->channel_level <= 70)
{
/* If the energy level is low, even for a moment, we consider this the
end of the tone. */
if (s->tone_present != MODEM_CONNECT_TONES_NONE)
report_tone_state(s, MODEM_CONNECT_TONES_NONE, -99);
s->tone_cycle_duration = 0;
s->good_cycles = 0;
s->tone_on = FALSE;
continue;
}
/* There is adequate energy in the channel. Is it mostly at 2100Hz? */
s->tone_cycle_duration++;
if (s->notch_level*6 < s->channel_level)
{
/* The notch test says yes, so we have the tone. */
/* We should get a kick from the notch filter every 450+-25ms, as the phase reverses, for an
EC disable tone. For a simple answer tone, the tone should persist unbroken for longer. */
if (!s->tone_on)
{
if (s->tone_cycle_duration >= ms_to_samples(450 - 25))
{
if (++s->good_cycles == 3)
report_tone_state(s, MODEM_CONNECT_TONES_ANS_PR, lfastrintf(log10f(s->channel_level/32768.0f)*20.0f + DBM0_MAX_POWER + 0.8f));
}
else
{
s->good_cycles = 0;
}
/* Cycles are timed from rising edge to rising edge */
s->tone_cycle_duration = 0;
}
else
{
if (s->tone_cycle_duration >= ms_to_samples(550))
{
if (s->tone_present == MODEM_CONNECT_TONES_NONE)
report_tone_state(s, MODEM_CONNECT_TONES_ANS, lfastrintf(log10f(s->channel_level/32768.0f)*20.0f + DBM0_MAX_POWER + 0.8f));
s->good_cycles = 0;
s->tone_cycle_duration = ms_to_samples(550);
}
}
s->tone_on = TRUE;
}
else
{
if (s->tone_present == MODEM_CONNECT_TONES_ANS)
{
report_tone_state(s, MODEM_CONNECT_TONES_NONE, -99);
s->good_cycles = 0;
}
else
{
if (s->tone_cycle_duration >= ms_to_samples(450 + 25))
{
/* The change came too late for a cycle of ANS_PR tone */
if (s->tone_present == MODEM_CONNECT_TONES_ANS_PR || s->tone_present == MODEM_CONNECT_TONES_ANSAM_PR)
report_tone_state(s, MODEM_CONNECT_TONES_NONE, -99);
s->good_cycles = 0;
}
}
s->tone_on = FALSE;
}
}
break;
}
return 0;
}
static void v21_put_bit(void *user_data, int bit)
{
modem_connect_tones_rx_state_t *s;
s = (modem_connect_tones_rx_state_t *) user_data;
if (bit < 0)
{
/* Special conditions. */
switch (bit)
{
case SIG_STATUS_CARRIER_DOWN:
/* Only declare tone off, if we were the one to declare tone on. */
if (s->tone_present == MODEM_CONNECT_TONES_FAX_PREAMBLE)
report_tone_state(s, MODEM_CONNECT_TONES_NONE, -99);
/* Fall through */
case SIG_STATUS_CARRIER_UP:
s->raw_bit_stream = 0;
s->num_bits = 0;
s->flags_seen = 0;
s->framing_ok_announced = FALSE;
break;
}
return;
}
/* Look for enough FAX V.21 message preamble (back to back HDLC flag octets) to be sure
we are really seeing preamble, and declare the signal to be present. Any change from
preamble declares the signal to not be present, though it will probably be the body
of the messages following the preamble. */
s->raw_bit_stream = (s->raw_bit_stream << 1) | ((bit << 8) & 0x100);
s->num_bits++;
if ((s->raw_bit_stream & 0x7F00) == 0x7E00)
{
if ((s->raw_bit_stream & 0x8000))
{
/* Hit HDLC abort */
s->flags_seen = 0;
}
else
{
/* Hit HDLC flag */
if (s->flags_seen < HDLC_FRAMING_OK_THRESHOLD)
{
/* Check the flags are back-to-back when testing for valid preamble. This
greatly reduces the chances of false preamble detection, and anything
which doesn't send them back-to-back is badly broken. */
if (s->num_bits != 8)
s->flags_seen = 0;
if (++s->flags_seen >= HDLC_FRAMING_OK_THRESHOLD && !s->framing_ok_announced)
{
report_tone_state(s, MODEM_CONNECT_TONES_FAX_PREAMBLE, lfastrintf(fsk_rx_signal_power(&(s->v21rx))));
s->framing_ok_announced = TRUE;
}
}
}
s->num_bits = 0;
}
else
{
if (s->flags_seen >= HDLC_FRAMING_OK_THRESHOLD)
{
if (s->num_bits == 8)
{
s->framing_ok_announced = FALSE;
s->flags_seen = 0;
}
}
}
}
