p_ol_wgh.cpp

实现3GPP的GSM中AMR语音的CODECS。

       // Weighting of the correlation function.
       L_Extract (corr[-i], &t0_h, &t0_l);
       t0 = Mpy_32_16 (t0_h, t0_l, *ww);
       ww--;
       if (wght_flg > 0) {
          // Weight the neighbourhood of the old lag
          L_Extract (t0, &t0_h, &t0_l);
          t0 = Mpy_32_16 (t0_h, t0_l, *we);
          we--;
       }

       if (L_sub (t0, max) >= 0)
       {
          max = t0;
          p_max = i;
       }
    }

    p  = &scal_sig[0];
    p1 = &scal_sig[-p_max];
    t0 = 0;
    t1 = 0;

    for (j = 0; j < L_frame; j++, p++, p1++)
    {
       t0 = L_mac (t0, *p, *p1);
       t1 = L_mac (t1, *p1, *p1);
    }

    if (dtx)
    {  // no test() call since this if is only in simulation env
#ifdef VAD2
       vadSt->L_Rmax = L_add(vadSt->L_Rmax, t0);   // Save max correlation
       vadSt->L_R0 =   L_add(vadSt->L_R0, t1);        // Save max energy
#else
       // update and detect tone
       vad_tone_detection_update (vadSt, 0);
       vad_tone_detection (vadSt, t0, t1);
#endif
    }

    // gain flag is set according to the open_loop gain
    // is t2/t1 > 0.4 ?
    *gain_flg = pv_round(L_msu(t0, pv_round(t1), 13107));

    *cor_max = 0;

    return (p_max);
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/

static Word16 Lag_max(  /* o : lag found                               */
    vadState *vadSt,    /* i/o : VAD state struct                      */
    Word32 corr[],      /* i   : correlation vector.                   */
    Word16 scal_sig[],  /* i : scaled signal.                          */
    Word16 L_frame,     /* i : length of frame to compute pitch        */
    Word16 lag_max,     /* i : maximum lag                             */
    Word16 lag_min,     /* i : minimum lag                             */
    Word16 old_lag,     /* i : old open-loop lag                       */
    Word16 *cor_max,    /* o : normalized correlation of selected lag  */
    Word16 wght_flg,    /* i : is weighting function used              */
    Word16 *gain_flg,   /* o : open-loop flag                          */
    Flag dtx,           /* i : dtx flag; use dtx=1, do not use dtx=0   */
    Flag   *pOverflow   /* o : overflow flag                           */
)
{
    Word16 i;
    Word16 j;
    Word16 *p;
    Word16 *p1;
    Word32 max;
    Word32 t0;
    Word16 t0_h;
    Word16 t0_l;
    Word16 p_max;
    const Word16 *ww;
    const Word16 *we;
    Word32 t1;
    Word16 temp;

    ww = &corrweight[250];
    we = &corrweight[123 + lag_max - old_lag];

    max = MIN_32;
    p_max = lag_max;

    for (i = lag_max; i >= lag_min; i--)
    {
        t0 = corr[-i];

        /* Weighting of the correlation function.   */
        L_Extract(corr[-i], &t0_h, &t0_l, pOverflow);
        t0 = Mpy_32_16(t0_h, t0_l, *ww, pOverflow);
        ww--;
        if (wght_flg > 0)
        {
            /* Weight the neighbourhood of the old lag. */
            L_Extract(t0, &t0_h, &t0_l, pOverflow);
            t0 = Mpy_32_16(t0_h, t0_l, *we, pOverflow);
            we--;
        }

        /*       if (L_sub (t0, max) >= 0) */
        if (t0 >= max)
        {
            max = t0;
            p_max = i;
        }
    }
    p  = &scal_sig[0];
    p1 = &scal_sig[-p_max];
    t0 = 0;
    t1 = 0;

    for (j = 0; j < L_frame; j++, p++, p1++)
    {
        t0 = L_mac(t0, *p, *p1, pOverflow);
        t1 = L_mac(t1, *p1, *p1, pOverflow);
    }

    if (dtx)
    {  /* no test() call since this if is only in simulation env */
#ifdef VAD2
        /* Save max correlation */
        vadSt->L_Rmax = L_add(vadSt->L_Rmax, t0, pOverflow);
        /* Save max energy */
        vadSt->L_R0 =   L_add(vadSt->L_R0, t1, pOverflow);
#else
        /* update and detect tone */
        vad_tone_detection_update(vadSt, 0, pOverflow);
        vad_tone_detection(vadSt, t0, t1, pOverflow);
#endif
    }

    /* gain flag is set according to the open_loop gain */
    /* is t2/t1 > 0.4 ? */
    temp = pv_round(t1, pOverflow);
    t1 = L_msu(t0, temp, 13107, pOverflow);
    *gain_flg = pv_round(t1, pOverflow);

    *cor_max = 0;

    return (p_max);
}
/*----------------------------------------------------------------------------
; End Function: Lag_max
----------------------------------------------------------------------------*/

