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

 @publishedPartner

 @prototype

*/

#ifndef __DISPLAY_CHAN_H__

#define __DISPLAY_CHAN_H__

#include "nk_priv.h"

#include <dispchannel.h>

#include <videodriver.h>

#include "displayhandler.h"

struct TBufferAddressA;

class TScreenBuffer;

/**

Logical Channel kernel side class for Display

*/

class DDisplayChannel : public DLogicalChannel

	{

public:

	// constants

	enum { KDisplayChMajorVersionNumber = 1 };

	enum { KDisplayChMinorVersionNumber = 2 };

	enum { KDisplayChBuildVersionNumber = 1 };

public:

	// Duplicate of RDisplayChannel structure, as the header file cannot be used.

	class TCaps

    {

      public:

          TVersion iVersion;

    };

	class TRequest

		{

	public:

		inline TRequest(void) : iThread(0), iStatus(0) {}

		TBool SetStatus(TThreadMessage& aMsg);

		void Complete(TInt aResult);

	public:

		DThread* iThread;

		TRequestStatus* iStatus;

		};

	class TBufferInfo

		{

	public:

		TAny* iAddress;

		DChunk* iChunk;

		TRequest iRequest;

		};

	enum TDisplayPanic

		{

		EDisplayPanicNullThreadOnSet = 1,

		EDisplayPanicInUse = 2,

		EDisplayPanicThreadAlreadySet = 3,

		EDisplayPanicNullThreadOnComplete = 4,

		EDisplayPanicThreadOpenFailed = 5,

		EDisplayPanicWaitForPostMissed = 6,

		EDisplayPanicNullArgument = 7,

		EDisplayPanicNotYetImplemented = 8,

		EDisplayPanicInvalidDimensions = 9,

		EDisplayPanicInvalidRotation = 10,

		EDisplayPanicInvalidBitDepth = 11,

		EDisplayPanicInvalidStride = 12,

		EDisplayPanicInvalidWindowHandle = 13,

		EDisplayPanicInvalidFrameBuffers = 14,

		EDisplayPanicInvalidRefreshRate = 15,

		EDisplayPanicInvalidOffset = 16,

		EDisplayPanicNoLegacyBuffer = 17

		};

public:

	DDisplayChannel(void);

	~DDisplayChannel(void);

	// DLogicalChannel implementation

	virtual TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

	virtual void HandleMsg(TMessageBase* aMsg);

	// Function used by the UI code to set up the buffers.

	virtual TInt Initialize(RDisplayChannel::TDisplayInfo& aInfo, 

							RDisplayChannel::TDisplayRotation aRotation,

							HWND aHwnd, RPointerArray<TAny>& aFrameBuffers, 

							RPointerArray<TBufferAddressA>& aChunks,

							TScreenBuffer& aDsaBuffer,

							TSize aResolution, 

							TSize aTwips,

							const RDisplayChannel::TPixelFormat aPixelFormatArray[],

							const TInt aPixelFormatArraySize,

							const RDisplayChannel::TBufferFormat& aBufferFormat);

	virtual void SetLegacyBuffer(void *aAddress);

private:

	DDisplayChannel(const DDisplayChannel&);

	// Handlers for the three classes of channel message sent

	TInt DoControl(TInt aFunction);

	void DoRequest(TInt aFunction);

	TInt DoCancel(TInt aRequestMask);

	TInt NumberOfResolutions();

	TInt SafePut(TAny* aDst, TAny* aSrc, TInt aBytes);

	void ValidateSpecificInfo(TInt aBytesPerPixel, RDisplayChannel::TOrientationSpecificInfo& aInfo);

	static void Panic(TDisplayPanic aPanic);

	void ClientPanic(RDisplayChannel::TPanic aPanic);

	inline TBool IsCompositionBuffer(RDisplayChannel::TBufferId aId);

	static inline TBool IsLegacyBuffer(RDisplayChannel::TBufferId aId);

	static inline TBool IsUserBuffer(RDisplayChannel::TBufferId aId);

	inline TBool IsValidBuffer(RDisplayChannel::TBufferId aId);

    inline RDisplayChannel::TBufferId NextCompositionBuffer(RDisplayChannel::TBufferId aId);

	static inline TBool IsFlipped(RDisplayChannel::TDisplayRotation aRotation);

	static void VSyncTimerFn(TAny* aDisplayChannel);

	void DoVSyncTimer(void);

	static void VSyncDfcFn(TAny* aDisplayChannel);

	void DoVSync(void);

	TInt PostCompositionBuffer(TAny* aRegion, RDisplayChannel::TPostCount* aPostCount);

	TInt PostLegacyBuffer(TAny* aRegion, RDisplayChannel::TPostCount* aPostCount);

	TInt GetCompositionBuffer(TAny** aAddress);

	TInt PostUserBuffer(RDisplayChannel::TBufferId* aBufferId, TAny* aRegion, RDisplayChannel::TPostCount* aPostCount);

	TInt WaitForPost(RDisplayChannel::TPostCount* aPostCount);

	TInt WaitForDisplayConnect();

	TInt SetRotation(RDisplayChannel::TDisplayRotation* aNewRotation, TBool* aIsBufferPreserved);

	TInt RegisterUserBuffer(TInt aChunkHandle, TInt aOffset, RDisplayChannel::TBufferId* aBufferId);

	TInt DeregisterUserBuffer(RDisplayChannel::TBufferId* aBufferId);

	TInt GetResolutions();

	TInt SetResolution(TSize* aSize);

	TInt GetResolution(TSize* aSize);

	TInt GetTwips(TSize* aSize);

	TInt GetIndexForSize(const TSize& aSize,TInt& aSpinnerOut);

	TInt GetPixelFormats();

	TInt SetBufferFormat(RDisplayChannel::TBufferFormat* aBufferFormat);

	TInt NextPlaneOffset(RDisplayChannel::TBufferFormat* aBufferFormat, 

			            RDisplayChannel::TBufferFormatContext* aContext);

	TInt NextLineOffset(RDisplayChannel::TBufferFormat* aBufferFormat, 

			            RDisplayChannel::TBufferFormatContext* aContext);

	TInt ValidateBufferFormat(const RDisplayChannel::TBufferFormat& aBufferFormat,

						 	  const RDisplayChannel::TResolution& aResolution);

private:

	// Constants

	enum {KDfcPriority = 6};

	enum {KBufferNotSet = -1};

	// Buffer index points. The legacy buffer is first, followed by the user

	// buffers, followed by a variable number of composition buffers.

	enum { KLegacyBuffer = 0};

	enum { KFirstUserBuffer = KLegacyBuffer + 1};

	enum { KFirstCompositionBuffer = KFirstUserBuffer + RDisplayChannel::TDisplayInfo::KMaxUserBuffers};

	enum { KMaxBufferSizeHeightAndWidth = KMaxTInt16 };

private:

	TInt iScreenNumber;

	TThreadMessage* iMsg;

	TInt iVSyncTicks;					// Number of nanokernel ticks between frames

	TUint iNumCompositionBuffers;		// Number of composition buffers

	TUint iTotalBuffers;				// KFirstCompositionBuffer + iNumCompositionBuffers

	RDisplayChannel::TDisplayInfo iChannelInfo;

	RDisplayChannel::TPostCount iPostCount;				// Count of Post... calls

	RDisplayChannel::TPostCount iLastPostCount;			// Value of iPostCount when last buffer was actually posted

	TBufferInfo* iBuffer;				// Allocated to contain iTotalBuffers

	TBufferAddressA* iChunks;

	DThread* iClient;

	// Posting support

	NTimer iVSync;						// Emulated VSync signal using a timer

	TDfc iVSyncDfc;						// DFC queued on DfcQue0 when iVSync triggers

	RDisplayChannel::TBufferId iPostedBuffer;			// Index of buffer to be posted on next frame

	RDisplayChannel::TDisplayRotation iCurrentRotation;	// Rotation of buffer being posted

	RDisplayChannel::TDisplayRotation iNewRotation;	// Rotation of buffer being posted

	TSize iCurrentResolution;			// Display resolution (normal rotation) to be posted

	TSize iNewResolution;			    // Display resolution (normal rotation) for buffer being posted

	TSize iCurrentTwips;

	TInt iPostedRectCount;				// Number of rectangles defined in region

	RECT iPostedRect[RDisplayChannel::TDisplayInfo::KMaxRectangles];	//

	// Paint support

	HWND iHwnd;							// Window to be painted

	RDisplayChannel::TBufferId iDisplayBuffer;			// Index of buffer to be painted

	RDisplayChannel::TDisplayRotation iDisplayRotation;	// Rotation of buffer to be painted

	TSize iDisplayResolution;			// Display resolution (normal rotation) on screen

	// GetCompositionBuffer support

	TUint iGetBuffer;					// Index of next composition buffer

	// WaitForPost support

	RDisplayChannel::TPostCount iWaitForPost;			// Post count being awaited

	TRequest iWaitForPostRequest;		// Request to complete when post count reached

	// WaitForDisplayConnect support 

	TRequest iWaitForDisplayConnect;		// Request to complete when display connection state changes

	TInt iDisplayStateSpinner;

	TVersion iVersion;

	const RDisplayChannel::TPixelFormat* iPixelFormatArray;

	TInt iPixelFormatArraySize;

	RDisplayChannel::TBufferFormat iInitialBufferFormat;

	RDisplayChannel::TBufferFormat iCurrentBufferFormat;

	RDisplayChannel::TBufferFormat iDisplayBufferFormat;

	RDisplayChannel::TBufferFormat iNewBufferFormat;

	};

