// 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 <kernel/kern_priv.h>

#include <kernel/kernel.h>

#include <winsdef.h>

#include <emulator.h>

#include <pixelformats.h>

#include "gui.h"

#include "display_chan.h"

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

#ifndef DD_TRACE

#ifdef DD_TRACE_ENABLED

#define DD_TRACE(X) X

#else

#define DD_TRACE(X)

#endif

#endif

DDisplayChannel::DDisplayChannel() :

		iVSync(&DDisplayChannel::VSyncTimerFn, this),

		iVSyncDfc(&DDisplayChannel::VSyncDfcFn, this, Kern::DfcQue0(), KDfcPriority),

		iPostedBuffer((TUint)KBufferNotSet),

		iGetBuffer((TUint)KFirstCompositionBuffer),

		iDisplayStateSpinner(0),

		iVersion(KDisplayChMajorVersionNumber, 

			     KDisplayChMinorVersionNumber, 

			     KDisplayChBuildVersionNumber)

	{

	DD_TRACE(Kern::Printf("DDisplayChannel Creation");)

	}

DDisplayChannel::~DDisplayChannel()

	{

	DD_TRACE(Kern::Printf("DDisplayChannel Destruction");)

	//clean up.

	NKern::ThreadEnterCS();

	Kern::Free(iBuffer);

	NKern::ThreadLeaveCS();

	}

/**

  Second stage constructor called by the kernel's device driver framework.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DDisplayChannel::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

	// Check version

	if (!Kern::QueryVersionSupported(iDevice->iVersion, aVer))

		{

		return KErrNotSupported;

		}

	iScreenNumber = aUnit;	/*aUnit?*/

	SetDfcQ(Kern::DfcQue0());

	iMsgQ.Receive();

	// Ask the GUI code to initialize the rest of the object.

	return Kern::HalFunction(EHalGroupEmulator, EEmulatorHalSetDisplayChannel,

			(TAny*)iScreenNumber, this);

	}

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

	{

	__ASSERT_DEBUG(aInfo.iWidth > 0 && aInfo.iHeight > 0, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aInfo.iOffsetBetweenLines > 0, Panic(EDisplayPanicInvalidStride));

	__ASSERT_DEBUG(aInfo.iWidth * aBytesPerPixel <= (TUint)aInfo.iOffsetBetweenLines, Panic(EDisplayPanicInvalidStride));

	//this is just to stop compiler complaining..

	(TAny)aBytesPerPixel;

	(TAny)aInfo;

	}

/**

Finish creating the display channel object.

@param aInfo			Display description object

@param aRotation		Initial rotation

@param aHwnd			Associated window handle

@param aFrameBuffers	Array of one or more pointers to frame buffers

@param aResolution		Initial resolution

@param aTwips           Size in twips

@return	KErrNone if successful, or a system-wide error otherwise.

*/

TInt DDisplayChannel::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)

	{

	__ASSERT_DEBUG(aInfo.iBitsPerPixel >= 12 && aInfo.iBitsPerPixel <= 32, Panic(EDisplayPanicInvalidBitDepth));

	__ASSERT_DEBUG(aInfo.iRefreshRateHz > 0, Panic(EDisplayPanicInvalidRefreshRate));

	__ASSERT_DEBUG(aInfo.iAvailableRotations & aRotation, Panic(EDisplayPanicInvalidRotation));

	__ASSERT_DEBUG(aInfo.iNormal.iWidth == aInfo.iFlipped.iHeight, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aInfo.iNormal.iHeight == aInfo.iFlipped.iWidth, Panic(EDisplayPanicInvalidDimensions));

	__ASSERT_DEBUG(aRotation == RDisplayChannel::ERotationNormal ||

					aRotation == RDisplayChannel::ERotation90CW ||

					aRotation == RDisplayChannel::ERotation180 ||

					aRotation == RDisplayChannel::ERotation270CW, Panic(EDisplayPanicInvalidRotation));

	__ASSERT_DEBUG(aFrameBuffers.Count() > 0, Panic(EDisplayPanicInvalidFrameBuffers));

	__ASSERT_DEBUG(aHwnd, Panic(EDisplayPanicInvalidWindowHandle));

	ValidateSpecificInfo((aInfo.iBitsPerPixel > 16) ? 4 : 2, aInfo.iNormal);

	ValidateSpecificInfo((aInfo.iBitsPerPixel > 16) ? 4 : 2, aInfo.iFlipped);

	// aFrameBuffers includes the legacy buffer at index 0.

	iNumCompositionBuffers = aFrameBuffers.Count() - 1;

	iTotalBuffers = KFirstCompositionBuffer + iNumCompositionBuffers;

	iBuffer = (TBufferInfo*)Kern::AllocZ(iTotalBuffers * sizeof(TBufferInfo));

	iChunks = (TBufferAddressA*)Kern::AllocZ(iTotalBuffers * sizeof(TBufferAddressA));

	if (!iBuffer)

		{

		return KErrNoMemory;

		}

	aInfo.iNumCompositionBuffers = iNumCompositionBuffers;

	for (TUint index = 0; index < iNumCompositionBuffers; index++)

		{

		iBuffer[index + KFirstCompositionBuffer].iAddress = aFrameBuffers[index + 1];

		iChunks[index + KFirstCompositionBuffer].iChunk = aChunks[index + 1]->iChunk;

		}

	iChannelInfo = aInfo;

	iDisplayRotation = iCurrentRotation = aRotation;

	iDisplayResolution = iCurrentResolution = aResolution;

	iCurrentTwips = aTwips;

	iHwnd = aHwnd;

	// Ensure the VSync DFC is on the same queue as the message handling.

	iVSyncTicks = NKern::TimerTicks(1000 / aInfo.iRefreshRateHz);

    iVSync.OneShot(iVSyncTicks);

	if (aDsaBuffer.iMemChunks.Count() != 0)

		{	

		iBuffer[KLegacyBuffer].iAddress = aDsaBuffer.iFrameBuffers[0];

		}

	else

		{

		iBuffer[KLegacyBuffer].iAddress = NULL;

		}

	iPixelFormatArray = aPixelFormatArray;

	iPixelFormatArraySize = aPixelFormatArraySize;

	// copy the initial buffer format

	iInitialBufferFormat = aBufferFormat;

	iDisplayBufferFormat = iInitialBufferFormat;

	iCurrentBufferFormat = iDisplayBufferFormat;

	return KErrNone;

	}

