From 4bab78a009cbfc57426066ebb5070e7609d4be04 Mon Sep 17 00:00:00 2001 From: Benny Prijono Date: Thu, 27 Apr 2006 22:36:40 +0000 Subject: Initial support for stereo codecs, and added L16 codecs. Also better handling for case remote media is restarted git-svn-id: http://svn.pjsip.org/repos/pjproject/trunk@411 74dad513-b988-da41-8d7b-12977e46ad98 --- pjmedia/src/pjmedia-codec/gsm.c | 18 +- pjmedia/src/pjmedia-codec/l16.c | 594 ++++++++++++++++++++++++++++++++ pjmedia/src/pjmedia-codec/speex_codec.c | 66 ++-- 3 files changed, 621 insertions(+), 57 deletions(-) create mode 100644 pjmedia/src/pjmedia-codec/l16.c (limited to 'pjmedia/src/pjmedia-codec') diff --git a/pjmedia/src/pjmedia-codec/gsm.c b/pjmedia/src/pjmedia-codec/gsm.c index 55d207aa..ebb6d1be 100644 --- a/pjmedia/src/pjmedia-codec/gsm.c +++ b/pjmedia/src/pjmedia-codec/gsm.c @@ -49,8 +49,6 @@ static pj_status_t gsm_dealloc_codec( pjmedia_codec_factory *factory, pjmedia_codec *codec ); /* Prototypes for GSM implementation. */ -static pj_status_t gsm_codec_default_attr(pjmedia_codec *codec, - pjmedia_codec_param *attr); static pj_status_t gsm_codec_init( pjmedia_codec *codec, pj_pool_t *pool ); static pj_status_t gsm_codec_open( pjmedia_codec *codec, @@ -73,7 +71,6 @@ static pj_status_t gsm_codec_decode( pjmedia_codec *codec, /* Definition for GSM codec operations. */ static pjmedia_codec_op gsm_op = { - &gsm_codec_default_attr, &gsm_codec_init, &gsm_codec_open, &gsm_codec_close, @@ -233,7 +230,8 @@ static pj_status_t gsm_default_attr (pjmedia_codec_factory *factory, PJ_UNUSED_ARG(id); pj_memset(attr, 0, sizeof(pjmedia_codec_param)); - attr->sample_rate = 8000; + attr->clock_rate = 8000; + attr->channel_cnt = 1; attr->avg_bps = 13200; attr->pcm_bits_per_sample = 16; attr->ptime = 20; @@ -258,7 +256,8 @@ static pj_status_t gsm_enum_codecs(pjmedia_codec_factory *factory, codecs[0].encoding_name = pj_str("GSM"); codecs[0].pt = PJMEDIA_RTP_PT_GSM; codecs[0].type = PJMEDIA_TYPE_AUDIO; - codecs[0].sample_rate = 8000; + codecs[0].clock_rate = 8000; + codecs[0].channel_cnt = 1; *count = 1; @@ -327,15 +326,6 @@ static pj_status_t gsm_dealloc_codec( pjmedia_codec_factory *factory, return PJ_SUCCESS; } -/* - * Get codec default attributes. - */ -static pj_status_t gsm_codec_default_attr( pjmedia_codec *codec, - pjmedia_codec_param *attr) -{ - return gsm_default_attr( codec->factory, NULL, attr); -} - /* * Init codec. */ diff --git a/pjmedia/src/pjmedia-codec/l16.c b/pjmedia/src/pjmedia-codec/l16.c new file mode 100644 index 00000000..594aefc3 --- /dev/null +++ b/pjmedia/src/pjmedia-codec/l16.c @@ -0,0 +1,594 @@ +/* $Id$ */ +/* + * Copyright (C)2003-2006 Benny Prijono + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#include +#include +#include +#include +#include +#include +#include + + +/* + * Only build this file if PJMEDIA_HAS_L16_CODEC != 0 + */ +#if defined(PJMEDIA_HAS_L16_CODEC) && PJMEDIA_HAS_L16_CODEC != 0 + + +static const pj_str_t STR_L16 = { "L16", 3 }; + +/* To keep frame size below 1400 MTU, set ptime to 10ms for + * sampling rate > 35 KHz + */ +#define GET_PTIME(clock_rate) ((pj_uint16_t)(clock_rate > 35000 ? 10 : 20)) + + +/* Prototypes for L16 factory */ +static pj_status_t l16_test_alloc( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id ); +static pj_status_t l16_default_attr( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec_param *attr ); +static pj_status_t l16_enum_codecs (pjmedia_codec_factory *factory, + unsigned *count, + pjmedia_codec_info codecs[]); +static pj_status_t l16_alloc_codec( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec **p_codec); +static pj_status_t l16_dealloc_codec( pjmedia_codec_factory *factory, + pjmedia_codec *codec ); + +/* Prototypes for L16 implementation. */ +static pj_status_t l16_init( pjmedia_codec *codec, + pj_pool_t *pool ); +static pj_status_t l16_open( pjmedia_codec *codec, + pjmedia_codec_param *attr ); +static pj_status_t l16_close( pjmedia_codec *codec ); +static pj_status_t l16_get_frames(pjmedia_codec *codec, + void *pkt, + pj_size_t pkt_size, + unsigned *frame_cnt, + pjmedia_frame frames[]); +static pj_status_t l16_encode( pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output); +static pj_status_t l16_decode( pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output); + +/* Definition for L16 codec operations. */ +static pjmedia_codec_op l16_op = +{ + &l16_init, + &l16_open, + &l16_close, + &l16_get_frames, + &l16_encode, + &l16_decode +}; + +/* Definition for L16 codec factory operations. */ +static pjmedia_codec_factory_op l16_factory_op = +{ + &l16_test_alloc, + &l16_default_attr, + &l16_enum_codecs, + &l16_alloc_codec, + &l16_dealloc_codec +}; + +/* L16 factory private data */ +static struct l16_factory +{ + pjmedia_codec_factory base; + pjmedia_endpt *endpt; + pj_pool_t *pool; + pj_mutex_t *mutex; + pjmedia_codec codec_list; +} l16_factory; + + +/* L16 codec private data. */ +struct l16_data +{ + unsigned frame_size; /* Frame size, in bytes */ +}; + + + +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; + + pj_list_init(&l16_factory.codec_list); + + /* 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_l16_deinit(void) +{ + pjmedia_codec_mgr *codec_mgr; + pj_status_t status; + + if (l16_factory.endpt == NULL) { + /* Not registered. */ + return PJ_SUCCESS; + } + + /* Lock mutex. */ + pj_mutex_lock(l16_factory.mutex); + + /* Get the codec manager. */ + codec_mgr = pjmedia_endpt_get_codec_mgr(l16_factory.endpt); + if (!codec_mgr) { + l16_factory.endpt = NULL; + pj_mutex_unlock(l16_factory.mutex); + return PJ_EINVALIDOP; + } + + /* Unregister L16 codec factory. */ + status = pjmedia_codec_mgr_unregister_factory(codec_mgr, + &l16_factory.base); + l16_factory.endpt = NULL; + + /* Destroy mutex. */ + pj_mutex_destroy(l16_factory.mutex); + l16_factory.mutex = NULL; + + + /* Release pool. */ + pj_pool_release(l16_factory.pool); + l16_factory.pool = NULL; + + + return status; +} + +static pj_status_t l16_test_alloc(pjmedia_codec_factory *factory, + const pjmedia_codec_info *id ) +{ + PJ_UNUSED_ARG(factory); + + if (pj_stricmp(&id->encoding_name, &STR_L16)==0) { + /* Match! */ + return PJ_SUCCESS; + } + + return -1; +} + +static pj_status_t l16_default_attr( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec_param *attr ) +{ + PJ_UNUSED_ARG(factory); + + pj_memset(attr, 0, sizeof(pjmedia_codec_param)); + attr->pt = id->pt; + attr->clock_rate = id->clock_rate; + attr->channel_cnt = id->channel_cnt; + attr->avg_bps = id->clock_rate * id->channel_cnt * 16; + attr->pcm_bits_per_sample = 16; + + /* To keep frame size below 1400 MTU, set ptime to 10ms for + * sampling rate > 35 KHz + */ + attr->ptime = GET_PTIME(id->clock_rate); + + /* Default all flag bits disabled. */ + + return PJ_SUCCESS; +} + +static pj_status_t l16_enum_codecs( pjmedia_codec_factory *factory, + unsigned *max_count, + pjmedia_codec_info codecs[]) +{ + unsigned count = 0; + + PJ_UNUSED_ARG(factory); + + if (count < *max_count) { + /* Register 44100Hz 1 channel L16 codec */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_1; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 44100; + codecs[count].channel_cnt = 1; + ++count; + } + + if (count < *max_count) { + /* Register 44100Hz 2 channels L16 codec */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_2; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 44100; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 8KHz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_8KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 8000; + codecs[count].channel_cnt = 1; + ++count; + } + + if (count < *max_count) { + /* 8KHz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_8KHZ_STEREO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 8000; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 11025 Hz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_11KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 11025; + codecs[count].channel_cnt = 1; + ++count; + } + + if (count < *max_count) { + /* 11025 Hz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_11KHZ_STEREO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 11025; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 16000 Hz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_16KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 16000; + codecs[count].channel_cnt = 1; + ++count; + } + + + if (count < *max_count) { + /* 16000 Hz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_16KHZ_STEREO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 16000; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 22050 Hz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_22KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 22050; + codecs[count].channel_cnt = 1; + ++count; + } + + + if (count < *max_count) { + /* 22050 Hz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_22KHZ_STEREO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 22050; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 32000 Hz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_32KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 32000; + codecs[count].channel_cnt = 1; + ++count; + } + + if (count < *max_count) { + /* 32000 Hz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_32KHZ_STEREO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 32000; + codecs[count].channel_cnt = 2; + ++count; + } + + if (count < *max_count) { + /* 48KHz mono */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_48KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 48000; + codecs[count].channel_cnt = 1; + ++count; + } + + if (count < *max_count) { + /* 48KHz stereo */ + codecs[count].type = PJMEDIA_TYPE_AUDIO; + codecs[count].pt = PJMEDIA_RTP_PT_L16_48KHZ_MONO; + codecs[count].encoding_name = STR_L16; + codecs[count].clock_rate = 48000; + codecs[count].channel_cnt = 2; + ++count; + } + + + *max_count = count; + + return PJ_SUCCESS; +} + +static pj_status_t l16_alloc_codec( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec **p_codec) +{ + pjmedia_codec *codec = NULL; + struct l16_data *data; + unsigned ptime; + + PJ_ASSERT_RETURN(factory==&l16_factory.base, PJ_EINVAL); + + /* Lock mutex. */ + pj_mutex_lock(l16_factory.mutex); + + /* Allocate new codec if no more is available */ + if (pj_list_empty(&l16_factory.codec_list)) { + + codec = pj_pool_alloc(l16_factory.pool, sizeof(pjmedia_codec)); + codec->codec_data = pj_pool_alloc(l16_factory.pool, + sizeof(struct l16_data)); + codec->factory = factory; + codec->op = &l16_op; + + } else { + codec = l16_factory.codec_list.next; + pj_list_erase(codec); + } + + /* Init private data */ + ptime = GET_PTIME(id->clock_rate); + data = codec->codec_data; + data->frame_size = ptime * id->clock_rate * id->channel_cnt * 2 / 1000; + + /* Zero the list, for error detection in l16_dealloc_codec */ + codec->next = codec->prev = NULL; + + *p_codec = codec; + + /* Unlock mutex. */ + pj_mutex_unlock(l16_factory.mutex); + + return PJ_SUCCESS; +} + +static pj_status_t l16_dealloc_codec(pjmedia_codec_factory *factory, + pjmedia_codec *codec ) +{ + + PJ_ASSERT_RETURN(factory==&l16_factory.base, PJ_EINVAL); + + /* Check that this node has not been deallocated before */ + pj_assert (codec->next==NULL && codec->prev==NULL); + if (codec->next!=NULL || codec->prev!=NULL) { + return PJ_EINVALIDOP; + } + + /* Lock mutex. */ + pj_mutex_lock(l16_factory.mutex); + + /* Insert at the back of the list */ + pj_list_insert_before(&l16_factory.codec_list, codec); + + /* Unlock mutex. */ + pj_mutex_unlock(l16_factory.mutex); + + return PJ_SUCCESS; +} + +static pj_status_t l16_init( pjmedia_codec *codec, pj_pool_t *pool ) +{ + /* There's nothing to do here really */ + PJ_UNUSED_ARG(codec); + PJ_UNUSED_ARG(pool); + + return PJ_SUCCESS; +} + +static pj_status_t l16_open(pjmedia_codec *codec, + pjmedia_codec_param *attr ) +{ + /* Nothing to do.. */ + PJ_UNUSED_ARG(codec); + PJ_UNUSED_ARG(attr); + return PJ_SUCCESS; +} + +static pj_status_t l16_close( pjmedia_codec *codec ) +{ + PJ_UNUSED_ARG(codec); + /* Nothing to do */ + return PJ_SUCCESS; +} + +static pj_status_t l16_get_frames( pjmedia_codec *codec, + void *pkt, + pj_size_t pkt_size, + unsigned *frame_cnt, + pjmedia_frame frames[]) +{ + unsigned count = 0; + struct l16_data *data = (struct l16_data*) codec->codec_data; + + PJ_UNUSED_ARG(codec); + PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL); + + while (pkt_size >= data->frame_size && count < *frame_cnt) { + frames[0].type = PJMEDIA_FRAME_TYPE_AUDIO; + frames[0].buf = pkt; + frames[0].size = data->frame_size; + + pkt = ((char*)pkt) + data->frame_size; + pkt_size -= data->frame_size; + + ++count; + } + + *frame_cnt = count; + return PJ_SUCCESS; +} + +static pj_status_t l16_encode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output) +{ + const pj_int16_t *samp = (const pj_int16_t*) input->buf; + const pj_int16_t *samp_end = samp + input->size/sizeof(pj_int16_t); + pj_int16_t *samp_out = (pj_int16_t*) output->buf; + + + PJ_UNUSED_ARG(codec); + + + /* Check output buffer length */ + if (output_buf_len < input->size) + return PJMEDIA_CODEC_EFRMTOOSHORT; + + + /* Encode */ +#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0 + while (samp!=samp_end) + *samp_out++ = pj_htons(*samp++); +#endif + + + /* Done */ + output->type = PJMEDIA_FRAME_TYPE_AUDIO; + output->size = input->size; + + return PJ_SUCCESS; +} + +static pj_status_t l16_decode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output) +{ + const pj_int16_t *samp = (const pj_int16_t*) input->buf; + const pj_int16_t *samp_end = samp + input->size/sizeof(pj_int16_t); + pj_int16_t *samp_out = (pj_int16_t*) output->buf; + + + PJ_UNUSED_ARG(codec); + + + /* Check output buffer length */ + if (output_buf_len < input->size) + return PJMEDIA_CODEC_EPCMTOOSHORT; + + + /* Decode */ +#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0 + while (samp!=samp_end) + *samp_out++ = pj_htons(*samp++); +#endif + + + output->type = PJMEDIA_FRAME_TYPE_AUDIO; + output->size = input->size; + + return PJ_SUCCESS; +} + + +#endif /* PJMEDIA_HAS_L16_CODEC */ + + diff --git a/pjmedia/src/pjmedia-codec/speex_codec.c b/pjmedia/src/pjmedia-codec/speex_codec.c index 840737ee..280cfbdd 100644 --- a/pjmedia/src/pjmedia-codec/speex_codec.c +++ b/pjmedia/src/pjmedia-codec/speex_codec.c @@ -56,8 +56,6 @@ static pj_status_t spx_dealloc_codec( pjmedia_codec_factory *factory, pjmedia_codec *codec ); /* Prototypes for Speex implementation. */ -static pj_status_t spx_codec_default_attr(pjmedia_codec *codec, - pjmedia_codec_param *attr); static pj_status_t spx_codec_init( pjmedia_codec *codec, pj_pool_t *pool ); static pj_status_t spx_codec_open( pjmedia_codec *codec, @@ -80,7 +78,6 @@ static pj_status_t spx_codec_decode( pjmedia_codec *codec, /* Definition for Speex codec operations. */ static pjmedia_codec_op spx_op = { - &spx_codec_default_attr, &spx_codec_init, &spx_codec_open, &spx_codec_close, @@ -230,7 +227,7 @@ PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt, /* Initialize default Speex parameter. */ spx_factory.speex_param[PARAM_NB].enabled = ((options & PJMEDIA_SPEEX_NO_NB) == 0); - spx_factory.speex_param[PARAM_NB].pt = 102; + spx_factory.speex_param[PARAM_NB].pt = PJMEDIA_RTP_PT_SPEEX_NB; spx_factory.speex_param[PARAM_NB].mode = &speex_nb_mode; spx_factory.speex_param[PARAM_NB].clock_rate = 8000; spx_factory.speex_param[PARAM_NB].quality = quality; @@ -238,7 +235,7 @@ PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt, spx_factory.speex_param[PARAM_WB].enabled = ((options & PJMEDIA_SPEEX_NO_WB) == 0); - spx_factory.speex_param[PARAM_WB].pt = 103; + spx_factory.speex_param[PARAM_WB].pt = PJMEDIA_RTP_PT_SPEEX_WB; spx_factory.speex_param[PARAM_WB].mode = &speex_wb_mode; spx_factory.speex_param[PARAM_WB].clock_rate = 16000; spx_factory.speex_param[PARAM_WB].quality = quality; @@ -246,7 +243,7 @@ PJ_DEF(pj_status_t) pjmedia_codec_speex_init( pjmedia_endpt *endpt, spx_factory.speex_param[PARAM_UWB].enabled = ((options & PJMEDIA_SPEEX_NO_UWB) == 0); - spx_factory.speex_param[PARAM_UWB].pt = 104; + spx_factory.speex_param[PARAM_UWB].pt = PJMEDIA_RTP_PT_SPEEX_UWB; spx_factory.speex_param[PARAM_UWB].mode = &speex_uwb_mode; spx_factory.speex_param[PARAM_UWB].clock_rate = 32000; spx_factory.speex_param[PARAM_UWB].quality = quality; @@ -358,7 +355,7 @@ static pj_status_t spx_test_alloc( pjmedia_codec_factory *factory, /* Check clock-rate */ for (i=0; isample_rate == spx_factory.speex_param[i].clock_rate) { + if (info->clock_rate == spx_factory.speex_param[i].clock_rate) { /* Okay, let's Speex! */ return PJ_SUCCESS; } @@ -381,18 +378,19 @@ static pj_status_t spx_default_attr (pjmedia_codec_factory *factory, pj_memset(attr, 0, sizeof(pjmedia_codec_param)); attr->pt = id->pt; + attr->channel_cnt = 1; - if (id->sample_rate <= 8000) { - attr->sample_rate = spx_factory.speex_param[PARAM_NB].clock_rate; + if (id->clock_rate <= 8000) { + attr->clock_rate = spx_factory.speex_param[PARAM_NB].clock_rate; attr->avg_bps = spx_factory.speex_param[PARAM_NB].bitrate; - } else if (id->sample_rate <= 16000) { - attr->sample_rate = spx_factory.speex_param[PARAM_WB].clock_rate; + } else if (id->clock_rate <= 16000) { + attr->clock_rate = spx_factory.speex_param[PARAM_WB].clock_rate; attr->avg_bps = spx_factory.speex_param[PARAM_WB].bitrate; } else { /* Wow.. somebody is doing ultra-wideband. Cool...! */ - attr->sample_rate = spx_factory.speex_param[PARAM_UWB].clock_rate; + attr->clock_rate = spx_factory.speex_param[PARAM_UWB].clock_rate; attr->avg_bps = spx_factory.speex_param[PARAM_UWB].bitrate; } @@ -401,14 +399,14 @@ static pj_status_t spx_default_attr (pjmedia_codec_factory *factory, attr->pt = id->pt; /* Default flags. */ - attr->cng_enabled = 1; - attr->concl_enabled = 1; - attr->hpf_enabled = 1; - attr->lpf_enabled =1 ; - attr->penh_enabled =1 ; + attr->cng = 1; + attr->concl = 1; + attr->hpf = 1; + attr->lpf =1 ; + attr->penh =1 ; /* Default, set VAD off as it caused voice chip off */ - attr->vad_enabled = 0; + attr->vad = 0; return PJ_SUCCESS; } @@ -442,7 +440,8 @@ static pj_status_t spx_enum_codecs(pjmedia_codec_factory *factory, codecs[*count].encoding_name = pj_str("speex"); codecs[*count].pt = spx_factory.speex_param[i].pt; codecs[*count].type = PJMEDIA_TYPE_AUDIO; - codecs[*count].sample_rate = spx_factory.speex_param[i].clock_rate; + codecs[*count].clock_rate = spx_factory.speex_param[i].clock_rate; + codecs[*count].channel_cnt = 1; ++*count; } @@ -486,9 +485,9 @@ static pj_status_t spx_alloc_codec( pjmedia_codec_factory *factory, spx->enc = NULL; spx->dec = NULL; - if (id->sample_rate <= 8000) + if (id->clock_rate <= 8000) spx->param_id = PARAM_NB; - else if (id->sample_rate <= 16000) + else if (id->clock_rate <= 16000) spx->param_id = PARAM_WB; else spx->param_id = PARAM_UWB; @@ -522,25 +521,6 @@ static pj_status_t spx_dealloc_codec( pjmedia_codec_factory *factory, return PJ_SUCCESS; } -/* - * Get codec default attributes. - */ -static pj_status_t spx_codec_default_attr( pjmedia_codec *codec, - pjmedia_codec_param *attr) -{ - struct spx_private *spx; - pjmedia_codec_info info; - - spx = (struct spx_private*) codec->codec_data; - - info.encoding_name = pj_str("speex"); - info.pt = 200; /* Don't care */ - info.sample_rate = spx_factory.speex_param[spx->param_id].clock_rate; - info.type = PJMEDIA_TYPE_AUDIO; - - return spx_default_attr( codec->factory, &info, attr); -} - /* * Init codec. */ @@ -579,12 +559,12 @@ static pj_status_t spx_codec_open( pjmedia_codec *codec, } /* Sampling rate. */ - tmp = attr->sample_rate; + tmp = attr->clock_rate; speex_encoder_ctl(spx->enc, SPEEX_SET_SAMPLING_RATE, &spx_factory.speex_param[id].clock_rate); /* VAD */ - tmp = attr->vad_enabled; + tmp = attr->vad; speex_encoder_ctl(spx->enc, SPEEX_SET_VAD, &tmp); /* Complexity */ @@ -608,7 +588,7 @@ static pj_status_t spx_codec_open( pjmedia_codec *codec, &spx_factory.speex_param[id].clock_rate); /* PENH */ - tmp = attr->penh_enabled; + tmp = attr->penh; speex_decoder_ctl(spx->dec, SPEEX_SET_ENH, &tmp); return PJ_SUCCESS; -- cgit v1.2.3