static void resolve_repair(char *reqname, repair_id_t *rid, const char **actualname) { uint16_t i,n; const repair_details_t *rd; n = repair_get_count(); for (i = 0; i < n; i++) { rd = repair_get_details(i); if (strcasecmp(rd->name, reqname) == 0) { *rid = rd->id; *actualname = rd->name; return; } } fprintf(stderr, "Repair type %s not recognized\n", reqname); exit(-1); }
static void list_repairs(void) { /* Repair interface is not consistent with other interfaces. * Does not have get_format get_details type fn, just get_name * (grumble, grumble, time, grumble) */ const repair_details_t *rd; uint16_t i, cnt; cnt = repair_get_count(); for(i = 0; i < cnt; i++) { rd = repair_get_details(i); printf("%s\n", rd->name); } return; }
void settings_save(session_t *sp) { /* FIXME: This needs to be updated for the transcoder */ const codec_format_t *pri_cf; const audio_port_details_t *iapd = NULL; const audio_port_details_t *oapd = NULL; const audio_format *af = NULL; const repair_details_t *repair = NULL; const converter_details_t *converter = NULL; const audio_device_details_t *add = NULL; const cc_details_t *ccd = NULL; codec_id_t pri_id; int cc_len; char *cc_param; int i; uint16_t j,n; uint32_t my_ssrc; pri_id = codec_get_by_payload(sp->encodings[0]); pri_cf = codec_get_format(pri_id); cc_len = 3 * (CODEC_LONG_NAME_LEN + 4) + 1; cc_param = (char*) xmalloc(cc_len); channel_encoder_get_parameters(sp->channel_coder, cc_param, cc_len); ccd = channel_get_coder_identity(sp->channel_coder); n = (uint16_t)converter_get_count(); for (j = 0; j < n; j++) { converter = converter_get_details(j); if (sp->converter == converter->id) { break; } } n = repair_get_count(); for (j = 0; j < n; j++) { repair = repair_get_details(j); if (sp->repair == repair->id) { break; } } n = (int)audio_get_device_count(); for (i = 0; i < n; i++) { add = audio_get_device_details(i); if (sp->audio_device == add->descriptor) { break; } } af = audio_get_ifmt(sp->audio_device); for(i = 0; i < audio_get_iport_count(sp->audio_device); i++) { iapd = audio_get_iport_details(sp->audio_device, i); if (iapd->port == audio_get_iport(sp->audio_device)) { break; } } for(i = 0; i < audio_get_oport_count(sp->audio_device); i++) { oapd = audio_get_oport_details(sp->audio_device, i); if (oapd->port == audio_get_oport(sp->audio_device)) { break; } } save_init_rtp(); my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); setting_save_str("rtpName", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NAME)); setting_save_str("rtpEmail", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_EMAIL)); setting_save_str("rtpPhone", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_PHONE)); setting_save_str("rtpLoc", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_LOC)); setting_save_str("rtpNote", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NOTE)); save_done_rtp(); save_init_rat(); setting_save_str("audioTool", rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_TOOL)); setting_save_str("audioDevice", add->name); setting_save_int("audioFrequency", af->sample_rate); setting_save_int("audioChannelsIn", af->channels); /* If we save a dynamically mapped codec we crash when we reload on startup */ if (pri_cf->default_pt != CODEC_PAYLOAD_DYNAMIC) { setting_save_str("audioPrimary", pri_cf->short_name); } setting_save_int("audioUnits", channel_encoder_get_units_per_packet(sp->channel_coder)); /* Don't save the layered channel coder - you need to start it */ /* from the command line anyway */ if (strcmp(ccd->name, "Layering") == 0) { setting_save_str("audioChannelCoding", "Vanilla"); } else { setting_save_str("audioChannelCoding", ccd->name); } setting_save_str("audioChannelParameters", cc_param); setting_save_str("audioRepair", repair->name); setting_save_str("audioAutoConvert", converter->name); setting_save_int("audioLimitPlayout", sp->limit_playout); setting_save_int("audioMinPlayout", sp->min_playout); setting_save_int("audioMaxPlayout", sp->max_playout); setting_save_int("audioLecture", sp->lecture); setting_save_int("audio3dRendering", sp->render_3d); setting_save_int("audioAGC", sp->agc_on); setting_save_int("audioLoopback", sp->loopback_gain); setting_save_int("audioEchoSuppress", sp->echo_suppress); setting_save_int("audioOutputGain", audio_get_ogain(sp->audio_device)); setting_save_int("audioInputGain", audio_get_igain(sp->audio_device)); setting_save_str("audioOutputPort", oapd->name); setting_save_str("audioInputPort", iapd->name); setting_save_int("audioPowermeters", sp->meter); setting_save_str("audioSilence", sd_name(sp->silence_detection)); setting_save_int("audioSilenceManualThresh", sp->manual_sd_thresh); /* We do not save audioOutputMute and audioInputMute by default, but should */ /* recognize them when reloading. */ save_done_rat(); xfree(cc_param); }
static void test_repair(struct s_sndfile *sf_out, codec_id_t cid, repair_id_t repair_type, struct s_sndfile *sf_in) { codec_state *encoder; struct s_codec_state_store *decoder_states; media_data *md_prev, *md_cur; coded_unit *cu; int32_t consec_lost = 0, total_lost, total_done; const codec_format_t *cf; uint16_t i; repair_id_t repair_none; for (i = 0; i < repair_get_count(); i++) { const repair_details_t *rd; rd = repair_get_details(i); if (strcasecmp(rd->name, "none") == 0) { repair_none = rd->id; break; } } codec_encoder_create(cid, &encoder); codec_state_store_create(&decoder_states, DECODER); cf = codec_get_format(cid); /* Read and write one unit to kick off with */ media_data_create(&md_cur, 1); read_and_encode(md_cur->rep[0], encoder, sf_in); decode_and_write(sf_out, decoder_states, md_cur); /* Initialize next reading cycle */ md_prev = md_cur; md_cur = NULL; media_data_create(&md_cur, 1); total_lost = total_done = 0; while(read_and_encode(md_cur->rep[0], encoder, sf_in)) { total_done++; if (do_drop()) { total_lost++; media_data_destroy(&md_cur, sizeof(media_data)); media_data_create(&md_cur, 0); cu = (coded_unit*)block_alloc(sizeof(coded_unit)); assert(cu != NULL); memset(cu, 0, sizeof(coded_unit)); /* Loss happens - invoke repair */ if (repair_type != repair_none) { cu->id = cid; repair(repair_type, consec_lost, decoder_states, md_prev, cu); } else { /* Create a silent unit */ cu->id = codec_get_native_coding((uint16_t)cf->format.sample_rate, (uint16_t)cf->format.channels); cu->state = NULL; cu->state_len = 0; cu->data = (u_char*)block_alloc(cf->format.bytes_per_block); cu->data_len = cf->format.bytes_per_block; memset(cu->data, 0, cu->data_len); } /* Add repaired audio to frame */ md_cur->rep[md_cur->nrep] = cu; md_cur->nrep++; consec_lost++; } else { consec_lost = 0; } decode_and_write(sf_out, decoder_states, md_cur); media_data_destroy(&md_prev, sizeof(media_data)); md_prev = md_cur; md_cur = NULL; media_data_create(&md_cur, 1); } printf("# Dropped %d frames out of %d (%f loss %%)\n", total_lost, total_done, 100.0 * total_lost / (double)total_done); media_data_destroy(&md_cur, sizeof(media_data)); media_data_destroy(&md_prev, sizeof(media_data)); codec_encoder_destroy(&encoder); codec_state_store_destroy(&decoder_states); }
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(); }