/*
	BASS spectrum analyser example
	Copyright (c) 2002-2014 Un4seen Developments Ltd.
*/

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <malloc.h>
#include "bass.h"

#define SPECWIDTH 368	// display width
#define SPECHEIGHT 127	// height (changing requires palette adjustments too)

HWND win = NULL;
DWORD timer = 0;

DWORD chan;

HDC specdc = 0;
HBITMAP specbmp = 0;
BYTE *specbuf;

int specmode = 0, specpos = 0; // spectrum mode (and marker pos for 3D mode)

// display error messages
void Error(const char *es)
{
	char mes[200];
	sprintf(mes, "%s\n(error code: %d)", es, BASS_ErrorGetCode());
	MessageBox(win, mes, 0, 0);
}

// select a file to play, and play it
BOOL PlayFile()
{
	char file[MAX_PATH] = "";
	OPENFILENAME ofn = { 0 };
	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = win;
	ofn.nMaxFile = MAX_PATH;
	ofn.lpstrFile = file;
	ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_EXPLORER;
	ofn.lpstrTitle = "Select a file to play";
	ofn.lpstrFilter = "playable files\0*.mo3;*.xm;*.mod;*.s3m;*.it;*.mtm;*.umx;*.mp3;*.mp2;*.mp1;*.ogg;*.wav;*.aif\0All files\0*.*\0\0";
	if (!GetOpenFileName(&ofn)) return FALSE;

	if (!(chan = BASS_StreamCreateFile(FALSE, file, 0, 0, BASS_SAMPLE_LOOP))
		&& !(chan = BASS_MusicLoad(FALSE, file, 0, 0, BASS_MUSIC_RAMP | BASS_SAMPLE_LOOP, 1))) {
		Error("Can't play file");
		return FALSE; // Can't load the file
	}

	BASS_ChannelPlay(chan, FALSE);

	return TRUE;
}

