#include "Define_config.h"



#if(FLAG_SELECT_C_DSP == 1)

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#endif





#include "SamsungSolomonVoiceW.h"

#include "SamsungSolomonVoiceW_Int.h"

#include "SamsungSolomonVoiceW_Table.h"

#include "SamsungSolomonVoiceW_Default_functions.h"

#include "SamsungSolomonVoiceW_ANC.h"



int HPFcoeff[5] = { 1058936990, -2117873982, 1058936990, 2117669841, -1044336298 };

int WindHPFcoeff[5] = { 812904568, -1625809136, 812904568, 1561482161, -616394288 }; //1kHz HPF



void FFTBUF_init_NB(FFTBUF_NB *fftbuf)

{

	short i;



	fftbuf->PRE_EMP = 0;

	fftbuf->BLK_NORM = 0;

	fftbuf->NORM_PRV = 0;

#ifndef	KHW_OPTI_20191216_HIFI_new

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

	{

		fftbuf->data_buffer[i] = 0;

#if(FLAG_SELECT_C_DSP == 1)

		fftbuf->dbg_data_buffer_FNLMSin[i] = 0;

		fftbuf->dbg_data_buffer_FNLMSout[i] = 0;

		fftbuf->dbg_data_buffer_RESout[i] = 0;

		fftbuf->dbg_data_buffer_NSout[i] = 0;

#endif

	}

	for (i = 0; i < /*DVTX_M_FFT_LEN_NB*/DVTX_M_DELAY_NB; i++)

		fftbuf->WINDOW_OVERLAP[i] = 0;

#else

	__vec_memset(fftbuf->data_buffer, 0, (DVTX_M_FFT_LEN_NB << 1));

	__vec_memset(fftbuf->WINDOW_OVERLAP, 0, (DVTX_M_DELAY_NB << 1));

#endif





	return;

}



void FFTBUF_init_WB(FFTBUF_WB *fftbuf)

{

	short i;



	fftbuf->PRE_EMP = 0;

	fftbuf->BLK_NORM = 0;

	fftbuf->NORM_PRV = 0;



#ifndef	KHW_OPTI_20191216_HIFI_new

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

	{

		fftbuf->data_buffer[i] = 0;

#if(FLAG_SELECT_C_DSP == 1)

		fftbuf->dbg_data_buffer_FNLMSin[i] = 0;

		fftbuf->dbg_data_buffer_FNLMSout[i] = 0;

		fftbuf->dbg_data_buffer_RESout[i] = 0;

		fftbuf->dbg_data_buffer_NSout[i] = 0;

		

		fftbuf->dbg_data_buffer_BFfbf[i] = 0;

		fftbuf->dbg_data_buffer_BFbm[i] = 0;

		fftbuf->dbg_data_buffer_BFgsc[i] = 0;



#endif

	}



	for (i = 0; i < /*DVTX_M_FFT_LEN_WB*/DVTX_M_DELAY_WB; i++)

		fftbuf->WINDOW_OVERLAP[i] = 0;

#else

	__vec_memset(fftbuf->data_buffer, 0, (DVTX_M_FFT_LEN_WB << 1));

	__vec_memset(fftbuf->WINDOW_OVERLAP, 0, (DVTX_M_DELAY_WB << 1));

#endif

	return;

}



void IFFTBUF_init_WB(IFFTBUF_WB *Ifftbuf)

{

	short i;



	Ifftbuf->DE_EMP = 0;

#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < DVTX_M_FFT_LEN_WB - DVTX_M_FRM_LEN_WB; i++)

		Ifftbuf->OVERLAP[i] = 0;

#else

	__vec_memset(Ifftbuf->OVERLAP, 0, ((DVTX_M_FFT_LEN_WB - DVTX_M_FRM_LEN_WB) << 1));

#endif



	return;

}



void IFFTBUF_init_NB(IFFTBUF_NB *Ifftbuf)

{

	short i;



	Ifftbuf->DE_EMP = 0;

#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < DVTX_M_FFT_LEN_NB - DVTX_M_FRM_LEN_NB; i++)

		Ifftbuf->OVERLAP[i] = 0;

#else

	__vec_memset(Ifftbuf->OVERLAP, 0, ((DVTX_M_FFT_LEN_NB - DVTX_M_FRM_LEN_NB) << 1));

#endif



	return;

}



void SolomonVoiceWCommonBufInit(COMMONBUF* buf)

{

	short i;



	// Inner output

#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < SAMSUNGDIAMONDVOICEWIDEBAND_TX; i++)	{

		buf->Output_buf_Inner[i] = 0;

	}



	// common buffer

	for (i = 0; i < DVTX_M_FRM_LEN_NB; i++) {

		buf->Buff_L_NB[i] = 0;

		buf->Buff_L_NB2[i] = 0;

	}

	for (i = 0; i < DVTX_M_FFT_LEN_WB; i++) {

		buf->Buff_L_WB[i] = 0;

	}

#else

	__vec_memset(buf->Output_buf_Inner, 0, (SAMSUNGDIAMONDVOICEWIDEBAND_TX << 1));

	__vec_memset(buf->Buff_L_NB, 0, (DVTX_M_FRM_LEN_NB << 2));

	__vec_memset(buf->Buff_L_NB2, 0, (DVTX_M_FRM_LEN_NB << 2));

	__vec_memset(buf->Buff_L_WB, 0, (DVTX_M_FFT_LEN_WB << 2));

#endif

	// PreNS

	buf->Gmin = 32767;



#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < DVTX_M_FFT_HALFLEN_NB; i++) {

		buf->gL_EEii[i] = 0;

	}

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

		buf->gf0contourAvg[i] = 0;

	}

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

		buf->gtmpf0contour[i] = 0;

	}

#else

	__vec_memset(buf->gL_EEii, 0, (DVTX_M_FFT_HALFLEN_NB << 2));

	__vec_memset(buf->gf0contourAvg, 0, (DVTX_M_FFT_HALFLEN_WB << 1));

	__vec_memset(buf->gtmpf0contour, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_WB) << 1));

#endif

	// RES

#ifndef	KHW_OPTI_20191216_HIFI_new

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

		buf->gL_DDBin[i] = 0;

		buf->gL_EEBin[i] = 0;

		buf->gGpwrres[i] = 0;

		buf->gW_fnlms_reression[i] = 0;

		buf->gW_fnlms_reression2[i] = 0;

		buf->gG_fnlms[i] = 0;

	}

#else

	__vec_memset(buf->gL_DDBin, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 2));

	__vec_memset(buf->gL_EEBin, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 2));

	__vec_memset(buf->gGpwrres, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 1));

	__vec_memset(buf->gW_fnlms_reression, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 1));

	__vec_memset(buf->gW_fnlms_reression2, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 1));

	__vec_memset(buf->gG_fnlms, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 1));

#endif

	// AEC

#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < 2000 + 1000; i++) {

		buf->gRxFrm_Delay_AEC[i] = 0;

	}

	for (i = 0; i < DVTX_M_FRM_LEN_WB + DVTX_Nadf_MAX - 1 + DVTX_M_FRM_LEN_NB + DVTX_Nadf_MAX - 1; i++) {

		buf->gRxFrm_AECin_AEC[i] = 0;

	}

	for (i = 0; i < DVTX_M_FRM_LEN_WB + DVTX_M_FRM_LEN_NB; i++) {

		buf->gE_tx_AEC[i] = 0;

		buf->gE_tx_AECaux[i] = 0;

		buf->gRxFFTfrm_AEC[i] = 0;

		buf->gRxFFTfrm_clp_AEC[i] = 0;

	}



	// FrmVAD

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

		buf->gavg_ANC_sigPwr[i] = 0;

	}



	// ANC

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

		buf->gANC_sigPwr[i] = 0;

	}

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

	//	buf->gANC_sigPwr_inner[i] = 0;

	//}

	for (i = 0; i < DVTX_M_FFT_LEN_WB + DVTX_M_FFT_LEN_NB; i++) {

		buf->gEnhenced_Signal[i] = 0;

		buf->gANC_W_Filter[i] = 0;

	}



	// Mixing

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

		buf->ECNSbuff_L_EEBin_forMixing[i] = 0;

	}

