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 "omxilprocessingfunction.h"

    25 #include "omxilcallbackmanager.h"

    26 #include "omxilutil.h"

    27 

    28 EXPORT_C COmxILPortManager*

    29 COmxILPortManager::NewL(

    30 	COmxILProcessingFunction& aProcessingFunction,

    31 	MOmxILCallbackManagerIf& aCallbacks,

    32 	const OMX_VERSIONTYPE& aOmxVersion,

    33 	OMX_U32 aNumberOfAudioPorts,

    34 	OMX_U32 aStartAudioPortNumber,

    35 	OMX_U32 aNumberOfImagePorts,

    36 	OMX_U32 aStartImagePortNumber,

    37 	OMX_U32 aNumberOfVideoPorts,

    38 	OMX_U32 aStartVideoPortNumber,

    39 	OMX_U32 aNumberOfOtherPorts,

    40 	OMX_U32 aStartOtherPortNumber,

    41 	OMX_BOOL aImmediateReturnTimeBuffer)

    42 	{

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

    44 

    45 	COmxILPortManager* self =

    46 		new (ELeave)COmxILPortManager(

    47 			aProcessingFunction,

    48 			aCallbacks,

    49 			aOmxVersion,

    50 			aNumberOfAudioPorts,

    51 			aStartAudioPortNumber,

    52 			aNumberOfImagePorts,

    53 			aStartImagePortNumber,

    54 			aNumberOfVideoPorts,

    55 			aStartVideoPortNumber,

    56 			aNumberOfOtherPorts,

    57 			aStartOtherPortNumber,

    58 			aImmediateReturnTimeBuffer);

    59 

    60 	CleanupStack::PushL(self);

    61 	self->ConstructL();

    62 	CleanupStack::Pop(self);

    63 	return self;

    64 	}

    65 

    66 void

    67 COmxILPortManager::ConstructL()

    68 	{

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

    70 

    71 	InsertParamIndexL(OMX_IndexParamAudioInit);

    72 	InsertParamIndexL(OMX_IndexParamImageInit);

    73 	InsertParamIndexL(OMX_IndexParamVideoInit);

    74 	InsertParamIndexL(OMX_IndexParamOtherInit);

    75 

    76 

    77 	if(iAudioParamInit.nStartPortNumber != 0)

    78 		{

    79 		User::Leave(KErrArgument);

    80 		}

    81 

    82 	if (iImageParamInit.nPorts > 0)

    83 		{

    84 		if (iAudioParamInit.nPorts !=

    85 			iImageParamInit.nStartPortNumber)

    86 			{

    87 			User::Leave(KErrArgument);

    88 			}

    89 		}

    90 

    91 	if (iVideoParamInit.nPorts > 0)

    92 		{

    93 		if ((iAudioParamInit.nPorts +

    94 			 iImageParamInit.nPorts)  !=

    95 			iVideoParamInit.nStartPortNumber)

    96 			{

    97 			User::Leave(KErrArgument);

    98 			}

    99 		}

   100 

   101 	if (iOtherParamInit.nPorts > 0)

   102 		{

   103 		if ((iAudioParamInit.nPorts +

   104 			 iImageParamInit.nPorts +

   105 			 iVideoParamInit.nPorts)  !=

   106 			iOtherParamInit.nStartPortNumber)

   107 			{

   108 			User::Leave(KErrArgument);

   109 			}

   110 		}

   111 

   112 	}

   113 

   114 COmxILPortManager::COmxILPortManager(

   115 	COmxILProcessingFunction& aProcessingFunction,

   116 	MOmxILCallbackManagerIf& aCallbacks,

   117 	const OMX_VERSIONTYPE& aOmxVersion,

   118 	OMX_U32 aNumberOfAudioPorts,

   119 	OMX_U32 aStartAudioPortNumber,

   120 	OMX_U32 aNumberOfImagePorts,

   121 	OMX_U32 aStartImagePortNumber,

   122 	OMX_U32 aNumberOfVideoPorts,

   123 	OMX_U32 aStartVideoPortNumber,

   124 	OMX_U32 aNumberOfOtherPorts,

   125 	OMX_U32 aStartOtherPortNumber,

   126 	OMX_BOOL aImmediateReturnTimeBuffer)

   127 	:

   128 	iProcessingFunction(aProcessingFunction),

   129 	iCallbacks(aCallbacks),

   130 	iAllPorts(),

   131 	iImmediateReturnTimeBuffer(aImmediateReturnTimeBuffer)

   132 	{

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

   134 

   135 	iAudioParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   136 	iAudioParamInit.nVersion		 = aOmxVersion;

   137 	iAudioParamInit.nPorts			 = aNumberOfAudioPorts;

   138 	iAudioParamInit.nStartPortNumber = aStartAudioPortNumber;

   139 

   140 	iImageParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   141 	iImageParamInit.nVersion		 = aOmxVersion;

   142 	iImageParamInit.nPorts			 = aNumberOfImagePorts;

   143 	iImageParamInit.nStartPortNumber = aStartImagePortNumber;

   144 

   145 	iVideoParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   146 	iVideoParamInit.nVersion		 = aOmxVersion;

   147 	iVideoParamInit.nPorts			 = aNumberOfVideoPorts;

   148 	iVideoParamInit.nStartPortNumber = aStartVideoPortNumber;

   149 

   150 	iOtherParamInit.nSize			 = sizeof(OMX_PORT_PARAM_TYPE);

   151 	iOtherParamInit.nVersion		 = aOmxVersion;

   152 	iOtherParamInit.nPorts			 = aNumberOfOtherPorts;

   153 	iOtherParamInit.nStartPortNumber = aStartOtherPortNumber;

   154 

   155 	}

   156 

   157 COmxILPortManager::~COmxILPortManager()

   158 	{

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

   160 	iAllPorts.Reset(); // data not owned here

   161 	iTimePorts.Close();

   162 	}

   163 

   164 void

   165 COmxILPortManager::AppendPortL(const COmxILPort* aPort)

   166 	{

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

   168 

   169 	const TInt portCount = iAllPorts.Count();

   170 	OMX_PORTDOMAINTYPE portDomain = aPort->Domain();

   171 	OMX_U32 startPortNumber = 0;

   172 	TBool timePort = EFalse;

   173 	

   174 	switch(portDomain)

   175 		{

   176 	case OMX_PortDomainAudio:

   177 		{

   178 		__ASSERT_ALWAYS(portCount >= 0,

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

   180 		__ASSERT_ALWAYS(portCount < iAudioParamInit.nPorts,

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

   182 

   183 		startPortNumber = iAudioParamInit.nStartPortNumber;

   184 

   185 		}

   186 		break;

   187 

   188 	case OMX_PortDomainImage:

   189 		{

   190 		__ASSERT_ALWAYS(portCount >= iAudioParamInit.nPorts,

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

   192 		__ASSERT_ALWAYS(portCount <

   193 						iAudioParamInit.nPorts +

   194 						iImageParamInit.nPorts,

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

   196 

   197 		startPortNumber = iImageParamInit.nStartPortNumber;

   198 

   199 		}

   200 		break;

   201 

   202 	case OMX_PortDomainVideo:

   203 		{

   204 		__ASSERT_ALWAYS(portCount >=

   205 						iAudioParamInit.nPorts +

   206 						iImageParamInit.nPorts,

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

   208 		__ASSERT_ALWAYS(portCount <

   209 						iAudioParamInit.nPorts +

   210 						iImageParamInit.nPorts +

   211 						iVideoParamInit.nPorts,

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

   213 

   214 		startPortNumber = iVideoParamInit.nStartPortNumber;

   215 

   216 		}

   217 		break;

   218 

   219 

   220 	case OMX_PortDomainOther:

   221 		{

   222 		__ASSERT_ALWAYS(portCount >=

   223 						iAudioParamInit.nPorts +

   224 						iImageParamInit.nPorts +

   225 						iVideoParamInit.nPorts,

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

   227 		__ASSERT_ALWAYS(portCount <

   228 						iAudioParamInit.nPorts +

   229 						iImageParamInit.nPorts +

   230 						iVideoParamInit.nPorts +

   231 						iOtherParamInit.nPorts,

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

   233 

   234 		startPortNumber = iOtherParamInit.nStartPortNumber;

   235 		

   236 		OMX_OTHER_PARAM_PORTFORMATTYPE paramFormat;

   237 		paramFormat.nSize = sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE);

   238 		paramFormat.nVersion = TOmxILSpecVersion();

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

   240 		paramFormat.nIndex = 0;

   241 

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

   243 			paramFormat.eFormat == OMX_OTHER_FormatTime)

   244 			{

   245 			timePort = ETrue;	

   246 			}

   247 		}

   248 		

   249 		break;

   250 

   251 	default:

   252 		{

   253 		User::Panic(KOmxILPortManagerPanicCategory, 1);

   254 		}

   255 		};

   256 

   257 	if(portCount ==  startPortNumber)

   258 		{

   259 		iAllPorts.AppendL(aPort);

   260 		}

   261 	else

   262 		{

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

   264 			{

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

   266 				{

   267 				User::Panic(KOmxILPortManagerPanicCategory, 1);

   268 				}

   269 			}

   270 		iAllPorts.AppendL(aPort);

   271 		}

   272 

   273 	iTimePorts.AppendL(timePort);

   274 	}

   275 

   276 /**

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

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

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

   280 

   281    @param aPort The port instance to be added.

   282 

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

   284 

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

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

   287    codes.

   288 */

   289 EXPORT_C TInt

   290 COmxILPortManager::AddPort(const COmxILPort* aPort,

   291 						   OMX_DIRTYPE aDirection)

   292 	{

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

   294 

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

   296 

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

   298 							  iVideoParamInit.nPorts +

   299 							  iImageParamInit.nPorts +

   300 							  iOtherParamInit.nPorts))

   301 		{

   302 		return KErrArgument;

   303 		}

   304 

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

   306 		{

   307 		return KErrArgument;

   308 		}

   309 

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

   311 		{

   312 		return KErrArgument;

   313 		}

   314 

   315 	TRAPD(err, AppendPortL(aPort));

   316 	if (KErrNone != err)

   317 		{

   318 		return err;

   319 		}

   320 

   321 	OMX_ERRORTYPE omxRetValue =

   322 		aPort->GetLocalOmxParamIndexes(ManagedParamIndexes());

   323 	if (OMX_ErrorNone == omxRetValue)

   324 		{

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

   326 		}

   327 

   328 	if (OMX_ErrorNone != omxRetValue)

   329 		{

   330 		if (OMX_ErrorInsufficientResources == omxRetValue)

   331 			{

   332 			return KErrNoMemory;

   333 			}

   334 		else

   335 			{

   336 			return KErrGeneral;

   337 			}

   338 		}

   339 

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

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

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

   343 	if (propagationPortIndex != COmxILPort::KBufferMarkPropagationPortNotNeeded)

   344 		{

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

   346 													 propagationPortIndex);

   347 		}

   348 

   349 	err = KErrNone;

   350 	if (OMX_ErrorNone != omxRetValue)

   351 		{

   352 		switch (omxRetValue)

   353 				{

   354 			case OMX_ErrorInsufficientResources:

   355 				{

   356 				err = KErrNoMemory;

   357 				}

   358 				break;

   359 			default:

   360 				{

   361 				err = KErrGeneral;

   362 				}

   363 				};

   364 		}

   365 

   366 	return err;

   367 

   368 	}

   369 

   370 TBool

   371 COmxILPortManager::RemoveBuffersFromPfOrCm(

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

   373 	{

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

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

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

   377 

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

   379 	OMX_BUFFERHEADERTYPE* pHeader = 0;

   380 	TBool allHeadersRemovedFromPf = ETrue;

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

   382 		{

   383 		pHeader = (*apPort)[j];

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

   385 			{

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

   387 			if (!iProcessingFunction.BufferRemovalIndication(

   388 					pHeader,

   389 					apPort->Direction()))

   390 				{

   391 				if (OMX_FALSE == aRemoveFromPfOnly)

   392 					{

   393 					if (!iCallbacks.BufferRemovalIndication(

   394 							pHeader,

   395 							apPort->Direction()))

   396 						{

   397 						allHeadersRemovedFromPf = EFalse;

   398 						}

   399 					else

   400 						{

   401 						apPort->SetBufferReturned(pHeader);

   402 						// Make sure the buffer contents are cleared

   403 						TOmxILUtil::ClearBufferContents(pHeader);

   404 						}

   405 					}

   406 				}

   407 			else

   408 				{

   409 				apPort->SetBufferReturned(pHeader);

   410 				// Make sure the buffer contents are cleared

   411 				TOmxILUtil::ClearBufferContents(pHeader);

   412 				}

   413 			}

   414 		}

   415 

   416 	return allHeadersRemovedFromPf;

   417 

   418 	}

   419 

   420 OMX_ERRORTYPE

   421 COmxILPortManager::GetParameter(OMX_INDEXTYPE aParamIndex,

   422 								TAny* apComponentParameterStructure) const

   423 	{

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

   425 

   426 	TInt index = FindParamIndex(aParamIndex);

   427 	if (KErrNotFound == index)

   428 		{

   429 		return OMX_ErrorUnsupportedIndex;

   430 		}

   431 

   432 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   433 	switch(aParamIndex)

   434 		{

   435 	case OMX_IndexParamAudioInit:

   436 	case OMX_IndexParamImageInit:

   437 	case OMX_IndexParamVideoInit:

   438 	case OMX_IndexParamOtherInit:

   439 		{

   440 		if (OMX_ErrorNone !=

   441 			(omxRetValue =

   442 			 TOmxILUtil::CheckOmxStructSizeAndVersion(

   443 				 const_cast<OMX_PTR>(apComponentParameterStructure),

   444 				 sizeof(OMX_PORT_PARAM_TYPE))))

   445 			{

   446 			return omxRetValue;

   447 			}

   448 

   449 		OMX_PORT_PARAM_TYPE*

   450 			pPortParamType

   451 			= static_cast<OMX_PORT_PARAM_TYPE*>(

   452 				apComponentParameterStructure);

   453 

   454 		switch(aParamIndex)

   455 			{

   456 		case OMX_IndexParamAudioInit:

   457 			*pPortParamType = iAudioParamInit;

   458 			break;

   459 		case OMX_IndexParamImageInit:

   460 			*pPortParamType = iImageParamInit;

   461 			break;

   462 		case OMX_IndexParamVideoInit:

   463 			*pPortParamType = iVideoParamInit;

   464 			break;

   465 		case OMX_IndexParamOtherInit:

   466 			*pPortParamType = iOtherParamInit;

   467 			break;

   468 			}

   469 

   470 		}

   471 		break;

   472 

   473 	default:

   474 		{

   475 		// Obtain the port index

   476 		OMX_U32 portIndex;

   477 		if (OMX_ErrorNone != GetPortIndexFromOmxStruct(

   478 				apComponentParameterStructure,

   479 				portIndex))

   480 			{

   481 			return OMX_ErrorBadPortIndex;

   482 			}

   483 

   484 		// Now delegate to the specific port

   485 		return iAllPorts[portIndex]->GetParameter(

   486 			aParamIndex,

   487 			apComponentParameterStructure);

   488 		}

   489 		};

   490 

   491 	return OMX_ErrorNone;

   492 

   493 	}

   494 

   495 OMX_ERRORTYPE

   496 COmxILPortManager::SetParameter(OMX_INDEXTYPE aParamIndex,

   497 								const TAny* apComponentParameterStructure,

   498 								OMX_BOOL aPortIsDisabled /* = OMX_FALSE */ )

   499 	{

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

   501 

   502 	TInt index = FindParamIndex(aParamIndex);

   503 	if (KErrNotFound == index)

   504 		{

   505 		return OMX_ErrorUnsupportedIndex;

   506 		}

   507 

   508 	// Obtain the port index

   509 	OMX_U32 portIndex;

   510 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(

   511 			apComponentParameterStructure,

   512 			portIndex))

   513 		{

   514 		return OMX_ErrorBadPortIndex;

   515 		}

   516 

   517 	// Grab the port here...

   518 	COmxILPort* pPort = iAllPorts[portIndex];

   519 

   520 	if (OMX_TRUE == aPortIsDisabled &&

   521 		pPort->IsEnabled() &&

   522 		!pPort->IsTransitioningToEnabled())

   523 		{

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

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

   526 		return OMX_ErrorIncorrectStateOperation;

   527 		}

   528 

   529 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   530 	switch(aParamIndex)

   531 		{

   532 	case OMX_IndexParamAudioInit:

   533 	case OMX_IndexParamVideoInit:

   534 	case OMX_IndexParamImageInit:

   535 	case OMX_IndexParamOtherInit:

   536 		{

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

   538 		return OMX_ErrorUnsupportedIndex;

   539 		}

   540 	default:

   541 		{

   542 		TBool updateProcessingFunction = EFalse;

   543 		omxRetValue =

   544 			pPort->SetParameter(

   545 				aParamIndex,

   546 				apComponentParameterStructure,

   547 				updateProcessingFunction);

   548 

   549 		if (OMX_ErrorNone == omxRetValue)

   550 			{

   551 			if (updateProcessingFunction)

   552 				{

   553 				omxRetValue = iProcessingFunction.ParamIndication(

   554 					aParamIndex,

   555 					apComponentParameterStructure);

   556 				}

   557 			}

   558 

   559 		}

   560 		};

   561 

   562 	return omxRetValue;

   563 

   564 	}

   565 

   566 OMX_ERRORTYPE

   567 COmxILPortManager::GetConfig(OMX_INDEXTYPE aConfigIndex,

   568 							 TAny* apComponentConfigStructure) const

   569 	{

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

   571 

   572 	TInt index = FindConfigIndex(aConfigIndex);

   573 	if (KErrNotFound == index)

   574 		{

   575 		return OMX_ErrorUnsupportedIndex;

   576 		}

   577 

   578 	// Obtain the port index

   579 	OMX_U32 portIndex;

   580 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(apComponentConfigStructure,

   581 												   portIndex))

   582 		{

   583 		return OMX_ErrorBadPortIndex;

   584 		}

   585 

   586 	// Now delegate to the specific port

   587 	return iAllPorts[portIndex]->GetConfig(

   588 		aConfigIndex,

   589 		apComponentConfigStructure);

   590 

   591 	}

   592 

   593 OMX_ERRORTYPE

   594 COmxILPortManager::SetConfig(OMX_INDEXTYPE aConfigIndex,

   595 							 const TAny* apComponentConfigStructure)

   596 	{

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

   598 

   599 	TInt index = FindConfigIndex(aConfigIndex);

   600 	if (KErrNotFound == index)

   601 		{

   602 		return OMX_ErrorUnsupportedIndex;

   603 		}

   604 

   605 	// Obtain the port index

   606 	OMX_U32 portIndex;

   607 	if (OMX_ErrorNone != GetPortIndexFromOmxStruct(apComponentConfigStructure,

   608 												   portIndex))

   609 		{

   610 		return OMX_ErrorBadPortIndex;

   611 		}

   612 

   613 	TBool updateProcessingFunction = EFalse;

   614 	OMX_ERRORTYPE omxRetValue =

   615 		iAllPorts[portIndex]->SetConfig(

   616 			aConfigIndex,

   617 			apComponentConfigStructure,

   618 			updateProcessingFunction);

   619 

   620 	if (OMX_ErrorNone == omxRetValue)

   621 		{

   622 		if (updateProcessingFunction)

   623 			{

   624 			omxRetValue = iProcessingFunction.ConfigIndication(

   625 				aConfigIndex,

   626 				apComponentConfigStructure);

   627 			}

   628 		}

   629 

   630 	return omxRetValue;

   631 

   632 	}

   633 

   634 OMX_ERRORTYPE

   635 COmxILPortManager::GetExtensionIndex(

   636 	OMX_STRING aParameterName,

   637 	OMX_INDEXTYPE* apIndexType) const

   638 	{

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

   640 

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

   642 	const TInt portCount = iAllPorts.Count();

   643 	OMX_ERRORTYPE retValue = OMX_ErrorNone;

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

   645 		{

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

   647 												   apIndexType);

   648 		if (retValue != OMX_ErrorUnsupportedIndex)

   649 			{

   650 			return retValue;

   651 			}

   652 		}

   653 

   654 	return OMX_ErrorUnsupportedIndex;

   655 

   656 	}

   657 

   658 OMX_ERRORTYPE

   659 COmxILPortManager::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,

   660 								  OMX_U32 aPortIndex,

   661 								  OMX_PTR apAppPrivate,

   662 								  OMX_U32 aSizeBytes,

   663 								  OMX_U8* apBuffer,

   664 								  TBool& portPopulationCompleted,

   665 								  OMX_BOOL aPortIsDisabled /* = OMX_FALSE */ )

   666 	{

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

   668 

   669 	// Check the index of the port..

   670 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   671 		{

   672 		return OMX_ErrorBadPortIndex;

   673 		}

   674 

   675 	// Grab the port here...

   676 	COmxILPort* pPort = iAllPorts[aPortIndex];

   677 

   678 	if (OMX_TRUE == aPortIsDisabled &&

   679 		pPort->IsEnabled() &&

   680 		!pPort->IsTransitioningToEnabled())

   681 		{

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

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

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

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

   686 		return OMX_ErrorIncorrectStateOperation;

   687 		}

   688 

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

   690 	if (pPort->IsTunnelledAndBufferSupplier())

   691 		{

   692 		return OMX_ErrorBadPortIndex;

   693 		}

   694 

   695 	// Now delegate to the port...

   696 	OMX_ERRORTYPE omxRetValue;

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

   698 							  appBufferHdr,

   699 							  apAppPrivate,

   700 							  aSizeBytes,

   701 							  apBuffer,

   702 							  portPopulationCompleted)))

   703 		{

   704 		return omxRetValue;

   705 		}

   706 

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

   708 		{

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

   710 		// has been enabled..

   711 		pPort->SetTransitionToEnabledCompleted();

   712 

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

   714 		// enabled completion event...

   715 		omxRetValue = iCallbacks.CommandCompleteNotification(

   716 			OMX_CommandPortEnable, pPort->Index());

   717 		}

   718 

   719 	return omxRetValue;

   720 

   721 	}

   722 

   723 

   724 OMX_ERRORTYPE

   725 COmxILPortManager::FreeBuffer(OMX_U32 aPortIndex,

   726 							  OMX_BUFFERHEADERTYPE* apBufferHeader,

   727 							  TBool& portDepopulationCompleted,

   728 							  OMX_BOOL aPortIsDisabled /* = OMX_FALSE */)

   729 	{

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

   731 

   732 	// Check the index of the port..

   733 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   734 		{

   735 		return OMX_ErrorBadPortIndex;

   736 		}

   737 

   738 	// Grab the port here...

   739 	COmxILPort* pPort = iAllPorts[aPortIndex];

   740 

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

   742 	if (pPort->IsTunnelledAndBufferSupplier())

   743 		{

   744 		return OMX_ErrorBadPortIndex;

   745 		}

   746 

   747 	TBool errorPortUnpopulated = EFalse;

   748 	if (OMX_TRUE == aPortIsDisabled &&

   749 		pPort->IsEnabled())

   750 		{

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

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

   753 		// an OMX_ErrorPortUnpopulated error in the current state.

   754 

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

   756 			{

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

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

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

   760 

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

   762 				{

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

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

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

   766 				// behaved)...

   767 				iProcessingFunction.BufferRemovalIndication(

   768 					apBufferHeader,

   769 					pPort->Direction());

   770 				}

   771 

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

   773 			// anymore...

   774 			pPort->SetBufferReturned(apBufferHeader);

   775 			}

   776 

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

   778 		errorPortUnpopulated = ETrue;

   779 		}

   780 

   781 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   782 	// Now delegate to the port...

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

   784 							  apBufferHeader,

   785 							  portDepopulationCompleted)))

   786 		{

   787 		return omxRetValue;

   788 		}

   789 

   790 	if (errorPortUnpopulated)

   791 		{

   792 		if (OMX_ErrorNone !=

   793 			(omxRetValue =

   794 			 iCallbacks.ErrorEventNotification(OMX_ErrorPortUnpopulated)))

   795 			{

   796 			return omxRetValue;

   797 			}

   798 		}

   799 

   800 

   801 	if (portDepopulationCompleted)

   802 		{

   803 		if (pPort->IsTransitioningToDisabled())

   804 			{

   805 			// Here we must complete the OMX_CommandPortDisable command

   806 

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

   808 			// completed...

   809 			pPort->SetTransitionToDisabledCompleted();

   810 

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

   812 			// with a disabled completion event...

   813 			omxRetValue = iCallbacks.CommandCompleteNotification(

   814 				OMX_CommandPortDisable, aPortIndex);

   815 

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

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

   818 			// case...

   819 			portDepopulationCompleted = EFalse;

   820 			}

   821 		}

   822 

   823 	return omxRetValue;

   824 

   825 	}

   826 

   827 OMX_ERRORTYPE

   828 COmxILPortManager::TunnelRequest(OMX_U32 aPortIndex,

   829 								 OMX_HANDLETYPE aTunneledComp,

   830 								 OMX_U32 aTunneledPort,

   831 								 OMX_TUNNELSETUPTYPE* apTunnelSetup,

   832 								 OMX_BOOL aPortIsDisabled /* = OMX_FALSE */)

   833 	{

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

   835 

   836 	// Check the index of the port..

   837 	if (CheckPortIndex(aPortIndex) != OMX_ErrorNone)

   838 		{

   839 		return OMX_ErrorBadPortIndex;

   840 		}

   841 

   842 	// Grab the port here...

   843 	COmxILPort* pPort = iAllPorts[aPortIndex];

   844 

   845 	if (OMX_TRUE == aPortIsDisabled &&

   846 		pPort->IsEnabled())

   847 		{

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

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

   850 		return OMX_ErrorIncorrectStateOperation;

   851 		}

   852 

   853 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

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

   855 	if (!aTunneledComp)

   856 		{

   857 		// Tell the port...

   858 		if (OMX_ErrorNone !=

   859 			(omxRetValue = pPort->TunnelRequest(

   860 				aTunneledComp,

   861 				aTunneledPort,

   862 				apTunnelSetup)))

   863 			{

   864 			return omxRetValue;

   865 			}

   866 

   867 		if (OMX_ErrorNone !=

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

   869 			{

   870 			// This is serious enough...

   871 			return OMX_ErrorInvalidComponent;

   872 			}

   873 

   874 		// We are done here...

   875 		return OMX_ErrorNone;

   876 		}

   877 

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

   879 	if (pPort->IsTunnelled())

   880 		{

   881 		// Only two valid options here:

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

   883 		// or...

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

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

   886 			 !pPort->IsTransitioningToEnabled() &&

   887 			 !pPort->IsTransitioningToDisabled())

   888 			||

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

   890 			{

   891 			if (OMX_ErrorNone !=

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

   893 				{

   894 				return OMX_ErrorInvalidComponent;

   895 				}

   896 			}

   897 		else

   898 			{

   899 			return OMX_ErrorIncorrectStateOperation;

   900 			}

   901 		}

   902 

   903 	// Delegate to the port...

   904 	if (OMX_ErrorNone !=

   905 		(omxRetValue = pPort->TunnelRequest(

   906 			aTunneledComp,

   907 			aTunneledPort,

   908 			apTunnelSetup)))

   909 		{

   910 		return omxRetValue;

   911 		}

   912 

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

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

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

   916 	// NULL handle parameter

   917 

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

   919 	if (OMX_ErrorNone !=

   920 		(omxRetValue = iCallbacks.RegisterTunnelCallback(aPortIndex,

   921 													  pPort->Direction(),

   922 													  aTunneledComp,

   923 													  aTunneledPort)))

   924 		{

   925 		// This is serious enough...

   926 		return OMX_ErrorInvalidComponent;

   927 		}

   928 

   929 	return OMX_ErrorNone;

   930 

   931 	}

   932 

   933 

   934 OMX_ERRORTYPE

   935 COmxILPortManager::TunnellingBufferAllocation(TBool& aComponentPopulationCompleted,

   936 											  TUint32 aPortIndex /* = OMX_ALL */)

   937 	{

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

   939 

   940 	aComponentPopulationCompleted = EFalse;

   941 

   942 	// Check the index of the port..

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

   944 		{

   945 		return OMX_ErrorBadPortIndex;

   946 		}

   947 

   948 	const TInt portCount = iAllPorts.Count();

   949 	COmxILPort* pPort = 0;

   950 	OMX_U32 portIndex = 0;

   951 	TInt i=0;

   952 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

   953 	do

   954 		{

   955 		if (aPortIndex != OMX_ALL)

   956 			{

   957 			// Grab the port here...

   958 			pPort = iAllPorts[aPortIndex];

   959 			portIndex = aPortIndex;

   960 			}

   961 		else

   962 			{

   963 			pPort = iAllPorts[i];

   964 			portIndex = pPort->Index();

   965 			}

   966 

   967 

   968 		if (pPort->IsEnabled() &&

   969 			pPort->IsTunnelledAndBufferSupplier() &&

   970 			!pPort->IsPopulated())

   971 			{

   972 			TBool portPopulationCompleted = EFalse;

   973 			if (OMX_ErrorNone !=

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

   975 				{

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

   977 				return omxRetValue;

   978 				}

   979 

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

   981 				{

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

   983 				// has been enabled..

   984 				pPort->SetTransitionToEnabledCompleted();

   985 

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

   987 				// enabled completion event...

   988 				if (OMX_ErrorNone != (

   989 						omxRetValue = iCallbacks.CommandCompleteNotification(

   990 							OMX_CommandPortEnable, portIndex)))

   991 					{

   992 					return omxRetValue;

   993 					}

   994 				}

   995 

   996 			}

   997 

   998 		// Increment loop counter

   999 		++i;

  1000 		}

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

  1002 

  1003 	if (AllPortsPopulated())

  1004 		{

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

  1006 		aComponentPopulationCompleted = ETrue;

  1007 		}

  1008 

  1009 	return OMX_ErrorNone;

  1010 

  1011 	}

  1012 

  1013 OMX_ERRORTYPE

  1014 COmxILPortManager::TunnellingBufferDeallocation(

  1015 	TBool& aComponentDepopulationCompleted)

  1016 	{

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

  1018 

  1019 	aComponentDepopulationCompleted = EFalse;

  1020 

  1021 	const TInt portCount = iAllPorts.Count();

  1022 	COmxILPort* pPort = 0;

  1023 	TInt portDepopulationCounter = 0;

  1024 	OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

  1025 	TBool portDepopulationCompleted = EFalse;

  1026 	for (TInt i=0; i<portCount; ++i)

  1027 		{

  1028 		pPort = iAllPorts[i];

  1029 		if (pPort->IsEnabled() && pPort->IsTunnelledAndBufferSupplier())

  1030 			{

  1031 			// TODO: Check that at this point, the ProcessingFunction must not

  1032 			// hold any buffer header...

  1033 			portDepopulationCompleted = EFalse;

  1034 			if (OMX_ErrorNone !=

  1035 				(omxRetValue = pPort->FreeTunnel(portDepopulationCompleted)))

  1036 				{

  1037 				return omxRetValue;

  1038 				}

  1039 

  1040 			if (pPort->IsDePopulated())

  1041 				{

  1042 				portDepopulationCounter++;

  1043 				}

  1044 			}

  1045 		}

  1046 

  1047 	if (AllPortsDePopulated())

  1048 		{

  1049 		DEBUG_PRINTF(_L8("COmxILPortManager::TunnellingBufferDeallocation : AllPortsDepopulated : [TRUE]"));

  1050 		aComponentDepopulationCompleted = ETrue;

  1051 		}

  1052 

  1053 	return OMX_ErrorNone;

  1054 

  1055 	}

  1056 

  1057 OMX_ERRORTYPE

  1058 COmxILPortManager::InitiateTunnellingDataFlow(OMX_U32 aPortIndex /* = OMX_ALL */)

  1059 	{

  1060     DEBUG_PRINTF2(_L8("COmxILPortManager::InitiateTunnellingDataFlow : PORT[%d]"), aPortIndex);

  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 	// This is an indication that the component is ready to start exchanging

  1069 	// buffers... Supplier tunnelled ports must initiate the buffer exchange in

  1070 	// the tunnel...

  1071 	const TInt portCount = iAllPorts.Count();

  1072 	COmxILPort* pPort = 0;

  1073 	OMX_U32 portIndex = 0;

  1074 	TInt i=0;

  1075 	do

  1076 		{

  1077 		if (aPortIndex != OMX_ALL)

  1078 			{

  1079 			// Grab the port here...

  1080 			pPort = iAllPorts[aPortIndex];

  1081 			portIndex = aPortIndex;

  1082 			}

  1083 		else

  1084 			{

  1085 			pPort = iAllPorts[i];

  1086 			portIndex = pPort->Index();

  1087 			}

  1088 

  1089 		if (pPort->IsEnabled() && pPort->IsTunnelledAndBufferSupplier())

  1090 			{

  1091 			const TInt headerCount = pPort->Count();

  1092 			OMX_BUFFERHEADERTYPE* pHeader = 0;

  1093 			OMX_DIRTYPE portDir = OMX_DirMax;

  1094 			OMX_ERRORTYPE omxRetValue = OMX_ErrorNone;

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

  1096 				{

  1097 				// Here, there are two options:

  1098 				//

  1099 				// 1. -The port is an input port, in which case, the buffer is

  1100 				// directly sent to the callback manager which in turn sends it

  1101 				// to the tunnelled component in charge of filling it

  1102 				// (OMX_FillThisBuffer)

  1103 				//

  1104 				// 2.- The port is an output port, and the buffer must be sent

  1105 				// to the processing function to be filled before the buffer

  1106 				// can be sent to the tunnelled component. After that, the proc

  1107 				// function will send the buffer to the call back manager to be

  1108 				// sent to the tunnelled component (OMX_EmptyThisBuffer)...

  1109 				pHeader = (*pPort)[j];

  1110 

  1111 				// Check that we actually have the buffer in our side...

  1112 				if (!pPort->IsBufferAtHome(pHeader))

  1113 					{

  1114 					DEBUG_PRINTF2(_L8("COmxILPortManager::InitiateTunnellingDataFlow : BUFFER HEADER[%X] is not at home"),

  1115 								  pHeader);

  1116 					continue;

  1117 					}

  1118 

  1119 				portDir = pPort->Direction();

  1120 				__ASSERT_DEBUG((OMX_DirInput == portDir ||

  1121 								OMX_DirOutput == portDir),

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

  1123 

  1124 				if (OMX_DirInput == portDir)

  1125 					{

  1126 					// Input port -> Send buffer to callback manager...

  1127 					omxRetValue =

  1128 						iCallbacks.BufferDoneNotification(pHeader,

  1129 														  portIndex,

  1130 														  portDir);

  1131 					}

  1132 				else

  1133 					{

  1134 					// Output port -> Send buffer to processing function...