acelp_cp.c

语音编码G.729 语音编码G.729

/*
   ITU-T G.729 Annex C+ - Reference C code for floating point
                         implementation of G.729 Annex C+
                         (integration of Annexes B, D and E)
                         Version 2.1 of October 1999
*/

/*
 File : ACELP_CP.C
*/

/*****************************************************************************/
/* fixed codebook encoding routines  for 11.8, 8 and 6.4 kbit/s              */
/*****************************************************************************/
#include <math.h>
#include <stdlib.h>

#include "typedef.h"
#include "ld8k.h"
#include "ld8cp.h"
#include "tabld8cp.h"

/* prototypes of local functions */
static void cor_h_cp(
    FLOAT *H,         /* (i)     :Impulse response of filters */
    FLOAT *rr,        /* (o)     :Correlations of H[]         */
    int   rate
);
static int d4i40_17(   /* (o)    : Index of pulses positions.               */
	FLOAT Dn[],        /* (i)    : Correlations between h[] and Xn[].       */
	FLOAT rr[],        /* (i)    : Correlations of impulse response h[].    */
	FLOAT h[],         /* (i)    : Impulse response of filters.             */
	FLOAT cod[],       /* (o)    : Selected algebraic codeword.             */
	FLOAT y[],         /* (o)    : Filtered algebraic codeword.             */
	int   *sign,       /* (o)    : Signs of 4 pulses.                       */
	int   i_subfr,     /* (i)    : subframe flag                            */
	int   *pextra
);

int ACELP_codebook(     /* (o)     :index of pulses positions    */
    FLOAT x[],            /* (i)     :Target vector                */
    FLOAT h[],            /* (i)     :Impulse response of filters  */
    int   t0,             /* (i)     :Pitch lag                    */
    FLOAT pitch_sharp,    /* (i)     :Last quantized pitch gain    */
    int i_subfr,          /* (i)     :Indicator of 1st subframe,   */
    FLOAT code[],         /* (o)     :Innovative codebook          */
    FLOAT y[],            /* (o)     :Filtered innovative codebook */
    int *sign,            /* (o)     :Signs of 4 pulses            */
	int *d4i40_17_extra
)
{
    int i, index;
    FLOAT dn[L_SUBFR];
    FLOAT rr[DIM_RR];
    
    /*----------------------------------------------------------------*
    * Include fixed-gain pitch contribution into impulse resp. h[]    *
    * Find correlations of h[] needed for the codebook search.        *
    *-----------------------------------------------------------------*/
    
    if(t0 < L_SUBFR) {
        for (i = t0; i < L_SUBFR; i++)
            h[i] += pitch_sharp * h[i-t0];
    }       
    cor_h_cp(h, rr, G729);
    
    /*----------------------------------------------------------------*
    * Compute correlation of target vector with impulse response.     *
    *-----------------------------------------------------------------*/
    
    cor_h_x(h, x, dn);      /* backward filtered target vector dn */
    
                            /*----------------------------------------------------------------*
                            * Find innovative codebook.                                       *
    *-----------------------------------------------------------------*/
    
    index = d4i40_17(dn, rr, h, code, y, sign, i_subfr, d4i40_17_extra);
    
    /*------------------------------------------------------*
    * - Add the fixed-gain pitch contribution to code[].    *
    *-------------------------------------------------------*/
    
    if(t0 < L_SUBFR) {
        for (i = t0; i < L_SUBFR; i++)
            code[i] += pitch_sharp * code[i-t0];
    }
    return index;
}

/*--------------------------------------------------------------------------*
*  Function  cor_h()                                                       *
*  ~~~~~~~~~~~~~~~~~                                                       *
* Compute  correlations of h[]  needed for the codebook search.            *
*--------------------------------------------------------------------------*/

