iLBC_decode.c File Reference

#include <math.h>
#include <stdlib.h>
#include "iLBC_define.h"
#include "StateConstructW.h"
#include "LPCdecode.h"
#include "iCBConstruct.h"
#include "doCPLC.h"
#include "helpfun.h"
#include "constants.h"
#include "packing.h"
#include "string.h"
#include "enhancer.h"
#include "hpOutput.h"
#include "syntFilter.h"

Include dependency graph for iLBC_decode.c:

Go to the source code of this file.

Functions
void	Decode (iLBC_Dec_Inst_t *iLBCdec_inst, float *decresidual, int start, int idxForMax, int *idxVec, float *syntdenum, int *cb_index, int *gain_index, int *extra_cb_index, int *extra_gain_index, int state_first)
void	iLBC_decode (float *decblock, unsigned char *bytes, iLBC_Dec_Inst_t *iLBCdec_inst, int mode)
short	initDecode (iLBC_Dec_Inst_t *iLBCdec_inst, int mode, int use_enhancer)

Function Documentation

Decode()

void Decode	(	iLBC_Dec_Inst_t *	iLBCdec_inst,
		float *	decresidual,
		int	start,
		int	idxForMax,
		int *	idxVec,
		float *	syntdenum,
		int *	cb_index,
		int *	gain_index,
		int *	extra_cb_index,
		int *	extra_gain_index,
		int	state_first
	)

Definition at line 118 of file iLBC_decode.c.

References BLOCKL_MAX, CB_MEML, CB_NSTAGES, iCBConstruct(), LPC_FILTERORDER, memLfTbl, iLBC_Dec_Inst_t_::nsub, STATE_LEN, iLBC_Dec_Inst_t_::state_short_len, StateConstructW(), stMemLTbl, and SUBL.

Referenced by iLBC_decode().

 {
 float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML];
 int k, meml_gotten, Nfor, Nback, i;
 int diff, start_pos;
 int subcount, subframe;






 diff = STATE_LEN - iLBCdec_inst->state_short_len;

 if (state_first == 1) {
 start_pos = (start-1)*SUBL;
 } else {
 start_pos = (start-1)*SUBL + diff;
 }

 /* decode scalar part of start state */

 StateConstructW(idxForMax, idxVec,
 &syntdenum[(start-1)*(LPC_FILTERORDER+1)],
 &decresidual[start_pos], iLBCdec_inst->state_short_len);


 if (state_first) { /* put adaptive part in the end */

 /* setup memory */

 memset(mem, 0,
 (CB_MEML-iLBCdec_inst->state_short_len)*sizeof(float));
 memcpy(mem+CB_MEML-iLBCdec_inst->state_short_len,
 decresidual+start_pos,
 iLBCdec_inst->state_short_len*sizeof(float));

 /* construct decoded vector */

 iCBConstruct(
 &decresidual[start_pos+iLBCdec_inst->state_short_len],
 extra_cb_index, extra_gain_index, mem+CB_MEML-stMemLTbl,
 stMemLTbl, diff, CB_NSTAGES);

 }
 else {/* put adaptive part in the beginning */

 /* create reversed vectors for prediction */

 for (k=0; k<diff; k++) {
 reverseDecresidual[k] =
 decresidual[(start+1)*SUBL-1-
 (k+iLBCdec_inst->state_short_len)];
 }

 /* setup memory */

 meml_gotten = iLBCdec_inst->state_short_len;
 for (k=0; k<meml_gotten; k++){
 mem[CB_MEML-1-k] = decresidual[start_pos + k];





 }
 memset(mem, 0, (CB_MEML-k)*sizeof(float));

 /* construct decoded vector */

 iCBConstruct(reverseDecresidual, extra_cb_index,
 extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl,
 diff, CB_NSTAGES);

 /* get decoded residual from reversed vector */

 for (k=0; k<diff; k++) {
 decresidual[start_pos-1-k] = reverseDecresidual[k];
 }
 }

 /* counter for predicted sub-frames */

 subcount=0;

 /* forward prediction of sub-frames */

 Nfor = iLBCdec_inst->nsub-start-1;

 if ( Nfor > 0 ){

 /* setup memory */

 memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
 memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
 STATE_LEN*sizeof(float));

 /* loop over sub-frames to encode */

 for (subframe=0; subframe<Nfor; subframe++) {

 /* construct decoded vector */

 iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
 cb_index+subcount*CB_NSTAGES,
 gain_index+subcount*CB_NSTAGES,
 mem+CB_MEML-memLfTbl[subcount],
 memLfTbl[subcount], SUBL, CB_NSTAGES);

 /* update memory */

 memmove(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
 memcpy(mem+CB_MEML-SUBL,





 &decresidual[(start+1+subframe)*SUBL],
 SUBL*sizeof(float));

 subcount++;

 }

 }

 /* backward prediction of sub-frames */

 Nback = start-1;

 if ( Nback > 0 ) {

 /* setup memory */

 meml_gotten = SUBL*(iLBCdec_inst->nsub+1-start);

 if ( meml_gotten > CB_MEML ) {
 meml_gotten=CB_MEML;
 }
 for (k=0; k<meml_gotten; k++) {
 mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
 }
 memset(mem, 0, (CB_MEML-k)*sizeof(float));

 /* loop over subframes to decode */

 for (subframe=0; subframe<Nback; subframe++) {

 /* construct decoded vector */

 iCBConstruct(&reverseDecresidual[subframe*SUBL],
 cb_index+subcount*CB_NSTAGES,
 gain_index+subcount*CB_NSTAGES,
 mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
 SUBL, CB_NSTAGES);

 /* update memory */

 memmove(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
 memcpy(mem+CB_MEML-SUBL,
 &reverseDecresidual[subframe*SUBL],
 SUBL*sizeof(float));

 subcount++;
 }





 /* get decoded residual from reversed vector */

 for (i=0; i<SUBL*Nback; i++)
 decresidual[SUBL*Nback - i - 1] =
 reverseDecresidual[i];
 }
 }

