path: root/media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/****************************************************************************************
Portions of this file are derived from the following 3GPP standard:

    3GPP TS 26.073
    ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
    Available from http://www.3gpp.org

(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
Permission to distribute, modify and use this file under the standard license
terms listed above has been obtained from the copyright holder.
****************************************************************************************/
/*
------------------------------------------------------------------------------



 Pathname: ./audio/gsm-amr/c/src/pitch_fr.c
 Functions:


     Date: 02/04/2002

------------------------------------------------------------------------------
 REVISION HISTORY

 Description: Added pOverflow as a passed in value to searchFrac and made
              other fixes to the code regarding simple syntax fixes. Removed
              the include of stio.h.

 Description: *lag-- decrements the pointer.  (*lag)-- decrements what is
 pointed to.  The latter is what the coder intended, but the former is
 the coding instruction that was used.

 Description: A common problem -- a comparison != 0 was inadvertantly replaced
 by a comparison == 0.


 Description:  For Norm_Corr() and getRange()
              1. Eliminated unused include files.
              2. Replaced array addressing by pointers
              3. Eliminated math operations that unnecessary checked for
                 saturation, in some cases this by shifting before adding and
                 in other cases by evaluating the operands
              4. Unrolled loops to speed up processing, use decrement loops
              5. Replaced extract_l() call with equivalent code
              6. Modified scaling threshold and group all shifts (avoiding
                 successive shifts)

 Description:  Replaced OSCL mem type functions and eliminated include
               files that now are chosen by OSCL definitions

 Description:  Replaced "int" and/or "char" with OSCL defined types.

 Description: Removed compiler warnings.

 Description:
------------------------------------------------------------------------------
 MODULE DESCRIPTION

      File             : pitch_fr.c
      Purpose          : Find the pitch period with 1/3 or 1/6 subsample
                       : resolution (closed loop).

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

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include <stdlib.h>

#include "pitch_fr.h"
#include "oper_32b.h"
#include "cnst.h"
#include "enc_lag3.h"
#include "enc_lag6.h"
#include "inter_36.h"
#include "inv_sqrt.h"
#include "convolve.h"

#include "basic_op.h"


/*----------------------------------------------------------------------------
; MACROS
; Define module specific macros here
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; DEFINES
; Include all pre-processor statements here. Include conditional
; compile variables also.
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; LOCAL FUNCTION DEFINITIONS
; Function Prototype declaration
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; LOCAL VARIABLE DEFINITIONS
; Variable declaration - defined here and used outside this module
----------------------------------------------------------------------------*/

/*
 * mode dependent parameters used in Pitch_fr()
 * Note: order of MRxx in 'enum Mode' is important!
 */
static const struct
{
    Word16 max_frac_lag;     /* lag up to which fractional lags are used    */
    Word16 flag3;            /* enable 1/3 instead of 1/6 fract. resolution */
    Word16 first_frac;       /* first fractional to check                   */
    Word16 last_frac;        /* last fractional to check                    */
    Word16 delta_int_low;    /* integer lag below TO to start search from   */
    Word16 delta_int_range;  /* integer range around T0                     */
    Word16 delta_frc_low;    /* fractional below T0                         */
    Word16 delta_frc_range;  /* fractional range around T0                  */
    Word16 pit_min;          /* minimum pitch                               */
} mode_dep_parm[N_MODES] =
{
    /* MR475 */  { 84,  1, -2,  2,  5, 10,  5,  9, PIT_MIN },
    /* MR515 */  { 84,  1, -2,  2,  5, 10,  5,  9, PIT_MIN },
    /* MR59  */  { 84,  1, -2,  2,  3,  6,  5,  9, PIT_MIN },
    /* MR67  */  { 84,  1, -2,  2,  3,  6,  5,  9, PIT_MIN },
    /* MR74  */  { 84,  1, -2,  2,  3,  6,  5,  9, PIT_MIN },
    /* MR795 */  { 84,  1, -2,  2,  3,  6, 10, 19, PIT_MIN },
    /* MR102 */  { 84,  1, -2,  2,  3,  6,  5,  9, PIT_MIN },
    /* MR122 */  { 94,  0, -3,  3,  3,  6,  5,  9, PIT_MIN_MR122 }
};

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

 Inputs:
    exc[] = pointer to buffer of type Word16
    xn[]  = pointer to buffer of type Word16
    h[]   = pointer to buffer of type Word16
    L_subfr = length of sub frame (Word16)
    t_min  = the minimum table value of type Word16
    t_max = the maximum table value of type Word16
    corr_norm[] = pointer to buffer of type Word16

 Outputs:
    pOverflow = 1 if the math functions called result in overflow else zero.

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

  FUNCTION:   Norm_Corr()

  PURPOSE: Find the normalized correlation between the target vector
           and the filtered past excitation.

  DESCRIPTION:
     The normalized correlation is given by the correlation between the
     target and filtered past excitation divided by the square root of
     the energy of filtered excitation.
                   corr[k] = <x[], y_k[]>/sqrt(y_k[],y_k[])
     where x[] is the target vector and y_k[] is the filtered past
     excitation at delay k.