#else

	__vec_memset(buf->gRxFrm_Delay_AEC, 0, (3000 << 1));

	__vec_memset(buf->gRxFrm_AECin_AEC, 0, ((DVTX_M_FRM_LEN_WB + DVTX_Nadf_MAX - 1 + DVTX_M_FRM_LEN_NB + DVTX_Nadf_MAX - 1) << 1));

	__vec_memset(buf->gE_tx_AEC, 0, ((DVTX_M_FRM_LEN_WB + DVTX_M_FRM_LEN_NB) << 1));

	__vec_memset(buf->gE_tx_AECaux, 0, ((DVTX_M_FRM_LEN_WB + DVTX_M_FRM_LEN_NB) << 1));

	__vec_memset(buf->gRxFFTfrm_AEC, 0, ((DVTX_M_FRM_LEN_WB + DVTX_M_FRM_LEN_NB) << 1));

	__vec_memset(buf->gRxFFTfrm_clp_AEC, 0, ((DVTX_M_FRM_LEN_WB + DVTX_M_FRM_LEN_NB) << 1));

	__vec_memset(buf->gavg_ANC_sigPwr, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 2));

	__vec_memset(buf->gANC_sigPwr, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 2));

	__vec_memset(buf->gEnhenced_Signal, 0, ((DVTX_M_FFT_LEN_WB + DVTX_M_FFT_LEN_NB) << 2));

	__vec_memset(buf->gANC_W_Filter, 0, ((DVTX_M_FFT_LEN_WB + DVTX_M_FFT_LEN_NB) << 1));

	__vec_memset(buf->ECNSbuff_L_EEBin_forMixing, 0, ((DVTX_M_FFT_HALFLEN_WB) << 2));

#endif

	// NS

	buf->gL_EEoo_07 = &buf->Buff_L_WB[DVTX_M_FFT_LEN_WB - (DVTX_M_FFT_HALFLEN_WB)];

	buf->gS_tmpfft1 = (short *)(&buf->Buff_L_WB[DVTX_M_FFT_LEN_WB - (DVTX_M_FFT_HALFLEN_WB >> 1)]);



#ifndef	KHW_OPTI_20191216_HIFI_new

	for (i = 0; i < DVTX_M_NUM_CHAN_WB; i++) {

		buf->ECNSbuff_L_SNR_by_Nmmse_ini[i] = 0;

		buf->ECNSbuff_L_SNR_by_Nmmse_global[i] = 0;



		buf->ECNSbuff_L_tmpvec[i] = 0;

		buf->ECNSbuff_L_tmpvec1[i] = 0;

		buf->ECNSbuff_S_tmpvec[i] = 0;

		buf->ECNSbuff_S_noise_floor[i] = 0;

		buf->ECNSbuff_S_spp_ns[i] = 0;



		buf->ECNSbuff_P_H1[i] = 0;

		buf->ECNSbuff_P_H1_GbyL[i] = 0;

		buf->ECNSbuff_L_SNR_by_Nmmse_ini_cepsmooth[i] = 0;

		buf->ECNSbuff_L_SNR_by_Nmmse_ini_cepsmooth_fix[i] = 0;

	}



	for (i = 0; i < DVTX_M_Nfft_ceps_WB; i++) {

		buf->ECNSbuff_tmpvec_ceps[i] = 0;

		buf->ECNSbuff_SNR_ini_ceps[i] = 0;

		buf->ECNSbuff_tmp_beta_ceps[i] = 0;

	}



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

		buf->gL_RRBin_step[i] = 0;

	}

#else

	__vec_memset(buf->ECNSbuff_L_SNR_by_Nmmse_ini, 0, ((DVTX_M_NUM_CHAN_WB) << 2));

	__vec_memset(buf->ECNSbuff_L_SNR_by_Nmmse_global, 0, ((DVTX_M_NUM_CHAN_WB) << 2));



	__vec_memset(buf->ECNSbuff_L_tmpvec, 0, ((DVTX_M_NUM_CHAN_WB) << 2));

	__vec_memset(buf->ECNSbuff_L_tmpvec1, 0, ((DVTX_M_NUM_CHAN_WB) << 2));

	__vec_memset(buf->ECNSbuff_S_tmpvec, 0, ((DVTX_M_NUM_CHAN_WB) << 1));

	__vec_memset(buf->ECNSbuff_S_noise_floor, 0, ((DVTX_M_NUM_CHAN_WB) << 1));

	__vec_memset(buf->ECNSbuff_S_spp_ns, 0, ((DVTX_M_NUM_CHAN_WB) << 1));



	__vec_memset(buf->ECNSbuff_P_H1, 0, ((DVTX_M_NUM_CHAN_WB) << 1));

	__vec_memset(buf->ECNSbuff_P_H1_GbyL, 0, ((DVTX_M_NUM_CHAN_WB) << 1));

	__vec_memset(buf->ECNSbuff_L_SNR_by_Nmmse_ini_cepsmooth, 0, ((DVTX_M_NUM_CHAN_WB) << 2));

	__vec_memset(buf->ECNSbuff_L_SNR_by_Nmmse_ini_cepsmooth_fix, 0, ((DVTX_M_NUM_CHAN_WB) << 2));



	__vec_memset(buf->ECNSbuff_tmpvec_ceps, 0, ((DVTX_M_Nfft_ceps_WB) << 1));

	__vec_memset(buf->ECNSbuff_SNR_ini_ceps, 0, ((DVTX_M_Nfft_ceps_WB) << 1));

	__vec_memset(buf->ECNSbuff_tmp_beta_ceps, 0, ((DVTX_M_Nfft_ceps_WB) << 1));

	__vec_memset(buf->gL_RRBin_step, 0, ((DVTX_M_FFT_HALFLEN_WB + DVTX_M_FFT_HALFLEN_NB) << 2));

#endif



	return;



}



void SolomonVoiceWFrameInit(FRAMEStatus* FRAME_buf, SamsungSolomonVoiceWTxFRAMEParam* FRAME_param, COMMONBUF* common_buf)

{

	short i;



	/**************** Buffers *****************/

	FRAME_buf->Flag_Tx_Clipping_Inner = 0;

	FRAME_buf->Flag_Tx_Clipping_Outer_1 = 0;

	FRAME_buf->Flag_Tx_Clipping_Outer_2 = 0;

#ifndef	KHW_OPTI_20191216_HIFI_new

	// back up inner NB input signal

	for (i = 0; i < DVTX_M_FFT_LEN_NB; i++) {

		FRAME_buf->FFTbuf_Tx_Inner_NB[i] = 0;

	}



	for (i = 0; i < DVTX_M_FFT_LEN_WB; i++) {

		FRAME_buf->FFTbuf_Tx_Outer_WB[i] = 0;

	}

#else

	__vec_memset(FRAME_buf->FFTbuf_Tx_Inner_NB, 0, ((DVTX_M_FFT_LEN_NB) << 1));

	__vec_memset(FRAME_buf->FFTbuf_Tx_Outer_WB, 0, ((DVTX_M_FFT_LEN_WB) << 1));

#endif

	// OLA

	FFTBUF_init_NB(&FRAME_buf->fftbuf_Inner);

	FFTBUF_init_NB(&FRAME_buf->fftbuf_RX_Inner);

	FFTBUF_init_NB(&FRAME_buf->fftbuf_RX2_Inner);

	//FFTBUF_init_WB(&FRAME_buf->fftbuf_Inner_WB);

	FFTBUF_init_WB(&FRAME_buf->fftbuf_Outer_1);

	FFTBUF_init_WB(&FRAME_buf->fftbuf_Outer_2);

	FFTBUF_init_WB(&FRAME_buf->fftbuf_RX_Outer);

//	FFTBUF_init_WB(&FRAME_buf->fftbuf_RX2_Outer);

	FFTBUF_init_WB(&FRAME_buf->fftbuf_Outer_1_WND);

	FFTBUF_init_WB(&FRAME_buf->fftbuf_Outer_2_WND);

		

	// OLA (NB mode)

	FFTBUF_init_NB(&FRAME_buf->fftbuf_Outer_NB);

	FFTBUF_init_NB(&FRAME_buf->fftbuf_RX_Outer_NB);

	//FFTBUF_init_NB(&FRAME_buf->fftbuf_RX2_Outer_NB);



	FFTBUF_init_WB(&FRAME_buf->fftbuffer_Acc);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_Acc);

		

	// IOLA

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_Output);

	//IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_Inner_WB);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_Outer_WB);



	IFFTBUF_init_NB(&FRAME_buf->Ifftbuf_Output_NB);



