// Copyright (c) 2004-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 <e32math.h>

#include <hal.h>

#include <bitdraw.h>

#include <bitdrawscaling.h>

#include <bitdraworigin.h>

#include <bitdrawinterfaceid.h>

#include <graphics/gdi/gdiconsts.h>

#include "TScdvScaling.h"

//Test line properties: 

//[iX, iY] - the starting point of the line

//iLength - line length

struct TLineProps

	{

	TInt iX;

	TInt iY;

	TInt iLength;

	};

//

//Constants

//

//This structure defines [TDrawMode <-> clear screen color value] relation

//When the test uses KDrawMode[i].iDrawMode, then the screen will be cleared using

//KDrawMode[i].iClearColorVal value

struct TDrawModeProps

	{

	CGraphicsContext::TDrawMode iDrawMode;

	// keep the color value 8-bit in both EColor256 and EColor64K, special care need

	// to be done when filling the buffer, e.g color=0x55 

	// in EColor256 clearing means filling 0x55 0x55 0x55 etc, but

	// in EColor64K it has to be 0x0055 0x0055 0x0055 etc

	TUint8 iClearColorVal;

	};

const TDrawModeProps KDrawMode[] = 

	{

		{CGraphicsContext::EDrawModePEN,		0xFF},

		{CGraphicsContext::EDrawModeAND,		0x37},

		{CGraphicsContext::EDrawModeXOR,		0x38},

		{CGraphicsContext::EDrawModeOR,			0xB1},

		{CGraphicsContext::EDrawModeNOTSCREEN,	0xC0},

		{CGraphicsContext::EDrawModeNOTPEN,		0x1D}

	};

const TInt KDrawModesCnt = sizeof(KDrawMode) / sizeof(KDrawMode[0]);

//Shadow/Fade modes

const CFbsDrawDevice::TShadowMode KShadowMode[] = 

	{

	CFbsDrawDevice::EShadow,

	CFbsDrawDevice::EFade,

	CFbsDrawDevice::EShadowFade

	};

const TInt KShadowModesCnt = sizeof(KShadowMode) / sizeof(KShadowMode[0]);

//Test pixel color value

const TUint8 KTestColorVal = 0x55;

//All possible orientations

const CFbsDrawDevice::TOrientation KOrientation[] = 

	{

	CFbsDrawDevice::EOrientationNormal,

	CFbsDrawDevice::EOrientationRotated90,

	CFbsDrawDevice::EOrientationRotated180,

	CFbsDrawDevice::EOrientationRotated270

	};

const TInt KOrientationsCnt = sizeof(KOrientation) / sizeof(KOrientation[0]);

//Width and Height of legacy application screen

const TInt KLegacyAppSizeWidth = 60;

const TInt KLegacyAppSizeHeight = 40;

//Scaling factors: X and Y

const TInt KScalingFactorX = 3;

const TInt KScalingFactorY = 2;

const TInt KMaxScalingFactor = 3;		//Max of previous 2 values

//

//Declarations

//

GLDEF_C TInt ByteSize(TDisplayMode aDisplayMode,TInt aWidth)

	{

	TInt wordSize=aWidth;

	switch(aDisplayMode)

		{

		case EGray2:

			wordSize = (wordSize + 31) / 32;

			break;

		case EGray4:

			wordSize = (wordSize + 15) / 16;

			break;

		case EGray16:

		case EColor16:

			wordSize = (wordSize + 7) / 8;

			break;

		case EGray256:

		case EColor256:

			wordSize = (wordSize + 3) / 4;

			break;

		case EColor4K:

		case EColor64K:

			wordSize = (wordSize + 1) / 2;

			break;

		case EColor16M:

			wordSize = ((wordSize + 3) / 4) * 3;

			break;

		case EColor16MU:

		case EColor16MA:

			//Doesn't need changing

			break;

		default:

			break;

		};

	return wordSize * 4;

	}

static inline TInt ByteSize(TDisplayMode aDisplayMode, TSize aSize)

	{

	return ByteSize(aDisplayMode,aSize.iWidth) * aSize.iHeight;

	}

template <class TPixelType> 

inline void MemFill(TPixelType* aBuffer, TInt aSize, TPixelType aValue)

	{

	TPixelType* p = aBuffer;

	TInt i = 0;

	while (i++<aSize)

		*p++ = aValue;

	}

//Generic test class for both Color256 and Color64K

