// Copyright (c) 2000-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 <graphicsaccelerator.h>

#include "TAccelerator.h"

#include <graphics/fbsdefs.h>

class TAcceleratedBitmapSpecTest : public TAcceleratedBitmapSpec

	{

// Provides public access to TAcceleratedBitmapSpec

public:

	inline TAcceleratedBitmapSpecTest() : TAcceleratedBitmapSpec() {}

	inline TAcceleratedBitmapSpecTest(CFbsBitmap* aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

	inline TAcceleratedBitmapSpecTest(RHardwareBitmap aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

	// 

	inline TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const { return TAcceleratedBitmapSpec::GetInfo(aInfo); }

	inline void Lock(TBitmapLockCount& aCount) { TAcceleratedBitmapSpec::Lock(aCount); }

	inline void Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo) { TAcceleratedBitmapSpec::Lock(aCount,aInfo); }

	inline void	Unlock(TBitmapLockCount& aCount)  { TAcceleratedBitmapSpec::Unlock(aCount); }

	};

const TInt KNumDisplayModes = 13;

static struct 

	{

	TDisplayMode iMode;

	TBool iEnabled;

	TInt iPixelShift;

	} TestDisplayModes[KNumDisplayModes] =	

   {  

		{EGray2,EFalse,0},

		{EGray4,EFalse,1},

		{EGray16,EFalse,2},

		{EGray256,EFalse,3},

		{EColor16,EFalse,2},

		{EColor256,EFalse,3},

		{EColor64K,EFalse,4},

		{EColor16M,EFalse,5},

		{ERgb,EFalse,5},

		{EColor4K,EFalse,4},

		{EColor16MU,EFalse,5},

		{EColor16MA,EFalse,5},

		{EColor16MAP,EFalse,5}

	};

_LIT(KRam32BitmapOnZ, "z:\\system\\data\\32RAM.mbm");

_LIT(KRamC24BitmapOnZ, "z:\\system\\data\\24RAMC.mbm");

_LIT(KRomC24Bitmap, "z:\\system\\data\\24ROMC.mbm");

//

// CTestBitmap

//

TInt CTestBitmap::ConstructL(TDisplayMode aDisplayMode,TSize aSize,TBool aHWBitmap)

	{

	Reset();

	iBitmap = new CFbsBitmap;

	if(iBitmap==NULL)

		User::Panic(_L("Bitmap not created"),KErrGeneral);

	TInt ret;

	if(aHWBitmap)

		ret = iBitmap->CreateHardwareBitmap(aSize,aDisplayMode,TUid());

	else

		ret = iBitmap->Create(aSize,aDisplayMode);

	if (ret == KErrNotSupported)

		{

		Reset();

		return ret;

		}

	User::LeaveIfError(ret);

	TRAPD(err,iDevice = CFbsBitmapDevice::NewL(iBitmap));

	if(err)

		User::Panic(_L("BitmapDevice not created"),err);

	err = iDevice->CreateContext(iGc);

	if(err)

		User::Panic(_L("BitmapDevice not created"),err);

	return KErrNone;

	}

void CTestBitmap::Reset()

	{

	delete iGc;

	iGc = 0;

	delete iDevice;

	iDevice = 0;

	delete iBitmap;

	iBitmap = 0;

	}

CTestBitmap::~CTestBitmap()

	{

	Reset();

	}

TBool CTestBitmap::Compare(CTestBitmap* aBitmap2)

	{	

	TInt width=iBitmap->SizeInPixels().iWidth;

	TInt pitch = iBitmap->DataStride();

	TInt height=iBitmap->SizeInPixels().iHeight;

	for(TInt yLoop=0;yLoop<height;yLoop++)

		{

		TInt offset=yLoop*pitch;

		TUint8* data1 = ((TUint8*)iBitmap->DataAddress())+offset;

		TUint8* data2 = ((TUint8*)aBitmap2->iBitmap->DataAddress())+offset;

		TUint8* dataLimit = data1 + CFbsBitmap::ScanLineLength(width, iBitmap->DisplayMode());

		while(data1<dataLimit)

			{

			if(*(data1++)!=*(data2++))

				{

				iBitmap->Save(_L("C:\\Compare1.mbm"));

				aBitmap2->iBitmap->Save(_L("C:\\Compare2.mbm"));

				return EFalse;

				}

			}

		}

	return(ETrue);

	}

//

// CTAccelerator

//

CTAccelerator::CTAccelerator(CTestStep* aStep):

	CTGraphicsBase(aStep), 

	iRandomSeed(1),

	iGraphicsAccelerator1(0),

	iGraphicsAccelerator2(0),

	iHwScreenDevice(0),

	iScreenGc(0)

	{

	TInt i;

	for(i=0;i<9;i++) 

		iFixedRegion.AddRect(TRect(i*16,i*8,i*16+32,i*8+32));

	for(i=0;i<9;i++) 

		iFixedRegion.AddRect(TRect(183-(i*16),i*8,199-(i*16),i*8+32));

	iDefaultRegion.AddRect(TRect(0,0,199,99));

	INFO_PRINTF1(_L("Graphics Accelerator Testing"));

	}

void CTAccelerator::Cleanup()

	{

	delete iGraphicsAccelerator1;

	iGraphicsAccelerator1 = 0;

	delete iGraphicsAccelerator2;

	iGraphicsAccelerator2 = 0;

	if(iHwScreenDevice)

		{

		delete iHwScreenDevice;

		iHwScreenDevice = 0;

		}

	if(iScreenGc)

		{

		delete iScreenGc;

		iScreenGc = 0;

		}

	iBitmap1.Reset();

	iBitmap2.Reset();

	iBitmap3.Reset();

	iBitmap4.Reset();

	iBitmap5.Reset();

	iBitmap6.Reset();

	iBitmap7.Reset();

	iTileBitmap.Reset();

	iAlphaBitmap.Reset();

	}

TInt CTAccelerator::Random(TInt aMax)	// aMax <= 0xFFFF

	{

	iRandomSeed *= 69069;

	TUint r = ((iRandomSeed>>16)*aMax)>>16;

	return r;

	}

void CTAccelerator::RunTestCaseL(TInt aCurTestCase)

	{

	TInt i;

	((CTAcceleratorStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with software bitmaps."));

		for(i=0; i<KNumDisplayModes; i++)

			if (TestDisplayModes[i].iEnabled)

				{

				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,EFalse);

				}

		break;

	case 2:

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

		INFO_PRINTF1(_L("Testing graphics operations with software bitmaps."));

		for(i=0; i<KNumDisplayModes; i++)

			if (TestDisplayModes[i].iEnabled)

				{

				TestGraphicsOperations(TestDisplayModes[i].iMode,EFalse);

				}

		break;

	case 3:

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with hardware bitmaps."));

		for(i=0; i<KNumDisplayModes; i++)

			if (TestDisplayModes[i].iEnabled)

				{

				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,ETrue);

				}

		break;

	case 4:

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmaps."));

		for(i=0; i<KNumDisplayModes; i++)

			if (TestDisplayModes[i].iEnabled)

				{

				TestGraphicsOperations(TestDisplayModes[i].iMode,ETrue);

				}

		break;

	case 5:

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0023"));

		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmap as screen."));

		for(i=0; i<KNumDisplayModes; i++)

			if (TestDisplayModes[i].iEnabled)	

				{

				TestGraphicsOperationsWithScreenL(TestDisplayModes[i].iMode,ETrue);

				}

		break;

	case 6:

/**

 @SYMTestCaseID          GRAPHICS-BITGDI-0112

*/

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));

		INFO_PRINTF1(_L("Testing passing of compressed info to accelerator"));

		TestAcceleratorInfo();

		break;

	case 7:

