#include "speech_mdct.h"

#include "basic_op.h"

#include "speech_fft.h"

#include "speech_opt_asm.h"

#include "comb_filter.h"







#ifdef HW_DATASIZE

//extern int pre_shared[312];   // 312+78(156)

extern int pre_shared[360];   // 312+78(156)

#endif





#ifndef OPT_KHW_BASIC_OP





#ifdef HW_DATA_SIZE_STATIC_WINDOW

 const extern short window[120];

#endif



#ifndef HW_DATASIZE

int f_enc[120];

int f2_enc[120];

#endif





#ifdef clt_mdct_backward_LOOP3_BX

int clt_mdct_backward_loop3(int *xp1,int *yp1,short *wp1,short *wp2,int overlap)

{

//	    int i;

//		for(i = 0; i < (overlap>>1); i++)

//		{

//            int x1, x2;

//

//			x1 = *xp1;

//			x2 = *yp1;

//

//			*yp1++ = SSC_MULT16x32_Q15(*wp2, x2) - SSC_MULT16x32_Q15(*wp1, x1);

//			*xp1-- = SSC_MULT16x32_Q15(*wp1, x2) + SSC_MULT16x32_Q15(*wp2, x1);

//			wp1++;

//			wp2--;

//		}

//#####################################################################

    int i;

    //ae_valign    align1;

	ae_int32x2  *yp_x=(ae_int32x2 *)yp1;

	ae_int32x2  *xp_x=(ae_int32x2 *)xp1;

	ae_int32x2 tmp_xp,tmp,tmp1,tmp2;

	ae_f16x4 tmp_wp;

	//align1 = AE_ZALIGN64();

    for(i = 0; i < (overlap>>1); i++)

	{

	  tmp_xp=AE_MOVDA32X2( *yp1, *xp1);

	  tmp_wp=AE_MOVDA16X2( *wp2, *wp1);

	  tmp=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

	  AE_S32_L_IP(tmp, xp_x, -4);

	  tmp = AE_SEL32_LH(tmp, tmp);

	  AE_S32_L_IP(tmp, yp_x, 4);

	  xp1--;

	  yp1++;

	  wp1++;

	  wp2--;

	}



}

#endif





#ifdef clt_mdct_backward_LOOP2_BX

int clt_mdct_backward_loop2(int *yp0,int *yp1,short *t0,short *t1,short *t2,short *t3,int N4)

