#include "SamsungSolomonVoiceW_VADACC.h"





#if(FLAG_SELECT_C_DSP == 1)

#include "math.h"

extern FILE *fp_debug1, *fp_deg_2micBF[N_fp_2micBF_debuffiles];

extern FILE *fp_debug_acc_E_low, *fp_debug_acc_E_hig, *fp_debug_acc_E_rat, *fp_debug_acc__zcr, *fp_debug_acc_ticflag, *fp_debug_acc_txt;

extern FILE *fp_dbg_Tic_txt, *fp_dbg_Tic_pcm;

#endif





void SolomonVoiceWVADACCInit(VADACCStatus* VADACC_buf, SamsungSolomonVoiceWTxVADACCParam* VADACC_param, COMMONBUF* common_buf)

{

	short i, j;

	

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

	{

		VADACC_buf->XXacc[i] = 0;		

	}



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

	{

		VADACC_buf->VADACCmask[i] = 0;

		VADACC_buf->VADACCmaskEcho[i] = 0;

		VADACC_buf->NpsdAcc[i] = 4;

		VADACC_buf->NpsdEchoAcc[i] = 0;

		VADACC_buf->SNRpostAcc[i] = 4;		

		VADACC_buf->SNRpostPrevAcc[i] = 4;

		VADACC_buf->SNRprioAcc[i] = 4;

		VADACC_buf->Gwiener[i] = DVTX_MAX_16;		

		VADACC_buf->Gacc[i] = DVTX_MAX_16;

		VADACC_buf->Gechoacc[i] = DVTX_MAX_16;

	}



#if(FLAG_SELECT_C_DSP == 1)

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

	{	

		VADACC_buf->XaccLPF[i] = 0;

	}

#endif



	

	VADACC_buf->VADACCframe_Fast = 1;

	VADACC_buf->VADACCframe_Slow = 1;



	VADACC_buf->LogPwrXXacc_LF_AVG = 0;

}



void SolomonVoiceW_VADACC_ParamConfig(SamsungSolomonVoiceWTxVADACCParam* VADACC_param, SamsungSolomonVoiceWTxVADACCParam* param)

{

	

	VADACC_param->tmp = param->tmp;



	return;

}

#ifndef SolomonVoiceWVADACCVectorSmooting_OPT_DSP

void SolomonVoiceWVADACCVectorSmooting(int *invec, int *tmpvec, short N)

{

	short i;



	for (i = 1; i < N - 1; i++)

		tmpvec[i] = DVTXOP_L_mpy_ls(DVTXOP_L_add(invec[i - 1], DVTXOP_L_add(invec[i], invec[i + 1])), 10922);

	for (i = 1; i < N - 1; i++)

		invec[i] = tmpvec[i];



}

#else

void SolomonVoiceWVADACCVectorSmooting(int *invec, int *tmpvec, short N)

{

	short i;

    //N:22 i:1~20

	ae_int32x2 data1, data2, data3, tmpdata, tmpadd;

	ae_int64 tmp1, tmp2;

	ae_valign align_vec, align_inout, align_tmpout;

	ae_int32x2 *pvec, *pinout, *ptmpout;

	ae_int32x2 mask = AE_MOVDA32X2(0xfffffffe, 0xfffffffe);



	ae_int16x4 var = AE_MOVF16_FROMF64(AE_MOV64(0x0000000000002aaaLL));

	pvec = (ae_int32x2 *)&invec[0];

	align_vec = AE_LA64_PP(pvec);

	AE_LA32X2_IP(data3, align_vec, pvec);



	pinout = (ae_int32x2 *)&invec[1];

	align_inout = AE_ZALIGN64();



	ptmpout = (ae_int32x2 *)&tmpvec[1];

	align_tmpout = AE_ZALIGN64();



	for(i = 1; i < N - 1; i += 2)

	{

		data1 = data3;

		AE_LA32X2_IP(data3, align_vec, pvec);

		data2 = AE_SEL32_LH(data1, data3);

		tmpdata = AE_ADD32S(data1, data2);

		tmpadd = AE_ADD32S(tmpdata, data3);

		//DVTXOP_L_mpy_ls

		tmpadd = AE_AND32(tmpadd, mask);

		tmp1 = AE_MUL32X16_L0(tmpadd, var);

		tmp2 = AE_MUL32X16_H0(tmpadd, var);

		tmp1 = AE_SLAI64S(tmp1, 17);

		tmp2 = AE_SLAI64S(tmp2, 17);

		tmpdata = AE_TRUNCI32X2F64S(tmp2, tmp1,0);

		AE_SA32X2_IP(tmpdata, align_inout, pinout);

		AE_SA32X2_IP(tmpdata, align_tmpout, ptmpout);

	}

	AE_SA64POS_FP(align_inout, pinout);

	AE_SA64POS_FP(align_tmpout, ptmpout);

}

#endif

#ifdef FN_VADACC_multi_constant_OPT_DSP

void FN_VADACC_multi_constant(short *Xacc,short *Gacc,short FFT_HALFLEN)

