// CCNMediaTerm.cpp : Implementation of CCCNMediaTerm

#include "stdafx.h"
#include "stdlib.h"

#include "CCNSMT.h"
#include "CCNMediaTerm.h"
#include "AudioCodecs.h"
#include "../MTC/AudioSampleManager.h"
#include "../MTC/Exception.h"

#include <math.h>

extern "C" {
#include "../MTC/DSP/FIRCoefficients.h"
}

#include <string>
#include <vector>

using namespace std;

long nextCookie;

int FilePlay::numOutstandingEvents;
bool FilePlay::closing;
CRITICAL_SECTION FilePlay::fireEventThreadMutex;
HANDLE FilePlay::fireEventThreadEvent;
CCCNMediaTerm * FilePlay::mediaTerm;

// #define NO_RECV_MIXER

int Connect(AudioSource *source, AudioSink *sink)
{
	source->SubscribeAudioSink(sink);
	sink->SubscribeAudioSource(source);
	return 0;
}

int Disconnect(AudioSource *source, AudioSink *sink)
{
	source->UnsubscribeAudioSink(sink);
	sink->UnsubscribeAudioSource(source);
	return 0;
}

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


// #define WM_GRAPHNOTIFY WM_USER + 13


// using namespace std;

/////////////////////////////////////////////////////////////////////////////
// CCCNMediaTerm

HRESULT 
CCCNMediaTerm::Initialize()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "Initialize\n");
	if (!initialized)
	{
		AudioSampleManager::Initialize();
		InitializeCriticalSection(&filesPlayingMutex);
		waveSource = new WaveAudioSource();
		waveSink = new WaveAudioSink();
		filePlayWaveSink = new WaveAudioSink();
		rtpSink = new RTPAudioSink();
		rtpSource = new RTPAudioSource();
		inputFIRTransformer = new FIRTransformer();
		inputFIRTransformer->SetCoefficients(FIR_TELECASTER_TX, FIR_TELECASTER_TX_NUM, 16);
		outputFIRTransformer = new FIRTransformer();
		outputFIRTransformer->SetCoefficients(FIR_TELECASTER_RX, FIR_TELECASTER_RX_NUM, 16);
		pcm2G711Transformer = new PCM2G711Transformer();
		g7112PcmTransformer = new G7112PCMTransformer();
		limiter = new Limiter(-8.0, 0.075, -0.00075);
		voiceActivityDetector = new VoiceActivityDetector();
		rtpJitterBuffer = new RTPJitterBuffer();
		fixedSizeAudioBuffer = new FixedSizeAudioBuffer();
		genericRTP2PCMDecoder = new GenericRTP2PCMDecoder();
		rxPCMMixer = new PCMMixer();
		txPCMMixer = new PCMMixer();
		pcmVolumeMaximizer = new PCMVolumeMaximizer;
		rxTransformer = g7112PcmTransformer;
		txTransformer = pcm2G711Transformer;
		txDuration = 20;
		rxDuration = 20;
		filesPlaying.clear();
		extraFilePlay = NULL;
		brxRunning = false;
		btxRunning = false;
		bFilePlayRunning = false;
		nextCookie = 0;
		waveinDeviceID = WAVE_MAPPER;
		waveoutDeviceID = WAVE_MAPPER;

		FilePlay::Initialize(this);

		initialized = true;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~Initialize\n");
	return NOERROR;
}


HRESULT
CCCNMediaTerm::UnInitialize() 
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(EE, "UnInitialize\n");
	if (initialized) 
	{
		tracer.tracef(EE, "UnInitialize : Stopping streaming\n");
		StopRX();
		StopTX();
		if (extraFilePlay && extraFilePlay->IsRunning())
		{
			StopPlayingFileRX(extraFilePlay->GetCookie());
		}
		RemoveNonPlayingFiles();
		if (g7112PcmTransformer)
		{
			delete g7112PcmTransformer;
		}
		if (pcm2G711Transformer)
		{
			delete pcm2G711Transformer;
		}
		if (waveSink)
		{
			delete waveSink;
		}
		if (filePlayWaveSink)
		{
			delete filePlayWaveSink;
		}
		if (waveSource)
		{
			delete waveSource;
		}
		if (rtpSource)
		{
			delete rtpSource;
		}
		if (rtpSink)
		{
			delete rtpSink;
		}
		if (inputFIRTransformer)
		{
			delete inputFIRTransformer;
		}
		if (outputFIRTransformer)
		{
			delete outputFIRTransformer;
		}
		if (limiter)
		{
			delete limiter;
		}
		if (voiceActivityDetector)
		{
			delete voiceActivityDetector;
		}
		if (rxPCMMixer)
		{
			delete rxPCMMixer;
		}
		if (txPCMMixer)
		{
			delete txPCMMixer;
		}
		if (rtpJitterBuffer)
		{
			delete rtpJitterBuffer;
		}
		if (fixedSizeAudioBuffer)
		{
			delete fixedSizeAudioBuffer;
		}
		if (genericRTP2PCMDecoder)
		{
			delete genericRTP2PCMDecoder;
		}
		if (pcmVolumeMaximizer)
		{
			delete pcmVolumeMaximizer;
		}
		DeleteCriticalSection(&filesPlayingMutex);

		FilePlay::Uninitialize();

		AudioSampleManager::Uninitialize();

		initialized = false;
	}
	else
	{
		tracer.tracef(EE, "UnInitialize : initialize = false\n");
	}
	tracer.tracef(EE, "~UnInitialize\n");
	return NOERROR;
}

STDMETHODIMP 
CCCNMediaTerm::SetAudioCodecRX(long CompressionType, long MillisecPacketSize, long EchoCancellationValue, long G723BitRate)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioCodecRX : %d %d %d %d\n", CompressionType, MillisecPacketSize, EchoCancellationValue, G723BitRate);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	SetTraceLevel();

	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioCodecRX : brxRunning = %d\n", brxRunning);
	bool restart = false;
	int result(0);
	int resultCode(0);

	bool needToSet = true;
	if (brxRunning)
	{
		needToSet = false;
		do
		{
			if (CompressionType != rxParameters.CompressionType)
			{
				needToSet = true;
				break;
			}
			if (CompressionType == Media_Payload_G7231 && G723BitRate != rxParameters.G723BitRate)
			{
				needToSet = true;
				break;
			}
		} while (false);
	}
	if (needToSet)
	{
		// update rxParameters
		rxParameters.CompressionType = CompressionType;
		rxParameters.EchoCancellationValue = EchoCancellationValue;
		rxParameters.G723BitRate = G723BitRate;
		rxParameters.MillisecPacketSize = MillisecPacketSize;

		if (brxRunning)
		{
			result = StopRX();
			if (result < 0)
			{
				resultCode = -10;
			}
			restart = true;
		}

		if (resultCode == 0)
		{
			rxDuration = MillisecPacketSize;
			waveSink->SetFrameSize(16 * MillisecPacketSize);

			switch (CompressionType) 
			{
			case Media_Payload_AutoDetect:
				rxTransformer = genericRTP2PCMDecoder;
				break;
			case Media_Payload_G711Ulaw64k:
				rxTransformer = g7112PcmTransformer;
				g7112PcmTransformer->SetULaw();
				break;
			case Media_Payload_G711Alaw64k: 
				rxTransformer = g7112PcmTransformer;
				g7112PcmTransformer->SetALaw();
				break;
			default:
				tracer.tracef(SDI_LEVEL_ERROR, "SetAudioCodecRX : Invalid Codec # %d\n", CompressionType);
				return -30;
			}

			if (restart)
			{
				result = StartRX(waveoutDeviceID);
				if (result < 0)
				{
					resultCode = -20;
				}
			}
		}
	}
	else
	{
		tracer.tracef(ARB, "SetAudioCodecRX : no need to restart\n");
	}

	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetAudioCodecRX : %d\n", resultCode);
	return resultCode;
}



