winamp/Src/Winamp/VIS.cpp

#include <windowsx.h>

#include "Main.h"
#include "vis.h"
#include "fft.h"
#include <bfc/platform/types.h>
#include <math.h>
#include <assert.h>
#include "./api.h"
#include "../nsutil/window.h"
#include "../nu/threadname.h"

static winampVisModule *vis_mod;
static DWORD WINAPI vis_thread(void *tmp);
static HANDLE hThread;
static DWORD visThreadId=0;
static volatile int killThread;
static int _nch = 2, _numframes=1;
int _srate = 44100;
static wchar_t _visplugin_name[512];
static int _visplugin_num;
static char *vsa_data;
static int vsa_position, vsa_entrysize=577*4;
static int vsa_length,size=576*4;
static int vis_stopping;
static CRITICAL_SECTION cs;
static HWND external_window = NULL;
static HWND external_window_host = NULL;

#ifdef _M_IX86
__inline static int lrint(float flt)
{
	int intgr;

	_asm
	{
		fld flt
		fistp intgr
	}

	return intgr;
}
#else
__inline static int lrint(float flt)
{
	return (int)flt;
}
#endif

//  quantizes to 23 bits - use appropriately
#define FASTMIN(x,b) { x = b - x;   x += (float)fabs(x);   x *= 0.5f;   x = b - x; }

static size_t vis_refCount=0;
static winampVisModule *GetVis()
{
	winampVisModule *ret = 0;
	EnterCriticalSection(&cs);
	if (vis_stopping)
	{
		LeaveCriticalSection(&cs);
		return 0;
	}
	if (vis_mod)
	{
		ret = vis_mod;
		vis_refCount++;
	}
	LeaveCriticalSection(&cs);
	return ret;
}

static void DestroyVis()
{
	killThread=1;
	vis_stopping=1;

	if (GetCurrentThreadId() != visThreadId)
	{
		HANDLE thisThread = hThread;
		LeaveCriticalSection(&cs);

		// run message pump. this shouldn't last long.
		int x=200;
		while (WaitForSingleObject(thisThread,10) == WAIT_TIMEOUT && x-- > 0)
		{
			WASABI_API_APP->app_messageLoopStep();
		}
		WaitForSingleObject(thisThread,INFINITE);
		EnterCriticalSection(&cs);
	}

	CloseHandle(hThread);
	if (vis_mod)
		FreeLibrary(vis_mod->hDllInstance);
	vis_stopping=0;
	vis_mod=0;
	
	hThread=0;
	killThread=0;
}

static void ReleaseVis(winampVisModule *vis)
{
	if (vis)
	{
		EnterCriticalSection(&cs);
		vis_refCount--;
		if (vis_refCount == 0)
		{
			DestroyVis();
		}

		LeaveCriticalSection(&cs);
	}
}

void vis_init(void)
{
	InitializeCriticalSectionAndSpinCount(&cs, 4000);
}

static char *vsa_get(int timestamp);
static void vsa_setdatasize();

int vis_running()
{
	int running=0;
	winampVisModule *vis = GetVis();
	if (vis)
	{
		running = !vis_stopping;
		ReleaseVis(vis);
	}
	return running;
}

static int priorities[5] =
{
	THREAD_PRIORITY_LOWEST,
	THREAD_PRIORITY_BELOW_NORMAL,
	THREAD_PRIORITY_NORMAL,
	THREAD_PRIORITY_ABOVE_NORMAL,
	THREAD_PRIORITY_HIGHEST
};

void vis_start(HWND hwnd, wchar_t *fn)
{
	if (vis_stopping || g_safeMode) return;
	vis_stop();
	vsa_deinit();
	if (!config_visplugin_name[0]) return;

	killThread=0;
	if (!fn || !*fn)
	{
		PathCombineW(_visplugin_name, VISDIR, config_visplugin_name);
		_visplugin_num=config_visplugin_num;
	}
	else
	{
		wchar_t buf[MAX_PATH] = {0};
		wchar_t *p;
		StringCchCopyW(buf,MAX_PATH,fn);
		p=wcsstr(buf,L",");
		if (p)
		{
			*p++=0;
			_visplugin_num=_wtoi(p);
		}
		else _visplugin_num=0;
		if (PathIsFileSpecW(buf) || PathIsRelativeW(buf))
			PathCombineW(_visplugin_name, VISDIR, buf);
		else
			StringCchCopyW(_visplugin_name,512,buf);
	}
	hThread = (HANDLE) CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) vis_thread,NULL,0,&visThreadId);
	SetThreadPriority(hThread,priorities[config_visplugin_priority]);
}