#if(FLAG_SELECT_C_DSP == 1)

	IFFTBUF_init_NB(&FRAME_buf->Ifftbuf_inner_FNLMSin);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_FNLMSin);

	IFFTBUF_init_NB(&FRAME_buf->Ifftbuf_inner_FNLMSout);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_FNLMSout);

	IFFTBUF_init_NB(&FRAME_buf->Ifftbuf_inner_RESout);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_RESout);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_acc_NSout);

	IFFTBUF_init_NB(&FRAME_buf->Ifftbuf_inner_NSout);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_NSout);



	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_BFfbf);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_BFbm);

	IFFTBUF_init_WB(&FRAME_buf->Ifftbuf_outer_BFgsc);

#endif

	FRAME_buf->L_EEBin_forMixing = common_buf->ECNSbuff_L_EEBin_forMixing;



	for (i = 0; i < 5; i++)	{

		FRAME_buf->HPFstateOuterTx_1[i] = 0;

		FRAME_buf->HPFstateOuterTx_2[i] = 0;

		FRAME_buf->HPFstateInnerTx[i] = 0;

		FRAME_buf->HPFstateOuterRx[i] = 0;

		FRAME_buf->HPFstateAccTx[i] = 0;

		FRAME_buf->WindHPFstateOuterTx_1[i] = 0;

		FRAME_buf->WindHPFstateOuterTx_2[i] = 0;

		

	}



	for (i = 0; i < 8; i++)	{

		FRAME_buf->Buf_Downsample_InnerRx[i] = 0;

		FRAME_buf->Buf_Downsample_InnerTx[i] = 0;

	}



	FRAME_buf->Pwr_1kHz_to_4kHz_Inner = 0;

	FRAME_buf->Pwr_100Hz_to_1kHz_Inner = 0;

	FRAME_buf->Pwr_1kHz_to_4kHz_Outer = 0;

	FRAME_buf->Pwr_100Hz_to_1kHz_Outer = 0;



	FRAME_buf->avg_ANC_sigPwr_Inner = &common_buf->gavg_ANC_sigPwr[DVTX_M_FFT_HALFLEN_WB];

	FRAME_buf->avg_ANC_sigPwr_Outer = common_buf->gavg_ANC_sigPwr;



	FRAME_buf->FrmPiLowBand_Inner = 0;

	FRAME_buf->FrmRioLowBand_Inner = 0;

	FRAME_buf->FrmPiLowBand_Outer = 0;

	FRAME_buf->FrmRioLowBand_Outer = 0;



	FRAME_buf->VariableTHD_Ratio_LowBandPwr = 2000;

	FRAME_buf->VariableTHD_THD_Pwr_inner = 1000;

	FRAME_buf->FrmDT_Inner = 0;

	FRAME_buf->FrmDT_Outer = 0;



	FRAME_buf->FrmVAD_Inner = 0;

	FRAME_buf->FrmVAD_Outer = 0;



	FRAME_buf->Avg_FrmPiLowBand = 1500;

	FRAME_buf->PtBuff_FrmPiLowBand = 0;



	

	/*context status Noise : ³ªÁß¿¡ context ±¸Á¶Ã¼·Î ÅëÇÕ ÇÒ °Í*/

	FRAME_buf->PwrNoise_Npsdgsc = 0;

	FRAME_buf->Flag_HighNoise_MixACC_MixNpsd = 0;

	

	/*context status Accelerometer : ³ªÁß¿¡ context ±¸Á¶Ã¼·Î ÅëÇÕ ÇÒ °Í*/

	FRAME_buf->PwrSpeech_Accel_HF_VADon = 75 << 23;

	FRAME_buf->PwrSpeech_Accel_HF_VADoff = 75 << 23;



	FRAME_buf->PwrSpeech_Accel_LF_VADon = 75 << 23;

	FRAME_buf->PwrSpeech_Accel_LF_VADoff = 75 << 23;

	

	FRAME_buf->STATE_ACC_Effective = 0;

	FRAME_buf->STATE_Noise_Free = 0;

	FRAME_buf->STATE_Mic_Abnormal = 0;

	FRAME_buf->STATE_Voice_Active = 0;

	

	FRAME_buf->CNXT_Mix_Weight_Mic = 0;



	FRAME_buf->PwrSpeech_Output = 0;

	FRAME_buf->PwrNoise_Output = 0;



	FRAME_buf->CNTX_Gain_TxSig_Out = 0;



	FRAME_buf->STATE_MIC_SWITCHING = 0;



#if 0 //#ifdef __EQ_HIGH_BAND_BOOSTING_NOISE_ENV__

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

	{

		FRAME_buf->CNTX_Variable_EQ[i] = DVTX_MAX_16;

	}

#endif



#if 0//#ifdef __USE_HIGH_RESOLUTION_NS__

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

	{

		FRAME_buf->XX_79BAND[i] = 0;

		FRAME_buf->NN_79BAND[i] = 0;

		FRAME_buf->SNRpost_79BAND[i] = 0;

		FRAME_buf->SNRpostPrev_79BAND[i] = 0;

		FRAME_buf->SNRprio_79BAND[i] = 0;

		FRAME_buf->Gain_79BAND[i] = 0;

	}

#endif





#ifndef	KHW_OPTI_20191216_HIFI_new

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

		FRAME_buf->Buff_FrmPiLowBand[i] = 0;

#else

	__vec_memset(FRAME_buf->Buff_FrmPiLowBand, 0, ((DVTX_NumFrm_MCRA_VAD) << 1));