STDMETHODIMP 
CCCNMediaTerm::SetAudioCodecTX(long CompressionType, long MillisecPacketSize, long PrecedenceValue, long SilenceSuppression, unsigned short MaxFramesPerPacket, long G723BitRate)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioCodecTX : %d %d %d %d %d %d\n", CompressionType, MillisecPacketSize, PrecedenceValue, SilenceSuppression, MaxFramesPerPacket, G723BitRate);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	SetTraceLevel();

	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioCodecTX : btxRunning = %d\n", btxRunning);
	bool needToSet = false;
	bool forceVADOff = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "ForceVADOff", false);
	int resultCode(0);

	SilenceSuppression = forceVADOff && SilenceSuppression;

	if (CompressionType != txParameters.CompressionType ||
		MillisecPacketSize != txParameters.MillisecPacketSize ||
		SilenceSuppression != txParameters.SilenceSuppression ||
		(CompressionType == Media_Payload_G7231 && G723BitRate != txParameters.G723BitRate)
		)
	{
		needToSet = true;
	}

	if (needToSet)
	{
		bool restart = false;
		int result(0);

		if (btxRunning)
		{
			result = StopTX();
			if (result < 0)
			{
				resultCode = -10;
			}
			restart = true;
		}

		// update btxVAD after StopTX, so that StopTX knows whether VAD was on or off the last time
		btxVAD = SilenceSuppression == 0 ? false : true;

		if (resultCode == 0)
		{
			txDuration = MillisecPacketSize;
			waveSource->SetBufferSize(MillisecPacketSize * 16);
			switch (CompressionType) 
			{
			case Media_Payload_G711Ulaw64k:
				txTransformer = pcm2G711Transformer;
				pcm2G711Transformer->SetULaw();
				break;

			case Media_Payload_G711Alaw64k:
				txTransformer = pcm2G711Transformer;
				pcm2G711Transformer->SetALaw();
				break;

			default:
				tracer.tracef(SDI_LEVEL_ERROR, "SetAudioCodecTX : Invalid Codec # %d\n", CompressionType);
				return -30;
			}

			if (restart)
			{
				result = StartTX(waveinDeviceID);
				if (result < 0)
				{
					resultCode = -20;
				}
			}
		}
	}

	if (resultCode == 0)
	{
		txParameters.CompressionType = CompressionType;
		txParameters.G723BitRate = G723BitRate;
		txParameters.MaxFramesPerPacket = MaxFramesPerPacket;
		txParameters.MillisecPacketSize = MillisecPacketSize;
		txParameters.PrecedenceValue = PrecedenceValue;
		txParameters.SilenceSuppression = SilenceSuppression;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetAudioCodecTX : %d\n", resultCode);
	return resultCode;
}



STDMETHODIMP 
CCCNMediaTerm::SetAudioDestination(BSTR strHostName, long nUDPPortNumber)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	USES_CONVERSION;
	LPSTR hostname = W2A((wchar_t *) strHostName);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioDestination %s %d\n", hostname, nUDPPortNumber);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioDestination : entered Mutex\n");
	int resultCode(0);

	bool bUseFixedTransmitPort = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "UseFixedTransmitPort", false);
	if (bUseFixedTransmitPort)
	{
		unsigned short localTransmitPort = (unsigned short)(GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "TransmitPort", 0) % 65536);
		rtpSink->SetLocalPort(localTransmitPort);
	}
	resultCode = rtpSink->SetDestination(hostname, (short)nUDPPortNumber);
	strcpy(txParameters.strHostName, hostname);
	txParameters.UDPPortNumber = nUDPPortNumber;
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetAudioDestination : %d\n", resultCode);
	return resultCode;
}



STDMETHODIMP 
CCCNMediaTerm::SetAudioReceivePort(long nUDPPortNumber)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioReceivePort %d\n", nUDPPortNumber);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetAudioReceivePort : entered Mutex\n");
	bool restart = false;
	int result(0);
	int resultCode(0);

	bool needToSet = false;
	unsigned short currentReceivePort(0);
	resultCode = rtpSource->GetReceivePort(&currentReceivePort);
	if (resultCode != 0 || currentReceivePort != (unsigned short)nUDPPortNumber)
	{
		needToSet = true;
	}

	if (needToSet)
	{
		if (brxRunning)
		{
			result = StopRX();
			if (result < 0)
			{
				resultCode = -10;
			}
			restart = true;
		}

		if (resultCode == 0)
		{
			result = rtpSource->SetReceivePort(nUDPPortNumber);
			if (result < 0)
			{
				resultCode = -20;
			}
		}

		// update rxParameters

		if (resultCode == 0)
		{
			if (restart)
			{
				result = StartRX(waveoutDeviceID);
			}
			if (result < 0)
			{
				resultCode = -30;
			}
		}
	}
	else
	{
		tracer.tracef(ARB, "SetAudioReceivePort : no need to restart\n");
	}

	rtpSource->GetReceivePort(&currentReceivePort);
	rxParameters.UDPPortNumber = currentReceivePort;
	
	if (resultCode == 0)
	{
		tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetAudioReceivePort : %d\n", resultCode);
	}
	else
	{
		tracer.tracef(ERR, "~StartAudioReceivePort : error %d\n", resultCode);
	}
	return resultCode;
}

STDMETHODIMP 
CCCNMediaTerm::StartPlayingFileTX(BSTR Filename, unsigned long Mode, unsigned long volume, long * Cookie)
{
	USES_CONVERSION;
	int result(0);
	std::string filename = std::string(W2A((wchar_t *)Filename));
	tracer.tracef(EE, "StartPlayingFileTX file = %s, mode = %d\n", filename.c_str(), Mode);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	try
	{
		tracer.tracef(ARB, "StartPlayingFileTX : calling RemoveNonPlayingFiles()\n");
		RemoveNonPlayingFiles();
		if (btxRunning)
		{
			int returnCode(0);
			tracer.tracef(ARB, "StartPlayingFileTX : btxRunning = true. Playing file\n");
			FilePlay *newFilePlay = new FilePlay(txPCMMixer, txDuration, true);
			returnCode = newFilePlay->LoadFile(filename.c_str());
			if (returnCode != 0)
			{
				delete newFilePlay;
				newFilePlay = NULL;
				throw Exception(-10, "Error loading file %s", filename.c_str());
			}
			if (Mode == 0)
			{
				newFilePlay->PlayInLoop();
			}
			newFilePlay->SetVolume((int)volume);
			newFilePlay->SetDestinationFormat(WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1));
			tracer.tracef(ARB, "StartPlayingFileTX : Entering filesPlayingMutex\n");
			EnterCriticalSection(&filesPlayingMutex);
			filesPlaying[newFilePlay->GetCookie()] = newFilePlay;
			*Cookie = newFilePlay->GetCookie();
			newFilePlay->Start();
			LeaveCriticalSection(&filesPlayingMutex);
			tracer.tracef(ARB, "StartPlayingFileTX : Left filesPlayingMutex\n");
		}
	}
	catch (Exception ex)
	{
		tracer.tracef(ERR, "StartPlayingFileTX : %s\n", ex.ErrorMessage());
		result = ex.ErrorCode();
	}
	tracer.tracef(EE, "~StartPlayingFileTX : cookie = %d\n", *Cookie);
	return result;
}

STDMETHODIMP 
CCCNMediaTerm::StopPlayingFileTX(unsigned long Cookie)
{
	tracer.tracef(EE, "StopPlayingFileTX : cookie = %u\n", Cookie);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(ARB, "StopPlayingFileTX : Entering filesPlayingMutex\n");
	EnterCriticalSection(&filesPlayingMutex);
	map<unsigned int, FilePlay *>::iterator iter = filesPlaying.find(Cookie);
	if (iter != filesPlaying.end())
	{
		FilePlay *filePlay = (*iter).second;
		if (filePlay->Transmitting() == true)
		{
			filePlay->StopImmediately();
		}
	}
	LeaveCriticalSection(&filesPlayingMutex);
	tracer.tracef(ARB, "StopPlayingFileTX : Left filesPlayingMutex\n");
	tracer.tracef(EE, "~StopPlayingFileTX\n");
	return NOERROR;
}