{

	int i;

	ae_int16x4 Xdata1, Xdata2, Gdata, datamul, tmpdata1, tmpdata2;

	ae_valign align_X, align_G, align_out;

	ae_int16x4 *ptmpX, *ptmpG, *ptmpout;



	ptmpX = (ae_int16x4 *)&Xacc[0];

	ptmpG = (ae_int16x4 *)&Gacc[0];

	ptmpout = (ae_int16x4 *)&Xacc[0];

	align_X = AE_LA64_PP(ptmpX);

	align_G = AE_LA64_PP(ptmpG);

	align_out = AE_ZALIGN64();

	for(i = 0;i < DVTX_M_ACC_MAXFREQ/4; i++)

	{

		AE_LA16X4_IP(Xdata1, align_X, ptmpX);

		AE_LA16X4_IP(Xdata2, align_X, ptmpX);

		AE_LA16X4_IP(Gdata, align_G, ptmpG);

		tmpdata1 = Gdata;

		tmpdata2 = AE_SEL16_7362(tmpdata1, Gdata);

		datamul = AE_MULFP16X4RAS(Xdata1, tmpdata2);

		AE_SA16X4_IP(datamul, align_out, ptmpout);

		tmpdata2 = AE_SEL16_5410(tmpdata1, Gdata);//2323

		tmpdata1 = tmpdata2;//2323

		Gdata = AE_SEL16_7362(tmpdata1, tmpdata2);//2233

		datamul = AE_MULFP16X4RAS(Xdata2, Gdata);

		AE_SA16X4_IP(datamul, align_out, ptmpout);

	}

	AE_LA16X4_IP(Xdata1, align_X, ptmpX);

	AE_LA16X4_IP(Gdata, align_G, ptmpG);

	tmpdata1 = Gdata;

	tmpdata2 = AE_SEL16_7362(tmpdata1, Gdata);

	datamul = AE_MULFP16X4RAS(Xdata1, tmpdata2);

	AE_SA16X4_IP(datamul, align_out, ptmpout);

	tmpdata1 = AE_MOVDA16(1000);

	for(i = 0; i < (FFT_HALFLEN-DVTX_M_ACC_MAXFREQ)/2; i++)

	{

		AE_LA16X4_IP(Xdata1, align_X, ptmpX);

		datamul = AE_MULFP16X4RAS(Xdata1, tmpdata1);

		AE_SA16X4_IP(datamul, align_out, ptmpout);

	}

	AE_SA64POS_FP(align_out, ptmpout);

}

#endif

#ifdef FN_VADACC_freqmask_OPT_DSP

void FN_VADACC_freqmask_vector(int *XXacc, short *VADACCmask, int st, int end, int vshift, int value )

{

	int i,num;

	ae_int32x2 *pin;

	ae_int16x4 *pout;

	ae_valign align_in;

	ae_valign align_out;

	ae_int32x2 Ltmp1, Ltmp2, Ltmp3, Lvalue, Lset;

	ae_int16x4 tmp;

	xtbool2 bool2;

	int ValPwrBin;

	pin = (ae_int32x2 *)&XXacc[st];

	pout = (ae_int16x4 *)&VADACCmask[st];

	align_in = AE_LA64_PP(pin);

	align_out = AE_ZALIGN64();



	Lvalue = AE_MOVDA32(value);

	Lset = AE_MOVDA32(1);

	num = (end - st)/4;

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

	{

		AE_LA32X2_IP(Ltmp1, align_in, pin);

		Ltmp1 = AE_SLAA32S(Ltmp1,vshift);

		Ltmp2 = AE_ZERO32();

		bool2 = AE_LT32(Lvalue, Ltmp1);

		AE_MOVT32X2(Ltmp2, Lset, bool2);

		AE_LA32X2_IP(Ltmp1, align_in, pin);

		Ltmp1 = AE_SLAA32S(Ltmp1,vshift);

		Ltmp3 = AE_ZERO32();

		bool2 = AE_LT32(Lvalue, Ltmp1);

		AE_MOVT32X2(Ltmp3, Lset, bool2);

		tmp = AE_SEL16_6420(AE_MOVINT16X4_FROMINT32X2(Ltmp2),AE_MOVINT16X4_FROMINT32X2(Ltmp3));

		AE_SA16X4_IP(tmp, align_out, pout);

	}

	AE_SA64POS_FP(align_out, pout);

	for(i = st + num*4; i < end; i++)

	{

		ValPwrBin = DVTXOP_L_shl(XXacc[i], vshift);

		VADACCmask[i]     = ValPwrBin > value ? 1 : 0;

	}



}

#endif

#ifdef FN_VADACC_multi_OPT_DSP

void FN_VADACC_multi_function(short *Xacc, short Gacc_tic)

{

	int i;

	ae_int16x4 *pin, *pout;

	ae_valign align_in, align_out;

	ae_int16x4 tmp1,tmp2,tmp3;



	pin = (ae_int16x4 *)&Xacc[0];

	pout = (ae_int16x4 *)&Xacc[0];

	align_in = AE_LA64_PP(pin);

	align_out = AE_ZALIGN64();



	tmp3 = AE_MOVDA16(Gacc_tic);



	for(i = 0; i < DVTX_M_ACC_MID2FREQ; i+=2)

	{

		AE_LA16X4_IP(tmp1, align_in, pin);

		tmp2 = AE_MULFP16X4RAS(tmp1, tmp3);

		AE_SA16X4_IP(tmp2, align_out, pout);

	}

	AE_SA64POS_FP(align_out, pout);

}

#endif

#ifdef FN_VADACC_recursiveAVG_ls_vector_OPT_DSP

extern ae_int32x2 fx_SolomonVoice_recursiveAVG_ls_2_vector(ae_int32x2 OldVal, ae_int32x2 NewVal, ae_int16x4 beOld, ae_int16x4 beNew, short shift);

void FN_VADACC_recursiveAVG_ls_vector(int *NpsdEchoAcc, int *tmpvec, int *NpsdAcc, short *EchoPSDgain,short shift)

