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

#include "WaveFileSource.h"
#include "AudioSampleManager.h"
#include "AudioSample.h"

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

WaveFileSource::WaveFileSource()
{
	szFileName[0] = '\0';
	pFormat = NULL;
	bufferDuration = WAVEFILESOURCE_DEFAULT_BUFFERDURATION;
	char subFacilityName[100];
	sprintf(subFacilityName, "WaveFileSource:%x", this);
	tracer.SetSubFacilityName(subFacilityName);
	SetTraceLevel();
	tracer.tracef(EE, "Constructor - begin\n");
	PlayOnce();
	bRunning = false;
	InitializeCriticalSection(&filterMutex);
	hmmio = NULL;
	tracer.tracef(EE, "Constructor - end\n");
}

WaveFileSource::~WaveFileSource()
{
	tracer.tracef(EE, "Destructor - begin\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "WaveFileSource~ : entered filterMutex\n");
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "WaveFileSource~ : left filterMutex\n");
	CloseMMIO();
	DeleteCriticalSection(&filterMutex);
	tracer.tracef(EE, "Destructor - end\n");
}

int
WaveFileSource::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", "WaveFileSource", 0x100000);
	}
	tracer.SetSystemMask(SystemMask);
	return 0;
}

int
WaveFileSource::PlayInLoop()
{
	looping = true;
	return 0;
}

int
WaveFileSource::PlayOnce()
{
	looping = false;
	return 0;
}

int
WaveFileSource::OpenWaveFile(const char *inputFileName)
{
	int result(0);
	PlayOnce();
	if (strlen(inputFileName) < 128 && !bRunning)
	{
		do
		{
			CloseMMIO();
			strcpy(szFileName, inputFileName);

			// Open the file for reading with buffered I/O 
			// by using the default internal buffer 
			if(!(hmmio = mmioOpen(szFileName, NULL, MMIO_READ | MMIO_ALLOCBUF)))
			{ 
				tracer.tracef(ERR, "SourceStarted : mmioOpen(%s) returned 0x%x\n", szFileName, hmmio); 
				result = -10;
				break;
			} 
 
			MMIOINFO mmInfoStart;
			mmioGetInfo(hmmio, &mmInfoStart, 0);
			LONG fileStartPosition = (LONG)mmInfoStart.pchNext;

			// Locate a "RIFF" chunk with a "WAVE" form type to make 
			// sure the file is a waveform-audio file. 
			mmckinfoParent.fccType = mmioFOURCC('W', 'A', 'V', 'E'); 
			if (mmioDescend(hmmio, (LPMMCKINFO) &mmckinfoParent, NULL, MMIO_FINDRIFF))
			{ 
				tracer.tracef(ERR, "SourceStarted : %s not wave file", szFileName); 
				result = -20;
				break;
			}

			// Find the "FMT" chunk (form type "FMT"); it must be 
			// a subchunk of the "RIFF" chunk. 
			mmckinfoSubchunk.ckid = mmioFOURCC('f', 'm', 't', ' '); 
			if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent, MMIO_FINDCHUNK))
			{ 
				tracer.tracef(ERR, "SourceStarted : File %s has no FMT chunk", szFileName);
				result = -30; 
				break;
			} 
 
			// Get the size of the "FMT" chunk. Allocate 
			// and lock memory for it. 
			dwFmtSize = mmckinfoSubchunk.cksize;
			pFormat = (WAVEFORMATEX *) new char[dwFmtSize];

			// Read the "FMT" chunk. 
			if (mmioRead(hmmio, (HPSTR) pFormat, dwFmtSize) != dwFmtSize)
			{ 
				tracer.tracef(ERR, "SourceStarted : Failed to read format chunk");
				result = -40;
				break;
			} 

			// Ascend out of the "FMT" subchunk. 
			mmioAscend(hmmio, &mmckinfoSubchunk, 0); 
 
			// Find the data subchunk. The current file position should be at 
			// the beginning of the data chunk; however, you should not make 
			// this assumption. Use mmioDescend to locate the data chunk. 
			mmckinfoSubchunk.ckid = mmioFOURCC('d', 'a', 't', 'a'); 
			if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent, MMIO_FINDCHUNK))
			{ 
				tracer.tracef(ERR, "SourceStarted : File %s has no data chunk", szFileName);
				result = -50; 
				break;
			} 
 
			// Get the size of the data subchunk. 
			dwDataSize = mmckinfoSubchunk.cksize;
			if (dwDataSize == 0L)
			{ 
				tracer.tracef(ERR, "SourceStarted : Data chunk of %s contains no data", szFileName); 
				result = -60;
				break;
			}
			MMIOINFO mmInfo;
			mmioGetInfo(hmmio, &mmInfo, 0);
			dataStartPosition = (LONG)mmInfo.pchNext - fileStartPosition;
		}
		while(false);
		if (result != 0)
		{
			CloseMMIO();
		}
	}
	else
	{
		if (bRunning)
		{
			result = -70;
		}
		else
		{
			result = -80;
		}
	}
	return result;
}