{

//    int i;

//	for(i=0;i<(N4+1)>>1;i++)

//	{

//		int re, im, yr, yi;

//

//		re = yp0[0];

//		im = yp0[1];

//		yr = S_MUL(re,t2[i]) - S_MUL(im,t3[i]);

//		yi = S_MUL(im,t2[i]) + S_MUL(re,t3[i]);

//

//		re = yp1[0];

//		im = yp1[1];

//

//		yp0[0] = -yr;

//		yp1[1] = yi;

//		yp1[0] = -S_MUL(re,t1[-i]) + S_MUL(im,t0[-i]);

//		yp0[1] = S_MUL(im,t1[-i]) + S_MUL(re,t0[-i]);

//

//		yp0 += 2;

//		yp1 -= 2;

//	 }





//#####################################################################

	int i;

	ae_valign    align1,align2,align3,align4;

	ae_int32x2  *yp_x=(ae_int32x2 *)yp0;

	ae_int32x2  *yp_x_alias=(ae_int32x2 *)yp0;

	ae_int32x2  yp01;

	ae_int32x2  *yp_x1=(ae_int32x2 *)(yp1+1);

	ae_int32x2  *yp_x1_alias=(ae_int32x2 *)(yp1+1);

	ae_int32x2  yp1_01;



	ae_int32x2 tmp_xp,tmp,tmp1,tmp2,tmp3,tmp2_1,tmp3_1;

	ae_f16x4 tmp_wp;

	align1 = AE_LA64_PP(yp_x);

	align2 = AE_LA64_PP(yp_x1);

	align3 = AE_ZALIGN64();

	align4 = AE_ZALIGN64();

	for(i=0;i<(N4+1)>>1;i++)

	{



	   AE_LA32X2_IP(yp01, align1, yp_x);//re im

	   tmp_wp=AE_MOVDA16X2(t2[i],t3[i]);

	   tmp=AE_MULFC32X16RAS_H(yp01,tmp_wp);//yr yi  //-yp0[0]  yp1[1]



	   AE_LA32X2_RIP(yp1_01, align2, yp_x1);//re im     (im re)

	   tmp_wp=AE_MOVDA16X2(t0[-i],t1[-i]);

	   tmp1=AE_MULFC32X16RAS_H(yp1_01,tmp_wp);//-yp1[0] yp0[1]      (yp1[0] yp0[1])





	   tmp2=AE_SEL32_HL(tmp,tmp1);	// -yp0[0] yp0[1]

	   tmp2_1=AE_NEG32S(tmp2);  // yp0[0] -yp0[1]

	   tmp2=AE_SEL32_HL(tmp2_1,tmp2); //yp0[0] yp0[1]

	   tmp3=AE_SEL32_HL(tmp1,tmp);	// -yp1[0] yp1[1]    (yp1[0] yp1[1])

	   tmp3=AE_SEL32_LH(tmp3,tmp3); // (yp1[1] yp1[0] )

//	   tmp3_1=AE_NEG32S(tmp3);  // yp1[0] -yp1[1]

//       tmp3=AE_SEL32_HL(tmp3_1,tmp3);//yp1[0]  yp1[1]





	   AE_SA32X2_IP(tmp2, align3, yp_x_alias);

	   AE_SA32X2_RIP(tmp3, align4, yp_x1_alias);

	   //yp0 += 2;

	   //yp1 -= 2;

	}

	AE_SA64POS_FP(align3, yp_x_alias);

	AE_SA64POS_FP(align4, yp_x1_alias);

	return 0;



}

#endif





#ifdef clt_mdct_backward_LOOP1_BX

int clt_mdct_backward_loop1(int *yp,int *xp1,int *xp2,short *t0,short *t1,int i)

{

//	do

//	{

//		*yp++ = -S_MUL(*xp2, *t0) + S_MUL(*xp1,*t1);

//		*yp++ = -S_MUL(*xp2, *t1) - S_MUL(*xp1,*t0);

//		t0++;

//		t1++;

//		xp1+=2;

//		xp2-=2;

//	}

//	while(--i);

//#####################################################################



	ae_valign    align1;

	ae_int32x2  *yp_x=(ae_int32x2 *)yp;

	ae_int32x2 tmp_xp,tmp,tmp1,tmp2;

	ae_f16x4 tmp_wp;

	align1 = AE_ZALIGN64();



	do

	{

	   tmp_xp=AE_MOVDA32X2(*xp1,*xp2);

	   tmp_wp=AE_MOVDA16X2(*t1,*t0);

	   tmp=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);



       tmp1=AE_NEG32S(tmp);

	   tmp2=AE_SEL32_HL(tmp,tmp1);

	   AE_SA32X2_IP(tmp2, align1, yp_x);

	    t0++;

		t1++;

		xp1+=2;

		xp2-=2;

	}while(--i);

	AE_SA64POS_FP(align1, yp_x);

	return 0;



}

#endif



#ifdef clt_mdct_forward_LOOP4_BX

//int forword_mdct_loop4(int *fp,short *t1,short *t,int *yp1,int *yp2,int i )

//{



//}

int  forword_mdct_loop4(int *fp,short *t1,short *t,int *yp1,int *yp2,int i )

