// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @internalComponent

*/

#include <mmf/server/mmfbuffer.h>

#include <mmf/server/mmfdatabuffer.h>

#include <ecom/ecom.h>

#include <openmax/il/khronos/v1_x/OMX_Component.h>

#include <openmax/il/loader/omxilcomponentif.h>

#include "log.h"

#include "tsu_omxil_component_base.h"

const TInt CCallbackHandler::KMaxMsgQueueEntries;

CAacTestFile*

CAacTestFile::NewL()

	{

    DEBUG_PRINTF(_L8("CAacTestFile::NewL"));

	CAacTestFile* self = new (ELeave) CAacTestFile();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

CAacTestFile::ConstructL()

	{

    DEBUG_PRINTF(_L8("CAacTestFile::ConstructL"));

	}

CAacTestFile::CAacTestFile() :

	iSourceFile(0),

	iSourceFileReadPos(0),

	iFinished(EFalse)

	{

    DEBUG_PRINTF(_L8("CAacTestFile::CAacTestFile"));

	}

CAacTestFile::~CAacTestFile()

	{

    DEBUG_PRINTF(_L8("CAacTestFile::~CAacTestFile"));

	delete iSourceFile;

	}

TInt

CAacTestFile::ReadTestFileInBuffer(const TDesC& aFileName)

	{

    DEBUG_PRINTF(_L8("CAacTestFile::ReadTestFileInBuffer"));

	RFs fs;

	TInt err;

	err = fs.Connect();

	if (err != KErrNone)

		{

		return err;

		}

	RFile file;

	err = file.Open(fs, aFileName, EFileRead);

	if (err == KErrNone)

		{

		TInt size;

		err = file.Size(size);

		if (err == KErrNone)

			{

			iSourceFile = HBufC8::NewMax(size);

			if(!iSourceFile)

				{

				return KErrNoMemory;

				}

			TPtr8 ptr = iSourceFile->Des();

			file.Read(ptr,size);

			file.Close();

			}

		fs.Close();

		}

    return err;

	}

void

CAacTestFile::ReadNextBuffer(CMMFBuffer& aDataBuffer)

    {

    DEBUG_PRINTF(_L8("CAacTestFile::ReadNextBuffer"));

	CMMFDataBuffer* pDataBuffer = static_cast<CMMFDataBuffer*>(&aDataBuffer);

    while (ETrue)

		{

		// check if finished

		if (iFinished)

			{

			DEBUG_PRINTF(_L8("CAacTestFile::ReadNextBuffer : File finished"));

			pDataBuffer->Data().Zero();

			return;

			}

		TInt srcLength = iSourceFile->Size();

		if (iSourceFileReadPos < srcLength)

			{

			TInt size = srcLength;

			if (size > pDataBuffer->Data().MaxLength())

				{

				size = pDataBuffer->Data().MaxLength();

				}

			Mem::Copy((TAny*)pDataBuffer->Data().Ptr(), (TAny*)iSourceFile->Mid(iSourceFileReadPos).Ptr(), size);

			pDataBuffer->Data().SetLength(size);

			iSourceFileReadPos += size;

			DEBUG_PRINTF2(_L8("CAacTestFile::ReadNextBuffer : data read = [%d] bytes"), iSourceFileReadPos);

			DEBUG_PRINTF2(_L8("CAacTestFile::ReadNextBuffer : pDataBuffer->BufferSize = [%u] bytes"), pDataBuffer->BufferSize());

			if (iSourceFileReadPos >= srcLength)

				{

				DEBUG_PRINTF(_L8("CAacTestFile::ReadNextBuffer : end of data"));

				pDataBuffer->SetLastBuffer(ETrue);

				iFinished = ETrue;

				}

			return;

			}

		else

			{

			// no more data

			DEBUG_PRINTF(_L8("CAacTestFile::ReadNextBuffer : end of data"));

			iFinished = ETrue;

			return;

			}

		}

    }

void

CAacTestFile::ResetPos()

	{

	iSourceFileReadPos = 0;

	iFinished = EFalse;

	}

TInt

CAacTestFile::GetPos()

	{

	return iSourceFileReadPos;

	}

CAacOutputTestFile*

CAacOutputTestFile::NewL()

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::NewL"));

	CAacOutputTestFile* self = new (ELeave) CAacOutputTestFile();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

CAacOutputTestFile::ConstructL()

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::ConstructL"));

	}

