// 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 "log.h"

#include "omxilfsm.h"

#include "omxilstate.h"

#include "omxilportmanager.h"

#include "omxilconfigmanager.h"

#include "omxilcallbackmanager.h"

#include "omxilprocessingfunction.h"

#define RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(_a)						\

	{																	\

	const OMX_ERRORTYPE _err = _a;										\

	if (OMX_ErrorNone == _err) return _err;								\

	else return SendOmxErrorEventIfNeeded(_err);						\

	}

const TInt COmxILFsm::KMaxMsgQueueEntries;

EXPORT_C COmxILFsm*

COmxILFsm::NewL(COmxILComponent& aComponent,

				COmxILProcessingFunction& aProcFunction,

				COmxILPortManager& aPortManager,

				COmxILConfigManager& aConfigManager,

				MOmxILCallbackManagerIf& aCallbacks)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::NewLC"));

	COmxILFsm* self = new (ELeave) COmxILFsm(aComponent,

											 aProcFunction,

											 aPortManager,

											 aConfigManager,

											 aCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return (self);

	}

void

COmxILFsm::ConstructL()

	{

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

	// Create the FSM states

	// Init the array

	for (TUint i=0; i < EStateMax; ++i)

		{

		iStates.AppendL(NULL);

		}

	// Add the standard states...

	iStates[EStateInvalid]			= new (ELeave)COmxILStateInvalid;

	iStates[EStateLoaded]			= new (ELeave)COmxILStateLoaded;

	iStates[EStateIdle]				= new (ELeave)COmxILStateIdle;

	iStates[EStateExecuting]		= new (ELeave)COmxILStateExecuting;

	iStates[EStatePause]			= new (ELeave)COmxILStatePause;

	iStates[EStateWaitForResources] = new (ELeave)COmxILStateWaitForResources;

	// Now add the substates

	iStates[ESubStateLoadedToIdle]	  = new (ELeave)COmxILStateLoadedToIdle;

	iStates[ESubStateIdleToLoaded]	  = new (ELeave)COmxILStateIdleToLoaded;

	iStates[ESubStateExecutingToIdle] = new (ELeave)COmxILStateExecutingToIdle;

	iStates[ESubStatePauseToIdle]	  = new (ELeave)COmxILStatePauseToIdle;

	iCallbacks.SetPortManager(iPortManager);

	iCallbacks.SetFsm(*this);

	}

COmxILFsm::COmxILFsm(COmxILComponent& aComponent,

					 COmxILProcessingFunction& aProcFunction,

					 COmxILPortManager& aPortManager,

					 COmxILConfigManager& aConfigManager,

					 MOmxILCallbackManagerIf& aCallbacks)

	:

	iComponent(aComponent),

	iProcFunction(aProcFunction),

	iPortManager(aPortManager),

	iConfigManager(aConfigManager),

	iCallbacks(aCallbacks),

	iStates(),

	iCurrentStateIndex(EStateMax),

	ipCurrentState(0)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::COmxILFsm"));

	}

COmxILFsm::~COmxILFsm()

	{

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

	iCurrentStateIndex = EStateMax;

	ipCurrentState = 0;

	iStates.ResetAndDestroy();

	}

OMX_ERRORTYPE

COmxILFsm::InitFsm()

	{

    DEBUG_PRINTF(_L8("COmxILFsm::InitFsm"));

	// Let's get ready to handle API calls...

	iCurrentStateIndex = EStateLoaded;

	ipCurrentState	   = iStates[iCurrentStateIndex];

	return OMX_ErrorNone;

	}

COmxILComponent*

COmxILFsm::GetComponent() const

	{

	return &iComponent;

	}

OMX_ERRORTYPE

COmxILFsm::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

						  OMX_U32 aPortIndex,

						  OMX_PTR apAppPrivate,

						  OMX_U32 aSizeBytes,

						  OMX_U8* apBuffer)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::PopulateBuffer"));

	TBool portPopulationCompleted = EFalse;

	OMX_ERRORTYPE omxRetValue =

		ipCurrentState->PopulateBuffer(*this,

									   appBufferHdr,

									   aPortIndex,

									   apAppPrivate,

									   aSizeBytes,

									   apBuffer,

									   portPopulationCompleted);

	if (OMX_ErrorNone == omxRetValue)

		{

		if (portPopulationCompleted &&

			ESubStateLoadedToIdle == iCurrentStateIndex &&

			iPortManager.AllPortsPopulated())

			{

			// Complete here the transition to OMX_StateIdle

			omxRetValue = FsmTransition(EStateIdle);

			if (OMX_ErrorNone == omxRetValue)

				{

				// Notify the IL client that port population has

				// completed sucessfully

				omxRetValue = iCallbacks.TransitionCompleteNotification(

					OMX_StateIdle);

				}

			}

		}

	if (OMX_ErrorNone == omxRetValue ||

		OMX_ErrorInsufficientResources == omxRetValue)

		{

		// OMX_ErrorInsufficientResources is allowed in OMX_EmptyThisBuffer and

		// OMX_FillThisBuffer

		return omxRetValue;

		}

	else

		{

		return SendOmxErrorEventIfNeeded(omxRetValue);

		}

	}