int
WaveFileSource::CloseMMIO()
{
	if (hmmio)
	{
		mmioClose(hmmio, 0);
	}
	hmmio = NULL;
	if (pFormat)
	{
		delete [] (char *)pFormat;
	}
	pFormat = NULL;
	return 0;
}

int
WaveFileSource::SourceStarted()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "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;
		}
		if (!hmmio || !pFormat)
		{
			tracer.tracef(ERR, "SourceStarted : e-error : hmmio = 0x%x, pFormat = 0x%x\n", hmmio, pFormat);
			result = -20;
			break;
		}
		bRunning = true;
	}
	while (false);

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

int
WaveFileSource::SourceStopped()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "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 = CloseMMIO();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceStopped : e-CloseMMIO : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		bRunning = false;
	}
	while (false);

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

int
WaveFileSource::SourceThreadStarted(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "SourceThreadStarted\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStarted : entered filterMutex\n");
	do
	{
		if (!hmmio || !pFormat)
		{
			tracer.tracef(ERR, "SourceThreadStarted : e-error : hmmio = 0x%x, pFormat = 0x%x\n", hmmio, pFormat);
			result = -10;
			break;
		}
		bRunning = true;
	}
	while (false);

	tracer.tracef(ARB, "SourceThreadStarted : before firing FILE_STARTED %s\n", szFileName);
	FireEvent(FILE_STARTED, szFileName);
	tracer.tracef(ARB, "SourceThreadStarted : after  firing FILE_STARTED %s\n", szFileName);

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

int
WaveFileSource::SourceThreadStopped(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "SourceThreadStopped\n");
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SourceThreadStopped : entered filterMutex\n");
	do
	{
		returnCode = CloseMMIO();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SourceThreadStopped : e-CloseMMIO : %d 0x%x\n", returnCode, returnCode);
			result = -10;
			break;
		}
		bRunning = false;
	}
	while (false);

	tracer.tracef(ARB, "SourceThreadStopped : before firing FILE_STOPPED %s\n", szFileName);
	FireEvent(FILE_STOPPED, szFileName);
	tracer.tracef(ARB, "SourceThreadStopped : after  firing FILE_STOPPED %s\n", szFileName);

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

int
WaveFileSource::GetFormat(WAVEFORMATEX *waveFormat)
{
	if (pFormat)
	{
		*waveFormat = *pFormat;
	}
	return 0;
}

int
WaveFileSource::SetBufferDuration(int bufferDurationMillisec)
{
	bufferDuration = bufferDurationMillisec;
	return 0;
}

