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

#include "fbsmessage.h"

#include <test/tefunit.h>

#include <hal.h>

// The following line must be disabled for testing with the background compression code

// When enabled foreground bitmap compression will take place.

// #define FORCE_FOREGROUND_COMPRESSION

// Number of times to repeat the tests

const TInt KRepeatTestCount = 100;

// The source bitmaps, only use the bitmaps from UIBENCH

_LIT( KmbmFilesInRom, "z:\\system\\data\\uibench_*.mbm" );

// The 16bit rle compressed source bitmap on Z drive

_LIT( Kmbm16bppRleComprFileInRom, "z:\\system\\data\\rlecompr_16bpp.mbm" );

// The 32bit alpha rle compressed source bitmap on Z drive

_LIT( Kmbm32abppRleComprFileInRom, "z:\\system\\data\\rlecompr_32abpp.mbm" );

// The 16bit rle compressed source bitmap on C drive

_LIT( Kmbm16bppRleComprFileOnC, "c:\\compressedBitmaps\\rlecompr_16bpp.mbm" );

#ifdef _DEBUG

// The 32bit alpha  rle compressed source bitmap on C drive

_LIT( Kmbm32abppRleComprFileOnC, "c:\\compressedBitmaps\\rlecompr_32abpp.mbm" );

#endif

// The resouce mbm file

_LIT( KmbmResouceFile, "z:\\resource\\32bit20col.mbm" );

// The directory to copy the bitmaps to

_LIT( KDirectoryFilesOnC , "c:\\bitmapOptimisation\\" );

// The directory to copy the compressed bitmaps to

_LIT( KDirectoryComprBmpFilesOnC , "c:\\compressedBitmaps\\" );

CTOptimisedBmp::CTOptimisedBmp()

	{

	SetTestStepName(KTOptimisedBmpStep);

	}

CTOptimisedBmp::~CTOptimisedBmp()

	{

	// clear test files

	if (iFileMan)

		{

		TBuf <255> filePath;

		_LIT(KFormat, "%S*.mbm");

		filePath.Format(KFormat, &KDirectoryFilesOnC);

		iFileMan->Delete(filePath);

		//remove filepath for compressed bitmap

		filePath.Format(KFormat, &KDirectoryComprBmpFilesOnC);		

		iFileMan->Delete(filePath);

		delete iFileMan;

		}	

	iFs.RmDir(KDirectoryFilesOnC);

	//remove directory for compressed bitmap

	iFs.RmDir(KDirectoryComprBmpFilesOnC);	

	iFs.Close();

	}

/**

Override of base class virtual

@return - TVerdict code

*/

TVerdict CTOptimisedBmp::doTestStepPreambleL()

	{

	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

	// copy all of the files in ROM z: to c:

	TInt err =  iFs.Connect();

	User::LeaveIfError(err);		

	iFs.ShareProtected();

	err =  iFs.MkDir(KDirectoryFilesOnC);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	//create directory to store rle-compressed bitmap	

	err =  iFs.MkDir(KDirectoryComprBmpFilesOnC);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	iFileMan = CFileMan::NewL( iFs );

	err =  iFileMan->Copy( KmbmFilesInRom, KDirectoryFilesOnC );

	TESTL(err == KErrNone);

	//Copying compressed mbm files to C drive

	err =  iFileMan->Copy( Kmbm16bppRleComprFileInRom, KDirectoryComprBmpFilesOnC );

	TESTL(err == KErrNone);

	err =  iFileMan->Copy( Kmbm32abppRleComprFileInRom, KDirectoryComprBmpFilesOnC );

	TESTL(err == KErrNone);

	return TestStepResult();

	}

/**

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

	{

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0021

@SYMTestCaseDesc

The test determines how long it takes to compress bitmaps, and how long it takes to bitblt the original and the compressed bitmaps.

@SYMTestActions

1. Over a number of iterations, measure time taken to compress a bitmap loaded from mbm file.  Each iteration the mbm is loaded from scratch.

2. Over a number of iterations, measure time taken to blit an uncompressed bitmap loaded from mbm file. This mbm file is the same as in step 1.

3. Over a number of iterations, measure time taken to blit the compressed bitmap loaded from step 1.

4. Check that the blits of the uncompressed bitmap and the compressed bitmap are the same.

Each of these steps is performed with various screen display modes and various display modes of the bitmap.

@SYMTestExpectedResults

Test should pass and display total and per bitmap compression, bitblt for uncompressed and compressed time.

*/

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

	CompressedBitmapTestL();	

	RecordTestResultL();

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0058

