int
vanilla_decoder_describe (uint8_t pkt_pt,
u_char *data,
uint32_t data_len,
char *out,
uint32_t out_len)
{
codec_id_t pri_id;
const codec_format_t *pri_cf;
pri_id = codec_get_by_payload(pkt_pt);
if (pri_id) {
pri_cf = codec_get_format(pri_id);
strncpy(out, pri_cf->long_name, out_len);
} else {
strncpy(out, "Unknown", out_len);
}
/* string safety - strncpy not always safe */
out[out_len - 1] = '\0';
UNUSED(data);
UNUSED(data_len);
return TRUE;
}
u_char
codec_get_payload(codec_id_t id)
{
u_char pt;
assert(codec_id_is_valid(id));
pt = codec_map[CODEC_GET_IFS_INDEX(id)][CODEC_GET_FMT_INDEX(id)];
if (payload_is_valid(pt)) {
assert(codec_get_by_payload(pt) == id);
return pt;
}
return CODEC_PAYLOAD_DYNAMIC;
}
int
vanilla_decoder_peek(uint8_t pkt_pt,
u_char *buf,
uint32_t len,
uint16_t *upp,
uint8_t *pt)
{
codec_id_t cid;
assert(buf != NULL);
assert(upp != NULL);
assert(pt != NULL);
cid = codec_get_by_payload(pkt_pt);
if (cid) {
const codec_format_t *cf;
uint32_t unit, done, step;
/* Vanilla coding does nothing but group
* units.
*/
cf = codec_get_format(cid);
unit = 0;
done = cf->mean_per_packet_state_size;
while(done < len) {
step = codec_peek_frame_size(cid, buf+done, (uint16_t)(len - done));
if (step == 0) {
debug_msg("Zero data len for audio unit ?\n");
goto fail;
}
done += step;
unit ++;
}
assert(done >= len);
if (done != len) goto fail;
*upp = (uint16_t)unit;
*pt = pkt_pt;
return TRUE;
}
fail:
*upp = 0;
*pt = 255;
return FALSE;
}
static void
vanilla_decoder_output(channel_unit *cu, struct s_pb *out, timestamp_t playout)
{
const codec_format_t *cf;
codec_id_t id;
uint32_t data_len;
u_char *p, *end;
media_data *m;
timestamp_t unit_dur;
id = codec_get_by_payload(cu->pt);
cf = codec_get_format(id);
unit_dur = ts_map32(cf->format.sample_rate, codec_get_samples_per_frame(id));
p = cu->data;
end = cu->data + cu->data_len;
while(p < end) {
media_data_create(&m, 1);
m->rep[0]->id = id;
if (p == cu->data && cf->mean_per_packet_state_size) {
/* First unit out of packet may have state */
m->rep[0]->state_len = cf->mean_per_packet_state_size;
m->rep[0]->state = (u_char*)block_alloc(m->rep[0]->state_len);
memcpy(m->rep[0]->state, p, cf->mean_per_packet_state_size);
p += cf->mean_per_packet_state_size;
}
/* Now do data section */
data_len = codec_peek_frame_size(id, p, (uint16_t)(end - p));
m->rep[0]->data = (u_char*)block_alloc(data_len);
m->rep[0]->data_len = (uint16_t)data_len;
memcpy(m->rep[0]->data, p, data_len);
if (pb_add(out, (u_char *)m, sizeof(media_data), playout) == FALSE) {
debug_msg("Vanilla decode failed\n");
media_data_destroy(&m, sizeof(media_data));
return;
}
p += data_len;
playout = ts_add(playout, unit_dur);
}
assert(p == end);
}
/* Just returns the long name of the codec.
* Could display number of layers if really bothered.
*/
int
layered_decoder_describe (uint8_t pkt_pt,
u_char *data,
uint32_t data_len,
char *out,
uint32_t out_len)
{
uint32_t hdr32, slen;
uint8_t hdrpt;
uint16_t blen, mrk;
codec_id_t pri_id;
const codec_format_t *pri_cf;
UNUSED(pkt_pt);
hdr32 = ntohl(*(uint32_t*)data);
if(hdr32 & LAY_HDR32_PAT) {
hdrpt = (uint8_t)(LAY_HDR32_GET_PT(hdr32));
mrk = (uint16_t)(LAY_HDR32_GET_MRK(hdr32));
blen = (uint16_t)(LAY_HDR32_GET_LEN(hdr32));
pri_id = codec_get_by_payload(hdrpt);
if(pri_id) {
pri_cf = codec_get_format(pri_id);
slen = strlen(pri_cf->long_name);
strncpy(out, pri_cf->long_name, out_len);
goto done;
}
}
strncpy(out, "Unknown", out_len);
done:
/* string safety - strncpy not always safe */
out[out_len - 1] = '\0';
UNUSED(data_len);
return TRUE;
}
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;
}
int
layered_decoder_peek(uint8_t pkt_pt,
u_char *buf,
uint32_t len,
uint16_t *upp,
uint8_t *pt)
{
codec_id_t cid;
u_char *p, *data;
uint32_t hdr32;
uint8_t hdrpt;
uint16_t blen, mrk;
assert(buf != NULL);
assert(upp != NULL);
assert(pt != NULL);
UNUSED(pkt_pt);
p = data = buf;
hdr32 = ntohl(*(uint32_t*)p);
if(hdr32 & LAY_HDR32_PAT) {
hdrpt = (uint8_t)(LAY_HDR32_GET_PT(hdr32));
mrk = (uint16_t)(LAY_HDR32_GET_MRK(hdr32));
blen = (uint16_t)(LAY_HDR32_GET_LEN(hdr32));
p+=4;
data += 4 + blen;
hdr32 = ntohl(*(uint32_t*)p);
/* assert(((uint32_t)data - (uint32_t)buf) <= blen); */
}
else {
debug_msg("Invalid layered header\n");
goto fail;
}
/* I'm haven't decided what exactly to do here yet, so for
* the time being if the header seems OK we return TRUE. The
* options are:
* (i) have a new function codec_peek_layer_frame_size
* (ii) work out length of total frame from length in header
* (iii) just check that length of packet matches what is in
* the header
* But what to do about *upp?
* The problem is that codec_peek_frame_size, if used with
* codec_vdvi, calls vdvi_decode, assuming a complete frame.
* Of course we only have one layer at this stage, so the
* decode function will fail. I am going to ignore this for
* the time being.
*/
*pt = hdrpt;
cid = codec_get_by_payload(*pt);
if (cid) {
const codec_format_t *cf;
uint32_t unit, done, step;
/* extra check since the header check seems
* to fail quite a lot (why?)
*/
if(codec_can_layer(cid)==1) goto fail;
cf = codec_get_format(cid);
unit = 0;
done = cf->mean_per_packet_state_size;
done += 4; /* step over header */
while(done < len) {
step = codec_peek_frame_size(cid, buf+done, (uint16_t)(len));
if (step == 0) {
debug_msg("Zero data len for audio unit ?\n");
goto fail;
}
done += blen;
unit ++;
}
/* assert(done <= len);*/
if (done != len) goto fail;
*upp = (uint16_t)unit;
return TRUE;
}
debug_msg("layered_decoder_peek - codec not found\n");
fail:
debug_msg("layered_decoder_peek error (len = %d)\n", len);
*upp = 0;
*pt = 255;
return FALSE;
}
static int
layered_decoder_reorganise(channel_data *in, struct s_pb *out, timestamp_t playout)
{
const codec_format_t *cf;
codec_id_t id;
coded_unit *cu;
u_char *p[LAY_MAX_LAYERS], *end;
uint32_t hdr32, data_len;
uint8_t hdrpt, i;
uint16_t len[LAY_MAX_LAYERS], mrk[LAY_MAX_LAYERS];
media_data *m;
timestamp_t playout_step;
media_data_create(&m, 1);
assert(m->nrep == 1);
if(in->nelem > LAY_MAX_LAYERS) {
debug_msg("Too many layers to reorganise\n");
goto done;
}
/* Since layer_decoder_peek checks all the headers, we can
* assume they are OK. We still need to check that they match
* up, however, i.e. that all the layers are intact, and that
* they are all using the same codec. Layers need to be sorted
* into order as well. We use the markers to determine how to
* join the layers together into one media_data, and then get
* out of here.
*/
p[0] = in->elem[0]->data;
hdr32 = ntohl(*(uint32_t*)p[0]);
if(hdr32 & LAY_HDR32_PAT) {
hdrpt = (uint8_t)(LAY_HDR32_GET_PT(hdr32));
mrk[0] = (uint8_t)(LAY_HDR32_GET_MRK(hdr32));
len[0] = (uint8_t)(LAY_HDR32_GET_LEN(hdr32));
p[0] += 4;
}
else {
debug_msg("Invalid layered header\n");
goto done;
}
for(i=1; i<in->nelem; i++) {
p[i] = in->elem[i]->data;
hdr32 = ntohl(*(uint32_t*)p[i]);
if(hdr32 & LAY_HDR32_PAT) {
if(hdrpt != (uint8_t)(LAY_HDR32_GET_PT(hdr32))) {
debug_msg("layered headers do not match!\n");
goto done;
}
mrk[i] = (uint16_t)(LAY_HDR32_GET_MRK(hdr32));
len[i] = (uint16_t)(LAY_HDR32_GET_LEN(hdr32));
p[i] += 4;
}
else {
debug_msg("Invalid layered header\n");
goto done;
}
}
end = in->elem[in->nelem-1]->data + in->elem[in->nelem-1]->data_len;
/* if layers missing say so */
if(in->nelem!=LAY_MAX_LAYERS) {
debug_msg("Not all layers arrived:\n");
for(i=0; i<in->nelem; i++) {
debug_msg("marker[%d] = %d\n", i, mrk[i]);
}
}
/* Everything matches, so we'll use the first layer's details */
cu = (coded_unit*)block_alloc(sizeof(coded_unit));
memset(cu, 0, sizeof(coded_unit));
id = codec_get_by_payload(hdrpt);
if (codec_id_is_valid(id) == FALSE) {
debug_msg("Layered channel coder - codec_id not recognised.\n");
goto fail;
}
cf = codec_get_format(id);
assert(cf != NULL);
/* Do first unit separately as that may have state */
if (cf->mean_per_packet_state_size) {
cu->state_len = cf->mean_per_packet_state_size;
cu->state = (u_char*)block_alloc(cu->state_len);
memcpy(cu->state, p[0], cf->mean_per_packet_state_size);
for(i=0; i<in->nelem; i++)
p[i] += cf->mean_per_packet_state_size;
}
data_len = codec_peek_frame_size(id, p[0], (uint16_t)(len[0]));
m->rep[0]->id = cu->id = id;
cu->data = (u_char*)block_alloc(data_len);
cu->data_len = (uint16_t)data_len;
memset(cu->data, 0, data_len);
/* join the layers up here */
for(i=0; i<in->nelem; i++) {
memcpy(cu->data + mrk[i], p[i], len[i]);
p[i] += len[i];
}
codec_combine_layer(id, cu, m->rep[0], in->nelem, mrk);
if (cu->state_len) {
block_free(cu->state, cu->state_len);
cu->state = NULL;
cu->state_len = 0;
}
assert(cu->state_len == 0);
if (cu->data_len) {
block_free(cu->data, cu->data_len);
cu->data = NULL;
cu->data_len = 0;
}
assert(cu->data_len == 0);
if (pb_add(out, (u_char *)m, sizeof(media_data), playout) == FALSE) {
debug_msg("layered decode failed\n");
goto fail;
}
/* Now do other units which do not have state*/
playout_step = ts_map32(cf->format.sample_rate, codec_get_samples_per_frame(id));
while(p[in->nelem - 1] < end) {
playout = ts_add(playout, playout_step);
media_data_create(&m, 1);
m->rep[0]->id = id;
assert(m->nrep == 1);
cu->data = (u_char*)block_alloc(data_len);
cu->data_len = (uint16_t)data_len;
memset(cu->data, 0, data_len);
for(i=0; i<in->nelem; i++) {
memcpy(cu->data + mrk[i], p[i], len[i]);
p[i] += len[i];
}
codec_combine_layer(id, cu, m->rep[0], in->nelem, mrk);
block_free(cu->data, cu->data_len);
cu->data = 0;
cu->data_len = 0;
if (pb_add(out, (u_char *)m, sizeof(media_data), playout) == FALSE) {
debug_msg("layered decode failed\n");
goto fail;
}
}
assert(p[in->nelem - 1] == end);
block_free(cu, sizeof(coded_unit));
channel_data_destroy(&in, sizeof(channel_data));
xmemchk();
return TRUE;
fail:
if (cu->state) {
block_free(cu->state, cu->state_len);
cu->state = 0;
cu->state_len = 0;
}
assert(cu->state_len == 0);
if (cu->data) {
block_free(cu->data, cu->data_len);
cu->data = 0;
cu->data_len = 0;
}
assert(cu->data_len == 0);
block_free(cu, sizeof(coded_unit));
done:
media_data_destroy(&m, sizeof(media_data));
channel_data_destroy(&in, sizeof(channel_data));
xmemchk();
return FALSE;
}
static void
redundancy_decoder_output(channel_unit *chu, struct s_pb *out, timestamp_t playout)
{
const codec_format_t *cf;
codec_id_t cid;
u_char *hp, *dp, *de, ppt, bpt;
uint32_t hdr32, blen, boff;
timestamp_t ts_max_off, ts_blk_off, this_playout;
hp = dp = chu->data;
de = chu->data + chu->data_len;
/* move data pointer past header */
while (ntohl(*((uint32_t*)dp)) & RED_HDR32_PAT) {
dp += 4;
}
if (dp == hp) {
debug_msg("Not a redundant block\n");
return;
}
/* At this point dp points to primary payload type.
* This is a most useful quantity... */
ppt = *dp;
dp += 1;
assert(dp < de);
/* Max offset should be in first header. Want max offset
* as we nobble timestamps to be:
* playout + max_offset - this_offset
*/
cid = codec_get_by_payload(ppt);
if (codec_id_is_valid(cid) == FALSE) {
debug_msg("Primary not recognized.\n");
return;
}
cf = codec_get_format(cid);
assert(cf != NULL);
hdr32 = ntohl(*(uint32_t*)hp);
ts_max_off = ts_map32(cf->format.sample_rate, RED_HDR32_GET_OFF(hdr32));
blen = 0;
while (hdr32 & RED_HDR32_PAT) {
boff = RED_HDR32_GET_OFF(hdr32);
blen = RED_HDR32_GET_LEN(hdr32);
bpt = (u_char)RED_HDR32_GET_PT(hdr32);
/* Calculate playout point = playout + max_offset - offset */
ts_blk_off = ts_map32(cf->format.sample_rate, boff);
this_playout = ts_add(playout, ts_max_off);
this_playout = ts_sub(this_playout, ts_blk_off);
hp += 4; /* hdr */
red_split_unit(ppt, bpt, dp, blen, this_playout, out);
xmemchk();
dp += blen;
hdr32 = ntohl(*(uint32_t*)hp);
}
this_playout = ts_add(playout, ts_max_off);
hp += 1;
blen = (uint32_t) (de - dp);
red_split_unit(ppt, ppt, dp, blen, this_playout, out);
xmemchk();
}
static void
red_split_unit(u_char ppt, /* Primary payload type */
u_char bpt, /* Block payload type */
u_char *b, /* Block pointer */
uint32_t blen, /* Block len */
timestamp_t playout, /* Block playout time */
struct s_pb *out) /* media buffer */
{
const codec_format_t *cf;
media_data *md;
codec_id_t cid, pid;
coded_unit *cu;
u_char *p,*pe;
timestamp_t step;
pid = codec_get_by_payload(ppt);
if (!pid) {
debug_msg("Payload not recognized\n");
return;
}
cid = codec_get_by_payload(bpt);
if (!cid) {
debug_msg("Payload not recognized\n");
return;
}
if (!codec_audio_formats_compatible(pid, cid)) {
debug_msg("Primary (%d) and redundant (%d) not compatible\n", ppt, bpt);
return;
}
cf = codec_get_format(cid);
assert(cf != NULL);
step = ts_map32(cf->format.sample_rate, codec_get_samples_per_frame(cid));
p = b;
pe = b + blen;
while(p < pe) {
cu = (coded_unit*)block_alloc(sizeof(coded_unit));
cu->id = cid;
if (p == b && cf->mean_per_packet_state_size) {
cu->state_len = cf->mean_per_packet_state_size;
cu->state = block_alloc(cu->state_len);
memcpy(cu->state, p, cu->state_len);
p += cu->state_len;
} else {
cu->state = NULL;
cu->state_len = 0;
}
cu->data_len = (uint16_t)codec_peek_frame_size(cid, p, (uint16_t)(pe - p));
cu->data = block_alloc(cu->data_len);
memcpy(cu->data, p, cu->data_len);
p += cu->data_len;
md = red_media_data_create_or_get(out, playout);
if (md->nrep == MAX_MEDIA_UNITS) continue;
if (place_unit(md, cu) == TRUE) {
playout = ts_add(playout, step);
} else {
/* unit could not be placed - destroy */
if (cu->state_len) {
block_free(cu->state, cu->state_len);
}
block_free(cu->data, cu->data_len);
block_free(cu, sizeof(coded_unit));
}
}
}
int
redundancy_decoder_describe (uint8_t pkt_pt,
u_char *data,
uint32_t data_len,
char *out,
uint32_t out_len)
{
const codec_format_t *cf;
codec_id_t cid;
uint32_t hdr32, slen, blksz, off, nlen;
u_char *p, pt;
UNUSED(pkt_pt);
*out = '\0';
slen = 0;
p = data;
hdr32 = ntohl(*((uint32_t*)p));
while (hdr32 & RED_HDR32_PAT) {
pt = (u_char)RED_HDR32_GET_PT(hdr32);
off = RED_HDR32_GET_OFF(hdr32);
blksz = RED_HDR32_GET_LEN(hdr32);
cid = codec_get_by_payload(pt);
if (cid == 0) {
p += 4;
hdr32 = ntohl(*((uint32_t*)p));
continue;
}
cf = codec_get_format(cid);
assert(cf != NULL);
nlen = strlen(cf->long_name);
if (slen + nlen >= out_len) {
debug_msg("Out of buffer space\n");
return FALSE;
}
if (slen != 0) {
memmove(out + nlen + 1, out, slen);
}
strncpy(out, cf->long_name, nlen);
slen += nlen;
out[nlen] = '/';
slen++;
out[nlen+1] = '\0';
p += 4;
assert((uint32_t)(p - data) < data_len);
hdr32 = ntohl(*((uint32_t*)p));
}
pt = *p;
cid = codec_get_by_payload(pt);
if (cid == 0) {
return FALSE;
}
cf = codec_get_format(cid);
assert(cf != NULL);
nlen = strlen(cf->long_name);
if (slen + nlen >= out_len) {
debug_msg("Out of buffer space\n");
return FALSE;
}
memmove(out + nlen + 1, out, slen);
strncpy(out, cf->long_name, nlen);
out[nlen] = '/';
slen += nlen + 1;
/* Axe trailing separator */
out[slen-1] = '\0';
return TRUE;
}
int
redundancy_decoder_peek(uint8_t pkt_pt,
u_char *buf,
uint32_t len,
uint16_t *upp,
uint8_t *pt)
{
const codec_format_t *cf;
codec_id_t cid;
u_char *p, *data;
uint32_t hdr32, dlen, blen;
uint16_t units;
assert(buf != NULL);
assert(upp != NULL);
assert(pt != NULL);
/* Just check primary, so skip over other headers and
* advance data pointer past them.
*/
p = data = buf;
hdr32 = ntohl(*(uint32_t*)p);
while ((hdr32 & RED_HDR32_PAT)) {
blen = RED_HDR32_GET_LEN(hdr32);
p += 4; /* goto next hdr */
data += 4 + blen;
hdr32 = ntohl(*(uint32_t*)p);
assert(((unsigned long)data - (unsigned long)buf) <= len);
}
*pt = *p;
data += 1; /* step over payload field of primary */
cid = codec_get_by_payload(*pt);
if (!cid) {
debug_msg("Codec not found\n");
return FALSE;
}
/* Primary data length */
dlen = len - (uint32_t)(data - buf);
cf = codec_get_format(cid);
assert(cf);
data += cf->mean_per_packet_state_size;
dlen -= cf->mean_per_packet_state_size;
assert(((unsigned long)data - (unsigned long)buf) <= len);
units = 0;
while (dlen != 0) {
blen = codec_peek_frame_size(cid, p, (uint16_t)dlen);
assert(blen != 0);
data += blen;
dlen -= blen;
units ++;
assert(((unsigned long)data - (unsigned long)buf) <= len);
}
*upp = units;
assert(*upp < 50);
UNUSED(pkt_pt);
return TRUE;
}
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);
}
