kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-11-19 00:00:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

merge rizzo's codec module rework (very similar to the format module rework)

Browse Source 
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@18541 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Kevin P. Fleming
2006-04-08 21:40:57 +00:00
parent 1481e53ba8
commit 1bba6ec6fc
12 changed files with 1509 additions and 2659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
codecs/codec_a_mu.c
View File

@@ -43,12 +43,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/ulaw.h"
#include "asterisk/utils.h"
#define BUFFER_SIZE 8096 /* size for the translation buffers */
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt = 0;
static char *tdesc = "A-law and Mulaw direct Coder/Decoder";
#define BUFFER_SAMPLES 8000 /* size for the translation buffers */
static unsigned char mu2a[256];
static unsigned char a2mu[256];
@@ -57,146 +52,37 @@ static unsigned char a2mu[256];
#include "ulaw_slin_ex.h"
/*
* Private workspace for translating signed linear signals to alaw.
*/
struct alaw_encoder_pvt
/*! \brief convert frame data and store into the buffer */
static int alawtoulaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
unsigned char outbuf[BUFFER_SIZE]; /* Encoded alaw, two nibbles to a word */
int tail;
};
/*
* Private workspace for translating laws.
*/
struct ulaw_encoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
unsigned char outbuf[BUFFER_SIZE]; /* Encoded ulaw values */
int tail;
};
static struct ast_translator_pvt *alawtoulaw_new(void)
{
struct ulaw_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
tmp->tail = 0;
localusecnt++;
ast_update_use_count();
}
return (struct ast_translator_pvt *)tmp;
}
static struct ast_translator_pvt *ulawtoalaw_new(void)
{
struct alaw_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
localusecnt++;
ast_update_use_count();
tmp->tail = 0;
}
return (struct ast_translator_pvt *)tmp;
}
static int alawtoulaw_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct ulaw_encoder_pvt *tmp = (struct ulaw_encoder_pvt *)pvt;
int x;
unsigned char *b;
unsigned char *src = f->data;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
if ((tmp->tail + f->datalen) > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
/* Reset ssindex and signal to frame's specified values */
b = f->data;
for (x=0;x<f->datalen;x++)
tmp->outbuf[tmp->tail + x] = a2mu[b[x]];
tmp->tail += f->datalen;
for ( x = 0 ; x < f->samples; x++)
dst[x] = a2mu[src[x]];
pvt->samples += f->samples;
pvt->datalen += f->datalen;
return 0;
}
static struct ast_frame *alawtoulaw_frameout(struct ast_translator_pvt *pvt)
/*! \brief convert frame data and store into the buffer */
static int ulawtoalaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ulaw_encoder_pvt *tmp = (struct ulaw_encoder_pvt *)pvt;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ULAW;
tmp->f.datalen = tmp->tail;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->tail = 0;
return &tmp->f;
}
static int ulawtoalaw_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct alaw_encoder_pvt *tmp = (struct alaw_encoder_pvt *)pvt;
int x;
unsigned char *s;
if (tmp->tail + f->datalen >= sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
s = f->data;
for (x=0;x<f->datalen;x++)
tmp->outbuf[x+tmp->tail] = mu2a[s[x]];
tmp->tail += f->datalen;
unsigned char *src = f->data;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
for ( x = 0 ; x < f->samples; x++)
dst[x] = mu2a[src[x]];
pvt->samples += f->samples;
pvt->datalen += f->datalen;
return 0;
}
/*
* LinToalaw_FrameOut
* Convert a buffer of raw 16-bit signed linear PCM to a buffer
* of 4-bit alaw packed two to a byte (Big Endian).
*
* Results:
* Foo
*
* Side effects:
* Leftover inbuf data gets packed, tail gets updated.
* alawToLin_Sample. Just random data, somehow...
*/
static struct ast_frame *ulawtoalaw_frameout(struct ast_translator_pvt *pvt)
{
struct alaw_encoder_pvt *tmp = (struct alaw_encoder_pvt *)pvt;
if (tmp->tail) {
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ALAW;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->f.datalen = tmp->tail;
tmp->tail = 0;
return &tmp->f;
} else
return NULL;
}
/*
* alawToLin_Sample
*/
static struct ast_frame *alawtoulaw_sample(void)
{
static struct ast_frame f;
@@ -207,7 +93,7 @@ static struct ast_frame *alawtoulaw_sample(void)
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.data = ulaw_slin_ex;
f.data = ulaw_slin_ex; /* XXX what ? */
return &f;
}
@@ -225,66 +111,41 @@ static struct ast_frame *ulawtoalaw_sample(void)
return &f;
}
/*
* alaw_Destroy
* Destroys a private workspace.
*
* Results:
* It's gone!
*
* Side effects:
* None.
*/
static void alaw_destroy(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
ast_update_use_count();
}
/*
* The complete translator for alawToLin.
*/
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator alawtoulaw = {
"alawtoulaw",
AST_FORMAT_ALAW,
AST_FORMAT_ULAW,
alawtoulaw_new,
alawtoulaw_framein,
alawtoulaw_frameout,
alaw_destroy,
/* NULL */
alawtoulaw_sample
.name = "alawtoulaw",
.srcfmt = AST_FORMAT_ALAW,
.dstfmt = AST_FORMAT_ULAW,
.framein = alawtoulaw_framein,
.sample = alawtoulaw_sample,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES,
.lockp = &me,
};
/*
* The complete translator for LinToalaw.
*/
static struct ast_translator ulawtoalaw = {
"ulawtoalaw",
AST_FORMAT_ULAW,
AST_FORMAT_ALAW,
ulawtoalaw_new,
ulawtoalaw_framein,
ulawtoalaw_frameout,
alaw_destroy,
/* NULL */
ulawtoalaw_sample
.name = "ulawtoalaw",
.srcfmt = AST_FORMAT_ULAW,
.dstfmt = AST_FORMAT_ALAW,
.framein = ulawtoalaw_framein,
.sample = ulawtoalaw_sample,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES,
.lockp = &me,
};
/*! \brief standard module glue */
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&ulawtoalaw);
if (!res)
res = ast_unregister_translator(&alawtoulaw);
if (localusecnt)
res |= ast_unregister_translator(&alawtoulaw);
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -304,20 +165,14 @@ int load_module(void)
return res;
}
/*
* Return a description of this module.
*/
char *description(void)
{
return tdesc;
return "A-law and Mulaw direct Coder/Decoder";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

367
codecs/codec_adpcm.c
View File

@@ -40,6 +40,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/lock.h"
#include "asterisk/logger.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/options.h"
@@ -50,14 +51,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
/* define NOT_BLI to use a faster but not bit-level identical version */
/* #define NOT_BLI */
#define BUFFER_SIZE 8096 /* size for the translation buffers */
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt = 0;
static char *tdesc = "Adaptive Differential PCM Coder/Decoder";
static int useplc = 0;
#define BUFFER_SAMPLES 8096 /* size for the translation buffers */
/* Sample frame data */
@@ -227,250 +221,81 @@ static inline int adpcm(short csig, struct adpcm_state *state)
return encoded;
}
/*
* Private workspace for translating signed linear signals to ADPCM.
*/
/*----------------- Asterisk-codec glue ------------*/
struct adpcm_encoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
short inbuf[BUFFER_SIZE]; /* Unencoded signed linear values */
unsigned char outbuf[BUFFER_SIZE]; /* Encoded ADPCM, two nibbles to a word */
/*! \brief Workspace for translating signed linear signals to ADPCM. */
struct adpcm_encoder_pvt {
struct adpcm_state state;
int tail;
int16_t inbuf[BUFFER_SAMPLES]; /* Unencoded signed linear values */
};
/*
* Private workspace for translating ADPCM signals to signed linear.
*/
struct adpcm_decoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
short outbuf[BUFFER_SIZE]; /* Decoded signed linear values */
/*! \brief Workspace for translating ADPCM signals to signed linear. */
struct adpcm_decoder_pvt {
struct adpcm_state state;
int tail;
plc_state_t plc;
};
/*
* AdpcmToLin_New
* Create a new instance of adpcm_decoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *adpcmtolin_new(void)
/*! \brief decode 4-bit adpcm frame data and store in output buffer */
static int adpcmtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct adpcm_decoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
tmp->tail = 0;
plc_init(&tmp->plc);
localusecnt++;
ast_update_use_count();
}
return (struct ast_translator_pvt *)tmp;
}
/*
* LinToAdpcm_New
* Create a new instance of adpcm_encoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *lintoadpcm_new(void)
{
struct adpcm_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
localusecnt++;
ast_update_use_count();
tmp->tail = 0;
}
return (struct ast_translator_pvt *)tmp;
}
/*
* AdpcmToLin_FrameIn
* Take an input buffer with packed 4-bit ADPCM values and put decoded PCM in outbuf,
* if there is room left.
*
* Results:
* Foo
*
* Side effects:
* tmp->tail is the number of packed values in the buffer.
*/
static int adpcmtolin_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct adpcm_decoder_pvt *tmp = (struct adpcm_decoder_pvt *)pvt;
struct adpcm_decoder_pvt *tmp = pvt->pvt;
int x;
unsigned char *b;
unsigned char *src = f->data;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
if((tmp->tail + 160) > sizeof(tmp->outbuf) / 2) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->outbuf+tmp->tail, 160);
tmp->tail += 160;
}
return 0;
for (x=0; x < f->datalen; x++) {
*dst++ = decode((src[x] >> 4) & 0xf, &tmp->state);
*dst++ = decode(src[x] & 0x0f, &tmp->state);
}
if (f->datalen * 4 + tmp->tail * 2 > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
b = f->data;
for (x=0;x<f->datalen;x++) {
tmp->outbuf[tmp->tail++] = decode((b[x] >> 4) & 0xf, &tmp->state);
tmp->outbuf[tmp->tail++] = decode(b[x] & 0x0f, &tmp->state);
}
if(useplc)
plc_rx(&tmp->plc, tmp->outbuf+tmp->tail-f->datalen*2, f->datalen*2);
pvt->samples += f->samples;
pvt->datalen += 2*f->samples;
return 0;
}
/*
* AdpcmToLin_FrameOut
* Convert 4-bit ADPCM encoded signals to 16-bit signed linear.
*
* Results:
* Converted signals are placed in tmp->f.data, tmp->f.datalen
* and tmp->f.samples are calculated.
*
* Side effects:
* None.
*/
static struct ast_frame *adpcmtolin_frameout(struct ast_translator_pvt *pvt)
/*! \brief fill input buffer with 16-bit signed linear PCM values. */
static int lintoadpcm_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct adpcm_decoder_pvt *tmp = (struct adpcm_decoder_pvt *)pvt;
struct adpcm_encoder_pvt *tmp = pvt->pvt;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->tail = 0;
return &tmp->f;
}
/*
* LinToAdpcm_FrameIn
* Fill an input buffer with 16-bit signed linear PCM values.
*
* Results:
* None.
*
* Side effects:
* tmp->tail is number of signal values in the input buffer.
*/
static int lintoadpcm_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct adpcm_encoder_pvt *tmp = (struct adpcm_encoder_pvt *)pvt;
if ((tmp->tail + f->datalen / 2) < (sizeof(tmp->inbuf) / 2)) {
memcpy(&tmp->inbuf[tmp->tail], f->data, f->datalen);
tmp->tail += f->datalen / 2;
} else {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(&tmp->inbuf[pvt->samples], f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
/*
* LinToAdpcm_FrameOut
* Convert a buffer of raw 16-bit signed linear PCM to a buffer
* of 4-bit ADPCM packed two to a byte (Big Endian).
*
* Results:
* Foo
*
* Side effects:
* Leftover inbuf data gets packed, tail gets updated.
*/
static struct ast_frame *lintoadpcm_frameout(struct ast_translator_pvt *pvt)
/*! \brief convert inbuf and store into frame */
static struct ast_frame *lintoadpcm_frameout(struct ast_trans_pvt *pvt)
{
struct adpcm_encoder_pvt *tmp = (struct adpcm_encoder_pvt *)pvt;
int i_max, i;
struct adpcm_encoder_pvt *tmp = pvt->pvt;
struct ast_frame *f;
int i;
int samples = pvt->samples; /* save original number */
if (tmp->tail < 2)
if (samples < 2)
return NULL;
i_max = tmp->tail & ~1; /* atomic size is 2 samples */
pvt->samples &= ~1; /* atomic size is 2 samples */
/* What is this, state debugging? should be #ifdef'd then
tmp->outbuf[0] = tmp->ssindex & 0xff;
tmp->outbuf[1] = (tmp->signal >> 8) & 0xff;
tmp->outbuf[2] = (tmp->signal & 0xff);
tmp->outbuf[3] = tmp->zero_count;
tmp->outbuf[4] = tmp->next_flag;
*/
for (i = 0; i < i_max; i+=2) {
tmp->outbuf[i/2] =
for (i = 0; i < pvt->samples; i += 2) {
pvt->outbuf[i/2] =
(adpcm(tmp->inbuf[i ], &tmp->state) << 4) |
(adpcm(tmp->inbuf[i+1], &tmp->state) );
};
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ADPCM;
tmp->f.samples = i_max;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->f.datalen = i_max / 2;
f = ast_trans_frameout(pvt, pvt->samples/2, 0);
/*
* If there is a signal left over (there should be no more than
* one) move it to the beginning of the input buffer.
* If there is a left over sample, move it to the beginning
* of the input buffer.
*/
if (tmp->tail == i_max)
tmp->tail = 0;
else {
tmp->inbuf[0] = tmp->inbuf[tmp->tail];
tmp->tail = 1;
if (samples & 1) { /* move the leftover sample at beginning */
tmp->inbuf[0] = tmp->inbuf[samples - 1];
pvt->samples = 1;
}
return &tmp->f;
return f;
}
/*
* AdpcmToLin_Sample
*/
/*! \brief AdpcmToLin_Sample */
static struct ast_frame *adpcmtolin_sample(void)
{
static struct ast_frame f;
@@ -485,10 +310,7 @@ static struct ast_frame *adpcmtolin_sample(void)
return &f;
}
/*
* LinToAdpcm_Sample
*/
/*! \brief LinToAdpcm_Sample */
static struct ast_frame *lintoadpcm_sample(void)
{
static struct ast_frame f;
@@ -504,75 +326,51 @@ static struct ast_frame *lintoadpcm_sample(void)
return &f;
}
/*
* Adpcm_Destroy
* Destroys a private workspace.
*
* Results:
* It's gone!
*
* Side effects:
* None.
*/
static void adpcm_destroy(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
ast_update_use_count();
}
/*
* The complete translator for ADPCMToLin.
*/
struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator adpcmtolin = {
"adpcmtolin",
AST_FORMAT_ADPCM,
AST_FORMAT_SLINEAR,
adpcmtolin_new,
adpcmtolin_framein,
adpcmtolin_frameout,
adpcm_destroy,
/* NULL */
adpcmtolin_sample
.name = "adpcmtolin",
.srcfmt = AST_FORMAT_ADPCM,
.dstfmt = AST_FORMAT_SLINEAR,
.framein = adpcmtolin_framein,
.sample = adpcmtolin_sample,
.desc_size = sizeof(struct adpcm_decoder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.plc_samples = 160,
.lockp = &me,
};
/*
* The complete translator for LinToADPCM.
*/
static struct ast_translator lintoadpcm = {
"lintoadpcm",
AST_FORMAT_SLINEAR,
AST_FORMAT_ADPCM,
lintoadpcm_new,
lintoadpcm_framein,
lintoadpcm_frameout,
adpcm_destroy,
/* NULL */
lintoadpcm_sample
.name = "lintoadpcm",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_ADPCM,
.framein = lintoadpcm_framein,
.frameout = lintoadpcm_frameout,
.sample = lintoadpcm_sample,
.desc_size = sizeof (struct adpcm_encoder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES/ 2, /* 2 samples per byte */
.lockp = &me,
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_config *cfg = ast_config_load("codecs.conf");
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_adpcm: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
if (cfg == NULL)
return;
for (var = ast_variable_browse(cfg, "plc"); var ; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
adpcmtolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_adpcm: %susing generic PLC\n", adpcmtolin.useplc ? "" : "not ");
}
ast_config_destroy(cfg);
}
ast_config_destroy(cfg);
}
/*! \brief standard module glue */
int reload(void)
{
parse_config();
@@ -582,13 +380,12 @@ int reload(void)
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintoadpcm);
if (!res)
res = ast_unregister_translator(&adpcmtolin);
if (localusecnt)
res |= ast_unregister_translator(&adpcmtolin);
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -604,20 +401,14 @@ int load_module(void)
return res;
}
/*
* Return a description of this module.
*/
char *description(void)
{
return tdesc;
return "Adaptive Differential PCM Coder/Decoder";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

338
codecs/codec_alaw.c
View File

@@ -44,232 +44,42 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/alaw.h"
#include "asterisk/utils.h"
#define BUFFER_SIZE 8096 /* size for the translation buffers */
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt = 0;
static char *tdesc = "A-law Coder/Decoder";
static int useplc = 0;
#define BUFFER_SAMPLES 8096 /* size for the translation buffers */
/* Sample frame data (Mu data is okay) */
#include "slin_ulaw_ex.h"
#include "ulaw_slin_ex.h"
/*!
* \brief Private workspace for translating signed linear signals to alaw.
*/
struct alaw_encoder_pvt
/*! \brief decode frame into lin and fill output buffer. */
static int alawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /*!< Space to build offset */
unsigned char outbuf[BUFFER_SIZE]; /*!< Encoded alaw, two nibbles to a word */
int tail;
};
int i;
unsigned char *src = f->data;
int16_t *dst = (int16_t *)pvt->outbuf;
/*!
* \brief Private workspace for translating alaw signals to signed linear.
*/
struct alaw_decoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
short outbuf[BUFFER_SIZE]; /* Decoded signed linear values */
int tail;
plc_state_t plc;
};
/*!
* \brief alawToLin_New
* Create a new instance of alaw_decoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *alawtolin_new(void)
{
struct alaw_decoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
tmp->tail = 0;
plc_init(&tmp->plc);
localusecnt++;
ast_update_use_count();
}
return (struct ast_translator_pvt *)tmp;
}
/*!
* \brief LinToalaw_New
* Create a new instance of alaw_encoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *lintoalaw_new(void)
{
struct alaw_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
localusecnt++;
ast_update_use_count();
tmp->tail = 0;
}
return (struct ast_translator_pvt *)tmp;
}
/*!
* \brief alawToLin_FrameIn
* Fill an input buffer with packed 4-bit alaw values if there is room
* left.
*
* Results:
* Foo
*
* Side effects:
* tmp->tail is the number of packed values in the buffer.
*/
static int alawtolin_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct alaw_decoder_pvt *tmp = (struct alaw_decoder_pvt *)pvt;
int x;
unsigned char *b;
if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
if((tmp->tail + 160) * 2 > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->outbuf+tmp->tail, 160);
tmp->tail += 160;
}
return 0;
}
if ((tmp->tail + f->datalen) * 2 > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
/* Reset ssindex and signal to frame's specified values */
b = f->data;
for (x=0;x<f->datalen;x++)
tmp->outbuf[tmp->tail + x] = AST_ALAW(b[x]);
if(useplc)
plc_rx(&tmp->plc, tmp->outbuf+tmp->tail, f->datalen);
tmp->tail += f->datalen;
for ( i = 0; i < f->samples; i++)
dst[pvt->samples + i] = AST_ALAW(src[i]);
pvt->samples += f->samples;
pvt->datalen += 2*f->samples; /* 2 bytes/sample */
return 0;
}
/*!
* \brief alawToLin_FrameOut
* Convert 4-bit alaw encoded signals to 16-bit signed linear.
*
* Results:
* Converted signals are placed in tmp->f.data, tmp->f.datalen
* and tmp->f.samples are calculated.
*
* Side effects:
* None.
*/
static struct ast_frame *alawtolin_frameout(struct ast_translator_pvt *pvt)
/*! \brief convert and store input samples in output buffer */
static int lintoalaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct alaw_decoder_pvt *tmp = (struct alaw_decoder_pvt *)pvt;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->tail = 0;
return &tmp->f;
}
/*!
* \brief LinToalaw_FrameIn
* Fill an input buffer with 16-bit signed linear PCM values.
*
* Results:
* None.
*
* Side effects:
* tmp->tail is number of signal values in the input buffer.
*/
static int lintoalaw_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct alaw_encoder_pvt *tmp = (struct alaw_encoder_pvt *)pvt;
int x;
short *s;
if (tmp->tail + f->datalen / 2 >= sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
s = f->data;
for (x=0;x<f->datalen/2;x++)
tmp->outbuf[x+tmp->tail] = AST_LIN2A(s[x]);
tmp->tail += f->datalen/2;
char *dst = pvt->outbuf + pvt->samples;
int16_t *src = f->data;
for ( x = 0; x < f->samples; x++)
*dst++ = AST_LIN2A(src[x]);
pvt->samples += f->samples;
pvt->datalen += f->samples; /* 1 byte/sample */
return 0;
}
/*!
* \brief LinToalaw_FrameOut
* Convert a buffer of raw 16-bit signed linear PCM to a buffer
* of 4-bit alaw packed two to a byte (Big Endian).
*
* Results:
* Foo
*
* Side effects:
* Leftover inbuf data gets packed, tail gets updated.
*/
static struct ast_frame *lintoalaw_frameout(struct ast_translator_pvt *pvt)
{
struct alaw_encoder_pvt *tmp = (struct alaw_encoder_pvt *)pvt;
if (tmp->tail) {
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ALAW;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->f.datalen = tmp->tail;
tmp->tail = 0;
return &tmp->f;
} else
return NULL;
}
/*!
* \brief alawToLin_Sample
*/
/*! \brief alawToLin_Sample */
static struct ast_frame *alawtolin_sample(void)
{
static struct ast_frame f;
@@ -284,17 +94,13 @@ static struct ast_frame *alawtolin_sample(void)
return &f;
}
/*!
* \brief LinToalaw_Sample
*/
/*! \brief LinToalaw_Sample */
static struct ast_frame *lintoalaw_sample(void)
{
static struct ast_frame f;
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_SLINEAR;
f.datalen = sizeof(slin_ulaw_ex);
/* Assume 8000 Hz */
f.samples = sizeof(slin_ulaw_ex) / 2;
f.mallocd = 0;
f.offset = 0;
@@ -303,76 +109,49 @@ static struct ast_frame *lintoalaw_sample(void)
return &f;
}
/*!
* \brief alaw_Destroy
* Destroys a private workspace.
*
* Results:
* It's gone!
*
* Side effects:
* None.
*/
static void alaw_destroy(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
ast_update_use_count();
}
/*!
* \brief The complete translator for alawToLin.
*/
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator alawtolin = {
"alawtolin",
AST_FORMAT_ALAW,
AST_FORMAT_SLINEAR,
alawtolin_new,
alawtolin_framein,
alawtolin_frameout,
alaw_destroy,
/* NULL */
alawtolin_sample
.name = "alawtolin",
.srcfmt = AST_FORMAT_ALAW,
.dstfmt = AST_FORMAT_SLINEAR,
.framein = alawtolin_framein,
.sample = alawtolin_sample,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.plc_samples = 160,
.lockp = &me,
};
/*!
* \brief The complete translator for LinToalaw.
*/
static struct ast_translator lintoalaw = {
"lintoalaw",
AST_FORMAT_SLINEAR,
AST_FORMAT_ALAW,
lintoalaw_new,
lintoalaw_framein,
lintoalaw_frameout,
alaw_destroy,
/* NULL */
lintoalaw_sample
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_ALAW,
.framein = lintoalaw_framein,
.sample = lintoalaw_sample,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES,
.lockp = &me,
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_alaw: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
struct ast_config *cfg = ast_config_load("codecs.conf");
if (!cfg)
return;
for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
alawtolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_alaw: %susing generic PLC\n", alawtolin.useplc ? "" : "not ");
}
ast_config_destroy(cfg);
}
ast_config_destroy(cfg);
}
/*! \brief standard module stuff */
int reload(void)
{
parse_config();
@@ -382,13 +161,12 @@ int reload(void)
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintoalaw);
if (!res)
res = ast_unregister_translator(&alawtolin);
if (localusecnt)
res |= ast_unregister_translator(&alawtolin);
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -404,20 +182,14 @@ int load_module(void)
return res;
}
/*
* Return a description of this module.
*/
char *description(void)
{
return tdesc;
return "A-law Coder/Decoder";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

268
codecs/codec_g723_1.c
View File

@@ -74,14 +74,11 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "slin_g723_ex.h"
#include "g723_slin_ex.h"
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt=0;
#ifdef ANNEX_B
static char *tdesc = "Annex B (floating point) G.723.1/PCM16 Codec Translator";
#else
static char *tdesc = "Annex A (fixed point) G.723.1/PCM16 Codec Translator";
#endif
/* g723_1 has 240 samples per buffer.
* We want a buffer which is a multiple...
*/
#define G723_SAMPLES 240
#define BUFFER_SAMPLES 8160 /* 240 * 34 */
/* Globals */
Flag UsePf = True;
@@ -92,37 +89,20 @@ enum Crate WrkRate = Rate63;
struct g723_encoder_pvt {
struct cod_state cod;
struct ast_frame f;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
/* Buffer for our outgoing frame */
char outbuf[8000];
/* Enough to store a full second */
short buf[8000];
int tail;
int16_t buf[BUFFER_SAMPLES]; /* input buffer */
};
struct g723_decoder_pvt {
struct dec_state dec;
struct ast_frame f;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
/* Enough to store a full second */
short buf[8000];
int tail;
};
static struct ast_translator_pvt *g723tolin_new(void)
static struct ast_trans_pvt *g723tolin_new(struct ast *pvt)
{
struct g723_decoder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
Init_Decod(&tmp->dec);
Init_Dec_Cng(&tmp->dec);
tmp->tail = 0;
localusecnt++;
ast_update_use_count();
}
return (struct ast_translator_pvt *)tmp;
struct g723_decoder_pvt *tmp = pvt;
Init_Decod(&tmp->dec);
Init_Dec_Cng(&tmp->dec);
return tmp;
}
static struct ast_frame *lintog723_sample(void)
@@ -131,7 +111,6 @@ static struct ast_frame *lintog723_sample(void)
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_SLINEAR;
f.datalen = sizeof(slin_g723_ex);
/* Assume 8000 Hz */
f.samples = sizeof(slin_g723_ex)/2;
f.mallocd = 0;
f.offset = 0;
@@ -155,53 +134,16 @@ static struct ast_frame *g723tolin_sample(void)
return &f;
}
static struct ast_translator_pvt *lintog723_new(void)
static void *lintog723_new(void *pvt)
{
struct g723_encoder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
Init_Coder(&tmp->cod);
/* Init Comfort Noise Functions */
if( UseVx ) {
Init_Vad(&tmp->cod);
Init_Cod_Cng(&tmp->cod);
}
localusecnt++;
ast_update_use_count();
tmp->tail = 0;
struct g723_encoder_pvt *tmp = pvt;
Init_Coder(&tmp->cod);
/* Init Comfort Noise Functions */
if( UseVx ) {
Init_Vad(&tmp->cod);
Init_Cod_Cng(&tmp->cod);
}
return (struct ast_translator_pvt *)tmp;
}
static struct ast_frame *g723tolin_frameout(struct ast_translator_pvt *pvt)
{
struct g723_decoder_pvt *tmp = (struct g723_decoder_pvt *)pvt;
if (!tmp->tail)
return NULL;
/* Signed linear is no particular frame size, so just send whatever
we have in the buffer in one lump sum */
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
/* Assume 8000 Hz */
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->buf;
/* Reset tail pointer */
tmp->tail = 0;
#if 0
/* Save the frames */
{
static int fd2 = -1;
if (fd2 == -1) {
fd2 = open("g723.example", O_WRONLY | O_CREAT | O_TRUNC, 0644);
}
write(fd2, tmp->f.data, tmp->f.datalen);
}
#endif
return &tmp->f;
return tmp;
}
static int g723_len(unsigned char buf)
@@ -225,19 +167,22 @@ static int g723_len(unsigned char buf)
return -1;
}
static int g723tolin_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
static int g723tolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g723_decoder_pvt *tmp = (struct g723_decoder_pvt *)pvt;
struct g723_decoder_pvt *tmp = pvt->pvt;
int len = 0;
int res;
int16_t *dst = pvt->outbuf;
#ifdef ANNEX_B
FLOAT tmpdata[Frame];
int x;
#endif
unsigned char *src = f->data;
while(len < f->datalen) {
/* Assuming there's space left, decode into the current buffer at
the tail location */
res = g723_len(((unsigned char *)f->data + len)[0]);
res = g723_len(src[len]);
if (res < 0) {
ast_log(LOG_WARNING, "Invalid data\n");
return -1;
@@ -246,145 +191,127 @@ static int g723tolin_framein(struct ast_translator_pvt *pvt, struct ast_frame *f
ast_log(LOG_WARNING, "Measured length exceeds frame length\n");
return -1;
}
if (tmp->tail + Frame < sizeof(tmp->buf)/2) {
#ifdef ANNEX_B
Decod(&tmp->dec, tmpdata, f->data + len, 0);
for (x=0;x<Frame;x++)
(tmp->buf + tmp->tail)[x] = (short)(tmpdata[x]);
#else
Decod(&tmp->dec, tmp->buf + tmp->tail, f->data + len, 0);
#endif
tmp->tail+=Frame;
} else {
if (pvt->samples + Frame > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
#ifdef ANNEX_B
Decod(&tmp->dec, tmpdata, f->data + len, 0);
for (x=0;x<Frame;x++)
dst[pvt->samples + x] = (int16_t)(tmpdata[x]);
#else
Decod(&tmp->dec, dst + pvt->samples, f->data + len, 0);
#endif
pvt->samples += Frame;
pvt->datalen += 2*Frame; /* 2 bytes/sample */
len += res;
}
return 0;
}
static int lintog723_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
static int lintog723_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
/* Just add the frames to our stream */
/* XXX We should look at how old the rest of our stream is, and if it
is too old, then we should overwrite it entirely, otherwise we can
get artifacts of earlier talk that do not belong */
struct g723_encoder_pvt *tmp = (struct g723_encoder_pvt *)pvt;
if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
memcpy(&tmp->buf[tmp->tail], f->data, f->datalen);
tmp->tail += f->datalen/2;
} else {
struct g723_encoder_pvt *tmp = pvt->pvt;
if (tmp->samples + f->samples > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(&tmp->buf[pvt->samples], f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
static struct ast_frame *lintog723_frameout(struct ast_translator_pvt *pvt)
static struct ast_frame *lintog723_frameout(void *pvt)
{
struct g723_encoder_pvt *tmp = (struct g723_encoder_pvt *)pvt;
int samples = 0; /* how many samples in buffer */
#ifdef ANNEX_B
int x;
FLOAT tmpdata[Frame];
#endif
int cnt=0;
int cnt = 0; /* how many bytes so far */
/* We can't work on anything less than a frame in size */
if (tmp->tail < Frame)
if (pvt->samples < Frame)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_G723_1;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.samples = 0;
tmp->f.mallocd = 0;
while(tmp->tail >= Frame) {
while (pvt->samples >= Frame) {
/* Encode a frame of data */
if (cnt + 24 >= sizeof(tmp->outbuf)) {
/* at most 24 bytes/frame... */
if (cnt + 24 > pvt->buf_size) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return NULL;
}
#ifdef ANNEX_B
for (x=0;x<Frame;x++)
for ( x = 0; x < Frame ; x++)
tmpdata[x] = tmp->buf[x];
Coder(&tmp->cod, tmpdata, tmp->outbuf + cnt);
Coder(&tmp->cod, tmpdata, pvt->outbuf + cnt);
#else
Coder(&tmp->cod, tmp->buf, tmp->outbuf + cnt);
Coder(&tmp->cod, tmp->buf, pvt->outbuf + cnt);
#endif
/* Assume 8000 Hz */
tmp->f.samples += 240;
samples += G723_SAMPLES;
cnt += g723_len(tmp->outbuf[cnt]);
tmp->tail -= Frame;
pvt->samples -= Frame;
/* Move the data at the end of the buffer to the front */
if (tmp->tail)
memmove(tmp->buf, tmp->buf + Frame, tmp->tail * 2);
/* XXX inefficient... */
if (pvt->samples)
memmove(tmp->buf, tmp->buf + Frame, pvt->samples * 2);
}
tmp->f.datalen = cnt;
tmp->f.data = tmp->outbuf;
#if 0
/* Save to a g723 sample output file... */
{
static int fd = -1;
int delay = htonl(30);
short size;
if (fd < 0)
fd = open("trans.g723", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0)
ast_log(LOG_WARNING, "Unable to create demo\n");
write(fd, &delay, 4);
size = htons(tmp->f.datalen);
write(fd, &size, 2);
write(fd, tmp->f.data, tmp->f.datalen);
}
#endif
return &tmp->f;
return ast_trans_frameout(pvt, cnt, samples);
}
static void g723_destroy(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
ast_update_use_count();
}
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator g723tolin =
static struct ast_translator g723tolin = {
.name =
#ifdef ANNEX_B
{ "g723tolinb",
"g723btolin",
#else
{ "g723tolin",
"g723tolin",
#endif
AST_FORMAT_G723_1, AST_FORMAT_SLINEAR,
g723tolin_new,
g723tolin_framein,
g723tolin_frameout,
g723_destroy,
g723tolin_sample
};
.srcfmt = AST_FORMAT_G723_1,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = g723tolin_new,
.framein = g723tolin_framein,
.sample = g723tolin_sample,
.desc_size = sizeof(struct ...),
.lockp = &me,
};
static struct ast_translator lintog723 =
static struct ast_translator lintog723 = {
.name =
#ifdef ANNEX_B
{ "lintog723b",
"lintog723b",
#else
{ "lintog723",
"lintog723",
#endif
AST_FORMAT_SLINEAR, AST_FORMAT_G723_1,
lintog723_new,
lintog723_framein,
lintog723_frameout,
g723_destroy,
lintog723_sample
};
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_G723_1,
.new = lintog723_new,
.framein = lintog723_framein,
.frameout = lintog723_frameout,
.destroy = g723_destroy,
.sample = lintog723_sample,
.lockp = &me,
.desc_size = sizeof(struct ...),
};
/*! \brief standard module glue */
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintog723);
if (!res)
res = ast_unregister_translator(&g723tolin);
if (localusecnt)
res |= ast_unregister_translator(&g723tolin);
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -401,14 +328,17 @@ int load_module(void)
char *description(void)
{
return tdesc;
#ifdef ANNEX_B
return "Annex B (floating point) G.723.1/PCM16 Codec Translator";
#else
return "Annex A (fixed point) G.723.1/PCM16 Codec Translator";
#endif
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key(void)

488
codecs/codec_g726.c
View File

@@ -19,7 +19,6 @@
* at the top of the source tree.
*/
/*! \file
*
* \brief codec_g726.c - translate between signed linear and ITU G.726-32kbps
@@ -40,6 +39,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/lock.h"
#include "asterisk/logger.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/options.h"
@@ -63,16 +63,9 @@ typedef long long sint64;
# endif
#endif
#define BUFFER_SIZE 8096 /* size for the translation buffers */
#define BUFFER_SAMPLES 8096 /* size for the translation buffers */
#define BUF_SHIFT 5
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt = 0;
static char *tdesc = "ITU G.726-32kbps G726 Transcoder";
static int useplc = 0;
/* Sample frame data */
#include "slin_g726_ex.h"
@@ -152,8 +145,7 @@ static void g726_init_state(struct g726_state *state_ptr)
state_ptr->dms = 0;
state_ptr->dml = 0;
state_ptr->ap = 0;
for (cnta = 0; cnta < 2; cnta++)
{
for (cnta = 0; cnta < 2; cnta++) {
state_ptr->a[cnta] = 0;
state_ptr->pk[cnta] = 0;
#ifdef NOT_BLI
@@ -162,8 +154,7 @@ static void g726_init_state(struct g726_state *state_ptr)
state_ptr->sr[cnta] = 32;
#endif
}
for (cnta = 0; cnta < 6; cnta++)
{
for (cnta = 0; cnta < 6; cnta++) {
state_ptr->b[cnta] = 0;
#ifdef NOT_BLI
state_ptr->dq[cnta] = 1;
@@ -693,397 +684,186 @@ static int g726_encode(int sl, struct g726_state *state_ptr)
return (i);
}
/*
* ------------ Asterisk-codec hooks. -------------------
*/
/*
* Private workspace for translating signed linear signals to G726.
* Don't bother to define two distinct structs.
*/
struct g726_encoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
unsigned char outbuf[BUFFER_SIZE]; /* Encoded G726, two nibbles to a word */
unsigned char next_flag;
struct g726_state g726;
int tail;
struct g726_coder_pvt {
/* buffer any odd byte in input - 0x80 + (value & 0xf) if present */
unsigned char next_flag;
struct g726_state g726;
};
/*
* Private workspace for translating G726 signals to signed linear.
*/
struct g726_decoder_pvt
/*! \brief init a new instance of g726_coder_pvt. */
static void *lintog726_new(struct ast_trans_pvt *pvt)
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
short outbuf[BUFFER_SIZE]; /* Decoded signed linear values */
struct g726_state g726;
int tail;
plc_state_t plc;
};
struct g726_coder_pvt *tmp = pvt->pvt;
/*
* G726ToLin_New
* Create a new instance of g726_decoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *
g726tolin_new (void)
{
struct g726_decoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp))))
{
tmp->tail = 0;
plc_init(&tmp->plc);
localusecnt++;
g726_init_state(&tmp->g726);
ast_update_use_count ();
}
return (struct ast_translator_pvt *) tmp;
g726_init_state(&tmp->g726);
return tmp;
}
/*
* LinToG726_New
* Create a new instance of g726_encoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *
lintog726_new (void)
/*! \brief decode packed 4-bit G726 values and store in buffer. */
static int g726tolin_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp))))
{
localusecnt++;
tmp->tail = 0;
g726_init_state(&tmp->g726);
ast_update_use_count ();
}
return (struct ast_translator_pvt *) tmp;
}
struct g726_coder_pvt *tmp = pvt->pvt;
unsigned char *src = f->data;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
int i;
/*
* G726ToLin_FrameIn
* Fill an input buffer with packed 4-bit G726 values if there is room
* left.
*
* Results:
* Foo
*
* Side effects:
* tmp->tail is the number of packed values in the buffer.
*/
static int
g726tolin_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct g726_decoder_pvt *tmp = (struct g726_decoder_pvt *) pvt;
unsigned char *b;
int x;
if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
if((tmp->tail + 160) > BUFFER_SIZE) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->outbuf+tmp->tail, 160);
tmp->tail += 160;
for ( i = 0 ; i < f->datalen ; i++ ) {
*dst++ = g726_decode((src[i] >> 4) & 0xf, &tmp->g726);
*dst++ = g726_decode(src[i] & 0x0f, &tmp->g726);
}
return 0;
}
b = f->data;
for (x=0;x<f->datalen;x++) {
if (tmp->tail >= BUFFER_SIZE) {
ast_log(LOG_WARNING, "Out of buffer space!\n");
return -1;
}
tmp->outbuf[tmp->tail++] = g726_decode((b[x] >> 4) & 0xf, &tmp->g726);
if (tmp->tail >= BUFFER_SIZE) {
ast_log(LOG_WARNING, "Out of buffer space!\n");
return -1;
}
tmp->outbuf[tmp->tail++] = g726_decode(b[x] & 0x0f, &tmp->g726);
}
if(useplc) plc_rx(&tmp->plc, tmp->outbuf+tmp->tail-f->datalen*2, f->datalen*2);
return 0;
pvt->samples += f->samples;
pvt->datalen += 2 * f->samples; /* 2 bytes/sample */
return 0;
}
/*
* G726ToLin_FrameOut
* Convert 4-bit G726 encoded signals to 16-bit signed linear.
*
* Results:
* Converted signals are placed in tmp->f.data, tmp->f.datalen
* and tmp->f.samples are calculated.
*
* Side effects:
* None.
*/
static struct ast_frame *
g726tolin_frameout (struct ast_translator_pvt *pvt)
/*! \brief compress and store data (4-bit G726 samples) in outbuf */
static int lintog726_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_decoder_pvt *tmp = (struct g726_decoder_pvt *) pvt;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->tail = 0;
return &tmp->f;
}
/*
* LinToG726_FrameIn
* Fill an input buffer with 16-bit signed linear PCM values.
*
* Results:
* None.
*
* Side effects:
* tmp->tail is number of signal values in the input buffer.
*/
static int
lintog726_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct g726_encoder_pvt *tmp = (struct g726_encoder_pvt *) pvt;
short *s = f->data;
int samples = f->datalen / 2;
int x;
for (x=0;x<samples;x++) {
if (tmp->next_flag & 0x80) {
if (tmp->tail >= BUFFER_SIZE) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
struct g726_coder_pvt *tmp = pvt->pvt;
int16_t *src = f->data;
int i;
for ( i = 0; i < f->samples; i++ ) {
unsigned char d = g726_encode(src[i], &tmp->g726); /* this sample */
if (tmp->next_flag & 0x80) { /* merge with leftover sample */
pvt->outbuf[pvt->datalen++] = ((tmp->next_flag & 0xf)<< 4) | d;
pvt->samples += 2; /* 2 samples per byte */
tmp->next_flag = 0;
} else {
tmp->next_flag = 0x80 | d;
}
tmp->outbuf[tmp->tail++] = ((tmp->next_flag & 0xf)<< 4) | g726_encode(s[x], &tmp->g726);
tmp->next_flag = 0;
} else {
tmp->next_flag = 0x80 | g726_encode(s[x], &tmp->g726);
}
}
return 0;
return 0;
}
/*
* LinToG726_FrameOut
* Convert a buffer of raw 16-bit signed linear PCM to a buffer
* of 4-bit G726 packed two to a byte (Big Endian).
*
* Results:
* Foo
*
* Side effects:
* Leftover inbuf data gets packed, tail gets updated.
*/
static struct ast_frame *
lintog726_frameout (struct ast_translator_pvt *pvt)
/*! \brief G726ToLin_Sample */
static struct ast_frame *g726tolin_sample(void)
{
struct g726_encoder_pvt *tmp = (struct g726_encoder_pvt *) pvt;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_G726;
tmp->f.samples = tmp->tail * 2;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->f.datalen = tmp->tail;
tmp->tail = 0;
return &tmp->f;
static struct ast_frame f;
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_G726;
f.datalen = sizeof (g726_slin_ex);
f.samples = sizeof(g726_slin_ex) * 2; /* 2 samples per byte */
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.data = g726_slin_ex;
return &f;
}
/*
* G726ToLin_Sample
*/
static struct ast_frame *
g726tolin_sample (void)
/*! \brief LinToG726_Sample */
static struct ast_frame *lintog726_sample (void)
{
static struct ast_frame f;
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_G726;
f.datalen = sizeof (g726_slin_ex);
f.samples = sizeof(g726_slin_ex) * 2;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.data = g726_slin_ex;
return &f;
static struct ast_frame f;
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_SLINEAR;
f.datalen = sizeof (slin_g726_ex);
/* Assume 8000 Hz */
f.samples = sizeof (slin_g726_ex) / 2; /* 1 sample per 2 bytes */
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.data = slin_g726_ex;
return &f;
}
/*
* LinToG726_Sample
*/
static struct ast_frame *
lintog726_sample (void)
{
static struct ast_frame f;
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_SLINEAR;
f.datalen = sizeof (slin_g726_ex);
/* Assume 8000 Hz */
f.samples = sizeof (slin_g726_ex) / 2;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.data = slin_g726_ex;
return &f;
}
/*
* G726_Destroy
* Destroys a private workspace.
*
* Results:
* It's gone!
*
* Side effects:
* None.
*/
static void
g726_destroy (struct ast_translator_pvt *pvt)
{
free (pvt);
localusecnt--;
ast_update_use_count ();
}
/*
* The complete translator for G726ToLin.
*/
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator g726tolin = {
"g726tolin",
AST_FORMAT_G726,
AST_FORMAT_SLINEAR,
g726tolin_new,
g726tolin_framein,
g726tolin_frameout,
g726_destroy,
/* NULL */
g726tolin_sample
.name = "g726tolin",
.srcfmt = AST_FORMAT_G726,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = lintog726_new, /* same for both directions */
.framein = g726tolin_framein,
.sample = g726tolin_sample,
.desc_size = sizeof(struct g726_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.plc_samples = 160,
.lockp = &me,
};
/*
* The complete translator for LinToG726.
*/
static struct ast_translator lintog726 = {
"lintog726",
AST_FORMAT_SLINEAR,
AST_FORMAT_G726,
lintog726_new,
lintog726_framein,
lintog726_frameout,
g726_destroy,
/* NULL */
lintog726_sample
.name = "lintog726",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_G726,
.newpvt = lintog726_new, /* same for both directions */
.framein = lintog726_framein,
.sample = lintog726_sample,
.desc_size = sizeof(struct g726_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES/2,
.lockp = &me,
};
static void
parse_config(void)
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_g726: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
}
ast_config_destroy(cfg);
}
struct ast_variable *var;
struct ast_config *cfg = ast_config_load("codecs.conf");
if (!cfg)
return;
for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
g726tolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_g726: %susing generic PLC\n",
g726tolin.useplc ? "" : "not ");
}
}
ast_config_destroy(cfg);
}
int
reload(void)
/*! \brief standard module glue */
int reload(void)
{
parse_config();
return 0;
parse_config();
return 0;
}
int
unload_module (void)
int unload_module (void)
{
int res;
ast_mutex_lock (&localuser_lock);
res = ast_unregister_translator (&lintog726);
if (!res)
res = ast_unregister_translator (&g726tolin);
if (localusecnt)
res = -1;
ast_mutex_unlock (&localuser_lock);
return res;
int res;
ast_mutex_lock (&me.lock);
res = ast_unregister_translator (&lintog726);
res |= ast_unregister_translator (&g726tolin);
if (me.usecnt)
res = -1;
ast_mutex_unlock (&me.lock);
return res;
}
int
load_module (void)
int load_module (void)
{
int res;
parse_config();
res = ast_register_translator (&g726tolin);
if (!res)
res = ast_register_translator (&lintog726);
else
ast_unregister_translator (&g726tolin);
return res;
int res;
parse_config();
res = ast_register_translator (&g726tolin);
if (!res)
res = ast_register_translator (&lintog726);
else
ast_unregister_translator (&g726tolin);
return res;
}
/*
* Return a description of this module.
*/
char *
description (void)
char *description (void)
{
return tdesc;
return "ITU G.726-32kbps G726 Transcoder";
}
int
usecount (void)
int usecount (void)
{
int res;
OLD_STANDARD_USECOUNT (res);
return res;
return me.usecnt;
}
char *
key ()
char *key()
{
return ASTERISK_GPL_KEY;
return ASTERISK_GPL_KEY;
}