@SYMTestCaseDesc

The test determines how long it takes to load 16bpp compressed bitmaps.

@SYMDEF INC095318

@SYMTestPriority High

@SYMTestActions

Compare the results over time.

@SYMTestExpectedResults

Test should pass and logs the time taken to load compressed bitmap .

*/

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

	TestDecompressBitmapL(Kmbm16bppRleComprFileOnC, _L("Load-Compressed-Bitmap-16bit"));

	RecordTestResultL();

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0059

@SYMTestCaseDesc

The test determines how long it takes to load 32 bpp compressed alpha bitmaps.

@SYMDEF DEF095361

@SYMTestPriority Low

@SYMTestActions

Compare the results over time.

@SYMTestExpectedResults

Test should pass and logs the time taken to load compressed bitmap .

*/

#ifdef _DEBUG

	//It uses Heap Allocation failure macro 

	//which is supported only for debug mode	

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

	TestDecompressBitmapAltL(Kmbm32abppRleComprFileOnC, _L("Load-Compressed-Bitmap-32abit"));

	RecordTestResultL();

#endif

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

	GetScanLineTestL();

	RecordTestResultL();

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0085

@SYMTestCaseDesc

The test determines how long it takes to load a bitmap from the resource folder.

@SYMDEF DEF105049

@SYMTestPriority Medium

@SYMTestActions

Compare the results over time.

@SYMTestExpectedResults

Test should pass and display load time / bitmap.

*/

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

	ResourceBitmapLoadL(KmbmResouceFile, 0, ETrue, _L("Resouce Bitmap Load"));

	RecordTestResultL();

	return TestStepResult();

	}

