// Copyright (c) 2005-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 <e32base.h>

#include <e32msgqueue.h>

#include <mmf/server/mmfdatabuffer.h>

#include "omxcomponentbody.h"

#include "omxcomponentimpl.h"

const TInt KMaxMsgQueueEntries = 10;

const TInt KMaxComponentNameLength = 256;

const TInt KSymbianErrors[] =

	{

	KErrNoMemory, /*OMX_ErrorInsufficientResources*/

	KErrUnknown,

	KErrBadName,

	KErrNotFound,

	KErrGeneral, /*OMX_ErrorInvalidComponent*/

	KErrArgument, /*OMX_ErrorBadParameter*/

	KErrNotSupported, /*OMX_ErrorNotImplemented*/

	KErrUnderflow, /*OMX_ErrorUnderflow*/

	KErrOverflow, /*OMX_ErrorOverflow*/

	KErrHardwareNotAvailable, /* OMX_ErrorHardware*/

	KErrGeneral, /*OMX_ErrorInvalidState*/

  	KErrCorrupt, /*OMX_ErrorStreamCorrupt*/

  	KErrArgument, /*OMX_ErrorPortsNotCompatible*/

  	KErrHardwareNotAvailable, /*OMX_ErrorResourcesLost*/

  	KErrCompletion, /*OMX_ErrorNoMore*/ 

  	KErrGeneral, /*OMX_ErrorVersionMismatch*/

  	KErrNotReady, /*OMX_ErrorNotReady*/

  	KErrTimedOut, /*OMX_ErrorTimeout*/

  	KErrNone /*OMX_ErrorSameState*/

	};

/**

 Converts an OpenMAX error code to a Symbian error code.

 @param		aErrorType The OpenMAX error code.

 @return	The Symbian error code.

 */

TInt ConvertOmxErrorType(OMX_ERRORTYPE aErrorType)

	{

	if (aErrorType == OMX_ErrorNone)

		{

		return KErrNone;

		}

	else if (aErrorType >= OMX_ErrorInsufficientResources &&

			  aErrorType <= OMX_ErrorSameState)

		{

		return KSymbianErrors[aErrorType - OMX_ErrorInsufficientResources];

		}

	else

		{

		return KErrGeneral;

		}

	}

/**

 Converts a Symbian error code to an OpenMAX error code.

 @param		aError The Symbian error code.

 @return	The OpenMAX error code.

 */

OMX_ERRORTYPE ConvertSymbianErrorType(TInt aError)

	{

	OMX_ERRORTYPE err = OMX_ErrorNone;

	switch (aError)

		{

	case KErrNone:

		err = OMX_ErrorNone;

		break;

	case KErrNoMemory:

		err = OMX_ErrorInsufficientResources;

		break;

	case KErrGeneral:

		break;

	default:

		err = OMX_ErrorUndefined;

		}

	return err;

	}

COmxBufferManager::COmxBufferManager(OMX_COMPONENTTYPE* aHandle)

	: iHandle(aHandle)

	{

	}

COmxBufferManager::COmxBuffer::COmxBuffer()

	{

	}

COmxBufferManager::COmxBuffer* COmxBufferManager::COmxBuffer::NewL(OMX_BUFFERHEADERTYPE* aBufferHeader, CMMFBuffer* aBuffer)

	{

	COmxBuffer* self = new (ELeave) COmxBuffer;

	CleanupStack::PushL(self);

	self->ConstructL(aBufferHeader, aBuffer);

	CleanupStack::Pop(self);

	return self;

	}

COmxBufferManager::COmxBuffer::~COmxBuffer()

	{

	if (iOwnsMmfBuffer)

		{

		delete iMmfBuffer;

		}

	}

CMMFBuffer* COmxBufferManager::COmxBuffer::MmfBuffer() const

	{

	return iMmfBuffer;

	}

OMX_BUFFERHEADERTYPE* COmxBufferManager::COmxBuffer::BufferHeader() const

	{

	return iBufferHeader;

	}

MOmxInputPortCallbacks* COmxBufferManager::COmxBuffer::InputPortCallbacks() const

	{

	return iInputPortCallbacks;

	}

