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

 @test

 @internalComponent - Internal Symbian test code 

*/

#include "tbitbltperf_directgdi.h"

#include <graphics/directgdidriver.h>

#include <graphics/directgdidrawablesource.h>

#include <bitdrawinterfaceid.h>

#include <bmalphablend.h>

#include <bitdraw.h>

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

_LIT(KBitmap12bit, "z:\\system\\data\\uibench_12bit.mbm");

_LIT(KBitmap16bit, "z:\\system\\data\\uibench_16bit.mbm");

_LIT(KBitmap24bit, "z:\\system\\data\\uibench_24bit.mbm");

_LIT(KBitmap32bit, "z:\\system\\data\\uibench_32bit.mbm");

_LIT(KBitmapTile, "z:\\system\\data\\uibench_tile.mbm");

#endif

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

const TInt KIterationsToTest = 5; 		// Number of iterations to run tests

#endif

const TInt KMaxPixelFormats = 30;		// Number of bitmaps/tiles to create

// For many of these tests, the size of which the destination blit is cropped to. 

const TRect KCropTo = TRect(0,0,200,200);

CTBitBltPerfDirectGdi::~CTBitBltPerfDirectGdi()

	{

	}

CTBitBltPerfDirectGdi::CTBitBltPerfDirectGdi()

	:iBitmapImage(KMaxPixelFormats),

	iBitmapTile(KMaxPixelFormats)

	{

	SetTestStepName(KTBitBltPerfDirectGdi);

	}

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

/**

Override of base class virtual

@return - TVerdict code

*/

TVerdict CTBitBltPerfDirectGdi::doTestStepPreambleL()

	{	

	CTDirectGdiTestBase::doTestStepPreambleL();

	// Create a CFbsBitmap image for each source mode we are testing.

	for (TInt srcMode = 0; srcMode < iSourcePixelFormatArray.Count(); ++srcMode)

		{

		TDisplayMode bitmapDisplayMode = TDisplayModeMapping::MapPixelFormatToDisplayMode(iSourcePixelFormatArray[srcMode]);

		CFbsBitmap* bitmapImage = NULL;

		switch(bitmapDisplayMode)

		{

			case EColor4K:

			case EGray256:

				bitmapImage = LoadBitmapL(KBitmap12bit, 0);

				break;

			case EColor64K:

				bitmapImage = LoadBitmapL(KBitmap16bit, 0);

				break;

			case EColor16M:

				bitmapImage = LoadBitmapL(KBitmap24bit, 0);

				break;

			default:

				bitmapImage = LoadBitmapL(KBitmap32bit, 0);

				break;

		}

		if (bitmapImage && bitmapImage->DisplayMode() != bitmapDisplayMode)

			{

			CleanupStack::PushL(bitmapImage);

			CFbsBitmap* tempBitmap = CopyIntoNewBitmapL(bitmapImage, bitmapDisplayMode);

			CleanupStack::PopAndDestroy(1, bitmapImage); //bitmapImage

			bitmapImage = tempBitmap;

			}

		iBitmapImage.AppendL(bitmapImage);

		}

	// Create 8bit alpha bitmap

	CFbsBitmap* tempBitmap = LoadBitmapL(KBitmap12bit, 0);

	CleanupStack::PushL(tempBitmap);

	iAlpha8bit = CopyIntoNewBitmapL(tempBitmap, EGray256);

	CleanupStack::PopAndDestroy(tempBitmap);	// tempBitmap

	// Create CFbsBitmaps for the tile images of various pixel formats.

	// The first entry in the array is always the default pixelformat loaded from the mbm.

	// Then in the rest of the array are bitmaps converted to the source pixel formats.

	CFbsBitmap* tile = LoadBitmapL(KBitmapTile, 0);	

	iBitmapTile.AppendL(tile);

	for (TInt srcMode = 0; srcMode < iSourcePixelFormatArray.Count(); ++srcMode)

		{

		TDisplayMode bitmapDisplayMode = TDisplayModeMapping::MapPixelFormatToDisplayMode(iSourcePixelFormatArray[srcMode]);

		CFbsBitmap* tileCopy = CopyIntoNewBitmapL(tile, bitmapDisplayMode);

		iBitmapTile.AppendL(tileCopy);

		}

	return TestStepResult();

	}

/**

Override of base class virtual

@return - TVerdict code

*/

TVerdict CTBitBltPerfDirectGdi::doTestStepPostambleL()

	{	

	delete iAlpha8bit;

	iAlpha8bit = NULL;

	for (TInt ii = iBitmapImage.Count() - 1; ii >= 0; --ii)

		{

		delete iBitmapImage[ii];

		}

	iBitmapImage.Close();

	for (TInt ii = iBitmapTile.Count() - 1; ii >= 0; --ii)

		{

		delete iBitmapTile[ii];

		}

	iBitmapTile.Close();

	return CTDirectGdiTestBase::doTestStepPostambleL();

	}

#endif

/**

Override of base class pure virtual

Our implementation only gets called if the base class doTestStepPreambleL() did

not leave. That being the case, the current test result value will be EPass.

@return - TVerdict code

*/

