editor/bass-sys/win/bass24/c/rectest/rectest.c

/*
	BASS recording example
	Copyright (c) 2002-2019 Un4seen Developments Ltd.
*/

#include <windows.h>
#include <commctrl.h>
#include <stdlib.h>
#include <stdio.h>
#include "bass.h"

HWND win = NULL;

#define FREQ 44100
#define CHANS 2
#define BUFSTEP 200000	// memory allocation unit

int input;				// current input source
BYTE *recbuf = NULL;		// recording buffer
DWORD reclen;			// recording length
HRECORD rchan = 0;		// recording channel
HSTREAM chan = 0;			// playback channel

void StopRecording();

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

// messaging macros
#define MESS(id,m,w,l) SendDlgItemMessage(win,id,m,(WPARAM)(w),(LPARAM)(l))
#define DLGITEM(id) GetDlgItem(win,id)

// buffer the recorded data
BOOL CALLBACK RecordingCallback(HRECORD handle, const void *buffer, DWORD length, void *user)
{
	// increase buffer size if needed
	if ((reclen % BUFSTEP) + length >= BUFSTEP) {
		recbuf = realloc(recbuf, ((reclen + length) / BUFSTEP + 1) * BUFSTEP);
		if (!recbuf) {
			rchan = 0;
			Error("Out of memory!");
			MESS(10, WM_SETTEXT, 0, "Record");
			return FALSE; // stop recording
		}
	}
	// buffer the data
	memcpy(recbuf + reclen, buffer, length);
	reclen += length;
	return TRUE; // continue recording
}

void StartRecording()
{
	WAVEFORMATEX *wf;
	if (recbuf) { // free old recording
		BASS_StreamFree(chan);
		chan = 0;
		free(recbuf);
		recbuf = NULL;
		EnableWindow(DLGITEM(11), FALSE);
		EnableWindow(DLGITEM(12), FALSE);
	}
	// allocate initial buffer and make space for WAVE header
	recbuf = malloc(BUFSTEP);
	reclen = 44;
	// fill the WAVE header
	memcpy(recbuf, "RIFF\0\0\0\0WAVEfmt \20\0\0\0", 20);
	memcpy(recbuf + 36, "data\0\0\0\0", 8);
	wf = (WAVEFORMATEX*)(recbuf + 20);
	wf->wFormatTag = 1;
	wf->nChannels = CHANS;
	wf->wBitsPerSample = 16;
	wf->nSamplesPerSec = FREQ;
	wf->nBlockAlign = wf->nChannels * wf->wBitsPerSample / 8;
	wf->nAvgBytesPerSec = wf->nSamplesPerSec * wf->nBlockAlign;
	// start recording
	rchan = BASS_RecordStart(FREQ, CHANS, 0, RecordingCallback, 0);
	if (!rchan) {
		Error("Can't start recording");
		free(recbuf);
		recbuf = 0;
		return;
	}
	MESS(10, WM_SETTEXT, 0, "Stop");
}

void StopRecording()
{
	BASS_ChannelStop(rchan);
	rchan = 0;
	MESS(10, WM_SETTEXT, 0, "Record");
	// complete the WAVE header
	*(DWORD*)(recbuf + 4) = reclen - 8;
	*(DWORD*)(recbuf + 40) = reclen - 44;
	// enable "save" button
	EnableWindow(DLGITEM(12), TRUE);
	// create a stream from the recording
	if (chan = BASS_StreamCreateFile(TRUE, recbuf, 0, reclen, 0))
		EnableWindow(DLGITEM(11), TRUE); // enable "play" button
}

// write the recorded data to disk
void WriteToDisk()
{
	FILE *fp;
	char file[MAX_PATH] = "";
	OPENFILENAME ofn = { 0 };
	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = win;
	ofn.nMaxFile = MAX_PATH;
	ofn.lpstrFile = file;
	ofn.Flags = OFN_HIDEREADONLY | OFN_EXPLORER;
	ofn.lpstrFilter = "WAV files\0*.wav\0All files\0*.*\0\0";
	ofn.lpstrDefExt = "wav";
	if (!GetSaveFileName(&ofn)) return;
	if (!(fp = fopen(file, "wb"))) {
		Error("Can't create the file");
		return;
	}
	fwrite(recbuf, reclen, 1, fp);
	fclose(fp);
}

void UpdateInputInfo()
{
	char *type;
	float level;
	int it = BASS_RecordGetInput(input, &level); // get info on the input
	if (it == -1 || level < 0) { // failed to get level
		it = BASS_RecordGetInput(-1, &level); // try master input instead
		if (it == -1 || level < 0) { // that failed too
			level = 1; // just display 100%
			EnableWindow(DLGITEM(14), FALSE);
		} else
			EnableWindow(DLGITEM(14), TRUE);
	} else
		EnableWindow(DLGITEM(14), TRUE);
	MESS(14, TBM_SETPOS, TRUE, level * 100); // set the level slider
	switch (it & BASS_INPUT_TYPE_MASK) {
		case BASS_INPUT_TYPE_DIGITAL:
			type = "digital";
			break;
		case BASS_INPUT_TYPE_LINE:
			type = "line-in";
			break;
		case BASS_INPUT_TYPE_MIC:
			type = "microphone";
			break;
		case BASS_INPUT_TYPE_SYNTH:
			type = "midi synth";
			break;
		case BASS_INPUT_TYPE_CD:
			type = "analog cd";
			break;
		case BASS_INPUT_TYPE_PHONE:
			type = "telephone";
			break;
		case BASS_INPUT_TYPE_SPEAKER:
			type = "pc speaker";
			break;
		case BASS_INPUT_TYPE_WAVE:
			type = "wave/pcm";
			break;
		case BASS_INPUT_TYPE_AUX:
			type = "aux";
			break;
		case BASS_INPUT_TYPE_ANALOG:
			type = "analog";
			break;
		default:
			type = "undefined";
			{
				// check if it's a loopback device
				BASS_DEVICEINFO info;
				BASS_RecordGetDeviceInfo(BASS_RecordGetDevice(), &info);
				if (info.flags & BASS_DEVICE_LOOPBACK) type = "loopback";
			}
	}
	MESS(15, WM_SETTEXT, 0, type); // display the type
}