iLBC_decode()

void iLBC_decode	(	float *	decblock,
		unsigned char *	bytes,
		iLBC_Dec_Inst_t *	iLBCdec_inst,
		int	mode
	)

Definition at line 326 of file iLBC_decode.c.

References iLBC_Dec_Inst_t_::blockl, BLOCKL_MAX, iLBC_ULP_Inst_t_::cb_gain, iLBC_ULP_Inst_t_::cb_index, CB_NSTAGES, Decode(), DecoderInterpolateLSF(), doThePLC(), ENH_BLOCKL, enhancerInterface(), iLBC_ULP_Inst_t_::extra_cb_gain, iLBC_ULP_Inst_t_::extra_cb_index, iLBC_Dec_Inst_t_::hpomem, hpOutput(), index_conv_dec(), iLBC_Dec_Inst_t_::last_lag, LPC_FILTERORDER, iLBC_Dec_Inst_t_::lpc_n, LPC_N_MAX, iLBC_ULP_Inst_t_::lsf_bits, LSF_check(), LSF_NSPLIT, iLBC_Dec_Inst_t_::mode, iLBC_Dec_Inst_t_::nasub, NASUB_MAX, iLBC_Dec_Inst_t_::nsub, NSUB_MAX, iLBC_Dec_Inst_t_::old_syntdenum, packcombine(), iLBC_Dec_Inst_t_::prev_enh_pl, iLBC_ULP_Inst_t_::scale_bits, SimplelsfDEQ(), iLBC_ULP_Inst_t_::start_bits, iLBC_ULP_Inst_t_::startfirst_bits, iLBC_ULP_Inst_t_::state_bits, STATE_LEN, iLBC_Dec_Inst_t_::state_short_len, SUBL, syntFilter(), iLBC_Dec_Inst_t_::syntMem, iLBC_Dec_Inst_t_::ULP_inst, unpack(), iLBC_Dec_Inst_t_::use_enhancer, and xCorrCoef().