{

//		    long long tmp_val,tmp_val2;

//			do{

//

//				tmp_val = AE_MUL32X16_H0(fp[1], *t1);

//				tmp_val2 = AE_MUL32X16_H0(fp[0], *t);

//				*yp1 = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

//

//				tmp_val = AE_MUL32X16_H0(fp[0], *t1);

//				tmp_val2 = AE_MUL32X16_H0(fp[1], *t);

//				*yp2 = (int)(tmp_val>>15) - (int)(tmp_val2>>15);

//

//				t++; t1++;

//				fp += 2;

//				yp1 += 2;

//				yp2 -= 2;

//			}while(--i);

//			return 0;

//#############################################################

    long long tmp_val,tmp_val2;



short tmp1;

	ae_valign align1,align2,align3;

    ae_int32x2  *fp_x=(ae_int32x2 *)fp;

	ae_int32x2  fp01,tmp;

	ae_f16x4 t01;

	ae_int32x2 *pt_yp1=(ae_int32x2 *)yp1;

	ae_int32x2 *pt_yp2=(ae_int32x2 *)yp2;

	align1 = AE_LA64_PP(fp_x);//下载

	do{



	   AE_LA32X2_IP(fp01, align1, fp_x);   //fp[0]  fp[1]

//下面这个放在了高位

	   t01 = AE_MOVDA16X2( *t1,*t);

	   tmp = AE_MULFC32X16RAS_L(fp01,t01);//32bit*16bit乘累加放在高32bit位



	   AE_S32_L_IP(tmp, pt_yp1, 8);//8

	  // pt_yp1++;

///下面的实现结果跟上面的是一样的

//	   t01 = AE_MOVDA16X2( *t1,*t);//a0 a1绑定到一起形成32bit

//	   tmp = AE_MULFC32X16RAS_H(fp01,t01);

	   //pt_yp2--;

	   tmp = AE_SEL32_LH(tmp, tmp);

	   AE_S32_L_IP(tmp, pt_yp2, -8);//-8  //数据下载不正确  tmp: yp2,yp1

	   t++; t1++;





	}while(--i);

	return 0;



}



#endif



#ifdef clt_mdct_forward_LOOP3_BX

int forword_mdct_loop3(int *yp,short *t1,short *t,int i )

{

//	  long long tmp_val,tmp_val2;

//

//		do{

//					int re, im;

//

//

//					re = *yp++;

//					im = *yp--;

//

//					tmp_val = AE_MUL32X16_H0(re, *t);

//					tmp_val2 = AE_MUL32X16_H0(im, *t1);

//					*yp++ = -((int)(tmp_val>>15) + (int)(tmp_val2>>15));

//

//					tmp_val = AE_MUL32X16_H0(im, *t);

//					tmp_val2 = AE_MUL32X16_H0(re, *t1);

//					*yp++ = (int)(tmp_val2>>15) - (int)(tmp_val>>15);

//

//					t++; t1++;

//		 }while(--i);

//	  return 0;

//#####################################################################

	        ae_valign align1,align2;

			ae_int32x2  yp01;

			ae_f16x4 t01;

			ae_int32x2  *yp_x=(ae_int32x2 *)yp;

			ae_int32x2  *yp_x1=(ae_int32x2 *)yp;

			ae_int32x2 tmp,tmp1,tmp2;

			align1 = AE_LA64_PP(yp_x);

		    align2 = AE_ZALIGN64();//下载

			do{

			      AE_LA32X2_IP(yp01, align1, yp_x);//re im

			      //yp01=AE_SEL32_LH(yp01,yp01);

				  t01 = AE_MOVDA16X2(*t1, *t);//*t *t1

				  //yp01=AE_NEG32S(yp01);

				  tmp=AE_MULFC32X16RAS_H(yp01,t01);//高位减去低位

				  tmp1=AE_NEG32S(tmp);

				  tmp2=AE_SEL32_LH(tmp1,tmp);

				  AE_SA32X2_IP(tmp2, align2, yp_x1);





				  t++; t1++;

				}while(--i);

	       AE_SA64POS_FP(align2, yp_x1);





		return 0;

}

#endif

#ifdef clt_mdct_forward_LOOP2_BX

int forword_mdct_loop2(int *yp,int *xp1,int *xp2,short *wp1,short *wp2,int N4,int N2,int i)

