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

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

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

HWND win = NULL;
DWORD timer = 0;

HRECORD chan;	// recording channel

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);
}

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

	if (specmode == 3) { // waveform
		short buf[SPECWIDTH];
		memset(specbuf, 0, SPECWIDTH * SPECHEIGHT);
		BASS_ChannelGetData(chan, buf, sizeof(buf)); // get the sample data
		for (x = 0; x < SPECWIDTH; x++) {
			int v = (32767 - buf[x]) * SPECHEIGHT / 65536; // invert and scale to fit display
			if (!x) y = v;
			do { // draw line from previous sample...
				if (y < v) y++;
				else if (y > v) y--;
				specbuf[y * SPECWIDTH + x] = abs(y - SPECHEIGHT / 2) * 2 + 1;
			} 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);
	if (LOWORD(BASS_ChannelGetLevel(chan)) < 1000) { // check if it's quiet
		quietcount++;
		if (quietcount > 40 && (quietcount & 16)) { // it's been quiet for over a second
			RECT r = { 0,0,SPECWIDTH,SPECHEIGHT };
			SetTextColor(dc, 0xffffff);
			SetBkMode(dc, TRANSPARENT);
			DrawText(dc, "make some noise!", -1, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
		}
	} else
		quietcount = 0; // not quiet
	ReleaseDC(win, dc);
}

// Recording callback - not doing anything with the data
BOOL CALLBACK DuffRecording(HRECORD handle, const void *buffer, DWORD length, void *user)
{
	return TRUE; // continue recording
}

// 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 default recording device
			if (!BASS_RecordInit(-1)) {
				Error("Can't initialize device");
				return -1;
			}
			// start recording (44100hz mono 16-bit)
			if (!(chan = BASS_RecordStart(44100, 1, 0, &DuffRecording, 0))) {
				Error("Can't start recording");
				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_RecordFree();
			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 \"live\" spectrum (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;
}