/*

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

#include "omxilutil.h"

#include "comxilvideoschedulerpf.h"

#include "comxilvideoscheduler.h"

#include "resourcefilereader.h"

#include "buffercopierstatemonitor.h"

#include "omxilvideoschedulerextensionsindexes.h"

#include <openmax/il/extensions/omxildroppedframeeventextension.h>

#include "log.h"

_LIT(KVideoSchedulerPanicCategory, "omxilvscheduler"); //should restrict to 16 characters as it is used in User::Panic

_LIT(KResourceFileName, "Z:\\resource\\videoscheduler\\videoscheduler.rsc");

const TInt KMaxRenderTime = 1000000;

const TInt KMaxGraphicSinkBufferCount(2); //This is set as the maximum number of buffers that can be sent to the graphic sink without the risk of overloading it.

COmxILVideoSchedulerPF* COmxILVideoSchedulerPF::NewL(MOmxILCallbackNotificationIf& aCallbacks, COmxILVideoScheduler& aComponent, OMX_COMPONENTTYPE* aHandle)

	{

	COmxILVideoSchedulerPF* self = new (ELeave) COmxILVideoSchedulerPF(aCallbacks, aComponent, aHandle);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxILVideoSchedulerPF::COmxILVideoSchedulerPF(MOmxILCallbackNotificationIf& aCallbacks, COmxILVideoScheduler& aComponent, OMX_COMPONENTTYPE* aHandle)

: COmxILProcessingFunction(aCallbacks),

  iComponent(aComponent),

  iIsClockStopped(ETrue),

  iInvalid(EFalse),

  iTimeStamp(KMinTInt64),

  iHandle(aHandle)

 	{

	}

void COmxILVideoSchedulerPF::ConstructL()

	{

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

	iBufferCopierStateMonitor = CBufferCopierStateMonitor::NewL(*this, iComponent);

	// get timer info

	CResourceFileReader* reader = CResourceFileReader::NewLC(KResourceFileName);

	reader->ReadTimerInfoL(iRenderTime, iMaxLateness);

	CleanupStack::PopAndDestroy(reader);

	// Prefill the render time array with the default render time read from resource file

	for (TInt count = 0; count < KRenderTimeListLength; ++count)

		{

		iRenderTimeList[count] = iRenderTime;

		}

	iRenderTimeSum = iRenderTime * KRenderTimeListLength;

	}

COmxILVideoSchedulerPF::~COmxILVideoSchedulerPF()

	{

	delete iBufferCopierStateMonitor;

    iMutex.Wait();

	iWaitingBuffers.Reset();

	iCompletedBuffersHeldByPause.Reset();

    iMutex.Signal();	

	iMutex.Close();

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::StateTransitionIndication(COmxILFsm::TStateIndex aNewState)

	{

	switch(aNewState)

		{

		case COmxILFsm::EStateExecuting:

			{

			if (iPausedState)

				{

			    iMutex.Wait();

				iPausedState = EFalse;

				// send any buffers that received time updates during paused state

				if (iOutputBufferSentCount < KMaxGraphicSinkBufferCount)   // only allowed to send 2 buffers at a time

					{

					SubmitBufferHeldByPause();

					}

                iMutex.Signal();

				}

			break;

			}

		case COmxILFsm::EStatePause:

			{

			iPausedState = ETrue;

			break;

			}

		case COmxILFsm::ESubStateLoadedToIdle:

			{

			TUint32 bufferCount = iComponent.BufferCount();

			TInt error = iBufferCopierStateMonitor->SetState(CBufferCopierStateMonitor::ESubLoadedToIdle);

			if (error != KErrNone)

			    {

			    return SymbianErrorToOmx(error);                    

			    }

			error = iWaitingBuffers.Reserve(bufferCount);

			if (error != KErrNone)

			    {

			    return SymbianErrorToOmx(error);                    

			    }

			error = iCompletedBuffersHeldByPause.Reserve(bufferCount);

			if (error != KErrNone)

			    {

			    return SymbianErrorToOmx(error);                    

			    }

			break;

			}

		case COmxILFsm::EStateIdle:

			{

			iOutputBufferSentCount = iComponent.BufferCount();

			break;

			}

		case COmxILFsm::ESubStateIdleToLoaded:

			{

			TInt error = iBufferCopierStateMonitor->SetState(CBufferCopierStateMonitor::ESubIdleToLoaded);

			if (error != KErrNone)

			    {

			    return SymbianErrorToOmx(error);                    

			    }

			break;

			}

		default:

			{

			break;

			}	

		}

	return OMX_ErrorNone;	

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::BufferFlushingIndication(TUint32 aPortIndex, OMX_DIRTYPE aDirection)

	{

	// called from command thread

    iMutex.Wait();

	if (iBufferCopierStateMonitor->BufferCopier())

		{

		if (aPortIndex == OMX_ALL)

			{

			iBufferCopierStateMonitor->BufferCopier()->FlushBuffers(OMX_DirInput);

			iBufferCopierStateMonitor->BufferCopier()->FlushBuffers(OMX_DirOutput);

			}

		else

			{

			iBufferCopierStateMonitor->BufferCopier()->FlushBuffers(aDirection);

			}

		}

	if (aDirection == OMX_DirOutput || aPortIndex == OMX_ALL)

		{

		while (iWaitingBuffers.Count() > 0)

			{

			iWaitingBuffers[0]->nFilledLen = 0;

			iWaitingBuffers[0]->nOffset = 0;

			iWaitingBuffers[0]->nTimeStamp = 0;

			iCallbacks.BufferDoneNotification(iWaitingBuffers[0], 1, OMX_DirOutput);

			iWaitingBuffers.Remove(0);

			iOutputBufferSentCount++;

			}

		if(iSinkPendingBuffer)

			{

			iSinkPendingBuffer->nFilledLen = 0;

			iSinkPendingBuffer->nOffset = 0;

			iSinkPendingBuffer->nTimeStamp = 0;

			iCallbacks.BufferDoneNotification(iSinkPendingBuffer, 1, OMX_DirOutput);

			iSinkPendingBuffer = NULL;

			iOutputBufferSentCount++;

			}

		}

    iMutex.Signal();        

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::ParamIndication(OMX_INDEXTYPE aParamIndex,

													const TAny* apComponentParameterStructure)

	{

	DEBUG_PRINTF(_L8("COmxILVideoSchedulerProcessingFunction::ParamIndication"));

	if(aParamIndex == OMX_NokiaIndexParamDroppedFrameEvent)

		{

		const OMX_NOKIA_PARAM_DROPPEDFRAMEEVENT* dropFrame = static_cast<const OMX_NOKIA_PARAM_DROPPEDFRAMEEVENT*>(apComponentParameterStructure);

		iEnableDropFrameEvent = dropFrame->bEnabled;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::ConfigIndication(OMX_INDEXTYPE /*aConfigIndex*/, const TAny* /*apComponentConfigStructure*/)

	{

	return OMX_ErrorNone;	

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::BufferIndication(OMX_BUFFERHEADERTYPE* apBufferHeader,

	  												   OMX_DIRTYPE aDirection)			

	{

	if (iInvalid)

	    {

	    return OMX_ErrorInvalidState;

	    }

	// called from decoder data thread or sink data thread

	iMutex.Wait();

	if(aDirection == OMX_DirOutput)

		{

		apBufferHeader->nFlags = 0;

		iOutputBufferSentCount--;

		ASSERT(iOutputBufferSentCount <= iComponent.BufferCount());

		DEBUG_PRINTF2(_L8("VS2::BufferIndication : apBufferHeader->nTickCount = %d"), apBufferHeader->nTickCount);

		// update the render time if it is set

		if (apBufferHeader->nTickCount > 0 && apBufferHeader->nTickCount <= KMaxRenderTime)

			{

			// Add new render time to render time list, and recalculate average

			iRenderTimeSum -= iRenderTimeList[iRenderTimeListPos];

			iRenderTimeSum += apBufferHeader->nTickCount;

			iRenderTimeList[iRenderTimeListPos] = apBufferHeader->nTickCount;

			++iRenderTimeListPos;

			iRenderTimeListPos %= KRenderTimeListLength;

			iRenderTime = iRenderTimeSum / KRenderTimeListLength;

			DEBUG_PRINTF2(_L8("VS2::BufferIndication : New iRenderTime = %ld"), iRenderTime);

			}

		// previously sent buffer has come back

		// send any buffers that received time updates

		// at startup, iOutputBufferSentCount may be >2 if output port is non-supplier

		if (!iPausedState && iOutputBufferSentCount < KMaxGraphicSinkBufferCount)

			{

			SubmitBufferHeldByPause();

			}

		}

	else if(apBufferHeader->nFlags & OMX_BUFFERFLAG_DECODEONLY)

		{

		// this frame is not to be rendered (probably as part of an accurate seek)

		// drop the data and send it back to the decoder

		apBufferHeader->nFilledLen = 0;

		apBufferHeader->nFlags = 0;

		apBufferHeader->nOffset = 0;

		iCallbacks.BufferDoneNotification(apBufferHeader, 0, OMX_DirInput);

		iMutex.Signal();

		return OMX_ErrorNone;

		}

	if (iBufferCopierStateMonitor->BufferCopier())

	    {

	    iBufferCopierStateMonitor->BufferCopier()->DeliverBuffer(apBufferHeader, aDirection);

	    }

    iMutex.Signal();

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILVideoSchedulerPF::MediaTimeIndication(const OMX_TIME_MEDIATIMETYPE& aTimeInfo)

	{

	// called from clock thread

	switch(aTimeInfo.eUpdateType)

		{

	case OMX_TIME_UpdateRequestFulfillment:

		{

		iMutex.Wait();

		TInt index = -1;

		OMX_BUFFERHEADERTYPE* buffer = reinterpret_cast<OMX_BUFFERHEADERTYPE*>(aTimeInfo.nClientPrivate);

		__ASSERT_DEBUG(buffer->nTimeStamp == aTimeInfo.nMediaTimestamp, Panic(EPanicBadAssociation));

		if(FindWaitingBuffer(buffer, aTimeInfo.nMediaTimestamp, index))

			{

			if (iPausedState || iCompletedBuffersHeldByPause.Count() > 0)

				{

				TBufferMessage bufferMessage;

				bufferMessage.iBufferHeader = buffer;

				bufferMessage.iMediaTimeInfo = aTimeInfo;

				OMX_ERRORTYPE error = SymbianErrorToOmx(iCompletedBuffersHeldByPause.Append(bufferMessage)); // note append cannot fail, allocated enough slots

				iMutex.Signal();

				return error;

				}

			else 

				{

				SendTimedOutputBuffer(buffer, aTimeInfo, index);

				}

			}

		else

			{

			// TODO [SL] now what?

			User::Invariant();

			}

		iMutex.Signal();

		return OMX_ErrorNone;

		}

	case OMX_TIME_UpdateScaleChanged:

		if(aTimeInfo.xScale >= 0)

			{

			// the clock takes care completing requests at the correct media time

			return OMX_ErrorNone;

			}

		else

			{

			// TODO think harder about implications of negative scale

			// certainly the iTimeStamp checking must be reversed

			ASSERT(0);

			return OMX_ErrorNotImplemented;

			}

	case OMX_TIME_UpdateClockStateChanged:

		iClockState.eState = aTimeInfo.eState;

		switch(aTimeInfo.eState)

			{

		case OMX_TIME_ClockStateStopped:

		    {

		    // clock stopped so remove any pending buffers from the list as time requests

		    // will be resent when the clock is running again

	        iIsClockStopped	= ETrue;	 

	        iMutex.Wait();

			while (iCompletedBuffersHeldByPause.Count() > 0)

                { 

				iCompletedBuffersHeldByPause.Remove(0);

                }           	         

			if(iSinkPendingBuffer && iBufferCopierStateMonitor)

				{

				// if sink pending buffer exist (as sink is bottleneck) then drop the frame

				iBufferCopierStateMonitor->BufferCopier()->DeliverBuffer(iSinkPendingBuffer, OMX_DirOutput);

				iSinkPendingBuffer = NULL;

				}

            iMutex.Signal();            

	        }

			break;

		case OMX_TIME_ClockStateWaitingForStartTime:

		    {

		    iIsClockStopped = EFalse;

		    // if now in WaitingForStartTime state and start time already received, send it now

		    if (iStartTimePending)

		        {

		        OMX_ERRORTYPE error = iComponent.SetVideoStartTime(iStartTime);

		        if (error != OMX_ErrorNone)

		            {

		            // iStartTimePending = EFalse; // FIXME - Is this required?

		            return error;

		            }

		        }

		    }

			break;

		case OMX_TIME_ClockStateRunning:

			{

			iTimeStamp = KMinTInt64;

			if(iIsClockStopped)

				{

				// the clock is running after being stopped previously

				// resend time requests for waiting buffers

				iIsClockStopped = EFalse;

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

					{

					iComponent.MediaTimeRequest(iWaitingBuffers[i], iWaitingBuffers[i]->nTimeStamp, iRenderTime);

					}

				}

			}

			break;

			}

		iStartTimePending = EFalse;

		DEBUG_PRINTF2(_L8("VS2::MediaTimeIndication : ClockStateChanged = %d"), aTimeInfo.eState);

		return OMX_ErrorNone;

	default:

		return OMX_ErrorBadParameter;

		}

	}

/* Check if aBuffer still exist in the waiting queue */ 

TBool COmxILVideoSchedulerPF::FindWaitingBuffer(const OMX_BUFFERHEADERTYPE* aBuffer, const OMX_TICKS& aMediaTime, TInt& aIndex) const

	{

	__ASSERT_DEBUG(const_cast<RMutex&>(iMutex).IsHeld(), Panic(EPanicMutexUnheld));

	TBool found = EFalse;

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

		{

		if ((iWaitingBuffers[i] == aBuffer) && (iWaitingBuffers[i]->nTimeStamp == aMediaTime))

			{

			found = ETrue;

			aIndex = i;

			break;

			}

		}

	return found;

	}

/**

Check if a specified buffer is currently held by the processing function,

and remove it if found.

@param apBufferHeader Buffer to remove

@param aDirection Port direction

@return Flag to indicate if buffer was removed.

*/

OMX_BOOL COmxILVideoSchedulerPF::BufferRemovalIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE aDirection)

	{

    iMutex.Wait();	

	if(iBufferCopierStateMonitor->BufferCopier() && iBufferCopierStateMonitor->BufferCopier()->RemoveBuffer(apBufferHeader, aDirection))

		{

		if(aDirection == OMX_DirOutput)

			{

			iOutputBufferSentCount++;

			}

		iMutex.Signal();

		return OMX_TRUE;

		}

	else if(aDirection == OMX_DirOutput)

		{

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

			{

			if (iWaitingBuffers[i] == apBufferHeader)

				{

				iWaitingBuffers[i]->nFilledLen = 0;

				iWaitingBuffers.Remove(i);

				iOutputBufferSentCount++;

			    iMutex.Signal();

				return OMX_TRUE;

				}

			}

		if(apBufferHeader == iSinkPendingBuffer)

			{

			iSinkPendingBuffer = NULL;

			iOutputBufferSentCount++;

			iMutex.Signal();

			return OMX_TRUE;

			}

		}

	iMutex.Signal();    

	return OMX_FALSE;

	}

/* Submit the first time update buffer that still exists in the waiting queue. */

void COmxILVideoSchedulerPF::SubmitBufferHeldByPause()

	{

	__ASSERT_DEBUG(iMutex.IsHeld(), Panic(EPanicMutexUnheld));

	__ASSERT_DEBUG(iOutputBufferSentCount < KMaxGraphicSinkBufferCount, Panic(EPanicBadOutputRegulation));

	if(iSinkPendingBuffer)

		{

		DEBUG_PRINTF(_L8("VS2::SubmitBufferHeldByPause ***************************SEND SINK PENDING BUFFER"));

		OMX_BUFFERHEADERTYPE* buffer = iSinkPendingBuffer;

		iSinkPendingBuffer = NULL;

		SendOutputBuffer(buffer);

		return;

		}

	TInt index = -1;

	TBool bufferSent = EFalse;

	while (iCompletedBuffersHeldByPause.Count() > 0 && !bufferSent)

		{

		TBufferMessage& msg = iCompletedBuffersHeldByPause[0];

		if (FindWaitingBuffer(msg.iBufferHeader, 

					msg.iMediaTimeInfo.nMediaTimestamp, index))

			{

			DEBUG_PRINTF(_L8("VS2::SubmitBufferHeldByPause ***************************SEND HELD BUFFER"));

			bufferSent = SendTimedOutputBuffer(msg.iBufferHeader, msg.iMediaTimeInfo, index);

			}

		iCompletedBuffersHeldByPause.Remove(0);

		}

	}

/** Returns ETrue if aBuffer was sent, EFalse otherwise */

TBool COmxILVideoSchedulerPF::SendTimedOutputBuffer(OMX_BUFFERHEADERTYPE* aBuffer, const OMX_TIME_MEDIATIMETYPE& aMediaTimeInfo, TInt aIndex)

	{

	__ASSERT_DEBUG(iMutex.IsHeld(), Panic(EPanicMutexUnheld));

	__ASSERT_DEBUG(aBuffer->nTimeStamp == aMediaTimeInfo.nMediaTimestamp, Panic(EPanicBadAssociation));

	__ASSERT_DEBUG(aBuffer == reinterpret_cast<OMX_BUFFERHEADERTYPE*>(aMediaTimeInfo.nClientPrivate), Panic(EPanicBadAssociation));

#ifdef _OMXIL_COMMON_DEBUG_TRACING_ON	

	DEBUG_PRINTF(_L8("VS2::SendTimedOutputBuffer **********************************"));

	TTime t;

	t.HomeTime();

	DEBUG_PRINTF2(_L8("VS2::SendTimedOutputBuffer : t.HomeTime() = %ld"), t.Int64());

	DEBUG_PRINTF2(_L8("VS2::SendTimedOutputBuffer : aMediaTimeInfo.nClientPrivate = 0x%X"), aMediaTimeInfo.nClientPrivate);

	DEBUG_PRINTF2(_L8("VS2::SendTimedOutputBuffer : aMediaTimeInfo.nMediaTimestamp = %ld"), aMediaTimeInfo.nMediaTimestamp);

	DEBUG_PRINTF2(_L8("VS2::SendTimedOutputBuffer : aMediaTimeInfo.nOffset = %ld"), aMediaTimeInfo.nOffset);

	DEBUG_PRINTF2(_L8("VS2::SendTimedOutputBuffer : aMediaTimeInfo.nWallTimeAtMediaTime = %ld"), aMediaTimeInfo.nWallTimeAtMediaTime);

#endif

	TBool bufferSent = EFalse;

	OMX_U32 flags = aBuffer->nFlags;