// Copyright (c) 2002-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 <bitdev.h>

#include <e32math.h>

#include "tcompressed.h"

CTCompressed::CTCompressed(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

void CTCompressed::BlankBitmap(CFbsBitmapEx& aBitmap)

	{

	TSize size = aBitmap.SizeInPixels();

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

	aBitmap.LockHeap();

	Mem::FillZ((TUint8*)aBitmap.DataAddress(),dataLength);

	aBitmap.UnlockHeap();

	}

void CTCompressed::RunTestCaseL(TInt aCurTestCase)

    {

    ((CTCompressedStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0571"));

		TRAPD(err, RunTestL());

		TEST(err == KErrNone);

		break;	

	case 2:

		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0572"));

		TRAP(err, DefectFix_EXT5DXGK6_L());

		TEST(err == KErrNone);

		break;	

	case 3:

		{

		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0500"));

		// Set size of bitmap large enough to warrant compression

		const TSize KBitmapSize(200,200);

		INFO_PRINTF1(_L("Test case for INC082713\r\n"));

		TRAP(err, DefectFix_INC082713_L(EColor16MU, KBitmapSize));

		TEST(err == KErrNone);		

		TRAP(err, DefectFix_INC082713_L(EColor16MA, KBitmapSize));

		TEST(err == KErrNone);

		}

		break;

	case 4:

		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0573"));

		TRAPD(err1, INC088856_TestL());

		TEST(err1 == KErrNone);

		break;

 	case 5:

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0615"));

		TestDestroyBitmapWhileBeingBackgroundCompressedL();

		break;

	case 6:

		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0616"));

		TestBackgroundCompressionThreadPriorityInheritanceL();

		break;

	case 7:

		((CTCompressedStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTCompressedStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;	

		}

	((CTCompressedStep*)iStep)->RecordTestResultL();

    }

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0571

	@SYMTestCaseDesc

	Tests compression of bitmaps in RAM and ROM.

	@SYMTestActions

	Four bitmaps are loaded. One compressed and one

	uncompressed from ROM and from RAM. The bitmap

	in RAM is tested if it can be compressed successfully.

	The bitmap in ROM should fail when tried to be compressed.

	All of the bitmaps are then tried to be BitBlt.	

	@SYMTestExpectedResults

	Test should pass

*/

void CTCompressed::RunTestL()

    {

    TInt skipRomBitmapTests = EFalse;

	TUint32* romAddress = NULL;

	if(!CFbsBitmap::IsFileInRom(KRomNotCompressed, romAddress)) //any ROM bitmap

		{

		INFO_PRINTF2(_L("Skipping ROM bitmap tests since file \"%S\" is reported to not be a ROM bitmap."),

				&KRomNotCompressed);

		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));

		skipRomBitmapTests = ETrue;

		}

	TBuf<64> romNotCompressed(KRomNotCompressed);

	TBuf<64> romCompressed(KRomCompressed);

	TBuf<64> fileNotCompressed(KFileNotCompressed);

	TBuf<64> fileCompressed(KFileCompressed);

	TInt ret = KErrNone;

	CFbsBitmap rom;

	CFbsBitmap romcomp;

	if(!skipRomBitmapTests)

		{

		TEST(rom.Load(romNotCompressed, 0, EFalse)== KErrNone);

		TEST(romcomp.Load(romCompressed, 0, EFalse)== KErrNone);

		INFO_PRINTF1(_L("Check compressing of ROM bitmaps causes error.\r\n"));

		ret = rom.Compress();

		TEST(ret == KErrAccessDenied); //cannot compress bitmaps in ROM

		TEST(rom.IsCompressedInRAM());

		}

	CFbsBitmap file;

	CFbsBitmap filecomp;

	TEST(file.Load(fileNotCompressed, 0, EFalse)== KErrNone);

	TEST(filecomp.Load(fileCompressed, 0, EFalse)== KErrNone);

	INFO_PRINTF1(_L("Check compressing of RAM files is OK.\r\n"));

	CFbsBitmap ram;

	ret=ram.Load(fileNotCompressed,0,EFalse);

	TEST(ret == KErrNone);

	ret = ram.Compress();

	TEST(ret == KErrNone); //can compress bitmaps in RAM

	TEST(ram.IsCompressedInRAM());

	INFO_PRINTF1(_L("Check compressing a created EColor256 bitmap.\r\n"));

	CFbsBitmapEx created;

	ret=created.Create(TSize(200,200),EColor256);

	TEST(ret==KErrNone);

	// This makes sure we can compress it...

	BlankBitmap(created);

	ret = created.Compress();

	TEST(ret==KErrNone);

	TEST(created.IsCompressedInRAM());

	INFO_PRINTF1(_L("Check compressing a created EColor24MU bitmap.\r\n"));

	CFbsBitmapEx created24MU;

	ret=created24MU.Create(TSize(200,200),EColor16MU);

	TEST(ret==KErrNone);

	// This makes sure we can compress it...

	BlankBitmap(created24MU);

	ret = created24MU.Compress();

	TEST(ret==KErrNone);

	TEST(created24MU.IsCompressedInRAM());

	INFO_PRINTF1(_L("Try bitblt on all bitmaps"));

	for (TInt mode = EGray2; mode < EColorLast; mode++)

		{

		if(!skipRomBitmapTests)

			{

			INFO_PRINTF2(_L("BitBlt rom with %d display mode.\r\n"), mode);

			TestBitBltL(rom,      TDisplayMode(mode));

			INFO_PRINTF2(_L("BitBlt romcomp with %d display mode.\r\n"), mode);

			TestBitBltL(romcomp,  TDisplayMode(mode));

			}

		INFO_PRINTF2(_L("BitBlt file with %d display mode.\r\n"), mode);

		TestBitBltL(file,     TDisplayMode(mode));

		INFO_PRINTF2(_L("BitBlt filecomp with %d display mode.\r\n"), mode);

		TestBitBltL(filecomp, TDisplayMode(mode));

		INFO_PRINTF2(_L("BitBlt ram with %d display mode.\r\n"), mode);

		TestBitBltL(ram,      TDisplayMode(mode));

		INFO_PRINTF2(_L("BitBlt created with %d display mode.\r\n"), mode);

		TestBitBltL(created,  TDisplayMode(mode));

		INFO_PRINTF2(_L("BitBlt 24MU created bitmap with %d display mode.\r\n"), mode);

		TestBitBltL(created24MU,  TDisplayMode(mode));

		}

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0572

	@SYMTestCaseDesc

	Testcode to check for fix to defect EXT-5DXGK6 Bitmap 

	compression causes crash when loading skins.

	Its not a conclusive test as it depends on where the 

	bitmap is loaded into memory and if there is 

	memory allocated at the end of the bitmap.

	@SYMTestActions

	@SYMTestExpectedResults

	Test should pass

*/

void CTCompressed::DefectFix_EXT5DXGK6_L()

	{

	CFbsBitmapEx bmp1;

	TSize size(1000,1);

	TInt ret=bmp1.Create(size,EGray2);

	TEST(ret==KErrNone);

	BlankBitmap(bmp1);

//

	// calculate the size of the destination scan line in bytes

	// + 31 to pad to 4 byte boundary; 8 bits in a byte

	TInt source_buffer_size = (size.iWidth + 31) / 8 ;

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

	TPtr8 source_ptr(buffer,source_buffer_size,source_buffer_size);

	for(TInt ii = 0; ii<source_buffer_size; ++ii)

		{

		if(ii%2)

			source_ptr[ii] = 2;

		else

			source_ptr[ii] = 3;

		}

	source_ptr[source_buffer_size-1] = 5;

	source_ptr[source_buffer_size-2] = 5;

	source_ptr[source_buffer_size-3] = 5;

	source_ptr[source_buffer_size-4] = 4;

	bmp1.SetScanLine(source_ptr,0);

	delete [] buffer;

	bmp1.Compress();

	}

/**

 * @SYMTestCaseID GRAPHICS-FBSERV-0500

 *

 * @SYMDEF INC082713

 *

 * @SYMTestCaseDesc Test RLE compression algorithm of EColor16MU and EColor16MA bitmaps.

 *

 * @SYMTestPriority Critical

 *

 * @SYMTestStatus Implemented

 *

 * @SYMTestActions The following test checks a corner-case of the algorithm triggered by a specific pixel pattern.

 *

 * The corner case is triggered when the input to the compression function ends in a run of equal pixels, 

 * terminated by a single pixel that is different i.e. ...rrrrrrrrrrrrrrrg 

 * where we have a run of equal (red) pixels followed by a green pixel, which is the last pixel in the 

 * bitmap (or the scanline, depending on how the data is being compressed).

 *

 * This test case performs the following:

 * 1) Creates a bitmap in the display mode and of size specified in function args.

 * This size must be large enough to trigger the compression when requested.

 * 2) Creates a scanline the width of this bitmap, which is a run of equal pixels, and 

 * then sets the last pixel to be different.

 * 3) Sets the last scanline of the bitmap to the scanline we have just created. 

 * This means that the last scanline of the bitmap conforms to the corner-case pattern.

 * 4) Compresses the bitmap

 * 5) Checks the compression has been successful

 * 6) Retrieves the last scanline of the bitmap and compares it with the original one

 * to verify that the compression of data has been successful.

 *

 * @SYMTestExpectedResults

 * The compression should occur successfully without panicking.

 * The scanline retrieved from the compressed version of the bitmap should match

 * the original scanline created.

 */

void CTCompressed::DefectFix_INC082713_L(const TDisplayMode aDispMode, const TSize aBitmapSize)

	{

	// *** This function assumes that pixels are stored as 32 bit words ***

	// *** for EColor16MU and EColor16MA bitmaps                        ***

	switch(aDispMode)

		{

	case EColor16MU:

		INFO_PRINTF1(_L("Check compression algorithm corner case for EColor16MU bitmap.\r\n"));

		break;

	case EColor16MA:

		INFO_PRINTF1(_L("Check compression algorithm corner case for EColor16MA bitmap.\r\n"));

		break;

	default:

		INFO_PRINTF1(_L("Unsupported display mode for test"));

		return;

		}

	CFbsBitmap bitmap;

	TInt ret=bitmap.Create(aBitmapSize,aDispMode);

	TEST(ret==KErrNone);

	TInt widthInPixels = bitmap.SizeInPixels().iWidth;

	TInt heightInPixels = bitmap.SizeInPixels().iHeight;

	TInt scanLineByteLength = bitmap.ScanLineLength(widthInPixels, aDispMode);

	TUint32* buffer = (TUint32*)User::AllocLC(scanLineByteLength);

	// Breaking from a run of equal pixels

	// i.e. rrrrrrr...rrrrrrrrg

	for (TInt ii = 0; ii < widthInPixels; ii++)

		{

		buffer[ii] = 0xc6ebff;

		}

	// Last pixel differs - must be able to re-enter loop when at last pixel

	buffer[widthInPixels - 1] = 0xcee7ff;

	TPtr8 scanline((TUint8*)buffer ,scanLineByteLength,scanLineByteLength);

	bitmap.SetScanLine(scanline, heightInPixels - 1);

	INFO_PRINTF1(_L("Compressing bitmap"));

	ret = bitmap.Compress();

	TEST(ret==KErrNone);

	TEST(bitmap.IsCompressedInRAM());

	// Retrieve the scanline from the compressed bitmap and compare with original

	// in order to test whether the scanline is correctly compressed

	INFO_PRINTF1(_L("Retrieving scanline from compressed bitmap"));

	TUint32* readbackbuffer = (TUint32*)User::AllocLC(scanLineByteLength);

	TPtr8 readbackscanline((TUint8*)readbackbuffer ,scanLineByteLength,scanLineByteLength);

	readbackscanline.Fill(0xff);

	bitmap.GetScanLine(readbackscanline,TPoint(0,heightInPixels - 1),widthInPixels, aDispMode);

	INFO_PRINTF1(_L("Comparing scanlines\r\n"));

	// Compare the original scanline with the one retrieved from the compressed version

	switch(aDispMode)

		{

	case EColor16MU:

		{		

		TBool result = ETrue;

		for (TInt ii = 0; ii < widthInPixels; ii++)

			{

			// Must mask off top bits (as we can ignore them, since we have no alpha channel)

			TUint32 original = buffer[ii] & 0x00ffffff;

			TUint32 readback = readbackbuffer[ii] & 0x00ffffff;

			result = result && (original == readback);

			}

		TEST(result);

		}

		break;

	case EColor16MA:

		ret = Mem::Compare((TUint8*)buffer, scanLineByteLength, (TUint8*)readbackbuffer, scanLineByteLength);

		// Mem::Compare returns 0 if the two scanlines are equal

		TEST(ret == 0);

		break;

	default:

		INFO_PRINTF1(_L("Unsupported display mode for test"));

		break;

		}

	CleanupStack::PopAndDestroy(2, buffer);

	}

void CTCompressed::TestBitBltL(CFbsBitmap& aBmp, TDisplayMode aDispMode)

	{

	CFbsScreenDevice* scd = 0;

	TRAPD(ret, scd = CFbsScreenDevice::NewL(_L("scdv"),aDispMode));

	if (!scd)

		{

		WARN_PRINTF3(_L("Could not create screen device in %d mode, reason=%d.\r\n"), aDispMode, ret);

		return;

		}

	CleanupStack::PushL(scd);

	scd->ChangeScreenDevice(NULL);

	CFbsBitGc* sgc;

	if (scd->CreateContext((CGraphicsContext*&)sgc)==KErrNone) 

		{

		CleanupStack::PushL(sgc);

		TSize halfScreen = scd->SizeInPixels();

		halfScreen.iWidth /= 2;

		INFO_PRINTF1(_L("BitBlt..."));

		sgc->BitBlt(TPoint(halfScreen.iWidth,0),&aBmp);

		INFO_PRINTF1(_L("worked\r\n"));

		CleanupStack::PopAndDestroy(sgc);

		}

	else

		{

		INFO_PRINTF2(_L("Could not create context in %d mode.\r\n"), aDispMode);

		}

	CleanupStack::PopAndDestroy(scd);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0573

	@SYMDEF INC088856

	@SYMTestCaseDesc

	Verifies defect INC088856. Checks the 

	updated padding value before compression for

	256 gray scale and 64k colour.

	@SYMTestActions

	Creates a bitmap. Gets the bitmaps scanline length.

	Locks the heap. Retrieves the bitmaps data address.

	Unlocks the heap. Then for both 256 gray scale and 64k colour

	it checks the padding after compression matches before compression.

	@SYMTestExpectedResults

	Test should pass

*/

void CTCompressed::INC088856_TestL()

	{

	INFO_PRINTF1(_L("Check updated Padding value in before compression \r\n"));

	INFO_PRINTF1(_L("Check updated Padding value for EGray256 \r\n"));

	DoUpdateOnPadding(TSize(5,3),EGray256);

	DoUpdateOnPadding(TSize(25,43),EGray256);

	INFO_PRINTF1(_L("Check updated Padding value for EColor64K \r\n"));

	DoUpdateOnPadding(TSize(5,3),EColor64K);

	DoUpdateOnPadding(TSize(25,43),EColor64K);

	}

void CTCompressed::DoUpdateOnPadding(const TSize aSize, const TDisplayMode aDispMode)

	{

	CFbsBitmapEx bmp1;

	TInt ret=bmp1.Create(aSize,aDispMode);

	TEST(ret==KErrNone);

	TInt dataLength = CFbsBitmap::ScanLineLength(aSize.iWidth, bmp1.DisplayMode()) * aSize.iHeight;

	bmp1.LockHeap();

	TUint8* srcBits = (TUint8*)bmp1.DataAddress();

	bmp1.UnlockHeap();

	TInt val=1,pos=0;

	switch (aDispMode)

		{

	case EGray256:

		{

		TUint8* bmpBits = srcBits;

		TUint8* bmpBitsLimit = srcBits + dataLength;

		while(bmpBits<bmpBitsLimit)

			{

			if(pos++ < aSize.iWidth)

				{

				*bmpBits++ = val;

				}

			else 

				{

				bmpBits += 3;

				val++;

				pos=0;

				}

			}

		}

		break;

	case EColor64K:

		{

		TUint16* bmpBits = (TUint16*)srcBits;

		TUint16* bmpBitsLimit = (TUint16*)(srcBits + dataLength);

		while(bmpBits<bmpBitsLimit)

			{

			if(pos++ < aSize.iWidth)

				{

				*bmpBits++ = val;

				}

			else 

				{

				bmpBits++;

				val++;

				pos=0;

				}

			}

		}

		break;

	default:

		break;

		}

	bmp1.Compress();

	TInt stride = bmp1.DataStride();

	TUint8* dataPtr = (TUint8*)bmp1.DataAddress();

	switch(aDispMode)

		{

	case EGray256:

		{

		for (TInt row = 0; row < aSize.iHeight - 1; ++row)

			{

			TEST(*dataPtr++ == stride - 1);

			TEST(*dataPtr++ == row + 1);

			}

		break;

		}

	case EColor64K:

		{

		for (TInt row = 0; row < aSize.iHeight - 1; ++row)

			{

			TEST(*dataPtr++ == stride / 2 - 1);

			TEST(*dataPtr++ == row + 1);

			TEST(*dataPtr++ == 0);

			}

		}

		break;

	default:

		break;

		}

	}

/**

 * @SYMTestCaseID GRAPHICS-FBSERV-0615

 *

 * @SYMDEF PDEF115511

 *

 * @SYMTestCaseDesc

 * Test Fbserv robustness when bitmaps are destroyed while they are being background compressed

 *

 * @SYMTestPriority High

 *

 * @SYMTestStatus Implemented

 *

 * @SYMTestActions

 * Preform various scenarios to create bitmaps, compress them in background and then destroy the 

 * bitmaps without waiting the compression to complete.

 *

 * @SYMTestExpectedResults