unsigned char *bytes,           /* (i) encoded signal bits */       iLBC_Dec_Inst_t *iLBCdec_inst,  /* (i/o) the decoder state                                                structure */       int mode                    /* (i) 0: bad packet, PLC,                                              1: normal */   ){       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 check;       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);               check=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;       }   }