cellular-infrastructure
/
osmocom-analog
9
1
Fork 2
Code Issues 11 Pull Requests 2 Projects Releases Wiki Activity

prepare audio handling for multi carrier SDR

This commit is contained in:
Andreas Eversberg 2017-01-03 12:31:59 +01:00
parent 713b1ab118
commit d54d3ac265
23 changed files with 131 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/amps/amps.c
View File

@ -376,7 +376,7 @@ static amps_t *search_pc(void)
static void amps_go_idle(amps_t *amps);
/* Create transceiver instance and link to a list. */
int amps_create(int channel, enum amps_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, amps_si *si, uint16_t sid, uint8_t sat, int polarity, int tolerant, int loopback)
int amps_create(int channel, enum amps_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, amps_si *si, uint16_t sid, uint8_t sat, int polarity, int tolerant, int loopback)
{
sender_t *sender;
amps_t *amps;
@ -442,7 +442,7 @@ int amps_create(int channel, enum amps_chan_type chan_type, const char *sounddev
PDEBUG(DAMPS, DEBUG_DEBUG, "Creating 'AMPS' instance for channel = %d (sample rate %d).\n", channel, samplerate);
/* init general part of transceiver */
rc = sender_create(&amps->sender, channel, sounddev, samplerate, cross_channels, rx_gain, 0, 0, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
rc = sender_create(&amps->sender, channel, sounddev, samplerate, rx_gain, 0, 0, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
if (rc < 0) {
PDEBUG(DAMPS, DEBUG_ERROR, "Failed to init transceiver process!\n");
goto error;

2
src/amps/amps.h
View File

@ -163,7 +163,7 @@ const char *amps_min12number(uint32_t min1);
void amps_number2min(const char *number, uint32_t *min1, uint16_t *min2);
const char *amps_min2number(uint32_t min1, uint16_t min2);
const char *amps_scm(uint8_t scm);
int amps_create(int channel, enum amps_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, amps_si *si, uint16_t sid, uint8_t sat, int polarity, int tolerant, int loopback);
int amps_create(int channel, enum amps_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, amps_si *si, uint16_t sid, uint8_t sat, int polarity, int tolerant, int loopback);
void amps_destroy(sender_t *sender);
void amps_rx_signaling_tone(amps_t *amps, int tone, double quality);
void amps_rx_sat(amps_t *amps, int tone, double quality);

2
src/amps/main.c
View File

@ -348,7 +348,7 @@ int main(int argc, char *argv[])
amps_si si;
init_sysinfo(&si, ms_power, ms_power, dcc, sid >> 1, regh, regr, pureg, pdreg, locaid, regincr, bis);
rc = amps_create(kanal[i], chan_type[i], sounddev[i], samplerate, cross_channels, rx_gain, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, &si, sid, scc, polarity, tolerant, loopback);
rc = amps_create(kanal[i], chan_type[i], sounddev[i], samplerate, rx_gain, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, &si, sid, scc, polarity, tolerant, loopback);
if (rc < 0) {
fprintf(stderr, "Failed to create \"Sender\" instance. Quitting!\n");
goto fail;

4
src/anetz/anetz.c
View File

@ -168,7 +168,7 @@ static void anetz_timeout(struct timer *timer);
static void anetz_go_idle(anetz_t *anetz);
/* Create transceiver instance and link to a list. */
int anetz_create(int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int page_sequence, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume)
int anetz_create(int kanal, const char *sounddev, int samplerate, double rx_gain, int page_sequence, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume)
{
anetz_t *anetz;
int rc;
@ -187,7 +187,7 @@ int anetz_create(int kanal, const char *sounddev, int samplerate, int cross_chan
PDEBUG(DANETZ, DEBUG_DEBUG, "Creating 'A-Netz' instance for 'Kanal' = %d (sample rate %d).\n", kanal, samplerate);
/* init general part of transceiver */
rc = sender_create(&anetz->sender, kanal, sounddev, samplerate, cross_channels, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, loss_volume, PILOT_SIGNAL_NONE);
rc = sender_create(&anetz->sender, kanal, sounddev, samplerate, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, loss_volume, PILOT_SIGNAL_NONE);
if (rc < 0) {
PDEBUG(DANETZ, DEBUG_ERROR, "Failed to init 'Sender' processing!\n");
goto error;

2
src/anetz/anetz.h
View File

@ -45,7 +45,7 @@ typedef struct anetz {
double anetz_kanal2freq(int kanal, int unterband);
int anetz_init(void);
int anetz_create(int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int page_sequence, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume);
int anetz_create(int kanal, const char *sounddev, int samplerate, double rx_gain, int page_sequence, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume);
void anetz_destroy(sender_t *sender);
void anetz_loss_indication(anetz_t *anetz);
void anetz_receive_tone(anetz_t *anetz, int bit);

2
src/anetz/main.c
View File

@ -171,7 +171,7 @@ int main(int argc, char *argv[])
/* create transceiver instance */
for (i = 0; i < num_kanal; i++) {
rc = anetz_create(kanal[i], sounddev[i], samplerate, cross_channels, rx_gain, page_sequence, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, lossdetect / 100.0);
rc = anetz_create(kanal[i], sounddev[i], samplerate, rx_gain, page_sequence, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, lossdetect / 100.0);
if (rc < 0) {
fprintf(stderr, "Failed to create \"Sender\" instance. Quitting!\n");
goto fail;

4
src/bnetz/bnetz.c
View File

@ -141,7 +141,7 @@ static void bnetz_timeout(struct timer *timer);
static void bnetz_go_idle(bnetz_t *bnetz);
/* Create transceiver instance and link to a list. */
int bnetz_create(int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int gfs, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_factor, const char *pilot)
int bnetz_create(int kanal, const char *sounddev, int samplerate, double rx_gain, int gfs, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_factor, const char *pilot)
{
bnetz_t *bnetz;
enum pilot_signal pilot_signal = PILOT_SIGNAL_NONE;
@ -202,7 +202,7 @@ error_pilot:
PDEBUG(DBNETZ, DEBUG_DEBUG, "Creating 'B-Netz' instance for 'Kanal' = %d 'Gruppenfreisignal' = %d (sample rate %d).\n", kanal, gfs, samplerate);
/* init general part of transceiver */
rc = sender_create(&bnetz->sender, kanal, sounddev, samplerate, cross_channels, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, loss_factor, pilot_signal);
rc = sender_create(&bnetz->sender, kanal, sounddev, samplerate, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, loss_factor, pilot_signal);
if (rc < 0) {
PDEBUG(DBNETZ, DEBUG_ERROR, "Failed to init transceiver process!\n");
goto error;

2
src/bnetz/bnetz.h
View File

@ -100,7 +100,7 @@ typedef struct bnetz {
double bnetz_kanal2freq(int kanal, int unterband);
int bnetz_init(void);
int bnetz_create(int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int gfs, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_factor, const char *pilot);
int bnetz_create(int kanal, const char *sounddev, int samplerate, double rx_gain, int gfs, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_factor, const char *pilot);
void bnetz_destroy(sender_t *sender);
void bnetz_loss_indication(bnetz_t *bnetz);
void bnetz_receive_tone(bnetz_t *bnetz, int bit);

2
src/bnetz/main.c
View File

@ -187,7 +187,7 @@ int main(int argc, char *argv[])
/* create transceiver instance */
for (i = 0; i < num_kanal; i++) {
rc = bnetz_create(kanal[i], sounddev[i], samplerate, cross_channels, rx_gain, gfs, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, (double)lossdetect / 100.0, pilot[i]);
rc = bnetz_create(kanal[i], sounddev[i], samplerate, rx_gain, gfs, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, (double)lossdetect / 100.0, pilot[i]);
if (rc < 0) {
fprintf(stderr, "Failed to create \"Sender\" instance. Quitting!\n");
goto fail;

4
src/cnetz/cnetz.c
View File

@ -215,7 +215,7 @@ int cnetz_init(void)
static void cnetz_go_idle(cnetz_t *cnetz);
/* Create transceiver instance and link to a list. */
int cnetz_create(int kanal, enum cnetz_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int auth, int ms_power, int measure_speed, double clock_speed[2], int polarity, double noise, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback)
int cnetz_create(int kanal, enum cnetz_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int auth, int ms_power, int measure_speed, double clock_speed[2], int polarity, double noise, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback)
{
sender_t *sender;
cnetz_t *cnetz;
@ -274,7 +274,7 @@ int cnetz_create(int kanal, enum cnetz_chan_type chan_type, const char *sounddev
/* init general part of transceiver */
/* do not enable emphasis, since it is done by cnetz code, not by common sender code */
rc = sender_create(&cnetz->sender, kanal, sounddev, samplerate, cross_channels, rx_gain, 0, 0, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
rc = sender_create(&cnetz->sender, kanal, sounddev, samplerate, rx_gain, 0, 0, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
if (rc < 0) {
PDEBUG(DCNETZ, DEBUG_ERROR, "Failed to init transceiver process!\n");
goto error;

2
src/cnetz/cnetz.h
View File

@ -123,7 +123,7 @@ int cnetz_channel_by_short_name(const char *short_name);
const char *chan_type_short_name(enum cnetz_chan_type chan_type);
const char *chan_type_long_name(enum cnetz_chan_type chan_type);
int cnetz_init(void);
int cnetz_create(int kanal, enum cnetz_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int auth, int ms_power, int measure_speed, double clock_speed[2], int polarity, double noise, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback);
int cnetz_create(int kanal, enum cnetz_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int auth, int ms_power, int measure_speed, double clock_speed[2], int polarity, double noise, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback);
void cnetz_destroy(sender_t *sender);
void cnetz_sync_frame(cnetz_t *cnetz, double sync, int ts);
int cnetz_meldeaufruf(uint8_t futln_nat, uint8_t futln_fuvst, uint16_t futln_rest);

5
src/cnetz/dsp.c
View File

@ -610,12 +610,11 @@ again:
/* measure actual signal speed */
calc_clock_speed(cnetz, cnetz->sender.samplerate * 24 / 10, 1, 1);
/* sync TX (might not be required, if there is no error in math calculation) */
if (cnetz->sender.slave) {
if (!cnetz->sender.master) { /* if no link to a master, we are master */
/* we are master, so we store sample count and phase */
cnetz->frame_last_scount = cnetz->fsk_tx_scount;
cnetz->frame_last_phase = cnetz->fsk_tx_phase;
}
if (cnetz->sender.master) {
} else {
/* we are slave, so we sync to phase */
cnetz_t *master = (cnetz_t *)cnetz->sender.master;
/* it may happen that the sample count does not match with the master,

2
src/cnetz/main.c
View File

@ -302,7 +302,7 @@ int main(int argc, char *argv[])
/* create transceiver instance */
for (i = 0; i < num_kanal; i++) {
rc = cnetz_create(kanal[i], chan_type[i], sounddev[i], samplerate, cross_channels, rx_gain, auth, ms_power, (i == 0) ? measure_speed : 0, clock_speed, polarity, noise, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback);
rc = cnetz_create(kanal[i], chan_type[i], sounddev[i], samplerate, rx_gain, auth, ms_power, (i == 0) ? measure_speed : 0, clock_speed, polarity, noise, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback);
if (rc < 0) {
fprintf(stderr, "Failed to create \"Sender\" instance. Quitting!\n");
goto fail;

8
src/common/call.c
View File

@ -638,7 +638,7 @@ void process_call(int c)
/* handle audio, if sound device is used */
int16_t samples[call.latspl];
int16_t samples[call.latspl], *spl_list[1];
int count;
int rc;
@ -670,7 +670,8 @@ void process_call(int c)
default:
jitter_load(&call.audio, up, count);
}
rc = sound_write(call.sound, up, up, count);
spl_list[0] = up;
rc = sound_write(call.sound, spl_list, count, 1);
if (rc < 0) {
PDEBUG(DSENDER, DEBUG_ERROR, "Failed to write TX data to sound device (rc = %d)\n", rc);
if (rc == -EPIPE)
@ -678,7 +679,8 @@ void process_call(int c)
return;
}
}
count = sound_read(call.sound, samples, samples, call.latspl);
spl_list[0] = samples;
count = sound_read(call.sound, spl_list, call.latspl, 1);
if (count < 0) {
PDEBUG(DSENDER, DEBUG_ERROR, "Failed to read from sound device (rc = %d)!\n", count);
if (count == -EPIPE)

1
src/common/main.h
View File

@ -7,7 +7,6 @@ extern const char *call_sounddev;
extern int samplerate;
extern int interval;
extern int latency;
extern int cross_channels;
extern int uses_emphasis;
extern int do_pre_emphasis;
extern int do_de_emphasis;

11
src/common/main_common.c
View File

@ -42,7 +42,6 @@ const char *call_sounddev = "";
int samplerate = 48000;
int interval = 1;
int latency = 50;
int cross_channels = 0;
int uses_emphasis = 1;
int do_pre_emphasis = 0;
int do_de_emphasis = 0;
@ -81,9 +80,6 @@ void print_help_common(const char *arg0, const char *ext_usage)
printf(" increase latency accordingly.\n");
printf(" -b --buffer <ms>\n");
printf(" How many milliseconds are processed in advance (default = '%d')\n", latency);
printf(" -x --cross\n");
printf(" Cross channels on sound card. 1st channel (right) is swapped with\n");
printf(" second channel (left)\n");
if (uses_emphasis) {
printf(" -p --pre-emphasis\n");
printf(" Enable pre-emphasis, if you directly connect to the oscillator of the\n");
@ -137,7 +133,6 @@ static struct option long_options_common[] = {
{"samplerate", 1, 0, 's'},
{"interval", 1, 0, 'i'},
{"buffer", 1, 0, 'b'},
{"cross", 0, 0, 'x'},
{"pre-emphasis", 0, 0, 'p'},
{"de-emphasis", 0, 0, 'd'},
{"rx-gain", 0, 0, 'g'},
@ -152,7 +147,7 @@ static struct option long_options_common[] = {
{0, 0, 0, 0}
};
const char *optstring_common = "hv:k:a:s:i:b:xpdg:mc:t:l:r:";
const char *optstring_common = "hv:k:a:s:i:b:pdg:mc:t:l:r:";
struct option *long_options;
char *optstring;
@ -232,10 +227,6 @@ void opt_switch_common(int c, char *arg0, int *skip_args)
latency = atoi(optarg);
*skip_args += 2;
break;
case 'x':
cross_channels = 1;
*skip_args += 1;
break;
case 'p':
if (!uses_emphasis) {
no_emph:

182
src/common/sender.c
View File

@ -32,7 +32,7 @@ static sender_t **sender_tailp = &sender_head;
int cant_recover = 0;
/* Init transceiver instance and link to list of transceivers. */
int sender_create(sender_t *sender, int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume, enum pilot_signal pilot_signal)
int sender_create(sender_t *sender, int kanal, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume, enum pilot_signal pilot_signal)
{
sender_t *master;
int rc = 0;
@ -40,7 +40,6 @@ int sender_create(sender_t *sender, int kanal, const char *sounddev, int sampler
sender->kanal = kanal;
strncpy(sender->sounddev, sounddev, sizeof(sender->sounddev) - 1);
sender->samplerate = samplerate;
sender->cross_channels = cross_channels;
sender->rx_gain = rx_gain;
sender->pre_emphasis = pre_emphasis;
sender->de_emphasis = de_emphasis;
@ -66,6 +65,7 @@ int sender_create(sender_t *sender, int kanal, const char *sounddev, int sampler
break;
}
if (master) {
// FIXME: link more than two channels
if (master->slave) {
PDEBUG(DSENDER, DEBUG_ERROR, "Sound device '%s' cannot be used for channel %d. It is already shared by channel %d and %d!\n", sounddev, kanal, master->kanal, master->slave->kanal);
rc = -EBUSY;
@ -86,8 +86,9 @@ int sender_create(sender_t *sender, int kanal, const char *sounddev, int sampler
rc = -EBUSY;
goto error;
}
/* link us to a master */
/* link us to a master/slave */
master->slave = sender;
// FIXME: link more than two channels, so link to last slave
sender->master = master;
} else {
/* open own device */
@ -163,11 +164,6 @@ void sender_destroy(sender_t *sender)
sender_tailp = &((*sender_tailp)->next);
}
if (sender->slave)
sender->slave->master = NULL;
if (sender->master)
sender->master->slave = NULL;
if (sender->sound) {
sound_close(sender->sound);
sender->sound = NULL;
@ -219,9 +215,22 @@ static void gain_samples(int16_t *samples, int length, double gain)
/* Handle audio streaming of one transceiver. */
void process_sender_audio(sender_t *sender, int *quit, int latspl)
{
sender_t *slave = sender->slave;
int16_t samples[latspl], pilot[latspl], slave_samples[latspl];
sender_t *inst;
int rc, count;
int num_chan, i;
/* count instances for audio channel */
for (num_chan = 0, inst = sender; inst; num_chan++, inst = inst->slave);
if (sender->pilot_signal) {
if (num_chan != 1) {
PDEBUG(DSENDER, DEBUG_ERROR, "Software error, please fix!\n");
abort();
}
num_chan++;
}
int16_t buff[num_chan][latspl], *samples[num_chan];
for (i = 0; i < num_chan; i++)
samples[i] = buff[i];
count = sound_get_inbuffer(sender->sound);
if (count < 0) {
@ -239,103 +248,60 @@ cant_recover:
}
if (count < latspl) {
count = latspl - count;
/* load TX data from audio loop or from sender instance */
if (sender->loopback == 3)
jitter_load(&sender->audio, samples, count);
else
sender_send(sender, samples, count);
if (sender->wave_tx_rec.fp)
wave_write(&sender->wave_tx_rec, samples, count);
/* internal loopback: loop back TX audio to RX */
if (sender->loopback == 1) {
if (sender->wave_rx_rec.fp)
wave_write(&sender->wave_rx_rec, samples, count);
display_wave(sender, samples, count);
sender_receive(sender, samples, count);
}
/* do pre emphasis towards radio, not wave_write */
if (sender->pre_emphasis)
pre_emphasis(&sender->estate, samples, count);
/* do above for audio slave, if set */
if (slave) {
if (slave->loopback == 3)
jitter_load(&slave->audio, slave_samples, count);
/* loop through all channels */
for (i = 0, inst = sender; inst; i++, inst = inst->slave) {
/* load TX data from audio loop or from sender instance */
if (inst->loopback == 3)
jitter_load(&inst->audio, samples[i], count);
else
sender_send(slave, slave_samples, count);
if (sender->wave_tx_rec.fp)
wave_write(&slave->wave_tx_rec, slave_samples, count);
/* internal loopback, if audio slave is set */
if (slave && slave->loopback == 1) {
if (slave->wave_rx_rec.fp)
wave_write(&slave->wave_rx_rec, slave_samples, count);
display_wave(slave, slave_samples, count);
sender_receive(slave, slave_samples, count);
sender_send(inst, samples[i], count);
if (inst->wave_tx_rec.fp)
wave_write(&inst->wave_tx_rec, samples[i], count);
/* internal loopback: loop back TX audio to RX */
if (inst->loopback == 1) {
if (inst->wave_rx_rec.fp)
wave_write(&inst->wave_rx_rec, samples[i], count);
display_wave(inst, samples[i], count);
sender_receive(inst, samples[i], count);
}
/* do pre emphasis towards radio, not wave_write */
if (slave->pre_emphasis)
pre_emphasis(&slave->estate, slave_samples, count);
if (inst->pre_emphasis)
pre_emphasis(&inst->estate, samples[i], count);
}
switch (sender->pilot_signal) {
case PILOT_SIGNAL_TONE:
/* tone if pilot signal is on */
if (sender->pilot_on)
gen_pilotton(sender, pilot, count);
gen_pilotton(sender, samples[1], count);
else
memset(pilot, 0, count << 1);
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, pilot, count);
else
rc = sound_write(sender->sound, pilot, samples, count);
memset(samples[1], 0, count << 1);
break;
case PILOT_SIGNAL_NOTONE:
/* tone if pilot signal is off */
if (!sender->pilot_on)
gen_pilotton(sender, pilot, count);
gen_pilotton(sender, samples[1], count);
else
memset(pilot, 0, count << 1);
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, pilot, count);
else
rc = sound_write(sender->sound, pilot, samples, count);
memset(samples[1], 0, count << 1);
break;
case PILOT_SIGNAL_POSITIVE:
/* positive signal if pilot signal is on */
if (sender->pilot_on)
memset(pilot, 127, count << 1);
memset(samples[1], 127, count << 1);
else
memset(pilot, 128, count << 1);
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, pilot, count);
else
rc = sound_write(sender->sound, pilot, samples, count);
memset(samples[1], 128, count << 1);
break;
case PILOT_SIGNAL_NEGATIVE:
/* negative signal if pilot signal is on */
if (sender->pilot_on)
memset(pilot, 128, count << 1);
memset(samples[1], 128, count << 1);
else
memset(pilot, 127, count << 1);
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, pilot, count);
else
rc = sound_write(sender->sound, pilot, samples, count);
memset(samples[1], 127, count << 1);
break;
case PILOT_SIGNAL_NONE:
break;
default:
/* if audio slave is set, write audio of both sender instances */
if (slave) {
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, slave_samples, count);
else
rc = sound_write(sender->sound, slave_samples, samples, count);
}else {
/* use pilot tone buffer for silence */
memset(pilot, 0, count << 1);
if (!sender->cross_channels)
rc = sound_write(sender->sound, samples, pilot, count);
else
rc = sound_write(sender->sound, pilot, samples, count);
}
}
rc = sound_write(sender->sound, samples, count, num_chan);
if (rc < 0) {
PDEBUG(DSENDER, DEBUG_ERROR, "Failed to write TX data to sound device (rc = %d)\n", rc);
if (rc == -EPIPE) {
@ -347,11 +313,7 @@ cant_recover:
}
}
if (!sender->cross_channels)
count = sound_read(sender->sound, samples, slave_samples, latspl);
else
count = sound_read(sender->sound, slave_samples, samples, latspl);
//printf("count=%d time= %.4f\n", count, (double)count * 1000 / sender->samplerate);
count = sound_read(sender->sound, samples, latspl, num_chan);
if (count < 0) {
PDEBUG(DSENDER, DEBUG_ERROR, "Failed to read from sound device (rc = %d)!\n", count);
if (count == -EPIPE) {
@ -362,38 +324,24 @@ cant_recover:
return;
}
if (count) {
/* rx gain */
if (sender->rx_gain != 1.0)
gain_samples(samples, count, sender->rx_gain);
/* do de emphasis from radio (then write_wave/wave_read), receive audio, process echo test */
if (sender->de_emphasis)
de_emphasis(&sender->estate, samples, count);
if (sender->wave_rx_play.fp)
wave_read(&sender->wave_rx_play, samples, count);
if (sender->loopback != 1) {
if (sender->wave_rx_rec.fp)
wave_write(&sender->wave_rx_rec, samples, count);
display_wave(sender, samples, count);
sender_receive(sender, samples, count);
}
if (sender->loopback == 3)
jitter_save(&sender->audio, samples, count);
/* do above for audio slave, if set */
if (slave) {
if (sender->rx_gain != 1.0)
gain_samples(slave_samples, count, slave->rx_gain);
if (slave->de_emphasis)
de_emphasis(&slave->estate, slave_samples, count);
if (slave->wave_rx_play.fp)
wave_read(&slave->wave_rx_play, slave_samples, count);
if (slave->loopback != 1) {
if (slave->wave_rx_rec.fp)
wave_write(&slave->wave_rx_rec, slave_samples, count);
display_wave(slave, slave_samples, count);
sender_receive(slave, slave_samples, count);
/* loop through all channels */
for (i = 0, inst = sender; inst; i++, inst = inst->slave) {
/* rx gain */
if (inst->rx_gain != 1.0)
gain_samples(samples[i], count, inst->rx_gain);
/* do de emphasis from radio (then write_wave/wave_read), receive audio, process echo test */
if (inst->de_emphasis)
de_emphasis(&inst->estate, samples[i], count);
if (inst->wave_rx_play.fp)
wave_read(&inst->wave_rx_play, samples[i], count);
if (inst->loopback != 1) {
if (inst->wave_rx_rec.fp)
wave_write(&inst->wave_rx_rec, samples[i], count);
display_wave(inst, samples[i], count);
sender_receive(inst, samples[i], count);
}
if (slave->loopback == 3)
jitter_save(&slave->audio, slave_samples, count);
if (inst->loopback == 3)
jitter_save(&inst->audio, samples[i], count);
}
}
}

7
src/common/sender.h
View File

@ -20,8 +20,8 @@ enum pilot_signal {
/* common structure of each transmitter */
typedef struct sender {
struct sender *next;
struct sender *slave; /* points to audio device slave member */
struct sender *master; /* points to audio device master source */
struct sender *slave; /* points to 'slave' that uses next channel of audio device */
struct sender *master; /* if set, the audio device is owned by 'master' */
/* system info */
int kanal; /* channel number */
@ -30,7 +30,6 @@ typedef struct sender {
void *sound;
char sounddev[64]; /* sound device name */
int samplerate;
int cross_channels; /* swap right and left on IO */
samplerate_t srstate; /* sample rate conversion state */
double rx_gain; /* factor of level to apply on rx samples */
int pre_emphasis; /* use pre_emhasis, done by sender */
@ -70,7 +69,7 @@ typedef struct sender {
extern sender_t *sender_head;
extern int cant_recover;
int sender_create(sender_t *sender, int kanal, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume, enum pilot_signal pilot_signal);
int sender_create(sender_t *sender, int kanal, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, int loopback, double loss_volume, enum pilot_signal pilot_signal);
void sender_destroy(sender_t *sender);
void process_sender_audio(sender_t *sender, int *quit, int latspl);
void sender_send(sender_t *sender, int16_t *samples, int count);

4
src/common/sound.h
View File

@ -1,8 +1,8 @@
void *sound_open(const char *device, int samplerate);
void sound_close(void *inst);
int sound_write(void *inst, int16_t *samples_left, int16_t *samples_right, int num);
int sound_read(void *inst, int16_t *samples_left, int16_t *samples_right, int num);
int sound_write(void *inst, int16_t **samples, int num, int channels);
int sound_read(void *inst, int16_t **samples, int num, int channels);
int sound_get_inbuffer(void *inst);
int sound_is_stereo_capture(void *inst);
int sound_is_stereo_playback(void *inst);

49
src/common/sound_alsa.c
View File

@ -187,24 +187,29 @@ void sound_close(void *inst)
free(sound);
}
int sound_write(void *inst, int16_t *samples_left, int16_t *samples_right, int num)
int sound_write(void *inst, int16_t **samples, int num, int channels)
{
sound_t *sound = (sound_t *)inst;
int16_t buff[num << 1], *samples;
int16_t buff[num << 1];
int rc;
int i, ii;
if (sound->pchannels == 2) {
for (i = 0, ii = 0; i < num; i++) {
buff[ii++] = *samples_right++;
buff[ii++] = *samples_left++;
if (channels < 2) {
for (i = 0, ii = 0; i < num; i++) {
buff[ii++] = samples[0][i];
buff[ii++] = samples[0][i];
}
} else {
for (i = 0, ii = 0; i < num; i++) {
buff[ii++] = samples[0][i];
buff[ii++] = samples[1][i];
}
}
samples = buff;
rc = snd_pcm_writei(sound->phandle, buff, num);
} else
samples = samples_left;
rc = snd_pcm_writei(sound->phandle, samples[0], num);
rc = snd_pcm_writei(sound->phandle, samples, num);
if (rc < 0) {
PDEBUG(DSOUND, DEBUG_ERROR, "failed to write audio to interface (%s)\n", snd_strerror(rc));
if (rc == -EPIPE)
@ -220,10 +225,11 @@ int sound_write(void *inst, int16_t *samples_left, int16_t *samples_right, int n
#define KEEP_FRAMES 8 /* minimum frames not to read, due to bug in ALSA */
int sound_read(void *inst, int16_t *samples_left, int16_t *samples_right, int num)
int sound_read(void *inst, int16_t **samples, int num, int channels)
{
sound_t *sound = (sound_t *)inst;
int16_t buff[num << 1];
int32_t spl;
int in, rc;
int i, ii;
@ -241,7 +247,7 @@ int sound_read(void *inst, int16_t *samples_left, int16_t *samples_right, int nu
if (sound->cchannels == 2)
rc = snd_pcm_readi(sound->chandle, buff, in);
else
rc = snd_pcm_readi(sound->chandle, samples_left, in);
rc = snd_pcm_readi(sound->chandle, samples[0], in);
if (rc < 0) {
if (errno == EAGAIN)
@ -254,12 +260,23 @@ int sound_read(void *inst, int16_t *samples_left, int16_t *samples_right, int nu
}
if (sound->cchannels == 2) {
for (i = 0, ii = 0; i < rc; i++) {
*samples_right++ = buff[ii++];
*samples_left++ = buff[ii++];
if (channels < 2) {
for (i = 0, ii = 0; i < rc; i++) {
spl = buff[ii++];
spl += buff[ii++];
if (spl > 32767)
spl = 32767;
else if (spl < -32768)
spl = -32768;
samples[0][i] = spl;
}
} else {
for (i = 0, ii = 0; i < rc; i++) {
samples[0][i] = buff[ii++];
samples[1][i] = buff[ii++];
}
}
} else
memcpy(samples_right, samples_left, num << 1);
}
return rc;
}

2
src/nmt/main.c
View File

@ -343,7 +343,7 @@ int main(int argc, char *argv[])
/* create transceiver instance */
for (i = 0; i < num_kanal; i++) {
rc = nmt_create(kanal[i], (loopback) ? CHAN_TYPE_TEST : chan_type[i], sounddev[i], samplerate, cross_channels, rx_gain, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, ms_power, nmt_digits2value(traffic_area, 2), area_no, compandor, supervisory, smsc_number, send_callerid, loopback);
rc = nmt_create(kanal[i], (loopback) ? CHAN_TYPE_TEST : chan_type[i], sounddev[i], samplerate, rx_gain, do_pre_emphasis, do_de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, ms_power, nmt_digits2value(traffic_area, 2), area_no, compandor, supervisory, smsc_number, send_callerid, loopback);
if (rc < 0) {
fprintf(stderr, "Failed to create transceiver instance. Quitting!\n");
goto fail;

4
src/nmt/nmt.c
View File

@ -303,7 +303,7 @@ uint8_t nmt_country_by_short_name(const char *short_name)
static void nmt_timeout(struct timer *timer);
/* Create transceiver instance and link to a list. */
int nmt_create(int channel, enum nmt_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, uint8_t ms_power, uint8_t traffic_area, uint8_t area_no, int compandor, int supervisory, const char *smsc_number, int send_callerid, int loopback)
int nmt_create(int channel, enum nmt_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, uint8_t ms_power, uint8_t traffic_area, uint8_t area_no, int compandor, int supervisory, const char *smsc_number, int send_callerid, int loopback)
{
nmt_t *nmt;
int rc;
@ -334,7 +334,7 @@ int nmt_create(int channel, enum nmt_chan_type chan_type, const char *sounddev,
PDEBUG(DNMT, DEBUG_DEBUG, "Creating 'NMT' instance for channel = %d (sample rate %d).\n", channel, samplerate);
/* init general part of transceiver */
rc = sender_create(&nmt->sender, channel, sounddev, samplerate, cross_channels, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
rc = sender_create(&nmt->sender, channel, sounddev, samplerate, rx_gain, pre_emphasis, de_emphasis, write_rx_wave, write_tx_wave, read_rx_wave, loopback, 0, PILOT_SIGNAL_NONE);
if (rc < 0) {
PDEBUG(DNMT, DEBUG_ERROR, "Failed to init transceiver process!\n");
goto error;

2
src/nmt/nmt.h
View File

@ -143,7 +143,7 @@ const char *chan_type_long_name(enum nmt_chan_type chan_type);
double nmt_channel2freq(int channel, int uplink);
void nmt_country_list(void);
uint8_t nmt_country_by_short_name(const char *short_name);
int nmt_create(int channel, enum nmt_chan_type chan_type, const char *sounddev, int samplerate, int cross_channels, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, uint8_t ms_power, uint8_t traffic_area, uint8_t area_no, int compandor, int supervisory, const char *smsc_number, int send_callerid, int loopback);
int nmt_create(int channel, enum nmt_chan_type chan_type, const char *sounddev, int samplerate, double rx_gain, int pre_emphasis, int de_emphasis, const char *write_rx_wave, const char *write_tx_wave, const char *read_rx_wave, uint8_t ms_power, uint8_t traffic_area, uint8_t area_no, int compandor, int supervisory, const char *smsc_number, int send_callerid, int loopback);
void nmt_check_channels(void);
void nmt_destroy(sender_t *sender);
void nmt_go_idle(nmt_t *nmt);