diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicstest/uibench/src/tbitbltperf_directgdi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/graphicstest/uibench/src/tbitbltperf_directgdi.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,680 @@ +// 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 +#include +#include +#include +#include + +#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