ilbc_encode.cxx

MiniSip Client with DomainKeys Authentication, Sip, Audio communications, Echo Cancel

    
           /* loop over subframes to encode */ 
    
           for (subframe=0; subframe<Nfor; subframe++) { 
    
               /* encode subframe */ 
    
               iCBSearch(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*(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(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<6;k++) { 
               packsplit(&lsf_i[k], &firstpart, &lsf_i[k],  
                   ulp_lsf_bitsTbl[k][ulp],  
                   ulp_lsf_bitsTbl[k][ulp]+ 
                   ulp_lsf_bitsTbl[k][ulp+1]+ 
                   ulp_lsf_bitsTbl[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   ulp_lsf_bitsTbl[k][ulp], &pos); 
           } 
    
           /* Start block info */ 
    
           packsplit(&start, &firstpart, &start,  
               ulp_start_bitsTbl[ulp],  
               ulp_start_bitsTbl[ulp]+ 
               ulp_start_bitsTbl[ulp+1]+ 
               ulp_start_bitsTbl[ulp+2]); 
           dopack( &pbytes, firstpart,  
               ulp_start_bitsTbl[ulp], &pos); 
    
           packsplit(&state_first, &firstpart, &state_first,  
               ulp_startfirst_bitsTbl[ulp],  
               ulp_startfirst_bitsTbl[ulp]+ 
               ulp_startfirst_bitsTbl[ulp+1]+ 
               ulp_startfirst_bitsTbl[ulp+2]); 
     
           dopack( &pbytes, firstpart,  
               ulp_startfirst_bitsTbl[ulp], &pos); 
    
           packsplit(&idxForMax, &firstpart, &idxForMax,  
               ulp_scale_bitsTbl[ulp], ulp_scale_bitsTbl[ulp]+ 
               ulp_scale_bitsTbl[ulp+1]+ulp_scale_bitsTbl[ulp+2]); 
           dopack( &pbytes, firstpart,  
               ulp_scale_bitsTbl[ulp], &pos); 
    
           for (k=0; k<STATE_SHORT_LEN; k++) { 
               packsplit(idxVec+k, &firstpart, idxVec+k,  
                   ulp_state_bitsTbl[ulp],  
                   ulp_state_bitsTbl[ulp]+ 
                   ulp_state_bitsTbl[ulp+1]+ 
                   ulp_state_bitsTbl[ulp+2]); 
               dopack( &pbytes, firstpart,  
                   ulp_state_bitsTbl[ulp], &pos); 
           } 
    
           /* 22 sample block */ 
    
           for (k=0;k<CB_NSTAGES;k++) { 
               packsplit(extra_cb_index+k, &firstpart,  
                   extra_cb_index+k,  
                   ulp_extra_cb_indexTbl[k][ulp],  
                   ulp_extra_cb_indexTbl[k][ulp]+ 
                   ulp_extra_cb_indexTbl[k][ulp+1]+ 
                   ulp_extra_cb_indexTbl[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   ulp_extra_cb_indexTbl[k][ulp], &pos); 
           } 
           for (k=0;k<CB_NSTAGES;k++) { 
               packsplit(extra_gain_index+k, &firstpart,  
                   extra_gain_index+k,  
                   ulp_extra_cb_gainTbl[k][ulp],  
                   ulp_extra_cb_gainTbl[k][ulp]+ 
                   ulp_extra_cb_gainTbl[k][ulp+1]+ 
                   ulp_extra_cb_gainTbl[k][ulp+2]); 
               dopack( &pbytes, firstpart,  
                   ulp_extra_cb_gainTbl[k][ulp], &pos); 
           } 
                
           /* The four 40 sample sub blocks */ 
    
           for (i=0; i<NASUB; i++) { 
               for (k=0; k<CB_NSTAGES; k++) { 
                   packsplit(cb_index+i*CB_NSTAGES+k, &firstpart,  
                       cb_index+i*CB_NSTAGES+k,  
                       ulp_cb_indexTbl[i][k][ulp],  
                       ulp_cb_indexTbl[i][k][ulp]+ 
                       ulp_cb_indexTbl[i][k][ulp+1]+ 
                       ulp_cb_indexTbl[i][k][ulp+2]); 
                   dopack( &pbytes, firstpart,  
     
                       ulp_cb_indexTbl[i][k][ulp], &pos); 
               } 
           } 
            
           for (i=0; i<NASUB; i++) { 
               for (k=0; k<CB_NSTAGES; k++) { 
                   packsplit(gain_index+i*CB_NSTAGES+k, &firstpart,  
                       gain_index+i*CB_NSTAGES+k,  
                       ulp_cb_gainTbl[i][k][ulp],  
                       ulp_cb_gainTbl[i][k][ulp]+ 
                       ulp_cb_gainTbl[i][k][ulp+1]+ 
                       ulp_cb_gainTbl[i][k][ulp+2]); 
                   dopack( &pbytes, firstpart,  
                       ulp_cb_gainTbl[i][k][ulp], &pos); 
               } 
           } 
       } 
    
       /* set the last unused bit to zero */ 
       dopack( &pbytes, 0, 1, &pos); 
   }