cbsearch.c

AMR-NB 的编码实现,纯C, VC下建立工程即可用.

    set_sign(dn, dn_sign, dn2, 6);
    cor_h(h, dn_sign, rr);
    search_3i40_14BITS(dn, dn2, rr, codvec);
                                
    index = build_code_3i40_14BITS(codvec, dn_sign, code, h, y, sign);

  /*-----------------------------------------------------------------*
  * Compute innovation vector gain.                                 *
  * Include fixed-gain pitch contribution into code[].              *
  *-----------------------------------------------------------------*/

 
    if (T0 < L_CODE )
    {
       for (i = T0; i < L_CODE; i++) 
	{ 
          code[i] +=  (code[i - T0]* sharp >> 15 );   
       }
    }
    return index;

}

/*
********************************************************************************
*                         PRIVATE PROGRAM CODE
********************************************************************************
*/

/*************************************************************************
 *
 *  FUNCTION  search_3i40()
 *
 *  PURPOSE: Search the best codevector; determine positions of the 3 pulses
 *           in the 40-sample frame.
 *
 *************************************************************************/


static void search_3i40_14BITS(
    Word16 dn[],         /* i : correlation between target and h[] */
    Word16 dn2[],        /* i : maximum of corr. in each track.    */
    Word16 rr[][L_CODE], /* i : matrix of autocorrelation          */
    Word16 codvec[]      /* o : algebraic codebook vector          */
)
{


    Word16 i0, i1, i2;
    Word16 ix = 0; /* initialization only needed to keep gcc silent */
    Word16 ps = 0; /* initialization only needed to keep gcc silent */
    Word16 i, pos, track1, track2, ipos[NB_PULSE_3i40_14BITS];
    Word16 psk, ps0, ps1, sq, sq1;
    Word16 alpk, alp, alp_16;
    Word32 s, alp0, alp1;

   Word16 *pdn = dn, *pdn2 = dn2, *pcodvec = codvec;

    psk = -1;     
    alpk = 1;   
	
    pcodvec[0] = 0;  pcodvec[1] = 1;pcodvec[2] = 2;

    for (track1 = 1; track1 < 4; track1 += 2)
    {
       for (track2 = 2; track2 < 5; track2 += 2)
       {		
          /* fix starting position */

          ipos[0] = 0;       
          ipos[1] = track1;  
          ipos[2] = track2;  
          
          /*------------------------------------------------------------------*
           * main loop: try 3 tracks.                                         *
           *------------------------------------------------------------------*/
          
          for (i = 0; i < NB_PULSE_3i40_14BITS; i++)
          {
             /*----------------------------------------------------------------*
              * i0 loop: try 8 positions.                                      *
              *----------------------------------------------------------------*/
             
            
             for (i0 = ipos[0]; i0 < L_CODE; i0 += STEP)
             {
               
                if (pdn2[i0] >= 0)
                {
                   ps0  = pdn[i0]; 
                   alp0 = (rr[i0][i0]<<14);
                   
                   /*----------------------------------------------------------------*
                    * i1 loop: 8 positions.                                          *
                    *----------------------------------------------------------------*/
                   
                   sq = -1;         
                   alp = 1;         
                   ps = 0;           
                   ix = ipos[1];   
                
                   /* initialize 4 index for next loop. */
                   /*-------------------------------------------------------------------*
                    *  These index have low complexity address computation because      *
                    *  they are, in fact, pointers with fixed increment.  For example,  *
                    *  "rr[i0][i2]" is a pointer initialized to "&rr[i0][ipos[2]]"      *
                    *  and incremented by "STEP".                                       *
                    *-------------------------------------------------------------------*/
                   
                   
                   for (i1 = ipos[1]; i1 < L_CODE; i1 += STEP)
                   {
                      ps1 = ( ps0 + pdn[i1]);   /* idx increment = STEP */
                      
                      /* alp1 = alp0 + rr[i0][i1] + 1/2*rr[i1][i1]; */
                      
                      alp1 = alp0 +( rr[i1][i1]<<14); /* idx incr = STEP */
                      alp1 = alp1 +( rr[i0][i1]<<15); /* idx incr = STEP */

		       
                      sq1 = (ps1* ps1>>15 );
                      
                      alp_16 = (alp1+0x00008000)>>16 ;
                      
                      s =  (alp* sq1-  sq* alp_16)<< 1 ;
                      
                      
                      if (s > 0)
                      {
                         sq = sq1;     
                         ps = ps1;     
                         alp = alp_16;  
                         ix = i1;    
                      }
                   }
                   i1 = ix;            
                   
                   /*----------------------------------------------------------------*
                    * i2 loop: 8 positions.                                          *
                    *----------------------------------------------------------------*/
                   
                   ps0 = ps;         
                   alp0 = (alp<<14 );
                   
                   sq = -1;            
                   alp = 1;           
                   ps = 0;             
                   ix = ipos[2];        
                   
                   /* initialize 4 index for next loop (see i1 loop) */
                   
                  
                   for (i2 = ipos[2]; i2 < L_CODE; i2 += STEP)
                   {
                      ps1 = (ps0+pdn[i2]); /* index increment = STEP */
                      
                      /* alp1 = alp0 + rr[i0][i2] + rr[i1][i2] + 1/2*rr[i2][i2]; */
                      
                       alp1 = alp0 + (rr[i2][i2]<<12); /* idx incr = STEP */
                       alp1 = alp1 + (rr[i1][i2]<<13);  /* idx incr = STEP */
                      alp1  = alp1 + (rr[i0][i2]<<13);  /* idx incr = STEP */
                      
                      sq1 =  (ps1*ps1 >> 15 );
                      
                      alp_16 = (alp1+0x00008000)>>16;
                      
                      s = (alp* sq1 -sq*alp_16)<<1 ;
                      
                     
                      if (s > 0)
                      {
                         sq = sq1;     
                         ps = ps1;      
                         alp = alp_16;  
                         ix = i2;       
                      }
                   }
                   i2 = ix;           
                   
                   /*----------------------------------------------------------------*
                    * memorise codevector if this one is better than the last one.   *
                    *----------------------------------------------------------------*/
                   
                   s = (alpk*sq - psk*alp)<< 1 ;
                   
                  
                   if (s > 0)
                   {
                      psk = sq;        
                      alpk = alp;       
                      pcodvec[0] = i0;   
                      pcodvec[1] = i1;   
                      pcodvec[2] = i2;  
                   }
                }
             }
             /*----------------------------------------------------------------*
              * Cyclic permutation of i0, i1 and i2.                           *
              *----------------------------------------------------------------*/
             
             pos = ipos[2];          
             ipos[2] = ipos[1];      
             ipos[1] = ipos[0];     
             ipos[0] = pos;          
          }
       }
    }    
    


    return;
}

