/* ------------------------------------------------------------------ * 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 #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] = /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 mul; 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; __builtin_mul_overflow(temp, temp, &mul); __builtin_add_overflow(s, mul, &s); temp = *(p_excf++); *(p_s_excf++) = temp >> 2; __builtin_mul_overflow(temp, temp, &mul); __builtin_add_overflow(s, mul, &s); } 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--) { __builtin_mul_overflow(*(p_x++), *p_s_excf, &mul); __builtin_add_overflow(s, mul, &s); __builtin_mul_overflow(*p_s_excf, *p_s_excf, &mul); __builtin_add_overflow(s2, mul, &s2); p_s_excf++; __builtin_mul_overflow(*(p_x++), *p_s_excf, &mul); __builtin_add_overflow(s, mul, &s); __builtin_mul_overflow(*p_s_excf, *p_s_excf, &mul); __builtin_add_overflow(s2, mul, &s2); p_s_excf++; } s2 = s2 << 1; s2 = Inv_sqrt(s2, pOverflow); norm_h = (Word16)(s2 >> 16); __builtin_sub_overflow((s2 >> 1), (norm_h << 15), &norm_l); corr_h = (Word16)(s >> 15); __builtin_sub_overflow(s, (corr_h << 15), &corr_l); /* 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, enum Mode mode ) { Word16 i; Word16 max; Word16 corr_int; Word16 minPitch; /* 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; } } minPitch = (mode == MR122) ? PIT_MIN_MR122 : PIT_MIN; if (flag3 == 0) { /* Limit the fraction value in the interval [-2,-1,0,1,2,3] */ if (*frac == -3) { if (*lag > minPitch) { *frac = 3; (*lag)--; } else { *frac = -2; } } } else { /* limit the fraction value between -1 and 1 */ if (*frac == -2) { if (*lag > minPitch) { *frac = 1; (*lag)--; } else { *frac = -1; } } else if (*frac == 2) { if (*lag < PIT_MAX) { *frac = -1; (*lag)++; } else { *frac = 1; } } } } /****************************************************************************/ /* ------------------------------------------------------------------------------ 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, mode); } else if (lag == (tmp_lag - 2)) { /* limit search around T0 to the right side */ frac = 0; searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow, mode); } 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, mode); } else { /* no fractional search */ frac = 0; } } else /* test the fractions around T0 */ searchFrac(&lag, &frac, last_frac, corr, flag3, pOverflow, mode); } /*-----------------------------------------------------------------------* * 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); }