/*
* Encode test. Read input from WAV file, encode to temporary output file,
* and compare the temporary output file to the reference file.
*/
static int codec_test_encode(pjmedia_codec_mgr *mgr,
char *codec_name,
unsigned bitrate,
const char *wav_file,
const char *ref_encoded_file)
{
pj_str_t codec_id = pj_str(codec_name);
pj_pool_t *pool = NULL;
unsigned count, samples_per_frame, encoded_frame_len = 0, pos;
pjmedia_codec *codec = NULL;
const pjmedia_codec_info *ci[1];
pjmedia_codec_param codec_param;
pjmedia_port *wav_port = NULL;
pjmedia_frame in_frame, out_frame;
FILE *output = NULL, *fref = NULL;
int rc = 0;
pj_status_t status;
pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL);
if (!pool) {
rc = -20;
goto on_return;
}
/* Find and open the codec */
count = 1;
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL);
if (status != PJ_SUCCESS) {
rc = -30;
goto on_return;
}
status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec);
if (status != PJ_SUCCESS) {
rc = -40;
goto on_return;
}
status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param);
if (status != PJ_SUCCESS) {
rc = -50;
goto on_return;
}
codec_param.info.avg_bps = bitrate;
codec_param.setting.vad = 0;
status = codec->op->init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = codec->op->open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = -70;
goto on_return;
}
/* Open WAV file */
status = pjmedia_wav_player_port_create(pool, wav_file,
codec_param.info.frm_ptime,
PJMEDIA_FILE_NO_LOOP, 0,
&wav_port);
if (status != PJ_SUCCESS) {
rc = -80;
goto on_return;
}
/* Open output file */
output = fopen(TMP_OUT, "wb");
if (!output) {
rc = -90;
goto on_return;
}
/* Allocate buffer for PCM and encoded frames */
samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000;
in_frame.buf = pj_pool_alloc(pool, samples_per_frame * 2);
out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame);
/* Loop read WAV file and encode and write to output file */
for (;;) {
in_frame.size = samples_per_frame * 2;
in_frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
status = pjmedia_port_get_frame(wav_port, &in_frame);
if (status != PJ_SUCCESS || in_frame.type != PJMEDIA_FRAME_TYPE_AUDIO)
break;
out_frame.size = samples_per_frame;
status = codec->op->encode(codec, &in_frame, samples_per_frame,
&out_frame);
if (status != PJ_SUCCESS) {
rc = -95;
goto on_return;
}
if (out_frame.size) {
int cnt;
cnt = fwrite(out_frame.buf, out_frame.size, 1, output);
if (encoded_frame_len == 0)
encoded_frame_len = out_frame.size;
}
}
fclose(output);
output = NULL;
/* Compare encoded files */
fref = fopen(ref_encoded_file, "rb");
if (!fref) {
rc = -100;
goto on_return;
}
output = fopen(TMP_OUT, "rb");
if (!output) {
rc = -110;
goto on_return;
}
pos = 0;
for (;;) {
int count;
count = fread(in_frame.buf, encoded_frame_len, 1, fref);
if (count != 1)
break;
count = fread(out_frame.buf, encoded_frame_len, 1, output);
if (count != 1)
break;
if (memcmp(in_frame.buf, out_frame.buf, encoded_frame_len)) {
unsigned i;
pj_uint8_t *in = (pj_uint8_t*)in_frame.buf;
pj_uint8_t *out = (pj_uint8_t*)out_frame.buf;
for (i=0; i<encoded_frame_len; ++i) {
if (in[i] != out[i])
break;
}
PJ_LOG(1,(THIS_FILE," failed: mismatch at pos %d", pos+i));
rc = -200;
break;
}
pos += encoded_frame_len;
}
on_return:
if (output)
fclose(output);
if (fref)
fclose(fref);
if (codec) {
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec(mgr, codec);
}
if (wav_port)
pjmedia_port_destroy(wav_port);
if (pool)
pj_pool_release(pool);
return rc;
}
static pj_status_t enc_dec_test(const char *codec_id,
const char *filein,
const char *fileout)
{
pj_pool_t *pool;
pjmedia_codec_mgr *cm;
pjmedia_codec *codec;
const pjmedia_codec_info *pci;
pjmedia_codec_param param;
unsigned cnt, samples_per_frame;
pj_str_t tmp;
pjmedia_port *wavin, *wavout;
unsigned lost_pct;
pj_status_t status;
#define T file_msec_duration/1000, file_msec_duration%1000
pool = pjmedia_endpt_create_pool(mept, "encdec", 1000, 1000);
cm = pjmedia_endpt_get_codec_mgr(mept);
#ifdef LOST_PCT
lost_pct = LOST_PCT;
#else
lost_pct = 0;
#endif
cnt = 1;
CHECK( pjmedia_codec_mgr_find_codecs_by_id(cm, pj_cstr(&tmp, codec_id),
&cnt, &pci, NULL) );
CHECK( pjmedia_codec_mgr_get_default_param(cm, pci, ¶m) );
samples_per_frame = param.info.clock_rate * param.info.frm_ptime / 1000;
/* Control VAD */
param.setting.vad = 1;
/* Open wav for reading */
CHECK( pjmedia_wav_player_port_create(pool, filein,
param.info.frm_ptime,
PJMEDIA_FILE_NO_LOOP, 0, &wavin) );
/* Open wav for writing */
CHECK( pjmedia_wav_writer_port_create(pool, fileout,
param.info.clock_rate,
param.info.channel_cnt,
samples_per_frame,
16, 0, 0, &wavout) );
/* Alloc codec */
CHECK( pjmedia_codec_mgr_alloc_codec(cm, pci, &codec) );
CHECK( codec->op->init(codec, pool) );
CHECK( codec->op->open(codec, ¶m) );
for (;;) {
pjmedia_frame frm_pcm, frm_bit, out_frm, frames[4];
pj_int16_t pcmbuf[320];
pj_timestamp ts;
pj_uint8_t bitstream[160];
frm_pcm.buf = (char*)pcmbuf;
frm_pcm.size = samples_per_frame * 2;
/* Read from WAV */
if (pjmedia_port_get_frame(wavin, &frm_pcm) != PJ_SUCCESS)
break;
if (frm_pcm.type != PJMEDIA_FRAME_TYPE_AUDIO)
break;;
/* Update duration */
file_msec_duration += samples_per_frame * 1000 /
param.info.clock_rate;
/* Encode */
frm_bit.buf = bitstream;
frm_bit.size = sizeof(bitstream);
CHECK(codec->op->encode(codec, &frm_pcm, sizeof(bitstream), &frm_bit));
/* On DTX, write zero frame to wavout to maintain duration */
if (frm_bit.size == 0 || frm_bit.type != PJMEDIA_FRAME_TYPE_AUDIO) {
out_frm.buf = (char*)pcmbuf;
out_frm.size = 160;
CHECK( pjmedia_port_put_frame(wavout, &out_frm) );
TRACE_((THIS_FILE, "%d.%03d read: %u, enc: %u",
T, frm_pcm.size, frm_bit.size));
continue;
}
/* Parse the bitstream (not really necessary for this case
* since we always decode 1 frame, but it's still good
* for testing)
*/
ts.u64 = 0;
cnt = PJ_ARRAY_SIZE(frames);
CHECK( codec->op->parse(codec, bitstream, frm_bit.size, &ts, &cnt,
frames) );
CHECK( (cnt==1 ? PJ_SUCCESS : -1) );
/* Decode or simulate packet loss */
out_frm.buf = (char*)pcmbuf;
out_frm.size = sizeof(pcmbuf);
if ((pj_rand() % 100) < (int)lost_pct) {
/* Simulate loss */
CHECK( codec->op->recover(codec, sizeof(pcmbuf), &out_frm) );
TRACE_((THIS_FILE, "%d.%03d Packet lost", T));
} else {
/* Decode */
CHECK( codec->op->decode(codec, &frames[0], sizeof(pcmbuf),
&out_frm) );
}
/* Write to WAV */
CHECK( pjmedia_port_put_frame(wavout, &out_frm) );
TRACE_((THIS_FILE, "%d.%03d read: %u, enc: %u, dec/write: %u",
T, frm_pcm.size, frm_bit.size, out_frm.size));
}
/* Close wavs */
pjmedia_port_destroy(wavout);
pjmedia_port_destroy(wavin);
/* Close codec */
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec(cm, codec);
/* Release pool */
pj_pool_release(pool);
return PJ_SUCCESS;
}
/*
* Decode test
*
* Decode the specified encoded file in "in_encoded_file" into temporary
* PCM output file, and compare the temporary PCM output file with
* the PCM reference file.
*
* Some reference file requires manipulation to the PCM output
* before comparison, such manipulation can be done by supplying
* this function with the "manip" function.
*/
static int codec_test_decode(pjmedia_codec_mgr *mgr,
char *codec_name,
unsigned bitrate,
unsigned encoded_len,
const char *in_encoded_file,
const char *ref_pcm_file,
void (*manip)(short *pcm, unsigned count))
{
pj_str_t codec_id = pj_str(codec_name);
pj_pool_t *pool = NULL;
unsigned count, samples_per_frame, pos;
pjmedia_codec *codec = NULL;
const pjmedia_codec_info *ci[1];
pjmedia_codec_param codec_param;
pjmedia_frame out_frame;
void *pkt;
FILE *input = NULL, *output = NULL, *fref = NULL;
pj_bool_t is_itu_format = PJ_FALSE;
int rc = 0;
pj_status_t status;
pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL);
if (!pool) {
rc = -20;
goto on_return;
}
/* Find and open the codec */
count = 1;
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL);
if (status != PJ_SUCCESS) {
rc = -30;
goto on_return;
}
status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec);
if (status != PJ_SUCCESS) {
rc = -40;
goto on_return;
}
status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param);
if (status != PJ_SUCCESS) {
rc = -50;
goto on_return;
}
codec_param.info.avg_bps = bitrate;
codec_param.setting.vad = 0;
status = codec->op->init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = codec->op->open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = -70;
goto on_return;
}
/* Open input file */
input = fopen(in_encoded_file, "rb");
if (!input) {
rc = -80;
goto on_return;
}
/* Is the file in ITU format? */
is_itu_format = pj_ansi_stricmp(in_encoded_file+strlen(in_encoded_file)-4,
".itu")==0;
/* Open output file */
output = fopen(TMP_OUT, "wb");
if (!output) {
rc = -90;
goto on_return;
}
/* Allocate buffer for PCM and encoded frames */
samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000;
pkt = pj_pool_alloc(pool, samples_per_frame * 2);
out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame * 2);
/* Loop read WAV file and encode and write to output file */
for (;;) {
pjmedia_frame in_frame[2];
pj_timestamp ts;
unsigned count;
pj_bool_t has_frame;
if (is_itu_format) {
int nsamp;
short frame_err = 0;
nsamp = read_ITU_format(input, (short*)pkt, &frame_err,
encoded_len / 2, PJ_TRUE);
if (nsamp != (int)encoded_len / 2)
break;
has_frame = !frame_err;
} else {
if (fread(pkt, encoded_len, 1, input) != 1)
break;
has_frame = PJ_TRUE;
}
if (has_frame) {
count = 2;
if (codec->op->parse(codec, pkt, encoded_len, &ts,
&count, in_frame) != PJ_SUCCESS)
{
rc = -100;
goto on_return;
}
if (count != 1) {
rc = -110;
goto on_return;
}
if (codec->op->decode(codec, &in_frame[0], samples_per_frame*2,
&out_frame) != PJ_SUCCESS)
{
rc = -120;
goto on_return;
}
} else {
if (codec->op->recover(codec, samples_per_frame*2,
&out_frame) != PJ_SUCCESS)
{
rc = -125;
goto on_return;
}
}
if (manip)
manip((short*)out_frame.buf, samples_per_frame);
if (fwrite(out_frame.buf, out_frame.size, 1, output) != 1) {
rc = -130;
goto on_return;
}
}
fclose(input);
input = NULL;
fclose(output);
output = NULL;
/* Compare encoded files */
fref = fopen(ref_pcm_file, "rb");
if (!fref) {
rc = -140;
goto on_return;
}
output = fopen(TMP_OUT, "rb");
if (!output) {
rc = -110;
goto on_return;
}
pos = 0;
for (;;) {
int count;
count = fread(pkt, samples_per_frame*2, 1, fref);
if (count != 1)
break;
count = fread(out_frame.buf, samples_per_frame*2, 1, output);
if (count != 1)
break;
if (memcmp(pkt, out_frame.buf, samples_per_frame*2)) {
unsigned i;
pj_int16_t *in = (pj_int16_t*)pkt;
pj_int16_t *out = (pj_int16_t*)out_frame.buf;
for (i=0; i<samples_per_frame; ++i) {
if (in[i] != out[i])
break;
}
PJ_LOG(1,(THIS_FILE," failed: mismatch at samples %d", pos+i));
rc = -200;
break;
}
pos += samples_per_frame;
}
on_return:
if (output)
fclose(output);
if (fref)
fclose(fref);
if (input)
fclose(input);
if (codec) {
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec(mgr, codec);
}
if (pool)
pj_pool_release(pool);
return rc;
}
