diff -r 000000000000 -r 40261b775718 omxil/omxilcomponentcommon/src/common/omxilcallbackmanagerifimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/omxilcomponentcommon/src/common/omxilcallbackmanagerifimpl.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,502 @@
+// 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 "omxilcallbackmanagerifimpl.h"
+#include "omxilportmanager.h"
+#include "omxilfsm.h"
+
+
+EXPORT_C
+XOmxILCallbackManagerIfImpl::XOmxILCallbackManagerIfImpl(OMX_HANDLETYPE apComponentHandle,
+											 OMX_PTR apAppData,
+											 OMX_CALLBACKTYPE* apCallbacks)
+	:
+	ipHandle(static_cast<OMX_COMPONENTTYPE*>(apComponentHandle)),
+	ipAppData(apAppData),
+	ipCallbacks(apCallbacks),
+	iRegisteredTunnels(),
+	iBufferMarkPropagationPorts(),
+	iBufferMarks(),
+	ipPortManager(0),
+	ipFsm(0)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::XOmxILCallbackManagerIfImpl"));
+	}
+
+EXPORT_C
+XOmxILCallbackManagerIfImpl::~XOmxILCallbackManagerIfImpl()
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::~XOmxILCallbackManagerIfImpl"));
+	// These pointers are cleared to make sure that any further calls on this
+	// object will fail (e.g., from a threaded PF)
+	ipHandle	= 0;
+	ipAppData	= 0;
+	ipCallbacks = 0;
+
+	iRegisteredTunnels.Close();
+	iBufferMarkPropagationPorts.Close();
+	iBufferMarks.Close();
+
+	ipPortManager = 0;
+
+	ipFsm = 0;
+
+	}
+
+EXPORT_C void
+XOmxILCallbackManagerIfImpl::DoSetPortManager(COmxILPortManager& apPortManager)
+	{
+	ipPortManager = &apPortManager;
+	}
+
+EXPORT_C void
+XOmxILCallbackManagerIfImpl::DoSetFsm(COmxILFsm& apFsm)
+	{
+	ipFsm = &apFsm;
+	}
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoRegisterComponentHandle(OMX_HANDLETYPE aComponentHandle)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::DoRegisterComponentHandle"));
+
+	__ASSERT_DEBUG(aComponentHandle,
+				   User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	ipHandle = static_cast<OMX_COMPONENTTYPE *>(aComponentHandle);
+
+	return OMX_ErrorNone;
+
+	}
+
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoRegisterILClientCallbacks(const OMX_CALLBACKTYPE* apCallbacks,
+												   const OMX_PTR apAppData)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::DoRegisterILClientCallbacks"));
+
+	ipAppData   = const_cast<OMX_PTR>(apAppData);
+	ipCallbacks = const_cast<OMX_CALLBACKTYPE*>(apCallbacks);
+
+	return OMX_ErrorNone;
+
+	}
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoRegisterTunnelCallback(
+	OMX_U32 aLocalPortIndex,
+	OMX_DIRTYPE aLocalPortDirection,
+	OMX_HANDLETYPE aTunnelledComponentHandle,
+	OMX_U32 aTunnelledPortIndex)
+	{
+	DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::DoRegisterTunnelCallback"));
+
+	OMX_ERRORTYPE omxError = OMX_ErrorNone;
+
+	if (aTunnelledComponentHandle)
+		{
+		// Register tunnelled port
+		TInt err = iRegisteredTunnels.Append(
+			TTunnelRegistrationInfo(aLocalPortIndex,
+									aLocalPortDirection,
+									aTunnelledComponentHandle,
+									aTunnelledPortIndex));
+		if (KErrNone != err)
+			{
+			switch (err)
+				{
+			case KErrNoMemory:
+				{
+				omxError = OMX_ErrorInsufficientResources;
+				}
+				break;
+			default:
+				{
+				omxError = OMX_ErrorUndefined;
+				}
+				};
+			}
+
+		}
+	else
+		{
+		// Deregister tunnelled port
+		const TUint tunnelCount = iRegisteredTunnels.Count();
+		for (TUint i=0; i<tunnelCount; ++i)
+			{
+			if (iRegisteredTunnels[i].iLocalPortIndex ==
+				aLocalPortIndex)
+				{
+				iRegisteredTunnels.Remove(i);
+				break;
+				}
+			}
+		}
+
+	return omxError;
+
+	}
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoRegisterBufferMarkPropagationPort(
+	OMX_U32 aPortIndex,
+	OMX_U32 aPropagationPortIndex)
+	{
+	DEBUG_PRINTF3(_L8("XOmxILCallbackManagerIfImpl::DoRegisterBufferMarkPropagationPort : aPortIndex[%d] aPropagationPortIndex[%d] "),aPortIndex, aPropagationPortIndex);
+
+	TInt err = iBufferMarkPropagationPorts.Append(
+		TBufferMarkPropagationInfo(aPortIndex,
+								   aPropagationPortIndex));
+
+	OMX_ERRORTYPE omxError = OMX_ErrorNone;
+	if (KErrNone != err)
+		{
+		switch (err)
+			{
+		case KErrNoMemory:
+			{
+			omxError = OMX_ErrorInsufficientResources;
+			}
+			break;
+		default:
+			{
+			omxError = OMX_ErrorUndefined;
+			}
+			};
+		}
+
+	return omxError;
+
+	}
+
+
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoTransitionCompleteNotification(OMX_STATETYPE aOmxState)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::DoTransitionCompleteNotification"));
+
+	return DoEventNotification(OMX_EventCmdComplete,
+							 OMX_CommandStateSet,
+							 aOmxState,
+							 0);
+
+	}
+
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoCommandCompleteNotification(OMX_COMMANDTYPE aOmxCommand,
+												   OMX_U32 aOmxPortIndex)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::DoCommandCompleteNotification"));
+
+	return DoEventNotification(OMX_EventCmdComplete,
+							 aOmxCommand,
+							 aOmxPortIndex,
+							 0);
+
+	}
+
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoErrorEventNotification(OMX_ERRORTYPE aOmxError)
+	{
+    DEBUG_PRINTF2(_L8("XOmxILCallbackManagerIfImpl::DoErrorEventNotification : aOmxError[%X] "), aOmxError);
+
+	return DoEventNotification(OMX_EventError,
+							 aOmxError,
+							 0,
+							 0);
+
+	}
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoEventNotification(OMX_EVENTTYPE aEvent,
+										   TUint32 aData1,
+										   TUint32 aData2,
+										   OMX_STRING aExtraInfo)
+	{
+    DEBUG_PRINTF4(_L8("XOmxILCallbackManagerIfImpl::DoEventNotification : aEvent[%u] aData1[%u] aData2[%u]"), aEvent, aData1, aData2);
+
+	__ASSERT_DEBUG(ipHandle && ipCallbacks, User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	ipCallbacks->EventHandler(ipHandle,
+							  ipAppData,
+							  aEvent,
+							  aData1,
+							  aData2,
+							  aExtraInfo);
+	return OMX_ErrorNone;
+
+	}
+
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoBufferDoneNotification(OMX_BUFFERHEADERTYPE* apBufferHeader,
+											 OMX_U32 aLocalPortIndex,
+											 OMX_DIRTYPE aLocalPortDirection)
+	{
+    DEBUG_PRINTF5(_L8("XOmxILCallbackManagerIfImpl::DoBufferDoneNotification : HANDLE [%X] BUFFER [%X] PORT[%d] DIR[%d]"), ipHandle, apBufferHeader, aLocalPortIndex, aLocalPortDirection);
+
+	__ASSERT_ALWAYS(apBufferHeader &&
+					(OMX_DirInput == aLocalPortDirection ||
+					 OMX_DirOutput == aLocalPortDirection),
+					User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	__ASSERT_ALWAYS(apBufferHeader->nOffset + apBufferHeader->nFilledLen
+					<= apBufferHeader->nAllocLen,
+					User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	__ASSERT_DEBUG(ipHandle && ipCallbacks, User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	// Look for buffer marks to be signalled or propagated
+	SignalOrPropagateBufferMarks(apBufferHeader,
+								 aLocalPortDirection);
+
+	// find out whether the port is tunnelled or not
+	TBool tunnelled = EFalse;
+	TUint tunnelInfoArrayIndex = 0;
+	const TUint tunnelCount = iRegisteredTunnels.Count();
+	for (TUint i=0; i<tunnelCount; ++i)
+		{
+		if (iRegisteredTunnels[i].iLocalPortIndex ==
+			aLocalPortIndex)
+			{
+			tunnelled = ETrue;
+			tunnelInfoArrayIndex = i;
+			break;
+			}
+		}
+
+	if (tunnelled)
+		{
+		OMX_COMPONENTTYPE* ipTunnelledComponent =
+			static_cast<OMX_COMPONENTTYPE*>(
+				iRegisteredTunnels[tunnelInfoArrayIndex].
+				iTunnelledComponentHandle);
+
+		__ASSERT_DEBUG(ipTunnelledComponent,
+					   User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+		// From OMX_Core.h "Callbacks should not return an error to the
+		// component, so if an error occurs, the application shall handle it
+		// internally". Callback return error ignored here.
+		if (OMX_DirInput == aLocalPortDirection)
+			{
+			OMX_FillThisBuffer(ipTunnelledComponent, apBufferHeader);
+			}
+		else
+			{
+			OMX_EmptyThisBuffer(ipTunnelledComponent, apBufferHeader);
+			}
+
+		}
+	else
+		{
+		OMX_ERRORTYPE (*fp2CBackHandler)
+			(OMX_HANDLETYPE, OMX_PTR, OMX_BUFFERHEADERTYPE*) =
+			(aLocalPortDirection == OMX_DirInput ?
+			 ipCallbacks->EmptyBufferDone :
+			 ipCallbacks->FillBufferDone);
+
+		// From OMX_Core.h "Callbacks should not return an error to the
+		// component, so if an error occurs, the application shall handle it
+		// internally". Callback return error ignored here.
+		fp2CBackHandler(ipHandle,
+						ipAppData,
+						apBufferHeader);
+		}
+
+	return OMX_ErrorNone;
+
+	}
+
+EXPORT_C OMX_ERRORTYPE
+XOmxILCallbackManagerIfImpl::DoPortSettingsChangeNotification(
+	OMX_U32 aLocalPortIndex,
+	TUint aPortSettingsIndex,
+	const TDesC8& aPortSettings)
+	{
+    DEBUG_PRINTF2(_L8("XOmxILCallbackManagerIfImpl::DoPortSettingsChangeNotification : aLocalPortIndex[%d]"), aLocalPortIndex);
+
+	__ASSERT_DEBUG(ipHandle &&
+				   ipCallbacks &&
+				   ipPortManager,
+				   User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+	HBufC8* pPortSettings = HBufC8::New(aPortSettings.Length());
+	if (!pPortSettings)
+		{
+		return OMX_ErrorInsufficientResources;
+		}
+	*pPortSettings = aPortSettings;
+
+	// This is an event that the port may want to convey to the IL Client...
+	OMX_EVENTTYPE eventForILClient = OMX_EventMax;
+	OMX_ERRORTYPE omxRetError =
+		ipPortManager->PortSettingsChangeIndication(aLocalPortIndex,
+													aPortSettingsIndex,
+													*pPortSettings,
+													eventForILClient);
+
+	delete pPortSettings;
+	pPortSettings = NULL;
+
+	// Inform the IL Client that some value in one of the ports' configuration
+	// structures has changed...
+	if (OMX_EventMax != eventForILClient)
+		{
+		// Only allow these two port events...
+		__ASSERT_ALWAYS(eventForILClient == OMX_EventPortSettingsChanged ||
+						eventForILClient == OMX_EventPortFormatDetected,
+						User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));
+
+		// From OMX_Core.h "Callbacks should not return an error to the component,
+		// so if an error occurs, the application shall handle it
+		// internally". Callback return error ignored here.
+		ipCallbacks->EventHandler(ipHandle,
+								  ipAppData,
+								  eventForILClient,
+								  aLocalPortIndex,
+								  0,
+								  0);
+		}
+
+	return OMX_ErrorNone;
+
+	}
+
+EXPORT_C void
+XOmxILCallbackManagerIfImpl::SignalOrPropagateBufferMarks(
+	OMX_BUFFERHEADERTYPE* apBufferHeader,
+	OMX_U32 aLocalPortIndex)
+	{
+    DEBUG_PRINTF(_L8("XOmxILCallbackManagerIfImpl::SignalOrPropagateBufferMarks()"));
+
+	// Look for buffer marks to be signalled or propagated
+	if (apBufferHeader->hMarkTargetComponent)
+		{
+		// See if this component is the buffer mark target component...
+		if (apBufferHeader->hMarkTargetComponent == ipHandle)
+			{
+			// Inform the IL Client that a marked buffer has been processed...
+			ipCallbacks->EventHandler(ipHandle,
+									  ipAppData,
+									  OMX_EventMark,
+									  0,
+									  0,
+									  apBufferHeader->pMarkData);
+
+			// At this point, the mark has been delivered to the IL
+			// Client...Remove the mark from the processed header...
+			apBufferHeader->hMarkTargetComponent = 0;
+			apBufferHeader->pMarkData = 0;
+
+			}
+		else
+			{
+			// Propagate the mark...
+
+			// First find the buffer mark propagation port...
+			const TInt index = iBufferMarkPropagationPorts.Find(
+				TBufferMarkPropagationInfo(aLocalPortIndex),
+				TIdentityRelation<TBufferMarkPropagationInfo>(
+					&TBufferMarkPropagationInfo::Compare));
+
+			// Note that sink components don't propagate marks...
+			if (index != KErrNotFound)
+				{
+				const TBufferMarkPropagationInfo& propInfo =
+					iBufferMarkPropagationPorts[index];
+
+				// Let's check for the special case: The case for a source
+				// component where the output port is both the port that marks
+				// the headers and the port that propagates them ... Therefore
+				// no need to store the mark for later propagation...
+				if (propInfo.iPropagationPortIndex != aLocalPortIndex)
+					{
+					// Now, store temporarily the mark so the next time we send
+					// a buffer done callback in that propagation port, we mark
+					// that header accordingly...
+					// Unsuccessful insertion is ignored.
+					iBufferMarks.Append(
+						TOutputPortBufferMarkInfo(
+							propInfo.iPropagationPortIndex,
+							apBufferHeader->hMarkTargetComponent,
+							apBufferHeader->pMarkData));
+
+					// At this point the mark has been set for propagation to
+					// an output port. Remove the mark from the processed
+					// header...
+					apBufferHeader->hMarkTargetComponent = 0;
+					apBufferHeader->pMarkData = 0;
+					}
+				}
+			}
+		}
+	else
+		{
+		if(iBufferMarks.Count() != 0)
+			{
+			// Let's see if we have a mark waiting to go out...This will find the
+			// first mark in the local list of marks ...
+			const TInt index = iBufferMarks.Find(
+				TOutputPortBufferMarkInfo(aLocalPortIndex),
+				TIdentityRelation<TOutputPortBufferMarkInfo>(
+					&TOutputPortBufferMarkInfo::Compare));
+			if (index != KErrNotFound)
+				{
+				const TOutputPortBufferMarkInfo& markInfo =
+					iBufferMarks[index];
+
+				// Mark the header...
+				apBufferHeader->hMarkTargetComponent = markInfo.ipMarkTargetComponent;
+				apBufferHeader->pMarkData			 = markInfo.ipMarkData;
+
+				// Remove the mark info from the local store
+				iBufferMarks.Remove(index);
+				}
+			}
+
+		}
+
+
+	}
+
+EXPORT_C void
+XOmxILCallbackManagerIfImpl::HandleInsufficientResources()
+	{
+    DEBUG_PRINTF3(_L8("XOmxILCallbackManagerIfImpl::HandleInsufficientResources : ipCallbacks[%X] ipHandle[%X]"), ipCallbacks, ipHandle);
+
+	if (ipCallbacks && ipHandle)
+		{
+		// This is a best-effort action, let's try to inform the IL Client of
+		// the lack of resources...
+		ipCallbacks->EventHandler(ipHandle,
+								  ipAppData,
+								  OMX_EventError,
+					  			  (OMX_U32)OMX_ErrorInsufficientResources,
+								  0,
+								  0);
+		}
+	}