pjmedia_codec_opus_set_default_param(const pjmedia_codec_opus_config *cfg,
pjmedia_codec_param *param )
{
const pj_str_t opus_str = {"opus", 4};
const pjmedia_codec_info *info[1];
pjmedia_codec_mgr *codec_mgr;
unsigned count = 1;
pj_status_t status;
TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));
PJ_ASSERT_RETURN(cfg, PJ_EINVAL);
codec_mgr = pjmedia_endpt_get_codec_mgr(opus_codec_factory.endpt);
status = pjmedia_codec_mgr_find_codecs_by_id(codec_mgr, &opus_str,
&count, info, NULL);
if (status != PJ_SUCCESS)
return status;
/* Set sample rate */
if (cfg->sample_rate != 8000 && cfg->sample_rate != 12000 &&
cfg->sample_rate != 16000 && cfg->sample_rate != 24000 &&
cfg->sample_rate != 48000)
{
return PJ_EINVAL;
}
param->info.clock_rate = opus_cfg.sample_rate = cfg->sample_rate;
/* Set channel count */
if (cfg->channel_cnt != 1 && cfg->channel_cnt != 2)
return PJ_EINVAL;
param->info.channel_cnt = opus_cfg.channel_cnt = cfg->channel_cnt;
/* Set bit_rate */
if (cfg->bit_rate < 6000 || cfg->bit_rate > 510000) {
return PJ_EINVAL;
}
opus_cfg.bit_rate = cfg->bit_rate;
/* Set expected packet loss */
if (cfg->packet_loss >= 100)
return PJ_EINVAL;
opus_cfg.packet_loss = cfg->packet_loss;
/* Set complexity */
if (cfg->complexity > 10)
return PJ_EINVAL;
opus_cfg.complexity = cfg->complexity;
opus_cfg.cbr = cfg->cbr;
generate_fmtp(param);
status = pjmedia_codec_mgr_set_default_param(codec_mgr, info[0], param);
return status;
}
/*
* Internal function for collecting codec info and param from the SDP media.
*/
static pj_status_t get_audio_codec_info_param(pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_codec_mgr *mgr,
const pjmedia_sdp_media *local_m,
const pjmedia_sdp_media *rem_m)
{
const pjmedia_sdp_attr *attr;
pjmedia_sdp_rtpmap *rtpmap;
unsigned i, fmti, pt = 0;
pj_status_t status;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
pjmedia_sdp_rtpmap r;
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if (pt < 96) {
/* This is known static PT. Skip rtpmap checking because it is
* optional. */
break;
}
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
continue;
status = pjmedia_sdp_attr_get_rtpmap(attr, &r);
if (status != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) != 0)
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* Get payload type for receiving direction */
si->rx_pt = pt;
/* Get codec info.
* For static payload types, get the info from codec manager.
* For dynamic payload types, MUST get the rtpmap.
*/
if (pt < 96) {
pj_bool_t has_rtpmap;
rtpmap = NULL;
has_rtpmap = PJ_TRUE;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL) {
has_rtpmap = PJ_FALSE;
}
if (attr != NULL) {
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
has_rtpmap = PJ_FALSE;
}
/* Build codec format info: */
if (has_rtpmap) {
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
/* The session info should have the actual clock rate, because
* this info is used for calculationg buffer size, etc in stream
*/
if (si->fmt.pt == PJMEDIA_RTP_PT_G722)
si->fmt.clock_rate = 16000;
#endif
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
} else {
const pjmedia_codec_info *p_info;
status = pjmedia_codec_mgr_get_codec_info( mgr, pt, &p_info);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
}
/* For static payload type, pt's are symetric */
si->tx_pt = pt;
} else {
pjmedia_codec_id codec_id;
pj_str_t codec_id_st;
const pjmedia_codec_info *p_info;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
return PJMEDIA_EMISSINGRTPMAP;
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
return status;
/* Build codec format info: */
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
si->fmt.encoding_name = rtpmap->enc_name;
si->fmt.clock_rate = rtpmap->clock_rate;
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
/* Normalize the codec info from codec manager. Note that the
* payload type will be resetted to its default (it might have
* been rewritten by the SDP negotiator to match to the remote
* offer), this is intentional as currently some components may
* prefer (or even require) the default PT in codec info.
*/
pjmedia_codec_info_to_id(&si->fmt, codec_id, sizeof(codec_id));
i = 1;
codec_id_st = pj_str(codec_id);
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id_st,
&i, &p_info, NULL);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
/* Determine payload type for outgoing channel, by finding
* dynamic payload type in remote SDP that matches the answer.
*/
si->tx_pt = 0xFFFF;
for (i=0; i<rem_m->desc.fmt_count; ++i) {
if (pjmedia_sdp_neg_fmt_match(pool,
(pjmedia_sdp_media*)local_m, fmti,
(pjmedia_sdp_media*)rem_m, i, 0) ==
PJ_SUCCESS)
{
/* Found matched codec. */
si->tx_pt = pj_strtoul(&rem_m->desc.fmt[i]);
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
}
/* Now that we have codec info, get the codec param. */
si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt,
si->param);
/* Get remote fmtp for our encoder. */
pjmedia_stream_info_parse_fmtp(pool, rem_m, si->tx_pt,
&si->param->setting.enc_fmtp);
/* Get local fmtp for our decoder. */
pjmedia_stream_info_parse_fmtp(pool, local_m, si->rx_pt,
&si->param->setting.dec_fmtp);
if (!pj_stricmp2(&si->fmt.encoding_name, "opus")) {
get_opus_channels_and_clock_rate(&si->param->setting.enc_fmtp,
&si->param->setting.dec_fmtp,
&si->fmt.channel_cnt,
&si->fmt.clock_rate);
}
/* Get the remote ptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"ptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
unsigned frm_per_pkt;
pj_strltrim(&tmp_val);
/* Round up ptime when the specified is not multiple of frm_ptime */
frm_per_pkt = (pj_strtoul(&tmp_val) +
si->param->info.frm_ptime/2) /
si->param->info.frm_ptime;
if (frm_per_pkt != 0) {
si->param->setting.frm_per_pkt = (pj_uint8_t)frm_per_pkt;
}
}
/* Get remote maxptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"maxptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
pj_strltrim(&tmp_val);
si->tx_maxptime = pj_strtoul(&tmp_val);
}
/* When direction is NONE (it means SDP negotiation has failed) we don't
* need to return a failure here, as returning failure will cause
* the whole SDP to be rejected. See ticket #:
* http://
*
* Thanks Alain Totouom
*/
if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
return status;
/* Get incomming payload type for telephone-events */
si->rx_event_pt = -1;
for (i=0; i<local_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = local_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->rx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Get outgoing payload type for telephone-events */
si->tx_event_pt = -1;
for (i=0; i<rem_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = rem_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->tx_event_pt = pj_strtoul(&r.pt);
break;
}
}
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;
/* For G7221, the bitrate is set via param.setting.dec_fmtp, if it has
* no info about bitrate, the codec will check info.avg_bps. So, let's
* just clear the SDP fmtp.
*/
if (pj_ansi_strstr(codec_name, "G7221/")) {
codec_param.setting.dec_fmtp.cnt = 0;
}
status = pjmedia_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = pjmedia_codec_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 (pjmedia_codec_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 (pjmedia_codec_decode(codec, &in_frame[0], samples_per_frame*2,
&out_frame) != PJ_SUCCESS)
{
rc = -120;
goto on_return;
}
} else {
if (pjmedia_codec_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 (;;) {
pj_size_t 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) {
pjmedia_codec_close(codec);
pjmedia_codec_mgr_dealloc_codec(mgr, codec);
}
if (pool)
pj_pool_release(pool);
return rc;
}
static void pcap2wav(const pj_str_t *codec,
const pj_str_t *wav_filename,
pjmedia_aud_dev_index dev_id,
const pj_str_t *srtp_crypto,
const pj_str_t *srtp_key)
{
const pj_str_t WAV = {".wav", 4};
struct pkt
{
pj_uint8_t buffer[320];
pjmedia_rtp_hdr *rtp;
pj_uint8_t *payload;
unsigned payload_len;
} pkt0;
pjmedia_codec_mgr *cmgr;
const pjmedia_codec_info *ci;
pjmedia_codec_param param;
unsigned samples_per_frame;
pj_status_t status;
/* Initialize all codecs */
T( pjmedia_codec_register_audio_codecs(app.mept, NULL) );
/* Create SRTP transport is needed */
#if PJMEDIA_HAS_SRTP
if (srtp_crypto->slen) {
pjmedia_srtp_crypto crypto;
pj_bzero(&crypto, sizeof(crypto));
crypto.key = *srtp_key;
crypto.name = *srtp_crypto;
T( pjmedia_transport_srtp_create(app.mept, NULL, NULL, &app.srtp) );
T( pjmedia_transport_srtp_start(app.srtp, &crypto, &crypto) );
}
#else
PJ_UNUSED_ARG(srtp_crypto);
PJ_UNUSED_ARG(srtp_key);
#endif
/* Read first packet */
read_rtp(pkt0.buffer, sizeof(pkt0.buffer), &pkt0.rtp,
&pkt0.payload, &pkt0.payload_len, PJ_FALSE);
cmgr = pjmedia_endpt_get_codec_mgr(app.mept);
/* Get codec info and param for the specified payload type */
app.pt = pkt0.rtp->pt;
if (app.pt >=0 && app.pt < 96) {
T( pjmedia_codec_mgr_get_codec_info(cmgr, pkt0.rtp->pt, &ci) );
} else {
unsigned cnt = 2;
const pjmedia_codec_info *info[2];
T( pjmedia_codec_mgr_find_codecs_by_id(cmgr, codec, &cnt,
info, NULL) );
if (cnt != 1)
err_exit("Codec ID must be specified and unique!", 0);
ci = info[0];
}
T( pjmedia_codec_mgr_get_default_param(cmgr, ci, ¶m) );
/* Alloc and init codec */
T( pjmedia_codec_mgr_alloc_codec(cmgr, ci, &app.codec) );
T( pjmedia_codec_init(app.codec, app.pool) );
T( pjmedia_codec_open(app.codec, ¶m) );
/* Init audio device or WAV file */
samples_per_frame = ci->clock_rate * param.info.frm_ptime / 1000;
if (pj_strcmp2(wav_filename, "-") == 0) {
pjmedia_aud_param aud_param;
/* Open audio device */
T( pjmedia_aud_dev_default_param(dev_id, &aud_param) );
aud_param.dir = PJMEDIA_DIR_PLAYBACK;
aud_param.channel_count = ci->channel_cnt;
aud_param.clock_rate = ci->clock_rate;
aud_param.samples_per_frame = samples_per_frame;
T( pjmedia_aud_stream_create(&aud_param, NULL, &play_cb,
NULL, &app.aud_strm) );
T( pjmedia_aud_stream_start(app.aud_strm) );
} else if (pj_stristr(wav_filename, &WAV)) {
/* Open WAV file */
T( pjmedia_wav_writer_port_create(app.pool, wav_filename->ptr,
ci->clock_rate, ci->channel_cnt,
samples_per_frame,
param.info.pcm_bits_per_sample, 0, 0,
&app.wav) );
} else {
err_exit("invalid output file", PJ_EINVAL);
}
/* Loop reading PCAP and writing WAV file */
for (;;) {
struct pkt pkt1;
pj_timestamp ts;
pjmedia_frame frames[16], pcm_frame;
short pcm[320];
unsigned i, frame_cnt;
long samples_cnt, ts_gap;
pj_assert(sizeof(pcm) >= samples_per_frame);
/* Parse first packet */
ts.u64 = 0;
frame_cnt = PJ_ARRAY_SIZE(frames);
T( pjmedia_codec_parse(app.codec, pkt0.payload, pkt0.payload_len,
&ts, &frame_cnt, frames) );
/* Decode and write to WAV file */
samples_cnt = 0;
for (i=0; i<frame_cnt; ++i) {
pjmedia_frame pcm_frame;
pcm_frame.buf = pcm;
pcm_frame.size = samples_per_frame * 2;
T( pjmedia_codec_decode(app.codec, &frames[i],
(unsigned)pcm_frame.size, &pcm_frame) );
if (app.wav) {
T( pjmedia_port_put_frame(app.wav, &pcm_frame) );
}
if (app.aud_strm) {
T( wait_play(&pcm_frame) );
}
samples_cnt += samples_per_frame;
}
/* Read next packet */
read_rtp(pkt1.buffer, sizeof(pkt1.buffer), &pkt1.rtp,
&pkt1.payload, &pkt1.payload_len, PJ_TRUE);
/* Fill in the gap (if any) between pkt0 and pkt1 */
ts_gap = pj_ntohl(pkt1.rtp->ts) - pj_ntohl(pkt0.rtp->ts) -
samples_cnt;
while (ts_gap >= (long)samples_per_frame) {
pcm_frame.buf = pcm;
pcm_frame.size = samples_per_frame * 2;
if (app.codec->op->recover) {
T( pjmedia_codec_recover(app.codec, (unsigned)pcm_frame.size,
&pcm_frame) );
} else {
pj_bzero(pcm_frame.buf, pcm_frame.size);
}
if (app.wav) {
T( pjmedia_port_put_frame(app.wav, &pcm_frame) );
}
if (app.aud_strm) {
T( wait_play(&pcm_frame) );
}
ts_gap -= samples_per_frame;
}
/* Next */
pkt0 = pkt1;
pkt0.rtp = (pjmedia_rtp_hdr*)pkt0.buffer;
pkt0.payload = pkt0.buffer + (pkt1.payload - pkt1.buffer);
}
}
/*
* 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;
pj_size_t 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;
/* For G7221, the bitrate is set via param.setting.dec_fmtp, if it has
* no info about bitrate, the codec will check info.avg_bps. So, let's
* just clear the SDP fmtp.
*/
if (pj_ansi_strstr(codec_name, "G7221/")) {
codec_param.setting.dec_fmtp.cnt = 0;
}
status = pjmedia_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = pjmedia_codec_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 = pjmedia_codec_encode(codec, &in_frame, samples_per_frame,
&out_frame);
if (status != PJ_SUCCESS) {
rc = -95;
goto on_return;
}
if (out_frame.size) {
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 (;;) {
pj_size_t 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) {
pjmedia_codec_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;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pjmedia_port *rec_file_port = NULL, *play_file_port = NULL;
pjmedia_master_port *master_port = NULL;
pjmedia_snd_port *snd_port = NULL;
pjmedia_stream *stream = NULL;
pjmedia_port *stream_port;
char tmp[10];
pj_status_t status;
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
/* SRTP variables */
pj_bool_t use_srtp = PJ_FALSE;
char tmp_tx_key[64];
char tmp_rx_key[64];
pj_str_t srtp_tx_key = {NULL, 0};
pj_str_t srtp_rx_key = {NULL, 0};
pj_str_t srtp_crypto_suite = {NULL, 0};
int tmp_key_len;
#endif
/* Default values */
const pjmedia_codec_info *codec_info;
pjmedia_codec_param codec_param;
pjmedia_dir dir = PJMEDIA_DIR_DECODING;
pj_sockaddr_in remote_addr;
pj_uint16_t local_port = 4000;
char *codec_id = NULL;
char *rec_file = NULL;
char *play_file = NULL;
enum {
OPT_CODEC = 'c',
OPT_LOCAL_PORT = 'p',
OPT_REMOTE = 'r',
OPT_PLAY_FILE = 'w',
OPT_RECORD_FILE = 'R',
OPT_SEND_RECV = 'b',
OPT_SEND_ONLY = 's',
OPT_RECV_ONLY = 'i',
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
OPT_USE_SRTP = 'S',
#endif
OPT_SRTP_TX_KEY = 'x',
OPT_SRTP_RX_KEY = 'y',
OPT_HELP = 'h',
};
struct pj_getopt_option long_options[] = {
{ "codec", 1, 0, OPT_CODEC },
{ "local-port", 1, 0, OPT_LOCAL_PORT },
{ "remote", 1, 0, OPT_REMOTE },
{ "play-file", 1, 0, OPT_PLAY_FILE },
{ "record-file", 1, 0, OPT_RECORD_FILE },
{ "send-recv", 0, 0, OPT_SEND_RECV },
{ "send-only", 0, 0, OPT_SEND_ONLY },
{ "recv-only", 0, 0, OPT_RECV_ONLY },
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
{ "use-srtp", 2, 0, OPT_USE_SRTP },
{ "srtp-tx-key", 1, 0, OPT_SRTP_TX_KEY },
{ "srtp-rx-key", 1, 0, OPT_SRTP_RX_KEY },
#endif
{ "help", 0, 0, OPT_HELP },
{ NULL, 0, 0, 0 },
};
int c;
int option_index;
pj_bzero(&remote_addr, sizeof(remote_addr));
/* init PJLIB : */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Parse arguments */
pj_optind = 0;
while((c=pj_getopt_long(argc,argv, "h", long_options, &option_index))!=-1) {
switch (c) {
case OPT_CODEC:
codec_id = pj_optarg;
break;
case OPT_LOCAL_PORT:
local_port = (pj_uint16_t) atoi(pj_optarg);
if (local_port < 1) {
printf("Error: invalid local port %s\n", pj_optarg);
return 1;
}
break;
case OPT_REMOTE:
{
pj_str_t ip = pj_str(strtok(pj_optarg, ":"));
pj_uint16_t port = (pj_uint16_t) atoi(strtok(NULL, ":"));
status = pj_sockaddr_in_init(&remote_addr, &ip, port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Invalid remote address", status);
return 1;
}
}
break;
case OPT_PLAY_FILE:
play_file = pj_optarg;
break;
case OPT_RECORD_FILE:
rec_file = pj_optarg;
break;
case OPT_SEND_RECV:
dir = PJMEDIA_DIR_ENCODING_DECODING;
break;
case OPT_SEND_ONLY:
dir = PJMEDIA_DIR_ENCODING;
break;
case OPT_RECV_ONLY:
dir = PJMEDIA_DIR_DECODING;
break;
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
case OPT_USE_SRTP:
use_srtp = PJ_TRUE;
if (pj_optarg) {
pj_strset(&srtp_crypto_suite, pj_optarg, strlen(pj_optarg));
} else {
srtp_crypto_suite = pj_str("AES_CM_128_HMAC_SHA1_80");
}
break;
case OPT_SRTP_TX_KEY:
tmp_key_len = hex_string_to_octet_string(tmp_tx_key, pj_optarg,
(int)strlen(pj_optarg));
pj_strset(&srtp_tx_key, tmp_tx_key, tmp_key_len/2);
break;
case OPT_SRTP_RX_KEY:
tmp_key_len = hex_string_to_octet_string(tmp_rx_key, pj_optarg,
(int)strlen(pj_optarg));
pj_strset(&srtp_rx_key, tmp_rx_key, tmp_key_len/2);
break;
#endif
case OPT_HELP:
usage();
return 1;
default:
printf("Invalid options %s\n", argv[pj_optind]);
return 1;
}
}
/* Verify arguments. */
if (dir & PJMEDIA_DIR_ENCODING) {
if (remote_addr.sin_addr.s_addr == 0) {
printf("Error: remote address must be set\n");
return 1;
}
}
if (play_file != NULL && dir != PJMEDIA_DIR_ENCODING) {
printf("Direction is set to --send-only because of --play-file\n");
dir = PJMEDIA_DIR_ENCODING;
}
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
/* SRTP validation */
if (use_srtp) {
if (!srtp_tx_key.slen || !srtp_rx_key.slen)
{
printf("Error: Key for each SRTP stream direction must be set\n");
return 1;
}
}
#endif
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for application purpose */
pool = pj_pool_create( &cp.factory, /* pool factory */
"app", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Register all supported codecs */
status = init_codecs(med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Find which codec to use. */
if (codec_id) {
unsigned count = 1;
pj_str_t str_codec_id = pj_str(codec_id);
pjmedia_codec_mgr *codec_mgr = pjmedia_endpt_get_codec_mgr(med_endpt);
status = pjmedia_codec_mgr_find_codecs_by_id( codec_mgr,
&str_codec_id, &count,
&codec_info, NULL);
if (status != PJ_SUCCESS) {
printf("Error: unable to find codec %s\n", codec_id);
return 1;
}
} else {
/* Default to pcmu */
pjmedia_codec_mgr_get_codec_info( pjmedia_endpt_get_codec_mgr(med_endpt),
0, &codec_info);
}
/* Create stream based on program arguments */
status = create_stream(pool, med_endpt, codec_info, dir, local_port,
&remote_addr,
#if defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
use_srtp, &srtp_crypto_suite,
&srtp_tx_key, &srtp_rx_key,
#endif
&stream);
if (status != PJ_SUCCESS)
goto on_exit;
/* Get codec default param for info */
status = pjmedia_codec_mgr_get_default_param(
pjmedia_endpt_get_codec_mgr(med_endpt),
codec_info,
&codec_param);
/* Should be ok, as create_stream() above succeeded */
pj_assert(status == PJ_SUCCESS);
/* Get the port interface of the stream */
status = pjmedia_stream_get_port( stream, &stream_port);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
if (play_file) {
unsigned wav_ptime;
wav_ptime = PJMEDIA_PIA_PTIME(&stream_port->info);
status = pjmedia_wav_player_port_create(pool, play_file, wav_ptime,
0, -1, &play_file_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to use file", status);
goto on_exit;
}
status = pjmedia_master_port_create(pool, play_file_port, stream_port,
0, &master_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create master port", status);
goto on_exit;
}
status = pjmedia_master_port_start(master_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error starting master port", status);
goto on_exit;
}
printf("Playing from WAV file %s..\n", play_file);
} else if (rec_file) {
status = pjmedia_wav_writer_port_create(pool, rec_file,
PJMEDIA_PIA_SRATE(&stream_port->info),
PJMEDIA_PIA_CCNT(&stream_port->info),
PJMEDIA_PIA_SPF(&stream_port->info),
PJMEDIA_PIA_BITS(&stream_port->info),
0, 0, &rec_file_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to use file", status);
goto on_exit;
}
status = pjmedia_master_port_create(pool, stream_port, rec_file_port,
0, &master_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create master port", status);
goto on_exit;
}
status = pjmedia_master_port_start(master_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error starting master port", status);
goto on_exit;
}
printf("Recording to WAV file %s..\n", rec_file);
} else {
/* Create sound device port. */
if (dir == PJMEDIA_DIR_ENCODING_DECODING)
status = pjmedia_snd_port_create(pool, -1, -1,
PJMEDIA_PIA_SRATE(&stream_port->info),
PJMEDIA_PIA_CCNT(&stream_port->info),
PJMEDIA_PIA_SPF(&stream_port->info),
PJMEDIA_PIA_BITS(&stream_port->info),
0, &snd_port);
else if (dir == PJMEDIA_DIR_ENCODING)
status = pjmedia_snd_port_create_rec(pool, -1,
PJMEDIA_PIA_SRATE(&stream_port->info),
PJMEDIA_PIA_CCNT(&stream_port->info),
PJMEDIA_PIA_SPF(&stream_port->info),
PJMEDIA_PIA_BITS(&stream_port->info),
0, &snd_port);
else
status = pjmedia_snd_port_create_player(pool, -1,
PJMEDIA_PIA_SRATE(&stream_port->info),
PJMEDIA_PIA_CCNT(&stream_port->info),
PJMEDIA_PIA_SPF(&stream_port->info),
PJMEDIA_PIA_BITS(&stream_port->info),
0, &snd_port);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create sound port", status);
goto on_exit;
}
/* Connect sound port to stream */
status = pjmedia_snd_port_connect( snd_port, stream_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* Start streaming */
pjmedia_stream_start(stream);
/* Done */
if (dir == PJMEDIA_DIR_DECODING)
printf("Stream is active, dir is recv-only, local port is %d\n",
local_port);
else if (dir == PJMEDIA_DIR_ENCODING)
printf("Stream is active, dir is send-only, sending to %s:%d\n",
pj_inet_ntoa(remote_addr.sin_addr),
pj_ntohs(remote_addr.sin_port));
else
printf("Stream is active, send/recv, local port is %d, "
"sending to %s:%d\n",
local_port,
pj_inet_ntoa(remote_addr.sin_addr),
pj_ntohs(remote_addr.sin_port));
for (;;) {
puts("");
puts("Commands:");
puts(" s Display media statistics");
puts(" q Quit");
puts("");
printf("Command: "); fflush(stdout);
if (fgets(tmp, sizeof(tmp), stdin) == NULL) {
puts("EOF while reading stdin, will quit now..");
break;
}
if (tmp[0] == 's')
print_stream_stat(stream, &codec_param);
else if (tmp[0] == 'q')
break;
}
/* Start deinitialization: */
on_exit:
/* Destroy sound device */
if (snd_port) {
pjmedia_snd_port_destroy( snd_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* If there is master port, then we just need to destroy master port
* (it will recursively destroy upstream and downstream ports, which
* in this case are file_port and stream_port).
*/
if (master_port) {
pjmedia_master_port_destroy(master_port, PJ_TRUE);
play_file_port = NULL;
stream = NULL;
}
/* Destroy stream */
if (stream) {
pjmedia_transport *tp;
tp = pjmedia_stream_get_transport(stream);
pjmedia_stream_destroy(stream);
pjmedia_transport_close(tp);
}
/* Destroy file ports */
if (play_file_port)
pjmedia_port_destroy( play_file_port );
if (rec_file_port)
pjmedia_port_destroy( rec_file_port );
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
return (status == PJ_SUCCESS) ? 0 : 1;
}
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;
}
JNIEXPORT jint JNICALL Java_org_sipdroid_pjlib_codec_open
(JNIEnv *env, jclass cls, jstring codec_id) {
int rc = 0;
unsigned count = 1;
LOGE("Intializing PJLIB...");
pj_init();
pj_caching_pool_init(&caching_pool, &pj_pool_factory_default_policy, 0);
pj_log_set_decor(PJ_LOG_HAS_NEWLINE);
pj_log_set_level(3);
mem = &caching_pool.factory;
char* ctmp;
jboolean iscopy;
const char *codec_str = env->GetStringUTFChars(codec_id, &iscopy);
ctmp = const_cast<char*>(codec_str);
const pj_str_t pj_codec_str = pj_str(ctmp);
unsigned clock_rate = 8000;
LOGE("pj_pool_create");
pool = pj_pool_create(mem, "pool", 1024, 1024, NULL);
LOGE("PJ_POOL_ZALLOC_T");
cp = PJ_POOL_ZALLOC_T(pool, struct codec_port);
LOGE("pjmedia_endpt_create");
status = pjmedia_endpt_create(mem, NULL, 0, &cp->endpt);
if (status != PJ_SUCCESS)
return NULL;
cm = pjmedia_endpt_get_codec_mgr(cp->endpt);
#if PJMEDIA_HAS_G711_CODEC
CHECK( pjmedia_codec_g711_init(cp->endpt) );
#endif
#if PJMEDIA_HAS_GSM_CODEC
CHECK( pjmedia_codec_gsm_init(cp->endpt) );
#endif
#if PJMEDIA_HAS_ILBC_CODEC
CHECK( pjmedia_codec_ilbc_init(cp->endpt, 30) );
#endif
#if PJMEDIA_HAS_SPEEX_CODEC
CHECK( pjmedia_codec_speex_init(cp->endpt, 0, 5, 5) );
#endif
#if PJMEDIA_HAS_G722_CODEC
CHECK( pjmedia_codec_g722_init(cp->endpt) );
#endif
LOGE("pjmedia_codec_mgr_find_codecs_by_id: %s", codec_str);
CHECK( status = pjmedia_codec_mgr_find_codecs_by_id(cm,
&pj_codec_str, &count, &ci, NULL) );
if (status != PJ_SUCCESS) {
LOGE("Cannot find codec");
return NULL;
}
LOGE("pjmedia_codec_mgr_get_default_param");
CHECK( status = pjmedia_codec_mgr_get_default_param(cm, ci, ¶m) );
if (status != PJ_SUCCESS) {
LOGE("pjmedia_codec_mgr_get_default_param failed");
return NULL;
}
//param.setting.vad = 1;
LOGE("pjmedia_codec_mgr_alloc_codec");
CHECK( status = pjmedia_codec_mgr_alloc_codec(cm, ci, &cp->codec) );
if (status != PJ_SUCCESS) {
LOGE("Cannot allocate codec");
return NULL;
}
LOGE("codec->op->init"); // channels=%d frm_ptime=%s", ci->channel_cnt, param.info.frm_ptime);
status = (*cp->codec->op->init)(cp->codec, pool);
if (status != PJ_SUCCESS)
return NULL;
LOGE("codec->op->open");
status = cp->codec->op->open(cp->codec, ¶m);
if (status != PJ_SUCCESS)
return NULL;
samples_per_frame = param.info.clock_rate * param.info.frm_ptime / 1000;
LOGE("Finished initializing codec...");
LOGE(" -> clock_rate=%d channel_count=%d samples_per_frame=%d pcm_bits_per_sample=%d", param.info.clock_rate, param.info.channel_cnt, \
samples_per_frame, param.info.pcm_bits_per_sample);
return (jint)PJ_SUCCESS;
}
static pj_status_t stream_init(const struct stream_cfg *cfg, struct stream **p_stream)
{
pj_pool_t *pool = NULL;
struct stream *stream = NULL;
pjmedia_codec_mgr *cm;
unsigned count;
const pjmedia_codec_info *ci;
pjmedia_stream_info si;
pj_status_t status;
/* Create instance */
pool = pj_pool_create(&g_app.cp.factory, cfg->name, 512, 512, NULL);
stream = PJ_POOL_ZALLOC_T(pool, struct stream);
stream->pool = pool;
/* Create stream info */
pj_bzero(&si, sizeof(si));
si.type = PJMEDIA_TYPE_AUDIO;
si.proto = PJMEDIA_TP_PROTO_RTP_AVP;
si.dir = cfg->dir;
pj_sockaddr_in_init(&si.rem_addr.ipv4, NULL, 4000); /* dummy */
pj_sockaddr_in_init(&si.rem_rtcp.ipv4, NULL, 4001); /* dummy */
/* Apply JB settings if this is RX direction */
if (cfg->dir == PJMEDIA_DIR_DECODING) {
si.jb_init = g_app.cfg.rx_jb_init;
si.jb_min_pre = g_app.cfg.rx_jb_min_pre;
si.jb_max_pre = g_app.cfg.rx_jb_max_pre;
si.jb_max = g_app.cfg.rx_jb_max;
}
/* Get the codec info and param */
cm = pjmedia_endpt_get_codec_mgr(g_app.endpt);
count = 1;
status = pjmedia_codec_mgr_find_codecs_by_id(cm, &cfg->codec, &count, &ci, NULL);
if (status != PJ_SUCCESS) {
jbsim_perror("Unable to find codec", status);
goto on_error;
}
pj_memcpy(&si.fmt, ci, sizeof(*ci));
si.param = PJ_POOL_ALLOC_T(pool, struct pjmedia_codec_param);
status = pjmedia_codec_mgr_get_default_param(cm, &si.fmt, si.param);
if (status != PJ_SUCCESS) {
jbsim_perror("Unable to get codec defaults", status);
goto on_error;
}
si.tx_pt = si.fmt.pt;
/* Apply ptime setting */
if (cfg->ptime) {
si.param->setting.frm_per_pkt = (pj_uint8_t)
((cfg->ptime + si.param->info.frm_ptime - 1) /
si.param->info.frm_ptime);
}
/* Apply DTX setting */
si.param->setting.vad = cfg->dtx;
/* Apply PLC setting */
si.param->setting.plc = cfg->plc;
/* Create stream */
status = pjmedia_stream_create(g_app.endpt, pool, &si, g_app.loop, NULL, &stream->strm);
if (status != PJ_SUCCESS) {
jbsim_perror("Error creating stream", status);
goto on_error;
}
status = pjmedia_stream_get_port(stream->strm, &stream->port);
if (status != PJ_SUCCESS) {
jbsim_perror("Error retrieving stream", status);
goto on_error;
}
/* Start stream */
status = pjmedia_stream_start(stream->strm);
if (status != PJ_SUCCESS) {
jbsim_perror("Error starting stream", status);
goto on_error;
}
/* Done */
*p_stream = stream;
return PJ_SUCCESS;
on_error:
if (stream) {
stream_destroy(stream);
} else {
if (pool)
pj_pool_release(pool);
}
return status;
}