void vis_setprio()
{
	if (vis_stopping) return;
	if (hThread) SetThreadPriority(hThread,priorities[config_visplugin_priority]);
}

void vis_stop()
{
	if (vis_stopping||!hThread) return;
	EnterCriticalSection(&cs); // go into critical section so vis_mod doesn't suddenly appear out of nowhere
	winampVisModule *thisVis = vis_mod;
	LeaveCriticalSection(&cs);
	ReleaseVis(thisVis); 
}

void vis_setinfo(int srate, int nch)
{
	if (srate > 0) _srate = srate;
	if (nch > 0) _nch = nch;
	if (!vis_running()) return;
	EnterCriticalSection(&cs);
	winampVisModule *vis = GetVis();
	if (vis)
	{
		vis->sRate = _srate;
		vis->nCh = _nch;
		ReleaseVis(vis);
	}
	LeaveCriticalSection(&cs);
}

void vis_setextwindow(HWND hwnd)
{
	HWND test_window;
	unsigned int test_window_style_ex;
	unsigned long window_thread_id;

	EnterCriticalSection(&cs);

	external_window = hwnd;
	external_window_host = external_window;

	window_thread_id = GetWindowThreadProcessId(external_window, NULL);
	while(NULL != external_window_host)
	{
		test_window = GetAncestor(external_window_host, GA_PARENT);
		if (NULL != test_window && 
			window_thread_id == GetWindowThreadProcessId(test_window, NULL))
		{
			test_window_style_ex = (unsigned int)GetWindowLongPtrW(test_window, GWL_STYLE);
			if (0 != (WS_EX_CONTROLPARENT & test_window_style_ex))
			{
				external_window_host = test_window;
				continue;
			}
		}
		break;		
	}
	
	LeaveCriticalSection(&cs);
}

static winampVisModule *CreateVis(HINSTANCE visLib)
{
	EnterCriticalSection(&cs);
	winampVisModule *ret = 0;
	ret = GetVis();
	if (ret)
	{
		LeaveCriticalSection(&cs);
		return ret;
	}

	winampVisGetHeaderType pr;
	pr = (winampVisGetHeaderType) GetProcAddress(visLib,"winampVisGetHeader");
	if (!pr)
	{
		LeaveCriticalSection(&cs);
		return 0;
	}

	winampVisHeader* pv = pr(hMainWindow);
	if (!pv)
	{
		LeaveCriticalSection(&cs);
		return 0;
	}

	vis_mod = pv->getModule(_visplugin_num);
	if (!vis_mod)
	{
		LeaveCriticalSection(&cs);
		return 0;
	}

	vis_mod->sRate = _srate;
	vis_mod->nCh = _nch;
	vis_mod->hwndParent = hMainWindow;
	vis_mod->hDllInstance = visLib;

	vis_refCount++;
	LeaveCriticalSection(&cs);
	return vis_mod;
}

static BOOL vis_process_message(MSG *msg)
{
	if (msg->message >= WM_KEYFIRST && msg->message <= WM_KEYLAST &&
		msg->hwnd == external_window &&
		NULL != external_window)	
	{
		return FALSE;
	}

	if (WM_MOUSEWHEEL == msg->message && 
		NULL != external_window_host)
	{
		POINT cursor;
		HWND target_window;
		
		POINTSTOPOINT(cursor, msg->lParam);
		target_window = WindowFromPoint(cursor);

		if (NULL != target_window && 
			FALSE == IsChild(external_window_host, target_window ) &&
			GetWindowThreadProcessId(target_window, NULL) != GetWindowThreadProcessId(external_window_host, NULL))
		{
			PostMessageW(hMainWindow, msg->message, msg->wParam, msg->lParam);
			return TRUE;
		}

	}

	if (NULL != external_window_host)
		return IsDialogMessageW(external_window_host, msg);

	return FALSE;
}

