ilbc_decode.c

PA1688网络电话机全部源程序

    
   void iLBC_decode(  
       float *decblock,            /* (o) decoded signal block */ 
       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; 
       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]); 
                   } 
               } 
           } 
    
           /* Check for bit errors */ 
           if (start<1) 
               mode = 0; 
           if (iLBCdec_inst->mode==20 && start>3) 
               mode = 0; 
           if (iLBCdec_inst->mode==30 && start>5) 
               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; 
       } 
   }