// Copyright (c) 2005-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 <e32test.h>

#include <hal.h>

#include <bitdraw.h>

#include <bitdrawinterfaceid.h>

#include <bitdrawsurface.h>

#include "cdsb.h"

#include <bitstd.h>

#include <bitdev.h>

#include "BMDRAW.H"

#ifdef SYMBIAN_GRAPHICS_GCE

#undef __WINS__

#elif __WINS__

#include "_WININC.H"

#endif

#include "TDirectScreenBitmap.h"

enum 

	{

	WAIT_TIME = 1*400000

	};

class CCommonInterfaces

	{

public:

	virtual ~CCommonInterfaces();

	TBool ScreenClear();

	TBool ScreenClearPartial();

	TBool DrawColor(const TRect& aRect,const TRgb& aColour);

	CCommonInterfaces(const TRect& aRect, const TDisplayMode& aDispMode,CDirectScreenBitmap* aDSBitmap);

	void BeginDraw();

	void EndDraw(TRequestStatus& aStatus);

	void EndDraw(const TRect& aRect, TRequestStatus& aStatus);

	void Drawing(const TRect& aRect);

	void DrawColour64KPixel(TInt aX,TInt aY, const TRgb& aColour);

protected:

	TRect iRect;

	TDisplayMode iDispMode;

   	CDirectScreenBitmap* iDSBitmap;

   	TAcceleratedBitmapInfo iBitmapInfo;

   	TBool iDrawingRed;

	};

CCommonInterfaces::CCommonInterfaces(const TRect& aRect, const TDisplayMode& aDispMode,CDirectScreenBitmap* aDSBitmap):iRect(aRect),iDispMode(aDispMode),iDSBitmap(aDSBitmap),iDrawingRed(ETrue)

	{

	}

CCommonInterfaces::~CCommonInterfaces()

	{

	}

/** If the display mode of iBitmapInfo is not expected, return EFalse

 * or render to the back buffer and returns ETrue

*/

TBool CCommonInterfaces::DrawColor(const TRect& aRect,const TRgb& aColour)

	{

	TRect local = TRect(aRect.iTl-iRect.iTl, aRect.Size());

	TUint16* pBuffer16;

	TUint32* pBuffer32;

	if (iBitmapInfo.iDisplayMode != iDispMode)

		{

		return EFalse;

		}

	for (TInt y = local.iTl.iY; y < local.iBr.iY; y++)

		{

		for (TInt x = local.iTl.iX; x < local.iBr.iX; x++)

			{

			switch (iDispMode)

				{

				case EColor64K:

					pBuffer16 = (TUint16*)iBitmapInfo.iAddress;

					pBuffer16[y*iBitmapInfo.iLinePitch/2+x] = aColour._Color64K();

					break;

				case EColor16M:

					pBuffer16 = (TUint16*)iBitmapInfo.iAddress;

					pBuffer16[y*iBitmapInfo.iLinePitch/2+x] = aColour._Color64K();

					break;

				case EColor16MU:

					pBuffer32 = (TUint32*)iBitmapInfo.iAddress;

					pBuffer32[y*iBitmapInfo.iLinePitch/4+x] = aColour._Color16MU();

					break;

				case EColor16MA:

					pBuffer32 = (TUint32*)iBitmapInfo.iAddress;

					pBuffer32[y*iBitmapInfo.iLinePitch/4+x] = aColour._Color16MA();

					break;

				case EColor4K:

					pBuffer16 = (TUint16*)iBitmapInfo.iAddress;

					pBuffer16[y*iBitmapInfo.iLinePitch/2+x] = aColour._Color4K();

					break;

				case EColor16MAP:

					pBuffer32 = (TUint32*)iBitmapInfo.iAddress;

					pBuffer32[y*iBitmapInfo.iLinePitch/4+x] = aColour._Color16MAP();

					break;

				default:

					break;

				}

			}

		}

	return ETrue;

	}