{

	int i;

	int tmpNpsdEchoAcc;

	ae_int16x4 LforgetOld, LforgetNew;

	ae_int32x2 Ltmp1, Ltmp2, Ltmp3;

	ae_int32x2 *pNpsdEchoAcc_in, *pNpsdEchoAcc_out, *ptmpvec, *pNpsdAcc_in,*pNpsdAcc_out;

	ae_valign align_NpsdEchoAcc_in, align_NpsdEchoAcc_out, align_tmpvec, align_NpsdAcc_in, align_NpsdAcc_out, align_EchoPSDgain;

	LforgetOld = LforgetNew = AE_MOVDA16(DVTX_WORD16_0_5);

	pNpsdEchoAcc_in = pNpsdEchoAcc_out = (ae_int32x2 *)&NpsdEchoAcc[0];

	ptmpvec = (ae_int32x2 *)&tmpvec[0];

	pNpsdAcc_in = pNpsdAcc_out = (ae_int32x2 *)&NpsdAcc[0];

	align_NpsdEchoAcc_in = AE_LA64_PP(pNpsdEchoAcc_in);

	align_NpsdEchoAcc_out = AE_ZALIGN64();

	align_NpsdAcc_in = AE_LA64_PP(pNpsdAcc_in);

	align_NpsdAcc_out = AE_ZALIGN64();

	align_tmpvec = AE_LA64_PP(ptmpvec);

	ae_int32x2 Lminset = AE_MOVDA32(4);

	int tmp1, tmp2;

	for(i = 0; i < DVTX_M_ACC_MAXFREQ; i+=2)

	{

		AE_LA32X2_IP(Ltmp1, align_NpsdEchoAcc_in, pNpsdEchoAcc_in);

		AE_LA32X2_IP(Ltmp2, align_tmpvec, ptmpvec);

		Ltmp3 = fx_SolomonVoice_recursiveAVG_ls_2_vector(Ltmp1, Ltmp2, LforgetOld, LforgetNew, shift);

		Ltmp3 = AE_MAX32(Ltmp3, Lminset);

		tmp1 = DVTXOP_L_mpy_ls(AE_MOVAD32_H(Ltmp3), EchoPSDgain[i]);

		tmp2 = DVTXOP_L_mpy_ls(AE_MOVAD32_L(Ltmp3), EchoPSDgain[i+1]);

		Ltmp3 = AE_MOVDA32X2(tmp1, tmp2);

		Ltmp1 = AE_SLAA32S(Ltmp3, 1);

		AE_SA32X2_IP(Ltmp1, align_NpsdEchoAcc_out, pNpsdEchoAcc_out);

		AE_LA32X2_IP(Ltmp2, align_NpsdAcc_in, pNpsdAcc_in);

		Ltmp3 = AE_MAX32(Ltmp1, Ltmp2);

		AE_SA32X2_IP(Ltmp3, align_NpsdAcc_out, pNpsdAcc_out);

	}

	AE_SA64POS_FP(align_NpsdEchoAcc_out, pNpsdEchoAcc_out);

	AE_SA64POS_FP(align_NpsdAcc_out, pNpsdAcc_out);

}

#endif









void FN_VADACC(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars)

