iLBC_decode.h File Reference

#include "iLBC_define.h"

Include dependency graph for iLBC_decode.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
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

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.

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

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().

initDecode()

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

Definition at line 33 of file iLBC_decode.c.

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

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().