#endif

	FRAME_buf->MinVal_FrmPiLowBand = 0;



	/****************Params*****************/

	FRAME_param->PARA_txMode= 0;// DO NOT CHANGE

	FRAME_param->PARA_call_mode_HS_HF_EAR= 0;



	FRAME_param->TX_Inner_bandwidth= 0;

	FRAME_param->TX_Outer_bandwidth= 0;



	FRAME_param->PARA_AEC_ONOFF_Inner= 0; // Outer_PARA_AEC_on_off

	FRAME_param->PARA_AEC_ONOFF_Outer= 0; // Outer_PARA_AEC_on_off

	FRAME_param->PARA_FNLMS_ONOFF_Inner= 0; // Outer_PARA_FNLMS_on_off

	FRAME_param->PARA_FNLMS_ONOFF_Outer= 0; // Outer_PARA_FNLMS_on_off

	FRAME_param->PARA_RES_ONOFF_Inner= 0; // Outer_PARA_RES_on_off

	FRAME_param->PARA_RES_ONOFF_Outer= 0; // Outer_PARA_RES_on_off

	FRAME_param->PARA_NS_ONOFF_Inner= 0; // Outer_PARA_NS_on_off

	FRAME_param->PARA_NS_ONOFF_Outer= 0; // Outer_PARA_NS_on_off

	FRAME_param->PARA_Mixing_ONOFF_Outer= 0; // Outer_PARA_Mixing_on_off



	FRAME_param->PARA_FLAG_FIRST_FRM_Inner = 0;

	FRAME_param->PARA_FLAG_FIRST_FRM_Outer = 0;



	FRAME_param->PARA_Q_for_InSigGain_Inner = 0;

	FRAME_param->PARA_Gain_TxSig_Inner = 0;

	FRAME_param->PARA_Gain_RxSig_Inner = 0;

	FRAME_param->PARA_Gain_TxSig_NS_IN_Inner = 0;

	FRAME_param->PARA_Gain_RxSig_NS_IN_Inner = 0;

	FRAME_param->PARA_Gain_TxSig_NS_Out_Inner = 0;



	FRAME_param->PARA_Q_for_InSigGain_Outer = 0;

	FRAME_param->PARA_Gain_TxSig_Outer = 0;

	FRAME_param->PARA_Gain_RxSig_Outer = 0;

	FRAME_param->PARA_Gain_TxSig_NS_IN_Outer = 0;

	FRAME_param->PARA_Gain_RxSig_NS_IN_Outer = 0;

	FRAME_param->PARA_Gain_TxSig_NS_Out_Outer = 0;

	FRAME_param->PARA_Gain_TxSig_Out = 0;



	FRAME_param->PARA_reserved_11= 0; // gain is Q4.11 format...



	FRAME_param->PARA_reserved_12= 0; //reserved

	FRAME_param->PARA_reserved_13= 0;

	FRAME_param->PARA_reserved_14= 0;

	FRAME_param->PARA_reserved_15= 0;

	FRAME_param->PARA_reserved_16= 0;

	FRAME_param->PARA_reserved_17= 0;

	FRAME_param->PARA_reserved_18= 0;

	FRAME_param->PARA_reserved_19= 0;

	FRAME_param->PARA_reserved_20= 0;



	return;

}



void SolomonVoiceWCONTEXTInit(ContextStatus *Context_buf)

{

	short i, k;



	Context_buf->CNTX_N_LEVEL   = Noise_Free;

	Context_buf->CNTX_VOICE_ACTIVE = Voice_Confirmed;	

	Context_buf->CNTX_N_DYNAMIC = Noise_Stationary;

	Context_buf->CNTX_N_TYPE    = Noise_Normal;

	Context_buf->CNTX_V         = Voice_Normal;

	Context_buf->CNTX_E         = Echo_SingleTalk;

	Context_buf->CNTX_OUT_NS    = NS_Normal;

	Context_buf->CNTX_OUT_EC    = EC_Normal;



	Context_buf->CNTX_LTSV = 0;



};



int SolomonVoiceECNSINIT(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars)

{

	DVTX_ECNS_vars->TX_bandwidth_Inner = DVTX_FRAME_LENGTH_NB;

	DVTX_ECNS_vars->TX_bandwidth_Outer = DVTX_FRAME_LENGTH_WB;





	SolomonVoiceWCONTEXTInit(&DVTX_ECNS_vars->Context_buf);





	SolomonVoiceWCommonBufInit(&DVTX_ECNS_vars->COMMON_buf);

	SolomonVoiceWFrameInit(&DVTX_ECNS_vars->FRAME_buf, &DVTX_ECNS_vars->FRAME_param, &DVTX_ECNS_vars->COMMON_buf);

	SolomonVoiceWAECInit(&DVTX_ECNS_vars->AEC_Inner_buf, &DVTX_ECNS_vars->AEC_Inner_param, &DVTX_ECNS_vars->COMMON_buf, CH_INNER);

	SolomonVoiceWAECInit(&DVTX_ECNS_vars->AEC_Outer_buf_1, &DVTX_ECNS_vars->AEC_Outer_param_1, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_1);

	SolomonVoiceWAECInit(&DVTX_ECNS_vars->AEC_Outer_buf_2, &DVTX_ECNS_vars->AEC_Outer_param_2, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_2);

	SolomonVoiceWBFInit(&DVTX_ECNS_vars->BF_buf, &DVTX_ECNS_vars->BF_param, &DVTX_ECNS_vars->COMMON_buf);



	SolomonVoiceWVADACCInit(&DVTX_ECNS_vars->VADACC_buf, &DVTX_ECNS_vars->VADACC_param, &DVTX_ECNS_vars->COMMON_buf);



	SolomonVoiceWRESInit(&DVTX_ECNS_vars->RES_Inner_buf, &DVTX_ECNS_vars->RES_Inner_param, &DVTX_ECNS_vars->COMMON_buf, CH_INNER);

	SolomonVoiceWRESInit(&DVTX_ECNS_vars->RES_Outer_buf, &DVTX_ECNS_vars->RES_Outer_param, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_1);

	SolomonVoiceWNSInit(&DVTX_ECNS_vars->NS_Inner_buf, &DVTX_ECNS_vars->NS_Inner_param, &DVTX_ECNS_vars->COMMON_buf, CH_INNER);

	SolomonVoiceWNSInit(&DVTX_ECNS_vars->NS_Outer_buf, &DVTX_ECNS_vars->NS_Outer_param, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_1);

	SolomonVoiceWPreNSInit(&DVTX_ECNS_vars->PRENS_Inner_buf, &DVTX_ECNS_vars->PreNS_Inner_param, &DVTX_ECNS_vars->COMMON_buf, CH_INNER);

	SolomonVoiceWPreNSInit(&DVTX_ECNS_vars->PRENS_Outer_buf, &DVTX_ECNS_vars->PreNS_Outer_param, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_1);

#if 0//#ifdef __EXE_ANC__

	SolomonVoiceWANCInit(&DVTX_ECNS_vars->ANC_Inner_buf, &DVTX_ECNS_vars->ANC_Inner_param, &DVTX_ECNS_vars->COMMON_buf, CH_INNER);

	SolomonVoiceWANCInit(&DVTX_ECNS_vars->ANC_Outer_buf, &DVTX_ECNS_vars->ANC_Outer_param, &DVTX_ECNS_vars->COMMON_buf, CH_OUTER_1);

#endif

	SolomonVoiceWMixingInit(&DVTX_ECNS_vars->Mix_buf, &DVTX_ECNS_vars->Mix_param, &DVTX_ECNS_vars->COMMON_buf);

	SolomonVoiceWAGCInit(&DVTX_ECNS_vars->AGC_buf_2input, &DVTX_ECNS_vars->AGC_param_2input);

	SolomonVoiceWAGCInit(&DVTX_ECNS_vars->AGC_buf_output, &DVTX_ECNS_vars->AGC_param_output);

	SolomonVoiceWMBDRCInit(&DVTX_ECNS_vars->MBDRC_buf, &DVTX_ECNS_vars->MBDRC_param);

	SolomonVoiceWFIRFilterInit(&DVTX_ECNS_vars->FIR_buf_out_WB, &DVTX_ECNS_vars->FIR_param);

	SolomonVoiceWFIRFilterInit(&DVTX_ECNS_vars->FIR_buf_out_NB, &DVTX_ECNS_vars->FIR_param);



	SolomonVoiceWFIRFilterInit(&DVTX_ECNS_vars->FIR_buf_out_RX_WB, &DVTX_ECNS_vars->FIR_param);

	SolomonVoiceWFIRFilterInit(&DVTX_ECNS_vars->FIR_buf_out_RX_NB, &DVTX_ECNS_vars->FIR_param);



#if 1//#ifdef __EXE_RNN__

	rnnnoise_init(&(DVTX_ECNS_vars->Denoisest));

#endif



#if 0//#ifdef __EXE_ANC__

	DVTX_ECNS_vars->ICANC_buf = SolomonVoiceInterChannelANCInit();

#endif

	return 0;

}



