// 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:

//

#include "omxildummyaudiodec.h"

#include "iltestuids.hrh"

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

#include <mmf/server/mmfdatabuffer.h>

_LIT8(KDummyDecoderILComponentName,"OMX.SYMBIAN.AUDIO.DECODER.DUMMY");

const TInt KMaxComponentNameLength = 128;

OMXIL_COMPONENT_ECOM_ENTRYPOINT(KUidOmxILDummyAudioDec);

const TUint32 KOMXALL = 0xFFFFFFFF;

const TInt KMaxComponentRoleLength = 128;

const TInt KIndexInputPort = 0;

const TInt KIndexOutputPort = 1;

// Set some dummy input and output buffer sizes

const TInt KDummyDecoderInputBufferSize 	= 0x2000;

const TInt KDummyDecoderOutputBufferSize 	= 0x4000;

//_LIT(KDummyDecoder, "DummyDecoder");

TInt COmxIlDummyAudioDec::CreateComponent(OMX_HANDLETYPE hComponent)

	{

	COmxIlDummyAudioDec* self = new COmxIlDummyAudioDec(hComponent);

	if (self==NULL)

		{

		return KErrNoMemory;

		}

	else

		{

		return KErrNone;

		}

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::GetComponentVersion(

       OMX_STRING pComponentName,

       OMX_VERSIONTYPE* pComponentVersion,

       OMX_VERSIONTYPE* pSpecVersion,

       OMX_UUIDTYPE* pComponentUUID)

	{

	TPtr8 name(reinterpret_cast<TUint8*>(pComponentName),

			   KMaxComponentNameLength);

	name.Copy(KDummyDecoderILComponentName);

	name.PtrZ();

	OMX_VERSIONTYPE compVer = { 1,0,0,0 };

	OMX_VERSIONTYPE specVer = { 1,1,1,0 };

	(*pComponentVersion) 	= compVer;

	(*pSpecVersion)	  		= specVer;

	TPtr8 thisUid(reinterpret_cast<TUint8*>(*pComponentUUID), 128); //Maxsize fixed by Khronos;

	thisUid = TPtr8(reinterpret_cast<TUint8*>(this), sizeof(TUint32));

	return OMX_ErrorNone;

	}

COmxIlDummyAudioDec::COmxIlDummyAudioDec(OMX_HANDLETYPE hComponent)

	:COmxComponentImpl(hComponent)

	{

	iState = OMX_StateLoaded;

	}

COmxIlDummyAudioDec::~COmxIlDummyAudioDec()

	{

	if (iState == OMX_StateExecuting)

		{

		iState = OMX_StateIdle;

		}

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::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:

				case OMX_StatePause:

				case OMX_StateExecuting:

					break;

					};

				iState = state;

				EventHandlerCallback(

					OMX_EventCmdComplete,

					OMX_CommandStateSet,

					iState,

					NULL);	

				}			

			break;

			}

		case OMX_CommandFlush:

			{

			if(nParam1 == KOMXALL)

				{

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandFlush,

						0,

						NULL);	

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandFlush,

						1,

						NULL);	

				}

			else

				{

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandFlush,

						nParam1,

						NULL);	

				}

			break;

			}

		case OMX_CommandPortDisable:

			{

			if(nParam1 == KOMXALL)

				{

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandPortDisable,

						0,

						NULL);	

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandPortDisable,

						1,

						NULL);	

				}

			else

				{

				EventHandlerCallback(

						OMX_EventCmdComplete,

						OMX_CommandPortDisable,

						nParam1,

						NULL);	

				}

			break;

			}

		}	

	return error;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::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 = KDummyDecoderInputBufferSize;

			portDef->nBufferCountActual = iBufferCountActual0;	

			}

		else

			{

			portDef->eDir = OMX_DirOutput;

			portDef->nBufferSize = KDummyDecoderOutputBufferSize;

			portDef->nBufferCountActual = iBufferCountActual1;	

			}

		}

		break;

	default:

		return OMX_ErrorUnsupportedIndex;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::SetParameter(

       OMX_INDEXTYPE nIndex,

       TAny* ComponentParameterStructure)

	{

	ASSERT(iState == OMX_StateLoaded);

	switch (nIndex)

		{

		case OMX_IndexParamAudioVorbis:

			{

			// Fake this is Audio Vorbis decoder for the purpose of testing

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

			switch(param->nPortIndex)

				{

				case 0: // Input port

					{

					// nothing to set

					return OMX_ErrorNone;

					}			

				case 1: // Output port

				default:

					{

					return OMX_ErrorUnsupportedIndex;	

					}

				};

			}

		case OMX_IndexParamAudioPcm:

			{

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

			switch(param->nPortIndex)

				{

				case 1: // Output port = PCM

					{

					return OMX_ErrorNone;

					}

				case 0: // Input port

				default:

					{

					return OMX_ErrorUnsupportedIndex;	

					}

				};

			}

		case OMX_IndexParamPortDefinition:

			{

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

			if (portDef->nPortIndex==0)	

				{

				iBufferCountActual0 = portDef->nBufferCountActual;	

				}

			else

				{

				iBufferCountActual1 = portDef->nBufferCountActual;	

				}

			return OMX_ErrorNone;

			}

		default:

			{

			return OMX_ErrorUnsupportedIndex;

			}

		};		

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::GetConfig(

       OMX_INDEXTYPE /*nIndex*/, 

       TAny* /*value*/)

	{

	return OMX_ErrorUnsupportedIndex;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::SetConfig(

       OMX_INDEXTYPE /*nIndex*/, 

       TAny* /*value*/)

	{

	return OMX_ErrorUnsupportedIndex;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::GetExtensionIndex(

       OMX_STRING /*parameterName*/,

       OMX_INDEXTYPE* pIndexType)

	{

	// This test component returns always 	OMX_IndexParamPortDefinition

	*pIndexType = OMX_IndexParamPortDefinition;

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::GetState(

       OMX_STATETYPE* pState)

	{

	*pState = iState;

	return OMX_ErrorNone;

	}

// To be implemented for DM4

OMX_ERRORTYPE COmxIlDummyAudioDec::ComponentTunnelRequest(

		OMX_HANDLETYPE /*hInput*/,

		TUint32 /*nInputPort*/,

		OMX_HANDLETYPE /*hOutput*/,

		TUint32 /*nOutputPort*/,

		OMX_TUNNELSETUPTYPE* /*pTunnelSetup*/)

	{

	// Fake everything as if it went fine 

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::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)

		{

		TPtr8 ptr(pBuffer,nSizeBytes,nSizeBytes);

		CMMFBuffer* buffer = NULL;

		TRAPD(err, buffer = CMMFPtrBuffer::NewL(ptr));

		if (err != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		switch (nPortIndex)

			{

		case KIndexInputPort:

				{

				(*ppBufferHeader)->pInputPortPrivate = buffer;

				(*ppBufferHeader)->nInputPortIndex = nPortIndex;

				}

				break;

			case KIndexOutputPort:

				{

				(*ppBufferHeader)->pOutputPortPrivate = buffer;	

				(*ppBufferHeader)->nOutputPortIndex = nPortIndex;

				}

				break;

			}

		return OMX_ErrorNone;

		}

	else

		{

		return OMX_ErrorInsufficientResources;

		}

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::AllocateBuffer(

		OMX_BUFFERHEADERTYPE** pBuffer,

		TUint32 nPortIndex,

		TAny* pAppData,

		TUint32 nSizeBytes)

	{

	ASSERT(iState == OMX_StateLoaded);

	*pBuffer = new OMX_BUFFERHEADERTYPE;

	if (*pBuffer != NULL)

		{

		CMMFDescriptorBuffer* buffer = NULL;

		TRAPD(err, buffer = CMMFDescriptorBuffer::NewL(nSizeBytes));

		if (err != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		(*pBuffer)->pBuffer = const_cast<TUint8*>(buffer->Data().Ptr());

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

		switch (nPortIndex)

			{

		case KIndexInputPort:

			(*pBuffer)->pInputPortPrivate = buffer;

			(*pBuffer)->pOutputPortPrivate = NULL;

			break;

		case KIndexOutputPort:

			(*pBuffer)->pOutputPortPrivate = buffer;

			(*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 COmxIlDummyAudioDec::FreeBuffer(

		TUint32 nPortIndex,

       OMX_BUFFERHEADERTYPE* pBuffer)

	{

	switch (nPortIndex) 

		{		

		case KIndexInputPort:

			{

			delete (static_cast<CMMFBuffer*>(pBuffer->pInputPortPrivate));

			pBuffer->pInputPortPrivate = NULL;

			break;

			}

		case KIndexOutputPort:

			delete (static_cast<CMMFBuffer*>(pBuffer->pOutputPortPrivate));

			pBuffer->pOutputPortPrivate = NULL;

			break;	

		}

	delete pBuffer;

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::EmptyThisBuffer(

       OMX_BUFFERHEADERTYPE* pBuffer)

	{

	ASSERT(iState == OMX_StateExecuting ||

			iState == OMX_StateIdle ||

			iState == OMX_StatePause);

	EmptyBufferDoneCallback(pBuffer);

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::FillThisBuffer(

           OMX_BUFFERHEADERTYPE* pBuffer)

	{

	ASSERT(iState == OMX_StateExecuting ||

			iState == OMX_StateIdle ||

			iState == OMX_StatePause);

	FillBufferDoneCallback(pBuffer);

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::SetCallbacks(

           OMX_CALLBACKTYPE* pCallbacks, 

           TAny* pAppData)

	{

	iCallback = pCallbacks;

	iAppData = pAppData;

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIlDummyAudioDec::ComponentRoleEnum(

			OMX_OUT OMX_U8 *aRole,

			OMX_IN OMX_U32 aIndex)

	{

	_LIT8(KFakeRole,"audio_decoder.vrb");

	if (aIndex == 0)

		{

		TPtr8 ptr((TUint8*)aRole, 0, KMaxComponentRoleLength);

		ptr.Copy(KFakeRole);

		ptr.PtrZ();

		return OMX_ErrorNone;

		}

	else

		{

		return OMX_ErrorBadParameter;