Add a global phase shifting function (don't change amplitude position) in the x86 assembly code (complex number * (cos(a) + isin(a))) for frequency > 0, 0 for frequency = 0, and (complex number * (cos(a) - isin(a))) for frequency < 0:

// MV's Short-Time Fourier Transform Framework
// Frame Size: 1024
//   Hop Size: 256
//    Overlap: 75%

// Inputs
streamin inL;				// left  channel input (L,*,*,*)
streamin inR;				// right channel input (R,*,*,*)
floatarrayin win[1024];		// window function (win,win,win,win)

// Outputs
streamout outL;				// left  channel output (L,*,*,*)
streamout outR;				// right channel output (R,*,*,*)

// Arrays
float inBuffer[1024]=0;		// circular input buffer (L,*,R,*)
float outBufferL[1024]=0;	// left  channel output buffer (L0,L1,L2,L3)
float outBufferR[1024]=0;	// right channel output buffer (R0,R1,R2,R3)
float inData[1024]=0;		// FFT input  array (Re_L,Im_L,Re_R,Im_R)
float outData[1024]=0;		// FFT output array (Re_L,Im_L,Re_R,Im_R)
float brx[1024]=0;			// bit reversal index map (brx,*,*,*)

// FFT size related parameters
float n=1024;	// FFT size
float invn=0;	// 1/FFT size
int N=0;		// integer (16x) FFT size 	

// variables
int istep=0;	int mmax=0;		int mfft=0;	// FFT internal
float k1=0;		float k2=0;					// coeffs for twiddle factor recursion

// constants
int true=-1;
int mask02=0;	// (true,false,true,false)

float F0=0;		float F1=1;		float F16 = 16;
float FM1=-1;	float FM2=-2;	float FM16=-16;
float FP66=0.66666667;

float mpmp=1;	// (-1,+1,-1,+1)

// tan approximation
float ta1=-15.82785243;		float tb0=10.07632266;
float ta3=4.38079593;		float tb2=-11.07632266;
float ta5=-0.109285181;

stage0;	/******************************************/

// FFT size related
movaps xmm1,F1; divps xmm1,n; movaps invn,xmm1;
cvtps2dq xmm0,n; pslld xmm0,4; movaps N,xmm0;

// some masks and multipliers
fld FM1[0]; fst mpmp[0]; fstp mpmp[2];
fld true[0]; fst mask02[0]; fstp mask02[2];

// bit reversal index map
push ebx; 	// j
push ecx;	// m
mov eax,0; mov ebx,0;				// i = j = 0

iLoop:
	mov brx[eax],ebx;				// brx[i] = j
	mov ecx,N[0]; shr ecx,1; 		// m = N/2
	
	mjLoop:
		cmp ecx,ebx; jg mjLoopEnd;	// if j < m break
		sub ebx,ecx; 				// j = j - m
		cmp ecx,16; jng mjLoopEnd;	// if m <= 1 break
		shr ecx,1; 					// m = m/2
		jmp mjLoop;
	mjLoopEnd:
	
	add ebx,ecx; 					// j = j + m
	add eax,16; 					// i = i + 1
cmp eax,N[0]; jl iLoop;

pop ecx;
pop ebx;

stage2;	/******************************************/

// every 256 samples populate inData array, do FFT, processing, IFFT, outBuffer

mov eax,ecx; and eax,255; cmp eax,0; jnz skipFFT;

	push ebx;
	mov eax,ecx; and eax,1023; shl eax,4;	// eax starts at current position
	mov ebx,0;								// ebx starts at zero
	
	inDataLoop:
		movaps xmm0,inBuffer[eax]; 
		movaps xmm1,win[ebx]; mulps xmm0,xmm1; 	// analysis window
		mulps xmm0,invn;						// 1/N normalization
		movaps inData[ebx],xmm0;				// (L,0,R,0)
		
		add eax,16; and eax,16383;
		add ebx,16;
	cmp ebx,N[0]; jl inDataLoop;
	
	pop ebx;
	
	//*************************
	// FFT
	//*************************
	
	mov eax,N[0]; mov istep[0],eax;
	push ebx; mov ebx,eax;
	
	whileIstep:	// istep >= 2
		mov eax,istep[0]; shr eax,1; mov mmax[0],eax; 
	
		// compute k1, k2
		cvtdq2ps xmm5,mmax; shufps xmm5,xmm5,0; movaps xmm2,F16;
		divps xmm2,xmm5; mulps xmm2,mpmp;	// xmm3 is f
		movaps xmm3,xmm2; mulps xmm2,xmm2; 	// xmm2 is f^2
	
		movaps xmm0,ta5; mulps xmm0,xmm2;
		addps xmm0,ta3; mulps xmm0,xmm2;
		addps xmm0,ta1; mulps xmm0,xmm3;	// xmm0 is numerator
	
		movaps xmm1,tb2; addps xmm1,xmm2;
		mulps xmm1,xmm2; addps xmm1,tb0;	// xmm1 is denominator
		divps xmm0,xmm1; movaps k1,xmm0;	// k1 = -tan
	
		movaps xmm1,FM2; mulps xmm1,xmm0; 
		mulps xmm0,xmm0; addps xmm0,F1;
		divps xmm1,xmm0; movaps k2,xmm1;	// assign k2
	
		movaps xmm0,F1;		// Re(w) = 1
		movaps xmm1,F0;		// Im(w) = 0
		mov eax,0; mov mfft[0],eax;		// m = 0
	
		doM:	// m = 0, m < mmax, 16
			mov eax,mfft[0];
			
			doI:	// i = m, i < n, istep
				// get data(i)
				movaps xmm5,inData[eax]; movaps xmm4,xmm5;
				
				// get data(j)
				add eax,mmax[0]; movaps xmm2,inData[eax];
				
				// complex multiply (data(i) - data(j))*w
				// data structure is (x,y,x,y)
				// twiddle factor w is 
				// xmm0 = (cos,cos,cos,cos)
				// xmm1 = (sin,-sin,sin,-sin)
				subps xmm5,xmm2; movaps xmm3,xmm5; mulps xmm5,xmm0;
				mulps xmm3,xmm1; shufps xmm3,xmm3,177;
				subps xmm5,xmm3;
				
				// write data(j)
				 movaps inData[eax],xmm5;
				
				// write data(i)
				sub eax,mmax[0]; addps xmm4,xmm2; movaps inData[eax],xmm4;
	
				// increment i
				add eax,istep[0]; cmp eax,ebx;	// i < n?
			jl doI;		
			// end doI
		
			// update twiddle factors
			movaps xmm2,k1; mulps xmm2,xmm0; addps xmm1,xmm2;	// tmp
			movaps xmm2,k2; mulps xmm2,xmm1; addps xmm0,xmm2;	// cos
			movaps xmm2,k1; mulps xmm2,xmm0; addps xmm1,xmm2;	// sin
			// xmm0 is (cos,cos,cos,cos)
			// xmm1 is (-sin,sin,-sin,sin)
				
			// increment m
			mov eax,mfft[0]; add eax,16; mov mfft[0],eax;
			sub eax,mmax[0]; cmp eax,0;	// m < mmax?
		jl doM;
		// end doM
	
		mov eax,mmax[0]; mov istep[0],eax; cmp eax,32; 	// istep >= 2?
	jnl whileIstep;
	
	pop ebx;
	
	// end FFT
	
	//**************************
	// Fourier Domain Processing
	//**************************
	
	push ebx;
	mov eax,0;
	
	fDomainLoop:
		// if you don't need ordered bins comment the following line and use eax instead of ebx
		mov ebx,brx[eax];	// ebx is "ordered" index in the Fourier domain
		movaps xmm0,inData[ebx];	// (Re_L,Im_L,Re_R,Im_R)
		
		// do your funky stuff here...
		
		movaps outData[ebx],xmm0;	// (Re_L,Im_L,Re_R,Im_R)
	add eax,16; cmp eax,N[0]; jl fDomainLoop;
	
	pop ebx;
	
	// end Fourier domain processing
	
	//*************************
	// IFFT
	//*************************
	
	mov eax,16; mov mmax[0],eax;
	movaps xmm0,F0; movaps k1,xmm0; movaps k2,xmm0;
	push ebx; mov ebx,N[0];
	
	whileMmaxInv:	// mmax < n
		mov eax,mmax[0];
		shl eax,1;		// *2
		mov istep[0],eax;
		movaps xmm0,F1;		// Re(w) = 1
		movaps xmm1,F0;		// Im(w) = 0
		mov eax,0; mov mfft[0],eax;		// m = 0
	
		doMinv:	// m = 0, m < mmax, 16
			mov eax,mfft[0];
			
			doIinv:	// i = m, i < n, istep
				// get data(i)
				movaps xmm5,outData[eax]; movaps xmm4,xmm5;
				
				// get data(j)
				add eax,mmax[0]; movaps xmm2,outData[eax];
				
				// complex multiply data(j)*w
				// data structure is (x,y,x,y)
				// twiddle factor w is 
				// xmm0 = (cos,cos,cos,cos)
				// xmm1 = (sin,-sin,sin,-sin)
				movaps xmm3,xmm2; mulps xmm2,xmm0;
				mulps xmm3,xmm1; shufps xmm3,xmm3,177;
				subps xmm2,xmm3;	// xmm2 is temp
				
				// write data(j)
				subps xmm5,xmm2; movaps outData[eax],xmm5;
				
				// write data(i)
				sub eax,mmax[0]; addps xmm4,xmm2; movaps outData[eax],xmm4;
	
				// increment i
				add eax,istep[0]; cmp eax,ebx;	// i < n?
			jl doIinv;		
			// end doIinv
		
			// update twiddle factors
			movaps xmm2,k1; mulps xmm2,xmm0; addps xmm1,xmm2;	// tmp
			movaps xmm2,k2; mulps xmm2,xmm1; addps xmm0,xmm2;	// cos
			movaps xmm2,k1; mulps xmm2,xmm0; addps xmm1,xmm2;	// sin
			// xmm0 is (cos,cos,cos,cos)
			// xmm1 is (-sin,sin,-sin,sin)
	
			// increment m
			mov eax,mfft[0]; add eax,16; mov mfft[0],eax;
			sub eax,mmax[0]; cmp eax,0;	// m < mmax?
		jl doMinv;
		// end doMinv
	
		mov eax,istep[0]; mov mmax[0],eax;
	
		// compute k1, k2
		cvtdq2ps xmm5,mmax; shufps xmm5,xmm5,0; movaps xmm2,FM16;
		divps xmm2,xmm5; mulps xmm2,mpmp;	// xmm3 is f
		movaps xmm3,xmm2; mulps xmm2,xmm2; 	// xmm2 is f^2
	
		movaps xmm0,ta5; mulps xmm0,xmm2;
		addps xmm0,ta3; mulps xmm0,xmm2;
		addps xmm0,ta1; mulps xmm0,xmm3;	// xmm0 is numerator
	
		movaps xmm1,tb2; addps xmm1,xmm2;
		mulps xmm1,xmm2; addps xmm1,tb0;	// xmm1 is denominator
		divps xmm0,xmm1; movaps k1,xmm0;	// k1 = -tan
	
		movaps xmm1,FM2; mulps xmm1,xmm0; 
		mulps xmm0,xmm0; addps xmm0,F1;
		divps xmm1,xmm0; movaps k2,xmm1;	// assign k2
	
		mov eax,mmax[0]; sub eax,N[0]; cmp eax,0; 	// mmax < n?
	jl whileMmaxInv;
	
	pop ebx;
	
	// end IFFT

	//***********************************
	// Pack Left and Right Output Buffers
	//***********************************

	push ebx;
	mov eax,ecx; and eax,1023; shl eax,4;	// eax starts at current position
	mov ebx,0;								// ebx starts at 0
	
	outDataLoop:
		movaps xmm0,outData[ebx]; 		// (L,*,R,*) ignore imaginary parts
		movaps xmm1,win[ebx];			// (win,win,win,win)
		movaps xmm2,outBufferL[eax];	// (L0,L1,L2,L3)
		movaps xmm3,outBufferR[eax];	// (R0,R1,R2,R3)
		mulps xmm0,xmm1;				// synthesis window
		mulps xmm0,FP66;				// OLA normalization (Hann window)
		
		// shuffle the results from outData into the outBuffers
		
		movaps xmm1,xmm0;
		shufps xmm0,xmm2,0;				// 0044 (L,L ,L0,L0)
		shufps xmm0,xmm2,152;			// 0256 (L,L0,L1,L2)
		movaps outBufferL[eax],xmm0;
		
		shufps xmm1,xmm3,10;			// 2244 (R,R ,R0,R0)
		shufps xmm1,xmm3,152;			// 0256 (R,R0,R1,R2)
		movaps outBufferR[eax],xmm1;
		
		add eax,16; and eax,16383;
		add ebx,16;
	cmp ebx,N[0]; jl outDataLoop;
	
	pop ebx;
	
	// end pack output buffers

skipFFT:

// overlap and add output

mov eax,ecx; and eax,1023; shl eax,4;

movaps xmm0,outBufferL[eax];			// 		(L0,L1,L2,L3)
movaps xmm2,xmm0; shufps xmm2,xmm2,177;	// 1032 (L1,L0,L3,L2)
addps xmm0,xmm2;						// 		(L0+L1,L0+L1,L2+L3,L2+L3)
movaps xmm2,xmm0; shufps xmm0,xmm2,78;	// 2301 (L2+L3,L2+L3,L0+L1,L0+L1)
addps xmm0,xmm2; movaps outL,xmm0;		//		(L0+L1+L2+L3,*,*,*)

movaps xmm1,outBufferR[eax];			// 		(R0,R1,R2,R3)
movaps xmm3,xmm1; shufps xmm3,xmm3,177;	// 1032	(R1,R0,R3,R2)
addps xmm1,xmm3;						// 		(R0+R1,R0+R1,R2+R3,R2+R3)
movaps xmm3,xmm1; shufps xmm1,xmm3,78;	// 2301	(R2+R3,R2+R3,R0+R1,R0+R1)
addps xmm1,xmm3; movaps outR,xmm1;		// 		(R0+R1+R2+R3,*,*,*)

// pack and buffer left and right channel inputs

movaps xmm0,inL; movaps xmm1,inR;
shufps xmm0,xmm1,68;		// 0145
andps xmm0,mask02;			// (inL,0,inR,0)

mov eax,ecx; and eax,1023; shl eax,4;
movaps inBuffer[eax],xmm0;	// (inL,0,inR,0)