TBool CCommonInterfaces::ScreenClear()

	{

    iDSBitmap->BeginUpdate(iBitmapInfo);

    TBool ret= DrawColor(iRect, KRgbWhite);

    if (ret)

    	{

        TRequestStatus requestStatus;

        iDSBitmap->EndUpdate(requestStatus);	

    	}

    return ret;

	}

TBool CCommonInterfaces::ScreenClearPartial()

	{

    iDSBitmap->BeginUpdate(iBitmapInfo);

    TBool ret= DrawColor(iRect, KRgbWhite);

    if (ret)

    	{

        TRequestStatus requestStatus;

        iDSBitmap->EndUpdate(iRect,requestStatus);	

    	}

    return ret;

	}

void CCommonInterfaces::BeginDraw()

    {

    iDSBitmap->BeginUpdate(iBitmapInfo);       

    }

void CCommonInterfaces::EndDraw(TRequestStatus& aStatus)

    {

     iDSBitmap->EndUpdate(aStatus);       

    }

void CCommonInterfaces::EndDraw(const TRect& aRect, TRequestStatus& aStatus)

	{

    iDSBitmap->EndUpdate(aRect,aStatus);       

	}

void CCommonInterfaces::Drawing(const TRect& aRect)

	{

    if (iDrawingRed)

    	{

    	DrawColor(aRect,KRgbRed);

    	iDrawingRed = EFalse;

    	}

    else

    	{

    	DrawColor(aRect,KRgbBlack);

    	iDrawingRed = ETrue;

    	}

     }

void CCommonInterfaces::DrawColour64KPixel(TInt aX,TInt aY, const TRgb& aColour) 

	{ 

	TUint16 *pBuffer = (TUint16*)iBitmapInfo.iAddress; 

	pBuffer[aY*iBitmapInfo.iLinePitch/2+aX] = aColour._Color64K(); 

	}

class CRendering : public CActive, public CCommonInterfaces

    {

 	public:

 		static CRendering* NewL(const TRect& aRect, const TDisplayMode& aDispMode, CDirectScreenBitmap* aDSBitmap,CDirectScreenBitmap::TSettingsFlags aSettings);

 		void ProcessFrame();

 		void EndDraw();

 		virtual ~CRendering();

 	protected: // from CActive

    	void DoCancel();

    	void RunL();

    private:

    	CRendering(const TRect& aRect, const TDisplayMode& aDispMode,CDirectScreenBitmap* aDSBitmap,CDirectScreenBitmap::TSettingsFlags aSettings);

    	void ConstructL();

    private:

    	TAcceleratedBitmapInfo iBitmapInfo;

    	TInt iFrames;	

    	CDirectScreenBitmap::TSettingsFlags iSettings;

    };

CRendering* CRendering::NewL(const TRect& aRect, const TDisplayMode& aDispMode,CDirectScreenBitmap* aDSBitmap, CDirectScreenBitmap::TSettingsFlags aSettings)

	{

	CRendering * rendering = new (ELeave) CRendering(aRect, aDispMode, aDSBitmap, aSettings);

	CleanupStack::PushL(rendering);

	rendering->ConstructL();

	CleanupStack::Pop(rendering);

	return rendering;

	}

CRendering::~CRendering()

    {

    // "Cancel" is a meaningless call, since the service 

    // (video driver's screen update process) is not cancellable.

    // When destroying this active object, you must make sure, 

    // that the last update request (CDirectScreenBitmap::EndUpdate()) is completed.

    // Assuming that LCD refresh rate is not less than 60 Hz,

    // the wait time should be more than 1/60 secs.

    // (Otherwise a stay signal comes.)

    User::After(WAIT_TIME); // to let the GCE return a valid request notification back to CDSB

    						// or surface update panics with EUpdateServPanicDataIntegrity

    Cancel();

    }

CRendering::CRendering(const TRect& aRect, const TDisplayMode& aDispMode, CDirectScreenBitmap* aDSBitmap,CDirectScreenBitmap::TSettingsFlags aSettings)

:CActive( CActive::EPriorityStandard ),CCommonInterfaces(aRect,aDispMode,aDSBitmap),iFrames(0),iSettings(aSettings)

    {

    }