int
WaveFileSource::GenerateData(AudioSample **ppAudioSample)
{
	tracer.tracef(DET, "GenerateData\n");
	int result(0);
	AudioSample *audioSample = NULL;
	result = (AudioSampleManager::GetInstance())->GetAudioSample(&audioSample, this);
	*ppAudioSample = NULL;
	if (audioSample)
	{
		audioSample->SetDataSize(0);
		audioSample->SetSilenceDuration(bufferDuration);
		if (bRunning)
		{
			audioSample->SetFormat(*pFormat);
			int nBytesToRead = (pFormat->nAvgBytesPerSec * bufferDuration) / 1000;
			if (audioSample->BufferSize() < nBytesToRead)
			{
				result = -20;
			}
			else
			{
				int bytes(0);
				if((bytes = mmioRead(hmmio, (HPSTR) audioSample->Data(), nBytesToRead)) != nBytesToRead)
				{
					if (bytes < 0 || (bytes == 0 && !looping))
					{
						bytes = 0;
						result = -30;
					}
					else if (looping)
					{
						mmioSeek(hmmio, dataStartPosition, SEEK_SET);
						int nBytes = mmioRead(hmmio, (HPSTR) audioSample->Data(), nBytesToRead - bytes);
						if (nBytes <= 0)
						{
							result = -40;
						}
						else
						{
							bytes += nBytes;
						}
					}
					audioSample->SetDataSize(bytes);
				}
				else
				{
					audioSample->SetDataSize(nBytesToRead);
				}
			}
		}
	}
	if (result < 0)
	{
		if (audioSample)
		{
			audioSample->Release(this);
			audioSample = NULL;
		}
	}
	*ppAudioSample = audioSample;
	if (*ppAudioSample)
	{
		tracer.tracef(DET, "~GenerateData : data %d bytes, silence %d ms\n", audioSample->DataSize(), audioSample->GetSilenceDuration());
	}
	else
	{
		tracer.tracef(DET, "~GenerateData : returning NULL : result = %d\n", result);
	}
	return result;
}

int
WaveFileSource::AddFilePlayListener(WaveFileSourceListener *waveFileSourceListener)
{
	return AddListener((void *)waveFileSourceListener);
}

int
WaveFileSource::RemoveFilePlayListener(WaveFileSourceListener *waveFileSourceListener)
{
	return RemoveListener((void *)waveFileSourceListener);
}

int
WaveFileSource::FireEvent(int eventType, char *waveFileName)
{
	EnterCriticalSection(&listenersMutex);
	std::vector<void *>::iterator iter = listeners.begin();
	while (iter != listeners.end())
	{
		switch(eventType)
		{
		case FILE_STARTED:
			((WaveFileSourceListener *)(*iter))->FilePlayStarted(this, waveFileName);
			break;
		case FILE_STOPPED:
			((WaveFileSourceListener *)(*iter))->FilePlayStopped(this, waveFileName);
			break;
		default:
			break;
		}
		iter++;
	}
	LeaveCriticalSection(&listenersMutex);
/*	FireEventThreadParams *params = new FireEventThreadParams();
	params->eventType = eventType;
	params->waveFileSource = this;
	strncpy(params->waveFileName, waveFileName, min(strlen(waveFileName)+1, 1024));
	(params->waveFileName)[1024] = '\0';
	DWORD threadID;
	CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)FireEventThread, (LPVOID)params, 0, &threadID);
*/	return 0;
}

DWORD WINAPI
WaveFileSource::FireEventThread(LPVOID param)
{
	FireEventThreadParams *params = (FireEventThreadParams *)param;
	WaveFileSource *waveFileSource = params->waveFileSource;
	EnterCriticalSection(&(waveFileSource->listenersMutex));
	std::vector<void *>::iterator iter = waveFileSource->listeners.begin();
	while (iter != waveFileSource->listeners.end())
	{
		switch(params->eventType)
		{
		case FILE_STARTED:
			((WaveFileSourceListener *)(*iter))->FilePlayStarted(waveFileSource, params->waveFileName);
			break;
		case FILE_STOPPED:
			((WaveFileSourceListener *)(*iter))->FilePlayStopped(waveFileSource, params->waveFileName);
			break;
		default:
			break;
		}
		iter++;
	}
	LeaveCriticalSection(&(waveFileSource->listenersMutex));
	return 0;
}

void
WaveFileSourceListener::FilePlayStarted(WaveFileSource *waveFileSource, char *waveFileName)
{
//	AfxMessageBox("WaveFileSourceListener::FilePlayStarted : ERROR : pure virtual function call !!!\n");
}

void
WaveFileSourceListener::FilePlayStopped(WaveFileSource *waveFileSource, char *waveFileName)
{
//	AfxMessageBox("WaveFileSourceListener::FilePlaySopped : ERROR : pure virtual function call !!!\n");
}