/**

 @SYMTestCaseID          GRAPHICS-BITGDI-0113

*/

		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));

		INFO_PRINTF1(_L("Testing GetInfo() with an extended bitmap"));

		TestAcceleratorInfoForExtendedBitmapL();

		break;

	case 8:

		((CTAcceleratorStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTAcceleratorStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

		}

	((CTAcceleratorStep*)iStep)->RecordTestResultL();

 	}

const TSize TestBitmapSize = TSize(199,99);

TSize TestScreenSize;

const TSize TestBitmapSize1 = TSize(165,53);

/**

 @SYMTestCaseID          GRAPHICS-BITGDI-0021

 @SYMCreationDate        21/11/2008

 @SYMAuthor              douglashetherington

 @SYMTestStatus          3. Released

 @SYMTestPriority        High

 @SYMTestCaseDesc        Checks that TAcceleratedBitmapSpec does not change the underlaying bitmaps data

 @SYMTestExpectedResults The bitmap data is not changed

 @SYMTestActions         Creates a bitmap, puts it into a TAcceleratedBitmapSpec then checks the pixel data is unchanged

 @SYMDEF                 

*/

void CTAccelerator::TestAcceleratedBitmapSpecL(TDisplayMode aDisplayMode,TBool aHWBitmap)

	{

	TInt ret=0; 

	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

	// Create bitmap

	ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);

	INFO_PRINTF2(_L(" TestAcceleratedBitmapSpecL ret=%d"),ret);

	if(ret!=KErrNone)

		{

		WARN_PRINTF1(_L("  Not Supported."));

		return;

		}

	TAcceleratedBitmapSpecTest bitmapSpec(iBitmap1.iBitmap);

	TAcceleratedBitmapInfo info;

	// Check correct size	

	bitmapSpec.Lock(iBitmapLockCount);

	User::LeaveIfError(bitmapSpec.GetInfo(info));

	TEST(info.iSize==iBitmap1.iBitmap->SizeInPixels());

	INFO_PRINTF3(_L("Test Display Modes , Expected iPixelShift : %d, Actual iPixelShift: %d"),TestDisplayModes[aDisplayMode-1].iPixelShift,info.iPixelShift);

	TEST(info.iPixelShift == TestDisplayModes[aDisplayMode-1].iPixelShift);

	bitmapSpec.Unlock(iBitmapLockCount);

	TInt scanLineLength = iBitmap1.iBitmap->ScanLineLength(TestBitmapSize.iWidth,aDisplayMode);

	HBufC8* scanLineBuffer = HBufC8::NewMaxLC(scanLineLength);

	TPtr8 scanLine(scanLineBuffer->Des());

	TInt y,x;

	// fill bitmap with test data

	for(y=info.iSize.iHeight-1; y>=0; y--)

		{

		TUint8* ptr = &(scanLine)[0];

		TUint8* ptrLimit = ptr+scanLineLength;

		x = 42;

		while(ptr<ptrLimit)

			*(ptr++) = (TUint8)(y^(x++));

		iBitmap1.iBitmap->SetScanLine(scanLine,y);

		}

	// use TAcceleratedBitmapSpec to check contents

	bitmapSpec.Lock(iBitmapLockCount,info);

	for(y=0; y<info.iSize.iHeight; y++)

		{

		TUint8* ptr = info.iAddress+y*info.iLinePitch;

		TUint8* ptrLimit = ptr+scanLineLength;

		x = 42;

		while(ptr<ptrLimit)

			if(*(ptr++) != (TUint8)(y^(x++)))

				{

				ERR_PRINTF2(_L("!!!  Failed at compare A, line %d"),y);

				User::Leave(KErrGeneral);

				}

		}

	bitmapSpec.Unlock(iBitmapLockCount);

	// fill bitmap with test data (inverse of previous)

	for(y=info.iSize.iHeight-1; y>=0; y--)

		{

		TUint8* ptr = &(scanLine)[0];

		TUint8* ptrLimit = ptr+scanLineLength;

		x = 42;

		while(ptr<ptrLimit)

			*(ptr++) = (TUint8)~(y^(x++));

		iBitmap1.iBitmap->SetScanLine(scanLine,y);

		}

	// use TAcceleratedBitmapSpec to check contents

	bitmapSpec.Lock(iBitmapLockCount,info);

	for(y=0; y<info.iSize.iHeight; y++)

		{

		TUint8* ptr = info.iAddress+y*info.iLinePitch;

		TUint8* ptrLimit = ptr+scanLineLength;

		x = 42;

		while(ptr<ptrLimit)

			if(*(ptr++) != (TUint8)~(y^(x++)))

				{

				ERR_PRINTF2(_L("!!!  Failed at compare B, line %d"),y);

				User::Leave(KErrGeneral);

				}

		}

	bitmapSpec.Unlock(iBitmapLockCount);

	// End

	CleanupStack::PopAndDestroy();	//scanLineBuffer

	Cleanup();

	INFO_PRINTF1(_L("  OK"));

	}