// update the spectrum display - the interesting bit :)
void CALLBACK UpdateSpectrum(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
{
	HDC dc;
	int x, y, y1;

	if (specmode == 3) { // waveform
		int c;
		float *buf;
		BASS_CHANNELINFO ci;
		memset(specbuf, 0, SPECWIDTH * SPECHEIGHT);
		BASS_ChannelGetInfo(chan, &ci); // get number of channels
		buf = alloca(ci.chans * SPECWIDTH * sizeof(float)); // allocate buffer for data
		BASS_ChannelGetData(chan, buf, (ci.chans * SPECWIDTH * sizeof(float)) | BASS_DATA_FLOAT); // get the sample data (floating-point to avoid 8 & 16 bit processing)
		for (c = 0; c < ci.chans; c++) {
			for (x = 0; x < SPECWIDTH; x++) {
				int v = (1 - buf[x * ci.chans + c]) * SPECHEIGHT / 2; // invert and scale to fit display
				if (v < 0) v = 0;
				else if (v >= SPECHEIGHT) v = SPECHEIGHT - 1;
				if (!x) y = v;
				do { // draw line from previous sample...
					if (y < v) y++;
					else if (y > v) y--;
					specbuf[y * SPECWIDTH + x] = c & 1 ? 127 : 1; // left=green, right=red (could add more colours to palette for more chans)
				} while (y != v);
			}
		}
	} else {
		float fft[1024];
		BASS_ChannelGetData(chan, fft, BASS_DATA_FFT2048); // get the FFT data

		if (!specmode) { // "normal" FFT
			memset(specbuf, 0, SPECWIDTH * SPECHEIGHT);
			for (x = 0; x < SPECWIDTH / 2; x++) {
#if 1
				y = sqrt(fft[x + 1]) * 3 * SPECHEIGHT - 4; // scale it (sqrt to make low values more visible)
#else
				y = fft[x + 1] * 10 * SPECHEIGHT; // scale it (linearly)
#endif
				if (y > SPECHEIGHT) y = SPECHEIGHT; // cap it
				if (x && (y1 = (y + y1) / 2)) // interpolate from previous to make the display smoother
					while (--y1 >= 0) specbuf[y1 * SPECWIDTH + x * 2 - 1] = y1 + 1;
				y1 = y;
				while (--y >= 0) specbuf[y * SPECWIDTH + x * 2] = y + 1; // draw level
			}
		} else if (specmode == 1) { // logarithmic, combine bins
			int b0 = 0;
			memset(specbuf, 0, SPECWIDTH * SPECHEIGHT);
#define BANDS 28
			for (x = 0; x < BANDS; x++) {
				float peak = 0;
				int b1 = pow(2, x * 10.0 / (BANDS - 1));
				if (b1 <= b0) b1 = b0 + 1; // make sure it uses at least 1 FFT bin
				if (b1 > 1023) b1 = 1023;
				for (; b0 < b1; b0++)
					if (peak < fft[1 + b0]) peak = fft[1 + b0];
				y = sqrt(peak) * 3 * SPECHEIGHT - 4; // scale it (sqrt to make low values more visible)
				if (y > SPECHEIGHT) y = SPECHEIGHT; // cap it
				while (--y >= 0)
					memset(specbuf + y * SPECWIDTH + x * (SPECWIDTH / BANDS), y + 1, SPECWIDTH / BANDS - 2); // draw bar
			}
		} else { // "3D"
			for (x = 0; x < SPECHEIGHT; x++) {
				y = sqrt(fft[x + 1]) * 3 * 127; // scale it (sqrt to make low values more visible)
				if (y > 127) y = 127; // cap it
				specbuf[x * SPECWIDTH + specpos] = 128 + y; // plot it
			}
			// move marker onto next position
			specpos = (specpos + 1) % SPECWIDTH;
			for (x = 0; x < SPECHEIGHT; x++) specbuf[x * SPECWIDTH + specpos] = 255;
		}
	}

	// update the display
	dc = GetDC(win);
	BitBlt(dc, 0, 0, SPECWIDTH, SPECHEIGHT, specdc, 0, 0, SRCCOPY);
	ReleaseDC(win, dc);
}

// window procedure
LRESULT CALLBACK SpectrumWindowProc(HWND h, UINT m, WPARAM w, LPARAM l)
{
	switch (m) {
		case WM_PAINT:
			if (GetUpdateRect(h, 0, 0)) {
				PAINTSTRUCT p;
				HDC dc;
				if (!(dc = BeginPaint(h, &p))) return 0;
				BitBlt(dc, 0, 0, SPECWIDTH, SPECHEIGHT, specdc, 0, 0, SRCCOPY);
				EndPaint(h, &p);
			}
			return 0;

		case WM_LBUTTONUP:
			specmode = (specmode + 1) % 4; // change spectrum mode
			memset(specbuf, 0, SPECWIDTH * SPECHEIGHT);	// clear display
			return 0;

		case WM_CREATE:
			win = h;
			// initialize BASS
			if (!BASS_Init(-1, 44100, 0, win, NULL)) {
				Error("Can't initialize device");
				return -1;
			}
			if (!PlayFile()) { // start a file playing
				BASS_Free();
				return -1;
			}
			{ // create bitmap to draw spectrum in (8 bit for easy updating)
				BYTE data[2000] = { 0 };
				BITMAPINFOHEADER *bh = (BITMAPINFOHEADER*)data;
				RGBQUAD *pal = (RGBQUAD*)(data + sizeof(*bh));
				int a;
				bh->biSize = sizeof(*bh);
				bh->biWidth = SPECWIDTH;
				bh->biHeight = SPECHEIGHT; // upside down (line 0=bottom)
				bh->biPlanes = 1;
				bh->biBitCount = 8;
				bh->biClrUsed = bh->biClrImportant = 256;
				// setup palette
				for (a = 1; a < 128; a++) {
					pal[a].rgbGreen = 256 - 2 * a;
					pal[a].rgbRed = 2 * a;
				}
				for (a = 0; a < 32; a++) {
					pal[128 + a].rgbBlue = 8 * a;
					pal[128 + 32 + a].rgbBlue = 255;
					pal[128 + 32 + a].rgbRed = 8 * a;
					pal[128 + 64 + a].rgbRed = 255;
					pal[128 + 64 + a].rgbBlue = 8 * (31 - a);
					pal[128 + 64 + a].rgbGreen = 8 * a;
					pal[128 + 96 + a].rgbRed = 255;
					pal[128 + 96 + a].rgbGreen = 255;
					pal[128 + 96 + a].rgbBlue = 8 * a;
				}
				// create the bitmap
				specbmp = CreateDIBSection(0, (BITMAPINFO*)bh, DIB_RGB_COLORS, (void**)&specbuf, NULL, 0);
				specdc = CreateCompatibleDC(0);
				SelectObject(specdc, specbmp);
			}
			// start update timer (40hz)
			timer = timeSetEvent(25, 25, (LPTIMECALLBACK)&UpdateSpectrum, 0, TIME_PERIODIC);
			break;

		case WM_DESTROY:
			if (timer) timeKillEvent(timer);
			BASS_Free();
			if (specdc) DeleteDC(specdc);
			if (specbmp) DeleteObject(specbmp);
			PostQuitMessage(0);
			break;
	}
	return DefWindowProc(h, m, w, l);
}

int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASS wc = { 0 };
	MSG msg;

	// check the correct BASS was loaded
	if (HIWORD(BASS_GetVersion()) != BASSVERSION) {
		MessageBox(0, "An incorrect version of BASS.DLL was loaded", 0, MB_ICONERROR);
		return 0;
	}

	// register window class and create the window
	wc.lpfnWndProc = SpectrumWindowProc;
	wc.hInstance = hInstance;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.lpszClassName = "BASS-Spectrum";
	if (!RegisterClass(&wc) || !CreateWindow("BASS-Spectrum",
			"BASS spectrum example (click to switch mode)",
			WS_POPUPWINDOW | WS_CAPTION | WS_VISIBLE, 200, 200,
			SPECWIDTH + 2 * GetSystemMetrics(SM_CXDLGFRAME),
			SPECHEIGHT + GetSystemMetrics(SM_CYCAPTION) + 2 * GetSystemMetrics(SM_CYDLGFRAME),
			NULL, NULL, hInstance, NULL)) {
		Error("Can't create window");
		return 0;
	}
	ShowWindow(win, SW_SHOWNORMAL);

	while (GetMessage(&msg, NULL, 0, 0) > 0) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}