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

#include "omxilfsm.h"

#include "omxilutil.h"

EXPORT_C COmxILInContextCallbackManager*

COmxILInContextCallbackManager::NewL(

	OMX_HANDLETYPE apComponentHandle,

	OMX_PTR apAppData,

	OMX_CALLBACKTYPE* apCallbacks)

	{

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

	COmxILInContextCallbackManager* self = new (ELeave)COmxILInContextCallbackManager(

		apComponentHandle,

		apAppData,

		apCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

COmxILInContextCallbackManager::ConstructL()

	{

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

	User::LeaveIfError(iLock.CreateLocal());

	}

COmxILInContextCallbackManager::COmxILInContextCallbackManager(OMX_HANDLETYPE apComponentHandle,

											 OMX_PTR apAppData,

											 OMX_CALLBACKTYPE* apCallbacks)

	:

	CBase(),

	XOmxILCallbackManagerIfImpl(

		static_cast<OMX_COMPONENTTYPE*>(apComponentHandle),

		apAppData,

		apCallbacks),

	iLock(),

	iPendingQueue(),

	iFlushPendingQueue(EFalse),

	iCurrentState(OMX_StateLoaded),

	iPreviousState(OMX_StateLoaded)

	{

    DEBUG_PRINTF(_L8("COmxILInContextCallbackManager::COmxILInContextCallbackManager"));

	}

EXPORT_C

COmxILInContextCallbackManager::~COmxILInContextCallbackManager()

	{

    DEBUG_PRINTF2(_L8("COmxILInContextCallbackManager::~COmxILInContextCallbackManager Pending Queue count [%d]"),

				  iPendingQueue.Count());

	iLock.Close();

	iPendingQueue.Close();

	}

void

COmxILInContextCallbackManager::LockCallbackManager()

	{

	iLock.Wait();

	}

void

COmxILInContextCallbackManager::UnlockCallbackManager()

	{

	iLock.Signal();

	}

EXPORT_C void

COmxILInContextCallbackManager::SetPortManager(COmxILPortManager& apPortManager)

	{

	LockCallbackManager();

	DoSetPortManager(apPortManager);

	UnlockCallbackManager();

	}

EXPORT_C void

COmxILInContextCallbackManager::SetFsm(COmxILFsm& apFsm)

	{

	LockCallbackManager();

	DoSetFsm(apFsm);

	UnlockCallbackManager();

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::RegisterComponentHandle(OMX_HANDLETYPE aComponentHandle)

	{

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

	LockCallbackManager();

	OMX_ERRORTYPE omxError = DoRegisterComponentHandle(aComponentHandle);

	UnlockCallbackManager();

	return omxError;

	}

/**

   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

 */

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::RegisterILClientCallbacks(const OMX_CALLBACKTYPE* apCallbacks,

												 const OMX_PTR apAppData)

	{

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

	LockCallbackManager();

	OMX_ERRORTYPE omxError = DoRegisterILClientCallbacks(apCallbacks, apAppData);

	UnlockCallbackManager();

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::RegisterTunnelCallback(

	OMX_U32 aLocalPortIndex,

	OMX_DIRTYPE aLocalPortDirection,

	OMX_HANDLETYPE aTunnelledComponentHandle,

	OMX_U32 aTunnelledPortIndex)

	{

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

	LockCallbackManager();

	OMX_ERRORTYPE omxError = DoRegisterTunnelCallback(aLocalPortIndex,

													  aLocalPortDirection,

													  aTunnelledComponentHandle,

													  aTunnelledPortIndex);

	UnlockCallbackManager();

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::DeregisterTunnelCallback(

	OMX_U32 aLocalPortIndex)

	{

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

	LockCallbackManager();

	OMX_ERRORTYPE omxError =  DoRegisterTunnelCallback(aLocalPortIndex,

													   OMX_DirMax,

													   0,

													   0);

	UnlockCallbackManager();

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::RegisterBufferMarkPropagationPort(

	OMX_U32 aPortIndex,

	OMX_U32 aPropagationPortIndex)

	{

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

	LockCallbackManager();

	OMX_ERRORTYPE omxError = DoRegisterBufferMarkPropagationPort(

		aPortIndex,

		aPropagationPortIndex);

	UnlockCallbackManager();

	return omxError;

	}

EXPORT_C TBool

COmxILInContextCallbackManager::BufferRemovalIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE aDirection)

	{

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

	return RemoveBuffersByBufferHeader(

		iPendingQueue, apBufferHeader, aDirection);

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::TransitionCompleteNotification(OMX_STATETYPE aOmxState)

	{

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

	// No need to lock callback manager. Anyway, we should not have it locked

	// when calling an IL Client callback method

	OMX_ERRORTYPE omxError = EventNotification(OMX_EventCmdComplete,

											   OMX_CommandStateSet,

											   aOmxState,

											   0);

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::CommandCompleteNotification(OMX_COMMANDTYPE aOmxCommand,

												   OMX_U32 aOmxPortIndex)

	{

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

	// No need to lock callback manager. Anyway, we should not have it locked

	// when calling an IL Client callback method

	OMX_ERRORTYPE omxError = EventNotification(OMX_EventCmdComplete,

											   aOmxCommand,

											   aOmxPortIndex,

											   0);

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::ErrorEventNotification(OMX_ERRORTYPE aOmxError)

	{

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

	// No need to lock callback manager. Anyway, we should not have it locked

	// when calling an IL Client callback method

	OMX_ERRORTYPE omxError = EventNotification(OMX_EventError,

											   aOmxError,

											   0,

											   0);

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::EventNotification(OMX_EVENTTYPE aEvent,

												  TUint32 aData1,

												  TUint32 aData2,

												  OMX_STRING aExtraInfo)

	{

    DEBUG_PRINTF4(_L8("COmxILInContextCallbackManager::EventNotification : aEvent[%u] aData1[%u] aData2[%u]"),

				  aEvent, aData1, aData2);

	OMX_ERRORTYPE omxError = OMX_ErrorNone;

	switch(aData1)

		{

	case OMX_CommandStateSet:

		{

		LockCallbackManager();

		iPreviousState = iCurrentState;

		iCurrentState  = static_cast<OMX_STATETYPE>(aData2);

		DEBUG_PRINTF4(_L8("COmxILInContextCallbackManager::EventNotification() : Handle[%X] iPreviousState[%d] -> iCurrentState[%d]"), ipHandle, iPreviousState, iCurrentState);

		if (OMX_StatePause == iPreviousState &&

			OMX_StateIdle == iCurrentState)

			{

			// Release lock before any callback gets called...

			UnlockCallbackManager();

			// Flush pending queue first...

			FlushQueue(iPendingQueue);

			// ... and now signal command completion...

			omxError =

				DoEventNotification(aEvent,

									aData1,

									aData2,

									aExtraInfo);

			}

		else if (OMX_StatePause == iPreviousState &&

				 OMX_StateExecuting == iCurrentState)

			{

			// Release lock before any callback...

			UnlockCallbackManager();

			// Signal command completion first...

			omxError =

				DoEventNotification(aEvent,

									aData1,

									aData2,

									aExtraInfo);

			// ... and now flush...

			FlushQueue(iPendingQueue);

			}

		else

			{

			// Release lock before any callback...

			UnlockCallbackManager();

			// Signal command completion...

			omxError =

				DoEventNotification(aEvent,

									aData1,

									aData2,

									aExtraInfo);

			}

		}

		break;

	case OMX_CommandPortDisable:

	case OMX_CommandFlush:

		{

		// Flush first...

		if (OMX_ALL == aData2)

			{

			FlushQueue(iPendingQueue);

			}

		else

			{

			FlushBuffersByPortIndex(iPendingQueue,

									aData2);

			}

		// ... and now signal command completion...

		omxError =

			DoEventNotification(aEvent,

								aData1,

								aData2,

								aExtraInfo);

		}

		break;

	default:

		{

		// Signal command completion...

		omxError =

			DoEventNotification(aEvent,

								aData1,

								aData2,

								aExtraInfo);

		}

		};

	if (OMX_ErrorInsufficientResources == omxError)

		{

		HandleInsufficientResources();

		}

	return omxError;

	}

EXPORT_C OMX_ERRORTYPE

COmxILInContextCallbackManager::BufferDoneNotification(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_U32 aLocalPortIndex,

	OMX_DIRTYPE aLocalPortDirection)

	{

    DEBUG_PRINTF2(_L8("COmxILInContextCallbackManager::BufferDoneNotificaton : BUFFER [%X]"),

				  apBufferHeader);

	__ASSERT_ALWAYS(apBufferHeader &&

					(OMX_DirInput == aLocalPortDirection ||

					 OMX_DirOutput == aLocalPortDirection),

					User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));

	__ASSERT_ALWAYS(apBufferHeader->nOffset + apBufferHeader->nFilledLen

					<= apBufferHeader->nAllocLen,

					User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));

	__ASSERT_DEBUG(ipHandle && ipCallbacks,

				   User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));

	LockCallbackManager();

	if (OMX_StatePause == iCurrentState)

		{

		if (KErrNone != iPendingQueue.Append(TOmxILBuffer(

												 apBufferHeader,

												 aLocalPortIndex,

												 aLocalPortDirection)))

			{

			// Not much we can do here...

			UnlockCallbackManager();

			HandleInsufficientResources();

			}

		else

			{

			DEBUG_PRINTF4(_L8("COmxILInContextCallbackManager::BufferDoneNotificaton : DEFERRED buffer header[%X] port [%X] queue items [%d]"),

					  apBufferHeader, aLocalPortIndex, iPendingQueue.Count());

			UnlockCallbackManager();

			}

		return OMX_ErrorNone;

		}

	UnlockCallbackManager();

	ProcessBufferDoneNotification(apBufferHeader,

								  aLocalPortIndex,

								  aLocalPortDirection);

	return OMX_ErrorNone;

	}

void

COmxILInContextCallbackManager::ProcessBufferDoneNotification(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_U32 aLocalPortIndex,

	OMX_DIRTYPE aLocalPortDirection)

	{

    DEBUG_PRINTF2(_L8("COmxILInContextCallbackManager::ProcessBufferDoneNotification : BUFFER [%X]"),

				  apBufferHeader);

	// Look for buffer marks to be signalled or propagated (maintain callback

	// manager unlocked here)

	SignalOrPropagateBufferMarks(apBufferHeader,

								 aLocalPortDirection);

	LockCallbackManager();

	// find out whether the port is tunnelled or not

	TBool tunnelled = EFalse;

	OMX_COMPONENTTYPE* pTunnelledComponent = 0;

	const TUint tunnelCount = iRegisteredTunnels.Count();

	for (TUint i=0; i<tunnelCount; ++i)

		{

		if (iRegisteredTunnels[i].iLocalPortIndex ==

			aLocalPortIndex)

			{

			tunnelled = ETrue;

			pTunnelledComponent =

				static_cast<OMX_COMPONENTTYPE*>(

					iRegisteredTunnels[i].

					iTunnelledComponentHandle);

			__ASSERT_DEBUG(pTunnelledComponent,

						   User::Panic(KOmxILCallbackManagerIfImplPanicCategory, 1));

			break;

			}

		}

	// Unlock callback manager before calling the callback

	UnlockCallbackManager();

	if (tunnelled)

		{

		// From OMX_Core.h "Callbacks should not return an error to the

		// component, so if an error occurs, the application shall handle it

		// internally". Callback return error ignored here.

		if (OMX_DirInput == aLocalPortDirection)

			{

			OMX_FillThisBuffer(pTunnelledComponent, apBufferHeader);

			}

		else

			{

			OMX_EmptyThisBuffer(pTunnelledComponent, apBufferHeader);

			}

		}

	else

		{

		OMX_ERRORTYPE (*fp2CBackHandler)

			(OMX_HANDLETYPE, OMX_PTR, OMX_BUFFERHEADERTYPE*) =

			(aLocalPortDirection == OMX_DirInput ?

			 ipCallbacks->EmptyBufferDone :

			 ipCallbacks->FillBufferDone);

		// From OMX_Core.h "Callbacks should not return an error to the

		// component, so if an error occurs, the application shall handle it

		// internally". Callback return error ignored here.

		fp2CBackHandler(ipHandle,

						ipAppData,

						apBufferHeader);

		}

	}

void

COmxILInContextCallbackManager::SignalOrPropagateBufferMarks(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_U32 aLocalPortIndex)

	{

    DEBUG_PRINTF2(_L8("COmxILInContextCallbackManager::SignalOrPropagateBufferMarks() : BUFFER [%X]"),

				  apBufferHeader);

	// Look for buffer marks to be signalled or propagated

	if (apBufferHeader->hMarkTargetComponent)

		{

		// See if this component is the buffer mark target component...

		if (apBufferHeader->hMarkTargetComponent == ipHandle)

			{

			// Inform the IL Client that a marked buffer has been processed...

			ipCallbacks->EventHandler(ipHandle,

									  ipAppData,