{

	BFStatus*      BF_buf = &DVTX_ECNS_vars->BF_buf;

	FRAMEStatus*   FRAME_buf  = &DVTX_ECNS_vars->FRAME_buf;

	VADACCStatus*  VADACC_buf = &DVTX_ECNS_vars->VADACC_buf;

	AECStatus*     AEC_buf1   = &DVTX_ECNS_vars->AEC_Outer_buf_1;

	MixingStatus*     Mix_buf = &DVTX_ECNS_vars->Mix_buf;

	SamsungSolomonVoiceWTxFRAMEParam* Frame_param = Frame_param = &DVTX_ECNS_vars->FRAME_param;;

	



#if(FLAG_SELECT_C_DSP == 1)

	short *dbg_data_buffer_NSout;

	short dbg_acc[320] = { 0, };

	int dbg_tmp;

#endif



	short FFT_LEN, FFT_HALFLEN, i, BLK_NORM_Acc, forgetOld, forgetNew;	

	int PwrXXacc, LogPwrXXacc_HF, LogPwrXXacc_LF, THD_LogPwrXXacc_LF, LogPwrDiffVADonoff, LogPwrDiffVADonoffTHD, ValPwrBin, Ltmp;

	

	int LogPwrXXacc_ExtLF, THD_EchoMask;

	short Flag_UserVoiceOn, GainEchoMin;

	short *data_buffer_rx, BLK_NORM_rx, Q_Npsd;



	short *Xacc, *VADACCmask, *VADACCmaskEcho, *Gacc, *Gechoacc;

	int *XXacc, *NpsdAcc, *NpsdEchoAcc, *SNRpostAcc, *SNRpostPrevAcc, *SNRprioAcc, *Gwiener, *tmpvec;



	int	WND_strong_ON = Mix_buf->WND_strong_ON;

	

	short tic_flag = 0;

	short Gacc_tic = 32767;

	int Gacc_tic_L;

	int Thr_tic_high, Thr_tic_low;

	static int E_low_prev = 0;

	static short zcr_prev = 0;

	int E_low = 0;

	int E_high = 0;

	short E_ratio = 0;



	short f_h1, f_h2, f_v1;

	int E_h1, E_h2, E_v1;

	static short f_h1_prev = 0, harmonic = 0;



	short VADaccFixedTHD;

	

	Xacc = FRAME_buf->fftbuffer_Acc.data_buffer;

	BLK_NORM_Acc = FRAME_buf->fftbuffer_Acc.BLK_NORM;

	

	data_buffer_rx = FRAME_buf->fftbuf_RX_Outer.data_buffer;

	BLK_NORM_rx    = FRAME_buf->fftbuf_RX_Outer.BLK_NORM;



	XXacc = VADACC_buf->XXacc;

	VADACCmask = VADACC_buf->VADACCmask;

	VADACCmaskEcho = VADACC_buf->VADACCmaskEcho;

	NpsdAcc = VADACC_buf->NpsdAcc;	

	NpsdEchoAcc = VADACC_buf->NpsdEchoAcc;

	SNRpostAcc = VADACC_buf->SNRpostAcc;	

	SNRpostPrevAcc = VADACC_buf->SNRpostPrevAcc;

	SNRprioAcc= VADACC_buf->SNRprioAcc;

	Gwiener = VADACC_buf->Gwiener;

	Gacc = VADACC_buf->Gacc;

	Gechoacc = VADACC_buf->Gechoacc;

	

	tmpvec = DVTX_ECNS_vars->BF_buf.tmpvec256A;



	// WB/NB para setting

	if (DVTX_ECNS_vars->FRAME_param.TX_Outer_bandwidth == DVTX_FRM_LEN_WB)

	{

		FFT_LEN = DVTX_FFT_LEN_WB;

		FFT_HALFLEN = DVTX_FFT_HALFLEN_WB;

#if(FLAG_SELECT_C_DSP == 1)

		dbg_data_buffer_NSout = FRAME_buf->fftbuffer_Acc.dbg_data_buffer_NSout;

#endif

	}

	else

	{

		FFT_LEN = DVTX_FFT_LEN_NB;

		FFT_HALFLEN = DVTX_FFT_HALFLEN_NB;

	}

	

	/* ACC Power spectrum bin */

	fltfx_SolomonVoice_FFT_to_FFTpwr(XXacc, Xacc, FFT_HALFLEN);



	/* VAD frame  */

	PwrXXacc = 0;	

	for (i = 3; i < DVTX_M_ACC_MAXFREQ; i++) // 300Hz~Max 

	{

		PwrXXacc = DVTXOP_L_add(PwrXXacc, XXacc[i]); //Q.Q

	}

	//log_pwr = DVTXOP_10log10_l(pwr, Q); //Q23

	LogPwrXXacc_LF = DVTXOP_10log10_l(PwrXXacc, DVTXOP_sub(2* BLK_NORM_Acc + 1, 16)); //Q23

	LogPwrXXacc_LF = DVTXOP_L_sub(LogPwrXXacc_LF, 115569475); // log_pwr - DVTXOP_10log10_l(24/*28-4*/, 0)



	// Average : LogPwrXXacc_LF 

	if (VADACC_buf->LogPwrXXacc_LF_AVG > LogPwrXXacc_LF)

	{

		VADACC_buf->LogPwrXXacc_LF_AVG = DVTXOP_L_add(DVTXOP_L_mpy_ls(VADACC_buf->LogPwrXXacc_LF_AVG, DVTX_WORD16_0_8),

			DVTXOP_L_mpy_ls(LogPwrXXacc_LF, DVTX_WORD16_0_2));

	}

	else

	{

		VADACC_buf->LogPwrXXacc_LF_AVG = DVTXOP_L_add(DVTXOP_L_mpy_ls(VADACC_buf->LogPwrXXacc_LF_AVG, DVTX_WORD16_0_4),

			DVTXOP_L_mpy_ls(LogPwrXXacc_LF, DVTX_WORD16_0_6));

	}





	/*initial VAD for Fixed ACC THD */

	if(WND_strong_ON)

		THD_LogPwrXXacc_LF = THD_INI_VADACC_LOGPWR_XXACC_LF_WIND; //83.5*(2^23)

	else

		THD_LogPwrXXacc_LF = THD_INI_VADACC_LOGPWR_XXACC_LF; //78.0*2^23 -->82

	VADaccFixedTHD = LogPwrXXacc_LF > THD_LogPwrXXacc_LF ? 1 : 0;



	/*Variable VAD THD*/

	forgetOld = DVTX_WORD16_0_98;

	forgetNew = DVTX_WORD16_0_02;

	if (VADaccFixedTHD == 1)

		FRAME_buf->PwrSpeech_Accel_LF_VADon = DVTXOP_L_add(DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_LF_VADon, forgetOld), DVTXOP_L_mpy_ls(LogPwrXXacc_LF, forgetNew));

	else

		FRAME_buf->PwrSpeech_Accel_LF_VADoff = DVTXOP_L_add(DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_LF_VADoff, forgetOld), DVTXOP_L_mpy_ls(LogPwrXXacc_LF, forgetNew));







	if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_Free)

		forgetNew = 28500; //31128

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_52dBA)

		forgetNew = 28000;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_56dBA)

		forgetNew = 27500;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_60dBA)

		forgetNew = 27000;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_64dBA)

		forgetNew = 26500;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_68dBA)

		forgetNew = 26000;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_72dBA)

		forgetNew = 25500;

	else if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_76dBA)

		forgetNew = 25000;

	else // if (DVTX_ECNS_vars->Context_buf.CNTX_N_LEVEL == Noise_Extreme)

		forgetNew = 23000;//22937

	forgetOld = DVTXOP_sub(DVTX_MAX_16, forgetNew);



	THD_LogPwrXXacc_LF = DVTXOP_L_add(DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_LF_VADon, forgetOld), DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_LF_VADoff, forgetNew));

	THD_LogPwrXXacc_LF = DVTX_MIN(THD_LogPwrXXacc_LF, THD_VARIABLE_VADACC_LOGPWR_XXACC_LF_MAX); //83.5*(2^23)

	THD_LogPwrXXacc_LF = DVTX_MAX(THD_LogPwrXXacc_LF, THD_VARIABLE_VADACC_LOGPWR_XXACC_LF_MIN); //73*(2^23)



	/*VADACC*/

	if (WND_strong_ON)

		THD_LogPwrXXacc_LF = THD_INI_VADACC_LOGPWR_XXACC_LF_WIND; //83.5*(2^23)

	VADACC_buf->VADACCframe_Fast = LogPwrXXacc_LF > THD_LogPwrXXacc_LF ? 1 : 0;

	VADACC_buf->VADACCframe_Slow = VADACC_buf->LogPwrXXacc_LF_AVG > THD_LogPwrXXacc_LF ? 1 : 0;



	/*user voice detection for DT*/

	PwrXXacc = 0;

	for (i = 3; i < 8; i++) // 300Hz~Max 

	{

		PwrXXacc = DVTXOP_L_add(PwrXXacc, XXacc[i]); //Q.Q

	}

	LogPwrXXacc_ExtLF = DVTXOP_10log10_l(PwrXXacc, DVTXOP_sub(2 * BLK_NORM_Acc + 1, 16)); //Q23

	LogPwrXXacc_ExtLF = DVTXOP_L_sub(LogPwrXXacc_ExtLF, 115569475); // log_pwr - DVTXOP_10log10_l(24/*28-4*/, 0)

	Flag_UserVoiceOn = LogPwrXXacc_ExtLF > THD_USERVOICEON_VADACC_LOGPWR_XXACC_EXTLF ? 1 : 0; //713031680=85*(2^23)



	

	/* Decision effective Acc state*/

	PwrXXacc = 0;

	for (i = 10; i < DVTX_M_ACC_MAXFREQ; i++) // 300Hz~Max 

	{

		PwrXXacc = DVTXOP_L_add(PwrXXacc, XXacc[i]); //Q.Q

	}

	//log_pwr = DVTXOP_10log10_l(pwr, Q); //Q23

	LogPwrXXacc_HF = DVTXOP_10log10_l(PwrXXacc, DVTXOP_sub(2 * BLK_NORM_Acc + 1, 16)); //Q23

	LogPwrXXacc_HF = DVTXOP_L_sub(LogPwrXXacc_HF, 115569475); // log_pwr - DVTXOP_10log10_l(24/*28-4*/, 0)

	

	

	/*Pwr Acc sig in speech interval*/

	forgetOld = DVTX_WORD16_0_98;

	forgetNew = DVTX_WORD16_0_02;	

	if (VADACC_buf->VADACCframe_Fast == 1)

		FRAME_buf->PwrSpeech_Accel_HF_VADon = DVTXOP_L_add(DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_HF_VADon, forgetOld), DVTXOP_L_mpy_ls(LogPwrXXacc_HF, forgetNew));

	else

		FRAME_buf->PwrSpeech_Accel_HF_VADoff = DVTXOP_L_add(DVTXOP_L_mpy_ls(FRAME_buf->PwrSpeech_Accel_HF_VADoff, forgetOld), DVTXOP_L_mpy_ls(LogPwrXXacc_HF, forgetNew));

	

	LogPwrDiffVADonoffTHD = THD_ACC_EFFECTIVE_LOGPWR_HF_AVG_DIFF_VADON_VADOFF; //8*2^23

	LogPwrDiffVADonoff = DVTXOP_L_sub(FRAME_buf->PwrSpeech_Accel_HF_VADon, FRAME_buf->PwrSpeech_Accel_HF_VADoff);

	FRAME_buf->STATE_ACC_Effective = LogPwrDiffVADonoff > LogPwrDiffVADonoffTHD ? 1 : 0;

	

	// abnormal acc sensor

	if((LogPwrXXacc_LF < THD_ACC_ABNORMAL_LOGPWR_XXACC_LF_MIN /*452984832=54*2^23*/)|| (FRAME_buf->PwrSpeech_Accel_HF_VADon < THD_ACC_ABNORMAL_LOGPWR_HF_AVG_MIN /*503316480 = 60*2^23*/))

	{

		FRAME_buf->STATE_ACC_Effective = 0;

		FRAME_buf->PwrSpeech_Accel_HF_VADon = LogPwrXXacc_HF;

		FRAME_buf->PwrSpeech_Accel_HF_VADoff = LogPwrXXacc_HF;	

	}





	