------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

static void Norm_Corr (Word16 exc[], Word16 xn[], Word16 h[], Word16 L_subfr,
                       Word16 t_min, Word16 t_max, Word16 corr_norm[])
{
    Word16 i, j, k;
    Word16 corr_h, corr_l, norm_h, norm_l;
    Word32 s;

    // Usally dynamic allocation of (L_subfr)
    Word16 excf[L_SUBFR];
    Word16 scaling, h_fac, *s_excf, scaled_excf[L_SUBFR];

    k = -t_min;

    // compute the filtered excitation for the first delay t_min

    Convolve (&exc[k], h, excf, L_subfr);

    // scale "excf[]" to avoid overflow

    for (j = 0; j < L_subfr; j++) {
        scaled_excf[j] = shr (excf[j], 2);
    }

    // Compute 1/sqrt(energy of excf[])

    s = 0;
    for (j = 0; j < L_subfr; j++) {
        s = L_mac (s, excf[j], excf[j]);
    }
    if (L_sub (s, 67108864L) <= 0) {            // if (s <= 2^26)
        s_excf = excf;
        h_fac = 15 - 12;
        scaling = 0;
    }
    else {
        // "excf[]" is divided by 2
        s_excf = scaled_excf;
        h_fac = 15 - 12 - 2;
        scaling = 2;
    }

    // loop for every possible period

    for (i = t_min; i <= t_max; i++) {
        // Compute 1/sqrt(energy of excf[])

        s = 0;
        for (j = 0; j < L_subfr; j++) {
            s = L_mac (s, s_excf[j], s_excf[j]);
        }

        s = Inv_sqrt (s);
        L_Extract (s, &norm_h, &norm_l);

        // Compute correlation between xn[] and excf[]

        s = 0;
        for (j = 0; j < L_subfr; j++) {
            s = L_mac (s, xn[j], s_excf[j]);
        }
        L_Extract (s, &corr_h, &corr_l);

        // Normalize correlation = correlation * (1/sqrt(energy))

        s = Mpy_32 (corr_h, corr_l, norm_h, norm_l);

        corr_norm[i] = extract_h (L_shl (s, 16));

            // modify the filtered excitation excf[] for the next iteration

        if (sub (i, t_max) != 0) {
            k--;
            for (j = L_subfr - 1; j > 0; j--) {
                s = L_mult (exc[k], h[j]);
                s = L_shl (s, h_fac);
                s_excf[j] = add (extract_h (s), s_excf[j - 1]);
            }
            s_excf[0] = shr (exc[k], scaling);
        }
    }
    return;
}