static DWORD WINAPI vis_thread(void *tmp)
{
	winampVisModule *vis = 0;
	MSG Msg;
	HINSTANCE hLib=0;
	int t=0;
	SetThreadName((DWORD)-1, "Vis (plugin) thread");
	hLib = LoadLibrary(_visplugin_name);
	if (!hLib) 
	{
		t=1;
	}
	else 
	{
		vis = CreateVis(hLib);
		if (!vis)
		{
			FreeLibrary(hLib);
			hLib = 0;
			t=1;
		}
	}

	if (!t)
	{
		if (!(config_no_visseh&1))
		{
			__try
			{
				t = (vis ? vis->Init(vis) : 1);
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				t=1;
				char errstr[512] = {0};
				char caption[512] = {0};
				getString(IDS_PLUGINERROR,errstr,512);
				StringCchCatA(errstr, 512, " (1)");
				MessageBoxA(NULL,errstr,getString(IDS_ERROR,caption,512),MB_OK|MB_ICONEXCLAMATION);
			}
		}
		else
		{
			t = vis->Init(vis);
		}
	}

	if (!t)
	{
		if (config_disvis) sa_setthread(0);
		vsa_setdatasize();
	
		while (!killThread)
		{
			if (PeekMessage(&Msg,NULL,0,0,PM_REMOVE))
			{
				if (Msg.message == WM_QUIT) 
					break;

				if (FALSE == vis_process_message(&Msg))
				{
					TranslateMessage(&Msg);
					DispatchMessage(&Msg);
				}
			}
			else if (!paused)
			{
				static int upd;
				int p=playing;
				char *data=0;
				if (in_mod && p) data = vsa_get(in_mod->GetOutputTime()+vis->latencyMs);
				if (data)
				{
					int l=vis->spectrumNch;
					for (int n = 0; n < l; n ++)
					{
						memcpy(vis->spectrumData[n],data,576);
						data += 576;
					}
					l=vis->waveformNch;
					for (int n = 0; n < l; n ++)
					{
						memcpy(vis->waveformData[n],data,576);
						data += 576;
					}
				}
				if (!data)
				{
					memset(vis->spectrumData,0,576*2);
					memset(vis->waveformData,0,576*2);
				}
				if (p) upd=1;
				if (upd)
					if (!(config_no_visseh&1))
					{
						__try
						{
							if (vis->Render(vis))
							{
								break;
							}
						}
						__except(EXCEPTION_EXECUTE_HANDLER)
						{
							char errstr[512] = {0};
							char caption[512] = {0};
							getString(IDS_PLUGINERROR,errstr,512);
							StringCchCatA(errstr, 512, " (2)");
							MessageBoxA(NULL,errstr,getString(IDS_ERROR,caption,512),MB_OK|MB_ICONEXCLAMATION);
							break;
						}
					}
					else
					{
						if (vis->Render(vis)) 
						{
							break;
						}
					}
				if (!p) upd=0;
				Sleep(vis->delayMs);
			}
			else Sleep(min(1,vis->delayMs));
		}
		vsa_deinit();
		sa_setthread(config_sa);
		if (!(config_no_visseh&1))
		{
			__try
			{
				vis->Quit(vis);
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				wchar_t errstr[512] = {0};
				wchar_t caption[512] = {0};
				getStringW(IDS_PLUGINERROR,errstr,512);
				StringCchCatW(errstr, 512, L" (3)");
				MessageBoxW(NULL,errstr,getStringW(IDS_ERROR,caption,512),MB_OK|MB_ICONEXCLAMATION);
			}
		}
		else
		{
			vis->Quit(vis);
		}
		EnterCriticalSection(&cs);
		if (killThread)
		{
			LeaveCriticalSection(&cs);
			return 0;
		}
		else
		{
			ReleaseVis(vis);
			LeaveCriticalSection(&cs);
			return 0;
		}
	}
	
	ReleaseVis(vis);
	if (hLib)
		FreeLibrary(hLib);
	hLib = 0;
	return 0;
}

static int last_pos;

static void _vsa_init()
{
	vsa_deinit();
	if (_numframes < 1) _numframes=1;
	vsa_entrysize = 4+size;
	vsa_data = (char *) GlobalAlloc(GPTR,vsa_entrysize * _numframes);
	vsa_position=0;
	vsa_length = _numframes;
}

void vsa_init(int numframes)
{
	EnterCriticalSection(&cs);
	if (vis_running())
	{
		last_pos=0;
		_numframes=numframes;
		_vsa_init();
	}
	else
	{
		last_pos=0;
		_numframes=numframes;
	}
	LeaveCriticalSection(&cs);
}

static void vsa_setdatasize()
{
	EnterCriticalSection(&cs);
	winampVisModule *vis = GetVis();
	if (vis)
	{
		size=576*(vis->waveformNch+vis->spectrumNch);
		_vsa_init();
		ReleaseVis(vis);
	}

	LeaveCriticalSection(&cs);
}