#ifndef FN_VADACC_freqmask_OPT_DSP

	/* VAD freq mask */

	for (i = 3; i < DVTX_M_ACC_MAXFREQ; i++) // for (i = fl; i <= fh; i++)

	{

		ValPwrBin = DVTXOP_L_shl(XXacc[i], 8 - (2 * BLK_NORM_Acc + 1));

		VADACCmask[i]     = ValPwrBin > 10000000 ? 1 : 0;		

	}

#else

	FN_VADACC_freqmask_vector(XXacc, VADACCmask, 3, DVTX_M_ACC_MAXFREQ, 8 - (2 * BLK_NORM_Acc + 1), 10000000);

#endif

	/* Noise suppression for Acc input :0 ~1kHz band */

	/* Noise PSD */

	Q_Npsd = 7;

	if (VADACC_buf->VADACCframe_Fast == 0)	

	{

		forgetOld = DVTX_WORD16_0_5;

		forgetNew = DVTX_WORD16_0_5;

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

		{			

			/*30,1 -> 15,16*/

			NpsdAcc[i] = fx_SolomonVoice_recursiveAVG_ls(NpsdAcc[i], XXacc[i], DVTX_WORD16_0_5, 16384, BLK_NORM_Acc, Q_Npsd);

			//NpsdAcc[i] = DVTXOP_L_mpy_ls(DVTXOP_L_shl(NpsdAcc[i], 1), 18000);			

			NpsdAcc[i] = DVTX_MAX(NpsdAcc[i], 4);

		}

	}

	/* Noise PSD avg  */

	SolomonVoiceWVADACCVectorSmooting(NpsdAcc, tmpvec, DVTX_M_ACC_MAXFREQ);



	if (1)//(AEC_buf1->Flag_RxVAD_AEC == 1) // echo suppression ACC

	{

		fx_SolomonVoice_FFT_to_FFTpwr(tmpvec, data_buffer_rx, DVTX_M_ACC_MAXFREQ);

		if(Flag_UserVoiceOn==1)

			THD_EchoMask = 600000;

		else

			THD_EchoMask =  600;

#ifndef FN_VADACC_freqmask_OPT_DSP

		for (i = 0; i < DVTX_M_ACC_MAXFREQ; i++) // for (i = fl; i <= fh; i++)

		{

			ValPwrBin = DVTXOP_L_shl(tmpvec[i], 8 - (2 * BLK_NORM_rx + 1));

			VADACCmaskEcho[i] = ValPwrBin > THD_EchoMask ? 1 : 0;

		}

#else

		FN_VADACC_freqmask_vector(tmpvec, VADACCmaskEcho, 0, DVTX_M_ACC_MAXFREQ, 8 - (2 * BLK_NORM_rx + 1), THD_EchoMask);

#endif

#ifndef FN_VADACC_recursiveAVG_ls_vector_OPT_DSP

		forgetOld = DVTX_WORD16_0_5;

		forgetNew = DVTX_WORD16_0_5;

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

		{

			NpsdEchoAcc[i] = fx_SolomonVoice_recursiveAVG_ls(NpsdEchoAcc[i], tmpvec[i], forgetOld, forgetNew, BLK_NORM_rx, Q_Npsd); //Q8			

			NpsdEchoAcc[i] = DVTX_MAX(NpsdEchoAcc[i], 4);

		}



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

		{

			NpsdEchoAcc[i] = DVTXOP_L_mpy_ls(NpsdEchoAcc[i], EchoPSDgain[i]); //Q8			

			NpsdEchoAcc[i] = DVTXOP_L_shl(NpsdEchoAcc[i], 1);



			NpsdAcc[i] = DVTX_MAX(NpsdAcc[i], NpsdEchoAcc[i]);

		}

#else

		FN_VADACC_recursiveAVG_ls_vector(NpsdEchoAcc, tmpvec, NpsdAcc, EchoPSDgain,Q_Npsd-2*BLK_NORM_rx);

#endif

	}

	



	/* SNRpost Q15 */

	//fx_SolomonVoice_postSNR_estimation(SNRpostAcc, XXacc, NpsdAcc, BLK_NORM_Acc, 32767, DVTX_M_ACC_MAXFREQ+1);

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

	{	

		SNRpostAcc[i] = divide(XXacc[i], (BLK_NORM_Acc*2+1), NpsdAcc[i], Q_Npsd+1, 15);//Q15		

	}

	

	/* SNRpost avg */

	SolomonVoiceWVADACCVectorSmooting(SNRpostAcc, tmpvec, DVTX_M_ACC_MAXFREQ);



	/* SNR priori Decision directed  */

	forgetOld = DVTX_WORD16_0_95; //31128=0.95 , 31456=0.96

	forgetNew = DVTX_WORD16_0_05;

