/*
* 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_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;
}
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_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;
}
/*
* 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;
}
/*
* 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;
}
/*
* 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;
}
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;
}
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;
}
