// 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:

 //

 #include "videorenderer.h"

 #include "rendererrelay.h"

 #include "buffermanager.h"

 #include "rendererutil.h"

 #include "renderertimer.h"

 #include "resourcefilereader.h"

 #include "videoframebuffer.h"

 _LIT(KVideoRendererThreadName, "VideoRendererThread");

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

 const TThreadPriority KSubThreadPriority = EPriorityRealTime;

 const TInt KSubThreadStackSize = KDefaultStackSize;	// 0x2000 = 8k

 /**

 Factory method. Creates a new video renderer instance.

 @param aObserver Video renderer observer

 @param aTimed ETrue if CVideoRenderer should handle timing of buffer updates. 

               If ETrue CVideoRenderer launches its own high-priority thread to handle buffer update timing. If EFalse CVideoRenderer requires a CActiveScheduler to be present in calling thread.

 @return  A pointer to the newly created CVideoRenderer object.

 */

 EXPORT_C CVideoRenderer* CVideoRenderer::NewL(MVideoRendererObserver& aObserver, TBool aTimed)

 	{

 	CVideoRenderer* self = new (ELeave) CVideoRenderer(aObserver, aTimed);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

 Private constructor

 @internalComponent

 */

 CVideoRenderer::CVideoRenderer(MVideoRendererObserver& aObserver, TBool aTimed)

 :iObserver(aObserver), iTimed(aTimed)

 	{

 	}

 /**

 Second phase constructor

 @internalComponent

 */

 void CVideoRenderer::ConstructL()

 	{

 	User::LeaveIfError(iSurfaceManager.Open());

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

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

 	reader->ReadSupportedFormatL(iSupportedFormat);

 	if (iTimed)

 		{

 		// Create a high priority thread for timed mode

 		// get timer info for timed mode

 		TInt64 defaultDelay;

 		TInt64 maxDelay;

 		reader->ReadTimerInfoL(defaultDelay, maxDelay);

 		//Get a reference to this thread's heap

 		RHeap& thisHeap = User::Heap();

 		//Parameters to send to the sub thread

 		TThreadRelayParam param;

 		param.iObserver = &iObserver;

 		param.iThreadRelay = &iRendererRelay; // return pointer to allow direct calls

 		//Get the id of this thread

 		RThread thisThread;

 		TThreadId thisThreadId = thisThread.Id();

 		param.iMainThreadId = thisThreadId;

 		//Get a request to signal for setup completion

 		TRequestStatus setupComplete = KRequestPending;

 		param.iSetupComplete = &setupComplete;

 		//current time and the "this" pointer for a unique key

 		_LIT(KFormatString,"%S.%020Lu.%08X");

 	   	TName threadName;

 		TTime now;

 		now.UniversalTime();

 		threadName.Format(KFormatString, &KVideoRendererThreadName, now.Int64(), reinterpret_cast<TUint>(this));

 		//Create a new thread using the same heap as this thread

 		TInt result = iRendererThread.Create(threadName,

 										ThreadCreateFunction,

 										KSubThreadStackSize,

 										&thisHeap,

 										&param);

 		User::LeaveIfError(result);

 		//Run the thread under high priority

 		iRendererThread.SetPriority(KSubThreadPriority); 

 		//Wait for thread startup to complete

 		TRequestStatus threadStatus = KRequestPending;

 		iRendererThread.Logon(threadStatus);

 		//Start the thread

 		iRendererThread.Resume();

 		User::WaitForRequest(threadStatus, setupComplete);

 		if(threadStatus != KRequestPending)

 			{

 			//Thread creation failed

 			TInt reason = iRendererThread.ExitReason();

 			DEBUGPRINT3(_L("Renderer thread died with type=%d, reason=%d"), iRendererThread.ExitType(), reason);

 			User::Leave(reason);

 			}

 		// Thread creation was successfull

 		TInt error = iRendererThread.LogonCancel(threadStatus);

 		User::LeaveIfError(error); // There is no outstanding request

 		User::WaitForRequest(threadStatus); // Consume the signal

 		__ASSERT_DEBUG(iRendererRelay != NULL, User::Panic(_L("CVR::ConstructL"), KErrCorrupt));

 		iRendererRelay->SetRendererThread(&iRendererThread);

 		iRendererRelay->SetTimerInfo(defaultDelay, maxDelay);

 		iThreadCreated = ETrue;

 		User::LeaveIfError(setupComplete.Int());

 		//Create a listener that will monitor the thread

 		iRendererThreadUndertaker = CThreadUndertaker::NewL(iRendererThread);

 		}

 	else

 		{

 		iRendererRelay = CRendererRelay::NewL(iObserver);

 		}

 	CleanupStack::PopAndDestroy(reader);

 	}

 /**

 Main thread entry point for the video renderer sub-thread.

 Create a cleanup stack for the thread and process the codec

 inside a trap for cleanup behaviour.

 @internalComponent

 @param aPtr Parameters to be used for creating the thread.

 @return The error code for thread termination.

 */

 TInt CVideoRenderer::ThreadCreateFunction(TAny* aPtr)

 	{

 	TInt error = KErrNone;

 	// Create a cleanup stack for the thread

 	CTrapCleanup* cleanupStack = CTrapCleanup::New();

 	if (cleanupStack)

 		{

 		if(error == KErrNone)

 			{

 			TRAP(error, ThreadTrapFunctionL(aPtr));

 			}

 		}

 	else

 		{

 		error = KErrNoMemory;

 		}

 	delete cleanupStack;

 	return error;

 	}

 /**

 Function for thread execution. Create an active scheduler for the thread

 and start the function call listener. If the thread is successfully created signal

 the main thread that the thread creation was successfull.

 @internalComponent

 @param aPtr A pointer to a TThreadRelayParam object containing the startup parameters

 			for the thread.

 */

 void CVideoRenderer::ThreadTrapFunctionL(TAny* aPtr)

 	{

 	//Create an active scheduler for the thread

 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(scheduler);

 	CActiveScheduler::Install(scheduler);

 	//Call a Factory function to create a CSubThreadRelay derived object

 	TThreadRelayParam* relayParam;

 	relayParam = static_cast<TThreadRelayParam*>(aPtr);

 	CRendererThreadRelay* threadRelay = CRendererThreadRelay::NewL(*relayParam->iObserver, relayParam->iMainThreadId);

 	CleanupStack::PushL(threadRelay);

 	//Send a pointer to the sub thread relay back to the main thread

 	*relayParam->iThreadRelay = threadRelay;

 	threadRelay->Start();

 	threadRelay->SignalSetupComplete(relayParam->iSetupComplete);

 	CActiveScheduler::Start();	

 	CleanupStack::PopAndDestroy(2,scheduler); //threadRelay, scheduler

 	}

 /**

 Destructor

 */

 EXPORT_C CVideoRenderer::~CVideoRenderer()

 	{

 	iWsSession.Close();

 	iSupportedFormat.Close();

 	// first, stop all active objects that may use any buffers

 	if(iThreadCreated)

 		{

 		delete iRendererThreadUndertaker;

 		// this also delete CRendererThreadRelay

     	TRequestStatus terminateRequest = KRequestPending;

 	    iRendererRelay->Terminate(terminateRequest);

     	User::WaitForRequest(terminateRequest);

         iThreadCreated = EFalse;

         iRendererThread.Close();

 		}

 	else if (iTimed == EFalse)

 		{

 		delete iRendererRelay;

 		}

 	// next, close surface if still open

 	if (iBufferManager)

 		{

 		delete iBufferManager;

 		iSurfaceManager.CloseSurface(iSurfaceId);

 		}

 	// close the rest

 	iSurfaceManager.Close();

 	}

 /**

 Retrieves the list of supported surface formats from the renderer.

 @param aArray Supported video formats. The renderer will populate the array with supported formats.

 @leave KErrNoMemory Out of memory

 */

 EXPORT_C void CVideoRenderer::GetSupportedFormatsL(RArray<TUncompressedVideoFormat>& aArray)

 	{

 	aArray.Reset(); // first clear the old data

 	TInt count = iSupportedFormat.Count();

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

 		{

 		aArray.AppendL(iSupportedFormat[i]);

 		}

 	}

 /**

 Creates a new surface for video rendering and registers it with the windows server for all displays.

 @param aSize Surface size in pixels

 @param aNumBuffers The minimum number of buffers required. The renderer can create a surface with more buffers.

 @param aFormat Surface data format

 @param aSurface Output: Surface ID for the new surface

 @leave KErrNoMemory Out of memory

 @leave KErrNotSupported The requested parameters are not supported

 @leave KErrInUse Too many video surfaces are already in use

 */

 EXPORT_C void CVideoRenderer::CreateSurfaceL(const TSize& aSize, TInt aNumBuffers, const TUncompressedVideoFormat& aFormat, TSurfaceId& aSurface)

 	{

 	if (iBufferManager != NULL)

 		{

 		User::Leave(KErrInUse);

 		}

 	else if (aNumBuffers <= 0)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	RSurfaceManager::TSurfaceCreationAttributesBuf attribBuf;

 	RSurfaceManager::TSurfaceCreationAttributes& attrib = attribBuf();

 	attrib.iSize = aSize;

 	attrib.iBuffers = aNumBuffers;

 	attrib.iPixelFormat = VideoRendererUtil::ConvertUncompressedVideoFormatToUidPixelFormatL(aFormat);

 	attrib.iStride = aSize.iWidth * VideoRendererUtil::BytesPerPixelL(attrib.iPixelFormat);

 	attrib.iOffsetToFirstBuffer = 0;

 	attrib.iAlignment = 4;

 	attrib.iContiguous = ETrue;

 	attrib.iMappable = ETrue;

 	User::LeaveIfError(iSurfaceManager.CreateSurface(attribBuf, iSurfaceId));

 	// Push surfaceId to cleanup stack in case buffer manager constructor leave.

 	// SurfaceId needs to be pushed because the renderer state is inconsistent 

 	// if buffer manager creation leave

 	CleanupReleasePushL(*this);

 	RChunk chunk;

 	User::LeaveIfError(iSurfaceManager.MapSurface(iSurfaceId, chunk));

 	CleanupClosePushL(chunk);

 	RSurfaceManager::TInfoBuf infoBuf;

 	User::LeaveIfError(iSurfaceManager.SurfaceInfo(iSurfaceId, infoBuf));

 	// Register must take place after 'this' pushed onto cleanupstack just in case 

 	// function leaves after registration

 	RegisterSurfaceL();

 	// prepare the renderer relay

 	RSurfaceManager::TSurfaceInfoV01 info = infoBuf();

 	if (iTimed)

 		{

 		TRequestStatus updateRequest = KRequestPending;

 		TRequestStatus logonRequest = KRequestPending;

 		// While a function call is in progress this thread is suspended

 		// and the undertaker will not catch panics, listen for these here

 		iRendererThread.Logon(logonRequest);

 		// Send request to renderer thread

 		iRendererRelay->PrepareL(iSurfaceId, info.iBuffers, &updateRequest);

 		User::WaitForRequest(logonRequest, updateRequest);

 		if(logonRequest != KRequestPending)

 			{

 			// renderer thread got panic from surface update session, so panic client

 			TInt reason = iRendererThread.ExitReason();

 			TExitCategoryName category = iRendererThread.ExitCategory();

 			User::Panic(category,reason);

 			}

 		// Thread is still alive and well

 		iRendererThread.LogonCancel(logonRequest);

 		User::WaitForRequest(logonRequest); // Consume the signal

 		// leave if memory allocation failed in renderer thread

 		User::LeaveIfError(updateRequest.Int());

 		__ASSERT_DEBUG(updateRequest != KRequestPending, User::Panic(_L("CVR::UpdateBuffer"), KErrCorrupt));

 		}

 	else

 		{

 		iRendererRelay->PrepareL(iSurfaceId, info.iBuffers, NULL);

 		}

 	// find the buffer offsets

 	RArray<TInt> offsets;

 	CleanupClosePushL(offsets);

 	TInt offsetInChunk = 0;

 	for (TInt i = 0; i < info.iBuffers; ++i)

 		{

 		User::LeaveIfError(iSurfaceManager.GetBufferOffset(iSurfaceId, i, offsetInChunk));

 		offsets.AppendL(offsetInChunk);

 		}

 	// finally, create buffer manager

 	iBufferManager = CRendererBufferManager::NewL(info, offsets, chunk, iTimed);

 	CleanupStack::PopAndDestroy(&offsets);

 	CleanupStack::Pop(&chunk);

 	CleanupStack::Pop(this); // surfaceId

 	aSurface = iSurfaceId;

 	iRendererRelay->SetBufferManager(iBufferManager);

 	for (TInt i = 0; i < info.iBuffers; ++i)

 		{

 		// notify observer once for each buffer created

 		iObserver.MvroVideoBufferAvailable();

 		}

 	}

 /** 

  Helper function to unregister and release surfaceId when CreateSurfaceL leave

  @internalComponent

  */

 void CVideoRenderer::Release()

 	{

 	UnregisterSurface();

 	iSurfaceManager.CloseSurface(iSurfaceId);

 	}

 /** 

  Helper function to register surfaces for all displays

  @internalComponent

  */

 void CVideoRenderer::RegisterSurfaceL()

 	{

 	TInt screens = iWsSession.NumberOfScreens();

 	TInt error;

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

 		{

 		error = iWsSession.RegisterSurface(i, iSurfaceId);

 		User::LeaveIfError(error);

 		}

 	}

 /** 

  Helper function to unregister surafces for all displays

  @internalComponent

  */

 void CVideoRenderer::UnregisterSurface()

 	{

 	TInt screens = iWsSession.NumberOfScreens();

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

 		{

 		iWsSession.UnregisterSurface(i, iSurfaceId);

 		}

 	}

 /**

 Destroys a surface previously created with CreateSurfaceL() and unregisters it with the windows

 server for all displays. The client must stop using the surface before calling this method. All

 buffers retrieved with NextBuffer() will become invalid and can no longer be used.

 @param aSurface The surface to delete

 */

 EXPORT_C void CVideoRenderer::DestroySurface(const TSurfaceId& aSurface)

 	{

 	if (aSurface != iSurfaceId || iBufferManager == NULL)

 		{

 		// surface id is not expected or surface has not been created

 		return;

 		}

 	// cancel the active objects that use the surface

 	if (iTimed)

 		{

 		TRequestStatus request = KRequestPending;

 		TRequestStatus logonRequest = KRequestPending;

 		// While a function call is in progress this thread is suspended

 		// and the undertaker will not catch panics, listen for these here

 		iRendererThread.Logon(logonRequest);

 		// Send request to renderer thread

 		iRendererRelay->DestroySurface(&request);

 		User::WaitForRequest(logonRequest, request);

 		if(logonRequest != KRequestPending)

 			{

 			// renderer thread got panic from surface update session, so panic client

 			TInt reason = iRendererThread.ExitReason();

 			TExitCategoryName category = iRendererThread.ExitCategory();

 			User::Panic(category,reason);

 			}

 		// Thread is still alive and well

 		iRendererThread.LogonCancel(logonRequest);

 		User::WaitForRequest(logonRequest); // Consume the signal

 		__ASSERT_DEBUG(request != KRequestPending, User::Panic(_L("CVR::DestroySurface"), KErrCorrupt));

 		}

 	else

 		{

 		iRendererRelay->DestroySurface(NULL);

 		}

 	UnregisterSurface();

 	delete iBufferManager;

 	iBufferManager = NULL;

 	iRendererRelay->SetBufferManager(NULL);

 	TInt err = iSurfaceManager.CloseSurface(iSurfaceId);

 	DEBUGPRINT2(_L("RSurfaceManager::CloseSurface returned with %d"), err);

 	}

 /**

 Retrieves the next free buffer from the renderer. The client can write data to 

 the buffer and update it to the screen using UpdateBuffer(). The buffer will 

 remain accessible to the client until it returns it to the renderer with 

 UpdateBuffer() or ReleaseBuffer(), the surface is destroyed (DestroySurface()), 

 or the renderer object is deleted.

 If no free buffers are available the client should wait for a 

 MvroVideoBufferAvailable() callback instead of polling for free buffers continuously.

 @return A pointer to the free buffer, or NULL if no free buffers are available.

 */

 EXPORT_C TVideoFrameBuffer* CVideoRenderer::NextBuffer()

 	{

 	if (iBufferManager)

 		{

 		return iBufferManager->NextBuffer();

 		}

 	// surface had not been created, return null

 	return NULL;

 	}

 /**

 Updates a surface buffer on the display. The buffer must have previously been 

 retrieved with NextBuffer() and must contain a valid video picture. The 

 renderer uses statistics from previous video frame rendering times to render 

 the picture as close to the requested presentation time as possible.

 @param aBuffer The buffer to update

 @param aPresentationTime The system clock time when the buffer should be 

 			visible on the display. If the time is zero the renderer will 

 			update the buffer as soon as possible without further synchronization.

 */

 EXPORT_C void CVideoRenderer::UpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aPresentationTime)

 	{

 	__ASSERT_DEBUG(aBuffer != NULL, User::Panic(_L("CVR::UpdateBuffer"), KErrArgument));

 	DEBUGPRINT3(_L("CVideoRenderer::UpdateBuffer entered with bufId=%d, aPresentationTime=%Ld"), 

 				aBuffer->BufferId() , aPresentationTime.Int64());

 	// ignore request if a surface has not been created or has been destroyed

 	if (!iBufferManager)

 		{

 		return;

 		}

 	if (iTimed)

 		{

 		TRequestStatus updateRequest = KRequestPending;

 		TRequestStatus logonRequest = KRequestPending;

 		// While a function call is in progress this thread is suspended

 		// and the undertaker will not catch panics, listen for these here

 		iRendererThread.Logon(logonRequest);

 		// Send request to renderer thread

 		iRendererRelay->UpdateBuffer(aBuffer, aPresentationTime, &updateRequest);

 		User::WaitForRequest(logonRequest, updateRequest);

 		if(logonRequest != KRequestPending)

 			{

 			// renderer thread got panic from surface update session, so panic client

 			TInt reason = iRendererThread.ExitReason();

 			TExitCategoryName category = iRendererThread.ExitCategory();

 			User::Panic(category,reason);

 			}

 		// Thread is still alive and well

 		iRendererThread.LogonCancel(logonRequest);

 		User::WaitForRequest(logonRequest); // Consume the signal

 		__ASSERT_DEBUG(updateRequest != KRequestPending, User::Panic(_L("CVR::UpdateBuffer"), KErrCorrupt));

 		}

 	else

 		{

 		iRendererRelay->UpdateBuffer(aBuffer, aPresentationTime, NULL);

 		}

 	}

 /**

 Releases a buffer without updating it to the display.

 The buffer must have previously been retrieved with NextBuffer() and 

 UpdateBuffer() is not called yet, otherwise the release request is ignored.

 @param aBuffer The buffer to release

 */

 EXPORT_C void CVideoRenderer::ReleaseBuffer(TVideoFrameBuffer* aBuffer)

 	{

 	// ignore if if a surface has not been created or has beed destroyed

 	if (!iBufferManager || !aBuffer)

 		{

 		return;

 		}

 	if (iBufferManager->ReleaseBuffer(aBuffer))

 		{

 		// a buffer is releaseed, notify observer

 		iObserver.MvroVideoBufferAvailable();

 		}

 	}