------------------------------------------------------------------------------
 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 void Norm_Corr(Word16 exc[],
                      Word16 xn[],
                      Word16 h[],
                      Word16 L_subfr,
                      Word16 t_min,
                      Word16 t_max,
                      Word16 corr_norm[],
                      Flag *pOverflow)
{
    Word16 i;
    Word16 j;
    Word16 k;
    Word16 corr_h;
    Word16 corr_l;
    Word16 norm_h;
    Word16 norm_l;
    Word32 s;
    Word32 s2;
    Word16 excf[L_SUBFR];
    Word16 scaling;
    Word16 h_fac;
    Word16 *s_excf;
    Word16 scaled_excf[L_SUBFR];
    Word16 *p_s_excf;
    Word16 *p_excf;
    Word16  temp;
    Word16 *p_x;
    Word16 *p_h;

    k = -t_min;

    /* compute the filtered excitation for the first delay t_min */

    Convolve(&exc[k], h, excf, L_subfr);

    /* scale "excf[]" to avoid overflow */
    s = 0;
    p_s_excf = scaled_excf;
    p_excf   = excf;

    for (j = (L_subfr >> 1); j != 0; j--)
    {
        temp = *(p_excf++);
        *(p_s_excf++) = temp >> 2;
        s += (Word32) temp * temp;
        temp = *(p_excf++);
        *(p_s_excf++) = temp >> 2;
        s += (Word32) temp * temp;
    }


    if (s <= (67108864L >> 1))
    {
        s_excf = excf;
        h_fac = 12;
        scaling = 0;
    }
    else
    {
        /* "excf[]" is divided by 2 */
        s_excf = scaled_excf;
        h_fac = 14;
        scaling = 2;
    }

    /* loop for every possible period */

    for (i = t_min; i <= t_max; i++)
    {
        /* Compute 1/sqrt(energy of excf[]) */

        s   = s2 = 0;
        p_x      = xn;
        p_s_excf = s_excf;
        j        = L_subfr >> 1;

        while (j--)
        {
            s  += (Word32) * (p_x++) * *(p_s_excf);
            s2 += ((Word32)(*(p_s_excf)) * (*(p_s_excf)));
            p_s_excf++;
            s  += (Word32) * (p_x++) * *(p_s_excf);
            s2 += ((Word32)(*(p_s_excf)) * (*(p_s_excf)));
            p_s_excf++;
        }

        s2     = s2 << 1;
        s2     = Inv_sqrt(s2, pOverflow);
        norm_h = (Word16)(s2 >> 16);
        norm_l = (Word16)((s2 >> 1) - (norm_h << 15));
        corr_h = (Word16)(s >> 15);
        corr_l = (Word16)((s) - (corr_h << 15));

        /* Normalize correlation = correlation * (1/sqrt(energy)) */

        s = Mpy_32(corr_h, corr_l, norm_h, norm_l, pOverflow);

        corr_norm[i] = (Word16) s ;

        /* modify the filtered excitation excf[] for the next iteration */
        if (i != t_max)
        {
            k--;
            temp = exc[k];
            p_s_excf = &s_excf[L_subfr - 1];
            p_h = &h[L_subfr - 1];

            p_excf = &s_excf[L_subfr - 2];
            for (j = (L_subfr - 1) >> 1; j != 0; j--)
            {
                s = ((Word32) temp * *(p_h--)) >> h_fac;
                *(p_s_excf--) = (Word16) s  + *(p_excf--);
                s = ((Word32) temp * *(p_h--)) >> h_fac;
                *(p_s_excf--) = (Word16) s  + *(p_excf--);
            }

            s = ((Word32) temp * *(p_h)) >> h_fac;
            *(p_s_excf--) = (Word16) s  + *(p_excf);

            *(p_s_excf) = temp >> scaling;
        }

    }
    return;
}

/****************************************************************************/


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

 Inputs:
    lag = pointer to integer pitch of type Word16
    frac = pointer to starting point of search fractional pitch of type Word16
    last_frac = endpoint of search  of type Word16
    corr[] = pointer to normalized correlation of type Word16
    flag3 = subsample resolution (3: =1 / 6: =0) of type Word16

 Outputs:
    None

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

   FUNCTION:   searchFrac()

   PURPOSE: Find fractional pitch

   DESCRIPTION:
      The function interpolates the normalized correlation at the
      fractional positions around lag T0. The position at which the
      interpolation function reaches its maximum is the fractional pitch.
      Starting point of the search is frac, end point is last_frac.
      frac is overwritten with the fractional pitch.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

static void searchFrac (
    Word16 *lag,       // i/o : integer pitch
    Word16 *frac,      // i/o : start point of search -
                               fractional pitch
    Word16 last_frac,  // i   : endpoint of search
    Word16 corr[],     // i   : normalized correlation
    Word16 flag3       // i   : subsample resolution
                                (3: =1 / 6: =0)
)
{
    Word16 i;
    Word16 max;
    Word16 corr_int;

    // Test the fractions around T0 and choose the one which maximizes
    // the interpolated normalized correlation.

    max = Interpol_3or6 (&corr[*lag], *frac, flag3); // function result

    for (i = add (*frac, 1); i <= last_frac; i++) {
        corr_int = Interpol_3or6 (&corr[*lag], i, flag3);
        if (sub (corr_int, max) > 0) {
            max = corr_int;
            *frac = i;
        }
    }

    if (flag3 == 0) {
        // Limit the fraction value in the interval [-2,-1,0,1,2,3]

        if (sub (*frac, -3) == 0) {
            *frac = 3;
            *lag = sub (*lag, 1);
        }
    }
    else {
        // limit the fraction value between -1 and 1

        if (sub (*frac, -2) == 0) {
            *frac = 1;
            *lag = sub (*lag, 1);
        }
        if (sub (*frac, 2) == 0) {
            *frac = -1;
            *lag = add (*lag, 1);
        }
    }
}

