diff options
Diffstat (limited to 'media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp')
| -rw-r--r-- | media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp | 1609 |
1 files changed, 0 insertions, 1609 deletions
diff --git a/media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp b/media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp deleted file mode 100644 index 5a846fa..0000000 --- a/media/libstagefright/codecs/amrnb/enc/src/pitch_fr.cpp +++ /dev/null @@ -1,1609 +0,0 @@ -/* ------------------------------------------------------------------ - * 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); -} - |