{

//		long long tmp_val,tmp_val2;

//		//*yp++ =  -SSC_MULT16x32_Q15(*wp1, xp1[-N2]) + SSC_MULT16x32_Q15(*wp2, *xp2);

//		//*yp++ = SSC_MULT16x32_Q15(*wp2, *xp1)     + SSC_MULT16x32_Q15(*wp1, xp2[N2]);

//		for(;i<N4;i++)

//		{

//			/* Real part arranged as a-bR, Imag part arranged as -c-dR */

//			tmp_val = AE_MUL32X16_H0(xp1[-N2], *wp1);

//			tmp_val2 = AE_MUL32X16_H0(*xp2, *wp2);

//			*yp++ = (int)(tmp_val2>>15) - (int)(tmp_val>>15);

//

//

//			tmp_val = AE_MUL32X16_H0(*xp1, *wp2);

//			tmp_val2 = AE_MUL32X16_H0(xp2[N2], *wp1);

//			*yp++ = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

//

//			xp1+=2;

//			xp2-=2;

//			wp1+=2;

//			wp2-=2;

//		}

//	return 0;

//#####################################################################

	ae_valign    align1;

	ae_int32x2  *yp_x=(ae_int32x2 *)yp;

	ae_int32x2 tmp_xp,tmp,tmp1,tmp2;

	ae_f16x4 tmp_wp;

	align1 = AE_ZALIGN64();

	for(;i<N4;i++)

	{

//	   tmp_xp=AE_MOVDA32X2(xp1[-N2],*xp2);

//	   tmp_wp=AE_MOVDA16X2(*wp1,*wp2);

//	   tmp=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

//	   tmp=AE_NEG32S(tmp);

//	   tmp_xp=AE_MOVDA32X2(*xp1,xp2[N2]);

//	   tmp1=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

//	   tmp2=AE_SEL32_HL(tmp,tmp1);

//	   AE_SA32X2_IP(tmp2, align1, yp_x);



	   tmp_xp=AE_MOVDA32X2(*xp2,xp1[-N2]);

	   tmp_wp=AE_MOVDA16X2(*wp2,*wp1);

	   tmp=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

	   //tmp=AE_NEG32S(tmp);

	   tmp_xp=AE_MOVDA32X2(xp2[N2],*xp1);

	   tmp1=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

	   tmp2=AE_SEL32_HL(tmp,tmp1);

	   AE_SA32X2_IP(tmp2, align1, yp_x);



		xp1+=2;

		xp2-=2;

		wp1+=2;

		wp2-=2;

	}

	AE_SA64POS_FP(align1, yp_x);

	return 0;

}

#endif



#ifdef clt_mdct_forward_LOOP1_BX

int forword_mdct_loop1(int *yp,int *xp1,int *xp2,short *wp1,short *wp2,int N2)

{

//	    long long tmp_val,tmp_val2;

//	    int i;

//	    for(i=0;i<30;i++)

//		{

//	    	*yp++ = SSC_MULT16x32_Q15(*wp2, xp1[N2]) + SSC_MULT16x32_Q15(*wp1,*xp2);

//	    	*yp++ = SSC_MULT16x32_Q15(*wp1, *xp1)    - SSC_MULT16x32_Q15(*wp2, xp2[-N2]);

//

//

////		    tmp_val = AE_MUL32X16_H0(xp1[N2], *wp2);

////			tmp_val2 = AE_MUL32X16_H0(*xp2, *wp1);

////			*yp++ = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

////

////			tmp_val = AE_MUL32X16_H0(*xp1, *wp1);

////			tmp_val2 = AE_MUL32X16_H0(xp2[-N2], *wp2);

////			*yp++ = (int)(tmp_val>>15) - (int)(tmp_val2>>15);

//			xp1+=2;

//			xp2-=2;

//			wp1+=2;

//			wp2-=2;

//		}

//		return 0;

//#####################################################################

	int i;

	ae_valign    align1;

	ae_int32x2  *yp_x=(ae_int32x2 *)yp;

	ae_int32x2 tmp_xp,tmp,tmp1,tmp2;

	ae_f16x4 tmp_wp;

	align1 = AE_ZALIGN64();

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

	{

	   tmp_xp=AE_MOVDA32X2(xp1[N2],*xp2);

	   tmp_wp=AE_MOVDA16X2(*wp1,*wp2);

	   tmp=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);





	   tmp_xp=AE_MOVDA32X2(*xp1,xp2[-N2]);

	   tmp1=AE_MULFC32X16RAS_H(tmp_xp,tmp_wp);

	   tmp2=AE_SEL32_LH(tmp,tmp1);

	   //tmp3=AE_SEL32_LH(tmp2,tmp2);

	   AE_SA32X2_IP(tmp2, align1, yp_x);

		xp1+=2;

		xp2-=2;

		wp1+=2;

		wp2-=2;

	}

	AE_SA64POS_FP(align1, yp_x);

	return 0;



}