STDMETHODIMP 
CCCNMediaTerm::StartPlayingFileRX(BSTR Filename, unsigned long Mode, unsigned long waveoutDeviceID, unsigned long volume, long * Cookie)
{
	USES_CONVERSION;
	int result(0);
	std::string filename = std::string(W2A((wchar_t *)Filename));
	tracer.tracef(EE, "StartPlayingFileRX file = %s, mode = %d, waveOutDeviceID = %d\n", filename.c_str(), Mode, waveoutDeviceID);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	try
	{
		tracer.tracef(ARB, "StartPlayingFileRX : calling RemoveNonPlayingFiles()\n");
		RemoveNonPlayingFiles();
		if (brxRunning && waveoutDeviceID == this->waveoutDeviceID)
		{
			tracer.tracef(ARB, "StartPlayingFileRX : playing file in audio stream\n");
			int resultCode(0);
			FilePlay *newFilePlay = new FilePlay(rxPCMMixer, rxDuration, false);
			resultCode = newFilePlay->LoadFile(filename.c_str());
			if (resultCode != 0)
			{
				delete newFilePlay;
				newFilePlay = NULL;
				throw Exception(-10, "Error loading file %s", filename.c_str());
			}
			if (Mode == 0)
			{
				newFilePlay->PlayInLoop();
			}
			newFilePlay->SetVolume((int)volume);
			newFilePlay->SetDestinationFormat(WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1));
			tracer.tracef(ARB, "StartPlayingFileRX : Entering filesPlayingMutex\n");
			EnterCriticalSection(&filesPlayingMutex);
			filesPlaying[newFilePlay->GetCookie()] = newFilePlay;
			*Cookie = newFilePlay->GetCookie();
			newFilePlay->Start();
			LeaveCriticalSection(&filesPlayingMutex);
			tracer.tracef(ARB, "StartPlayingFileRX : Left filesPlayingMutex\n");
		}
		else
		{
			if (bFilePlayRunning)
			{
				if (extraFilePlay == NULL)
				{
					tracer.tracef(ERR, "StartPlayingFileRX : bFilePlayRunning = true but extraFilePlay = NULL\n");
					bFilePlayRunning = false;
				}
				else
				{
					tracer.tracef(ARB, "StartPlayingFileRX : bFilePlayRunning = true. Calling StopPlayingFileRX\n");
					StopPlayingFileRX(extraFilePlay->GetCookie());
				}
			}
			if (extraFilePlay == NULL)
			{
				tracer.tracef(ARB, "StartPlayingFileRX : extraFilePlay = NULL. Playing file\n");
				int resultCode(0);
				extraFilePlay = new FilePlay(filePlayWaveSink, 60, false);
				resultCode = extraFilePlay->LoadFile(filename.c_str());
				if (resultCode != 0)
				{
					delete extraFilePlay;
					extraFilePlay = NULL;
					throw Exception(-20, "Error loading file %s to extraFilePlay", filename.c_str());
				}
				extraFilePlay->SetDestinationFormat(WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1));
				extraFilePlay->SetVolume((int)volume);
				if (Mode == 0)
				{
					extraFilePlay->PlayInLoop();
				}
				filePlayWaveSink->SetDeviceID(waveoutDeviceID);
				filePlayWaveSink->SetFrameSize(60 * 16);
				filePlayWaveSink->SetNumFrames(10);
				filePlayWaveSink->SetFormat(WaveFormat_PCM_16_8_1);
				tracer.tracef(ARB, "StartPlayingFileRX : Entering filesPlayingMutex\n");
				EnterCriticalSection(&filesPlayingMutex);
				*Cookie = extraFilePlay->GetCookie();
				LeaveCriticalSection(&filesPlayingMutex);
				tracer.tracef(ARB, "StartPlayingFileRX : Left filesPlayingMutex\n");
				extraFilePlay->Start();
				filePlayWaveSink->StartSinkThread();
				bFilePlayRunning = true;
			}
		}
	}
	catch (Exception ex)
	{
		tracer.tracef(ERR, "StartPlayingFileRX : %s\n", ex.ErrorMessage());
		result = ex.ErrorCode();
		*Cookie = 0;
	}
	if (result == 0)
	{
		tracer.tracef(EE, "~StartPlayingFileRX : cookie = %u\n", *Cookie);
	}
	else
	{
		tracer.tracef(ERR, "~StartPlayingFileRX : returning error code %d\n", result);
	}
	return result;
}


STDMETHODIMP 
CCCNMediaTerm::StopPlayingFileRX(unsigned long Cookie)
{
	tracer.tracef(EE, "StopPlayingFileRX %u\n", Cookie);
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	tracer.tracef(ARB, "StopPlayingFileRX : Entering filesPlayingMutex\n");
	EnterCriticalSection(&filesPlayingMutex);
	map<unsigned int, FilePlay *>::iterator iter = filesPlaying.find(Cookie);
	if (iter != filesPlaying.end())
	{
		FilePlay *filePlay = (*iter).second;
		if (filePlay->Transmitting() == false)
		{
			filePlay->StopImmediately();
		}
		LeaveCriticalSection(&filesPlayingMutex);
		tracer.tracef(ARB, "StopPlayingFileRX : Left filesPlayingMutex\n");
	}
	else 
	{
		LeaveCriticalSection(&filesPlayingMutex);
		tracer.tracef(ARB, "StopPlayingFileRX : Left filesPlayingMutex\n");
		if (extraFilePlay)
		{
			tracer.tracef(DET, "StopPlayingFileRX : extraFilePlay->cookie = %d\n", extraFilePlay->GetCookie());
			if (Cookie == extraFilePlay->GetCookie())
			{
				tracer.tracef(DET, "StopPlayingFileRX : calling filePlayWaveSink->StopSinkThread\n");
				int i;
				i = filePlayWaveSink->StopSinkThread();
				if (i != 0)
				{
					tracer.tracef(ERR, "StopPlayingFileRX : e-filePlayWaveSink->StopSinkThread() : %d\n", i);
				}
				tracer.tracef(DET, "StopPlayingFileRX : calling extraFilePlay->StopImmediately\n");
				i = extraFilePlay->StopImmediately();
				if (i != 0)
				{
					tracer.tracef(ERR, "StopPlayingFileRX : e-extraFilePlay->StopImmediately() : %d\n", i);
				}
				if (!extraFilePlay->IsRunning())
				{
					bFilePlayRunning = false;
					tracer.tracef(DET, "StopPlayingFileRX : deleting extraFilePlay\n");
					delete extraFilePlay;
					extraFilePlay = NULL;
				}
				else
				{
					int i=10;
				}
			}
		}
	}
	tracer.tracef(EE, "~StopPlayingFileRX\n");
	return S_OK;
}

STDMETHODIMP 
CCCNMediaTerm::StartTX(unsigned long waveinDeviceID)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StartTX\n");
	CSingleLock cLock(&Mutex);
	cLock.Lock();
	int resultCode(0);
	
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StartTX : 0\n");
	if (!btxRunning)
	{
		// find out if pre-emphasis needs to be done, and if so with what parameters
		btxPreEmphasis = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "MicrophonePreprocess", true);
		long txFIRFilter = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "TxFIRFilter", 1);
		if (txFIRFilter == 2)
		{
			outputFIRTransformer->SetCoefficients(FIR_TELECASTER_TX, FIR_TELECASTER_TX_NUM, 16);
		}
		else
		{
			outputFIRTransformer->SetCoefficients(FIR_ITU_TX_IRS, FIR_ITU_TX_IRS_NUM, 16);
		}

		this->waveinDeviceID = waveinDeviceID;
		waveSource->SetDeviceID(waveinDeviceID);

		AudioSource *temp = waveSource;

		if (btxPreEmphasis)
		{
			Connect(temp, outputFIRTransformer);
			temp = outputFIRTransformer;
		}
		if (btxVAD)
		{
			Connect(temp, voiceActivityDetector);
			temp = voiceActivityDetector;
		}
		Connect(temp, txPCMMixer);
		Connect(txPCMMixer, txTransformer);
		Connect(txTransformer, rtpSink);

		do
		{
			int result(0);
			long transmitTOS = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "TransmitTOS", 0xb8);
			unsigned char tos = (unsigned char)transmitTOS;
			result = rtpSink->SetTOS(tos);
			result = rtpSink->StartSink();
			if (result < 0)
			{
				resultCode = -10;
				break;
			}
			result = txTransformer->StartTransform();
			if (result < 0)
			{
				rtpSink->StopSink();
				resultCode = -20;
				break;
			}
			result = txPCMMixer->StartTransform();
			if (result < 0)
			{
				rtpSink->StopSink();
				txTransformer->StopTransform();
				resultCode = -30;
				break;
			}
			if (btxVAD)
			{
				voiceActivityDetector->EnableDetection();
				result = voiceActivityDetector->StartTransform();
				if (result < 0)
				{
					rtpSink->StopSink();
					txTransformer->StopTransform();
					txPCMMixer->StopTransform();
					resultCode = -40;
					break;
				}
			}
			if (btxPreEmphasis)
			{
				result = outputFIRTransformer->StartTransform();
				if (result < 0)
				{
					rtpSink->StopSink();
					txTransformer->StopTransform();
					txPCMMixer->StopTransform();
					if (btxVAD)
					{
						voiceActivityDetector->StopTransform();
					}
					resultCode = -50;
					break;
				}
			}
			result = waveSource->StartSourceThread();
			if (result < 0)
			{
				rtpSink->StopSink();
				txTransformer->StopTransform();
				txPCMMixer->StopTransform();
				if (btxVAD)
				{
					voiceActivityDetector->StopTransform();
				}
				if (btxPreEmphasis)
				{
					outputFIRTransformer->StopTransform();
				}
				resultCode = -60;
				break;
			}
		} while (false);
	}
	if (resultCode == 0)
	{
		btxRunning = true;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~StartTX : %d\n", resultCode);
	return resultCode;
}





