예제 #1
0
파일: dtx.c 프로젝트: CEPBEP/onion-phone
/*-----------------------------------------------------------*
* procedure cod_cng:                                        *
*           ~~~~~~~~                                        *
*   computes DTX decision                                   *
*   encodes SID frames                                      *
*   computes CNG excitation for encoder update              *
*-----------------------------------------------------------*/
void cod_cng(float * exc,	/* (i/o) : excitation array                     */
	     int pastVad,	/* (i)   : previous VAD decision                */
	     float * lsp_old_q,	/* (i/o) : previous quantized lsp               */
	     float * old_A,	/* (i/o) : last stable filter LPC coefficients  */
	     float * old_rc,	/* (i/o) : last stable filter Reflection coefficients. */
	     float * Aq,	/* (o)   : set of interpolated LPC coefficients */
	     int *ana,		/* (o)   : coded SID parameters                 */
	     float freq_prev[MA_NP][M],	/* (i/o) : previous LPS for quantization        */
	     int16_t * seed	/* (i/o) : random generator seed                */
    )
{
	int i;

	float curAcf[MP1];
	float bid[MP1];
	float curCoeff[MP1];
	float lsp_new[M];
	float *lpcCoeff;
	int cur_igain;
	float energyq;

	/* Update Ener */
	for (i = NB_GAIN - 1; i >= 1; i--) {
		ener[i] = ener[i - 1];
	}

	/* Compute current Acfs */
	calc_sum_acf(Acf, curAcf, NB_CURACF);

	/* Compute LPC coefficients and residual energy */
	if (curAcf[0] == (float) 0.) {
		ener[0] = (float) 0.;	/* should not happen */
	} else {
		ener[0] = levinsone(M, curAcf, curCoeff, bid, old_A, old_rc);
	}

	/* if first frame of silence => SID frame */
	if (pastVad != 0) {
		ana[0] = 1;
		count_fr0 = 0;
		nb_ener = 1;
		qua_Sidgain(ener, nb_ener, &energyq, &cur_igain);
	} else {
		nb_ener++;
		if (nb_ener > NB_GAIN)
			nb_ener = NB_GAIN;
		qua_Sidgain(ener, nb_ener, &energyq, &cur_igain);

		/* Compute stationarity of current filter   */
		/* versus reference filter                  */
		if (cmp_filt(RCoeff, curAcf, ener[0], THRESH1) != 0) {
			flag_chang = 1;
		}

		/* compare energy difference between current frame and last frame */
		if ((float) fabs(prev_energy - energyq) > (float) 2.0)
			flag_chang = 1;

		count_fr0++;
		if (count_fr0 < FR_SID_MIN) {
			ana[0] = 0;	/* no transmission */
		} else {
			if (flag_chang != 0) {
				ana[0] = 1;	/* transmit SID frame */
			} else {
				ana[0] = 0;
			}
			count_fr0 = FR_SID_MIN;	/* to avoid overflow */
		}
	}

	if (ana[0] == 1) {

		/* Reset frame count and change flag */
		count_fr0 = 0;
		flag_chang = 0;

		/* Compute past average filter */
		calc_pastfilt(pastCoeff, old_A, old_rc);
		calc_RCoeff(pastCoeff, RCoeff);

		/* Compute stationarity of current filter   */
		/* versus past average filter               */

		/* if stationary */
		/* transmit average filter => new ref. filter */
		if (cmp_filt(RCoeff, curAcf, ener[0], THRESH2) == 0) {
			lpcCoeff = pastCoeff;
		}

		/* else */
		/* transmit current filter => new ref. filter */
		else {
			lpcCoeff = curCoeff;
			calc_RCoeff(curCoeff, RCoeff);
		}

		/* Compute SID frame codes */
		az_lsp(lpcCoeff, lsp_new, lsp_old_q);	/* From A(z) to lsp */

		/* LSP quantization */
		lsfq_noise(lsp_new, lspSid_q, freq_prev, &ana[1]);

		prev_energy = energyq;
		ana[4] = cur_igain;
		sid_gain = tab_Sidgain[cur_igain];

	}

	/* end of SID frame case */
	/* Compute new excitation */
	if (pastVad != 0) {
		cur_gain = sid_gain;
	} else {
		cur_gain *= A_GAIN0;
		cur_gain += A_GAIN1 * sid_gain;
	}

	calc_exc_rand(cur_gain, exc, seed, FLAG_COD);

	int_qlpc(lsp_old_q, lspSid_q, Aq);
	for (i = 0; i < M; i++) {
		lsp_old_q[i] = lspSid_q[i];
	}

	/* Update sumAcf if fr_cur = 0 */
	if (fr_cur == 0) {
		update_sumAcf();
	}

	return;
}
예제 #2
0
void coder_ld8a(

				int ana[]                   /* output: analysis parameters */

)

