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; }