// Copyright (c) 2005-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:

//

#include <e32debug.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

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

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

#include "OmxImpl.h"

#include "OmxPCMCodec.h"

const TInt KPCMBufferSize = 4096;

const TInt KThreadStackSize = 16384; 

const TInt KShutDownTime = 5000000; 

TInt ProcessingThread(TAny* aComponent)

	{

	// get our class

	CCodecProcessor* codecprocessor = static_cast<CCodecProcessor*>(aComponent);

	// run the thread

	TRAPD(err, codecprocessor->RunThreadL());

	// thread has exited or failed to start so return error to the client. 

	return err;

	}

TInt COmxPCMCodec::CreateComponent(OMX_HANDLETYPE hComponent)

	{

	COmxPCMCodec* self = new COmxPCMCodec(hComponent);

	if (self==NULL)

		{

		return KErrNoMemory;

		}		

	TRAPD(err, self->ConstructL());

	// self is stored in the handle, so we won't return it

	return err;

	}

OMX_ERRORTYPE COmxPCMCodec::GetComponentVersion(

       OMX_STRING /*pComponentName*/,

       OMX_VERSIONTYPE* /*pComponentVersion*/,

       OMX_VERSIONTYPE* /*pSpecVersion*/,

       OMX_UUIDTYPE* /*pComponentUUID*/)

	{

// to be implemented

	return OMX_ErrorNone;

	}

void COmxPCMCodec::ConstructL()

	{

	iCodecProcessor = CCodecProcessor::NewL(*this);	

	iState = OMX_StateLoaded;

	}

COmxPCMCodec::COmxPCMCodec(OMX_HANDLETYPE hComponent)

	:COmxComponentImpl(hComponent)

	{

	}

COmxPCMCodec::~COmxPCMCodec()

	{

	if (iState == OMX_StateExecuting)

		{

		iCodecProcessor->Stop();

		iState = OMX_StateIdle;

		}

	if (iCreatedThread &&(iProcessingThread.Handle() != KNullHandle) && (iProcessingThread.ExitType() == EExitPending))

		{

		TRequestStatus logonStatus;

		TBool logonFailed = EFalse;

		iProcessingThread.Logon(logonStatus);

		if(logonStatus != KRequestPending)

			{//logon failed. Mostly due to no memory

			logonFailed = ETrue;

			}		

		iCodecProcessor->Exit();

		RTimer timer;

		TInt err = timer.CreateLocal();

		if(err==KErrNone && !logonFailed) //both timer and logon successful

			{

			TRequestStatus timeout;

			timer.After(timeout, KShutDownTime);

			User::WaitForRequest(logonStatus, timeout);

			if(logonStatus==KRequestPending)

				{//Thread has not exited after the timeout. Kill it!

				iProcessingThread.LogonCancel(logonStatus);

				User::WaitForRequest(logonStatus);

				iProcessingThread.Kill(KErrDied);

				}

			else 

				{//Thread exited. Cancel the timer

				timer.Cancel();

				User::WaitForRequest(timeout);

				}

			}

		else 

			{//either timer or Logon method has failed.Poll the thread status a maximum

			 // of 10 times and kill the thread if it hasn't exited after the polling

			for (TInt i=0; i<10 && iProcessingThread.ExitType() == EExitPending; ++i)

				{

				User::After(KShutDownTime/10);	// wait for a while

				}

			if (iProcessingThread.ExitType() == EExitPending)

				{

				// The polling hasn't been succesful so we kill the thread

				iProcessingThread.Kill(KErrDied);

				}

			if(!logonFailed)

				{

				User::WaitForRequest(logonStatus);

				}

			}	

		iProcessingThread.Close();

		}

	delete iCodecProcessor;

	}

OMX_ERRORTYPE COmxPCMCodec::SendCommand(

       OMX_COMMANDTYPE Cmd,

       TUint32 nParam1,

       TAny* /*pCmdData*/)

	{

	OMX_ERRORTYPE error = OMX_ErrorNone;

	switch (Cmd)

		{

	case OMX_CommandStateSet:

		OMX_STATETYPE state = (OMX_STATETYPE)nParam1;

		if (state == iState)

			{

			error = OMX_ErrorSameState;

			}

		else

			{

			// notify client of the state change

			switch (state)

				{

			case OMX_StateIdle:

				{

				if (iState == OMX_StateExecuting)

					{

					iCodecProcessor->Stop();

					}

				break;

				}

			case OMX_StateExecuting:

				StartExecution();

				break;

				};

			iState = state;

			EventHandlerCallback(

				OMX_EventCmdComplete,

				OMX_CommandStateSet,

				iState,

				NULL);	

			break;

			}

		};	

	return error;

	}

