acelp_cp.c

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

	{
		int i1, i2, cswaps;
		FLOAT avg;

		/* quickly sample the elements */
		for (avg = (F)0.0, i = first; i < last; i += 4)
			avg += pulses[indices[i]].psal;
		avg /= (last - first) >> 2;

		for (cswaps = 0, i1 = 0, i2 = last - 1; i1 < i2; ++i1)
		{
			while (i1 < i2 && pulses[indices[i1]].psal > avg)
				++i1;

			while (i1 < i2 && pulses[indices[i2]].psal <= avg)
				--i2;

			if (i1 < i2)
			{
				int t = indices[i2];
				indices[i2] = indices[i1];
				indices[i1] = t;
				++cswaps;
			}
		}

		if (!cswaps)
			break; /* nothing more to sort */
		
		if (i1 >= maxi)
			last = i1;
		else
			first = i1;
	}
}

/*----------------------------------------------------------------------------
* d4i40_17 - algebraic codebook search 17 bits; 4 pulses 40 sampleframe
*----------------------------------------------------------------------------
*/
static int d4i40_17(    /* output: pulse positions                          */
	FLOAT dn[],           /* input : backward filtered target vector          */
	FLOAT rr[],           /* input : autocorrelations of impulse response h[] */
	FLOAT h[],            /* input : impulse response of filters              */
	FLOAT cod[],          /* output: selected algebraic codeword              */
	FLOAT y[],            /* output: filtered algebraic codeword              */
	int   *signs,         /* output: signs of 4 pulses                        */
	int   i_subfr,        /* input : subframe flag                            */
	int   *pextra
)
{
/*
* The code length is 40, containing 4 nonzero pulses i0, i1, i2, i3.
* with pulse spacings of step = 5
* Each pulses can have 8 possible positions (positive or negative):
*
* i0 (+-1) : 0, 5, 10, 15, 20, 25, 30, 35
* i1 (+-1) : 1, 6, 11, 16, 21, 26, 31, 36
* i2 (+-1) : 2, 7, 12, 17, 22, 27, 32, 37
* i3 (+-1) : 3, 8, 13, 18, 23, 28, 33, 38
*            4, 9, 14, 19, 24, 29, 34, 39
*---------------------------------------------------------------------------
    */
    int   i0, i1, i2, i3, ip0, ip1, ip2, ip3;
    int   i, j, is2, time;
    FLOAT ps0, ps1, ps2, ps3, alp0, alp1, alp2, alp3;
    FLOAT ps3c, psc, alpha;
    FLOAT average, max0, max1, max2, thres;
    FLOAT p_sign[L_SUBFR];
    
    FLOAT *rri0i0, *rri1i1, *rri2i2, *rri3i3, *rri4i4;
    FLOAT *rri0i1, *rri0i2, *rri0i3, *rri0i4;
    FLOAT *rri1i2, *rri1i3, *rri1i4;
    FLOAT *rri2i3, *rri2i4;
    
    FLOAT *ptr_ri0i0, *ptr_ri1i1, *ptr_ri2i2, *ptr_ri3i3, *ptr_ri4i4;
    FLOAT *ptr_ri0i1, *ptr_ri0i2, *ptr_ri0i3, *ptr_ri0i4;
    FLOAT *ptr_ri1i2, *ptr_ri1i3, *ptr_ri1i4;
    FLOAT *ptr_ri2i3, *ptr_ri2i4;

    pulse_info_t pulses[NB_POS * NB_POS];
	pulse_info_t *pulse;
	int pinds[NB_POS * NB_POS];

    /* 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;
    
    /*-----------------------------------------------------------------------*
    * Reset max_time for 1st subframe.                                      *
    *-----------------------------------------------------------------------*
    */
    if (i_subfr == 0) *pextra = 30;
    
    /*----------------------------------------------------------------------*
    * Chose the signs of the impulses.                                      *
    *-----------------------------------------------------------------------*/
    
    for (i=0; i<L_SUBFR; i++)
    {
        if( dn[i] >= (F)0.0)
        {
            p_sign[i] = (F)1.0;
        }
        else {
            p_sign[i] = (F)-1.0;
            dn[i] = -dn[i];
        }
    }
    
    /*-------------------------------------------------------------------*
    * - Compute the search threshold after three pulses                 *
    *-------------------------------------------------------------------*/
    
    
    average  = dn[0] + dn[1] + dn[2];
    max0 = dn[0];
    max1 = dn[1];
    max2 = dn[2];
    for (i = 5; i < L_SUBFR; i+=STEP)
    {
        average += dn[i] + dn[i+1]+ dn[i+2];
        if (dn[i]   > max0) max0 = dn[i];
        if (dn[i+1] > max1) max1 = dn[i+1];
        if (dn[i+2] > max2) max2 = dn[i+2];
    }
    max0 += max1+max2;
    average  *= (F)0.125;         /* 1/8 */
    thres = average + (max0-average)*THRESHFCB;
    
    /*-------------------------------------------------------------------*
    * Modification of rrixiy to take into account signs.                *
    *-------------------------------------------------------------------*/
    ptr_ri0i1 = rri0i1;
    ptr_ri0i2 = rri0i2;
    ptr_ri0i3 = rri0i3;
    ptr_ri0i4 = rri0i4;
    
    for(i0=0; i0<L_SUBFR; i0+=STEP)
    {
        for(i1=1; i1<L_SUBFR; i1+=STEP) {
            *ptr_ri0i1 *= (p_sign[i0] * p_sign[i1]);
            ptr_ri0i1++;
            *ptr_ri0i2 *= (p_sign[i0] * p_sign[i1+1]);
            ptr_ri0i2++;
            *ptr_ri0i3 *= (p_sign[i0] * p_sign[i1+2]);
            ptr_ri0i3++;
            *ptr_ri0i4 *= (p_sign[i0] * p_sign[i1+3]);
            ptr_ri0i4++;
        }
    }
    
    ptr_ri1i2 = rri1i2;
    ptr_ri1i3 = rri1i3;
    ptr_ri1i4 = rri1i4;
    
    for(i1=1; i1<L_SUBFR; i1+=STEP)
    {
        for(i2=2; i2<L_SUBFR; i2+=STEP)
        {
            *ptr_ri1i2 *= (p_sign[i1] * p_sign[i2]);
            ptr_ri1i2++;
            *ptr_ri1i3 *= (p_sign[i1] * p_sign[i2+1]);
            ptr_ri1i3++;
            *ptr_ri1i4 *= (p_sign[i1] * p_sign[i2+2]);
            ptr_ri1i4++;
        }
    }
    
    ptr_ri2i3 = rri2i3;
    ptr_ri2i4 = rri2i4;
    
    for(i2=2; i2<L_SUBFR; i2+=STEP)
    {
        for(i3=3; i3<L_SUBFR; i3+=STEP)
        {
            *ptr_ri2i3 *= (p_sign[i2] * p_sign[i3]);
            ptr_ri2i3++;
            *ptr_ri2i4 *= (p_sign[i2] * p_sign[i3+1]);
            ptr_ri2i4++;
        }
    }
    
    /*-------------------------------------------------------------------*
    * Search the optimum positions of the four  pulses which maximize   *
    *     square(correlation) / energy                                  *
    * The search is performed in four  nested loops. At each loop, one  *
    * pulse contribution is added to the correlation and energy.        *
    *                                                                   *
    * The fourth loop is entered only if the correlation due to the     *
    *  contribution of the first three pulses exceeds the preset        *
    *  threshold.                                                       *
    *-------------------------------------------------------------------*/
    
    /* Default values */
    
    ip0    = 0;
    ip1    = 1;
    ip2    = 2;
    ip3    = 3;
    psc    = (F)0.0;
    alpha  = (F)1000000.0;
    time   = MAX_TIME + *pextra;
    
    ptr_ri0i0 = rri0i0;
    ptr_ri0i1 = rri0i1;

    for (i0 = 0, pulse = pulses; i0 < NB_POS; ++i0)        /* first pulse loop  */
    {
        ps0  = dn[i0 * STEP];
        alp0 = *ptr_ri0i0++;
        
        ptr_ri1i1 = rri1i1;    /* Init. pointers that depend on second loop */
        
        for (i1 = 0; i1 < NB_POS; ++i1, ++pulse)      /* second pulse loop */
        {
            ps1  = ps0  + dn[1 + i1 * STEP];
            alp1 = alp0 + *ptr_ri1i1++ + (F)2.0 * *ptr_ri0i1++;

			pulse->psal = ps1 * ps1 / alp1;
			
			pulse->d0 = i0;
			pulse->d1 = i1;
			pulse->ps = ps1;
			pulse->alp = alp1;
		}
	}
#define NBESTPULSES 40
	pulse_info_best(pinds, NBESTPULSES, pulses, NB_POS * NB_POS);


    /* Four loops to search innovation code. */
    /* Init. pointers that depend on first loop */
	//ptr_ri0i0 = rri0i0;
    //ptr_ri0i1 = rri0i1;
    //ptr_ri0i2 = rri0i2;
    //ptr_ri0i3 = rri0i3;
    //ptr_ri0i4 = rri0i4;

	/* iterate through part of sorted pulses */
    for (i = 0; i < NBESTPULSES; ++i)
    {
        int ofs0, ofs1;
		pulse_info_t spulses[NB_POS];
		pulse_info_t* sp;
		int spinds[NB_POS];
		int csps;

		pulse = pulses + pinds[i];

		i0 = pulse->d0 * STEP;
		i1 = 1 + pulse->d1 * STEP;

        ps1 = pulse->ps;
		alp1 = pulse->alp;

		/* Init all pointer states */
		ofs0 = pulse->d0 * NB_POS;
		//ptr_ri0i0 = rri0i0 + pulse->d0 + 1; dont care
		//ptr_ri0i1 = rri0i1 + pulse->d0 * NB_POS + pulse->d1 + 1; dont care;
		ptr_ri0i2 = rri0i2 + ofs0;
		ptr_ri0i3 = rri0i3 + ofs0;
		ptr_ri0i4 = rri0i4 + ofs0;

		ofs1 = pulse->d1 * NB_POS;
		//ptr_ri1i1 = rri1i1 + pulse->d1 + 1; dont care;
        ptr_ri1i2 = rri1i2 + ofs1;
        ptr_ri1i3 = rri1i3 + ofs1;
        ptr_ri1i4 = rri1i4 + ofs1;
        
        ptr_ri2i2 = rri2i2;     /* Init. pointers that depend on third loop */

#define NBESTPULSES2 6        
		for (i2 = 0, csps = 0, sp = spulses; i2 < NB_POS; ++i2)
        {
            ps2  = ps1  + dn[2 + i2 * STEP];
            alp2 = alp1 + *ptr_ri2i2++ + (F)2.0 * (*ptr_ri0i2++ + *ptr_ri1i2++);
            
            if (ps2 <= thres)
				continue;

			sp->psal = ps2 * ps2 / alp2;
			
			sp->d0 = i2;
			sp->ps = ps2;
			sp->alp = alp2;
			++sp;
			++csps;
		}

		if (!csps)
			continue;
		else if (csps > NBESTPULSES2)
		{
			pulse_info_best(spinds, NBESTPULSES2, spulses, csps);
			csps = NBESTPULSES2;
		}
		else
		{
			for (is2 = 0; is2 < csps; ++is2)
				spinds[is2] = is2;
		}

		for (is2 = 0; is2 < csps; ++is2)
        {
			sp = spulses + spinds[is2];
			i2 = 2 + sp->d0 * STEP;

			ps2  = sp->ps;
            alp2 = sp->alp;
            
			ptr_ri2i3 = rri2i3 + sp->d0 * NB_POS;
			ptr_ri2i4 = rri2i4 + sp->d0 * NB_POS;

            ptr_ri3i3 = rri3i3;    /* Init. pointers that depend on 4th loop */
            
            for (i3 = 3; i3 < L_SUBFR; i3 += STEP)
            {
                ps3 = ps2 + dn[i3];
                alp3 = alp2 + *ptr_ri3i3++ + (F)2.0*(*ptr_ri1i3++ + *ptr_ri0i3++ + *ptr_ri2i3++);
                
                ps3c = ps3*ps3;
                if( (ps3c*alpha) > (psc * alp3) )
                {
                    psc = ps3c;
                    alpha = alp3;
                    ip0 = i0;
                    ip1 = i1;
                    ip2 = i2;
                    ip3 = i3;
                }
            }  /*  end of for i3 = */
            
            ptr_ri0i3 -= NB_POS;
            ptr_ri1i3 -= NB_POS;
            
            ptr_ri4i4 = rri4i4;    /* Init. pointers that depend on 4th loop */
            
            for (i3 = 4; i3 < L_SUBFR; i3 += STEP)
            {
                ps3 = ps2 + dn[i3];
                alp3 = alp2 + *ptr_ri4i4++ + (F)2.0*(*ptr_ri1i4++ + *ptr_ri0i4++ + *ptr_ri2i4++);
                
                ps3c = ps3*ps3;
                if( (ps3c*alpha) > (psc * alp3) )
                {
                    psc = ps3c;
                    alpha = alp3;
                    ip0 = i0;
                    ip1 = i1;
                    ip2 = i2;
                    ip3 = i3;
                }
            }       /*  end of for i3 = */
            ptr_ri0i4 -= NB_POS;
            ptr_ri1i4 -= NB_POS;
            
            time--;
            if (time <= 0)
				goto end_search;     /* Maximum time finish */
            
        } /* end of for i2 = */
        
    } /* end of for i = */
    
end_search:
    
    *pextra = time;
    
    /* Find the codeword corresponding to the selected positions */
    
    for(i=0; i<L_SUBFR; i++) cod[i] = (F)0.0;
    cod[ip0] = p_sign[ip0];
    cod[ip1] = p_sign[ip1];
    cod[ip2] = p_sign[ip2];
    cod[ip3] = p_sign[ip3];
    
    /* find the filtered codeword */
    
    for (i = 0; i < L_SUBFR; i++) y[i] = (F)0.0;
    
    if(p_sign[ip0] > (F)0.0) {
        for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = h[j];
    }
    else {
        for(i=ip0, j=0; i<L_SUBFR; i++, j++) y[i] = -h[j];
    }   
    if(p_sign[ip1] > (F)0.0) {
        for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
    }
    else {
        for(i=ip1, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
    }
    if(p_sign[ip2] > (F)0.0) {
        for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
    }
    else {
        for(i=ip2, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
    }                       
    if(p_sign[ip3] > (F)0.0) {
        for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] + h[j];
    }
    else {
        for(i=ip3, j=0; i<L_SUBFR; i++, j++) y[i] = y[i] - h[j];
    }                           
    /* find codebook index;  4 bit signs + 13 bit positions */
    
    i = 0;
    if(p_sign[ip0] > (F)0.0) i+=1;
    if(p_sign[ip1] > (F)0.0) i+=2;
    if(p_sign[ip2] > (F)0.0) i+=4;
    if(p_sign[ip3] > (F)0.0) i+=8;
    *signs = i;
    
    ip0 = ip0 / 5;
    ip1 = ip1 / 5;
    ip2 = ip2 / 5;
    j   = (ip3 % 5) - 3;
    ip3 = ( (ip3 / 5) << 1 ) + j;
    
    i = (ip0) + (ip1<<3) + (ip2<<6) + (ip3<<9);
    
    return i;
}