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

#include <bitdrawinterfaceid.h>

#include <bmalphablend.h>

#include <graphics/lookuptable.h>

#include <graphics/blendingalgorithms.h>

#include <graphics/gdi/gdiconsts.h>

#include "BMDRAW.H"

GLREF_C TInt ByteSize(TDisplayMode aDisplayMode,TInt aWidth);

TInt KNumberDisplayModes1 = sizeof (TestDisplayMode1) / sizeof (TestDisplayMode1[0]);

#if defined(SYMBIAN_USE_FAST_FADING)

const TBool KFastFading = ETrue;

#else

const TBool KFastFading = EFalse;

#endif

//these are for EColor16MAP testing

const TInt KInaccuracyLimit = 15;

const TInt KUserDispModes = 2;

//The array below is used in CTLowLevel::TestWriteRGBAlpha() to step through display modes,

//to ensure adequate test coverage.

const TDisplayMode UserDisplayModes[KUserDispModes] =

	{

	ENone,

	EColor16MAP,

	};

const TInt KMaskFill =3;

const TUint32 MaskFill[KMaskFill] =

	{

	0x00,

	0xff,

	0x3A,

	};

TInt DisplayMode2Index(TDisplayMode aMode)

	{

	TInt i;

	for(i=0;i<KNumDispModes;i++)

		{

		if(TestDisplayMode[i] == aMode)

			break;

		}

	return i;

	}

inline TInt AbsDiff(TInt aValue1, TInt aValue2)

	{

	return (aValue1 < aValue2) ? (aValue2-aValue1) : (aValue1-aValue2);

	}

//CTLowLevel implementation is shared between TLLD and TLLD2 test apps.

//The change was made because the original TLLD test app took too much time (over 0.5 hour)

//and usually was terminated with a TIMEOUT on LUBBOCK device.