CAacOutputTestFile::CAacOutputTestFile() :

	iFileServerSession(),

	iOutputFile(),

	iWrittenDataTotal(0),

	iBuffersWrittenCount(0)

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::CAacOutputTestFile"));

	}

CAacOutputTestFile::~CAacOutputTestFile()

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::~CAacOutputTestFile"));

	}

TInt

CAacOutputTestFile::SetUpOutputFile(const TDesC& aFileName)

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::SetUpOutputFile"));

	TInt err;

	err = iFileServerSession.Connect();

	if (err != KErrNone)

		{

		return err;

		}

	err = iOutputFile.Create(iFileServerSession,

 			   					  aFileName,

 			   					  EFileWrite|EFileShareExclusive);

	if(err != KErrNone)

		{

		err = iOutputFile.Replace(iFileServerSession,

							aFileName,

							EFileWrite|EFileShareExclusive);

		}

	return err;

	}

TInt

CAacOutputTestFile::WriteDataToFile(const CMMFBuffer& aDataBuffer)

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::WriteDataToFile"));

	const CMMFDataBuffer& dataBuffer = static_cast<const CMMFDataBuffer&>(aDataBuffer);

	const TDesC8& data = dataBuffer.Data();

	TInt err = KErrNone;

	err = iOutputFile.Write(data);

	if(err != KErrNone)

		{

		return err;

		}

	// keep record of amount of data and the number of buffers written out

	iWrittenDataTotal += data.Size();

	iBuffersWrittenCount++;

    DEBUG_PRINTF2(_L8("CAacOutputTestFile::WriteDataToFile : data.Size()[%d]"), data.Size());

    DEBUG_PRINTF2(_L8("CAacOutputTestFile::WriteDataToFile : iWrittenDataTotal[%d]"), iWrittenDataTotal);

	DEBUG_PRINTF2(_L8("CAacOutputTestFile::WriteDataToFile : iBuffersWrittenCount[%d]"), iBuffersWrittenCount);

	return err;

	}

TInt

CAacOutputTestFile::AddWavHeader()

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::AddWavHeader"));

	TInt err;

	RFs fs;

	err = fs.Connect();

	if (err != KErrNone)

		{

		return err;

		}

	RFile file;

	err = file.Open(fs, KAacDecoderOutputTestFile, EFileRead);

	if (err != KErrNone)

		{

		return err;

		}

	TInt size;

	err = file.Size(size);

	if (err != KErrNone)

		{

		return err;

		}

	HBufC8* rawDecFile = HBufC8::NewMax(size);

	if(!rawDecFile)

		{

		return KErrNoMemory;

		}

	TPtr8 ptr = rawDecFile->Des();

	file.Read(ptr,size);

	file.Close();

	// add headers

	err = file.Replace(fs, KAacDecoderOutputTestFile, EFileWrite);

	if (err != KErrNone)

		{

		return err;

		}

	// this is canonical WAV file format header

	TInt32 chunkSize = size + KTestWavFormatPCMChunkHeaderSize;

	TInt32 subchunk1size = KTestWavFormatPCMSubchunk1Size;

	TInt16 audioFormat = KTestAudioFormatPCM;

	TInt16 numChannels = KTestNumChannels;

	TInt32 sampleRate = KTestSampleRate;

	TInt16 bitsPerSample = KTestBitsPerSample;

	TInt32 byteRate = sampleRate * numChannels * (bitsPerSample / 8);

	TInt16 blockAlign = numChannels * (bitsPerSample / 8);

	TInt32 subchunk2size = size;

	file.Write(_L8("RIFF"));

	{ TPtrC8 buf((TText8*)&chunkSize,sizeof(TInt32)); file.Write(buf); }

	file.Write(_L8("WAVEfmt "));

	{ TPtrC8 buf((TText8*)&subchunk1size,sizeof(TInt32)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&audioFormat,sizeof(TInt16)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&numChannels,sizeof(TInt16)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&sampleRate,sizeof(TInt32)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&byteRate,sizeof(TInt32)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&blockAlign,sizeof(TInt16)); file.Write(buf); }

	{ TPtrC8 buf((TText8*)&bitsPerSample,sizeof(TInt16)); file.Write(buf); }

	file.Write(_L8("data"));

	{ TPtrC8 buf((TText8*)&subchunk2size,sizeof(TInt32)); file.Write(buf); }

	file.Write(ptr,size);

	// store file size

	file.Size(iWrittenDataTotal);

	file.Close();

	fs.Close();

	delete rawDecFile;

	return KErrNone;

	}

