int main(int argc, char *argv[])
{
fsk_tx_state_t *caller_tx;
fsk_rx_state_t *caller_rx;
fsk_tx_state_t *answerer_tx;
fsk_rx_state_t *answerer_rx;
bert_state_t caller_bert;
bert_state_t answerer_bert;
bert_results_t bert_results;
power_meter_t caller_meter;
power_meter_t answerer_meter;
int16_t caller_amp[BLOCK_LEN];
int16_t answerer_amp[BLOCK_LEN];
int16_t caller_model_amp[BLOCK_LEN];
int16_t answerer_model_amp[BLOCK_LEN];
int16_t out_amp[2*BLOCK_LEN];
AFfilehandle inhandle;
AFfilehandle outhandle;
int outframes;
int i;
int j;
int samples;
int test_bps;
int noise_level;
int noise_sweep;
int bits_per_test;
int line_model_no;
int modem_under_test_1;
int modem_under_test_2;
int modems_set;
int log_audio;
int channel_codec;
int rbs_pattern;
int on_at;
int off_at;
tone_gen_descriptor_t tone_desc;
tone_gen_state_t tone_tx;
int opt;
channel_codec = MUNGE_CODEC_NONE;
rbs_pattern = 0;
line_model_no = 0;
decode_test_file = NULL;
noise_sweep = FALSE;
modem_under_test_1 = FSK_V21CH1;
modem_under_test_2 = FSK_V21CH2;
log_audio = FALSE;
modems_set = 0;
while ((opt = getopt(argc, argv, "c:dlm:nr:s:")) != -1)
{
switch (opt)
{
case 'c':
channel_codec = atoi(optarg);
break;
case 'd':
decode_test_file = optarg;
break;
case 'l':
log_audio = TRUE;
break;
case 'm':
line_model_no = atoi(optarg);
break;
case 'n':
noise_sweep = TRUE;
break;
case 'r':
rbs_pattern = atoi(optarg);
break;
case 's':
switch (modems_set++)
{
case 0:
modem_under_test_1 = atoi(optarg);
break;
case 1:
modem_under_test_2 = atoi(optarg);
break;
}
break;
default:
//usage();
exit(2);
break;
}
}
if (modem_under_test_1 >= 0)
printf("Modem channel 1 is '%s'\n", preset_fsk_specs[modem_under_test_1].name);
if (modem_under_test_2 >= 0)
printf("Modem channel 2 is '%s'\n", preset_fsk_specs[modem_under_test_2].name);
outhandle = AF_NULL_FILEHANDLE;
if (log_audio)
{
if ((outhandle = afOpenFile_telephony_write(OUTPUT_FILE_NAME, 2)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
}
noise_level = -200;
bits_per_test = 0;
inhandle = NULL;
memset(caller_amp, 0, sizeof(*caller_amp));
memset(answerer_amp, 0, sizeof(*answerer_amp));
memset(caller_model_amp, 0, sizeof(*caller_model_amp));
memset(answerer_model_amp, 0, sizeof(*answerer_model_amp));
power_meter_init(&caller_meter, 7);
power_meter_init(&answerer_meter, 7);
if (decode_test_file)
{
if ((inhandle = afOpenFile_telephony_read(decode_test_file, 1)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", decode_test_file);
exit(2);
}
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, put_bit, NULL);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
for (;;)
{
samples = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
caller_model_amp,
BLOCK_LEN);
if (samples < BLOCK_LEN)
break;
for (i = 0; i < samples; i++)
power_meter_update(&caller_meter, caller_model_amp[i]);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (afCloseFile(inhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", decode_test_file);
exit(2);
}
}
else
{
printf("Test cutoff level\n");
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, cutoff_test_put_bit, NULL);
fsk_rx_signal_cutoff(caller_rx, -30.0f);
fsk_rx_set_modem_status_handler(caller_rx, cutoff_test_rx_status, (void *) &caller_rx);
on_at = 0;
for (i = -40; i < -25; i++)
{
make_tone_gen_descriptor(&tone_desc,
1500,
i,
0,
0,
1,
0,
0,
0,
TRUE);
tone_gen_init(&tone_tx, &tone_desc);
for (j = 0; j < 10; j++)
{
samples = tone_gen(&tone_tx, caller_model_amp, 160);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (cutoff_test_carrier)
break;
}
on_at = i;
off_at = 0;
for ( ; i > -40; i--)
{
make_tone_gen_descriptor(&tone_desc,
1500,
i,
0,
0,
1,
0,
0,
0,
TRUE);
tone_gen_init(&tone_tx, &tone_desc);
for (j = 0; j < 10; j++)
{
samples = tone_gen(&tone_tx, caller_model_amp, 160);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (!cutoff_test_carrier)
break;
}
off_at = i;
printf("Carrier on at %d, off at %d\n", on_at, off_at);
if (on_at < -29 || on_at > -26
||
off_at < -35 || off_at > -31)
{
printf("Tests failed.\n");
exit(2);
}
printf("Test with BERT\n");
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
if (modem_under_test_1 >= 0)
{
caller_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_1], (get_bit_func_t) bert_get_bit, &caller_bert);
fsk_tx_set_modem_status_handler(caller_tx, tx_status, (void *) &caller_tx);
answerer_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, (put_bit_func_t) bert_put_bit, &answerer_bert);
fsk_rx_set_modem_status_handler(answerer_rx, rx_status, (void *) &answerer_rx);
}
if (modem_under_test_2 >= 0)
{
answerer_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_2], (get_bit_func_t) bert_get_bit, &answerer_bert);
fsk_tx_set_modem_status_handler(answerer_tx, tx_status, (void *) &answerer_tx);
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_2], TRUE, (put_bit_func_t) bert_put_bit, &caller_bert);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
}
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
bits_per_test = 500000;
noise_level = -24;
bert_init(&caller_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&caller_bert, 100000, reporter, (void *) (intptr_t) 1);
bert_init(&answerer_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&answerer_bert, 100000, reporter, (void *) (intptr_t) 2);
if ((model = both_ways_line_model_init(line_model_no, (float) noise_level, line_model_no, (float) noise_level, channel_codec, rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
for (;;)
{
samples = fsk_tx(caller_tx, caller_amp, BLOCK_LEN);
for (i = 0; i < samples; i++)
power_meter_update(&caller_meter, caller_amp[i]);
samples = fsk_tx(answerer_tx, answerer_amp, BLOCK_LEN);
for (i = 0; i < samples; i++)
power_meter_update(&answerer_meter, answerer_amp[i]);
both_ways_line_model(model,
caller_model_amp,
caller_amp,
answerer_model_amp,
answerer_amp,
samples);
//printf("Powers %10.5fdBm0 %10.5fdBm0\n", power_meter_current_dbm0(&caller_meter), power_meter_current_dbm0(&answerer_meter));
fsk_rx(answerer_rx, caller_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i] = caller_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i] = 0;
fsk_rx(caller_rx, answerer_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i + 1] = answerer_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i + 1] = 0;
if (log_audio)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
out_amp,
BLOCK_LEN);
if (outframes != BLOCK_LEN)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
if (samples < BLOCK_LEN)
{
bert_result(&caller_bert, &bert_results);
fprintf(stderr, "%ddB AWGN, %d bits, %d bad bits, %d resyncs\n", noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
if (!noise_sweep)
{
if (bert_results.total_bits != bits_per_test - 43
||
bert_results.bad_bits != 0
||
bert_results.resyncs != 0)
{
printf("Tests failed.\n");
exit(2);
}
}
bert_result(&answerer_bert, &bert_results);
fprintf(stderr, "%ddB AWGN, %d bits, %d bad bits, %d resyncs\n", noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
if (!noise_sweep)
{
if (bert_results.total_bits != bits_per_test - 43
||
bert_results.bad_bits != 0
||
bert_results.resyncs != 0)
{
printf("Tests failed.\n");
exit(2);
}
break;
}
/* Put a little silence between the chunks in the file. */
memset(out_amp, 0, sizeof(out_amp));
if (log_audio)
{
for (i = 0; i < 200; i++)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
out_amp,
BLOCK_LEN);
}
}
if (modem_under_test_1 >= 0)
{
caller_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_1], (get_bit_func_t) bert_get_bit, &caller_bert);
fsk_tx_set_modem_status_handler(caller_tx, tx_status, (void *) &caller_tx);
answerer_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, (put_bit_func_t) bert_put_bit, &answerer_bert);
fsk_rx_set_modem_status_handler(answerer_rx, rx_status, (void *) &answerer_rx);
}
if (modem_under_test_2 >= 0)
{
answerer_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_2], (get_bit_func_t) bert_get_bit, &answerer_bert);
fsk_tx_set_modem_status_handler(answerer_tx, tx_status, (void *) &answerer_tx);
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_2], TRUE, (put_bit_func_t) bert_put_bit, &caller_bert);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
}
noise_level++;
if ((model = both_ways_line_model_init(line_model_no, (float) noise_level, line_model_no, noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
bert_init(&caller_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&caller_bert, 100000, reporter, (void *) (intptr_t) 1);
bert_init(&answerer_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&answerer_bert, 100000, reporter, (void *) (intptr_t) 2);
}
}
printf("Tests passed.\n");
}
if (log_audio)
{
if (afCloseFile(outhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
}
return 0;
}
static void test_both_ways_model(int line_model_no, int speech_test)
{
both_ways_line_model_state_t *model;
int16_t input1[BLOCK_LEN];
int16_t input2[BLOCK_LEN];
int16_t output1[BLOCK_LEN];
int16_t output2[BLOCK_LEN];
int16_t amp[2*BLOCK_LEN];
SNDFILE *inhandle1;
SNDFILE *inhandle2;
SNDFILE *outhandle;
int outframes;
int samples;
int i;
int j;
awgn_state_t noise1;
awgn_state_t noise2;
if ((model = both_ways_line_model_init(line_model_no,
-50,
-15.0f,
-15.0f,
line_model_no + 1,
-35,
-15.0f,
-15.0f,
channel_codec,
rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
awgn_init_dbm0(&noise1, 1234567, -10.0f);
awgn_init_dbm0(&noise2, 1234567, -10.0f);
if (speech_test)
{
if ((inhandle1 = sf_open_telephony_read(IN_FILE_NAME1, 1)) == NULL)
{
fprintf(stderr, " Cannot open audio file '%s'\n", IN_FILE_NAME1);
exit(2);
}
if ((inhandle2 = sf_open_telephony_read(IN_FILE_NAME2, 1)) == NULL)
{
fprintf(stderr, " Cannot open audio file '%s'\n", IN_FILE_NAME2);
exit(2);
}
}
else
{
inhandle1 =
inhandle2 = NULL;
}
if ((outhandle = sf_open_telephony_write(OUT_FILE_NAME2, 2)) == NULL)
{
fprintf(stderr, " Cannot create audio file '%s'\n", OUT_FILE_NAME2);
exit(2);
}
for (i = 0; i < 10000; i++)
{
if (speech_test)
{
samples = sf_readf_short(inhandle1, input1, BLOCK_LEN);
if (samples == 0)
break;
samples = sf_readf_short(inhandle2, input2, samples);
if (samples == 0)
break;
}
else
{
for (j = 0; j < BLOCK_LEN; j++)
{
input1[j] = awgn(&noise1);
input2[j] = awgn(&noise2);
}
samples = BLOCK_LEN;
}
for (j = 0; j < samples; j++)
{
both_ways_line_model(model,
&output1[j],
&input1[j],
&output2[j],
&input2[j],
1);
amp[2*j] = output1[j];
amp[2*j + 1] = output2[j];
}
outframes = sf_writef_short(outhandle, amp, samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing audio file\n");
exit(2);
}
}
if (speech_test)
{
if (sf_close_telephony(inhandle1))
{
fprintf(stderr, " Cannot close audio file '%s'\n", IN_FILE_NAME1);
exit(2);
}
if (sf_close_telephony(inhandle2))
{
fprintf(stderr, " Cannot close audio file '%s'\n", IN_FILE_NAME2);
exit(2);
}
}
if (sf_close_telephony(outhandle))
{
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME2);
exit(2);
}
both_ways_line_model_free(model);
}
int main(int argc, char *argv[])
{
int16_t caller_amp[BLOCK_LEN];
int16_t answerer_amp[BLOCK_LEN];
int16_t caller_model_amp[BLOCK_LEN];
int16_t answerer_model_amp[BLOCK_LEN];
int16_t out_amp[2*BLOCK_LEN];
AFfilehandle outhandle;
AFfilesetup filesetup;
int outframes;
int samples;
int i;
int test_bps;
int line_model_no;
int bits_per_test;
int noise_level;
int signal_level;
int log_audio;
int channel_codec;
int opt;
channel_codec = MUNGE_CODEC_NONE;
test_bps = 2400;
line_model_no = 0;
noise_level = -70;
signal_level = -13;
bits_per_test = 50000;
log_audio = FALSE;
while ((opt = getopt(argc, argv, "b:c:glm:n:s:")) != -1)
{
switch (opt)
{
case 'b':
bits_per_test = atoi(optarg);
break;
case 'c':
channel_codec = atoi(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 's':
signal_level = atoi(optarg);
break;
default:
//usage();
exit(2);
break;
}
}
argc -= optind;
argv += optind;
if (argc > 0)
{
if (strcmp(argv[0], "2400") == 0)
test_bps = 2400;
else if (strcmp(argv[0], "1200") == 0)
test_bps = 1200;
else
{
fprintf(stderr, "Invalid bit rate\n");
exit(2);
}
}
filesetup = AF_NULL_FILESETUP;
outhandle = AF_NULL_FILEHANDLE;
if (log_audio)
{
if ((filesetup = afNewFileSetup()) == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
afInitSampleFormat(filesetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitRate(filesetup, AF_DEFAULT_TRACK, (float) SAMPLE_RATE);
afInitFileFormat(filesetup, AF_FILE_WAVE);
afInitChannels(filesetup, AF_DEFAULT_TRACK, 2);
if ((outhandle = afOpenFile(OUT_FILE_NAME, "w", filesetup)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
}
v22bis_init(&caller, test_bps, 2, TRUE, v22bis_getbit, v22bis_putbit, &caller);
v22bis_tx_power(&caller, signal_level);
/* Move the carrier off a bit */
caller.tx.carrier_phase_rate = dds_phase_ratef(1207.0f);
v22bis_init(&answerer, test_bps, 2, FALSE, v22bis_getbit, v22bis_putbit, &answerer);
v22bis_tx_power(&answerer, signal_level);
answerer.tx.carrier_phase_rate = dds_phase_ratef(2407.0f);
v22bis_set_qam_report_handler(&caller, qam_report, (void *) &qam_caller);
v22bis_set_qam_report_handler(&answerer, qam_report, (void *) &qam_answerer);
span_log_set_level(&caller.logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_FLOW);
span_log_set_tag(&caller.logging, "caller");
span_log_set_level(&answerer.logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_FLOW);
span_log_set_tag(&answerer.logging, "answerer");
qam_caller.s = &caller;
qam_caller.smooth_power = 0.0f;
qam_caller.symbol_no = 0;
qam_answerer.s = &answerer;
qam_answerer.smooth_power = 0.0f;
qam_answerer.symbol_no = 0;
#if defined(ENABLE_GUI)
if (use_gui)
{
qam_caller.qam_monitor = qam_monitor_init(6.0f, "Calling modem");
qam_answerer.qam_monitor = qam_monitor_init(6.0f, "Answering modem");
}
#endif
if ((model = both_ways_line_model_init(line_model_no, (float) noise_level, line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
for (;;)
{
samples = v22bis_tx(&caller, caller_amp, BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_caller.qam_monitor, caller_amp, samples);
#endif
if (samples == 0)
{
printf("Restarting on zero output\n");
v22bis_restart(&caller, test_bps);
rx_ptr = 0;
tx_ptr = 0;
}
samples = v22bis_tx(&answerer, answerer_amp, BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_answerer.qam_monitor, answerer_amp, samples);
#endif
if (samples == 0)
{
printf("Restarting on zero output\n");
v22bis_restart(&answerer, test_bps);
rx_ptr = 0;
tx_ptr = 0;
}
both_ways_line_model(model,
caller_model_amp,
caller_amp,
answerer_model_amp,
answerer_amp,
samples);
v22bis_rx(&answerer, caller_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i] = caller_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i] = 0;
v22bis_rx(&caller, answerer_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i + 1] = answerer_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i + 1] = 0;
if (log_audio)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
out_amp,
BLOCK_LEN);
if (outframes != BLOCK_LEN)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
}
if (log_audio)
{
if (afCloseFile(outhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
afFreeFileSetup(filesetup);
}
return 0;
}
int main(int argc, char *argv[])
{
int16_t amp[2][BLOCK_LEN];
int16_t model_amp[2][BLOCK_LEN];
int16_t out_amp[2*BLOCK_LEN];
SNDFILE *inhandle;
SNDFILE *outhandle;
int outframes;
int samples;
int samples2;
int i;
int j;
int test_bps;
int line_model_no;
int bits_per_test;
int noise_level;
int signal_level;
int channel_codec;
int rbs_pattern;
int guard_tone_option;
int opt;
bool log_audio;
channel_codec = MUNGE_CODEC_NONE;
rbs_pattern = 0;
test_bps = 2400;
line_model_no = 0;
decode_test_file = NULL;
noise_level = -70;
signal_level = -13;
bits_per_test = 50000;
guard_tone_option = V22BIS_GUARD_TONE_1800HZ;
log_audio = false;
while ((opt = getopt(argc, argv, "b:B:c:d:gG:lm:n:r:s:")) != -1)
{
switch (opt)
{
case 'b':
test_bps = atoi(optarg);
if (test_bps != 2400 && test_bps != 1200)
{
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 'G':
guard_tone_option = atoi(optarg);
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;
default:
//usage();
exit(2);
break;
}
}
inhandle = NULL;
if (decode_test_file)
{
/* We will decode the audio from a file. */
if ((inhandle = sf_open_telephony_read(decode_test_file, 1)) == NULL)
{
fprintf(stderr, " Cannot open audio file '%s'\n", decode_test_file);
exit(2);
}
}
outhandle = NULL;
if (log_audio)
{
if ((outhandle = sf_open_telephony_write(OUT_FILE_NAME, 2)) == NULL)
{
fprintf(stderr, " Cannot create audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
}
memset(endpoint, 0, sizeof(endpoint));
for (i = 0; i < 2; i++)
{
endpoint[i].v22bis = v22bis_init(NULL, test_bps, guard_tone_option, (i == 0), v22bis_getbit, &endpoint[i], v22bis_putbit, &endpoint[i]);
v22bis_tx_power(endpoint[i].v22bis, signal_level);
/* Move the carrier off a bit */
endpoint[i].v22bis->tx.carrier_phase_rate = dds_phase_ratef((i == 0) ? 1207.0f : 2407.0f);
v22bis_rx_set_qam_report_handler(endpoint[i].v22bis, qam_report, (void *) &endpoint[i]);
span_log_set_level(&endpoint[i].v22bis->logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME | SPAN_LOG_FLOW);
span_log_set_tag(&endpoint[i].v22bis->logging, (i == 0) ? "caller" : "answerer");
endpoint[i].smooth_power = 0.0f;
endpoint[i].symbol_no = 0;
bert_init(&endpoint[i].bert_tx, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_init(&endpoint[i].bert_rx, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&endpoint[i].bert_rx, 10000, reporter, &endpoint[i]);
}
#if defined(ENABLE_GUI)
if (use_gui)
{
endpoint[0].qam_monitor = qam_monitor_init(6.0f, V22BIS_CONSTELLATION_SCALING_FACTOR, "Calling modem");
endpoint[1].qam_monitor = qam_monitor_init(6.0f, V22BIS_CONSTELLATION_SCALING_FACTOR, "Answering modem");
}
#endif
if ((model = both_ways_line_model_init(line_model_no,
(float) noise_level,
-15.0f,
-15.0f,
line_model_no,
(float) noise_level,
-15.0f,
-15.0f,
channel_codec,
rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
samples = 0;
for (;;)
{
for (i = 0; i < 2; i++)
{
samples = v22bis_tx(endpoint[i].v22bis, amp[i], BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(endpoint[i].qam_monitor, amp[i], samples);
#endif
if (samples == 0)
{
/* Note that we might get a few bad bits as the carrier shuts down. */
bert_result(&endpoint[i].bert_rx, &endpoint[i].latest_results);
bert_init(&endpoint[i].bert_tx, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_init(&endpoint[i].bert_rx, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&endpoint[i].bert_rx, 10000, reporter, &endpoint[i]);
printf("Restarting on zero output\n");
v22bis_restart(endpoint[i].v22bis, test_bps);
}
}
#if 1
both_ways_line_model(model,
model_amp[0],
amp[0],
model_amp[1],
amp[1],
samples);
#else
vec_copyi16(model_amp[0], amp[0], samples);
vec_copyi16(model_amp[1], amp[1], samples);
#endif
if (decode_test_file)
{
samples2 = sf_readf_short(inhandle, model_amp[0], samples);
if (samples2 != samples)
break;
}
for (i = 0; i < 2; i++)
{
span_log_bump_samples(&endpoint[i].v22bis->logging, samples);
v22bis_rx(endpoint[i ^ 1].v22bis, model_amp[i], samples);
for (j = 0; j < samples; j++)
out_amp[2*j + i] = model_amp[i][j];
for ( ; j < BLOCK_LEN; j++)
out_amp[2*j + i] = 0;
}
if (log_audio)
{
outframes = sf_writef_short(outhandle, out_amp, BLOCK_LEN);
if (outframes != BLOCK_LEN)
{
fprintf(stderr, " Error writing audio file\n");
exit(2);
}
}
}
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(endpoint[0].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;
}
static void test_both_ways_model(int line_model_no, int speech_test)
{
both_ways_line_model_state_t *model;
int16_t input1[BLOCK_LEN];
int16_t input2[BLOCK_LEN];
int16_t output1[BLOCK_LEN];
int16_t output2[BLOCK_LEN];
int16_t amp[2*BLOCK_LEN];
AFfilehandle inhandle1;
AFfilehandle inhandle2;
AFfilehandle outhandle;
AFfilesetup filesetup;
int outframes;
int samples;
int i;
int j;
awgn_state_t noise1;
awgn_state_t noise2;
if ((model = both_ways_line_model_init(line_model_no, -50, line_model_no + 1, -35, MUNGE_CODEC_ALAW)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
awgn_init_dbm0(&noise1, 1234567, -10.0f);
awgn_init_dbm0(&noise2, 1234567, -10.0f);
filesetup = afNewFileSetup();
if (filesetup == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
afInitSampleFormat(filesetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitRate(filesetup, AF_DEFAULT_TRACK, (float) SAMPLE_RATE);
afInitFileFormat(filesetup, AF_FILE_WAVE);
afInitChannels(filesetup, AF_DEFAULT_TRACK, 2);
inhandle1 = afOpenFile(IN_FILE_NAME1, "r", NULL);
if (inhandle1 == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", IN_FILE_NAME1);
exit(2);
}
inhandle2 = afOpenFile(IN_FILE_NAME2, "r", NULL);
if (inhandle2 == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", IN_FILE_NAME2);
exit(2);
}
outhandle = afOpenFile(OUT_FILE_NAME, "w", filesetup);
if (outhandle == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
for (i = 0; i < 10000; i++)
{
if (speech_test)
{
samples = afReadFrames(inhandle1,
AF_DEFAULT_TRACK,
input1,
BLOCK_LEN);
if (samples == 0)
break;
samples = afReadFrames(inhandle2,
AF_DEFAULT_TRACK,
input2,
samples);
if (samples == 0)
break;
}
else
{
for (j = 0; j < BLOCK_LEN; j++)
{
input1[j] = awgn(&noise1);
input2[j] = awgn(&noise2);
}
samples = BLOCK_LEN;
}
for (j = 0; j < samples; j++)
{
both_ways_line_model(model,
&output1[j],
&input1[j],
&output2[j],
&input2[j],
1);
amp[2*j] = output1[j];
amp[2*j + 1] = output2[j];
}
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
amp,
samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
if (afCloseFile(inhandle1))
{
fprintf(stderr, " Cannot close wave file '%s'\n", IN_FILE_NAME1);
exit(2);
}
if (afCloseFile(inhandle2))
{
fprintf(stderr, " Cannot close wave file '%s'\n", IN_FILE_NAME2);
exit(2);
}
if (afCloseFile(outhandle))
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
afFreeFileSetup(filesetup);
both_ways_line_model_release(model);
}