OMX_ERRORTYPE

COmxILFsm::FsmTransition(TStateIndex aNewState)

	{

    DEBUG_PRINTF2(_L8("COmxILFsm::FsmTransition : %d"), aNewState);

	__ASSERT_ALWAYS(aNewState < EStateMax,

					User::Panic(KOmxILFsmPanicCategory, 1));

	if (aNewState != iCurrentStateIndex)

		{

		// We notify the processing function of all the state transitions, even

		// if they are not to a final OpenMAX IL state.

		OMX_ERRORTYPE omxRetValue;

		if (OMX_ErrorNone !=

			(omxRetValue =

			 iProcFunction.StateTransitionIndication(aNewState)))

			{

			// No need of propagating further error codes if the component is

			// transitioning to OMX_StateInvalid or if the PF itself is

			// invalidating the component...

			if (EStateInvalid != aNewState &&

				OMX_ErrorInvalidState != omxRetValue)

				{

				return omxRetValue;

				}

			}

		iCurrentStateIndex = aNewState;

		ipCurrentState = iStates[iCurrentStateIndex];

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILFsm::FsmTransition(TUint32 aNewState)

	{

	return FsmTransition(static_cast<TStateIndex>(aNewState));

	}

OMX_ERRORTYPE

COmxILFsm::GetComponentVersion(OMX_STRING aComponentName,

							   OMX_VERSIONTYPE* apComponentVersion,

							   OMX_VERSIONTYPE* apSpecVersion,

							   OMX_UUIDTYPE* apComponentUUID) const

	{

    DEBUG_PRINTF(_L8("COmxILFsm::GetComponentVersion"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	// This api should not be allowed in OMX_StateInvalid

	if (EStateInvalid == iCurrentStateIndex)

		{

		return SendOmxErrorEventIfNeeded(OMX_ErrorInvalidState);

		}

	if (!aComponentName ||

		!apComponentVersion ||

		!apSpecVersion ||

		!apComponentUUID)

		{

		return OMX_ErrorBadParameter;

		}

	// This API call is independent of the current state. Its handled by the

	// the config manager

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		iConfigManager.GetComponentVersion(

			aComponentName,

			apComponentVersion,

			apSpecVersion,

			apComponentUUID));

	}

OMX_ERRORTYPE

COmxILFsm::SendCommand(OMX_COMMANDTYPE aCommand,

					   TUint32 anParam1,

					   TAny* apCmdData)

	{

    DEBUG_PRINTF3(_L8("COmxILFsm::SendCommand : command [%d] Param1 [%d]"), aCommand, anParam1);

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	// Do some very minor error checking here to try to save some time...

	if (OMX_CommandStateSet == aCommand &&

		anParam1 > OMX_StateWaitForResources)

		{

		return OMX_ErrorBadParameter;

		}

	TOmxILCommand command(aCommand, anParam1, apCmdData);

	OMX_ERRORTYPE sendCommandError;

	switch (aCommand)

		{

	case OMX_CommandStateSet:

		{

		sendCommandError = ipCurrentState->CommandStateSet(*this, command);

		}

		break;

	case OMX_CommandFlush:

		{

		sendCommandError = ipCurrentState->CommandFlush(*this, command);

		}

		break;

	case OMX_CommandPortDisable:

		{

		sendCommandError = ipCurrentState->CommandPortDisable(*this, command);

		}

		break;

	case OMX_CommandPortEnable:

		{

		sendCommandError = ipCurrentState->CommandPortEnable(*this, command);

		}

		break;

	case OMX_CommandMarkBuffer:

		{

		sendCommandError = ipCurrentState->CommandMarkBuffer(*this, command);

		}

		break;

	default:

		{

		// This is an invalid command type

		return OMX_ErrorBadParameter;

		}

		};

	if (OMX_ErrorNone == sendCommandError ||

		OMX_ErrorInsufficientResources == sendCommandError)

		{

		// OMX_ErrorInsufficientResources is allowed in OMX_SendCommand

		return sendCommandError;

		}

	else

		{

		return SendOmxErrorEventIfNeeded(sendCommandError);

		}

	}

OMX_ERRORTYPE

COmxILFsm::GetParameter(OMX_INDEXTYPE aParamIndex,

						TAny* apComponentParameterStructure) const

	{

    DEBUG_PRINTF(_L8("COmxILFsm::GetParameter"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apComponentParameterStructure)

		{

		return OMX_ErrorBadParameter;

		}

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		ipCurrentState->GetParameter(*this, aParamIndex,

									 apComponentParameterStructure));

	}

OMX_ERRORTYPE

COmxILFsm::SetParameter(OMX_INDEXTYPE aParamIndex,

						const TAny* apComponentParameterStructure)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::SetParameter"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apComponentParameterStructure)

		{

		return OMX_ErrorBadParameter;

		}

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

	ipCurrentState->SetParameter(*this, aParamIndex,

								 apComponentParameterStructure));

	}

OMX_ERRORTYPE

COmxILFsm::GetConfig(OMX_INDEXTYPE aConfigIndex,

					 TAny* apComponentConfigStructure) const

	{

    DEBUG_PRINTF(_L8("COmxILFsm::GetConfig"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apComponentConfigStructure)

		{

		return OMX_ErrorBadParameter;

		}

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		ipCurrentState->GetConfig(*this,

								  aConfigIndex,

								  apComponentConfigStructure));

	}

OMX_ERRORTYPE

COmxILFsm::SetConfig(OMX_INDEXTYPE aIndex,

					 const TAny* apComponentConfigStructure)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::SetConfig"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apComponentConfigStructure)

		{

		return OMX_ErrorBadParameter;

		}

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		ipCurrentState->SetConfig(*this, aIndex, apComponentConfigStructure));

	}

