// WaveAudioSource.cpp: implementation of the WaveAudioSource class.
//
//////////////////////////////////////////////////////////////////////

#include "AudioSample.h"
#include "AudioSampleManager.h"
#include "WaveAudioSource.h"

using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

WaveAudioSource::WaveAudioSource()
{
	char subFacilityName[100];
	sprintf(subFacilityName, "WaveAudioSource:%x", this);
	tracer.SetSubFacilityName(subFacilityName);
	SetTraceLevel();
	tracer.tracef(EE, "Constructor begin\n");
	numBuffers = WAVESOURCE_NUM_WAVEHDR;
	bufferSize = WAVESOURCE_DEFAULT_WAVEHDR_SIZE;
	InitializeCriticalSection(&waveInMutex);
	InitializeCriticalSection(&bufferListMutex);
	InitializeCriticalSection(&filterMutex);
	dataEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	bEnableAddBuffer = false;
	hWaveIn = NULL;
	waveinDeviceID = WAVE_MAPPER;
	buffersToAdd.clear();
	bRunning = false;
	needToSetVolume = false;
	micVolume = 0;

	// set default format
	SetFormat(WaveFormat_PCM_16_8_1);
}

WaveAudioSource::~WaveAudioSource()
{
	tracer.tracef(EE, "Destructor begin\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "WaveAudioSource~ : entered filterMutex\n");
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "WaveAudioSource~ : left filterMutex\n");
	DeleteCriticalSection(&waveInMutex);
	DeleteCriticalSection(&bufferListMutex);
	DeleteCriticalSection(&filterMutex);
	CloseHandle(dataEvent);
	tracer.tracef(EE, "Destructor end\n");
}

int
WaveAudioSource::SetTraceLevel()
{
	long SystemMask = 0;
	if ((SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "AllComponents", 0x0)) == 0)
	{
		SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "WaveAudioSource", 0x100000);
	}
	tracer.SetSystemMask(SystemMask);
	return 0;
}

int
WaveAudioSource::SetFormat(int waveFormatNumber)
{
	tracer.tracef(EE, "SetFormat %d : bRunning = %d\n", waveFormatNumber, bRunning);
	if (!bRunning)
	{
		format = WaveFormat::GetWaveFormat(waveFormatNumber);
	}
	tracer.tracef(EE, "~SetFormat\n");
	return 0;
}