MOmxOutputPortCallbacks* COmxBufferManager::COmxBuffer::OutputPortCallbacks() const

	{

	return iOutputPortCallbacks;

	}

void COmxBufferManager::COmxBuffer::SetInputPortCallbacks(MOmxInputPortCallbacks* aCallbacks)

	{

	iInputPortCallbacks = aCallbacks;

	}

void COmxBufferManager::COmxBuffer::SetOutputPortCallbacks(MOmxOutputPortCallbacks* aCallbacks)

	{

	iOutputPortCallbacks = aCallbacks;

	}

// look up the corresponding buffer

COmxBufferManager::COmxBuffer* COmxBufferManager::FindBuffer(const CMMFBuffer* aBuffer) const

	{

	COmxBuffer* buffer = NULL;

	for (TInt i=0;i<iBuffers.Count() && !buffer;i++)

		{

		if (iBuffers[i]->MmfBuffer() == aBuffer)

			{

			buffer = iBuffers[i];

			}

		}

	return buffer;

	}

COmxBufferManager::COmxBuffer* COmxBufferManager::FindBuffer(OMX_BUFFERHEADERTYPE* aBuffer) const

	{

	return reinterpret_cast<COmxBuffer*>(aBuffer->pAppPrivate);

	}

 TInt COmxBufferManager::UseBuffer(CMMFBuffer& aBuffer, TUint aPortIndex)

	{

	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer.Type()))

		{

		OMX_BUFFERHEADERTYPE* buffer;

		CMMFDataBuffer& dataBuffer = static_cast<CMMFDataBuffer&>(aBuffer);

        TDes8& aBufferDes = dataBuffer.Data();

        OMX_ERRORTYPE error = iHandle->UseBuffer(static_cast<OMX_HANDLETYPE>(iHandle), &buffer, aPortIndex, (void*)&aBuffer, aBufferDes.MaxLength(), const_cast<TUint8*>(aBufferDes.Ptr()));

    	if (error != OMX_ErrorNone)

    		{

    		return ConvertOmxErrorType(error);

    		}

		TRAPD(err, StoreBufferL(buffer, &aBuffer));

		return err;

		}

	else

		{

		return KErrNotSupported;

		}

	}

 CMMFBuffer* COmxBufferManager::AllocateBufferL(TUint aPortIndex, TUint aSizeBytes)

	{

	OMX_BUFFERHEADERTYPE* buffer;

	OMX_ERRORTYPE error = iHandle->AllocateBuffer(static_cast<OMX_HANDLETYPE>(iHandle), &buffer, aPortIndex, NULL, aSizeBytes);

	User::LeaveIfError(ConvertOmxErrorType(error));

	StoreBufferL(buffer,NULL); // transfers ownership

	// return the newly created buffer

	return FindBuffer(buffer)->MmfBuffer();

	}

 TInt COmxBufferManager::FreeBuffer(CMMFBuffer* aBuffer)

	{

	COmxBuffer* buffer;

	for (TInt i=0;i<iBuffers.Count();i++)

		{

		buffer = iBuffers[i];

		if (buffer->MmfBuffer() == aBuffer)

			{

			iBuffers.Remove(i);

			OMX_ERRORTYPE err = iHandle->FreeBuffer(static_cast<OMX_HANDLETYPE>(iHandle), 0, buffer->BufferHeader());

			delete buffer;

			return err;

			}

		}

	return KErrNotFound;

	}

void COmxBufferManager::COmxBuffer::ConstructL(OMX_BUFFERHEADERTYPE* aBufferHeader, CMMFBuffer* aBuffer)

	{

	// Now if CMMFBuffer is NULL, this is been called from allocate buffer, and we need to 

	// Allocate a ptr buffer to correspond to the buffer created by OMX

	ASSERT(aBufferHeader);

	iBufferHeader = aBufferHeader;	

	if (aBuffer == NULL)

		{

		TPtr8 ptr(iBufferHeader->pBuffer, iBufferHeader->nFilledLen, iBufferHeader->nAllocLen);

		CMMFBuffer* mmfBuffer = CMMFPtrBuffer::NewL(ptr);

		iMmfBuffer = mmfBuffer;

		iOwnsMmfBuffer = ETrue;

		}

	else

		{

		iMmfBuffer = aBuffer;

		}

	// store pointer to element in array

	iBufferHeader->pAppPrivate = this;

	}

