lpc.c

这是g.723语音标准的编码过程

**  Word16 Dpnt[]       Highpass filtered speech x[n] (240 words)
**  Word16 PerLpc[]     Filter coefficients (80 words)
**
** Inputs:
**
**  CodStat.WghtFirDl[] FIR filter memory from previous frame (10 words)
**  CodStat.WghtIirDl[] IIR filter memory from previous frame (10 words)

**
** Outputs:
**
**  Word16 Dpnt[]       Weighted speech f[n] (240 words)
**
** Return value:    None
**
*/
void  Error_Wght( Word16 *Dpnt, Word16 *PerLpc )
{
    int   i,j,k ;

    Word32   Acc0  ;


/*
 * Do for all subframes
 */
    for ( k = 0 ; k < SubFrames ; k ++ ) {

        for ( i = 0 ; i < SubFrLen ; i ++ ) {

/*
 * Do the FIR part
 */
            /* Filter */
            Acc0 = L_mult( *Dpnt, (Word16) 0x2000 ) ;
            for ( j = 0 ; j < LpcOrder ; j ++ )
                Acc0 = L_msu( Acc0, PerLpc[j], CodStat.WghtFirDl[j] ) ;

            /* Update memory */
            for ( j = LpcOrder-1 ; j > 0 ; j -- )
                CodStat.WghtFirDl[j] = CodStat.WghtFirDl[j-1] ;
            CodStat.WghtFirDl[0] = *Dpnt ;

 /*
  * Do the IIR part
  */

            /* Filter */
            for ( j = 0 ; j < LpcOrder ; j ++ )
                Acc0 = L_mac( Acc0, PerLpc[LpcOrder+j],
                                                    CodStat.WghtIirDl[j] ) ;
            for ( j = LpcOrder-1 ; j > 0 ; j -- )
                CodStat.WghtIirDl[j] = CodStat.WghtIirDl[j-1] ;
            Acc0 = L_shl( Acc0, (Word16) 2 ) ;

            /* Update memory */
            CodStat.WghtIirDl[0] = round( Acc0 ) ;
            *Dpnt ++ = CodStat.WghtIirDl[0] ;
        }
        PerLpc += 2*LpcOrder ;
    }
}

/*
**
** Function:        Comp_Ir()
**
** Description:     Computes the combined impulse response of the
**          formant perceptual weighting filter, harmonic
**          noise shaping filter, and synthesis filter for
**          a subframe.
**
** Links to text:   Section 2.12
**
** Arguments:
**
**  Word16 *ImpResp     Empty Buffer
**  Word16 QntLpc[]     Quantized LPC coefficients (10 words)
**  Word16 PerLpc[]     Perceptual filter coefficients (20 words)
**  PWDEF Pw        Harmonic noise shaping filter parameters
**
** Outputs:
**
**  Word16 ImpResp[]    Combined impulse response (60 words)
**
** Return value:    None
**
*/
void  Comp_Ir( Word16 *ImpResp, Word16 *QntLpc, Word16 *PerLpc, PWDEF Pw )
{
    int   i,j   ;

    Word16   FirDl[LpcOrder] ;
    Word16   IirDl[LpcOrder] ;
    Word16   Temp[PitchMax+SubFrLen] ;

    Word32   Acc0,Acc1 ;


 /*
  * Clear all memory.  Impulse response calculation requires
  * an all-zero initial state.
  */

    /* Perceptual weighting filter */
    for ( i = 0 ; i < LpcOrder ; i ++ )
        FirDl[i] = IirDl[i] = (Word16) 0 ;

    /* Harmonic noise shaping filter */
    for ( i = 0 ; i < PitchMax+SubFrLen ; i ++ )
        Temp[i] = (Word16) 0 ;


 /*
  * Input a single impulse
  */
    Acc0 = (Word32) 0x04000000L ;

 /*
  * Do for all elements in a subframe
  */
    for ( i = 0 ; i < SubFrLen ; i ++ ) {

 /*
  * Synthesis filter
  */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, QntLpc[j], FirDl[j] ) ;
        Acc1 = L_shl( Acc0, (Word16) 2 ) ;

 /*
  * Perceptual weighting filter
  */

        /* FIR part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_msu( Acc0, PerLpc[j], FirDl[j] ) ;
                                Acc0 = L_shl( Acc0, (Word16) 1 ) ;
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            FirDl[j] = FirDl[j-1] ;
        FirDl[0] = round( Acc1 ) ;

        /* Iir part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, PerLpc[LpcOrder+j], IirDl[j] ) ;
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            IirDl[j] = IirDl[j-1] ;
        Acc0 = L_shl( Acc0, (Word16) 2 ) ;
        IirDl[0] = round( Acc0 ) ;
        Temp[PitchMax+i] = IirDl[0] ;

 /*
  * Harmonic noise shaping filter
  */

        Acc0 = L_deposit_h( IirDl[0] ) ;
        Acc0 = L_msu( Acc0, Pw.Gain, Temp[PitchMax-Pw.Indx+i] ) ;
        ImpResp[i] = round( Acc0 ) ;

        Acc0 = (Word32) 0 ;
    }
}

