Пример #1
0
void DecoderInterpolateLSF(  
    float *syntdenum,   /* (o) synthesis filter coefficients */ 
    float *weightdenum, /* (o) weighting denumerator  
                               coefficients */ 
    float *lsfdeq,      /* (i) dequantized lsf coefficients */ 
    int length,         /* (i) length of lsf coefficient vector */ 
    iLBC_Dec_Inst_t *iLBCdec_inst  
                        /* (i) the decoder state structure */ 
){ 
    int    i, pos, lp_length; 
    float  lp[LPC_FILTERORDER + 1], *lsfdeq2; 
         
    lsfdeq2 = lsfdeq + length; 
    lp_length = length + 1; 
     
    if (iLBCdec_inst->mode==30) { 
        /* subframe 1: Interpolation between old and first */ 
 
        LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq,  
            lsf_weightTbl_30ms[0], length); 
        memcpy(syntdenum,lp,lp_length*sizeof(float)); 
        bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length); 
 
        /* subframes 2 to 6: interpolation between first and last  
        LSF */ 
     
        pos = lp_length; 
        for (i = 1; i < 6; i++) { 
            LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq2,  
                lsf_weightTbl_30ms[i], length); 
            memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); 
            bwexpand(weightdenum + pos, lp,  
                LPC_CHIRP_WEIGHTDENUM, lp_length); 
            pos += lp_length; 
        } 
    } 
    else { 
        pos = 0; 
        for (i = 0; i < iLBCdec_inst->nsub; i++) { 
            LSFinterpolate2a_dec(lp, iLBCdec_inst->lsfdeqold, lsfdeq,  
                lsf_weightTbl_20ms[i], length); 
            memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); 
            bwexpand(weightdenum+pos, lp, LPC_CHIRP_WEIGHTDENUM,  
                lp_length); 
            pos += lp_length; 
        } 
    } 
     
    /* update memory */ 
 
    if (iLBCdec_inst->mode==30) 
        memcpy(iLBCdec_inst->lsfdeqold, lsfdeq2,  
                    length*sizeof(float)); 
    else 
        memcpy(iLBCdec_inst->lsfdeqold, lsfdeq,  
                    length*sizeof(float)); 
 
} 
Пример #2
0
   void SimpleAnalysis(
       float *lsf,         /* (o) lsf coefficients */
       float *data,    /* (i) new data vector */
       iLBC_Enc_Inst_t *iLBCenc_inst
                           /* (i/o) the encoder state structure */
   ){
       int k, is;
       float temp[BLOCKL_MAX], lp[LPC_FILTERORDER + 1];
       float lp2[LPC_FILTERORDER + 1];
       float r[LPC_FILTERORDER + 1];

       is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl;
       memcpy(iLBCenc_inst->lpc_buffer+is,data,
           iLBCenc_inst->blockl*sizeof(float));

       /* No lookahead, last window is asymmetric */

       for (k = 0; k < iLBCenc_inst->lpc_n; k++) {

           is = LPC_LOOKBACK;

           if (k < (iLBCenc_inst->lpc_n - 1)) {
               window(temp, lpc_winTbl,
                   iLBCenc_inst->lpc_buffer, BLOCKL_MAX);
           } else {
               window(temp, lpc_asymwinTbl,
                   iLBCenc_inst->lpc_buffer + is, BLOCKL_MAX);
           }

           autocorr(r, temp, BLOCKL_MAX, LPC_FILTERORDER);
           window(r, r, lpc_lagwinTbl, LPC_FILTERORDER + 1);

           levdurb(lp, temp, r, LPC_FILTERORDER);
           bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, LPC_FILTERORDER+1);

           a2lsf(lsf + k*LPC_FILTERORDER, lp2);
       }
       is=LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl;
       memmove(iLBCenc_inst->lpc_buffer,
           iLBCenc_inst->lpc_buffer+LPC_LOOKBACK+BLOCKL_MAX-is,
           is*sizeof(float));
   }
