/*
* Unregister G722 codec factory from pjmedia endpoint and deinitialize
* the G722 codec library.
*/
PJ_DEF(pj_status_t) pjmedia_codec_g722_deinit(void)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (g722_codec_factory.pool == NULL)
return PJ_SUCCESS;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(g722_codec_factory.endpt);
if (!codec_mgr) {
pj_pool_release(g722_codec_factory.pool);
g722_codec_factory.pool = NULL;
return PJ_EINVALIDOP;
}
/* Unregister G722 codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&g722_codec_factory.base);
/* Destroy mutex. */
pj_mutex_destroy(g722_codec_factory.mutex);
/* Destroy pool. */
pj_pool_release(g722_codec_factory.pool);
g722_codec_factory.pool = NULL;
TRACE_((THIS_FILE, "G722 codec factory shutdown"));
return status;
}
*/ PJ_DEF(pj_status_t) pjmedia_codec_opus_deinit(void) {
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (opus_factory.endpt == NULL) {
/* Not registered. */
return PJ_SUCCESS;
}
/* Lock mutex. */
pj_mutex_lock(opus_factory.mutex);
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(opus_factory.endpt);
if (!codec_mgr) {
opus_factory.endpt = NULL;
pj_mutex_unlock(opus_factory.mutex);
return PJ_EINVALIDOP;
}
/* Unregister opus codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr, &opus_factory.base);
opus_factory.endpt = NULL;
/* Destroy mutex. */
pj_mutex_destroy(opus_factory.mutex);
opus_factory.mutex = NULL;
/* Release pool. */
pj_pool_release(opus_factory.pool);
opus_factory.pool = NULL;
return status;
}
static void cleanup()
{
if (app.srtp) pjmedia_transport_close(app.srtp);
if (app.wav) {
pj_ssize_t pos = pjmedia_wav_writer_port_get_pos(app.wav);
if (pos >= 0) {
unsigned msec;
msec = (unsigned)pos / 2 * 1000 / PJMEDIA_PIA_SRATE(&app.wav->info);
printf("Written: %dm:%02ds.%03d\n",
msec / 1000 / 60,
(msec / 1000) % 60,
msec % 1000);
}
pjmedia_port_destroy(app.wav);
}
if (app.pcap) pj_pcap_close(app.pcap);
if (app.codec) {
pjmedia_codec_mgr *cmgr;
pjmedia_codec_close(app.codec);
cmgr = pjmedia_endpt_get_codec_mgr(app.mept);
pjmedia_codec_mgr_dealloc_codec(cmgr, app.codec);
}
if (app.aud_strm) {
pjmedia_aud_stream_stop(app.aud_strm);
pjmedia_aud_stream_destroy(app.aud_strm);
}
if (app.mept) pjmedia_endpt_destroy(app.mept);
if (app.pool) pj_pool_release(app.pool);
pj_caching_pool_destroy(&app.cp);
pj_shutdown();
}
/*
* Unregister AMR codec factory from pjmedia endpoint and deinitialize
* the AMR codec library.
*/
PJ_DEF(pj_status_t) pjmedia_codec_opencore_amr_deinit(void)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
amr_codec_factory.init[IDX_AMR_NB] = PJ_FALSE;
amr_codec_factory.init[IDX_AMR_WB] = PJ_FALSE;
if (amr_codec_factory.pool == NULL)
return PJ_SUCCESS;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(amr_codec_factory.endpt);
if (!codec_mgr) {
pj_pool_release(amr_codec_factory.pool);
amr_codec_factory.pool = NULL;
return PJ_EINVALIDOP;
}
/* Unregister AMR codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&amr_codec_factory.base);
/* Destroy pool. */
pj_pool_release(amr_codec_factory.pool);
amr_codec_factory.pool = NULL;
return status;
}
/*
* Unregister Opus codec factory from pjmedia endpoint and
* deinitialize the codec.
*/
PJ_DEF(pj_status_t) pjmedia_codec_opus_deinit( void )
{
pj_status_t status;
pjmedia_codec_mgr *codec_mgr;
if (opus_codec_factory.pool == NULL)
return PJ_SUCCESS;
/* Get the codec manager */
codec_mgr = pjmedia_endpt_get_codec_mgr(opus_codec_factory.endpt);
if (!codec_mgr) {
PJ_LOG(2, (THIS_FILE, "Unable to get the codec manager"));
pj_pool_release(opus_codec_factory.pool);
opus_codec_factory.pool = NULL;
return PJ_EINVALIDOP;
}
/* Unregister the codec factory */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&opus_codec_factory.base);
if (status != PJ_SUCCESS)
PJ_LOG(2, (THIS_FILE, "Unable to unregister the codec factory"));
/* Release the memory pool */
pj_pool_release(opus_codec_factory.pool);
opus_codec_factory.pool = NULL;
return status;
}
/*
* Unregister CODEC2 codec factory from pjmedia endpoint and deinitialize
* the CODEC2 codec library.
*/
PJ_DEF(pj_status_t) pjmedia_codec_codec2_deinit(void)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (codec2_codec_factory.pool == NULL)
return PJ_SUCCESS;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(codec2_codec_factory.endpt);
if (!codec_mgr) {
pj_pool_release(codec2_codec_factory.pool);
codec2_codec_factory.pool = NULL;
return PJ_EINVALIDOP;
}
/* Unregister GSM codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&codec2_codec_factory.base);
/* Destroy mutex. */
pj_mutex_destroy(codec2_codec_factory.mutex);
/* Destroy pool. */
pj_pool_release(codec2_codec_factory.pool);
codec2_codec_factory.pool = NULL;
return status;
}
/*
* Initialize and register AMR codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_opencore_amr_init( pjmedia_endpt *endpt,
unsigned options)
{
pjmedia_codec_mgr *codec_mgr;
pj_str_t codec_name;
pj_status_t status;
if (amr_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create AMR codec factory. */
amr_codec_factory.base.op = &amr_factory_op;
amr_codec_factory.base.factory_data = NULL;
amr_codec_factory.endpt = endpt;
#ifdef USE_AMRNB
amr_codec_factory.init[IDX_AMR_NB] = ((options & PJMEDIA_AMR_NO_NB) == 0);
#else
amr_codec_factory.init[IDX_AMR_NB] = PJ_FALSE;
#endif
#ifdef USE_AMRWB
amr_codec_factory.init[IDX_AMR_WB] = ((options & PJMEDIA_AMR_NO_WB) == 0);
#else
amr_codec_factory.init[IDX_AMR_WB] = PJ_FALSE;
#endif
amr_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "amr", 1000,
1000);
if (!amr_codec_factory.pool)
return PJ_ENOMEM;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register format match callback. */
pj_cstr(&codec_name, "AMR");
status = pjmedia_sdp_neg_register_fmt_match_cb(
&codec_name,
&pjmedia_codec_amr_match_sdp);
if (status != PJ_SUCCESS)
goto on_error;
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&amr_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(amr_codec_factory.pool);
amr_codec_factory.pool = NULL;
return status;
}
PJ_DEF(pj_status_t) pjmedia_codec_l16_init(pjmedia_endpt *endpt,
unsigned options)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
PJ_UNUSED_ARG(options);
if (l16_factory.endpt != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Init factory */
l16_factory.base.op = &l16_factory_op;
l16_factory.base.factory_data = NULL;
l16_factory.endpt = endpt;
/* Create pool */
l16_factory.pool = pjmedia_endpt_create_pool(endpt, "l16", 4000, 4000);
if (!l16_factory.pool)
return PJ_ENOMEM;
/* Create mutex. */
status = pj_mutex_create_simple(l16_factory.pool, "l16",
&l16_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
return PJ_EINVALIDOP;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&l16_factory.base);
if (status != PJ_SUCCESS)
return status;
return PJ_SUCCESS;
on_error:
if (l16_factory.mutex) {
pj_mutex_destroy(l16_factory.mutex);
l16_factory.mutex = NULL;
}
if (l16_factory.pool) {
pj_pool_release(l16_factory.pool);
l16_factory.pool = NULL;
}
return status;
}
PJ_DEF(pj_status_t) pjmedia_codec_opus_init(pjmedia_endpt *endpt) {
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (opus_factory.endpt != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Init factory */
opus_factory.base.op = &opus_factory_op;
opus_factory.base.factory_data = NULL;
opus_factory.endpt = endpt;
if (opus_factory.internal_clock_rate == 0) {
opus_factory.internal_clock_rate = 48000;
}
/* Create pool */
opus_factory.pool =
pjmedia_endpt_create_pool(endpt, "opus codecs", 4000, 4000);
if (!opus_factory.pool) return PJ_ENOMEM;
/* Init list */
pj_list_init(&opus_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(opus_factory.pool, "opus codecs",
&opus_factory.mutex);
if (status != PJ_SUCCESS) goto on_error;
PJ_LOG(5, (THIS_FILE, "Init opus"));
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
return PJ_EINVALIDOP;
}
PJ_LOG(5, (THIS_FILE, "Init opus > DONE"));
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr, &opus_factory.base);
if (status != PJ_SUCCESS) return status;
return PJ_SUCCESS;
on_error:
if (opus_factory.mutex) {
pj_mutex_destroy(opus_factory.mutex);
opus_factory.mutex = NULL;
}
if (opus_factory.pool) {
pj_pool_release(opus_factory.pool);
opus_factory.pool = NULL;
}
return status;
}
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;
}
PJ_DEF(pj_status_t) pjmedia_codec_g711_init(pjmedia_endpt *endpt)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (g711_factory.endpt != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Init factory */
g711_factory.base.op = &g711_factory_op;
g711_factory.base.factory_data = NULL;
g711_factory.endpt = endpt;
pj_list_init(&g711_factory.codec_list);
/* Create pool */
g711_factory.pool = pjmedia_endpt_create_pool(endpt, "g711", 4000, 4000);
if (!g711_factory.pool)
return PJ_ENOMEM;
/* Create mutex. */
status = pj_mutex_create_simple(g711_factory.pool, "g611",
&g711_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
return PJ_EINVALIDOP;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&g711_factory.base);
if (status != PJ_SUCCESS)
return status;
return PJ_SUCCESS;
on_error:
if (g711_factory.mutex) {
pj_mutex_destroy(g711_factory.mutex);
g711_factory.mutex = NULL;
}
if (g711_factory.pool) {
pj_pool_release(g711_factory.pool);
g711_factory.pool = NULL;
}
return status;
}
/*
* Initialize and register G722 codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_g722_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (g722_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create G722 codec factory. */
g722_codec_factory.base.op = &g722_factory_op;
g722_codec_factory.base.factory_data = NULL;
g722_codec_factory.endpt = endpt;
g722_codec_factory.pcm_shift = PJMEDIA_G722_DEFAULT_PCM_SHIFT;
g722_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "g722", 1000,
1000);
if (!g722_codec_factory.pool)
return PJ_ENOMEM;
pj_list_init(&g722_codec_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(g722_codec_factory.pool, "g722",
&g722_codec_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&g722_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
TRACE_((THIS_FILE, "G722 codec factory initialized"));
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(g722_codec_factory.pool);
g722_codec_factory.pool = NULL;
return status;
}
/*
* Initialize and register GSM codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_gsm_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (gsm_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create GSM codec factory. */
gsm_codec_factory.base.op = &gsm_factory_op;
gsm_codec_factory.base.factory_data = NULL;
gsm_codec_factory.endpt = endpt;
gsm_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "gsm", 4000,
4000);
if (!gsm_codec_factory.pool)
return PJ_ENOMEM;
pj_list_init(&gsm_codec_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(gsm_codec_factory.pool, "gsm",
&gsm_codec_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&gsm_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(gsm_codec_factory.pool);
gsm_codec_factory.pool = NULL;
return status;
}
/*
* Unregister iLBC codec factory from pjmedia endpoint and deinitialize
* the iLBC codec library.
*/
PJ_DEF(pj_status_t) pjmedia_codec_ilbc_deinit(void)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(ilbc_factory.endpt);
if (!codec_mgr)
return PJ_EINVALIDOP;
/* Unregister iLBC codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&ilbc_factory.base);
return status;
}
/*
* Initialize and register AMR-NB codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_opencore_amrnb_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
pj_str_t codec_name;
if (amr_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create AMR-NB codec factory. */
amr_codec_factory.base.op = &amr_factory_op;
amr_codec_factory.base.factory_data = NULL;
amr_codec_factory.endpt = endpt;
amr_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "amrnb", 1000,
1000);
if (!amr_codec_factory.pool)
return PJ_ENOMEM;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register format match callback. */
pj_cstr(&codec_name, "AMR");
status = pjmedia_sdp_neg_register_fmt_match_cb( &codec_name,
&pjmedia_codec_amr_match_sdp);
if (status != PJ_SUCCESS){
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&amr_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(amr_codec_factory.pool);
amr_codec_factory.pool = NULL;
return status;
}
void list_codecs(pjmedia_endpt *ep) {
unsigned int count = 100;
int i;
char buffer[100];
pjmedia_codec_mgr *mgr = 0;
pjmedia_codec_info codec[20];
mgr = pjmedia_endpt_get_codec_mgr(ep);
pjmedia_codec_mgr_enum_codecs(mgr, &count, codec, NULL);
PJ_LOG(3, (__FILE__, "THERE ARE %d codecs", count));
for ( i = 0; i < count; i++ ) {
pj_bzero(buffer, sizeof(buffer));
pjmedia_codec_info_to_id(&codec[i], buffer, sizeof(buffer));
PJ_LOG(3, (__FILE__, "Codec : %s", buffer));
}
}
/*
* Initialize and register Opus codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_opus_init( pjmedia_endpt *endpt )
{
pj_status_t status;
pjmedia_codec_mgr *codec_mgr;
PJ_ASSERT_RETURN(endpt, PJ_EINVAL);
if (opus_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create the Opus codec factory */
opus_codec_factory.base.op = &opus_factory_op;
opus_codec_factory.base.factory_data = &opus_codec_factory;
opus_codec_factory.endpt = endpt;
opus_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "opus-factory",
1024, 1024);
if (!opus_codec_factory.pool) {
PJ_LOG(2, (THIS_FILE, "Unable to create memory pool for Opus codec"));
return PJ_ENOMEM;
}
/* Get the codec manager */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
PJ_LOG(2, (THIS_FILE, "Unable to get the codec manager"));
status = PJ_EINVALIDOP;
goto on_codec_factory_error;
}
/* Register the codec factory */
status = pjmedia_codec_mgr_register_factory (codec_mgr,
&opus_codec_factory.base);
if (status != PJ_SUCCESS) {
PJ_LOG(2, (THIS_FILE, "Unable to register the codec factory"));
goto on_codec_factory_error;
}
return PJ_SUCCESS;
on_codec_factory_error:
pj_pool_release(opus_codec_factory.pool);
opus_codec_factory.pool = NULL;
return status;
}
/*
* Unregister Speex codec factory from pjmedia endpoint and deinitialize
* the Speex codec library.
*/
PJ_DEF(pj_status_t) pjmedia_codec_speex_deinit(void)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (spx_factory.pool == NULL) {
/* Already deinitialized */
return PJ_SUCCESS;
}
pj_mutex_lock(spx_factory.mutex);
/* We don't want to deinit if there's outstanding codec. */
/* This is silly, as we'll always have codec in the list if
we ever allocate a codec! A better behavior maybe is to
deallocate all codecs in the list.
if (!pj_list_empty(&spx_factory.codec_list)) {
pj_mutex_unlock(spx_factory.mutex);
return PJ_EBUSY;
}
*/
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(spx_factory.endpt);
if (!codec_mgr) {
pj_pool_release(spx_factory.pool);
spx_factory.pool = NULL;
return PJ_EINVALIDOP;
}
/* Unregister Speex codec factory. */
status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
&spx_factory.base);
/* Destroy mutex. */
pj_mutex_destroy(spx_factory.mutex);
/* Destroy pool. */
pj_pool_release(spx_factory.pool);
spx_factory.pool = NULL;
return status;
}
/*
* Initialize and register iLBC codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_ilbc_init( pjmedia_endpt *endpt,
int mode )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
PJ_ASSERT_RETURN(endpt != NULL, PJ_EINVAL);
PJ_ASSERT_RETURN(mode==0 || mode==20 || mode==30, PJ_EINVAL);
/* Create iLBC codec factory. */
ilbc_factory.base.op = &ilbc_factory_op;
ilbc_factory.base.factory_data = NULL;
ilbc_factory.endpt = endpt;
if (mode == 0)
mode = DEFAULT_MODE;
ilbc_factory.mode = mode;
if (mode == 20) {
ilbc_factory.bps = 15200;
} else {
ilbc_factory.bps = 13333;
}
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr)
return PJ_EINVALIDOP;
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&ilbc_factory.base);
if (status != PJ_SUCCESS)
return status;
/* Done. */
return PJ_SUCCESS;
}
/*
* Initialize and register G726 codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_g726_init( pjmedia_endpt *endpt )
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (g726_codec_factory.pool != NULL)
return PJ_SUCCESS;
/* Create G726 codec factory. */
g726_codec_factory.base.op = &g726_factory_op;
g726_codec_factory.base.factory_data = NULL;
g726_codec_factory.endpt = endpt;
g726_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "g726", 512, 512);
if (!g726_codec_factory.pool)
return PJ_ENOMEM;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&g726_codec_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(g726_codec_factory.pool);
g726_codec_factory.pool = NULL;
return status;
}
/*
* Initialize and register Speex codec factory to pjmedia endpoint.
*/
PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt,
unsigned options,
int quality,
int complexity )
{
pjmedia_codec_mgr *codec_mgr;
unsigned i;
pj_status_t status;
if (spx_factory.pool != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Get defaults */
if (quality < 0) quality = PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY;
if (complexity < 0) complexity = PJMEDIA_CODEC_SPEEX_DEFAULT_COMPLEXITY;
/* Validate quality & complexity */
PJ_ASSERT_RETURN(quality >= 0 && quality <= 10, PJ_EINVAL);
PJ_ASSERT_RETURN(complexity >= 1 && complexity <= 10, PJ_EINVAL);
/* Create Speex codec factory. */
spx_factory.base.op = &spx_factory_op;
spx_factory.base.factory_data = NULL;
spx_factory.endpt = endpt;
spx_factory.pool = pjmedia_endpt_create_pool(endpt, "speex",
4000, 4000);
if (!spx_factory.pool)
return PJ_ENOMEM;
pj_list_init(&spx_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(spx_factory.pool, "speex",
&spx_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Initialize default Speex parameter. */
spx_factory.speex_param[PARAM_NB].enabled =
((options & PJMEDIA_SPEEX_NO_NB) == 0);
spx_factory.speex_param[PARAM_NB].pt = PJMEDIA_RTP_PT_SPEEX_NB;
spx_factory.speex_param[PARAM_NB].mode = speex_lib_get_mode(SPEEX_MODEID_NB);
spx_factory.speex_param[PARAM_NB].clock_rate = 8000;
spx_factory.speex_param[PARAM_NB].quality = quality;
spx_factory.speex_param[PARAM_NB].complexity = complexity;
spx_factory.speex_param[PARAM_WB].enabled =
((options & PJMEDIA_SPEEX_NO_WB) == 0);
spx_factory.speex_param[PARAM_WB].pt = PJMEDIA_RTP_PT_SPEEX_WB;
spx_factory.speex_param[PARAM_WB].mode = speex_lib_get_mode(SPEEX_MODEID_WB);
spx_factory.speex_param[PARAM_WB].clock_rate = 16000;
spx_factory.speex_param[PARAM_WB].quality = quality;
spx_factory.speex_param[PARAM_WB].complexity = complexity;
spx_factory.speex_param[PARAM_UWB].enabled =
((options & PJMEDIA_SPEEX_NO_UWB) == 0);
spx_factory.speex_param[PARAM_UWB].pt = PJMEDIA_RTP_PT_SPEEX_UWB;
spx_factory.speex_param[PARAM_UWB].mode = speex_lib_get_mode(SPEEX_MODEID_UWB);
spx_factory.speex_param[PARAM_UWB].clock_rate = 32000;
spx_factory.speex_param[PARAM_UWB].quality = quality;
spx_factory.speex_param[PARAM_UWB].complexity = complexity;
/* Somehow quality <=4 is broken in linux. */
if (quality <= 4 && quality >= 0) {
PJ_LOG(5,(THIS_FILE, "Adjusting quality to 5 for uwb"));
spx_factory.speex_param[PARAM_UWB].quality = 5;
}
/* Get codec framesize and avg bitrate for each mode. */
for (i=0; i<PJ_ARRAY_SIZE(spx_factory.speex_param); ++i) {
status = get_speex_info(&spx_factory.speex_param[i]);
}
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
status = PJ_EINVALIDOP;
goto on_error;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&spx_factory.base);
if (status != PJ_SUCCESS)
goto on_error;
/* Done. */
return PJ_SUCCESS;
on_error:
pj_pool_release(spx_factory.pool);
spx_factory.pool = NULL;
return status;
}
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;
}
PJ_DEF(pj_status_t) pjmedia_codec_silk_init(pjmedia_endpt *endpt)
{
pjmedia_codec_mgr *codec_mgr;
silk_param *sp;
pj_status_t status;
if (silk_factory.endpt != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Init factory */
pj_bzero(&silk_factory, sizeof(silk_factory));
silk_factory.base.op = &silk_factory_op;
silk_factory.base.factory_data = NULL;
silk_factory.endpt = endpt;
/* Create pool */
silk_factory.pool = pjmedia_endpt_create_pool(endpt, "silk", 4000, 4000);
if (!silk_factory.pool)
return PJ_ENOMEM;
/* Create mutex. */
status = pj_mutex_create_simple(silk_factory.pool, "silk",
&silk_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
/* Initialize default codec params */
/* From SILK docs:
- SILK bitrate tables:
+----------------+---------+-----------+
| | fs (Hz) | BR (kbps) |
+----------------+---------+-----------+
| Narrowband | 8000 | 6 - 20 |
| Mediumband | 12000 | 7 - 25 |
| Wideband | 16000 | 8 - 30 |
| Super Wideband | 24000 | 12 - 40 |
+----------------+---------+-----------+
- The upper limits of the bit rate ranges in this table are
recommended values.
*/
sp = &silk_factory.silk_param[PARAM_NB];
sp->pt = PJMEDIA_RTP_PT_SILK_NB;
sp->clock_rate = 8000;
sp->max_bitrate = 22000;
sp->bitrate = CALC_BITRATE(sp->max_bitrate);
sp->ptime = FRAME_LENGTH_MS;
sp->complexity = PJMEDIA_CODEC_SILK_DEFAULT_COMPLEXITY;
sp->enabled = 1;
sp = &silk_factory.silk_param[PARAM_MB];
sp->pt = PJMEDIA_RTP_PT_SILK_MB;
sp->clock_rate = 12000;
sp->max_bitrate = 28000;
sp->bitrate = CALC_BITRATE(sp->max_bitrate);
sp->ptime = FRAME_LENGTH_MS;
sp->complexity = PJMEDIA_CODEC_SILK_DEFAULT_COMPLEXITY;
sp->enabled = 0;
sp = &silk_factory.silk_param[PARAM_WB];
sp->pt = PJMEDIA_RTP_PT_SILK_WB;
sp->clock_rate = 16000;
sp->max_bitrate = 36000;
sp->bitrate = CALC_BITRATE(sp->max_bitrate);
sp->ptime = FRAME_LENGTH_MS;
sp->complexity = PJMEDIA_CODEC_SILK_DEFAULT_COMPLEXITY;
sp->enabled = 1;
sp = &silk_factory.silk_param[PARAM_SWB];
sp->pt = PJMEDIA_RTP_PT_SILK_SWB;
sp->clock_rate = 24000;
sp->max_bitrate = 46000;
sp->bitrate = CALC_BITRATE(sp->max_bitrate);
sp->ptime = FRAME_LENGTH_MS;
sp->complexity = PJMEDIA_CODEC_SILK_DEFAULT_COMPLEXITY;
sp->enabled = 0;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
return PJ_EINVALIDOP;
}
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&silk_factory.base);
if (status != PJ_SUCCESS)
return status;
PJ_LOG(4,(THIS_FILE, "SILK codec version %s initialized",
SKP_Silk_SDK_get_version()));
return PJ_SUCCESS;
on_error:
if (silk_factory.mutex) {
pj_mutex_destroy(silk_factory.mutex);
silk_factory.mutex = NULL;
}
if (silk_factory.pool) {
pj_pool_release(silk_factory.pool);
silk_factory.pool = NULL;
}
return status;
}
/*
* 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;
}
PJ_DEF(pj_status_t) pjmedia_codec_silk_init(pjmedia_endpt *endpt)
{
pjmedia_codec_mgr *codec_mgr;
pj_status_t status;
if (silk_factory.endpt != NULL) {
/* Already initialized. */
return PJ_SUCCESS;
}
/* Init factory */
silk_factory.base.op = &silk_factory_op;
silk_factory.base.factory_data = NULL;
silk_factory.endpt = endpt;
/* Create pool */
silk_factory.pool = pjmedia_endpt_create_pool(endpt, "silk codecs", 4000, 4000);
if (!silk_factory.pool)
return PJ_ENOMEM;
/* Init list */
pj_list_init(&silk_factory.codec_list);
/* Create mutex. */
status = pj_mutex_create_simple(silk_factory.pool, "silk codecs",
&silk_factory.mutex);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(5, (THIS_FILE, "Init silk"));
/* Table from silk docs
| fs (Hz) | BR (kbps)
----------------+---------+----------
Narrowband | 8000 | 5 - 20
Mediumband | 12000 | 7 - 25
Wideband | 16000 | 8 - 30
Super Wideband | 24000 | 20 - 40
*/
// The max_bitrate is based on the maximum bitrate that can be used for the encoder.
// BTW, if a remote side send us something very big, we will not get lost.
// If such a remote side send us big packets it could be considered unefficient.
// On our side we set for bitrate the medium value of bitrate for each clock rate based
// on table above.
struct silk_param *silk_param;
silk_param = &silk_factory.silk_param[PARAM_NB];
silk_param->pt = PJMEDIA_RTP_PT_SILK_NB;
silk_param->clock_rate = 8000;
silk_param->bitrate = 13000;
pj_utoa(silk_param->bitrate, silk_param->bitrate_str);
silk_param->max_bitrate = SILK_MAX_CODER_BITRATE;
silk_param->packet_size_ms = FRAME_LENGTH_MS;
silk_param->complexity = 2;
silk_param->enabled = 1;
silk_param = &silk_factory.silk_param[PARAM_MB];
silk_param->pt = PJMEDIA_RTP_PT_SILK_MB;
silk_param->clock_rate = 12000;
silk_param->bitrate = 16000;
pj_utoa(silk_param->bitrate, silk_param->bitrate_str);
silk_param->max_bitrate = SILK_MAX_CODER_BITRATE;
silk_param->packet_size_ms = FRAME_LENGTH_MS;
silk_param->complexity = 2;
silk_param->enabled = 1;
silk_param = &silk_factory.silk_param[PARAM_WB];
silk_param->pt = PJMEDIA_RTP_PT_SILK_WB;
silk_param->clock_rate = 16000;
silk_param->bitrate = 19000;
pj_utoa(silk_param->bitrate, silk_param->bitrate_str);
silk_param->max_bitrate = SILK_MAX_CODER_BITRATE;
silk_param->packet_size_ms = FRAME_LENGTH_MS;
silk_param->complexity = 2;
silk_param->enabled = 1;
silk_param = &silk_factory.silk_param[PARAM_UWB];
silk_param->pt = PJMEDIA_RTP_PT_SILK_UWB;
silk_param->clock_rate = 24000;
silk_param->bitrate = 30000;
pj_utoa(silk_param->bitrate, silk_param->bitrate_str);
silk_param->max_bitrate = SILK_MAX_CODER_BITRATE;
silk_param->packet_size_ms = FRAME_LENGTH_MS;
silk_param->complexity = 2;
silk_param->enabled = 1;
/* Get the codec manager. */
codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
if (!codec_mgr) {
return PJ_EINVALIDOP;
}
PJ_LOG(5, (THIS_FILE, "Init silk > DONE"));
/* Register codec factory to endpoint. */
status = pjmedia_codec_mgr_register_factory(codec_mgr,
&silk_factory.base);
if (status != PJ_SUCCESS)
return status;
return PJ_SUCCESS;
on_error:
if (silk_factory.mutex) {
pj_mutex_destroy(silk_factory.mutex);
silk_factory.mutex = NULL;
}
if (silk_factory.pool) {
pj_pool_release(silk_factory.pool);
silk_factory.pool = NULL;
}
return status;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
pjmedia_sdp_rtpmap *rtpmap;
int local_fmtp_mode = 0, rem_fmtp_mode = 0;
unsigned i, pt, fmti;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Reset: */
pj_bzero(si, sizeof(*si));
/* Media type: */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) == 0) {
si->type = PJMEDIA_TYPE_AUDIO;
} else if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) == 0) {
si->type = PJMEDIA_TYPE_VIDEO;
} else {
si->type = PJMEDIA_TYPE_UNKNOWN;
return PJMEDIA_EINVALIMEDIATYPE;
}
/* Transport type must be equal */
if (pj_stricmp(&rem_m->desc.transport,
&local_m->desc.transport) != 0)
{
si->type = PJMEDIA_TYPE_UNKNOWN;
return PJMEDIA_SDPNEG_EINVANSTP;
}
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_inet_addr(&local_conn->addr).s_addr==0 ||
pj_inet_addr(&rem_conn->addr).s_addr==0 ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* Set remote address: */
status = pj_sockaddr_in_init(&si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_in_init(&si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_in_init(&si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
si->rem_rtcp.sin_addr.s_addr = si->rem_addr.sin_addr.s_addr;
}
}
}
if (si->rem_rtcp.sin_addr.s_addr == 0) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr_in));
rtcp_port = pj_ntohs(si->rem_addr.sin_port) + 1;
si->rem_rtcp.sin_port = pj_htons((pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* This is to suppress MSVC warning about uninitialized var */
pt = 0;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if ( PJMEDIA_RTP_PT_TELEPHONE_EVENTS == 0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS )
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* 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;
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
if (rtpmap->param.slen == 2) {
si->fmt.channel_cnt = rtpmap->param.ptr[1] - '0';
} else {
pj_str_t cnt;
cnt.ptr = rtpmap->param.ptr + 1;
cnt.slen = rtpmap->param.slen - 1;
si->fmt.channel_cnt = (unsigned) pj_strtoul(&cnt);
}
} 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 {
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]);
pj_strdup(pool, &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) {
if (rtpmap->param.slen == 2) {
si->fmt.channel_cnt = rtpmap->param.ptr[1] - '0';
} else {
pj_str_t cnt;
cnt.ptr = rtpmap->param.ptr + 1;
cnt.slen = rtpmap->param.slen - 1;
si->fmt.channel_cnt = (unsigned) pj_strtoul(&cnt);
}
} else {
si->fmt.channel_cnt = 1;
}
/* Get fmtp mode= param in local SDP, if any */
get_fmtp_mode(local_m, &local_m->desc.fmt[fmti], &local_fmtp_mode);
/* 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) {
unsigned rpt;
pjmedia_sdp_attr *r_attr;
pjmedia_sdp_rtpmap r_rtpmap;
rpt = pj_strtoul(&rem_m->desc.fmt[i]);
if (rpt < 96)
continue;
r_attr = pjmedia_sdp_media_find_attr(rem_m, &ID_RTPMAP,
&rem_m->desc.fmt[i]);
if (!r_attr)
continue;
if (pjmedia_sdp_attr_get_rtpmap(r_attr, &r_rtpmap) != PJ_SUCCESS)
continue;
if (!pj_stricmp(&rtpmap->enc_name, &r_rtpmap.enc_name) &&
rtpmap->clock_rate == r_rtpmap.clock_rate)
{
/* Found matched codec. */
si->tx_pt = rpt;
/* Get fmtp mode param in remote SDP, if any */
get_fmtp_mode(rem_m, &rtpmap->pt, &rem_fmtp_mode);
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
}
/* Now that we have codec info, get the codec param. */
si->param = pj_pool_alloc(pool, sizeof(*si->param));
status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt, si->param);
if (status != PJ_SUCCESS)
return status;
/* Set fmtp mode for both local and remote */
if (local_fmtp_mode != 0)
si->param->setting.dec_fmtp_mode = (pj_int8_t)local_fmtp_mode;
if (rem_fmtp_mode != 0)
si->param->setting.enc_fmtp_mode = (pj_int8_t)rem_fmtp_mode;
/* 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;
}
}
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return PJ_SUCCESS;
}
int codec_test_vectors(void)
{
pjmedia_endpt *endpt;
pjmedia_codec_mgr *mgr;
int rc, rc_final = 0;
struct enc_vectors {
char *codec_name;
unsigned bit_rate;
const char *wav_file;
const char *ref_encoded_file;
} enc_vectors[] =
{
#if PJMEDIA_HAS_G7221_CODEC
{ "G7221/16000/1", 24000,
"../src/test/vectors/g722_1_enc_in.wav",
"../src/test/vectors/g722_1_enc_out_24000_be.pak"
},
{ "G7221/16000/1", 32000,
"../src/test/vectors/g722_1_enc_in.wav",
"../src/test/vectors/g722_1_enc_out_32000_be.pak"
},
#endif
{ NULL }
};
struct dec_vectors {
char *codec_name;
unsigned bit_rate;
unsigned encoded_frame_len;
void (*manip)(short *pcm, unsigned count);
const char *enc_file;
const char *ref_pcm_file;
} dec_vectors[] =
{
#if PJMEDIA_HAS_G7221_CODEC
{ "G7221/16000/1", 24000, 60,
&g7221_pcm_manip,
"../src/test/vectors/g722_1_enc_out_24000_be.pak",
"../src/test/vectors/g722_1_dec_out_24000.pcm"
},
{ "G7221/16000/1", 32000, 80,
&g7221_pcm_manip,
"../src/test/vectors/g722_1_enc_out_32000_be.pak",
"../src/test/vectors/g722_1_dec_out_32000.pcm"
},
{ "G7221/16000/1", 24000, 60,
&g7221_pcm_manip,
"../src/test/vectors/g722_1_dec_in_24000_fe.itu",
"../src/test/vectors/g722_1_dec_out_24000_fe.pcm"
},
{ "G7221/16000/1", 32000, 80,
&g7221_pcm_manip,
"../src/test/vectors/g722_1_dec_in_32000_fe.itu",
"../src/test/vectors/g722_1_dec_out_32000_fe.pcm"
},
#endif
{ NULL }
};
unsigned i;
pj_status_t status;
status = pjmedia_endpt_create(mem, NULL, 0, &endpt);
if (status != PJ_SUCCESS)
return -5;
mgr = pjmedia_endpt_get_codec_mgr(endpt);
#if PJMEDIA_HAS_G7221_CODEC
status = pjmedia_codec_g7221_init(endpt);
if (status != PJ_SUCCESS) {
pjmedia_endpt_destroy(endpt);
return -7;
}
/* Set shift value to zero for the test vectors */
pjmedia_codec_g7221_set_pcm_shift(0);
#endif
PJ_LOG(3,(THIS_FILE," encode tests:"));
for (i=0; i<PJ_ARRAY_SIZE(enc_vectors); ++i) {
if (!enc_vectors[i].codec_name)
continue;
PJ_LOG(3,(THIS_FILE," %s @%d bps %s ==> %s",
enc_vectors[i].codec_name,
enc_vectors[i].bit_rate,
enc_vectors[i].wav_file,
enc_vectors[i].ref_encoded_file));
rc = codec_test_encode(mgr, enc_vectors[i].codec_name,
enc_vectors[i].bit_rate,
enc_vectors[i].wav_file,
enc_vectors[i].ref_encoded_file);
if (rc != 0)
rc_final = rc;
}
PJ_LOG(3,(THIS_FILE," decode tests:"));
for (i=0; i<PJ_ARRAY_SIZE(dec_vectors); ++i) {
if (!dec_vectors[i].codec_name)
continue;
PJ_LOG(3,(THIS_FILE," %s @%d bps %s ==> %s",
dec_vectors[i].codec_name,
dec_vectors[i].bit_rate,
dec_vectors[i].enc_file,
dec_vectors[i].ref_pcm_file));
rc = codec_test_decode(mgr, dec_vectors[i].codec_name,
dec_vectors[i].bit_rate,
dec_vectors[i].encoded_frame_len,
dec_vectors[i].enc_file,
dec_vectors[i].ref_pcm_file,
dec_vectors[i].manip);
if (rc != 0)
rc_final = rc;
}
if (pj_file_exists(TMP_OUT))
pj_file_delete(TMP_OUT);
pjmedia_endpt_destroy(endpt);
return rc_final;
}
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);
}
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
const pj_str_t STR_INACTIVE = { "inactive", 8 };
const pj_str_t STR_SENDONLY = { "sendonly", 8 };
const pj_str_t STR_RECVONLY = { "recvonly", 8 };
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Media type must be audio */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) != 0)
return PJMEDIA_EINVALIMEDIATYPE;
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Reset: */
pj_bzero(si, sizeof(*si));
#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
/* Set default RTCP XR enabled/disabled */
si->rtcp_xr_enabled = PJ_TRUE;
#endif
/* Media type: */
si->type = PJMEDIA_TYPE_AUDIO;
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* Get codec info and param */
status = get_audio_codec_info_param(si, pool, mgr, local_m, rem_m);
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return status;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pjmedia_sdp_rtpmap *rtpmap;
unsigned i, pt, fmti;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Reset: */
pj_bzero(si, sizeof(*si));
#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
/* Set default RTCP XR enabled/disabled */
si->rtcp_xr_enabled = PJ_TRUE;
#endif
/* Media type: */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) == 0) {
si->type = PJMEDIA_TYPE_AUDIO;
} else if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) == 0) {
si->type = PJMEDIA_TYPE_VIDEO;
} else {
si->type = PJMEDIA_TYPE_UNKNOWN;
/* Avoid rejecting call because of unrecognized media,
* just return PJ_SUCCESS, this media will be deactivated later.
*/
//return PJMEDIA_EINVALIMEDIATYPE;
return PJ_SUCCESS;
}
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* This is to suppress MSVC warning about uninitialized var */
pt = 0;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if ( PJMEDIA_RTP_PT_TELEPHONE_EVENTS == 0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS )
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* 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 {
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]);
pj_strdup(pool, &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;
}
/* 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) {
unsigned rpt;
pjmedia_sdp_attr *r_attr;
pjmedia_sdp_rtpmap r_rtpmap;
rpt = pj_strtoul(&rem_m->desc.fmt[i]);
if (rpt < 96)
continue;
r_attr = pjmedia_sdp_media_find_attr(rem_m, &ID_RTPMAP,
&rem_m->desc.fmt[i]);
if (!r_attr)
continue;
if (pjmedia_sdp_attr_get_rtpmap(r_attr, &r_rtpmap) != PJ_SUCCESS)
continue;
if (!pj_stricmp(&rtpmap->enc_name, &r_rtpmap.enc_name) &&
rtpmap->clock_rate == r_rtpmap.clock_rate)
{
/* Found matched codec. */
si->tx_pt = rpt;
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. */
parse_fmtp(pool, rem_m, si->tx_pt, &si->param->setting.enc_fmtp);
/* Get local fmtp for our decoder. */
parse_fmtp(pool, local_m, si->fmt.pt, &si->param->setting.dec_fmtp);
/* 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;
}
}
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return PJ_SUCCESS;
}
