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

#include "omxilport.h"

#include "omxilutil.h"

const TInt COmxILPort::KMaxBufferMarksQueueSize;

const TInt COmxILPort::KBufferMarkPropagationPortNotNeeded;

EXPORT_C

TOmxILCommonPortData::TOmxILCommonPortData(

	OMX_VERSIONTYPE aOmxVersion,

	OMX_U32 aPortIndex,

	OMX_DIRTYPE aDirection,

	OMX_U32 aBufferCountMin,

	OMX_U32 aBufferSizeMin,

	OMX_PORTDOMAINTYPE aPortDomain,

	OMX_BOOL aBuffersContiguous,

	OMX_U32 aBufferAlignment,

	OMX_BUFFERSUPPLIERTYPE aBufferSupplier,

	OMX_U32 aBufferMarkPropagationPortIndex)

	:

	iOmxVersion(aOmxVersion),

	iPortIndex(aPortIndex),

	iDirection(aDirection),

	iBufferCountMin(aBufferCountMin),

	iBufferSizeMin(aBufferSizeMin),

	iPortDomain(aPortDomain),

	iBuffersContiguous(aBuffersContiguous),

	iBufferAlignment(aBufferAlignment),

	iBufferSupplier(aBufferSupplier),

	iBufferMarkPropagationPortIndex(aBufferMarkPropagationPortIndex)

	{

	}

EXPORT_C

COmxILPort::COmxILPort(const TOmxILCommonPortData& aCommonPortData)

	:

	iTunnelledComponent(0),

	iTunnelledPort(0),

	iBufferHeaders(),

	iBufferMarks(_FOFF(TBufferMarkInfo, iLink)),

	iTransitionState(EPortNotTransitioning),

	iBufferMarkPropagationPortIndex(

		aCommonPortData.iBufferMarkPropagationPortIndex)

	{

    DEBUG_PRINTF(_L8("COmxILPort::COmxILPort"));

	__ASSERT_DEBUG(aCommonPortData.iDirection == OMX_DirInput ||

				   aCommonPortData.iDirection == OMX_DirOutput,

				   User::Panic(KOmxILPortPanicCategory, 1));

	// From Section 3.1.2.12.1 .

	//

	// nBufferCountMin : "The component shall define this non-zero default

	// value."

	//

	// nBufferCountActual : "The component shall set a default value no less

	// than nBufferCountMin for this field"

	__ASSERT_DEBUG(aCommonPortData.iBufferCountMin > 0,

				   User::Panic(KOmxILPortPanicCategory, 1));

	// Filll in OMX_PARAM_PORTDEFINITIONTYPE

	iParamPortDefinition.nSize				= sizeof(OMX_PARAM_PORTDEFINITIONTYPE);

	iParamPortDefinition.nVersion			= aCommonPortData.iOmxVersion;

	iParamPortDefinition.nPortIndex			= aCommonPortData.iPortIndex;

	iParamPortDefinition.eDir				= aCommonPortData.iDirection;

	iParamPortDefinition.nBufferCountActual = aCommonPortData.iBufferCountMin;

	iParamPortDefinition.nBufferCountMin	= aCommonPortData.iBufferCountMin;

	iParamPortDefinition.nBufferSize		= aCommonPortData.iBufferSizeMin;

	iParamPortDefinition.bEnabled			= OMX_TRUE;

	iParamPortDefinition.bPopulated			= OMX_FALSE;

	iParamPortDefinition.eDomain			= aCommonPortData.iPortDomain;

	// NOTE: iParamPortDefinition.format must be finished up by concrete ports

	iParamPortDefinition.bBuffersContiguous = aCommonPortData.iBuffersContiguous;

	iParamPortDefinition.nBufferAlignment	= aCommonPortData.iBufferAlignment;

	// Fill in OMX_PARAM_BUFFERSUPPLIERTYPE

	iParamCompBufferSupplier.nSize			 = sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE);

	iParamCompBufferSupplier.nVersion		 = aCommonPortData.iOmxVersion;

	iParamCompBufferSupplier.nPortIndex		 = aCommonPortData.iPortIndex;

	iParamCompBufferSupplier.eBufferSupplier = aCommonPortData.iBufferSupplier;

	}

EXPORT_C