#endif

void clt_mdct_forward(const short *trig, int *in, int *out)

{

	short i;

	short N, N2, N4;

//	int f[120];

//	int f2[120];





#ifndef HW_DATASIZE

	int *f = f_enc;

	int *f2 = f2_enc;

#else

	int *f = pre_shared;

	int *f2 = &pre_shared[120];

#endif



	const short *t;

	const short *t1;



#ifdef	HW_HIFI3

	long long tmp_val,tmp_val2;

#endif





	N = 240;

	N2 = N>>1;

	N4 = N>>2;

	



	

	

	{

		/* Temp pointers to make it really clear to the compiler what we're doing */

		const int *xp1 = in+60;

		const int *xp2 = in+N2+59;

		int *yp = f;

		const short *wp1 = window+60;

		const short *wp2 = window+59;

#ifdef clt_mdct_forward_LOOP1_BX



		forword_mdct_loop1(yp,xp1,xp2,wp1,wp2, N2);

//int forword_mdct_loop1(int *yp,int *xp1,int *xp2,short *wp1,short *wp2,int N2)



		i=30;

		yp+=60;

		xp1+=60;

		xp2-=60;



#else

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

		{

			/* Real part arranged as -d-cR, Imag part arranged as -b+aR*/

#ifndef HW_HIFI3

			*yp++ = SSC_MULT16x32_Q15(*wp2, xp1[N2]) + SSC_MULT16x32_Q15(*wp1,*xp2);

			*yp++ = SSC_MULT16x32_Q15(*wp1, *xp1)    - SSC_MULT16x32_Q15(*wp2, xp2[-N2]);

#else

			tmp_val = AE_MUL32X16_H0(xp1[N2], *wp2);

			tmp_val2 = AE_MUL32X16_H0(*xp2, *wp1);

			*yp++ = (int)(tmp_val>>15) + (int)(tmp_val2>>15);



			tmp_val = AE_MUL32X16_H0(*xp1, *wp1);

			tmp_val2 = AE_MUL32X16_H0(xp2[-N2], *wp2);

			*yp++ = (int)(tmp_val>>15) - (int)(tmp_val2>>15);

#endif

			xp1+=2;

			xp2-=2;

			wp1+=2;

			wp2-=2;

		}

#endif

		wp1 = window;

		wp2 = window+119;

#ifdef clt_mdct_forward_LOOP2_BX

forword_mdct_loop2(yp,xp1,xp2,wp1,wp2,N4, N2,i);

#else

		for(;i<N4;i++)

		{

			/* Real part arranged as a-bR, Imag part arranged as -c-dR */



#ifndef HW_HIFI3

			*yp++ =  -SSC_MULT16x32_Q15(*wp1, xp1[-N2]) + SSC_MULT16x32_Q15(*wp2, *xp2);

			*yp++ = SSC_MULT16x32_Q15(*wp2, *xp1)     + SSC_MULT16x32_Q15(*wp1, xp2[N2]);

#else

			tmp_val = AE_MUL32X16_H0(xp1[-N2], *wp1);

			tmp_val2 = AE_MUL32X16_H0(*xp2, *wp2);

			*yp++ = (int)(tmp_val2>>15) - (int)(tmp_val>>15);





			tmp_val = AE_MUL32X16_H0(*xp1, *wp2);

			tmp_val2 = AE_MUL32X16_H0(xp2[N2], *wp1);

			*yp++ = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

#endif

			xp1+=2;

			xp2-=2;

			wp1+=2;

			wp2-=2;

		}

#endif

	}

	/* Pre-rotation */

	{

		int *yp;

		yp = f;

		t = trig;

		t1 = t+N4+1;

		i=N4;

#ifdef  clt_mdct_forward_LOOP3_BX

forword_mdct_loop3( yp, t1, t, i );



#else

		do{

			int re, im;





			

			



			re = *yp++;

			im = *yp--;

#ifndef HW_HIFI3

			*yp++ = -SSC_MULT16x32_Q15(*t, re)  -  SSC_MULT16x32_Q15(*t1, im);

			*yp++ = -SSC_MULT16x32_Q15(*t, im)  +  SSC_MULT16x32_Q15(*t1, re);

#else

			tmp_val = AE_MUL32X16_H0(re, *t);

			tmp_val2 = AE_MUL32X16_H0(im, *t1);

			*yp++ = -((int)(tmp_val>>15) + (int)(tmp_val2>>15));



			tmp_val = AE_MUL32X16_H0(im, *t);

			tmp_val2 = AE_MUL32X16_H0(re, *t1);

			*yp++ = (int)(tmp_val2>>15) - (int)(tmp_val>>15);

#endif

			t++; t1++;

		}while(--i);

#endif

	}

	sun_fft(f, f2,1);

	{

		/* Temp pointers to make it really clear to the compiler what we're doing */

		const int *fp = f2;

		int *yp1 = out;

		int *yp2 = out+(N2-1);



		t = trig;

		t1 = t+N4+1;

		i=N4;

#ifdef clt_mdct_forward_LOOP4_BX

   forword_mdct_loop4(fp, t1, t, yp1,yp2, i );

#else



		do{

#ifndef HW_HIFI3

			*yp1 = SSC_MULT16x32_Q15(*t1, fp[1]) + SSC_MULT16x32_Q15(*t, fp[0]);

			*yp2 = SSC_MULT16x32_Q15(*t1, fp[0]) - SSC_MULT16x32_Q15(*t, fp[1]);

#else

			tmp_val = AE_MUL32X16_H0(fp[1], *t1);

			tmp_val2 = AE_MUL32X16_H0(fp[0], *t);

			*yp1 = (int)(tmp_val>>15) + (int)(tmp_val2>>15);



			tmp_val = AE_MUL32X16_H0(fp[0], *t1);

			tmp_val2 = AE_MUL32X16_H0(fp[1], *t);

			*yp2 = (int)(tmp_val>>15) - (int)(tmp_val2>>15);

#endif

			t++; t1++;

			fp += 2;

			yp1 += 2;

			yp2 -= 2;

		}while(--i);

#endif





	}

}