{

	/* LPC coefficients */



	FLOAT Aq_t[(MP1)*2];         /* A(z) quantized for the 2 subframes   */

	FLOAT Ap_t[(MP1)*2];         /* A(z) with spectral expansion         */

	FLOAT *Aq, *Ap;              /* Pointer on Aq_t  and Ap_t            */



	/* Other vectors */



	FLOAT h1[L_SUBFR];           /* Impulse response h1[]              */

	FLOAT xn[L_SUBFR];           /* Target vector for pitch search     */

	FLOAT xn2[L_SUBFR];          /* Target vector for codebook search  */

	FLOAT code[L_SUBFR];         /* Fixed codebook excitation          */

	FLOAT y1[L_SUBFR];           /* Filtered adaptive excitation       */

	FLOAT y2[L_SUBFR];           /* Filtered fixed codebook excitation */

	FLOAT g_coeff[5];            /* Correlations between xn, y1, & y2:

								 <y1,y1>, <xn,y1>, <y2,y2>, <xn,y2>,<y1,y2>*/



	/* Scalars */



	int i, j, i_subfr;

	int T_op, T0, T0_min, T0_max, T0_frac;

	int index;

	FLOAT   gain_pit, gain_code;

	int     taming;



	/*------------------------------------------------------------------------*

	*  - Perform LPC analysis:                                               *

	*       * autocorrelation + lag windowing                                *

	*       * Levinson-durbin algorithm to find a[]                          *

	*       * convert a[] to lsp[]                                           *

	*       * quantize and code the LSPs                                     *

	*       * find the interpolated LSPs and convert to a[] for the 2        *

	*         subframes (both quantized and unquantized)                     *

	*------------------------------------------------------------------------*/

	{

		/* Temporary vectors */

		FLOAT r[MP1];                    /* Autocorrelations       */

		FLOAT rc[M];                     /* Reflexion coefficients */

		FLOAT lsp_new[M];                /* lsp coefficients       */

		FLOAT lsp_new_q[M];              /* Quantized lsp coeff.   */



		/* LP analysis */



		autocorr(p_window, M, r);             /* Autocorrelations */

		lag_window(M, r);                     /* Lag windowing    */

		levinson(r, Ap_t, rc);                /* Levinson Durbin  */

		az_lsp(Ap_t, lsp_new, lsp_old);       /* Convert A(z) to lsp */



		/* LSP quantization */



		qua_lsp(lsp_new, lsp_new_q, ana);

		ana += 2;                        /* Advance analysis parameters pointer */



		/*--------------------------------------------------------------------*

		* Find interpolated LPC parameters in all subframes                  *

		* The interpolated parameters are in array Aq_t[].                   *

		*--------------------------------------------------------------------*/



		int_qlpc(lsp_old_q, lsp_new_q, Aq_t);



		/* Compute A(z/gamma) */



		weight_az(&Aq_t[0],   GAMMA1, M, &Ap_t[0]);

		weight_az(&Aq_t[MP1], GAMMA1, M, &Ap_t[MP1]);



		/* update the LSPs for the next frame */



		copy(lsp_new,   lsp_old,   M);

		copy(lsp_new_q, lsp_old_q, M);

	}



	/*----------------------------------------------------------------------*

	* - Find the weighted input speech w_sp[] for the whole speech frame   *

	* - Find the open-loop pitch delay for the whole speech frame          *

	* - Set the range for searching closed-loop pitch in 1st subframe      *

	*----------------------------------------------------------------------*/



	residu(&Aq_t[0],   &speech[0],       &exc[0],       L_SUBFR);

	residu(&Aq_t[MP1], &speech[L_SUBFR], &exc[L_SUBFR], L_SUBFR);



	{

		FLOAT Ap1[MP1];



		Ap = Ap_t;

		Ap1[0] = (F)1.0;

		for(i=1; i<=M; i++)

			Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];

		syn_filt(Ap1, &exc[0], &wsp[0], L_SUBFR, mem_w, 1);



		Ap += MP1;

		for(i=1; i<=M; i++)

			Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];

		syn_filt(Ap1, &exc[L_SUBFR], &wsp[L_SUBFR], L_SUBFR, mem_w, 1);

	}





	/* Find open loop pitch lag for whole speech frame */



	T_op = pitch_ol_fast(wsp, L_FRAME);



	/* Range for closed loop pitch search in 1st subframe */



	T0_min = T_op - 3;

	if (T0_min < PIT_MIN) T0_min = PIT_MIN;

	T0_max = T0_min + 6;

	if (T0_max > PIT_MAX)

	{

		T0_max = PIT_MAX;

		T0_min = T0_max - 6;

	}



	/*------------------------------------------------------------------------*

	*          Loop for every subframe in the analysis frame                 *

	*------------------------------------------------------------------------*

	*  To find the pitch and innovation parameters. The subframe size is     *

	*  L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times.               *

	*     - find the weighted LPC coefficients                               *

	*     - find the LPC residual signal                                     *

	*     - compute the target signal for pitch search                       *

	*     - compute impulse response of weighted synthesis filter (h1[])     *

	*     - find the closed-loop pitch parameters                            *

	*     - encode the pitch delay                                           *

	*     - find target vector for codebook search                           *

	*     - codebook search                                                  *

	*     - VQ of pitch and codebook gains                                   *

	*     - update states of weighting filter                                *

	*------------------------------------------------------------------------*/



	Aq = Aq_t;    /* pointer to interpolated quantized LPC parameters */

	Ap = Ap_t;    /* pointer to weighted LPC coefficients             */



	for (i_subfr = 0;  i_subfr < L_FRAME; i_subfr += L_SUBFR)

	{

		/*---------------------------------------------------------------*

		* Compute impulse response, h1[], of weighted synthesis filter  *

		*---------------------------------------------------------------*/



		h1[0] = (F)1.0;

		set_zero(&h1[1], L_SUBFR-1);

		syn_filt(Ap, h1, h1, L_SUBFR, &h1[1], 0);



		/*-----------------------------------------------*

		* Find the target vector for pitch search:      *

		*----------------------------------------------*/



		syn_filt(Ap, &exc[i_subfr], xn, L_SUBFR, mem_w0, 0);



		/*-----------------------------------------------------------------*

		*    Closed-loop fractional pitch search                          *

		*-----------------------------------------------------------------*/



		T0 = pitch_fr3_fast(&exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max,

			i_subfr, &T0_frac);



		index = enc_lag3(T0, T0_frac, &T0_min, &T0_max, PIT_MIN, PIT_MAX,

			i_subfr);



		*ana++ = index;



		if (i_subfr == 0)

			*ana++ = parity_pitch(index);



		/*-----------------------------------------------------------------*

		*   - find filtered pitch exc                                     *

		*   - compute pitch gain and limit between 0 and 1.2              *

		*   - update target vector for codebook search                    *

		*   - find LTP residual.                                          *

		*-----------------------------------------------------------------*/



		syn_filt(Ap, &exc[i_subfr], y1, L_SUBFR, mem_zero, 0);



		gain_pit = g_pitch(xn, y1, g_coeff, L_SUBFR);



		/* clip pitch gain if taming is necessary */



		taming = test_err(T0, T0_frac);



		if( taming == 1){

			if (gain_pit > GPCLIP) {

				gain_pit = GPCLIP;

			}

		}



		for (i = 0; i < L_SUBFR; i++)

			xn2[i] = xn[i] - y1[i]*gain_pit;



		/*-----------------------------------------------------*

		* - Innovative codebook search.                       *

		*-----------------------------------------------------*/



		index = ACELP_code_A(xn2, h1, T0, sharp, code, y2, &i);



		*ana++ = index;           /* Positions index */

		*ana++ = i;               /* Signs index     */



		/*------------------------------------------------------*

		*  - Compute the correlations <y2,y2>, <xn,y2>, <y1,y2>*

		*  - Vector quantize gains.                            *

		*------------------------------------------------------*/



		corr_xy2(xn, y1, y2, g_coeff);

		*ana++ =qua_gain(code, g_coeff, L_SUBFR, &gain_pit, &gain_code,

			taming);



		/*------------------------------------------------------------*

		* - Update pitch sharpening "sharp" with quantized gain_pit  *

		*------------------------------------------------------------*/



		sharp = gain_pit;

		if (sharp > SHARPMAX) sharp = SHARPMAX;

		if (sharp < SHARPMIN) sharp = SHARPMIN;



		/*------------------------------------------------------*

		* - Find the total excitation                          *

		* - update filters' memories for finding the target    *

		*   vector in the next subframe  (mem_w0[])            *

		*------------------------------------------------------*/



		for (i = 0; i < L_SUBFR;  i++)

			exc[i+i_subfr] = gain_pit*exc[i+i_subfr] + gain_code*code[i];



		update_exc_err(gain_pit, T0);



		for (i = L_SUBFR-M, j = 0; i < L_SUBFR; i++, j++)

			mem_w0[j]  = xn[i] - gain_pit*y1[i] - gain_code*y2[i];



		Aq += MP1;           /* interpolated LPC parameters for next subframe */

		Ap += MP1;

	}



	/*--------------------------------------------------*

	* Update signal for next frame.                    *

	* -> shift to the left by L_FRAME:                 *

	*     speech[], wsp[] and  exc[]                   *

	*--------------------------------------------------*/



	copy(&old_speech[L_FRAME], &old_speech[0], L_TOTAL-L_FRAME);

	copy(&old_wsp[L_FRAME], &old_wsp[0], PIT_MAX);

	copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL);



	return;

}