int
WaveAudioSource::SetVolume(unsigned long vvolume)
{
	if (bRunning)
	{
		MMRESULT rc;              // Return code.
		HMIXER hMixer;            // Mixer handle used in mixer API calls.
		MIXERCONTROL mxc;         // Holds the mixer control data.
		MIXERLINE mxl;            // Holds the mixer line data.
		MIXERLINECONTROLS mxlc;   // Obtains the mixer control.
		bool volumeChanged = false;

		// Open the mixer. This opens the mixer with a deviceID of 0. If you
		// have a single sound card/mixer, then this will open it. If you have
		// multiple sound cards/mixers, the deviceIDs will be 0, 1, 2, and
		// so on.
		rc = mixerOpen(&hMixer, (UINT)hWaveIn, 0, 0, MIXER_OBJECTF_HWAVEIN);
		if (MMSYSERR_NOERROR == rc) 
		{
			tracer.tracef(DET, "SetVolume : mixerOpen succeeded\n");
			do
			{
				// Initialize MIXERLINE structure.
				ZeroMemory(&mxl,sizeof(mxl));
				mxl.cbStruct = sizeof(mxl);

				// Specify the line you want to get. You are getting the input line
				// here. If you want to get the output line, you need to use
				// MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT.
				mxl.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;

				rc = mixerGetLineInfo((HMIXEROBJ)hMixer, &mxl,
									   MIXER_GETLINEINFOF_COMPONENTTYPE);
				if (MMSYSERR_NOERROR != rc)
				{
					tracer.tracef(ERR, "SetVolume : e-mixerGetLineInfo((HMIXEROBJ)hMixer, &mxl, MIXER_GETLINEINFOF_COMPONENTTYPE) : %d\n", rc);
					break;
				}

				// now find out the microphone input for that line (the ADC)
				int numConnections = mxl.cConnections;
				tracer.tracef(DET, "SetVolume : mixerGetLineInfo succeeded. numConnections = %d\n", numConnections);
				DWORD destinationLineID = mxl.dwDestination;
				for (int j=0; j<numConnections; j++)
				{
					mxl.cbStruct = sizeof(MIXERLINE);
					mxl.dwDestination = destinationLineID;
					mxl.dwSource = j;

					rc = mixerGetLineInfo((HMIXEROBJ)hMixer, &mxl, MIXER_GETLINEINFOF_SOURCE);
					if (rc == MMSYSERR_NOERROR)
					{
						tracer.tracef(DET, "SetVolume : mixerGetLineInfo succeeded. dwComponentType %d = 0x%x\n", j, mxl.dwComponentType);
						if (mxl.dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE ||
							mxl.dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED)
						{
							// Get the control.
							ZeroMemory(&mxlc, sizeof(mxlc));
							mxlc.cbStruct = sizeof(mxlc);
							mxlc.dwLineID = mxl.dwLineID;
							mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
							mxlc.cControls = 1;
							mxlc.cbmxctrl = sizeof(mxc);
							mxlc.pamxctrl = &mxc;
							ZeroMemory(&mxc, sizeof(mxc));
							mxc.cbStruct = sizeof(mxc);
							rc = mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc,
													   MIXER_GETLINECONTROLSF_ONEBYTYPE);
							if (MMSYSERR_NOERROR != rc)
							{
								tracer.tracef(ERR, "SetVolume : e-mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) : %d. Could not get MIXERCONTROL_CONTROLTYPE_VOLUME\n", rc);
								break;
							}

							// After successfully getting the peakmeter control, the volume range
							// will be specified by mxc.Bounds.lMinimum to mxc.Bounds.lMaximum.

							MIXERCONTROLDETAILS mxcd;             // Gets the control values.
							MIXERCONTROLDETAILS_UNSIGNED volStruct; // Gets the control values.
							MIXERCONTROLDETAILS_BOOLEAN muteStruct; // Get Mute Setting
							long volume;                          // Holds the final volume value.

							// Initialize the MIXERCONTROLDETAILS structure
							ZeroMemory(&mxcd, sizeof(mxcd));
							mxcd.cbStruct = sizeof(mxcd);
							mxcd.cbDetails = sizeof(volStruct);
							mxcd.dwControlID = mxc.dwControlID;
							mxcd.paDetails = &volStruct;
							mxcd.cChannels = 1;

							// Get the current value of the volume control. Typically, you
							// would set a timer in your program to query the volume every 10th
							// of a second or so.
							rc = mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd,
														 MIXER_GETCONTROLDETAILSF_VALUE);
							if (MMSYSERR_NOERROR != rc) 
							{
								tracer.tracef(ERR, "SetVolume : e-mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_GETCONTROLDETAILSF_VALUE) : %d\n", rc);
								break;
							}
							volume = volStruct.dwValue;

							volStruct.dwValue = (0xffff * vvolume) / 100;
							rc = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd,
														 MIXER_SETCONTROLDETAILSF_VALUE);
							if (MMSYSERR_NOERROR != rc) 
							{
								tracer.tracef(ERR, "SetVolume : e-mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE) : %d\n", rc);
								break;
							}

							volumeChanged = true;

							// Get the mute control.
							ZeroMemory(&mxlc, sizeof(mxlc));
							mxlc.cbStruct = sizeof(mxlc);
							mxlc.dwLineID = mxl.dwLineID;
							mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
							mxlc.cControls = 1;
							mxlc.cbmxctrl = sizeof(mxc);
							mxlc.pamxctrl = &mxc;
							ZeroMemory(&mxc, sizeof(mxc));
							mxc.cbStruct = sizeof(mxc);
							rc = mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc,
													   MIXER_GETLINECONTROLSF_ONEBYTYPE);
							if (MMSYSERR_NOERROR != rc)
							{
								tracer.tracef(ERR, "SetVolume : e-mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) : %d. Could not get MIXERCONTROL_CONTROLTYPE_VOLUME\n", rc);
								if (mxl.dwComponentType != MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE)
								{
									continue;
								}
								else
								{
									break;
								}
							}

							ZeroMemory(&mxcd, sizeof(mxcd));
							mxcd.cbStruct = sizeof(mxcd);
							mxcd.cbDetails = sizeof(muteStruct);
							mxcd.dwControlID = mxc.dwControlID;
							mxcd.paDetails = &muteStruct;
							mxcd.cChannels = 1;

							// Get the current value of the mute control. Typically, you
							// would set a timer in your program to query the volume every 10th
							// of a second or so.
							rc = mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd,
														 MIXER_GETCONTROLDETAILSF_VALUE);
							if (MMSYSERR_NOERROR != rc) 
							{
								tracer.tracef(ERR, "SetVolume : e-mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_GETCONTROLDETAILSF_VALUE) : %d\n", rc);
								break;
							}
							muteStruct.fValue = vvolume == 0 ? 1 : 0;
							rc = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd,
														 MIXER_SETCONTROLDETAILSF_VALUE);
							if (MMSYSERR_NOERROR != rc) 
							{
								tracer.tracef(ERR, "SetVolume : e-mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE) : %d\n", rc);
								break;
							}
							break;
						}
					}
				}
			} while (false);
			if (volumeChanged == false)
			{
				do
				{
					// Initialize MIXERLINE structure.
					ZeroMemory(&mxl,sizeof(mxl));
					mxl.cbStruct = sizeof(mxl);

					// Specify the line you want to get. You are getting the input line
					// here. If you want to get the output line, you need to use
					// MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT.
					mxl.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;

					rc = mixerGetLineInfo((HMIXEROBJ)hMixer, &mxl,
										   MIXER_GETLINEINFOF_COMPONENTTYPE);
					if (MMSYSERR_NOERROR != rc)
					{
						tracer.tracef(ERR, "SetVolume : e-mixerGetLineInfo((HMIXEROBJ)hMixer, &mxl, MIXER_GETLINEINFOF_COMPONENTTYPE) : %d\n", rc);
						break;
					}

					// now find out the microphone input for that line (the ADC)
					int numConnections = mxl.cConnections;
					tracer.tracef(DET, "SetVolume : mixerGetLineInfo succeeded. numConnections = %d\n", numConnections);
					DWORD destinationLineID = mxl.dwDestination;

					// Get the control.
					ZeroMemory(&mxlc, sizeof(mxlc));
					mxlc.cbStruct = sizeof(mxlc);
					mxlc.dwLineID = mxl.dwLineID;
					mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
					mxlc.cControls = 1;
					mxlc.cbmxctrl = sizeof(mxc);
					mxlc.pamxctrl = &mxc;
					ZeroMemory(&mxc, sizeof(mxc));
					mxc.cbStruct = sizeof(mxc);
					rc = mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc,
											   MIXER_GETLINECONTROLSF_ONEBYTYPE);
					if (MMSYSERR_NOERROR != rc)
					{
						tracer.tracef(ERR, "SetVolume : e-mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) : %d. Could not get MIXERCONTROL_CONTROLTYPE_VOLUME\n", rc);
						if (mxl.dwComponentType != MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE)
						{
							continue;
						}
						else
						{
							break;
						}
					}
					MIXERCONTROLDETAILS mxcd;             // Gets the control values.
					MIXERCONTROLDETAILS_UNSIGNED volStruct; // Gets the control values.
					MIXERCONTROLDETAILS_BOOLEAN muteStruct; // Get Mute Setting
					long volume;                          // Holds the final volume value.

					// Initialize the MIXERCONTROLDETAILS structure
					ZeroMemory(&mxcd, sizeof(mxcd));
					mxcd.cbStruct = sizeof(mxcd);
					mxcd.cbDetails = sizeof(volStruct);
					mxcd.dwControlID = mxc.dwControlID;
					mxcd.paDetails = &volStruct;
					mxcd.cChannels = 1;

					// Get the current value of the peakmeter control. Typically, you
					// would set a timer in your program to query the volume every 10th
					// of a second or so.
					rc = mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd,
												 MIXER_GETCONTROLDETAILSF_VALUE);
					if (MMSYSERR_NOERROR != rc) 
					{
						tracer.tracef(ERR, "SetVolume : e-mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_GETCONTROLDETAILSF_VALUE) : %d\n", rc);
						break;
					}
					volume = volStruct.dwValue;

					volStruct.dwValue = (0xffff * vvolume) / 100;
					rc = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd,
												 MIXER_SETCONTROLDETAILSF_VALUE);
					if (MMSYSERR_NOERROR != rc) 
					{
						tracer.tracef(ERR, "SetVolume : e-mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE) : %d\n", rc);
						break;
					}
					volumeChanged = true;

					// Get the mute control.
					ZeroMemory(&mxlc, sizeof(mxlc));
					mxlc.cbStruct = sizeof(mxlc);
					mxlc.dwLineID = mxl.dwLineID;
					mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
					mxlc.cControls = 1;
					mxlc.cbmxctrl = sizeof(mxc);
					mxlc.pamxctrl = &mxc;
					ZeroMemory(&mxc, sizeof(mxc));
					mxc.cbStruct = sizeof(mxc);
					rc = mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc,
											   MIXER_GETLINECONTROLSF_ONEBYTYPE);
					if (MMSYSERR_NOERROR != rc)
					{
						tracer.tracef(ERR, "SetVolume : e-mixerGetLineControls((HMIXEROBJ)hMixer,&mxlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) : %d. Could not get MIXERCONTROL_CONTROLTYPE_VOLUME\n", rc);
						if (mxl.dwComponentType != MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE)
						{
							continue;
						}
						else
						{
							break;
						}
					}

					ZeroMemory(&mxcd, sizeof(mxcd));
					mxcd.cbStruct = sizeof(mxcd);
					mxcd.cbDetails = sizeof(muteStruct);
					mxcd.dwControlID = mxc.dwControlID;
					mxcd.paDetails = &muteStruct;
					mxcd.cChannels = 1;

					// Get the current value of the mute control. Typically, you
					// would set a timer in your program to query the volume every 10th
					// of a second or so.
					rc = mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd,
												 MIXER_GETCONTROLDETAILSF_VALUE);
					if (MMSYSERR_NOERROR != rc) 
					{
						tracer.tracef(ERR, "SetVolume : e-mixerGetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_GETCONTROLDETAILSF_VALUE) : %d\n", rc);
						break;
					}
					muteStruct.fValue = vvolume == 0 ? 1 : 0;
					rc = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd,
												 MIXER_SETCONTROLDETAILSF_VALUE);
					if (MMSYSERR_NOERROR != rc) 
					{
						tracer.tracef(ERR, "SetVolume : e-mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE) : %d\n", rc);
						break;
					}
					break;
				} while (false);
			}
			mixerClose(hMixer);
		}
		else
		{
			tracer.tracef(ERR, "SetVolume : e-mixerOpen : %d\n", rc);
		}
	}
	else
	{
		needToSetVolume = true;
	}
	micVolume = vvolume;
	return 0;
}