------------------------------------------------------------------------------
 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 void searchFrac(
    Word16 *lag,       /* i/o : integer pitch           */
    Word16 *frac,      /* i/o : start point of search -
                                fractional pitch        */
    Word16 last_frac,  /* i   : endpoint of search      */
    Word16 corr[],     /* i   : normalized correlation  */
    Word16 flag3,      /* i   : subsample resolution
                                (3: =1 / 6: =0)         */
    Flag   *pOverflow
)
{
    Word16 i;
    Word16 max;
    Word16 corr_int;

    /* Test the fractions around T0 and choose the one which maximizes   */
    /* the interpolated normalized correlation.                          */

    max = Interpol_3or6(&corr[*lag], *frac, flag3, pOverflow);
    /* function result */

    for (i = *frac + 1; i <= last_frac; i++)
    {
        corr_int = Interpol_3or6(&corr[*lag], i, flag3, pOverflow);
        if (corr_int > max)
        {
            max = corr_int;
            *frac = i;
        }
    }

    if (flag3 == 0)
    {
        /* Limit the fraction value in the interval [-2,-1,0,1,2,3] */

        if (*frac == -3)
        {
            *frac = 3;
            (*lag)--;
        }
    }
    else
    {
        /* limit the fraction value between -1 and 1 */

        if (*frac == -2)
        {
            *frac = 1;
            (*lag)--;
        }
        if (*frac == 2)
        {
            *frac = -1;
            (*lag)++;
        }
    }
}

/****************************************************************************/


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

 Inputs:
    T0 = integer pitch of type Word16
    delta_low = search start offset of type Word16
    delta_range = search range of type Word16
    pitmin = minimum pitch of type Word16
    pitmax = maximum pitch of type Word16
    t0_min = search range minimum of type Word16
    t0_max = search range maximum of type Word16

 Outputs:
    pOverflow = 1 if the math functions called result in overflow else zero.

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

   FUNCTION:   getRange()

   PURPOSE: Sets range around open-loop pitch or integer pitch of last subframe

   DESCRIPTION:
      Takes integer pitch T0 and calculates a range around it with
        t0_min = T0-delta_low  and t0_max = (T0-delta_low) + delta_range
      t0_min and t0_max are bounded by pitmin and pitmax
------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

static void getRange (
    Word16 T0,           // i : integer pitch
    Word16 delta_low,    // i : search start offset
    Word16 delta_range,  // i : search range
    Word16 pitmin,       // i : minimum pitch
    Word16 pitmax,       // i : maximum pitch
    Word16 *t0_min,      // o : search range minimum
    Word16 *t0_max)      // o : search range maximum
{
    *t0_min = sub(T0, delta_low);
    if (sub(*t0_min, pitmin) < 0) {
        *t0_min = pitmin;
    }
    *t0_max = add(*t0_min, delta_range);
    if (sub(*t0_max, pitmax) > 0) {
        *t0_max = pitmax;
        *t0_min = sub(*t0_max, delta_range);
    }
}

------------------------------------------------------------------------------
 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 void getRange(
    Word16 T0,           /* i : integer pitch          */
    Word16 delta_low,    /* i : search start offset    */
    Word16 delta_range,  /* i : search range           */
    Word16 pitmin,       /* i : minimum pitch          */
    Word16 pitmax,       /* i : maximum pitch          */
    Word16 *t0_min,      /* o : search range minimum   */
    Word16 *t0_max,      /* o : search range maximum   */
    Flag   *pOverflow)
{

    Word16 temp;
    OSCL_UNUSED_ARG(pOverflow);

    temp = *t0_min;
    temp = T0 - delta_low;
    if (temp < pitmin)
    {
        temp = pitmin;
    }
    *t0_min = temp;

    temp +=  delta_range;
    if (temp > pitmax)
    {
        temp = pitmax;
        *t0_min = pitmax - delta_range;
    }
    *t0_max = temp;

}


/****************************************************************************/


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

 Inputs:
    state = pointer to a pointer of structure type Pitch_fr_State.

 Outputs:
    None

 Returns:
    Returns a zero if successful and -1 if not successful.

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

  Function:   Pitch_fr_init
  Purpose:    Allocates state memory and initializes state memory

------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

int Pitch_fr_init (Pitch_frState **state)
{
    Pitch_frState* s;

    if (state == (Pitch_frState **) NULL){
        // fprintf(stderr, "Pitch_fr_init: invalid parameter\n");
        return -1;
    }
    *state = NULL;

    // allocate memory
    if ((s= (Pitch_frState *) malloc(sizeof(Pitch_frState))) == NULL){
        // fprintf(stderr, "Pitch_fr_init: can not malloc state structure\n");
        return -1;
    }

    Pitch_fr_reset(s);
    *state = s;

    return 0;
}

------------------------------------------------------------------------------
 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_fr_init(Pitch_frState **state)
{
    Pitch_frState* s;

    if (state == (Pitch_frState **) NULL)
    {
        /* fprintf(stderr, "Pitch_fr_init: invalid parameter\n"); */
        return -1;
    }
    *state = NULL;

    /* allocate memory */
    if ((s = (Pitch_frState *) malloc(sizeof(Pitch_frState))) == NULL)
    {
        /* fprintf(stderr, "Pitch_fr_init: can not malloc state structure\n"); */
        return -1;
    }

    Pitch_fr_reset(s);
    *state = s;

    return 0;
}


