Home | History | Annotate | Download | only in src
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 /****************************************************************************************
     19 Portions of this file are derived from the following 3GPP standard:
     20 
     21     3GPP TS 26.073
     22     ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
     23     Available from http://www.3gpp.org
     24 
     25 (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
     26 Permission to distribute, modify and use this file under the standard license
     27 terms listed above has been obtained from the copyright holder.
     28 ****************************************************************************************/
     29 /*
     30 ------------------------------------------------------------------------------
     31 
     32 
     33 
     34  Pathname: ./audio/gsm-amr/c/src/pitch_ol.c
     35  Funtions: Pitch_ol
     36            Lag_max
     37 
     38 ------------------------------------------------------------------------------
     39  MODULE DESCRIPTION
     40 
     41  The modules in this file compute the open loop pitch lag.
     42 ------------------------------------------------------------------------------
     43 */
     44 
     45 
     46 /*----------------------------------------------------------------------------
     47 ; INCLUDES
     48 ----------------------------------------------------------------------------*/
     49 #include <string.h>
     50 
     51 #include "pitch_ol.h"
     52 #include "typedef.h"
     53 #include "basicop_malloc.h"
     54 #include "cnst.h"
     55 #include "inv_sqrt.h"
     56 #include "vad.h"
     57 #include "calc_cor.h"
     58 #include "hp_max.h"
     59 #include "basic_op.h"
     60 
     61 /*----------------------------------------------------------------------------
     62 ; MACROS
     63 ; Define module specific macros here
     64 ----------------------------------------------------------------------------*/
     65 
     66 
     67 /*----------------------------------------------------------------------------
     68 ; DEFINES
     69 ; Include all pre-processor statements here. Include conditional
     70 ; compile variables also.
     71 ----------------------------------------------------------------------------*/
     72 #define THRESHOLD 27853
     73 
     74 /*----------------------------------------------------------------------------
     75 ; LOCAL FUNCTION DEFINITIONS
     76 ; Function Prototype declaration
     77 ----------------------------------------------------------------------------*/
     78 
     79 /*----------------------------------------------------------------------------
     80 ; LOCAL VARIABLE DEFINITIONS
     81 ; Variable declaration - defined here and used outside this module
     82 ----------------------------------------------------------------------------*/
     83 
     84 
     85 /*
     86 ------------------------------------------------------------------------------
     87  FUNCTION NAME: Lag_max
     88 ------------------------------------------------------------------------------
     89  INPUT AND OUTPUT DEFINITIONS (If VAD2 is defined)
     90 
     91  Inputs
     92     corr = pointer to buffer of correlation values (Word32)
     93     scal_sig = pointer to buffer of scaled signal values (Word16)
     94     scal_fac = scaled signal factor (Word16)
     95     scal_flag = EFR compatible scaling flag (Word16)
     96     L_frame = length of frame to compute pitch (Word16)
     97     lag_max = maximum lag (Word16)
     98     lag_min = minimum lag (Word16)
     99     cor_max = pointer to the normalized correlation of selected lag (Word16)
    100     rmax = pointer to max(<s[i]*s[j]>), (Word32)
    101     r0 = pointer to the residual energy (Word32)
    102     dtx  = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
    103 
    104  Outputs:
    105     cor_max contains the newly calculated normalized correlation of the
    106       selected lag
    107     rmax contains the newly calculated max(<s[i]*s[j]>)
    108     r0 contains the newly calculated residual energy
    109 
    110  Returns:
    111     p_max = lag of the max correlation found (Word16)
    112 
    113  Global Variables Used:
    114     None.
    115 
    116  Local Variables Needed:
    117     None.
    118 
    119 ------------------------------------------------------------------------------
    120  INPUT AND OUTPUT DEFINITIONS (If VAD2 is not defined)
    121 
    122  Inputs
    123     vadSt = pointer to a vadState structure
    124     corr = pointer to buffer of correlation values (Word32)
    125     scal_sig = pointer to buffer of scaled signal values (Word16)
    126     scal_fac = scaled signal factor (Word16)
    127     scal_flag = EFR compatible scaling flag (Word16)
    128     L_frame = length of frame to compute pitch (Word16)
    129     lag_max = maximum lag (Word16)
    130     lag_min = minimum lag (Word16)
    131     cor_max = pointer to the normalized correlation of selected lag (Word16)
    132     dtx  = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
    133     pOverflow = pointer to overflow indicator (Flag)
    134 
    135  Outputs:
    136     cor_max contains the newly calculated normalized correlation of the
    137       selected lag
    138     vadSt contains the updated VAD state parameters
    139     pOverflow -> 1 if the math operations called by this routine saturate
    140 
    141  Returns:
    142     p_max = lag of the max correlation found (Word16)
    143 
    144  Global Variables Used:
    145     None.
    146 
    147  Local Variables Needed:
    148     None.
    149 
    150 ------------------------------------------------------------------------------
    151  FUNCTION DESCRIPTION
    152 
    153  Find the lag that has maximum correlation of scal_sig in a given delay range.
    154  The correlation is given by:
    155 
    156          cor[t] = <scal_sig[n],scal_sig[n-t]>,  t=lag_min,...,lag_max
    157 
    158  The function returns the maximum correlation after normalization and the
    159  corresponding lag.
    160 
    161 ------------------------------------------------------------------------------
    162  REQUIREMENTS
    163 
    164  None.
    165 
    166 ------------------------------------------------------------------------------
    167  REFERENCES
    168 
    169  pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
    170 
    171 ------------------------------------------------------------------------------
    172  PSEUDO-CODE
    173 
    174 #ifdef VAD2
    175 static Word16 Lag_max ( // o   : lag found
    176     Word32 corr[],      // i   : correlation vector.
    177     Word16 scal_sig[],  // i   : scaled signal.
    178     Word16 scal_fac,    // i   : scaled signal factor.
    179     Word16 scal_flag,   // i   : if 1 use EFR compatible scaling
    180     Word16 L_frame,     // i   : length of frame to compute pitch
    181     Word16 lag_max,     // i   : maximum lag
    182     Word16 lag_min,     // i   : minimum lag
    183     Word16 *cor_max,    // o   : normalized correlation of selected lag
    184     Word32 *rmax,       // o   : max(<s[i]*s[j]>)
    185     Word32 *r0,         // o   : residual energy
    186     Flag dtx            // i   : dtx flag; use dtx=1, do not use dtx=0
    187     )
    188 #else
    189 static Word16 Lag_max ( // o   : lag found
    190     vadState *vadSt,    // i/o : VAD state struct
    191     Word32 corr[],      // i   : correlation vector.
    192     Word16 scal_sig[],  // i   : scaled signal.
    193     Word16 scal_fac,    // i   : scaled signal factor.
    194     Word16 scal_flag,   // i   : if 1 use EFR compatible scaling
    195     Word16 L_frame,     // i   : length of frame to compute pitch
    196     Word16 lag_max,     // i   : maximum lag
    197     Word16 lag_min,     // i   : minimum lag
    198     Word16 *cor_max,    // o   : normalized correlation of selected lag
    199     Flag dtx            // i   : dtx flag; use dtx=1, do not use dtx=0
    200     )
    201 #endif
    202 {
    203     Word16 i, j;
    204     Word16 *p;
    205     Word32 max, t0;
    206     Word16 max_h, max_l, ener_h, ener_l;
    207     Word16 p_max = 0; // initialization only needed to keep gcc silent
    208 
    209     max = MIN_32;
    210     p_max = lag_max;
    211 
    212     for (i = lag_max, j = (PIT_MAX-lag_max-1); i >= lag_min; i--, j--)
    213     {
    214        if (L_sub (corr[-i], max) >= 0)
    215        {
    216           max = corr[-i];
    217           p_max = i;
    218        }
    219     }
    220 
    221     // compute energy
    222 
    223     t0 = 0;
    224     p = &scal_sig[-p_max];
    225     for (i = 0; i < L_frame; i++, p++)
    226     {
    227         t0 = L_mac (t0, *p, *p);
    228     }
    229     // 1/sqrt(energy)
    230 
    231     if (dtx)
    232     {  // no test() call since this if is only in simulation env
    233 #ifdef VAD2
    234        *rmax = max;
    235        *r0 = t0;
    236 #else
    237        // check tone
    238        vad_tone_detection (vadSt, max, t0);
    239 #endif
    240     }
    241 
    242     t0 = Inv_sqrt (t0);
    243 
    244     if (scal_flag)
    245     {
    246        t0 = L_shl (t0, 1);
    247     }
    248 
    249     // max = max/sqrt(energy)
    250 
    251     L_Extract (max, &max_h, &max_l);
    252     L_Extract (t0, &ener_h, &ener_l);
    253 
    254     t0 = Mpy_32 (max_h, max_l, ener_h, ener_l);
    255 
    256     if (scal_flag)
    257     {
    258       t0 = L_shr (t0, scal_fac);
    259       *cor_max = extract_h (L_shl (t0, 15)); // divide by 2
    260     }
    261     else
    262     {
    263       *cor_max = extract_l(t0);
    264     }
    265 
    266     return (p_max);
    267 }
    268 
    269 ------------------------------------------------------------------------------
    270  RESOURCES USED [optional]
    271 
    272  When the code is written for a specific target processor the
    273  the resources used should be documented below.
    274 
    275  HEAP MEMORY USED: x bytes
    276 
    277  STACK MEMORY USED: x bytes
    278 
    279  CLOCK CYCLES: (cycle count equation for this function) + (variable
    280                 used to represent cycle count for each subroutine
    281                 called)
    282      where: (cycle count variable) = cycle count for [subroutine
    283                                      name]
    284 
    285 ------------------------------------------------------------------------------
    286  CAUTION [optional]
    287  [State any special notes, constraints or cautions for users of this function]
    288 
    289 ------------------------------------------------------------------------------
    290 */
    291 
    292 #ifdef VAD2
    293 static Word16 Lag_max(  /* o   : lag found                               */
    294     Word32 corr[],      /* i   : correlation vector.                     */
    295     Word16 scal_sig[],  /* i   : scaled signal.                          */
    296     Word16 scal_fac,    /* i   : scaled signal factor.                   */
    297     Word16 scal_flag,   /* i   : if 1 use EFR compatible scaling         */
    298     Word16 L_frame,     /* i   : length of frame to compute pitch        */
    299     Word16 lag_max,     /* i   : maximum lag                             */
    300     Word16 lag_min,     /* i   : minimum lag                             */
    301     Word16 *cor_max,    /* o   : normalized correlation of selected lag  */
    302     Word32 *rmax,       /* o   : max(<s[i]*s[j]>)                        */
    303     Word32 *r0,         /* o   : residual energy                         */
    304     Flag dtx,           /* i   : dtx flag; use dtx=1, do not use dtx=0   */
    305     Flag *pOverflow     /* i/o : overflow Flag                           */
    306 )
    307 #else
    308 static Word16 Lag_max(  /* o   : lag found                               */
    309     vadState *vadSt,    /* i/o : VAD state struct                        */
    310     Word32 corr[],      /* i   : correlation vector.                     */
    311     Word16 scal_sig[],  /* i   : scaled signal.                          */
    312     Word16 scal_fac,    /* i   : scaled signal factor.                   */
    313     Word16 scal_flag,   /* i   : if 1 use EFR compatible scaling         */
    314     Word16 L_frame,     /* i   : length of frame to compute pitch        */
    315     Word16 lag_max,     /* i   : maximum lag                             */
    316     Word16 lag_min,     /* i   : minimum lag                             */
    317     Word16 *cor_max,    /* o   : normalized correlation of selected lag  */
    318     Flag dtx,           /* i   : dtx flag; use dtx=1, do not use dtx=0   */
    319     Flag *pOverflow     /* i/o : overflow Flag                           */
    320 )
    321 #endif
    322 {
    323     Word16 i;
    324     Word16 *p;
    325     Word32 max;
    326     Word32 t0;
    327     Word16 max_h;
    328     Word16 max_l;
    329     Word16 ener_h;
    330     Word16 ener_l;
    331     Word16 p_max = 0; /* initialization only needed to keep gcc silent */
    332     Word32 L_temp;
    333     Word32 L_temp_2;
    334     Word32 L_temp_3;
    335     Word32  *p_corr = &corr[-lag_max];
    336 
    337     max = MIN_32;
    338     p_max = lag_max;
    339 
    340     for (i = lag_max; i >= lag_min; i--)
    341     {
    342         /* The negative array index is equivalent to a negative */
    343         /* address offset, i.e., corr[-i] == *(corr - i)        */
    344         if (*(p_corr++) >= max)
    345         {
    346             p_corr--;
    347             max = *(p_corr++);
    348             p_max = i;
    349         }
    350     }
    351 
    352     /* compute energy */
    353 
    354     t0 = 0;
    355 
    356     /* The negative array index is equivalent to a negative          */
    357     /* address offset, i.e., scal_sig[-p_max] == *(scal_sig - p_max) */
    358     p = &scal_sig[-p_max];
    359     for (i = (L_frame >> 2); i != 0; i--)
    360     {
    361         t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
    362         p++;
    363         t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
    364         p++;
    365         t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
    366         p++;
    367         t0 = amrnb_fxp_mac_16_by_16bb((Word32) * (p), (Word32) * (p), t0);
    368         p++;
    369     }
    370 
    371     t0 <<= 1;
    372     /* 1/sqrt(energy) */
    373 
    374     if (dtx)
    375     {  /* no test() call since this if is only in simulation env */
    376         /* check tone */
    377 #ifdef VAD2
    378         *rmax = max;
    379         *r0 = t0;
    380 #else
    381         /* check tone */
    382         vad_tone_detection(vadSt, max, t0, pOverflow);
    383 #endif
    384     }
    385 
    386     t0 = Inv_sqrt(t0, pOverflow);
    387 
    388     if (scal_flag)
    389     {
    390         if (t0 > (Word32) 0x3fffffffL)
    391         {
    392             t0 = MAX_32;
    393         }
    394         else
    395         {
    396             t0 = t0 << 1;
    397         }
    398     }
    399 
    400     /* max = max/sqrt(energy)  */
    401     /* The following code is an inlined version of */
    402     /* L_Extract (max, &max_h, &max_l), i.e.       */
    403     /*                                             */
    404     /* *max_h = extract_h (max);                   */
    405     max_h = (Word16)(max >> 16);
    406 
    407     /* L_temp_2 = L_shr(max,1), which is used in      */
    408     /* the calculation of *max_l (see next operation) */
    409     L_temp_2 = max >> 1;
    410 
    411     /* *max_l = extract_l (L_msu (L_shr (max, 1), *max_h, 16384)); */
    412     L_temp_3 = (Word32)(max_h << 15);
    413 
    414     L_temp = L_temp_2 - L_temp_3;
    415 
    416     max_l = (Word16)L_temp;
    417 
    418     /* The following code is an inlined version of */
    419     /* L_Extract (t0, &ener_h, &ener_l), i.e.      */
    420     /*                                             */
    421     /* *ener_h = extract_h (t0);                   */
    422     ener_h = (Word16)(t0 >> 16);
    423 
    424     /* L_temp_2 = L_shr(t0,1), which is used in        */
    425     /* the calculation of *ener_l (see next operation) */
    426 
    427     L_temp_2 = t0 >> 1;
    428 
    429     L_temp_3 = (Word32)(ener_h << 15);
    430 
    431     L_temp = L_temp_2 - L_temp_3;
    432 
    433     ener_l = (Word16)L_temp;
    434 
    435     t0 = Mpy_32(max_h, max_l, ener_h, ener_l, pOverflow);
    436 
    437     if (scal_flag)
    438     {
    439         t0 = L_shr(t0, scal_fac, pOverflow);
    440 
    441         if (t0 > (Word32) 0X0000FFFFL)
    442         {
    443             *cor_max = MAX_16;
    444         }
    445         else if (t0 < (Word32) 0xFFFF0000L)
    446         {
    447             *cor_max = MIN_16;
    448         }
    449         else
    450         {
    451             *cor_max = (Word16)(t0 >> 1);
    452         }
    453     }
    454     else
    455     {
    456         *cor_max = (Word16)t0;
    457     }
    458 
    459     return (p_max);
    460 }
    461 
    462 /*----------------------------------------------------------------------------
    463 ; End Function: Lag_max
    464 ----------------------------------------------------------------------------*/
    465 
    466 
    467 /*
    468 ------------------------------------------------------------------------------
    469  FUNCTION NAME: Lag_max_wrapper
    470 ------------------------------------------------------------------------------
    471  INPUT AND OUTPUT DEFINITIONS
    472 
    473  Inputs
    474     corr = pointer to buffer of correlation values (Word32)
    475     scal_sig = pointer to buffer of scaled signal values (Word16)
    476     scal_fac = scaled signal factor (Word16)
    477     scal_flag = EFR compatible scaling flag (Word16)
    478     L_frame = length of frame to compute pitch (Word16)
    479     lag_max = maximum lag (Word16)
    480     lag_min = minimum lag (Word16)
    481     cor_max = pointer to the normalized correlation of selected lag (Word16)
    482     rmax = pointer to max(<s[i]*s[j]>), (Word32)
    483     r0 = pointer to the residual energy (Word32)
    484     dtx  = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
    485     pOverflow = pointer to overflow indicator (Flag)
    486 
    487  Outputs:
    488     cor_max contains the newly calculated normalized correlation of the
    489       selected lag
    490     rmax contains the newly calculated max(<s[i]*s[j]>)
    491     r0 contains the newly calculated residual energy
    492     pOverflow -> 1 if the math operations called by this routine saturate
    493 
    494  Returns:
    495     p_max = lag of the max correlation found (Word16)
    496 
    497  Global Variables Used:
    498     None.
    499 
    500  Local Variables Needed:
    501     None.
    502 
    503 ------------------------------------------------------------------------------
    504  INPUT AND OUTPUT DEFINITIONS (If VAD2 is not defined)
    505 
    506  Inputs
    507     vadSt = pointer to a vadState structure
    508     corr = pointer to buffer of correlation values (Word32)
    509     scal_sig = pointer to buffer of scaled signal values (Word16)
    510     scal_fac = scaled signal factor (Word16)
    511     scal_flag = EFR compatible scaling flag (Word16)
    512     L_frame = length of frame to compute pitch (Word16)
    513     lag_max = maximum lag (Word16)
    514     lag_min = minimum lag (Word16)
    515     cor_max = pointer to the normalized correlation of selected lag (Word16)
    516     dtx  = dtx flag; equal to 1, if dtx is enabled, 0, otherwise (Flag)
    517     pOverflow = pointer to overflow indicator (Flag)
    518 
    519  Outputs:
    520     cor_max contains the newly calculated normalized correlation of the
    521       selected lag
    522     vadSt contains the updated VAD state parameters
    523     pOverflow -> 1 if the math operations called by this routine saturate
    524 
    525  Returns:
    526     p_max = lag of the max correlation found (Word16)
    527 
    528  Global Variables Used:
    529     None.
    530 
    531  Local Variables Needed:
    532     None.
    533 
    534 ------------------------------------------------------------------------------
    535  FUNCTION DESCRIPTION
    536 
    537  This function provides external access to the local function Lag_max.
    538 
    539 ------------------------------------------------------------------------------
    540  REQUIREMENTS
    541 
    542  None
    543 
    544 ------------------------------------------------------------------------------
    545  REFERENCES
    546 
    547  pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
    548 
    549 ------------------------------------------------------------------------------
    550  PSEUDO-CODE
    551 
    552 #ifdef VAD2
    553  CALL Lag_max(corr = corr
    554           scal_sig = scal_sig
    555           scal_fac = scal_fac
    556           scal_flag = scal_flag
    557           L_frame = L_frame
    558           lag_max = lag_max
    559           lag_min = lag_min
    560           cor_max = cor_max
    561           rmax = rmax
    562           r0 = r0
    563           dtx = dtx
    564           pOverflow = pOverflow)
    565    MODIFYING(nothing)
    566    RETURNING(temp)
    567 
    568 #else
    569  CALL Lag_max(vadSt = vadSt
    570           corr = corr
    571           scal_sig = scal_sig
    572           scal_fac = scal_fac
    573           scal_flag = scal_flag
    574           L_frame = L_frame
    575           lag_max = lag_max
    576           lag_min = lag_min
    577           cor_max = cor_max
    578           dtx = dtx
    579           pOverflow = pOverflow)
    580    MODIFYING(nothing)
    581    RETURNING(temp)
    582 
    583 #endif
    584 
    585 ------------------------------------------------------------------------------
    586  RESOURCES USED [optional]
    587 
    588  When the code is written for a specific target processor the
    589  the resources used should be documented below.
    590 
    591  HEAP MEMORY USED: x bytes
    592 
    593  STACK MEMORY USED: x bytes
    594 
    595  CLOCK CYCLES: (cycle count equation for this function) + (variable
    596                 used to represent cycle count for each subroutine
    597                 called)
    598      where: (cycle count variable) = cycle count for [subroutine
    599                                      name]
    600 
    601 ------------------------------------------------------------------------------
    602  CAUTION [optional]
    603  [State any special notes, constraints or cautions for users of this function]
    604 
    605 ------------------------------------------------------------------------------
    606 */
    607 
    608 #ifdef VAD2
    609 Word16 Lag_max_wrapper(  /* o   : lag found                          */
    610     Word32 corr[],      /* i   : correlation vector.                     */
    611     Word16 scal_sig[],  /* i   : scaled signal.                          */
    612     Word16 scal_fac,    /* i   : scaled signal factor.                   */
    613     Word16 scal_flag,   /* i   : if 1 use EFR compatible scaling         */
    614     Word16 L_frame,     /* i   : length of frame to compute pitch        */
    615     Word16 lag_max,     /* i   : maximum lag                             */
    616     Word16 lag_min,     /* i   : minimum lag                             */
    617     Word16 *cor_max,    /* o   : normalized correlation of selected lag  */
    618     Word32 *rmax,       /* o   : max(<s[i]*s[j]>)                        */
    619     Word32 *r0,         /* o   : residual energy                         */
    620     Flag dtx,           /* i   : dtx flag; use dtx=1, do not use dtx=0   */
    621     Flag *pOverflow     /* i/o : overflow Flag                           */
    622 )
    623 {
    624     Word16 temp;
    625 
    626     temp = Lag_max(corr, scal_sig, scal_fac, scal_flag, L_frame, lag_max,
    627                    lag_min, cor_max, rmax, r0, dtx, pOverflow);
    628 
    629     return(temp);
    630 }
    631 
    632 #else
    633 Word16 Lag_max_wrapper(  /* o   : lag found                          */
    634     vadState *vadSt,    /* i/o : VAD state struct                        */
    635     Word32 corr[],      /* i   : correlation vector.                     */
    636     Word16 scal_sig[],  /* i   : scaled signal.                          */
    637     Word16 scal_fac,    /* i   : scaled signal factor.                   */
    638     Word16 scal_flag,   /* i   : if 1 use EFR compatible scaling         */
    639     Word16 L_frame,     /* i   : length of frame to compute pitch        */
    640     Word16 lag_max,     /* i   : maximum lag                             */
    641     Word16 lag_min,     /* i   : minimum lag                             */
    642     Word16 *cor_max,    /* o   : normalized correlation of selected lag  */
    643     Flag dtx,           /* i   : dtx flag; use dtx=1, do not use dtx=0   */
    644     Flag *pOverflow     /* i/o : overflow Flag                           */
    645 )
    646 {
    647     Word16 temp;
    648 
    649     temp = Lag_max(vadSt, corr, scal_sig, scal_fac, scal_flag, L_frame,
    650                    lag_max, lag_min, cor_max, dtx, pOverflow);
    651 
    652     return(temp);
    653 }
    654 
    655 #endif
    656 
    657 /*----------------------------------------------------------------------------
    658 ; End Function: Lag_max_wrapper
    659 ----------------------------------------------------------------------------*/
    660 
    661 /*
    662 ------------------------------------------------------------------------------
    663  FUNCTION NAME: Pitch_ol
    664 ------------------------------------------------------------------------------
    665  INPUT AND OUTPUT DEFINITIONS
    666 
    667  Inputs:
    668     vadSt = pointer to a vadState structure
    669     mode =  data of type enum Mode specifies the mode.
    670     signal = pointer to buffer of signal used to compute the open loop
    671          pitch
    672     where signal[-pit_max] to signal[-1] should be known
    673     pit_min = 16 bit value specifies the minimum pitch lag
    674     pit_max = 16 bit value specifies the maximum pitch lag
    675     L_frame = 16 bit value specifies the length of frame to compute pitch
    676     idx = 16 bit value specifies the frame index
    677     dtx = Data of type 'Flag' used for dtx. Use dtx=1, do not use dtx=0
    678     pOverflow = pointer to overflow indicator (Flag)
    679 
    680  Outputs
    681     vadSt = The vadSt state structure may be modified.
    682     pOverflow -> 1 if the math operations called by this routine saturate
    683 
    684  Returns:
    685     p_max1 = 16 bit value representing the open loop pitch lag.
    686 
    687  Global Variables Used:
    688     None.
    689 
    690  Local Variables Needed:
    691     None.
    692 
    693 ------------------------------------------------------------------------------
    694  FUNCTION DESCRIPTION
    695 
    696  This function computes the open loop pitch lag based on the perceptually
    697  weighted speech signal. This is done in the following steps:
    698        - find three maxima of the correlation <sw[n],sw[n-T]>,
    699          dividing the search range into three parts:
    700               pit_min ... 2*pit_min-1
    701             2*pit_min ... 4*pit_min-1
    702             4*pit_min ...   pit_max
    703        - divide each maximum by <sw[n-t], sw[n-t]> where t is the delay at
    704          that maximum correlation.
    705        - select the delay of maximum normalized correlation (among the
    706          three candidates) while favoring the lower delay ranges.
    707 
    708 
    709 ------------------------------------------------------------------------------
    710  REQUIREMENTS
    711 
    712  None.
    713 
    714 ------------------------------------------------------------------------------
    715  REFERENCES
    716 
    717  pitch_ol.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
    718 
    719 ------------------------------------------------------------------------------
    720  PSEUDO-CODE
    721 
    722 Word16 Pitch_ol (      // o   : open loop pitch lag
    723     vadState *vadSt,   // i/o : VAD state struct
    724     enum Mode mode,    // i   : coder mode
    725     Word16 signal[],   // i   : signal used to compute the open loop pitch
    726                        //    signal[-pit_max] to signal[-1] should be known
    727     Word16 pit_min,    // i   : minimum pitch lag
    728     Word16 pit_max,    // i   : maximum pitch lag
    729     Word16 L_frame,    // i   : length of frame to compute pitch
    730     Word16 idx,        // i   : frame index
    731     Flag dtx           // i   : dtx flag; use dtx=1, do not use dtx=0
    732     )
    733 {
    734     Word16 i, j;
    735     Word16 max1, max2, max3;
    736     Word16 p_max1, p_max2, p_max3;
    737     Word16 scal_flag = 0;
    738     Word32 t0;
    739 #ifdef VAD2
    740     Word32  r01, r02, r03;
    741     Word32  rmax1, rmax2, rmax3;
    742 #else
    743     Word16 corr_hp_max;
    744 #endif
    745     Word32 corr[PIT_MAX+1], *corr_ptr;
    746 
    747     // Scaled signal
    748 
    749     Word16 scaled_signal[L_FRAME + PIT_MAX];
    750     Word16 *scal_sig, scal_fac;
    751 
    752 #ifndef VAD2
    753     if (dtx)
    754     {  // no test() call since this if is only in simulation env
    755        // update tone detection
    756        if ((sub(mode, MR475) == 0) || (sub(mode, MR515) == 0))
    757        {
    758           vad_tone_detection_update (vadSt, 1);
    759        }
    760        else
    761        {
    762           vad_tone_detection_update (vadSt, 0);
    763        }
    764     }
    765 #endif
    766 
    767     scal_sig = &scaled_signal[pit_max];
    768 
    769     t0 = 0L;
    770     for (i = -pit_max; i < L_frame; i++)
    771     {
    772         t0 = L_mac (t0, signal[i], signal[i]);
    773     }
    774 
    775      *--------------------------------------------------------*
    776      * Scaling of input signal.                               *
    777      *                                                        *
    778      *   if Overflow        -> scal_sig[i] = signal[i]>>3     *
    779      *   else if t0 < 1^20  -> scal_sig[i] = signal[i]<<3     *
    780      *   else               -> scal_sig[i] = signal[i]        *
    781      *--------------------------------------------------------*
    782 
    783      *--------------------------------------------------------*
    784      *  Verification for risk of overflow.                    *
    785      *--------------------------------------------------------*
    786 
    787     if (L_sub (t0, MAX_32) == 0L)               // Test for overflow
    788     {
    789         for (i = -pit_max; i < L_frame; i++)
    790         {
    791             scal_sig[i] = shr (signal[i], 3);
    792         }
    793         scal_fac = 3;
    794     }
    795     else if (L_sub (t0, (Word32) 1048576L) < (Word32) 0)
    796         // if (t0 < 2^20)
    797     {
    798         for (i = -pit_max; i < L_frame; i++)
    799         {
    800             scal_sig[i] = shl (signal[i], 3);
    801         }
    802         scal_fac = -3;
    803     }
    804     else
    805     {
    806         for (i = -pit_max; i < L_frame; i++)
    807         {
    808             scal_sig[i] = signal[i];
    809         }
    810         scal_fac = 0;
    811     }
    812 
    813     // calculate all coreelations of scal_sig, from pit_min to pit_max
    814     corr_ptr = &corr[pit_max];
    815     comp_corr (scal_sig, L_frame, pit_max, pit_min, corr_ptr);
    816 
    817      *--------------------------------------------------------------------*
    818      *  The pitch lag search is divided in three sections.                *
    819      *  Each section cannot have a pitch multiple.                        *
    820      *  We find a maximum for each section.                               *
    821      *  We compare the maximum of each section by favoring small lags.    *
    822      *                                                                    *
    823      *  First section:  lag delay = pit_max     downto 4*pit_min          *
    824      *  Second section: lag delay = 4*pit_min-1 downto 2*pit_min          *
    825      *  Third section:  lag delay = 2*pit_min-1 downto pit_min            *
    826      *--------------------------------------------------------------------*
    827 
    828     // mode dependent scaling in Lag_max
    829     if (sub(mode, MR122) == 0)
    830     {
    831        scal_flag = 1;
    832     }
    833     else
    834     {
    835        scal_flag = 0;
    836     }
    837 
    838 #ifdef VAD2
    839     j = shl (pit_min, 2);
    840     p_max1 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    841                       pit_max, j, &max1, &rmax1, &r01, dtx);
    842 
    843     i = sub (j, 1);
    844     j = shl (pit_min, 1);
    845     p_max2 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    846                       i, j, &max2, &rmax2, &r02, dtx);
    847 
    848     i = sub (j, 1);
    849     p_max3 = Lag_max (corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    850                       i, pit_min, &max3, &rmax3, &r03, dtx);
    851 #else
    852     j = shl (pit_min, 2);
    853     p_max1 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    854                       pit_max, j, &max1, dtx);
    855 
    856     i = sub (j, 1);
    857     j = shl (pit_min, 1);
    858     p_max2 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    859                       i, j, &max2, dtx);
    860 
    861     i = sub (j, 1);
    862     p_max3 = Lag_max (vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
    863                       i, pit_min, &max3, dtx);
    864 
    865     if (dtx)
    866     {  // no test() call since this if is only in simulation env
    867        if (sub(idx, 1) == 0)
    868        {
    869           // calculate max high-passed filtered correlation of all lags
    870           hp_max (corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max);
    871 
    872           // update complex background detector
    873           vad_complex_detection_update(vadSt, corr_hp_max);
    874        }
    875     }
    876 #endif
    877 
    878      *--------------------------------------------------------------------*
    879      * Compare the 3 sections maximum, and favor small lag.               *
    880      *--------------------------------------------------------------------*
    881 
    882     if (sub (mult (max1, THRESHOLD), max2) < 0)
    883     {
    884         max1 = max2;
    885         p_max1 = p_max2;
    886 #ifdef VAD2
    887         if (dtx)
    888         {
    889             rmax1 = rmax2;
    890             r01 = r02;
    891 #endif
    892     }
    893     if (sub (mult (max1, THRESHOLD), max3) < 0)
    894     {
    895         p_max1 = p_max3;
    896 #ifdef VAD2
    897         if (dtx)
    898         {
    899             rmax1 = rmax3;
    900             r01 = r03;
    901         }
    902 #endif
    903     }
    904 
    905 #ifdef VAD2
    906     if (dtx)
    907     {
    908         vadSt->L_Rmax = L_add(vadSt->L_Rmax, rmax1);   // Save max correlation
    909         vadSt->L_R0 =   L_add(vadSt->L_R0, r01);        // Save max energy
    910     }
    911 #endif
    912 
    913     return (p_max1);
    914 }
    915 
    916 ------------------------------------------------------------------------------
    917  RESOURCES USED [optional]
    918 
    919  When the code is written for a specific target processor the
    920  the resources used should be documented below.
    921 
    922  HEAP MEMORY USED: x bytes
    923 
    924  STACK MEMORY USED: x bytes
    925 
    926  CLOCK CYCLES: (cycle count equation for this function) + (variable
    927                 used to represent cycle count for each subroutine
    928                 called)
    929      where: (cycle count variable) = cycle count for [subroutine
    930                                      name]
    931 
    932 ------------------------------------------------------------------------------
    933  CAUTION [optional]
    934  [State any special notes, constraints or cautions for users of this function]
    935 
    936 ------------------------------------------------------------------------------
    937 */
    938 
    939 Word16 Pitch_ol(       /* o   : open loop pitch lag                         */
    940     vadState *vadSt,   /* i/o : VAD state struct                            */
    941     enum Mode mode,    /* i   : coder mode                                  */
    942     Word16 signal[],   /* i   : signal used to compute the open loop pitch  */
    943     /*    signal[-pit_max] to signal[-1] should be known */
    944     Word16 pit_min,    /* i   : minimum pitch lag                           */
    945     Word16 pit_max,    /* i   : maximum pitch lag                           */
    946     Word16 L_frame,    /* i   : length of frame to compute pitch            */
    947     Word16 idx,        /* i   : frame index                                 */
    948     Flag dtx,          /* i   : dtx flag; use dtx=1, do not use dtx=0       */
    949     Flag *pOverflow    /* i/o : overflow Flag                               */
    950 )
    951 {
    952     Word16 i;
    953     Word16 j;
    954     Word16 max1;
    955     Word16 max2;
    956     Word16 max3;
    957     Word16 p_max1;
    958     Word16 p_max2;
    959     Word16 p_max3;
    960     Word16 scal_flag = 0;
    961     Word32 t0;
    962 
    963 #ifdef VAD2
    964     Word32 r01;
    965     Word32 r02;
    966     Word32 r03;
    967     Word32 rmax1;
    968     Word32 rmax2;
    969     Word32 rmax3;
    970 #else
    971     Word16 corr_hp_max;
    972 #endif
    973     Word32 corr[PIT_MAX+1];
    974     Word32 *corr_ptr;
    975 
    976     /* Scaled signal */
    977 
    978     Word16 scaled_signal[L_FRAME + PIT_MAX];
    979     Word16 *scal_sig;
    980     Word16 *p_signal;
    981     Word16 scal_fac;
    982     Word32 L_temp;
    983 
    984 #ifndef VAD2
    985     if (dtx)
    986     {   /* no test() call since this if is only in simulation env */
    987         /* update tone detection */
    988         if ((mode == MR475) || (mode == MR515))
    989         {
    990             vad_tone_detection_update(vadSt, 1, pOverflow);
    991         }
    992         else
    993         {
    994             vad_tone_detection_update(vadSt, 0, pOverflow);
    995         }
    996     }
    997 #endif
    998 
    999 
   1000     t0 = 0L;
   1001     p_signal = &signal[-pit_max];
   1002 
   1003     for (i = -pit_max; i < L_frame; i++)
   1004     {
   1005         t0 += (((Word32) * (p_signal)) * *(p_signal)) << 1;
   1006         p_signal++;
   1007         if (t0 < 0)
   1008         {
   1009             t0 = MAX_32;
   1010             break;
   1011         }
   1012 
   1013     }
   1014 
   1015     /*--------------------------------------------------------*
   1016      * Scaling of input signal.                               *
   1017      *                                                        *
   1018      *   if Overflow        -> scal_sig[i] = signal[i]>>3     *
   1019      *   else if t0 < 1^20  -> scal_sig[i] = signal[i]<<3     *
   1020      *   else               -> scal_sig[i] = signal[i]        *
   1021      *--------------------------------------------------------*/
   1022 
   1023     /*--------------------------------------------------------*
   1024      *  Verification for risk of overflow.                    *
   1025      *--------------------------------------------------------*/
   1026 
   1027     scal_sig = &scaled_signal[0];
   1028     p_signal = &signal[-pit_max];
   1029 
   1030     if (t0 == MAX_32)     /* Test for overflow */
   1031     {
   1032 
   1033         for (i = (pit_max + L_frame) >> 1; i != 0; i--)
   1034         {
   1035             *(scal_sig++) = (Word16)(((Word32) * (p_signal++) >> 3));
   1036             *(scal_sig++) = (Word16)(((Word32) * (p_signal++) >> 3));
   1037         }
   1038 
   1039         if ((pit_max + L_frame) & 1)
   1040         {
   1041             *(scal_sig) = (Word16)(((Word32) * (p_signal) >> 3));
   1042         }
   1043 
   1044         scal_fac = 3;
   1045     }
   1046     else if (t0 < (Word32)1048576L)
   1047         /* if (t0 < 2^20) */
   1048     {
   1049         for (i = (pit_max + L_frame) >> 1; i != 0; i--)
   1050         {
   1051             *(scal_sig++) = (Word16)(((Word32) * (p_signal++) << 3));
   1052             *(scal_sig++) = (Word16)(((Word32) * (p_signal++) << 3));
   1053         }
   1054 
   1055         if ((pit_max + L_frame) & 1)
   1056         {
   1057             *(scal_sig) = (Word16)(((Word32) * (p_signal) << 3));
   1058         }
   1059         scal_fac = -3;
   1060     }
   1061     else
   1062     {
   1063 
   1064         memcpy(scal_sig, p_signal, (L_frame + pit_max)*sizeof(*signal));
   1065         scal_fac = 0;
   1066     }
   1067 
   1068     /* calculate all coreelations of scal_sig, from pit_min to pit_max */
   1069     corr_ptr = &corr[pit_max];
   1070 
   1071     scal_sig = &scaled_signal[pit_max];
   1072 
   1073     comp_corr(scal_sig, L_frame, pit_max, pit_min, corr_ptr);
   1074 
   1075     /*--------------------------------------------------------------------*
   1076      *  The pitch lag search is divided in three sections.                *
   1077      *  Each section cannot have a pitch multiple.                        *
   1078      *  We find a maximum for each section.                               *
   1079      *  We compare the maximum of each section by favoring small lags.    *
   1080      *                                                                    *
   1081      *  First section:  lag delay = pit_max     downto 4*pit_min          *
   1082      *  Second section: lag delay = 4*pit_min-1 downto 2*pit_min          *
   1083      *  Third section:  lag delay = 2*pit_min-1 downto pit_min            *
   1084      *--------------------------------------------------------------------*/
   1085 
   1086     /* mode dependent scaling in Lag_max */
   1087 
   1088     if (mode == MR122)
   1089     {
   1090         scal_flag = 1;
   1091     }
   1092     else
   1093     {
   1094         scal_flag = 0;
   1095     }
   1096 
   1097 #ifdef VAD2
   1098     L_temp = ((Word32)pit_min) << 2;
   1099     if (L_temp != (Word32)((Word16) L_temp))
   1100     {
   1101         *pOverflow = 1;
   1102         j = (pit_min > 0) ? MAX_16 : MIN_16;
   1103     }
   1104     else
   1105     {
   1106         j = (Word16)L_temp;
   1107     }
   1108 
   1109     p_max1 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1110                      pit_max, j, &max1, &rmax1, &r01, dtx, pOverflow);
   1111 
   1112     i = j - 1;
   1113 
   1114     j = pit_min << 1;
   1115 
   1116     p_max2 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1117                      i, j, &max2, &rmax2, &r02, dtx, pOverflow);
   1118 
   1119     i = j - 1;
   1120 
   1121     p_max3 = Lag_max(corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1122                      i, pit_min, &max3, &rmax3, &r03, dtx, pOverflow);
   1123 
   1124 #else
   1125     L_temp = ((Word32)pit_min) << 2;
   1126     if (L_temp != (Word32)((Word16) L_temp))
   1127     {
   1128         *pOverflow = 1;
   1129         j = (pit_min > 0) ? MAX_16 : MIN_16;
   1130     }
   1131     else
   1132     {
   1133         j = (Word16)L_temp;
   1134     }
   1135 
   1136     p_max1 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1137                      pit_max, j, &max1, dtx, pOverflow);
   1138 
   1139     i = j - 1;
   1140 
   1141 
   1142     j = pit_min << 1;
   1143 
   1144 
   1145     p_max2 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1146                      i, j, &max2, dtx, pOverflow);
   1147 
   1148     i = j - 1;
   1149     p_max3 = Lag_max(vadSt, corr_ptr, scal_sig, scal_fac, scal_flag, L_frame,
   1150                      i, pit_min, &max3, dtx, pOverflow);
   1151 
   1152     if (dtx)
   1153     {  /* no test() call since this if is only in simulation env */
   1154 
   1155         if (idx == 1)
   1156         {
   1157             /* calculate max high-passed filtered correlation of all lags */
   1158             hp_max(corr_ptr, scal_sig, L_frame, pit_max, pit_min, &corr_hp_max,
   1159                    pOverflow);
   1160 
   1161             /* update complex background detector */
   1162             vad_complex_detection_update(vadSt, corr_hp_max);
   1163         }
   1164     }
   1165 #endif
   1166 
   1167     /*--------------------------------------------------------------------*
   1168      * Compare the 3 sections maximum, and favor small lag.               *
   1169      *--------------------------------------------------------------------*/
   1170 
   1171     i =  mult(max1, THRESHOLD, pOverflow);
   1172 
   1173     if (i < max2)
   1174     {
   1175         max1 = max2;
   1176         p_max1 = p_max2;
   1177 
   1178 #ifdef VAD2
   1179         if (dtx)
   1180         {
   1181             rmax1 = rmax2;
   1182             r01 = r02;
   1183         }
   1184 #endif
   1185     }
   1186 
   1187     i =  mult(max1, THRESHOLD, pOverflow);
   1188 
   1189     if (i < max3)
   1190     {
   1191         p_max1 = p_max3;
   1192 
   1193 #ifdef VAD2
   1194         if (dtx)
   1195         {
   1196             rmax1 = rmax3;
   1197             r01 = r03;
   1198         }
   1199 #endif
   1200     }
   1201 
   1202 #ifdef VAD2
   1203     if (dtx)
   1204     {
   1205         /* Save max correlation */
   1206         vadSt->L_Rmax = L_add(vadSt->L_Rmax, rmax1, pOverflow);
   1207         /* Save max energy */
   1208         vadSt->L_R0 =   L_add(vadSt->L_R0, r01, pOverflow);
   1209     }
   1210 #endif
   1211 
   1212     return (p_max1);
   1213 }
   1214