Beispiel #1
0
static int codec_decoder(const struct PluginCodec_Definition * codec, 
                                           void * context,
                                     const void * from, 
                                       unsigned * fromLen,
                                           void * to,         
                                       unsigned * toLen,
                                   unsigned int * flag)
{
  int i;
#ifndef OPAL_SYSTEM_ILBC
  float block[BLOCKL_MAX];
  short * sampleBuffer = (short *)to;
#endif

  struct iLBC_Dec_Inst_t_ * decoder = (struct iLBC_Dec_Inst_t_ *)context;

  // If packet not have integral number of frames for this mode
  if ((*fromLen % decoder->no_of_bytes) != 0) {
    // Then switch to the other mode
    initDecode(context, decoder->mode == 20 ? 30 : 20, 0); 
    if ((*fromLen % decoder->no_of_bytes) != 0)
      return 0; // Still wrong, what are they sending us?
  }

  /* do actual decoding of block */ 
#ifdef OPAL_SYSTEM_ILBC
  iLBC_decode((short *)to, (WebRtc_UWord16 *)from, decoder, 1);
#else
  iLBC_decode(block, (unsigned char *)from, decoder, 1);

  /* convert to short */     
  for (i = 0; i < decoder->blockl; i++) {
    float tmp = block[i];
    if (tmp < -32767)
      tmp = -32767;
    else if (tmp > 32767)
      tmp = 32767;
    sampleBuffer[i] = (short)tmp;
  }
#endif

  if (*toLen < decoder->blockl*2U)
    return 0;

  // set output lengths
  *toLen = decoder->blockl*2;
  *fromLen = decoder->no_of_bytes;

  return 1;
}
Beispiel #2
0
static int do_dec(struct audec_state *st, int16_t *sampv, size_t *sampc,
		  const uint8_t *buf, size_t len)
{
	float float_buf[st->nsamp];
	const int mode = len ? 1 : 0;
	uint32_t i;

	/* Make sure there is enough space in the buffer */
	if (*sampc < st->nsamp)
		return ENOMEM;

	iLBC_decode(float_buf,      /* (o) decoded signal block */
		    (uint8_t *)buf, /* (i) encoded signal bits */
		    &st->dec,       /* (i/o) the decoder state structure */
		    mode);          /* (i) 0: bad packet, PLC, 1: normal */

	/* Convert from float to 16-bit samples */
	for (i=0; i<st->nsamp; i++) {
		sampv[i] = (int16_t)float_buf[i];
	}

	*sampc = st->nsamp;

	return 0;
}
Beispiel #3
0
/*! \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;
	int16_t *dst = (int16_t *)pvt->outbuf;
	float tmpf[ILBC_SAMPLES];

	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 % 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 += 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;
}
short decode(       /* (o) Number of decoded samples */
	iLBC_Dec_Inst_t *iLBCdec_inst,  /* (i/o) Decoder instance */
	short *decoded_data,        /* (o) Decoded signal block*/
	short *encoded_data,        /* (i) Encoded bytes */
	short mode                       /* (i) 0=PL, 1=Normal */
){
	int k;
	float decblock[BLOCKL_MAX], dtmp;

	/* check if mode is valid */

	if (mode<0 || mode>1) {
		printf("\nERROR - Wrong mode - 0, 1 allowed\n"); exit(3);}

	/* do actual decoding of block */
	iLBC_decode(decblock, (unsigned char *)encoded_data, iLBCdec_inst, mode);

	/* convert to short */
	for (k=0; k<iLBCdec_inst->blockl; k++){
		dtmp=decblock[k];

		if (dtmp<MIN_SAMPLE)
			dtmp=MIN_SAMPLE;
		else if (dtmp>MAX_SAMPLE)
			dtmp=MAX_SAMPLE;
		decoded_data[k] = (short) dtmp;
	}

	return (iLBCdec_inst->blockl);
}
Beispiel #5
0
static int ilbctolin_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,i;
	float tmpf[240];
	
	if (f->datalen % 50) {
		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 {
			ast_log(LOG_WARNING, "Out of buffer space\n");
			return -1;
		}		
	}
	return 0;
}
/*解码一次
 */
static int decode(unsigned char *data, short *samples, int mode) {
	int i;
	float block[BLOCKL_MAX];

	// Validate Mode
	if (mode != 0 && mode != 1) {
		LOGE("Bad mode");
		return -1;
	}

	iLBC_decode(block, data, &g_dec_inst, mode);

	// Validate PCM16
	for (i = 0; i < g_dec_inst.blockl; i++) {
		float point;

		point = block[i];
		if (point < MIN_SAMPLE) {
			point = MIN_SAMPLE;
		} else if (point > MAX_SAMPLE) {
			point = MAX_SAMPLE;
		}

		samples[i] = point;
	}

	return g_dec_inst.blockl * 2;
}
Beispiel #7
0
static void dec_process(MSFilter *f){
	DecState *s=(DecState*)f->data;
	mblk_t *im,*om;
	int nbytes;
	float samples[BLOCKL_MAX],tmp;
	int i;

	while ((im=ms_queue_get(f->inputs[0]))!=NULL){
		nbytes=msgdsize(im);
		if (nbytes<=0)
			return;
		if (nbytes%38!=0 && nbytes%50!=0)
			return;
		if (nbytes%38==0 && s->nbytes!=NO_OF_BYTES_20MS)
		{
			/* not yet configured, or misconfigured */
			s->ms_per_frame=20;
			s->nbytes=NO_OF_BYTES_20MS;
			s->nsamples=BLOCKL_20MS;
			initDecode(&s->ilbc_dec,s->ms_per_frame,0);
		}
		else if (nbytes%50==0 && s->nbytes!=NO_OF_BYTES_30MS)
		{
			/* not yet configured, or misconfigured */
			s->ms_per_frame=30;
			s->nbytes=NO_OF_BYTES_30MS;
			s->nsamples=BLOCKL_30MS;
			initDecode(&s->ilbc_dec,s->ms_per_frame,0);
		}
		if (s->nbytes>0 && nbytes>=s->nbytes){
			int frame_per_packet = nbytes/s->nbytes;
			int k;

			for (k=0;k<frame_per_packet;k++)
			{
				om=allocb(s->nsamples*2,0);
				iLBC_decode(samples,(uint8_t*)im->b_rptr+(k*s->nbytes),&s->ilbc_dec,1);
				for (i=0;i<s->nsamples;i++,om->b_wptr+=2){
					tmp=samples[i];
					//ÐÞÕý±¬ÆÆÒô
					if (tmp<MIN_SAMPLE) 
						tmp=MIN_SAMPLE; 
					else if (tmp>MAX_SAMPLE) 
						tmp=MAX_SAMPLE;
					*((int16_t*)om->b_wptr)= tmp;
				}
				ms_queue_put(f->outputs[0],om);
			}
		}else{
			ms_warning("bad iLBC frame !");
		}
		freemsg(im);
	}
}
Beispiel #8
0
static int iLBC_2_Pcm16_Ext( unsigned char* out_buf, unsigned char* in_buf, unsigned int size,
			     unsigned int channels, unsigned int rate, long h_codec, int mode )
{
  short* out_b = (short*)out_buf;
  int i,k,noframes;
  float decblock[BLOCKL_MAX];
  float dtmp;
  iLBC_Codec_Inst_t* codec_inst;
  
  short out_buf_offset=0;

  if (!h_codec){
    ERROR("iLBC codec not initialized.\n");
    return 0;
  }
  if ((channels!=1)||(rate!=8000)) {
    ERROR("Unsupported input format for iLBC encoder.\n");
    return 0;
  }

  codec_inst = (iLBC_Codec_Inst_t*)h_codec;
  
  noframes = size / codec_inst->iLBC_Dec_Inst.no_of_bytes;
  if (noframes*codec_inst->iLBC_Dec_Inst.no_of_bytes != size) {
    WARN("Dropping extra %d bytes from iLBC packet.\n",
	 size - noframes*codec_inst->iLBC_Dec_Inst.no_of_bytes);
  }

  for (i=0;i<noframes;i++) {
    /* do actual decoding of block */
      
    iLBC_decode(decblock,in_buf+i*codec_inst->iLBC_Dec_Inst.no_of_bytes,
		&codec_inst->iLBC_Dec_Inst, mode/* mode 0=PL, 1=Normal */);

    for (k=0; k<codec_inst->iLBC_Dec_Inst.blockl; k++){
      dtmp=decblock[k];
      if (dtmp<MIN_SAMPLE)
	dtmp=MIN_SAMPLE;
      else if (dtmp>MAX_SAMPLE)
	dtmp=MAX_SAMPLE;
      out_b[out_buf_offset] = (short) dtmp;
      out_buf_offset++;
    }
  }

  return out_buf_offset*2; // sample size: 2 bytes (short)
}
Beispiel #9
0
static int codec_decoder(const struct PluginCodec_Definition * codec, 
                                           void * context,
                                     const void * from, 
                                       unsigned * fromLen,
                                           void * to,         
                                       unsigned * toLen,
                                   unsigned int * flag)
{
  int i;
  float block[BLOCKL_MAX];

  struct iLBC_Dec_Inst_t_ * decoder = (struct iLBC_Dec_Inst_t_ *)context;
  short * sampleBuffer = (short *)to;

  if (*fromLen < (unsigned)decoder->no_of_bytes)
    return 0;

  /* do actual decoding of block */ 
  iLBC_decode(block, (unsigned char *)from, decoder, 1);

  if (*toLen < (unsigned)decoder->blockl*2)
    return 0;

  /* convert to short */     
  for (i = 0; i < decoder->blockl; i++) {
    float tmp = block[i];
    if (tmp < MIN_SAMPLE)
      tmp = MIN_SAMPLE;
    else if (tmp > MAX_SAMPLE)
      tmp = MAX_SAMPLE;
    sampleBuffer[i] = (short)tmp;
  }

  *toLen = decoder->blockl*2;

  return 1;
}
Beispiel #10
0
static void dec_process(MSFilter *f){
	DecState *s=(DecState*)f->data;
	mblk_t *im,*om;
	int nbytes;
	float samples[BLOCKL_MAX]={0};
	int i;

	while ((im=ms_queue_get(f->inputs[0]))!=NULL){
		nbytes=msgdsize(im);
		if (nbytes==0  || (nbytes%38!=0 && nbytes%50!=0)){
			freemsg(im);
			continue;
		}
		if (nbytes%38==0 && s->nbytes!=NO_OF_BYTES_20MS)
		{
			/* not yet configured, or misconfigured */
			s->ms_per_frame=20;
			s->nbytes=NO_OF_BYTES_20MS;
			s->nsamples=BLOCKL_20MS;
			s->ready=TRUE;
			initDecode(&s->ilbc_dec,s->ms_per_frame,s->postfilter);
		}
		else if (nbytes%50==0 && s->nbytes!=NO_OF_BYTES_30MS)
		{
			/* not yet configured, or misconfigured */
			s->ms_per_frame=30;
			s->nbytes=NO_OF_BYTES_30MS;
			s->nsamples=BLOCKL_30MS;
			s->ready=TRUE;
			initDecode(&s->ilbc_dec,s->ms_per_frame,s->postfilter);
		}
		if (s->nbytes>0 && nbytes>=s->nbytes){
			int frame_per_packet = nbytes/s->nbytes;
			int k;
			int plctime;

			for (k=0;k<frame_per_packet;k++)
			{
				om=allocb(s->nsamples*2,0);
				iLBC_decode(samples,(uint8_t*)im->b_rptr+(k*s->nbytes),&s->ilbc_dec,1);
				for (i=0;i<s->nsamples;i++,om->b_wptr+=2){
					*((int16_t*)om->b_wptr)=samples[i];
				}
				mblk_meta_copy(im,om);
				ms_queue_put(f->outputs[0],om);
			}
			if (s->plcctx){
				plctime=ms_concealer_inc_sample_time(s->plcctx,f->ticker->time,frame_per_packet*s->ms_per_frame,1);
				if (plctime>0){
					ms_warning("ilbc: did plc during %i ms",plctime);
				}
			}
		}else{
			ms_warning("bad iLBC frame !");
		}
		freemsg(im);
	}
	if (s->plcctx && s->ready && ms_concealer_context_is_concealement_required(s->plcctx,f->ticker->time)){
		om=allocb(s->nsamples*2,0);
		iLBC_decode(samples,(uint8_t*)NULL,&s->ilbc_dec,0 /*PLC*/);
		for (i=0;i<s->nsamples;i++,om->b_wptr+=2){
			*((int16_t*)om->b_wptr)=samples[i];
		}
		mblk_set_plc_flag(om,TRUE);
		ms_queue_put(f->outputs[0],om);
		ms_concealer_inc_sample_time(s->plcctx,f->ticker->time,s->ms_per_frame,0);
	}
}
Beispiel #11
0
void IlbcToPcmFilter::AudioChunkIn(AudioChunkRef& inputAudioChunk)
{
	int r_samples = 0, fs = 0, i = 0, pos = 0, o_samples = 0, j = 0;
	float ilbcf[240];

	m_outputAudioChunk.reset();

	if(inputAudioChunk.get() == NULL) {
		return;
	}

	if(inputAudioChunk->GetNumSamples() == 0) {
		return;
	}

	AudioChunkDetails outputDetails = *inputAudioChunk->GetDetails();

	if(SupportsInputRtpPayloadType(outputDetails.m_rtpPayloadType) == false)
	{
		return;
	}

	r_samples = inputAudioChunk->GetNumSamples();
	if((r_samples % 50) && (r_samples % 38)) {
		/* Strange iLBC frame that is not a multiple of 50 bytes
		 * (30ms frame) and neither is it a multiple of 38 bytes
		 * (20ms frame). We should probably log something? */
                LOG4CXX_ERROR(this->s_ilbclog, "Error, received iLBC frame is not a multiple of 50 or 38!");
		return;
	}

	if(!(r_samples % 50)) {
		i = r_samples / 50;
		o_samples = i * 240;
		fs = 50;
#if 0
		LOG4CXX_INFO(this->s_ilbclog, "Frame size is 50 bytes");
#endif
	} else {
		i = r_samples / 38;
		o_samples = i * 160;
		fs = 38;
#if 0
		LOG4CXX_INFO(this->s_ilbclog, "Frame size is 38 bytes");
#endif
	}

	m_outputAudioChunk.reset(new AudioChunk());
	outputDetails.m_rtpPayloadType = -1;
	outputDetails.m_encoding = PcmAudio;

	outputDetails.m_numBytes = (o_samples * 2);
	short* outputBuffer = (short*)m_outputAudioChunk->CreateBuffer(outputDetails);
	unsigned char* inputBuffer = (unsigned char*)inputAudioChunk->m_pBuffer;

	for(i = 0; i < r_samples; i += fs) {
		if((pos+((fs == 50) ? 240 : 160)) <= o_samples) {
			if(fs == 50) {
				iLBC_decode(ilbcf, inputBuffer+i, &dec30, 1);

				for(j = 0; j < 240; j++) {
					outputBuffer[pos + j] = (short)ilbcf[j];
				}

				pos += 240;
			} else {
				iLBC_decode(ilbcf, inputBuffer+i, &dec20, 1);

				for(j = 0; j < 160; j++) {
                                        outputBuffer[pos + j] = (short)ilbcf[j];
                                }

                                pos += 160;
			}
		} else {
			/* This should ordinarily never happen.
			 * Log something? */
			CStdString logMsg;

			logMsg.Format("Strange, I ran out of space: pos=%d, o_samples=%d, r_samples=%d, i=%d, "
					"(pos+((fs == 50) ? 240 : 160))=%d",
					pos, o_samples, r_samples, i, (pos+((fs == 50) ? 240 : 160)));
			LOG4CXX_ERROR(this->s_ilbclog, logMsg);
			return;
		}
	}
}
Beispiel #12
0
static tsk_size_t tdav_codec_ilbc_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)
{
	int blocks, i, k, block_size;
	float dtmp;
	tsk_size_t out_size;
	tdav_codec_ilbc_t* ilbc = (tdav_codec_ilbc_t*)self;

	if(!self || !in_data || !in_size || !out_data){
		TSK_DEBUG_ERROR("Invalid parameter");
		return 0;
	}

	if((in_size % NO_OF_BYTES_20MS) == 0){
		/* Using 20ms mode */
		blocks = (in_size/NO_OF_BYTES_20MS);
		out_size = (BLOCKL_20MS * blocks) * sizeof(short);
		block_size = out_size/blocks;
		if(ilbc->decoder.mode != 20){
			 initDecode(&ilbc->decoder, 20, tsk_true/* Enhancer */);
		}
	}
	else if((in_size % NO_OF_BYTES_30MS) == 0){
		/* Using 30ms mode */
		blocks = (in_size/NO_OF_BYTES_30MS);
		out_size = (BLOCKL_30MS * blocks) * sizeof(short);
		block_size = out_size/blocks;
		if(ilbc->decoder.mode != 30){
			 initDecode(&ilbc->decoder, 30, tsk_true/* Enhancer */);
		}
	}
	else{
		TSK_DEBUG_ERROR("Invalid iLBC mode");
		return 0;
	}

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

	for(i = 0; i<blocks; i++){
		iLBC_decode(ilbc->decblock, &((uint8_t*)in_data)[i*block_size], &ilbc->decoder, 1/* Normal */);

       /* convert to short */
       for(k=0; k<ilbc->decoder.blockl; k++){
           dtmp=ilbc->decblock[k];

		   if(dtmp<MIN_SAMPLE){
               dtmp = MIN_SAMPLE;
		   }
		   else if(dtmp>MAX_SAMPLE){
               dtmp = MAX_SAMPLE;
		   }
		  
		   ((short*)*out_data)[(i*block_size) + k] = ((short) dtmp);
       }
	}

	return out_size;
}