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

*/

#ifndef RENDERERRELAY_H

#define RENDERERRELAY_H

#include <e32base.h>

#include <e32msgqueue.h>

#include <graphics/surfaceupdateclient.h>

#include <mmf/devvideo/devvideobase.h>

#include "videorenderer.h"

class CBufAvailListener;

class CBufDisplayListener;

class CRendererTimer;

/** Interface for renderer relay object */

class MVideoRendererRelay

	{

public:

	virtual ~MVideoRendererRelay() {};

	virtual void UpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aPresentationTime, TRequestStatus* aRequestStatus) = 0;

	virtual void DestroySurface(TRequestStatus* aRequestStatus) = 0;

	virtual void SetBufferManager(CRendererBufferManager* aBufManager) = 0;

	virtual void PrepareL(const TSurfaceId& aSurfaceId, TInt aNumBuffers, TRequestStatus* aRequestStatus) = 0;

	virtual void SetRendererThread(RThread* aRendererThread) = 0;

	virtual void Terminate(TRequestStatus& aRequestStatus) = 0;

	virtual void SetTimerInfo(TInt64 aDefaultDelay, TInt64 aMaxDelay) = 0;

	};

/** 

Implemenation of MVideoRendererRelay. This class is responsible for submitting 

update for CVideoRenderer in non-timed mode. In timed mode, this class submits 

update for CRendererThreadRelay.

*/

NONSHARABLE_CLASS(CRendererRelay) : public CBase, public MVideoRendererRelay

	{

public:

	static CRendererRelay* NewL(MVideoRendererObserver& aObserver);

	~CRendererRelay();

	// from MRendererRelay

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

	void DestroySurface(TRequestStatus* aRequestStatus);

	void SetBufferManager(CRendererBufferManager* aBufManager);

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

	void SetRendererThread(RThread* aRendererThread);

	void Terminate(TRequestStatus& aRequestStatus);

	void SetTimerInfo(TInt64 aDefaultDelay, TInt64 aMaxDelay);

	void BufferDisplayed(TBool aDisplayed, TInt64 aDelay);

	TBool UpdateSubmitted();

	void SetRendererTimer(CRendererTimer* aRendererTimer);

	void RendererTimerExpired();

	void SubmitBufferTimed();

	TInt64 Delay();

private:

	CRendererRelay(MVideoRendererObserver& aObserver);

	void ConstructL();

	CBufAvailListener* BufAvailListener();

	void SubmitBuffer();

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

private:

	MVideoRendererObserver& iObserver;

	RSurfaceUpdateSession iSurfaceUpdateSession;

	CRendererBufferManager* iBufManager; // not owned

	CBufDisplayListener* iDisplayListener;

	TDblQue<CBufAvailListener> iBufAvailListeners;

	TDblQueIter<CBufAvailListener> iAvailListenersIter;

	TSurfaceId iSurfaceId;

	TBool iUpdateSubmitted;	// true if an update has been submitted

	TInt iFastCounterFrequency;

	TBool iFastCounterCountsUp;

	CRendererTimer* iRendererTimer; // not owned, null in non-timed mode

	TInt64 iDelay; // delay in microseconds

	TInt64 iMaxDelay;

	};

/** 

Listener in main thread for observer callback so that callback is done in main thread.

This class is needed so that callback to observer is done in the main thread 

instead of the renderer thread in timed mode.

*/

NONSHARABLE_CLASS(CRendererCallbackListener) : public CActive

	{

public:

	enum TFunctionCode

		{

		EBufferAvailable,

		EBufferDisplayed,

		EBufferSkipped

		};

	static CRendererCallbackListener* NewL(MVideoRendererObserver& aObserver, TInt aNumBuffer);

	~CRendererCallbackListener();

	void Start();

	void SendCallback(TFunctionCode aFunctionCode, TInt aBufferId, const TTime& aTime);

	void ExtendMsgQueueL(TInt aNumBuffer);

private:

	CRendererCallbackListener(MVideoRendererObserver& aObserver);

	void ConstructL(TInt aNumBuffer);

	// From CActive

	void RunL();

	void DoCancel();

private:

	class TCallbackData

		{

	public:

		TFunctionCode iFunctionCode;

		TInt iBufferId;

		TTime iTime;

		};

	MVideoRendererObserver& iObserver;

	RMsgQueue<TCallbackData> iMsgQueue;

	};

/** 

Implemenation of MVideoRendererRelay. This class is responsible taking submit

update request to the renderer thread in timed mode.

*/

NONSHARABLE_CLASS(CRendererThreadRelay) : public CActive, public MVideoRendererRelay, public MVideoRendererObserver

	{

public:

	~CRendererThreadRelay();

	static CRendererThreadRelay* NewL(MVideoRendererObserver& aObserver, TThreadId aMainThreadId);

	void Start();

	void SignalSetupComplete(TRequestStatus* aSetupComplete);

	TRequestStatus* Status();

	// from MRendererRelay

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

	void DestroySurface(TRequestStatus* aRequestStatus);

	void SetBufferManager(CRendererBufferManager* aBufManager);

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

	void SetRendererThread(RThread* aRendererThread);

	void Terminate(TRequestStatus& aRequestStatus);

	void SetTimerInfo(TInt64 aDefaultDelay, TInt64 aMaxDelay);

	// from MVideoRendererObserver

	void MvroVideoBufferAvailable();

	void MvroBufferDisplayed(TInt aBufferId, const TTime& aTime);

	void MvroBufferSkipped(TInt aBufferId);

private:

	CRendererThreadRelay(MVideoRendererObserver& aObserver);

	void ConstructL(TThreadId aMainThreadId);

	void RunL();

	void DoCancel();

	void RunUpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aPresentationTime);

	void RunDestroySurface();

	void RunPrepareL();

	void RunSetBufferManager();

private:

	enum TFunctionCode

		{

		ETermination,

		ESubmitUpdate,

		EDestroySurface,

		EPrepare,

		ESetBufferManager

		};

	MVideoRendererObserver& iObserver;

	RThread iMainThread;

	CRendererRelay* iRendererRelay;

	CRendererTimer* iRendererTimer;

	CRendererCallbackListener* iRendererCallbackListener;

	RThread* iRendererThread; //Not owned

	CRendererBufferManager* iBufManager; // not owned

	TRequestStatus* iCallingStatus; // not owned

	TFunctionCode iFunctionCode;

	TVideoFrameBuffer* iBuffer; // parameter for UpdateBuffer

	TTime iPresentationTime; // parameter for UpdateBuffer

	TSurfaceId iSurfaceId; // parameter for PrepareL

	TInt iNumBuffers; // parameter for PrepareL

	TInt64 iMaxDelay;

	};

/** Internal class for passing parameter to renderer thread */

class TThreadRelayParam

	{

public:

	MVideoRendererObserver* iObserver; //Not owned

	MVideoRendererRelay** iThreadRelay; //Not owned

	TThreadId iMainThreadId;

	TRequestStatus* iSetupComplete; //Not owned

	};	

#endif // RENDERERRELAY_H