diff options
Diffstat (limited to 'pjmedia/src/pjmedia-codec/g722.c')
| -rw-r--r-- | pjmedia/src/pjmedia-codec/g722.c | 714 |
1 files changed, 714 insertions, 0 deletions
diff --git a/pjmedia/src/pjmedia-codec/g722.c b/pjmedia/src/pjmedia-codec/g722.c new file mode 100644 index 0000000..7e0e4e4 --- /dev/null +++ b/pjmedia/src/pjmedia-codec/g722.c @@ -0,0 +1,714 @@ +/* $Id: g722.c 3664 2011-07-19 03:42:28Z nanang $ */ +/* + * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) + * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> + * + * 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 <pjmedia-codec/g722.h> +#include <pjmedia/codec.h> +#include <pjmedia/errno.h> +#include <pjmedia/endpoint.h> +#include <pjmedia/plc.h> +#include <pjmedia/port.h> +#include <pjmedia/silencedet.h> +#include <pj/assert.h> +#include <pj/log.h> +#include <pj/pool.h> +#include <pj/string.h> +#include <pj/os.h> + +#if defined(PJMEDIA_HAS_G722_CODEC) && (PJMEDIA_HAS_G722_CODEC != 0) + +#include "g722/g722_enc.h" +#include "g722/g722_dec.h" + +#define THIS_FILE "g722.c" + +/* Defines */ +#define PTIME (10) +#define SAMPLES_PER_FRAME (16000 * PTIME /1000) +#define FRAME_LEN (80) +#define PLC_DISABLED 0 + +/* Tracing */ +#ifndef PJ_TRACE +# define PJ_TRACE 0 +#endif + +#if PJ_TRACE +# define TRACE_(expr) PJ_LOG(4,expr) +#else +# define TRACE_(expr) +#endif + + +/* Prototypes for G722 factory */ +static pj_status_t g722_test_alloc(pjmedia_codec_factory *factory, + const pjmedia_codec_info *id ); +static pj_status_t g722_default_attr(pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec_param *attr ); +static pj_status_t g722_enum_codecs(pjmedia_codec_factory *factory, + unsigned *count, + pjmedia_codec_info codecs[]); +static pj_status_t g722_alloc_codec(pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec **p_codec); +static pj_status_t g722_dealloc_codec(pjmedia_codec_factory *factory, + pjmedia_codec *codec ); + +/* Prototypes for G722 implementation. */ +static pj_status_t g722_codec_init(pjmedia_codec *codec, + pj_pool_t *pool ); +static pj_status_t g722_codec_open(pjmedia_codec *codec, + pjmedia_codec_param *attr ); +static pj_status_t g722_codec_close(pjmedia_codec *codec ); +static pj_status_t g722_codec_modify(pjmedia_codec *codec, + const pjmedia_codec_param *attr ); +static pj_status_t g722_codec_parse(pjmedia_codec *codec, + void *pkt, + pj_size_t pkt_size, + const pj_timestamp *ts, + unsigned *frame_cnt, + pjmedia_frame frames[]); +static pj_status_t g722_codec_encode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output); +static pj_status_t g722_codec_decode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output); +#if !PLC_DISABLED +static pj_status_t g722_codec_recover(pjmedia_codec *codec, + unsigned output_buf_len, + struct pjmedia_frame *output); +#endif + +/* Definition for G722 codec operations. */ +static pjmedia_codec_op g722_op = +{ + &g722_codec_init, + &g722_codec_open, + &g722_codec_close, + &g722_codec_modify, + &g722_codec_parse, + &g722_codec_encode, + &g722_codec_decode, +#if !PLC_DISABLED + &g722_codec_recover +#else + NULL +#endif +}; + +/* Definition for G722 codec factory operations. */ +static pjmedia_codec_factory_op g722_factory_op = +{ + &g722_test_alloc, + &g722_default_attr, + &g722_enum_codecs, + &g722_alloc_codec, + &g722_dealloc_codec, + &pjmedia_codec_g722_deinit +}; + +/* G722 factory */ +static struct g722_codec_factory +{ + pjmedia_codec_factory base; + pjmedia_endpt *endpt; + pj_pool_t *pool; + pj_mutex_t *mutex; + pjmedia_codec codec_list; + unsigned pcm_shift; +} g722_codec_factory; + + +/* G722 codec private data. */ +struct g722_data +{ + g722_enc_t encoder; + g722_dec_t decoder; + unsigned pcm_shift; + pj_int16_t pcm_clip_mask; + pj_bool_t plc_enabled; + pj_bool_t vad_enabled; + pjmedia_silence_det *vad; + pj_timestamp last_tx; +#if !PLC_DISABLED + pjmedia_plc *plc; +#endif +}; + + + +/* + * 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; +} + +/* + * 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; +} + + +/* + * Set level adjustment. + */ +PJ_DEF(pj_status_t) pjmedia_codec_g722_set_pcm_shift(unsigned val) +{ + g722_codec_factory.pcm_shift = val; + return PJ_SUCCESS; +} + + +/* + * Check if factory can allocate the specified codec. + */ +static pj_status_t g722_test_alloc(pjmedia_codec_factory *factory, + const pjmedia_codec_info *info ) +{ + PJ_UNUSED_ARG(factory); + + /* Check payload type. */ + if (info->pt != PJMEDIA_RTP_PT_G722) + return PJMEDIA_CODEC_EUNSUP; + + /* Ignore the rest, since it's static payload type. */ + + return PJ_SUCCESS; +} + +/* + * Generate default attribute. + */ +static pj_status_t g722_default_attr( pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec_param *attr ) +{ + PJ_UNUSED_ARG(factory); + PJ_UNUSED_ARG(id); + + pj_bzero(attr, sizeof(pjmedia_codec_param)); + attr->info.clock_rate = 16000; + attr->info.channel_cnt = 1; + attr->info.avg_bps = 64000; + attr->info.max_bps = 64000; + attr->info.pcm_bits_per_sample = 16; + attr->info.frm_ptime = PTIME; + attr->info.pt = PJMEDIA_RTP_PT_G722; + + attr->setting.frm_per_pkt = 2; + attr->setting.vad = 1; + attr->setting.plc = 1; + + /* Default all other flag bits disabled. */ + + return PJ_SUCCESS; +} + +/* + * Enum codecs supported by this factory (i.e. only G722!). + */ +static pj_status_t g722_enum_codecs(pjmedia_codec_factory *factory, + unsigned *count, + pjmedia_codec_info codecs[]) +{ + PJ_UNUSED_ARG(factory); + PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL); + + pj_bzero(&codecs[0], sizeof(pjmedia_codec_info)); + codecs[0].encoding_name = pj_str("G722"); + codecs[0].pt = PJMEDIA_RTP_PT_G722; + codecs[0].type = PJMEDIA_TYPE_AUDIO; + codecs[0].clock_rate = 16000; + codecs[0].channel_cnt = 1; + + *count = 1; + + return PJ_SUCCESS; +} + +/* + * Allocate a new G722 codec instance. + */ +static pj_status_t g722_alloc_codec(pjmedia_codec_factory *factory, + const pjmedia_codec_info *id, + pjmedia_codec **p_codec) +{ + pjmedia_codec *codec; + struct g722_data *g722_data; + + PJ_ASSERT_RETURN(factory && id && p_codec, PJ_EINVAL); + PJ_ASSERT_RETURN(factory == &g722_codec_factory.base, PJ_EINVAL); + + pj_mutex_lock(g722_codec_factory.mutex); + + /* Get free nodes, if any. */ + if (!pj_list_empty(&g722_codec_factory.codec_list)) { + codec = g722_codec_factory.codec_list.next; + pj_list_erase(codec); + } else { + pj_status_t status; + + codec = PJ_POOL_ZALLOC_T(g722_codec_factory.pool, pjmedia_codec); + PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM); + codec->op = &g722_op; + codec->factory = factory; + + g722_data = PJ_POOL_ZALLOC_T(g722_codec_factory.pool, struct g722_data); + codec->codec_data = g722_data; + +#if !PLC_DISABLED + /* Create PLC */ + status = pjmedia_plc_create(g722_codec_factory.pool, 16000, + SAMPLES_PER_FRAME, 0, &g722_data->plc); + if (status != PJ_SUCCESS) { + pj_mutex_unlock(g722_codec_factory.mutex); + return status; + } +#endif + + /* Create silence detector */ + status = pjmedia_silence_det_create(g722_codec_factory.pool, + 16000, SAMPLES_PER_FRAME, + &g722_data->vad); + if (status != PJ_SUCCESS) { + pj_mutex_unlock(g722_codec_factory.mutex); + TRACE_((THIS_FILE, "Create silence detector failed (status = %d)", + status)); + return status; + } + } + + + pj_mutex_unlock(g722_codec_factory.mutex); + + *p_codec = codec; + return PJ_SUCCESS; +} + +/* + * Free codec. + */ +static pj_status_t g722_dealloc_codec(pjmedia_codec_factory *factory, + pjmedia_codec *codec ) +{ + struct g722_data *g722_data; + int i; + + PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL); + PJ_ASSERT_RETURN(factory == &g722_codec_factory.base, PJ_EINVAL); + + g722_data = (struct g722_data*) codec->codec_data; + + /* Close codec, if it's not closed. */ + g722_codec_close(codec); + +#if !PLC_DISABLED + /* Clear left samples in the PLC, since codec+plc will be reused + * next time. + */ + for (i=0; i<2; ++i) { + pj_int16_t frame[SAMPLES_PER_FRAME]; + pjmedia_zero_samples(frame, PJ_ARRAY_SIZE(frame)); + pjmedia_plc_save(g722_data->plc, frame); + } +#else + PJ_UNUSED_ARG(i); +#endif + + /* Re-init silence_period */ + pj_set_timestamp32(&g722_data->last_tx, 0, 0); + + /* Put in the free list. */ + pj_mutex_lock(g722_codec_factory.mutex); + pj_list_push_front(&g722_codec_factory.codec_list, codec); + pj_mutex_unlock(g722_codec_factory.mutex); + + return PJ_SUCCESS; +} + +/* + * Init codec. + */ +static pj_status_t g722_codec_init(pjmedia_codec *codec, + pj_pool_t *pool ) +{ + PJ_UNUSED_ARG(codec); + PJ_UNUSED_ARG(pool); + return PJ_SUCCESS; +} + +/* + * Open codec. + */ +static pj_status_t g722_codec_open(pjmedia_codec *codec, + pjmedia_codec_param *attr ) +{ + struct g722_data *g722_data = (struct g722_data*) codec->codec_data; + pj_status_t status; + + PJ_ASSERT_RETURN(codec && attr, PJ_EINVAL); + PJ_ASSERT_RETURN(g722_data != NULL, PJ_EINVALIDOP); + + status = g722_enc_init(&g722_data->encoder); + if (status != PJ_SUCCESS) { + TRACE_((THIS_FILE, "g722_enc_init() failed, status=%d", status)); + pj_mutex_unlock(g722_codec_factory.mutex); + return PJMEDIA_CODEC_EFAILED; + } + + status = g722_dec_init(&g722_data->decoder); + if (status != PJ_SUCCESS) { + TRACE_((THIS_FILE, "g722_dec_init() failed, status=%d", status)); + pj_mutex_unlock(g722_codec_factory.mutex); + return PJMEDIA_CODEC_EFAILED; + } + + g722_data->vad_enabled = (attr->setting.vad != 0); + g722_data->plc_enabled = (attr->setting.plc != 0); + g722_data->pcm_shift = g722_codec_factory.pcm_shift; + g722_data->pcm_clip_mask = (pj_int16_t)(1<<g722_codec_factory.pcm_shift)-1; + g722_data->pcm_clip_mask <<= (16-g722_codec_factory.pcm_shift); + + TRACE_((THIS_FILE, "G722 codec opened: vad=%d, plc=%d", + g722_data->vad_enabled, g722_data->plc_enabled)); + return PJ_SUCCESS; +} + +/* + * Close codec. + */ +static pj_status_t g722_codec_close( pjmedia_codec *codec ) +{ + /* The codec, encoder, and decoder will be reused, so there's + * nothing to do here + */ + + PJ_UNUSED_ARG(codec); + + TRACE_((THIS_FILE, "G722 codec closed")); + return PJ_SUCCESS; +} + + +/* + * Modify codec settings. + */ +static pj_status_t g722_codec_modify(pjmedia_codec *codec, + const pjmedia_codec_param *attr ) +{ + struct g722_data *g722_data = (struct g722_data*) codec->codec_data; + + pj_assert(g722_data != NULL); + + g722_data->vad_enabled = (attr->setting.vad != 0); + g722_data->plc_enabled = (attr->setting.plc != 0); + + TRACE_((THIS_FILE, "G722 codec modified: vad=%d, plc=%d", + g722_data->vad_enabled, g722_data->plc_enabled)); + return PJ_SUCCESS; +} + + +/* + * Get frames in the packet. + */ +static pj_status_t g722_codec_parse(pjmedia_codec *codec, + void *pkt, + pj_size_t pkt_size, + const pj_timestamp *ts, + unsigned *frame_cnt, + pjmedia_frame frames[]) +{ + unsigned count = 0; + + PJ_UNUSED_ARG(codec); + + PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL); + + TRACE_((THIS_FILE, "G722 parse(): input len=%d", pkt_size)); + + while (pkt_size >= FRAME_LEN && count < *frame_cnt) { + frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO; + frames[count].buf = pkt; + frames[count].size = FRAME_LEN; + frames[count].timestamp.u64 = ts->u64 + count * SAMPLES_PER_FRAME; + + pkt = ((char*)pkt) + FRAME_LEN; + pkt_size -= FRAME_LEN; + + ++count; + } + + TRACE_((THIS_FILE, "G722 parse(): got %d frames", count)); + + *frame_cnt = count; + return PJ_SUCCESS; +} + +/* + * Encode frame. + */ +static pj_status_t g722_codec_encode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output) +{ + struct g722_data *g722_data = (struct g722_data*) codec->codec_data; + pj_status_t status; + + pj_assert(g722_data && input && output); + + PJ_ASSERT_RETURN((input->size >> 2) <= output_buf_len, + PJMEDIA_CODEC_EFRMTOOSHORT); + + /* Detect silence */ + if (g722_data->vad_enabled) { + pj_bool_t is_silence; + pj_int32_t silence_duration; + + silence_duration = pj_timestamp_diff32(&g722_data->last_tx, + &input->timestamp); + + is_silence = pjmedia_silence_det_detect(g722_data->vad, + (const pj_int16_t*) input->buf, + (input->size >> 1), + NULL); + if (is_silence && + (PJMEDIA_CODEC_MAX_SILENCE_PERIOD == -1 || + silence_duration < PJMEDIA_CODEC_MAX_SILENCE_PERIOD*16000/1000)) + { + output->type = PJMEDIA_FRAME_TYPE_NONE; + output->buf = NULL; + output->size = 0; + output->timestamp = input->timestamp; + return PJ_SUCCESS; + } else { + g722_data->last_tx = input->timestamp; + } + } + + /* Adjust input signal level from 16-bit to 14-bit */ + if (g722_data->pcm_shift) { + pj_int16_t *p, *end; + + p = (pj_int16_t*)input->buf; + end = p + input->size/2; + while (p < end) { + *p++ >>= g722_data->pcm_shift; + } + } + + /* Encode to temporary buffer */ + output->size = output_buf_len; + status = g722_enc_encode(&g722_data->encoder, (pj_int16_t*)input->buf, + (input->size >> 1), output->buf, &output->size); + if (status != PJ_SUCCESS) { + output->size = 0; + output->buf = NULL; + output->type = PJMEDIA_FRAME_TYPE_NONE; + TRACE_((THIS_FILE, "G722 encode() status: %d", status)); + return PJMEDIA_CODEC_EFAILED; + } + + output->type = PJMEDIA_FRAME_TYPE_AUDIO; + output->timestamp = input->timestamp; + + TRACE_((THIS_FILE, "G722 encode(): size=%d", output->size)); + return PJ_SUCCESS; +} + +/* + * Decode frame. + */ +static pj_status_t g722_codec_decode(pjmedia_codec *codec, + const struct pjmedia_frame *input, + unsigned output_buf_len, + struct pjmedia_frame *output) +{ + struct g722_data *g722_data = (struct g722_data*) codec->codec_data; + pj_status_t status; + + pj_assert(g722_data != NULL); + PJ_ASSERT_RETURN(input && output, PJ_EINVAL); + + TRACE_((THIS_FILE, "G722 decode(): inbuf=%p, insize=%d, outbuf=%p," + "outsize=%d", + input->buf, input->size, output->buf, output_buf_len)); + + if (output_buf_len < SAMPLES_PER_FRAME * 2) { + TRACE_((THIS_FILE, "G722 decode() ERROR: PJMEDIA_CODEC_EPCMTOOSHORT")); + return PJMEDIA_CODEC_EPCMTOOSHORT; + } + + if (input->size != FRAME_LEN) { + TRACE_((THIS_FILE, "G722 decode() ERROR: PJMEDIA_CODEC_EFRMTOOSHORT")); + return PJMEDIA_CODEC_EFRMTOOSHORT; + } + + + /* Decode */ + output->size = SAMPLES_PER_FRAME; + status = g722_dec_decode(&g722_data->decoder, input->buf, input->size, + (pj_int16_t*)output->buf, &output->size); + if (status != PJ_SUCCESS) { + TRACE_((THIS_FILE, "G722 decode() status: %d", status)); + return PJMEDIA_CODEC_EFAILED; + } + + pj_assert(output->size == SAMPLES_PER_FRAME); + + /* Adjust input signal level from 14-bit to 16-bit */ + if (g722_data->pcm_shift) { + pj_int16_t *p, *end; + + p = (pj_int16_t*)output->buf; + end = p + output->size; + while (p < end) { +#if PJMEDIA_G722_STOP_PCM_SHIFT_ON_CLIPPING + /* If there is clipping, stop the PCM shifting */ + if (*p & g722_data->pcm_clip_mask) { + g722_data->pcm_shift = 0; + break; + } +#endif + *p++ <<= g722_data->pcm_shift; + } + } + + output->size = SAMPLES_PER_FRAME * 2; + output->type = PJMEDIA_FRAME_TYPE_AUDIO; + output->timestamp = input->timestamp; + +#if !PLC_DISABLED + if (g722_data->plc_enabled) + pjmedia_plc_save(g722_data->plc, (pj_int16_t*)output->buf); +#endif + + TRACE_((THIS_FILE, "G722 decode done")); + return PJ_SUCCESS; +} + + +#if !PLC_DISABLED +/* + * Recover lost frame. + */ +static pj_status_t g722_codec_recover(pjmedia_codec *codec, + unsigned output_buf_len, + struct pjmedia_frame *output) +{ + struct g722_data *g722_data = (struct g722_data*)codec->codec_data; + + PJ_ASSERT_RETURN(g722_data->plc_enabled, PJ_EINVALIDOP); + + PJ_ASSERT_RETURN(output_buf_len >= SAMPLES_PER_FRAME * 2, + PJMEDIA_CODEC_EPCMTOOSHORT); + + pjmedia_plc_generate(g722_data->plc, (pj_int16_t*)output->buf); + + output->size = SAMPLES_PER_FRAME * 2; + output->type = PJMEDIA_FRAME_TYPE_AUDIO; + + return PJ_SUCCESS; +} +#endif + +#endif // PJMEDIA_HAS_G722_CODEC + |