void SolomonVoiceW_FRAME_ParamConfig(SamsungSolomonVoiceWTxFRAMEParam* param_buf, SamsungSolomonVoiceWTxFRAMEParam* param)

{

	param_buf->PARA_txMode = param->PARA_txMode;

	param_buf->PARA_call_mode_HS_HF_EAR = param->PARA_call_mode_HS_HF_EAR;

	

	param_buf->TX_Inner_bandwidth = param->TX_Inner_bandwidth;

	param_buf->TX_Outer_bandwidth = param->TX_Outer_bandwidth;

	

	param_buf->PARA_AEC_ONOFF_Inner = param->PARA_AEC_ONOFF_Inner;

	param_buf->PARA_AEC_ONOFF_Outer = param->PARA_AEC_ONOFF_Outer;

	param_buf->PARA_FNLMS_ONOFF_Inner = param->PARA_FNLMS_ONOFF_Inner;

	param_buf->PARA_FNLMS_ONOFF_Outer = param->PARA_FNLMS_ONOFF_Outer;

	param_buf->PARA_RES_ONOFF_Inner = param->PARA_RES_ONOFF_Inner;

	param_buf->PARA_RES_ONOFF_Outer = param->PARA_RES_ONOFF_Outer;

	param_buf->PARA_NS_ONOFF_Inner = param->PARA_NS_ONOFF_Inner;

	param_buf->PARA_NS_ONOFF_Outer = param->PARA_NS_ONOFF_Outer;

	param_buf->PARA_Mixing_ONOFF_Outer = param->PARA_Mixing_ONOFF_Outer;

	

	param_buf->PARA_FLAG_FIRST_FRM_Inner = param->PARA_FLAG_FIRST_FRM_Inner;

	param_buf->PARA_FLAG_FIRST_FRM_Outer = param->PARA_FLAG_FIRST_FRM_Outer;

	

	param_buf->PARA_Q_for_InSigGain_Inner = param->PARA_Q_for_InSigGain_Inner;

	param_buf->PARA_Gain_TxSig_Inner = param->PARA_Gain_TxSig_Inner;

	param_buf->PARA_Gain_RxSig_Inner = param->PARA_Gain_RxSig_Inner;

	param_buf->PARA_Gain_TxSig_NS_IN_Inner = param->PARA_Gain_TxSig_NS_IN_Inner;

	param_buf->PARA_Gain_RxSig_NS_IN_Inner = param->PARA_Gain_RxSig_NS_IN_Inner;

	param_buf->PARA_Gain_TxSig_NS_Out_Inner = param->PARA_Gain_TxSig_NS_Out_Inner;



	param_buf->PARA_Q_for_InSigGain_Outer = param->PARA_Q_for_InSigGain_Outer;

	param_buf->PARA_Gain_TxSig_Outer = param->PARA_Gain_TxSig_Outer;

	param_buf->PARA_Gain_RxSig_Outer = param->PARA_Gain_RxSig_Outer;

	param_buf->PARA_Gain_TxSig_NS_IN_Outer = param->PARA_Gain_TxSig_NS_IN_Outer;

	param_buf->PARA_Gain_RxSig_NS_IN_Outer = param->PARA_Gain_RxSig_NS_IN_Outer;

	param_buf->PARA_Gain_TxSig_NS_Out_Outer = param->PARA_Gain_TxSig_NS_Out_Outer;

	param_buf->PARA_Gain_TxSig_Out = param->PARA_Gain_TxSig_Out;



	param_buf->PARA_reserved_11 = param->PARA_reserved_11;

	

	param_buf->PARA_reserved_12 = param->PARA_reserved_12;

	param_buf->PARA_reserved_13 = param->PARA_reserved_13;

	param_buf->PARA_reserved_14 = param->PARA_reserved_14;

	param_buf->PARA_reserved_15 = param->PARA_reserved_15;

	param_buf->PARA_reserved_16 = param->PARA_reserved_16;

	param_buf->PARA_reserved_17 = param->PARA_reserved_17;

	param_buf->PARA_reserved_18 = param->PARA_reserved_18;

	param_buf->PARA_reserved_19 = param->PARA_reserved_19;

	param_buf->PARA_reserved_20 = param->PARA_reserved_20;



	return;

}



#if(FLAG_SELECT_C_DSP == 1)

void SamsungTxECNSInOutConfig(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars,

	short* Speech_Tx_Inner, short* Speech_Tx_Outer_1, short* Speech_Tx_Outer_2, short* Speech_rx_Inner, short* Speech_rx_Outer, short *Speech_tx_Acc, short* OutSignal,

	short *Output_buf_Inner_NB, short *Output_buf_Inner_WB, short *Output_buf_Outer)

{

	//Tx input config

	DVTX_ECNS_vars->Speech_Tx_Inner = Speech_Tx_Inner;

	DVTX_ECNS_vars->Speech_Tx_Outer_1 = Speech_Tx_Outer_1;

	DVTX_ECNS_vars->Speech_Tx_Outer_2 = Speech_Tx_Outer_2;

	DVTX_ECNS_vars->Speech_Tx_Acc = Speech_tx_Acc;



	//Rx input 

	DVTX_ECNS_vars->Speech_Rx_Inner = Speech_rx_Inner;

	DVTX_ECNS_vars->Speech_Rx_Outer = Speech_rx_Outer;



	//Output config

	DVTX_ECNS_vars->OutSignal_Inner = DVTX_ECNS_vars->COMMON_buf.Output_buf_Inner;

	DVTX_ECNS_vars->OutSignal_Outer = OutSignal;



	// dbg

	DVTX_ECNS_vars->dbgOutput_buf_Inner_NB = Output_buf_Inner_NB;

	DVTX_ECNS_vars->dbgOutput_buf_Inner_WB = Output_buf_Inner_WB;

	DVTX_ECNS_vars->dbgOutput_buf_Outer = Output_buf_Outer;



	return;

}

#else

void SamsungTxECNSInOutConfig(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars,

	short* Speech_Tx_Inner, short* Speech_Tx_Outer_1, short* Speech_Tx_Outer_2, short* Speech_rx_Inner, short* Speech_rx_Outer, short *Speech_tx_Acc, short* OutSignal)

{

	short i;



	//Tx input config

	DVTX_ECNS_vars->Speech_Tx_Inner = Speech_Tx_Inner;

	DVTX_ECNS_vars->Speech_Tx_Outer_1 = Speech_Tx_Outer_1;

	DVTX_ECNS_vars->Speech_Tx_Outer_2 = Speech_Tx_Outer_2;

	DVTX_ECNS_vars->Speech_Tx_Acc = Speech_tx_Acc;



	//Rx input 

	DVTX_ECNS_vars->Speech_Rx_Inner = Speech_rx_Inner;

	DVTX_ECNS_vars->Speech_Rx_Outer = Speech_rx_Outer;



	//Output config

	DVTX_ECNS_vars->OutSignal_Inner = DVTX_ECNS_vars->COMMON_buf.Output_buf_Inner;

	DVTX_ECNS_vars->OutSignal_Outer = OutSignal;



	return;

}

#endif



int SolomonVoiceWParamConfig(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars, SamsungSolomonVoiceParam* param)