// Store OMX buffer pointer

void COmxBufferManager::StoreBufferL(OMX_BUFFERHEADERTYPE* aBufferHeader, CMMFBuffer* aBuffer)

	{

	COmxBuffer* buf = COmxBuffer::NewL(aBufferHeader, aBuffer);

	CleanupStack::PushL(buf);

	iBuffers.AppendL(buf);

	CleanupStack::Pop(buf);

	}

 TInt COmxBufferManager::EmptyThisBuffer(const CMMFBuffer* aBuffer, MOmxInputPortCallbacks* aObserver)

	{

	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))

		{

		COmxBuffer* omxBuffer = FindBuffer(aBuffer);

		if (!omxBuffer)

			{

			return KErrNotFound;

			}

		omxBuffer->SetInputPortCallbacks(aObserver);

		OMX_BUFFERHEADERTYPE* bufferHeader = omxBuffer->BufferHeader();

		const CMMFDataBuffer* buf = static_cast<const CMMFDataBuffer*>(aBuffer);

		const TDesC8& des = buf->Data();

		bufferHeader->nFilledLen = des.Length();

		bufferHeader->nFlags = 0;

		if (aBuffer->LastBuffer())

			{	

			bufferHeader->nFlags |= OMX_BUFFERFLAG_EOS;

			}

		else

			{

			bufferHeader->nFlags &= ~OMX_BUFFERFLAG_EOS;

			}

		return ConvertOmxErrorType(iHandle->EmptyThisBuffer(static_cast<OMX_HANDLETYPE>(iHandle), bufferHeader));

		}

	else

		{

		return KErrNotSupported;

		}

	}

 TInt COmxBufferManager::FillThisBuffer(CMMFBuffer* aBuffer, MOmxOutputPortCallbacks* aObserver)

	{

	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))

		{

		COmxBuffer* omxBuffer = FindBuffer(aBuffer);

		if (!omxBuffer)

			{

			return KErrNotFound;

			}

		omxBuffer->SetOutputPortCallbacks(aObserver);

		OMX_BUFFERHEADERTYPE* bufferHeader = omxBuffer->BufferHeader();

		bufferHeader->nFilledLen = 0;

		// clear last buffer flag

		bufferHeader->nFlags &= ~OMX_BUFFERFLAG_EOS;

		return ConvertOmxErrorType(iHandle->FillThisBuffer(static_cast<OMX_HANDLETYPE>(iHandle), bufferHeader));

		}

	else

		{

		return KErrNotSupported;

		}

	}

COmxBufferManager::~COmxBufferManager()

	{

	for (TInt i=0;i<iBuffers.Count();i++)

		{

		COmxBuffer* omxBuffer = iBuffers[i];

		iHandle->FreeBuffer(static_cast<OMX_HANDLETYPE>(iHandle), 0, omxBuffer->BufferHeader());

		delete omxBuffer;

		}

	iBuffers.Close();

	}

//  Implementation of the Class COmxComponent

