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

#include "FixedSizeAudioBuffer.h"
#include "AudioSample.h"
#include "AudioSampleManager.h"

using namespace std;

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

FixedSizeAudioBuffer::FixedSizeAudioBuffer()
{
	char subFacilityName[100];
	sprintf(subFacilityName, "FixedSizeAudioBuffer:%x", this);
	tracer.SetSubFacilityName(subFacilityName);
	SetTraceLevel();
	outputDuration = 20;
	minFrameSize = 1;
	minFrameDuration = 1;
	outputSize = 1000;	// any high number
	bRunning = false;
	InitializeCriticalSection(&audioBufferMutex);
}

FixedSizeAudioBuffer::~FixedSizeAudioBuffer()
{
	DeleteCriticalSection(&audioBufferMutex);
}

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

int
FixedSizeAudioBuffer::SetOutputDuration(int duration)
{
	outputDuration = duration;
	return 0;
}

int
FixedSizeAudioBuffer::EnqueuePacket(std::vector<std::pair<AudioSample *, AudioSource *> > &data)
{
	AudioSample *audioSample = NULL;
	if (data.size() > 0)
	{
		audioSample = data[0].first;
	}
	if (audioSample)
	{
		minFrameDuration = audioSample->MinFrameDuration();
		minFrameSize = audioSample->MinFrameSize();
		audioSample->GetFormat(&audioFormat);
		outputSize = (outputDuration * 1000 * minFrameSize) / minFrameDuration;
		if (audioSample->DataSize() > 0)
		{
			EnterCriticalSection(&audioBufferMutex);
			audioBuffer.insert(audioBuffer.end(), audioSample->Data(), audioSample->Data() + audioSample->DataSize());
			LeaveCriticalSection(&audioBufferMutex);
		}
		else if (audioSample->GetSilenceDuration() > 0)
		{
			EnterCriticalSection(&audioBufferMutex);
			for (int i=0; i<audioSample->SilenceSize(); i++)
			{
				audioBuffer.push_back(0);
			}
			LeaveCriticalSection(&audioBufferMutex);
		}
	}
	else
	{
		tracer.tracef(ERR, "EnquePacket : asked to enqueue NULL packet\n");
		Sleep(5);
	}
	return 0;
}

int
FixedSizeAudioBuffer::TransformStarted()
{
	EnterCriticalSection(&audioBufferMutex);
	audioBuffer.clear();
	audioFormat = WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1);
	LeaveCriticalSection(&audioBufferMutex);
	bRunning = true;
	return 0;
}

int
FixedSizeAudioBuffer::TransformStopped()
{
	bRunning = false;
	return 0;
}

int
FixedSizeAudioBuffer::RenderAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data)
{
	if (bRunning)
	{
		EnqueuePacket(data);
		int outputSize = (outputDuration * 1000 * minFrameSize) / minFrameDuration;
		EnterCriticalSection(&audioBufferMutex);
		while (audioBuffer.size() >= outputSize)
		{
			AudioSample *outputSample = NULL;
			(AudioSampleManager::GetInstance())->GetAudioSample(&outputSample, this);
			outputSample->SetFormat(audioFormat);
			char *outputData = outputSample->Data();
			for (int i=0; i<outputSize; i++)
			{
				*outputData = audioBuffer[0];
				audioBuffer.erase(audioBuffer.begin());
			}
			outputSample->SetDataSize(outputSize);
			EnterCriticalSection(&audioSinksMutex);
			std::vector<AudioSink *>::iterator iter;
			for (iter = audioSinks.begin(); iter != audioSinks.end(); iter++)
			{
				SendAudioSample(outputSample, *iter);
			}
			LeaveCriticalSection(&audioSinksMutex);
			outputSample->Release(this);
			outputSample = NULL;
		}
		LeaveCriticalSection(&audioBufferMutex);
	}
	return 0;
}

int
FixedSizeAudioBuffer::GenerateData(AudioSample **ppAudioSample)
{
	tracer.tracef(DET, "GenerateData\n");
	tracer.tracef(DET, "GenerateData : filling data\n");
	int result(0);
	*ppAudioSample = NULL;
	while(audioBuffer.size() < outputSize)
	{
		tracer.tracef(DET, "GenerateData : audioBuffer.size = %d, outputSize = %d\n", audioBuffer.size(), outputSize);
		if (!bRunning)
		{
			break;
		}
		// get data from all sources
		inputData.clear();
		EnterCriticalSection(&audioSourcesMutex);
		vector<AudioSource *>::iterator iter = audioSources.begin();
		for (iter = audioSources.begin(); iter != audioSources.end(); iter++)
		{
			AudioSample *pAudioSample = NULL;
//			tracer.tracef(DET, "GenerateData : calling GiveNextAudioSample\n");
			result = (*iter)->GiveNextAudioSample(&pAudioSample, this);
			if (result != 0)
			{
				if (pAudioSample)
				{
					pAudioSample->Release(this);
					pAudioSample = NULL;
				}
			}
			else
			{
				if (pAudioSample)
				{
					inputData.push_back(make_pair(pAudioSample, *iter));
				}
			}
		}
		LeaveCriticalSection(&audioSourcesMutex);

		// add the data to the queue
		EnqueuePacket(inputData);

		// release all the input samples
		// (since they were obtained by GiveNextAudioSample, they will not be released by the corresponding source
		for (int i = 0; i < inputData.size(); i++)
		{
			AudioSample *sample = (inputData[i]).first;
			if (sample)
			{
				sample->Release(this);
				sample = NULL;
			}
		}
	}
	tracer.tracef(DET, "GenerateData : transmitting data\n");
	if (bRunning && audioBuffer.size() >= outputSize)
	{
		AudioSample *outputSample = NULL;
		(AudioSampleManager::GetInstance())->GetAudioSample(&outputSample, this);
		outputSample->SetFormat(audioFormat);
		char *outputData = outputSample->Data();
		for (int i=0; i<outputSize; i++)
		{
			*outputData = audioBuffer[0];
			outputData++;
			audioBuffer.erase(audioBuffer.begin());
		}
		outputSample->SetDataSize(outputSize);
		*ppAudioSample = outputSample;
	}
	if (*ppAudioSample == NULL)
	{
		(AudioSampleManager::GetInstance())->GetAudioSample(ppAudioSample, this);
		(*ppAudioSample)->SetFormat(audioFormat);
		(*ppAudioSample)->SetDataSize(0);
		(*ppAudioSample)->SetSilenceDuration(outputDuration);
	}
	tracer.tracef(DET, "~GenerateData\n");
	return 0;
}

int
FixedSizeAudioBuffer::TransformAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data, AudioSample **ppAudioSample)
{
	return 0;
}