/*
------------------------------------------------------------------------------
 FUNCTION NAME: Pitch_ol_wgh
------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    st = pointer to pitchOLWghtState structure
    vadSt = pointer to a vadState structure
    signal = pointer to buffer of signal used to compute the open loop
         pitch where signal[-pit_max] to signal[-1] should be known
    pit_min = 16 bit value specifies the minimum pitch lag
    pit_max = 16 bit value specifies the maximum pitch lag
    L_frame = 16 bit value specifies the length of frame to compute pitch
    old_lags = pointer to history with old stored Cl lags (Word16)
    ol_gain_flg = pointer to OL gain flag (Word16)
    idx = 16 bit value specifies the frame index
    dtx = Data of type 'Flag' used for dtx. Use dtx=1, do not use dtx=0
    pOverflow = pointer to Overflow indicator (Flag)
 Outputs
    st = The pitchOLWghtState may be modified
    vadSt = The vadSt state structure may be modified.
    pOverflow -> 1 if the math functions invoked by this routine saturate.

 Returns:
    p_max1 = 16 bit value representing the open loop pitch lag.

 Global Variables Used:
    None.

 Local Variables Needed:
    None.

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

 This function performs an open-loop pitch search with weighting
------------------------------------------------------------------------------
 REQUIREMENTS

 None.

------------------------------------------------------------------------------
 REFERENCES

 pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001

------------------------------------------------------------------------------
 PSEUDO-CODE

Word16 Pitch_ol_wgh (     // o   : open loop pitch lag
    pitchOLWghtState *st, // i/o : State struct
    vadState *vadSt,      // i/o : VAD state struct/
    Word16 signal[],      // i   : signal used to compute the open loop pitch
                          //       signal[-pit_max] to signal[-1] should be known
    Word16 pit_min,       // i   : minimum pitch lag
    Word16 pit_max,       // i   : maximum pitch lag
    Word16 L_frame,       // i   : length of frame to compute pitch
    Word16 old_lags[],    // i   : history with old stored Cl lags
    Word16 ol_gain_flg[], // i   : OL gain flag
    Word16 idx,           // i   : index
    Flag dtx              // i   : dtx flag; use dtx=1, do not use dtx=0
    )
{
    Word16 i;
    Word16 max1;
    Word16 p_max1;
    Word32 t0;
#ifndef VAD2
    Word16 corr_hp_max;
#endif
    Word32 corr[PIT_MAX+1], *corr_ptr;

    // Scaled signal
    Word16 scaled_signal[PIT_MAX + L_FRAME];
    Word16 *scal_sig;

    scal_sig = &scaled_signal[pit_max];

    t0 = 0L;
    for (i = -pit_max; i < L_frame; i++)
    {
        t0 = L_mac (t0, signal[i], signal[i]);
    }
    //
    // Scaling of input signal
    //
    //   if Overflow        -> scal_sig[i] = signal[i]>>2
    //   else if t0 < 1^22  -> scal_sig[i] = signal[i]<<2
    //   else               -> scal_sig[i] = signal[i]

    //
    //  Verification for risk of overflow.
    //

    // Test for overflow
    if (L_sub (t0, MAX_32) == 0L)
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = shr (signal[i], 3);
        }
    }
    else if (L_sub (t0, (Word32) 1048576L) < (Word32) 0)
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = shl (signal[i], 3);
        }
    }
    else
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = signal[i];
        }
    }

    // calculate all coreelations of scal_sig, from pit_min to pit_max
    corr_ptr = &corr[pit_max];
    comp_corr (scal_sig, L_frame, pit_max, pit_min, corr_ptr);

    p_max1 = Lag_max (vadSt, corr_ptr, scal_sig, L_frame, pit_max, pit_min,
                      st->old_T0_med, &max1, st->wght_flg, &ol_gain_flg[idx],
                      dtx);

    if (ol_gain_flg[idx] > 0)
    {
       // Calculate 5-point median of previous lag
       for (i = 4; i > 0; i--) // Shift buffer
       {
          old_lags[i] = old_lags[i-1];
       }
       old_lags[0] = p_max1;
       st->old_T0_med = gmed_n (old_lags, 5);
       st->ada_w = 32767; // Q15 = 1.0
    }
    else
    {
       st->old_T0_med = p_max1;
       st->ada_w = mult(st->ada_w, 29491);      // = ada_w = ada_w * 0.9
    }

    if (sub(st->ada_w, 9830) < 0)  // ada_w - 0.3
    {
       st->wght_flg = 0;
    }
    else
    {
       st->wght_flg = 1;
    }

#ifndef VAD2
    if (dtx)
    {  // no test() call since this if is only in simulation env
       if (sub(idx, 1) == 0)
       {
          // calculate max high-passed filtered correlation of all lags
          hp_max (corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max);

          // update complex background detector
          vad_complex_detection_update(vadSt, corr_hp_max);
       }
    }
#endif

    return (p_max1);
}

------------------------------------------------------------------------------
 RESOURCES USED [optional]

 When the code is written for a specific target processor the
 the resources used should be documented below.

 HEAP MEMORY USED: x bytes

 STACK MEMORY USED: x bytes

 CLOCK CYCLES: (cycle count equation for this function) + (variable
                used to represent cycle count for each subroutine
                called)
     where: (cycle count variable) = cycle count for [subroutine
                                     name]

------------------------------------------------------------------------------
 CAUTION [optional]
 [State any special notes, constraints or cautions for users of this function]

------------------------------------------------------------------------------
*/