COmxCallbacks* COmxCallbacks::NewL(MOmxPuCallbacks& aPuCallbacks)

	{

	COmxCallbacks* self = new (ELeave) COmxCallbacks(aPuCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void COmxCallbacks::ConstructL()

	{

	OMX_CALLBACKTYPE h =

			{

			&::EventHandler,

			&::EmptyBufferDone,

			&::FillBufferDone

			};

	iHandle = h;

	CActiveScheduler::Add(this);

	User::LeaveIfError(iMsgQueue.CreateLocal(KMaxMsgQueueEntries));

	iMsgQueue.NotifyDataAvailable(iStatus);

	SetActive();

	}

COmxCallbacks::COmxCallbacks(MOmxPuCallbacks& aPuCallbacks)

	: CActive(EPriorityNormal),

	iPuCallbacks(&aPuCallbacks)

	{

	}

COmxCallbacks::operator OMX_CALLBACKTYPE*()

	{

	return &iHandle;

	}

void COmxCallbacks::RunL()

	{

	TOmxMessage msg;

	while (iMsgQueue.Receive(msg)==KErrNone)

		{

		switch (msg.iType)

			{

			case EEmptyBufferCallback:

				{

				MOmxInputPortCallbacks* callback = msg.iBuffer->InputPortCallbacks();

				const CMMFBuffer* buffer = msg.iBuffer->MmfBuffer();

				callback->EmptyBufferDone(msg.iComponent, buffer);

				break;

				}				

			case EFillBufferCallback:

				{

				CMMFBuffer* mmfBuffer = msg.iBuffer->MmfBuffer();

				OMX_BUFFERHEADERTYPE* bufferHeader = msg.iBuffer->BufferHeader();

				if (CMMFBuffer::IsSupportedDataBuffer(mmfBuffer->Type()))

					{

					CMMFDataBuffer* dataBuffer = static_cast<CMMFDataBuffer*>(mmfBuffer);

					TDes8& aBufferDes = dataBuffer->Data();

					aBufferDes.SetLength(bufferHeader->nFilledLen);

					mmfBuffer->SetLastBuffer(bufferHeader->nFlags & OMX_BUFFERFLAG_EOS);

					}				

				else

					{

					ASSERT(EFalse);

					}

				MOmxOutputPortCallbacks* callback = msg.iBuffer->OutputPortCallbacks();

				callback->FillBufferDone(msg.iComponent, mmfBuffer);

				break;

				}				

			case EEventCallback:

				{

				iPuCallbacks->MopcEventHandler(msg.iComponent, 

											msg.iEventParams.iEvent, 

											msg.iEventParams.iData1, 

											msg.iEventParams.iData2, 

											msg.iEventParams.iExtra);

				break;

				}				

			default:

				{

				// This is an invalid state

				ASSERT(EFalse);

				}					

			};

		}

	// setup for next callbacks		

	iStatus = KRequestPending;

	iMsgQueue.NotifyDataAvailable(iStatus);

	SetActive();	

	}

COmxCallbacks::~COmxCallbacks()

	{

	Cancel();	

	iMsgQueue.Close();

	}

void COmxCallbacks::DoCancel()

	{

	if (iMsgQueue.Handle()!=NULL)

		{

		iMsgQueue.CancelDataAvailable();

		}

	}

TInt COmxCallbacks::FillBufferDone(OMX_HANDLETYPE aComponent, COmxBufferManager::COmxBuffer* aBuffer)

	{

	TOmxMessage message;

	message.iType = EFillBufferCallback;

	message.iComponent = aComponent;

	message.iBuffer = aBuffer;

	return iMsgQueue.Send(message);

	}

TInt COmxCallbacks::EmptyBufferDone(OMX_HANDLETYPE aComponent, COmxBufferManager::COmxBuffer* aBuffer)

	{

	TOmxMessage message;

	message.iType = EEmptyBufferCallback;

	message.iComponent = aComponent;

	message.iBuffer = aBuffer;

	return iMsgQueue.Send(message);

	}

TInt COmxCallbacks::EventHandler(OMX_HANDLETYPE aComponent, TEventParams aEventParams)

	{

	TOmxMessage message;

	message.iType = EEventCallback;

	message.iComponent = aComponent;

	message.iEventParams = aEventParams;

	return iMsgQueue.Send(message);

	}

 COmxProcessingUnit::CBody::CBody()

	{

	iPuState = EProcessingUnitInvalid;

	}

COmxProcessingUnit::CBody::~CBody()

	{

	delete iBufferManager;

	delete iCallbacks;

	iInputPorts.Close();

	iOutputPorts.Close();

	::OMX_FreeHandle((OMX_HANDLETYPE)iHandle);

	}

COmxProcessingUnit::CBody* COmxProcessingUnit::CBody::NewL(const TDesC8& aComponentName, 

															MOmxPuCallbacks& aPuCallbacks, 

															COmxProcessingUnit* aParent,

															const MMdfProcessingUnitObserver& aObserver)

	{

	CBody* self = new (ELeave) CBody;

	CleanupStack::PushL(self);

	self->ConstructL(aComponentName, aPuCallbacks, aParent, aObserver);

	CleanupStack::Pop(self);

	return self;

	}

void COmxProcessingUnit::CBody::ConstructL(const TDesC8& aComponentName, 

											MOmxPuCallbacks& aPuCallbacks, 

											COmxProcessingUnit* aParent,

											const MMdfProcessingUnitObserver& aObserver)

	{

	iCallbacks = COmxCallbacks::NewL(aPuCallbacks);

	iParent = aParent;

	iObserver = const_cast<MMdfProcessingUnitObserver*>(&aObserver);

	OMX_ERRORTYPE errorType;

	OMX_CALLBACKTYPE* omxCallbacks = *iCallbacks;

	TBuf8<KMaxComponentNameLength> buf;

	buf.Copy(aComponentName);

	const char* name = reinterpret_cast<const char*>(buf.PtrZ());

	errorType = ::OMX_GetHandle((OMX_HANDLETYPE*)&iHandle, const_cast<char*>(name), iCallbacks, omxCallbacks);

	User::LeaveIfError(ConvertOmxErrorType(errorType));

	// Create the BufferManager class to look after the buffering

	iBufferManager = new (ELeave) COmxBufferManager(iHandle);

	SetPuState(EProcessingUnitLoaded);

	}

TInt COmxProcessingUnit::CBody::GetInputPorts(RPointerArray<MMdfInputPort>& aComponentInputPorts)

	{

	TInt err = KErrNone;

	for (TInt i=0; i < iInputPorts.Count() && err == KErrNone; i++ )

		{

		err = aComponentInputPorts.Append(iInputPorts[i]);

		}

	return err;

	}

TInt COmxProcessingUnit::CBody::GetOutputPorts(RPointerArray<MMdfOutputPort>& aComponentOutputPorts)

	{

	TInt err = KErrNone;

	for (TInt i=0; i < iOutputPorts.Count() && err == KErrNone; i++ )

		{

		err = aComponentOutputPorts.Append(iOutputPorts[i]);

		}

	return err;

	}

void COmxProcessingUnit::CBody::Initialize()

	{

	// if the state is not Loaded, we should not accept this call

	if (State() != EProcessingUnitLoaded)

		{	

		Observer()->InitializeComplete(iParent, KErrNotReady); 

		}

	else

		{

		// initialize each of the ports in turn		

		for (TInt i=0; i < iInputPorts.Count(); i++ )

			{

			iInputPorts[i]->MipInitialize();

			}

	for (TInt i=0; i < iOutputPorts.Count(); i++ )

		{

		iOutputPorts[i]->MopInitialize();

		}

		// instruct the OMX component to go into the Idle state

		SendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL);

		SetPuState(EProcessingUnitInitializing);

		}	

	}

void COmxProcessingUnit::CBody::Execute()

	{

	SendCommand(OMX_CommandStateSet, OMX_StateExecuting, NULL);

	iPuState = EProcessingUnitExecuting;

	}

TProcessingUnitState COmxProcessingUnit::CBody::State()

	{

	return iPuState;

	}

TInt COmxProcessingUnit::CBody::EventHandler(OMX_HANDLETYPE /*aComponent*/, OMX_EVENTTYPE aEvent, TUint32 /*aData1*/,

		 TUint32 aData2, TAny* /*aExtraInfo*/)

	{	

	switch (aEvent)

		{

		case OMX_EventCmdComplete:

			{

			switch (aData2)

				{

				case OMX_StateIdle:

					if (iPuState == EProcessingUnitInitializing)

						{

						Observer()->InitializeComplete(iParent, KErrNone);

						}

					else

						{

						Observer()->ExecuteComplete(iParent, KErrNone);

						}

					SetPuState(EProcessingUnitIdle);

					break;

				};

			break;

			}

		case OMX_EventBufferFlag:

			{

			SendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL);

			}

		}

	return KErrNone;

	}