int vsa_add(void *data, int timestamp)
{
	if (!vsa_data) return 1;
	EnterCriticalSection(&cs);
	if (vsa_data) // check again, it might have gone away while we were waiting on the CS
	{
		if (vsa_length < 2)
		{
			vsa_position = 0;
		}
		char *c = vsa_data + vsa_position*vsa_entrysize;
		*(int32_t *)c=timestamp;

		memcpy(c+4,data,vsa_entrysize-4);
		if (++vsa_position >= vsa_length) vsa_position -= vsa_length;
		LeaveCriticalSection(&cs);
		return 0;
	}
	else
	{
		LeaveCriticalSection(&cs);
		return 1;
	}
}

void vsa_deinit(void)
{
	EnterCriticalSection(&cs);
	if (vsa_data)
	{
		GlobalFree(vsa_data);
		vsa_data=0;
		vsa_length=0;
	}
	LeaveCriticalSection(&cs);
}

static char *vsa_get(int timestamp)
{
	int i,x, closest=1000000, closest_v = -1;
	if (!vsa_data) return NULL;
	if (vsa_length<2)
	{
		return vsa_data+4;
	}
	EnterCriticalSection(&cs);
	x=last_pos;
	if (x >= vsa_length) x=0;
	for (i = 0; i < vsa_length; i ++)
	{
		int *q = (int *)(vsa_data+x*vsa_entrysize);
		int d = timestamp-*q;
		if (++x == vsa_length) x=0;
		if (d < 0) d = -d;
		if (d < closest)
		{
			closest = d;
			closest_v = x;
		}
		else if (closest<200) break;
	}
	if (closest_v >= 0)
	{
		static char data[576*4];
		last_pos=closest_v;
		memcpy(data,vsa_data+vsa_entrysize*closest_v+4,vsa_entrysize-4);
		LeaveCriticalSection(&cs);
		return data;
	}
	else
	{
		LeaveCriticalSection(&cs);
		return 0;
	}
}

int vsa_getmode(int *sp, int *wa)
{
	int rv=0;
		winampVisModule *vis = GetVis();
	if (vis)
	{
		EnterCriticalSection(&cs);
		*sp=vis->spectrumNch;
		*wa=vis->waveformNch;
		rv=1;

		LeaveCriticalSection(&cs);
		ReleaseVis(vis);
	}
	else *sp=*wa=0;
	return rv;
}

void FillRealSamples_8Bit(unsigned char *data, const int stride, const int channels, float *samples, const float divider)
{
	int frame,c;
	const float p = (float)channels*divider;

	for (frame = 0; frame <512; frame ++)
	{
		//done by memset - samples[x*2]=0;
		for (c=0;c<channels;c++)
		{
			samples[frame] += (float)(*data - 128);
			data+=stride; // jump to the next sample (channels are interleaved)
		}

		samples[frame] /= p;
		//done by memset - wavetrum[x*2+1] = 0.0f;
	}
	nsutil_window_Hann_F32_IP(samples, 512);
}

#define SA_DC_FILTER
void FillRealSamples(char *ptr, const int stride, const int channels, float *samples, const float divider)
{
#ifdef SA_DC_FILTER
	float x1=0, y1=0;
#endif
	int frame, c;
	const float p=(float)channels * divider;

	// we're calculating using only the most significant byte,
	// because we only end up with 6 bit data anyway
	// if you want full resolution, check out CVS tag BETA_2005_1122_182830, file: vis.c

	for (frame = 0;frame <512;frame++)
	{
		//done by memset - wavetrum[x*2]=0;
		float x=0;
		for (c=0;c<channels;c++)
		{
			x += (float)(*ptr);
			ptr+=stride; // jump to the next sample (channels are interleaved)
		}
#ifdef SA_DC_FILTER
		float y = x - x1 + 0.99f * y1;
		y1=y;
		x1=x;
#else
		float y=x;
#endif
		y/=p;

		samples[frame]=y;
		//done by memset - wavetrum[x*2+1] = 0.0f;
	}
		nsutil_window_Hann_F32_IP(samples, 512);
}