STDMETHODIMP 
CCCNMediaTerm::StopTX()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StopTX\n");
	CSingleLock cLock(&Mutex);
	cLock.Lock();

	bool bError(false);
	int resultCode(0);
	tracer.tracef(ARB, "StopTX : after cLock.Lock()\n");
	if (btxRunning)
	{
		int result(0);
		result = StopAllFiles(true);
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopTX : e-StopAllFiles %d\n", result);
		}
		tracer.tracef(ARB, "StopTX : before waveSource->StopSourceThread()\n");
		result = waveSource->StopSourceThread();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopTX : e-waveSource->StopSourceThread %d\n", result);
		}
		if (btxPreEmphasis)
		{
			tracer.tracef(ARB, "StopTX : before outputFIRTransformer->StopTransform()\n");
			result = outputFIRTransformer->StopTransform();
			if (result < 0)
			{
				bError = true;
				tracer.tracef(ERR, "StopTX : e-outputFIRTransformer->StopTransform %d\n", result);
			}
		}
		if (btxVAD)
		{
			tracer.tracef(ARB, "StopTX : before voiceActivityDetector->StopTransform()\n");
			result = voiceActivityDetector->StopTransform();
			if (result < 0)
			{
				bError = true;
				tracer.tracef(ERR, "StopTX : e-voiceActivityDetector->StopTransform %d\n", result);
			}
		}
		tracer.tracef(ARB, "StopTX : before txPCMMixer->StopTransform()\n");
		result = txPCMMixer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopTX : e-txPCMMixer->StopTransform %d\n", result);
		}
		tracer.tracef(ARB, "StopTX : before txTransformer->StopTransform()\n");
		result = txTransformer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopTX : e-txTransformer->StopTransform %d\n", result);
		}
		tracer.tracef(ARB, "StopTX : before rtpSink->StopSink()\n");
		result = rtpSink->StopSink();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopTX : e-rtpSink->StopSink %d\n", result);
		}
		tracer.tracef(ARB, "StopTX : before Disconnects\n");

		AudioSource *temp = waveSource;
		if (btxPreEmphasis)
		{
			Disconnect(temp, outputFIRTransformer);
			temp = outputFIRTransformer;
		}
		if (btxVAD)
		{
			Disconnect(temp, voiceActivityDetector);
			temp = voiceActivityDetector;
		}
		Disconnect(temp, txPCMMixer);
		Disconnect(txPCMMixer, txTransformer);
		Disconnect(txTransformer, rtpSink);

		tracer.tracef(ARB, "StopTX : after Disconnects\n");
	}
	if (!bError)
	{
		btxRunning = false;
	}
	else
	{
		resultCode = -10;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~StopTX : %d\n", resultCode);
	return resultCode;
}




STDMETHODIMP 
CCCNMediaTerm::StartRX(unsigned long waveoutDeviceID)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StartRX\n");
	CSingleLock cLock(&Mutex);
	cLock.Lock();

	int result(0);
	int returnCode(0);

	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StartRX : brxRunning = %d\n", brxRunning);
	if (!brxRunning)
	{
		brxPostEmphasis = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "SpeakerPostprocess", true);
		brxVolumeLimit = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "LimitVolume", true);

		// set up the post emphasis filter
		long rxFIRFilter = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "RxFIRFilter", 1);
		if (rxFIRFilter == 2)
		{
			inputFIRTransformer->SetCoefficients(FIR_TELECASTER_RX, FIR_TELECASTER_RX_NUM, 16);
		}
		else
		{
			inputFIRTransformer->SetCoefficients(FIR_ITU_RX_IRS, FIR_ITU_RX_IRS_NUM, 16);
		}

		// set up the limiter
		// set up RTP jitter buffer and fixed size audio buffer
		long jitterBufferDepth = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "JitterBufferTime", 100);
		rtpJitterBuffer->SetJitterBufferDepth(jitterBufferDepth);
		fixedSizeAudioBuffer->SetOutputDuration(rxDuration);
		int numFrames = _winmajor < 5 ? 10 : 6;
		bool  useDynamicJitterBuffer = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "UseDynamicJitterBuffer", true);
		if (useDynamicJitterBuffer)
		{
			waveSink->SetNumFrames(numFrames);
		}
		else
		{
			waveSink->SetNumFrames(max(numFrames, jitterBufferDepth/rxDuration));
		}

		double threshold;
		double lossIncrement;
		double lossDecrement;
		std::string strThreshold = GetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "LimiterThreshold", "-8.0");
		std::string strLossIncrement = GetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "LimiterLossIncrement", "0.075");
		std::string strLossDecrement = GetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "LimiterLossDecrement", "-0.00075");
		threshold = atof(strThreshold.c_str());
		lossIncrement = atof(strLossIncrement.c_str());
		lossDecrement = atof(strLossDecrement.c_str());
		limiter->SetParameters(threshold, lossIncrement, lossDecrement);

		this->waveoutDeviceID = waveoutDeviceID;
		waveSink->SetDeviceID(waveoutDeviceID);

		double volumeMaximizePercentile = atof((GetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "VolumeMaximizePercentile", "95.00")).c_str());
		double volumeMaximizeMaxAmplification = fabs(atof((GetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "VolumeMaximizeMaxGain", "8.00")).c_str()));
		unsigned int maxGain = (unsigned int)(volumeMaximizeMaxAmplification * 100);
		pcmVolumeMaximizer->SetMaximizePercentile(volumeMaximizePercentile);
		pcmVolumeMaximizer->SetMaximumAmplification(maxGain);

		Connect(rtpSource, rxTransformer);
		Connect(rxTransformer, rtpJitterBuffer);
		Connect(rtpJitterBuffer, fixedSizeAudioBuffer);
		Connect(fixedSizeAudioBuffer, pcmVolumeMaximizer);
		Connect(pcmVolumeMaximizer, rxPCMMixer);
		AudioSource *tempSource = rxPCMMixer;
		if (brxPostEmphasis)
		{
			Connect(tempSource, inputFIRTransformer);
			tempSource = inputFIRTransformer;
		}
		if (brxVolumeLimit)
		{
			Connect(tempSource, limiter);
			tempSource = limiter;
		}
		Connect(tempSource, waveSink);

		do
		{
			result = rxTransformer->StartTransform();
			if (result < 0)
			{
				returnCode = -10;
				break;
			}
			result = rtpJitterBuffer->StartTransform();
			if (result < 0)
			{
				rxTransformer->StopTransform();
				returnCode = -20;
				break;
			}
			result = fixedSizeAudioBuffer->StartTransform();
			if (result < 0)
			{
				rxTransformer->StopTransform();
				rtpJitterBuffer->StopTransform();
				returnCode = -30;
				break;
			}
			result = pcmVolumeMaximizer->StartTransform();
			if (result < 0)
			{
				rxTransformer->StopTransform();
				rtpJitterBuffer->StopTransform();
				fixedSizeAudioBuffer->StopTransform();
				returnCode = -40;
				break;
			}
			result = rxPCMMixer->StartTransform();
			if (result < 0)
			{
				rxTransformer->StopTransform();
				rtpJitterBuffer->StopTransform();
				fixedSizeAudioBuffer->StopTransform();
				pcmVolumeMaximizer->StopTransform();
				returnCode = -50;
				break;
			}
			if (brxPostEmphasis)
			{
				result = inputFIRTransformer->StartTransform();
				if (result < 0)
				{
					rxTransformer->StopTransform();
					rtpJitterBuffer->StopTransform();
					fixedSizeAudioBuffer->StopTransform();
					pcmVolumeMaximizer->StopTransform();
					rxPCMMixer->StopTransform();
					returnCode = -60;
					break;
				}
			}
			if (brxVolumeLimit)
			{
				result = limiter->StartTransform();
				if (result < 0)
				{
					rxTransformer->StopTransform();
					rtpJitterBuffer->StopTransform();
					fixedSizeAudioBuffer->StopTransform();
					pcmVolumeMaximizer->StopTransform();
					rxPCMMixer->StopTransform();
					inputFIRTransformer->StopTransform();
					returnCode = -70;
					break;
				}
			}
			result = waveSink->StartSinkThread();
			if (result < 0)
			{
				rxTransformer->StopTransform();
				rtpJitterBuffer->StopTransform();
				fixedSizeAudioBuffer->StopTransform();
				pcmVolumeMaximizer->StopTransform();
				rxPCMMixer->StopTransform();
				inputFIRTransformer->StopTransform();
				limiter->StopTransform();
				returnCode = -80;
				break;
			}
			result = rtpSource->StartSourceThread();
			if (result < 0)
			{
				waveSink->StopSinkThread();
				rxTransformer->StopTransform();
				rtpJitterBuffer->StopTransform();
				fixedSizeAudioBuffer->StopTransform();
				pcmVolumeMaximizer->StopTransform();
				rxPCMMixer->StopTransform();
				inputFIRTransformer->StopTransform();
				limiter->StopTransform();
				returnCode = -90;
				break;
			}
		} while (false);
	}			
	if (returnCode == 0)
	{
		brxRunning = true;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~StartRX : returning %d\n", returnCode);
	return returnCode;
}