// Base Versions are not supported

TInt COmxProcessingUnit::CBody::Configure(const TPuConfig& /*aConfig*/)

	{

	return KErrNotSupported;

	}

// Base Versions are not supported

TInt COmxProcessingUnit::CBody::GetConfig(TPuConfig& /*aConfig*/)

	{

	return KErrNotSupported;

	}

TInt COmxProcessingUnit::CBody::Pause ()

	{

	return KErrNone;

	}

void COmxProcessingUnit::CBody::Stop()

	{

	SendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL);	

	TInt err = KErrNone;

	for (TInt i=0; i < iInputPorts.Count() && err == KErrNone; i++ )

		{

		iInputPorts[i]->MipDisconnectTunnel();

		}

	for (TInt i=0; i < iOutputPorts.Count() && err == KErrNone; i++ )

		{

		iOutputPorts[i]->MopDisconnectTunnel();

		}

	SetPuState(EProcessingUnitIdle);	

	}

TInt COmxProcessingUnit::CBody::CreateCustomInterface(TUid /*aUid*/)

	{

	return KErrNotSupported;

	}

TAny* COmxProcessingUnit::CBody::CustomInterface(TUid /*aUid*/)

	{

 	return NULL;

	}

TInt COmxProcessingUnit::CBody::AddInputPort(MMdfInputPort* aInputPort)

	{

	if (iInputPorts.Find(aInputPort)>=0)

		return KErrAlreadyExists;

	return iInputPorts.Append(aInputPort);

	}

