// 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 "omxilcallbackmanager.h"

#include "omxilfsm.h"

#include <openmax/il/common/omxilstatedefs.h>

#include <openmax/il/common/omxilutil.h>

#include "omxilportmanagerif.h"

const TInt COmxILCallbackManager::KMaxMsgQueueEntries;

COmxILCallbackManager*

COmxILCallbackManager::NewL(

	OMX_HANDLETYPE apComponentHandle,

	OMX_PTR apAppData,

	OMX_CALLBACKTYPE* apCallbacks)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::NewL"));

	COmxILCallbackManager* self = new (ELeave)COmxILCallbackManager(

		apComponentHandle,

		apAppData,

		apCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

COmxILCallbackManager::ConstructL()

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::ConstructL"));

	CActiveScheduler::Add(this);

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

	iCommandQueue.NotifyDataAvailable(iStatus);

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

	SetActive();

	}

COmxILCallbackManager::COmxILCallbackManager(OMX_HANDLETYPE apComponentHandle,

											 OMX_PTR apAppData,

											 OMX_CALLBACKTYPE* apCallbacks)

	:

	CActive(CActive::EPriorityStandard),

	XOmxILCallbackManagerIfImpl(

		static_cast<OMX_COMPONENTTYPE*>(apComponentHandle),

		apAppData,

		apCallbacks),

	iCommandQueue(),

	iPendingQueue(),

	iFlushPendingQueue(EFalse),

	iCurrentState(OMX_StateLoaded),

	iPreviousState(OMX_StateLoaded)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::COmxILCallbackManager"));

	}

COmxILCallbackManager::~COmxILCallbackManager()

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::~COmxILCallbackManager"));

	Cancel();

	CleanUpQueue(iPendingQueue);

	CleanUpQueue(iCommandQueue);

	}

void

COmxILCallbackManager::CleanUpQueue(RCallbackManagerQueue& aQueue)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::CleanUpQueue"));

	if (aQueue.Handle() != 0)

		{

		CCallbackCommand* pCommand = 0;

		TInt err = KErrNone;

		while ((err = aQueue.Receive(pCommand)) == KErrNone)

			{

			DEBUG_PRINTF2(_L8("COmxILCallbackManager::CleanUpQueue : aQueue.Receive [%X]"), pCommand);

			delete pCommand;

			pCommand = 0;

			}

		if (KErrNone != err)

			{

			DEBUG_PRINTF2(_L8("COmxILCallbackManager::CleanUpQueue : aQueue.Receive returned error [%d]"), err);

			if (KErrNoMemory == err)

				{

				HandleInsufficientResources();

				}

			}

		}

	aQueue.Close();

	}

void

COmxILCallbackManager::SetPortManager(MOmxILPortManagerIf& apPortManager)

	{

	DoSetPortManager(apPortManager);

	}

void

COmxILCallbackManager::SetFsm(COmxILFsm& apFsm)

	{

	DoSetFsm(apFsm);

	}

OMX_ERRORTYPE