TVerdict CTBitBltPerfDirectGdi::doTestStepL()

	{

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    INFO_PRINTF1(_L("CTBitBltPerfDirectGdi can only be run with RSgImage legacy"));

    return TestStepResult();

#else

	// for each display mode

	for(TInt dispModeIndex = 0; dispModeIndex < iTargetPixelFormatArray.Count(); ++dispModeIndex)

		{

		TDisplayMode targetDisplayMode = TDisplayModeMapping::MapPixelFormatToDisplayMode(iTargetPixelFormatArray[dispModeIndex]);

		if(SetTargetPixelFormatL(targetDisplayMode))

			{

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0150"));

			SimpleBitBltL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0151"));

			SimpleDrawBitmapL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0153"));

			MaskedBitBltAlphaL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0154"));

			MaskedBitBltSameL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0155"));

			MaskedBitBltL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0156"));

			MaskedDrawBitmapL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0136"));

			MaskedDrawBitmapScaledL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0157"));

			BitBltCpuAccessL();

			RecordTestResultL();

			SetTestStepID(_L("GRAPHICS-UI-BENCH-0158"));

			SimpleDrawResourceL();

			RecordTestResultL();

			}

		}

    CloseTMSGraphicsStep();

	return TestStepResult();

#endif	

	}

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0150

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of BitBlt() for the current screen mode and for various bitmap pixel formats.

@SYMTestActions

Draw an entire bitmap using BitBlt(), with no overlapping or clipping. 

Measure the time taken.

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::SimpleBitBltL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::SimpleBitBlt"));

	_LIT(KTestName, "DirectGdiBitBlt");

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		BitBltBitmapTestL(EBitBlt, iBitmapImage[source], NULL, KCropTo, KTestName, iContext);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0151

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measures the performance of DrawBitmap() for the current screen mode, for various bitmap pixel formats.

The bitmap is drawn without scaling.

@SYMTestActions

Create a copy of the bitmap, and scale to the required size, prior to running the test.

For each required source pixel format, use DrawBitmap() to tile a bitmap across the target, avoiding any

clipping or overlap. 

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::SimpleDrawBitmapL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::SimpleDrawBitmap"));

	_LIT(KTestName, "DirectGdiDrawBitmap");

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		// Use a bitmap that needs no scaling.

		CFbsBitmap* bitmapBitBltImage = CopyIntoNewBitmapL(iBitmapImage[source], iBitmapImage[source]->DisplayMode());

		CleanupStack::PushL(bitmapBitBltImage);

		bitmapBitBltImage->Resize(KCropTo.Size());

		BitBltBitmapTestL(EDrawBitmap, bitmapBitBltImage, NULL, bitmapBitBltImage->SizeInPixels(), KTestName, iContext);

		CleanupStack::PopAndDestroy(1, bitmapBitBltImage);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0155

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of BitBltMasked() for the current screen mode, using bitmaps of various 

pixel formats.

@SYMTestActions

Call BitBltMasked() with a bitmap for various pixel formats of bitmap, using the same bitmap 

as the mask bitmap each time. The bitmap is tiled across the target to avoid overlapping or clipping. 

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::MaskedBitBltL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::MaskedBitBlt"));

	_LIT(KTestName, "DirectGdiMBitBlt");

	// for each display mode

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		BitBltBitmapTestL(EBitBltMasked, iBitmapImage[source], iBitmapTile[0], KCropTo, KTestName, iContext);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0154

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of BitBlt(), using the same bitmap as a mask with different screen modes.

@SYMTestActions

Call BitBltMasked() with a bitmap for various pixel formats of bitmap, using the bitmap 

as the mask bitmap each time. The bitmap is tiled across the target to avoid overlapping or clipping.

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/	

void CTBitBltPerfDirectGdi::MaskedBitBltSameL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::MaskedBitBltSame"));

	_LIT(KTestName, "DirectGdiMBitBltS");

	for (TInt tile = 0; tile < iBitmapTile.Count(); ++tile)

		{

		BitBltBitmapTestL(EBitBltMasked, iBitmapTile[tile], iBitmapTile[tile], KCropTo, KTestName, iContext);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0153

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of BitBltMasked(), with an alpha bitmap with different screen modes.

@SYMTestActions

Call BitBltMasked() with a bitmap for various pixel formats of bitmap, using the same alpha bitmap 

as the mask bitmap each time. The bitmap is tiled across the target to avoid overlapping or clipping.

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::MaskedBitBltAlphaL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::MaskedBitBltAlpha"));	

	_LIT(KTestName, "DirectGdiMBitBltA");

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		BitBltBitmapTestL(EBitBltMasked, iBitmapImage[source], iAlpha8bit, KCropTo, KTestName, iContext);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0157

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of BitBlt() for the current screen mode and for various bitmap pixel formats,

with a bitmap that is accessed by the CPU via DataAddresss(), and is therefore never cached by DirectGDI.

@SYMTestActions

Create a copy of a test bitmap.

Call DataAddress() on the bitmap.

Draw an entire bitmap using BitBlt(), with no overlapping or clipping. 

Measure the time taken.

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::BitBltCpuAccessL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::BitBltCpuAccess"));

	_LIT(KTestName, "DirectGdiBitBltCpuAccess");

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		CFbsBitmap* bitmapBitBltImage = CopyIntoNewBitmapL(iBitmapImage[source], iBitmapImage[source]->DisplayMode());

		TESTL(bitmapBitBltImage != NULL);

		CleanupStack::PushL(bitmapBitBltImage);

		bitmapBitBltImage->DataAddress();	// CPU Access so that it is not cached by DirectGDI.

		BitBltBitmapTestL(EBitBlt, bitmapBitBltImage, NULL, KCropTo, KTestName, iContext);

		CleanupStack::PopAndDestroy(1, bitmapBitBltImage);		

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0158

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of DrawResource() for the current screen mode and for various bitmap pixel formats,

with no rotation.

@SYMTestActions

Draw an entire bitmap using DrawResource(), by tiling the image across the target to avoid overlapping and

clipping. Measure the time taken.

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::SimpleDrawResourceL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::SimpleDrawResource"));

	_LIT(KTestName, "DirectGdiDrawResource");

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		TSgImageInfo imageInfo;

		imageInfo.iSizeInPixels = iBitmapImage[source]->SizeInPixels();

		imageInfo.iPixelFormat = TDisplayModeMapping::MapDisplayModeToPixelFormat(iBitmapImage[source]->DisplayMode());

		imageInfo.iUsage = ESgUsageDirectGdiSource;

		// Create an RSgImage from the CFbsBitmap.

		RSgImage sgImage;	

		TInt res = sgImage.Create(imageInfo, iBitmapImage[source]->DataAddress(), iBitmapImage[source]->DataStride());

		TESTNOERRORL(res);

		CleanupClosePushL(sgImage);		

		CDirectGdiDriver* drv = CDirectGdiDriver::Static();

		TEST(drv != NULL);

		RDirectGdiDrawableSource* imageSrc = new RDirectGdiDrawableSource(*drv);

		TEST(imageSrc != NULL);

		res = imageSrc->Create(sgImage);		

		TESTNOERRORL(res);	

		// The test loop.

		// Tile across the target, and avoid clipping and overlapping of tiles.

		const TSize targetSize = GetPixmapSizeInPixels();

		const TSize tileSize = imageInfo.iSizeInPixels;

		const TInt tileColumns = targetSize.iWidth / tileSize.iWidth;

		const TInt tileRows = targetSize.iHeight / tileSize.iHeight;

		const TInt numTiles = tileColumns * tileRows;

		const TInt numPixelsPerIteration = numTiles * tileSize.iWidth * tileSize.iHeight;

		iProfiler->InitResults();

		for(TInt count=KIterationsToTest; count>0; --count)

			{

			TPoint bitmapPosition = TPoint(0,0);

			for (TInt tile = numTiles - 1; tile >= 0; --tile)

				{

				iContext->DrawResource(bitmapPosition, *imageSrc, DirectGdi::EGraphicsRotationNone);

				bitmapPosition.iX += tileSize.iWidth;

				if (bitmapPosition.iX + tileSize.iWidth > targetSize.iWidth)

					{

					bitmapPosition.iX = 0;

					bitmapPosition.iY += tileSize.iHeight;

					}

				}

			iDGdiDriver->Finish();

			}

		iProfiler->MarkResultSetL();

		TESTNOERRORL(iDGdiDriver->GetError());

		WriteTargetOutput(KTestName());		

		const TDisplayMode targetDisplayMode = TDisplayModeMapping::MapPixelFormatToDisplayMode(iImageInfo.iPixelFormat);

		iProfiler->ResultsAnalysisPixelRate(KTestName, CFbsBitGc::EGraphicsOrientationNormal, iBitmapImage[source]->DisplayMode(), targetDisplayMode, KIterationsToTest, numPixelsPerIteration);

		imageSrc->Close();

		delete imageSrc;

		CleanupStack::PopAndDestroy(1, &sgImage);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0156

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc

Measure the performance of DrawBitmapMasked() for the current screen mode, using bitmaps of various 

pixel formats.

@SYMTestActions

Call DrawBitmapMasked() with a bitmap for various pixel formats of bitmap, using the same bitmap 

as the mask bitmap each time. The bitmap is tiled across the target to avoid overlapping or clipping. 

@SYMTestExpectedResults

The performance to be logged as a pixel rate, per bitmap.

*/

void CTBitBltPerfDirectGdi::MaskedDrawBitmapL()

	{

	INFO_PRINTF1(_L("CTBitBltPerfDirectGdi::MaskedDrawBitmap"));

	_LIT(KTestName, "DirectGdiDrawBitmapM");

	// for each display mode

	for (TInt source = 0; source < iBitmapImage.Count(); ++source)

		{

		BitBltBitmapTestL(EDrawBitmapMasked, iBitmapImage[source], iBitmapTile[0], KCropTo, KTestName, iContext, EFalse);

		}

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0136

@SYMPREQ PREQ39

@SYMREQ REQ9236 

@SYMREQ REQ9237

@SYMTestCaseDesc