    
   /****************************************************************** 
    
       iLBC Speech Coder ANSI-C Source Code 
    
       iLBC_encode.c  
    
       Copyright (c) 2001, 
       Global IP Sound AB. 
       All rights reserved. 
    
   ******************************************************************/ 
    
   #include <math.h> 
   #include <stdlib.h> 
   #include <string.h> 
    
   #include "iLBC_define.h" 
   #include "LPCencode.h" 
   #include "FrameClassify.h" 
   #include "StateSearchW.h" 
   #include "StateConstructW.h" 
   #include "helpfun.h" 
   #include "constants.h" 
   #include "packing.h" 
   #include "iCBSearch.h" 
   #include "iCBConstruct.h" 
   #include "hpInput.h" 
   #include "anaFilter.h" 
   #include "syntFilter.h" 
    
   /*----------------------------------------------------------------* 
    *  Initiation of encoder instance. 
    *---------------------------------------------------------------*/ 
    
   short initEncode(                   /* (o) Number of bytes encoded */ 
       iLBC_Enc_Inst_t *iLBCenc_inst,  /* (i/o) Encoder instance */ 
     
    
    
       int mode                    /* (i) frame size mode */ 
   ){ 
       iLBCenc_inst->mode = mode; 
       if (mode==30) { 
           iLBCenc_inst->blockl = BLOCKL_30MS; 
           iLBCenc_inst->nsub = NSUB_30MS; 
           iLBCenc_inst->nasub = NASUB_30MS; 
           iLBCenc_inst->lpc_n = LPC_N_30MS; 
           iLBCenc_inst->no_of_bytes = NO_OF_BYTES_30MS; 
           iLBCenc_inst->no_of_words = NO_OF_WORDS_30MS; 
           iLBCenc_inst->state_short_len=STATE_SHORT_LEN_30MS; 
           /* ULP init */ 
           iLBCenc_inst->ULP_inst=&ULP_30msTbl; 
       } 
       else if (mode==20) { 
           iLBCenc_inst->blockl = BLOCKL_20MS; 
           iLBCenc_inst->nsub = NSUB_20MS; 
           iLBCenc_inst->nasub = NASUB_20MS; 
           iLBCenc_inst->lpc_n = LPC_N_20MS; 
           iLBCenc_inst->no_of_bytes = NO_OF_BYTES_20MS; 
           iLBCenc_inst->no_of_words = NO_OF_WORDS_20MS; 
           iLBCenc_inst->state_short_len=STATE_SHORT_LEN_20MS; 
           /* ULP init */ 
           iLBCenc_inst->ULP_inst=&ULP_20msTbl; 
       } 
       else { 
           exit(2); 
       } 
    
       memset((*iLBCenc_inst).anaMem, 0,  
           LPC_FILTERORDER*sizeof(float)); 
       memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl, 
           LPC_FILTERORDER*sizeof(float)); 
       memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl, 
           LPC_FILTERORDER*sizeof(float)); 
       memset((*iLBCenc_inst).lpc_buffer, 0,  
           (LPC_LOOKBACK+BLOCKL_MAX)*sizeof(float)); 
       memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float)); 
    
       return (iLBCenc_inst->no_of_bytes); 
   } 
    
   /*----------------------------------------------------------------* 
    *  main encoder function  
    *---------------------------------------------------------------*/ 
    
   void iLBC_encode( 
       unsigned char *bytes,           /* (o) encoded data bits iLBC */ 
       float *block,                   /* (o) speech vector to encode */ 
       iLBC_Enc_Inst_t *iLBCenc_inst   /* (i/o) the general encoder  
                                              state */ 
   ){ 
        
     
    
    
       float data[BLOCKL_MAX]; 
       float residual[BLOCKL_MAX], reverseResidual[BLOCKL_MAX]; 
    
       int start, idxForMax, idxVec[STATE_LEN]; 
       float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML]; 
       int n, k, meml_gotten, Nfor, Nback, i, pos; 
       int gain_index[CB_NSTAGES*NASUB_MAX],  
           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]; 
       unsigned char *pbytes; 
       int diff, start_pos, state_first; 
       float en1, en2; 
       int index, ulp, firstpart; 
       int subcount, subframe; 
       float weightState[LPC_FILTERORDER]; 
       float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)];  
       float weightdenum[NSUB_MAX*(LPC_FILTERORDER+1)];  
       float decresidual[BLOCKL_MAX]; 
    
       /* high pass filtering of input signal if such is not done  
              prior to calling this function */ 
    
       hpInput(block, iLBCenc_inst->blockl,  
                   data, (*iLBCenc_inst).hpimem); 
    
       /* otherwise simply copy */ 
    
       /*memcpy(data,block,iLBCenc_inst->blockl*sizeof(float));*/ 
            
       /* LPC of hp filtered input data */ 
    
       LPCencode(syntdenum, weightdenum, lsf_i, data, iLBCenc_inst); 
    
    
       /* inverse filter to get residual */ 
    
       for (n=0; n<iLBCenc_inst->nsub; n++) { 
           anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)],  
               SUBL, &residual[n*SUBL], iLBCenc_inst->anaMem); 
       } 
    
       /* find state location */ 
    
       start = FrameClassify(iLBCenc_inst, residual); 
        
       /* check if state should be in first or last part of the  
       two subframes */ 
    
       diff = STATE_LEN - iLBCenc_inst->state_short_len; 
       en1 = 0; 
       index = (start-1)*SUBL; 
       for (i = 0; i < iLBCenc_inst->state_short_len; i++) { 
     
    
    
           en1 += residual[index+i]*residual[index+i]; 
       } 
       en2 = 0; 
       index = (start-1)*SUBL+diff; 
       for (i = 0; i < iLBCenc_inst->state_short_len; i++) { 
           en2 += residual[index+i]*residual[index+i]; 
       } 
        
        
       if (en1 > en2) { 
           state_first = 1; 
           start_pos = (start-1)*SUBL; 
       } else { 
           state_first = 0; 
           start_pos = (start-1)*SUBL + diff; 
       } 
    
       /* scalar quantization of state */ 
    
       StateSearchW(iLBCenc_inst, &residual[start_pos],  
           &syntdenum[(start-1)*(LPC_FILTERORDER+1)],  
           &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax,  
           idxVec, iLBCenc_inst->state_short_len, state_first); 
    
       StateConstructW(idxForMax, idxVec,  
           &syntdenum[(start-1)*(LPC_FILTERORDER+1)],  
           &decresidual[start_pos], iLBCenc_inst->state_short_len); 
    
       /* predictive quantization in state */ 
        
       if (state_first) { /* put adaptive part in the end */ 
            
           /* setup memory */ 
    
           memset(mem, 0,  
               (CB_MEML-iLBCenc_inst->state_short_len)*sizeof(float)); 
           memcpy(mem+CB_MEML-iLBCenc_inst->state_short_len,  
               decresidual+start_pos,  
               iLBCenc_inst->state_short_len*sizeof(float)); 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
    
           /* encode subframes */ 
    
           iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index,  
               &residual[start_pos+iLBCenc_inst->state_short_len],  
               mem+CB_MEML-stMemLTbl, 
               stMemLTbl, diff, CB_NSTAGES,  
               &weightdenum[start*(LPC_FILTERORDER+1)], weightState, 0); 
    
           /* construct decoded vector */ 
    
           iCBConstruct( 
               &decresidual[start_pos+iLBCenc_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++) { 
               reverseResidual[k] = residual[(start+1)*SUBL-1 
                   -(k+iLBCenc_inst->state_short_len)]; 
           } 
            
           /* setup memory */ 
    
           meml_gotten = iLBCenc_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)); 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
            
           /* encode subframes */ 
    
           iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index,  
               reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl, diff,  
               CB_NSTAGES, &weightdenum[(start-1)*(LPC_FILTERORDER+1)],  
               weightState, 0); 
    
           /* 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 subframes */ 
    
       subcount=0; 
    
       /* forward prediction of subframes */ 
    
       Nfor = iLBCenc_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)); 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
    
           /* loop over subframes to encode */ 
    
           for (subframe=0; subframe<Nfor; subframe++) { 
    
               /* encode subframe */ 
    
               iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,  
                   gain_index+subcount*CB_NSTAGES,  
                   &residual[(start+1+subframe)*SUBL],  
                   mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],  
                   SUBL, CB_NSTAGES,  
                   &weightdenum[(start+1+subframe)*(LPC_FILTERORDER+1)], 
                   weightState, subcount+1); 
    
               /* 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)); 
               memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
    
               subcount++; 
           } 
       } 
        
    
       /* backward prediction of subframes */ 
    
       Nback = start-1; 
    
        
       if ( Nback > 0 ) { 
                   
           /* create reverse order vectors */ 
    
           for (n=0; n<Nback; n++) { 
               for (k=0; k<SUBL; k++) { 
     
    
    
                   reverseResidual[n*SUBL+k] =  
                       residual[(start-1)*SUBL-1-n*SUBL-k]; 
                   reverseDecresidual[n*SUBL+k] =  
                       decresidual[(start-1)*SUBL-1-n*SUBL-k]; 
               } 
           } 
    
           /* setup memory */ 
    
           meml_gotten = SUBL*(iLBCenc_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)); 
           memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
    
           /* loop over subframes to encode */ 
    
           for (subframe=0; subframe<Nback; subframe++) { 
                
               /* encode subframe */ 
    
               iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES,  
                   gain_index+subcount*CB_NSTAGES,  
                   &reverseResidual[subframe*SUBL],  
                   mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],  
                   SUBL, CB_NSTAGES,  
                   &weightdenum[(start-2-subframe)*(LPC_FILTERORDER+1)],  
                   weightState, subcount+1); 
    
               /* 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)); 
               memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); 
    
               subcount++; 
    
     
    
    
           } 
    
           /* get decoded residual from reversed vector */ 
    
           for (i=0; i<SUBL*Nback; i++) { 
               decresidual[SUBL*Nback - i - 1] =  
                   reverseDecresidual[i]; 
           } 
       } 
       /* end encoding part */ 
    
       /* adjust index */ 
       index_conv_enc(cb_index); 
    
       /* pack bytes */ 
    
       pbytes=bytes; 
       pos=0; 
    
       /* loop over the 3 ULP classes */ 
    
       for (ulp=0; ulp<3; ulp++) { 
        
           /* LSF */ 
           for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_n; k++) { 
               packsplit(&lsf_i[k], &firstpart, &lsf_i[k],  
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp],  
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+ 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+ 
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos); 
           } 
    
           /* Start block info */ 
    
           packsplit(&start, &firstpart, &start,  
               iLBCenc_inst->ULP_inst->start_bits[ulp],  
               iLBCenc_inst->ULP_inst->start_bits[ulp]+ 
               iLBCenc_inst->ULP_inst->start_bits[ulp+1]+ 
               iLBCenc_inst->ULP_inst->start_bits[ulp+2]); 
           dopack( &pbytes, firstpart,  
               iLBCenc_inst->ULP_inst->start_bits[ulp], &pos); 
    
           packsplit(&state_first, &firstpart, &state_first,  
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp],  
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+ 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+ 
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]); 
           dopack( &pbytes, firstpart,  
               iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos); 
    
           packsplit(&idxForMax, &firstpart, &idxForMax,  
     
    
    
               iLBCenc_inst->ULP_inst->scale_bits[ulp],  
               iLBCenc_inst->ULP_inst->scale_bits[ulp]+ 
               iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+ 
               iLBCenc_inst->ULP_inst->scale_bits[ulp+2]); 
           dopack( &pbytes, firstpart,  
               iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos); 
    
           for (k=0; k<iLBCenc_inst->state_short_len; k++) { 
               packsplit(idxVec+k, &firstpart, idxVec+k,  
                   iLBCenc_inst->ULP_inst->state_bits[ulp],  
                   iLBCenc_inst->ULP_inst->state_bits[ulp]+ 
                   iLBCenc_inst->ULP_inst->state_bits[ulp+1]+ 
                   iLBCenc_inst->ULP_inst->state_bits[ulp+2]); 
               dopack( &pbytes, firstpart,  
                   iLBCenc_inst->ULP_inst->state_bits[ulp], &pos); 
           } 
    
           /* 23/22 (20ms/30ms) sample block */ 
    
           for (k=0;k<CB_NSTAGES;k++) { 
               packsplit(extra_cb_index+k, &firstpart,  
                   extra_cb_index+k,  
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp],  
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+ 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+ 
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp],  
                   &pos); 
           } 
    
           for (k=0;k<CB_NSTAGES;k++) { 
               packsplit(extra_gain_index+k, &firstpart,  
                   extra_gain_index+k,  
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp],  
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+ 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+ 
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp],  
                   &pos); 
           } 
                
           /* The two/four (20ms/30ms) 40 sample sub blocks */ 
    
           for (i=0; i<iLBCenc_inst->nasub; i++) { 
               for (k=0; k<CB_NSTAGES; k++) { 
                   packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,  
                       cb_index+i*CB_NSTAGES+k,  
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp],  
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+ 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+ 
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]); 
     
    
    
                   dopack( &pbytes, firstpart,  
                       iLBCenc_inst->ULP_inst->cb_index[i][k][ulp],  
                       &pos); 
               } 
           } 
            
           for (i=0; i<iLBCenc_inst->nasub; i++) { 
               for (k=0; k<CB_NSTAGES; k++) { 
                   packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,  
                       gain_index+i*CB_NSTAGES+k,  
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp],  
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+ 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+ 
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]); 
                   dopack( &pbytes, firstpart,  
                       iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp],  
                       &pos); 
               } 
           } 
       } 
    
       /* set the last unused bit to zero */ 
       dopack( &pbytes, 0, 1, &pos); 
   } 
    
 