COmxILCallbackManager::RegisterComponentHandle(OMX_HANDLETYPE aComponentHandle)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::RegisterComponentHandle"));

	__ASSERT_DEBUG(aComponentHandle,

				   User::Panic(KOmxILCallbackManagerPanicCategory, 1));

	CCompHandleRegistrationCommand* pHandleReg =

		new CCompHandleRegistrationCommand(aComponentHandle);

	if (!pHandleReg || (iCommandQueue.Send(pHandleReg) != KErrNone))

		{

		delete pHandleReg;

		DoRegisterComponentHandle(aComponentHandle);

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

/**

   The IL Client callback registration is handled in this implementation

   asynchronously. Note that this implementation assumes that the IL Client

   will update the callbacks information once all expected callbacks from this

   component have already been received and therefore, the callback change will

   be safe leading to no race condition at the IL Client side.

   @param apCallbacks The IL Client callback structure.

   @param apAppData Pointer to an application provided value so that the

	    application can have a component specific context when receiving

	    the callback.

   @return OMX_ERRORTYPE

 */

OMX_ERRORTYPE

COmxILCallbackManager::RegisterILClientCallbacks(

	const OMX_CALLBACKTYPE* apCallbacks,

	const OMX_PTR apAppData)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::RegisterILClientCallbacks"));

	CClientCallbacksRegistrationCommand* pClientCBacksReg =

		new CClientCallbacksRegistrationCommand(

			apCallbacks,

			apAppData);

	if (!pClientCBacksReg || (iCommandQueue.Send(pClientCBacksReg) != KErrNone))

		{

		delete pClientCBacksReg;

		DoRegisterILClientCallbacks(apCallbacks, apAppData);

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILCallbackManager::RegisterTunnelCallback(

	OMX_U32 aLocalPortIndex,

	OMX_DIRTYPE aLocalPortDirection,

	OMX_HANDLETYPE aTunnelledComponentHandle,

	OMX_U32 aTunnelledPortIndex)

	{

	DEBUG_PRINTF2(_L8("COmxILCallbackManager::RegisterTunnelCallback : aTunnelledComponentHandle [%x]"), aTunnelledComponentHandle);

	CTunnelCallbackRegistrationCommand* pTunnelCBacksReg =

		new CTunnelCallbackRegistrationCommand(aLocalPortIndex,

											   aLocalPortDirection,

											   aTunnelledComponentHandle,

											   aTunnelledPortIndex);

	if (!pTunnelCBacksReg || (iCommandQueue.Send(pTunnelCBacksReg) != KErrNone))

		{

		delete pTunnelCBacksReg;

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILCallbackManager::DeregisterTunnelCallback(

	OMX_U32 aLocalPortIndex)

	{

	DEBUG_PRINTF(_L8("COmxILCallbackManager::DeregisterTunnelCallback"));

	return RegisterTunnelCallback(aLocalPortIndex,

								  OMX_DirMax,

								  0,

								  0);

	}

OMX_ERRORTYPE

COmxILCallbackManager::RegisterBufferMarkPropagationPort(

	OMX_U32 aPortIndex,

	OMX_U32 aPropagationPortIndex)

	{

	DEBUG_PRINTF(_L8("COmxILCallbackManager::RegisterBufferMarkPropagationPort"));

	CBufferMarkPropagationRegistrationCommand* pBufferMarkPropReg =

		new CBufferMarkPropagationRegistrationCommand(aPortIndex,

													  aPropagationPortIndex);

	if (!pBufferMarkPropReg || (iCommandQueue.Send(pBufferMarkPropReg) != KErrNone))

		{

		delete pBufferMarkPropReg;

		HandleInsufficientResources();

		}

	return OMX_ErrorNone;

	}

TBool

COmxILCallbackManager::BufferRemovalIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE aDirection)

	{

	DEBUG_PRINTF(_L8("COmxILCallbackManager::BufferRemovalIndication"));

	CBufferRemovalCommand* pBufferRemovalCmd =

		new CBufferRemovalCommand(apBufferHeader, aDirection);

	if (!pBufferRemovalCmd ||

		(iCommandQueue.Send(pBufferRemovalCmd) != KErrNone))

		{

		delete pBufferRemovalCmd;

		HandleInsufficientResources();

		}

	// Always return false now as the buffer would be removed asynchronously

	return EFalse;

	}

OMX_ERRORTYPE

COmxILCallbackManager::TransitionCompleteNotification(OMX_STATETYPE aOmxState)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::TransitionCompleteNotification"));

	return EventNotificationImpl(OMX_EventCmdComplete,

								OMX_CommandStateSet,

								aOmxState,

								0);

	}

OMX_ERRORTYPE

COmxILCallbackManager::CommandCompleteNotification(OMX_COMMANDTYPE aOmxCommand,

												   OMX_U32 aOmxPortIndex)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::CommandCompleteNotification"));

	return EventNotification(OMX_EventCmdComplete,

							 aOmxCommand,

							 aOmxPortIndex,

							 0);

	}

#ifdef _OMXIL_COMMON_IL516C_ON

OMX_ERRORTYPE

COmxILCallbackManager::EjectBuffersRequest(OMX_U32 aLocalOmxPortIndex)

	{

    DEBUG_PRINTF2(_L8("COmxILCallbackManager::EjectBuffersRequest : aLocalOmxPortIndex [%u]"), aLocalOmxPortIndex);

	CEjectBuffersRequestCommand* pEjectCBack =

		new CEjectBuffersRequestCommand(aLocalOmxPortIndex);

	if (!pEjectCBack || (iCommandQueue.Send(pEjectCBack) != KErrNone))

		{

		delete pEjectCBack;

		HandleInsufficientResources();

		}

	return OMX_ErrorNone;

	}

#endif

OMX_ERRORTYPE

COmxILCallbackManager::ErrorEventNotification(OMX_ERRORTYPE aOmxError)

	{

    DEBUG_PRINTF2(_L8("COmxILCallbackManager::ErrorEventNotification : aOmxError[%X] "), aOmxError);

	return EventNotification(OMX_EventError,

							 aOmxError,

							 0,

							 0);

	}

OMX_ERRORTYPE

COmxILCallbackManager::EventNotification(OMX_EVENTTYPE aEvent,

										 TUint32 aData1,

										 TUint32 aData2,

										 OMX_STRING aExtraInfo)

	{

	// The error code is ignored intentionally, as errors from this function cannot be handled by clients, since they don't have

	// another mechanism for reporting an error

	(void)EventNotificationImpl(aEvent, aData1, aData2, aExtraInfo);

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILCallbackManager::EventNotificationImpl(OMX_EVENTTYPE aEvent,

														   TUint32 aData1,

														   TUint32 aData2,

														   OMX_STRING aExtraInfo)

	{

    DEBUG_PRINTF4(_L8("COmxILCallbackManager::EventNotificationImpl : aEvent[%X] aData1[%X] aData2[%u]"), aEvent, aData1, aData2);

	CEventCallbackCommand* pEventCBack =

		new CEventCallbackCommand(aEvent,

								  aData1,

								  aData2,

								  aExtraInfo);

	if (!pEventCBack || (iCommandQueue.Send(pEventCBack) != KErrNone))

		{

		delete pEventCBack;

		HandleInsufficientResources();

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILCallbackManager::BufferDoneNotification(OMX_BUFFERHEADERTYPE* apBufferHeader,

											 OMX_U32 aLocalPortIndex,

											 OMX_DIRTYPE aLocalPortDirection)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::BufferDoneNotificaton"));

	return SendBufferDoneNotification(apBufferHeader,

									  aLocalPortIndex,

									  aLocalPortDirection,

									  CCallbackCommand::EPriorityNormal);

	}

OMX_ERRORTYPE

COmxILCallbackManager::ClockBufferDoneNotification(OMX_BUFFERHEADERTYPE* apBufferHeader,

												   OMX_U32 aLocalPortIndex,

												   OMX_DIRTYPE aLocalPortDirection)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::ClockBufferDoneNotification"));

	return SendBufferDoneNotification(apBufferHeader,

									  aLocalPortIndex,

									  aLocalPortDirection,

									  CCallbackCommand::EPriorityHigh);

	}

OMX_ERRORTYPE

COmxILCallbackManager::PortSettingsChangeNotification(

	OMX_U32 aLocalPortIndex,

	TUint aPortSettingsIndex,

	const TDesC8& aPortSettings)

	{

    DEBUG_PRINTF2(_L8("COmxILCallbackManager::PortSettingsChangeNotification : aLocalPortIndex[%d]"), aLocalPortIndex);

	HBufC8* pPortSettings = aPortSettings.Alloc();

	if (!pPortSettings)

		{

		HandleInsufficientResources();

		return OMX_ErrorNone;

		}

	CPortSettingsChangeCommand* pPortSettingsCmd =

		new CPortSettingsChangeCommand(aLocalPortIndex,

									   aPortSettingsIndex,

									   pPortSettings);

	if (!pPortSettingsCmd)

		{

		delete pPortSettings;

		HandleInsufficientResources();

		return OMX_ErrorNone;

		}

	if (iCommandQueue.Send(pPortSettingsCmd) != KErrNone)

		{

		delete pPortSettingsCmd; // Destructor will delete pPortSettings

		HandleInsufficientResources();

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILCallbackManager::SendBufferDoneNotification(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_U32 aLocalPortIndex,

	OMX_DIRTYPE aLocalPortDirection,

	TInt aPriority)

	{

    DEBUG_PRINTF(_L8("COmxILCallbackManager::SendBufferDoneNotification"));

	__ASSERT_ALWAYS(apBufferHeader &&

					(OMX_DirInput == aLocalPortDirection ||

					 OMX_DirOutput == aLocalPortDirection),

					User::Panic(KOmxILCallbackManagerPanicCategory, 1));

	__ASSERT_ALWAYS(apBufferHeader->nOffset + apBufferHeader->nFilledLen

					<= apBufferHeader->nAllocLen,

					User::Panic(KOmxILCallbackManagerPanicCategory, 1));

	CBufferDoneCallbackCommand* pEventCBack =

		new CBufferDoneCallbackCommand(apBufferHeader,

									   aLocalPortIndex,

									   aLocalPortDirection,

									   aPriority);

	if (!pEventCBack || (iCommandQueue.Send(pEventCBack) != KErrNone))

		{

		delete pEventCBack;

		HandleInsufficientResources();

		}

	return OMX_ErrorNone;

	}

void

COmxILCallbackManager::RunL()

	{

    DEBUG_PRINTF2(_L8("COmxILCallbackManager::RunL : Handle[%X]"), ipHandle);

	ProcessQueue(iCommandQueue);

	// Setup for next callbacks

	iCommandQueue.NotifyDataAvailable(iStatus);

	SetActive();

	}

void

COmxILCallbackManager::ProcessQueue(RCallbackManagerQueue& aQueue)

	{

    DEBUG_PRINTF2(_L8("COmxILCallbackManager::ProcessQueue : Handle[%X]"), ipHandle);

	CCallbackCommand* pCommand = 0;

	TInt receiveRes = 0;

	TBool hasBeenDeferred = EFalse;

	while ((receiveRes = aQueue.Receive(pCommand)) == KErrNone)

		{

		if (pCommand)

			{

			DEBUG_PRINTF2(_L8("COmxILCallbackManager::ProcessQueue : aQueue.Receive [%X]"),

						  pCommand);

			hasBeenDeferred = EFalse;

			(*pCommand)(*this, hasBeenDeferred);

			if (hasBeenDeferred)

				{

				// Move the current command to the pending queue

				if (iPendingQueue.Send(pCommand) != KErrNone)

					{

					delete pCommand;

					pCommand = 0;

					HandleInsufficientResources();

					}

				}

			else

				{

				delete pCommand;

				pCommand = 0;

				}

			}

		}

	if (KErrNoMemory == receiveRes)

		{

		HandleInsufficientResources();

		}

	}