// 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);

	}