// Copyright (c) 2007-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 <hal.h>

#include <graphics/suerror.h>

#include "rendererrelay.h"

#include "buflistener.h"

#include "buffermanager.h"

#include "videoframebuffer.h"

#include "rendererutil.h"

#include "renderertimer.h"

/** static factory contruction */

CRendererRelay* CRendererRelay::NewL(MVideoRendererObserver& aObserver)

	{

	CRendererRelay* self = new (ELeave) CRendererRelay(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CRendererRelay::CRendererRelay(MVideoRendererObserver& aObserver)

:iObserver(aObserver), 

 iBufAvailListeners(CBufAvailListener::iOffset), 

 iAvailListenersIter(iBufAvailListeners)

	{

	}

void CRendererRelay::ConstructL()

	{

	User::LeaveIfError(iSurfaceUpdateSession.Connect());

	User::LeaveIfError(HAL::Get(HAL::EFastCounterFrequency, iFastCounterFrequency));

	User::LeaveIfError(HAL::Get(HAL::EFastCounterCountsUp, iFastCounterCountsUp));

	}

/** Destructor */

CRendererRelay::~CRendererRelay()

	{

	delete iDisplayListener;

	iAvailListenersIter.SetToFirst();

	CBufAvailListener* listener = NULL;

	while ((listener = iAvailListenersIter++) != NULL)

		{

		listener->iDblQueLink.Deque();

		delete listener;

		}

	iSurfaceUpdateSession.Close();

	}

/** Update buffer manager pointer in this class and listeners */

void CRendererRelay::SetBufferManager(CRendererBufferManager* aBufManager)

	{

	iBufManager = aBufManager;

	// change buffer manager pointer for listeners

	iAvailListenersIter.SetToFirst();

	CBufAvailListener* listener = NULL;

	while ((listener = iAvailListenersIter++) != NULL)

		{

		listener->SetBufferManager(aBufManager);

		if (!aBufManager && listener->IsAdded())

			{

			listener->Deque();

			}

		else if (aBufManager && !listener->IsAdded())

			{

			CActiveScheduler::Add(listener);

			}

		}

	}

/** Return the next unused CBufAvailListener. */

CBufAvailListener* CRendererRelay::BufAvailListener()

	{

	CBufAvailListener* listener = NULL;

	iAvailListenersIter.SetToFirst();

	while ((listener = iAvailListenersIter++) != NULL)

		{

		if (listener->IsActive() == EFalse)

			{

			// Move to end so that the next search is a bit faster

			listener->iDblQueLink.Deque();

			iBufAvailListeners.AddLast(*listener);

			return listener;

			}

		}

	// Should not reach here as the number of listeners is same as number of buffer

	__ASSERT_DEBUG(EFalse, User::Panic(_L("CRR::BufAvailListener"), KErrUnknown));

	return listener;

	}

/** Set update parameter and create listeners */

void CRendererRelay::PrepareL(const TSurfaceId& aSurfaceId, TInt aNumBuffers, TRequestStatus* /*aRequestStatus*/)

	{

	iUpdateSubmitted = EFalse;

	iSurfaceId = aSurfaceId;

	if (!iDisplayListener)

		{

		iDisplayListener = CBufDisplayListener::NewL(iObserver, iSurfaceUpdateSession, *this, iFastCounterFrequency, iFastCounterCountsUp);

		}

	TInt numListeners = 0;

	iAvailListenersIter.SetToFirst();

	while (iAvailListenersIter++ != NULL)

		{

		numListeners++;

		}

	CBufAvailListener* listener = NULL;

	// create new listeners if there are more numBuffers than listeners

	for (TInt i = numListeners; i < aNumBuffers; ++i)

		{

		listener = CBufAvailListener::NewL(iObserver, iSurfaceUpdateSession);

		iBufAvailListeners.AddFirst(*listener);

		}

	}

/** Handle update buffer request in non-timed mode */

void CRendererRelay::UpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aPresentationTime, TRequestStatus* /* aRequestStatus */)

	{

	__ASSERT_DEBUG(iBufManager != NULL, User::Panic(_L("CRR::UpdateBuffer"), KErrNotReady));

	iBufManager->UpdateBuffer(aBuffer, aPresentationTime);

	if (iUpdateSubmitted == EFalse)

		{

		// an update haven't been submitted, submit one now

		SubmitBuffer();

		}

	}

/** Callback from display listener that a buffer has been displayed or skipped*/

void CRendererRelay::BufferDisplayed(TBool aDisplayed, TInt64 aDelay)

	{

	DEBUGPRINT3(_L("CRendererRelay::BufferDisplayed entered aDisplayed=%d, aDelay=%Ld"), aDisplayed, aDelay);

	iUpdateSubmitted = EFalse;

	if (iRendererTimer)

		{

		// rendering in timed mode

		if (aDisplayed)

			{

			// update delay value

			iDelay = aDelay;

			}

		SubmitBufferTimed();

		}

	else

		{

		// rendering in non timed mode

		SubmitBuffer();

		}

	}

/** Submit the next buffer that is waiting to be submitted in non-timed mode*/

void CRendererRelay::SubmitBuffer()

	{

	DEBUGPRINT1(_L("CRendererRelay::SubmitBuffer entered"));

	__ASSERT_DEBUG(iBufManager != NULL, User::Panic(_L("CRR::SubmitBuffer"), KErrCorrupt));

	__ASSERT_DEBUG(iUpdateSubmitted == EFalse, User::Panic(_L("CRR::SubmitBuffer"), KErrGeneral));

	TBool lastBuf;

	TVideoFrameBuffer* buf = iBufManager->WaitingBuffer(ETrue, lastBuf);

	TInt numBufferSkipped = 0;

	TTime now;

	now.UniversalTime();

	TUint32 fastCounter = User::FastCounter();

	while (buf != NULL)

		{

		TInt bufId = buf->BufferId();

		DEBUGPRINT4(_L("bufId=%d presTime=%Ld, now=%Ld"), 

					bufId, buf->PresentationTime().Int64(), now.Int64());

		// submit the buffer for update if presntation time is not in past 

		// or if the buffer is the last in queue or presentation time is zero

		if (buf->PresentationTime() >= now || lastBuf || buf->PresentationTime().Int64() == 0)

			{

			DoUpdateBuffer(bufId, now, fastCounter);

			break;

			}

		// The buffer presentation time occurs in past if codeflow reaches here.

		// Change the buffer status to available and notify observer about the skipped buffer

		iBufManager->BufferAvailable(bufId);

		iObserver.MvroBufferSkipped(bufId);

		numBufferSkipped++;

		// get next buffer

		buf = iBufManager->WaitingBuffer(ETrue, lastBuf);

		}

	//notifiy observer about the available buffers

	for (TInt i = 0; i < numBufferSkipped; ++i)

		{

		iObserver.MvroVideoBufferAvailable();

		}

	}

/** Set a pointer to renderer timer in timed mode */

void CRendererRelay::SetRendererTimer(CRendererTimer* aRendererTimer)

	{

	iRendererTimer = aRendererTimer;

	}

/** Callback function when a renderer timer has expired */

void CRendererRelay::RendererTimerExpired()

	{

	SubmitBufferTimed();

	}

/** Submit the next buffer in timed mode */

void CRendererRelay::SubmitBufferTimed()

	{

	DEBUGPRINT1(_L("CRendererRelay::SubmitBufferTimed entered"));

	__ASSERT_DEBUG(iBufManager != NULL, User::Panic(_L("CRR::SubmitBufferTimed"), KErrCorrupt));

	__ASSERT_DEBUG(iUpdateSubmitted == EFalse, 

			User::Panic(_L("CRR::SubmitBufferTimed"), KErrGeneral));

	__ASSERT_DEBUG(iRendererTimer && iRendererTimer->IsActive() == EFalse, 

					User::Panic(_L("CRR::SubmitBufferTimed"), KErrInUse));

	TBool lastBuf;

	TVideoFrameBuffer* buf = iBufManager->WaitingBuffer(EFalse, lastBuf);

	TInt numBufferSkipped = 0;

	TTime now;

	now.UniversalTime();

	TUint32 fastCounter = User::FastCounter();

	while (buf != NULL)

		{

		TInt bufId = buf->BufferId();

		TTimeIntervalMicroSeconds deltaFromNow = buf->PresentationTime().MicroSecondsFrom(now);

		TInt64 waitTime = 0;

		if (buf->PresentationTime().Int64() != 0)

			{

			// presentation time is not zero, calculate wait time. Otherwise, wait time is zero.

			waitTime = deltaFromNow.Int64() - iDelay;

			}

		DEBUGPRINT4(_L("bufId=%d presTime=%Ld, now=%Ld"), 

				bufId, buf->PresentationTime().Int64(), now.Int64());

		// submit the buffer for update if presntation time is not in past 

		// or if the buffer is the last in queue

		if (waitTime > 0)

			{

			iRendererTimer->Start(waitTime);

			break;

			}

		else if (buf->PresentationTime().Int64() == 0 ||

					deltaFromNow.Int64() + iMaxDelay >= 0 || 

					lastBuf)

			{

			// if presentation time is zero (waitTime is not used for checking because it may be zero from calculation)

			// or the frame is within maximun allowed delay, i.e. (presentation time + max delay >= now)

			// or submission time has passed but this is the last buf, submit the buffer now

			iBufManager->BufferSubmitted(buf);

			DoUpdateBuffer(bufId, now, fastCounter);

			break;

			}

		// The buffer presentation time has passed maxDelay if codeflow reaches here, skip the buffer.

		// Change the buffer status to available and notify observer

		iBufManager->BufferAvailable(bufId);

		iObserver.MvroBufferSkipped(bufId);

		numBufferSkipped++;

		// get next buffer

		buf = iBufManager->WaitingBuffer(EFalse, lastBuf);

		}

	//notifiy observer about the available buffers

	for (TInt i = 0; i < numBufferSkipped; ++i)

		{

		iObserver.MvroVideoBufferAvailable();

		}

	}

/**

Submits a buffer to be updated at the specified time.

*/

void CRendererRelay::DoUpdateBuffer(TInt aBufferId, const TTime& aTime, TUint32 aFastCounter)

	{

	CBufAvailListener* availListener = BufAvailListener();

	availListener->Start(aBufferId);

	iDisplayListener->Start(aBufferId, aTime, aFastCounter);

	TInt err = iSurfaceUpdateSession.SubmitUpdate(KAllScreens, iSurfaceId, aBufferId);

	DEBUGPRINT2(_L("SubmitUpdate return %d"), err);

	// error will also be returned from listener, so the next submit updated will be triggered by display listener

	iUpdateSubmitted = ETrue;

	}

/** 

Return ETrue if an update has been submitted and the display notification 

haven't been received yet. i.e. Need to wait till for listener callback before 

the next buffer can be submitted.

*/

TBool CRendererRelay::UpdateSubmitted()

	{

	return iUpdateSubmitted;

	}

/** return the delay for surface update */

TInt64 CRendererRelay::Delay()

	{

	return iDelay;

	}

/** Cancel all update notification when a surface is destroyed */

void CRendererRelay::DestroySurface(TRequestStatus* /* aRequestStatus */ )

	{

	iSurfaceUpdateSession.CancelAllUpdateNotifications();

	}

/* This function is not used */

void CRendererRelay::SetRendererThread(RThread* /* aRendererThread */)

	{

	__ASSERT_DEBUG(EFalse, User::Panic(_L("CRR::SetRendererThread"), KErrUnknown));

	}

/* This function is not used */

void CRendererRelay::Terminate(TRequestStatus& /* aRequestStatus */)

	{

	__ASSERT_DEBUG(EFalse, User::Panic(_L("CRR::Terminate"), KErrUnknown));

	}

/** Set timer info for timed mode, this function is not called in non-timed mode */

void CRendererRelay::SetTimerInfo(TInt64 aDefaultDelay, TInt64 aMaxDelay)

	{

	iDelay = aDefaultDelay;

	iMaxDelay = aMaxDelay;

	}

/** Two-phased constructor. */

CRendererThreadRelay* CRendererThreadRelay::NewL(MVideoRendererObserver& aObserver, TThreadId aMainThreadId)

	{

	CRendererThreadRelay* self = new (ELeave) CRendererThreadRelay(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(aMainThreadId);

	CleanupStack::Pop(self);

	return self;

	}

CRendererThreadRelay::CRendererThreadRelay(MVideoRendererObserver& aObserver) 

: CActive(EPriorityStandard), iObserver(aObserver)

	{

	CActiveScheduler::Add(this);

	}

/** Second-phase constructor */

void CRendererThreadRelay::ConstructL(TThreadId aMainThreadId)

	{

	User::LeaveIfError(iMainThread.Open(aMainThreadId));

	iRendererRelay = CRendererRelay::NewL(*this);

	iRendererTimer = CRendererTimer::NewL(*iRendererRelay);

	iRendererRelay->SetRendererTimer(iRendererTimer);

	}

/** 

Destructor. 

This active object is always cancelled by main thread so no need to cancel this active object here

*/

CRendererThreadRelay::~CRendererThreadRelay()

	{

	delete iRendererCallbackListener;

	delete iRendererTimer;

	delete iRendererRelay;

	iMainThread.Close();

	}

void CRendererThreadRelay::DoCancel()

	{

	// Don't need to do anything, will be stopped by main thread

	}

/** Function for making the initial request */

void CRendererThreadRelay::Start()

	{

	__ASSERT_DEBUG(IsActive() == EFalse, User::Panic(_L("CRTR::Start"), KErrInUse));

	iStatus = KRequestPending;

	SetActive();

	}

/** Handle requests from main thread */

void CRendererThreadRelay::RunL()

	{

	__ASSERT_DEBUG(iStatus == KErrNone, User::Panic(_L("CRTR::RunL"), KErrUnknown));

	TInt result = KErrNone;

	if (iFunctionCode == ESubmitUpdate)

		{

		Start();

		RunUpdateBuffer(iBuffer, iPresentationTime);

		}

	else if (iFunctionCode == EDestroySurface)

		{

		Start();

		RunDestroySurface();

		}

	else if (iFunctionCode == EPrepare)

		{

		Start();

		TRAP(result, RunPrepareL());

		}

	else if (iFunctionCode == ESetBufferManager)

		{

		Start();

		RunSetBufferManager();

		}

	else // iFunctionCode == ETermination

		{

		CActiveScheduler::Stop();

		}

	TRequestStatus *status = iCallingStatus;

	iMainThread.RequestComplete(status, result);

	}

/** Send a signal to the main thread to indicate that the thread startup was successful. */

void CRendererThreadRelay::SignalSetupComplete(TRequestStatus* aSetupComplete)

	{

	iMainThread.RequestComplete(aSetupComplete, KErrNone);

	}

/** Send update buffer request from main thread to renderer thread */

void CRendererThreadRelay::UpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aPresentationTime, TRequestStatus* aRequestStatus)

	{

	__ASSERT_DEBUG(aRequestStatus != NULL, User::Panic(_L("CRTR::UpdateBuffer"), KErrArgument));

	// set function parameters

	iCallingStatus = aRequestStatus;

	iFunctionCode = ESubmitUpdate;

	iBuffer = aBuffer;

	iPresentationTime = aPresentationTime;

	// send request to renderer thread

	TRequestStatus* rendererRequest = Status();

	iRendererThread->RequestComplete(rendererRequest, KErrNone);

	}

/** Send terminate renderer thread request from main thread to renderer thread */

void CRendererThreadRelay::Terminate(TRequestStatus& aRequestStatus)

	{

	iCallingStatus = &aRequestStatus;

	iFunctionCode = ETermination;

	if (iRendererCallbackListener)

		{

		iRendererCallbackListener->Cancel();

		}

	// send request to renderer thread

	TRequestStatus* rendererRequest = Status();

	iRendererThread->RequestComplete(rendererRequest, KErrNone);

	}

/** Send destroy surface request from main thread to renderer thread */

void CRendererThreadRelay::DestroySurface(TRequestStatus* aRequestStatus)

	{

	__ASSERT_DEBUG(aRequestStatus != NULL, User::Panic(_L("CRTR::DestroySurface"), KErrArgument));

	iCallingStatus = aRequestStatus;

	iFunctionCode = EDestroySurface;

	// send request to renderer thread

	TRequestStatus* rendererRequest = Status();

	iRendererThread->RequestComplete(rendererRequest, KErrNone);

	}

/* Prepare the object after a surface is created */

void CRendererThreadRelay::PrepareL(const TSurfaceId& aSurfaceId, TInt aNumBuffers, TRequestStatus* aRequestStatus)

	{

	__ASSERT_DEBUG(aRequestStatus != NULL, User::Panic(_L("CRTR::PrepareL"), KErrArgument));

	if(!iRendererCallbackListener)

		{

		// first, create callback listener in the main thread

		iRendererCallbackListener = CRendererCallbackListener::NewL(iObserver, aNumBuffers);

		iRendererCallbackListener->Start();		

		}

	else if (iNumBuffers < aNumBuffers)

		{

		iRendererCallbackListener->Cancel();

		iRendererCallbackListener->ExtendMsgQueueL(aNumBuffers);

		iRendererCallbackListener->Start();		

		}

	// set function parameters

	iCallingStatus = aRequestStatus;

	iFunctionCode = EPrepare;

	iSurfaceId = aSurfaceId;

	iNumBuffers = aNumBuffers;

	// send request to renderer thread

	TRequestStatus* rendererRequest = Status();