diff -r 000000000000 -r 0e4a32b9112d omxil_generic/omxilcomplib/src/omxilport.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil_generic/omxilcomplib/src/omxilport.cpp	Wed Aug 25 12:40:50 2010 +0300
@@ -0,0 +1,716 @@
+// Copyright (c) 2008-2010 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 <mmf/server/mmfbuffer.h>
+#include <mmf/server/mmfdatabuffer.h>
+
+#include "log.h"
+#include "omxilportimpl.h"
+#include <openmax/il/common/omxilport.h>
+#include <openmax/il/common/omxilutil.h>
+
+const TInt COmxILPort::KBufferMarkPropagationPortNotNeeded;
+
+EXPORT_C
+TOmxILCommonPortData::TOmxILCommonPortData(
+	OMX_VERSIONTYPE aOmxVersion,
+	OMX_U32 aPortIndex,
+	OMX_DIRTYPE aDirection,
+	OMX_U32 aBufferCountMin,
+	OMX_U32 aBufferSizeMin,
+	OMX_PORTDOMAINTYPE aPortDomain,
+	OMX_BOOL aBuffersContiguous,
+	OMX_U32 aBufferAlignment,
+	OMX_BUFFERSUPPLIERTYPE aBufferSupplier,
+	OMX_U32 aBufferMarkPropagationPortIndex)
+	:
+	iOmxVersion(aOmxVersion),
+	iPortIndex(aPortIndex),
+	iDirection(aDirection),
+	iBufferCountMin(aBufferCountMin),
+	iBufferSizeMin(aBufferSizeMin),
+	iPortDomain(aPortDomain),
+	iBuffersContiguous(aBuffersContiguous),
+	iBufferAlignment(aBufferAlignment),
+	iBufferSupplier(aBufferSupplier),
+	iBufferMarkPropagationPortIndex(aBufferMarkPropagationPortIndex)
+	{
+	}
+
+
+COmxILPort::COmxILPort()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::COmxILPort"));
+	}
+
+
+COmxILPort::~COmxILPort()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::~COmxILPort"));
+	delete ipPortImpl;
+	}
+
+void COmxILPort::ConstructL(const TOmxILCommonPortData& aCommonPortData)
+	{
+    __ASSERT_DEBUG(aCommonPortData.iDirection == OMX_DirInput ||
+                   aCommonPortData.iDirection == OMX_DirOutput,
+                   User::Panic(KOmxILPortPanicCategory, 1));
+
+    // From Section 3.1.2.12.1 .
+    //
+    // nBufferCountMin : "The component shall define this non-zero default
+    // value."
+    //
+    // nBufferCountActual : "The component shall set a default value no less
+    // than nBufferCountMin for this field"
+    __ASSERT_DEBUG(aCommonPortData.iBufferCountMin > 0,
+                   User::Panic(KOmxILPortPanicCategory, 1));
+    
+	ipPortImpl=COmxILPortImpl::NewL(aCommonPortData, *this);
+	}
+	
+OMX_ERRORTYPE
+COmxILPort::GetLocalOmxParamIndexes(RArray<TUint>& aIndexArray) const
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::GetLocalOmxParamIndexes"));
+	
+	TInt err = aIndexArray.InsertInOrder(OMX_IndexParamPortDefinition);
+
+	// Note that index duplication is OK.
+	if (KErrNone == err || KErrAlreadyExists == err)
+		{
+		err = aIndexArray.InsertInOrder(OMX_IndexParamCompBufferSupplier);
+		}
+
+	if (KErrNone != err && KErrAlreadyExists != err)
+		{
+		return OMX_ErrorInsufficientResources;
+		}
+
+	return OMX_ErrorNone;
+
+	}
+
+OMX_ERRORTYPE
+COmxILPort::GetLocalOmxConfigIndexes(RArray<TUint>& /*aIndexArray*/) const
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::GetLocalOmxConfigIndexes"));
+
+	return OMX_ErrorNone;
+
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::GetParameter(OMX_INDEXTYPE aParamIndex,
+						 TAny* apComponentParameterStructure) const
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::GetParameter"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetParameter(aParamIndex, apComponentParameterStructure);
+	}
+
+OMX_ERRORTYPE
+COmxILPort::SetParameter(OMX_INDEXTYPE aParamIndex,
+						 const TAny* apComponentParameterStructure,
+						 TBool& aUpdateProcessingFunction)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetParameter"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetParameter(aParamIndex, apComponentParameterStructure, aUpdateProcessingFunction);
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::GetConfig(OMX_INDEXTYPE /*aConfigIndex*/,
+					  TAny* /*apComponentConfigStructure*/) const
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::GetConfig"));
+	return OMX_ErrorUnsupportedIndex;
+	}
+
+OMX_ERRORTYPE
+COmxILPort::SetConfig(OMX_INDEXTYPE /*aConfigIndex*/,
+					  const TAny* /*apComponentConfigStructure*/,
+					  TBool& /*aUpdateProcessingFunction*/)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetConfig"));
+	return OMX_ErrorUnsupportedIndex;
+	}
+
+OMX_ERRORTYPE
+COmxILPort::GetExtensionIndex(OMX_STRING /* aParameterName */,
+							  OMX_INDEXTYPE* /* apIndexType */) const
+	{
+	// This method is intended to be overridden by the concrete ports when
+	// needed...
+	return OMX_ErrorUnsupportedIndex;
+	}
+
+OMX_ERRORTYPE
+COmxILPort::PopulateBuffer(OMX_BUFFERHEADERTYPE** appBufferHdr,
+						   const OMX_PTR apAppPrivate,
+						   OMX_U32 aSizeBytes,
+						   OMX_U8* apBuffer,
+						   TBool& aPortPopulationCompleted)
+	{
+    DEBUG_PRINTF2(_L8("COmxILPort::PopulateBuffer : pBuffer [%X]"), apBuffer);
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->PopulateBuffer(appBufferHdr, apAppPrivate, aSizeBytes, apBuffer, aPortPopulationCompleted);
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::FreeBuffer(OMX_BUFFERHEADERTYPE* apBufferHeader,
+					   TBool& aPortDepopulationCompleted)
+	{
+    DEBUG_PRINTF2(_L8("COmxILPort::FreeBuffer : BUFFER [%X]"), apBufferHeader);
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->FreeBuffer(apBufferHeader, aPortDepopulationCompleted);
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::TunnelRequest(OMX_HANDLETYPE aTunneledComp,
+						  OMX_U32 aTunneledPort,
+						  OMX_TUNNELSETUPTYPE* apTunnelSetup)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::TunnelRequest"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->TunnelRequest(aTunneledComp, aTunneledPort, apTunnelSetup);
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::PopulateTunnel(TBool& portPopulationCompleted)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::PopulateTunnel"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->PopulateTunnel(portPopulationCompleted);
+	}
+
+
+OMX_ERRORTYPE
+COmxILPort::FreeTunnel(TBool& portDepopulationCompleted)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::FreeTunnel"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->FreeTunnel(portDepopulationCompleted);
+	}
+
+
+
+TBool
+COmxILPort::SetBufferSent(OMX_BUFFERHEADERTYPE* apBufferHeader,
+						  TBool& aBufferMarkedWithOwnMark)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetBufferSent"));
+	__ASSERT_DEBUG(apBufferHeader, User::Panic(KOmxILPortPanicCategory, 1));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetBufferSent(apBufferHeader, aBufferMarkedWithOwnMark);
+	}
+
+TBool
+COmxILPort::SetBufferReturned(OMX_BUFFERHEADERTYPE* apBufferHeader)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetBufferReturned"));
+
+	__ASSERT_DEBUG(apBufferHeader, User::Panic(KOmxILPortPanicCategory, 1));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetBufferReturned(apBufferHeader);
+	}
+
+void
+COmxILPort::SetTransitionToEnabled()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetTransitionToEnabled"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetTransitionToEnabled();
+	}
+
+void
+COmxILPort::SetTransitionToDisabled()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetTransitionToDisabled"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetTransitionToDisabled();
+	}
+
+void
+COmxILPort::SetTransitionToDisabledCompleted()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetTransitionToDisabledCompleted"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetTransitionToDisabledCompleted();
+	}
+
+void
+COmxILPort::SetTransitionToEnabledCompleted()
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetTransitionToEnabledCompleted"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->SetTransitionToEnabledCompleted();
+	}
+
+OMX_ERRORTYPE
+COmxILPort::StoreBufferMark(const OMX_MARKTYPE* apMark)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::StoreBufferMark"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->StoreBufferMark(apMark);
+	}
+
+
+/**
+   This utility method may be called from the most derived port
+   class' destructor to delete any buffer header and or buffer that may remain
+   allocated in the port. This typically happens when the component is unloaded
+   without being properly transitioned from OMX_StateIdle to OMX_StateLoaded.
+
+ */
+EXPORT_C void
+COmxILPort::CleanUpPort()
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->CleanUpPort();
+	}
+
+/**
+   This is to be overriden by concrete ports that either support more than
+   one role or that want to let the IL Client to reset the component to
+   some default state...
+
+   @param aComponentRoleIndex The index of the role that is to be assumed by
+   the component.
+
+   @return OMX_ERRORTYPE
+ */
+OMX_ERRORTYPE
+COmxILPort::SetComponentRoleDefaults(TUint /*aComponentRoleIndex*/)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::SetComponentRoleDefaults"));
+
+	return OMX_ErrorNotImplemented;
+	}
+
+/**
+   This is to be overriden by concrete ports that either support more than one
+   role or that want to let the IL Client to reset the component to some
+   default state...
+
+   @param aPortSettingsIndex An implementation-specific identifier that the
+   implementation associates to the setting(s) that need(s) updating in the
+   port.
+
+   @param aPortSettings A buffer descriptor that contains an
+   implementation-specific structure with the new setting(s) that need to
+   be updated in the port.
+
+   @param [output] aEventForILClient An event that the port may choose to
+   deliver to the IL Client. This should be one of OMX_EventPortSettingsChanged
+   or OMX_EventPortFormatDetected. Use OMX_EventMax if no event need to be
+   sent.
+ */
+OMX_ERRORTYPE
+COmxILPort::DoPortReconfiguration(TUint /* aPortSettingsIndex */,
+								  const TDesC8& /* aPortSettings */,
+								  OMX_EVENTTYPE& aEventForILClient)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::DoPortReconfiguration"));
+
+	// This means no need to notify the IL Client...
+	aEventForILClient = OMX_EventMax;
+
+	return OMX_ErrorNotImplemented;
+	}
+
+OMX_ERRORTYPE
+COmxILPort::StoreBufferMark(OMX_HANDLETYPE& ipMarkTargetComponent,
+							OMX_PTR& ipMarkData)
+	{
+    DEBUG_PRINTF(_L8("COmxILPort::StoreBufferMark"));
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->StoreBufferMark(ipMarkTargetComponent, ipMarkData);
+	}
+
+TBool
+COmxILPort::HasAllBuffersAtHome() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	__ASSERT_ALWAYS(ipPortImpl->IsTunnelledAndBufferSupplier(),
+					User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->HasAllBuffersAtHome();
+	}
+
+TBool
+COmxILPort::IsBufferAtHome(OMX_BUFFERHEADERTYPE* apBufferHeader) const
+	{
+	DEBUG_PRINTF2(_L8("COmxILPort::IsBufferAtHome : [%X]"), apBufferHeader);
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsBufferAtHome(apBufferHeader);
+	}
+
+
+/**
+   This method provides a mechanism for ports to place the port-specific
+   buffer allocation logic (typically used in an OMX_AllocateBuffer
+   scenario).
+
+   @param aSizeBytes The size in bytes of the buffer to be allocated.
+
+   @param [OUT] apPortSpecificBuffer A pointer to the memory area allocated by
+   the port.
+
+   @param [OUT] apPortPrivate A pointer that refers to an optional
+   port-specific structure.
+
+   @apPlatformPrivate[OUT] A pointer to an optional platform-specific
+   structure.
+
+   @param apAppPrivate A pointer that refers to a buffer supplier-specific
+   structure.
+
+   @return OMX_ERRORTYPE
+*/
+OMX_ERRORTYPE
+COmxILPort::DoBufferAllocation(OMX_U32 aSizeBytes,
+							   OMX_U8*& apPortSpecificBuffer,
+							   OMX_PTR& apPortPrivate,
+							   OMX_PTR& /* apPlatformPrivate */,
+							   OMX_PTR /* apAppPrivate = 0 */)
+	{
+	DEBUG_PRINTF2(_L8("COmxILPort::DoBufferAllocation : aSizeBytes[%u]"), aSizeBytes);
+
+	__ASSERT_DEBUG(aSizeBytes > 0, User::Panic(KOmxILPortPanicCategory, 1));
+
+	CMMFDescriptorBuffer* pDescBuffer = 0;
+	TRAPD(allocRes, pDescBuffer = CMMFDescriptorBuffer::NewL(aSizeBytes));
+	if (KErrNone != allocRes)
+		{
+		return OMX_ErrorInsufficientResources;
+		}
+
+	apPortSpecificBuffer = const_cast<TUint8*>(pDescBuffer->Data().Ptr());
+	apPortPrivate		 = static_cast<CMMFBuffer*>(pDescBuffer);
+
+	return OMX_ErrorNone;
+
+	}
+
+/**
+   This method provides a mechanism for ports to place the port-specific
+   buffer deallocation logic (typically used in an OMX_FreeBuffer
+   scenario).
+
+   @param apPortSpecificBuffer A pointer to the memory area to be deallocated
+   by the port.
+
+   @param apPortPrivate A pointer that refers to a port-specific structure.
+
+   @param apPlatformPrivate A pointer to an optional platform-specific
+   structure.
+
+   @param apAppPrivate A pointer that refers to a buffer supplier-specific
+   structure.
+
+*/
+void
+COmxILPort::DoBufferDeallocation(OMX_PTR /*apPortSpecificBuffer */,
+								 OMX_PTR apPortPrivate,
+								 OMX_PTR /* apPlatformPrivate */,
+								 OMX_PTR /* apAppPrivate = 0 */)
+	{
+	DEBUG_PRINTF(_L8("COmxILPort::DoBufferDeallocation"));
+
+	__ASSERT_DEBUG(apPortPrivate, User::Panic(KOmxILPortPanicCategory, 1));
+
+	delete reinterpret_cast<CMMFBuffer*>(apPortPrivate);
+
+	}
+
+/**
+   This method provides a mechanism for ports to place the port-specific buffer
+   wrapping logic (typically used in an OMX_UseBuffer scenario).
+
+   @param aSizeBytes The size in bytes of the buffer to be wrapped.
+
+   @param apBuffer A pointer received from the IL Client or another
+   component that references the allocated memory area .
+
+   @param [OUT] apPortPrivate A pointer that refers to a port-specific
+   structure.
+
+   @param [OUT] apPlatformPrivate A pointer to an optional platform-specific
+   structure.
+
+   @param [OUT] apAppPrivate A pointer that refers to a buffer
+   supplier-specific structure.
+
+   @return OMX_ERRORTYPE
+*/
+OMX_ERRORTYPE
+COmxILPort::DoBufferWrapping(OMX_U32 aSizeBytes,
+							 OMX_U8* apBuffer,
+							 OMX_PTR& apPortPrivate,
+							 OMX_PTR& /* apPlatformPrivate */,
+							 OMX_PTR /* apAppPrivate = 0 */)
+	{
+	DEBUG_PRINTF(_L8("COmxILPort::DoBufferWrapping"));
+
+	__ASSERT_DEBUG(aSizeBytes > 0 && apBuffer,
+				   User::Panic(KOmxILPortPanicCategory, 1));
+
+	CMMFBuffer* pMmfBuffer = 0;
+	TPtr8 ptr(apBuffer, aSizeBytes, aSizeBytes);
+	TRAPD(allocRes, pMmfBuffer = CMMFPtrBuffer::NewL(ptr));
+	if (KErrNone != allocRes)
+		{
+		return OMX_ErrorInsufficientResources;
+		}
+
+	apPortPrivate = pMmfBuffer;
+
+	return OMX_ErrorNone;
+
+	}
+
+/**
+   This method provides a mechanism for ports to place the port-specific buffer
+   unwrapping logic (typically used in an OMX_FreeBuffer scenario).
+
+   @param apPortSpecificBuffer A pointer to the allocated memory area.
+
+   @param apPortPrivate A pointer that refers to a port-specific structure.
+
+   @param apPlatformPrivate A pointer to an optional platform-specific
+   structure.
+
+   @param apAppPrivate A pointer that refers to a buffer supplier-specific
+   structure.
+
+*/
+void
+COmxILPort::DoBufferUnwrapping(OMX_PTR /* apBuffer*/,
+							   OMX_PTR appPortPrivate,
+							   OMX_PTR /* apPlatformPrivate */,
+							   OMX_PTR /* apAppPrivate = 0 */)
+	{
+
+	DEBUG_PRINTF(_L8("COmxILPort::DoBufferUnwrapping"));
+
+	__ASSERT_DEBUG(appPortPrivate, User::Panic(KOmxILPortPanicCategory, 1));
+
+	delete reinterpret_cast<CMMFBuffer*>(appPortPrivate);
+
+	}
+
+/**
+   This method gets called during tunnelled buffer allocation (i.e.,
+   PopulateTunnel). This is to allow component implementations to override this
+   default implementation in a way that the pAppPrivate pointer parameter of
+   OMX_UseBuffer can be used to convey pPortPrivate or pPlatformPrivate to the
+   tunnelled component.
+
+   @param aTunnelledComponent Handle to the tunnelled component
+
+   @param [OUT] appBufferHdr The buffer header that will be allocated by the
+   tunnelled component
+
+   @param aTunnelledPortIndex The index of the tunnelled port
+
+   @param apPortPrivate pPortPrivate pointer as returned by DoBufferAllocation
+
+   @param apPlatformPrivate pPlatformPrivate pointer as returned by
+   DoBufferAllocation
+
+   @aSizeBytes The size in bytes of the to be allocated buffer
+
+   @apBuffer A pointer to the allocated buffer
+
+   @return OMX_ERRORTYPE
+
+*/
+OMX_ERRORTYPE
+COmxILPort::DoOmxUseBuffer(OMX_HANDLETYPE aTunnelledComponent,
+						   OMX_BUFFERHEADERTYPE** appBufferHdr,
+						   OMX_U32 aTunnelledPortIndex,
+						   OMX_PTR /* apPortPrivate */,
+						   OMX_PTR /* apPlatformPrivate */,
+						   OMX_U32 aSizeBytes,
+						   OMX_U8* apBuffer)
+	{
+
+	DEBUG_PRINTF(_L8("COmxILPort::DoOmxUseBuffer"));
+
+	return OMX_UseBuffer(
+		aTunnelledComponent,
+		appBufferHdr,
+		aTunnelledPortIndex,
+		0,
+		aSizeBytes,
+		apBuffer);
+
+	}
+
+
+OMX_DIRTYPE
+COmxILPort::Direction() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->Direction();
+	}
+
+EXPORT_C TBool
+COmxILPort::IsEnabled() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsEnabled();
+	}
+
+TBool
+COmxILPort::IsPopulated() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsPopulated();
+	}
+
+TBool
+COmxILPort::IsDePopulated() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsDePopulated();
+	}
+
+TBool
+COmxILPort::IsTunnelled() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsTunnelled();
+	}
+
+TBool
+COmxILPort::IsTunnelledAndBufferSupplier() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsTunnelledAndBufferSupplier();
+	}
+
+TBool
+COmxILPort::IsTransitioningToEnabled() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsTransitioningToEnabled();
+	}
+
+TBool
+COmxILPort::IsTransitioningToDisabled() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->IsTransitioningToDisabled();
+	}
+
+EXPORT_C OMX_U32
+COmxILPort::Index() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->Index();
+	}
+
+OMX_PORTDOMAINTYPE
+COmxILPort::Domain() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->Domain();
+	}
+
+OMX_U32
+COmxILPort::Count() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->Count();
+	}
+
+OMX_BUFFERHEADERTYPE* const&
+COmxILPort::operator[](TInt anIndex) const
+	{
+	return this->operator[](anIndex);
+	}
+
+OMX_BUFFERHEADERTYPE*&
+COmxILPort::operator[](TInt anIndex)
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->operator[](anIndex);
+	}
+
+
+OMX_U32
+COmxILPort::BufferMarkPropagationPort() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->BufferMarkPropagationPort();
+	}
+
+EXPORT_C const OMX_PARAM_PORTDEFINITIONTYPE& COmxILPort::GetParamPortDefinition() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetParamPortDefinition();
+	}
+	
+EXPORT_C const OMX_HANDLETYPE& COmxILPort::GetTunnelledComponent() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetTunnelledComponent();
+	}
+	
+EXPORT_C const OMX_U32& COmxILPort::GetTunnelledPort() const
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetTunnelledPort();
+	}
+
+EXPORT_C OMX_PARAM_PORTDEFINITIONTYPE& COmxILPort::GetParamPortDefinition()
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetParamPortDefinition();
+	}
+	
+EXPORT_C OMX_HANDLETYPE& COmxILPort::GetTunnelledComponent()
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetTunnelledComponent();
+	}
+	
+EXPORT_C OMX_U32& COmxILPort::GetTunnelledPort()
+	{
+	__ASSERT_ALWAYS(ipPortImpl, User::Panic(KOmxILPortPanicCategory, 1));
+	return ipPortImpl->GetTunnelledPort();
+	}
+
+EXPORT_C
+TInt COmxILPort::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)
+	{
+	return CBase::Extension_(aExtensionId, a0, a1);
+	}	
+
+
+
+