COmxILPort::~COmxILPort()

	{

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

#ifdef _DEBUG

	const TInt headerCount = iBufferHeaders.Count();

	if (headerCount > 0)

		{

		DEBUG_PRINTF(_L8("COmxILPort::~COmxILPort :: ------------------------------- WARNING ---------------------------------------  "));

		DEBUG_PRINTF2(_L8("COmxILPort::~COmxILPort :: [%d] Buffer headers still exist"), headerCount);

		DEBUG_PRINTF(_L8("COmxILPort::~COmxILPort :: CleanUpPort() may be used from the most derived port class to delete them"));

		DEBUG_PRINTF(_L8("COmxILPort::~COmxILPort :: ------------------------------- WARNING ---------------------------------------  "));

		}

#endif

	iBufferHeaders.Close();

	iBufferMarks.ResetAndDestroy();

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::GetLocalOmxParamIndexes(RArray<TUint>& aIndexArray) const

	{

    DEBUG_PRINTF(_L8("COmxILPort::GetLocalOmxParamIndexes"));

	TInt err = aIndexArray.InsertInOrder(OMX_IndexParamPortDefinition);

	// Note that index duplication is OK.

	if (KErrNone == err || KErrAlreadyExists == err)

		{

		err = aIndexArray.InsertInOrder(OMX_IndexParamCompBufferSupplier);

		}

	if (KErrNone != err && KErrAlreadyExists != err)

		{

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::GetLocalOmxConfigIndexes(RArray<TUint>& /*aIndexArray*/) const

	{

    DEBUG_PRINTF(_L8("COmxILPort::GetLocalOmxConfigIndexes"));

	return OMX_ErrorNone;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::GetParameter(OMX_INDEXTYPE aParamIndex,

						 TAny* apComponentParameterStructure) const

	{

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

	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

	switch(aParamIndex)

		{

	case OMX_IndexParamPortDefinition:

		{

		if (OMX_ErrorNone != (omxRetValue =

							  TOmxILUtil::CheckOmxStructSizeAndVersion(

								  apComponentParameterStructure,

								  sizeof(OMX_PARAM_PORTDEFINITIONTYPE))))

			{

			return omxRetValue;

			}

		OMX_PARAM_PORTDEFINITIONTYPE* pPortDefinition

			= static_cast<OMX_PARAM_PORTDEFINITIONTYPE*>(

				apComponentParameterStructure);

		*pPortDefinition = iParamPortDefinition;

		}

		break;

	case OMX_IndexParamCompBufferSupplier:

		{

		if (OMX_ErrorNone != (omxRetValue =

							  TOmxILUtil::CheckOmxStructSizeAndVersion(

								  apComponentParameterStructure,

								  sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE))))

			{

			return omxRetValue;

			}

		OMX_PARAM_BUFFERSUPPLIERTYPE* pBufferSupplier

			= static_cast<OMX_PARAM_BUFFERSUPPLIERTYPE*>(

				apComponentParameterStructure);

		pBufferSupplier->eBufferSupplier =

			iParamCompBufferSupplier.eBufferSupplier;

		}

		break;

	default:

		{

		return OMX_ErrorUnsupportedIndex;

		}

		};

	return OMX_ErrorNone;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::SetParameter(OMX_INDEXTYPE aParamIndex,

						 const TAny* apComponentParameterStructure,

						 TBool& aUpdateProcessingFunction)

	{

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

	aUpdateProcessingFunction = EFalse;

	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

	switch(aParamIndex)

		{

	case OMX_IndexParamPortDefinition:

		{

		if (OMX_ErrorNone != (omxRetValue =

							  TOmxILUtil::CheckOmxStructSizeAndVersion(

								  const_cast<OMX_PTR>(apComponentParameterStructure),

								  sizeof(OMX_PARAM_PORTDEFINITIONTYPE))))

			{

			return omxRetValue;

			}

		const OMX_PARAM_PORTDEFINITIONTYPE* pPortDefinition

			= static_cast<const OMX_PARAM_PORTDEFINITIONTYPE*>(

				apComponentParameterStructure);

		// Port Format must be set by the concrete port...

		if (OMX_ErrorNone !=

			(omxRetValue =

			 SetFormatInPortDefinition(*pPortDefinition,

									   aUpdateProcessingFunction)))

			{

			return omxRetValue;

			}

		// Set here only the additional read-write parameters of

		// OMX_PARAM_PORTDEFINITIONTYPE

		if (iParamPortDefinition.nBufferCountActual !=

			pPortDefinition->nBufferCountActual)

			{

			if (pPortDefinition->nBufferCountActual <

				iParamPortDefinition.nBufferCountMin)

				{

				return OMX_ErrorBadParameter;

				}

			iParamPortDefinition.nBufferCountActual =

				pPortDefinition->nBufferCountActual;

			aUpdateProcessingFunction = ETrue;

			}

		}

		break;

	case OMX_IndexParamCompBufferSupplier:

		{

		if (OMX_ErrorNone != (omxRetValue =

							  TOmxILUtil::CheckOmxStructSizeAndVersion(

								  const_cast<OMX_PTR>(apComponentParameterStructure),

								  sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE))))

			{

			return omxRetValue;

			}

		const OMX_PARAM_BUFFERSUPPLIERTYPE* pBufferSupplier

			= static_cast<const OMX_PARAM_BUFFERSUPPLIERTYPE*>(

				apComponentParameterStructure);

		// OMX_BufferSupplyOutput is the last of the supported values as of

		// v1.1.1

		if (iParamCompBufferSupplier.eBufferSupplier > OMX_BufferSupplyOutput)

			{

			return OMX_ErrorBadParameter;

			}

		if (iParamCompBufferSupplier.eBufferSupplier !=

			pBufferSupplier->eBufferSupplier)

			{

			// The component providing the input port is responsible for

			// signalling the tunnelled component about the buffer supplier

			// override...

			if (iTunnelledComponent &&

				iParamPortDefinition.eDir == OMX_DirInput)

				{

				OMX_PARAM_BUFFERSUPPLIERTYPE bufferSupplierType;

				bufferSupplierType.nSize		   = sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE);

				bufferSupplierType.nVersion		   = iParamPortDefinition.nVersion;

				bufferSupplierType.nPortIndex	   = iTunnelledPort;

				bufferSupplierType.eBufferSupplier = pBufferSupplier->eBufferSupplier;

				OMX_ERRORTYPE retValue = OMX_ErrorUndefined;

				if (OMX_ErrorNone !=

					(retValue =

					 OMX_SetParameter(iTunnelledComponent,

									  OMX_IndexParamCompBufferSupplier,

									  &bufferSupplierType)) )

					{

					return retValue;

					}

				}

			iParamCompBufferSupplier.eBufferSupplier =

				pBufferSupplier->eBufferSupplier;

			}

		}

		break;

	default:

		{

		return OMX_ErrorUnsupportedIndex;

		}

		};

	return OMX_ErrorNone;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::GetConfig(OMX_INDEXTYPE /*aConfigIndex*/,

					  TAny* /*apComponentConfigStructure*/) const

	{

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

	return OMX_ErrorUnsupportedIndex;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::SetConfig(OMX_INDEXTYPE /*aConfigIndex*/,

					  const TAny* /*apComponentConfigStructure*/,

					  TBool& /*aUpdateProcessingFunction*/)

	{

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

	return OMX_ErrorUnsupportedIndex;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::GetExtensionIndex(OMX_STRING /* aParameterName */,

							  OMX_INDEXTYPE* /* apIndexType */) const

	{

	// This method is intended to be overridden by the concrete ports when

	// needed...

	return OMX_ErrorUnsupportedIndex;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

						   const OMX_PTR apAppPrivate,

						   OMX_U32 aSizeBytes,

						   OMX_U8* apBuffer,

						   TBool& portPopulationCompleted)

	{

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

	portPopulationCompleted = EFalse;

	if(aSizeBytes < iParamPortDefinition.nBufferSize)

		{

		return OMX_ErrorBadParameter;

		}

	// Allocate the buffer header...

	OMX_BUFFERHEADERTYPE* pHeader = new OMX_BUFFERHEADERTYPE;

	*appBufferHdr = pHeader;

	if (!pHeader)

		{

		return OMX_ErrorInsufficientResources;

		}

	// Here, lets discriminate between apBuffer == 0 (AllocateBuffer) and

	// apBuffer != 0 (UseBuffer)

	TUint8* pPortSpecificBuffer = 0;

	OMX_PTR pPortPrivate = 0;

	OMX_PTR pPlatformPrivate = 0;

	OMX_ERRORTYPE portSpecificErr = OMX_ErrorNone;

	if (apBuffer)

		{

		//... (UseBuffer) Do any port-specific wrapping of the received buffer,

		// if needed by the port....

		portSpecificErr = DoBufferWrapping(aSizeBytes,

										   apBuffer,

										   pPortPrivate,

										   pPlatformPrivate,

										   apAppPrivate);

		}

	else

		{

		// ... (AllocateBuffer) Do the port-specific buffer allocation ...

		portSpecificErr = DoBufferAllocation(aSizeBytes,

											 pPortSpecificBuffer,

											 pPortPrivate,

											 pPlatformPrivate,

											 apAppPrivate);

		}

	if (OMX_ErrorNone != portSpecificErr)

		{

		delete *appBufferHdr; *appBufferHdr = 0;

		return portSpecificErr;

		}

	// Add to local list of buffer headers...

	if (KErrNone !=

		iBufferHeaders.Append(

			TBufferInfo(pHeader,

						(apBuffer ?

						 TBufferInfo::EBufferAway :

						 TBufferInfo::EBufferAtHome),

						(apBuffer ?

						 TBufferInfo::EBufferNotOwned :

						 TBufferInfo::EBufferOwned),

						apBuffer,

						apAppPrivate,

						pPlatformPrivate,

						pPortPrivate)))

		{

		// Undo custom buffer allocation/wrapping

		if (apBuffer)

			{

			DoBufferUnwrapping(

				apBuffer,

				pPortPrivate,

				pPlatformPrivate,

				apAppPrivate);

			}

		else

			{

			DoBufferDeallocation(

				pPortSpecificBuffer,

				pPortPrivate,

				pPlatformPrivate,

				apAppPrivate);

			}

		delete *appBufferHdr; *appBufferHdr = NULL;

		return OMX_ErrorInsufficientResources;

		}

	// Fill in the header...

	pHeader->nSize				  = sizeof(OMX_BUFFERHEADERTYPE);

	pHeader->nVersion			  = iParamPortDefinition.nVersion;

	pHeader->pBuffer			  = apBuffer ? apBuffer : pPortSpecificBuffer;

	pHeader->nAllocLen			  = aSizeBytes;

	pHeader->nFilledLen			  = 0;

	pHeader->nOffset			  = 0;

	pHeader->pAppPrivate		  = apAppPrivate;

	pHeader->pPlatformPrivate	  = pPlatformPrivate;

	pHeader->hMarkTargetComponent = 0;

	pHeader->pMarkData			  = 0;

	pHeader->nTickCount			  = 0;

	pHeader->nTimeStamp			  = 0;

	pHeader->nFlags				  = 0;

	if (OMX_DirInput == iParamPortDefinition.eDir)

		{

		pHeader->pInputPortPrivate	= pPortPrivate;

		pHeader->pOutputPortPrivate = 0;

		pHeader->nInputPortIndex	= iParamPortDefinition.nPortIndex;

		pHeader->nOutputPortIndex	= 0;

		}

	else

		{

		pHeader->pInputPortPrivate	= 0;

		pHeader->pOutputPortPrivate = pPortPrivate;

		pHeader->nInputPortIndex	= 0;

		pHeader->nOutputPortIndex	= iParamPortDefinition.nPortIndex;

		}

	if (iParamPortDefinition.nBufferCountActual == iBufferHeaders.Count())

		{

		iParamPortDefinition.bPopulated = OMX_TRUE;

		portPopulationCompleted			= ETrue;

		}

	return OMX_ErrorNone;

	}

EXPORT_C OMX_ERRORTYPE

COmxILPort::FreeBuffer(OMX_BUFFERHEADERTYPE* apBufferHeader,

					   TBool& portDepopulationCompleted)

	{

    DEBUG_PRINTF2(_L8("COmxILPort::FreeBuffer : BUFFER [%X]"), apBufferHeader);

	portDepopulationCompleted = EFalse;

	TInt headerIndex = 0;

	if (KErrNotFound ==

		(headerIndex =

		 iBufferHeaders.Find(TBufferInfo(apBufferHeader),

							 TIdentityRelation<TBufferInfo>(

								 &TBufferInfo::Compare))))

		{

		return OMX_ErrorBadParameter;

		}

	OMX_PTR pPortPrivate =

		OMX_DirInput == iParamPortDefinition.eDir ?

		apBufferHeader->pInputPortPrivate :

		apBufferHeader->pOutputPortPrivate;

	if (iBufferHeaders[headerIndex].IsBufferOwned())

		{

		DoBufferDeallocation(

			apBufferHeader->pBuffer,

			pPortPrivate,

			apBufferHeader->pPlatformPrivate,

			apBufferHeader->pAppPrivate);