void CTOptimisedBmp::CompressedBitmapTestL()

	{

	_LIT(KTestName1, "CompressBitmap");

	_LIT(KTestName2, "BlitUncompressedBitmap");

	_LIT(KTestName3, "BlitCompressedBitmap");

	// strings for writing target output

	_LIT(KTargetString, "_TGT=");

	_LIT(KSourceString, "_SRC=");

	// for each of the files in the directory

	// load, compress & compare size before and after

	TBufC<KMaxFileName> fileName(KDirectoryFilesOnC);

	TInt dirLen = KDirectoryFilesOnC().Length();

	CDir* fileList;

	TInt err = iFs.GetDir(KDirectoryFilesOnC, KEntryAttNormal, ESortBySize, fileList);

	User::LeaveIfError(err);

	CleanupStack::PushL(fileList);

#ifdef FORCE_FOREGROUND_COMPRESSION

	_LIT(KForceForegroundCompression, "Force Foreground Compression");

	INFO_PRINTF2(KForceForegroundCompression);

	RFbsSession* fbs = RFbsSession::GetSession();

	if (!fbs)

		{

		ERR_PRINTF1("Error: fbs cannot be NULL");

		SetTestStepError();

		}		

	fbs->SendCommand(EFbsCompress, 1); // force to compress the bitmaps in the foreground

#endif // FORCE_FOREGROUND_COMPRESSION

	CFbsBitmap* fbsBitmap = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(fbsBitmap);

	CFbsBitmap* fbsCompressed = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(fbsCompressed);

	for (TInt dispModeIndex = 0; dispModeIndex < KNumValidDisplayModes; dispModeIndex++)

		{

		SetScreenModeL(KValidDisplayModes[dispModeIndex], ETrue);

		iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);

		TSize scrSize = iScreenDevice->SizeInPixels();

		TPoint left(0 ,0);

		TPoint right(scrSize.iWidth / 2, 0);

		for (TInt ii = 0; ii < fileList->Count(); ++ii)

			{

			// Load uncompressed bitmap

			const TEntry entry((*fileList)[ii]);

			TPtr fnamePtr = fileName.Des();

			fnamePtr.SetLength(dirLen);

			fnamePtr.Append(entry.iName);

			err = fbsBitmap->Load(fnamePtr, 0, EFalse);

			if (err != KErrNone)

				{

				INFO_PRINTF3(_L("Error %d loading bitmap (%S)"), err, &fnamePtr);

				fbsBitmap->Reset();

				continue;

				}

			TDisplayMode bitmapDispMode = fbsBitmap->DisplayMode();  //same display mode used for fbsCompressed

			TDisplayMode screenDispMode = iScreenDevice->BitmapDevice().DisplayMode();

			TInt rpt;

			// Test speed of compressing an image

			iProfiler->InitResults();

			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

				{

				// Load bitmap to be compressed

				err = fbsCompressed->Load(fnamePtr, 0, EFalse);

				if (err != KErrNone)

					{

					INFO_PRINTF4(_L("Error %d loading the bitmap (%S), rpt = %d"), err, &fnamePtr, rpt);

					fbsCompressed->Reset();

					break;

					}

				iProfiler->StartTimer();

				fbsCompressed->Compress();

				iProfiler->MarkResultSetL();

				// on last iteration, don't reset fbsCompressed

				if (rpt < KRepeatTestCount-1)

					{

					fbsCompressed->Reset();

					}

				}

			iProfiler->ResultsAnalysis(KTestName1, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount);

			// Clip rect size to half-screen width and screen height

			TSize sizeInPixels = fbsBitmap->SizeInPixels();

			if (sizeInPixels.iWidth > scrSize.iWidth / 2)

				sizeInPixels.iWidth = scrSize.iWidth / 2;

			if (sizeInPixels.iHeight > scrSize.iHeight)

				sizeInPixels.iHeight = scrSize.iHeight;

			TRect blitRect(TPoint(0,0), sizeInPixels);

			TInt numPixels = sizeInPixels.iHeight * sizeInPixels.iWidth;

			// Test pixel rate of blitting uncompressed bitmap

			iProfiler->InitResults();

			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

				{

				iGc->BitBlt(left, fbsBitmap, blitRect);

				}

			iProfiler->MarkResultSetL();

			iProfiler->ResultsAnalysisPixelRate(KTestName2, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount, numPixels);

			// Test pixel rate of blitting compressed bitmap

			iProfiler->InitResults();

			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

				{

				iGc->BitBlt(right, fbsCompressed, blitRect);

				}

			iProfiler->MarkResultSetL();

			iProfiler->ResultsAnalysisPixelRate(KTestName3, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount, numPixels);

			// Sanity check that uncompressed and compressed bitmaps display the same

			CBitmapDevice& bmpDevice = iScreenDevice->BitmapDevice();

			if (iScreenDevice->isScreenDevice())

				{

				TEST(((CFbsScreenDevice&)bmpDevice).RectCompare(TRect(left, sizeInPixels), (CFbsScreenDevice&)bmpDevice, TRect(right, sizeInPixels)));

				}

			else

				{

				TEST(((CFbsBitmapDevice&)bmpDevice).RectCompare(TRect(left, sizeInPixels), (CFbsBitmapDevice&)bmpDevice, TRect(right, sizeInPixels)));

				}

			fbsBitmap->Reset();

			fbsCompressed->Reset();

			// Save offscreen bitmap to mbm file

			TBuf<KMaxFileName> testFileName;

			testFileName.Append(KTestName1);

			testFileName.Append(KTargetString);

			TBuf<10> string;

			string.Format(_L("%d"),screenDispMode);

			testFileName.Append(string);

			testFileName.Append(KSourceString);

			string.Format(_L("%d"),bitmapDispMode);

			testFileName.Append(string);

			WriteTargetOutput(testFileName);

			}

		}

	CleanupStack::PopAndDestroy(3, fileList); // fbsCompressed, fbsBitmap, fileList

#ifdef FORCE_FOREGROUND_COMPRESSION

	fbs->SendCommand(EFbsCompress, 0); // resume normal background compression

#endif // FORCE_FOREGROUND_COMPRESSION

	}

void CTOptimisedBmp::StripeBitmap(CFbsBitmap& aBitmap) // Compression friendly bitmap filling

	{

	TSize size = aBitmap.SizeInPixels();

	TInt dataLength = CFbsBitmap::ScanLineLength(size.iWidth,aBitmap.DisplayMode()) * size.iHeight;

	aBitmap.LockHeap();

	TUint8* bmpBits = (TUint8*)aBitmap.DataAddress();

	aBitmap.UnlockHeap();

	TUint8* bmpBitsLimit = bmpBits + dataLength;

	TInt64 seed = aBitmap.Handle();

	if (aBitmap.DisplayMode() != EColor4K)

		{

		while (bmpBits < bmpBitsLimit)

			{

			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

			while (bmpBits < tempBmpBitsLimit)

				*bmpBits++ = 0;

			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

			while (bmpBits < tempBmpBitsLimit)

				*bmpBits++ = 0xff;

			}

		}

	else

		{

		Mem::FillZ(bmpBits,dataLength);

		while (bmpBits < bmpBitsLimit)

			{

			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)(Math::Rand(seed) * 2));

			while (bmpBits < tempBmpBitsLimit)

				{

				*bmpBits++ = 0;

				*bmpBits++ = 0;

				}

			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

			while (bmpBits < tempBmpBitsLimit)

				{

				*bmpBits++ = 0xff;

				*bmpBits++ = 0x0f;

				}

			}		

		}

	}