int
WaveAudioSource::SetDeviceID(unsigned int deviceID)
{
	waveinDeviceID = deviceID;
	return 0;
}

int
WaveAudioSource::SetBufferSize(int size)
{
	tracer.tracef(EE, "SetBufferSize %d : bRunning = %d\n", size, bRunning);
	if (!bRunning)
	{
		bufferSize = size;
	}
	tracer.tracef(EE, "~SetBufferSize\n");
	return 0;
}

int
WaveAudioSource::SetNumBuffers(int num)
{
	tracer.tracef(EE, "SetNumBuffers %d : bRunning = %d\n", num, bRunning);
	if (!bRunning)
	{
		numBuffers = num;
	}
	tracer.tracef(EE, "~SetNumBuffers\n");
	return 0;
}

int
WaveAudioSource::BeginAudioCapture()
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "BeginAudioCapture\n");
	HRESULT result = NOERROR;
	tracer.tracef(SDI_LEVEL_DETAILED, "BeginAudioCapture : Entering bufferListMutex\n");
	EnterCriticalSection(&bufferListMutex);
	buffersToAdd.clear();
	LeaveCriticalSection(&bufferListMutex);
	tracer.tracef(SDI_LEVEL_DETAILED, "BeginAudioCapture : Left bufferListMutex\n");

	audioSampleManager = AudioSampleManager::GetInstance();

	WaveFormat::TraceFormat(&tracer, ARB, format);
	tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : waveInOpen\n");
	MMRESULT mr = waveInOpen(&hWaveIn, waveinDeviceID, &format, (DWORD)WaveInCallback, DWORD(this), CALLBACK_FUNCTION);
	tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : ~waveInOpen\n");
	if (mr != NOERROR)
	{
		tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : e-waveInOpen : 0x%x\n", mr);
		WaveFormat::TraceFormat(&tracer, ERR, format);
		Sleep(1000);
		tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : waveInOpen : 2nd try\n");
		mr = waveInOpen(&hWaveIn, waveinDeviceID, &format, (DWORD)WaveInCallback, DWORD(this), CALLBACK_FUNCTION);
		tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : ~waveInOpen : returned 0x%x\n", mr);
		if (mr != NOERROR)
		{
			tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : e-waveInOpen : 0x%x\n", mr);
			WaveFormat::TraceFormat(&tracer, ERR, format);
			result = -10;
		}
	}
	if (result == 0)
	{
		tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : Entering waveInMutex\n");
		EnterCriticalSection(&waveInMutex);
		bEnableAddBuffer = true;
		for (int i=0; i<numBuffers; i++) {
			waveHdr[i].lpData = dataBuffer[i];
			waveHdr[i].dwBufferLength = bufferSize;
			waveHdr[i].dwFlags = 0;
			waveHdr[i].dwUser = i;

			tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : waveInPrepareHeader\n");
			result = waveInPrepareHeader(hWaveIn, &(waveHdr[i]), sizeof(waveHdr[i]));
			tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : ~waveInPrepareHeader\n");
			if (result == MMSYSERR_NOERROR)
			{
				AddBuffer(i);
			}
			else
			{
				tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : e-waveInPrepareHeader : 0x%x\n", result);
			}
		}
		tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : waveInStart\n");
		result = waveInStart(hWaveIn);
		tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : ~waveInStart\n");
		if (result != MMSYSERR_NOERROR)
		{
			tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioCapture : e-waveInStart : 0x%x\n", result);
			result = -20;
		}
		LeaveCriticalSection(&waveInMutex);
		tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioCapture : Left waveInMutex\n");
	}
	if (result == 0)
	{
		tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~BeginAudioCapture\n");
	}
	else
	{
		tracer.tracef(ERR, "~BeginAudioCapture : returning %d\n", result);
	}

	return result;
}