void vsa_addpcmdata(void *_data_buf, int numChannels, int numBits, int ts)
{
	char *data_buf = reinterpret_cast<char *>(_data_buf);
	// begin vis plugin stuff
	winampVisModule *vis = GetVis();
	if (vis)
	{
		__declspec(align(32)) float wavetrum[512];
		extern int vsa_add(void *data, int timestamp);
		char data[576*4*2] = {0};
		int data_offs=0;
		int y,x,spectrumChannels, waveformChannels, stride;

		spectrumChannels=min(numChannels,vis->spectrumNch);
		stride=numBits/8;

		for (y = 0; y < spectrumChannels; y ++)
		{
			if (spectrumChannels == 1) // downmix to mono, if necessary
			{
				if (numBits == 8)
					FillRealSamples_8Bit((unsigned char*)data_buf, 1, numChannels, wavetrum, 1.f);
				else
				{
					const int stride=numBits/8; // number of bytes between samples
					char *ptr = data_buf+y*stride+stride-1; // offset for little endian
					FillRealSamples(ptr, stride, numChannels, wavetrum, 1.f);
				}
			}
			else // TODO: deal with 'downmixing' to stereo if channels>2
			{
				if (numBits == 8)
					FillRealSamples_8Bit((unsigned char*)data_buf, numChannels, 1, wavetrum, 1.f);
				else
				{
					const int stride=numBits/8; // number of bytes between samples
					char *ptr = data_buf+y*stride+stride-1; // offset for little endian
					FillRealSamples(ptr, stride*numChannels, 1, wavetrum, 1.f);
				}
			}
			fft_9(wavetrum);
			{
				float la=0;
				int thisBand=0;

				for (x = 0; x < 256; x ++)
				{
					float sinT = wavetrum[x*2];
					float cosT = wavetrum[x*2+1];

					float thisValue=(float)sqrt(sinT*sinT+cosT*cosT)/16.0f;
					thisBand++;

					FASTMIN(thisValue, 255.f);
					data[data_offs++] = lrint((thisValue + la)/2.f);
					//data[data_offs++] = lrint((thisValue + thisValue + la)/3.f);
					data[data_offs++] = lrint(thisValue);
					la=thisValue;
				}
				while ((data_offs % 576)!=0)
				{
					la/=2;
					data[data_offs++]=lrint(la);
				}

				assert((data_offs % 576)==0);
			}
		}

		if (numChannels == 1 && vis->spectrumNch == 2) // upmix, if necessary
		{
			memcpy(data+data_offs,data+data_offs-576,576);
			data_offs+=576;
		}

		waveformChannels=min(numChannels,vis->waveformNch);
		if (waveformChannels == 1) 		// downmix to mono, if necessary
		{
			char *ptr = data_buf+stride-1; // offset for little endian
			for (x=0;x<576;x++)
			{
				__int32 mix=0;
				for (int channel=0;channel<numChannels;channel++)
				{
					mix += (*ptr);
					ptr+=stride; // jump to the next sample (channels are interleaved)
				}
				data[data_offs++] = (char)(mix / numChannels);
			}
		}
		else // TODO: deal with 'downmixing' to stereo if numChannels>2
		{
			for (y = 0; y < waveformChannels; y++)
			{
				char *ptr = data_buf+y*stride+stride-1; // offset for little endian
				for (x=0;x<576;x++)
				{
					data[data_offs++] = *ptr;
					ptr+=stride*numChannels;
				}
			}
		}

		if (numChannels == 1 && vis->waveformNch == 2)
		{
			memcpy(data+data_offs,data+data_offs-576,576);
			//data_offs+=576;
		}
		vsa_add(data,ts);
		ReleaseVis(vis);
	}
}

HWND hVisWindow, hPLVisWindow;

LRESULT CALLBACK VIS_WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_RBUTTONDOWN:
		case WM_RBUTTONUP:
		case WM_LBUTTONDBLCLK:
		{
			RECT r1, r2;
			int xPos = GET_X_LPARAM(lParam);  // horizontal position of cursor
			int yPos = GET_Y_LPARAM(lParam);
			if (hwnd == hVisWindow)
			{
				GetWindowRect(hMainWindow,&r1);
			}
			else GetWindowRect(hPLWindow,&r1);
			GetWindowRect(hwnd,&r2);
			xPos += r2.left-r1.left;
			yPos += r2.top-r1.top;
			lParam = MAKELPARAM(xPos,yPos);
			SendMessageW(hwnd == hVisWindow?hMainWindow:hPLWindow,message,wParam,lParam);
			return 0;
		}
		case WM_USER+0xebe:
		case WM_DROPFILES:
			return SendMessageW(GetParent(hwnd),message,wParam,lParam);
		case WM_CREATE:
			if (NULL != WASABI_API_APP)
				WASABI_API_APP->app_registerGlobalWindow(hwnd);
			break;
		case WM_DESTROY:
			if (NULL != WASABI_API_APP)
				WASABI_API_APP->app_unregisterGlobalWindow(hwnd);
			break;
	}

	if (FALSE != IsDirectMouseWheelMessage(message))
	{
		SendMessageW(hwnd, WM_MOUSEWHEEL, wParam, lParam);
		return TRUE;
	}

	return DefWindowProcW(hwnd,message,wParam,lParam);
}