STDMETHODIMP 
CCCNMediaTerm::StopRX()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "StopRX\n");
	CSingleLock cLock(&Mutex);
	cLock.Lock();

	bool bError = false;
	int resultCode(0);
	tracer.tracef(ARB, "StopRX : brxRunning = %d\n", brxRunning);
	if (brxRunning)
	{
		int result(0);
		tracer.tracef(ARB, "StopRX : calling StopAllFiles(false)\n");
		result = StopAllFiles(false);
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-StopAllFiles = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling waveSink->StopSinkThread()\n");
		result = waveSink->StopSinkThread();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-waveSink->StopSinkThread = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling rtpSource->UnprepareSource()\n");
		result = rtpSource->UnprepareSource();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-rtpSource->UnprepareSource = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling rtpSource->StopSourceThread()\n");
		result = rtpSource->StopSourceThread();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-rtpSource->StopSourceThread = %d\n", result);
		}
		if (brxVolumeLimit)
		{
			tracer.tracef(ARB, "StopRX : calling limiter->StopTransform()\n");
			result = limiter->StopTransform();
			if (result < 0)
			{
				bError = true;
				tracer.tracef(ERR, "StopRX : e-limiter->StopTransform = %d\n", result);
			}
		}
		if (brxPostEmphasis)
		{
			tracer.tracef(ARB, "StopRX : calling inputFIRTransformer->StopTransform()\n");
			result = inputFIRTransformer->StopTransform();
			if (result < 0)
			{
				bError = true;
				tracer.tracef(ERR, "StopRX : e-inputFIRTransformer->StopTransform = %d\n", result);
			}
		}
		tracer.tracef(ARB, "StopRX : calling rxPCMMixer->StopTransform()\n");
		result = rxPCMMixer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-rxPCMMixer->StopTransform = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling pcmVolumeMaximizer->StopTransform()\n");
		result = pcmVolumeMaximizer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-pcmVolumeMaximizer->StopTransform = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling fixedSizeAudioBuffer->StopTransform()\n");
		result = fixedSizeAudioBuffer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-fixedSizeAudioBuffer->StopTransform = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling rtpJitterBuffer->StopTransform()\n");
		result = rtpJitterBuffer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-rtpJitterBuffer->StopTransform = %d\n", result);
		}
		tracer.tracef(ARB, "StopRX : calling rxTransformer->StopTransform()\n");
		result = rxTransformer->StopTransform();
		if (result < 0)
		{
			bError = true;
			tracer.tracef(ERR, "StopRX : e-rxTransformer->StopTransform = %d\n", result);
		}

		tracer.tracef(ARB, "StopRX : disconnecting filters\n");
		Disconnect(rtpSource, rxTransformer);
		Disconnect(rxTransformer, rtpJitterBuffer);
		Disconnect(rtpJitterBuffer, fixedSizeAudioBuffer);
		Disconnect(fixedSizeAudioBuffer, pcmVolumeMaximizer);
		Disconnect(pcmVolumeMaximizer, rxPCMMixer);
		AudioSource *tempSource = rxPCMMixer;
		if (brxPostEmphasis)
		{
			Disconnect(tempSource, inputFIRTransformer);
			tempSource = inputFIRTransformer;
		}
		if (brxVolumeLimit)
		{
			Disconnect(tempSource, limiter);
			tempSource = limiter;
		}
		Disconnect(tempSource, waveSink);
	}
	if (!bError)
	{
		brxRunning = false;
	}
	else
	{
		resultCode = -10;
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~StopRX : %d\n", resultCode);
	return resultCode;
}

int 
CCCNMediaTerm::RemoveNonPlayingFiles()
{
	tracer.tracef(EE, "RemoveNonPlayingFiles\n");
	tracer.tracef(ARB, "RemoveNonPlayingFiles : Entering filesPlayingMutex\n");
	EnterCriticalSection(&filesPlayingMutex);
	vector<map<unsigned int, FilePlay *>::iterator> filesToDelete;
	map<unsigned int, FilePlay *>::iterator iter = filesPlaying.begin();
	while (iter != filesPlaying.end())
	{
		FilePlay *filePlay = (*iter).second;
		tracer.tracef(DET, "RemoveNonPlayingFiles : file found with cookie = %d\n", filePlay->GetCookie());
		if (!(filePlay->IsRunning()))
		{
			tracer.tracef(DET, "RemoveNonPlayingFiles : file with cookie = %d is not playing\n", filePlay->GetCookie());
			filesToDelete.push_back(iter);
		}
		iter++;
	}
	tracer.tracef(DET, "RemoveNonPlayingFiles : deleting non-playing files from list\n");
	for (int i=0; i<filesToDelete.size(); i++)
	{
		map<unsigned int, FilePlay *>::iterator iter = filesToDelete[i];
		FilePlay *filePlay = (*iter).second;
		filesPlaying.erase(iter);
		delete filePlay;
	}
	if (extraFilePlay)
	{
		if (!extraFilePlay->IsRunning())
		{
			tracer.tracef(DET, "RemoveNonPlayingFiles : extrafileplay found with cookie = %d\n", extraFilePlay->GetCookie());
			tracer.tracef(DET, "RemoveNonPlayingFiles : deleting extraFilePlay\n");
			delete extraFilePlay;
			extraFilePlay = NULL;
			bFilePlayRunning = false;
		}
	}
	LeaveCriticalSection(&filesPlayingMutex);
	tracer.tracef(ARB, "RemoveNonPlayingFiles : Left filesPlayingMutex\n");
	tracer.tracef(EE, "~RemoveNonPlayingFiles\n");
	return NOERROR;
}

int
CCCNMediaTerm::StopAllFiles(bool transmitSide)
{
	tracer.tracef(EE, "StopAllFiles %d\n", transmitSide);
	tracer.tracef(ARB, "StopAllFiles : Entering filesPlayingMutex\n");
	EnterCriticalSection(&filesPlayingMutex);
	map<unsigned int, FilePlay *>::iterator iter = filesPlaying.begin();
	while(iter != filesPlaying.end())
	{
		FilePlay *filePlay = (*iter).second;
		tracer.tracef(DET, "StopAllFiles : file with cookie = %d\n", filePlay->GetCookie());
		if (filePlay->IsRunning() && filePlay->Transmitting() == transmitSide)
		{
			tracer.tracef(DET, "StopAllFiles : stopping filePlay with cookie = %d\n", filePlay->GetCookie());
			filePlay->StopImmediately();
		}
		iter++;
	}
	LeaveCriticalSection(&filesPlayingMutex);
	tracer.tracef(ARB, "StopAllFiles : Left filesPlayingMutex\n");
	tracer.tracef(EE, "~StopAllFiles\n");
	return 0;
}

STDMETHODIMP CCCNMediaTerm::SetSpeakerVolume(unsigned long deviceID, unsigned long volume)
{
	tracer.tracef(EE, "SetSpeakerVolume device=%u, volume=%u\n", deviceID, volume);
	int result(0);
	if (deviceID == filePlayWaveSink->GetDeviceID() && bFilePlayRunning)
	{
		result = filePlayWaveSink->SetVolume(volume);
	}
	else if (deviceID == waveSink->GetDeviceID() && brxRunning)
	{
		result = waveSink->SetVolume(volume);
	}
	tracer.tracef(EE, "~SetSpeakerVolume : returning %d 0x%x\n", result, result);
	return result;
}



// sets the components internal setting for mic volume. max volume = system's current mic volume setting
STDMETHODIMP 
CCCNMediaTerm::SetMicrophoneVolume(unsigned long deviceID, unsigned long volume)
{
	tracer.tracef(EE, "SetMicrophoneVolume device=%u, volume=%u\n", deviceID, volume);
	waveSource->SetVolume(volume);
	tracer.tracef(EE, "~SetMicrophoneVolume\n");
	return S_OK;
}



// changes the system's microphone volume setting
HRESULT 
CCCNMediaTerm::SetSystemMicrophoneVolume(unsigned long volume)
{
	return S_OK;
}


bool
CCCNMediaTerm::SpeakerAvailable() 
{
	bool available = true;
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SpeakerAvailable\n");

	WAVEFORMATEX waveFormatex;
	waveFormatex.nAvgBytesPerSec = 16000;
	waveFormatex.wFormatTag = WAVE_FORMAT_PCM;
	waveFormatex.wBitsPerSample = 16;
	waveFormatex.nChannels = 1;
	waveFormatex.nBlockAlign = 2;
	waveFormatex.nSamplesPerSec = 8000;
	waveFormatex.cbSize = 0;

	// see if the speaker is available
	HWAVEOUT hWaveOut;
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SpeakerAvailable : opening wave device\n");
	MMRESULT mmr = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormatex, NULL, NULL, CALLBACK_NULL);
	if (mmr != MMSYSERR_NOERROR) {
		available = false;
		int retryInterval = 2000;
		tracer.tracef(SDI_LEVEL_ERROR, "SpeakerAvailable : error : could not open wave device. waveOutOpen returned 0x%x\n", mmr);
		tracer.tracef(SDI_LEVEL_ARBITRARY, "SpeakerAvailable : trying again after %d ms\n", retryInterval);
		Sleep(retryInterval);
		MMRESULT mmr = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormatex, NULL, NULL, CALLBACK_NULL);
		if (mmr != MMSYSERR_NOERROR) {
			tracer.tracef(SDI_LEVEL_ERROR, "SpeakerAvailable : error : still could not open wave device. waveOutOpen returned 0x%x\n", mmr);
		}
		else {
			tracer.tracef(SDI_LEVEL_ARBITRARY, "SpeakerAvailable : got the speaker second time\n");
			waveOutReset(hWaveOut);
			waveOutClose(hWaveOut);
			available = true;
		}
	}
	else {
		waveOutReset(hWaveOut);
		waveOutClose(hWaveOut);
		available = true;
	}
	
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SpeakerAvailable : returning %d\n", available);
	return available;
}