int
WaveAudioSource::EndAudioCapture()
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "EndAudioCapture\n");
	tracer.tracef(SDI_LEVEL_DETAILED, "EndAudioCapture : entering waveInMutex\n");
	EnterCriticalSection(&waveInMutex);
	bEnableAddBuffer = false;
	HRESULT result = NOERROR;
	tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : waveInReset\n");
	result = waveInReset(hWaveIn);
	tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : ~waveInReset\n");
	if (result != MMSYSERR_NOERROR)
	{
		tracer.tracef(SDI_LEVEL_ERROR, "EndAudioCapture : e-waveInReset : 0x%x\n", result);
	}
	else
	{
		LeaveCriticalSection(&waveInMutex);
		tracer.tracef(SDI_LEVEL_DETAILED, "EndAudioCapture : left waveInMutex\n");
		while(true)
		{
			tracer.tracef(DET, "EndAudioCapture : entering bufferListMutex\n");
			EnterCriticalSection(&bufferListMutex);
			tracer.tracef(DET, "EndAudioCapture : buffersToAdd.size = %d, numBuffers = %d\n", buffersToAdd.size(), numBuffers);
			if (buffersToAdd.size() < numBuffers)
			{
				LeaveCriticalSection(&bufferListMutex);
				tracer.tracef(DET, "EndAudioCapture : left bufferListMutex. Waiting for dataEvent\n");
				WaitForSingleObject(dataEvent, INFINITE);
				tracer.tracef(DET, "EndAudioCapture : got dataEvent\n");
				continue;
			}
			else
			{
				LeaveCriticalSection(&bufferListMutex);
				tracer.tracef(DET, "EndAudioCapture : left bufferListMutex\n");
				break;
			}
		}
		tracer.tracef(DET, "EndAudioCapture : entering waveInMutex\n");
		EnterCriticalSection(&waveInMutex);
		for (int i=0; i<numBuffers; i++) {
			tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : waveInUnprepareHeader\n");
			result = waveInUnprepareHeader(hWaveIn, &(waveHdr[i]), sizeof(waveHdr[i]));
			tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : ~waveInUnprepareHeader\n");
			if (result != MMSYSERR_NOERROR)
			{
				tracer.tracef(SDI_LEVEL_ERROR, "EndAudioCapture : e-waveInUnprepareHeader : 0x%x\n", result);
			}
		}
		tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : waveInClose\n");
		result = waveInClose(hWaveIn);
		tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioCapture : ~waveInClose\n");
		if (result != MMSYSERR_NOERROR)
		{
			tracer.tracef(SDI_LEVEL_ERROR, "EndAudioCapture : e-waveInClose : 0x%x\n", result);
		}
		hWaveIn = NULL;
	}
	LeaveCriticalSection(&waveInMutex);
	tracer.tracef(SDI_LEVEL_DETAILED, "EndAudioCapture : Left waveInMutex\n");
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~EndAudioCapture\n");
	return result;
}