Referenced by decode(), and ilbctolin_framein().

 {
 float data[BLOCKL_MAX];
 float lsfdeq[LPC_FILTERORDER*LPC_N_MAX];
 float PLCresidual[BLOCKL_MAX], PLClpc[LPC_FILTERORDER + 1];
 float zeros[BLOCKL_MAX], one[LPC_FILTERORDER + 1];
 int k, i, start, idxForMax, pos, lastpart, ulp;
 int lag, ilag;
 float cc, maxcc;
 int idxVec[STATE_LEN];
 int gain_index[NASUB_MAX*CB_NSTAGES],
 extra_gain_index[CB_NSTAGES];
 int cb_index[CB_NSTAGES*NASUB_MAX], extra_cb_index[CB_NSTAGES];
 int lsf_i[LSF_NSPLIT*LPC_N_MAX];
 int state_first;
 int last_bit;
 unsigned char *pbytes;
 float weightdenum[(LPC_FILTERORDER + 1)*NSUB_MAX];
 int order_plus_one;
 float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)];
 float decresidual[BLOCKL_MAX];

 if (mode>0) { /* the data are good */

 /* decode data */

 pbytes=bytes;
 pos=0;






 /* Set everything to zero before decoding */

 for (k=0; k<LSF_NSPLIT*LPC_N_MAX; k++) {
 lsf_i[k]=0;
 }
 start=0;
 state_first=0;
 idxForMax=0;
 for (k=0; k<iLBCdec_inst->state_short_len; k++) {
 idxVec[k]=0;
 }
 for (k=0; k<CB_NSTAGES; k++) {
 extra_cb_index[k]=0;
 }
 for (k=0; k<CB_NSTAGES; k++) {
 extra_gain_index[k]=0;
 }
 for (i=0; i<iLBCdec_inst->nasub; i++) {
 for (k=0; k<CB_NSTAGES; k++) {
 cb_index[i*CB_NSTAGES+k]=0;
 }
 }
 for (i=0; i<iLBCdec_inst->nasub; i++) {
 for (k=0; k<CB_NSTAGES; k++) {
 gain_index[i*CB_NSTAGES+k]=0;
 }
 }

 /* loop over ULP classes */

 for (ulp=0; ulp<3; ulp++) {

 /* LSF */
 for (k=0; k<LSF_NSPLIT*iLBCdec_inst->lpc_n; k++){
 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->lsf_bits[k][ulp], &pos);
 packcombine(&lsf_i[k], lastpart,
 iLBCdec_inst->ULP_inst->lsf_bits[k][ulp]);
 }

 /* Start block info */

 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->start_bits[ulp], &pos);
 packcombine(&start, lastpart,
 iLBCdec_inst->ULP_inst->start_bits[ulp]);

 unpack( &pbytes, &lastpart,





 iLBCdec_inst->ULP_inst->startfirst_bits[ulp], &pos);
 packcombine(&state_first, lastpart,
 iLBCdec_inst->ULP_inst->startfirst_bits[ulp]);

 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->scale_bits[ulp], &pos);
 packcombine(&idxForMax, lastpart,
 iLBCdec_inst->ULP_inst->scale_bits[ulp]);

 for (k=0; k<iLBCdec_inst->state_short_len; k++) {
 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->state_bits[ulp], &pos);
 packcombine(idxVec+k, lastpart,
 iLBCdec_inst->ULP_inst->state_bits[ulp]);
 }

 /* 23/22 (20ms/30ms) sample block */

 for (k=0; k<CB_NSTAGES; k++) {
 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->extra_cb_index[k][ulp],
 &pos);
 packcombine(extra_cb_index+k, lastpart,
 iLBCdec_inst->ULP_inst->extra_cb_index[k][ulp]);
 }
 for (k=0; k<CB_NSTAGES; k++) {
 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->extra_cb_gain[k][ulp],
 &pos);
 packcombine(extra_gain_index+k, lastpart,
 iLBCdec_inst->ULP_inst->extra_cb_gain[k][ulp]);
 }

 /* The two/four (20ms/30ms) 40 sample sub-blocks */

 for (i=0; i<iLBCdec_inst->nasub; i++) {
 for (k=0; k<CB_NSTAGES; k++) {
 unpack( &pbytes, &lastpart,
 iLBCdec_inst->ULP_inst->cb_index[i][k][ulp],
 &pos);
 packcombine(cb_index+i*CB_NSTAGES+k, lastpart,
 iLBCdec_inst->ULP_inst->cb_index[i][k][ulp]);
 }
 }

 for (i=0; i<iLBCdec_inst->nasub; i++) {
 for (k=0; k<CB_NSTAGES; k++) {
 unpack( &pbytes, &lastpart,





 iLBCdec_inst->ULP_inst->cb_gain[i][k][ulp],
 &pos);
 packcombine(gain_index+i*CB_NSTAGES+k, lastpart,
 iLBCdec_inst->ULP_inst->cb_gain[i][k][ulp]);
 }
 }
 }
 /* Extract last bit. If it is 1 this indicates an
 empty/lost frame */
 unpack( &pbytes, &last_bit, 1, &pos);

 /* Check for bit errors or empty/lost frames */
 if (start<1)
 mode = 0;
 if (iLBCdec_inst->mode==20 && start>3)
 mode = 0;
 if (iLBCdec_inst->mode==30 && start>5)
 mode = 0;
 if (last_bit==1)
 mode = 0;

 if (mode==1) { /* No bit errors was detected,
 continue decoding */

 /* adjust index */
 index_conv_dec(cb_index);

 /* decode the lsf */

 SimplelsfDEQ(lsfdeq, lsf_i, iLBCdec_inst->lpc_n);
 LSF_check(lsfdeq, LPC_FILTERORDER,
 iLBCdec_inst->lpc_n);
 DecoderInterpolateLSF(syntdenum, weightdenum,
 lsfdeq, LPC_FILTERORDER, iLBCdec_inst);

 Decode(iLBCdec_inst, decresidual, start, idxForMax,
 idxVec, syntdenum, cb_index, gain_index,
 extra_cb_index, extra_gain_index,
 state_first);

 /* preparing the plc for a future loss! */

 doThePLC(PLCresidual, PLClpc, 0, decresidual,
 syntdenum +
 (LPC_FILTERORDER + 1)*(iLBCdec_inst->nsub - 1),
 (*iLBCdec_inst).last_lag, iLBCdec_inst);







 memcpy(decresidual, PLCresidual,
 iLBCdec_inst->blockl*sizeof(float));
 }

 }

 if (mode == 0) {
 /* the data is bad (either a PLC call
 * was made or a severe bit error was detected)
 */

 /* packet loss conceal */

 memset(zeros, 0, BLOCKL_MAX*sizeof(float));

 one[0] = 1;
 memset(one+1, 0, LPC_FILTERORDER*sizeof(float));

 start=0;

 doThePLC(PLCresidual, PLClpc, 1, zeros, one,
 (*iLBCdec_inst).last_lag, iLBCdec_inst);
 memcpy(decresidual, PLCresidual,
 iLBCdec_inst->blockl*sizeof(float));

 order_plus_one = LPC_FILTERORDER + 1;
 for (i = 0; i < iLBCdec_inst->nsub; i++) {
 memcpy(syntdenum+(i*order_plus_one), PLClpc,
 order_plus_one*sizeof(float));
 }
 }

 if (iLBCdec_inst->use_enhancer == 1) {

 /* post filtering */

 iLBCdec_inst->last_lag =
 enhancerInterface(data, decresidual, iLBCdec_inst);

 /* synthesis filtering */

 if (iLBCdec_inst->mode==20) {
 /* Enhancer has 40 samples delay */
 i=0;
 syntFilter(data + i*SUBL,
 iLBCdec_inst->old_syntdenum +
 (i+iLBCdec_inst->nsub-1)*(LPC_FILTERORDER+1),
 SUBL, iLBCdec_inst->syntMem);





 for (i=1; i < iLBCdec_inst->nsub; i++) {
 syntFilter(data + i*SUBL,
 syntdenum + (i-1)*(LPC_FILTERORDER+1),
 SUBL, iLBCdec_inst->syntMem);
 }
 } else if (iLBCdec_inst->mode==30) {
 /* Enhancer has 80 samples delay */
 for (i=0; i < 2; i++) {
 syntFilter(data + i*SUBL,
 iLBCdec_inst->old_syntdenum +
 (i+iLBCdec_inst->nsub-2)*(LPC_FILTERORDER+1),
 SUBL, iLBCdec_inst->syntMem);
 }
 for (i=2; i < iLBCdec_inst->nsub; i++) {
 syntFilter(data + i*SUBL,
 syntdenum + (i-2)*(LPC_FILTERORDER+1), SUBL,
 iLBCdec_inst->syntMem);
 }
 }

 } else {

 /* Find last lag */
 lag = 20;
 maxcc = xCorrCoef(&decresidual[BLOCKL_MAX-ENH_BLOCKL],
 &decresidual[BLOCKL_MAX-ENH_BLOCKL-lag], ENH_BLOCKL);

 for (ilag=21; ilag<120; ilag++) {
 cc = xCorrCoef(&decresidual[BLOCKL_MAX-ENH_BLOCKL],
 &decresidual[BLOCKL_MAX-ENH_BLOCKL-ilag],
 ENH_BLOCKL);

 if (cc > maxcc) {
 maxcc = cc;
 lag = ilag;
 }
 }
 iLBCdec_inst->last_lag = lag;

 /* copy data and run synthesis filter */

 memcpy(data, decresidual,
 iLBCdec_inst->blockl*sizeof(float));
 for (i=0; i < iLBCdec_inst->nsub; i++) {
 syntFilter(data + i*SUBL,
 syntdenum + i*(LPC_FILTERORDER+1), SUBL,
 iLBCdec_inst->syntMem);
 }





 }

 /* high pass filtering on output if desired, otherwise
 copy to out */

 hpOutput(data, iLBCdec_inst->blockl,
 decblock,iLBCdec_inst->hpomem);

 /* memcpy(decblock,data,iLBCdec_inst->blockl*sizeof(float));*/

 memcpy(iLBCdec_inst->old_syntdenum, syntdenum,

 iLBCdec_inst->nsub*(LPC_FILTERORDER+1)*sizeof(float));

 iLBCdec_inst->prev_enh_pl=0;

 if (mode==0) { /* PLC was used */
 iLBCdec_inst->prev_enh_pl=1;
 }
 }

