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

#include "AudioTransformer.h"
#include "AudioSample.h"

using namespace std;

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

AudioTransformer::AudioTransformer()
{

}

AudioTransformer::~AudioTransformer()
{

}

int
AudioTransformer::StartTransform()
{
	tracer.tracef(EE, "StartTransform\n");
	SetTraceLevel();
	int result = TransformStarted();
	if (result != 0)
	{
		tracer.tracef(ERR, "StartTransform : TransformStarted returned error %d\n", result);
	}
	tracer.tracef(EE, "~StartTransform\n");
	return result;
}

int
AudioTransformer::StopTransform()
{
	tracer.tracef(EE, "StopTransform\n");
	int result = TransformStopped();
	if (result != 0)
	{
		tracer.tracef(ERR, "StopTransform : TransformStopped returned error %d\n", result);
	}
	tracer.tracef(EE, "~StopTransform\n");
	return result;
}

int
AudioTransformer::TransformStarted()
{
	return 0;
}

int
AudioTransformer::TransformStopped()
{
	return 0;
}

int
AudioTransformer::RenderAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data)
{
	tracer.tracef(DET, "RenderAudioSamples\n");
	AudioSample *audioSample = NULL;
	int result(0);
	result = TransformAudioSamples(data, &audioSample);
	if (result != 0)
	{
		if (audioSample)
		{
			audioSample->Release(this);
			audioSample = NULL;
		}
	}
	EnterCriticalSection(&audioSinksMutex);
	vector<AudioSink *>::iterator iter = audioSinks.begin();
	for (iter = audioSinks.begin(); iter != audioSinks.end(); iter++)
	{
		tracer.tracef(DET, "RenderAudioSamples : sending sample 0x%x to 0x%x\n", audioSample, *iter);
		SendAudioSample(audioSample, *iter);
	}
	LeaveCriticalSection(&audioSinksMutex);

	if (audioSample)
	{
		audioSample->Release(this);
		audioSample = NULL;
	}
	
	tracer.tracef(DET, "~RenderAudioSamples\n");
	return result;
}

int
AudioTransformer::GenerateData(AudioSample **ppAudioSample)
{
	tracer.tracef(DET, "GenerateData\n");
	// get data from all sources
	inputData.clear();
	int result(0);
	*ppAudioSample = NULL;

	EnterCriticalSection(&audioSourcesMutex);
	vector<AudioSource *>::iterator iter = audioSources.begin();
	for (iter = audioSources.begin(); iter != audioSources.end(); iter++)
	{
		AudioSample *audioSample = NULL;
//		tracer.tracef(DET, "GenerateData : calling GiveNextAudioSample\n");
		result = (*iter)->GiveNextAudioSample(&audioSample, this);
		if (result != 0)
		{
			tracer.tracef(ERR, "GenerateData : GiveNextAudioSample from %s returned error %d\n", (*iter)->TraceName(), result);
			if (audioSample)
			{
				audioSample->Release(this);
				audioSample = NULL;
			}
		}
		else 
		{
			if (audioSample)
			{
				inputData.push_back(make_pair(audioSample, *iter));
			}
		}
	}
	LeaveCriticalSection(&audioSourcesMutex);
	// transform the data
	result = TransformAudioSamples(inputData, ppAudioSample);
	if (result != 0)
	{
		if (*ppAudioSample)
		{
			tracer.tracef(ERR, "GenerateData : TransformAudioSamples returned error %d\n", result);
			(*ppAudioSample)->Release(this);
			*ppAudioSample = NULL;
		}
	}
	// 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);
		}
	}
	tracer.tracef(DET, "~GenerateData\n");
	return result;
}

int
AudioTransformer::TransformAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data, AudioSample **ppAudioSample)
{
	tracer.tracef(ERR, "AudioTransformer : ERROR : pure virtual function call !!!\n");
	return 0;
}