// Copyright (c) 2010 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 "omxilportimpl.h"

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

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

const TInt COmxILPortImpl::KMaxBufferMarksQueueSize;

COmxILPortImpl* COmxILPortImpl::NewL(const TOmxILCommonPortData& aCommonPortData, COmxILPort& aPort)

	{

	COmxILPortImpl* self = new (ELeave) COmxILPortImpl(aCommonPortData, aPort);

	return self;	

	}

COmxILPortImpl::COmxILPortImpl(const TOmxILCommonPortData& aCommonPortData, COmxILPort& aPort)

	:

	iTunnelledComponent(0),

	iTunnelledPort(0),

	iBufferHeaders(),

	iBufferMarks(_FOFF(TBufferMarkInfo, iLink)),

	iTransitionState(EPortNotTransitioning),

	iBufferMarkPropagationPortIndex(aCommonPortData.iBufferMarkPropagationPortIndex),

	aFirstUseBufferHasBeenReceived(OMX_FALSE),

	iOmxILPort(aPort)

	{

    DEBUG_PRINTF(_L8("COmxILPortImpl::COmxILPortImpl"));

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

	}

COmxILPortImpl::~COmxILPortImpl()

	{

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

#ifdef _DEBUG

	const TInt headerCount = iBufferHeaders.Count();

	if (headerCount > 0)

		{

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

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

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

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

		}

#endif

	iBufferHeaders.Close();

	iBufferMarks.ResetAndDestroy();

	}

OMX_ERRORTYPE

COmxILPortImpl::GetParameter(OMX_INDEXTYPE aParamIndex,

						 TAny* apComponentParameterStructure) const

	{

    DEBUG_PRINTF(_L8("COmxILPortImpl::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;

	}

OMX_ERRORTYPE

COmxILPortImpl::SetParameter(OMX_INDEXTYPE aParamIndex,

						 const TAny* apComponentParameterStructure,

						 TBool& aUpdateProcessingFunction)

	{

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

	aUpdateProcessingFunction = EFalse;

	if (OMX_TRUE == aFirstUseBufferHasBeenReceived)

		{

		DEBUG_PRINTF2(_L8("COmxILPortImpl::SetParameter : PORT [%u] WARNING : port population already initiated, returning OMX_ErrorIncorrectStateOperation"), Index());

		// SetParameter is not allowed after the first OMX_UseBuffer has been

		// received in the port, that is, the population of the port has

		// already been initiated...

		return OMX_ErrorIncorrectStateOperation;

		}

	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 =

			 iOmxILPort.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;

				}

			DEBUG_PRINTF3(_L8("COmxILPortImpl::SetParameter : old.nBufferCountActual [%u] new.nBufferCountActual [%u]"),

						  iParamPortDefinition.nBufferCountActual, pPortDefinition->nBufferCountActual);

			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;

					}

				}

			DEBUG_PRINTF3(_L8("COmxILPortImpl::SetParameter : old.eBufferSupplier [%u] new.eBufferSupplier [%u]"),

						  iParamCompBufferSupplier.eBufferSupplier, pBufferSupplier->eBufferSupplier);

			iParamCompBufferSupplier.eBufferSupplier =

				pBufferSupplier->eBufferSupplier;

			}

		}

		break;

	default:

		{

		return OMX_ErrorUnsupportedIndex;

		}

		};

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILPortImpl::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

						   const OMX_PTR apAppPrivate,

						   OMX_U32 aSizeBytes,

						   OMX_U8* apBuffer,

						   TBool& portPopulationCompleted)

	{

	DEBUG_PRINTF3(_L8("COmxILPort::PopulateBuffer : pBuffer[%X] PORT[%u]"), apBuffer, iParamPortDefinition.nPortIndex);

	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;

		}

    DEBUG_PRINTF2(_L8("COmxILPortImpl::PopulateBuffer : BUFFER [%X]"), pHeader);

	// 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 = iOmxILPort.DoBufferWrapping(aSizeBytes,

										   apBuffer,

										   pPortPrivate,

										   pPlatformPrivate,

										   apAppPrivate);

		aFirstUseBufferHasBeenReceived = OMX_TRUE;

		}

	else

		{

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

		portSpecificErr = iOmxILPort.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)

			{

			iOmxILPort.DoBufferUnwrapping(

				apBuffer,

				pPortPrivate,

				pPlatformPrivate,

				apAppPrivate);

			}

		else

			{

			iOmxILPort.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;

	}

OMX_ERRORTYPE

COmxILPortImpl::FreeBuffer(OMX_BUFFERHEADERTYPE* apBufferHeader,

					   TBool& portDepopulationCompleted)

	{

    DEBUG_PRINTF2(_L8("COmxILPortImpl::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())

		{

		iOmxILPort.DoBufferDeallocation(

			apBufferHeader->pBuffer,

			pPortPrivate,

			apBufferHeader->pPlatformPrivate,

			apBufferHeader->pAppPrivate);

		}

	else

		{

		iOmxILPort.DoBufferUnwrapping(

			apBufferHeader->pBuffer,

			pPortPrivate,

			apBufferHeader->pPlatformPrivate,

			apBufferHeader->pAppPrivate);

		}

	delete apBufferHeader;

	iBufferHeaders.Remove(headerIndex);

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

		{

		iParamPortDefinition.bPopulated = OMX_FALSE;

		}

	if (0 == iBufferHeaders.Count())

		{

		portDepopulationCompleted = ETrue;

		aFirstUseBufferHasBeenReceived = OMX_FALSE;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILPortImpl::TunnelRequest(OMX_HANDLETYPE aTunneledComp,

						  OMX_U32 aTunneledPort,

						  OMX_TUNNELSETUPTYPE* apTunnelSetup)

	{

    DEBUG_PRINTF(_L8("COmxILPortImpl::TunnelRequest"));

	// Check whether the tunnel is being torn down

	if (!aTunneledComp)

		{

		// Cancel existing tunnel setup, if any

		iTunnelledComponent = 0;

		return OMX_ErrorNone;

		}

	// Check that we are receiving a valid tunnel setup structure

	if (!apTunnelSetup)

		{

		return OMX_ErrorBadParameter;

		}

	// STEP 0: Retrieve the port definition from the tunnelled component...

	OMX_PARAM_PORTDEFINITIONTYPE paramPortDef;

	paramPortDef.nSize		= sizeof(OMX_PARAM_PORTDEFINITIONTYPE);

	paramPortDef.nVersion	= iParamPortDefinition.nVersion;

	paramPortDef.nPortIndex = aTunneledPort;

	if (OMX_ErrorNone !=

		OMX_GetParameter(aTunneledComp,

						 OMX_IndexParamPortDefinition,

						 &paramPortDef) )

		{

		return OMX_ErrorUndefined;

		}

	if (OMX_DirOutput == iParamPortDefinition.eDir)

		{

		// OMX_DirOutput

		//

		// Step 1: Check that this output port is being tunnelled to an input

		// port...

		if (paramPortDef.eDir != OMX_DirInput)

			{

			return OMX_ErrorPortsNotCompatible;

			}

		// Step 2: Fill in the tunnel setup structure received...

		apTunnelSetup->nTunnelFlags = 0;

		apTunnelSetup->eSupplier	= iParamCompBufferSupplier.eBufferSupplier;