296
codecs/codec_gsm.c
View File

@@ -58,40 +58,22 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "slin_gsm_ex.h"
#include "gsm_slin_ex.h"
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt=0;
#define BUFFER_SAMPLES 8000
#define GSM_SAMPLES 160
#define GSM_FRAME_LEN 33
#define MSGSM_FRAME_LEN 65
static char *tdesc = "GSM/PCM16 (signed linear) Codec Translator";
static int useplc = 0;
struct ast_translator_pvt {
struct gsm_translator_pvt { /* both gsm2lin and lin2gsm */
gsm gsm;
struct ast_frame f;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
/* Buffer for our outgoing frame */
short outbuf[8000];
/* Enough to store a full second */
short buf[8000];
int tail;
plc_state_t plc;
int16_t buf[BUFFER_SAMPLES]; /* lin2gsm, temporary storage */
};
#define gsm_coder_pvt ast_translator_pvt
static struct ast_translator_pvt *gsm_new(void)
static void *gsm_new(struct ast_trans_pvt *pvt)
{
struct gsm_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
if (!(tmp->gsm = gsm_create())) {
free(tmp);
tmp = NULL;
}
tmp->tail = 0;
plc_init(&tmp->plc);
localusecnt++;
}
struct gsm_translator_pvt *tmp = pvt->pvt;
if (!(tmp->gsm = gsm_create()))
return NULL;
return tmp;
}
@@ -117,7 +99,7 @@ static struct ast_frame *gsmtolin_sample(void)
f.subclass = AST_FORMAT_GSM;
f.datalen = sizeof(gsm_slin_ex);
/* All frames are 20 ms long */
f.samples = 160;
f.samples = GSM_SAMPLES;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
@@ -125,189 +107,151 @@ static struct ast_frame *gsmtolin_sample(void)
return &f;
}
static struct ast_frame *gsmtolin_frameout(struct ast_translator_pvt *tmp)
/*! \brief decode and store in outbuf. */
static int gsmtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
if (!tmp->tail)
return NULL;
/* Signed linear is no particular frame size, so just send whatever
we have in the buffer in one lump sum */
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
/* Assume 8000 Hz */
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->buf;
/* Reset tail pointer */
tmp->tail = 0;
return &tmp->f;
}
static int gsmtolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
{
/* Assuming there's space left, decode into the current buffer at
the tail location. Read in as many frames as there are */
struct gsm_translator_pvt *tmp = pvt->pvt;
int x;
unsigned char data[66];
int msgsm=0;
if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
if((tmp->tail + 160) > sizeof(tmp->buf) / 2) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->buf+tmp->tail, 160);
tmp->tail += 160;
}
return 0;
}
int16_t *dst = (int16_t *)pvt->outbuf;
/* guess format from frame len. 65 for MSGSM, 33 for regular GSM */
int flen = (f->datalen % MSGSM_FRAME_LEN == 0) ?
MSGSM_FRAME_LEN : GSM_FRAME_LEN;
if ((f->datalen % 33) && (f->datalen % 65)) {
ast_log(LOG_WARNING, "Huh? A GSM frame that isn't a multiple of 33 or 65 bytes long from %s (%d)?\n", f->src, f->datalen);
return -1;
}
if (f->datalen % 65 == 0)
msgsm = 1;
for (x=0;x<f->datalen;x+=(msgsm ? 65 : 33)) {
if (msgsm) {
for (x=0; x < f->datalen; x += flen) {
unsigned char data[2 * GSM_FRAME_LEN];
char *src;
int len;
if (flen == MSGSM_FRAME_LEN) {
len = 2*GSM_SAMPLES;
src = data;
/* Translate MSGSM format to Real GSM format before feeding in */
/* XXX what's the point here! we should just work
* on the full format.
*/
conv65(f->data + x, data);
if (tmp->tail + 320 < sizeof(tmp->buf)/2) {
if (gsm_decode(tmp->gsm, data, tmp->buf + tmp->tail)) {
ast_log(LOG_WARNING, "Invalid GSM data (1)\n");
return -1;
}
tmp->tail+=160;
if (gsm_decode(tmp->gsm, data + 33, tmp->buf + tmp->tail)) {
ast_log(LOG_WARNING, "Invalid GSM data (2)\n");
return -1;
}
tmp->tail+=160;
} else {
ast_log(LOG_WARNING, "Out of (MS) buffer space\n");
return -1;
}
} else {
if (tmp->tail + 160 < sizeof(tmp->buf)/2) {
if (gsm_decode(tmp->gsm, f->data + x, tmp->buf + tmp->tail)) {
ast_log(LOG_WARNING, "Invalid GSM data\n");
return -1;
}
tmp->tail+=160;
} else {
ast_log(LOG_WARNING, "Out of buffer space\n");
len = GSM_SAMPLES;
src = f->data + x;
}
/* XXX maybe we don't need to check */
if (pvt->samples + len > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if (gsm_decode(tmp->gsm, src, dst + pvt->samples)) {
ast_log(LOG_WARNING, "Invalid GSM data (1)\n");
return -1;
}
pvt->samples += GSM_SAMPLES;
pvt->datalen += 2 * GSM_SAMPLES;
if (flen == MSGSM_FRAME_LEN) {
if (gsm_decode(tmp->gsm, data + GSM_FRAME_LEN, dst + pvt->samples)) {
ast_log(LOG_WARNING, "Invalid GSM data (2)\n");
return -1;
}
pvt->samples += GSM_SAMPLES;
pvt->datalen += 2 * GSM_SAMPLES;
}
}
/* just add the last 20ms frame; there must have been at least one */
if(useplc) plc_rx(&tmp->plc, tmp->buf+tmp->tail-160, 160);
return 0;
}
static int lintogsm_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
/*! \brief store samples into working buffer for later decode */
static int lintogsm_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
/* Just add the frames to our stream */
struct gsm_translator_pvt *tmp = pvt->pvt;
/* XXX We should look at how old the rest of our stream is, and if it
is too old, then we should overwrite it entirely, otherwise we can
get artifacts of earlier talk that do not belong */
if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
tmp->tail += f->datalen/2;
} else {
if (pvt->samples + f->samples > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
static struct ast_frame *lintogsm_frameout(struct ast_translator_pvt *tmp)
/*! \brief encode and produce a frame */
static struct ast_frame *lintogsm_frameout(struct ast_trans_pvt *pvt)
{
int x=0;
struct gsm_translator_pvt *tmp = pvt->pvt;
int datalen = 0;
int samples = 0;
/* We can't work on anything less than a frame in size */
if (tmp->tail < 160)
if (pvt->samples < GSM_SAMPLES)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_GSM;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
while(tmp->tail >= 160) {
if ((x+1) * 33 >= sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
break;
}
while (pvt->samples >= GSM_SAMPLES) {
/* Encode a frame of data */
gsm_encode(tmp->gsm, tmp->buf, ((gsm_byte *) tmp->outbuf) + (x * 33));
/* Assume 8000 Hz -- 20 ms */
tmp->tail -= 160;
gsm_encode(tmp->gsm, tmp->buf, (gsm_byte *)pvt->outbuf + datalen);
datalen += GSM_FRAME_LEN;
samples += GSM_SAMPLES;
pvt->samples -= GSM_SAMPLES;
/* Move the data at the end of the buffer to the front */
if (tmp->tail)
memmove(tmp->buf, tmp->buf + 160, tmp->tail * 2);
x++;
if (pvt->samples)
memmove(tmp->buf, tmp->buf + GSM_SAMPLES, pvt->samples * 2);
}
tmp->f.datalen = x * 33;
tmp->f.samples = x * 160;
return &tmp->f;
return ast_trans_frameout(pvt, datalen, samples);
}
static void gsm_destroy_stuff(struct ast_translator_pvt *pvt)
static void gsm_destroy_stuff(struct ast_trans_pvt *pvt)
{
if (pvt->gsm)
gsm_destroy(pvt->gsm);
free(pvt);
localusecnt--;
struct gsm_translator_pvt *tmp = pvt->pvt;
if (tmp->gsm)
gsm_destroy(tmp->gsm);
}
static struct ast_translator gsmtolin =
{ "gsmtolin",
AST_FORMAT_GSM, AST_FORMAT_SLINEAR,
gsm_new,
gsmtolin_framein,
gsmtolin_frameout,
gsm_destroy_stuff,
gsmtolin_sample
};
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator lintogsm =
{ "lintogsm",
AST_FORMAT_SLINEAR, AST_FORMAT_GSM,
gsm_new,
lintogsm_framein,
lintogsm_frameout,
gsm_destroy_stuff,
lintogsm_sample
};
static struct ast_translator gsmtolin = {
.name = "gsmtolin",
.srcfmt = AST_FORMAT_GSM,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = gsm_new,
.framein = gsmtolin_framein,
.destroy = gsm_destroy_stuff,
.sample = gsmtolin_sample,
.lockp = &me,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.desc_size = sizeof (struct gsm_translator_pvt ),
.plc_samples = GSM_SAMPLES,
};
static struct ast_translator lintogsm = {
.name = "lintogsm",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_GSM,
.newpvt = gsm_new,
.framein = lintogsm_framein,
.frameout = lintogsm_frameout,
.destroy = gsm_destroy_stuff,
.sample = lintogsm_sample,
.lockp = &me,
.desc_size = sizeof (struct gsm_translator_pvt ),
.buf_size = (BUFFER_SAMPLES * GSM_FRAME_LEN + GSM_SAMPLES - 1)/GSM_SAMPLES,
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_gsm: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
}
ast_config_destroy(cfg);
struct ast_config *cfg = ast_config_load("codecs.conf");
if (!cfg)
return;
for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
gsmtolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_gsm: %susing generic PLC\n", gsmtolin.useplc ? "" : "not ");
}
}
ast_config_destroy(cfg);
}
/*! \brief standard module glue */
int reload(void)
{
parse_config();
@@ -317,13 +261,13 @@ int reload(void)
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintogsm);
if (!res)
res = ast_unregister_translator(&gsmtolin);
if (localusecnt)
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -341,14 +285,12 @@ int load_module(void)
char *description(void)
{
return tdesc;
return "GSM/PCM16 (signed linear) Codec Translator";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

235
codecs/codec_ilbc.c
View File

@@ -54,49 +54,32 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#define ILBC_MS 30
/* #define ILBC_MS 20 */
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt=0;
#define ILBC_FRAME_LEN 50 /* apparently... */
#define ILBC_SAMPLES 240 /* 30ms at 8000 hz */
#define BUFFER_SAMPLES 8000
static char *tdesc = "iLBC/PCM16 (signed linear) Codec Translator";
struct ast_translator_pvt {
struct ilbc_coder_pvt {
iLBC_Enc_Inst_t enc;
iLBC_Dec_Inst_t dec;
struct ast_frame f;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
/* Buffer for our outgoing frame */
short outbuf[8000];
/* Enough to store a full second */
short buf[8000];
int tail;
int16_t buf[BUFFER_SAMPLES];
};
#define ilbc_coder_pvt ast_translator_pvt
static struct ast_translator_pvt *lintoilbc_new(void)
static void *lintoilbc_new(struct ast_trans_pvt *pvt)
{
struct ilbc_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
/* Shut valgrind up */
memset(&tmp->enc, 0, sizeof(tmp->enc));
initEncode(&tmp->enc, ILBC_MS);
tmp->tail = 0;
localusecnt++;
}
struct ilbc_coder_pvt *tmp = pvt->pvt;
initEncode(&tmp->enc, ILBC_MS);
return tmp;
}
static struct ast_translator_pvt *ilbctolin_new(void)
static void *ilbctolin_new(struct ast_trans_pvt *pvt)
{
struct ilbc_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
/* Shut valgrind up */
memset(&tmp->dec, 0, sizeof(tmp->dec));
initDecode(&tmp->dec, ILBC_MS, USE_ILBC_ENHANCER);
tmp->tail = 0;
localusecnt++;
}
struct ilbc_coder_pvt *tmp = pvt->pvt;
initDecode(&tmp->dec, ILBC_MS, USE_ILBC_ENHANCER);
return tmp;
}
@@ -106,7 +89,6 @@ static struct ast_frame *lintoilbc_sample(void)
f.frametype = AST_FRAME_VOICE;
f.subclass = AST_FORMAT_SLINEAR;
f.datalen = sizeof(slin_ilbc_ex);
/* Assume 8000 Hz */
f.samples = sizeof(slin_ilbc_ex)/2;
f.mallocd = 0;
f.offset = 0;
@@ -122,7 +104,7 @@ static struct ast_frame *ilbctolin_sample(void)
f.subclass = AST_FORMAT_ILBC;
f.datalen = sizeof(ilbc_slin_ex);
/* All frames are 30 ms long */
f.samples = 240;
f.samples = ILBC_SAMPLES;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
@@ -130,161 +112,120 @@ static struct ast_frame *ilbctolin_sample(void)
return &f;
}
static struct ast_frame *ilbctolin_frameout(struct ast_translator_pvt *tmp)
{
if (!tmp->tail)
return NULL;
/* Signed linear is no particular frame size, so just send whatever
we have in the buffer in one lump sum */
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
/* Assume 8000 Hz */
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->buf;
/* Reset tail pointer */
tmp->tail = 0;
return &tmp->f;
}
static int ilbctolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
/*! \brief decode a frame and store in outbuf */
static int ilbctolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ilbc_coder_pvt *tmp = pvt->pvt;
int plc_mode = 1; /* 1 = normal data, 0 = plc */
/* Assuming there's space left, decode into the current buffer at
the tail location. Read in as many frames as there are */
int x,i;
float tmpf[240];
int16_t *dst = (int16_t *)pvt->outbuf;
float tmpf[ILBC_SAMPLES];
if (f->datalen == 0) { /* native PLC */
if (tmp->tail + 240 < sizeof(tmp->buf)/2) {
iLBC_decode(tmpf, NULL, &tmp->dec, 0);
for (i=0;i<240;i++)
tmp->buf[tmp->tail + i] = tmpf[i];
tmp->tail+=240;
} else {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if (f->datalen == 0) { /* native PLC, set fake f->datalen and clear plc_mode */
f->datalen = ILBC_FRAME_LEN;
f->samples = ILBC_SAMPLES;
plc_mode = 0; /* do native plc */
pvt->samples += ILBC_SAMPLES;
}
if (f->datalen % 50) {
if (f->datalen % ILBC_FRAME_LEN) {
ast_log(LOG_WARNING, "Huh? An ilbc frame that isn't a multiple of 50 bytes long from %s (%d)?\n", f->src, f->datalen);
return -1;
}
for (x=0;x<f->datalen;x+=50) {
if (tmp->tail + 240 < sizeof(tmp->buf)/2) {
iLBC_decode(tmpf, f->data + x, &tmp->dec, 1);
for (i=0;i<240;i++)
tmp->buf[tmp->tail + i] = tmpf[i];
tmp->tail+=240;
} else {
for (x=0; x < f->datalen ; x += ILBC_FRAME_LEN) {
if (pvt->samples + ILBC_SAMPLES > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
iLBC_decode(tmpf, plc_mode ? f->data + x : NULL, &tmp->dec, plc_mode);
for ( i=0; i < ILBC_SAMPLES; i++)
dst[pvt->samples + i] = tmpf[i];
pvt->samples += ILBC_SAMPLES;
pvt->datalen += 2*ILBC_SAMPLES;
}
return 0;
}
static int lintoilbc_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
/*! \brief store a frame into a temporary buffer, for later decoding */
static int lintoilbc_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ilbc_coder_pvt *tmp = pvt->pvt;
/* Just add the frames to our stream */
/* XXX We should look at how old the rest of our stream is, and if it
is too old, then we should overwrite it entirely, otherwise we can
get artifacts of earlier talk that do not belong */
if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
tmp->tail += f->datalen/2;
} else {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
static struct ast_frame *lintoilbc_frameout(struct ast_translator_pvt *tmp)
/*! \brief encode the temporary buffer and generate a frame */
static struct ast_frame *lintoilbc_frameout(struct ast_trans_pvt *pvt)
{
int x=0,i;
float tmpf[240];
struct ilbc_coder_pvt *tmp = pvt->pvt;
int datalen = 0;
int samples = 0;
/* We can't work on anything less than a frame in size */
if (tmp->tail < 240)
if (pvt->samples < ILBC_SAMPLES)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ILBC;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
while(tmp->tail >= 240) {
if ((x+1) * 50 >= sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
break;
}
for (i=0;i<240;i++)
tmpf[i] = tmp->buf[i];
while (pvt->samples >= ILBC_SAMPLES) {
float tmpf[ILBC_SAMPLES];
int i;
/* Encode a frame of data */
iLBC_encode(((unsigned char *)(tmp->outbuf)) + (x * 50), tmpf, &tmp->enc);
/* Assume 8000 Hz -- 20 ms */
tmp->tail -= 240;
for ( i = 0 ; i < ILBC_SAMPLES ; i++ )
tmpf[i] = tmp->buf[i];
iLBC_encode(pvt->outbuf + datalen, tmpf, &tmp->enc);
datalen += ILBC_FRAME_LEN;
samples += ILBC_SAMPLES;
pvt->samples -= ILBC_SAMPLES;
/* Move the data at the end of the buffer to the front */
if (tmp->tail)
memmove(tmp->buf, tmp->buf + 240, tmp->tail * 2);
x++;
if (pvt->samples)
memmove(tmp->buf, tmp->buf + ILBC_SAMPLES, pvt->samples * 2);
}
tmp->f.datalen = x * 50;
tmp->f.samples = x * 240;
#if 0
{
static int fd = -1;
if (fd == -1) {
fd = open("ilbc.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
write(fd, tmp->f.data, tmp->f.datalen);
close(fd);
}
}
#endif
return &tmp->f;
return ast_trans_frameout(pvt, datalen, samples);
}
static void ilbc_destroy_stuff(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
}
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator ilbctolin =
{ "ilbctolin",
AST_FORMAT_ILBC, AST_FORMAT_SLINEAR,
ilbctolin_new,
ilbctolin_framein,
ilbctolin_frameout,
ilbc_destroy_stuff,
ilbctolin_sample
};
static struct ast_translator ilbctolin = {
.name = "ilbctolin",
.srcfmt = AST_FORMAT_ILBC,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = ilbctolin_new,
.framein = ilbctolin_framein,
.sample = ilbctolin_sample,
.desc_size = sizeof(struct ilbc_coder_pvt),
.buf_size = BUFFER_SAMPLES * 2,
.lockp = &me,
};
static struct ast_translator lintoilbc =
{ "lintoilbc",
AST_FORMAT_SLINEAR, AST_FORMAT_ILBC,
lintoilbc_new,
lintoilbc_framein,
lintoilbc_frameout,
ilbc_destroy_stuff,
lintoilbc_sample
};
static struct ast_translator lintoilbc = {
.name = "lintoilbc",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_ILBC,
.newpvt = lintoilbc_new,
.framein = lintoilbc_framein,
.frameout = lintoilbc_frameout,
.sample = lintoilbc_sample,
.desc_size = sizeof(struct ilbc_coder_pvt),
.buf_size = (BUFFER_SAMPLES * ILBC_FRAME_LEN + ILBC_SAMPLES - 1) / ILBC_SAMPLES,
.lockp = &me,
};
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintoilbc);
if (!res)
res = ast_unregister_translator(&ilbctolin);
if (localusecnt)
res |= ast_unregister_translator(&ilbctolin);
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -306,9 +247,7 @@ char *description(void)
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

307
codecs/codec_lpc10.c
View File

@@ -60,62 +60,36 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#define LPC10_BYTES_IN_COMPRESSED_FRAME (LPC10_BITS_IN_COMPRESSED_FRAME + 7)/8
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt=0;
#define BUFFER_SAMPLES 8000
static char *tdesc = "LPC10 2.4kbps (signed linear) Voice Coder";
static int useplc = 0;
struct ast_translator_pvt {
struct lpc10_coder_pvt {
union {
struct lpc10_encoder_state *enc;
struct lpc10_decoder_state *dec;
} lpc10;
struct ast_frame f;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
/* Buffer for our outgoing frame */
short outbuf[8000];
/* Enough to store a full second */
short buf[8000];
int tail;
short buf[BUFFER_SAMPLES];
int longer;
plc_state_t plc; /* god only knows why I bothered to implement PLC for LPC10 :) */
};
#define lpc10_coder_pvt ast_translator_pvt
static struct ast_translator_pvt *lpc10_enc_new(void)
static void *lpc10_enc_new(struct ast_trans_pvt *pvt)
{
struct lpc10_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
if (!(tmp->lpc10.enc = create_lpc10_encoder_state())) {
free(tmp);
tmp = NULL;
}
tmp->tail = 0;
tmp->longer = 0;
localusecnt++;
}
struct lpc10_coder_pvt *tmp = pvt->pvt;
if (!(tmp->lpc10.enc = create_lpc10_encoder_state()))
return NULL;
return tmp;
}
static struct ast_translator_pvt *lpc10_dec_new(void)
static void *lpc10_dec_new(struct ast_trans_pvt *pvt)
{
struct lpc10_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
if (!(tmp->lpc10.dec = create_lpc10_decoder_state())) {
free(tmp);
tmp = NULL;
}
tmp->tail = 0;
tmp->longer = 0;
plc_init(&tmp->plc);
localusecnt++;
}
struct lpc10_coder_pvt *tmp = pvt->pvt;
if (!(tmp->lpc10.dec = create_lpc10_decoder_state()))
return NULL;
return tmp;
}
static struct ast_frame *lintolpc10_sample(void)
{
static struct ast_frame f;
@@ -147,39 +121,6 @@ static struct ast_frame *lpc10tolin_sample(void)
return &f;
}
static struct ast_frame *lpc10tolin_frameout(struct ast_translator_pvt *tmp)
{
if (!tmp->tail)
return NULL;
/* Signed linear is no particular frame size, so just send whatever
we have in the buffer in one lump sum */
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
/* Assume 8000 Hz */
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->buf;
/* Reset tail pointer */
tmp->tail = 0;
#if 0
/* Save a sample frame */
{ static int samplefr = 0;
if (samplefr == 80) {
int fd;
fd = open("lpc10.example", O_WRONLY | O_CREAT, 0644);
write(fd, tmp->f.data, tmp->f.datalen);
close(fd);
}
samplefr++;
}
#endif
return &tmp->f;
}
static void extract_bits(INT32 *bits, unsigned char *c)
{
int x;
@@ -193,6 +134,7 @@ static void extract_bits(INT32 *bits, unsigned char *c)
}
}
/* XXX note lpc10_encode() produces one bit per word in bits[] */
static void build_bits(unsigned char *c, INT32 *bits)
{
unsigned char mask=0x80;
@@ -210,48 +152,32 @@ static void build_bits(unsigned char *c, INT32 *bits)
}
}
static int lpc10tolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
static int lpc10tolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
/* Assuming there's space left, decode into the current buffer at
the tail location */
int x;
int len=0;
float tmpbuf[LPC10_SAMPLES_PER_FRAME];
short *sd;
INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME];
struct lpc10_coder_pvt *tmp = pvt->pvt;
int16_t *dst = (int16_t *)pvt->outbuf;
int len = 0;
if(f->datalen == 0) { /* perform PLC with nominal framesize of LPC10_SAMPLES_PER_FRAME */
if((tmp->tail + LPC10_SAMPLES_PER_FRAME) > sizeof(tmp->buf)/2) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->buf+tmp->tail, LPC10_SAMPLES_PER_FRAME);
tmp->tail += LPC10_SAMPLES_PER_FRAME;
}
return 0;
}
while(len + LPC10_BYTES_IN_COMPRESSED_FRAME <= f->datalen) {
if (tmp->tail + LPC10_SAMPLES_PER_FRAME < sizeof(tmp->buf)/2) {
sd = tmp->buf + tmp->tail;
extract_bits(bits, f->data + len);
if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
ast_log(LOG_WARNING, "Invalid lpc10 data\n");
return -1;
}
for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++) {
/* Convert to a real between -1.0 and 1.0 */
sd[x] = 32768.0 * tmpbuf[x];
}
if(useplc) plc_rx(&tmp->plc, tmp->buf + tmp->tail, LPC10_SAMPLES_PER_FRAME);
tmp->tail+=LPC10_SAMPLES_PER_FRAME;
} else {
while (len + LPC10_BYTES_IN_COMPRESSED_FRAME <= f->datalen) {
int x;
float tmpbuf[LPC10_SAMPLES_PER_FRAME];
INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME]; /* XXX see note */
if (pvt->samples + LPC10_SAMPLES_PER_FRAME > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
extract_bits(bits, f->data + len);
if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
ast_log(LOG_WARNING, "Invalid lpc10 data\n");
return -1;
}
for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++) {
/* Convert to a short between -1.0 and 1.0 */
dst[pvt->samples + x] = (int16_t)(32768.0 * tmpbuf[x]);
}
pvt->samples += LPC10_SAMPLES_PER_FRAME;
pvt->datalen += 2*LPC10_SAMPLES_PER_FRAME;
len += LPC10_BYTES_IN_COMPRESSED_FRAME;
}
if (len != f->datalen)
@@ -259,125 +185,108 @@ static int lpc10tolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *
return 0;
}
static int lintolpc10_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
static int lintolpc10_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct lpc10_coder_pvt *tmp = pvt->pvt;
/* Just add the frames to our stream */
/* XXX We should look at how old the rest of our stream is, and if it
is too old, then we should overwrite it entirely, otherwise we can
get artifacts of earlier talk that do not belong */
if (tmp->tail + f->datalen < sizeof(tmp->buf) / 2) {
memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
tmp->tail += f->datalen/2;
} else {
if (pvt->samples + f->samples > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
static struct ast_frame *lintolpc10_frameout(struct ast_translator_pvt *tmp)
static struct ast_frame *lintolpc10_frameout(struct ast_trans_pvt *pvt)
{
struct lpc10_coder_pvt *tmp = pvt->pvt;
int x;
int consumed = 0;
int datalen = 0; /* output frame */
int samples = 0; /* output samples */
float tmpbuf[LPC10_SAMPLES_PER_FRAME];
INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME];
INT32 bits[LPC10_BITS_IN_COMPRESSED_FRAME]; /* XXX what ??? */
/* We can't work on anything less than a frame in size */
if (tmp->tail < LPC10_SAMPLES_PER_FRAME)
if (pvt->samples < LPC10_SAMPLES_PER_FRAME)
return NULL;
/* Start with an empty frame */
tmp->f.samples = 0;
tmp->f.datalen = 0;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_LPC10;
while(tmp->tail >= LPC10_SAMPLES_PER_FRAME) {
if (tmp->f.datalen + LPC10_BYTES_IN_COMPRESSED_FRAME > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return NULL;
}
while (pvt->samples >= LPC10_SAMPLES_PER_FRAME) {
/* Encode a frame of data */
for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++) {
tmpbuf[x] = (float)tmp->buf[x+consumed] / 32768.0;
}
for (x=0;x<LPC10_SAMPLES_PER_FRAME;x++)
tmpbuf[x] = (float)tmp->buf[x + samples] / 32768.0;
lpc10_encode(tmpbuf, bits, tmp->lpc10.enc);
build_bits(((unsigned char *)tmp->outbuf) + tmp->f.datalen, bits);
tmp->f.datalen += LPC10_BYTES_IN_COMPRESSED_FRAME;
tmp->f.samples += LPC10_SAMPLES_PER_FRAME;
build_bits(pvt->outbuf + datalen, bits);
datalen += LPC10_BYTES_IN_COMPRESSED_FRAME;
samples += LPC10_SAMPLES_PER_FRAME;
pvt->samples -= LPC10_SAMPLES_PER_FRAME;
/* Use one of the two left over bits to record if this is a 22 or 23 ms frame...
important for IAX use */
tmp->longer = 1 - tmp->longer;
#if 0 /* what the heck was this for? */
((char *)(tmp->f.data))[consumed - 1] |= tmp->longer;
#endif
tmp->tail -= LPC10_SAMPLES_PER_FRAME;
consumed += LPC10_SAMPLES_PER_FRAME;
}
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
/* Move the data at the end of the buffer to the front */
if (tmp->tail)
memmove(tmp->buf, tmp->buf + consumed, tmp->tail * 2);
#if 0
/* Save a sample frame */
{ static int samplefr = 0;
if (samplefr == 0) {
int fd;
fd = open("lpc10.example", O_WRONLY | O_CREAT, 0644);
write(fd, tmp->f.data, tmp->f.datalen);
close(fd);
}
samplefr++;
}
#endif
return &tmp->f;
if (pvt->samples)
memmove(tmp->buf, tmp->buf + samples, pvt->samples * 2);
return ast_trans_frameout(pvt, datalen, samples);
}
static void lpc10_destroy(struct ast_translator_pvt *pvt)
static void lpc10_destroy(struct ast_trans_pvt *arg)
{
struct lpc10_coder_pvt *pvt = arg->pvt;
/* Enc and DEC are both just allocated, so they can be freed */
free(pvt->lpc10.enc);
free(pvt);
localusecnt--;
}
static struct ast_translator lpc10tolin =
{ "lpc10tolin",
AST_FORMAT_LPC10, AST_FORMAT_SLINEAR,
lpc10_dec_new,
lpc10tolin_framein,
lpc10tolin_frameout,
lpc10_destroy,
lpc10tolin_sample
};
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator lintolpc10 =
{ "lintolpc10",
AST_FORMAT_SLINEAR, AST_FORMAT_LPC10,
lpc10_enc_new,
lintolpc10_framein,
lintolpc10_frameout,
lpc10_destroy,
lintolpc10_sample
};
static struct ast_translator lpc10tolin = {
.name = "lpc10tolin",
.srcfmt = AST_FORMAT_LPC10,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = lpc10_dec_new,
.framein = lpc10tolin_framein,
.destroy = lpc10_destroy,
.sample = lpc10tolin_sample,
.lockp = &me,
.desc_size = sizeof(struct lpc10_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.plc_samples = LPC10_SAMPLES_PER_FRAME,
.buf_size = BUFFER_SAMPLES * 2,
};
static struct ast_translator lintolpc10 = {
.name = "lintolpc10",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_LPC10,
.newpvt = lpc10_enc_new,
.framein = lintolpc10_framein,
.frameout = lintolpc10_frameout,
.destroy = lpc10_destroy,
.sample = lintolpc10_sample,
.lockp = &me,
.desc_size = sizeof(struct lpc10_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = LPC10_BYTES_IN_COMPRESSED_FRAME * (1 + BUFFER_SAMPLES / LPC10_SAMPLES_PER_FRAME),
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_lpc10: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
}
ast_config_destroy(cfg);
struct ast_config *cfg = ast_config_load("codecs.conf");
if (!cfg)
return;
for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
lpc10tolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_lpc10: %susing generic PLC\n",
lpc10tolin.useplc ? "" : "not ");
}
}
ast_config_destroy(cfg);
}
int reload(void)
@@ -390,13 +299,13 @@ int reload(void)
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintolpc10);
if (!res)
res = ast_unregister_translator(&lpc10tolin);
if (localusecnt)
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -414,14 +323,12 @@ int load_module(void)
char *description(void)
{
return tdesc;
return "LPC10 2.4kbps (signed linear) Voice Coder";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

588
codecs/codec_speex.c
View File

@@ -41,6 +41,7 @@
#include <speex/speex_preprocess.h>
#endif
/* codec variables */
static int quality = 3;
static int complexity = 2;
static int enhancement = 0;
@@ -48,12 +49,12 @@ static int vad = 0;
static int vbr = 0;
static float vbr_quality = 4;
static int abr = 0;
static int dtx = 0;
static int dtx = 0; /* set to 1 to enable silence detection */
static int preproc = 0;
static int pp_vad = 0;
static int pp_agc = 0;
static float pp_agc_level = 8000;
static float pp_agc_level = 8000; /* XXX what is this 8000 ? */
static int pp_denoise = 0;
static int pp_dereverb = 0;
static float pp_dereverb_decay = 0.4;
@@ -81,97 +82,75 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "slin_speex_ex.h"
#include "speex_slin_ex.h"
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt=0;
#define BUFFER_SAMPLES 8000
#define SPEEX_SAMPLES 160
static char *tdesc = "Speex/PCM16 (signed linear) Codec Translator";
struct ast_translator_pvt {
struct speex_coder_pvt {
void *speex;
struct ast_frame f;
SpeexBits bits;
int framesize;
/* Space to build offset */
char offset[AST_FRIENDLY_OFFSET];
int silent_state;
#ifdef _SPEEX_TYPES_H
SpeexPreprocessState *pp;
/* Buffer for our outgoing frame */
spx_int16_t outbuf[8000];
/* Enough to store a full second */
spx_int16_t buf[8000];
spx_int16_t buf[BUFFER_SAMPLES];
#else
short outbuf[8000];
short buf[8000];
int16_t buf[BUFFER_SAMPLES]; /* input, waiting to be compressed */
#endif
int tail;
int silent_state;
};
#define speex_coder_pvt ast_translator_pvt
static struct ast_translator_pvt *lintospeex_new(void)
static void *lintospeex_new(struct ast_trans_pvt *pvt)
{
struct speex_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
if (!(tmp->speex = speex_encoder_init(&speex_nb_mode))) {
free(tmp);
tmp = NULL;
} else {
speex_bits_init(&tmp->bits);
speex_bits_reset(&tmp->bits);
speex_encoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
speex_encoder_ctl(tmp->speex, SPEEX_SET_COMPLEXITY, &complexity);
struct speex_coder_pvt *tmp = pvt->pvt;
if (!(tmp->speex = speex_encoder_init(&speex_nb_mode)))
return NULL;
speex_bits_init(&tmp->bits);
speex_bits_reset(&tmp->bits);
speex_encoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
ast_log(LOG_WARNING, "speex framesize is %d\n", tmp->framesize);
speex_encoder_ctl(tmp->speex, SPEEX_SET_COMPLEXITY, &complexity);
#ifdef _SPEEX_TYPES_H
if (preproc) {
tmp->pp = speex_preprocess_state_init(tmp->framesize, 8000);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_VAD, &pp_vad);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC, &pp_agc);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &pp_agc_level);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DENOISE, &pp_denoise);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB, &pp_dereverb);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &pp_dereverb_decay);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &pp_dereverb_level);
}
#endif
if (!abr && !vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_QUALITY, &quality);
if (vad)
speex_encoder_ctl(tmp->speex, SPEEX_SET_VAD, &vad);
}
if (vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR, &vbr);
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR_QUALITY, &vbr_quality);
}
if (abr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_ABR, &abr);
}
if (dtx)
speex_encoder_ctl(tmp->speex, SPEEX_SET_DTX, &dtx);
tmp->tail = 0;
tmp->silent_state = 0;
}
localusecnt++;
if (preproc) {
tmp->pp = speex_preprocess_state_init(tmp->framesize, 8000); /* XXX what is this 8000 ? */
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_VAD, &pp_vad);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC, &pp_agc);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_AGC_LEVEL, &pp_agc_level);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DENOISE, &pp_denoise);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB, &pp_dereverb);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &pp_dereverb_decay);
speex_preprocess_ctl(tmp->pp, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &pp_dereverb_level);
}
#endif
if (!abr && !vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_QUALITY, &quality);
if (vad)
speex_encoder_ctl(tmp->speex, SPEEX_SET_VAD, &vad);
}
if (vbr) {
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR, &vbr);
speex_encoder_ctl(tmp->speex, SPEEX_SET_VBR_QUALITY, &vbr_quality);
}
if (abr)
speex_encoder_ctl(tmp->speex, SPEEX_SET_ABR, &abr);
if (dtx)
speex_encoder_ctl(tmp->speex, SPEEX_SET_DTX, &dtx);
tmp->silent_state = 0;
return tmp;
}
static struct ast_translator_pvt *speextolin_new(void)
static void *speextolin_new(struct ast_trans_pvt *pvt)
{
struct speex_coder_pvt *tmp;
if ((tmp = ast_malloc(sizeof(*tmp)))) {
if (!(tmp->speex = speex_decoder_init(&speex_nb_mode))) {
free(tmp);
tmp = NULL;
} else {
speex_bits_init(&tmp->bits);
speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
if (enhancement)
speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);
tmp->tail = 0;
}
localusecnt++;
}
struct speex_coder_pvt *tmp = pvt->pvt;
if (!(tmp->speex = speex_decoder_init(&speex_nb_mode)))
return NULL;
speex_bits_init(&tmp->bits);
speex_decoder_ctl(tmp->speex, SPEEX_GET_FRAME_SIZE, &tmp->framesize);
if (enhancement)
speex_decoder_ctl(tmp->speex, SPEEX_SET_ENH, &enhancement);
return tmp;
}
@@ -197,7 +176,7 @@ static struct ast_frame *speextolin_sample(void)
f.subclass = AST_FORMAT_SPEEX;
f.datalen = sizeof(speex_slin_ex);
/* All frames are 20 ms long */
f.samples = 160;
f.samples = SPEEX_SAMPLES;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
@@ -205,122 +184,91 @@ static struct ast_frame *speextolin_sample(void)
return &f;
}
static struct ast_frame *speextolin_frameout(struct ast_translator_pvt *tmp)
/*! \brief convert and store into outbuf */
static int speextolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
if (!tmp->tail)
return NULL;
/* Signed linear is no particular frame size, so just send whatever
we have in the buffer in one lump sum */
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
/* Assume 8000 Hz */
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->buf;
/* Reset tail pointer */
tmp->tail = 0;
return &tmp->f;
}
struct speex_coder_pvt *tmp = pvt->pvt;
static int speextolin_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
{
/* Assuming there's space left, decode into the current buffer at
the tail location. Read in as many frames as there are */
int x;
int res;
int16_t *dst = (int16_t *)pvt->outbuf;
/* XXX fout is a temporary buffer, may have different types */
#ifdef _SPEEX_TYPES_H
spx_int16_t out[1024];
spx_int16_t fout[1024];
#else
float fout[1024];
#endif
if (f->datalen == 0) { /* Native PLC interpolation */
if (tmp->tail + tmp->framesize > sizeof(tmp->buf) / 2) {
if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
#ifdef _SPEEX_TYPES_H
speex_decode_int(tmp->speex, NULL, tmp->buf + tmp->tail);
speex_decode_int(tmp->speex, NULL, dst + pvt->samples);
#else
speex_decode(tmp->speex, NULL, fout);
for (x=0;x<tmp->framesize;x++) {
tmp->buf[tmp->tail + x] = fout[x];
dst[pvt->samples + x] = (int16_t)fout[x];
}
#endif
tmp->tail += tmp->framesize;
pvt->samples += tmp->framesize;
return 0;
}
/* Read in bits */
speex_bits_read_from(&tmp->bits, f->data, f->datalen);
for(;;) {
for (;;) {
#ifdef _SPEEX_TYPES_H
res = speex_decode_int(tmp->speex, &tmp->bits, out);
res = speex_decode_int(tmp->speex, &tmp->bits, fout);
#else
res = speex_decode(tmp->speex, &tmp->bits, fout);
#endif
if (res < 0)
break;
if (tmp->tail + tmp->framesize < sizeof(tmp->buf) / 2) {
for (x=0;x<tmp->framesize;x++) {
#ifdef _SPEEX_TYPES_H
tmp->buf[tmp->tail + x] = out[x];
#else
tmp->buf[tmp->tail + x] = fout[x];
#endif
}
tmp->tail += tmp->framesize;
} else {
if (pvt->samples + tmp->framesize > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
for (x = 0 ; x < tmp->framesize; x++)
dst[pvt->samples + x] = (int16_t)fout[x];
pvt->samples += tmp->framesize;
pvt->datalen += 2 * tmp->framesize; /* 2 bytes/sample */
}
return 0;
}
static int lintospeex_framein(struct ast_translator_pvt *tmp, struct ast_frame *f)
/*! \brief store input frame in work buffer */
static int lintospeex_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
/* Just add the frames to our stream */
struct speex_coder_pvt *tmp = pvt->pvt;
/* XXX We should look at how old the rest of our stream is, and if it
is too old, then we should overwrite it entirely, otherwise we can
get artifacts of earlier talk that do not belong */
if (tmp->tail + f->datalen/2 < sizeof(tmp->buf) / 2) {
memcpy((tmp->buf + tmp->tail), f->data, f->datalen);
tmp->tail += f->datalen/2;
} else {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
pvt->samples += f->samples;
return 0;
}
static struct ast_frame *lintospeex_frameout(struct ast_translator_pvt *tmp)
/*! \brief convert work buffer and produce output frame */
static struct ast_frame *lintospeex_frameout(struct ast_trans_pvt *pvt)
{
#ifndef _SPEEX_TYPES_H
float fbuf[1024];
int x;
#endif
int len;
int y=0;
struct speex_coder_pvt *tmp = pvt->pvt;
int is_speech=1;
int datalen = 0; /* output bytes */
int samples = 0; /* output samples */
/* We can't work on anything less than a frame in size */
if (tmp->tail < tmp->framesize)
if (pvt->samples < tmp->framesize)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SPEEX;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
speex_bits_reset(&tmp->bits);
while(tmp->tail >= tmp->framesize) {
while (pvt->samples >= tmp->framesize) {
#ifdef _SPEEX_TYPES_H
/* Preprocess audio */
if(preproc)
if (preproc)
is_speech = speex_preprocess(tmp->pp, tmp->buf, NULL);
/* Encode a frame of data */
if (is_speech) {
@@ -331,254 +279,230 @@ static struct ast_frame *lintospeex_frameout(struct ast_translator_pvt *tmp)
speex_bits_pack(&tmp->bits, 0, 5);
}
#else
/* Convert to floating point */
for (x=0;x<tmp->framesize;x++)
fbuf[x] = tmp->buf[x];
/* Encode a frame of data */
is_speech = speex_encode(tmp->speex, fbuf, &tmp->bits) || !dtx;
{
float fbuf[1024];
int x;
/* Convert to floating point */
for (x = 0; x < tmp->framesize; x++)
fbuf[x] = tmp->buf[x];
/* Encode a frame of data */
is_speech = speex_encode(tmp->speex, fbuf, &tmp->bits) || !dtx;
}
#endif
/* Assume 8000 Hz -- 20 ms */
tmp->tail -= tmp->framesize;
samples += tmp->framesize;
pvt->samples -= tmp->framesize;
/* Move the data at the end of the buffer to the front */
if (tmp->tail)
memmove(tmp->buf, tmp->buf + tmp->framesize, tmp->tail * 2);
y++;
if (pvt->samples)
memmove(tmp->buf, tmp->buf + tmp->framesize, pvt->samples * 2);
}
/* Use AST_FRAME_CNG to signify the start of any silence period */
if (!is_speech) {
if (is_speech) {
tmp->silent_state = 0;
} else {
if (tmp->silent_state) {
return NULL;
} else {
tmp->silent_state = 1;
speex_bits_reset(&tmp->bits);
tmp->f.frametype = AST_FRAME_CNG;
memset(&pvt->f, 0, sizeof(pvt->f));
pvt->f.frametype = AST_FRAME_CNG;
pvt->f.samples = samples;
/* XXX what now ? format etc... */
}
} else {
tmp->silent_state = 0;
}
/* Terminate bit stream */
speex_bits_pack(&tmp->bits, 15, 5);
len = speex_bits_write(&tmp->bits, (char *)tmp->outbuf, sizeof(tmp->outbuf));
tmp->f.datalen = len;
tmp->f.samples = y * 160;
#if 0
{
static int fd = -1;
if (fd < 0) {
fd = open("speex.raw", O_WRONLY|O_TRUNC|O_CREAT);
if (fd > -1) {
write(fd, tmp->f.data, tmp->f.datalen);
close(fd);
}
}
}
#endif
return &tmp->f;
datalen = speex_bits_write(&tmp->bits, pvt->outbuf, pvt->t->buf_size);
return ast_trans_frameout(pvt, datalen, samples);
}
static void speextolin_destroy(struct ast_translator_pvt *pvt)
static void speextolin_destroy(struct ast_trans_pvt *arg)
{
struct speex_coder_pvt *pvt = arg->pvt;
speex_decoder_destroy(pvt->speex);
speex_bits_destroy(&pvt->bits);
free(pvt);
localusecnt--;
}
static void lintospeex_destroy(struct ast_translator_pvt *pvt)
static void lintospeex_destroy(struct ast_trans_pvt *arg)
{
struct speex_coder_pvt *pvt = arg->pvt;
#ifdef _SPEEX_TYPES_H
if (preproc)
speex_preprocess_state_destroy(pvt->pp);
#endif
speex_encoder_destroy(pvt->speex);
speex_bits_destroy(&pvt->bits);
free(pvt);
localusecnt--;
}
static struct ast_translator speextolin =
{ "speextolin",
AST_FORMAT_SPEEX, AST_FORMAT_SLINEAR,
speextolin_new,
speextolin_framein,
speextolin_frameout,
speextolin_destroy,
speextolin_sample
};
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator lintospeex =
{ "lintospeex",
AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX,
lintospeex_new,
lintospeex_framein,
lintospeex_frameout,
lintospeex_destroy,
lintospeex_sample
};
static struct ast_translator speextolin = {
.name = "speextolin",
.srcfmt = AST_FORMAT_SPEEX,
.dstfmt = AST_FORMAT_SLINEAR,
.newpvt = speextolin_new,
.framein = speextolin_framein,
.destroy = speextolin_destroy,
.sample = speextolin_sample,
.desc_size = sizeof(struct speex_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.lockp = &me,
};
static struct ast_translator lintospeex = {
.name = "lintospeex",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_SPEEX,
.newpvt = lintospeex_new,
.framein = lintospeex_framein,
.frameout = lintospeex_frameout,
.destroy = lintospeex_destroy,
.sample = lintospeex_sample,
.desc_size = sizeof(struct speex_coder_pvt),
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2, /* XXX maybe a lot less ? */
.lockp = &me,
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_config *cfg = ast_config_load("codecs.conf");
struct ast_variable *var;
int res;
float res_f;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "speex"))) {
while (var) {
if (!strcasecmp(var->name, "quality")) {
res = abs(atoi(var->value));
if (res > -1 && res < 11) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting Quality to %d\n",res);
ast_mutex_lock(&localuser_lock);
quality = res;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error Quality must be 0-10\n");
} else if (!strcasecmp(var->name, "complexity")) {
res = abs(atoi(var->value));
if (res > -1 && res < 11) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting Complexity to %d\n",res);
ast_mutex_lock(&localuser_lock);
complexity = res;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! Complexity must be 0-10\n");
} else if (!strcasecmp(var->name, "vbr_quality")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0 && res_f <= 10) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting VBR Quality to %f\n",res_f);
ast_mutex_lock(&localuser_lock);
vbr_quality = res_f;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! VBR Quality must be 0-10\n");
} else if (!strcasecmp(var->name, "abr_quality")) {
ast_log(LOG_ERROR,"Error! ABR Quality setting obsolete, set ABR to desired bitrate\n");
} else if (!strcasecmp(var->name, "enhancement")) {
ast_mutex_lock(&localuser_lock);
enhancement = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Perceptual Enhancement Mode. [%s]\n",enhancement ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "vbr")) {
ast_mutex_lock(&localuser_lock);
vbr = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: VBR Mode. [%s]\n",vbr ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "abr")) {
res = abs(atoi(var->value));
if (res >= 0) {
if (option_verbose > 2) {
if (res > 0)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting ABR target bitrate to %d\n",res);
else
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Disabling ABR\n");
}
ast_mutex_lock(&localuser_lock);
abr = res;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! ABR target bitrate must be >= 0\n");
} else if (!strcasecmp(var->name, "vad")) {
ast_mutex_lock(&localuser_lock);
vad = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: VAD Mode. [%s]\n",vad ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "dtx")) {
ast_mutex_lock(&localuser_lock);
dtx = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: DTX Mode. [%s]\n",dtx ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "preprocess")) {
ast_mutex_lock(&localuser_lock);
preproc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessing. [%s]\n",preproc ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "pp_vad")) {
ast_mutex_lock(&localuser_lock);
pp_vad = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor VAD. [%s]\n",pp_vad ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "pp_agc")) {
ast_mutex_lock(&localuser_lock);
pp_agc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor AGC. [%s]\n",pp_agc ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "pp_agc_level")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor AGC Level to %f\n",res_f);
ast_mutex_lock(&localuser_lock);
pp_agc_level = res_f;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! Preprocessor AGC Level must be >= 0\n");
} else if (!strcasecmp(var->name, "pp_denoise")) {
ast_mutex_lock(&localuser_lock);
pp_denoise = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor Denoise. [%s]\n",pp_denoise ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "pp_dereverb")) {
ast_mutex_lock(&localuser_lock);
pp_dereverb = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor Dereverb. [%s]\n",pp_dereverb ? "on" : "off");
ast_mutex_unlock(&localuser_lock);
} else if (!strcasecmp(var->name, "pp_dereverb_decay")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor Dereverb Decay to %f\n",res_f);
ast_mutex_lock(&localuser_lock);
pp_dereverb_decay = res_f;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Decay must be >= 0\n");
} else if (!strcasecmp(var->name, "pp_dereverb_level")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor Dereverb Level to %f\n",res_f);
ast_mutex_lock(&localuser_lock);
pp_dereverb_level = res_f;
ast_mutex_unlock(&localuser_lock);
} else
ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Level must be >= 0\n");
if (cfg == NULL)
return;
for (var = ast_variable_browse(cfg, "speex"); var; var = var->next) {
if (!strcasecmp(var->name, "quality")) {
res = abs(atoi(var->value));
if (res > -1 && res < 11) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting Quality to %d\n",res);
quality = res;
} else
ast_log(LOG_ERROR,"Error Quality must be 0-10\n");
} else if (!strcasecmp(var->name, "complexity")) {
res = abs(atoi(var->value));
if (res > -1 && res < 11) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting Complexity to %d\n",res);
complexity = res;
} else
ast_log(LOG_ERROR,"Error! Complexity must be 0-10\n");
} else if (!strcasecmp(var->name, "vbr_quality")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0 && res_f <= 10) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting VBR Quality to %f\n",res_f);
vbr_quality = res_f;
} else
ast_log(LOG_ERROR,"Error! VBR Quality must be 0-10\n");
} else if (!strcasecmp(var->name, "abr_quality")) {
ast_log(LOG_ERROR,"Error! ABR Quality setting obsolete, set ABR to desired bitrate\n");
} else if (!strcasecmp(var->name, "enhancement")) {
enhancement = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Perceptual Enhancement Mode. [%s]\n",enhancement ? "on" : "off");
} else if (!strcasecmp(var->name, "vbr")) {
vbr = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: VBR Mode. [%s]\n",vbr ? "on" : "off");
} else if (!strcasecmp(var->name, "abr")) {
res = abs(atoi(var->value));
if (res >= 0) {
if (option_verbose > 2) {
if (res > 0)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting ABR target bitrate to %d\n",res);
else
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Disabling ABR\n");
}
var = var->next;
}
abr = res;
} else
ast_log(LOG_ERROR,"Error! ABR target bitrate must be >= 0\n");
} else if (!strcasecmp(var->name, "vad")) {
vad = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: VAD Mode. [%s]\n",vad ? "on" : "off");
} else if (!strcasecmp(var->name, "dtx")) {
dtx = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: DTX Mode. [%s]\n",dtx ? "on" : "off");
} else if (!strcasecmp(var->name, "preprocess")) {
preproc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessing. [%s]\n",preproc ? "on" : "off");
} else if (!strcasecmp(var->name, "pp_vad")) {
pp_vad = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor VAD. [%s]\n",pp_vad ? "on" : "off");
} else if (!strcasecmp(var->name, "pp_agc")) {
pp_agc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor AGC. [%s]\n",pp_agc ? "on" : "off");
} else if (!strcasecmp(var->name, "pp_agc_level")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor AGC Level to %f\n",res_f);
pp_agc_level = res_f;
} else
ast_log(LOG_ERROR,"Error! Preprocessor AGC Level must be >= 0\n");
} else if (!strcasecmp(var->name, "pp_denoise")) {
pp_denoise = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor Denoise. [%s]\n",pp_denoise ? "on" : "off");
} else if (!strcasecmp(var->name, "pp_dereverb")) {
pp_dereverb = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Preprocessor Dereverb. [%s]\n",pp_dereverb ? "on" : "off");
} else if (!strcasecmp(var->name, "pp_dereverb_decay")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor Dereverb Decay to %f\n",res_f);
pp_dereverb_decay = res_f;
} else
ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Decay must be >= 0\n");
} else if (!strcasecmp(var->name, "pp_dereverb_level")) {
if (sscanf(var->value, "%f", &res_f) == 1 && res_f >= 0) {
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "CODEC SPEEX: Setting preprocessor Dereverb Level to %f\n",res_f);
pp_dereverb_level = res_f;
} else
ast_log(LOG_ERROR,"Error! Preprocessor Dereverb Level must be >= 0\n");
}
ast_config_destroy(cfg);
}
ast_config_destroy(cfg);
}
int reload(void)
{
/*
* XXX reloading while there are active sessions is
* somewhat silly because the old state presumably
* wouldn't work anymore...
* maybe we shuld do a standard hangup localusers ?
*/
ast_mutex_lock(&me.lock);
parse_config();
ast_mutex_lock(&me.lock);
return 0;
}
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintospeex);
if (!res)
res = ast_unregister_translator(&speextolin);
if (localusecnt)
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -596,14 +520,12 @@ int load_module(void)
char *description(void)
{
return tdesc;
return "Speex/PCM16 (signed linear) Codec Translator";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()

320
codecs/codec_ulaw.c
View File

@@ -44,235 +44,43 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/ulaw.h"
#include "asterisk/utils.h"
#define BUFFER_SIZE 8096 /* size for the translation buffers */
AST_MUTEX_DEFINE_STATIC(localuser_lock);
static int localusecnt = 0;
static char *tdesc = "Mu-law Coder/Decoder";
static int useplc = 0;
#define BUFFER_SAMPLES 8096 /* size for the translation buffers */
/* Sample frame data */
#include "slin_ulaw_ex.h"
#include "ulaw_slin_ex.h"
/*!
* \brief Private workspace for translating signed linear signals to ulaw.
*/
struct ulaw_encoder_pvt
/*! \brief convert and store samples in outbuf */
static int ulawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /*!< Space to build offset */
unsigned char outbuf[BUFFER_SIZE]; /*!< Encoded ulaw, two nibbles to a word */
int tail;
};
int i;
unsigned char *src = f->data;
int16_t *dst = (int16_t *)pvt->outbuf;
/*!
* \brief Private workspace for translating ulaw signals to signed linear.
*/
/* convert and copy in outbuf */
for (i=0; i<f->samples; i++)
dst[pvt->samples + i] = AST_MULAW(src[i]);
struct ulaw_decoder_pvt
{
struct ast_frame f;
char offset[AST_FRIENDLY_OFFSET]; /* Space to build offset */
short outbuf[BUFFER_SIZE]; /* Decoded signed linear values */
int tail;
plc_state_t plc;
};
/*!
* \brief ulawToLin_New
* Create a new instance of ulaw_decoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *ulawtolin_new(void)
{
struct ulaw_decoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
tmp->tail = 0;
plc_init(&tmp->plc);
localusecnt++;
ast_update_use_count();
}
return (struct ast_translator_pvt *)tmp;
}
/*!
* \brief LinToulaw_New
* Create a new instance of ulaw_encoder_pvt.
*
* Results:
* Returns a pointer to the new instance.
*
* Side effects:
* None.
*/
static struct ast_translator_pvt *lintoulaw_new(void)
{
struct ulaw_encoder_pvt *tmp;
if ((tmp = ast_calloc(1, sizeof(*tmp)))) {
localusecnt++;
ast_update_use_count();
tmp->tail = 0;
}
return (struct ast_translator_pvt *)tmp;
}
/*!
* \brief ulawToLin_FrameIn
* Fill an input buffer with packed 4-bit ulaw values if there is room
* left.
*
* Results:
* Foo
*
* Side effects:
* tmp->tail is the number of packed values in the buffer.
*/
static int ulawtolin_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct ulaw_decoder_pvt *tmp = (struct ulaw_decoder_pvt *)pvt;
int x;
unsigned char *b;
if(f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */
if((tmp->tail + 160) * 2 > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
if(useplc) {
plc_fillin(&tmp->plc, tmp->outbuf+tmp->tail, 160);
tmp->tail += 160;
}
return 0;
}
if ((tmp->tail + f->datalen) * 2 > sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
/* Reset ssindex and signal to frame's specified values */
b = f->data;
for (x=0;x<f->datalen;x++)
tmp->outbuf[tmp->tail + x] = AST_MULAW(b[x]);
if(useplc)
plc_rx(&tmp->plc, tmp->outbuf+tmp->tail, f->datalen);
tmp->tail += f->datalen;
pvt->samples += f->samples;
pvt->datalen += 2 * f->samples;
return 0;
}
/*!
* \brief ulawToLin_FrameOut
* Convert 4-bit ulaw encoded signals to 16-bit signed linear.
*
* Results:
* Converted signals are placed in tmp->f.data, tmp->f.datalen
* and tmp->f.samples are calculated.
*
* Side effects:
* None.
*/
static struct ast_frame *ulawtolin_frameout(struct ast_translator_pvt *pvt)
/*! \brief convert and store samples in outbuf */
static int lintoulaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct ulaw_decoder_pvt *tmp = (struct ulaw_decoder_pvt *)pvt;
int i;
int16_t *src = f->data;
if (!tmp->tail)
return NULL;
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_SLINEAR;
tmp->f.datalen = tmp->tail * 2;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->tail = 0;
return &tmp->f;
}
/*!
* \brief LinToulaw_FrameIn
* Fill an input buffer with 16-bit signed linear PCM values.
*
* Results:
* None.
*
* Side effects:
* tmp->tail is number of signal values in the input buffer.
*/
static int lintoulaw_framein(struct ast_translator_pvt *pvt, struct ast_frame *f)
{
struct ulaw_encoder_pvt *tmp = (struct ulaw_encoder_pvt *)pvt;
int x;
short *s;
if (tmp->tail + f->datalen / 2 >= sizeof(tmp->outbuf)) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
s = f->data;
for (x=0;x<f->datalen/2;x++)
tmp->outbuf[x+tmp->tail] = AST_LIN2MU(s[x]);
tmp->tail += f->datalen/2;
for (i=0 ; i < f->samples; i++)
pvt->outbuf[pvt->samples + i] = AST_LIN2MU(src[i]);
pvt->samples += f->samples;
pvt->datalen += f->samples; /* 1 byte/sample */
return 0;
}
/*!
* \brief LinToulaw_FrameOut
* Convert a buffer of raw 16-bit signed linear PCM to a buffer
* of 4-bit ulaw packed two to a byte (Big Endian).
*
* Results:
* Foo
*
* Side effects:
* Leftover inbuf data gets packed, tail gets updated.
*/
static struct ast_frame *lintoulaw_frameout(struct ast_translator_pvt *pvt)
{
struct ulaw_encoder_pvt *tmp = (struct ulaw_encoder_pvt *)pvt;
if (tmp->tail) {
tmp->f.frametype = AST_FRAME_VOICE;
tmp->f.subclass = AST_FORMAT_ULAW;
tmp->f.samples = tmp->tail;
tmp->f.mallocd = 0;
tmp->f.offset = AST_FRIENDLY_OFFSET;
tmp->f.src = __PRETTY_FUNCTION__;
tmp->f.data = tmp->outbuf;
tmp->f.datalen = tmp->tail;
tmp->tail = 0;
return &tmp->f;
} else
return NULL;
}
/*!
* \brief ulawToLin_Sample
*/
/*! * \brief ulawToLin_Sample */
static struct ast_frame *ulawtolin_sample(void)
{
static struct ast_frame f;
@@ -306,38 +114,22 @@ static struct ast_frame *lintoulaw_sample(void)
return &f;
}
/*!
* \brief ulaw_Destroy
* Destroys a private workspace.
*
* Results:
* It's gone!
*
* Side effects:
* None.
*/
static void ulaw_destroy(struct ast_translator_pvt *pvt)
{
free(pvt);
localusecnt--;
ast_update_use_count();
}
/*!
* \brief The complete translator for ulawToLin.
*/
static struct ast_module_lock me = { .usecnt = -1 };
static struct ast_translator ulawtolin = {
"ulawtolin",
AST_FORMAT_ULAW,
AST_FORMAT_SLINEAR,
ulawtolin_new,
ulawtolin_framein,
ulawtolin_frameout,
ulaw_destroy,
/* NULL */
ulawtolin_sample
.name = "ulawtolin",
.srcfmt = AST_FORMAT_ULAW,
.dstfmt = AST_FORMAT_SLINEAR,
.framein = ulawtolin_framein,
.sample = ulawtolin_sample,
.lockp = &me,
.buffer_samples = BUFFER_SAMPLES,
.buf_size = BUFFER_SAMPLES * 2,
.plc_samples = 160,
};
/*!
@@ -345,34 +137,30 @@ static struct ast_translator ulawtolin = {
*/
static struct ast_translator lintoulaw = {
"lintoulaw",
AST_FORMAT_SLINEAR,
AST_FORMAT_ULAW,
lintoulaw_new,
lintoulaw_framein,
lintoulaw_frameout,
ulaw_destroy,
/* NULL */
lintoulaw_sample
.name = "lintoulaw",
.srcfmt = AST_FORMAT_SLINEAR,
.dstfmt = AST_FORMAT_ULAW,
.framein = lintoulaw_framein,
.sample = lintoulaw_sample,
.lockp = &me,
.buf_size = BUFFER_SAMPLES,
.buffer_samples = BUFFER_SAMPLES,
};
static void parse_config(void)
{
struct ast_config *cfg;
struct ast_variable *var;
if ((cfg = ast_config_load("codecs.conf"))) {
if ((var = ast_variable_browse(cfg, "plc"))) {
while (var) {
if (!strcasecmp(var->name, "genericplc")) {
useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_ulaw: %susing generic PLC\n", useplc ? "" : "not ");
}
var = var->next;
}
struct ast_config *cfg = ast_config_load("codecs.conf");
if (cfg == NULL)
return;
for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) {
if (!strcasecmp(var->name, "genericplc")) {
ulawtolin.useplc = ast_true(var->value) ? 1 : 0;
if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_3 "codec_ulaw: %susing generic PLC\n", ulawtolin.useplc ? "" : "not ");
}
ast_config_destroy(cfg);
}
ast_config_destroy(cfg);
}
int reload(void)
@@ -384,13 +172,13 @@ int reload(void)
int unload_module(void)
{
int res;
ast_mutex_lock(&localuser_lock);
ast_mutex_lock(&me.lock);
res = ast_unregister_translator(&lintoulaw);
if (!res)
res = ast_unregister_translator(&ulawtolin);
if (localusecnt)
if (me.usecnt)
res = -1;
ast_mutex_unlock(&localuser_lock);
ast_mutex_unlock(&me.lock);
return res;
}
@@ -412,14 +200,12 @@ int load_module(void)
char *description(void)
{
return tdesc;
return "Mu-law Coder/Decoder";
}
int usecount(void)
{
int res;
OLD_STANDARD_USECOUNT(res);
return res;
return me.usecnt;
}
char *key()