class CTestFbsDevice : public CFbsDevice

	{

public:

	inline CGraphicsAccelerator* StealGraphicsAccelerator()

		{ CGraphicsAccelerator* acc = iGraphicsAccelerator; iGraphicsAccelerator = 0; return acc; };

	};

/**

 @SYMTestCaseID          GRAPHICS-BITGDI-0022

 @SYMCreationDate        21/11/2008

 @SYMAuthor              douglashetherington

 @SYMTestStatus          3. Released

 @SYMTestPriority        High

 @SYMTestCaseDesc        Tests various basic graphic operations

 @SYMTestExpectedResults Tests should perform graphics operations succesfully.

 @SYMTestActions         Creates a number of bitmaps then uses them in various graphic operations

 @SYMDEF                 

*/

void CTAccelerator::TestGraphicsOperations(TDisplayMode aDisplayMode,TBool aHWBitmap)

	{

	TInt ret=0;

	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

	TRAPD(errCode, ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	if((ret!=KErrNone) || (errCode !=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))

		{

		WARN_PRINTF1(_L("  Not Supported."));

		return;

		}

	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();

	delete iGraphicsAccelerator1;

	iGraphicsAccelerator1 = 0;

	if(!iSubRegion.IsEmpty())

		iSubRegion.Clear();

	iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());

	iSubRegion.SubRegion(iFixedRegion);

	iSubRegionPtr = &iSubRegion;

	TRAP(errCode, ret = iBitmap2.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	TRAP(errCode, ret = iBitmap3.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();

	TRAP(errCode, ret = iBitmap4.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	TRAP(errCode, ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	TRAP(errCode, ret = iBitmap6.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	TRAP(errCode, ret = iBitmap7.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	TRAP(errCode, ret = iBitmap8.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	//BrushBitmap

    CFbsBitmap* iTile = new CFbsBitmap();

	TEST(iTile!=NULL);

	ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);

    TEST(ret==KErrNone);

	TSize tileSize = iTile->SizeInPixels();

	TDisplayMode tileDisplayMode = iTile->DisplayMode();

	TRAP(errCode, ret = iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret== KErrNotSupported)

		{

		WARN_PRINTF1(_L("  Not Supported."));

		delete iTile;

		iTile = NULL;

		return;

		}

	iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);

	delete iTile;

	iTile = NULL;

	//Alpha bitmap

	TRAP(errCode, ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap));

	TEST(errCode== KErrNone);

	if(ret!=KErrNone)

		User::Panic(_L("Bitmap not created"),ret);

	iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();

	INFO_PRINTF1(_L("FilledRect"));

	TestFilledRect();

	resetColorBitmaps();

	INFO_PRINTF1(_L("FilledRectWithPattern "));

	TestFilledRectWithPattern();

	resetColorBitmaps();

	INFO_PRINTF1(_L("InvertRect")); 

	TestInvertRect();

	resetColorBitmaps();

	INFO_PRINTF1(_L("FadeRect "));

	TestFadeRect();

	resetColorBitmaps();

	INFO_PRINTF1(_L("BitBlt "));

	TestBitBlt();

	resetColorBitmaps();

	INFO_PRINTF1(_L("BitBltMasked "));

	TestBitBltMasked();

	resetColorBitmaps();

	INFO_PRINTF1(_L("BitBltAlphaBitmap"));

	TestBitBltAlphaBitmap();

	resetColorBitmaps();

	INFO_PRINTF1(_L("AlphaBlendTwoBitmaps "));

	TestAlphaBlendTwoBitmaps();