#ifndef OVERFLOW_CHANGE

	fx_SolomonVoice_DD_SNRprio_estimation(SNRprioAcc, SNRprioAcc, SNRpostAcc, SNRpostPrevAcc, Gacc, forgetOld, forgetNew, 256, 4194304, DVTX_M_ACC_MAXFREQ + 1);//16.15	



	/* Wiener Filter */

	Ltmp = fx_SolomonVoice_Wiener_gainvector_Q31(Gwiener, SNRprioAcc, DVTX_M_ACC_MAXFREQ + 1, 0);//Gain=Q0.31, GainAVG=Q0.15

	fx_SolomonVoice_WienerQ31_to_GainQ15(Gacc, Gwiener, 3, DVTX_M_ACC_MAXFREQ + 1);

#else

	fx_SolomonVoice_DD_SNRprio_estimation(SNRprioAcc, SNRprioAcc, SNRpostAcc, SNRpostPrevAcc, Gacc, forgetOld, forgetNew, 256, 4194304, DVTX_M_ACC_MAXFREQ - 1);//16.15

	/* Wiener Filter */

	Ltmp = fx_SolomonVoice_Wiener_gainvector_Q31(Gwiener, SNRprioAcc, DVTX_M_ACC_MAXFREQ - 1, 0);//Gain=Q0.31, GainAVG=Q0.15

	fx_SolomonVoice_WienerQ31_to_GainQ15(Gacc, Gwiener, 3, DVTX_M_ACC_MAXFREQ - 1);

#endif



	/* NS filtering */

	Gacc[0] = 0;

	Gacc[1] = 1000;

	Gacc[2] = 2000;

	if (AEC_buf1->Flag_RxVAD_AEC == 1) // echo suppression ACC

	{

		if (Flag_UserVoiceOn == 1)

			GainEchoMin = 200;

		else

			GainEchoMin = 20;

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

		{

			if (VADACCmaskEcho[i] == 1)

			{

				Gacc[i] = GainEchoMin;

				Gacc[i-1] = GainEchoMin;

				Gacc[i+1] = GainEchoMin;

			}

		}	

	}

#ifndef	FN_VADACC_multi_constant_OPT_DSP

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

	{

		Xacc[2 * i] = DVTXOP_mult_r(Xacc[2 * i], Gacc[i]);

		Xacc[2 * i + 1] = DVTXOP_mult_r(Xacc[2 * i + 1], Gacc[i]);

	}

	for (i = DVTX_M_ACC_MAXFREQ; i < FFT_HALFLEN; i++) // fixed gain

	{

		Xacc[2 * i] = DVTXOP_mult_r(Xacc[2 * i], 1000);

		Xacc[2 * i + 1] = DVTXOP_mult_r(Xacc[2 * i + 1], 1000);

	}

#else

	FN_VADACC_multi_constant(Xacc,Gacc,FFT_HALFLEN);

