// 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 "trasterizer.h"

#include "testutils.h"

#include "examplerasterizer.h"

#include <fbs.h>

#include <gdi.h>

#include <s32mem.h>

#include <e32math.h>

#include <e32svr.h>

#include <u32hal.h>

const TDisplayMode KDisplayModes[] = {EGray256, EColor64K, EColor16MU, EColor16MAP};

const TInt KNumDisplayModes = sizeof(KDisplayModes)/sizeof(KDisplayModes[0]);

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

CTRasterizer::CTRasterizer()

	{

	SetTestStepName(KTRasterizerStep);

	}

/**

@SYMTestCaseID		

	GRAPHICS-FBSERV-RASTERIZER-001

@SYMTestPriority

	High

@SYMPREQ

	PREQ2096

@SYMREQ

	REQ10860

	REQ10861 

@SYMTestCaseDesc

	Test that the example rasterizer dll "fbsrasterizer_test.dll" has been loaded.

@SYMTestActions	

	On the emulator check that the rasterizer setting is "fbsrasterizer_test.dll".

	Get a pointer to the rasterizer.

@SYMTestExpectedResults

	"fbsrasterizer_test.dll" has been loaded successfully

*/

void CTRasterizer::TestLoadRasterizerDllL()

	{

	INFO_PRINTF1(_L("TestLoadRasterizerDll"));

#ifdef __WINS__

	_LIT8(KTestRasterizerName, "fbsrasterizer_test.dll");

	TUint8* rasterizerSetting = NULL;

	UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalStringProperty, (TAny*)"FBSRASTERIZER_DLL", &rasterizerSetting);

	TESTL(rasterizerSetting != NULL);

	TESTL(TPtrC8(rasterizerSetting).CompareF(KTestRasterizerName) == 0);

#endif

	GetExampleRasterizerL();

	}

/**

@SYMTestCaseID		

	GRAPHICS-FBSERV-RASTERIZER-002

@SYMTestPriority

	High

@SYMPREQ

	PREQ2096

@SYMREQ

	REQ10860

	REQ10861 

@SYMTestCaseDesc

	Test that a scanline retrieved from the example rasterizer is what we expect.

@SYMTestActions		

	Create an extended bitmap and set its extended data to three colours followed by a TUint8.

	The example rasterizer interprets this data as the three colours in a tricolour flag drawn

	with either horizontal or vertical stripes depending on the value of the TUint8.	

	Draw a scanline of the extended bitmap by calling:

		- CFbsRasterizer::BeginBitmap()

		- CFbsRasterizer::ScanLine()

		- CFbsRasterizer::EndBitmap()

@SYMTestExpectedResults

	The scan line returned by the example rasterizer should be exactly the same as the

	corresponding scanline in the test data.

*/

void CTRasterizer::TestScanLineL()

	{	

	TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); 

	INFO_PRINTF2(_L("TestScanLine, display mode %S"), &displayModeDes);

	const TInt KNumBeginBitmapCalls = 5;

	// Get the example rasterizer

	GetExampleRasterizerL();	

	// Test for both stripe styles, 0 for vertical stripes and 1 for horizontal stripes

	for (TInt stripeStyle = 0; stripeStyle < 2; stripeStyle++)

		{

		if (stripeStyle == 0)

			{

			INFO_PRINTF1(_L("... Vertical stripes"));

			}

		else

			{

			INFO_PRINTF1(_L("... Horizontal stripes"));

			}

		const TSize sizeInPixels(64,32);

		CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, stripeStyle, sizeInPixels);					

		// Begin scanline access to the extended bitmap

		CFbsRasterizer::TBitmapDesc bitmapDesc;

		TInt64 bitmapId = extendedBitmap->SerialNumber();

		bitmapDesc.iSizeInPixels = sizeInPixels;

		bitmapDesc.iDispMode = iDisplayMode;

		bitmapDesc.iDataType = KUidExampleExtendedBitmap;

		bitmapDesc.iData = extendedBitmap->DataAddress();

		bitmapDesc.iDataSize = extendedBitmap->DataSize();

		extendedBitmap->BeginDataAccess();

		// test calling BeginBitmap more than once as each additional call should just increment as reference count

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

			{			

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

			}				

		TInt scanlineLength;

		TPoint startPixel;

		TRgb bufferColour;

		// The width or height of a stripe in the tricolour flag that the extended bitmap rasterizer draws

		TInt stripeSize = (stripeStyle == 0) ? sizeInPixels.iWidth/3 : sizeInPixels.iHeight/3; 				

		for (TInt h = 0; h < sizeInPixels.iHeight; h++)

			{

			// Get a full scanline from the extended bitmap using the rasterizer	

			startPixel = TPoint(0, h);

			scanlineLength = sizeInPixels.iWidth;

			const TUint8* scanline = reinterpret_cast<const TUint8*>(iRasterizer->ScanLine(bitmapId, startPixel, scanlineLength));

			TESTL(scanline != NULL);								

			// Make sure each pixel in the scanline is the colour that we expect						

			TRgb compareColour;

			for (TInt w = 0; w < scanlineLength; w++)

				{																			

				if (((stripeStyle == 0) && (w < stripeSize)) 

					|| ((stripeStyle == 1) && (h < stripeSize)))

					{					

					compareColour = KStripeColours[0]; // left or top

					}

				else if (((stripeStyle == 0) && (w >= sizeInPixels.iWidth-stripeSize)) 

					|| ((stripeStyle == 1) && (h >= sizeInPixels.iHeight-stripeSize)))

					{

					compareColour = KStripeColours[2]; // right or bottom

					}

				else

					{

					compareColour = KStripeColours[1]; // middle

					}					

				bufferColour = ExtractRgb(scanline, w, iDisplayMode);

				if (((iDisplayMode != EGray256) && (bufferColour != compareColour))

					|| ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(compareColour.Gray256()))))

					{					

					INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h);

					TEST(EFalse);

					}			

				}							

			}

		// End scanline access to the extended bitmap

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

			{

			iRasterizer->EndBitmap(bitmapId);			

			}

		extendedBitmap->EndDataAccess();

		// Clean up

		CleanupStack::Pop(1, extendedBitmap);

		}

	}

/**

@SYMTestCaseID		

	GRAPHICS-FBSERV-RASTERIZER-003

@SYMTestPriority

	High

@SYMPREQ

	PREQ2096

@SYMREQ

	REQ10860

	REQ10861 

@SYMTestCaseDesc

	Test that we can get scanlines from 3 extended bitmaps simultaneously using the example rasterizer.

@SYMTestActions	

	Load a normal bitmap.	

	Create 3 extended bitmaps and set their extended data to be vertically striped colours.	

	Draw a scanline of each extended bitmap by calling:

		- CFbsRasterizer::BeginBitmap() for each extended bitmap

		- CFbsRasterizer::ScanLine() for each extended bitmap

		- CFbsRasterizer::EndBitmap() for each extended bitmap

	Compare the first pixel of each scanline and the last pixel of each scanline against the

	expected colour.

@SYMTestExpectedResults

	The rasterizer should be able to handle rasterizing up to 3 extended bitmaps at once,

	all three scanlines should be returned with no errors.

	The colours compared should match exactly.

*/

void CTRasterizer::TestMultipleScanLinesL()

	{

	TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); 

	INFO_PRINTF2(_L("TestMultipleScanLines, vertical stripes, display mode %S"), &displayModeDes);

	const TInt KNumBitmaps = 3;

	const TInt KBaseSize = 10;			

	RArray<CFbsBitmap*> bitmaps;

	CleanupClosePushL(bitmaps);	

	// Get the example rasterizer

	GetExampleRasterizerL();

	// Create the three differently sized extended bitmaps each coloured with vertical stripes 

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

		{

		const TSize KSizeInPixels = TSize(KBaseSize*(i+1), KBaseSize*(i+1));			

		CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, EFalse, KSizeInPixels);		

		bitmaps.AppendL(extendedBitmap);			

		}

	// Begin scanline access to the extended bitmaps

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

		{

		bitmaps[i]->BeginDataAccess();

		CFbsRasterizer::TBitmapDesc bitmapDesc;

		TInt64 bitmapId = bitmaps[i]->SerialNumber();

		bitmapDesc.iSizeInPixels = bitmaps[i]->SizeInPixels();

		bitmapDesc.iDispMode = iDisplayMode;

		bitmapDesc.iDataType = KUidExampleExtendedBitmap;

		bitmapDesc.iData = bitmaps[i]->DataAddress();

		bitmapDesc.iDataSize = bitmaps[i]->DataSize();	

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

		}

	// Get scanlines from each extended bitmap and check that the first and last pixel in each is the correct colour

	for (TInt h = 0; h < KBaseSize; h++)

		{

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

			{	

			const TUint8* scanline = reinterpret_cast<const TUint8*>(iRasterizer->ScanLine(bitmaps[i]->SerialNumber(), TPoint(0,h), KBaseSize*(i+1)));			

			TESTL(scanline != NULL);					

			// Test that the first pixel is the correct colour (the first pixel in each scanline should be KStripeColours[0]

			// as the bitmaps should have all been drawn with vertical stripes with the first stripe being KStripeColours[0]

			TRgb bufferColour = ExtractRgb(scanline, 0, iDisplayMode);			

			if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[0]))

				|| ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[0].Gray256()))))	

				{

				INFO_PRINTF3(_L("Pixel comparison failed for bitmap %d, pixel 0,%d"), i, h);

				TEST(EFalse);

				}	

			// The last pixel should be KStripeColours[2]							

			bufferColour = ExtractRgb(scanline, (KBaseSize*(i+1))-1, iDisplayMode);

			if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[2]))

				|| ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[2].Gray256()))))	

				{

				INFO_PRINTF4(_L("Pixel comparison failed for bitmap %d, pixel %d,%d"), i, (KBaseSize*(i+1))-1, h);

				TEST(EFalse);

				}

			}

		}

	// Unregister each extended bitmap

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

		{					

		iRasterizer->EndBitmap(bitmaps[i]->SerialNumber());

		bitmaps[i]->EndDataAccess();

		}

	// Cleanup

	CleanupStack::PopAndDestroy(KNumBitmaps+1);

	}

/**

@SYMTestCaseID		

	GRAPHICS-FBSERV-RASTERIZER-004

@SYMTestPriority

	High

@SYMPREQ

	PREQ2096

@SYMREQ

	REQ10860

	REQ10861 

@SYMTestCaseDesc

	Test that the rasterizer returns portions of scanline correctly

	when a region of interest is specified.

@SYMTestActions	

	Create an extended bitmap.

	Rasterize it specifying a region of interest that has three regions that roughly

	form a squared off C shape.		

@SYMTestExpectedResults

	Check that scanlines returned are correct in the specified region of interest.

	(Anything outside the region of interest does not matter).

*/

void CTRasterizer::TestRegionOfInterestL()

	{

	TBuf<32> displayModeDes(TestUtils::DisplayModeToString(iDisplayMode)); 

	INFO_PRINTF2(_L("TestRegionOfInterest, horizontal stripes, display mode %S"), &displayModeDes);

	// Get the example rasterizer

	GetExampleRasterizerL();	

	// Create an extended bitmap with horizontal stripes

	const TSize sizeInPixels(24,24);

	CFbsBitmap* extendedBitmap = CreateExtendedBitmapLC(KStripeColours, ETrue, sizeInPixels);		

	// Create a region of interest in the shape of a square with a hole in the middle

	TRegionFix<4> regionOfInterest;

	const TInt KStripeSize = sizeInPixels.iHeight/3;

	const TInt KEdgeOffset = 2;	

	regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,KEdgeOffset), TSize(sizeInPixels.iWidth-(KEdgeOffset*2),KStripeSize)));	// top of the square

	regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,sizeInPixels.iHeight-KEdgeOffset-KStripeSize), TSize(sizeInPixels.iWidth-(KEdgeOffset*2),KStripeSize)));	// bottom of the square

	regionOfInterest.AddRect(TRect(TPoint(KEdgeOffset,KEdgeOffset+KStripeSize), TSize(KStripeSize,sizeInPixels.iHeight-(KEdgeOffset*2)-(KStripeSize*2))));	// left of the square

	regionOfInterest.AddRect(TRect(TPoint(sizeInPixels.iWidth-KEdgeOffset-KStripeSize,KEdgeOffset+KStripeSize), TSize(KStripeSize,sizeInPixels.iHeight-(KEdgeOffset*2)-(KStripeSize*2)))); // right of the square		

	TEST(regionOfInterest.CheckError() == EFalse);

	// Begin scanline access to the extended bitmap

	CFbsRasterizer::TBitmapDesc bitmapDesc;

	TInt64 bitmapId = extendedBitmap->SerialNumber();

	bitmapDesc.iSizeInPixels = sizeInPixels;

	bitmapDesc.iDispMode = iDisplayMode;

	bitmapDesc.iDataType = KUidExampleExtendedBitmap;

	bitmapDesc.iData = extendedBitmap->DataAddress();

	bitmapDesc.iDataSize = extendedBitmap->DataSize();

	extendedBitmap->BeginDataAccess();

	iRasterizer->BeginBitmap(bitmapId, bitmapDesc, &regionOfInterest);	

	TInt scanlineLength;

	TPoint startPixel;

	TRgb bufferColour;

	for (TInt h = 0; h < sizeInPixels.iHeight; h++)

		{

		// Get scanlines from the extended bitmap using the rasterizer	

		startPixel = TPoint(0, h);

		scanlineLength = sizeInPixels.iWidth;

		const TUint8* scanline = reinterpret_cast<const TUint8*>(iRasterizer->ScanLine(bitmapId, startPixel, scanlineLength));

		TESTL(scanline != NULL);								

		// Make sure each pixel in the scanline is the colour that we expect					

		for (TInt w = 0; w < sizeInPixels.iWidth; w++)

			{										

			bufferColour = ExtractRgb(scanline, w, iDisplayMode);

			// Pixels that lie inside the region should be set to a flag stripe colour, pixels

			// outside of the region should be white			

			if (regionOfInterest.Contains(TPoint(w,h)))

				{				

				if (((iDisplayMode != EGray256) && (bufferColour != KStripeColours[h/KStripeSize]))

					|| ((iDisplayMode == EGray256) && (bufferColour != TRgb::Gray256(KStripeColours[h/KStripeSize].Gray256()))))

					{

					INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h);

					TEST(EFalse);

					}			

				}

			else

				{

				if (bufferColour != KRgbWhite)

					{

					INFO_PRINTF3(_L("Pixel comparison failed for pixel %d,%d"), w, h);

					TEST(EFalse);

					}

				}

			}		

		}

	// End scanline access to the extended bitmap	

	iRasterizer->EndBitmap(bitmapId);

	extendedBitmap->EndDataAccess();

	// Clean up

	CleanupStack::Pop(1, extendedBitmap);

	}

/**

Override of base class pure virtual

Lists the tests to be run

*/

TVerdict CTRasterizer::doTestStepL()

	{

	TestLoadRasterizerDllL();

	// Tests that require testing in multiple display modes

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

		{

		iDisplayMode = KDisplayModes[i];		

		TestScanLineL();

		TestMultipleScanLinesL();

		TestRegionOfInterestL();

		}

	return TestStepResult();

	}

/** Helper function for getting a TRgb colour value from a buffer given a pixel offset and 

a display mode.

@param aBuffer A buffer to extract the TRgb from

@param aPixelOffset The pixel position in the buffer to extract the TRgb from

@param aDispMode The display mode of the buffer

@return The TRgb value found at the pixel position specified

 */

TRgb CTRasterizer::ExtractRgb(const TUint8* aBuffer, TInt aPixelOffset, TDisplayMode aDispMode)

	{

	switch (aDispMode)

		{

	case EGray2:

		{

		TUint8 byte = *(aBuffer + (aPixelOffset >> 3));

		if (byte & (1 << (aPixelOffset & 7)))

			return KRgbWhite;

		return KRgbBlack;

		}

	case EGray4:

		{

		TUint8 byte = *(aBuffer + (aPixelOffset >> 2));

		byte >>= ((aPixelOffset & 3) << 1);

		return TRgb::Gray4(byte & 3);

		}

	case EGray16:

		{

		TUint8 byte = *(aBuffer + (aPixelOffset >> 1));

		if (aPixelOffset & 1)

			byte >>= 4;

		return TRgb::Gray16(byte & 0xf);

		}

	case EGray256:

		return TRgb::Gray256(*(aBuffer + aPixelOffset));

	case EColor16:

		{

		TUint8 byte = *(aBuffer + (aPixelOffset >> 1));

		if (aPixelOffset & 1)

			byte >>= 4;

		return TRgb::Color16(byte & 0xf);

		}

	case EColor256:

		return TRgb::Color256(*(aBuffer + aPixelOffset));

	case EColor4K:

		{

		TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset);

		return TRgb::Color4K(doubleByte & 0xfff);

		}

	case EColor64K:

		{

		TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset);

		return TRgb::Color64K(doubleByte);

		}

	case EColor16M:

		{

		aBuffer += aPixelOffset * 3;

		TInt value = *aBuffer++;

		value |= *aBuffer++ << 8;

		value |= *aBuffer << 16;

		return TRgb::Color16M(value);

		}

	case ERgb:

		return *(((TRgb*)aBuffer) + aPixelOffset);

	case EColor16MU:

		{

		// Note this is | with 0xFF000000 to match the example rasterizer which sets

		// the alpha to 0xFF when drawing using EColor16MU

		return TRgb::Color16MU((*(((TUint32*)aBuffer) + aPixelOffset)) | 0xFF000000);

		}

	case EColor16MA:

		{

		return TRgb::Color16MA(*(((TUint32*)aBuffer) + aPixelOffset));

		}	

	case EColor16MAP:

		{

		return TRgb::_Color16MAP(*(((TUint32*)aBuffer) + aPixelOffset));

		}	

	default:

		break;

		};

	return KRgbBlack;

	}

/** Helper function for creating an extended bitmap. 

@param aColours A pointer to an array of three colours to use when creating the extended bitmap, 

these colours define the colours used when drawing the stripes in the extended bitmap.

@param aHorizontalStripe ETrue for horizontal stripes, EFalse for vertical stripes.

@param aSizeInPixels The size of the extended bitmap to create.

@return A pointer to a newly created extended bitmap that has been pushed on to the cleanup stack.

 */

CFbsBitmap* CTRasterizer::CreateExtendedBitmapLC(const TRgb* aColours, TBool aHorizontalStripe, TSize aSizeInPixels)

	{	

	// Set up the buffer containing the three TRgb values and one TUint8 value that the rasterizer expects

	TInt dataSize = (sizeof(TRgb)*3) + sizeof(TUint8); // estimate the size to be written

	TUint8* data = new (ELeave)TUint8[dataSize];

	CleanupArrayDeletePushL(data);

	RMemWriteStream writeStream;

	writeStream.Open(data, dataSize);

	CleanupClosePushL(writeStream);		

	writeStream << aColours[0]; 		

	writeStream << aColours[1];		

	writeStream << aColours[2];

	TUint8 stripe = aHorizontalStripe; // EFalse is vertical stripes, ETrue is horizontal stripes

	writeStream << stripe;

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

	CleanupStack::PopAndDestroy(&writeStream);					

	CFbsBitmap* extendedBitmap = new(ELeave) CFbsBitmap;

	TInt err = extendedBitmap->CreateExtendedBitmap(aSizeInPixels, 

													iDisplayMode,

													KUidExampleExtendedBitmap,

													data,

													dataSize);

	CleanupStack::PopAndDestroy(data);

	CleanupStack::PushL(extendedBitmap);

	TESTL(err == KErrNone);

	return extendedBitmap;

	}