bool
CCCNMediaTerm::MicrophoneAvailable()
{
	bool available = true;
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "MicrophoneAvailable\n");

	WAVEFORMATEX waveFormatex;
	waveFormatex.nAvgBytesPerSec = 16000;
	waveFormatex.wFormatTag = WAVE_FORMAT_PCM;
	waveFormatex.wBitsPerSample = 16;
	waveFormatex.nChannels = 1;
	waveFormatex.nBlockAlign = 2;
	waveFormatex.nSamplesPerSec = 8000;
	waveFormatex.cbSize = 0;

	// see if the microphone is available
	HWAVEIN hwaveIn;
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "MicrophoneAvailable : opening wavein device\n");
	MMRESULT mmr = waveInOpen(&hwaveIn, WAVE_MAPPER, &waveFormatex, NULL, NULL, CALLBACK_NULL);
	if (mmr != MMSYSERR_NOERROR) {
		tracer.tracef(SDI_LEVEL_ERROR, "MicrophoneAvailable : error : could not open wavein device. waveInOpen returned 0x%x\n", mmr);
		available = false;
	}

	else {
		waveInReset(hwaveIn);
		waveInClose(hwaveIn);
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~MicrophoneAvailable : returning %d\n", available);
	return available;
}



STDMETHODIMP CCCNMediaTerm::SetFilePlayVolume(unsigned long cookie, unsigned long volume)
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetFilePlayVolume cookie=%u volume=%u\n", cookie, volume);
	if (bFilePlayRunning && extraFilePlay && cookie == extraFilePlay->GetCookie())
	{
		tracer.tracef(ARB, "SetFilePlayVolume : Setting volume for extraFilePlay\n");
		extraFilePlay->SetVolume((int)volume);
	}
	else
	{
		tracer.tracef(ARB, "SetFilePlayVolume : Entering filesPlayingMutex\n");
		EnterCriticalSection(&filesPlayingMutex);
		map<unsigned int, FilePlay *>::iterator iter = filesPlaying.find(cookie);
		if (iter != filesPlaying.end())
		{
			FilePlay *filePlay = (*iter).second;
			filePlay->SetVolume((int)volume);
		}
		LeaveCriticalSection(&filesPlayingMutex);
		tracer.tracef(ARB, "SetFilePlayVolume : Left filesPlayingMutex\n");
	}
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetFilePlayVolume\n");
	return S_OK;
}

void
CCCNMediaTerm::FireEndOfFileRX(unsigned long cookie)
{
	int resultCode(0);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "FireEndOfFileRX cookie=%u\n", cookie);
	if ((extraFilePlay && (cookie == extraFilePlay->GetCookie())) ||
		!bFilePlayRunning
		)
	{
		resultCode = filePlayWaveSink->StopSinkThread();
		if (resultCode != 0)
		{
			if (resultCode != -10)
			{
				tracer.tracef(ERR, "FireEndOfFileRX : e-filePlayWaveSink->StopSinkThread() : %d\n", resultCode);
			}
			else
			{
				tracer.tracef(SIG, "FireEndOfFileRX : e-filePlayWaveSink->StopSinkThread() : %d\n", resultCode);
			}
		}
		tracer.tracef(DET, "FireEndOfFileRX : setting bFilePlayRunning to false\n");
		bFilePlayRunning = false;
	}
	Fire_EndOfFileEventRX(cookie);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~FireEndOfFileRX\n");
}

void
CCCNMediaTerm::FireEndOfFileTX(unsigned long cookie)
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "FireEndOfFileTX cookie=%u\n", cookie);
	Fire_EndOfFileEventTX(cookie);
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~FireEndOfFileTX\n");
}

STDMETHODIMP CCCNMediaTerm::NetworkMonitor(unsigned long, unsigned long)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StartDtmfTone(long, long, long)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StopDtmfTone(void)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StopAudioReceive(void)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StartAudioReceive(void)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StopMicrophone(void)
{
	return S_OK;
}

STDMETHODIMP CCCNMediaTerm::StartMicrophone(void)
{
	return S_OK;
}

int
FilePlay::Initialize(CCCNMediaTerm *mediaTerm)
{
	FilePlay::mediaTerm = mediaTerm;
	InitializeCriticalSection(&fireEventThreadMutex);
	fireEventThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	numOutstandingEvents = 0;
	closing = false;
	return 0;
}

int
FilePlay::Uninitialize()
{
	EnterCriticalSection(&fireEventThreadMutex);
	closing = true;
	LeaveCriticalSection(&fireEventThreadMutex);
	while (true)
	{
		EnterCriticalSection(&fireEventThreadMutex);
		{
			if (numOutstandingEvents > 0)
			{
				LeaveCriticalSection(&fireEventThreadMutex);
				WaitForSingleObject(fireEventThreadEvent, INFINITE);
			}
			else
			{
				LeaveCriticalSection(&fireEventThreadMutex);
				break;
			}
		}
	}
	DeleteCriticalSection(&fireEventThreadMutex);
	CloseHandle(fireEventThreadEvent);
	return 0;
}

DWORD WINAPI
FilePlay::FireEventThread(LPVOID params)
{
	if (FilePlay::closing)
	{
		return 0;
	}
	
	EnterCriticalSection(&fireEventThreadMutex);
	numOutstandingEvents++;
	LeaveCriticalSection(&fireEventThreadMutex);

	FireEventThreadParams *fetParams = (FireEventThreadParams *)params;
	if (fetParams->receiveSide)
	{
		mediaTerm->FireEndOfFileRX(fetParams->cookie);
	}
	else
	{
		mediaTerm->FireEndOfFileTX(fetParams->cookie);
	}

	SetEvent(FilePlay::fireEventThreadEvent);
	delete fetParams;
	EnterCriticalSection(&fireEventThreadMutex);
	numOutstandingEvents--;
	LeaveCriticalSection(&fireEventThreadMutex);
	return 0;
}

FilePlay::FilePlay(AudioSink *audioSink, int outputDuration, bool bTransmit)
{
	char subFacilityName[100];
	sprintf(subFacilityName, "FilePlay:%x", this);
	tracer.SetSubFacilityName(subFacilityName);
	SetTraceLevel();
	InitializeCriticalSection(&stateMutex);
	stateChangedEvent = CreateEvent(NULL, NULL, FALSE, NULL);
	this->bTransmit = bTransmit;
	waveFileSource = new WaveFileSource();
	waveFileSource->AddFilePlayListener(this);
	acmTransformer = new ACMTransformer();
	acmTransformer->SetOutputDuration(outputDuration);
	pcmVolumeTransformer = new PCMVolumeTransformer();
	this->audioSink = NULL;	// will be set in the call to Connect(audioSink) below
	currentState = STATE_STOPPED;

	::Connect(waveFileSource, acmTransformer);
	::Connect(acmTransformer, pcmVolumeTransformer);
	Connect(audioSink);

	cookie = ++nextCookie;
}

FilePlay::~FilePlay()
{
	StopImmediately();
	Disconnect();
	delete waveFileSource;
	delete acmTransformer;
	delete pcmVolumeTransformer;
	DeleteCriticalSection(&stateMutex);
	CloseHandle(stateChangedEvent);
}

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

bool
FilePlay::IsRunning()
{
	tracer.tracef(EE, "IsRunning\n");
	bool isRunning(true);
	tracer.tracef(ARB, "IsRunning : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState == STATE_STOPPED)
	{
		isRunning = false;
	}
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "IsRunning : left stateMutex\n");
	tracer.tracef(EE, "~IsRunning : returning %d\n", isRunning);
	return isRunning;
}

int
FilePlay::LoadFile(const char *fileName)
{
	tracer.tracef(EE, "LoadFile %s\n", fileName);
	int result = waveFileSource->OpenWaveFile(fileName);
	if (result != 0)
	{
		tracer.tracef(ERR, "LoadFile : e-waveFileSource->OpenWaveFile : %d\n", result);
	}
	tracer.tracef(EE, "~LoadFile : %d\n", result);
	return result;
}

int
FilePlay::PlayOnce()
{
	tracer.tracef(EE, "PlayOnce\n");
	int result = waveFileSource->PlayOnce();
	if (result != 0)
	{
		tracer.tracef(ERR, "LoadFile : e-waveFileSource->PlayOnce : %d\n", result);
	}
	tracer.tracef(EE, "~PlayOnce : %d\n", result);
	return result;
}

int
FilePlay::PlayInLoop()
{
	tracer.tracef(EE, "PlayInLoop\n");
	int result = waveFileSource->PlayInLoop();
	if (result != 0)
	{
		tracer.tracef(ERR, "LoadFile : e-waveFileSource->PlayInLoop : %d\n", result);
	}
	tracer.tracef(EE, "~PlayInLoop : %d\n", result);
	return result;
}