#endif

	fltfx_SolomonVoice_FFT_to_FFTpwr(XXacc, Xacc, DVTX_M_ACC_MAXFREQ);













	// Tic detection

	if (AEC_buf1->Flag_RxVAD_AEC == 1)

	{

		E_low = 0;

		E_high = 0;

		f_h1 = 0;

		f_h2 = 0;

		f_v1 = 0;

		harmonic = 0;

		tic_flag = 0;

	}

	else

	{

		E_low = 0;

		E_high = 0;

		for (i = 3; i < DVTX_M_ACC_MIDFREQ; i++)

			E_low = DVTXOP_L_add(E_low, XXacc[i]); //Q.(2* BLK_NORM_Acc + 1)

		for (; i < DVTX_M_ACC_MAXFREQ; i++)

			E_high = DVTXOP_L_add(E_high, XXacc[i]); //Q.(2* BLK_NORM_Acc + 1)



		if (E_low > (long long)E_low_prev * 5)

			E_ratio = 1;

		else

			E_ratio = 0;



		E_low_prev = E_low;



		tic_flag = 0;



	/* harmonic detection */

	// find first harmonic freq f_h1

	f_h1 = 0;

	f_h2 = 0;

	for (i = 3; i < 16; i++)

	{

		if ((XXacc[i - 1] > 1000000/*60dB*/) && (XXacc[i] < (XXacc[i - 1] >> 1)))

		{

			f_h1 = i - 1;

			break;

		}

	}



	for (; i < 16; i++)

	{

		if (XXacc[i] > (XXacc[i - 1] << 1))

		{

			f_v1 = i - 1;

			break;

		}

	}

	

	// find second harmonic freq

	for (; i < 32; i++)

	{

		if ((XXacc[i - 1] > 1000000/*60dB*/) && (XXacc[i] < (XXacc[i - 1] >> 1)))

		{

			f_h2 = i - 1;

			break;

		}

	}

	

	if (((f_h2 + 1) > ((f_h1 + 1) << 1)) || ((f_h2 + 1) << 1) < ((f_h1 + 1) + ((f_h1 + 1) << 1)))

	{

		f_h1 = 0;

		f_h2 = 0;

	}



	// find first velley freq

	f_v1 = (((f_h1 + 1) + (f_h2 + 1)) >> 1) - 1;



	// peak, valley energy

	E_h1 = (XXacc[f_h1 - 1] > XXacc[f_h1]) ? XXacc[f_h1 - 1] : XXacc[f_h1];

	E_h1 = (XXacc[f_h1 + 1] > E_h1) ? XXacc[f_h1 + 1] : E_h1;

	E_h2 = (XXacc[f_h2 - 1] > XXacc[f_h2]) ? XXacc[f_h2 - 1] : XXacc[f_h2];

	E_h2 = (XXacc[f_h2 + 1] > E_h2) ? XXacc[f_h2 + 1] : E_h2;

	E_v1 = (XXacc[f_v1 - 1] < XXacc[f_v1]) ? XXacc[f_v1 - 1] : XXacc[f_v1];

	E_v1 = (XXacc[f_v1 + 1] < E_v1) ? XXacc[f_v1 + 1] : E_v1;



	// harmonic detection

	if (harmonic && (f_h1_prev - 2 < f_h1 || f_h1_prev + 2 < f_h1))

		harmonic = 1;

	else if (f_h1 < 3)

		harmonic = 0;

	else if ((E_h1 > (E_v1 << 2)) && (E_h2 > (E_v1 << 2)))

		harmonic = 1;

	else

		harmonic = 0;



	f_h1_prev = f_h1;



#if 0 //E-high -> Block de-norm

	Thr_tic = 64000;

	if (DVTXOP_L_shr(E_high, (2 * BLK_NORM_Acc + 1)) < Thr_tic)		tic_flag = 1;

#else //better

	//Thr_tic_high = 1000000;

	Thr_tic_high = 31622776;

	Thr_tic_low = 464158;

	//if ((E_high < Thr_tic_high) && (E_ratio == 1))		tic_flag = 1;

	//if ((E_low > Thr_tic_low) && (E_high < Thr_tic_high) && (E_ratio == 1))		tic_flag = 1;

	if ((E_low > Thr_tic_low) && (E_high < Thr_tic_high) && (harmonic == 0))		tic_flag = 1;

#endif



	// Tic suppression

	Gacc_tic_L = fx_SolomonVoice_32bit_Divide(E_high, E_low, 1, 0); //Q0.31

	Gacc_tic = int_sqrt_0_50(Gacc_tic_L);//Q0.15

	Gacc_tic = DVTXOP_mult_r(Gacc_tic, 27694>>2); /*sqrt(10/14)*/

	Gacc_tic = (Gacc_tic > 16384) ? 16384 : Gacc_tic;



	if (tic_flag == 1)

	{

#ifndef FN_VADACC_multi_OPT_DSP

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

		{

			Xacc[2 * i] = DVTXOP_mult_r(Xacc[2 * i], Gacc_tic);

			Xacc[2 * i + 1] = DVTXOP_mult_r(Xacc[2 * i + 1], Gacc_tic);

			}

#else

			FN_VADACC_multi_function(Xacc, Gacc_tic);



#endif

		}

	}



	/* DEBUG */

#if(FLAG_SELECT_C_DSP == 1)

#if(Debug_File_Write_C == 1)

	if (DVTX_ECNS_vars->FRAME_param.TX_Outer_bandwidth == DVTX_FRM_LEN_WB)

		for (i = 0; i < DVTX_FFT_LEN_WB; i++) dbg_data_buffer_NSout[i] = Xacc[i];



	fprintf(fp_dbg_Tic_txt, "%d, %d, %d, %d, %d, %d, %d\n", E_low, E_high, f_h1, f_h2, f_v1, harmonic, tic_flag);



	fprintf(fp_debug_acc_txt, "%f\n", (float)DVTXOP_L_shr(E_high, (2 * BLK_NORM_Acc + 1)));

	

	dbg_tmp = E_low/10000;

	dbg_tmp = (dbg_tmp > 32767) ? 32767 : dbg_tmp;	for (i = 0; i < 320; i++) dbg_acc[i] = (short)dbg_tmp;

	fwrite(dbg_acc, sizeof(short), 320, fp_debug_acc_E_low);



	dbg_tmp = E_high / 30000;

	dbg_tmp = (dbg_tmp > 32767) ? 32767 : dbg_tmp;	for (i = 0; i < 320; i++) dbg_acc[i] = (short)dbg_tmp;

	fwrite(dbg_acc, sizeof(short), 320, fp_debug_acc_E_hig);



	dbg_tmp = E_ratio * 100;

	dbg_tmp = (dbg_tmp > 32767) ? 32767 : dbg_tmp;	for (i = 0; i < 320; i++) dbg_acc[i] = (short)dbg_tmp;

	fwrite(dbg_acc, sizeof(short), 320, fp_debug_acc_E_rat);



	dbg_tmp = tic_flag * 16384;

	dbg_tmp = (dbg_tmp > 32767) ? 32767 : dbg_tmp;	for (i = 0; i < 320; i++) dbg_acc[i] = (short)dbg_tmp;

	fwrite(dbg_acc, sizeof(short), 320, fp_debug_acc_ticflag);



	dbg_tmp = 0;

	dbg_tmp = (dbg_tmp > 32767) ? 32767 : dbg_tmp;	for (i = 0; i < 320; i++) dbg_acc[i] = (short)dbg_tmp;

	fwrite(dbg_acc, sizeof(short), 320, fp_debug_acc__zcr);

	

	

	// debugNS 3

	fprintf(fp_deg_2micBF[9], "%ld %ld %ld %ld %ld %d %ld %ld %ld %ld %d\n", LogPwrXXacc_ExtLF, LogPwrXXacc_LF, VADACC_buf->LogPwrXXacc_LF_AVG, LogPwrXXacc_HF, THD_LogPwrXXacc_LF, VADACC_buf->VADACCframe_Slow,

		FRAME_buf->PwrSpeech_Accel_HF_VADoff, 

		FRAME_buf->PwrSpeech_Accel_HF_VADon,

		LogPwrDiffVADonoff,

		LogPwrDiffVADonoffTHD,

		FRAME_buf->STATE_ACC_Effective);



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

	{

		fprintf(fp_deg_2micBF[10], "%ld %d %d %ld %d %ld %ld %ld\n", NpsdEchoAcc[i], VADACCmaskEcho[i], VADACCmask[i], SNRprioAcc[i], Gacc[i], NpsdAcc[i], SNRpostAcc[i], DVTXOP_L_shl(XXacc[i], 8 - (2 * BLK_NORM_Acc + 1)));

	}

	

	

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

	{

		fprintf(fp_deg_2micBF[8], "%ld\n", DVTXOP_L_shl(XXacc[i], 8 - (2 * BLK_NORM_Acc + 1)));

	}