/**

Set the address of the legacy buffer. 

@param aAddress			Pointer to the legacy buffer. 

*/

void DDisplayChannel::SetLegacyBuffer(void *aAddress)

	{ 

	iBuffer[KLegacyBuffer].iAddress = aAddress;

	}

/**

Handle a message on this display for the logical channel.

@param aMsg	The message to process. The iValue member of this distinguishes the

		message type:

		iValue == ECloseMsg, channel close message

		iValue == KMaxTInt, a 'DoCancel' message

		iValue >= 0, a 'DoControl' message with function number equal to iValue

		iValue < 0, a 'DoRequest' message with function number equal to ~iValue

*/

void DDisplayChannel::HandleMsg(TMessageBase* aMsg)

	{

	iMsg = (TThreadMessage*)aMsg;

	TInt id = iMsg->iValue;

	TInt r = KErrNone;

    if (id == (TInt)ECloseMsg)

       {

       iVSync.Cancel();

	   iWaitForPostRequest.Complete(KErrCancel);

	   iWaitForDisplayConnect.Complete(KErrCancel);

       if (iBuffer)

	       	{

    		// Unhook display channel from the GUI code if initialized.

    		if (iBuffer[KLegacyBuffer].iAddress)

	       		{

    		      	Kern::HalFunction(EHalGroupEmulator, EEmulatorHalSetDisplayChannel,

	   					(TAny*)iScreenNumber, NULL);

        	   		PostMessage(iHwnd, WMU_SET_DISPLAY_BUFFER, 0, 0);

		      	    InvalidateRect(iHwnd, NULL, FALSE);

    			}

	       	RDisplayChannel::TBufferId index = iTotalBuffers;

    		while (index-- > 0)

	       		{

		          	iBuffer[index].iRequest.Complete(KErrCancel);

        			if (IsUserBuffer(index))

		          		{

        				// Close chunk

		          		if (iBuffer[index].iChunk)

        					{

		              			NKern::ThreadEnterCS();

            					Kern::ChunkClose(iBuffer[index].iChunk);

            					NKern::ThreadLeaveCS();

        					}

				        }

			     }

            }

			iMsg->Complete(KErrNone, EFalse);

			return;

        }

	if (id < 0)

		{

		DoRequest(~id);

		r = KErrNone;

		}

	else

		{

		r = (id == KMaxTInt) ? DoCancel(iMsg->Int0()) : DoControl(id);

		}

	iMsg->Complete(r, (id != ECloseMsg));

	}

/**

Process synchronous 'control' requests. Parameters are in the first two

arguments of iMsg.

*/

