int main()
{
codec_id_t cid;
u_int16 ic, ir, oc, or;
for(ic = 1; ic <= 2; ic++) {
for(ir = 8000; ir <= 48000; ir += 8000) {
cid = codec_get_native_coding(ir, ic);
codec_get_native_info(cid, &or, &oc);
debug_msg("0x%08x % 5d %d % 5d %d\n",
cid, ir, ic, or, oc);
assert(ir == or);
assert(ic == oc);
}
}
return 1;
}
static void
test_render(struct s_render_3D_dbentry *r, int rate)
{
int n_channels, azimuth, filter, lindex, length,i;
sample *s;
coded_unit in, out;
memset(&in, 0, sizeof(coded_unit));
memset(&out, 0, sizeof(coded_unit));
in.data = (u_char*)block_alloc(SAMPLES*sizeof(sample));
in.data_len = SAMPLES * sizeof(sample);
s = (sample*)in.data;
for(i = 0; i < SAMPLES; i++) {
s[i] = (sample)(12000 * sin(M_PI* (float)i/(float)SAMPLES));
}
for(n_channels = 1; n_channels <=2; n_channels++) {
for(filter = 0; filter < render_3D_filter_get_count(); filter++) {
for(lindex = 0; lindex < render_3D_filter_get_lengths_count(); lindex++) {
length = render_3D_filter_get_length(lindex);
printf("%d %d % 5d ",
n_channels,
length,
rate);
printf("%s(%d)\t",
render_3D_filter_get_name(filter),
filter);
for(azimuth = render_3D_filter_get_lower_azimuth();
azimuth <= render_3D_filter_get_upper_azimuth();
azimuth += 5) {
render_3D_set_parameters(r, rate, azimuth, filter, length);
in.id = codec_get_native_coding(rate, n_channels);
render_3D(r, &in, &out);
codec_clear_coded_unit(&out);
printf(".");
}
printf("\n");
}
}
}
codec_clear_coded_unit(&in);
}
static int
read_and_encode(coded_unit *out,
codec_state *encoder,
struct s_sndfile *sf_in)
{
const codec_format_t *cf;
coded_unit dummy;
sample *buf;
uint16_t req_samples, act_samples;
req_samples = codec_get_samples_per_frame(encoder->id);
buf = (sample*)block_alloc(sizeof(sample) * req_samples);
act_samples = (uint16_t)snd_read_audio(&sf_in, buf, req_samples);
if (req_samples != act_samples) {
memset(buf + act_samples, 0, sizeof(short) * (req_samples - act_samples));
}
cf = codec_get_format(encoder->id);
assert(cf != NULL);
dummy.id = codec_get_native_coding((uint16_t)cf->format.sample_rate,
(uint16_t)cf->format.channels);
dummy.state = NULL;
dummy.state_len = 0;
dummy.data = (u_char*)buf;
dummy.data_len = req_samples * sizeof(short);
assert(out != NULL);
if (codec_encode(encoder, &dummy, out) == FALSE) {
abort();
}
block_free(dummy.data, dummy.data_len);
return (sf_in != NULL);
}
int
codec_decode(codec_state *cs,
coded_unit *in,
coded_unit *out)
{
const codec_format_t *cf;
codec_id_t id;
uint16_t ifs, fmt, rate, channels;
int success;
assert(cs != NULL);
assert(out != NULL);
assert(in != NULL);
id = cs->id;
assert(in->id == cs->id);
assert(codec_is_native_coding(in->id) == FALSE);
ifs = CODEC_GET_IFS_INDEX(id);
fmt = CODEC_GET_FMT_INDEX(id);
/* Setup outgoing data block */
cf = codec_get_format(id);
assert(out->state == NULL);
assert(out->data == NULL);
rate = (uint16_t)cf->format.sample_rate;
channels = (uint16_t)cf->format.channels;
out->id = codec_get_native_coding(rate, channels);
out->data_len = cf->format.bytes_per_block;
out->data = (u_char*)block_alloc(out->data_len);
/* Decode */
xmemchk();
success = codec_table[ifs].cx_decode(fmt, cs->state, in, (sample*)out->data);
xmemchk();
return success;
}
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);
}