void CRendering::ConstructL()

    {

    CActiveScheduler::Add( this );

    // clear the screen, and also check the display mode of iBitmapInfo is the same as expected

    // If not, stop creating the CRendering object. 

    TBool ret = (iSettings & CDirectScreenBitmap::EIncrementalUpdate) ? ScreenClearPartial() : ScreenClear();

    if (!ret)

    	{

    	User::Leave(KErrGeneral);

    	}

    }

void CRendering::RunL()

    {

    // Video driver finished to draw the last frame on the screen

    // You may initiate rendering the next frame from here, 

    // but it would be slow, since there is a delay between CDirectScreenBitmap::EndUpdate() 

    // and the completition of screen refresh by the video driver	

    if (iFrames++ <200)

    	{

    	ProcessFrame();

      	}

    else

    	{

    	CActiveScheduler::Stop();

    	}      

    }

void CRendering::DoCancel()

    {

    // Cancel not implemented in service provider, so we can't do anything here

    }

void CRendering::EndDraw()

    {

    if (IsActive())

    	{

    	Cancel();

    	}

    CCommonInterfaces::EndDraw(iStatus);

    SetActive();

    }

void CRendering::ProcessFrame()

    {

    BeginDraw();

    Drawing(iRect);

    EndDraw();

    }

//A largely visual test to demonstrate regional refreshing of DirectScreenBitmaps and the correct display function

//of the Emulator.

class CTDirectScreenBitmap : public CTGraphicsBase

	{

	public:	

		~CTDirectScreenBitmap();

		void ConstructL(const TRect &aScreenRect, const CDirectScreenBitmap::TSettingsFlags aSettings,TInt aScreenNo=0);	

		void Close();

		void DoRefreshCycle(void);

		void TestOrientRefresh(CFbsDrawDevice *aDev);

		void TestRefreshingWindowsL();

		void ExhaustiveTestMergeL(TBool aInSrcPreMul,TBool aInDestPreMul,TBool aOutDestPreMul,TInt aStepSize=1,TInt aChannelControl=1);

		void ExhaustiveTestMergePerDispModeL(TDisplayMode aDrawDeviceDispMode, TBool aInSrcPreMul,TBool aInDestPreMul,TBool aOutDestPreMul,TInt aStepSize=1,TInt aChannelControl=1,TInt aOtherChannels=0,TDisplayMode aTestMode=EColor16MA);

 		void LogColourEvent(TInt aPreMulDestPixColor,TInt aNonPreMulDestPixColor,TInt aPreMulSrcPixelColor,TInt aNonPreMulSrcPixelColor,TReal aVal1,TReal aVal2,TReal aVal3,TRefByValue<const TDesC> aMsg,TBool aErr);

 		void TestContinuousRefreshingL();

 		void TestRefreshingTimeL();

	private:

	    void TestRefreshingWindowsPerDisplayModeL(TDisplayMode aDisplayMode);

		void TestContinuousRefreshingPerDisplayModeL(const TDisplayMode& aDisplayMode);

		void UpdateFrame();

		void MeasureFrame(const TRect &aScreenRect);

	    CDirectScreenBitmap::TSettingsFlags iSettings;

		CDirectScreenBitmap* iDirectScreenBitmap;

		TAcceleratedBitmapInfo iBitmapInfo;

		TRequestStatus iRequestStatus;

		TRect iFullRect;

		TRect iTopLeft;

		TRect iTopRight;

		TRect iBotLeft; 

		TRect iBotRight;

		TRect iMiddle;

		TInt iScreenType;

		CCommonInterfaces* iInterface; 

		CRendering* iRendering;

	public:

		CTDirectScreenBitmap();

		CTDirectScreenBitmap(CTestStep* aStep);

	protected:

	//from 	CTGraphicsStep

		virtual void RunTestCaseL(TInt aCurTestCase);

	private:

		TDisplayMode iDispMode;

		TInt iFreq;			// For measuring the average time per frame

	    TReal iMeasure ;

	    TUint32 iTimeBefore;

	    TUint32 iTimeAfter;

	};