#ifndef HW_DATASIZE

int f2_dec[120];

#endif



void clt_mdct_backward(const short *trig, int *in, int *out) 

{

	short N = 240; 

	short N2 = N>>1;

	short overlap = N2;

	short N4 = N>>2;

	short i;

#ifndef HW_DATASIZE

	int *f2 = f2_dec;	//N2

#else

	int f2[120];	//N2

#endif





#ifdef	HW_HIFI3

	long long tmp_val,tmp_val2;

#endif



	{

		/* Temp pointers to make it really clear to the compiler what we're doing */

		const int *xp1 = in;

		const int *xp2 = in+(N2-1);

		int *yp = f2;

	    const short *t0 = trig;

		const short *t1 = &trig[N4+1];

		i=N4;

#ifdef	clt_mdct_backward_LOOP1_BX

		clt_mdct_backward_loop1(yp,xp1,xp2,t0,t1, i);

#else

		do

		{

#ifndef HW_HIFI3

			*yp++ = -S_MUL(*xp2, *t0) + S_MUL(*xp1,*t1);

			*yp++ = -S_MUL(*xp2, *t1) - S_MUL(*xp1,*t0);

#else

			tmp_val = AE_MUL32X16_H0(*xp2, *t0);

			tmp_val2 = AE_MUL32X16_H0(*xp1, *t1);

			*yp++ = (int)(tmp_val2>>15) - (int)(tmp_val>>15);



			tmp_val = AE_MUL32X16_H0(*xp2, *t1);

			tmp_val2 = AE_MUL32X16_H0(*xp1,*t0);

			*yp++ = -((int)(tmp_val>>15) + (int)(tmp_val2>>15));

#endif

			t0++;

			t1++;

			xp1+=2;

			xp2-=2;

		}

		while(--i);

#endif

   }

   sun_fft(f2,(out+(overlap>>1)),0);

   {

		int *yp0 = out+(overlap>>1);

		int *yp1 = out+(overlap>>1)+N2-2;

		const short *t0 = &trig[(N4<<1)];

		const short *t1 = &trig[N4-1];

		const short *t2 = &trig[0];

		const short *t3 = &trig[N4+1];



#ifdef clt_mdct_backward_LOOP2_BX

clt_mdct_backward_loop2(yp0,yp1,t0,t1,t2,t3, N4);

#else

		for(i=0;i<(N4+1)>>1;i++)

		{

			int re, im, yr, yi;



			re = yp0[0];

			im = yp0[1];

#ifndef HW_HIFI3

			yr = S_MUL(re,t2[i]) - S_MUL(im,t3[i]);

			yi = S_MUL(im,t2[i]) + S_MUL(re,t3[i]);

#else

			tmp_val = AE_MUL32X16_H0(re, t2[i]);

			tmp_val2 = AE_MUL32X16_H0(im, t3[i]);

			yr = (int)(tmp_val>>15) - (int)(tmp_val2>>15);



			tmp_val = AE_MUL32X16_H0(im, t2[i]);

			tmp_val2 = AE_MUL32X16_H0(re, t3[i]);

			yi = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

#endif

			re = yp1[0];

			im = yp1[1];





	

			yp0[0] = -yr;

			yp1[1] = yi;

#ifndef HW_HIFI3

			yp1[0] = -S_MUL(re,t1[-i]) + S_MUL(im,t0[-i]);

			yp0[1] = S_MUL(im,t1[-i]) + S_MUL(re,t0[-i]);

#else

			tmp_val = AE_MUL32X16_H0(re, t1[-i]);

			tmp_val2 = AE_MUL32X16_H0(im, t0[-i]);

			yp1[0] = (int)(tmp_val2>>15) - (int)(tmp_val>>15);



			tmp_val = AE_MUL32X16_H0(im, t1[-i]);

			tmp_val2 = AE_MUL32X16_H0(re, t0[-i]);

			yp0[1] = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

#endif

			yp0 += 2;

			yp1 -= 2;

		}

#endif

	}

	{

		int *xp1 = out+overlap-1;

		int *yp1 = out;

		const short *wp1 = window;

		const short *wp2 = window+overlap-1;

#ifdef	clt_mdct_backward_LOOP3_BX

		clt_mdct_backward_loop3(xp1,yp1,wp1,wp2, overlap);

#else

		for(i = 0; i < (overlap>>1); i++)

		{

			int x1, x2;



			x1 = *xp1;

			x2 = *yp1;

#ifndef HW_HIFI3

			*yp1++ = SSC_MULT16x32_Q15(*wp2, x2) - SSC_MULT16x32_Q15(*wp1, x1);

			*xp1-- = SSC_MULT16x32_Q15(*wp1, x2) + SSC_MULT16x32_Q15(*wp2, x1);

#else

			tmp_val = AE_MUL32X16_H0(x2, *wp2);

			tmp_val2 = AE_MUL32X16_H0(x1, *wp1);

			*yp1++ = (int)(tmp_val>>15) - (int)(tmp_val2>>15);



			tmp_val = AE_MUL32X16_H0(x2, *wp1);

			tmp_val2 = AE_MUL32X16_H0(x1, *wp2);

			*xp1-- = (int)(tmp_val>>15) + (int)(tmp_val2>>15);

#endif

			wp1++;

			wp2--;

		}

#endif

	}

}

#endif