CTLowLevel::CTLowLevel(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iDrawDevice(NULL),

	iBits(NULL),

	iBuf(NULL),

	iDispMode(ENone),

	iUserDispMode(ENone),

	iOrientation(CFbsDrawDevice::EOrientationNormal),

	iSize(TSize(0,0)),

	iLongWidth(0),

	iTestNo(0),

	iIteration(0),

	iReportIteration(0),

	iTotalReportIterations(0),

	iFuzzyMatch(EFalse),

	iBlendTestColors(ETrue),

	iUseFastFade(EFalse)

	{

	iColorConvertor[ENone] = &iNullConvertor;

	iColorConvertor[EGray2] = &iGray2Convertor;

	iColorConvertor[EGray4] = &iGray4Convertor;

	iColorConvertor[EGray16] = &iGray16Convertor;

	iColorConvertor[EGray256] = &iGray256Convertor;

	iColorConvertor[EColor16] = &iColor16Convertor;

	iColorConvertor[EColor256] = &iColor256Convertor;

	iColorConvertor[EColor4K] = &iColor4KConvertor;

	iColorConvertor[EColor64K] = &iColor64KConvertor;

	iColorConvertor[EColor16M] = &iColor16MConvertor;

	iColorConvertor[ERgb] = &iColor16MConvertor;

	iColorConvertor[EColor16MU] = &iColor16MUConvertor;

	iColorConvertor[EColor16MA] = &iColor16MAConvertor;

	iColorConvertor[EColor16MAP] = &iColor16MAPConvertor;

	iOrientation = CFbsDrawDevice::EOrientationNormal;

	iOrientationEnd = CFbsDrawDevice::EOrientationRotated90;

	}

CTLowLevel::~CTLowLevel()

	{

	Reset();

	}

void CTLowLevel::Reset()

	{

	delete iDrawDevice;

	iDrawDevice = NULL;

	delete iBits;

	iBits = NULL;

	delete iBuf;

	iBuf = NULL;

	iDispMode = ENone;

	iSize.SetSize(0,0);

	iLongWidth = 0;

	}

void CTLowLevel::RunTestCaseL(TInt aCurTestCase)

	{

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

	switch(aCurTestCase)

		{

	case 1:

		INFO_PRINTF1(_L("Bitmap device EGray2"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0004

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0004"));

		TestBitmapDraw(EGray2,TSize(128,100));

		break;

	case 2:

		INFO_PRINTF1(_L("Bitmap device EGray4"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0005

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0005"));

		TestBitmapDraw(EGray4,TSize(112,100));

		break;

	case 3:

		INFO_PRINTF1(_L("Bitmap device EGray16"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0006

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0006"));

		TestBitmapDraw(EGray16,TSize(104,100));

		break;

	case 4:

		INFO_PRINTF1(_L("Bitmap device EGray256"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0007

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0007"));

		TestBitmapDraw(EGray256,TSize(104,100));

		break;

	case 5:

		INFO_PRINTF1(_L("Bitmap device EColor16"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0008

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0008"));

		TestBitmapDraw(EColor16,TSize(104,100));

		break;

	case 6:

		INFO_PRINTF1(_L("Bitmap device EColor256"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0009

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0009"));

		TestBitmapDraw(EColor256,TSize(102,100));

		break;

	case 7:

		INFO_PRINTF1(_L("Bitmap device EColor4K"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0010

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0010"));

		TestBitmapDraw(EColor4K,TSize(100,100));

		break;

	case 8:

		INFO_PRINTF1(_L("Bitmap device EColor64K"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0011

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0011"));

		TestBitmapDraw(EColor64K,TSize(100,100));

		break;

	case 9:

		INFO_PRINTF1(_L("Bitmap device EColor16M"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0012

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0012"));

		TestBitmapDraw(EColor16M,TSize(102,100));

		break;

	case 10:

		INFO_PRINTF1(_L("Bitmap device EColor16MU"));

		iFuzzyMatch=ETrue;

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0013

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0013"));

		TestBitmapDraw(EColor16MU,TSize(102,100));

		iFuzzyMatch=EFalse;

		break;

	case 11:

		INFO_PRINTF1(_L("Bitmap device EColor16MA"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0014

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0014"));

		TestBitmapDraw(EColor16MA,TSize(102,100));

		break;

	case 12:

		INFO_PRINTF1(_L("Bitmap device EColor16MAP"));

		iFuzzyMatch=ETrue;

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0015

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0015"));

		TestBitmapDraw(EColor16MAP,TSize(102,100));

		iFuzzyMatch=EFalse;

		break;

	case 13:

		INFO_PRINTF1(_L("User display mode mapping"));

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0016

*/

		((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0016"));

		TestUserDisplayModeMapping();

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

		break;

	default:

		if(iOrientation <= iOrientationEnd)

			{

/**

	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0017

*/

			((CTLowLevelStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0017"));

			INFO_PRINTF2(_L("Screen device : %S"), &DisplayModeNames1[iCurScreenDeviceModeIndex]);

			TDisplayMode display = TestDisplayMode1[iCurScreenDeviceModeIndex++];

			TestScreenDrawL(display);

			if(iCurScreenDeviceModeIndex >= KNumberDisplayModes1)

				{

				iCurScreenDeviceModeIndex = 0;

				iOrientation ++;

				}

			}

		else

			{

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

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

			TestComplete();

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

			}

		break;

		}

	}

/* this function is used for likeness matching, using a fixed inaccuracy */

void CTLowLevel::CheckMatch(TUint32 aFirst,TUint32 aSecond)

	{

	TBool fail=EFalse;

	if (iFuzzyMatch==EFalse)

		fail|=Check(aFirst==aSecond);

	else

		{

		TUint8* val1=static_cast<TUint8*>(static_cast<void*>(&aFirst));

		TUint8* val2=static_cast<TUint8*>(static_cast<void*>(&aSecond));

		fail|=Check(AbsDiff(*val1,*val2)<KInaccuracyLimit);

		fail|=Check(AbsDiff(*(val1+1),*(val2+1))<KInaccuracyLimit);

		fail|=Check(AbsDiff(*(val1+2),*(val2+2))<KInaccuracyLimit);

		fail|=Check(AbsDiff(*(val1+3),*(val2+3))<KInaccuracyLimit);

		}

	if (fail)

		{

		_LIT(KLog,"The values 0x%x and 0x%x don't match, fuzzyMatch=%d (limit=%d)");

		INFO_PRINTF5(KLog,aFirst,aSecond,iFuzzyMatch,KInaccuracyLimit);

		}

	}

void CTLowLevel::TestScreenDrawL(TDisplayMode aDisplayMode)

	{

	TUint startTime=User::TickCount();

	Reset();

	iDispMode = aDisplayMode;

	INFO_PRINTF1(_L("\n"));

	INFO_PRINTF2(_L("Testing Screen driver \"%S\""), &(DisplayModeNames[::DisplayMode2Index(aDisplayMode)]));

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

	TInt address = NULL;

	TSize size(0,0);

	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress,address));

	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayXPixels,size.iWidth));

	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayYPixels,size.iHeight));

	ASSERT(size.iWidth > 0 && size.iHeight > 0 && address != NULL);

	TPckgBuf<TScreenInfoV01> info;

	info().iScreenAddressValid = ETrue;

	info().iScreenAddress = REINTERPRET_CAST(TAny*,address);

	info().iScreenSize = size;

	TRAPD(ret,iDrawDevice = CFbsDrawDevice::NewScreenDeviceL(info(),aDisplayMode));

	if (ret == KErrNotSupported)

		{

		INFO_PRINTF1(_L("Not supported\r\n"));

		return;

		}

	else if (ret != KErrNone)

		User::Panic(_L("Draw device create"),ret);

	iDrawDevice->InitScreen();

	iDrawDevice->SetDisplayMode(iDrawDevice);

	iDrawDevice->SetAutoUpdate(EFalse);

	TBool orientation[4];

	iDrawDevice->OrientationsAvailable(orientation);

	TBool orientationSupported = iDrawDevice->SetOrientation(CFbsDrawDevice::TOrientation(iOrientation));

	if (orientationSupported)

		{

		Check(orientation[iOrientation]);

		if (iOrientation & 1)

			iSize = TSize(size.iHeight,size.iWidth);

		else

			iSize = size;

		iLongWidth = LongWidth(iSize.iWidth,aDisplayMode);

		Test();

		}

	else

		{

		Check(!orientation[iOrientation]);

		INFO_PRINTF1(_L("Orientation not supported\r\n"));

		}

	INFO_PRINTF2(_L("Testing time=%d"), (User::TickCount() - startTime) * 100 / 64);

	}

void CTLowLevel::TestBitmapDraw(TDisplayMode aDisplayMode,const TSize& aSize)

	{

	TUint startTime=User::TickCount();

	Reset();

	iDispMode = aDisplayMode;

	iSize = aSize;

	iLongWidth = LongWidth(aSize.iWidth,aDisplayMode);

	TSize size(0,0);

	INFO_PRINTF1(KNullDesC);

	const TInt byteSize=ByteSize()*iSize.iHeight;

	_LIT(KNoMem,"Not enough memory for bitmap bits");

	iBits = new TUint8[byteSize];

	if(!iBits)

		{

		User::Panic(KNoMem,KErrNoMemory);

		}

	iBuf = new TUint32[byteSize];

	if(!iBuf)

		{

		User::Panic(KNoMem,KErrNoMemory);

		}

	TPckgBuf<TScreenInfoV01> info;

	info().iScreenSize = aSize;

	info().iScreenAddress = NULL;

	info().iScreenAddressValid = ETrue;

	TRAPD(ret, iDrawDevice = CFbsDrawDevice::NewBitmapDeviceL(info(), aDisplayMode, ByteSize() ));

	if (ret == KErrNotSupported)

		{

		INFO_PRINTF1(_L("Not supported\r\n"));

		return;

		}

	else if (ret != KErrNone)

	{

		User::Panic(_L("Draw device create"),ret);

	}

	iDrawDevice->SetAutoUpdate(EFalse);

	//Initialize the iDrowDevice object, if successful val=KErrNone

	TInt val=iDrawDevice->InitScreen();

	TEST(val==KErrNone);

	iDrawDevice->CFbsDrawDevice::SetBits(iBits);

	iDrawDevice->CFbsDrawDevice::ShadowBuffer(10,iBuf);

	iDrawDevice->CFbsDrawDevice::SetUserDisplayMode(iDispMode);

	iDrawDevice->SetDisplayMode(iDrawDevice);

	iDrawDevice->Update();

	iDrawDevice->SetUserDisplayMode(iDispMode);

	iDrawDevice->SetBits(iBits);

	Test();

	TBool orientation[4];

	iDrawDevice->OrientationsAvailable(orientation);

	TBool orientationSupported = iDrawDevice->SetOrientation(CFbsDrawDevice::TOrientation(iOrientation));

	if (orientationSupported)

		{

		Check(orientation[iOrientation]);

		if (iOrientation & 1)

			iSize = TSize(size.iHeight,size.iWidth);

		else

			iSize = size;

		iLongWidth = LongWidth(iSize.iWidth,aDisplayMode);

		}

	else

		{

		Check(!orientation[iOrientation]);

		INFO_PRINTF1(_L("Orientation not supported\r\n"));

		}

	INFO_PRINTF2(_L("Testing time=%d"), (User::TickCount() - startTime) * 100 / 64);

	}

TInt RgbComponent(TRgb aRgb, TInt aRgbIndex)

	{

	return(aRgbIndex==0?aRgb.Red():(aRgbIndex==1?aRgb.Green():aRgb.Blue()));

	}

TBool CheckNormalizedValue(TRgb aReadCol, TRgb aNormalizedCol1, TRgb aNormalizedCol2, TRgb aNormalizedCol3, TRgb aNormalizedCol4, TInt aRgbIndex)

	{

	const TInt KErrorMargin=5;

	TInt minCol=Min(RgbComponent(aNormalizedCol1,aRgbIndex),

					Min(RgbComponent(aNormalizedCol2,aRgbIndex),

						Min(RgbComponent(aNormalizedCol3,aRgbIndex),RgbComponent(aNormalizedCol4,aRgbIndex))))-KErrorMargin;

	TInt maxCol=Max(RgbComponent(aNormalizedCol1,aRgbIndex),

					Max(RgbComponent(aNormalizedCol2,aRgbIndex),

						Max(RgbComponent(aNormalizedCol3,aRgbIndex),RgbComponent(aNormalizedCol4,aRgbIndex))))+KErrorMargin;

	TInt readComponent=RgbComponent(aReadCol,aRgbIndex);

	return(readComponent>=minCol && readComponent<=maxCol);

	}

void CTLowLevel::CheckNormalizedRgb(TRgb aReadRgb, TRgb aCheckRgb, TDisplayMode aDevDisplayMode, TDisplayMode aUserDisplayMode, TBool aWriteRgbAlphaLine)

	{

	TRgb normalized1=aCheckRgb;

	Normalize(normalized1,aUserDisplayMode);

	if (aDevDisplayMode==EColor16MAP)

		{

		const TInt KNormalizeErrorMargin=3;

		TRgb normalizedPMA1=aCheckRgb;

// Allow error margin for blending errors before calculating value normalized to user display mode

		normalizedPMA1.SetRed(Min(0xFF,normalizedPMA1.Red()+KNormalizeErrorMargin));

		normalizedPMA1.SetGreen(Min(0xFF,normalizedPMA1.Green()+KNormalizeErrorMargin));

		normalizedPMA1.SetBlue(Min(0xFF,normalizedPMA1.Blue()+KNormalizeErrorMargin));

//

		Normalize(normalizedPMA1,aUserDisplayMode);

		TRgb normalizedPMA3=normalizedPMA1;

		normalizedPMA1=TRgb::Color16MAP(normalizedPMA1.Color16MAP());

		TRgb normalizedPMA2=aCheckRgb;

		normalizedPMA2=TRgb::Color16MAP(normalizedPMA2.Color16MAP());

		normalizedPMA2.SetRed(Max(0,normalizedPMA2.Red()-KNormalizeErrorMargin));

		normalizedPMA2.SetGreen(Max(0,normalizedPMA2.Green()-KNormalizeErrorMargin));

		normalizedPMA2.SetBlue(Max(0,normalizedPMA2.Blue()-KNormalizeErrorMargin));

		Normalize(normalizedPMA2,aUserDisplayMode);

		TEST(CheckNormalizedValue(aReadRgb,normalizedPMA1,normalizedPMA2,normalizedPMA3,normalized1,0) &&

				CheckNormalizedValue(aReadRgb,normalizedPMA1,normalizedPMA2,normalizedPMA3,normalized1,1) &&

				CheckNormalizedValue(aReadRgb,normalizedPMA1,normalizedPMA2,normalizedPMA3,normalized1,2));

		}

	else

		{

		if (aDevDisplayMode==EColor64K && aWriteRgbAlphaLine)

			{

	// In EColor64K the WriteRgbAlphaLine code maps to native display mode first, before mapping to

	// user mode then back again to device display mode. So use normalized2 to check for that case

			TRgb normalized2=aCheckRgb;

			Normalize(normalized2,aDevDisplayMode);

			Normalize(normalized2,aUserDisplayMode);

			Normalize(normalized2,aDevDisplayMode);

			TEST(aReadRgb.Color16MU()==normalized2.Color16MU());

			}

		else

			{

			Normalize(normalized1,aDevDisplayMode);

			TEST(aReadRgb.Color16MU()==normalized1.Color16MU());

			}

		}

	}

void CTLowLevel::PrepareDestPixel(TDisplayMode aDevDisplayMode, TRgb& aRgb, TInt aDstAlpha)

	{

	CGraphicsContext::TDrawMode drawMode;

	if (aDevDisplayMode==EColor16MAP)

		{

		aRgb.SetAlpha(aDstAlpha);

		drawMode=CGraphicsContext::EDrawModeWriteAlpha;

		}

	else

		{

		aRgb.SetAlpha(0xFF);

		drawMode=CGraphicsContext::EDrawModePEN;

		}

	iDrawDevice->WriteRgbMulti(0,0,1,1,aRgb,drawMode);

	}

void CTLowLevel::CheckMappedRgb(TDisplayMode aDevDisplayMode, TDisplayMode aUserDisplayMode, TRgb aRgb)

	{

	const TInt KMaxAlphaModes=5;

	TInt alphaModeValues[KMaxAlphaModes]={0xFF,0xC0,0x80,0x40,0};

	TInt dstAlphaModeCount=aDevDisplayMode==EColor16MAP?KMaxAlphaModes:1;

	for(TInt dstAlphaMode=0;dstAlphaMode<dstAlphaModeCount;dstAlphaMode++)

		{

		TInt dstAlpha=alphaModeValues[dstAlphaMode];

		for(TInt alphaMode=0;alphaMode<KMaxAlphaModes;alphaMode++)

			{

			TInt alpha=alphaModeValues[alphaMode];

			if ((aUserDisplayMode==EColor16 || aUserDisplayMode==EColor256) && (alpha!=0xFF || dstAlpha!=0xFF))

				continue;	// Mapping to EColor16 or EColor256 with fuzzy blends and PMA losses impossible to check for accurately

			PrepareDestPixel(aDevDisplayMode,aRgb,dstAlpha);

			aRgb.SetAlpha(alpha);

			iDrawDevice->WriteRgb(0,0,aRgb,CGraphicsContext::EDrawModePEN);

			TRgb readRgb=iDrawDevice->ReadPixel(0,0);

			CheckNormalizedRgb(readRgb,aRgb,aDevDisplayMode,aUserDisplayMode,EFalse);

//

			PrepareDestPixel(aDevDisplayMode,aRgb,dstAlpha);

			iDrawDevice->WriteRgbMulti(0,0,1,1,aRgb,CGraphicsContext::EDrawModePEN);

			readRgb=iDrawDevice->ReadPixel(0,0);

			CheckNormalizedRgb(readRgb,aRgb,aDevDisplayMode,aUserDisplayMode,EFalse);

//

			PrepareDestPixel(aDevDisplayMode,aRgb,dstAlpha);