/**

The runtime code currently contains a special case when dest starts unmultipled and ends premultiplied. 

When src alpha is 0 the dest colour is simply passed through, not converted from unmultiplied to premultiplied. 

That causes this fn to record errors, that will get ignored 

for all source mask (srcMask==0), and most values of bkgrdChannel.

*/

class TIgnoreSpecialCases  

	{ 

	public: 

		TIgnoreSpecialCases (TBool aInSrcPreMul,TBool aInDestPreMul,TBool aOutDestPreMul) ;

		bool operator()(TInt aPreMulDestPixColor,TInt aNonPreMulDestPixColor,TInt aSrcMask,TInt aSrcChannel);

		TInt IgnoreCount();

		TInt ExpectedIgnoreCount(TInt aFreq);

      private: 

	      TInt iIgnoredCount; 

	      TBool iDoIgnore; 

	}; 

CTDirectScreenBitmap::CTDirectScreenBitmap(CTestStep* aStep) :

	CTGraphicsBase(aStep),iMeasure(0)

	{

	}

CTDirectScreenBitmap::~CTDirectScreenBitmap()

	{

	Close();

	}

//Construct the DirectScreenBitmap and sub-rects for test of the refresh.	

//Constructs a DirectScreenBitmap for EDoubleBuffer and EIncrementalUpdate

void CTDirectScreenBitmap::ConstructL(const TRect &aScreenRect, const CDirectScreenBitmap::TSettingsFlags aSettings, TInt aScreenType)

	{

	Close();

	iScreenType = aScreenType;

	TInt Screenno;

	if (iScreenType==CDirectScreenBitmap::EDoubleBuffer || iScreenType==CDirectScreenBitmap::EIncrementalUpdate)  

		{

		Screenno=iScreenType;

		iDirectScreenBitmap = CDirectScreenBitmap::NewL(Screenno);

		}

	else

		{

		iDirectScreenBitmap = CDirectScreenBitmap::NewL();

		}

	iSettings = aSettings;

	TInt create=iDirectScreenBitmap->Create(aScreenRect, aSettings);

	if (create==KErrNone)

		{

		iFullRect	 = aScreenRect;

		TPoint Pos	 = aScreenRect.iTl;

		TSize hSize	 = TSize(aScreenRect.Width()/2, aScreenRect.Height()/2);

		TSize hSizeX = TSize(aScreenRect.Width()/2, 0);

		TSize hSizeY = TSize(0, aScreenRect.Height()/2);

		TSize qSize	 = TSize(aScreenRect.Width()/4, aScreenRect.Height()/4);

		iTopLeft  = TRect(Pos,  hSize);

		iTopRight = TRect(Pos + hSizeX, hSize);

		iBotLeft  = TRect(Pos + hSizeY, hSize);	

		iBotRight = TRect(Pos + hSize,  hSize);

		iMiddle   = TRect(Pos + hSize - qSize,  hSize);

		iInterface = new (ELeave) CCommonInterfaces(iFullRect, iDispMode, iDirectScreenBitmap);

		iRendering = CRendering::NewL(iFullRect,iDispMode,iDirectScreenBitmap,iSettings);

		}

	else 

		{

		User::Leave(create);

		}

	}

void CTDirectScreenBitmap::Close()

	{

	User::After(WAIT_TIME);

	delete iDirectScreenBitmap;

	iDirectScreenBitmap = NULL;

	delete iInterface;

	iInterface = NULL;

	delete iRendering;

	iRendering = NULL;

	}

//A refresh cycle fills a 2x2 region of RGBW rects and draws it to the screen. If the mode is incremental

//The different colour rects are updated seperately to test the sub-region update.

