/* 
       * 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] ;
      }
}


/*
**
** Function:        Synt()
**
** Description:     Implements the decoder synthesis filter for a
**          subframe.  This is a tenth-order IIR filter.
**
** Links to text:   Section 3.7
**
** Arguments:       
**
**  Word16 Dpnt[]       Pitch-postfiltered excitation for the current 
**               subframe ppf[n] (60 words)
**  Word16 Lpc[]        Quantized LPC coefficients (10 words)
**  
** Inputs:
**
**  DecStat.SyntIirDl[] Synthesis filter memory from previous
subframe (10 words)
**
** Outputs:     
**
**  Word16 Dpnt[]       Synthesized speech vector sy[n]
**  DecStat.SyntIirDl[] Updated synthesis filter memory 
**
** Return value:    None
**
*/
void     Synt( Word16 *Dpnt, Word16 *Lpc )
{
   int   i,j   ;

   Word32   Acc0  ;


   /*
    * 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, Lpc[j], DecStat.SyntIirDl[j] ) ;

      /* Update memory */
      for ( j = LpcOrder-1 ; j > 0 ; j -- )
         DecStat.SyntIirDl[j] = DecStat.SyntIirDl[j-1] ;

      Acc0 = L_shl( Acc0, (Word16) 2 ) ;

      DecStat.SyntIirDl[0] = round( Acc0 ) ;


      /* 
       * Scale output if postfilter is off.  (Otherwise output is
       * scaled by the gain scaling unit.)  
       */
      if ( UsePf )
         Dpnt[i] = DecStat.SyntIirDl[0] ;
      else
         Dpnt[i] = shl( DecStat.SyntIirDl[0], (Word16) 1 ) ;

      }
}


/*
**
** Function:        Spf()
**
** Description:     Implements the formant postfilter for a
**          subframe.  The formant postfilter is a
**          10-pole, 10-zero ARMA filter followed by a
**          single-tap tilt compensation filter.
**
** Links to text:   Section 3.8
**
** Arguments:       
**
**  Word16 Tv[]     Synthesized speech vector sy[n] (60 words)
**  Word16 Lpc[]        Quantized LPC coefficients (10 words)
**  
** Inputs:
**
**  DecStat.PostIirDl[] Postfilter IIR memory from previous
subframe (10 words)
**  DecStat.PostFirDl[] Postfilter FIR memory from previous
subframe (10 words)
**  DecStat.Park        Previous value of compensation filter parameter
**
** Outputs:     
**
**  Word16 Tv[]     Postfiltered speech vector pf[n] (60 words)
**  DecStat.PostIirDl[] Updated postfilter IIR memory
**  DecStat.PostFirDl[] Updated postfilter FIR memory
**  DecStat.Park        Updated compensation filter parameter
**
** Return value: Input vector energy
**
*/
Word32  Spf( Word16 *Tv, Word16 *Lpc )
{
   int   i,j   ;

   Word32   Acc0,Acc1   ;
   Word32   Sen ;
   Word16   Tmp ;
   Word16   Exp ;

   Word16   FirCoef[LpcOrder] ;
   Word16   IirCoef[LpcOrder] ;

   Word16   TmpVect[SubFrLen] ;

   /* 
    * Compute ARMA coefficients.  Compute the jth FIR coefficient by
    * multiplying the jth quantized LPC coefficient by (0.65)^j.
    * Compute the jth IIR coefficient by multiplying the jth quantized
    * LPC coefficient by (0.75)^j.  This emphasizes the formants in
    * the frequency response.  
    */
   for ( i = 0 ; i < LpcOrder ; i ++ ) {
      FirCoef[i] = mult_r( Lpc[i], PostFiltZeroTable[i] ) ;
      IirCoef[i] = mult_r( Lpc[i], PostFiltPoleTable[i] ) ;
      }

   /*
    * Normalize the speech vector.
    */
   for ( i = 0 ; i < SubFrLen ; i ++ )
      TmpVect[i] = Tv[i] ;
   Exp = Vec_Norm( TmpVect, (Word16) SubFrLen ) ;

   /*
    * Compute the first two autocorrelation coefficients R[0] and R[1]
    */
   Acc0 = (Word32) 0 ;
   Acc1 = L_mult( TmpVect[0], TmpVect[0] ) ;
   for ( i = 1 ; i < SubFrLen ; i ++ ) {
      Acc0 = L_mac( Acc0, TmpVect[i], TmpVect[i-1] ) ;
      Acc1 = L_mac( Acc1, TmpVect[i], TmpVect[i] ) ;
      }

   /*
    * Scale the energy for the later use.
    */
   Sen = L_shr( Acc1, (Word16)(2*Exp + 4) ) ;

   /* 
    * Compute the first-order partial correlation coefficient of the
    * input speech vector.
    */
   Tmp = extract_h( Acc1 ) ;
   if ( Tmp != (Word16) 0 ) {

      /* Compute first parcor */
      Acc0 = L_shr( Acc0, (Word16) 1 ) ;
      Acc1 = Acc0 ;
      Acc0 = L_abs( Acc0 ) ;

      Tmp = div_l( Acc0, Tmp ) ;

      if ( Acc1 < (Word32) 0 )
         Tmp = negate( Tmp ) ;
      }
   else
      Tmp = (Word16) 0 ;

   /* 
    * Compute the compensation filter parameter and update the memory
    */
   Acc0 = L_deposit_h( DecStat.Park ) ;
   Acc0 = L_msu( Acc0, DecStat.Park, (Word16) 0x2000 ) ;
   Acc0 = L_mac( Acc0, Tmp, (Word16) 0x2000 ) ;
   DecStat.Park = round( Acc0 ) ;

   Tmp = mult( DecStat.Park, PreCoef ) ;
   Tmp &= (Word16) 0xfffc ;


   /* 
    *  Do for all elements in the subframe
    */
   for ( i = 0 ; i < SubFrLen ; i ++ ) {
     
     /* 
      * Input the speech vector
      */
      Acc0 = L_deposit_h( Tv[i] ) ;
      Acc0 = L_shr( Acc0, (Word16) 2 ) ;


      /* 
       * Formant postfilter
       */

      /* FIR part */
      for ( j = 0 ; j < LpcOrder ; j ++ )
         Acc0 = L_msu( Acc0, FirCoef[j], DecStat.PostFirDl[j] ) ;

      /* Update FIR memory */
      for ( j = LpcOrder-1 ; j > 0 ; j -- )
         DecStat.PostFirDl[j] = DecStat.PostFirDl[j-1] ;
      DecStat.PostFirDl[0] = Tv[i] ;

      /* IIR part */
      for ( j = 0 ; j < LpcOrder ; j ++ )
         Acc0 = L_mac( Acc0, IirCoef[j], DecStat.PostIirDl[j] ) ;
      
      /* Update IIR memory */
      for ( j = LpcOrder-1 ; j > 0 ; j -- )
         DecStat.PostIirDl[j] = DecStat.PostIirDl[j-1] ;

      Acc0 = L_shl( Acc0, (Word16) 2 ) ;
      Acc1 = Acc0 ;

      DecStat.PostIirDl[0] = round( Acc0 ) ;

      /* 
       * Compensation filter
       */
      Acc1 = L_mac( Acc1, DecStat.PostIirDl[1], Tmp ) ;

      Tv[i] = round( Acc1 ) ;
      }
   return Sen ;
}