*/
void  Gen_Trn( Word16 *Dst, Word16 *Src, Word16 Olp )
{
    int   i  ;

    Word16   Tmp0,Tmp1   ;
    Word16   Tmp[SubFrLen] ;

    Tmp0 = Olp ;

    for ( i = 0 ; i < SubFrLen ; i ++ ) {
        Tmp[i] = Src[i] ;
        Dst[i] = Src[i] ;
    }

    while ( Tmp0 < SubFrLen ) {
        for ( i = (int) Tmp0 ; i < SubFrLen ; i ++ ) {
            Tmp1 = add( Dst[i], Tmp[i-(int)Tmp0] ) ;
            Dst[i] = Tmp1 ;
        }
        Tmp0 = add( Tmp0, Olp ) ;
    }

    return;
}

/*
**
** Function:        Find_Best()
**
** Description:     Fixed codebook search for the high rate encoder.
**                  It performs the quantization of the residual signal.
**                  The excitation made of Np positive or negative pulses
**                  multiplied by a gain and whose positions on the grid are
**                  either all odd or all even, should approximate as best as
**                  possible the residual signal (perceptual criterion).
**
** Links to text:   Section 2.15
**
** Arguments:
**
**  BESTDEF *Best   Parameters of the best excitation model
**  Word16 *Tv      Target vector
**  Word16 *ImpResp Impulse response of the combined filter
**  Word16 Np       Number of pulses (6 for even subframes; 5 for odd subframes)
**  Word16 Olp      Closed-loop pitch lag of subframe 0 (for subframes 0 & 1)
**                  Closed-loop pitch lag of subframe 2 (for subframes 2 & 3)
**
** Outputs:
**
**  BESTDEF *Best
**
** Return value:    None
**
*/
void  Find_Best( BESTDEF *Best, Word16 *Tv, Word16 *ImpResp, Word16 Np,
Word16 Olp )
{

    int   i,j,k,l  ;
    BESTDEF  Temp  ;

    Word16   Exp   ;
    Word16   MaxAmpId ;
    Word16   MaxAmp   ;
    Word32   Acc0,Acc1,Acc2 ;

    Word16   Imr[SubFrLen]  ;
    Word16   OccPos[SubFrLen] ;
    Word16   ImrCorr[SubFrLen] ;
    Word32   ErrBlk[SubFrLen] ;
    Word32   WrkBlk[SubFrLen] ;


    /* Update Impulse response */
    if ( Olp < (Word16) (SubFrLen-2) ) {
        Temp.UseTrn = (Word16) 1 ;
        Gen_Trn( Imr, ImpResp, Olp ) ;
    }
    else {
        Temp.UseTrn = (Word16) 0 ;
        for ( i = 0 ; i < SubFrLen ; i ++ )
            Imr[i] = ImpResp[i] ;
    }

    /* Scale Imr to avoid overflow */
    for ( i = 0 ; i < SubFrLen ; i ++ )
        OccPos[i] = shr( Imr[i], (Word16) 1 ) ;

    /* Compute Imr AutoCorr function */
    Acc0 = (Word32) 0 ;
    for ( i = 0 ; i < SubFrLen ; i ++ )
        Acc0 = L_mac( Acc0, OccPos[i], OccPos[i] ) ;

    Exp = norm_l( Acc0 ) ;
    Acc0 = L_shl( Acc0, Exp ) ;
    ImrCorr[0] = round( Acc0 ) ;

    /* Compute all the other */
    for ( i = 1 ; i < SubFrLen ; i ++ ) {
        Acc0 = (Word32) 0 ;
        for ( j = i ; j < SubFrLen ; j ++ )
            Acc0 = L_mac( Acc0, OccPos[j], OccPos[j-i] ) ;
        Acc0 = L_shl( Acc0, Exp ) ;
        ImrCorr[i] = round( Acc0 ) ;
    }

    /* Cross correlation with the signal */
    Exp = sub( Exp, 4 ) ;
    for ( i = 0 ; i < SubFrLen ; i ++ ) {
        Acc0 = (Word32) 0 ;
        for ( j = i ; j < SubFrLen ; j ++ )
            Acc0 = L_mac( Acc0, Tv[j], Imr[j-i] ) ;
        ErrBlk[i] = L_shl( Acc0, Exp ) ;
    }

    /* Search for the best sequence */
    for ( k = 0 ; k < Sgrid ; k ++ ) {

        Temp.GridId = (Word16) k ;

        /* Find maximum amplitude */
        Acc1 = (Word32) 0 ;
        for ( i = k ; i < SubFrLen ; i += Sgrid ) {
            Acc0 = L_abs( ErrBlk[i] ) ;
            if ( Acc0 >= Acc1 ) {
                Acc1 = Acc0 ;
                Temp.Ploc[0] = (Word16) i ;
            }
        }

        /* Quantize the maximum amplitude */
        Acc2 = Acc1 ;
        Acc1 = (Word32) 0x40000000L ;
        MaxAmpId = (Word16) (NumOfGainLev - MlqSteps) ;

        for ( i = MaxAmpId ; i >= MlqSteps ; i -- ) {
            Acc0 = L_mult( FcbkGainTable[i], ImrCorr[0] ) ;
            Acc0 = L_sub( Acc0, Acc2 ) ;
            Acc0 = L_abs( Acc0 ) ;
            if ( Acc0 < Acc1 ) {
                Acc1 = Acc0 ;
                MaxAmpId = (Word16) i ;
            }
        }
        MaxAmpId -- ;

        for ( i = 1 ; i <=2*MlqSteps ; i ++ ) {

            for ( j = k ; j < SubFrLen ; j += Sgrid ) {
                WrkBlk[j] = ErrBlk[j] ;
                OccPos[j] = (Word16) 0 ;
            }
            Temp.MampId = MaxAmpId - (Word16) MlqSteps + (Word16) i ;

            MaxAmp = FcbkGainTable[Temp.MampId] ;

            if ( WrkBlk[Temp.Ploc[0]] >= (Word32) 0 )
                Temp.Pamp[0] = MaxAmp ;
            else
                Temp.Pamp[0] = negate(MaxAmp) ;

            OccPos[Temp.Ploc[0]] = (Word16) 1 ;

            for ( j = 1 ; j < Np ; j ++ ) {

                Acc1 = (Word32) 0xc0000000L ;

                for ( l = k ; l < SubFrLen ; l += Sgrid ) {

                    if ( OccPos[l] != (Word16) 0 )
                        continue ;

                    Acc0 = WrkBlk[l] ;
                    Acc0 = L_msu( Acc0, Temp.Pamp[j-1],
                            ImrCorr[abs_s((Word16)(l-Temp.Ploc[j-1]))] ) ;
                    WrkBlk[l] = Acc0 ;
                    Acc0 = L_abs( Acc0 ) ;
                    if ( Acc0 > Acc1 ) {
                        Acc1 = Acc0 ;
                        Temp.Ploc[j] = (Word16) l ;
                    }
                }

                if ( WrkBlk[Temp.Ploc[j]] >= (Word32) 0 )
                    Temp.Pamp[j] = MaxAmp ;
                else
                    Temp.Pamp[j] = negate(MaxAmp) ;

                OccPos[Temp.Ploc[j]] = (Word16) 1 ;
            }

            /* Compute error vector */
            for ( j = 0 ; j < SubFrLen ; j ++ )
                OccPos[j] = (Word16) 0 ;

            for ( j = 0 ; j < Np ; j ++ )
                OccPos[Temp.Ploc[j]] = Temp.Pamp[j] ;

            for ( l = SubFrLen-1 ; l >= 0 ; l -- ) {
                Acc0 = (Word32) 0 ;
                for ( j = 0 ; j <= l ; j ++ )
                    Acc0 = L_mac( Acc0, OccPos[j], Imr[l-j] ) ;
                Acc0 = L_shl( Acc0, (Word16) 2 ) ;
                OccPos[l] = extract_h( Acc0 ) ;
            }

            /* Evaluate error */
            Acc1 = (Word32) 0 ;
            for ( j = 0 ; j < SubFrLen ; j ++ ) {
                Acc1 = L_mac( Acc1, Tv[j], OccPos[j] ) ;
                Acc0 = L_mult( OccPos[j], OccPos[j] ) ;
                Acc1 = L_sub( Acc1, L_shr( Acc0, (Word16) 1 ) ) ;
            }

            if ( Acc1 > (*Best).MaxErr ) {
                (*Best).MaxErr = Acc1 ;
                (*Best).GridId = Temp.GridId ;
                (*Best).MampId = Temp.MampId ;
                (*Best).UseTrn = Temp.UseTrn ;
                for ( j = 0 ; j < Np ; j ++ ) {
                    (*Best).Pamp[j] = Temp.Pamp[j] ;
                    (*Best).Ploc[j] = Temp.Ploc[j] ;
                }
            }
        }
    }
    return;
}
/*
**
** Function:        Fcbk_Pack()
**
** Description:     Encoding of the pulse positions and gains for the high
**                  rate case.
**                  Combinatorial encoding is used to transmit the optimal
**                  combination of pulse locations.
**
** Links to text:   Section 2.15
**
** Arguments:
**
**  Word16 *Dpnt    Excitation vector
**  SFSDEF *Sfs     Encoded parameters of the excitation model
**  BESTDEF *Best   Parameters of the best excitation model
**  Word16 Np       Number of pulses (6 for even subframes; 5 for odd subframes)
**
** Outputs:
**
**  SFSDEF *Sfs     Encoded parameters of the excitation model
**
** Return value:    None
**
*/
void  Fcbk_Pack( Word16 *Dpnt, SFSDEF *Sfs, BESTDEF *Best, Word16 Np )
{
    int   i,j   ;


    /* Code the amplitudes and positions */
    j = MaxPulseNum - (int) Np ;

    (*Sfs).Pamp = (Word16) 0 ;
    (*Sfs).Ppos = (Word32) 0 ;

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

        if ( Dpnt[(int)(*Best).GridId + Sgrid*i] == (Word16) 0 )
            (*Sfs).Ppos = L_add( (*Sfs).Ppos, CombinatorialTable[j][i] ) ;
        else {
            (*Sfs).Pamp = shl( (*Sfs).Pamp, (Word16) 1 ) ;
            if ( Dpnt[(int)(*Best).GridId + Sgrid*i] < (Word16) 0 )
                (*Sfs).Pamp = add( (*Sfs).Pamp, (Word16) 1 ) ;

            j ++ ;
            /* Check for end */
            if ( j == MaxPulseNum )
                break ;
        }
    }

    (*Sfs).Mamp = (*Best).MampId ;
    (*Sfs).Grid = (*Best).GridId ;
    (*Sfs).Tran = (*Best).UseTrn ;

    return;
}