int
WaveAudioSource::ResetAudioCapture()
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "ResetAudioCapture\n");
	HRESULT result = NOERROR;
	result = EndAudioCapture();
	if (result == MMSYSERR_NOERROR)
	{
		result = BeginAudioCapture();
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~ResetAudioCapture\n");
	return result;
}


int
WaveAudioSource::AddBuffer(int i)
{
	tracer.tracef(SDI_LEVEL_DETAILED, "AddBuffer %d\n", i);
	HRESULT result = NOERROR;
	tracer.tracef(SDI_LEVEL_DETAILED, "AddBuffer : Entering waveInMutex\n");
	EnterCriticalSection(&waveInMutex);
	bool bEnabled = bEnableAddBuffer;
	if (bEnabled)
	{
		tracer.tracef(DET, "AddBuffer : waveInAddBuffer\n");
		result = waveInAddBuffer(hWaveIn, &(waveHdr[i]), sizeof(waveHdr[i]));
		tracer.tracef(DET, "AddBuffer : ~waveInAddBuffer\n");
		LeaveCriticalSection(&waveInMutex);
		tracer.tracef(DET, "AddBuffer : Left waveInMutex\n");
		if (result != MMSYSERR_NOERROR)
		{
			tracer.tracef(SDI_LEVEL_ERROR, "AddBuffer : e-waveInAddBuffer : 0x%x\n", result);
			result = -10;
		}
	}
	else
	{
		LeaveCriticalSection(&waveInMutex);
		tracer.tracef(SDI_LEVEL_DETAILED, "AddBuffer : !bEnabled. Left waveInMutex. Putting buffer back in buffersToAdd\n");
		tracer.tracef(SDI_LEVEL_DETAILED, "AddBuffer : Entering bufferListMutex\n");
		EnterCriticalSection(&bufferListMutex);
		buffersToAdd.push_back(&(waveHdr[i]));
		LeaveCriticalSection(&bufferListMutex);
		SetEvent(dataEvent);
		tracer.tracef(SDI_LEVEL_DETAILED, "AddBuffer : Left bufferListMutex\n");
	}
	tracer.tracef(SDI_LEVEL_DETAILED, "~AddBuffer\n");
	return result;
}



