1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 /**

    18  @file

    19  @internalComponent

    20 */

    21 

    22 #include "log.h"

    23 #include "omxilportmanager.h"

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

    25 #include "omxilcallbackmanager.h"

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

    27 

    28 	/**

    29 	   Static NewL for two-phase construction

    30 

    31 	   @param   aProcessingFunction The component's processing function

    32 

    33 	   @param   aCallbacks The component's callback manager

    34 

    35 	   @param   aOmxVersion The IL Spec version in use

    36 

    37 	   @param   aNumberOfAudioPorts Number of audio ports in the component

    38 

    39 	   @param   aStartAudioPortNumber The start index for audio ports

    40 

    41 	   @param   aNumberOfImagePorts Number of image ports in the component

    42 

    43 	   @param   aStartImagePortNumber The start index for image ports

    44 

    45 	   @param   aNumberOfVideoPorts Number of video ports in the component

    46 

    47 	   @param   aStartVideoPortNumber The start index for video ports

    48 

    49 	   @param   aNumberOfOtherPorts Number of other ports in the component

    50 

    51 	   @param   aStartOtherPortNumber The start index for other ports

    52 

    53 	   @param aImmediateReturnTimeBuffer This only applies to components with a

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

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

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

    57 	   the Processing Function, this will happen using the BufferIndication

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

    59 	   used instead.

    60 	*/

    61 COmxILPortManager*

    62 COmxILPortManager::NewL(

    63 	COmxILProcessingFunction& aProcessingFunction,

    64 	MOmxILCallbackManagerIf& aCallbacks,

    65 	const OMX_VERSIONTYPE& aOmxVersion,

    66 	OMX_U32 aNumberOfAudioPorts,

    67 	OMX_U32 aStartAudioPortNumber,

    68 	OMX_U32 aNumberOfImagePorts,

    69 	OMX_U32 aStartImagePortNumber,

    70 	OMX_U32 aNumberOfVideoPorts,

    71 	OMX_U32 aStartVideoPortNumber,

    72 	OMX_U32 aNumberOfOtherPorts,

    73 	OMX_U32 aStartOtherPortNumber,

    74 	OMX_BOOL aImmediateReturnTimeBuffer)

    75 	{

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

    77 

    78 	COmxILPortManager* self =

    79 		new (ELeave)COmxILPortManager(

    80 			aProcessingFunction,

    81 			aCallbacks);

    82 

    83 	CleanupStack::PushL(self);

    84 	self->ConstructL(aProcessingFunction,

    85 					 aCallbacks,

    86 					 aOmxVersion,

    87 					 aNumberOfAudioPorts,

    88 					 aStartAudioPortNumber,

    89 					 aNumberOfImagePorts,

    90 					 aStartImagePortNumber,

    91 					 aNumberOfVideoPorts,

    92 					 aStartVideoPortNumber,

    93 					 aNumberOfOtherPorts,

    94 					 aStartOtherPortNumber,

    95 					 aImmediateReturnTimeBuffer);

    96 	CleanupStack::Pop(self);

    97 	return self;

    98 	}

    99 

   100 void

   101 COmxILPortManager::ConstructL(

   102 	COmxILProcessingFunction& /* aProcessingFunction */,

   103 	MOmxILCallbackManagerIf& /* aCallbacks */,

   104 	const OMX_VERSIONTYPE& aOmxVersion,

   105 	OMX_U32 aNumberOfAudioPorts,

   106 	OMX_U32 aStartAudioPortNumber,

   107 	OMX_U32 aNumberOfImagePorts,

   108 	OMX_U32 aStartImagePortNumber,

   109 	OMX_U32 aNumberOfVideoPorts,

   110 	OMX_U32 aStartVideoPortNumber,

   111 	OMX_U32 aNumberOfOtherPorts,

   112 	OMX_U32 aStartOtherPortNumber,

   113 	OMX_BOOL aImmediateReturnTimeBuffer)

   114 	{

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

   116 

   117 	iImmediateReturnTimeBuffer = aImmediateReturnTimeBuffer;

   118 

   119 	iAudioParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   120 	iAudioParamInit.nVersion		 = aOmxVersion;

   121 	iAudioParamInit.nPorts			 = aNumberOfAudioPorts;

   122 	iAudioParamInit.nStartPortNumber = aStartAudioPortNumber;

   123 

   124 	iImageParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   125 	iImageParamInit.nVersion		 = aOmxVersion;

   126 	iImageParamInit.nPorts			 = aNumberOfImagePorts;

   127 	iImageParamInit.nStartPortNumber = aStartImagePortNumber;

   128 

   129 	iVideoParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   130 	iVideoParamInit.nVersion		 = aOmxVersion;

   131 	iVideoParamInit.nPorts			 = aNumberOfVideoPorts;

   132 	iVideoParamInit.nStartPortNumber = aStartVideoPortNumber;

   133 

   134 	iOtherParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   135 	iOtherParamInit.nVersion		 = aOmxVersion;

   136 	iOtherParamInit.nPorts			 = aNumberOfOtherPorts;

   137 	iOtherParamInit.nStartPortNumber = aStartOtherPortNumber;

   138 

   139 

   140 	InsertParamIndexL(OMX_IndexParamAudioInit);

   141 	InsertParamIndexL(OMX_IndexParamImageInit);

   142 	InsertParamIndexL(OMX_IndexParamVideoInit);

   143 	InsertParamIndexL(OMX_IndexParamOtherInit);

   144 

   145 

   146 	if(iAudioParamInit.nStartPortNumber != 0)

   147 		{

   148 		User::Leave(KErrArgument);

   149 		}

   150 

   151 	if (iImageParamInit.nPorts > 0)

   152 		{

   153 		if (iAudioParamInit.nPorts !=

   154 			iImageParamInit.nStartPortNumber)

   155 			{

   156 			User::Leave(KErrArgument);

   157 			}

   158 		}

   159 

   160 	if (iVideoParamInit.nPorts > 0)

   161 		{

   162 		if ((iAudioParamInit.nPorts +

   163 			 iImageParamInit.nPorts)  !=

   164 			iVideoParamInit.nStartPortNumber)

   165 			{

   166 			User::Leave(KErrArgument);

   167 			}

   168 		}

   169 

   170 	if (iOtherParamInit.nPorts > 0)

   171 		{

   172 		if ((iAudioParamInit.nPorts +

   173 			 iImageParamInit.nPorts +

   174 			 iVideoParamInit.nPorts)  !=

   175 			iOtherParamInit.nStartPortNumber)

   176 			{

   177 			User::Leave(KErrArgument);

   178 			}

   179 		}

   180 

   181 	}

   182 

   183 COmxILPortManager::COmxILPortManager(

   184 	COmxILProcessingFunction& aProcessingFunction,

   185 	MOmxILCallbackManagerIf& aCallbacks)

   186 	:

   187 	iProcessingFunction(aProcessingFunction),

   188 	iCallbacks(aCallbacks),

   189 	iAllPorts()

   190 	{

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

   192 

   193 	}

   194 

   195 COmxILPortManager::~COmxILPortManager()

   196 	{

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

   198 	iAllPorts.ResetAndDestroy();

   199 	iTimePorts.Close();

   200 	}

   201 

   202 void

   203 COmxILPortManager::AppendPortL(const COmxILPort* aPort)

   204 	{

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

   206 

   207 	const TInt portCount = iAllPorts.Count();

   208 	OMX_PORTDOMAINTYPE portDomain = aPort->Domain();

   209 	OMX_U32 startPortNumber = 0;

   210 	TBool timePort = EFalse;

   211 	

   212 	switch(portDomain)

   213 		{

   214 	case OMX_PortDomainAudio:

   215 		{

   216 		__ASSERT_ALWAYS(portCount >= 0,

   217 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   218 		__ASSERT_ALWAYS(portCount < iAudioParamInit.nPorts,

   219 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   220 

   221 		startPortNumber = iAudioParamInit.nStartPortNumber;

   222 

   223 		}

   224 		break;

   225 

   226 	case OMX_PortDomainImage:

   227 		{

   228 		__ASSERT_ALWAYS(portCount >= iAudioParamInit.nPorts,

   229 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   230 		__ASSERT_ALWAYS(portCount <

   231 						iAudioParamInit.nPorts +

   232 						iImageParamInit.nPorts,

   233 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   234 

   235 		startPortNumber = iImageParamInit.nStartPortNumber;

   236 

   237 		}

   238 		break;

   239 

   240 	case OMX_PortDomainVideo:

   241 		{

   242 		__ASSERT_ALWAYS(portCount >=

   243 						iAudioParamInit.nPorts +

   244 						iImageParamInit.nPorts,

   245 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   246 		__ASSERT_ALWAYS(portCount <

   247 						iAudioParamInit.nPorts +

   248 						iImageParamInit.nPorts +

   249 						iVideoParamInit.nPorts,

   250 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   251 

   252 		startPortNumber = iVideoParamInit.nStartPortNumber;

   253 

   254 		}

   255 		break;

   256 

   257 

   258 	case OMX_PortDomainOther:

   259 		{

   260 		__ASSERT_ALWAYS(portCount >=

   261 						iAudioParamInit.nPorts +

   262 						iImageParamInit.nPorts +

   263 						iVideoParamInit.nPorts,

   264 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   265 		__ASSERT_ALWAYS(portCount <

   266 						iAudioParamInit.nPorts +

   267 						iImageParamInit.nPorts +

   268 						iVideoParamInit.nPorts +

   269 						iOtherParamInit.nPorts,

   270 						User::Panic(KOmxILPortManagerPanicCategory, 1));

   271 

   272 		startPortNumber = iOtherParamInit.nStartPortNumber;

   273 		

   274 		OMX_OTHER_PARAM_PORTFORMATTYPE paramFormat;

   275 		paramFormat.nSize = sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE);

   276 		paramFormat.nVersion = TOmxILSpecVersion();

   277 		paramFormat.nPortIndex = aPort->Index();

   278 		paramFormat.nIndex = 0;

   279 

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

   281 			paramFormat.eFormat == OMX_OTHER_FormatTime)

   282 			{

   283 			timePort = ETrue;	

   284 			}

   285 		}

   286 		

   287 		break;

   288 

   289 	default:

   290 		{

   291 		User::Panic(KOmxILPortManagerPanicCategory, 1);

   292 		}

   293 		};

   294 

   295 	if(portCount ==  startPortNumber)

   296 		{

   297 		iAllPorts.AppendL(aPort);

   298 		}

   299 	else

   300 		{

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

   302 			{

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

   304 				{

   305 				User::Panic(KOmxILPortManagerPanicCategory, 1);

   306 				}

   307 			}

   308 		iAllPorts.AppendL(aPort);

   309 		}

   310 

   311 	

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

   313     if (KErrNone != err)

   314         {

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

   316         User::Leave(err);

   317         }

   318  	}

   319  

   320 void COmxILPortManager::RemoveLastAppendedPort()

   321 	{

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

   323 		{

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

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

   326 		}

   327 	}

   328 

   329 

   330 /**

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

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

   333   the component's ports to its port manager instance.

   334 

   335    @param aPort The port instance to be added.

   336 

   337    @param aDirection The direction of the port being added.

   338 

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

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

   341    codes.

   342 */

   343 TInt

   344 COmxILPortManager::AddPort(const COmxILPort* aPort,

   345 						   OMX_DIRTYPE aDirection)

   346 	{

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

   348 

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

   350 

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

   352 							  iVideoParamInit.nPorts +

   353 							  iImageParamInit.nPorts +

   354 							  iOtherParamInit.nPorts))

   355 		{

   356 		return KErrArgument;

   357 		}

   358 

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

   360 		{

   361 		return KErrArgument;

   362 		}

   363 

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

   365 		{

   366 		return KErrArgument;

   367 		}

   368 

   369 	OMX_ERRORTYPE omxRetValue =

   370 		aPort->GetLocalOmxParamIndexes(ManagedParamIndexes());

   371 	if (OMX_ErrorNone == omxRetValue)

   372 		{

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

   374 		}

   375 

   376 	if (OMX_ErrorNone != omxRetValue)

   377 		{

   378 		if (OMX_ErrorInsufficientResources == omxRetValue)

   379 			{

   380 			return KErrNoMemory;

   381 			}

   382 		else

   383 			{

   384 			return KErrGeneral;

   385 			}

   386 		}

   387 		

   388 	TRAPD(err, AppendPortL(aPort));

   389 	if (KErrNone != err)

   390 		{

   391 		return err;

   392 		}

   393 		

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

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

   396 	const OMX_U32 propagationPortIndex = aPort->BufferMarkPropagationPort();

   397 	if (propagationPortIndex != COmxILPort::KBufferMarkPropagationPortNotNeeded)

   398 		{

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

   400 													 propagationPortIndex);

   401 		}

   402 

   403 	err = KErrNone;

   404 	if (OMX_ErrorNone != omxRetValue)

   405 		{

   406 		RemoveLastAppendedPort();

   407 		switch (omxRetValue)

   408 				{

   409 			case OMX_ErrorInsufficientResources:

   410 				{

   411 				err = KErrNoMemory;

   412 				}

   413 				break;

   414 			default:

   415 				{

   416 				err = KErrGeneral;

   417 				}

   418 				};

   419 		}

   420 

   421 	return err;

   422 

   423 	}

   424 

   425 TBool

   426 COmxILPortManager::RemoveBuffersFromPfOrCm(

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

   428 	{

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

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

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

   432 

   433 	const TInt headerCount = apPort->Count();

   434 	OMX_BUFFERHEADERTYPE* pHeader = 0;

   435 	TBool allHeadersRemovedFromPf = ETrue;

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

   437 		{

   438 		pHeader = (*apPort)[j];

   439 		if (!apPort->IsBufferAtHome(pHeader))

   440 			{

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

   442 			if (!iProcessingFunction.BufferRemovalIndication(

   443 					pHeader,

   444 					apPort->Direction()))

   445 				{

   446 				if (OMX_FALSE == aRemoveFromPfOnly)

   447 					{

   448 					if (!iCallbacks.BufferRemovalIndication(

   449 							pHeader,

   450 							apPort->Direction()))

   451 						{

   452 						allHeadersRemovedFromPf = EFalse;

   453 						}

   454 					else

   455 						{

   456 						apPort->SetBufferReturned(pHeader);

   457 						// Make sure the buffer contents are cleared

   458 						TOmxILUtil::ClearBufferContents(pHeader);

   459 						}

   460 					}

   461 				}

   462 			else

   463 				{

   464 				apPort->SetBufferReturned(pHeader);

   465 				// Make sure the buffer contents are cleared

   466 				TOmxILUtil::ClearBufferContents(pHeader);

   467 				}

   468 			}

   469 		}

   470 

   471 	return allHeadersRemovedFromPf;

   472 

   473 	}

   474 

   475 OMX_ERRORTYPE

   476 COmxILPortManager::GetParameter(OMX_INDEXTYPE aParamIndex,

   477 								TAny* apComponentParameterStructure) const

   478 	{

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

   480 

   481 	TInt index = FindParamIndex(aParamIndex);

   482 	if (KErrNotFound == index)

   483 		{

   484 		return OMX_ErrorUnsupportedIndex;

   485 		}

   486 

   487 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   488 	switch(aParamIndex)

   489 		{

   490 	case OMX_IndexParamAudioInit:

   491 	case OMX_IndexParamImageInit:

   492 	case OMX_IndexParamVideoInit:

   493 	case OMX_IndexParamOtherInit:

   494 		{

   495 		if (OMX_ErrorNone !=

   496 			(omxRetValue =

   497 			 TOmxILUtil::CheckOmxStructSizeAndVersion(

   498 				 const_cast<OMX_PTR>(apComponentParameterStructure),

   499 				 sizeof(OMX_PORT_PARAM_TYPE))))

   500 			{

   501 			return omxRetValue;

   502 			}

   503 

   504 		OMX_PORT_PARAM_TYPE*

   505 			pPortParamType

   506 			= static_cast<OMX_PORT_PARAM_TYPE*>(

   507 				apComponentParameterStructure);

   508 

   509 		switch(aParamIndex)

   510 			{

   511 		case OMX_IndexParamAudioInit:

   512 			*pPortParamType = iAudioParamInit;

   513 			break;

   514 		case OMX_IndexParamImageInit:

   515 			*pPortParamType = iImageParamInit;

   516 			break;

   517 		case OMX_IndexParamVideoInit:

   518 			*pPortParamType = iVideoParamInit;

   519 			break;

   520 		case OMX_IndexParamOtherInit:

   521 			*pPortParamType = iOtherParamInit;

   522 			break;

   523 			}

   524 

   525 		}

   526 		break;

   527 

   528 	default:

   529 		{

   530 		// Obtain the port index

   531 		OMX_U32 portIndex;

   532 		if (OMX_ErrorNone != GetPortIndexFromOmxStruct(

   533 				apComponentParameterStructure,

   534 				portIndex))

   535 			{

   536 			return OMX_ErrorBadPortIndex;

   537 			}

   538 

   539 		// Now delegate to the specific port

   540 		return iAllPorts[portIndex]->GetParameter(

   541 			aParamIndex,

   542 			apComponentParameterStructure);

   543 		}

   544 		};

   545 

   546 	return OMX_ErrorNone;

   547 

   548 	}

   549 

   550 OMX_ERRORTYPE

   551 COmxILPortManager::SetParameter(OMX_INDEXTYPE aParamIndex,

   552 								const TAny* apComponentParameterStructure,

   553 								OMX_BOOL aPortIsDisabled /* = OMX_FALSE */ )

   554 	{

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

   556 

   557 	TInt index = FindParamIndex(aParamIndex);

   558 	if (KErrNotFound == index)

   559 		{

   560 		return OMX_ErrorUnsupportedIndex;

   561 		}

   562 

   563 	// Obtain the port index

   564 	OMX_U32 portIndex;

   565 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(

   566 			apComponentParameterStructure,

   567 			portIndex))

   568 		{

   569 		return OMX_ErrorBadPortIndex;

   570 		}

   571 

   572     DEBUG_PRINTF2(_L8("COmxILPortManager::SetParameter : PORT[%u]"), portIndex);

   573 

   574 	// Grab the port here...

   575 	COmxILPort* pPort = iAllPorts[portIndex];

   576 

   577 	if (OMX_TRUE == aPortIsDisabled &&

   578 		pPort->IsEnabled() &&

   579 		!pPort->IsTransitioningToEnabled())

   580 		{

   581 		// There is an indication from the FSM that the port must be disabled,

   582 		// otherwise, this is not allowed in the current state.

   583 		return OMX_ErrorIncorrectStateOperation;

   584 		}

   585 

   586 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   587 	switch(aParamIndex)

   588 		{

   589 	case OMX_IndexParamAudioInit:

   590 	case OMX_IndexParamVideoInit:

   591 	case OMX_IndexParamImageInit:

   592 	case OMX_IndexParamOtherInit:

   593 		{

   594 		// Don't allow changes in the OMX_PORT_PARAM_TYPE structure

   595 		return OMX_ErrorUnsupportedIndex;

   596 		}

   597 	default:

   598 		{

   599 		TBool updateProcessingFunction = EFalse;

   600 		omxRetValue =

   601 			pPort->SetParameter(

   602 				aParamIndex,

   603 				apComponentParameterStructure,

   604 				updateProcessingFunction);

   605 

   606 		if (OMX_ErrorNone == omxRetValue)

   607 			{

   608 			if (updateProcessingFunction)

   609 				{

   610 				omxRetValue = iProcessingFunction.ParamIndication(

   611 					aParamIndex,

   612 					apComponentParameterStructure);

   613 				}

   614 			}

   615 

   616 		}

   617 		};

   618 

   619 	return omxRetValue;

   620 

   621 	}

   622 

   623 OMX_ERRORTYPE

   624 COmxILPortManager::GetConfig(OMX_INDEXTYPE aConfigIndex,

   625 							 TAny* apComponentConfigStructure) const

   626 	{

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

   628 

   629 	TInt index = FindConfigIndex(aConfigIndex);

   630 	if (KErrNotFound == index)

   631 		{

   632 		return OMX_ErrorUnsupportedIndex;

   633 		}

   634 

   635 	// Obtain the port index

   636 	OMX_U32 portIndex;

   637 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(apComponentConfigStructure,

   638 												   portIndex))

   639 		{

   640 		return OMX_ErrorBadPortIndex;

   641 		}

   642 

   643 	// Now delegate to the specific port

   644 	return iAllPorts[portIndex]->GetConfig(

   645 		aConfigIndex,

   646 		apComponentConfigStructure);

   647 

   648 	}

   649 

   650 OMX_ERRORTYPE

   651 COmxILPortManager::SetConfig(OMX_INDEXTYPE aConfigIndex,

   652 							 const TAny* apComponentConfigStructure)

   653 	{

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

   655 

   656 #ifdef _OMXIL_COMMON_IL516C_ON

   657 

   658 	if (OMX_IndexConfigPortBufferReturnRequest == aConfigIndex)

   659 		{

   660 		OMX_U32 portIndex;

   661 		if (OMX_ErrorNone != GetPortIndexFromOmxStruct(

   662 				apComponentConfigStructure,

   663 				portIndex))

   664 			{

   665 			return OMX_ErrorBadPortIndex;

   666 			}

   667 		DEBUG_PRINTF2(_L8("COmxILPortManager::SetConfig : PORT[%u] OMX_IndexConfigPortBufferReturnRequest"), portIndex);

   668 

   669 		// Check the index of the port..

   670 		if ((OMX_ALL != portIndex) &&

   671 			(CheckPortIndex(portIndex) != OMX_ErrorNone))

   672 			{

   673 			return OMX_ErrorBadPortIndex;

   674 			}

   675 

   676 		// This error will be ignored...

   677 		OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   678 		if (portIndex != OMX_ALL)

   679 			{

   680 			omxRetValue = BufferEjectIndication(portIndex);

   681 			}

   682 		else

   683 			{

   684 			const TInt portCount = iAllPorts.Count();

   685 

   686 			for (TUint i = 0; i< portCount; ++i)

   687 				{

   688 				omxRetValue = BufferEjectIndication(iAllPorts[i]->Index());

   689 				}

   690 			}

   691 

   692 		return OMX_ErrorNone;

   693 

   694 		}

   695 #endif

   696 

   697 	TInt index = FindConfigIndex(aConfigIndex);

   698 	if (KErrNotFound == index)

   699 		{

   700 		return OMX_ErrorUnsupportedIndex;

   701 		}

   702 

   703 	// Obtain the port index

   704 	OMX_U32 portIndex;

   705 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(apComponentConfigStructure,

   706 												   portIndex))

   707 		{

   708 		return OMX_ErrorBadPortIndex;

   709 		}

   710 

   711     DEBUG_PRINTF2(_L8("COmxILPortManager::SetConfig : PORT[%u]"), portIndex);

   712 

   713 	TBool updateProcessingFunction = EFalse;

   714 	OMX_ERRORTYPE omxRetValue =

   715 		iAllPorts[portIndex]->SetConfig(

   716 			aConfigIndex,

   717 			apComponentConfigStructure,

   718 			updateProcessingFunction);

   719 

   720 	if (OMX_ErrorNone == omxRetValue)

   721 		{

   722 		if (updateProcessingFunction)

   723 			{

   724 			omxRetValue = iProcessingFunction.ConfigIndication(

   725 				aConfigIndex,

   726 				apComponentConfigStructure);

   727 			}

   728 		}

   729 

   730 	return omxRetValue;

   731 

   732 	}

   733 

   734 OMX_ERRORTYPE

   735 COmxILPortManager::GetExtensionIndex(

   736 	OMX_STRING aParameterName,

   737 	OMX_INDEXTYPE* apIndexType) const

   738 	{

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

   740 

   741 	// See if the extension index is supported by any of the ports...

   742 	const TInt portCount = iAllPorts.Count();

   743 	OMX_ERRORTYPE retValue = OMX_ErrorNone;

   744 	for (TUint i = 0; i< portCount; ++i)

   745 		{

   746 		retValue = iAllPorts[i]->GetExtensionIndex(aParameterName,

   747 												   apIndexType);

   748 		if (retValue != OMX_ErrorUnsupportedIndex)

   749 			{

   750 			return retValue;

   751 			}

   752 		}

   753 

   754 	return OMX_ErrorUnsupportedIndex;

   755 

   756 	}

   757 

   758 OMX_ERRORTYPE

   759 COmxILPortManager::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

   760 								  OMX_U32 aPortIndex,

   761 								  OMX_PTR apAppPrivate,

   762 								  OMX_U32 aSizeBytes,

   763 								  OMX_U8* apBuffer,

   764 								  TBool& portPopulationCompleted,

   765 								  OMX_BOOL aPortIsDisabled /* = OMX_FALSE */ )

   766 	{

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

   768 

   769 	// Check the index of the port..

   770 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   771 		{

   772 		return OMX_ErrorBadPortIndex;

   773 		}

   774 

   775 	// Grab the port here...

   776 	COmxILPort* pPort = iAllPorts[aPortIndex];

   777 

   778 #ifdef _OMXIL_COMMON_IL516C_ON

   779 	if (!apBuffer)

   780 		{

   781 		// Basically, if OMX_UseBuffer is used, the port must not be populated

   782 		// at this point, otherwise it is an error...

   783 		if (pPort->IsPopulated())

   784 			{

   785 			return OMX_ErrorIncorrectStateOperation;

   786 			}

   787 		}

   788 	else

   789 		{

   790 		// ... AllocateBuffer... this is only allowed if the the IL Client has

   791 		// issued the command to idle already..

   792 #endif

   793 

   794 	if (OMX_TRUE == aPortIsDisabled &&

   795 		pPort->IsEnabled() &&

   796 		!pPort->IsTransitioningToEnabled())

   797 		{

   798 		// There is an indication from the FSM that the port must be disabled,

   799 		// otherwise, the buffer allocation is not allowed in the current

   800 		// state. Note that a port may be transitioning to enabled and in that

   801 		// case the buffer population must be allowed...

   802 		return OMX_ErrorIncorrectStateOperation;

   803 		}

   804 

   805 #ifdef _OMXIL_COMMON_IL516C_ON

   806 		}

   807 #endif

   808 

   809 	// Check that in case of tunnelling, this port is not buffer supplier...

   810 	if (pPort->IsTunnelledAndBufferSupplier())

   811 		{

   812 		return OMX_ErrorBadPortIndex;

   813 		}

   814 

   815 	// Now delegate to the port...

   816 	OMX_ERRORTYPE omxRetValue;

   817 	if (OMX_ErrorNone != (omxRetValue = pPort->PopulateBuffer(

   818 							  appBufferHdr,

   819 							  apAppPrivate,

   820 							  aSizeBytes,

   821 							  apBuffer,

   822 							  portPopulationCompleted)))

   823 		{

   824 		return omxRetValue;

   825 		}

   826 

   827 	if (portPopulationCompleted && pPort->IsTransitioningToEnabled())

   828 		{

   829 		// This is a case of port being enabled...  Inform the port that it

   830 		// has been enabled..

   831 		pPort->SetTransitionToEnabledCompleted();

   832 

   833 		// For each enabled port, the IL Client must be notified with an

   834 		// enabled completion event...

   835 		omxRetValue = iCallbacks.CommandCompleteNotification(

   836 			OMX_CommandPortEnable, pPort->Index());

   837 		}

   838 

   839 	return omxRetValue;

   840 

   841 	}

   842 

   843 

   844 OMX_ERRORTYPE

   845 COmxILPortManager::FreeBuffer(OMX_U32 aPortIndex,

   846 							  OMX_BUFFERHEADERTYPE* apBufferHeader,

   847 							  TBool& portDepopulationCompleted,

   848 							  OMX_BOOL aPortIsDisabled /* = OMX_FALSE */)

   849 	{

   850     DEBUG_PRINTF3(_L8("COmxILPortManager::FreeBuffer : PORT[%u] BUFFER [%X]"), aPortIndex, apBufferHeader);

   851 

   852 	// Check the index of the port..

   853 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   854 		{

   855 		return OMX_ErrorBadPortIndex;

   856 		}

   857 

   858 	// Grab the port here...

   859 	COmxILPort* pPort = iAllPorts[aPortIndex];

   860 

   861 	// Check that in case of tunnelling, this port is not buffer supplier...

   862 	if (pPort->IsTunnelledAndBufferSupplier())

   863 		{

   864 		return OMX_ErrorBadPortIndex;

   865 		}

   866 

   867 	TBool errorPortUnpopulated = EFalse;

   868 	if (OMX_TRUE == aPortIsDisabled &&

   869 		pPort->IsEnabled())

   870 		{

   871 		// There is an indication from the FSM that the port should be

   872 		// disabled. If that's not the case, the buffer deallocation will raise

   873 		// an OMX_ErrorPortUnpopulated error in the current state.

   874 

   875 		if (!pPort->IsBufferAtHome(apBufferHeader))

   876 			{

   877 			// FreeBuffer will normally be called in a situation where we are

   878 			// not suppliers and the supplier already got the buffer. So the

   879 			// buffer won't be on our side almost never.

   880 

   881 			if (!iTimePorts[aPortIndex] || !iImmediateReturnTimeBuffer)

   882 				{

   883 				// We'll tell the PF to remove this

   884 				// header from its queues, in case this is called in some strange

   885 				// situation (should not happen if the tunnelled component is well

   886 				// behaved)...

   887 				iProcessingFunction.BufferRemovalIndication(

   888 					apBufferHeader,

   889 					pPort->Direction());

   890 				}

   891 

   892 			// Set the returned flag as this buffer will not count as "away"

   893 			// anymore...

   894 			pPort->SetBufferReturned(apBufferHeader);

   895 			}

   896 

   897 		// We have to send the Port Unpopulated Error...

   898 		errorPortUnpopulated = ETrue;

   899 		}

   900 

   901 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   902 	// Now delegate to the port...

   903 	if (OMX_ErrorNone != (omxRetValue = pPort->FreeBuffer(

   904 							  apBufferHeader,

   905 							  portDepopulationCompleted)))

   906 		{

   907 		return omxRetValue;

   908 		}

   909 

   910 	if (errorPortUnpopulated)

   911 		{

   912 		if (OMX_ErrorNone !=

   913 			(omxRetValue =

   914 			 iCallbacks.ErrorEventNotification(OMX_ErrorPortUnpopulated)))

   915 			{

   916 			return omxRetValue;

   917 			}

   918 		}

   919 

   920 

   921 	if (portDepopulationCompleted)

   922 		{

   923 		if (pPort->IsTransitioningToDisabled())

   924 			{

   925 			// Here we must complete the OMX_CommandPortDisable command

   926 

   927 			// Set the state of the port to  disabled as the command has already

   928 			// completed...

   929 			pPort->SetTransitionToDisabledCompleted();

   930 

   931 			// For each disabled port, the IL Client must be notified

   932 			// with a disabled completion event...

   933 			omxRetValue = iCallbacks.CommandCompleteNotification(

   934 				OMX_CommandPortDisable, aPortIndex);

   935 

   936 			// Clear this flag here. Otherwise, the FSM would inform the client

   937 			// of a successful transition to OMX_StateIdle which is not the

   938 			// case...

   939 			portDepopulationCompleted = EFalse;

   940 			}

   941 		}

   942 

   943 	return omxRetValue;

   944 

   945 	}

   946 

   947 OMX_ERRORTYPE

   948 COmxILPortManager::TunnelRequest(OMX_U32 aPortIndex,

   949 								 OMX_HANDLETYPE aTunneledComp,

   950 								 OMX_U32 aTunneledPort,

   951 								 OMX_TUNNELSETUPTYPE* apTunnelSetup,

   952 								 OMX_BOOL aPortIsDisabled /* = OMX_FALSE */)

   953 	{

   954     DEBUG_PRINTF3(_L8("COmxILPortManager::TunnelRequest : aTunneledComp [%X] aTunneledPort [%d]"), aTunneledComp, aTunneledPort);

   955 

   956 	// Check the index of the port..

   957 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   958 		{

   959 		return OMX_ErrorBadPortIndex;

   960 		}

   961 

   962 	// Grab the port here...

   963 	COmxILPort* pPort = iAllPorts[aPortIndex];

   964 

   965 	if (OMX_TRUE == aPortIsDisabled &&

   966 		pPort->IsEnabled())

   967 		{

   968 		// There is an indication from the FSM that the port must be disabled,

   969 		// otherwise, the tunnel request is not allowed in the current state.

   970 		return OMX_ErrorIncorrectStateOperation;

   971 		}

   972 

   973 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   974 	// Check whether the tunnel is being torn down...

   975 	if (!aTunneledComp)

   976 		{

   977 		// Tell the port...

   978 		if (OMX_ErrorNone !=

   979 			(omxRetValue = pPort->TunnelRequest(

   980 				aTunneledComp,

   981 				aTunneledPort,

   982 				apTunnelSetup)))

   983 			{

   984 			return omxRetValue;

   985 			}

   986 

   987 		if (OMX_ErrorNone !=

   988 			(omxRetValue = iCallbacks.DeregisterTunnelCallback(aPortIndex)))

   989 			{

   990 			// This is serious enough...

   991 			return OMX_ErrorInvalidComponent;

   992 			}

   993 

   994 		// We are done here...

   995 		return OMX_ErrorNone;

   996 		}

   997 

   998 	// Check whether the port is being re-tunnelled...

   999 	if (pPort->IsTunnelled())

  1000 		{

  1001 		// Only two valid options here:

  1002 		// 1.- The port is completely disabled...

  1003 		// or...

  1004 		// 2.- The port is enabled AND component in OMX_StateLoaded

  1005 		if ((!pPort->IsEnabled() &&

  1006 			 !pPort->IsTransitioningToEnabled() &&

  1007 			 !pPort->IsTransitioningToDisabled())

  1008 			||

  1009 			(pPort->IsEnabled() && !aPortIsDisabled))

  1010 			{

  1011 			if (OMX_ErrorNone !=

  1012 				(omxRetValue = iCallbacks.DeregisterTunnelCallback(aPortIndex)))

  1013 				{

  1014 				return OMX_ErrorInvalidComponent;

  1015 				}

  1016 			}

  1017 		else

  1018 			{

  1019 			return OMX_ErrorIncorrectStateOperation;

  1020 			}

  1021 		}

  1022 

  1023 	// Delegate to the port...

  1024 	if (OMX_ErrorNone !=

  1025 		(omxRetValue = pPort->TunnelRequest(

  1026 			aTunneledComp,

  1027 			aTunneledPort,

  1028 			apTunnelSetup)))

  1029 		{

  1030 		return omxRetValue;

  1031 		}

  1032 

  1033 	// From this point on, the port will assume that a tunnel has been

  1034 	// successfully created. If there is a problem at other end, the IL Client

  1035 	// will clear the tunnel on this side using ComponentTunnelRequest with

  1036 	// NULL handle parameter

  1037 

  1038 	// Register the existence of a tunnel within the callback manager...

  1039 	if (OMX_ErrorNone !=

  1040 		(omxRetValue = iCallbacks.RegisterTunnelCallback(aPortIndex,

  1041 													  pPort->Direction(),

  1042 													  aTunneledComp,

  1043 													  aTunneledPort)))

  1044 		{

  1045 		// This is serious enough...

  1046 		return OMX_ErrorInvalidComponent;

  1047 		}

  1048 

  1049 	return OMX_ErrorNone;

  1050 

  1051 	}

  1052 

  1053 

  1054 OMX_ERRORTYPE

  1055 COmxILPortManager::TunnellingBufferAllocation(TBool& aComponentPopulationCompleted,

  1056 											  TUint32 aPortIndex /* = OMX_ALL */)

  1057 	{

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

  1059 

  1060 	aComponentPopulationCompleted = EFalse;

  1061 

  1062 	// Check the index of the port..

  1063 	if ((OMX_ALL != aPortIndex) && (CheckPortIndex(aPortIndex) != OMX_ErrorNone))

  1064 		{

  1065 		return OMX_ErrorBadPortIndex;

  1066 		}

  1067 

  1068 	const TInt portCount = iAllPorts.Count();

  1069 	COmxILPort* pPort = 0;

  1070 	OMX_U32 portIndex = 0;

  1071 	TInt i=0;

  1072 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

  1073 	do

  1074 		{

  1075 		if (aPortIndex != OMX_ALL)

  1076 			{

  1077 			// Grab the port here...

  1078 			pPort = iAllPorts[aPortIndex];

  1079 			portIndex = aPortIndex;

  1080 			}

  1081 		else

  1082 			{

  1083 			pPort = iAllPorts[i];

  1084 			portIndex = pPort->Index();

  1085 			}

  1086 

  1087 

  1088 		if (pPort->IsEnabled() &&

  1089 			pPort->IsTunnelledAndBufferSupplier() &&

  1090 			!pPort->IsPopulated())

  1091 			{

  1092 			TBool portPopulationCompleted = EFalse;

  1093 			if (OMX_ErrorNone !=

  1094 				(omxRetValue = pPort->PopulateTunnel(portPopulationCompleted)))

  1095 				{

  1096 				// TODO: Check case of ports being enabled (error callback needed...)

  1097 				return omxRetValue;

  1098 				}

  1099 

  1100 			if (portPopulationCompleted && pPort->IsTransitioningToEnabled())

  1101 				{

  1102 				// This is a case of port being enabled...  Inform the port that it

  1103 				// has been enabled..

  1104 				pPort->SetTransitionToEnabledCompleted();

  1105 

  1106 				// For each enabled port, the IL Client must be notified with an

  1107 				// enabled completion event...

  1108 				if (OMX_ErrorNone != (

  1109 						omxRetValue = iCallbacks.CommandCompleteNotification(

  1110 							OMX_CommandPortEnable, portIndex)))

  1111 					{

  1112 					return omxRetValue;

  1113 					}

  1114 				}

  1115 

  1116 			}

  1117 

  1118 		// Increment loop counter

  1119 		++i;

  1120 		}

  1121 	while (OMX_ALL == aPortIndex && i < portCount);

  1122 

  1123 	if (AllPortsPopulated())

  1124 		{

  1125 		DEBUG_PRINTF(_L8("COmxILPortManager::TunnellingBufferAllocation : AllPortsPopulated : [TRUE]"));

  1126 		aComponentPopulationCompleted = ETrue;

  1127 		}

  1128 

  1129 	return OMX_ErrorNone;

  1130 

  1131 	}

  1132 

  1133 OMX_ERRORTYPE

  1134 COmxILPortManager::TunnellingBufferDeallocation(