initDecode()

short initDecode	(	iLBC_Dec_Inst_t *	iLBCdec_inst,
		int	mode,
		int	use_enhancer
	)

Definition at line 33 of file iLBC_decode.c.

References iLBC_Dec_Inst_t_::blockl, BLOCKL_20MS, BLOCKL_30MS, BLOCKL_MAX, iLBC_Dec_Inst_t_::consPLICount, iLBC_Dec_Inst_t_::enh_buf, ENH_BUFL, ENH_NBLOCKS_TOT, iLBC_Dec_Inst_t_::enh_period, iLBC_Dec_Inst_t_::hpomem, iLBC_Dec_Inst_t_::last_lag, LPC_FILTERORDER, iLBC_Dec_Inst_t_::lpc_n, LPC_N_20MS, LPC_N_30MS, lsfmeanTbl, iLBC_Dec_Inst_t_::mode, iLBC_Dec_Inst_t_::nasub, NASUB_20MS, NASUB_30MS, iLBC_Dec_Inst_t_::no_of_bytes, NO_OF_BYTES_20MS, NO_OF_BYTES_30MS, iLBC_Dec_Inst_t_::no_of_words, NO_OF_WORDS_20MS, NO_OF_WORDS_30MS, iLBC_Dec_Inst_t_::nsub, NSUB_20MS, NSUB_30MS, NSUB_MAX, iLBC_Dec_Inst_t_::old_syntdenum, iLBC_Dec_Inst_t_::per, iLBC_Dec_Inst_t_::prev_enh_pl, iLBC_Dec_Inst_t_::prevLag, iLBC_Dec_Inst_t_::prevLpc, iLBC_Dec_Inst_t_::prevPLI, iLBC_Dec_Inst_t_::prevResidual, iLBC_Dec_Inst_t_::seed, iLBC_Dec_Inst_t_::state_short_len, STATE_SHORT_LEN_20MS, STATE_SHORT_LEN_30MS, iLBC_Dec_Inst_t_::syntMem, ULP_20msTbl, ULP_30msTbl, iLBC_Dec_Inst_t_::ULP_inst, and iLBC_Dec_Inst_t_::use_enhancer.

