// Copyright (c) 2008-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 "textendedbitmap.h"

 #include "tdirectgditestbase.h"

 #include <gdi.h>

 #include <s32mem.h>

 #include <e32base.h>

 #include <e32uid.h>

 const TInt KIterationsToTest = 1000;

 const TDisplayMode KDisplayMode = EColor64K;

 // Test the performance of extended bitmaps using the extended bitmap

 // Uid supported by the test example rasterizer

 const TUid KExtendedBitmapUid = {0x10285A78};

 CTExtendedBitmap::CTExtendedBitmap()

 	{

 	SetTestStepName(KTExtendedBitmap);

 	}

 CTExtendedBitmap::~CTExtendedBitmap()

 	{		

 	delete iExtendedBmp;

 	delete [] iExtendedBmpData;

 	delete iNormalBmp;

 	delete iTargetBmp;

 	delete iBitmapDevice;

 	delete iBitGc;		

 	}

 /**

 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 CTExtendedBitmap::doTestStepL()

 	{

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

 	CreateExtendedBitmapL();	

 	RecordTestResultL();

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

 	DeleteExtendedBitmapL();

 	RecordTestResultL();

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

 	GetScanlinePreRenderedExtendedBitmapL();

 	RecordTestResultL();

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

 	GetScanlineNonPreRenderedExtendedBitmapL();

 	RecordTestResultL();

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

 	BitBltExtendedBitmapL();

 	RecordTestResultL();

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

 	BitBltNormalBitmapL();

 	RecordTestResultL();

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

 	DrawBitmapExtendedBitmapL();

 	RecordTestResultL();

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

 	DrawBitmapNormalBitmapL();

 	RecordTestResultL();

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

 	GetPixelL(ETrue);	// extended bitmap

 	RecordTestResultL();

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

 	GetPixelL(EFalse);	// normal bitmap

 	RecordTestResultL();

 	return TestStepResult();

 	}

 /**

 Called before doTestStepL() to allow

 initialization steps common to each test case to take place.

 @return - TVerdict code

 */

 TVerdict CTExtendedBitmap::doTestStepPreambleL()

 	{

 	TVerdict res = CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

 	const TRgb colors[] = {TRgb(0,255,255), TRgb(255,0,255), TRgb(255,255,0)};

 	const TInt numColors = sizeof(colors)/sizeof(colors[0]);

 	const TUint8 stripe = 1; // 1 mean draw horizontal stripes, 0 means draw vertical stripes

 	iExtendedBmpDataSize = sizeof(colors)+sizeof(stripe); // estimate the data size

 	iExtendedBmpData = new(ELeave) TUint8[iExtendedBmpDataSize];

 	RMemWriteStream ws;

 	ws.Open(iExtendedBmpData, iExtendedBmpDataSize);

 	CleanupClosePushL(ws);

 	for (TInt i = 0; i < numColors; i++)

 		{

 		ws << colors[i];

 		}

 	ws << stripe;

 	iExtendedBmpDataSize = ws.Sink()->TellL(MStreamBuf::EWrite).Offset(); // get the actual size written

 	CleanupStack::PopAndDestroy(&ws);

 	iExtendedBmp = new(ELeave) CFbsBitmap;	

 	TInt err = iExtendedBmp->CreateExtendedBitmap(KBitmapSize, KDisplayMode, KExtendedBitmapUid, iExtendedBmpData, iExtendedBmpDataSize);

 	TESTL(err == KErrNone);

 	iNormalBmp = new(ELeave) CFbsBitmap;

 	err = iNormalBmp->Create(KBitmapSize, KDisplayMode);

 	TESTL(err == KErrNone);

 	iTargetBmp = new(ELeave) CFbsBitmap;

 	err = iTargetBmp->Create(KBitmapSize, KDisplayMode);

 	TESTL(err == KErrNone);

 	iBitmapDevice = CFbsBitmapDevice::NewL(iTargetBmp);

 	TESTL(iBitmapDevice != NULL);

 	iBitGc = CFbsBitGc::NewL();

 	iBitGc->Activate(iBitmapDevice);	

 	iRasterizer = CFbsBitmap::Rasterizer();

 	if (iRasterizer == NULL)

 		{

 		INFO_PRINTF1(_L("Error: Extended bitmap tests only work when the example rasterizer is available, make sure \"-DFBSRASTERIZER_DLL=fbsrasterizer_test.dll\" is included in your rombuild command."));

 		User::Leave(KErrGeneral);

 		}

 	return res;

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0159

 @SYMPREQ 

 PREQ2096

 @SYMREQ

 REQ10847

 REQ10849

 @SYMTestCaseDesc

 The test determines how long it takes to create an extended bitmap.

 @SYMTestActions

 Measure the average time taken to create an extended bitmap by creating an

 extended bitmap 1000 times and then calculating the average time.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per extended bitmap creation.

 */

 void CTExtendedBitmap::CreateExtendedBitmapL()

 	{		

 	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

 	TESTL(bmp != NULL);

 	CleanupStack::PushL(bmp);

 	iProfiler->InitResults();	

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

 		{		

 		iProfiler->StartTimer();		

 		TInt err = bmp->CreateExtendedBitmap(KBitmapSize, EColor64K, KExtendedBitmapUid, iExtendedBmpData, iExtendedBmpDataSize);						

 		iProfiler->MarkResultSetL();

 		TESTL(err == KErrNone);

 		// Reset the bitmap so the time taken to reset it the next time CreateExtendedBitmap()

 		// is called is not included in the test

 		bmp->Reset();

 		}	

 	iProfiler->ResultsAnalysis(_L("Create-ExtendedBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	CleanupStack::PopAndDestroy(bmp);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0160

 @SYMPREQ 

 PREQ2096

 @SYMREQ

 REQ10847

 REQ10849

 @SYMTestCaseDesc

 The test determines how long it takes to delete an extended bitmap.

 @SYMTestActions

 Measure the average time taken to delete an extended bitmap by creating and

 deleting an extended bitmap 1000 times and then calculating the average time for the deletion.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per extended bitmap deletion.

 */

 void CTExtendedBitmap::DeleteExtendedBitmapL()

 	{		

 	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

 	TESTL(bmp != NULL);

 	CleanupStack::PushL(bmp);

 	iProfiler->InitResults();	

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

 		{						

 		TInt err = bmp->CreateExtendedBitmap(KBitmapSize, EColor64K, KExtendedBitmapUid, iExtendedBmpData, iExtendedBmpDataSize);

 		TESTL(err == KErrNone);		

 		CleanupStack::Pop(bmp);

 		iProfiler->StartTimer();

 		delete bmp;

 		iProfiler->MarkResultSetL();

 		bmp = new(ELeave) CFbsBitmap;		

 		TESTL(bmp != NULL);

 		CleanupStack::PushL(bmp);

 		}	

 	iProfiler->ResultsAnalysis(_L("Delete-ExtendedBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	CleanupStack::PopAndDestroy(bmp);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0161

 @SYMPREQ 

 PREQ2096

 @SYMREQ 

 REQ10847 

 REQ10860

 @SYMTestCaseDesc

 Measure the average time taken to get a scanline from an extended bitmap directly using

 the example rasterizer where there is one call to BeginBitmap() and EndBitmap() for 

 many GetScanLine() calls. This test only measures the performance of the example rasterizer. 

 It is included here to help isolate performance changes in CTExtendedBitmap::BitBltExtendedBitmapL() 

 and CTExtendedBitmap::DrawBitmapExtendedBitmapL().

 @SYMTestActions

 Measure the average time taken to get a scanline from an extended bitmap directly using

 the example rasterizer by calling CFbsRasterizer::ScanLine() 1000 times for an extended

 bitmap.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per scanline.

 @see GetScanlineNonPreRenderedExtendedBitmapL()

 */

 void CTExtendedBitmap::GetScanlinePreRenderedExtendedBitmapL()

 	{			

 	CFbsRasterizer::TBitmapDesc bitmapDesc;

 	TInt64 bitmapId = iExtendedBmp->SerialNumber();

 	bitmapDesc.iSizeInPixels = KBitmapSize;

 	bitmapDesc.iDispMode = KDisplayMode;

 	bitmapDesc.iDataType = KExtendedBitmapUid;

 	bitmapDesc.iData = iExtendedBmpData;

 	bitmapDesc.iDataSize = iExtendedBmpDataSize;	

 	iRasterizer->BeginBitmap(bitmapId, bitmapDesc, NULL);

 	TInt h;

 	const TUint32* scanline;

 	TPoint point(0,0);

 	iProfiler->InitResults();

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

 		{								

 		for (h = 0; h < KBitmapSize.iHeight; h++)

 			{

 			point.iY = h;

 			scanline = iRasterizer->ScanLine(bitmapId, point, KBitmapSize.iWidth);

 			TESTL(scanline != NULL);

 			}

 		iProfiler->MarkResultSetL();

 		}	

 	iProfiler->ResultsAnalysis(_L("GetScanline-PreRendered-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	iRasterizer->EndBitmap(bitmapId);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0162

 @SYMPREQ PREQ2096

 @SYMREQ 

 REQ10847 

 REQ10860

 @SYMTestCaseDesc

 Measure the average time taken to get a scanline from an extended bitmap directly using

 the example rasterizer where the calls to BeginBitmap() and EndBitmap() are done for each 

 GetScanLine().

 @SYMTestActions

 Call CFbsRasterizer::ScanLine() 1000 times for an extended bitmap. This test case is similar 

 to GetScanlinePreRenderedExtendedBitmapL() but in this case each CFbsRasterizer::ScanLine() 

 call is bracketed by CFbsRasterizer::BeginBitmap() and CFbsRasterizer::EndBitmap() to highlight 

 the performance hit that would be seen by an application calling CFbsBitmap::GetScanLine() 

 when using an extended bitmap rasterizer that does not have a cache. 

 @SYMTestExpectedResults

 Test should pass and display total test time and time per scanline when bracketed by 

 CFbsRasterizer::BeginBitmap() and CFbsRasterizer::EndBitmap().

 @see GetScanlinePreRenderedExtendedBitmapL()

 */

 void CTExtendedBitmap::GetScanlineNonPreRenderedExtendedBitmapL()

 	{				

 	CFbsRasterizer::TBitmapDesc bitmapDesc;

 	TInt64 bitmapId = iExtendedBmp->SerialNumber();

 	bitmapDesc.iSizeInPixels = KBitmapSize;

 	bitmapDesc.iDispMode = KDisplayMode;

 	bitmapDesc.iDataType = KExtendedBitmapUid;

 	bitmapDesc.iData = iExtendedBmpData;

 	bitmapDesc.iDataSize = iExtendedBmpDataSize;		

 	TInt h;

 	const TUint32* scanline;

 	TPoint point(0,0);

 	iProfiler->InitResults();

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

 		{

 		for (h = 0; h < KBitmapSize.iHeight; h++)

 			{

 			// Only the first call to BeginBitmap() should cause rasterization of the bitmap,

 			// since the test rasterizer has a cache of recently used bitmaps.

 			iRasterizer->BeginBitmap(bitmapId, bitmapDesc, NULL);

 			point.iY = h;

 			scanline = iRasterizer->ScanLine(bitmapId, point, KBitmapSize.iWidth);

 			TESTL(scanline != NULL);

 			iRasterizer->EndBitmap(bitmapId);

 			}

 		iProfiler->MarkResultSetL();

 		}

 	iProfiler->ResultsAnalysis(_L("GetScanline-NonPreRendered-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0163

 @SYMPREQ 

 PREQ2096

 @SYMREQ

 REQ10857

 REQ10859

 @SYMTestCaseDesc

 The test determines how long it takes to BitBlt() an extended bitmap to an offscreen bitmap.

 This test is paired with BitBltNormalBitmapL().

 @SYMTestActions

 Measure the time taken to BitBlt() an extended bitmap to an offscreen buffer 1000 times

 and calculate the average time taken. 

 @SYMTestExpectedResults

 Test should pass and display total test time and time per image BitBlt().

 @see BitBltNormalBitmapL()

 */

 void CTExtendedBitmap::BitBltExtendedBitmapL()

 	{			

 	const TPoint pt(0,0);

 	iProfiler->InitResults();	

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

 		{

 		iBitGc->BitBlt(pt, iExtendedBmp);

 		iProfiler->MarkResultSetL();

 		}	

 	iProfiler->ResultsAnalysis(_L("BitBlt-ExtendedBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0164

 @SYMPREQ PREQ2096

 @SYMTestCaseDesc

 The test determines how long it takes to BitBlt() a standard bitmap that is the same size

 as the extended bitmap used in the previous test case BitBltExtendedBitmapL().

 This test is paired with BitBltExtendedBitmapL().

 @SYMTestActions

 Measure the time taken to BitBlt() a normal bitmap to an offscreen buffer 1000 times

 and calculate the average time taken.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per image BitBlt().

 @see BitBltExtendedBitmapL()

 */

 void CTExtendedBitmap::BitBltNormalBitmapL()

 	{		

 	const TPoint pt(0,0);

 	iProfiler->InitResults();	

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

 		{

 		iBitGc->BitBlt(pt, iNormalBmp);

 		iProfiler->MarkResultSetL();

 		}	

 	iProfiler->ResultsAnalysis(_L("BitBlt-NormalBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0165

 @SYMPREQ 

 PREQ2096

 @SYMREQ

 REQ10857

 REQ10859

 @SYMTestCaseDesc

 The test determines how long it takes to draw an extended bitmap to an offscreen bitmap

 using DrawBitmap(). This test is paired with DrawBitmapNormalBitmapL().

 @SYMTestActions

 Measure the time taken to DrawBitmap() an extended bitmap to an offscreen buffer 1000 times

 and calculate the average time taken. This test is paired with DrawBitmapNormalBitmapL().

 @SYMTestExpectedResults

 Test should pass and display total test time and time per image DrawBitmap().

 @see DrawBitmapNormalBitmapL()

 */

 void CTExtendedBitmap::DrawBitmapExtendedBitmapL()

 	{			

 	const TPoint pt(0,0);

 	const TRect rect(pt, KBitmapSize);

 	iProfiler->InitResults();	

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

 		{

 		iBitGc->DrawBitmap(rect, iExtendedBmp, rect);

 		iProfiler->MarkResultSetL();

 		}	

 	iProfiler->ResultsAnalysis(_L("DrawBitmap-ExtendedBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0166

 @SYMPREQ PREQ2096

 @SYMTestCaseDesc

 The test determines how long it takes to draw a standard bitmap that is the same size

 as the extended bitmap used in the previous test case (DrawBitmapExtendedBitmapL()) 

 using DrawBitmap(). This test is paired with DrawBitmapExtendedBitmapL().

 This test is paired with DrawBitmapExtendedBitmapL().

 @SYMTestActions

 Measure the time taken to DrawBitmap() a normal bitmap to an offscreen buffer 1000 times

 and calculate the average time taken.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per image DrawBitmap().

 @see DrawBitmapExtendedBitmapL()

 */

 void CTExtendedBitmap::DrawBitmapNormalBitmapL()

 	{		

 	const TPoint pt(0,0);

 	const TRect rect(pt, KBitmapSize);

 	iProfiler->InitResults();	

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

 		{

 		iBitGc->DrawBitmap(rect, iNormalBmp, rect);

 		iProfiler->MarkResultSetL();

 		}	

 	iProfiler->ResultsAnalysis(_L("DrawBitmap-NormalBitmap-64K"), 0, EColor64K, EColor64K, KIterationsToTest);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0173

 @SYMCR

 CR1804

 @SYMREQ 

 REQ10858

 @SYMTestCaseDesc

 Measure the average time taken to get 128 pixels from a normal or extended bitmap.

 @SYMTestActions

 Measure the average time taken to get 128 pixels from a normal or extended bitmap 

 by calling CFbsBitmap::GetPixel() 1000 times on the bitmap.

 @SYMTestExpectedResults

 Test should pass and display total test time and time per 128 pixels.

 */

 void CTExtendedBitmap::GetPixelL(TBool aIsExtendedBmp)

 	{

 	CFbsBitmap* bmp = NULL;

 	_LIT(KTestName, "GetPixel-%S-64K");

 	TBuf<30> buf;

 	if (aIsExtendedBmp)

 		{

 		_LIT(KExtBmpName, "ExtendedBitmap");

 		buf.Format(KTestName, &KExtBmpName);

 		bmp= iExtendedBmp;

 		}

 	else

 		{

 		_LIT(KNormalBmpName, "NormalBitmap");

 		buf.Format(KTestName, &KNormalBmpName);

 		bmp = iNormalBmp;

 		}

 	TInt y;

 	TPoint point(0,0);

 	TRgb color;

 	iProfiler->InitResults();

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

 		{								

 		for (y = 0; y < KBitmapSize.iHeight; ++y)

 			{

 			point.iY = y;

 			bmp->GetPixel(color, point);

 			}

 		iProfiler->MarkResultSetL();

 		}

 	iProfiler->ResultsAnalysis(buf, 0, KDisplayMode, KDisplayMode, KIterationsToTest);

 	}