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

#include "omxilfsm.h"

#include <openmax/il/common/omxilstatedefs.h>

#include "omxilcommand.h"

#include <openmax/il/common/omxilconfigmanager.h>

#include "omxilcallbackmanager.h"

OMX_ERRORTYPE

COmxILFsm::COmxILState::GetParameter(

	const COmxILFsm& aFsm,

	OMX_INDEXTYPE aParamIndex,

	TAny* apComponentParameterStructure) const

	{

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

	// This API can be used independently of the current state of the

	// component.  Let's try first the Port Manager to check if the index is

	// known there

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.GetParameter(aParamIndex,

									   apComponentParameterStructure);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Otherwise, try Config Manager...

		retValue = aFsm.iConfigManager.GetParameter(

			aParamIndex,

			apComponentParameterStructure);

		}

	return retValue;

	}

// This SetParameter version must be used in the following states:

// - OMX_StateIdle,

// - OMX_StateExecuting,

// - OMX_StatePaused, and

//

OMX_ERRORTYPE

COmxILFsm::COmxILState::SetParameter(

	COmxILFsm& aFsm,

	OMX_INDEXTYPE aParamIndex,

	const TAny* apComponentParameterStructure)

	{

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

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.SetParameter(

			aParamIndex,

			apComponentParameterStructure,

			OMX_TRUE				// Port must be disabled

			);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Try Config Manager now...

		retValue = aFsm.iConfigManager.SetParameter(

			aParamIndex,

			apComponentParameterStructure,

			OMX_FALSE // run-time

			);

		}

	return retValue;

	}

// This SetParameter version must be used in the following states:

// - OMX_StateLoaded and derived states,

// - OMX_StateWaitForResources

//

OMX_ERRORTYPE

COmxILFsm::COmxILState::SetParameterV2(

	COmxILFsm& aFsm,

	OMX_INDEXTYPE aParamIndex,

	const TAny* apComponentParameterStructure)

	{

    DEBUG_PRINTF(_L8("COmxILState::SetParameterV2"));

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.SetParameter(aParamIndex,

									   apComponentParameterStructure);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Try Config Manager now...

		retValue = aFsm.iConfigManager.SetParameter(

			aParamIndex,

			apComponentParameterStructure);

		}

	return retValue;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::GetConfig(

	const COmxILFsm& aFsm,

	OMX_INDEXTYPE aConfigIndex,

	TAny* apComponentConfigStructure) const

	{

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

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.GetConfig(aConfigIndex,

									apComponentConfigStructure);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Try Config Manager now...

		retValue = aFsm.iConfigManager.GetConfig(

			aConfigIndex,

			apComponentConfigStructure);

		}

	return retValue;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::SetConfig(COmxILFsm& aFsm,

								  OMX_INDEXTYPE aConfigIndex,

								  const TAny* apComponentConfigStructure)

	{

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

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.SetConfig(aConfigIndex,

									apComponentConfigStructure);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Try Config Manager now...

		retValue = aFsm.iConfigManager.SetConfig(

			aConfigIndex,

			apComponentConfigStructure);

		}

	return retValue;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::GetExtensionIndex(const COmxILFsm& aFsm,

										  OMX_STRING aParameterName,

										  OMX_INDEXTYPE* apIndexType) const

	{

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

	OMX_ERRORTYPE retValue =

		aFsm.iPortManager.GetExtensionIndex(aParameterName,

											apIndexType);

	if (OMX_ErrorUnsupportedIndex == retValue)

		{

		// Try Config Manager now...

		retValue = aFsm.iConfigManager.GetExtensionIndex(

			aParameterName,

			apIndexType);

		}

	return retValue;

	}

//

//

//

OMX_ERRORTYPE

COmxILFsm::COmxILState::CommandFlush(COmxILFsm& aFsm,

									 const TOmxILCommand& aCommand)

	{

    DEBUG_PRINTF(_L8("COmxILState::CommandFlush"));

	__ASSERT_DEBUG(aCommand.iCommandType == OMX_CommandFlush,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	return aFsm.iPortManager.BufferFlushIndicationFlushCommand(

		aCommand.iParam1);

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::CommandPortDisable(COmxILFsm& aFsm,

										   const TOmxILCommand& aCommand)

	{

    DEBUG_PRINTF(_L8("COmxILState::CommandPortDisable"));

	__ASSERT_DEBUG(aCommand.iCommandType == OMX_CommandPortDisable,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	// First, flush all buffers in the port(s) that is(are) to be disabled.

	return aFsm.iPortManager.PortDisableIndication(

		aCommand.iParam1);

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::CommandPortEnable(COmxILFsm& aFsm,

										  const TOmxILCommand& aCommand)

	{

    DEBUG_PRINTF(_L8("COmxILState::CommandPortEnable"));

	__ASSERT_DEBUG(aCommand.iCommandType == OMX_CommandPortEnable,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	TBool indicationIsFinal = EFalse;

	return aFsm.iPortManager.PortEnableIndication(

		aCommand.iParam1,

		indicationIsFinal);

	}

OMX_ERRORTYPE

COmxILFsm::COmxILState::CommandMarkBuffer(COmxILFsm& aFsm,

										  const TOmxILCommand& aCommand)

	{

    DEBUG_PRINTF(_L8("COmxILState::CommandMarkBuffer"));

	__ASSERT_DEBUG(aCommand.iCommandType == OMX_CommandMarkBuffer,

				   User::Panic(KOmxILFsmPanicCategory, 1));

	if (!aCommand.ipCommandData)

		{

		return OMX_ErrorBadParameter;

		}

	return aFsm.iPortManager.BufferMarkIndication(aCommand.iParam1,

												  aCommand.ipCommandData);

	}

//

// COmxILStateInvalid

//

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::GetParameter(

	const COmxILFsm& /*aFsm*/,

	OMX_INDEXTYPE /*aParamIndex*/,

	TAny* /*apComponentParameterStructure*/) const

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::SetParameter(

	COmxILFsm& /*aFsm*/,

	OMX_INDEXTYPE /*aParamIndex*/,

	const TAny* /*apComponentParameterStructure*/)

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::GetConfig(

	const COmxILFsm& /*aFsm*/,

	OMX_INDEXTYPE /*aConfigIndex*/,

	TAny* /*apComponentConfigStructure*/) const

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::SetConfig(

	COmxILFsm& /*aFsm*/,

	OMX_INDEXTYPE /*aConfigIndex*/,

	const TAny* /*apComponentConfigStructure*/)

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::GetExtensionIndex(

	const COmxILFsm& /*aFsm*/,

	OMX_STRING /*aParameterName*/,

	OMX_INDEXTYPE* /*apIndexType*/) const

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_STATETYPE

COmxILFsm::COmxILStateInvalid::GetState() const

	{

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

	return OMX_StateInvalid;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::ComponentTunnelRequest(

	COmxILFsm& /*aFsm*/,

	OMX_U32 /*aPort*/,

	OMX_HANDLETYPE /*aTunneledComp*/,

	OMX_U32 /*aTunneledPort*/,

	OMX_TUNNELSETUPTYPE* /*apTunnelSetup*/)

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::PopulateBuffer(

	COmxILFsm& /*aFsm*/,

	OMX_BUFFERHEADERTYPE** /*appBufferHdr*/,

	OMX_U32 /*aPortIndex*/,

	OMX_PTR /*apAppPrivate*/,

	OMX_U32 /*aSizeBytes*/,

	OMX_U8* /*apBuffer*/,

	TBool& /*portPopulationCompleted*/)

	{

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

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::FreeBuffer(COmxILFsm& aFsm,

										  OMX_U32 aPortIndex,

										  OMX_BUFFERHEADERTYPE* apBuffer,

										  TBool& aPortDepopulationCompleted)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::FreeBuffer"));

	return COmxILState::FreeBufferV2(

		aFsm,

		aPortIndex,

		apBuffer,

		aPortDepopulationCompleted);

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::EmptyThisBuffer(

	COmxILFsm& /*aFsm*/,

	OMX_BUFFERHEADERTYPE* /*apBuffer*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::EmptyThisBuffer"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::FillThisBuffer(

	COmxILFsm& /*aFsm*/,

	OMX_BUFFERHEADERTYPE* /*apBuffer*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::FillThisBuffer"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::CommandStateSet(

	COmxILFsm& /*aFsm*/,

	const TOmxILCommand& /*aCommand*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::CommandStateSet"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::CommandFlush(

	COmxILFsm& /*aFsm*/,

	const TOmxILCommand& /*aCommand*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::CommandFlush"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::CommandPortEnable(

	COmxILFsm& /*aFsm*/,

	const TOmxILCommand& /*aCommand*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::CommandPortEnable"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::CommandPortDisable(

	COmxILFsm& /*aFsm*/,

	const TOmxILCommand& /*aCommand*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::CommandPortDisable"));

	return OMX_ErrorInvalidState;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateInvalid::CommandMarkBuffer(

	COmxILFsm& /*aFsm*/,

	const TOmxILCommand& /*aCommand*/)

	{

    DEBUG_PRINTF(_L8("COmxILStateInvalid::CommandMarkBuffer"));

	return OMX_ErrorInvalidState;

	}

//

// COmxILStateLoaded

//

OMX_STATETYPE

COmxILFsm::COmxILStateLoaded::GetState() const

	{

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

	return OMX_StateLoaded;

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateLoaded::SetParameter(

	COmxILFsm& aFsm,

	OMX_INDEXTYPE aParamIndex,

	const TAny* apComponentParameterStructure)

	{

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

	return COmxILState::SetParameterV2(aFsm,

									   aParamIndex,

									   apComponentParameterStructure);

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateLoaded::PopulateBuffer(

	COmxILFsm& aFsm,

	OMX_BUFFERHEADERTYPE** appBufferHdr,

	OMX_U32 aPortIndex,

	OMX_PTR apAppPrivate,

	OMX_U32 aSizeBytes,

	OMX_U8* apBuffer,

	TBool& portPopulationCompleted)

	{

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

#ifdef _OMXIL_COMMON_IL516C_ON

	if (!apBuffer)

		{

		// ... AllocateBuffer

		//

		// At this point, the command requesting the transition from Loaded to

		// Idle has not been received yet.. (see

		// COmxILStateLoadedToIdle). Therefore, this can only be successful if

		// the port is disabled

		return COmxILState::PopulateBuffer(aFsm,

									   appBufferHdr,

									   aPortIndex,

									   apAppPrivate,

									   aSizeBytes,

									   apBuffer,

									   portPopulationCompleted);

		}

	else

		{

		//... UseBuffer...

		OMX_ERRORTYPE omxError =

			COmxILState::PopulateBufferV2(aFsm,

										  appBufferHdr,

										  aPortIndex,

										  apAppPrivate,

										  aSizeBytes,

										  apBuffer,

										  portPopulationCompleted);

		if (apBuffer && OMX_ErrorNone == omxError)

			{

			DEBUG_PRINTF2(_L8("COmxILStateLoaded::PopulateBuffer : PORT [%u] : Buffer population occurring in OMX_StateLoaded"), aPortIndex);

			}

		return omxError;

		}

#else

	// At this point, the command requesting the transition from Loaded to Idle

	// has not been received yet.. (see COmxILStateLoadedToIdle). Therefore,

	// this can only be successful if the port is disabled

	return COmxILState::PopulateBuffer(aFsm,

									   appBufferHdr,

									   aPortIndex,

									   apAppPrivate,

									   aSizeBytes,

									   apBuffer,

									   portPopulationCompleted);

#endif

	}

OMX_ERRORTYPE

COmxILFsm::COmxILStateLoaded::FreeBuffer(COmxILFsm& aFsm,

										 OMX_U32 aPortIndex,

										 OMX_BUFFERHEADERTYPE* apBuffer,

										 TBool& aPortDepopulationCompleted)

	{

    DEBUG_PRINTF(_L8("COmxILStateLoaded::FreeBuffer"));

	return COmxILState::FreeBuffer(aFsm,

								   aPortIndex,

								   apBuffer,