int
FilePlay::Start()
{
	tracer.tracef(EE, "Start\n");
	int returnCode(0);
	tracer.tracef(ARB, "Start : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	tracer.tracef(ARB, "Start : currentState = %d\n", currentState);
	bool startNeeded = false;
	switch(currentState)
	{
	case STATE_STOPPED:
		currentState = STATE_STARTING;
		SetEvent(stateChangedEvent);
		tracer.tracef(ARB, "Start STATE_STOPPED: setting stateChangedEvent. Went to STATE_STARTING\n");
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "Start STATE_STOPPED: left stateMutex\n");
		returnCode = 0;
		startNeeded = true;
		break;
	case STATE_RUNNING:
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "Start STATE_RUNNING: left stateMutex\n");
		returnCode = 0;
		break;
	case STATE_STARTING:
		while (currentState != STATE_RUNNING && currentState != STATE_STOPPED)
		{
			tracer.tracef(ARB, "Start STATE_STARTING: currentState = %d\n", currentState);
			ResetEvent(stateChangedEvent);
			tracer.tracef(ARB, "Start STATE_STARTING: resetting stateChangedEvent\n");
			LeaveCriticalSection(&stateMutex);
			tracer.tracef(ARB, "Start STATE_STARTING: left stateMutex\n");
			tracer.tracef(ARB, "Start STATE_STARTING: waiting for stateChangedEvent\n");
			WaitForSingleObject(stateChangedEvent, INFINITE);
			tracer.tracef(ARB, "Start STATE_STARTING: entering stateMutex\n");
			EnterCriticalSection(&stateMutex);
		}
		if (currentState == STATE_STOPPED)
		{
			tracer.tracef(ERR, "Start STATE_STARTING: went to STATE_STOPPED ! Returning error\n");
			returnCode = -10;
		}
		else
		{
			returnCode = 0;
		}
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "Start STATE_STARTING: left stateMutex\n");
		break;
	case STATE_STOPPING:
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "Start STATE_STOPPING: left stateMutex\n");
		tracer.tracef(ERR, "Start STATE_STOPPING: invalid state to call Start\n");
		returnCode = -20;
		break;
	default:
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "Start default: left stateMutex\n");
		tracer.tracef(ERR, "Start default: Error : invalid current state %d\n", currentState);
		returnCode = -30;
		break;
	}

	if (returnCode == 0 && startNeeded)
	{
		int result(0);
		tracer.tracef(ARB, "Start : bRunning = false\n");
		WAVEFORMATEX wfx;
		do
		{
			tracer.tracef(DET, "Start : calling waveFileSource->GetFormat\n");
			result = waveFileSource->GetFormat(&wfx);
			if (result < 0)
			{
				tracer.tracef(ERR, "Start : e-waveFileSource->GetFormat : %d %x\n", result, result);
				returnCode = -35;
				break;
			}
			tracer.tracef(DET, "Start : calling acmTransformer->SetSourceFormat\n");
			result = acmTransformer->SetSourceFormat(wfx);
			if (result < 0)
			{
				tracer.tracef(ERR, "Start : e-acmTransformer->SetSourceFormat : %d %x\n", result, result);
				returnCode = -40;
				break;
			}
			tracer.tracef(DET, "Start : calling pcmVolumeTransformer->StartTransform\n");
			result = pcmVolumeTransformer->StartTransform();
			if (result < 0)
			{
				tracer.tracef(ERR, "Start : e-pcmVolumeTransformer->StartTransform : %d %x\n", result, result);
				returnCode = -50;
				break;
			}
			tracer.tracef(DET, "Start : calling acmTransformer->StartTransform\n");
			result = acmTransformer->StartTransform();
			if (result < 0)
			{
				tracer.tracef(ERR, "Start : e-acmTransformer->StartTransform : %d %x\n", result, result);
				pcmVolumeTransformer->StopTransform();
				returnCode = -60;
				break;
			}
			tracer.tracef(DET, "Start : calling waveFileSource->StartSourceThread\n");
			waveFileSource->StartSourceThread();
			if (result < 0)
			{
				tracer.tracef(ERR, "Start : e-waveFileSource->StartSourceThread : %d %x\n", result, result);
				pcmVolumeTransformer->StopTransform();
				acmTransformer->StopTransform();
				returnCode = -70;
				break;
			}
		} while (false);
		if (returnCode == 0)
		{
			// this means start was successful. then FilePlayStarted would have 
			// set the current State to STATE_RUNNING
			tracer.tracef(ARB, "Start : successful start\n");
		}
		else
		{
			tracer.tracef(ARB, "Start : entering stateMutex\n");
			EnterCriticalSection(&stateMutex);
			tracer.tracef(ERR, "Start : unsuccessful start. Going to STOPPED state\n");
			currentState = STATE_STOPPED;
			tracer.tracef(ARB, "Start : setting stateChangedEvent. Went to STATE_STOPPED\n");
			SetEvent(stateChangedEvent);
			LeaveCriticalSection(&stateMutex);
			tracer.tracef(ARB, "Start : left stateMutex\n");
		}
	}
	if (returnCode == 0)
	{
		tracer.tracef(EE, "~Start : success\n");
	}
	else
	{
		tracer.tracef(ERR, "~Start : e-Start : failure : returnCode = %d\n", returnCode);
	}
	return returnCode;
}

void FilePlay::Cleanup()
{	
	tracer.tracef(EE, "Cleanup\n");
	tracer.tracef(ARB, "Cleanup : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState != STATE_STOPPING)
	{
		tracer.tracef(ERR, "Cleanup : invalid state %d to call Cleanup\n", currentState);
	}
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "Cleanup : left stateMutex\n");
	tracer.tracef(ARB, "Cleanup : calling ::Disconnect(waveFileSource, acmTransformer)\n");
	::Disconnect(waveFileSource, acmTransformer);
	tracer.tracef(ARB, "Cleanup : calling acmTransformer->StopTransform\n");
	acmTransformer->StopTransform();
	tracer.tracef(ARB, "Cleanup : calling pcmVolumeTransformer->StopTransform\n");
	pcmVolumeTransformer->StopTransform();
	tracer.tracef(ARB, "Cleanup : calling ::Disconnect(acmTransformer, pcmVolumeTransformer)\n");
	::Disconnect(acmTransformer, pcmVolumeTransformer);
	tracer.tracef(ARB, "Cleanup : calling Disconnect\n");
	Disconnect();

	FireEventThreadParams *fetParams = new FireEventThreadParams();
	fetParams->cookie = cookie;
	DWORD threadID;
	if (bTransmit)
	{
		tracer.tracef(ARB, "Cleanup : calling mediaTerm->FireEndOfFileTX\n");
		fetParams->receiveSide = false;
	}
	else
	{
		tracer.tracef(ARB, "Cleanup : calling mediaTerm->FireEndOfFileRX\n");
		fetParams->receiveSide = true;
	}
	CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)FireEventThread, (LPVOID)fetParams, 0, &threadID);
	tracer.tracef(ARB, "CleanupImmediately : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState != STATE_STOPPING)
	{
		tracer.tracef(ERR, "Cleanup : invalid state %d to call Cleanup\n", currentState);
	}
	currentState = STATE_STOPPED;
	SetEvent(stateChangedEvent);
	tracer.tracef(ARB, "Cleanup : setting stateChangedEvent. Went to STATE_STOPPED\n");
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "Cleanup : left stateMutex\n");

	tracer.tracef(EE, "~Cleanup\n");
}

void FilePlay::CleanupImmediately()
{
	tracer.tracef(EE, "CleanupImmediately\n");
	tracer.tracef(ARB, "CleanupImmediately : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState != STATE_STOPPING)
	{
		tracer.tracef(ERR, "CleanupImmediately : invalid state %d to call CleanupImmediately\n", currentState);
	}
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "CleanupImmediately : left stateMutex\n");
	tracer.tracef(ARB, "CleanupImmediately : calling acmTransformer->StopTransform\n");
	acmTransformer->StopTransform();
	tracer.tracef(ARB, "CleanupImmediately : calling pcmVolumeTransformer->StopTransform\n");
	pcmVolumeTransformer->StopTransform();
	tracer.tracef(ARB, "CleanupImmediately : calling ::Disconnect(waveFileSource, acmTransformer)\n");
	::Disconnect(waveFileSource, acmTransformer);
	tracer.tracef(ARB, "CleanupImmediately : calling ::Disconnect(acmTransformer, pcmVolumeTransformer)\n");
	::Disconnect(acmTransformer, pcmVolumeTransformer);
	tracer.tracef(ARB, "CleanupImmediately : calling Disconnect\n");
	Disconnect();
	if (bTransmit)
	{
		tracer.tracef(ARB, "CleanupImmediately : calling mediaTerm->FireEndOfFileTX\n");
		mediaTerm->FireEndOfFileTX(cookie);
	}
	else
	{
		tracer.tracef(ARB, "CleanupImmediately : calling mediaTerm->FireEndOfFileRX\n");
		mediaTerm->FireEndOfFileRX(cookie);
	}
	tracer.tracef(ARB, "CleanupImmediately : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState != STATE_STOPPING)
	{
		tracer.tracef(ERR, "CleanupImmediately : invalid state %d to call CleanupImmediately\n", currentState);
	}
	currentState = STATE_STOPPED;
	SetEvent(stateChangedEvent);
	tracer.tracef(ARB, "CleanupImmediately : setting stateChangedEvent. Went to STATE_STOPPED\n");
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "CleanupImmediately : left stateMutex\n");
	tracer.tracef(EE, "~CleanupImmediately\n");
}