/*************************************************************************
 *
 *  FUNCTION:  build_code()
 *
 *  PURPOSE: Builds the codeword, the filtered codeword and index of the
 *           codevector, based on the signs and positions of 3 pulses.
 *
 *************************************************************************/

static Word16
build_code_3i40_14BITS(
    Word16 codvec[],  /* i : position of pulses                            */
    Word16 dn_sign[], /* i : sign of pulses                                */
    Word16 cod[],     /* o : innovative code vector                        */
    Word16 h[],       /* i : impulse response of weighted synthesis filter */
    Word16 y[],       /* o : filtered innovative code                      */
    Word16 sign[]     /* o : sign of 3 pulses                              */
)
{


    Word16 i, j, k, track, index, _sign[NB_PULSE_3i40_14BITS], indx, rsign;
    Word16 *p0, *p1, *p2;
 

    Word16 *pcodvec = codvec, *pdn_sign = dn_sign, *pcod = cod, *ph = h, *py = y, *psign = sign;


    memset(pcod , 0 , 80);
    indx = 0;              
    rsign = 0;             
    for (k = 0; k < NB_PULSE_3i40_14BITS; k++)
    {
       i = pcodvec[k];     
       j = pdn_sign[i];    
       
       index = (i* 6554>> 15);    /* index = pos/5 */
                                 /* track = pos%5 */
       track = i - (Word16)(index*5);
       
      
       if ( track ==  1)
          index <<= 4 ;
       else if (track == 2)
       {
         
          track = 2;                      
          index <<= 8 ;
       }
       else if ( track ==  3)
       {
         
          track = 1;                              
          index = (index<<4)+  8;
       }
       else if (track ==  4)
       {
         
          track = 2;                         
          index = (index<< 8) +128;
       }
       
     
       if (j > 0)
       {
          pcod[i] = 8191;                      
          _sign[k] = 32767;                   
          rsign = rsign + (1<< track);
       } else {
          pcod[i] = -8192;                    
          _sign[k] = (Word16) - 32768L;       
       }
       
       indx += index;
    }
    *psign = rsign;                           

    p0 = ph - pcodvec[0];                       
    p1 = ph - pcodvec[1];                      
    p2 = ph - pcodvec[2];                      
    
    for (i = 0; i < L_CODE; i+=4 )
    {    
	py[i] = ( (((*p0++)* _sign[0] + (*p1++)* _sign[1]+ (*p2++)* _sign[2])<<1) + 0x00008000) >>16 ;     
	py[i+1] = ( (((*p0++)* _sign[0] + (*p1++)* _sign[1]+ (*p2++)* _sign[2])<<1) + 0x00008000) >>16 ;
	py[i+2] = ( (((*p0++)* _sign[0] + (*p1++)* _sign[1]+ (*p2++)* _sign[2])<<1) + 0x00008000) >>16 ;
	py[i+3] = ( (((*p0++)* _sign[0] + (*p1++)* _sign[1]+ (*p2++)* _sign[2])<<1) + 0x00008000) >>16 ;
    }
    
    return indx;


}