TInt DDisplayChannel::DoControl(TInt aFunction)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoControl fn=%d\n", aFunction);)

	TInt r = KErrNotSupported;

	TPckgBuf<RDisplayChannel::TDisplayInfo> pkg(iChannelInfo);

	switch(aFunction)

		{

		case RDisplayChannel::ECtrlGetDisplayInfo:

			// a1: TDisplayInfo* info [out]

			Kern::KUDesPut(*(TDes8*)iMsg->Ptr0(), pkg); ///*&iChannelInfo*/);

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlOpen:

			// Everything is done in Construct

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlClose:

			// Nothing to do?

			r = KErrNone;

			break;

		case RDisplayChannel::ECtrlPostCompositionBuffer:

			// a1: const TRegionFix<KMaxRectangles>* region [in]

			// a2: TPostCount* post count [out]

			r = PostCompositionBuffer(iMsg->Ptr0(), (RDisplayChannel::TPostCount*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlPostLegacyBuffer:

			// a1: const TRegionFix<KMaxRectangles>* region [in]

			// a2: TPostCount* post count [out]

			r = PostLegacyBuffer(iMsg->Ptr0(), (RDisplayChannel::TPostCount*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlRegisterUserBuffer:

			// a1: { TInt Chunk handle, TInt offset }* [in]

			// a2: TInt* buffer ID [out]

			{

			__ASSERT_DEBUG(iMsg->Ptr0(), Panic(EDisplayPanicNullArgument));

			TInt arg[2];

			kumemget(arg, iMsg->Ptr0(), sizeof(arg));

			r = RegisterUserBuffer(arg[0], arg[1], (RDisplayChannel::TBufferId*)iMsg->Ptr1());

			}

			break;

		case RDisplayChannel::ECtrlDeregisterUserBuffer:

			// a1: TBufferId* buffer ID [in]

			r = DeregisterUserBuffer((RDisplayChannel::TBufferId*)iMsg->Ptr0());

			break;

		case RDisplayChannel::ECtrlSetRotation:

			// a1: TDisplayRotation* new rotation [in]

			// a2: TBool* display config has changed [out]

			r = SetRotation((RDisplayChannel::TDisplayRotation*)iMsg->Ptr0(), (TBool*)iMsg->Ptr1());

			break;

		case RDisplayChannel::ECtrlCurrentRotation:

			// a1: TDisplayRotation* current rotation [out]

			r = SafePut(iMsg->Ptr0(), &iCurrentRotation, sizeof(iCurrentRotation));

			break;

		case ECloseMsg:

			r = KErrNone;

			break;

	    case RDisplayChannel::ECtrlGetCompositionBufferInfo:

    	    {

    	    TInt arg[2];

    	    TInt index = *((TInt*)(iMsg->Ptr0()));

            r = Kern::MakeHandleAndOpen(iMsg->Client(), iChunks[index + KFirstCompositionBuffer].iChunk);

            if(r >= 0)

                {

	            arg[0] = r;

	            arg[1] = 0;

				SafePut(iMsg->Ptr1(),&arg,(sizeof(TInt)*2));

                r = KErrNone;

                }

             }

    	    break;

    	 // added to v1.0

	    case RDisplayChannel::ECtrlVersion:

			r = SafePut(iMsg->Ptr0(), &iVersion, sizeof(iVersion));

	    	break;

    	//v1_1

	    case RDisplayChannel::ECtrlNumberOfResolutions:

	    	{

	    	r = NumberOfResolutions();

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetResolutions:

	    	{

	    	r = GetResolutions();

	    	if(r == KErrCorrupt) //Resolution list changed during GetResolutions

	    		{//second go

	    		r = GetResolutions();

	    		}

	    	}

	    	break;

	    case RDisplayChannel::ECtrlSetResolution:

	    	{

	    	r = SetResolution((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetResolution:

	    	{

	    	r = GetResolution((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlGetTwips:

	    	{

	    	r = GetTwips((TSize*)iMsg->Ptr0());

	    	}

	    	break;

	    case RDisplayChannel::ECtrlNumberOfPixelFormats:

			r = iPixelFormatArraySize;

	    	break;

	    case RDisplayChannel::ECtrlGetPixelFormats:

	    	r = GetPixelFormats();

	    	break;

	    case RDisplayChannel::ECtrlSetBufferFormat:

	    	r = SetBufferFormat((RDisplayChannel::TBufferFormat*)iMsg->Ptr0());

	    	break;

	    case RDisplayChannel::ECtrlGetBufferFormat:

			r = SafePut(iMsg->Ptr0(), &iCurrentBufferFormat, sizeof(iCurrentBufferFormat));

	    	break;

	    case RDisplayChannel::ECtrlNextPlaneOffset:

	    	// we support, for moment only packed pixel formats

	    	r = NextPlaneOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(), NULL);

	    	break;

	    case RDisplayChannel::ECtrlNextLineOffset:

	    	// use the internal current resolution and current rotation

	    	r = NextLineOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(), NULL);

	    	break;

	    case RDisplayChannel::ECtrlNextPlaneOffsetExtended:

	    	// we support, for moment only packed pixel formats

	    	r = NextPlaneOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(),

	    			            (RDisplayChannel::TBufferFormatContext*)iMsg->Ptr1());

	    	break;

	    case RDisplayChannel::ECtrlNextLineOffsetExtended:

	    	r = NextLineOffset((RDisplayChannel::TBufferFormat*)iMsg->Ptr0(),

	    			           (RDisplayChannel::TBufferFormatContext*)iMsg->Ptr1());

	    	break;

		}

	DD_TRACE(Kern::Printf("<DDisplayChannel::DoControl result=%d\n",r);)

	return r;

	}

TInt DDisplayChannel::GetIndexForSize(const TSize& aSize,TInt& aSpinnerOut)

	{

	TInt numberOfResolutions = 0;

	TInt spinner1 = 0;

	TInt r = Kern::HalFunction(EHalGroupDisplay, EDisplayHalNumberOfResolutions, &numberOfResolutions, &spinner1, iScreenNumber);

	if(r < KErrNone)

		return r;

	TVideoInfoV01 info;

	TPckg<TVideoInfoV01> infoPckg(info);

	for (TInt res=0;res<numberOfResolutions;res++)

		{

		//pass info package to be filled in, also sending the config to read, and the screen within that

		Kern::HalFunction(EHalGroupDisplay, EDisplayHalSpecificScreenInfo, (TAny*)&res, (TAny*)&infoPckg, iScreenNumber);

		if (info.iSizeInPixels.iWidth==aSize.iWidth && info.iSizeInPixels.iHeight==aSize.iHeight)

			{

			r = Kern::HalFunction(EHalGroupDisplay, EDisplayHalNumberOfResolutions, &numberOfResolutions, &aSpinnerOut, iScreenNumber);

			if(r < KErrNone)

				return r;

			if (aSpinnerOut!=spinner1)

				{

				return KErrCorrupt;

				}

			else

				{

				return res;

				}

			}

		}

	return KErrArgument;

	}

/**

Process asynchronous requests. TRequestStatus is at iMsg->Ptr0(), and the other

two parameters are in iMsg->Ptr1() and iMsg->Ptr2().

*/

void DDisplayChannel::DoRequest(TInt aFunction)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoRequest fn=%d\n", aFunction);)

	TInt r = KErrNotSupported;

	switch(aFunction)

		{

		case RDisplayChannel::EReqGetCompositionBuffer:

			// a1: TAny** buffer address [out]

			r = GetCompositionBuffer(static_cast<TAny**>(iMsg->Ptr1()));

			break;

		case RDisplayChannel::EReqPostUserBuffer:

			// a1: { TBufferId* buffer ID, const TRegionFix<KMaxRectangles>* region }* [in]

			// a2: TPostCount* post count [out]

			{

			TAny* arg[2];

			__ASSERT_DEBUG(iMsg->Ptr1(), Panic(EDisplayPanicNullArgument));

			kumemget(arg, iMsg->Ptr1(), sizeof(arg));

			r = PostUserBuffer(reinterpret_cast<RDisplayChannel::TBufferId*>(arg[0]), arg[1],

					reinterpret_cast<RDisplayChannel::TPostCount*>(iMsg->Ptr2()));

			}

			break;

		case RDisplayChannel::EReqWaitForPost:

			// a1: TInt* post to wait for [in]

			r = WaitForPost(static_cast<RDisplayChannel::TPostCount*>(iMsg->Ptr1()));

			break;

	    	//v1_1

		case RDisplayChannel::EReqWaitForDisplayConnect:

			r = WaitForDisplayConnect();

			break;

		}

	DD_TRACE(Kern::Printf("<DDisplayChannel::DoRequest result=%d\n",r);)

	if (r != KRequestPending)

		{

		TRequestStatus* status = reinterpret_cast<TRequestStatus*>(iMsg->Ptr0());

		Kern::RequestComplete(iMsg->Client(), status, r);

		}

	}

/**

Process asynchronous request cancellations

*/

TInt DDisplayChannel::DoCancel(TInt aRequestMask)

	{

	DD_TRACE(Kern::Printf(">DDisplayChannel::DoCancel mask=%x\n", aRequestMask);)

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelGetCompositionBuffer))

		{

		if (IsCompositionBuffer(iGetBuffer))

			{

			iBuffer[iGetBuffer].iRequest.Complete(KErrCancel);

			}

		}

	if (aRequestMask & (1 << RDisplayChannel::ECtrlCancelPostUserBuffer))

		{

		if (IsUserBuffer(iPostedBuffer))

			{

			iBuffer[iPostedBuffer].iRequest.Complete(KErrCancel);

			}