// TO avoid problems with wave calls not returning, one has to GUARANTEE that the callback function
// will return regardless of the state of any other function. if this function grabs a mutex that is
// also entered by other functions, one has to ensure that in no circumstance does the other function
// hold in while making a system call (like a wave api call) since those calls may freeze until this
// callback function returns. that's the potential deadlock
void CALLBACK
WaveAudioSource::WaveInCallback(HWAVEIN hWaveIn, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) {
	WAVEHDR *wHdr;
	WaveAudioSource *waveAudioSource;
	waveAudioSource = (WaveAudioSource *)dwInstance;
	(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback\n");
	switch(uMsg) {
	case WIM_OPEN:
		(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback : WIM_OPEN\n");
		break;
	case WIM_CLOSE:
		(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback : WIM_CLOSE\n");
		SetEvent(waveAudioSource->dataEvent);
		break;
	case WIM_DATA:
		wHdr = (WAVEHDR *)dwParam1;
		(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback : WIM_DATA %d\n", wHdr->dwUser);
		(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback : Entering bufferListMutex\n");
		EnterCriticalSection(&(waveAudioSource->bufferListMutex));
		(waveAudioSource->buffersToAdd).push_back(wHdr);
		LeaveCriticalSection(&(waveAudioSource->bufferListMutex));
		SetEvent(waveAudioSource->dataEvent);	// we do this within the critical section because fillbuffer resets this within the same critical section - ??? so i go it out
		(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "WaveInCallback : Left bufferListMutex\n");
		break;
	default:
		break;
	}
	(waveAudioSource->tracer).tracef(SDI_LEVEL_DETAILED, "~WaveInCallback\n");
}


int
WaveAudioSource::GenerateData(AudioSample **ppAudioSample)
{
	tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData\n");
	HRESULT result = NOERROR;
	*ppAudioSample = NULL;
	bool fireDataEvent = false;

	while (true)
	{
		tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : Entering waveInMutex\n");
		EnterCriticalSection(&waveInMutex);
		bool bEnabled = bEnableAddBuffer;
		LeaveCriticalSection(&waveInMutex);
		tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : Left waveInMutex\n");
		if (!bEnabled)
		{
			if (fireDataEvent)
			{
				SetEvent(dataEvent);
			}
			break;
		}
		tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : Entering bufferListMutex\n");
		EnterCriticalSection(&bufferListMutex);
		tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : buffersToAdd.size = %d\n", buffersToAdd.size());
		if (buffersToAdd.size() <= 0)
		{
			LeaveCriticalSection(&bufferListMutex);
			tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : Left bufferListMutex. Waiting for dataEvent\n");
			WaitForSingleObject(dataEvent, INFINITE);
			tracer.tracef(DET, "GenerateData : Got dataEvent\n");
			fireDataEvent = true;
			continue;
		}
		else
		{
			WAVEHDR *wHdr = buffersToAdd.front();
			buffersToAdd.pop_front();
			LeaveCriticalSection(&bufferListMutex);
			tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : Left bufferListMutex\n");
			AudioSample *audioSample;
			audioSampleManager->GetAudioSample(&audioSample, this);
			*ppAudioSample = audioSample;
			audioSample->SetFormat(format);
			int bytesToFill = min(wHdr->dwBytesRecorded, audioSample->BufferSize());
			audioSample->SetDataSize(bytesToFill);

			// check to see if the audio is loud enough
			int bytesPerSample = format.wBitsPerSample / 8;
			int numSamples = bytesToFill / bytesPerSample;
			double total = 0;
			bool canEncode = false;
			for (int i=0; i<bytesToFill; i+=bytesPerSample)
			{
				double sampleValue;
				switch(bytesPerSample)
				{
				case 1:
					sampleValue = *((char *)((char *)(wHdr->lpData) + i));
					break;
				case 2:
					sampleValue = *((short *)((char *)(wHdr->lpData) + i));
					break;
				case 4:
					sampleValue = *((int *)((char *)(wHdr->lpData) + i));
					break;
				}
				if (abs(sampleValue) > 4)
				{
					canEncode = true;
					break;
				}
			}

			if (micVolume > 0 && canEncode)
			{
				tracer.tracef(SDI_LEVEL_DETAILED, "GenerateData : memcpy(0x%x, 0x%x, %d)\n", audioSample->Data(), wHdr->lpData, bytesToFill);
				memcpy(audioSample->Data(), wHdr->lpData, bytesToFill);
			}
			else
			{
				audioSample->SetSilenceDuration(audioSample->GetDuration());
				audioSample->SetDataSize(0);
			}
			AddBuffer(wHdr->dwUser);
			break;
		}
	}
	tracer.tracef(SDI_LEVEL_DETAILED, "~GenerateData\n");
	return 0;
}


int
WaveAudioSource::SourceStarted()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SourceStarted\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceStarted : entered filterMutex\n");
	do
	{
		if (bRunning)
		{
			tracer.tracef(ERR, "SourceStarted : e-error : already running\n");
			result = -10;
			break;
		}
		returnCode = BeginAudioCapture();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceStarted : e-BeginAudioCapture : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		if (needToSetVolume)
		{
			SetVolume(micVolume);
			needToSetVolume = false;
		}
		bRunning = true;
	}
	while (false);

	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceStarted : left filterMutex\n");
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SourceStarted : returning %d\n", result);
	return result;
}


int
WaveAudioSource::SourceStopped()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SourceStopped\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceStopped : entered filterMutex\n");
	do
	{
		if (!bRunning)
		{
			tracer.tracef(ERR, "SourceStopped : e-error : not running\n");
			result = -10;
			break;
		}
		returnCode = EndAudioCapture();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceStopped : e-EndAudioCapture : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		needToSetVolume = false;
		bRunning = false;
	}
	while (false);
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceStopped : left filterMutex\n");
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SourceStopped : returning %d\n", result);
	return result;
}

int
WaveAudioSource::SourceThreadStarted(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	int result(0);
	int returnCode(0);
	SetTraceLevel();
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SourceThreadStarted\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStarted : entered filterMutex\n");
	do
	{
		returnCode = SetThreadPriority(sourceThreadHandle, THREAD_PRIORITY_TIME_CRITICAL);
		if (returnCode == 0)
		{
			returnCode = GetLastError();
			tracer.tracef(ERR, "SourceThreadStarted : e-SetThreadPriority : %d 0x%x\n", returnCode, returnCode);
		}
		returnCode = BeginAudioCapture();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceThreadStarted : e-BeginAudioCapture : %d 0x%x\n", returnCode, returnCode);
			result = -10;
			break;
		}
		if (needToSetVolume)
		{
			SetVolume(micVolume);
			needToSetVolume = false;
		}
		bRunning = true;
	}
	while (false);
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStarted : left filterMutex\n");
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SourceThreadStarted : returning %d\n", result);
	return result;
}

int
WaveAudioSource::SourceThreadStopped(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	int result(0);
	int returnCode(0);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SourceThreadStopped\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStopped : entered filterMutex\n");
	do
	{
		if (!bRunning)
		{
			tracer.tracef(ERR, "SourceThreadStopped : not running\n");
			result = -10;
			break;
		}
		returnCode = EndAudioCapture();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceThreadStopped : e-EndAudioCapture : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		needToSetVolume = false;
		bRunning = false;
	}
	while (false);
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStopped : left filterMutex\n");
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SourceThreadStopped : returning %d\n", result);
	return result;
}