/*
********************************************************************************
*                         LOCAL VARIABLES AND TABLES
********************************************************************************
*/


/*
********************************************************************************
*                         DECLARATION OF PROTOTYPES
********************************************************************************
*/
static void search_4i40_17BITS(
    Word16 dn[],        /* i : correlation between target and h[]            */
    Word16 dn2[],       /* i : maximum of corr. in each track.               */
    Word16 rr[][L_CODE],/* i : matrix of autocorrelation                     */
    Word16 codvec[]     /* o : algebraic codebook vector                     */
);

static Word16 build_code_4i40_17BITS(   
    Word16 codvec[],    /* i : algebraic codebook vector                     */
    Word16 dn_sign[],   /* i : sign of dn[]                                  */
    Word16 cod[],       /* o : algebraic (fixed) codebook excitation         */
    Word16 h[],         /* i : impulse response of weighted synthesis filter */
    Word16 y[],         /* o : filtered fixed codebook excitation            */
    Word16 sign[]       /* o : index of 4 pulses (position+sign+ampl)*4      */
);


/*
********************************************************************************
*                         PUBLIC PROGRAM CODE
********************************************************************************
*/
/*************************************************************************
 *
 *  FUNCTION:  code_4i40_17bits()
 *
 *  PURPOSE:  Searches a 17 bit algebraic codebook containing 4 pulses
 *            in a frame of 40 samples.
 *
 *  DESCRIPTION:
 *    The code length is 40, containing 4 nonzero pulses: i0...i3.
 *    All pulses can have two possible amplitudes: +1 or -1.
 *    Pulse i0 to i2 can have 8 possible positions, pulse i3 can have
 *    2x8=16 positions.
 *
 *       i0 :  0, 5, 10, 15, 20, 25, 30, 35.
 *       i1 :  1, 6, 11, 16, 21, 26, 31, 36.
 *       i2 :  2, 7, 12, 17, 22, 27, 32, 37.
 *       i3 :  3, 8, 13, 18, 23, 28, 33, 38.
 *             4, 9, 14, 19, 24, 29, 34, 39.
 *
 *************************************************************************/

Word16 code_4i40_17bits(
    Word16 x[],         /* i : target vector                                 */