diff -r 735348f59235 -r 948c7f65f6d4 omxil/mmilapi/unittest/test_plugins/omxildummybaseilif/omxildummybaseilifbody.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/mmilapi/unittest/test_plugins/omxildummybaseilif/omxildummybaseilifbody.cpp	Wed Sep 01 12:38:50 2010 +0100
@@ -0,0 +1,415 @@
+// 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:
+//
+
+#include "omxildummybaseilifbody.h"
+#include "omxilcoreutils.h"
+#include "omxilspecversion.h"
+#include "milifobserver.h"
+#include "tilstructtypes.h"
+
+
+const TInt KMaxComponentNameLength = 128;
+
+
+COmxILDummyBaseILIF::CBody::CBody(COmxILDummyBaseILIF& aParent,
+								  MILIfObserver& aComponentIfObserver)
+	:
+	iParent(aParent),
+	iIfObserver(aComponentIfObserver)
+    {
+    }
+
+COmxILDummyBaseILIF::CBody::~CBody()
+    {
+    iInputPorts.ResetAndDestroy();
+    iInputPorts.Close();
+    iOutputPorts.ResetAndDestroy();
+    iOutputPorts.Close();
+    delete iBufferManager;    
+    delete iCallbacks;    
+
+	::OMX_FreeHandle(reinterpret_cast<OMX_HANDLETYPE>(iHandle));
+    }
+
+COmxILDummyBaseILIF::CBody* COmxILDummyBaseILIF::CBody::NewL(COmxILDummyBaseILIF& aParent,
+													 	 MILIfObserver& aComponentIfObserver,
+													 	 const TDesC8& aComponentName)
+    {
+	CBody* self = new (ELeave) CBody(aParent, aComponentIfObserver);
+    CleanupStack::PushL(self);
+	self->ConstructL(aComponentName);
+    CleanupStack::Pop(self);
+    return self;
+    }
+    
+void COmxILDummyBaseILIF::CBody::ConstructL(const TDesC8& aComponentName)
+    {
+	iCallbacks = COmxCallbacks::NewL(iParent);
+	
+	RBuf8 buf;
+	buf.CleanupClosePushL();
+	buf.CreateL(aComponentName, KMaxComponentNameLength);
+    TUint8* name = const_cast<TUint8*>(buf.PtrZ());
+
+	OMX_ERRORTYPE errorType = ::OMX_GetHandle(reinterpret_cast<OMX_HANDLETYPE*>(&iHandle), 
+								reinterpret_cast<OMX_STRING>(name), 
+								iCallbacks, 
+							    *iCallbacks);
+	CleanupStack::PopAndDestroy(&buf);
+
+    User::LeaveIfError(ConvertOmxErrorType(errorType));
+
+    iBufferManager = new (ELeave) COmxBufferManager(iHandle);
+    }
+
+OMX_COMPONENTTYPE* COmxILDummyBaseILIF::CBody::Handle() const
+    {
+    return iHandle;    
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxGetComponentVersion(TPtr8 aComponentName, 
+                                                        OMX_VERSIONTYPE* aComponentVersion, 
+                                                        OMX_VERSIONTYPE* aSpecVersion, 
+                                                        OMX_UUIDTYPE* aComponentUUID)
+    {
+	ASSERT(aComponentVersion);
+	ASSERT(aSpecVersion);
+	ASSERT(aComponentUUID);
+    TUint8* cname = const_cast<TUint8*>(aComponentName.PtrZ());
+    OMX_ERRORTYPE error = iHandle->GetComponentVersion(reinterpret_cast<OMX_HANDLETYPE>(iHandle), 
+						  reinterpret_cast<OMX_STRING>(cname), aComponentVersion, aSpecVersion, aComponentUUID);
+
+	TLex8 lex(cname);
+	TInt length;
+	for( length = 0; !lex.Eos(); ++length )
+		{
+		lex.Inc();
+		}
+	aComponentName.SetLength(length);
+    return ConvertOmxErrorType(error);
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxSendCommand(OMX_COMMANDTYPE aCmd, 
+												TUint32 aParam, 
+												TAny* aCmdData)
+    {
+	OMX_ERRORTYPE error = iHandle->SendCommand(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aCmd, aParam, aCmdData);
+    return ConvertOmxErrorType(error);
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxGetParameter(OMX_INDEXTYPE aParamIndex, 
+												 TAny* aValue)
+    {
+	ASSERT(aValue);
+	OMX_ERRORTYPE error = iHandle->GetParameter(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aParamIndex, aValue);
+    return ConvertOmxErrorType(error);
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxSetParameter(OMX_INDEXTYPE aIndex, 
+												 TAny* aValue)
+    {
+	ASSERT(aValue);
+	OMX_ERRORTYPE error = iHandle->SetParameter(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
+    return ConvertOmxErrorType(error);
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxGetConfig(OMX_INDEXTYPE aIndex, 
+											  TAny* aValue)
+    {
+	ASSERT(aValue);
+	OMX_ERRORTYPE error = iHandle->GetConfig(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
+    return ConvertOmxErrorType(error);
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxSetConfig(OMX_INDEXTYPE aIndex, 
+											  TAny* aValue)
+    {
+	ASSERT(aValue);
+	OMX_ERRORTYPE error = iHandle->SetConfig(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
+    return ConvertOmxErrorType(error);
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxGetExtensionIndex(const TDesC8& aParameterName, 
+													  OMX_INDEXTYPE* aIndexType)
+{
+    HBufC8* buf = HBufC8::New(aParameterName.Length()+1);
+    if (buf == NULL)
+        {
+        return KErrNoMemory;
+        }
+    else
+        {
+		*buf = aParameterName;
+		TUint8* cstring = const_cast<TUint8*>(buf->Des().PtrZ());
+		OMX_ERRORTYPE error = iHandle->GetExtensionIndex(reinterpret_cast<OMX_HANDLETYPE>(iHandle), reinterpret_cast<char*>(cstring), aIndexType);
+		delete buf;
+		return ConvertOmxErrorType(error);
+        }
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxGetState(OMX_STATETYPE*  aState)
+    {
+	OMX_ERRORTYPE error = iHandle->GetState(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aState);
+    return ConvertOmxErrorType(error);
+    }
+    
+TInt COmxILDummyBaseILIF::CBody::OmxComponentTunnelRequest(TUint32 aPortInput, 
+														   OMX_HANDLETYPE aOutput, 
+														   TUint32 aPortOutput)
+    {
+	OMX_ERRORTYPE error = ::OMX_SetupTunnel(aOutput, aPortOutput, reinterpret_cast<OMX_HANDLETYPE>(iHandle), aPortInput);
+    return ConvertOmxErrorType(error);
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxComponentDisconnectTunnel(TUint32 aPortInput, 
+														 	  OMX_HANDLETYPE aOutput, 
+														 	  TUint32 aPortOutput)
+	{
+	OMX_ERRORTYPE error = ::OMX_SetupTunnel(aOutput, aPortOutput, 0, 0);
+	if (error == OMX_ErrorNone)
+		{
+		error = ::OMX_SetupTunnel(0, 0, reinterpret_cast<OMX_HANDLETYPE>(iHandle), aPortInput);
+		}
+	return ConvertOmxErrorType(error);
+	}
+    
+TInt COmxILDummyBaseILIF::CBody::OmxUseBuffer(CMMFBuffer* aBuffer, 
+											  TUint32 aPortIndex)
+    {
+	ASSERT(aBuffer);
+    return (iBufferManager->UseBuffer(*aBuffer, aPortIndex));    
+    }
+
+CMMFBuffer* COmxILDummyBaseILIF::CBody::OmxAllocateBufferL(TUint32 aPortIndex, 
+														   TUint32 aSizeBytes)
+    {
+    return (iBufferManager->AllocateBufferL(aPortIndex, aSizeBytes));
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxFreeBuffer(CMMFBuffer* aBuffer)
+    {
+	ASSERT(aBuffer);
+    return (iBufferManager->FreeBuffer(aBuffer));
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer, 
+													MOmxILComponentIfObserver* aObserver)
+    {
+	ASSERT(aBuffer);
+    return (iBufferManager->EmptyThisBuffer(aBuffer, aObserver));
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxFillThisBuffer(CMMFBuffer* aBuffer, 
+												   MOmxILComponentIfObserver* aObserver)
+    {
+	ASSERT(aBuffer);
+    return (iBufferManager->FillThisBuffer(aBuffer, aObserver));
+    }
+
+TInt COmxILDummyBaseILIF::CBody::OmxComponentRoleEnum(TPtr8& aComponentRole, 
+													  TUint32 aIndex)
+    {
+    TUint8* role = const_cast<TUint8*> (aComponentRole.PtrZ());
+	OMX_ERRORTYPE error = iHandle->ComponentRoleEnum(reinterpret_cast<OMX_HANDLETYPE>(iHandle), reinterpret_cast<unsigned char*>(role), aIndex);
+
+	TLex8 lex(role);
+	TInt length;
+	for( length = 0; !lex.Eos(); ++length )
+		{
+		lex.Inc();
+		}
+	aComponentRole.SetLength(length);
+
+    return ConvertOmxErrorType(error);
+    }
+
+TInt COmxILDummyBaseILIF::CBody::SetIfToRole(const TUid& aComponentRole)
+    {
+    iFormat = aComponentRole;
+    return KErrNone;
+    }
+
+TInt COmxILDummyBaseILIF::CBody::GetIfRole(TUid& aComponentRole) const
+    {
+    aComponentRole = iFormat;
+    return KErrNone;    
+    }
+
+TInt COmxILDummyBaseILIF::CBody::SetPortsL()
+    {
+    OMX_PORT_PARAM_TYPE param;
+    param.nVersion = KOMXILSpecVersion;
+    param.nSize = sizeof(OMX_PORT_PARAM_TYPE);
+    TInt err = OmxGetParameter(OMX_IndexParamAudioInit, &param);
+    
+    if (err == KErrNone)
+        {
+        for (TInt i=0; i < param.nPorts && err == KErrNone; i++ )
+            {
+            OMX_PARAM_PORTDEFINITIONTYPE portInfo;
+            portInfo.nPortIndex = i;
+			portInfo.nVersion = KOMXILSpecVersion;
+			portInfo.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
+            err = OmxGetParameter(OMX_IndexParamPortDefinition, &portInfo);    
+			if (err == KErrNone)
+				{
+            if (portInfo.eDir == OMX_DirInput)
+                {
+                COmxILDummyBasePortILIF* inputPort = COmxILDummyBasePortILIF::NewL(iParent, EDirInput, portInfo.nPortIndex);
+                err = iInputPorts.Append(inputPort);
+                }
+            else
+                {
+                COmxILDummyBasePortILIF* outputPort = COmxILDummyBasePortILIF::NewL(iParent, EDirOutput, portInfo.nPortIndex);
+                err = iOutputPorts.Append(outputPort);                
+					}
+				}
+			}
+		}
+    return err;
+    }
+
+TInt COmxILDummyBaseILIF::CBody::GetComponentPorts(RPointerArray<MILComponentPortIf>& aComponentPorts, 
+												   OMX_DIRTYPE aDirection)
+    {
+    TInt err = KErrNone;
+    if     (aDirection == OMX_DirInput)
+        {
+		const TInt counter = iInputPorts.Count();
+		for (TInt i=0; i < counter && err == KErrNone; i++ )
+            {
+            err = aComponentPorts.Append(iInputPorts[i]);
+            }
+        }
+    else if (aDirection == OMX_DirOutput)
+        {
+		const TInt counter = iOutputPorts.Count();
+		for (TInt i=0; i < counter && err == KErrNone; i++ )
+            {
+            err = aComponentPorts.Append(iOutputPorts[i]);
+            }            
+        }
+    else 
+        {
+        err = KErrNotSupported;
+        }
+    return err;
+    }
+
+TInt COmxILDummyBaseILIF::CBody::FillBufferDone(CMMFBuffer* aBuffer, 
+												TInt aPortIndex)
+    {
+	ASSERT(aBuffer);
+    // Loop through all output ports to search for the interface associated to this port index
+	const TInt counter = iOutputPorts.Count();
+	for (TInt i=0; i < counter; i++ )
+        {
+        if (iOutputPorts[i]->PortIndex() == aPortIndex)
+            {
+			return (iIfObserver.BufferDelivered(iOutputPorts[i], aBuffer));
+            }
+        }
+
+    return KErrNotFound;
+    }
+
+TInt COmxILDummyBaseILIF::CBody::EmptyBufferDone(const CMMFBuffer* aBuffer, 
+												 TInt aPortIndex)
+    {
+	ASSERT(aBuffer);
+    // Loop through all input ports to search for the interface associated to this port index
+	const TInt counter = iInputPorts.Count();
+	for (TInt i=0; i < counter; i++ )
+        {
+        if (iInputPorts[i]->PortIndex() == aPortIndex)
+            {
+			return (iIfObserver.BufferDelivered(iInputPorts[i], aBuffer));
+            }
+        }
+
+    return KErrNotFound;
+    }
+
+TInt COmxILDummyBaseILIF::CBody::EventHandler(OMX_EVENTTYPE aEvent, 
+											  TUint32 aData1, 
+											  TUint32 aData2, 
+											  TAny* /*aExtraInfo*/)
+    {
+    TInt err = KErrNone;
+    TILEvent thisEvent;
+
+	switch (aEvent)
+		{
+		case OMX_EventCmdComplete:
+			{
+			thisEvent.iEvent = EEventCmdComplete;
+			if (aData1 == OMX_CommandStateSet)
+				{
+				thisEvent.iData1 = ECommandStateSet;				
+				OMX_STATETYPE state = static_cast<OMX_STATETYPE>(aData2);	
+				thisEvent.iData2 = ConvertOmxState(state);
+				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+				break;	
+				}
+			else if (aData1 == OMX_CommandFlush)
+				{
+				thisEvent.iData1 = ECommandFlush;				
+				thisEvent.iData2 = aData2; // Port index
+				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+				}
+			else if (aData1 == OMX_CommandPortDisable)
+				{
+				thisEvent.iData1 = ECommandPortDisable;				
+				thisEvent.iData2 = aData2; // Port index
+				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+				}
+			else if (aData1 == OMX_CommandPortEnable)
+				{
+				thisEvent.iData1 = ECommandPortEnable;				
+				thisEvent.iData2 = aData2; // Port index
+				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+				}
+			else 
+				{
+				err = KErrNotSupported; 
+				}
+			
+			break;
+			}
+		case OMX_EventBufferFlag:
+			{
+			// Propagate the EOF up to client as KErrUnderflow
+			thisEvent.iEvent = EEventBufferFlag;
+			thisEvent.iData1 = aData1;				
+			thisEvent.iData2 = static_cast<TUint32>(KErrUnderflow);
+			err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+			break;
+			}
+		case OMX_EventError:
+			{
+			// Propagate the error up to client
+			thisEvent.iEvent = EEventError;
+			OMX_ERRORTYPE errorx = static_cast<OMX_ERRORTYPE>(aData1);
+			thisEvent.iData1 = ConvertOmxErrorType(errorx);				
+			err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
+			break;
+			}
+		default:
+			{
+			err = KErrNotSupported;
+			}
+		}
+	return err;
+	}