template <class TPixelType> class CTScaling: public CTGraphicsBase

	{

public:

	CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode);

	~CTScaling();

	void RunTestCaseL(TInt aCurTestCase);

private:

	void ConstructL();

	void CreateScreenDeviceL();

	void SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY);

	void CheckLine(const TLineProps& aLineProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);

	void CheckWriteRgbMulti(const TRect& aRcProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);

	void CheckRgbAlphaLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);

	void CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue);

	void WriteLine();

	void ClearScreen(const TDrawModeProps& aDrawModeProps);

	void SetTestData();

	void CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal);

	void CheckWriteBinary(const TPoint& aPt, const TPoint& aOrg, TPixelType aClearColorValue, TInt aLength, TInt aHeight);

	void CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);

	void WriteRgb();

	void WriteRgbMulti();

	void WriteRgbAlphaLine();

	void WriteBinary();

	void WriteBinaryLineVertical();

	void WriteBinaryLine();

	void WriteRgbAlphaMulti();

	void ShadowArea();

	void WriteRgbAlphaLine2();

	void TestScalingSettingsInterface();

	void PerformanceTest();

private:

	//Test data array

	TPixelType iTestData[KLegacyAppSizeWidth];

	//The device used in the tests

	CFbsDrawDevice* iDrawDevice;

	//Width and Height of the screen

	TSize iPhysSize;

	//The test allocates block of memory for a screen with PhysSize size 

	//mode. iBits will point to the allocated memory block.

	TPixelType* iBits;

	TDisplayMode iDisplayMode;

	//The scaling interface

	MScalingSettings* iScalingSettings;

	//The origin interface

	MDrawDeviceOrigin* iOriginInterface;

	TInt iCurOrientation;

	TInt iScalingFactorX;

	TInt iScalingFactorY;

	};

typedef CTScaling<TUint8> CTestNone;

typedef CTScaling<TUint8> CTestColor256;

typedef CTScaling<TUint16> CTestColor64K;

//

//Test code

//

/*template <class TPixelType>

CTScaling<TPixelType>* CTScaling<TPixelType>::NewL(TDisplayMode aDisplayMode)	

	{

	CTScaling<TPixelType>* self = new (ELeave) CTScaling<TPixelType>;

	CleanupStack::PushL(self);

	self->ConstructL(aDisplayMode);

	CleanupStack::Pop(self);

	return self;

	}

*/	

template <class TPixelType>

CTScaling<TPixelType>::CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode) :

				CTGraphicsBase(aTest),

				iDisplayMode(aDisplayMode)

	{

	INFO_PRINTF1(_L("Scaling tests"));

	}

template <class TPixelType>

void CTScaling<TPixelType>::ConstructL()	

	{

	CreateScreenDeviceL();

	}

template <class TPixelType>

CTScaling<TPixelType>::~CTScaling()

	{

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

	delete[] iBits;

	delete iDrawDevice;	

	}

template <class TPixelType>

void CTScaling<TPixelType>::SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY)

	{

	TEST(iDrawDevice != NULL);	

	if(!iScalingSettings)

		{

		TInt err = iDrawDevice->GetInterface(KScalingSettingsInterfaceID, 

											  reinterpret_cast <TAny*&> (iScalingSettings));

		TEST2(err, KErrNone);

		}

	TEST(iScalingSettings != NULL);

	TInt err = iScalingSettings->Set(aFx, aFy, aDivX, aDivY);

	TEST2(err, KErrNone);

	if(!iOriginInterface)

		{

		TInt err = iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 

											  reinterpret_cast <TAny*&> (iOriginInterface));

		TEST2(err, KErrNone);

		}

	TEST(iOriginInterface != NULL);

	err = iOriginInterface->Set(aOrigin);

	TEST2(err, KErrNone);

	}

//Clears the screen initializing each screen pixel with aDrawModeProps.iClearColorVal value

template <class TPixelType>

void CTScaling<TPixelType>::ClearScreen(const TDrawModeProps& aDrawModeProps)

	{

	::MemFill(iBits, ::ByteSize(EColor256, iPhysSize), TPixelType(aDrawModeProps.iClearColorVal));

	}

//Initializes iTestData array with KTestColorVal value

template <class TPixelType>

void CTScaling<TPixelType>::SetTestData()

	{

	::MemFill(iTestData, KLegacyAppSizeWidth, TPixelType(KTestColorVal));

	}

template <class TPixelType>

