/******************************************************************       iLBC Speech Coder ANSI-C Source Code       iLBC_decode.c       Copyright (C) The Internet Society (2004).       All Rights Reserved.   ******************************************************************/   #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"   /*----------------------------------------------------------------*    *  Initiation of decoder instance.    *---------------------------------------------------------------*/   short initDecode(                   /* (o) Number of decoded                                              samples */       iLBC_Dec_Inst_t *iLBCdec_inst,  /* (i/o) Decoder instance */       int mode,                       /* (i) frame size mode */       int use_enhancer                /* (i) 1 to use enhancer                                              0 to run without                                                enhancer */   ){       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 (short)(iLBCdec_inst->blockl);   }   /*----------------------------------------------------------------*    *  frame residual decoder function (subrutine to iLBC_decode)    *---------------------------------------------------------------*/   void Decode(       iLBC_Dec_Inst_t *iLBCdec_inst,  /* (i/o) the decoder state                                                structure */       float *decresidual,             /* (o) decoded residual frame */       int start,                      /* (i) location of start                                              state */       int idxForMax,                  /* (i) codebook index for the                                              maximum value */       int *idxVec,                /* (i) codebook indexes for the                                              samples  in the start                                              state */       float *syntdenum,               /* (i) the decoded synthesis                                              filter coefficients */       int *cb_index,                  /* (i) the indexes for the                                              adaptive codebook */       int *gain_index,            /* (i) the indexes for the                                              corresponding gains */       int *extra_cb_index,        /* (i) the indexes for the                                              adaptive codebook part                                              of start state */       int *extra_gain_index,          /* (i) the indexes for the                                              corresponding gains */       int state_first                 /* (i) 1 if non adaptive part                                              of start state comes                                              first 0 if that part                                              comes last */   ){       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 */               memcpy(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 */               memcpy(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];       }   }   /*----------------------------------------------------------------*    *  main decoder function    *---------------------------------------------------------------*/   void iLBC_decode(       float *decblock,            /* (o) decoded signal block */