Word16 Pitch_ol_wgh(      /* o   : open loop pitch lag                            */
    pitchOLWghtState *st, /* i/o : State struct                                   */
    vadState *vadSt,      /* i/o : VAD state struct                               */
    Word16 signal[],      /* i   : signal used to compute the open loop pitch     */
    /*       signal[-pit_max] to signal[-1] should be known */
    Word16 pit_min,       /* i   : minimum pitch lag                              */
    Word16 pit_max,       /* i   : maximum pitch lag                              */
    Word16 L_frame,       /* i   : length of frame to compute pitch               */
    Word16 old_lags[],    /* i   : history with old stored Cl lags                */
    Word16 ol_gain_flg[], /* i   : OL gain flag                                   */
    Word16 idx,           /* i   : index                                          */
    Flag dtx,             /* i   : dtx flag; use dtx=1, do not use dtx=0          */
    Flag   *pOverflow     /* o   : overflow flag                                  */
)
{
    Word16 i;
    Word16 max1;
    Word16 p_max1;
    Word32 t0;
#ifndef VAD2
    Word16 corr_hp_max;
#endif
    Word32 corr[PIT_MAX+1], *corr_ptr;

    /* Scaled signal */
    Word16 scaled_signal[PIT_MAX + L_FRAME];
    Word16 *scal_sig;

    scal_sig = &scaled_signal[pit_max];

    t0 = 0L;
    for (i = -pit_max; i < L_frame; i++)
    {
        t0 = L_mac(t0, signal[i], signal[i], pOverflow);
    }
    /*--------------------------------------------------------*
     * Scaling of input signal.                               *
     *                                                        *
     *   if Overflow        -> scal_sig[i] = signal[i]>>2     *
     *   else if t0 < 1^22  -> scal_sig[i] = signal[i]<<2     *
     *   else               -> scal_sig[i] = signal[i]        *
     *--------------------------------------------------------*/

    /*--------------------------------------------------------*
     *  Verification for risk of overflow.                    *
     *--------------------------------------------------------*/

    /* Test for overflow */
    if (L_sub(t0, MAX_32, pOverflow) == 0L)
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = shr(signal[i], 3, pOverflow);
        }
    }
    else if (L_sub(t0, (Word32) 1048576L, pOverflow) < (Word32) 0)
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = shl(signal[i], 3, pOverflow);
        }
    }
    else
    {
        for (i = -pit_max; i < L_frame; i++)
        {
            scal_sig[i] = signal[i];
        }
    }

    /* calculate all coreelations of scal_sig, from pit_min to pit_max */
    corr_ptr = &corr[pit_max];
    comp_corr(scal_sig, L_frame, pit_max, pit_min, corr_ptr);

    p_max1 = Lag_max(vadSt, corr_ptr, scal_sig, L_frame, pit_max, pit_min,
                     st->old_T0_med, &max1, st->wght_flg, &ol_gain_flg[idx],
                     dtx, pOverflow);

    if (ol_gain_flg[idx] > 0)
    {
        /* Calculate 5-point median of previous lags */
        for (i = 4; i > 0; i--) /* Shift buffer */
        {
            old_lags[i] = old_lags[i-1];
        }
        old_lags[0] = p_max1;
        st->old_T0_med = gmed_n(old_lags, 5);
        st->ada_w = 32767; /* Q15 = 1.0 */
    }
    else
    {
        st->old_T0_med = p_max1;
        /* = ada_w = ada_w * 0.9 */
        st->ada_w = mult(st->ada_w, 29491, pOverflow);
    }

    if (sub(st->ada_w, 9830, pOverflow) < 0)  /* ada_w - 0.3 */
    {
        st->wght_flg = 0;
    }
    else
    {
        st->wght_flg = 1;
    }

#ifndef VAD2
    if (dtx)
    {  /* no test() call since this if is only in simulation env */
        if (sub(idx, 1, pOverflow) == 0)
        {
            /* calculate max high-passed filtered correlation of all lags */
            hp_max(corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max, pOverflow);

            /* update complex background detector */
            vad_complex_detection_update(vadSt, corr_hp_max);
        }
    }
#endif

    return (p_max1);
}

/*----------------------------------------------------------------------------
; End Function: Pitch_ol_wgh
----------------------------------------------------------------------------*/