void CTScaling<TPixelType>::CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal)

	{

	const TInt KByteSize = ::ByteSize(EColor256, iPhysSize);

	TInt changedPixelsCnt = 0;

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

		{

		if(iBits[ii]!=aClearColorVal)

			{

			++changedPixelsCnt;

			}

		}

	TEST(changedPixelsCnt == aChangedPixelsCnt);

	if (changedPixelsCnt!=aChangedPixelsCnt)

		{

		_LIT(KLog,"Wrong number of changed pixels, expected=%d, actual=%d, color=0x%x");

		INFO_PRINTF4(KLog,aChangedPixelsCnt,changedPixelsCnt,aClearColorVal);

		}

	}

//Checks a set of horisontal lines , which starting point is 

//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]

//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate

//is incremented by 1.

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.

template <class TPixelType>

void CTScaling<TPixelType>::CheckLine(const TLineProps& aLineProps, 

					  const TPoint& aOrg, 

					  const TDrawModeProps& aDrawModeProps, 

					  TPixelType aClearColorValue)

	{

	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];

	TInt ii;

	for(ii=0;ii<iScalingFactorY;++ii)

		{

		Mem::Fill(data, sizeof(data), 0x00);

		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 

							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 

							   aLineProps.iLength * iScalingFactorX, 

							   data, 

							   iDisplayMode);

		const TInt length=aLineProps.iLength*iScalingFactorX;

		TInt firstErr=length;

		TInt numErrs=0;

		for(TInt jj=0;jj<length;++jj)

			{

			//TEST(data[jj]!=aClearColorValue);

			if (data[jj]==aClearColorValue)

				{

				++numErrs;

				if (jj<firstErr)

					firstErr=jj;

				}

			}

		TEST(numErrs==0);

		if (numErrs>0)

			{

			_LIT(KLog,"Line %d (of %d) of length %d has %d errors first one at %d,  ClearCol=0x%x");

			INFO_PRINTF7(KLog,ii,iScalingFactorY,length,numErrs,firstErr,aClearColorValue);

			}

		}

	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;

	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);

	}

//Checks the rectangle filled using CFbsScreenDevice::WriteRgbMulti. 

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.

template <class TPixelType>

void CTScaling<TPixelType>::CheckWriteRgbMulti(const TRect& aRcProps, 

							   const TPoint& aOrg, 

							   const TDrawModeProps& aDrawModeProps, 

							   TPixelType aClearColorValue)

	{

	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];

	TInt ii;

	TInt xx = aOrg.iX + aRcProps.iTl.iX * iScalingFactorX;

	TInt yy = aOrg.iY + aRcProps.iTl.iY * iScalingFactorY;

	for(ii=0;ii<(iScalingFactorY * aRcProps.Height());++ii)

		{

		Mem::Fill(data, sizeof(data), 0x00);

		iDrawDevice->ReadLine(xx, yy+ii, aRcProps.Width()*iScalingFactorX, data, iDisplayMode);

		const TInt width=aRcProps.Width()*iScalingFactorX;

		TInt firstErr=width;

		TInt numErrs=0;

		for(TInt jj=0;jj<width;++jj)

			{

			//TEST(data[jj]!=aClearColorValue);

			if (data[jj]==aClearColorValue)

				{

				++numErrs;

				if (jj<firstErr)

					firstErr=jj;

				}

			}

		TEST(numErrs==0);

		if (numErrs>0)

			{

			_LIT(KLog,"Line %d of width %d has %d errors first one at %d,  ClearCol=0x%x");

			INFO_PRINTF6(KLog,ii,width,numErrs,firstErr,aClearColorValue);

			}

		}

	TInt changedPixelsCnt = iScalingFactorY * aRcProps.Width() * aRcProps.Height() * iScalingFactorX;

	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);

	}

//Checks a set of horisontal lines , which starting point is 

//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]

//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate

//is incremented by 1.

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.

template <class TPixelType>