inline TBool DDisplayChannel::IsCompositionBuffer(RDisplayChannel::TBufferId aId)

	{ return (aId >= KFirstCompositionBuffer && aId < iTotalBuffers); }

inline TBool DDisplayChannel::IsLegacyBuffer(RDisplayChannel::TBufferId aId)

	{ return (aId == KLegacyBuffer); }

inline TBool DDisplayChannel::IsUserBuffer(RDisplayChannel::TBufferId aId)

	{ return (aId >= KFirstUserBuffer && aId < (KFirstUserBuffer + RDisplayChannel::TDisplayInfo::KMaxUserBuffers)); }

inline TBool DDisplayChannel::IsValidBuffer(RDisplayChannel::TBufferId aId)

	{ return (aId >= 0 && aId < iTotalBuffers); }

inline RDisplayChannel::TBufferId DDisplayChannel::NextCompositionBuffer(RDisplayChannel::TBufferId aId)

	{ TUint r = (aId + 1); return (r >= iTotalBuffers) ? KFirstCompositionBuffer : r; }

inline TBool DDisplayChannel::IsFlipped(RDisplayChannel::TDisplayRotation aRotation)

	{ return !(aRotation & (RDisplayChannel::ERotationNormal | RDisplayChannel::ERotation180)); }

#endif