/*
**
** Function:        Fcbk_Unpk()
**
** Description:     Decoding of the fixed codebook excitation for both rates.
**                  Gains, pulse positions, grid position (odd or even), signs
**                  are decoded and used to reconstruct the excitation.
**
** Links to text:   Section 2.17 & 3.5
**
** Arguments:
**
**  Word16 *Tv      Decoded excitation vector
**  SFSDEF Sfs      Encoded parameters of the excitation (for one subframe)
**  Word16 Olp      Closed loop adaptive pitch lag
**  Word16 Sfc      Subframe index
**
** Outputs:
**
**  Word16 *Tv      Decoded excitation vector
**
** Return value:    None
**
*/
void  Fcbk_Unpk( Word16 *Tv, SFSDEF Sfs, Word16 Olp, Word16 Sfc )
{
    int   i,j   ;

    Word32   Acc0  ;
    Word16   Np ;
    Word16 Tv_tmp[SubFrLen+4];
    Word16 acelp_gain, acelp_sign, acelp_shift, acelp_pos;
    Word16 offset, ipos, T0_acelp, gain_T0;



    switch(WrkRate)  {
        case Rate63: {

            Np = Nb_puls[(int)Sfc] ;

            for ( i = 0 ; i < SubFrLen ; i ++ )
                Tv[i] = (Word16) 0 ;

            if ( Sfs.Ppos >= MaxPosTable[Sfc] )
                return ;

            /* Decode the amplitudes and positions */
            j = MaxPulseNum - (int) Np ;

            Acc0 = Sfs.Ppos ;

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

                Acc0 = L_sub( Acc0, CombinatorialTable[j][i] ) ;

                if ( Acc0 < (Word32) 0 ) {
                    Acc0 = L_add( Acc0, CombinatorialTable[j][i] ) ;
                    j ++ ;
                    if ( (Sfs.Pamp & (1 << (MaxPulseNum-j) )) != (Word16) 0 )
                        Tv[(int)Sfs.Grid + Sgrid*i] = -FcbkGainTable[Sfs.Mamp] ;
                    else
                        Tv[(int)Sfs.Grid + Sgrid*i] =  FcbkGainTable[Sfs.Mamp] ;

                    if ( j == MaxPulseNum )
                        break ;
                }
            }

            if ( Sfs.Tran == (Word16) 1 )
                Gen_Trn( Tv, Tv, Olp ) ;
            break;
        }

        case Rate53: {
            for ( i = 0 ; i < SubFrLen+4 ; i ++ )
                Tv_tmp[i] = (Word16) 0 ;

            /* decoding gain */
            acelp_gain = FcbkGainTable[Sfs.Mamp];
            /* decoding grid */
            acelp_shift = Sfs.Grid;
            /* decoding Sign */
            acelp_sign = Sfs.Pamp;
            /* decoding Pos */
            acelp_pos = (short) Sfs.Ppos;

            offset  = 0;
            for(i=0; i<4; i++) {
                ipos = (acelp_pos & (Word16)0x0007) ;
                ipos = shl(ipos,3) + acelp_shift + offset;
                if( (acelp_sign & 1 )== 1) {
                    Tv_tmp[ipos] = acelp_gain;
                }
                else {
                    Tv_tmp[ipos] = -acelp_gain;
                }
                offset = add(offset,2);
                acelp_pos = shr(acelp_pos, 3);
                acelp_sign = shr(acelp_sign,1);
            }
            for (i = 0; i < SubFrLen; i++) Tv[i] = Tv_tmp[i];
            T0_acelp = search_T0( (Word16) (Olp-1+Sfs.AcLg), Sfs.AcGn,
                                                            &gain_T0);
            if(T0_acelp <SubFrLen-2) {
                /* code[i] += 0.8 * code[i-Olp] */
                for (i = T0_acelp ; i < SubFrLen; i++)
                    Tv[i] = add(Tv[i], mult(Tv[i-T0_acelp ], gain_T0));
            }

            break;
        }
    }
    return;
}