/****************************************************************************/


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

 Inputs:
    state = pointer to a pointer of structure type Pitch_fr_State.

 Outputs:
    None

 Returns:
    Returns a zero if successful and -1 if not successful.

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

  Function:   Pitch_fr_reset
  Purpose:    Initializes state memory to zero

------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

int Pitch_fr_reset (Pitch_frState *state)
{

    if (state == (Pitch_frState *) NULL){
        // fprintf(stderr, "Pitch_fr_reset: invalid parameter\n");
        return -1;
    }

    state->T0_prev_subframe = 0;

    return 0;
}

------------------------------------------------------------------------------
 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_fr_reset(Pitch_frState *state)
{

    if (state == (Pitch_frState *) NULL)
    {
        /* fprintf(stderr, "Pitch_fr_reset: invalid parameter\n"); */
        return -1;
    }

    state->T0_prev_subframe = 0;

    return 0;
}


/****************************************************************************/


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

 Inputs:
    state = pointer to a pointer of structure type Pitch_fr_State.

 Outputs:
    None

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

  Function:   Pitch_fr_exit
  Purpose:    The memory for state is freed.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

void Pitch_fr_exit (Pitch_frState **state)
{
    if (state == NULL || *state == NULL)
        return;

    // deallocate memory
    free(*state);
    *state = NULL;

    return;
}

------------------------------------------------------------------------------
 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]

------------------------------------------------------------------------------
*/
void Pitch_fr_exit(Pitch_frState **state)
{
    if (state == NULL || *state == NULL)
        return;

    /* deallocate memory */
    free(*state);
    *state = NULL;

    return;
}

/****************************************************************************/


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

 Inputs:
    st = pointer to stat structure of type Pitch_frState
    mode = codec mode of type enum Mode
    T_op[] = pointer to open loop pitch lags of type Word16
    exc[] = pointer to excitation buffer of type Word16
    xn[] = pointer to target vector of type Word16
    h[] = pointer to impulse response of synthesis and weighting filters
          of type Word16
    L_subfr = length of subframe of type Word16
    i_subfr = subframe offset of type Word16

 Outputs:
    pit_frac = pointer to pitch period (fractional) of type Word16
    resu3 = pointer to subsample resolution of type Word16
    ana_index = pointer to index of encoding of type Word16

 Returns:
    None

 Global Variables Used:
    None

 Local Variables Needed:
    None

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

   FUNCTION:   Pitch_fr()

   PURPOSE: Find the pitch period with 1/3 or 1/6 subsample resolution
            (closed loop).

   DESCRIPTION:
         - find the normalized correlation between the target and filtered
           past excitation in the search range.
         - select the delay with maximum normalized correlation.
         - interpolate the normalized correlation at fractions -3/6 to 3/6
           with step 1/6 around the chosen delay.
         - The fraction which gives the maximum interpolated value is chosen.

------------------------------------------------------------------------------
 REQUIREMENTS

 None

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

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

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