/*
**
** Function:        Sub_Ring()
**
** Description:     Computes the zero-input response of the
**          combined formant perceptual weighting filter,
**          harmonic noise shaping filter, and synthesis
**          filter for a subframe.  Subtracts the
**          zero-input response from the harmonic noise
**          weighted speech vector to produce the target 
**          speech vector.
**
** Links to text:   Section 2.13
**
** Arguments:       
**
**  Word16 Dpnt[]       Harmonic noise weighted vector w[n] (60 words)
**  Word16 QntLpc[]     Quantized LPC coefficients (10 words)
**  Word16 PerLpc[]     Perceptual filter coefficients (20 words)
**  Word16 PrevErr[]    Harmonic noise shaping filter memory (145 words)
**  PWDEF Pw        Harmonic noise shaping filter parameters
**  
** Inputs:
**
**  CodStat.RingFirDl[] Perceptual weighting filter FIR memory from 
**               previous subframe (10 words)
**  CodStat.RingIirDl[] Perceptual weighting filter IIR memory from 
**               previous subframe (10 words)
**
** Outputs:     
**
**  Word16 Dpnt[]       Target vector t[n] (60 words)
**
** Return value:    None
**
*/
void  Sub_Ring( Word16 *Dpnt, Word16 *QntLpc, Word16 *PerLpc, Word16
*PrevErr, PWDEF Pw )
{
    int   i,j   ;
    Word32   Acc0,Acc1 ;

    Word16   FirDl[LpcOrder] ;
    Word16   IirDl[LpcOrder] ;
    Word16   Temp[PitchMax+SubFrLen] ;


 /*
  * Initialize the memory
  */
    for ( i = 0 ; i < PitchMax ; i ++ )
        Temp[i] = PrevErr[i] ;

    for ( i = 0 ; i < LpcOrder ; i ++ ) {
        FirDl[i] = CodStat.RingFirDl[i] ;
        IirDl[i] = CodStat.RingIirDl[i] ;
    }

 /*
  * Do for all elements in a subframe
  */
    for ( i = 0 ; i < SubFrLen ; i ++ ) {

 /*
  * Input zero
  */
        Acc0 = (Word32) 0 ;

 /*
  * Synthesis filter
  */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, QntLpc[j], FirDl[j] ) ;
        Acc1 = L_shl( Acc0, (Word16) 2 ) ;

 /*
  * Perceptual weighting filter
  */

        /* Fir part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_msu( Acc0, PerLpc[j], FirDl[j] ) ;
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            FirDl[j] = FirDl[j-1] ;
        FirDl[0] = round( Acc1 ) ;

        /* Iir part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, PerLpc[LpcOrder+j], IirDl[j] ) ;
        Acc0 = L_shl( Acc0, (Word16) 2 ) ;
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            IirDl[j] = IirDl[j-1] ;
        IirDl[0] = round( Acc0 ) ;
        Temp[PitchMax+i] = IirDl[0] ;

 /*
  * Do the harmonic noise shaping filter and subtract the result
  * from the harmonic noise weighted vector.
  */
        Acc0 = L_deposit_h( sub( Dpnt[i], IirDl[0] ) ) ;
        Acc0 = L_mac( Acc0, Pw.Gain, Temp[PitchMax-(int)Pw.Indx+i] ) ;
        Dpnt[i] = round ( Acc0 ) ;
    }
}