/*
**
** Function:        Find_Acbk()
**
** Description:     Computation of adaptive codebook contribution in
**                  closed-loop around the open-loop pitch lag (subframes 0 & 2)
**                  around the previous subframe closed-loop pitch lag
**                  (subframes 1 & 3).  For subframes 0 & 2, the pitch lag is
**                  encoded whereas for subframes 1 & 3, only the difference
**                  with the previous value is encoded (-1, 0, +1 or +2).
**                  The pitch predictor gains are quantized using one of the two
**                  codebooks (85 entries or 170 entries) depending on the
**                  rate and on the pitch lag value.
**                  Finally, the contribution of the pitch predictor is decoded
**                  and subtracted to obtain the residual signal.
**
** Links to text:   Section 2.14
**
** Arguments:
**
**  Word16 *Tv      Target vector
**  Word16 *ImpResp Impulse response of the combined filter
**  Word16 *PrevExc Previous excitation vector
**  LINEDEF *Line   Contains pitch related parameters (open/closed loop lag, gain)
**  Word16 Sfc      Subframe index
**
** Outputs:
**
**  Word16 *Tv     Residual vector
**  LINEDEF *Line  Contains pitch related parameters (closed loop lag, gain)
**
** Return value:    None
**
*/
void  Find_Acbk( Word16 *Tv, Word16 *ImpResp, Word16 *PrevExc, LINEDEF
*Line, Word16 Sfc )
{
    int   i,j,k,l  ;

    Word32   Acc0,Acc1 ;

    Word16   RezBuf[SubFrLen+ClPitchOrd-1] ;
    Word16   FltBuf[ClPitchOrd][SubFrLen] ;
    Word32   CorBuf[4*(2*ClPitchOrd + ClPitchOrd*(ClPitchOrd-1)/2)] ;
    Word32   *lPnt ;

    Word16   CorVct[4*(2*ClPitchOrd + ClPitchOrd*(ClPitchOrd-1)/2)] ;
    Word16   *sPnt ;

    Word16   Olp ;
    Word16   Lid ;
    Word16   Gid ;
    Word16   Hb  ;
    Word16   Exp ;
    Word16   Bound[2] ;

    Word16   Lag1, Lag2;
    Word16   off_filt;

    /* Init constants */
    Olp = (*Line).Olp[shr(Sfc, (Word16) 1)] ;
    Lid = (Word16) Pstep ;
    Gid = (Word16) 0 ;
    Hb  = (Word16) 3 + (Sfc & (Word16) 1 ) ;