int
FilePlay::Stop()
{
	tracer.tracef(ERR, "Stop : should not be called\n");
/*	tracer.tracef(ARB, "Stop : calling waveFileSource->StopSourceThread\n");
	waveFileSource->StopSourceThread();
	tracer.tracef(ARB, "Stop : calling Cleanup\n");
	Cleanup();
	}
	else
	{
		tracer.tracef(ARB, "Stop : bRunning = false\n");
	}
*/	tracer.tracef(EE, "~Stop : did nothing\n");
	return 0;
}

int
FilePlay::StopImmediately()
{
	tracer.tracef(EE, "StopImmediately\n");
	int result(0);
	bool stopNeeded(false);
	tracer.tracef(ARB, "StopImmediately : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	tracer.tracef(ARB, "StopImmediately : currentState = %d\n", currentState);
	switch(currentState)
	{
	case STATE_STOPPED:
		result = 0;
		tracer.tracef(ARB, "StopImmediately STATE_STOPPED: already stopped\n");
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately STATE_STOPPED: left stateMutex\n");
		break;
	case STATE_STARTING:
		result = -10;
		tracer.tracef(ARB, "StopImmediately STATE_STARTING: invalid state to call StopImmediately\n");
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately STATE_STARTING: left stateMutex\n");
		break;
	case STATE_RUNNING:
		result = 0;
		stopNeeded = true;
		currentState = STATE_STOPPING;
		tracer.tracef(ARB, "StopImmediately STATE_RUNNING: trying to stop the file play\n");
		SetEvent(stateChangedEvent);
		tracer.tracef(ARB, "StopImmediately STATE_RUNNING: setting stateChangedEvent. Went to STATE_STOPPING\n");
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately STATE_RUNNING: left stateMutex\n");
		break;
	case STATE_STOPPING:
		while(currentState != STATE_STOPPED)
		{
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: current state = %d\n", currentState);
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: resetting stateChangedEvent\n");
			ResetEvent(stateChangedEvent);
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: flushing acmTransformer buffer\n");
			acmTransformer->FlushBuffer();
			LeaveCriticalSection(&stateMutex);
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: left stateMutex\n");
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: waiting for stateChangedEvent\n");
			WaitForSingleObject(stateChangedEvent, INFINITE);
			tracer.tracef(ARB, "StopImmediately STATE_STOPPING: entering stateMutex\n");
			EnterCriticalSection(&stateMutex);
		}
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately STATE_STOPPING: left stateMutex\n");
		result = 0;
		stopNeeded = false;
		break;
	default:
		tracer.tracef(ARB, "StopImmediately default : invalid state %d\n", currentState);
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately default : left stateMutex\n");
		break;
	}

	if (result == 0 && stopNeeded)
	{
		// in case we are already stopping because file ran out, then we need to stop
		// right away before buffer is finished. Guarantees that FilePlayStopped will
		// return soon so entering stateMutex will not wait forever
		tracer.tracef(ARB, "StopImmediately : flushing acmTransformer buffer\n");
		acmTransformer->FlushBuffer();
		tracer.tracef(ARB, "StopImmediately : calling acmTransformer->StopTransform\n");
		acmTransformer->StopTransform();
		tracer.tracef(ARB, "StopImmediately : calling waveFileSource->StopSourceThread\n");
		waveFileSource->StopSourceThread();
		tracer.tracef(ARB, "StopImmediately : calling CleanupImmediately\n");
		CleanupImmediately();
		tracer.tracef(ARB, "Start : entering stateMutex\n");
		EnterCriticalSection(&stateMutex);
		currentState = STATE_STOPPED;
		SetEvent(stateChangedEvent);
		tracer.tracef(ARB, "StopImmediately : setting stateChangedEvent. Went to STATE_STOPPED\n");
		LeaveCriticalSection(&stateMutex);
		tracer.tracef(ARB, "StopImmediately : left stateMutex\n");
	}
	if (result == 0)
	{
		tracer.tracef(EE, "~StopImmediately\n");
	}
	else
	{
		tracer.tracef(ERR, "~StopImmediately : returning %d\n", result);
	}
	return result;
}

int
FilePlay::SetVolume(int volume)
{
	tracer.tracef(EE, "SetVolume %d\n", volume);
	int result = pcmVolumeTransformer->SetVolume(volume);
	if (result != 0)
	{
		tracer.tracef(ERR, "SetVolume : e-pcmVolumeTransformer->SetVolume : %d\n", result);
	}
	tracer.tracef(EE, "~SetVolume : %d\n", result);
	return result;
}

int
FilePlay::GetVolume()
{
	tracer.tracef(EE, "GetVolume\n");
	int result = pcmVolumeTransformer->GetVolume();
	if (result != 0)
	{
		tracer.tracef(ERR, "GetVolume : e-pcmVolumeTransformer->GetVolume: %d\n", result);
	}
	tracer.tracef(EE, "~GetVolume : %d\n", result);
	return result;
}

unsigned int
FilePlay::GetCookie()
{
	return cookie;
}

int
FilePlay::Connect(AudioSink *audioSink)
{
	tracer.tracef(EE, "Connect\n");
	tracer.tracef(ARB, "Connect : calling Disconnect\n");
	Disconnect();
	if (audioSink)
	{
		tracer.tracef(ARB, "Connect : calling ::Connect(pcmVolumeTransformer, audioSink)\n");
		::Connect(pcmVolumeTransformer, audioSink);
	}
	this->audioSink = audioSink;
	tracer.tracef(EE, "~Connect\n");
	return 0;
}

int
FilePlay::Disconnect()
{
	tracer.tracef(EE, "Disconnect\n");
	if (audioSink)
	{
		tracer.tracef(ARB, "Disconnect : calling ::Disconnect(pcmVolumeTransformer, audioSink)\n");
		::Disconnect(pcmVolumeTransformer, audioSink);
	}
	audioSink = NULL;
	tracer.tracef(EE, "~Disconnect\n");
	return 0;
}

void
FilePlay::FilePlayStarted(WaveFileSource *waveFileSource, char *waveFileName)
{
	tracer.tracef(EE, "FilePlayStarted : %s\n", waveFileName);
	tracer.tracef(ARB, "FilePlayStarted : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	if (currentState != STATE_STARTING)
	{
		tracer.tracef(ERR, "FilePlayStarted : invalid current state %d\n", currentState);
	}
	currentState = STATE_RUNNING;
	SetEvent(stateChangedEvent);
	tracer.tracef(ARB, "FilePlayStarted : setting stateChangedEvent. Went to STATE_RUNNING\n");
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "FilePlayStarted : left stateMutex\n");
	tracer.tracef(EE, "~FilePlayStarted\n");
}

void
FilePlay::FilePlayStopped(WaveFileSource *waveFileSource, char *waveFileName)
{
	tracer.tracef(EE, "FilePlayStopped : %s\n", waveFileName);
	bool needToCallCleanup = false;
	tracer.tracef(ARB, "FilePlayStopped : entering stateMutex\n");
	EnterCriticalSection(&stateMutex);
	// if we are in STATE_STOPPING this is because StopImmediately was called
	// StopImmediately will call CleanupImmediately which will also set the 
	// state to STATE_STOPPED
	if (currentState != STATE_RUNNING && currentState != STATE_STOPPING)
	{
		tracer.tracef(ERR, "FilePlayStopped : invalid current state %d\n", currentState);
	}
	if (currentState == STATE_RUNNING)
	{
		tracer.tracef(ARB, "FilePlayStopped : currently RUNNING. need to call cleanup\n");
		needToCallCleanup = true;
		currentState = STATE_STOPPING;
		SetEvent(stateChangedEvent);
		tracer.tracef(ARB, "FilePlayStopped : setting stateChangedEvent. Went to STATE_STOPPING\n");
	}
	LeaveCriticalSection(&stateMutex);
	tracer.tracef(ARB, "FilePlayStopped : left stateMutex\n");
	if (needToCallCleanup)
	{
		tracer.tracef(ARB, "FilePlayStopped : calling Cleanup\n");
		Cleanup();
		// Cleanup will set the state to STATE_STOPPED
	}
	tracer.tracef(EE, "~FilePlayStopped\n");
}

int
FilePlay::SetOutputDuration(int outputDuration)
{
	tracer.tracef(EE, "SetOutputDuration %d\n", outputDuration);
	int result = acmTransformer->SetOutputDuration(outputDuration);
	if (result != 0)
	{
		tracer.tracef(ERR, "SetOutputDuration : e-acmTransformer->SetOutputDuration : %d\n", result);
	}
	tracer.tracef(EE, "~SetOutputDuration : %d\n", result);
	return result;
}

int
FilePlay::SetDestinationFormat(WAVEFORMATEX wfx)
{
	tracer.tracef(EE, "SetDestinationFormat\n");
	int result = acmTransformer->SetDestinationFormat(wfx);
	if (result != 0)
	{
		tracer.tracef(ERR, "SetDestinationFormat : e-acmTransformer->SetDestinationFormat : %d\n", result);
	}
	tracer.tracef(EE, "~SetDestinationFormat : %d\n", result);
	return result;
}

bool
FilePlay::Transmitting()
{
	return bTransmit;
}