OMX_ERRORTYPE COmxPCMCodec::GetParameter(

       OMX_INDEXTYPE nParamIndex,  

       TAny* ComponentParameterStructure)

	{

	switch (nParamIndex)

		{

	case OMX_IndexParamAudioInit :

		{

		OMX_PORT_PARAM_TYPE* param = static_cast<OMX_PORT_PARAM_TYPE*>(ComponentParameterStructure);

		param->nPorts = 2;

		}

		break;

	case OMX_IndexParamPortDefinition:

		{

		OMX_PARAM_PORTDEFINITIONTYPE* portDef = static_cast<OMX_PARAM_PORTDEFINITIONTYPE*>(ComponentParameterStructure);

		if (portDef->nPortIndex==0)	

			{

			portDef->eDir = OMX_DirInput;	

			portDef->nBufferSize = KPCMBufferSize;

			}

		else

			{

			portDef->eDir = OMX_DirOutput;

			portDef->nBufferSize = KPCMBufferSize;

			}

		}

		break;

	default:

		return OMX_ErrorUnsupportedIndex;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxPCMCodec::SetParameter(

       OMX_INDEXTYPE nIndex,

       TAny* ComponentParameterStructure)

	{

	ASSERT(iState == OMX_StateLoaded);

	switch (nIndex)

		{

		case OMX_IndexParamAudioPcm:

			{

			OMX_AUDIO_PARAM_PCMMODETYPE* param = static_cast<OMX_AUDIO_PARAM_PCMMODETYPE*>(ComponentParameterStructure);

			switch(param->nPortIndex)

				{

				case 0: // Input port

					{

					iCodecProcessor->SetInputBitsPerSample(param->nBitPerSample);

					iCodecProcessor->SetInputDataType(param->eNumData);

					//break;

					return OMX_ErrorNone;

					}			

				case 1: // Output port

					{

					iCodecProcessor->SetOutputBitsPerSample(param->nBitPerSample);

					iCodecProcessor->SetOutputDataType(param->eNumData);

					//break;	

					return OMX_ErrorNone;

					}

				default:

					{

					return OMX_ErrorUnsupportedIndex;	

					}

				};

			}

		default:

			{

			return OMX_ErrorUnsupportedIndex;

			}

		};		

	//return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxPCMCodec::GetConfig(

       OMX_INDEXTYPE /*nIndex*/, 

       TAny* /*value*/)

	{

	return OMX_ErrorUnsupportedIndex;

	}

OMX_ERRORTYPE COmxPCMCodec::SetConfig(

       OMX_INDEXTYPE /*nIndex*/, 

       TAny* /*value*/)

	{

	return OMX_ErrorUnsupportedIndex;

	}

OMX_ERRORTYPE COmxPCMCodec::GetExtensionIndex(

       OMX_STRING /*ParameterName*/,

       OMX_INDEXTYPE* /*pIndexType*/)

	{

	return OMX_ErrorNotImplemented;

	}

OMX_ERRORTYPE COmxPCMCodec::GetState(

       OMX_STATETYPE* pState)

	{

	*pState = iState;

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxPCMCodec::ComponentTunnelRequest(

		OMX_HANDLETYPE /*hInput*/,

		TUint32 /*nInputPort*/,

		OMX_HANDLETYPE /*hOutput*/,

		TUint32 /*nOutputPort*/,

		OMX_TUNNELSETUPTYPE* /*pTunnelSetup*/)

	{

	return OMX_ErrorNotImplemented;

	}

OMX_ERRORTYPE COmxPCMCodec::UseBuffer(

       OMX_BUFFERHEADERTYPE** ppBufferHeader,

       TUint32 /*nPortIndex*/,

       TAny* pAppPrivate,

       TUint32 nSizeBytes,

       TUint8* pBuffer)

	{

	ASSERT(iState == OMX_StateLoaded);

	*ppBufferHeader = new OMX_BUFFERHEADERTYPE;

	if (*ppBufferHeader != NULL)

		{

		(*ppBufferHeader)->pBuffer = pBuffer;

		(*ppBufferHeader)->pAppPrivate = pAppPrivate;

		(*ppBufferHeader)->nAllocLen = nSizeBytes;

		(*ppBufferHeader)->nFilledLen = 0;

		(*ppBufferHeader)->nFlags = 0;

		(*ppBufferHeader)->pInputPortPrivate = NULL;

		(*ppBufferHeader)->pOutputPortPrivate = NULL;

		}

	if (*ppBufferHeader)

		{

		return OMX_ErrorNone;

		}

	else

		{

		return OMX_ErrorInsufficientResources;

		}

	}

OMX_ERRORTYPE COmxPCMCodec::AllocateBuffer(

		OMX_BUFFERHEADERTYPE** pBuffer,

		TUint32 nPortIndex,

		TAny* pAppData,

		TUint32 nSizeBytes)

	{

	ASSERT(iState == OMX_StateLoaded);

	*pBuffer = new OMX_BUFFERHEADERTYPE;

	if (*pBuffer != NULL)

		{

		(*pBuffer)->pBuffer = new unsigned char[nSizeBytes];

		// store our allocated memory in component's private store

		switch (nPortIndex)

			{

		case 0:

			(*pBuffer)->pInputPortPrivate = (*pBuffer)->pBuffer;

			(*pBuffer)->pOutputPortPrivate = NULL;

			break;

		case 1:

			(*pBuffer)->pOutputPortPrivate = (*pBuffer)->pBuffer;

			(*pBuffer)->pInputPortPrivate = NULL;

			break;

			};

		(*pBuffer)->nAllocLen = nSizeBytes;

		(*pBuffer)->nFilledLen = 0;

		(*pBuffer)->pAppPrivate = pAppData;

		}

	if (*pBuffer && (*pBuffer)->pBuffer)

		{

		return OMX_ErrorNone;

		}

	else

		{

		return OMX_ErrorInsufficientResources;

		}

	}

OMX_ERRORTYPE COmxPCMCodec::FreeBuffer(

		TUint32 /*nPortIndex*/,

       OMX_BUFFERHEADERTYPE* pBuffer)

	{

	if (pBuffer->pInputPortPrivate || 

		pBuffer->pOutputPortPrivate)

		delete[] pBuffer->pBuffer;

	delete pBuffer;

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxPCMCodec::EmptyThisBuffer(

       OMX_BUFFERHEADERTYPE* pBuffer)

	{

	ASSERT(iState == OMX_StateExecuting ||

			iState == OMX_StateIdle ||

			iState == OMX_StatePause);

	return iCodecProcessor->EmptyThisBuffer(pBuffer);

	}

OMX_ERRORTYPE COmxPCMCodec::FillThisBuffer(

           OMX_BUFFERHEADERTYPE* pBuffer)

	{

	ASSERT(iState == OMX_StateExecuting ||

			iState == OMX_StateIdle ||

			iState == OMX_StatePause);

	return iCodecProcessor->FillThisBuffer(pBuffer);	

	}

OMX_ERRORTYPE COmxPCMCodec::SetCallbacks(

           OMX_CALLBACKTYPE* pCallbacks, 

           TAny* pAppData)

	{

	iCallback = pCallbacks;

	iAppData = pAppData;

	return OMX_ErrorNone;

	}

CCodecProcessor::CCodecProcessor(COmxPCMCodec& aParent) 

	: iParent(&aParent)

	{

	}

void CCodecProcessor::RunThreadL()

	{

	iQueueStatus = KRequestPending;

	iMessageQueue.NotifyDataAvailable(iQueueStatus);

	for (;;)

		{

		User::WaitForRequest(iQueueStatus);

		TCodecMessage msg;

		TBool exit = EFalse;

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

			{

			switch (msg.iType)

				{

				case EStopProcessing:

					iStarted = EFalse;

					break;

				case EExit:

					exit = ETrue;

					break;

				case EInputBuffer:

					iBuffersToEmpty.Append(msg.iBuffer); 

					break;

				case EOutputBuffer:

					iBuffersToFill.Append(msg.iBuffer);

					break;

				}

			}

		if (exit)

			{

			break;

			}

		else

			{

			// process all available buffers

			ProcessAvailableBuffers();	

			// request notification of further queue events

			iQueueStatus = KRequestPending;

			iMessageQueue.NotifyDataAvailable(iQueueStatus);

			}

		}

	}

CCodecProcessor* CCodecProcessor::NewL(COmxPCMCodec& aParent) 

	{

	CCodecProcessor* self = new (ELeave) CCodecProcessor(aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}	

void CCodecProcessor::ConstructL()

	{

	User::LeaveIfError(iMessageQueue.CreateLocal(10));

	// set the default case	

	iInputBitsPerSample = 8;

	iInputDataType = OMX_NumericalDataUnsigned;

	iOutputBitsPerSample = 16;

	iOutputDataType = OMX_NumericalDataSigned;

	}

OMX_ERRORTYPE CCodecProcessor::EmptyThisBuffer( 

		OMX_BUFFERHEADERTYPE* pBuffer) 

	{

	TCodecMessage message;

	message.iType = EInputBuffer;

	message.iBuffer = pBuffer;

	if (iMessageQueue.Send(message) == KErrNone)

		{

		return OMX_ErrorNone;	

		}

	else

		{

		return OMX_ErrorUndefined;

		}

	}

void CCodecProcessor::Stop()

	{

	TCodecMessage message;

	message.iType = EStopProcessing;

	message.iBuffer = NULL;

	iMessageQueue.Send(message);

	}

void CCodecProcessor::Exit()

	{

	TCodecMessage message;

	message.iType = EExit;

	message.iBuffer = NULL;

	iMessageQueue.SendBlocking(message);

	}

OMX_ERRORTYPE CCodecProcessor::FillThisBuffer(

									OMX_BUFFERHEADERTYPE* pBuffer) 

	{

	TCodecMessage message;

	message.iType = EOutputBuffer;

	message.iBuffer = pBuffer;

	if (iMessageQueue.Send(message)== KErrNone)

		{

		return OMX_ErrorNone;

		}

	else

		{

		return OMX_ErrorUndefined;

		}

	}

void CCodecProcessor::SetInputBitsPerSample(TInt aInputBitsPerSample)

	{

	iInputBitsPerSample = aInputBitsPerSample;

	}

void CCodecProcessor::SetInputDataType(OMX_NUMERICALDATATYPE aType)

	{

	iInputDataType = aType;

	}

void CCodecProcessor::SetOutputBitsPerSample(TInt aInputBitsPerSample)

	{

	iOutputBitsPerSample = aInputBitsPerSample;

	}

void CCodecProcessor::SetOutputDataType(OMX_NUMERICALDATATYPE aType)

	{

	iOutputDataType = aType;

	}

void CCodecProcessor::ChooseCodec()

	{

	// choose correct conversion codec

	if (iInputBitsPerSample == 8 && iOutputBitsPerSample == 16)

		{

		iOutputSamplesPerInputSample = 2;

		if (iInputDataType == OMX_NumericalDataSigned &&

		iOutputDataType == OMX_NumericalDataSigned)

			{

			iCurrentCodec = &iAudioS8ToS16PcmCodec;

			}

		else if (iInputDataType == OMX_NumericalDataUnsigned &&

			iOutputDataType == OMX_NumericalDataSigned)

			{

			iCurrentCodec = &iAudioU8ToS16PcmCodec;

			}

		}

	else if (iInputBitsPerSample == 16 && iOutputBitsPerSample == 8)

		{

		iOutputSamplesPerInputSample = .5;

		if (iInputDataType == OMX_NumericalDataSigned &&

		iOutputDataType == OMX_NumericalDataSigned)

			{

			iCurrentCodec = &iAudioS16ToS8PcmCodec;

			}

		else if (iInputDataType == OMX_NumericalDataSigned &&

			iOutputDataType == OMX_NumericalDataUnsigned)

			{

			iCurrentCodec = &iAudioS16ToU8PcmCodec;

			}

		}

	}

void CCodecProcessor::ProcessAvailableBuffers()

	{

	// Setup wait for data in queue

	while (iBuffersToFill.Count()>0 && iBuffersToEmpty.Count() > 0)

		{

		TBool lastBuffer = EFalse;

		if (!iStarted)

			{

			ChooseCodec();

			iStarted = ETrue;

			}

		OMX_BUFFERHEADERTYPE* srcBuffer = iBuffersToEmpty[0];

		OMX_BUFFERHEADERTYPE* destBuffer = iBuffersToFill[0];

		if (srcBuffer->nFlags & OMX_BUFFERFLAG_EOS)

			{

			lastBuffer = ETrue;

			}

		TInt destBufferPos = destBuffer->nFilledLen;

		TInt destBufferSize = destBuffer->nAllocLen - destBufferPos;

		TInt inputSamplesRequired = (TInt)((TReal)destBufferSize / iOutputSamplesPerInputSample);

		TInt availableSamples = srcBuffer->nFilledLen - iInputBufferPos;

		if (availableSamples <= inputSamplesRequired)

			{

			TInt samplesToConvert = availableSamples;

			if (iOutputSamplesPerInputSample == .5)

				{

				samplesToConvert >>= 1;

				}

			iCurrentCodec->Convert(&srcBuffer->pBuffer[iInputBufferPos], &destBuffer->pBuffer[destBufferPos], samplesToConvert);

			iInputBufferPos = 0; // finished buffer - so reset

			inputSamplesRequired -= availableSamples;

			destBuffer->nFilledLen = (TInt)((TReal)availableSamples * iOutputSamplesPerInputSample);

			srcBuffer->nFilledLen = 0;

			iBuffersToEmpty.Remove(0);

			iParent->EmptyBufferDoneCallback(srcBuffer);			

			if (inputSamplesRequired == 0 || lastBuffer)

				{

				iBuffersToFill.Remove(0);

				if (lastBuffer)

					{

					destBuffer->nFlags |= OMX_BUFFERFLAG_EOS;

					// propagate the EOS flag

					iParent->EventHandlerCallback(

						OMX_EventBufferFlag,

						0,

						destBuffer->nFlags,

						NULL);	

					}

				iParent->FillBufferDoneCallback(destBuffer);

				}

			}

		else

			{

			TInt samplesToConvert = inputSamplesRequired;

			if (iOutputSamplesPerInputSample == .5)

				{

				samplesToConvert >>= 2;

				}

			iCurrentCodec->Convert(&srcBuffer->pBuffer[iInputBufferPos], &destBuffer->pBuffer[destBufferPos], samplesToConvert);

			iInputBufferPos += inputSamplesRequired;

			destBuffer->nFilledLen = destBuffer->nAllocLen;

			iBuffersToFill.Remove(0);

			iParent->FillBufferDoneCallback(destBuffer);

			}		

		}

	}

CCodecProcessor::~CCodecProcessor()

	{

	iBuffersToEmpty.Close();

	iBuffersToFill.Close();

	iMessageQueue.Close();

	}

TInt COmxPCMCodec::StartExecution()

	{

	// create thread with current thread's heap

	// we can thus allocate and free memory across threads

	if (!iCreatedThread)

		{

		TInt err = iProcessingThread.Create(_L("PCMCodec"), 

							&ProcessingThread, 

							KThreadStackSize, 

							&User::Heap(),

							iCodecProcessor);

		if (err!=KErrNone)

			{

			return err;

			}

		iCreatedThread = ETrue;

		iThreadDeath = KRequestPending;

		iProcessingThread.Resume();

		}

	return KErrNone;						

	}

// Callbacks for the PCM codec

void COmxPCMCodec::EventHandlerCallback( 

        			OMX_OUT OMX_EVENTTYPE eEvent, 

        			OMX_OUT TUint32 nData1,

        			OMX_OUT TUint32 nData2,

        			OMX_OUT OMX_STRING cExtraInfo)

	{

	iCallback->EventHandler(

			this,

			iAppData,

			eEvent,

			nData1,

			nData2,

			cExtraInfo);	

	}

void COmxPCMCodec::FillBufferDoneCallback(OMX_BUFFERHEADERTYPE* aBuffer)

	{

	iCallback->FillBufferDone(

		*this,

		iAppData,

		aBuffer);

	}

void COmxPCMCodec::EmptyBufferDoneCallback(OMX_BUFFERHEADERTYPE* aBuffer)

	{

	iCallback->EmptyBufferDone(

		*this,

		iAppData,

		aBuffer);		

	}

// Component Entry Point

OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)

	{

	TInt err = COmxPCMCodec::CreateComponent(hComponent);

	if (err == KErrNone)

		{

		return OMX_ErrorNone;

		}		

	else 

		{

		// return problem

		return OMX_ErrorInsufficientResources;		

		}

	}