Word16 Pitch_fr (        // o   : pitch period (integer)
    Pitch_frState *st,   // i/o : State struct
    enum Mode mode,      // i   : codec mode
    Word16 T_op[],       // i   : open loop pitch lags
    Word16 exc[],        // i   : excitation buffer                      Q0
    Word16 xn[],         // i   : target vector                          Q0
    Word16 h[],          // i   : impulse response of synthesis and
                                  weighting filters                     Q12
    Word16 L_subfr,      // i   : Length of subframe
    Word16 i_subfr,      // i   : subframe offset
    Word16 *pit_frac,    // o   : pitch period (fractional)
    Word16 *resu3,       // o   : subsample resolution 1/3 (=1) or 1/6 (=0)
    Word16 *ana_index    // o   : index of encoding
)
{
    Word16 i;
    Word16 t_min, t_max;
    Word16 t0_min, t0_max;
    Word16 max, lag, frac;
    Word16 tmp_lag;
    Word16 *corr;
    Word16 corr_v[40];    // Total length = t0_max-t0_min+1+2*L_INTER_SRCH

    Word16 max_frac_lag;
    Word16 flag3, flag4;
    Word16 last_frac;
    Word16 delta_int_low, delta_int_range;
    Word16 delta_frc_low, delta_frc_range;
    Word16 pit_min;
    Word16 frame_offset;
    Word16 delta_search;

    //-----------------------------------------------------------------------
     //                      set mode specific variables
     //----------------------------------------------------------------------

    max_frac_lag    = mode_dep_parm[mode].max_frac_lag;
    flag3           = mode_dep_parm[mode].flag3;
    frac            = mode_dep_parm[mode].first_frac;
    last_frac       = mode_dep_parm[mode].last_frac;
    delta_int_low   = mode_dep_parm[mode].delta_int_low;
    delta_int_range = mode_dep_parm[mode].delta_int_range;

    delta_frc_low   = mode_dep_parm[mode].delta_frc_low;
    delta_frc_range = mode_dep_parm[mode].delta_frc_range;
    pit_min         = mode_dep_parm[mode].pit_min;

    //-----------------------------------------------------------------------
    //                 decide upon full or differential search
    //-----------------------------------------------------------------------

    delta_search = 1;

    if ((i_subfr == 0) || (sub(i_subfr,L_FRAME_BY2) == 0)) {

        // Subframe 1 and 3

        if (((sub((Word16)mode, (Word16)MR475) != 0) && (sub((Word16)mode,
            (Word16)MR515) != 0)) ||
            (sub(i_subfr,L_FRAME_BY2) != 0)) {

            // set t0_min, t0_max for full search
            // this is *not* done for mode MR475, MR515 in subframe 3

            delta_search = 0; // no differential search

            // calculate index into T_op which contains the open-loop
            // pitch estimations for the 2 big subframes

            frame_offset = 1;
            if (i_subfr == 0)
                frame_offset = 0;

            // get T_op from the corresponding half frame and
            // set t0_min, t0_max

            getRange (T_op[frame_offset], delta_int_low, delta_int_range,
                      pit_min, PIT_MAX, &t0_min, &t0_max);
        }
        else {

            // mode MR475, MR515 and 3. Subframe: delta search as well
            getRange (st->T0_prev_subframe, delta_frc_low, delta_frc_range,
                      pit_min, PIT_MAX, &t0_min, &t0_max);
        }
    }
    else {

        // for Subframe 2 and 4
        // get range around T0 of previous subframe for delta search

        getRange (st->T0_prev_subframe, delta_frc_low, delta_frc_range,
                  pit_min, PIT_MAX, &t0_min, &t0_max);
    }

    //-----------------------------------------------------------------------
                Find interval to compute normalized correlation
     -----------------------------------------------------------------------

    t_min = sub (t0_min, L_INTER_SRCH);
    t_max = add (t0_max, L_INTER_SRCH);

    corr = &corr_v[-t_min];

    //-----------------------------------------------------------------------
      Compute normalized correlation between target and filtered excitation
     -----------------------------------------------------------------------

    Norm_Corr (exc, xn, h, L_subfr, t_min, t_max, corr);

    //-----------------------------------------------------------------------
                                Find integer pitch
     -----------------------------------------------------------------------

    max = corr[t0_min];
    lag = t0_min;

    for (i = t0_min + 1; i <= t0_max; i++) {
        if (sub (corr[i], max) >= 0) {
            max = corr[i];
            lag = i;
        }
    }

    //-----------------------------------------------------------------------
                             Find fractional pitch
     -----------------------------------------------------------------------
    if ((delta_search == 0) && (sub (lag, max_frac_lag) > 0)) {

        // full search and integer pitch greater than max_frac_lag
        // fractional search is not needed, set fractional to zero

        frac = 0;
    }
    else {

        // if differential search AND mode MR475 OR MR515 OR MR59 OR MR67
        // then search fractional with 4 bits resolution

       if ((delta_search != 0) &&
           ((sub ((Word16)mode, (Word16)MR475) == 0) ||
            (sub ((Word16)mode, (Word16)MR515) == 0) ||
            (sub ((Word16)mode, (Word16)MR59) == 0) ||
            (sub ((Word16)mode, (Word16)MR67) == 0))) {

          // modify frac or last_frac according to position of last
          // integer pitch: either search around integer pitch,
          // or only on left or right side

          tmp_lag = st->T0_prev_subframe;
          if ( sub( sub(tmp_lag, t0_min), 5) > 0)
             tmp_lag = add (t0_min, 5);
          if ( sub( sub(t0_max, tmp_lag), 4) > 0)
               tmp_lag = sub (t0_max, 4);

          if ((sub (lag, tmp_lag) == 0) ||
              (sub (lag, sub(tmp_lag, 1)) == 0)) {

             // normal search in fractions around T0

             searchFrac (&lag, &frac, last_frac, corr, flag3);

          }
          else if (sub (lag, sub (tmp_lag, 2)) == 0) {
             // limit search around T0 to the right side
             frac = 0;
             searchFrac (&lag, &frac, last_frac, corr, flag3);
          }
          else if (sub (lag, add(tmp_lag, 1)) == 0) {
             // limit search around T0 to the left side
             last_frac = 0;
             searchFrac (&lag, &frac, last_frac, corr, flag3);
          }
          else {
             // no fractional search
             frac = 0;
            }
       }
       else
          // test the fractions around T0
          searchFrac (&lag, &frac, last_frac, corr, flag3);
    }

    //-----------------------------------------------------------------------
     //                           encode pitch
     //-----------------------------------------------------------------------

    if (flag3 != 0) {
       // flag4 indicates encoding with 4 bit resolution;
       // this is needed for mode MR475, MR515 and MR59

       flag4 = 0;
       if ( (sub ((Word16)mode, (Word16)MR475) == 0) ||
            (sub ((Word16)mode, (Word16)MR515) == 0) ||
            (sub ((Word16)mode, (Word16)MR59) == 0) ||
            (sub ((Word16)mode, (Word16)MR67) == 0) ) {
          flag4 = 1;
       }

       // encode with 1/3 subsample resolution

       *ana_index = Enc_lag3(lag, frac, st->T0_prev_subframe,
                             t0_min, t0_max, delta_search, flag4);
       // function result

    }
    else
    {
       // encode with 1/6 subsample resolution

       *ana_index = Enc_lag6(lag, frac, t0_min, delta_search);
       // function result
    }

     //-----------------------------------------------------------------------
     //                          update state variables
     //-----------------------------------------------------------------------

    st->T0_prev_subframe = lag;

     //-----------------------------------------------------------------------
     //                      update output variables
     //-----------------------------------------------------------------------

    *resu3    = flag3;

    *pit_frac = frac;

    return (lag);
}