OMX_ERRORTYPE

COmxILFsm::GetExtensionIndex(

	OMX_STRING aParameterName,

	OMX_INDEXTYPE* apIndexType) const

	{

    DEBUG_PRINTF(_L8("COmxILFsm::GetExtensionIndex"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apIndexType || !aParameterName)

		{

		return OMX_ErrorBadParameter;

		}

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		ipCurrentState->GetExtensionIndex(*this,

										  aParameterName,

										  apIndexType));

	}

OMX_ERRORTYPE

COmxILFsm::GetState(OMX_STATETYPE* apState) const

	{

    DEBUG_PRINTF(_L8("COmxILFsm::GetState"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!apState)

		{

		return OMX_ErrorBadParameter;

		}

	*apState = ipCurrentState->GetState();

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILFsm::ComponentTunnelRequest(OMX_U32 aPort,

								  OMX_HANDLETYPE aTunneledComp,

								  OMX_U32 aTunneledPort,

								  OMX_TUNNELSETUPTYPE* apTunnelSetup)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::ComponentTunnelRequest"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	// Here, since NULL is a valid parameter for aTunneledComp, checking of

	// input parameters is completely done by the ports.

	RETURN_OMX_ERROR_AND_EVENT_IF_NEEDED(

		ipCurrentState->ComponentTunnelRequest(*this,

											   aPort,

											   aTunneledComp,

											   aTunneledPort,

											   apTunnelSetup));

	}

OMX_ERRORTYPE

COmxILFsm::UseBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

					 OMX_U32 aPortIndex,

					 OMX_PTR apAppPrivate,

					 OMX_U32 aSizeBytes,

					 OMX_U8* apBuffer)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::UseBuffer"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!appBufferHdr || !aSizeBytes || !apBuffer)

		{

		return OMX_ErrorBadParameter;

		}

	return PopulateBuffer(appBufferHdr,

						  aPortIndex,

						  apAppPrivate,

						  aSizeBytes,

						  apBuffer);

	}

OMX_ERRORTYPE

COmxILFsm::AllocateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

						  OMX_U32 aPortIndex,

						  OMX_PTR apAppPrivate,

						  OMX_U32 aSizeBytes)

	{

    DEBUG_PRINTF(_L8("COmxILFsm::AllocateBuffer"));

	__ASSERT_DEBUG(iCurrentStateIndex != EStateMax,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!appBufferHdr || !aSizeBytes)

		{

		return OMX_ErrorBadParameter;

		}