static int libgsm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt) {
uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int out_size = avctx->frame_size * av_get_bytes_per_sample(avctx->sample_fmt);
if (*data_size < out_size) {
av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
return AVERROR(EINVAL);
}
*data_size = 0; /* In case of error */
if(buf_size < avctx->block_align) return -1;
switch(avctx->codec_id) {
case CODEC_ID_GSM:
if(gsm_decode(avctx->priv_data,buf,data)) return -1;
break;
case CODEC_ID_GSM_MS:
if(gsm_decode(avctx->priv_data,buf,data) ||
gsm_decode(avctx->priv_data,buf+33,((int16_t*)data)+GSM_FRAME_SIZE)) return -1;
}
*data_size = out_size;
return avctx->block_align;
}
static int
wav_gsm610_read_block (SF_PRIVATE *psf, GSM610_PRIVATE *pgsm610)
{ int k ;
pgsm610->blockcount ++ ;
pgsm610->samplecount = 0 ;
if (pgsm610->blockcount > pgsm610->blocks)
{ memset (pgsm610->samples, 0, GSM610_SAMPLES * sizeof (short)) ;
return 1 ;
} ;
if ((k = fread (pgsm610->block, 1, GSM610_BLOCKSIZE, psf->file)) != GSM610_BLOCKSIZE)
psf_log_printf (psf, "*** Warning : short read (%d != %d).\n", k, GSM610_BLOCKSIZE) ;
if (gsm_decode (pgsm610->gsm_data, pgsm610->block, pgsm610->samples) < 0)
{ psf_log_printf (psf, "Error from gsm_decode() on frame : %d\n", pgsm610->blockcount) ;
return 0 ;
} ;
if (gsm_decode (pgsm610->gsm_data, pgsm610->block+(GSM610_BLOCKSIZE+1)/2, pgsm610->samples+GSM610_SAMPLES/2) < 0)
{ psf_log_printf (psf, "Error from gsm_decode() on frame : %d.5\n", pgsm610->blockcount) ;
return 0 ;
} ;
return 1 ;
} /* wav_gsm610_read_block */
int voice_play(const char *buf, int length, int codec)
{
if (length <= 0)
return 0;
if (codec == EKG_CODEC_SPEEX) {
#if HAVE_SPEEX
spx_int16_t speex_output[320];
speex_bits_read_from(&speex_dec_bits, buf, length);
speex_decode_int(voice_speex_dec, &speex_dec_bits, speex_output); /* XXX, != 0 return? */
if (write(voice_fd, speex_output, sizeof(speex_output)) != sizeof(speex_output))
return -1;
return 0;
#else
printf("voice_play() received speex packet, but HAVE_SPEEX\n");
return -1;
#endif
}
if (codec == EKG_CODEC_GSM) {
#if HAVE_GSM
const int ramki_dwie = 33 + 33;
gsm_signal gsm_output[160];
const char *pos = buf;
while (pos <= (buf + length - ramki_dwie)) {
switch (codec) {
case EKG_CODEC_GSM:
if (gsm_decode(voice_gsm_dec, (unsigned char *) pos, gsm_output)) return -1;
pos += 33;
break;
}
if (write(voice_fd, gsm_output, 320) != 320)
return -1;
switch (codec) {
case EKG_CODEC_GSM:
if (gsm_decode(voice_gsm_dec, (unsigned char *) pos, gsm_output)) return -1;
pos += 33;
break;
}
if (write(voice_fd, gsm_output, 320) != 320)
return -1;
}
return 0;
#else
printf("voice_play() received gsm packet, but HAVE_GSM\n");
return -1;
#endif
}
return -1;
}
static int codec_decoder(const struct PluginCodec_Definition * codec,
void * _context,
const void * from,
unsigned * fromLen,
void * to,
unsigned * toLen,
unsigned int * flag)
{
gsm context = (gsm)_context;
if (*fromLen < BYTES_PER_FRAME)
return 0;
// if the packet is not 65 bytes long, assume it is frames of normal GSM
if (*fromLen != 65) {
int frames;
if (*toLen < SAMPLES_PER_FRAME * 2)
return 0;
frames = MIN(*toLen / (SAMPLES_PER_FRAME * 2), (*fromLen / BYTES_PER_FRAME));
if (frames == 0)
return 0;
{
int opt = 0;
gsm_option(context, GSM_OPT_WAV49, &opt);
}
*fromLen = frames * BYTES_PER_FRAME;
*toLen = frames * SAMPLES_PER_FRAME * 2;
while (frames-- > 0) {
gsm_decode(context, (void *)from, to);
from = ((const char *)from) + BYTES_PER_FRAME;
to = ((char *)to) + SAMPLES_PER_FRAME * 2;
}
return 1;
}
// MS-GSM packets are always 65 bytes long, and consists of two GSM packets
if (*toLen < MSGSM_SAMPLES_PER_FRAME * 2)
return 0;
{
int opt = 1;
gsm_option(context, GSM_OPT_WAV49, &opt);
}
gsm_decode(context, (unsigned char *)from, (short *)to);
gsm_decode(context, ((unsigned char *)from)+33, ((short *)to)+160);
*toLen = MSGSM_SAMPLES_PER_FRAME * 2;
return 1;
}
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 */
int x;
unsigned char data[66];
int msgsm=0;
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) {
/* Translate MSGSM format to Real GSM format before feeding in */
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");
return -1;
}
}
}
return 0;
}
static int libgsm_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
int i, ret;
LibGSMDecodeContext *s = avctx->priv_data;
uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int16_t *samples;
if (buf_size < avctx->block_align) {
av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
return AVERROR_INVALIDDATA;
}
/* get output buffer */
s->frame.nb_samples = avctx->frame_size;
if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
samples = (int16_t *)s->frame.data[0];
for (i = 0; i < avctx->frame_size / GSM_FRAME_SIZE; i++) {
if ((ret = gsm_decode(s->state, buf, samples)) < 0)
return -1;
buf += GSM_BLOCK_SIZE;
samples += GSM_FRAME_SIZE;
}
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
return avctx->block_align;
}
tsk_size_t tdav_codec_gsm_decode(tmedia_codec_t* self, const void* in_data, tsk_size_t in_size, void** out_data, tsk_size_t* out_max_size, const tsk_object_t* proto_hdr)
{
tsk_size_t out_size;
int ret;
tdav_codec_gsm_t* gsm = (tdav_codec_gsm_t*)self;
if(!self || !in_data || !in_size || !out_data || (in_size % TDAV_GSM_FRAME_SIZE)) {
TSK_DEBUG_ERROR("Invalid parameter");
return 0;
}
out_size = (in_size / TDAV_GSM_FRAME_SIZE) * (TMEDIA_CODEC_PCM_FRAME_SIZE(self) * sizeof(short));
/* allocate new buffer if needed */
if(*out_max_size <out_size) {
if(!(*out_data = tsk_realloc(*out_data, out_size))) {
TSK_DEBUG_ERROR("Failed to allocate new buffer");
*out_max_size = 0;
return 0;
}
*out_max_size = out_size;
}
ret = gsm_decode(gsm->decoder, (gsm_byte*)in_data, (gsm_signal*)*out_data);
return out_size;
}
static int gsm_2_pcm16(unsigned char* out_buf, unsigned char* in_buf, unsigned int size,
unsigned int channels, unsigned int rate, long h_codec )
{
int i;
gsm* h_arr;
div_t blocks;
unsigned int out_size;
h_arr = (gsm*)h_codec;
blocks = div(size,33);
if(blocks.rem){
ERROR("gsm_2_pcm16: number of blocks should be integral (block size = 33)\n");
return -1;
}
out_size = blocks.quot * 320;
if(out_size > AUDIO_BUFFER_SIZE){
ERROR("gsm_2_pcm16: converting buffer would lead to buffer overrun:\n");
ERROR("gsm_2_pcm16: input size=%u; needed output size=%u; buffer size=%u\n",
size,out_size,AUDIO_BUFFER_SIZE);
return -1;
}
for (i=0;i<blocks.quot;i++)
gsm_decode(h_arr[1],in_buf + i*33,(gsm_signal*)(out_buf + i*320));
return out_size;
}
SRef<Processing_Data*> Gsm_Decoder_Instance::decode(const SRef<Rtp_Packet*>& rtp)
{
short*inBuf = rtp->get_content();
SRef<Processing_Data_Audio*> data = new Processing_Data_Audio(true);
data->samples = (short*)malloc(GSM_EXEPECTED_INPUT*sizeof(short));
data->nsamples = GSM_EXEPECTED_INPUT;
data->sfreq = codec->get_sampling_freq();
data->nchannels = 1;
data->rtp_seq_no = rtp->get_header().get_seq_no();
data->_rtp_timestamp = rtp->get_header().get_timestamp();
data->rtp_marker = rtp->get_header().get_marker();
data->ssrc= rtp->get_header().get_ssrc();
short *outBuf = data->samples;
if( inSize != GSM_FRAME_SIZE )
{
return 0;
}
if( gsm_decode( gsmState, (gsm_byte *)inBuf, (gsm_signal *)outBuf ) < 0 )
{
return 0;
}
return data;
}
static int libgsm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt) {
int i, ret;
struct gsm_state *s = avctx->priv_data;
uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int16_t *samples = data;
int out_size = avctx->frame_size * av_get_bytes_per_sample(avctx->sample_fmt);
if (*data_size < out_size) {
av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
return AVERROR(EINVAL);
}
if (buf_size < avctx->block_align) {
av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
return AVERROR_INVALIDDATA;
}
for (i = 0; i < avctx->frame_size / GSM_FRAME_SIZE; i++) {
if ((ret = gsm_decode(s, buf, samples)) < 0)
return -1;
buf += GSM_BLOCK_SIZE;
samples += GSM_FRAME_SIZE;
}
*data_size = out_size;
return avctx->block_align;
}
/*! \brief decode and store in outbuf. */
static int gsmtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct gsm_translator_pvt *tmp = pvt->pvt;
int x;
int16_t *dst = pvt->outbuf.i16;
/* 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;
for (x=0; x < f->datalen; x += flen) {
unsigned char data[2 * GSM_FRAME_LEN];
unsigned 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.ptr + x, data);
} else {
len = GSM_SAMPLES;
src = f->data.ptr + 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;
}
}
return 0;
}
static int libgsm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size) {
*data_size = 0; /* In case of error */
if(buf_size < avctx->block_align) return -1;
switch(avctx->codec_id) {
case CODEC_ID_GSM:
if(gsm_decode(avctx->priv_data,buf,data)) return -1;
*data_size = GSM_FRAME_SIZE*sizeof(int16_t);
break;
case CODEC_ID_GSM_MS:
if(gsm_decode(avctx->priv_data,buf,data) ||
gsm_decode(avctx->priv_data,buf+33,((int16_t*)data)+GSM_FRAME_SIZE)) return -1;
*data_size = GSM_FRAME_SIZE*sizeof(int16_t)*2;
}
return avctx->block_align;
}
// static
int SoftGSM::DecodeGSM(gsm handle,
int16_t *out, uint8_t *in, size_t inSize) {
int ret = 0;
while (inSize > 0) {
gsm_decode(handle, in, out);
in += 33;
inSize -= 33;
out += 160;
ret += 160;
gsm_decode(handle, in, out);
in += 32;
inSize -= 32;
out += 160;
ret += 160;
}
return ret;
}
static GstFlowReturn
gst_gsmdec_handle_frame (GstAudioDecoder * dec, GstBuffer * buffer)
{
GstGSMDec *gsmdec;
gsm_signal *out_data;
gsm_byte *data;
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *outbuf;
GstMapInfo map, omap;
gsize outsize;
guint frames, i, errors = 0;
/* no fancy draining */
if (G_UNLIKELY (!buffer))
return GST_FLOW_OK;
gsmdec = GST_GSMDEC (dec);
gst_buffer_map (buffer, &map, GST_MAP_READ);
frames = gst_gsmdec_get_frame_count (gsmdec, map.size);
/* always the same amount of output samples (20ms worth per frame) */
outsize = ENCODED_SAMPLES * frames * sizeof (gsm_signal);
outbuf = gst_buffer_new_and_alloc (outsize);
gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
out_data = (gsm_signal *) omap.data;
data = (gsm_byte *) map.data;
for (i = 0; i < frames; ++i) {
/* now encode frame into the output buffer */
if (gsm_decode (gsmdec->state, data, out_data) < 0) {
/* invalid frame */
GST_AUDIO_DECODER_ERROR (gsmdec, 1, STREAM, DECODE, (NULL),
("tried to decode an invalid frame"), ret);
memset (out_data, 0, ENCODED_SAMPLES * sizeof (gsm_signal));
++errors;
}
out_data += ENCODED_SAMPLES;
data += gsmdec->needed;
if (gsmdec->use_wav49)
gsmdec->needed = (gsmdec->needed == 33 ? 32 : 33);
}
gst_buffer_unmap (outbuf, &omap);
gst_buffer_unmap (buffer, &map);
if (errors == frames) {
gst_buffer_unref (outbuf);
outbuf = NULL;
}
gst_audio_decoder_finish_frame (dec, outbuf, 1);
return ret;
}
static int codec_msgsm_decoder(const struct PluginCodec_Definition * codec,
void * _context,
const void * from,
unsigned * fromLen,
void * to,
unsigned * toLen,
unsigned int * flag)
{
struct gsm_state * context = (struct gsm_state *)_context;
if (*fromLen < MSGSM_BYTES_PER_FRAME || *toLen < (MSGSM_SAMPLES_PER_FRAME*2))
return 0;
gsm_decode(context, (unsigned char *)from, (short *)to);
gsm_decode(context, ((unsigned char *)from)+33, ((short *)to)+160);
*toLen = MSGSM_SAMPLES_PER_FRAME * 2;
return 1;
}
static int libgsm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size) {
if(buf_size < GSM_BLOCK_SIZE) return 0;
if(gsm_decode(avctx->priv_data,buf,data)) return -1;
*data_size = GSM_FRAME_SIZE*2;
return GSM_BLOCK_SIZE;
}
static int codec_decoder(const struct PluginCodec_Definition * codec,
void * _context,
const void * from,
unsigned * fromLen,
void * to,
unsigned * toLen,
unsigned int * flag)
{
gsm context = (gsm)_context;
if (*fromLen < BYTES_PER_FRAME)
return 0;
// Unless the packet is 65 bytes long, it must be normal GSM
if (*fromLen != 65) {
if (*toLen < SAMPLES_PER_FRAME * 2)
return 0;
{
int opt = 0;
gsm_option(context, GSM_OPT_WAV49, &opt);
}
gsm_decode(context, (void *)from, to);
*toLen = SAMPLES_PER_FRAME * 2;
return 1;
}
// MS-GSM packets are always 65 bytes long, and consists of two GSM packets
if (*toLen < MSGSM_SAMPLES_PER_FRAME * 2)
return 0;
{
int opt = 1;
gsm_option(context, GSM_OPT_WAV49, &opt);
}
gsm_decode(context, (unsigned char *)from, (short *)to);
gsm_decode(context, ((unsigned char *)from)+33, ((short *)to)+160);
*toLen = MSGSM_SAMPLES_PER_FRAME * 2;
return 1;
}
static gavl_source_status_t decode_frame_gsm(bgav_stream_t * s)
{
gavl_source_status_t st;
gsm_priv * priv;
priv = s->decoder_priv;
if(!priv->packet)
{
if((st = bgav_stream_get_packet_read(s, &priv->packet)) != GAVL_SOURCE_OK)
return st;
priv->packet_ptr = priv->packet->data;
}
else if(priv->packet_ptr - priv->packet->data + // Data already decoded
GSM_BLOCK_SIZE + priv->ms * (GSM_BLOCK_SIZE-1) // Next packet
> priv->packet->data_size)
{
bgav_stream_done_packet_read(s, priv->packet);
if((st = bgav_stream_get_packet_read(s, &priv->packet)) != GAVL_SOURCE_OK)
return st;
priv->packet_ptr = priv->packet->data;
}
gsm_decode(priv->gsm_state, priv->packet_ptr, priv->frame->samples.s_16);
priv->frame->valid_samples = GSM_FRAME_SAMPLES;
if(priv->ms)
{
priv->packet_ptr += GSM_BLOCK_SIZE;
// priv->packet_ptr += block_size-1;
gsm_decode(priv->gsm_state, priv->packet_ptr,
priv->frame->samples.s_16+GSM_FRAME_SAMPLES);
priv->frame->valid_samples += GSM_FRAME_SAMPLES;
priv->packet_ptr += GSM_BLOCK_SIZE-1;
}
else
priv->packet_ptr += GSM_BLOCK_SIZE;
gavl_audio_frame_copy_ptrs(&s->data.audio.format, s->data.audio.frame, priv->frame);
return GAVL_SOURCE_OK;
}
static int decode_audio(struct mgcp_process_rtp_state *state,
uint8_t **src, size_t *nbytes)
{
while (*nbytes >= state->src_frame_size) {
if (state->sample_cnt + state->src_samples_per_frame > ARRAY_SIZE(state->samples)) {
LOGP(DMGCP, LOGL_ERROR,
"Sample buffer too small: %d > %d.\n",
state->sample_cnt + state->src_samples_per_frame,
ARRAY_SIZE(state->samples));
return -ENOSPC;
}
switch (state->src_fmt) {
case AF_GSM:
if (gsm_decode(state->src.gsm_handle,
(gsm_byte *)*src, state->samples + state->sample_cnt) < 0) {
LOGP(DMGCP, LOGL_ERROR,
"Failed to decode GSM.\n");
return -EINVAL;
}
break;
#ifdef HAVE_BCG729
case AF_G729:
bcg729Decoder(state->src.g729_dec, *src, 0, state->samples + state->sample_cnt);
break;
#endif
case AF_PCMU:
ulaw_decode(*src, state->samples + state->sample_cnt,
state->src_samples_per_frame);
break;
case AF_PCMA:
alaw_decode(*src, state->samples + state->sample_cnt,
state->src_samples_per_frame);
break;
case AF_S16:
memmove(state->samples + state->sample_cnt, *src,
state->src_frame_size);
break;
case AF_L16:
l16_decode(*src, state->samples + state->sample_cnt,
state->src_samples_per_frame);
break;
default:
break;
}
*src += state->src_frame_size;
*nbytes -= state->src_frame_size;
state->sample_cnt += state->src_samples_per_frame;
}
return 0;
}
int GSMCodec::Decode (BYTE *in,int inLen,WORD* out,int outLen)
{
//Dependiendo de la longitud tenemos un tipo u otro
if (inLen==33)
{
//GSM Clasico
if (outLen<160)
return 0;
//Decodificamso
if (gsm_decode(g,(gsm_byte *)in,(gsm_signal *)out)<0)
return 0;
return 160;
} else if (inLen==65) {
//ponemos el modo wav
int wav=1;
gsm_option(g, GSM_OPT_WAV49, &wav);
//GSM de M$ vienen 2 paquetes seguidos
if (outLen<160*2)
return 0;
//Decodificamos el primero
if (gsm_decode(g,(gsm_byte *)in,(gsm_signal *)out)<0)
return 0;
//Y el segundo
if (gsm_decode(g,(gsm_byte *)&in[33],(gsm_signal *)&out[160])<0)
return 0;
return 160*2;
}
return 0;
}
static int decode(struct audec_state *st, int16_t *sampv, size_t *sampc,
const uint8_t *buf, size_t len)
{
int ret;
if (*sampc < FRAME_SIZE)
return ENOMEM;
if (len < sizeof(gsm_frame))
return EBADMSG;
ret = gsm_decode(st->dec, (gsm_byte *)buf, (gsm_signal *)sampv);
if (ret)
return EPROTO;
*sampc = 160;
return 0;
}
static int codec_decoder(const struct PluginCodec_Definition * codec,
void * _context,
const void * from,
unsigned * fromLen,
void * to,
unsigned * toLen,
unsigned int * flag)
{
struct gsm_state * context = (struct gsm_state *)_context;
if (*fromLen < BYTES_PER_FRAME)
return 0;
gsm_decode(context, (void *)from, to);
*toLen = SAMPLES_PER_FRAME * 2;
return 1;
}
static void dec_process(MSFilter *f){
gsm s=(gsm)f->data;
mblk_t *im;
mblk_t *om;
const int frsz=160*2;
while((im=ms_queue_get(f->inputs[0]))!=NULL){
om=allocb(frsz,0);
if (gsm_decode(s,(gsm_byte*)im->b_rptr,(gsm_signal*)om->b_wptr)<0){
ms_warning("gsm_decode error!");
freemsg(om);
}else{
om->b_wptr+=frsz;
ms_queue_put(f->outputs[0],om);
}
freemsg(im);
}
}
int main(int argc, char** argv)
{
gsm gsmh;
gsm_signal src[GSM_SAMPLE_BLOCK], dec[GSM_SAMPLE_BLOCK];
gsm_frame dst;
const char* inFN;
FILE* inFile;
const char* encFN;
FILE* encFile;
const char* decFN;
FILE* decFile;
int n; /* For status dots */
if (4 != argc)
fail ("Usage: testjms input encode decode");
inFN = argv[1];
inFile = mustOpen(inFN, "rb");
encFN = argv[2];
encFile = mustOpen(encFN, "wb");
decFN = argv[3];
decFile = mustOpen(decFN, "wb");
gsmh = gsm_create();
if (! gsmh)
fail ("Can't create gsm\n");
while (fread(FP(src), inFile) == GSM_SAMPLE_BLOCK) {
if ((n++) % 100) {
(void) printf (".");
n = 0;
}
gsm_encode(gsmh, src, dst);
fwrite(FP(dst), encFile);
gsm_decode(gsmh, dst, dec);
fwrite(FP(dec), decFile);
}
fclose (inFile);
fclose (encFile);
fclose (decFile);
(void) puts ("\ndone");
return 0;
}
st_ssize_t st_gsmread(ft_t ft, st_sample_t *buf, st_ssize_t samp)
{
int done = 0;
int r, ch, chans;
gsm_signal *gbuff;
struct gsmpriv *p = (struct gsmpriv *) ft->priv;
chans = p->channels;
while (done < samp)
{
while (p->samplePtr < p->sampleTop && done < samp)
buf[done++] =
ST_SIGNED_WORD_TO_SAMPLE(*(p->samplePtr)++);
if (done>=samp) break;
r = st_readbuf(ft, p->frames, p->channels*FRAMESIZE, 1);
if (r != 1) break;
p->samplePtr = p->samples;
for (ch=0; ch<chans; ch++) {
int i;
gsm_signal *gsp;
gbuff = p->sampleTop;
if (gsm_decode(p->handle[ch], p->frames + ch*FRAMESIZE, gbuff) < 0)
{
st_fail_errno(ft,errno,"error during GSM decode");
return (0);
}
gsp = p->samples + ch;
for (i=0; i<BLOCKSIZE; i++) {
*gsp = *gbuff++;
gsp += chans;
}
}
}
return done;
}
int MpdSipxGSM::decode(const MpRtpBufPtr &pPacket,
unsigned decodedBufferLength,
MpAudioSample *samplesBuffer,
UtlBoolean bIsPLCFrame)
{
if (!pPacket.isValid())
return 0;
unsigned payloadSize = pPacket->getPayloadSize();
unsigned maxPayloadSize = smCodecInfo.getMaxPacketBits()/8;
// do not accept frames longer than 20ms from RTP to protect against buffer overflow
assert(payloadSize <= maxPayloadSize);
if (payloadSize > maxPayloadSize || payloadSize <= 1)
{
return 0;
}
gsm_decode(mpGsmState, (gsm_byte*)pPacket->getDataPtr(), (gsm_signal*)samplesBuffer);
return smCodecInfo.getNumSamplesPerFrame();
}
static GstFlowReturn
gst_gsmdec_handle_frame (GstAudioDecoder * dec, GstBuffer * buffer)
{
GstGSMDec *gsmdec;
gsm_byte *data;
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *outbuf;
GstMapInfo map, omap;
/* no fancy draining */
if (G_UNLIKELY (!buffer))
return GST_FLOW_OK;
gsmdec = GST_GSMDEC (dec);
/* always the same amount of output samples */
outbuf = gst_buffer_new_and_alloc (ENCODED_SAMPLES * sizeof (gsm_signal));
/* now encode frame into the output buffer */
gst_buffer_map (buffer, &map, GST_MAP_READ);
gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
data = (gsm_byte *) map.data;
if (gsm_decode (gsmdec->state, data, (gsm_signal *) omap.data) < 0) {
/* invalid frame */
GST_AUDIO_DECODER_ERROR (gsmdec, 1, STREAM, DECODE, (NULL),
("tried to decode an invalid frame"), ret);
gst_buffer_unmap (outbuf, &omap);
gst_buffer_unref (outbuf);
outbuf = NULL;
} else {
gst_buffer_unmap (outbuf, &omap);
}
gst_buffer_unmap (buffer, &map);
gst_audio_decoder_finish_frame (dec, outbuf, 1);
return ret;
}
bool SmartSAudioDecoder::decode( const char* pData, int len )
{
PSMARTSIGHT_AUDIO_UDP_PACKET_HEAD pAudioHead = (PSMARTSIGHT_AUDIO_UDP_PACKET_HEAD)pData;
if( pAudioHead->m_cFormat == SS_AUDIO_PCM )
{
BlockDataParser::inputData( pData+SMARTSIGHT_AUDIO_UDP_PACKET_HEAD_LENGTH, len-SMARTSIGHT_AUDIO_UDP_PACKET_HEAD_LENGTH );
}
else if( pAudioHead->m_cFormat == SS_AUDIO_GSM )
{
assert( len == SMARTSIGHT_GSM_AUDIO_PACKET_LENGTH );
if( !m_GSMInstance && !( m_GSMInstance = gsm_create() ) )
return false;
if( !m_pGSMBuffer )
m_pGSMBuffer = new char[GSM_AUDIO_LENGTH];
for( int i=0; i<6; i++ )
gsm_decode( m_GSMInstance, (gsm_byte*)(pData+SMARTSIGHT_AUDIO_UDP_PACKET_HEAD_LENGTH+i*33), (gsm_signal*)(m_pGSMBuffer+i*320) );
BlockDataParser::inputData( m_pGSMBuffer, SMARTSIGHT_GSM_AUDIO_PACKET_LENGTH );
}
else
return false;
return true;
}
static void dec_process(MSFilter *f){
DecState *s=(DecState *)f->data;
mblk_t *im;
mblk_t *om;
const int frsz=160*2;
while((im=ms_queue_get(f->inputs[0]))!=NULL){
if (s->sample_time!=0 && f->ticker->time>s->sample_time){
/* we should output a frame but no packet were decoded
thus do packet loss concealment*/
om=allocb(frsz,0);
ms_plc_generate(s->plc_st, (int16_t*)om->b_wptr);
om->b_wptr+=frsz;
ms_queue_put(f->outputs[0],om);
ms_error("Doing packet loss concealment.");
s->sample_time+=20;
}
for (;(im->b_wptr-im->b_rptr)>=33;im->b_rptr+=33) {
om=allocb(frsz,0);
if (s->sample_time==0){
s->sample_time=f->ticker->time;
}
if (gsm_decode(s->state,(gsm_byte*)im->b_rptr,(gsm_signal*)om->b_wptr)<0){
ms_warning("gsm_decode error!");
freemsg(om);
}else{
om->b_wptr+=frsz;
s->sample_time+=20;
ms_plc_save(s->plc_st, om->b_rptr);
ms_queue_put(f->outputs[0],om);
}
}
freemsg(im);
}
}
CODEC_API int PLG_DECODE_V1(libgsm)(void* handle,
const void* pCodedData,
unsigned cbCodedPacketSize,
void* pAudioBuffer,
unsigned cbBufferSize,
unsigned *pcbDecodedSize,
const struct RtpHeader* pRtpHeader)
{
struct libgsm_codec_data *mpGsm = (struct libgsm_codec_data *)handle;
gsm_byte *pIn = (gsm_byte * ) pCodedData;
gsm_signal *pOut = ( gsm_signal * ) pAudioBuffer;
unsigned outSize = ( cbCodedPacketSize / GSM_FRAME_BYTES ) * GSM_FRAME_SAMPLES;
unsigned remaining = cbCodedPacketSize;
assert(handle != NULL);
/* Assert that payload have correct size. */
if ( (cbCodedPacketSize % GSM_FRAME_BYTES) != 0 )
{
return RPLG_CORRUPTED_DATA;
}
/* Assert that available buffer size is enough for the packet. */
if (cbBufferSize < outSize )
{
return RPLG_BUFFER_TOO_SMALL;
}
while ( remaining > 0 )
{
gsm_decode(mpGsm->mpGsmState, pIn, pOut);
pIn += GSM_FRAME_BYTES;
pOut += GSM_FRAME_SAMPLES;
remaining -= GSM_FRAME_BYTES;
}
*pcbDecodedSize = outSize;
return RPLG_SUCCESS;
}
