void
session_exit(session_t *sp)
{
codec_exit();
if (sp->local_file_player) {
voxlet_destroy(&sp->local_file_player);
}
if (sp->tone_generator) {
tonegen_destroy(&sp->tone_generator);
}
if (sp->in_file_converter) {
converter_destroy(&sp->in_file_converter);
}
if (sp->in_file != NULL) {
snd_read_close (&sp->in_file);
}
if (sp->out_file != NULL) {
snd_write_close(&sp->out_file);
}
if (sp->pdb != NULL) {
pdb_destroy(&sp->pdb);
}
channel_encoder_destroy(&sp->channel_coder);
source_list_destroy(&sp->active_sources);
xfree(sp->mbus_engine_addr);
xfree(sp->mbus_video_addr);
xfree(sp->mbus_ui_addr);
xfree(sp);
}
int
audio_device_reconfigure(session_t *sp)
{
audio_config prev_config, *curr_config, *new_config;
audio_port_t iport = 0, oport = 0;
int change_req;
assert(sp->new_config != NULL);
new_config = sp->new_config;
change_req = FALSE;
if (new_config->device == 0) {
/* No request to change audio device */
new_config->device = sp->audio_device;
} else if (new_config->device != sp->audio_device) {
/* Request to change device */
change_req = TRUE;
debug_msg("Change device requested.\n");
}
if (sp->audio_device) {
iport = audio_get_iport(sp->audio_device);
oport = audio_get_oport(sp->audio_device);
}
if (new_config->primary == 0) {
/* No request to change primary encoding */
new_config->primary = codec_get_by_payload(sp->encodings[0]);
} else if (codec_audio_formats_compatible(new_config->primary, codec_get_by_payload(sp->encodings[0])) == FALSE) {
/* Request to change primary and format incompatible so
* device needs rejigging */
change_req = TRUE;
debug_msg("Change primary requested.\n");
} else {
/* Request to change primary to compatible coding. */
sp->encodings[0] = codec_get_payload(new_config->primary);
}
if (new_config->render_3d == -1) {
/* No request to change 3d rendering */
new_config->render_3d = sp->render_3d;
} else if (new_config->render_3d != sp->render_3d) {
change_req = TRUE;
debug_msg("Change 3d rendering enabled requested.\n");
}
if (change_req) {
/* Store current config in case it reconfig attempt fails */
prev_config.device = sp->audio_device;
prev_config.primary = codec_get_by_payload(sp->encodings[0]);
prev_config.render_3d = sp->render_3d;
if (sp->audio_device) {
audio_device_release(sp, sp->audio_device);
}
if (audio_device_attempt_config(sp, new_config)) {
/* New config acceptable */
curr_config = new_config;
} else if (audio_device_attempt_config(sp, &prev_config)) {
/* else attempt to fallback to previous config */
curr_config = &prev_config;
debug_msg("Fellback to old dev config\n");
} else {
/* Fallback to guaranteed config - something
* went badly wrong */
ac_destroy(&new_config);
audio_device_get_safe_config(&new_config);
assert(new_config);
if (audio_device_attempt_config(sp, new_config) == FALSE) {
/* should never get here */
abort();
}
curr_config = new_config;
debug_msg("Fell back to safe config\n");
}
debug_msg("0x%08x 0x%08x\n", prev_config.device, curr_config->device);
if (prev_config.device == curr_config->device) {
debug_msg("Restoring ports\n");
audio_set_iport(curr_config->device, iport);
audio_set_oport(curr_config->device, oport);
} else {
const audio_port_details_t *papd;
/* Ports will be squiffy */
papd = audio_get_iport_details(curr_config->device, 0);
audio_set_iport(curr_config->device, papd->port);
papd = audio_get_oport_details(curr_config->device, 0);
audio_set_oport(curr_config->device, papd->port);
}
audio_loopback(curr_config->device, sp->loopback_gain);
sp->audio_device = curr_config->device;
sp->encodings[0] = codec_get_payload(curr_config->primary);
/* If using redundancy check it is still relevent */
if (sp->num_encodings > 1 &&
!codec_audio_formats_compatible(curr_config->primary, codec_get_by_payload(sp->encodings[1]))) {
const cc_details_t *ccd;
channel_encoder_destroy(&sp->channel_coder);
ccd = channel_get_null_coder();
channel_encoder_create(ccd->descriptor, &sp->channel_coder);
sp->num_encodings = 1;
}
sp->render_3d = curr_config->render_3d;
} else {
debug_msg("audio device reconfigure - nothing to do.\n");
if (tx_is_sending(sp->tb)) {
tx_stop(sp->tb);
tx_start(sp->tb);
}
}
tx_igain_update(sp->tb);
ac_destroy(&sp->new_config);
return change_req;
}
void settings_load_early(session_t *sp)
{
/* FIXME: This needs to be updated for the transcoder */
char *name, *param, *primary_codec, *port, *silence;
int freq, chan, mute;
uint32_t i, n, success, device_exists;
const cc_details_t *ccd;
const audio_device_details_t *add = NULL;
const audio_port_details_t *apd = NULL;
const converter_details_t *cod = NULL;
const repair_details_t *r = NULL;
codec_id_t cid;
load_init(); /* Initial settings come from the common prefs file... */
init_part_two(); /* Switch to pulling settings from the RAT specific prefs file... */
if (sp->mode == AUDIO_TOOL) {
name = setting_load_str("audioDevice", "No Audio Device");
} else {
name = (char *) xmalloc(20);
sprintf(name, "Transcoder Port %d", sp->id+1);
}
/* User may not have a (valid) audio device entry in the */
/* settings file, or have "No Audio Device" there. In */
/* either case try to use first available device, if */
/* it's in use we'll fallback to dummy device anyway. */
device_exists = FALSE;
n = (int)audio_get_device_count();
for(i = 0; i < n; i++) {
add = audio_get_device_details(i);
if (strcmp(add->name, name) == 0) {
device_exists = TRUE;
break;
}
}
if (strcmp(name, "No Audio Device") == 0 || device_exists == FALSE) {
add = audio_get_device_details(0);
}
audio_device_register_change_device(sp, add->descriptor);
freq = setting_load_int("audioFrequency", 8000);
chan = setting_load_int("audioChannelsIn", 1);
primary_codec = setting_load_str("audioPrimary", "GSM");
cid = codec_get_matching(primary_codec, (uint16_t)freq, (uint16_t)chan);
if (codec_id_is_valid(cid) == FALSE) {
/* Codec name is garbage...should only happen on upgrades */
cid = codec_get_matching("GSM", (uint16_t)freq, (uint16_t)chan);
}
audio_device_register_change_primary(sp, cid);
audio_device_reconfigure(sp);
port = setting_load_str("audioOutputPort", "Headphone");
n = audio_get_oport_count(sp->audio_device);
for(i = 0; i < n; i++) {
apd = audio_get_oport_details(sp->audio_device, i);
if (!strcasecmp(port, apd->name)) {
break;
}
}
audio_set_oport(sp->audio_device, apd->port);
port = setting_load_str("audioInputPort", "Microphone");
n = audio_get_iport_count(sp->audio_device);
for(i = 0; i < n; i++) {
apd = audio_get_iport_details(sp->audio_device, i);
if (!strcasecmp(port, apd->name)) {
break;
}
}
audio_set_iport(sp->audio_device, apd->port);
audio_set_ogain(sp->audio_device, setting_load_int("audioOutputGain", 75));
audio_set_igain(sp->audio_device, setting_load_int("audioInputGain", 75));
tx_igain_update(sp->tb);
name = setting_load_str("audioChannelCoding", "None");
param = setting_load_str("audioChannelParameters", "None");
do {
n = channel_get_coder_count();
for (i = 0; i < n; i++ ) {
ccd = channel_get_coder_details(i);
if (strcmp(ccd->name, name) == 0) {
if (sp->channel_coder) {
channel_encoder_destroy(&sp->channel_coder);
}
channel_encoder_create(ccd->descriptor, &sp->channel_coder);
break;
}
}
success = channel_encoder_set_parameters(sp->channel_coder, param);
if (success == 0) {
/* Could not set parameters for channel coder, fall back to "None" */
name = "None";
param = "";
}
} while (success == 0);
channel_encoder_set_units_per_packet(sp->channel_coder, (uint16_t) setting_load_int("audioUnits", 1));
/* Set default repair to be first available */
r = repair_get_details(0);
sp->repair = r->id;
name = setting_load_str("audioRepair", "Pattern-Match");
n = (int)repair_get_count();
for(i = 0; i < n; i++) {
r = repair_get_details((uint16_t)i);
if (strcasecmp(r->name, name) == 0) {
sp->repair = r->id;
break;
}
}
/* Set default converter to be first available */
cod = converter_get_details(0);
sp->converter = cod->id;
name = setting_load_str("audioAutoConvert", "High Quality");
n = (int)converter_get_count();
/* If converter setting name matches then override existing choice */
for(i = 0; i < n; i++) {
cod = converter_get_details(i);
if (strcasecmp(cod->name, name) == 0) {
sp->converter = cod->id;
break;
}
}
silence = setting_load_str("audioSilence", "Automatic");
sp->silence_detection = sd_name_to_type(silence);
sp->manual_sd_thresh = setting_load_int("audioSilenceManualThresh", 100);
if (sp->manual_sd) {
manual_sd_set_thresh(sp->manual_sd, sp->manual_sd_thresh);
}
sp->limit_playout = setting_load_int("audioLimitPlayout", 0);
sp->min_playout = setting_load_int("audioMinPlayout", 0);
sp->max_playout = setting_load_int("audioMaxPlayout", 2000);
sp->lecture = setting_load_int("audioLecture", 0);
sp->agc_on = setting_load_int("audioAGC", 0);
sp->loopback_gain = setting_load_int("audioLoopback", 0);
audio_loopback(sp->audio_device, sp->loopback_gain);
sp->echo_suppress = setting_load_int("audioEchoSuppress", 0);
sp->meter = setting_load_int("audioPowermeters", 1);
sp->rtp_promiscuous_mode = setting_load_int("rtpPromiscuousMode", 0);
sp->rtp_wait_for_rtcp = setting_load_int("rtpWaitForRTCP", 1);
/* Ignore saved render_3d setting. Break initial device config stuff. V.fiddly to fix. */
/* sp->render_3d = setting_load_int("audio3dRendering", 0); */
mute = setting_load_int("audioInputMute", sp->mode==TRANSCODER?0:1);
if (mute && tx_is_sending(sp->tb)) {
tx_stop(sp->tb);
} else if (mute == 0 && tx_is_sending(sp->tb) == 0) {
tx_start(sp->tb);
}
setting_load_int("audioOutputMute", 1);
xmemchk();
load_done();
}