static void cor_h_cp(
                     FLOAT *h,      /* (i) :Impulse response of filters */
                     FLOAT *rr,     /* (o) :Correlations of H[]         */
                     int   rate
                     )
{
    FLOAT *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
    FLOAT *rri0i1, *rri0i2, *rri0i3, *rri0i4;
    FLOAT *rri1i2, *rri1i3, *rri1i4;
    FLOAT *rri2i3, *rri2i4;
    
    FLOAT *p0, *p1, *p2, *p3, *p4;
    
    FLOAT *ptr_hd, *ptr_hf, *ptr_h1, *ptr_h2;
    FLOAT cor;
    int i, k, ldec, l_fin_sup, l_fin_inf;
    int lsym;
    
    /* Init pointers */
    rri0i0 = rr;
    rri1i1 = rri0i0 + NB_POS;
    rri2i2 = rri1i1 + NB_POS;
    rri3i3 = rri2i2 + NB_POS;
    rri4i4 = rri3i3 + NB_POS;
    rri0i1 = rri4i4 + NB_POS;
    rri0i2 = rri0i1 + MSIZE;
    rri0i3 = rri0i2 + MSIZE;
    rri0i4 = rri0i3 + MSIZE;
    rri1i2 = rri0i4 + MSIZE;
    rri1i3 = rri1i2 + MSIZE;
    rri1i4 = rri1i3 + MSIZE;
    rri2i3 = rri1i4 + MSIZE;
    rri2i4 = rri2i3 + MSIZE;
    
    /*------------------------------------------------------------*
    * Compute rri0i0[], rri1i1[], rri2i2[], rri3i3 and rri4i4[]  *
    *------------------------------------------------------------*/
    
    p0 = rri0i0 + NB_POS-1;   /* Init pointers to last position of rrixix[] */
    p1 = rri1i1 + NB_POS-1;
    p2 = rri2i2 + NB_POS-1;
    p3 = rri3i3 + NB_POS-1;
    p4 = rri4i4 + NB_POS-1;
    
    ptr_h1 = h;
    cor    = (F)0.0;
    for(i=0;  i<NB_POS; i++)
    {
        cor += *ptr_h1 * *ptr_h1; ptr_h1++;
        *p4-- = cor;
        
        cor += *ptr_h1 * *ptr_h1; ptr_h1++;
        *p3-- = cor;
        
        cor += *ptr_h1 * *ptr_h1; ptr_h1++;
        *p2-- = cor;
        
        cor += *ptr_h1 * *ptr_h1; ptr_h1++;
        *p1-- = cor;
        
        cor += *ptr_h1 * *ptr_h1; ptr_h1++;
        *p0-- = cor;
    }
    
    /*-----------------------------------------------------------------*
    * Compute elements of: rri2i3[], rri1i2[], rri0i1[] and rri0i4[]  *
    *-----------------------------------------------------------------*/
    
    l_fin_sup = MSIZE-1;
    l_fin_inf = l_fin_sup-1;
    ldec = NB_POS+1;
    
    ptr_hd = h;
    ptr_hf = ptr_hd + 1;
    
    for(k=0; k<NB_POS; k++) {
        
        p4=rri0i4+l_fin_sup;
        p3 = rri2i3 + l_fin_sup;
        p2 = rri1i2 + l_fin_sup;
        p1 = rri0i1 + l_fin_sup;
        p0 = rri0i4 + l_fin_inf;
        cor = (F)0.0;
        ptr_h1 = ptr_hd;
        ptr_h2 =  ptr_hf;
        
        for(i=k+1; i<NB_POS; i++ ) {
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            if (rate == G729D) *p4=cor;           
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p3 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p2 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p1 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            if (rate == G729) *p0 = cor;
            
            p4-=ldec;                                  
            p3 -= ldec;
            p2 -= ldec;
            p1 -= ldec;
            p0 -= ldec;
        }
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        if (rate == G729D) *p4=cor;
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p3 = cor;
        
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p2 = cor;
        
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p1 = cor;
        
        l_fin_sup -= NB_POS;
        l_fin_inf--;
        ptr_hf += STEP;
    }
    
    /*---------------------------------------------------------------------*
    * Compute elements of: rri2i4[], rri1i3[], rri0i2[], rri1i4[], rri0i3 *
    *---------------------------------------------------------------------*/
    
    ptr_hd = h;
    ptr_hf = ptr_hd + 2;
    l_fin_sup = MSIZE-1;
    l_fin_inf = l_fin_sup-1;
    for(k=0; k<NB_POS; k++) {
        
        p4 = rri2i4 + l_fin_sup;
        p3 = rri1i3 + l_fin_sup;
        p2 = rri0i2 + l_fin_sup;
        p1 = rri1i4 + l_fin_inf;
        p0 = rri0i3 + l_fin_inf;
        
        cor = (F)0.0;
        ptr_h1 = ptr_hd;
        ptr_h2 =  ptr_hf;
        for(i=k+1; i<NB_POS; i++ ) {
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p4 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p3 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p2 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p1 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p0 = cor;
            
            p4 -= ldec;
            p3 -= ldec;
            p2 -= ldec;
            p1 -= ldec;
            p0 -= ldec;
        }
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p4 = cor;
        
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p3 = cor;
        
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p2 = cor;
        
        l_fin_sup -= NB_POS;
        l_fin_inf--;
        ptr_hf += STEP;
    }
    
    /*----------------------------------------------------------------------*
    * Compute elements of: rri1i4[], rri0i3[], rri2i4[], rri1i3[], rri0i2  *
    *----------------------------------------------------------------------*/
    
    ptr_hd = h;
    ptr_hf = ptr_hd + 3;
    l_fin_sup = MSIZE-1;
    l_fin_inf = l_fin_sup-1;
    for(k=0; k<NB_POS; k++) {
        
        p4 = rri1i4 + l_fin_sup;
        p3 = rri0i3 + l_fin_sup;
        p2 = rri2i4 + l_fin_inf;
        p1 = rri1i3 + l_fin_inf;
        p0 = rri0i2 + l_fin_inf;
        
        ptr_h1 = ptr_hd;
        ptr_h2 =  ptr_hf;
        cor = (F)0.0;
        for(i=k+1; i<NB_POS; i++ ) {
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p4 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p3 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p2 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p1 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p0 = cor;
            
            p4 -= ldec;
            p3 -= ldec;
            p2 -= ldec;
            p1 -= ldec;
            p0 -= ldec;
        }
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p4 = cor;
        
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        *p3 = cor;
        
        l_fin_sup -= NB_POS;
        l_fin_inf--;
        ptr_hf += STEP;
    }
    
    /*----------------------------------------------------------------------*
    * Compute elements of: rri0i4[], rri2i3[], rri1i2[], rri0i1[]          *
    *----------------------------------------------------------------------*/
    
    ptr_hd = h;
    ptr_hf = ptr_hd + 4;
    l_fin_sup = MSIZE-1;
    l_fin_inf = l_fin_sup-1;
    for(k=0; k<NB_POS; k++) {
        
        if (rate == G729D)
            p3 = rri0i4 + l_fin_inf;
        else if (rate == G729)
            p3 = rri0i4 + l_fin_sup;
        p2 = rri2i3 + l_fin_inf;
        p1 = rri1i2 + l_fin_inf;
        p0 = rri0i1 + l_fin_inf;
        
        ptr_h1 = ptr_hd;
        ptr_h2 =  ptr_hf;
        cor = (F)0.;
        for(i=k+1; i<NB_POS; i++ ) {
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            if (rate == G729) *p3 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            if (rate == G729D) *p3 = cor;
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p2 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p1 = cor;
            
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p0 = cor;
            
            p3 -= ldec;
            p2 -= ldec;
            p1 -= ldec;
            p0 -= ldec;
        }
        cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
        if (rate == G729) *p3 = cor;
        
        l_fin_sup -= NB_POS;
        l_fin_inf--;
        ptr_hf += STEP;
    }
    
    /*----------------------------------------------------------------------*/  
    /* rri0i2 for i1 corr i1 */
    
    if (rate == G729D) {
        /* acf elements */
        p0 = rri0i2;                     
        for(k=0; k<NB_POS; k++) {
            *p0 = *rri1i1++;
            p0 += ldec;
        }
        ptr_hd = h;
        ptr_hf = ptr_hd + 5;
        l_fin_sup = MSIZE-1;
        l_fin_inf = l_fin_sup - NB_POS;
        lsym = 7;
        for (k=1; k < NB_POS; k++) {
            p0 = rri0i2+l_fin_inf;
            ptr_h1 = ptr_hd;
            ptr_h2 = ptr_hf;
            cor = (F)0.;
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
            *p0 = *(p0+lsym) = cor;
            p0 -= ldec;
            for(i=k+1; i<NB_POS; i++ ) {
                cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
                cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
                cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
                cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
                cor += *ptr_h1 * *ptr_h2; ptr_h1++; ptr_h2++;
                *p0 = *(p0+lsym) = cor;
                
                p0 -= ldec;
            }
            l_fin_inf -= NB_POS;
            ptr_hf += 5;
            lsym += 7;
        }     
    }
}

typedef struct pulse_info
{
	FLOAT psal;

	int d0, d1;
	FLOAT ps;
	FLOAT alp;

} pulse_info_t;

static void pulse_info_best(int indices[], int maxi, pulse_info_t pulses[], int npulses)
{
	int i, first, last;

	for (i = 0; i < npulses; ++i)
		indices[i] = i;

	for (first = 0, last = npulses; last > maxi; )