{



	SolomonVoiceW_FRAME_ParamConfig(&DVTX_ECNS_vars->FRAME_param, &param->FRAME_param);

	SolomonVoiceW_AEC_ParamConfig(&DVTX_ECNS_vars->AEC_Inner_param, &param->AEC_Inner_param);

	SolomonVoiceW_AEC_ParamConfig(&DVTX_ECNS_vars->AEC_Outer_param_1, &param->AEC_Outer_param_1);

	SolomonVoiceW_AEC_ParamConfig(&DVTX_ECNS_vars->AEC_Outer_param_2, &param->AEC_Outer_param_2);

	SolomonVoiceW_BF_ParamConfig(&DVTX_ECNS_vars->BF_param, &param->BF_param);



	SolomonVoiceW_VADACC_ParamConfig(&DVTX_ECNS_vars->VADACC_param, &param->VADACC_param);



	SolomonVoiceW_RES_ParamConfig(&DVTX_ECNS_vars->RES_Inner_param, &DVTX_ECNS_vars->RES_Inner_buf, &param->RES_Inner_param, CH_INNER);

	SolomonVoiceW_RES_ParamConfig(&DVTX_ECNS_vars->RES_Outer_param, &DVTX_ECNS_vars->RES_Outer_buf, &param->RES_Outer_param, CH_OUTER_1);

	SolomonVoiceW_NS_ParamConfig(&DVTX_ECNS_vars->NS_Inner_param, &param->NS_Inner_param);

	SolomonVoiceW_NS_ParamConfig(&DVTX_ECNS_vars->NS_Outer_param, &param->NS_Outer_param);

	SolomonVoiceW_PreNS_ParamConfig(&DVTX_ECNS_vars->PreNS_Inner_param, &param->PreNS_Inner_param);

	SolomonVoiceW_PreNS_ParamConfig(&DVTX_ECNS_vars->PreNS_Outer_param, &param->PreNS_Outer_param);

	SolomonVoiceW_ANC_ParamConfig(&DVTX_ECNS_vars->ANC_Inner_param, &param->ANC_Inner_param);

	SolomonVoiceW_ANC_ParamConfig(&DVTX_ECNS_vars->ANC_Outer_param, &param->ANC_Outer_param);

	SolomonVoiceW_Mix_ParamConfig(&DVTX_ECNS_vars->Mix_param, &param->Mix_param);

	SolomonVoiceW_AGC_ParamConfig(&DVTX_ECNS_vars->AGC_param_2input, &param->AGC_param_2input);

	SolomonVoiceW_AGC_ParamConfig(&DVTX_ECNS_vars->AGC_param_output, &param->AGC_param_output);

	SolomonVoiceW_MBDRC_ParamConfig(&DVTX_ECNS_vars->MBDRC_param, &param->MBDRC_param);

	SolomonVoiceW_FIR_ParamConfig(&DVTX_ECNS_vars->FIR_param, &param->FIR_param);



	return 0;

}



#ifndef fx_SolomonVoice_clipping_detection_OPT_DSP

short fx_SolomonVoice_clipping_detection(short *pTxinner, short TX_bandwidth, short Thr)

{

	short i;

	short Flag_Clipping = 0;



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

	{

		if (*(pTxinner + i) > Thr)

		{

			Flag_Clipping = 1;

			break;

		}

	}



	return Flag_Clipping;

}

#else

short fx_SolomonVoice_clipping_detection(short *pTxinner, short TX_bandwidth, short Thr)

{



	ae_valign align1;

	ae_int16x4 *pt1;

	ae_int16x4 data,vThr, vOne, vFlag;

	xtbool4 bool4;

	short i;

	short Flag_Clipping = 0;



	pt1=(ae_int16x4 *)pTxinner;

	align1 = AE_LA64_PP(pt1);

	vThr = AE_MOVDA16(Thr);

	vOne = AE_MOVDA16(1);

	vFlag =  AE_ZERO16() ;

	for (i = 0; i <  TX_bandwidth; i+=4)

	{

		AE_LA16X4_IP(data, align1, pt1);

		bool4 = AE_LT16(vThr,data );

		AE_MOVT16X4(vFlag, vOne, bool4);

	}

	Flag_Clipping = AE_MOVAD16_0(vFlag);

	Flag_Clipping += AE_MOVAD16_1(vFlag);

	Flag_Clipping += AE_MOVAD16_2(vFlag);

	Flag_Clipping += AE_MOVAD16_3(vFlag);



	if(Flag_Clipping > 1)

		Flag_Clipping = 1;





	return Flag_Clipping;

}

#endif



int SolomonVoiceWECNSExe(DVTX_ECNS_Cfg_t* DVTX_ECNS_vars)

