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

 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::MaskedDrawBitmapScaledL()

 	{

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

 	_LIT(KTestName, "DirectGdiDrawBitmapMS");

 	// for each display mode

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

 		{

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

 		}

 	}

 /**

 Helper function to test bitblt bitmaps for different types of blitting. The bitmap is 

 tiled across the target to avoid any overdraw. Once the target is filled, the process

 is performed for @c KIterationsToTest times.

 @param aBitBltTest the bitblt test to carry out

 @param aBitmapToBlt the bitmap to bitblt

 @param aBitmapMask the bitmap mask

 @param aCrop rectangle to crop bitblt to

 @param aOrientation the orientation of the display

 @param aTestName the name of the test

 @param aGc the graphics context to bitblt to

 */

 void CTBitBltPerfDirectGdi::BitBltBitmapTestL(TBitBltTest aBitBltTest, CFbsBitmap* aBitmapToBlt, CFbsBitmap* aBitmapMask, TRect aCropTo, const TDesC& aTestName, CDirectGdiContext* aGc, TBool aScaled)

 	{

 	aGc->Clear();

 	iDGdiDriver->Finish();

 	const TSize targetSize = GetPixmapSizeInPixels();

 	const TInt scalingFactor = aScaled ? 2 : 1;

 	// Calculate the number of tiles that will fit fully on the pixmap

 	const TSize tileSize = TSize(aCropTo.Width()/scalingFactor, aCropTo.Height()/scalingFactor);

 	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;

 	switch (aBitBltTest)

 	{

 	case EDrawBitmap:

 		{

 		// Do a draw outside the loop so that we aren't measuring the time to load and cache the bitmap.

 		aGc->DrawBitmap(TRect(0, 0, tileSize.iWidth, tileSize.iHeight), *aBitmapToBlt);

 		iProfiler->InitResults();

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

 			{

 			TPoint bitmapPosition = TPoint(0,0);

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

 				{

 				aGc->DrawBitmap(TRect(bitmapPosition.iX, bitmapPosition.iY, bitmapPosition.iX+tileSize.iWidth, bitmapPosition.iY+tileSize.iHeight), *aBitmapToBlt);

 				bitmapPosition.iX += tileSize.iWidth;

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

 					{

 					bitmapPosition.iX = 0;

 					bitmapPosition.iY += tileSize.iHeight;

 					}

 				}

 			iDGdiDriver->Finish();

 			}

 		}

 		break;

 	case EDrawBitmapMasked:

 		{

 		// Do a draw outside the loop so that we aren't measuring the time to load and cache the bitmap.

 		aGc->DrawBitmapMasked(TRect(0, 0, tileSize.iWidth, tileSize.iHeight), *aBitmapToBlt, aCropTo, *aBitmapMask, EFalse);

 		iProfiler->InitResults();

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

 			{

 			TPoint bitmapPosition = TPoint(0,0);

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

 				{

 				aGc->DrawBitmapMasked(TRect(bitmapPosition.iX, bitmapPosition.iY, bitmapPosition.iX+tileSize.iWidth, bitmapPosition.iY+tileSize.iHeight), *aBitmapToBlt, aCropTo, *aBitmapMask, EFalse);

 				bitmapPosition.iX += tileSize.iWidth;

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

 					{

 					bitmapPosition.iX = 0;

 					bitmapPosition.iY += tileSize.iHeight;

 					}

 				}

 			iDGdiDriver->Finish();

 			}

 		}

 		break;

 	case EBitBlt:

 		{

 		// Do a draw outside the loop so that we aren't measuring the time to load and cache the bitmap.

 		aGc->BitBlt(TPoint(0,0), *aBitmapToBlt, aCropTo);

 		iProfiler->InitResults();

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

 			{

 			TPoint bitmapPosition = TPoint(0,0);

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

 				{

 				aGc->BitBlt(bitmapPosition, *aBitmapToBlt, aCropTo);

 				bitmapPosition.iX += tileSize.iWidth;

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

 					{

 					bitmapPosition.iX = 0;

 					bitmapPosition.iY += tileSize.iHeight;

 					}

 				}

 			iDGdiDriver->Finish();

 			}

 		}

 		break;

 	case EBitBltMasked:

 		{

 		// Do a draw outside the loop so that we aren't measuring the time to load and cache the bitmap.

 		aGc->BitBltMasked(TPoint(0,0), *aBitmapToBlt, aCropTo, *aBitmapMask, EFalse);

 		iProfiler->InitResults();

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

 			{

 			TPoint bitmapPosition = TPoint(0,0);

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

 				{

 				aGc->BitBltMasked(bitmapPosition, *aBitmapToBlt, aCropTo, *aBitmapMask, EFalse);

 				bitmapPosition.iX += tileSize.iWidth;

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

 					{

 					bitmapPosition.iX = 0;

 					bitmapPosition.iY += tileSize.iHeight;

 					}

 				}

 			iDGdiDriver->Finish();

 			}

 		}

 		break;

 	}

 	TESTNOERRORL(iDGdiDriver->GetError());

 	iProfiler->MarkResultSetL();

 	WriteTargetOutput(aTestName);

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

 	iProfiler->ResultsAnalysisPixelRate(aTestName, CFbsBitGc::EGraphicsOrientationNormal, aBitmapToBlt->DisplayMode(), targetDisplayMode, KIterationsToTest, numPixelsPerIteration);

 	}

 #endif