#endif

#endif



}









void FN_BACKGROUND_NOISE_CONTEXT_FROM_BF_NS_AEC_ACCELEROMETER(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars)

{

	FRAMEStatus*   FRAME_buf   = &DVTX_ECNS_vars->FRAME_buf;

	VADACCStatus*  VADACC_buf  = &DVTX_ECNS_vars->VADACC_buf;

	AECStatus*     AEC_buf1    = &DVTX_ECNS_vars->AEC_Outer_buf_1;

	MixingStatus*  Mix_buf     = &DVTX_ECNS_vars->Mix_buf;

	BFStatus*      BF_buf      = &DVTX_ECNS_vars->BF_buf;

	ContextStatus* Context_buf = & DVTX_ECNS_vars->Context_buf;

		

	int Ltmp;













	// context speech //

	if(Context_buf->CNTX_N_LEVEL < Noise_64dBA)

		FRAME_buf->STATE_Voice_Active = VADACC_buf->VADACCframe_Slow;

	else

		FRAME_buf->STATE_Voice_Active = VADACC_buf->VADACCframe_Fast;



	if (FRAME_buf->STATE_Voice_Active == 1)

	{

		if (BF_buf->LSTV_value_BF < DVTX_LTSV_MIN)

		{

			FRAME_buf->STATE_Voice_Active = 0;

		}

	}



	if (FRAME_buf->STATE_ACC_Effective == 1)

	{

		if (FRAME_buf->STATE_Voice_Active == 1)

			Context_buf->CNTX_VOICE_ACTIVE = Voice_Confirmed;

		else

			Context_buf->CNTX_VOICE_ACTIVE = Noise_Confirmed;

	}

	else

	{

		if (BF_buf->VAD_LTSVgsc_multiFlag == 0)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_0_Voice;

		else if (BF_buf->VAD_LTSVgsc_multiFlag == 1)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_1_Voice;

		else if (BF_buf->VAD_LTSVgsc_multiFlag == 2)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_2_Voice;

		else if (BF_buf->VAD_LTSVgsc_multiFlag == 3)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_3_Voice;

		else if (BF_buf->VAD_LTSVgsc_multiFlag == 4)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_4_Voice;

		else // if (BF_buf->VAD_LTSVgsc_multiFlag == 5)

			Context_buf->CNTX_VOICE_ACTIVE = Soft5step_5_Voice;

	}



	/*Noise context : variance*/

	if (VADACC_buf->VADACCframe_Slow == 0)

	{

		Ltmp = DVTX_MIN(BF_buf->LSTV_value_BF, DVTX_LTSV_MAX);



		if (Context_buf->CNTX_LTSV > Ltmp)

		{

			Context_buf->CNTX_LTSV = DVTXOP_L_add(DVTXOP_L_mpy_ls(Context_buf->CNTX_LTSV, DVTX_WORD16_0_9),

				DVTXOP_L_mpy_ls(Ltmp, DVTX_WORD16_0_1));

		}

		else

		{

			Context_buf->CNTX_LTSV = DVTXOP_L_add(DVTXOP_L_mpy_ls(Context_buf->CNTX_LTSV, DVTX_WORD16_0_99),

				DVTXOP_L_mpy_ls(Ltmp, DVTX_WORD16_0_01));

		}

	}





	

	/* NOISE CONTEXT*/

	// Context Noise Level

	if (FRAME_buf->PwrNoise_Npsdgsc > 100000000 ? 1 : 0) //10 ^ (80 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_Extreme;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 39810717 ? 1 : 0) //10 ^ (76 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_76dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 15848932 ? 1 : 0) //10 ^ (72 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_72dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 6309573 ? 1 : 0) //10 ^ (68 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_68dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 2511886 ? 1 : 0) //10 ^ (64 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_64dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 1000000 ? 1 : 0) //10 ^ (60 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_60dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 398107 ? 1 : 0) //10 ^ (56 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_56dBA;

	else if (FRAME_buf->PwrNoise_Npsdgsc > 158489 ? 1 : 0) //10 ^ (52 / 10)	

		Context_buf->CNTX_N_LEVEL = Noise_52dBA;

	else

		Context_buf->CNTX_N_LEVEL = Noise_Free;



	



	/*not used in the algorithm yet*/

	// from BF

	FRAME_buf->STATE_Mic_Abnormal = BF_buf->Flag_AbnormalMic; // not used in the algorithm yet



	// from NS

	FRAME_buf->STATE_Noise_Free = DVTX_ECNS_vars->AEC_Outer_buf_1.Flag_Tx_silent_mode;





	// MIC SWICHING FLAG

	if(FRAME_buf->PwrNoise_Npsdgsc > 0x3FFFFFFF)

		FRAME_buf->STATE_MIC_SWITCHING = 0x3FFFFFFF;

	else

		FRAME_buf->STATE_MIC_SWITCHING = FRAME_buf->PwrNoise_Npsdgsc;



	if (FRAME_buf->STATE_Mic_Abnormal)

		FRAME_buf->STATE_MIC_SWITCHING |= (1 << 31);





#if(FLAG_SELECT_C_DSP == 1)

#if(Debug_File_Write_C == 1)

	fprintf(fp_deg_2micBF[17], "%d %d %d %d %d %d %ld\n", 

		FRAME_buf->STATE_Mic_Abnormal,

		FRAME_buf->STATE_Noise_Free,

		FRAME_buf->STATE_Voice_Active,

		FRAME_buf->STATE_ACC_Effective,

		Context_buf->CNTX_N_LEVEL,

		Context_buf->CNTX_VOICE_ACTIVE,

		Context_buf->CNTX_LTSV



	);

#endif

#endif



	/* WIND CONTEXT*/



	/* ECHO CONTEXT*/



}