/*
**
** Function:        Upd_Ring()
**
** Description:     Updates the memory of the combined formant
**          perceptual weighting filter, harmonic noise
**          shaping filter, and synthesis filter for a
**          subframe.  The update is done by passing the
**          current subframe's excitation through the
**          combined filter.
**
** Links to text:   Section 2.19
**
** Arguments:       
**
**  Word16 Dpnt[]       Decoded excitation for the current subframe e[n] 
**               (60 words)
**  Word16 QntLpc[]     Quantized LPC coefficients (10 words)
**  Word16 PerLpc[]     Perceptual filter coefficients (20 words)
**  Word16 PrevErr[]    Harmonic noise shaping filter memory (145 words)
**  
** Inputs:
**
**  CodStat.RingFirDl[] Perceptual weighting filter FIR memory from 

**               previous subframe (10 words)
**  CodStat.RingIirDl[] Perceptual weighting filter IIR memory from 
**               previous subframe (10 words)
**
** Outputs:     
**
**  Word16 PrevErr[]    Updated harmonic noise shaping filter memory 
**  CodStat.RingFirDl[] Updated perceptual weighting filter FIR memory 
**  CodStat.RingIirDl[] Updated perceptual weighting filter IIR memory 
**
** Return value:    None
**
*/
void  Upd_Ring( Word16 *Dpnt, Word16 *QntLpc, Word16 *PerLpc, Word16
*PrevErr )
{
    int   i,j   ;

    Word32   Acc0,Acc1   ;


 /*
  * Shift the harmonic noise shaping filter memory
  */
    for ( i = SubFrLen ; i < PitchMax ; i ++ )
        PrevErr[i-SubFrLen] = PrevErr[i] ;


 /*
  * Do for all elements in the subframe
  */
    for ( i = 0 ; i < SubFrLen ; i ++ ) {

 /*
  * Input the current subframe's excitation
  */
        Acc0 = L_deposit_h( Dpnt[i] ) ;
        Acc0 = L_shr( Acc0, (Word16) 3 ) ;

 /*
  * Synthesis filter
  */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, QntLpc[j], CodStat.RingFirDl[j] ) ;
        Acc1 = L_shl( Acc0, (Word16) 2 ) ;

        Dpnt[i] = shl( round( Acc1 ), (Word16) 1 ) ;

 /*
  * Perceptual weighting filter
  */

        /* FIR part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_msu( Acc0, PerLpc[j], CodStat.RingFirDl[j] ) ;

        /* Update FIR memory */
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            CodStat.RingFirDl[j] = CodStat.RingFirDl[j-1] ;
        CodStat.RingFirDl[0] = round( Acc1 ) ;

        /* IIR part */
        for ( j = 0 ; j < LpcOrder ; j ++ )
            Acc0 = L_mac( Acc0, PerLpc[LpcOrder+j], CodStat.RingIirDl[j] ) ;
        Acc0 = L_shl( Acc0, (Word16) 2 ) ;

        /* Update IIR memory */
        for ( j = LpcOrder-1 ; j > 0 ; j -- )
            CodStat.RingIirDl[j] = CodStat.RingIirDl[j-1] ;
        CodStat.RingIirDl[0] = round( Acc0 ) ;

        /* Update harmonic noise shaping memory */
        PrevErr[PitchMax-SubFrLen+i] = CodStat.RingIirDl[0] ;
    }
}