void CTDirectScreenBitmap::DoRefreshCycle(void)

	{

	if ((iSettings & CDirectScreenBitmap::EIncrementalUpdate)&&(!iInterface->ScreenClearPartial()))

		{

		INFO_PRINTF1(_L("The display mode of the iBitmapInfo is not expected"));

		}

	else if (!(iSettings & CDirectScreenBitmap::EIncrementalUpdate)&&(!iInterface->ScreenClear()))

		{

		INFO_PRINTF1(_L("The display mode of the iBitmapInfo is not expected"));

		}

	else 

		{

		iInterface->BeginDraw();

		iInterface->DrawColor(iTopLeft,KRgbRed);

		iInterface->DrawColor(iTopRight,KRgbGreen);

		iInterface->DrawColor(iBotLeft,KRgbBlue);

		iInterface->DrawColor(iBotRight,KRgbBlack);

		if (!(iSettings & CDirectScreenBitmap::EIncrementalUpdate))

			{		

			iInterface->EndDraw(iRequestStatus);	

			User::After(WAIT_TIME);

			}

		else

			{		

			iInterface->EndDraw(iTopLeft, iRequestStatus);	

			User::After(WAIT_TIME);

			iInterface->BeginDraw();

			iInterface->EndDraw(iTopRight, iRequestStatus);	

			User::After(WAIT_TIME);

			iInterface->BeginDraw();

			iInterface->EndDraw(iBotLeft, iRequestStatus);	

			User::After(WAIT_TIME);

			iInterface->BeginDraw();

			iInterface->EndDraw(iBotRight, iRequestStatus);	

			User::After(WAIT_TIME);

			iInterface->DrawColor(iMiddle,KRgbCyan);

			iInterface->BeginDraw();

			iInterface->EndDraw(iMiddle, iRequestStatus);

			User::After(WAIT_TIME);

			}

		__ASSERT_DEBUG(iInterface->ScreenClear(), User::Invariant());

		}

	}

//Tests the Orientation and Refresh operations

void CTDirectScreenBitmap::TestOrientRefresh(CFbsDrawDevice *aDev)

	{

	MSurfaceId* surfaceIdInterface;

	if (KErrNone != aDev->GetInterface(KSurfaceInterfaceID, reinterpret_cast <TAny*&> (surfaceIdInterface)))

		{

		// GCE is off

		TBool orientations[4];

		aDev->OrientationsAvailable(orientations);

		if ((!orientations[0])&&(!orientations[1])&&(!orientations[2])&&(!orientations[3]))

			{

			INFO_PRINTF1(_L("TestOrientRefresh(): All 4 orientations not supported? (error for non-gce)"));

			}

		for (TUint i = 0; i<4; i++)

			{

			if (orientations[i])

				{

				if (aDev->SetOrientation((CFbsDrawDevice::TOrientation)i))

					{

					DoRefreshCycle();	

					}

				else                                                                                                                                                                                                                                   

					{

					TEST(EFalse);

					}

				}

			}

		aDev->SetOrientation((CFbsDrawDevice::TOrientation)0);

		}

	else

		{

		//GCE is on

		TInt orientationAvailable = surfaceIdInterface->DeviceOrientationsAvailable();

		for (TUint32 i = (TUint32)EDeviceOrientationNormal; i <= (TUint32)EDeviceOrientation270CW; i *= 2)

			{

			if (orientationAvailable&i)

				{

				surfaceIdInterface->SetDeviceOrientation((TDeviceOrientation)i);

				DoRefreshCycle();	

				}

			}

		surfaceIdInterface->SetDeviceOrientation(EDeviceOrientationNormal);

		}

	}	

/** 

@SYMTestCaseID GRAPHICS-CTDirectScreenBitmap-TestRefreshingWindowsL-0001

@SYMDEF	PDEF103006

@SYMTestCaseDesc Test orientation and Tests refreshing windows for various display modes

on all type of screens( full screen non-incremental, full screen double buffer, full screen incremental,

sub-region non incremental, sub region double-buffer, sub region incremental). 

@SYMTestPriority Critical

@SYMTestStatus Implemented

@SYMTestActions Create a screen device for all type of screens. Set and test screen orientation 

and finally test refreshing windows.

@SYMTestExpectedResults

The orientation and windows refresh test shall succeed on all screen type for various display mode

**/ 

void CTDirectScreenBitmap::TestRefreshingWindowsL()

{