TInt COmxProcessingUnit::CBody::AddOutputPort(MMdfOutputPort* aOutputPort)

	{

	if (iOutputPorts.Find(aOutputPort)>=0)

		return KErrAlreadyExists;

	return iOutputPorts.Append(aOutputPort);

	}

MMdfProcessingUnitObserver* COmxProcessingUnit::CBody::Observer()

	{

	return iObserver;

	}

void COmxProcessingUnit::CBody::SetPuState(TProcessingUnitState aPuState)

	{

	iPuState = aPuState;

	}

TInt COmxProcessingUnit::CBody::GetComponentVersion(const TDesC8& /*aComponentName*/, OMX_VERSIONTYPE* /*aComponentVersion*/, OMX_VERSIONTYPE* /*aSpecVersion*/, OMX_UUIDTYPE* /*aComponentUUID*/)

	{

	return KErrNotSupported;

	}

TInt COmxProcessingUnit::CBody::SendCommand(OMX_COMMANDTYPE aCmd, TUint aParam, TAny* aCmdData)

	{

	OMX_ERRORTYPE error = iHandle->SendCommand(static_cast<OMX_HANDLETYPE>(iHandle), aCmd, aParam, aCmdData);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::GetParameter(OMX_INDEXTYPE aParamIndex, TAny* aComponentParameterStructure)

	{

	OMX_ERRORTYPE error = iHandle->GetParameter(static_cast<OMX_HANDLETYPE>(iHandle), aParamIndex, aComponentParameterStructure);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::SetParameter(OMX_INDEXTYPE aIndex, TAny* aComponentParameterStructure)

	{

	OMX_ERRORTYPE error = iHandle->SetParameter(static_cast<OMX_HANDLETYPE>(iHandle), aIndex, aComponentParameterStructure);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::GetConfig(OMX_INDEXTYPE aIndex, TAny* aValue)

	{

	OMX_ERRORTYPE error = iHandle->GetConfig(static_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::SetConfig(OMX_INDEXTYPE aIndex, TAny* aValue)

	{

	OMX_ERRORTYPE error = iHandle->SetConfig(static_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::GetExtensionIndex(const TDesC8& aParameterName, OMX_INDEXTYPE* aIndexType)

	{

	HBufC8* buf = HBufC8::New(aParameterName.Length()+1);

	if (buf == NULL)

		{

		return KErrNoMemory;

		}

	else

		{

		// Create a zero terminated version of the paramter name

		*buf = aParameterName;

		TPtr8 ptr = buf->Des();

		TUint8* cstring = const_cast<TUint8*>(ptr.PtrZ());

		OMX_ERRORTYPE error = iHandle->GetExtensionIndex(static_cast<OMX_HANDLETYPE>(iHandle), reinterpret_cast<char*>(cstring), aIndexType);

		// delete the created memory - note no leaving functions so CleanupStack not used

		delete buf;

		return ConvertOmxErrorType(error);

		}

	}

TInt COmxProcessingUnit::CBody::GetState(OMX_STATETYPE* aState)

	{

	OMX_ERRORTYPE error = iHandle->GetState(static_cast<OMX_HANDLETYPE>(iHandle), aState);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::ComponentTunnelRequest(TUint aPortInput, OMX_HANDLETYPE aOutput, TUint aPortOutput, OMX_TUNNELSETUPTYPE* aTunnelSetup)

	{

	OMX_ERRORTYPE error = iHandle->ComponentTunnelRequest(static_cast<OMX_HANDLETYPE>(iHandle), aPortInput, aOutput, aPortOutput, aTunnelSetup);

	return ConvertOmxErrorType(error);

	}

TInt COmxProcessingUnit::CBody::UseBuffer(CMMFBuffer* aBuffer, TUint aPortIndex)

	{

	return iBufferManager->UseBuffer(*aBuffer, aPortIndex);	

	}

CMMFBuffer* COmxProcessingUnit::CBody::AllocateBufferL(TUint aPortIndex, TUint aSizeBytes)

	{

	return iBufferManager->AllocateBufferL(aPortIndex, aSizeBytes);

	}

TInt COmxProcessingUnit::CBody::FreeBuffer(CMMFBuffer* aBuffer)

	{

	return iBufferManager->FreeBuffer(aBuffer);

	}

TInt COmxProcessingUnit::CBody::EmptyThisBuffer(const CMMFBuffer* aBuffer, MOmxInputPortCallbacks* aObserver)

	{

	return iBufferManager->EmptyThisBuffer(aBuffer, aObserver);

	}

TInt COmxProcessingUnit::CBody::FillThisBuffer(CMMFBuffer* aBuffer, MOmxOutputPortCallbacks* aObserver)

	{

	return iBufferManager->FillThisBuffer(aBuffer, aObserver);

	}

TInt COmxProcessingUnit::CBody::SetCallbacks(MOmxPuCallbacks& /*aPuCallbacks*/)

	{

	return KErrNotSupported;

	}

// Callbacks implementation - calls back to COMxCallbacks class, which manages a queue

OMX_ERRORTYPE EventHandler(OMX_OUT OMX_HANDLETYPE aComponent, 

					OMX_OUT TAny* aAppData,

        			OMX_OUT OMX_EVENTTYPE aEvent, 

        			OMX_OUT TUint32 aData1,

        			OMX_OUT TUint32 aData2,

        			OMX_OUT TAny* aExtra)

	{

	COmxCallbacks::TEventParams eventParams;

	eventParams.iEvent = aEvent;

	eventParams.iData1 = aData1;

	eventParams.iData2 = aData2;

	eventParams.iExtra = aExtra;

	TInt error = static_cast<COmxCallbacks*>(aAppData)->EventHandler(aComponent, eventParams);

	return ConvertSymbianErrorType(error);

	}

OMX_ERRORTYPE EmptyBufferDone(

       OMX_HANDLETYPE aComponent,

       TAny* aAppData,

       OMX_BUFFERHEADERTYPE* aBuffer)

	{

	COmxBufferManager::COmxBuffer* buffer = static_cast<COmxBufferManager::COmxBuffer*>(aBuffer->pAppPrivate);

	TInt error = static_cast<COmxCallbacks*>(aAppData)->EmptyBufferDone(aComponent, buffer);

	return ConvertSymbianErrorType(error);

	}

OMX_ERRORTYPE FillBufferDone(

       OMX_HANDLETYPE aComponent,

       TAny* aAppData,

       OMX_BUFFERHEADERTYPE* aBuffer)

	{

	COmxBufferManager::COmxBuffer* buffer = static_cast<COmxBufferManager::COmxBuffer*>(aBuffer->pAppPrivate);

	TInt error = static_cast<COmxCallbacks*>(aAppData)->FillBufferDone(aComponent, buffer);

	return ConvertSymbianErrorType(error);

	}