void CTScaling<TPixelType>::CheckRgbAlphaLine(const TLineProps& aLineProps, 

							  const TPoint& aOrg, 

							  TPixelType aClearColorValue)

	{

	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];

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

		{

		Mem::Fill(data, sizeof(data), 0x00);

		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 

							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 

							   aLineProps.iLength * iScalingFactorX, 

							   data, 

							   iDisplayMode);

		const TInt length=aLineProps.iLength*iScalingFactorX;

		TInt firstErr=length;

		TInt numErrs=0;

		for(TInt jj=0;jj<(aLineProps.iLength * iScalingFactorX);++jj)

			{

			//TEST(data[jj]!=aClearColorValue);

			if (data[jj]==aClearColorValue)

				{

				++numErrs;

				if (jj<firstErr)

					firstErr=jj;

				}

			}

		TEST(numErrs==0);

		if (numErrs>0)

			{

			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");

			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);

			}

		}

	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;

	CheckChangedPixels(changedPixelsCnt, aClearColorValue);

	}

//Checks the rectangle filled using CFbsScreenDevice::WriteBinary. 

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.

template <class TPixelType>

void CTScaling<TPixelType>::CheckWriteBinary(const TPoint& aPt, 

							 const TPoint& aOrg, 

							 TPixelType aClearColorValue, 

							 TInt aLength, TInt aHeight)

	{

	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];

	TInt ii;

	TInt xx = aOrg.iX + aPt.iX * iScalingFactorX;

	TInt yy = aOrg.iY + aPt.iY * iScalingFactorY;

	for(ii=0;ii<(iScalingFactorY * aHeight);++ii)

		{

		Mem::Fill(data, sizeof(data), 0x00);

		iDrawDevice->ReadLine(xx, yy + ii, aLength * iScalingFactorX, data, iDisplayMode);

		const TInt length=aLength*iScalingFactorX;

		TInt firstErr=length;

		TInt numErrs=0;

		for(TInt jj=0;jj<length;++jj)

			{

			//TEST(data[jj] != aClearColorValue);

			if (data[jj]==aClearColorValue)

				{

				++numErrs;

				if (jj<firstErr)

					firstErr=jj;

				}

			}

		TEST(numErrs==0);

		if (numErrs>0)

			{

			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");

			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);

			}

		}

	TInt changedPixelsCnt = iScalingFactorY * aLength * aHeight * iScalingFactorX;

	CheckChangedPixels(changedPixelsCnt, aClearColorValue);

	}

//Checks a set of vertical lines , which starting point is 

//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]

//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate

//is incremented by 1.

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.

template <class TPixelType>

void CTScaling<TPixelType>::CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue)

	{

	TInt x = aOrg.iX + aLineProps.iX * iScalingFactorX;

	TInt y = aOrg.iY + aLineProps.iY * iScalingFactorY;

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

		{

		for(TInt j=0;j<(aLineProps.iLength * iScalingFactorY);++j)

			{

			TRgb val = iDrawDevice->ReadPixel(x + i, y + j);				   

			switch (iDisplayMode)

				{

				case EColor64K:

				TEST(val.Color64K() != aClearColorValue);

				break;

				case EColor256:

				TEST(val.Color256() != aClearColorValue);

				break;

				default:

				TEST(EFalse);

				}

			}

		}

	TInt changedPixelsCnt = iScalingFactorX * aLineProps.iLength * iScalingFactorY;

	CheckChangedPixels(changedPixelsCnt, aClearColorValue);

	}

//Checks the rectangle filled using CFbsScreenDevice::ShadowArea

//The screen lines pixel values are tested against aClearColorValue value.

//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.

template <class TPixelType>

void CTScaling<TPixelType>::CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue)

	{

	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];

	TInt i;

	TInt x = aOrg.iX + aRc.iTl.iX * iScalingFactorX;

	TInt y = aOrg.iY + aRc.iTl.iY * iScalingFactorY;

	for(i=0;i<(iScalingFactorY * aRc.Height());++i)

		{

		Mem::Fill(data, sizeof(data), 0x00);

		iDrawDevice->ReadLine(x, y + i, aRc.Width() * iScalingFactorX, data, iDisplayMode);

		for(TInt j=0;j<(aRc.Width() * iScalingFactorX);++j)

			{

			TEST(data[j] != aClearColorValue);

			}

		}

	TInt changedPixelsCnt = iScalingFactorY * aRc.Width() * aRc.Height() * iScalingFactorX;

	CheckChangedPixels(changedPixelsCnt, aClearColorValue);

	}

//CFbsScreenDevice::WriteLine() and CFbsScreenDevice::ReadLine() test.

//(Set of test lines) X (Set of origins) X (Set of drawing modes) number of test cases.

template <class TPixelType>

void CTScaling<TPixelType>::WriteLine()

	{

	INFO_PRINTF1(_L("CFbsDrawDevice::WriteLine"));