Пример #3
0
static void SimpleAnalysis(float *lsf,                         /* (o) lsf coefficients */
                           float *data,                        /* (i) new data vector */
                           ilbc_encode_state_t *iLBCenc_inst)  /* (i/o) the encoder state structure */
{
    int k;
    int is;
    float temp[ILBC_BLOCK_LEN_MAX];
    float lp[ILBC_LPC_FILTERORDER + 1];
    float lp2[ILBC_LPC_FILTERORDER + 1];
    float r[ILBC_LPC_FILTERORDER + 1];

    is = LPC_LOOKBACK + ILBC_BLOCK_LEN_MAX - iLBCenc_inst->blockl;
    memcpy(iLBCenc_inst->lpc_buffer + is, data, iLBCenc_inst->blockl*sizeof(float));

    /* No lookahead, last window is asymmetric */

    for (k = 0;  k < iLBCenc_inst->lpc_n;  k++)
    {
        is = LPC_LOOKBACK;

        if (k < (iLBCenc_inst->lpc_n - 1))
            window(temp, lpc_winTbl, iLBCenc_inst->lpc_buffer, ILBC_BLOCK_LEN_MAX);
        else
            window(temp, lpc_asymwinTbl, iLBCenc_inst->lpc_buffer + is, ILBC_BLOCK_LEN_MAX);

        autocorr(r, temp, ILBC_BLOCK_LEN_MAX, ILBC_LPC_FILTERORDER);
        window(r, r, lpc_lagwinTbl, ILBC_LPC_FILTERORDER + 1);

        levdurb(lp, temp, r, ILBC_LPC_FILTERORDER);
        bwexpand(lp2, lp, LPC_CHIRP_SYNTDENUM, ILBC_LPC_FILTERORDER + 1);

        a2lsf(lsf + k*ILBC_LPC_FILTERORDER, lp2);
    }
    is = LPC_LOOKBACK + ILBC_BLOCK_LEN_MAX - iLBCenc_inst->blockl;
    memmove(iLBCenc_inst->lpc_buffer,
            iLBCenc_inst->lpc_buffer + LPC_LOOKBACK + ILBC_BLOCK_LEN_MAX - is,
            is*sizeof(float));
}
Пример #4
0
   void SimpleInterpolateLSF(
       float *syntdenum,   /* (o) the synthesis filter denominator
                                  resulting from the quantized
                                  interpolated lsf */
       float *weightdenum, /* (o) the weighting filter denominator
                                  resulting from the unquantized
                                  interpolated lsf */
       float *lsf,         /* (i) the unquantized lsf coefficients */
       float *lsfdeq,      /* (i) the dequantized lsf coefficients */
       float *lsfold,      /* (i) the unquantized lsf coefficients of
                                  the previous signal frame */
       float *lsfdeqold, /* (i) the dequantized lsf coefficients of
                                  the previous signal frame */
       int length,         /* (i) should equate LPC_FILTERORDER */
       iLBC_Enc_Inst_t *iLBCenc_inst
                           /* (i/o) the encoder state structure */
   ){
       int    i, pos, lp_length;
       float  lp[LPC_FILTERORDER + 1], *lsf2, *lsfdeq2;

       lsf2 = lsf + length;
       lsfdeq2 = lsfdeq + length;
       lp_length = length + 1;

       if (iLBCenc_inst->mode==30) {
           /* sub-frame 1: Interpolation between old and first


 set of lsf coefficients */

           LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
               lsf_weightTbl_30ms[0], length);
           memcpy(syntdenum,lp,lp_length*sizeof(float));
           LSFinterpolate2a_enc(lp, lsfold, lsf,
               lsf_weightTbl_30ms[0], length);
           bwexpand(weightdenum, lp, LPC_CHIRP_WEIGHTDENUM, lp_length);

           /* sub-frame 2 to 6: Interpolation between first
              and second set of lsf coefficients */

           pos = lp_length;
           for (i = 1; i < iLBCenc_inst->nsub; i++) {
               LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq2,
                   lsf_weightTbl_30ms[i], length);
               memcpy(syntdenum + pos,lp,lp_length*sizeof(float));

               LSFinterpolate2a_enc(lp, lsf, lsf2,
                   lsf_weightTbl_30ms[i], length);
               bwexpand(weightdenum + pos, lp,
                   LPC_CHIRP_WEIGHTDENUM, lp_length);
               pos += lp_length;
           }
       }
       else {
           pos = 0;
           for (i = 0; i < iLBCenc_inst->nsub; i++) {
               LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq,
                   lsf_weightTbl_20ms[i], length);
               memcpy(syntdenum+pos,lp,lp_length*sizeof(float));
               LSFinterpolate2a_enc(lp, lsfold, lsf,
                   lsf_weightTbl_20ms[i], length);
               bwexpand(weightdenum+pos, lp,
                   LPC_CHIRP_WEIGHTDENUM, lp_length);
               pos += lp_length;
           }
       }

       /* update memory */

       if (iLBCenc_inst->mode==30) {
           memcpy(lsfold, lsf2, length*sizeof(float));
           memcpy(lsfdeqold, lsfdeq2, length*sizeof(float));
       }
       else {
           memcpy(lsfold, lsf, length*sizeof(float));
           memcpy(lsfdeqold, lsfdeq, length*sizeof(float));


 }
   }