void

CAacOutputTestFile::CloseOutputFile()

	{

    DEBUG_PRINTF(_L8("CAacOutputTestFile::CloseOutputFile"));

	iOutputFile.Close();

	iFileServerSession.Close();

	}

//

// CUtilityTimer

//

CUtilityTimer*

CUtilityTimer::NewL(TTimeIntervalMicroSeconds32& aDelay,

					MTimerObserver& aObserver)

    {

    CUtilityTimer* self = new (ELeave) CUtilityTimer(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aDelay);

    CleanupStack::Pop(self);

    return self;

    }

void

CUtilityTimer::ConstructL(TTimeIntervalMicroSeconds32& aDelay)

    {

    CTimer::ConstructL();

    iDelay = aDelay;

    CActiveScheduler::Add(this);

    }

CUtilityTimer::~CUtilityTimer()

    {

    Cancel();

    }

void

CUtilityTimer::InitializeTimer()

    {

	// Request another wait - assume not active

	CTimer::After(iDelay);

    }

void

CUtilityTimer::RunL()

    {

	if (iStatus.Int() == KErrNone)

		iObserver.TimerExpired();

    }

void

CUtilityTimer::DoCancel()

	{

	}

CUtilityTimer::CUtilityTimer(MTimerObserver& aObserver) :

	CTimer(CActive::EPriorityUserInput),

    iObserver(aObserver)

	{

    }

//

// CCallbackHandler

//

CCallbackHandler*

CCallbackHandler::NewL(RAsyncTestStepOmxILComponentBase& aDecoderTest)

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::NewL"));

	CCallbackHandler* self = new (ELeave) CCallbackHandler(aDecoderTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

CCallbackHandler::ConstructL()

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::ConstructL"));

	OMX_CALLBACKTYPE h =

		{

		CCallbackHandler::EventHandler,

		CCallbackHandler::EmptyBufferDone,

		CCallbackHandler::FillBufferDone

		};

	iHandle = h;

	CActiveScheduler::Add(this);

	User::LeaveIfError(iMsgQueue.CreateLocal(KMaxMsgQueueEntries));

	iMsgQueue.NotifyDataAvailable(iStatus);

	SetActive();

	}

CCallbackHandler::CCallbackHandler(RAsyncTestStepOmxILComponentBase& aDecoderTest)

	: CActive(EPriorityNormal),

	  iDecoderTest(aDecoderTest)

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::CCallbackHandler"));

	}

CCallbackHandler::operator OMX_CALLBACKTYPE*()

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::operator OMX_CALLBACKTYPE*"));

	return &iHandle;

	}

void

CCallbackHandler::RunL()

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::RunL"));

	TOmxMessage msg;

	while (iMsgQueue.Receive(msg)==KErrNone)

		{

		switch (msg.iType)

			{

		case EEmptyBufferCallback:

			{

			iDecoderTest.DoEmptyBufferDoneL(msg.iComponent,

											msg.iBuffer);

			}

			break;

		case EFillBufferCallback:

			{

			iDecoderTest.DoFillBufferDoneL(msg.iComponent,

										   msg.iBuffer);

			}

			break;

		case EEventCallback:

			{

			iDecoderTest.DoEventHandlerL(msg.iComponent,

										 msg.iEventParams.iEvent,

										 msg.iEventParams.iData1,

										 msg.iEventParams.iData2,

										 msg.iEventParams.iExtra);

			}

			break;

		default:

			{

			// This is an invalid state

			ASSERT(EFalse);

			}

			};

		}

	// setup for next callbacks

	iStatus = KRequestPending;

	iMsgQueue.NotifyDataAvailable(iStatus);

	SetActive();

	}

CCallbackHandler::~CCallbackHandler()

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::~CCallbackHandler"));

	Cancel();

	iMsgQueue.Close();

	}

void

CCallbackHandler::DoCancel()

	{

    DEBUG_PRINTF(_L8("CCallbackHandler::DoCancel"));

	if (iMsgQueue.Handle())

		{

		iMsgQueue.CancelDataAvailable();

		}

	}

OMX_ERRORTYPE

CCallbackHandler::FillBufferDone(OMX_HANDLETYPE aComponent,

								 TAny* aAppData,

								 OMX_BUFFERHEADERTYPE* aBuffer)

	{