BOOL InitDevice(int device)
{
	BASS_RecordFree(); // free current device (and recording channel) if there is one
	// initalize new device
	if (!BASS_RecordInit(device)) {
		Error("Can't initialize recording device");
		return FALSE;
	}
	{ // get list of inputs
		int c;
		const char *i;
		MESS(13, CB_RESETCONTENT, 0, 0);
		input = 0;
		for (c = 0; i = BASS_RecordGetInputName(c); c++) {
			MESS(13, CB_ADDSTRING, 0, i);
			if (!(BASS_RecordGetInput(c, NULL) & BASS_INPUT_OFF)) { // this one is currently "on"
				input = c;
				MESS(13, CB_SETCURSEL, input, 0);
			}
		}
		UpdateInputInfo();
	}
	return TRUE;
}

INT_PTR CALLBACK dialogproc(HWND h, UINT m, WPARAM w, LPARAM l)
{
	switch (m) {
		case WM_TIMER:
			{ // update the recording/playback counter
				char text[30] = "";
				if (rchan) { // recording
					if (rchan != 1 && !BASS_ChannelIsActive(rchan)) { // the recording has stopped, eg. unplugged device
						StopRecording();
						Error("The recording stopped");
						break;
					}
					sprintf(text, "%d", reclen - 44);
				} else if (chan) {
					if (BASS_ChannelIsActive(chan)) // playing
						sprintf(text, "%I64d / %I64d", BASS_ChannelGetPosition(chan, BASS_POS_BYTE), BASS_ChannelGetLength(chan, BASS_POS_BYTE));
					else
						sprintf(text, "%I64d", BASS_ChannelGetLength(chan, BASS_POS_BYTE));
				}
				MESS(20, WM_SETTEXT, 0, text);
			}
			break;

		case WM_COMMAND:
			switch (LOWORD(w)) {
				case IDCANCEL:
					EndDialog(h, 0);
					break;
				case 10:
					if (!rchan)
						StartRecording();
					else
						StopRecording();
					break;
				case 11:
					BASS_ChannelPlay(chan, TRUE); // play the recorded data
					break;
				case 12:
					WriteToDisk();
					break;
				case 13:
					if (HIWORD(w) == CBN_SELCHANGE) { // input selection changed
						int i;
						input = MESS(13, CB_GETCURSEL, 0, 0); // get the selection
						// enable the selected input
						for (i = 0; BASS_RecordSetInput(i, BASS_INPUT_OFF, -1); i++); // 1st disable all inputs, then...
						BASS_RecordSetInput(input, BASS_INPUT_ON, -1); // enable the selected
						UpdateInputInfo();
					}
					break;
				case 16:
					if (HIWORD(w) == CBN_SELCHANGE) { // device selection changed
						int i = MESS(16, CB_GETCURSEL, 0, 0); // get the selection
						if (rchan) rchan = 1; // special handle (real handles always have highest bit set) to prevent timer ending the recording
						// initialize the selected device
						if (InitDevice(i)) {
							if (rchan) { // continue recording on the new device...
								HRECORD newrchan = BASS_RecordStart(FREQ, CHANS, 0, RecordingCallback, NULL);
								if (!newrchan)
									Error("Couldn't start recording");
								else
									rchan = newrchan;
							}
						}
					}
					break;
			}
			break;

		case WM_HSCROLL:
			if (l) { // set input source level
				float level = SendMessage((HWND)l, TBM_GETPOS, 0, 0) / 100.f;
				if (!BASS_RecordSetInput(input, 0, level)) // failed to set input level
					BASS_RecordSetInput(-1, 0, level); // try master level instead
			}
			break;

		case WM_INITDIALOG:
			win = h;
			MESS(14, TBM_SETRANGE, FALSE, MAKELONG(0, 100));
			{ // get list of recording devices
				int c, def;
				BASS_DEVICEINFO di;
				for (c = 0; BASS_RecordGetDeviceInfo(c, &di); c++) {
					MESS(16, CB_ADDSTRING, 0, di.name);
					if (di.flags & BASS_DEVICE_DEFAULT) { // got the default device
						MESS(16, CB_SETCURSEL, c, 0);
						def = c;
					}
				}
				InitDevice(def); // initialize default recording device
			}
			// initialize default output device
			if (!BASS_Init(-1, FREQ, 0, win, NULL))
				Error("Can't initialize output device");
			SetTimer(h, 0, 200, 0); // timer to update the position display
			return 1;

		case WM_DESTROY:
			// release all BASS stuff
			BASS_RecordFree();
			BASS_Free();
			break;
	}
	return 0;
}

int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	// 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;
	}

	{ // enable trackbar support (for the level control)
		INITCOMMONCONTROLSEX cc = { sizeof(cc),ICC_BAR_CLASSES };
		InitCommonControlsEx(&cc);
	}

	DialogBox(hInstance, MAKEINTRESOURCE(1000), NULL, dialogproc);

	return 0;
}