SPAN_DECLARE_NONSTD(int) fax_rx_fillin(fax_state_t *s, int len)
{
/* To mitigate the effect of lost packets on a packet network we should
try to sustain the status quo. If there is no receive modem running, keep
things that way. If there is a receive modem running, try to sustain its
operation, without causing a phase hop, or letting its adaptive functions
diverge. */
#if defined(LOG_FAX_AUDIO)
if (s->modems.audio_rx_log >= 0)
{
int i;
#if defined(_MSC_VER)
int16_t *amp = (int16_t *) _alloca(sizeof(int16_t)*len);
#else
int16_t amp[len];
#endif
vec_zeroi16(amp, len);
write(s->modems.audio_rx_log, amp, len*sizeof(int16_t));
}
#endif
/* Call the fillin function of the current modem (if there is one). */
s->modems.rx_fillin_handler(s->modems.rx_fillin_user_data, len);
t30_timer_update(&s->t30, len);
return 0;
}
SPAN_DECLARE(int) fax_rx_fillin(fax_state_t *s, int len)
{
/* To mitigate the effect of lost packets on a packet network we should
try to sustain the status quo. If there is no receive modem running, keep
things that way. If there is a receive modem running, try to sustain its
operation, without causing a phase hop, or letting its adaptive functions
diverge. */
#if defined(LOG_FAX_AUDIO)
if (s->modems.audio_rx_log >= 0)
{
int i;
#if defined(_MSC_VER)
int16_t *amp = (int16_t *) _alloca(sizeof(int16_t)*len);
#else
int16_t amp[len];
#endif
vec_zeroi16(amp, len);
write(s->modems.audio_rx_log, amp, len*sizeof(int16_t));
}
#endif
t30_timer_update(&s->t30, len);
/* Call the fillin function of the current modem (if there is one). */
switch (s->modems.current_rx_type)
{
case T30_MODEM_V21:
len = fsk_rx_fillin(&s->modems.v21_rx, len);
break;
case T30_MODEM_V27TER:
/* TODO: what about FSK in the early stages */
len = v27ter_rx_fillin(&s->modems.v27ter_rx, len);
break;
case T30_MODEM_V29:
/* TODO: what about FSK in the early stages */
len = v29_rx_fillin(&s->modems.v29_rx, len);
break;
case T30_MODEM_V17:
/* TODO: what about FSK in the early stages */
len = v17_rx_fillin(&s->modems.v17_rx, len);
break;
}
return len;
}
SPAN_DECLARE(int) ademco_contactid_sender_tx(ademco_contactid_sender_state_t *s, int16_t amp[], int max_samples)
{
int sample;
int samples;
for (sample = 0; sample < max_samples; sample += samples)
{
switch (s->step)
{
case 0:
if (!s->clear_to_send)
return 0;
s->clear_to_send = false;
s->step++;
s->remaining_samples = ms_to_samples(250);
/* Fall through */
case 1:
samples = (s->remaining_samples > (max_samples - sample)) ? (max_samples - sample) : s->remaining_samples;
vec_zeroi16(&[sample], samples);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "Pre-send silence finished\n");
s->step++;
break;
case 2:
samples = dtmf_tx(&s->dtmf, &[sample], max_samples - sample);
if (samples == 0)
{
s->clear_to_send = false;
s->step = 0;
return sample;
}
break;
default:
return sample;
}
}
return sample;
}
SPAN_DECLARE(int) ademco_contactid_receiver_tx(ademco_contactid_receiver_state_t *s, int16_t amp[], int max_samples)
{
int i;
int samples;
switch (s->step)
{
case 0:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
vec_zeroi16(amp, samples);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "Initial silence finished\n");
s->step++;
s->tone_phase_rate = dds_phase_rate(1400.0);
s->tone_level = dds_scaling_dbm0(-11);
s->tone_phase = 0;
s->remaining_samples = ms_to_samples(100);
return samples;
case 1:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
for (i = 0; i < samples; i++)
amp[i] = dds_mod(&s->tone_phase, s->tone_phase_rate, s->tone_level, 0);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "1400Hz tone finished\n");
s->step++;
s->remaining_samples = ms_to_samples(100);
return samples;
case 2:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
vec_zeroi16(amp, samples);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "Second silence finished\n");
s->step++;
s->tone_phase_rate = dds_phase_rate(2300.0);
s->tone_level = dds_scaling_dbm0(-11);
s->tone_phase = 0;
s->remaining_samples = ms_to_samples(100);
return samples;
case 3:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
for (i = 0; i < samples; i++)
amp[i] = dds_mod(&s->tone_phase, s->tone_phase_rate, s->tone_level, 0);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "2300Hz tone finished\n");
s->step++;
s->remaining_samples = ms_to_samples(100);
return samples;
case 4:
/* Idle here, waiting for a response */
return 0;
case 5:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
vec_zeroi16(amp, samples);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "Sending kissoff\n");
s->step++;
s->tone_phase_rate = dds_phase_rate(1400.0);
s->tone_level = dds_scaling_dbm0(-11);
s->tone_phase = 0;
s->remaining_samples = ms_to_samples(850);
return samples;
case 6:
samples = (s->remaining_samples > max_samples) ? max_samples : s->remaining_samples;
for (i = 0; i < samples; i++)
amp[i] = dds_mod(&s->tone_phase, s->tone_phase_rate, s->tone_level, 0);
s->remaining_samples -= samples;
if (s->remaining_samples > 0)
return samples;
span_log(&s->logging, SPAN_LOG_FLOW, "1400Hz tone finished\n");
s->step = 4;
s->remaining_samples = ms_to_samples(100);
return samples;
}
return max_samples;
}
int main(int argc, char *argv[])
{
v17_rx_state_t *rx;
v17_tx_state_t *tx;
bert_results_t bert_results;
int16_t gen_amp[BLOCK_LEN];
int16_t amp[BLOCK_LEN];
SNDFILE *inhandle;
SNDFILE *outhandle;
int outframes;
int samples;
int tep;
int block_no;
int noise_level;
int signal_level;
int bits_per_test;
int line_model_no;
int log_audio;
int channel_codec;
int rbs_pattern;
int opt;
logging_state_t *logging;
channel_codec = MUNGE_CODEC_NONE;
rbs_pattern = 0;
test_bps = 14400;
tep = FALSE;
line_model_no = 0;
decode_test_file = NULL;
use_gui = FALSE;
noise_level = -70;
signal_level = -13;
bits_per_test = 50000;
log_audio = FALSE;
while ((opt = getopt(argc, argv, "b:B:c:d:glm:n:r:s:t")) != -1)
{
switch (opt)
{
case 'b':
test_bps = atoi(optarg);
if (test_bps != 14400
&&
test_bps != 12000
&&
test_bps != 9600
&&
test_bps != 7200
&&
test_bps != 4800)
{
/* 4800 is an extension of V.17, to provide full coverage of the V.32bis modes */
fprintf(stderr, "Invalid bit rate specified\n");
exit(2);
}
break;
case 'B':
bits_per_test = atoi(optarg);
break;
case 'c':
channel_codec = atoi(optarg);
break;
case 'd':
decode_test_file = optarg;
break;
case 'g':
#if defined(ENABLE_GUI)
use_gui = TRUE;
#else
fprintf(stderr, "Graphical monitoring not available\n");
exit(2);
#endif
break;
case 'l':
log_audio = TRUE;
break;
case 'm':
line_model_no = atoi(optarg);
break;
case 'n':
noise_level = atoi(optarg);
break;
case 'r':
rbs_pattern = atoi(optarg);
break;
case 's':
signal_level = atoi(optarg);
break;
case 't':
tep = TRUE;
break;
default:
//usage();
exit(2);
break;
}
}
inhandle = NULL;
outhandle = NULL;
#if defined(HAVE_FENV_H)
fpe_trap_setup();
#endif
if (log_audio)
{
if ((outhandle = sf_open_telephony_write(OUT_FILE_NAME, 1)) == NULL)
{
fprintf(stderr, " Cannot create audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
}
if (decode_test_file)
{
/* We will decode the audio from a file. */
tx = NULL;
if ((inhandle = sf_open_telephony_read(decode_test_file, 1)) == NULL)
{
fprintf(stderr, " Cannot open audio file '%s'\n", decode_test_file);
exit(2);
}
}
else
{
/* We will generate V.17 audio, and add some noise to it. */
tx = v17_tx_init(NULL, test_bps, tep, v17getbit, NULL);
logging = v17_tx_get_logging_state(tx);
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
span_log_set_tag(logging, "V.17-tx");
v17_tx_power(tx, signal_level);
v17_tx_set_modem_status_handler(tx, v17_tx_status, (void *) tx);
#if defined(WITH_SPANDSP_INTERNALS)
/* Move the carrier off a bit */
tx->carrier_phase_rate = dds_phase_ratef(1792.0f);
tx->carrier_phase = 0x40000000;
#endif
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
one_way_line_model_set_dc(line_model, 0.0f);
#if defined(ADD_MAINS_INTERFERENCE)
one_way_line_model_set_mains_pickup(line_model, 50, -40.0f);
#endif
}
rx = v17_rx_init(NULL, test_bps, v17putbit, NULL);
logging = v17_rx_get_logging_state(rx);
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
span_log_set_tag(logging, "V.17-rx");
v17_rx_set_modem_status_handler(rx, v17_rx_status, (void *) rx);
v17_rx_set_qam_report_handler(rx, qam_report, (void *) rx);
#if defined(ENABLE_GUI)
if (use_gui)
{
qam_monitor = qam_monitor_init(10.0f, NULL);
if (!decode_test_file)
{
start_line_model_monitor(129);
line_model_monitor_line_model_update(line_model->near_filter, line_model->near_filter_len);
}
}
#endif
memset(&latest_results, 0, sizeof(latest_results));
for (block_no = 0; block_no < 100000000; block_no++)
{
if (decode_test_file)
{
samples = sf_readf_short(inhandle, amp, BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_monitor, amp, samples);
#endif
if (samples == 0)
break;
}
else
{
samples = v17_tx(tx, gen_amp, BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_monitor, gen_amp, samples);
#endif
if (samples == 0)
{
printf("Restarting on zero output\n");
/* Push a little silence through, to ensure all the data bits get out of the buffers */
vec_zeroi16(amp, BLOCK_LEN);
v17_rx(rx, amp, BLOCK_LEN);
/* Note that we might get a few bad bits as the carrier shuts down. */
bert_result(&bert, &bert_results);
fprintf(stderr, "Final result %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
/* See if bit errors are appearing yet. Also check we are getting enough bits out of the receiver. The last regular report
should be error free, though the final report will generally contain bits errors as the carrier was dying. The total
number of bits out of the receiver should be at least the number we sent. Also, since BERT sync should have occurred
rapidly at the start of transmission, the last report should have occurred at not much less than the total number of
bits we sent. */
if (bert_results.total_bits < bits_per_test
||
latest_results.total_bits < bits_per_test - 100
||
latest_results.bad_bits != 0)
{
break;
}
memset(&latest_results, 0, sizeof(latest_results));
#if defined(WITH_SPANDSP_INTERNALS)
signal_level--;
/* Bump the receiver AGC gain by 1dB, to compensate for the above */
rx->agc_scaling_save *= 1.122f;
#endif
v17_tx_restart(tx, test_bps, tep, TRUE);
v17_tx_power(tx, signal_level);
v17_rx_restart(rx, test_bps, TRUE);
//rx.eq_put_step = rand()%(192*10/3);
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
one_way_line_model_release(line_model);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
}
if (log_audio)
{
outframes = sf_writef_short(outhandle, gen_amp, samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing audio file\n");
exit(2);
}
}
one_way_line_model(line_model, amp, gen_amp, samples);
}
#if defined(ENABLE_GUI)
if (use_gui && !decode_test_file)
line_model_monitor_line_spectrum_update(amp, samples);
#endif
v17_rx(rx, amp, samples);
}
if (!decode_test_file)
{
bert_result(&bert, &bert_results);
fprintf(stderr, "At completion:\n");
fprintf(stderr, "Final result %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
one_way_line_model_release(line_model);
if (signal_level > -43)
{
printf("Tests failed.\n");
exit(2);
}
printf("Tests passed.\n");
}
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(qam_monitor);
#endif
if (decode_test_file)
{
if (sf_close_telephony(inhandle))
{
fprintf(stderr, " Cannot close audio file '%s'\n", decode_test_file);
exit(2);
}
}
if (log_audio)
{
if (sf_close_telephony(outhandle))
{
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
}
return 0;
}
SPAN_DECLARE(int) sig_tone_tx(sig_tone_tx_state_t *s, int16_t amp[], int len)
{
int i;
int j;
int k;
int n;
int16_t tone;
int need_update;
int high_low;
for (i = 0; i < len; i += n)
{
if (s->current_tx_timeout)
{
if (s->current_tx_timeout <= len - i)
{
n = s->current_tx_timeout;
need_update = TRUE;
}
else
{
n = len - i;
need_update = FALSE;
}
s->current_tx_timeout -= n;
}
else
{
n = len - i;
need_update = FALSE;
}
if (!(s->current_tx_tone & SIG_TONE_TX_PASSTHROUGH))
vec_zeroi16(&[i], n);
/*endif*/
if ((s->current_tx_tone & (SIG_TONE_1_PRESENT | SIG_TONE_2_PRESENT)))
{
/* Are we in the early phase (high tone energy level), or the sustaining
phase (low tone energy level) of tone generation? */
/* This doesn't try to get the high/low timing precise, as there is no
value in doing so. It works block by block, and the blocks are normally
quite short. */
if (s->high_low_timer > 0)
{
if (n > s->high_low_timer)
n = s->high_low_timer;
s->high_low_timer -= n;
high_low = 0;
}
else
{
high_low = 1;
}
/*endif*/
for (k = 0; k < s->desc->tones; k++)
{
if ((s->current_tx_tone & tone_present_bits[k]) && s->phase_rate[k])
{
for (j = i; j < i + n; j++)
{
tone = dds_mod(&s->phase_acc[k], s->phase_rate[k], s->tone_scaling[k][high_low], 0);
amp[j] = saturated_add16(amp[j], tone);
}
/*endfor*/
}
/*endif*/
}
}
/*endif*/
if (need_update && s->sig_update)
s->sig_update(s->user_data, SIG_TONE_TX_UPDATE_REQUEST, 0, 0);
/*endif*/
}
/*endfor*/
return len;
}
static int v8_calls_non_v8_tests(SNDFILE *outhandle)
{
v8_state_t *v8_caller;
modem_connect_tones_tx_state_t *non_v8_answerer_tx;
logging_state_t *caller_logging;
int caller_available_modulations;
int i;
int samples;
int outframes;
int16_t amp[SAMPLES_PER_CHUNK];
int16_t out_amp[2*SAMPLES_PER_CHUNK];
v8_parms_t v8_call_parms;
caller_available_modulations = V8_MOD_V17
| V8_MOD_V21
| V8_MOD_V22
| V8_MOD_V23HDX
| V8_MOD_V23
| V8_MOD_V26BIS
| V8_MOD_V26TER
| V8_MOD_V27TER
| V8_MOD_V29
| V8_MOD_V32
| V8_MOD_V34HDX
| V8_MOD_V34
| V8_MOD_V90
| V8_MOD_V92;
negotiations_ok = 0;
v8_call_parms.modem_connect_tone = MODEM_CONNECT_TONES_NONE;
v8_call_parms.send_ci = true;
v8_call_parms.v92 = -1;
v8_call_parms.call_function = V8_CALL_V_SERIES;
v8_call_parms.modulations = caller_available_modulations;
v8_call_parms.protocol = V8_PROTOCOL_LAPM_V42;
v8_call_parms.pcm_modem_availability = 0;
v8_call_parms.pstn_access = 0;
v8_call_parms.nsf = -1;
v8_call_parms.t66 = -1;
v8_caller = v8_init(NULL,
true,
&v8_call_parms,
handler,
(void *) "caller");
non_v8_answerer_tx = modem_connect_tones_tx_init(NULL, MODEM_CONNECT_TONES_ANS_PR);
caller_logging = v8_get_logging_state(v8_caller);
span_log_set_level(caller_logging, SPAN_LOG_FLOW | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(caller_logging, "caller");
for (i = 0; i < 1000; i++)
{
samples = v8_tx(v8_caller, amp, SAMPLES_PER_CHUNK);
if (samples < SAMPLES_PER_CHUNK)
{
vec_zeroi16(amp + samples, SAMPLES_PER_CHUNK - samples);
samples = SAMPLES_PER_CHUNK;
}
/*endif*/
span_log_bump_samples(caller_logging, samples);
for (i = 0; i < samples; i++)
out_amp[2*i] = amp[i];
/*endfor*/
samples = modem_connect_tones_tx(non_v8_answerer_tx, amp, SAMPLES_PER_CHUNK);
if (samples < SAMPLES_PER_CHUNK)
{
vec_zeroi16(amp + samples, SAMPLES_PER_CHUNK - samples);
samples = SAMPLES_PER_CHUNK;
}
/*endif*/
if (v8_rx(v8_caller, amp, samples))
break;
/*endif*/
for (i = 0; i < samples; i++)
out_amp[2*i + 1] = amp[i];
/*endfor*/
if (outhandle)
{
outframes = sf_writef_short(outhandle, out_amp, samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing audio file\n");
exit(2);
}
/*endif*/
}
/*endif*/
}
/*endfor*/
v8_free(v8_caller);
modem_connect_tones_tx_free(non_v8_answerer_tx);
if (negotiations_ok != 42)
{
printf("Tests failed.\n");
exit(2);
}
/*endif*/
return 0;
}
static int non_v8_calls_v8_tests(SNDFILE *outhandle)
{
silence_gen_state_t *non_v8_caller_tx;
modem_connect_tones_rx_state_t *non_v8_caller_rx;
v8_state_t *v8_answerer;
logging_state_t *answerer_logging;
int answerer_available_modulations;
int i;
int samples;
int remnant;
int outframes;
int tone;
int16_t amp[SAMPLES_PER_CHUNK];
int16_t out_amp[2*SAMPLES_PER_CHUNK];
v8_parms_t v8_answer_parms;
answerer_available_modulations = V8_MOD_V17
| V8_MOD_V21
| V8_MOD_V22
| V8_MOD_V23HDX
| V8_MOD_V23
| V8_MOD_V26BIS
| V8_MOD_V26TER
| V8_MOD_V27TER
| V8_MOD_V29
| V8_MOD_V32
| V8_MOD_V34HDX
| V8_MOD_V34
| V8_MOD_V90
| V8_MOD_V92;
negotiations_ok = 0;
non_v8_caller_tx = silence_gen_init(NULL, 10*SAMPLE_RATE);
non_v8_caller_rx = modem_connect_tones_rx_init(NULL, MODEM_CONNECT_TONES_ANS_PR, NULL, NULL);
v8_answer_parms.modem_connect_tone = MODEM_CONNECT_TONES_ANSAM_PR;
v8_answer_parms.send_ci = true;
v8_answer_parms.v92 = -1;
v8_answer_parms.call_function = V8_CALL_V_SERIES;
v8_answer_parms.modulations = answerer_available_modulations;
v8_answer_parms.protocol = V8_PROTOCOL_LAPM_V42;
v8_answer_parms.pcm_modem_availability = 0;
v8_answer_parms.pstn_access = 0;
v8_answer_parms.nsf = -1;
v8_answer_parms.t66 = -1;
v8_answerer = v8_init(NULL,
false,
&v8_answer_parms,
handler,
(void *) "answerer");
answerer_logging = v8_get_logging_state(v8_answerer);
span_log_set_level(answerer_logging, SPAN_LOG_FLOW | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(answerer_logging, "answerer");
for (i = 0; i < 1000; i++)
{
samples = silence_gen(non_v8_caller_tx, amp, SAMPLES_PER_CHUNK);
if (samples < SAMPLES_PER_CHUNK)
{
vec_zeroi16(amp + samples, SAMPLES_PER_CHUNK - samples);
samples = SAMPLES_PER_CHUNK;
}
/*endif*/
remnant = v8_rx(v8_answerer, amp, samples);
if (remnant)
break;
/*endif*/
for (i = 0; i < samples; i++)
out_amp[2*i] = amp[i];
/*endfor*/
samples = v8_tx(v8_answerer, amp, SAMPLES_PER_CHUNK);
if (samples < SAMPLES_PER_CHUNK)
{
vec_zeroi16(amp + samples, SAMPLES_PER_CHUNK - samples);
samples = SAMPLES_PER_CHUNK;
}
/*endif*/
span_log_bump_samples(answerer_logging, samples);
modem_connect_tones_rx(non_v8_caller_rx, amp, samples);
if ((tone = modem_connect_tones_rx_get(non_v8_caller_rx)) != MODEM_CONNECT_TONES_NONE)
{
printf("Detected %s (%d)\n", modem_connect_tone_to_str(tone), tone);
if (tone == MODEM_CONNECT_TONES_ANSAM_PR)
negotiations_ok++;
/*endif*/
}
/*endif*/
for (i = 0; i < samples; i++)
out_amp[2*i + 1] = amp[i];
/*endfor*/
if (outhandle)
{
outframes = sf_writef_short(outhandle, out_amp, samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing audio file\n");
exit(2);
}
/*endif*/
}
/*endif*/
}
/*endfor*/
silence_gen_free(non_v8_caller_tx);
modem_connect_tones_rx_free(non_v8_caller_rx);
v8_free(v8_answerer);
if (negotiations_ok != 1)
{
printf("Tests failed.\n");
exit(2);
}
/*endif*/
return 0;
}
int main(int argc, char *argv[])
{
int16_t silence[SAMPLES_PER_CHUNK];
int16_t t30_amp[2][SAMPLES_PER_CHUNK];
int16_t t38_amp[2][SAMPLES_PER_CHUNK];
int16_t t38_amp_hist_a[8][SAMPLES_PER_CHUNK];
int16_t t38_amp_hist_b[8][SAMPLES_PER_CHUNK];
int16_t out_amp[SAMPLES_PER_CHUNK*4];
int16_t *fax_rx_buf[2];
int16_t *fax_tx_buf[2];
int16_t *t38_gateway_rx_buf[2];
int16_t *t38_gateway_tx_buf[2];
int t30_len[2];
int t38_len[2];
int hist_ptr;
int log_audio;
int msg_len;
uint8_t msg[1024];
int outframes;
SNDFILE *wave_handle;
SNDFILE *input_wave_handle;
int use_ecm;
int use_tep;
int feedback_audio;
int use_transmit_on_idle;
int t38_version;
const char *input_tiff_file_name;
const char *decode_file_name;
int i;
int j;
int seq_no;
int g1050_model_no;
int g1050_speed_pattern_no;
int t38_transport;
double tx_when;
double rx_when;
int supported_modems;
int remove_fill_bits;
int opt;
int start_page;
int end_page;
int drop_frame;
int drop_frame_rate;
float signal_scaling;
int signal_level;
int noise_level;
int code_to_look_up;
int scan_line_time;
int allowed_bilevel_resolutions;
int colour_enabled;
t38_stats_t t38_stats;
t30_stats_t t30_stats;
logging_state_t *logging;
int expected_pages;
char *page_header_info;
char *page_header_tz;
const char *tag;
char buf[132 + 1];
#if defined(ENABLE_GUI)
int use_gui;
#endif
#if defined(ENABLE_GUI)
use_gui = false;
#endif
log_audio = false;
use_ecm = false;
t38_version = 1;
input_tiff_file_name = INPUT_TIFF_FILE_NAME;
t38_simulate_incrementing_repeats = false;
g1050_model_no = 0;
g1050_speed_pattern_no = 1;
remove_fill_bits = false;
use_tep = false;
feedback_audio = false;
use_transmit_on_idle = true;
supported_modems = T30_SUPPORT_V27TER | T30_SUPPORT_V29 | T30_SUPPORT_V17;
page_header_info = NULL;
page_header_tz = NULL;
drop_frame = 0;
drop_frame_rate = 0;
start_page = -1;
end_page = -1;
signal_level = 0;
noise_level = -99;
scan_line_time = 0;
decode_file_name = NULL;
code_to_look_up = -1;
allowed_bilevel_resolutions = 0;
colour_enabled = false;
t38_transport = T38_TRANSPORT_UDPTL;
while ((opt = getopt(argc, argv, "b:c:Cd:D:efFgH:i:Ilm:M:n:p:s:S:tT:u:v:z:")) != -1)
{
switch (opt)
{
case 'b':
allowed_bilevel_resolutions = atoi(optarg);
break;
case 'c':
code_to_look_up = atoi(optarg);
break;
case 'C':
colour_enabled = true;
break;
case 'd':
decode_file_name = optarg;
break;
case 'D':
drop_frame_rate =
drop_frame = atoi(optarg);
break;
case 'e':
use_ecm = true;
break;
case 'f':
feedback_audio = true;
break;
case 'F':
remove_fill_bits = true;
break;
case 'g':
#if defined(ENABLE_GUI)
use_gui = true;
#else
fprintf(stderr, "Graphical monitoring not available\n");
exit(2);
#endif
break;
case 'H':
page_header_info = optarg;
break;
case 'i':
input_tiff_file_name = optarg;
break;
case 'I':
t38_simulate_incrementing_repeats = true;
break;
case 'l':
log_audio = true;
break;
case 'm':
supported_modems = atoi(optarg);
break;
case 'M':
g1050_model_no = optarg[0] - 'A' + 1;
break;
case 'n':
noise_level = atoi(optarg);
break;
case 'p':
for (i = 0; i < 2; i++)
{
switch (optarg[i])
{
case 'A':
mode[i] = AUDIO_FAX;
break;
case 'G':
mode[i] = T38_GATEWAY_FAX;
break;
case 'T':
mode[i] = T38_TERMINAL_FAX;
break;
default:
fprintf(stderr, "Unknown FAX path element %c\n", optarg[i]);
exit(2);
}
}
if ((mode[0] == AUDIO_FAX && mode[1] != AUDIO_FAX)
||
(mode[0] != AUDIO_FAX && mode[1] == AUDIO_FAX))
{
fprintf(stderr, "Invalid FAX path %s\n", optarg);
exit(2);
}
break;
case 's':
g1050_speed_pattern_no = atoi(optarg);
break;
#if 0
case 's':
signal_level = atoi(optarg);
break;
#endif
case 'S':
scan_line_time = atoi(optarg);
break;
case 't':
use_tep = true;
break;
case 'T':
start_page = 0;
end_page = atoi(optarg);
break;
case 'u':
if (strcasecmp(optarg, "udptl") == 0)
t38_transport = T38_TRANSPORT_UDPTL;
else if (strcasecmp(optarg, "rtp") == 0)
t38_transport = T38_TRANSPORT_RTP;
else if (strcasecmp(optarg, "tcp") == 0)
t38_transport = T38_TRANSPORT_TCP;
else if (strcasecmp(optarg, "tcp-tpkt") == 0)
t38_transport = T38_TRANSPORT_TCP_TPKT;
else
{
fprintf(stderr, "Unknown T.38 transport mode\n");
exit(2);
}
break;
case 'v':
t38_version = atoi(optarg);
break;
case 'z':
page_header_tz = optarg;
break;
default:
//usage();
exit(2);
break;
}
}
if (code_to_look_up >= 0)
{
printf("Result code %d is %s\n", code_to_look_up, t30_completion_code_to_str(code_to_look_up));
exit(0);
}
printf("Using T.38 version %d\n", t38_version);
if (use_ecm)
printf("Using ECM\n");
wave_handle = NULL;
if (log_audio)
{
if ((wave_handle = sf_open_telephony_write(OUTPUT_WAVE_FILE_NAME, 4)) == NULL)
{
fprintf(stderr, " Cannot create audio file '%s'\n", OUTPUT_WAVE_FILE_NAME);
exit(2);
}
}
memset(silence, 0, sizeof(silence));
srand48(0x1234567);
/* Set up the nodes */
input_wave_handle = NULL;
if (mode[0] == T38_TERMINAL_FAX)
{
}
else
{
if (decode_file_name)
{
if ((input_wave_handle = sf_open_telephony_read(decode_file_name, 1)) == NULL)
{
fprintf(stderr, " Cannot open audio file '%s'\n", decode_file_name);
exit(2);
}
}
}
for (i = 0; i < 2; i++)
{
tag = (i == 0) ? "A" : "B";
memset(&expected_rx_info[i], 0, sizeof(expected_rx_info[i]));
if (mode[i] == T38_TERMINAL_FAX)
{
if ((t38_state[i] = t38_terminal_init(NULL, (i == 0), tx_packet_handler, (void *) (intptr_t) i)) == NULL)
{
fprintf(stderr, "Cannot start the T.38 terminal instance\n");
exit(2);
}
t30_state[i] = t38_terminal_get_t30_state(t38_state[i]);
t38_core_state[i] = t38_terminal_get_t38_core_state(t38_state[i]);
logging = t38_terminal_get_logging_state(t38_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = t38_core_get_logging_state(t38_core_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = t30_get_logging_state(t30_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
}
else
{
if ((fax_state[i] = fax_init(NULL, (i == 0))) == NULL)
{
fprintf(stderr, "Cannot start FAX instance\n");
exit(2);
}
t30_state[i] = fax_get_t30_state(fax_state[i]);
logging = fax_get_logging_state(fax_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = fax_modems_get_logging_state(&fax_state[i]->modems);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = t30_get_logging_state(t30_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
if (mode[i] == T38_GATEWAY_FAX)
{
if ((t38_gateway_state[i] = t38_gateway_init(NULL, tx_packet_handler, (void *) (intptr_t) i)) == NULL)
{
fprintf(stderr, "Cannot start the T.38 gateway instancel\n");
exit(2);
}
t38_core_state[i] = t38_gateway_get_t38_core_state(t38_gateway_state[i]);
logging = t38_gateway_get_logging_state(t38_gateway_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = fax_modems_get_logging_state(&t38_gateway_state[i]->audio.modems);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
logging = t38_core_get_logging_state(t38_core_state[i]);
span_log_set_level(logging, SPAN_LOG_DEBUG | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME);
span_log_set_tag(logging, tag);
fax_rx_buf[i] = t38_amp[i];
fax_tx_buf[i] = t30_amp[i];
t38_gateway_rx_buf[i] = t30_amp[i];
t38_gateway_tx_buf[i] = t38_amp[i];
}
else
{
fax_rx_buf[i] = t30_amp[i];
fax_tx_buf[i] = t30_amp[i ^ 1];
t38_gateway_rx_buf[i] = NULL;
t38_gateway_tx_buf[i] = NULL;
}
awgn_state[i] = NULL;
signal_scaling = 1.0f;
if (noise_level > -99)
{
awgn_state[i] = awgn_init_dbm0(NULL, 1234567, noise_level);
signal_scaling = powf(10.0f, signal_level/20.0f);
printf("Signal scaling %f\n", signal_scaling);
}
}
set_t30_callbacks(t30_state[i], i);
}
/* Set up the channels */
for (i = 0; i < 2; i++)
{
if ((g1050_path[i] = g1050_init(g1050_model_no, g1050_speed_pattern_no, 100, 33)) == NULL)
{
fprintf(stderr, "Failed to start IP network path model\n");
exit(2);
}
memset(audio_buffer[2*i], 0, SAMPLES_PER_CHUNK*sizeof(int16_t));
memset(audio_buffer[2*i + 1], 0, SAMPLES_PER_CHUNK*sizeof(int16_t));
memset(t30_amp[i], 0, sizeof(t30_amp[i]));
memset(t38_amp[i], 0, sizeof(t38_amp[i]));
}
memset(t38_amp_hist_a, 0, sizeof(t38_amp_hist_a));
memset(t38_amp_hist_b, 0, sizeof(t38_amp_hist_b));
for (i = 0; i < 2; i++)
{
j = i + 1;
sprintf(buf, "%d%d%d%d%d%d%d%d", j, j, j, j, j, j, j, j);
t30_set_tx_ident(t30_state[i], buf);
strcpy(expected_rx_info[i ^ 1].ident, buf);
sprintf(buf, "Sub-address %d", j);
t30_set_tx_sub_address(t30_state[i], buf);
//strcpy(expected_rx_info[i ^ 1].sub_address, buf);
sprintf(buf, "Sender ID %d", j);
t30_set_tx_sender_ident(t30_state[i], buf);
//strcpy(expected_rx_info[i ^ 1].sender_ident, buf);
sprintf(buf, "Password %d", j);
t30_set_tx_password(t30_state[i], buf);
//strcpy(expected_rx_info[i ^ 1].password, buf);
sprintf(buf, "Polled sub-add %d", j);
t30_set_tx_polled_sub_address(t30_state[i], buf);
//strcpy(expected_rx_info[i ^ 1].polled_sub_address, buf);
sprintf(buf, "Select poll add %d", j);
t30_set_tx_selective_polling_address(t30_state[i], buf);
//strcpy(expected_rx_info[i ^ 1].selective_polling_address, buf);
t30_set_tx_page_header_info(t30_state[i], page_header_info);
if (page_header_tz)
t30_set_tx_page_header_tz(t30_state[i], page_header_tz);
if ((i & 1) == 1)
{
t30_set_tx_nsf(t30_state[i], (const uint8_t *) "\x50\x00\x00\x00Spandsp\x00", 12);
expected_rx_info[i ^ 1].nsf = (uint8_t *) "\x50\x00\x00\x00Spandsp\x00";
expected_rx_info[i ^ 1].nsf_len = 12;
}
t30_set_supported_modems(t30_state[i], supported_modems);
t30_set_supported_t30_features(t30_state[i],
T30_SUPPORT_IDENTIFICATION
| T30_SUPPORT_SELECTIVE_POLLING
| T30_SUPPORT_SUB_ADDRESSING);
t30_set_supported_image_sizes(t30_state[i],
T4_SUPPORT_WIDTH_215MM
| T4_SUPPORT_WIDTH_255MM
| T4_SUPPORT_WIDTH_303MM
| T4_SUPPORT_LENGTH_US_LETTER
| T4_SUPPORT_LENGTH_US_LEGAL
| T4_SUPPORT_LENGTH_UNLIMITED);
switch (allowed_bilevel_resolutions)
{
case 0:
/* Allow anything */
t30_set_supported_bilevel_resolutions(t30_state[i],
T4_RESOLUTION_R8_STANDARD
| T4_RESOLUTION_R8_FINE
| T4_RESOLUTION_R8_SUPERFINE
| T4_RESOLUTION_R16_SUPERFINE
| T4_RESOLUTION_200_100
| T4_RESOLUTION_200_200
| T4_RESOLUTION_200_400
| T4_RESOLUTION_300_300
| T4_RESOLUTION_300_600
| T4_RESOLUTION_400_400
| T4_RESOLUTION_400_800
| T4_RESOLUTION_600_600
| T4_RESOLUTION_600_1200
| T4_RESOLUTION_1200_1200);
break;
case 1:
/* Allow anything metric */
t30_set_supported_bilevel_resolutions(t30_state[i],
T4_RESOLUTION_R8_STANDARD
| T4_RESOLUTION_R8_FINE
| T4_RESOLUTION_R8_SUPERFINE
| T4_RESOLUTION_R16_SUPERFINE);
break;
case 2:
/* Allow anything inch based */
t30_set_supported_bilevel_resolutions(t30_state[i],
T4_RESOLUTION_200_100
| T4_RESOLUTION_200_200
| T4_RESOLUTION_200_400
| T4_RESOLUTION_300_300
| T4_RESOLUTION_300_600
| T4_RESOLUTION_400_400
| T4_RESOLUTION_400_800
| T4_RESOLUTION_600_600
| T4_RESOLUTION_600_1200
| T4_RESOLUTION_1200_1200);
break;
case 3:
/* Allow only restricted length resolution */
t30_set_supported_bilevel_resolutions(t30_state[i],
T4_RESOLUTION_R8_STANDARD
| T4_RESOLUTION_R8_FINE
| T4_RESOLUTION_200_100
| T4_RESOLUTION_200_200);
break;
case 4:
/* Allow only more restricted length resolution */
t30_set_supported_bilevel_resolutions(t30_state[i],
T4_RESOLUTION_R8_STANDARD
| T4_RESOLUTION_200_100);
break;
}
if (colour_enabled)
{
t30_set_supported_colour_resolutions(t30_state[i],
T4_RESOLUTION_100_100
| T4_RESOLUTION_200_200
| T4_RESOLUTION_300_300
| T4_RESOLUTION_400_400
| T4_RESOLUTION_600_600
| T4_RESOLUTION_1200_1200);
}
else
{
t30_set_supported_colour_resolutions(t30_state[i], 0);
}
//t30_set_supported_output_compressions(t30_state[i], T4_COMPRESSION_T85);
t30_set_ecm_capability(t30_state[i], use_ecm);
t30_set_supported_compressions(t30_state[i],
T4_COMPRESSION_T4_1D
| T4_COMPRESSION_T4_2D
| T4_COMPRESSION_T6
| T4_COMPRESSION_T85
| T4_COMPRESSION_T85_L0
//| T4_COMPRESSION_T88
| T4_COMPRESSION_T43
| T4_COMPRESSION_T45
| T4_COMPRESSION_T42_T81
| T4_COMPRESSION_SYCC_T81
| T4_COMPRESSION_GRAYSCALE
| T4_COMPRESSION_COLOUR
| T4_COMPRESSION_12BIT
| T4_COMPRESSION_COLOUR_TO_GRAY
| T4_COMPRESSION_GRAY_TO_BILEVEL
| T4_COMPRESSION_COLOUR_TO_BILEVEL
| T4_COMPRESSION_RESCALING
| 0);
t30_set_minimum_scan_line_time(t30_state[i], scan_line_time);
if (mode[i] == T38_GATEWAY_FAX)
{
t38_gateway_set_transmit_on_idle(t38_gateway_state[i], use_transmit_on_idle);
t38_gateway_set_supported_modems(t38_gateway_state[i], supported_modems);
//t38_gateway_set_nsx_suppression(t38_state[i], NULL, 0, NULL, 0);
t38_gateway_set_fill_bit_removal(t38_gateway_state[i], remove_fill_bits);
t38_gateway_set_real_time_frame_handler(t38_gateway_state[i], real_time_gateway_frame_handler, (void *) (intptr_t) i);
t38_gateway_set_ecm_capability(t38_gateway_state[i], use_ecm);
}
if (mode[i] != AUDIO_FAX)
{
t38_set_t38_version(t38_core_state[i], t38_version);
}
if (mode[i] == T38_TERMINAL_FAX)
{
//t30_set_iaf_mode(t30_state[i], T30_IAF_MODE_NO_FILL_BITS);
switch (t38_transport)
{
case T38_TRANSPORT_UDPTL:
case T38_TRANSPORT_RTP:
t38_terminal_set_fill_bit_removal(t38_state[i], remove_fill_bits);
t38_terminal_set_tep_mode(t38_state[i], use_tep);
break;
case T38_TRANSPORT_TCP:
case T38_TRANSPORT_TCP_TPKT:
t38_terminal_set_fill_bit_removal(t38_state[i], true);
t38_terminal_set_config(t38_state[i], T38_TERMINAL_OPTION_NO_PACING | T38_TERMINAL_OPTION_NO_INDICATORS);
t38_terminal_set_tep_mode(t38_state[i], false);
break;
}
}
else
{
fax_set_transmit_on_idle(fax_state[i], use_transmit_on_idle);
fax_set_tep_mode(fax_state[i], use_tep);
}
}
t30_set_tx_file(t30_state[0], input_tiff_file_name, start_page, end_page);
t30_set_rx_file(t30_state[1], OUTPUT_TIFF_FILE_NAME, -1);
#if defined(ENABLE_GUI)
if (use_gui)
start_media_monitor();
#endif
hist_ptr = 0;
for (;;)
{
memset(out_amp, 0, sizeof(out_amp));
for (i = 0; i < 2; i++)
{
/* Update T.30 timing */
logging = t30_get_logging_state(t30_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
if (mode[i] == T38_TERMINAL_FAX)
{
/* Update T.38 termination timing */
logging = t38_terminal_get_logging_state(t38_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
logging = t38_core_get_logging_state(t38_core_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
completed[i] = t38_terminal_send_timeout(t38_state[i], SAMPLES_PER_CHUNK);
}
else
{
/* Update audio FAX timing */
logging = fax_get_logging_state(fax_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
#if 0
/* Mute the signal */
vec_zeroi16(fax_rx_buf[i], SAMPLES_PER_CHUNK);
#endif
fax_rx(fax_state[i], fax_rx_buf[i], SAMPLES_PER_CHUNK);
if (!t30_call_active(t30_state[i]))
{
completed[i] = true;
continue;
}
if (i == 0 && input_wave_handle)
{
t30_len[i] = sf_readf_short(input_wave_handle, fax_tx_buf[i], SAMPLES_PER_CHUNK);
if (t30_len[i] == 0)
break;
}
else
{
t30_len[i] = fax_tx(fax_state[i], fax_tx_buf[i], SAMPLES_PER_CHUNK);
if (!use_transmit_on_idle)
{
/* The receive side always expects a full block of samples, but the
transmit side may not be sending any when it doesn't need to. We
may need to pad with some silence. */
if (t30_len[i] < SAMPLES_PER_CHUNK)
{
memset(t30_amp[i] + t30_len[i], 0, sizeof(int16_t)*(SAMPLES_PER_CHUNK - t30_len[i]));
t30_len[i] = SAMPLES_PER_CHUNK;
}
}
if (awgn_state[i])
{
for (j = 0; j < t30_len[i]; j++)
fax_tx_buf[i][j] = ((int16_t) (fax_tx_buf[i][j]*signal_scaling)) + awgn(awgn_state[i]);
}
}
if (log_audio)
{
for (j = 0; j < t30_len[i]; j++)
out_amp[4*j + 2*i] = t30_amp[i][j];
}
if (feedback_audio)
{
for (j = 0; j < t30_len[i]; j++)
t30_amp[i][j] += t38_amp_hist_a[hist_ptr][j] >> 1;
memcpy(t38_amp_hist_a[hist_ptr], t38_amp[i], sizeof(int16_t)*SAMPLES_PER_CHUNK);
}
if (mode[i] == T38_GATEWAY_FAX)
{
/* Update T.38 gateway timing */
logging = t38_gateway_get_logging_state(t38_gateway_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
logging = t38_core_get_logging_state(t38_core_state[i]);
span_log_bump_samples(logging, SAMPLES_PER_CHUNK);
if (drop_frame_rate && --drop_frame == 0)
{
drop_frame = drop_frame_rate;
if (t38_gateway_rx_fillin(t38_gateway_state[i], SAMPLES_PER_CHUNK))
break;
}
else
{
if (t38_gateway_rx(t38_gateway_state[i], t38_gateway_rx_buf[i], SAMPLES_PER_CHUNK))
break;
}
t38_len[i] = t38_gateway_tx(t38_gateway_state[i], t38_gateway_tx_buf[i], SAMPLES_PER_CHUNK);
if (!use_transmit_on_idle)
{
if (t38_len[i] < SAMPLES_PER_CHUNK)
{
memset(t38_amp[i] + t38_len[i], 0, sizeof(int16_t)*(SAMPLES_PER_CHUNK - t38_len[i]));
t38_len[i] = SAMPLES_PER_CHUNK;
}
}
if (feedback_audio)
{
for (j = 0; j < t30_len[i]; j++)
t30_amp[i][j] += t38_amp_hist_a[hist_ptr][j] >> 1;
memcpy(t38_amp_hist_a[hist_ptr], t38_amp[i], sizeof(int16_t)*SAMPLES_PER_CHUNK);
}
if (log_audio)
{
for (j = 0; j < t38_len[i]; j++)
out_amp[4*j + 2*i + 1] = t38_amp[i][j];
}
}
}
if (mode[i] != AUDIO_FAX)
{
while ((msg_len = g1050_get(g1050_path[i], msg, 1024, when, &seq_no, &tx_when, &rx_when)) >= 0)
{
#if defined(ENABLE_GUI)
if (use_gui)
media_monitor_rx(seq_no, tx_when, rx_when);
#endif
t38_core_rx_ifp_packet(t38_core_state[i ^ 1], msg, msg_len, seq_no);
}
}
}
if (log_audio)
{
outframes = sf_writef_short(wave_handle, out_amp, SAMPLES_PER_CHUNK);
if (outframes != SAMPLES_PER_CHUNK)
break;
}
when += (float) SAMPLES_PER_CHUNK/(float) SAMPLE_RATE;
if (completed[0] && completed[1])
break;
#if defined(ENABLE_GUI)
if (use_gui)
media_monitor_update_display();
#endif
if (++hist_ptr > 3)
hist_ptr = 0;
}