/**

Logs the time taken to load the bitmap file identified by the filename.

@param aFileName the mbm file that is to be loaded

@param aTestCaseName the name of the test case

*/

void CTOptimisedBmp::TestDecompressBitmapL(const TDesC& aFileName, const TDesC& aTestCaseName)

	{

	TInt err = KErrNone;

	iProfiler->InitResults(); //initializes the timer

	for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

		{

		CFbsBitmap* fbsCompressed = new (ELeave) CFbsBitmap;

		CleanupStack::PushL( fbsCompressed );

		//Load mbm file identified by aFileName

		err = fbsCompressed->Load( aFileName, 0, EFalse ); //when there is no memory constraints

		TEST(err == KErrNone);

		fbsCompressed->Reset();

		CleanupStack::PopAndDestroy( fbsCompressed );

		iProfiler->MarkResultSetL();

		} // rpt loop

	//Logs the time taken to load the bmp file	

	iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

	}

#ifdef _DEBUG

/**

This test will only work correctly under UDEB builds of the OS.

It is same as CTOptimisedBmp::TestDecompressBitmapL function except that it also simulates the 

lack of memory use case while loading bitmap.

@param aFileName the mbm file that is to be loaded

@param aTestCaseName the name of the test case

*/

void CTOptimisedBmp::TestDecompressBitmapAltL(const TDesC& aFileName, const TDesC& aTestCaseName)

	{

	TInt err = KErrNone;

	RFbsSession* fbsSession = RFbsSession::GetSession();

	if (!fbsSession)

		{

		INFO_PRINTF1(_L("Error: fbs cannot be NULL"));

		ASSERT_NOT_NULL(fbsSession);

		}

	else

		{

		CFbsBitmap* fbsCompressed = new (ELeave) CFbsBitmap;

		CleanupStack::PushL( fbsCompressed );

		iProfiler->InitResults(); //initializes the timer

		for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

			{

			//Load mbm file identified by aFileName

			//Consider no memory case

			for (TInt count = 1; ; count++)

				{

				//Explicitly make the memory fails to check how will it loads bmp

				fbsSession->SendCommand(EFbsMessDefaultAllocFail,count);

				fbsSession->SendCommand(EFbsMessDefaultMark);

				fbsSession->SendCommand(EFbsMessUserMark);

				err = fbsCompressed->Load( aFileName, 0, EFalse );

				if (err == KErrNoMemory)

					{

					fbsSession->SendCommand(EFbsMessDefaultMarkEnd);

					fbsSession->SendCommand(EFbsMessUserMarkEnd);

					}

				else if (err == KErrNone)

					{

					fbsSession->SendCommand(EFbsMessUserMarkEnd);

					break;

					}

				}

			iProfiler->MarkResultSetL();

				fbsCompressed->Reset();

			} // rpt loop

		CleanupStack::PopAndDestroy( fbsCompressed );

		//Logs the time taken to load the bmp file	

		iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

		}

	}

#endif

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0076

@SYMDEF DEF105392

@SYMTestCaseDesc

Tests the performance of GetScanLine function for various display modes.

Also it tests the performance of various GetScanLineColorXX

(where XX => display mode, for eg. GetScanLineColor64K)

and TScanLineDecompressor::CopyPixel functions.

To test the performance of GetScanLineColorXX and other functions for any display mode, it creates

a bitmap of that display mode and passes it to CTOptimisedBmp::ScanlineTestL function

along with the display mode which was used for creating it and

the other display mode which will be used for reading this bitmap while logging the performance.

@SYMTestActions

Compare the results over time, and before and after changes to GetScanLine and CopyPixel code.

@SYMTestExpectedResults

Test should pass and display average time

*/

