void start_recording(int flag)
{
	//flag 1 = start recording
	//flag 2 = continue recording each frame
	//flag 3 = stop recording
	static ALCdevice     *pCaptureDevice;
	static const ALCchar *szDefaultCaptureDevice;
	static ALuint ulUnqueueCount = 0;
	static ALuint ulQueueCount = 0;
	static ALint lFormat, lFrequency, lBlockAlignment;
	static ALboolean bPlay = AL_FALSE;
	static ALuint SourceID;
	static ALint lLoop;
	static ALuint BufferID[QUEUEBUFFERCOUNT];
	static ALint lSamplesAvailable;
	static ALboolean  bPlaying = AL_FALSE;
	static ALint lProcessed, lPlaying;
	static ALuint TempBufferID;
	static ALuint ulBuffersAvailable = QUEUEBUFFERCOUNT;
	static ALchar Buffer[QUEUEBUFFERSIZE];
	static long lTotalProcessed;
	static long lOldSamplesAvailable;
	static long lOldTotalProcessed;
	static int fh;

	if ( flag == 1 ) {
		// Generate a Source and QUEUEBUFFERCOUNT Buffers for Queuing
		alGetError();
		alGenSources(1, &SourceID);
		for (lLoop = 0; lLoop < QUEUEBUFFERCOUNT; lLoop++) alGenBuffers(1, &BufferID[lLoop]);
		if (alGetError() != AL_NO_ERROR) {
			Log("Failed to generate Source or Buffers\n");
			return;
		}
		const ALchar *pDeviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
		if (pDeviceList) {
			Log("Available Capture Devices are:\n");
			while (*pDeviceList) {
				Log("**%s**\n", pDeviceList);
				pDeviceList += strlen(pDeviceList) + 1;
			}
		}
		szDefaultCaptureDevice = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
		Log("Default Capture Device is '%s'\n", szDefaultCaptureDevice);
		lFormat = AL_FORMAT_MONO8;
		lFrequency = 44100;
		lBlockAlignment = 2;
		lTotalProcessed = 0;
		lOldSamplesAvailable = 0;
		lOldTotalProcessed = 0;
		pCaptureDevice = alcCaptureOpenDevice(szDefaultCaptureDevice, lFrequency, lFormat, lFrequency);
		if (pCaptureDevice) {
			Log("Starting **%s** Capture Device\n", alcGetString(pCaptureDevice, ALC_CAPTURE_DEVICE_SPECIFIER));
			alcCaptureStart(pCaptureDevice);
			bPlay = AL_TRUE;
			fh = _open("recwav.wav", _O_BINARY | _O_CREAT | _O_TRUNC | _O_RDWR, _S_IWRITE);
		}
	}
	if ( flag == 2 ) {
		alGetError();
		alcGetIntegerv(pCaptureDevice, ALC_CAPTURE_SAMPLES, 1, &lSamplesAvailable);
		if ((lOldSamplesAvailable != lSamplesAvailable) || (lOldTotalProcessed != lTotalProcessed)) {
			lOldSamplesAvailable = lSamplesAvailable;
			lOldTotalProcessed = lTotalProcessed;
		}
		// If the Source is (or should be) playing, get number of buffers processed and check play status
		if (bPlaying) {
			alGetSourcei(SourceID, AL_BUFFERS_PROCESSED, &lProcessed);
			while (lProcessed) {
				lTotalProcessed++;
				alSourceUnqueueBuffers(SourceID, 1, &TempBufferID);
				if (++ulUnqueueCount == QUEUEBUFFERCOUNT) ulUnqueueCount = 0;
				ulBuffersAvailable++;
				lProcessed--;
			}
			// If the Source has stopped (been starved of data) it will need to be restarted
			alGetSourcei(SourceID, AL_SOURCE_STATE, &lPlaying);
			if (lPlaying == AL_STOPPED) {
				bPlay = AL_TRUE;
			}
		}
		if ((lSamplesAvailable > (QUEUEBUFFERSIZE / lBlockAlignment)) && !(ulBuffersAvailable)) {
			//OutputDebugString("underrun!\n");
		}
		else {
			// When we have enough data to fill our QUEUEBUFFERSIZE byte buffer, grab the samples
			if ((lSamplesAvailable > (QUEUEBUFFERSIZE / lBlockAlignment)) && (ulBuffersAvailable)) {
				alcCaptureSamples(pCaptureDevice, Buffer, QUEUEBUFFERSIZE / lBlockAlignment);
				alBufferData(BufferID[ulQueueCount], lFormat, Buffer, QUEUEBUFFERSIZE, lFrequency);
				_write(fh, Buffer, QUEUEBUFFERSIZE);
				alSourceQueueBuffers(SourceID, 1, &BufferID[ulQueueCount]);
				if (++ulQueueCount == QUEUEBUFFERCOUNT) ulQueueCount = 0;
				ulBuffersAvailable--;
				// If we need to start the Source do it now IF AND ONLY IF we have queued at least 2 buffers
				if ((bPlay) && (ulBuffersAvailable <= (QUEUEBUFFERCOUNT - 2))) {
					alSourcePlay(SourceID);
					Log("Buffer Starting\n");
					bPlaying = AL_TRUE;
					bPlay = AL_FALSE;
				}
			}
		}
	}
	if ( flag == 3 ) {
		_close(fh);
		alcCaptureCloseDevice(pCaptureDevice);
		alcCaptureStop(pCaptureDevice);
		alSourceStop(SourceID);
		alDeleteSources(1, &SourceID);
		for (lLoop = 0; lLoop < QUEUEBUFFERCOUNT; lLoop++)
		alDeleteBuffers(1, &BufferID[lLoop]);
	}
}