{

	short i, ret;



	short *Speech_Tx_Inner = DVTX_ECNS_vars->Speech_Tx_Inner;

	short *Speech_Tx_Outer_1 = DVTX_ECNS_vars->Speech_Tx_Outer_1;

	short *Speech_Tx_Outer_2 = DVTX_ECNS_vars->Speech_Tx_Outer_2;

	short *Speech_Rx_Inner = DVTX_ECNS_vars->Speech_Rx_Inner;

	short *Speech_Rx_Outer = DVTX_ECNS_vars->Speech_Rx_Outer;

	short *Speech_Tx_Acc = DVTX_ECNS_vars->Speech_Tx_Acc;

	

	short TX_Inner_bandwidth = DVTX_ECNS_vars->FRAME_param.TX_Inner_bandwidth;

	short TX_Outer_bandwidth = DVTX_ECNS_vars->FRAME_param.TX_Outer_bandwidth;



	short *FFTbuf_Tx_Inner_NB = DVTX_ECNS_vars->FRAME_buf.FFTbuf_Tx_Inner_NB;

	int *HPFstateOuterTx_1 = DVTX_ECNS_vars->FRAME_buf.HPFstateOuterTx_1;

	int *HPFstateOuterTx_2 = DVTX_ECNS_vars->FRAME_buf.HPFstateOuterTx_2;

	int *HPFstateOuterRx = DVTX_ECNS_vars->FRAME_buf.HPFstateOuterRx;

	int *HPFstateInnerTx = DVTX_ECNS_vars->FRAME_buf.HPFstateInnerTx;

	int *HPFstateAccTx = DVTX_ECNS_vars->FRAME_buf.HPFstateAccTx;

	int *WindHPFstateOuterTx_1 = DVTX_ECNS_vars->FRAME_buf.WindHPFstateOuterTx_1;

	int *WindHPFstateOuterTx_2 = DVTX_ECNS_vars->FRAME_buf.WindHPFstateOuterTx_2;



	long *Buf_Downsample_InnerRx = DVTX_ECNS_vars->FRAME_buf.Buf_Downsample_InnerRx;

	long *Buf_Downsample_InnerTx = DVTX_ECNS_vars->FRAME_buf.Buf_Downsample_InnerTx;



	short* RxFFTfrm_AEC_Inner = DVTX_ECNS_vars->AEC_Inner_buf.RxFFTfrm_AEC;

	short* RxFFTfrm_AEC_Outer_1 = DVTX_ECNS_vars->AEC_Outer_buf_1.RxFFTfrm_AEC;

	short* RxFFTfrm_AEC_Outer_2 = DVTX_ECNS_vars->AEC_Outer_buf_2.RxFFTfrm_AEC;

	short* RxFFTfrm_clp_AEC_Inner = DVTX_ECNS_vars->AEC_Inner_buf.RxFFTfrm_clp_AEC;

	short* RxFFTfrm_clp_AEC_Outer_1 = DVTX_ECNS_vars->AEC_Outer_buf_1.RxFFTfrm_clp_AEC;

	short* RxFFTfrm_clp_AEC_Outer_2 = DVTX_ECNS_vars->AEC_Outer_buf_2.RxFFTfrm_clp_AEC;

	short PARA_Gain_TxSig_NS_IN_Inner = DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_NS_IN_Inner;

	short PARA_Gain_RxSig_NS_IN_Inner = DVTX_ECNS_vars->FRAME_param.PARA_Gain_RxSig_NS_IN_Inner;

	short PARA_Gain_TxSig_NS_IN_Outer = DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_NS_IN_Outer;

	short PARA_Gain_RxSig_NS_IN_Outer = DVTX_ECNS_vars->FRAME_param.PARA_Gain_RxSig_NS_IN_Outer;

	short PARA_Q_for_InSigGain_Inner = DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Inner;

	short PARA_Q_for_InSigGain_Outer = DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer;



	short PARA_Gain_TxSig_Outer = DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_Outer;

	

	short* data_buffer_NB; // data_buffer_NB

	short* data_buffer_WB; // data_buffer_WB



#if 1//#ifdef __EXE_RNN__

	DenoiseState *rnnoise_st = &DVTX_ECNS_vars->Denoisest;

#endif



	FRAMEStatus* FRAME_buf = &DVTX_ECNS_vars->FRAME_buf;	

	ContextStatus* Context_buf = &DVTX_ECNS_vars->Context_buf;



	/********* inner tx clipping detection in time domain ********/

	DVTX_ECNS_vars->FRAME_buf.Flag_Tx_Clipping_Inner = fx_SolomonVoice_clipping_detection(Speech_Tx_Inner, TX_Inner_bandwidth, 24000);



	/********* outer tx clipping detection in time domain ********/

	//DVTX_ECNS_vars->FRAME_buf.Flag_Tx_Clipping_Outer_1 = fx_SolomonVoice_clipping_detection(Speech_Tx_Outer_1, TX_Outer_bandwidth, DVTX_MAX_16);

	//DVTX_ECNS_vars->FRAME_buf.Flag_Tx_Clipping_Outer_2 = fx_SolomonVoice_clipping_detection(Speech_Tx_Outer_2, TX_Outer_bandwidth, DVTX_MAX_16);



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

	{

		data_buffer_NB = DVTX_ECNS_vars->FRAME_buf.fftbuf_Inner.data_buffer; // data_buffer_NB

		data_buffer_WB = DVTX_ECNS_vars->FRAME_buf.fftbuf_Outer_1.data_buffer; // data_buffer_WB





		//

		Fx_vector_gain(Speech_Tx_Outer_1, PARA_Gain_TxSig_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		Fx_vector_gain(Speech_Tx_Outer_2, PARA_Gain_TxSig_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 



		/********* outer IIR Filtering ********/

		FN_2ndIIR_FILTERING(Speech_Tx_Outer_1, TX_Outer_bandwidth, HPFcoeff, HPFstateOuterTx_1); //¸Þ¸ð : HPFcoeff ó¸®ÇÒ °Í, IIRÇÊÅÍ Á¤¸® ÇÊ¿ä

		FN_2ndIIR_FILTERING(Speech_Tx_Outer_2, TX_Outer_bandwidth, HPFcoeff, HPFstateOuterTx_2);

		FN_2ndIIR_FILTERING(Speech_Tx_Inner, TX_Outer_bandwidth, HPFcoeff, HPFstateInnerTx);

		FN_2ndIIR_FILTERING(Speech_Rx_Outer, TX_Outer_bandwidth, HPFcoeff, HPFstateOuterRx);		

		FN_2ndIIR_FILTERING(Speech_Tx_Acc, TX_Outer_bandwidth, HPFcoeff, HPFstateAccTx); 		

		Fx_vector_gain(Speech_Tx_Acc, 1024*16, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 



		//RX EQ.

		FN_SOLOMONVOICEW_TX_FIRFilter(DVTX_ECNS_vars->Speech_Rx_Outer, DVTX_ECNS_vars->FIR_param.FIRCoef_out_RX_WB, DVTX_ECNS_vars->FIR_buf_out_RX_WB.FIRCoefBuff, DVTX_FRM_LEN_WB);

		Fx_vector_gain(DVTX_ECNS_vars->Speech_Rx_Outer, 1024 * 10, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 



		/********* copy inner 16kHz data for VAD and ANC and pref0NS ********/

		//Fx_vector_copy_s(Speech_Tx_Inner_WB, Speech_Tx_Inner, DVTX_FRM_LEN_WB);



		/********* inner downsampling : 16kHz to 8kHz ********/

		WebRtcSpl_DownsampleBy2(Speech_Rx_Inner, DVTX_FRAME_LENGTH_WB, Speech_Rx_Inner, Buf_Downsample_InnerRx);

		WebRtcSpl_DownsampleBy2(Speech_Tx_Inner, DVTX_FRAME_LENGTH_WB, Speech_Tx_Inner, Buf_Downsample_InnerTx);



#ifndef KHW_OPTI_20191216_HIFI

		for (i = DVTX_FRAME_LENGTH_NB + 1; i < DVTX_FRAME_LENGTH_WB; i++) {

			Speech_Rx_Inner[i] = 0;

			Speech_Tx_Inner[i] = 0;

		} 

#else

		__vec_memset(&Speech_Rx_Inner[DVTX_FRAME_LENGTH_NB+1],0,(DVTX_FRAME_LENGTH_WB-DVTX_FRAME_LENGTH_NB-1)<<1);

		__vec_memset(&Speech_Tx_Inner[DVTX_FRAME_LENGTH_NB+1],0,(DVTX_FRAME_LENGTH_WB-DVTX_FRAME_LENGTH_NB-1)<<1);

#endif

		

		/********* EC inner : 8kHz Fs ********/

		FN_SOLOMONVOICEW_TX_AEC(DVTX_ECNS_vars, CH_INNER);



		/********* EC outer : 16kHz Fs ********/

		FN_SOLOMONVOICEW_TX_AEC(DVTX_ECNS_vars, CH_OUTER_1);

		//FN_SOLOMONVOICEW_TX_AEC(DVTX_ECNS_vars, CH_OUTER_2);



		/********* AGC for 2outer input ********/

		FN_SOLOMONVOICEW_TX_AGC_2ch(Speech_Tx_Outer_1, Speech_Tx_Outer_2, &DVTX_ECNS_vars->AGC_buf_2input, &DVTX_ECNS_vars->AGC_param_2input);



		/********* input signal gain for NS module ********/

		//Fx_vector_gain(Speech_Tx_Inner, PARA_Gain_TxSig_NS_IN_Inner, PARA_Q_for_InSigGain_Inner, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_AEC_Inner, PARA_Gain_RxSig_NS_IN_Inner, PARA_Q_for_InSigGain_Inner, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_clp_AEC_Inner, PARA_Gain_RxSig_NS_IN_Inner, PARA_Q_for_InSigGain_Inner, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 



		Fx_vector_gain(Speech_Tx_Outer_1, PARA_Gain_TxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_AEC_Outer_1, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_clp_AEC_Outer_1, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		Fx_vector_gain(Speech_Tx_Outer_2, PARA_Gain_TxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_AEC_Outer_2, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_clp_AEC_Outer_2, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 

		//Fx_vector_gain(Speech_Tx_Inner_WB, PARA_Gain_TxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.11 format... 



		/********* Wind Detection ********/

		FN_Wind_Detection(DVTX_ECNS_vars);



		if (DVTX_ECNS_vars->Mix_buf.WND_strong_ON)

		{

			FN_2ndIIR_FILTERING(Speech_Tx_Outer_1, TX_Outer_bandwidth, WindHPFcoeff, WindHPFstateOuterTx_1);

			FN_2ndIIR_FILTERING(Speech_Tx_Outer_2, TX_Outer_bandwidth, WindHPFcoeff, WindHPFstateOuterTx_2);

		}



		/********* FFT ********/

		FFT_functions(DVTX_ECNS_vars);



		/********* noise voice context decision ********/

		FN_BACKGROUND_NOISE_CONTEXT_FROM_BF_NS_AEC_ACCELEROMETER(DVTX_ECNS_vars);



		/********* VADACC ********/

		FN_VADACC(DVTX_ECNS_vars);



		/********* Inner mic signal enhancement ********/

#ifdef __SV_USE_ANC_RESULT__

		FN_InterChannelANC_main(DVTX_ECNS_vars);

#endif



		/********* copy inner NB data for Unfit detection ********/

		Fx_vector_copy_s(FFTbuf_Tx_Inner_NB, data_buffer_NB, DVTX_M_FFT_LEN_NB);





		/********* MBDRC ********/

		FN_SOLOMONVOICEW_TX_MBDRC_2ch(DVTX_ECNS_vars);



		/********* BF ********/

		FN_BF(DVTX_ECNS_vars);



		/*context based signal mix : outer sub mic. and BFout*/

		//////FN_CONTEXT_BASED_SIGNAL_MIX_MIC_BF(DVTX_ECNS_vars);



		///********* NS inner : 8kHz Fs ********/

		DVTX_ECNS_vars->TX_bandwidth_Inner = DVTX_FRAME_LENGTH_NB;		

		FN_SOLOMONVOICEW_TX_RES_NS(DVTX_ECNS_vars, CH_INNER);

		

		/********* ECNS outer : 16kHz Fs ********/

		DVTX_ECNS_vars->FRAME_param.TX_Outer_bandwidth = DVTX_FRAME_LENGTH_WB;		

		FN_SOLOMONVOICEW_TX_RES_NS(DVTX_ECNS_vars, CH_OUTER_1);



		

		/********* Mixing (Frequency Domain) ********/

		FN_Mixing_FreqDomain(DVTX_ECNS_vars);



		FN_Mixing_FreqDomain_ACC(DVTX_ECNS_vars);



		/* extremly low band attenuation for voice clarity*/

		FN_Gain_LowBand_0_to_200Hz(DVTX_ECNS_vars);







		/********* RNNoise Module ********/

#if 1//#ifdef __EXE_RNN__

			//if ((FRAME_buf->STATE_ACC_Effective == 1) && (FRAME_buf->Flag_HighNoise_MixACC_MixNpsd == 1))

		{

			//rnnoise_st->BLK_NORM = DVTX_ECNS_vars->FRAME_buf.fftbuf_Outer_1.BLK_NORM;

			//fx_rnnoise_process_frame(rnnoise_st, data_buffer_WB, data_buffer_WB);



			//FN_CONTEXT_BASED_SIGNAL_MIX_MIC_BF(DVTX_ECNS_vars);



		}

#endif









		/********* IFFT ********/

		IFFT_functions(DVTX_ECNS_vars);



		/********* output signal gain ********/

		//Fx_vector_gain(data_buffer_NB, DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_NS_Out_Inner, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Inner, DVTX_FFT_LEN_NB); // gain is Q4.10 format... 

		//Fx_vector_gain(data_buffer_WB, DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_NS_Out_Outer, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer, DVTX_FFT_LEN_WB); // gain is Q4.10 format... 

		//if (DVTX_ECNS_vars->Mix_buf.State > 1)

		//	Fx_vector_gain(data_buffer_WB, 1149, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer, DVTX_FFT_LEN_WB); // +1dB for high noise gain is Q4.10 format... 



		/********* Mixing (mixing state, gainȐ̉) ********/

		FN_SOLOMONVOICEW_TX_MIXING_SET(DVTX_ECNS_vars);



		/********* OLA ********/

		IOLA_functions(DVTX_ECNS_vars);



		/********* EQ ********/

		FN_SOLOMONVOICEW_TX_FIRFilter(DVTX_ECNS_vars->OutSignal_Outer, DVTX_ECNS_vars->FIR_param.FIRCoef_out_WB, DVTX_ECNS_vars->FIR_buf_out_WB.FIRCoefBuff, DVTX_FRM_LEN_WB);



		/* context based output gain control */		

		FN_CONTEXT_BASED_OUPUT_GAIN_CONTROL(DVTX_ECNS_vars);		



		/********* AGC for outer output ********/

		FN_SOLOMONVOICEW_TX_AGC(DVTX_ECNS_vars->OutSignal_Outer, &DVTX_ECNS_vars->AGC_buf_output, &DVTX_ECNS_vars->AGC_param_output);



		/********* Final output gain ********/

		Fx_vector_gain(DVTX_ECNS_vars->OutSignal_Outer, DVTX_ECNS_vars->FRAME_buf.CNTX_Gain_TxSig_Out, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_WB); // gain is Q4.10 format... 



		/////Fx_vector_copy_s(DVTX_ECNS_vars->OutSignal_Outer, DVTX_ECNS_vars->Speech_Rx_Outer, DVTX_M_FFT_LEN_WB);

	}

	else // NarrowBand

	{

		data_buffer_NB = DVTX_ECNS_vars->FRAME_buf.fftbuf_Outer_NB.data_buffer; // data_buffer_NB



		if (DVTX_ECNS_vars->FRAME_param.PARA_FLAG_FIRST_FRM_Outer == DVTX_TRUE)

		{

			FN_NBcall_ParaConfig(&DVTX_ECNS_vars->NS_Outer_param, &DVTX_ECNS_vars->AEC_Outer_param_1);

		}



		FN_2ndIIR_FILTERING(Speech_Tx_Outer_1, TX_Outer_bandwidth, HPFcoeff, HPFstateOuterTx_1);

		FN_2ndIIR_FILTERING(Speech_Rx_Outer, TX_Outer_bandwidth, HPFcoeff, HPFstateOuterRx);



		DVTX_ECNS_vars->FRAME_buf.FrmVAD_Outer = 1;

		DVTX_ECNS_vars->FRAME_buf.FrmDT_Outer = 1;



		/********* EC outer ********/

		FN_SOLOMONVOICEW_TX_AEC(DVTX_ECNS_vars, CH_OUTER_1);



		/********* input signal gain for NS module ********/



		PARA_Gain_TxSig_NS_IN_Outer = 1024;//0dB Hardcording



		Fx_vector_gain(Speech_Tx_Outer_1, PARA_Gain_TxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_AEC_Outer_1, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 

		//Fx_vector_gain(RxFFTfrm_clp_AEC_Outer_1, PARA_Gain_RxSig_NS_IN_Outer, PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_NB); // gain is Q4.11 format... 



		/********* FFT ********/

		FFT_functions(DVTX_ECNS_vars);

		

		/********* ECNS outer ********/

		FN_SOLOMONVOICEW_TX_RES_NS_NBBT(DVTX_ECNS_vars, CH_OUTER_1);



		/********* IFFT ********/

		IFFT_functions(DVTX_ECNS_vars);



		/********* output signal gain ********/

		Fx_vector_gain(data_buffer_NB, DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_NS_Out_Outer, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer, DVTX_FFT_LEN_NB); // gain is Q4.10 format... 

		

		/********* OLA ********/

		IOLA_functions(DVTX_ECNS_vars);



		/********* EQ ********/

		FN_SOLOMONVOICEW_TX_FIRFilter(DVTX_ECNS_vars->OutSignal_Outer, DVTX_ECNS_vars->FIR_param.FIRCoef_out_NB, DVTX_ECNS_vars->FIR_buf_out_NB.FIRCoefBuff, DVTX_FRM_LEN_NB);



		/********* AGC for outer output ********/

		FN_SOLOMONVOICEW_TX_AGC(DVTX_ECNS_vars->OutSignal_Outer, &DVTX_ECNS_vars->AGC_buf_output, &DVTX_ECNS_vars->AGC_param_output);



		/********* Final output gain ********/

		DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_Out = 11489; //21dB Hardcoding

		Fx_vector_gain(DVTX_ECNS_vars->OutSignal_Outer, DVTX_ECNS_vars->FRAME_param.PARA_Gain_TxSig_Out, DVTX_ECNS_vars->FRAME_param.PARA_Q_for_InSigGain_Outer, DVTX_FRM_LEN_NB); // gain is Q4.10 format... 



	}



	return 0;

}