------------------------------------------------------------------------------
 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_fr(         /* o   : pitch period (integer)                    */
    Pitch_frState *st,   /* i/o : State struct                              */
    enum Mode mode,      /* i   : codec mode                                */
    Word16 T_op[],       /* i   : open loop pitch lags                      */
    Word16 exc[],        /* i   : excitation buffer                      Q0 */
    Word16 xn[],         /* i   : target vector                          Q0 */
    Word16 h[],          /* i   : impulse response of synthesis and
                                  weighting filters                     Q12 */
    Word16 L_subfr,      /* i   : Length of subframe                        */
    Word16 i_subfr,      /* i   : subframe offset                           */
    Word16 *pit_frac,    /* o   : pitch period (fractional)                 */
    Word16 *resu3,       /* o   : subsample resolution 1/3 (=1) or 1/6 (=0) */
    Word16 *ana_index,   /* o   : index of encoding                         */
    Flag   *pOverflow
)
{
    Word16 i;
    Word16 t_min;
    Word16 t_max;
    Word16 t0_min = 0;
    Word16 t0_max;
    Word16 max;
    Word16 lag;
    Word16 frac;
    Word16 tmp_lag;
    Word16 *corr;
    Word16 corr_v[40];    /* Total length = t0_max-t0_min+1+2*L_INTER_SRCH */

    Word16 max_frac_lag;
    Word16 flag3;
    Word16 flag4;
    Word16 last_frac;
    Word16 delta_int_low;
    Word16 delta_int_range;
    Word16 delta_frc_low;
    Word16 delta_frc_range;
    Word16 pit_min;
    Word16 frame_offset;
    Word16 delta_search;

    /*-----------------------------------------------------------------------*
     *                      set mode specific variables                      *
     *-----------------------------------------------------------------------*/

    max_frac_lag    = mode_dep_parm[mode].max_frac_lag;
    flag3           = mode_dep_parm[mode].flag3;
    frac            = mode_dep_parm[mode].first_frac;
    last_frac       = mode_dep_parm[mode].last_frac;
    delta_int_low   = mode_dep_parm[mode].delta_int_low;
    delta_int_range = mode_dep_parm[mode].delta_int_range;

    delta_frc_low   = mode_dep_parm[mode].delta_frc_low;
    delta_frc_range = mode_dep_parm[mode].delta_frc_range;
    pit_min         = mode_dep_parm[mode].pit_min;

    /*-----------------------------------------------------------------------*
     *                 decide upon full or differential search               *
     *-----------------------------------------------------------------------*/

    delta_search = 1;

    if ((i_subfr == 0) || (i_subfr == L_FRAME_BY2))
    {

        /* Subframe 1 and 3 */

        if (((mode != MR475) && (mode != MR515)) || (i_subfr != L_FRAME_BY2))
        {

            /* set t0_min, t0_max for full search */
            /* this is *not* done for mode MR475, MR515 in subframe 3 */

            delta_search = 0; /* no differential search */

            /* calculate index into T_op which contains the open-loop */
            /* pitch estimations for the 2 big subframes */

            frame_offset = 1;
            if (i_subfr == 0)
                frame_offset = 0;

            /* get T_op from the corresponding half frame and */
            /* set t0_min, t0_max */

            getRange(T_op[frame_offset], delta_int_low, delta_int_range,
                     pit_min, PIT_MAX, &t0_min, &t0_max, pOverflow);
        }
        else
        {

            /* mode MR475, MR515 and 3. Subframe: delta search as well */
            getRange(st->T0_prev_subframe, delta_frc_low, delta_frc_range,
                     pit_min, PIT_MAX, &t0_min, &t0_max, pOverflow);
        }
    }
    else
    {

        /* for Subframe 2 and 4 */
        /* get range around T0 of previous subframe for delta search */

        getRange(st->T0_prev_subframe, delta_frc_low, delta_frc_range,
                 pit_min, PIT_MAX, &t0_min, &t0_max, pOverflow);
    }

    /*-----------------------------------------------------------------------*
     *           Find interval to compute normalized correlation             *
     *-----------------------------------------------------------------------*/

    t_min = sub(t0_min, L_INTER_SRCH, pOverflow);
    t_max = add(t0_max, L_INTER_SRCH, pOverflow);

    corr = &corr_v[-t_min];

    /*-----------------------------------------------------------------------*
     * Compute normalized correlation between target and filtered excitation *
     *-----------------------------------------------------------------------*/

    Norm_Corr(exc, xn, h, L_subfr, t_min, t_max, corr, pOverflow);

    /*-----------------------------------------------------------------------*
     *                           Find integer pitch                          *
     *-----------------------------------------------------------------------*/

    max = corr[t0_min];
    lag = t0_min;

    for (i = t0_min + 1; i <= t0_max; i++)
    {
        if (corr[i] >= max)
        {
            max = corr[i];
            lag = i;
        }
    }

    /*-----------------------------------------------------------------------*
     *                        Find fractional pitch                          *
     *-----------------------------------------------------------------------*/
    if ((delta_search == 0) && (lag > max_frac_lag))
    {

        /* full search and integer pitch greater than max_frac_lag */
        /* fractional search is not needed, set fractional to zero */

        frac = 0;
    }
    else
    {

        /* if differential search AND mode MR475 OR MR515 OR MR59 OR MR67   */
        /* then search fractional with 4 bits resolution           */

        if ((delta_search != 0) &&
                ((mode == MR475) || (mode == MR515) ||
                 (mode == MR59) || (mode == MR67)))
        {

            /* modify frac or last_frac according to position of last */
            /* integer pitch: either search around integer pitch, */
            /* or only on left or right side */

            tmp_lag = st->T0_prev_subframe;
            if (sub(sub(tmp_lag, t0_min, pOverflow), 5, pOverflow) > 0)
                tmp_lag = add(t0_min, 5, pOverflow);
            if (sub(sub(t0_max, tmp_lag, pOverflow), 4, pOverflow) > 0)
                tmp_lag = sub(t0_max, 4, pOverflow);

            if ((lag == tmp_lag) || (lag == (tmp_lag - 1)))
            {

                /* normal search in fractions around T0 */

                searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow);

            }
            else if (lag == (tmp_lag - 2))
            {
                /* limit search around T0 to the right side */
                frac = 0;
                searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow);
            }
            else if (lag == (tmp_lag + 1))
            {
                /* limit search around T0 to the left side */
                last_frac = 0;
                searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow);
            }
            else
            {
                /* no fractional search */
                frac = 0;
            }
        }
        else
            /* test the fractions around T0 */
            searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow);
    }

    /*-----------------------------------------------------------------------*
     *                           encode pitch                                *
     *-----------------------------------------------------------------------*/

    if (flag3 != 0)
    {
        /* flag4 indicates encoding with 4 bit resolution;         */
        /* this is needed for mode MR475, MR515 and MR59           */

        flag4 = 0;
        if ((mode == MR475) || (mode == MR515) ||
                (mode == MR59) || (mode == MR67))
        {
            flag4 = 1;
        }

        /* encode with 1/3 subsample resolution */

        *ana_index = Enc_lag3(lag, frac, st->T0_prev_subframe,
                              t0_min, t0_max, delta_search, flag4, pOverflow);
        /* function result */

    }
    else
    {
        /* encode with 1/6 subsample resolution */

        *ana_index = Enc_lag6(lag, frac, t0_min, delta_search, pOverflow);
        /* function result */
    }

    /*-----------------------------------------------------------------------*
     *                          update state variables                       *
     *-----------------------------------------------------------------------*/

    st->T0_prev_subframe = lag;

    /*-----------------------------------------------------------------------*
     *                      update output variables                          *
     *-----------------------------------------------------------------------*/

    *resu3    = flag3;

    *pit_frac = frac;

    return (lag);
}