void CTOptimisedBmp::GetScanLineTestL()

	{

	CFbsBitmap bmp;

	const TSize bmpSize(22,5);

	_LIT(KTestCaseName,"GetScanLine");

	const TDisplayMode KTestDisplayModes[] = {EColor4K, EColor64K, EColor16M, EColor16MU, EColor16MA, EColor16MAP};

	const TInt KTestDisplayModeCnt = sizeof(KTestDisplayModes)/sizeof(TDisplayMode);

	for(TInt srcDispModeIndex = 0; srcDispModeIndex < KTestDisplayModeCnt; srcDispModeIndex++)

		{

		TDisplayMode displayMode = KTestDisplayModes[srcDispModeIndex];

		User::LeaveIfError(bmp.Create(bmpSize,displayMode));

		StripeBitmap(bmp);

		bmp.Compress();

		for(TInt destDispModeIndex = 0; destDispModeIndex < KTestDisplayModeCnt; destDispModeIndex++)

			{

			ScanlineTestL(bmp,displayMode,KTestDisplayModes[destDispModeIndex],KTestCaseName);

			}

		bmp.Reset();

		}

	}

/**

It reads a bitmap (aBitmap) of given display mode (aSrcDisplayMode) as a bitmap of

another display mode (aDestDisplayMode) and logs the performance for it.

@param aBitmap a bitmap

@param aSrcDisplayMode The used display mode when bitmap was created. 

						It is passed in this function just for logging purpose.

@param aDestDisplayMode The display mode used for reading the bitmap aBitmap

@param aTestCaseName The name of the test case

*/

void CTOptimisedBmp::ScanlineTestL(const CFbsBitmap& aBitmap, TDisplayMode aSrcDisplayMode, TDisplayMode aDestDisplayMode, const TDesC& aTestCaseName)

	{

	const TSize bmpSize(aBitmap.SizeInPixels());

	TInt byteWidth = CFbsBitmap::ScanLineLength(bmpSize.iWidth,aDestDisplayMode);

	TUint8* buffer = new (ELeave) TUint8[byteWidth];

	CleanupStack::PushL(buffer);

	TPtr8 scanLine(buffer,byteWidth,byteWidth);

	iProfiler->InitResults();

	for(TInt count=0;count<KRepeatTestCount;count++)

		{

		// For performance testing on same scanline, read the few pixels from bitmap.

		// And for a comprehensive testing, vary the start pixel and the number of pixels to get.

		for(TInt xStart = 0; xStart <= 11; xStart++)

			{

			for (TInt xLength = 1; xLength <= 11; xLength++)

				{

				TInt xEnd = xStart + xLength;

				if (xEnd <= bmpSize.iWidth)

					{

					aBitmap.GetScanLine(scanLine,TPoint(xStart,0),xLength,aDestDisplayMode);

					}

				}

			}

		// Test the performance of reading different scanlines.

		for(TInt yy = 0; yy < bmpSize.iHeight; yy++)

			{

			aBitmap.GetScanLine(scanLine,TPoint(0,yy),bmpSize.iWidth,aDestDisplayMode);

			}

		iProfiler->MarkResultSetL();

		}

	iProfiler->ResultsAnalysis(aTestCaseName, 0, aSrcDisplayMode, aDestDisplayMode, KRepeatTestCount);

	CleanupStack::PopAndDestroy(buffer);

	}

/**

Logs the time taken to load the bitmap file identified by the filename and file id.

@param aFileName the mbm or rsc file that is to be loaded

@param aId The bitmap identifier

@param aShareIfLoaded Specifies whether or not the loaded bitmap will be made available for sharing between font and bitmap server clients.

@param aTestCaseName the name of the test case

*/

void CTOptimisedBmp::ResourceBitmapLoadL(const TDesC& aFileName, TInt32 aId, TBool aShareIfLoaded, const TDesC& aTestCaseName)

	{

	TInt err = KErrNone;

	iProfiler->InitResults(); //initializes the timer

	for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

		{

		CFbsBitmap* resourceBitmap = new (ELeave) CFbsBitmap;

		CleanupStack::PushL(resourceBitmap);

		iProfiler->StartTimer();

		//Load mbm or rsc file identified by aFileName

		err = resourceBitmap->Load( aFileName, aId, aShareIfLoaded ); //when there is no memory constraints

		iProfiler->MarkResultSetL();

		TEST(err == KErrNone);

		resourceBitmap->Reset();

		CleanupStack::PopAndDestroy( resourceBitmap );

		}

	//Logs the time taken to load the bmp file

	iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

	}