pitch_fr.c

来自「君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图」· C语言 代码 · 共 701 行 · 第 1/2 页

    if (sub(*t0_max, pitmax) > 0) {
        *t0_max = pitmax;                                  //move16();
        *t0_min = sub(*t0_max, delta_range);
    }
}

/*
********************************************************************************
*                         PUBLIC PROGRAM CODE
********************************************************************************
*/

/*************************************************************************
*
*  Function:   Pitch_fr_init
*  Purpose:    Allocates state memory and initializes state memory
*
**************************************************************************
*/
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;
}

/*************************************************************************
*
*  Function:   Pitch_fr_reset
*  Purpose:    Initializes state memory to zero
*
**************************************************************************
*/
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;
}

/*************************************************************************
*
*  Function:   Pitch_fr_exit
*  Purpose:    The memory used for state memory is freed
*
**************************************************************************
*/
void Pitch_fr_exit (Pitch_frState **state)
{

printf(" RangeT=%d, normT = %d,searchFracT=%d,Enc_lag6T=%d\n",
         RangeT,    normT,     searchFracT,   Enc_lag6T);
    if (state == NULL || *state == NULL)
        return;

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

    return;
}

/*************************************************************************
 *
 *  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.
 *
 *************************************************************************/
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;
int readyT, endT;

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

    max_frac_lag    = mode_dep_parm[mode].max_frac_lag;           //move16 ();
    flag3           = mode_dep_parm[mode].flag3;                  //move16 ();
    frac            = mode_dep_parm[mode].first_frac;             //move16 ();
    last_frac       = mode_dep_parm[mode].last_frac;              //move16 ();
    delta_int_low   = mode_dep_parm[mode].delta_int_low;          //move16 ();
    delta_int_range = mode_dep_parm[mode].delta_int_range;        //move16 ();
    
    delta_frc_low   = mode_dep_parm[mode].delta_frc_low;          //move16 ();
    delta_frc_range = mode_dep_parm[mode].delta_frc_range;        //move16 ();
    pit_min         = mode_dep_parm[mode].pit_min;                //move16 ();
    
    /*-----------------------------------------------------------------------*
     *                 decide upon full or differential search               *
     *-----------------------------------------------------------------------*/
    
    delta_search = 1;                                             //move16 ();
    
readyT = GetTimer2();
//    test (); test ();
    if ((i_subfr == 0) || (sub(i_subfr,L_FRAME_BY2) == 0)) {
      
        /* Subframe 1 and 3 */
      
//        test (); test (); test ();
        if (((sub(mode, MR475) != 0) && (sub(mode, 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 */         //move16 ();
            
            /* calculate index into T_op which contains the open-loop */
            /* pitch estimations for the 2 big subframes */
            
            frame_offset = 1;                                      //move16 ();
       //     test ();
            if (i_subfr == 0)
                frame_offset = 0;                                  //move16 ();
            
            /* 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);
    }

endT = GetTimer2();
  RangeT += (endT - readyT);
    /*-----------------------------------------------------------------------*
     *           Find interval to compute normalized correlation             *
     *-----------------------------------------------------------------------*/
readyT = GetTimer2();
    t_min = sub (t0_min, L_INTER_SRCH);
    t_max = add (t0_max, L_INTER_SRCH);

    corr = &corr_v[-t_min];                                        //move16 ();

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

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

endT = GetTimer2();
    normT += (endT - readyT);
    /*-----------------------------------------------------------------------*
     *                           Find integer pitch                          *
     *-----------------------------------------------------------------------*/

    max = corr[t0_min];                                            //move16 ();
    lag = t0_min;                                                  //move16 ();

    for (i = t0_min + 1; i <= t0_max; i++) {
        //test ();
        if (sub (corr[i], max) >= 0) {
            max = corr[i];                                         //move16 ();
            lag = i;                                               //move16 ();
        }
    }
readyT = GetTimer2();
    /*-----------------------------------------------------------------------*
     *                        Find fractional pitch                          *
     *-----------------------------------------------------------------------*/
//    test (); test ();
    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;                                                  //move16 ();
    }
    else {

        /* if differential search AND mode MR475 OR MR515 OR MR59 OR MR67   */
        /* then search fractional with 4 bits resolution           */
       
       //test (); test (); test (); test (); test (); 
       if ((delta_search != 0) &&
           ((sub (mode, MR475) == 0) ||
            (sub (mode, MR515) == 0) ||
            (sub (mode, MR59) == 0) ||
            (sub (mode, 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;                          //move16 ();
 //         test ();
          if ( sub( sub(tmp_lag, t0_min), 5) > 0)
             tmp_lag = add (t0_min, 5);
//          test ();
          if ( sub( sub(t0_max, tmp_lag), 4) > 0)
               tmp_lag = sub (t0_max, 4);
          
//          test (); test ();
          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) {
//             test ();
             /* limit search around T0 to the right side */
             frac = 0;                                            //move16 ();
             searchFrac (&lag, &frac, last_frac, corr, flag3);
          }
          else if (sub (lag, add(tmp_lag, 1)) == 0) {
//             test (); test ();
             /* limit search around T0 to the left side */
             last_frac = 0;                                       //move16 ();
             searchFrac (&lag, &frac, last_frac, corr, flag3);
          }
          else {
//             test (); test ();
             /* no fractional search */
             frac = 0;                                            //move16 ();
            }
       }
       else
          /* test the fractions around T0 */
          searchFrac (&lag, &frac, last_frac, corr, flag3);
    }
endT = GetTimer2();
    searchFracT += (endT - readyT);    
    /*-----------------------------------------------------------------------*
     *                           encode pitch                                *
     *-----------------------------------------------------------------------*/
    
readyT =GetTimer2();
//    test ();
    if (flag3 != 0) {       
       /* flag4 indicates encoding with 4 bit resolution;         */
       /* this is needed for mode MR475, MR515 and MR59           */
       
       flag4 = 0;                                                 //move16 ();
//       test (); test (); test (); test (); 
       if ( (sub (mode, MR475) == 0) ||
            (sub (mode, MR515) == 0) ||
            (sub (mode, MR59) == 0) ||
            (sub (mode, MR67) == 0) ) {
          flag4 = 1;                                              //move16 ();
       }
       
       /* encode with 1/3 subsample resolution */
       
       *ana_index = Enc_lag3(lag, frac, st->T0_prev_subframe,
                             t0_min, t0_max, delta_search, flag4); //move16 (); /* function result */

    }  
    else
    {
       /* encode with 1/6 subsample resolution */
       
       *ana_index = Enc_lag6(lag, frac, t0_min, delta_search); //move16 (); /* function result */
    }
endT = GetTimer2();
   Enc_lag6T += (endT - readyT);    
    /*-----------------------------------------------------------------------*
     *                          update state variables                       *
     *-----------------------------------------------------------------------*/
    
    st->T0_prev_subframe = lag;                                    //move16 ();
    
    /*-----------------------------------------------------------------------*
     *                      update output variables                          *
     *-----------------------------------------------------------------------*/
    
    *resu3    = flag3;                                             //move16 ();

    *pit_frac = frac;                                              //move16 ();

    return (lag);
}