Referenced by ilbctolin_framein(), and main().

 {
 int i;

 iLBCdec_inst->mode = mode;





 if (mode==30) {
 iLBCdec_inst->blockl = BLOCKL_30MS;
 iLBCdec_inst->nsub = NSUB_30MS;
 iLBCdec_inst->nasub = NASUB_30MS;
 iLBCdec_inst->lpc_n = LPC_N_30MS;
 iLBCdec_inst->no_of_bytes = NO_OF_BYTES_30MS;
 iLBCdec_inst->no_of_words = NO_OF_WORDS_30MS;
 iLBCdec_inst->state_short_len=STATE_SHORT_LEN_30MS;
 /* ULP init */
 iLBCdec_inst->ULP_inst=&ULP_30msTbl;
 }
 else if (mode==20) {
 iLBCdec_inst->blockl = BLOCKL_20MS;
 iLBCdec_inst->nsub = NSUB_20MS;
 iLBCdec_inst->nasub = NASUB_20MS;
 iLBCdec_inst->lpc_n = LPC_N_20MS;
 iLBCdec_inst->no_of_bytes = NO_OF_BYTES_20MS;
 iLBCdec_inst->no_of_words = NO_OF_WORDS_20MS;
 iLBCdec_inst->state_short_len=STATE_SHORT_LEN_20MS;
 /* ULP init */
 iLBCdec_inst->ULP_inst=&ULP_20msTbl;
 }
 else {
 exit(2);
 }

 memset(iLBCdec_inst->syntMem, 0,
 LPC_FILTERORDER*sizeof(float));
 memcpy((*iLBCdec_inst).lsfdeqold, lsfmeanTbl,
 LPC_FILTERORDER*sizeof(float));

 memset(iLBCdec_inst->old_syntdenum, 0,
 ((LPC_FILTERORDER + 1)*NSUB_MAX)*sizeof(float));
 for (i=0; i<NSUB_MAX; i++)
 iLBCdec_inst->old_syntdenum[i*(LPC_FILTERORDER+1)]=1.0;

 iLBCdec_inst->last_lag = 20;

 iLBCdec_inst->prevLag = 120;
 iLBCdec_inst->per = 0.0;
 iLBCdec_inst->consPLICount = 0;
 iLBCdec_inst->prevPLI = 0;
 iLBCdec_inst->prevLpc[0] = 1.0;
 memset(iLBCdec_inst->prevLpc+1,0,
 LPC_FILTERORDER*sizeof(float));
 memset(iLBCdec_inst->prevResidual, 0, BLOCKL_MAX*sizeof(float));
 iLBCdec_inst->seed=777;






 memset(iLBCdec_inst->hpomem, 0, 4*sizeof(float));

 iLBCdec_inst->use_enhancer = use_enhancer;
 memset(iLBCdec_inst->enh_buf, 0, ENH_BUFL*sizeof(float));
 for (i=0;i<ENH_NBLOCKS_TOT;i++)
 iLBCdec_inst->enh_period[i]=(float)40.0;

 iLBCdec_inst->prev_enh_pl = 0;

 return (iLBCdec_inst->blockl);
 }