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

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

#include "omxilcallbackmanager.h"

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

	/**

	   Static NewL for two-phase construction

	   @param   aProcessingFunction The component's processing function

	   @param   aCallbacks The component's callback manager

	   @param   aOmxVersion The IL Spec version in use

	   @param   aNumberOfAudioPorts Number of audio ports in the component

	   @param   aStartAudioPortNumber The start index for audio ports

	   @param   aNumberOfImagePorts Number of image ports in the component

	   @param   aStartImagePortNumber The start index for image ports

	   @param   aNumberOfVideoPorts Number of video ports in the component

	   @param   aStartVideoPortNumber The start index for video ports

	   @param   aNumberOfOtherPorts Number of other ports in the component

	   @param   aStartOtherPortNumber The start index for other ports

	   @param aImmediateReturnTimeBuffer This only applies to components with a

	   clock client port. Indicates whether the Port Manager must forward an

	   arriving clock buffer to the Callback Manager (ETrue) or to the

	   Processing Function (EFalse) . If the clock buffer is to be forwarded to

	   the Processing Function, this will happen using the BufferIndication

	   function of the component's PF. Otherwise, PF's MediaTimeIndication is

	   used instead.

	*/

COmxILPortManager*

COmxILPortManager::NewL(

	COmxILProcessingFunction& aProcessingFunction,

	MOmxILCallbackManagerIf& aCallbacks,

	const OMX_VERSIONTYPE& aOmxVersion,

	OMX_U32 aNumberOfAudioPorts,

	OMX_U32 aStartAudioPortNumber,

	OMX_U32 aNumberOfImagePorts,

	OMX_U32 aStartImagePortNumber,

	OMX_U32 aNumberOfVideoPorts,

	OMX_U32 aStartVideoPortNumber,

	OMX_U32 aNumberOfOtherPorts,

	OMX_U32 aStartOtherPortNumber,

	OMX_BOOL aImmediateReturnTimeBuffer)

	{

    DEBUG_PRINTF(_L8("COmxILPortManager::NewL"));

	COmxILPortManager* self =

		new (ELeave)COmxILPortManager(

			aProcessingFunction,

			aCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL(aProcessingFunction,

					 aCallbacks,

					 aOmxVersion,

					 aNumberOfAudioPorts,

					 aStartAudioPortNumber,

					 aNumberOfImagePorts,

					 aStartImagePortNumber,

					 aNumberOfVideoPorts,

					 aStartVideoPortNumber,

					 aNumberOfOtherPorts,

					 aStartOtherPortNumber,

					 aImmediateReturnTimeBuffer);

	CleanupStack::Pop(self);

	return self;

	}

void

COmxILPortManager::ConstructL(

	COmxILProcessingFunction& /* aProcessingFunction */,

	MOmxILCallbackManagerIf& /* aCallbacks */,

	const OMX_VERSIONTYPE& aOmxVersion,

	OMX_U32 aNumberOfAudioPorts,

	OMX_U32 aStartAudioPortNumber,

	OMX_U32 aNumberOfImagePorts,

	OMX_U32 aStartImagePortNumber,

	OMX_U32 aNumberOfVideoPorts,

	OMX_U32 aStartVideoPortNumber,

	OMX_U32 aNumberOfOtherPorts,

	OMX_U32 aStartOtherPortNumber,

	OMX_BOOL aImmediateReturnTimeBuffer)

	{

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

	iImmediateReturnTimeBuffer = aImmediateReturnTimeBuffer;

	iAudioParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

	iAudioParamInit.nVersion		 = aOmxVersion;

	iAudioParamInit.nPorts			 = aNumberOfAudioPorts;

	iAudioParamInit.nStartPortNumber = aStartAudioPortNumber;

	iImageParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

	iImageParamInit.nVersion		 = aOmxVersion;

	iImageParamInit.nPorts			 = aNumberOfImagePorts;

	iImageParamInit.nStartPortNumber = aStartImagePortNumber;

	iVideoParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

	iVideoParamInit.nVersion		 = aOmxVersion;

	iVideoParamInit.nPorts			 = aNumberOfVideoPorts;

	iVideoParamInit.nStartPortNumber = aStartVideoPortNumber;

	iOtherParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

	iOtherParamInit.nVersion		 = aOmxVersion;

	iOtherParamInit.nPorts			 = aNumberOfOtherPorts;

	iOtherParamInit.nStartPortNumber = aStartOtherPortNumber;

	InsertParamIndexL(OMX_IndexParamAudioInit);

	InsertParamIndexL(OMX_IndexParamImageInit);

	InsertParamIndexL(OMX_IndexParamVideoInit);

	InsertParamIndexL(OMX_IndexParamOtherInit);

	if(iAudioParamInit.nStartPortNumber != 0)

		{

		User::Leave(KErrArgument);

		}

	if (iImageParamInit.nPorts > 0)

		{

		if (iAudioParamInit.nPorts !=

			iImageParamInit.nStartPortNumber)

			{

			User::Leave(KErrArgument);

			}

		}

	if (iVideoParamInit.nPorts > 0)

		{

		if ((iAudioParamInit.nPorts +

			 iImageParamInit.nPorts)  !=

			iVideoParamInit.nStartPortNumber)

			{

			User::Leave(KErrArgument);

			}

		}

	if (iOtherParamInit.nPorts > 0)

		{

		if ((iAudioParamInit.nPorts +

			 iImageParamInit.nPorts +

			 iVideoParamInit.nPorts)  !=

			iOtherParamInit.nStartPortNumber)

			{

			User::Leave(KErrArgument);

			}

		}

	}

COmxILPortManager::COmxILPortManager(

	COmxILProcessingFunction& aProcessingFunction,

	MOmxILCallbackManagerIf& aCallbacks)

	:

	iProcessingFunction(aProcessingFunction),

	iCallbacks(aCallbacks),

	iAllPorts()

	{

    DEBUG_PRINTF(_L8("COmxILPortManager::COmxILPortManager"));

	}

COmxILPortManager::~COmxILPortManager()

	{

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

	iAllPorts.ResetAndDestroy();

	iTimePorts.Close();

	}

void

COmxILPortManager::AppendPortL(const COmxILPort* aPort)

	{

    DEBUG_PRINTF(_L8("COmxILPortManager::AppendPort"));

	const TInt portCount = iAllPorts.Count();

	OMX_PORTDOMAINTYPE portDomain = aPort->Domain();

	OMX_U32 startPortNumber = 0;

	TBool timePort = EFalse;

	switch(portDomain)

		{

	case OMX_PortDomainAudio:

		{

		__ASSERT_ALWAYS(portCount >= 0,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		__ASSERT_ALWAYS(portCount < iAudioParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		startPortNumber = iAudioParamInit.nStartPortNumber;

		}

		break;

	case OMX_PortDomainImage:

		{

		__ASSERT_ALWAYS(portCount >= iAudioParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		__ASSERT_ALWAYS(portCount <

						iAudioParamInit.nPorts +

						iImageParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		startPortNumber = iImageParamInit.nStartPortNumber;

		}

		break;

	case OMX_PortDomainVideo:

		{

		__ASSERT_ALWAYS(portCount >=

						iAudioParamInit.nPorts +

						iImageParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		__ASSERT_ALWAYS(portCount <

						iAudioParamInit.nPorts +

						iImageParamInit.nPorts +

						iVideoParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		startPortNumber = iVideoParamInit.nStartPortNumber;

		}

		break;

	case OMX_PortDomainOther:

		{

		__ASSERT_ALWAYS(portCount >=

						iAudioParamInit.nPorts +

						iImageParamInit.nPorts +

						iVideoParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		__ASSERT_ALWAYS(portCount <

						iAudioParamInit.nPorts +

						iImageParamInit.nPorts +

						iVideoParamInit.nPorts +

						iOtherParamInit.nPorts,

						User::Panic(KOmxILPortManagerPanicCategory, 1));

		startPortNumber = iOtherParamInit.nStartPortNumber;

		OMX_OTHER_PARAM_PORTFORMATTYPE paramFormat;

		paramFormat.nSize = sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE);

		paramFormat.nVersion = TOmxILSpecVersion();

		paramFormat.nPortIndex = aPort->Index();

		paramFormat.nIndex = 0;

		if ((aPort->GetParameter(OMX_IndexParamOtherPortFormat, &paramFormat) == OMX_ErrorNone) &&

			paramFormat.eFormat == OMX_OTHER_FormatTime)

			{

			timePort = ETrue;	

			}

		}

		break;

	default:

		{

		User::Panic(KOmxILPortManagerPanicCategory, 1);

		}

		};

	if(portCount ==  startPortNumber)

		{

		iAllPorts.AppendL(aPort);

		}

	else

		{

		for (TInt i=startPortNumber; i<portCount; ++i)

			{

			if (iAllPorts[i]->Index() >= aPort->Index())

				{

				User::Panic(KOmxILPortManagerPanicCategory, 1);

				}

			}

		iAllPorts.AppendL(aPort);

		}

    TRAPD(err, iTimePorts.AppendL(timePort));

    if (KErrNone != err)

        {

        iAllPorts.Remove(iAllPorts.Count()-1);

        User::Leave(err);

        }

 	}

void COmxILPortManager::RemoveLastAppendedPort()

	{

	if (iAllPorts.Count()>0 && iTimePorts.Count()>0)

		{

		iAllPorts.Remove(iAllPorts.Count()-1);

		iTimePorts.Remove(iTimePorts.Count()-1);	

		}

	}

/**

  This method is used at component's construction time, i.e., in a factory

  method of the component. The main component object uses this method to add

  the component's ports to its port manager instance.

   @param aPort The port instance to be added.

   @param aDirection The direction of the port being added.

   @ return A Symbian error code indicating if the function call was

   successful.  KErrNone on success, otherwise another of the system-wide error

   codes.

*/

TInt

COmxILPortManager::AddPort(const COmxILPort* aPort,

						   OMX_DIRTYPE aDirection)

	{

    DEBUG_PRINTF(_L8("COmxILPortManager::AddPort"));

	__ASSERT_ALWAYS(aPort, User::Panic(KOmxILPortManagerPanicCategory, 1));

	if (iAllPorts.Count() >= (iAudioParamInit.nPorts +

							  iVideoParamInit.nPorts +

							  iImageParamInit.nPorts +

							  iOtherParamInit.nPorts))

		{

		return KErrArgument;

		}

	if (aPort->Direction() != aDirection)

		{

		return KErrArgument;

		}

	if (iAllPorts.Find(aPort) != KErrNotFound)

		{

		return KErrArgument;

		}

	OMX_ERRORTYPE omxRetValue =

		aPort->GetLocalOmxParamIndexes(ManagedParamIndexes());

	if (OMX_ErrorNone == omxRetValue)

		{

		omxRetValue = aPort->GetLocalOmxConfigIndexes(ManagedConfigIndexes());

		}

	if (OMX_ErrorNone != omxRetValue)

		{

		if (OMX_ErrorInsufficientResources == omxRetValue)

			{

			return KErrNoMemory;

			}

		else

			{

			return KErrGeneral;

			}

		}

	TRAPD(err, AppendPortL(aPort));

	if (KErrNone != err)

		{

		return err;

		}

	// Here, let's register this port into the call back manager so buffer

	// marks can be propagated to the right port...

	const OMX_U32 propagationPortIndex = aPort->BufferMarkPropagationPort();

	if (propagationPortIndex != COmxILPort::KBufferMarkPropagationPortNotNeeded)

		{

		omxRetValue = iCallbacks.RegisterBufferMarkPropagationPort(aPort->Index(),

													 propagationPortIndex);

		}

	err = KErrNone;

	if (OMX_ErrorNone != omxRetValue)

		{

		RemoveLastAppendedPort();

		switch (omxRetValue)

				{

			case OMX_ErrorInsufficientResources:

				{

				err = KErrNoMemory;

				}

				break;

			default:

				{

				err = KErrGeneral;

				}

				};

		}

	return err;

	}

TBool

COmxILPortManager::RemoveBuffersFromPfOrCm(

	COmxILPort* apPort, OMX_BOOL aRemoveFromPfOnly /* = OMX_FALSE */) const

	{

	__ASSERT_DEBUG(apPort, User::Panic(KOmxILPortManagerPanicCategory, 1));

    DEBUG_PRINTF3(_L8("COmxILPortManager::RemoveBuffersFromPfOrCm: PORT[%d] aRemoveFromPfOnly[%s] "),

				  apPort->Index(), aRemoveFromPfOnly ? "TRUE" : "FALSE");

	const TInt headerCount = apPort->Count();

	OMX_BUFFERHEADERTYPE* pHeader = 0;

	TBool allHeadersRemovedFromPf = ETrue;

	for (TInt j=0; j<headerCount; ++j)

		{

		pHeader = (*apPort)[j];

		if (!apPort->IsBufferAtHome(pHeader))

			{

			// Tell the PF to remove this header from its queues...

			if (!iProcessingFunction.BufferRemovalIndication(

					pHeader,

					apPort->Direction()))

				{

				if (OMX_FALSE == aRemoveFromPfOnly)

					{

					if (!iCallbacks.BufferRemovalIndication(

							pHeader,

							apPort->Direction()))

						{

						allHeadersRemovedFromPf = EFalse;

						}

					else

						{

						apPort->SetBufferReturned(pHeader);

						// Make sure the buffer contents are cleared

						TOmxILUtil::ClearBufferContents(pHeader);

						}

					}

				}

			else

				{

				apPort->SetBufferReturned(pHeader);

				// Make sure the buffer contents are cleared

				TOmxILUtil::ClearBufferContents(pHeader);

				}

			}

		}

	return allHeadersRemovedFromPf;

	}

OMX_ERRORTYPE

COmxILPortManager::GetParameter(OMX_INDEXTYPE aParamIndex,

								TAny* apComponentParameterStructure) const

	{

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

	TInt index = FindParamIndex(aParamIndex);

	if (KErrNotFound == index)

		{

		return OMX_ErrorUnsupportedIndex;

		}

	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

	switch(aParamIndex)

		{

	case OMX_IndexParamAudioInit:

	case OMX_IndexParamImageInit:

	case OMX_IndexParamVideoInit:

	case OMX_IndexParamOtherInit:

		{

		if (OMX_ErrorNone !=

			(omxRetValue =

			 TOmxILUtil::CheckOmxStructSizeAndVersion(

				 const_cast<OMX_PTR>(apComponentParameterStructure),

				 sizeof(OMX_PORT_PARAM_TYPE))))

			{

			return omxRetValue;

			}

		OMX_PORT_PARAM_TYPE*

			pPortParamType

			= static_cast<OMX_PORT_PARAM_TYPE*>(

				apComponentParameterStructure);

		switch(aParamIndex)

			{

		case OMX_IndexParamAudioInit:

			*pPortParamType = iAudioParamInit;

			break;

		case OMX_IndexParamImageInit:

			*pPortParamType = iImageParamInit;

			break;

		case OMX_IndexParamVideoInit:

			*pPortParamType = iVideoParamInit;

			break;

		case OMX_IndexParamOtherInit:

			*pPortParamType = iOtherParamInit;

			break;

			}

		}

		break;

	default: