// 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;
	}