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); }