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

#include "tdirectgdieglcontent_client.h"

#include "tdirectgdieglcontent_clientserver.h"

#include <graphics/sgimage_sw.h>

#include <graphics/directgdiimagetarget.h>

#include <graphics/directgdidriver.h>

#include <e32math.h>

/**

A utility class used by the templated function CleanupResetAndDestroyPushL() to create

a TCleanupItem item that will perform a ResetAndDestroy() operation on the class T type object.

Used for cleanup RPointerArray objects.

*/

template <class T> class CleanupResetAndDestroy

	{

public:

	static void PushL(T &aRef)

		{

		CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &aRef));

		};

private:

	static void ResetAndDestroy(TAny *aPtr)

		{

		(STATIC_CAST(T *, aPtr))->ResetAndDestroy();

		};

	};

/**

Helper function for pushing CleanupResetAndDestroy object onto CleanupStack.

*/

template <class T> void CleanupResetAndDestroyPushL(T &aRef)

	{

	CleanupResetAndDestroy<T>::PushL(aRef);

	};

CTInterleaving::CTInterleaving()

	{

	SetTestStepName(KTDirectGdiInterleavingStep);

	}

CTInterleaving::~CTInterleaving()

	{

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-INTERLEAVING-0001

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9188 

	REQ9189 

	REQ9196 

	REQ9213 

	REQ9227 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Test synchronized drawing with egl content

@SYMTestPriority	

	High

@SYMTestStatus 		

	Implemented

@SYMTestActions 	Establish connection to EglContentServer.

					Render frame synchronized with EGL content in following way:

					 - Draw multicolor checkboard to gdi target

					 - Get EGL content sgimage id from EglContentServer in synchronous mode.

					 - Using obtained id create DirectGdi image source and draw it on target with  DrawResource() method.

					 - Draw semi-transparent vertical bars to gdi target.

					Repeat above steps a few times. 

@SYMTestExpectedResults 

	Valid set of bitmaps should be created.

    These bitmaps should be the same as a reference bitmaps.

*/

void CTInterleaving::TestSyncL()

	{

	_LIT(KTestName, "Interleaving-Sync"); //test case name

	// start EGL content server

	REglContentSession eglContentSession;

	TESTNOERRORL(eglContentSession.Connect());

	CleanupClosePushL(eglContentSession);

	// render few frames synchronized with egl content

	for(TInt frame=0; frame<10; frame++)

		{

		ResetGc();

		DrawDirectGdiCheckboardToTarget();

		TESTNOERRORL(iGc->GetError());

		// get egl content sgimage id

		TSgDrawableId imageId;

		TESTNOERRORL(eglContentSession.GetSyncImage(imageId));

		DrawImageToTargetL(imageId);

		TESTNOERRORL(iGc->GetError());

		DrawDirectGdiBarsToTarget();

		TESTNOERRORL(iGc->GetError());

		// save target

		TBuf<30> testName;

		testName.Append(KTestName);

		testName.AppendNum(frame);

		TESTNOERRORL(CTDirectGdiStepBase::WriteTargetOutput(iTestParams, testName));

		}

	CleanupStack::PopAndDestroy(&eglContentSession);

	}

/**

@SYMTestCaseID  	

	GRAPHICS-DIRECTGDI-INTERLEAVING-0002

@SYMPREQ 			

	PREQ39

@SYMREQ

	REQ9188 

	REQ9189 

	REQ9196 

	REQ9213 

	REQ9227 

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc	

	Test asynchronous drawing of egl content

@SYMTestPriority	

	High

@SYMTestStatus 		

	Implemented

@SYMTestActions 	Establish connection to EglContentServer.

					Render frame in following way:

					 - Draw multicolor checkboard to gdi target

					 - Get EGL content sgimage id and frame number from EglContentServer in asynchronous mode. 

					 - Using obtained id create DirectGdi image source and draw it on target with  DrawResource() method.

					 - Draw semi-transparent vertical bars to gdi target.

					 - Find currently created target bitmap in stored bitmaps array. 

					   Use frame number obtained from EglContentServer as an array index. 

					   If it not exists in this array, store it. Otherwise  compare it with stored one pixel by pixel. 

					   Test fails when this comparison fails.

					EglContentServer produce ten different frames, 

					so for proper testing repeat above steps at least fifty times.

@SYMTestExpectedResults Valid set of bitmaps should be created.

                        These bitmaps should be the same as a reference bitmaps.

*/

void CTInterleaving::TestAsyncL(TBool aDebug)

	{

	_LIT(KTestName, "Interleaving-Async"); //test case name

	// start EGL content server

	REglContentSession eglContentSession;

	TESTNOERRORL(eglContentSession.Connect());

	CleanupClosePushL(eglContentSession);

	// prepare array to store frames

	RPointerArray<CFbsBitmap> storedBitmaps(KEglContentAsyncMaxFrames);

	CleanupResetAndDestroyPushL(storedBitmaps);

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

		{

		storedBitmaps.AppendL(NULL);

		}

	// prepare line buffers for bitmap comparision

	TInt bufSize = iGdiTarget->SizeInPixels().iWidth*4; // buffer is 32-bit BGRA

	HBufC8* lineBuf1 = HBufC8::NewLC(bufSize);

	HBufC8* lineBuf2 = HBufC8::NewLC(bufSize);

	// With the EGL context continuously being generated, we cannot guarantee that

	// all the frames will be retrieved.

	// However, in theory, the probability of picking each frame can be

	// approximated to a uniform discrete distribution.

	// So we can work out how many times we need to pick a frame to get all

	// the unique frames 99% of the time.

	// This works out to be approximately 65 times for 10 unique frames.

	const TInt KNumTriesToGetAllFrames = 65;

	if(!aDebug)

		{

		WARN_PRINTF1(_L("Note: Due to the nature of the test, it may be possible that not all the frames are captured"));

		}

	TInt64 seed = (TInt64)User::FastCounter();

	// render few frames asynchronous from egl content

	for(TInt frame=0; frame<KNumTriesToGetAllFrames; frame++)

		{

		ResetGc();

		DrawDirectGdiCheckboardToTarget();

		TESTNOERRORL(iGc->GetError());

		// get egl content sgimage id

		TSgDrawableId imageId;

		TInt fnum;

		if(!aDebug)

			{

			TESTNOERRORL(eglContentSession.GetAsyncImage(imageId, fnum));

			// Due to the nature of the asynchronous test, where the frames are

			// continuously being rendered and we can only dip in and pick the last

			// rendered frame, it cannot be guaranteed that all the unique frames will

			// be retrieved.  This could be due to this loop and the EGL content

			// generation running in harmony.  To try to overcome this, introduce

			// a random delay between 0 and 3 frames (0 seconds to 100 milliseconds - 

			// EGL content generated at 30fps).

			TInt delay = Math::Rand(seed)%100000;

			User::After(delay);

			}

		else

			{

			TESTNOERRORL(eglContentSession.GetAsyncImageDebug(imageId, fnum));

			}

		DrawImageToTargetL(imageId);

		TESTNOERRORL(iGc->GetError());

		DrawDirectGdiBarsToTarget();

		TESTNOERRORL(iGc->GetError());

		iGdiTarget->Finish();

		CFbsBitmap* targetBitmap = iGdiTarget->GetTargetFbsBitmapL();

		if(storedBitmaps[fnum] != NULL)

			{

			// compare with previously stored bitmap

			TUint32 cmpMask; // BGRA mask

			if((iTestParams.iTargetPixelFormat == EUidPixelFormatXRGB_8888) ||

				(iTestParams.iTargetPixelFormat == EUidPixelFormatXRGB_4444))

				{

				cmpMask = 0xffffff00; // exclude unused pixel part from comparision

				}

			else

				{

				cmpMask = 0xffffffff;

				}

			TInt width = targetBitmap->SizeInPixels().iWidth;

			TInt height = targetBitmap->SizeInPixels().iHeight;

			TPtr8 linePtr1(lineBuf1->Des());

			TPtr8 linePtr2(lineBuf2->Des());

			TBool pass = ETrue;

			// compare pixel by pixel

			for(TInt line=0; line<height; line++)

				{

				targetBitmap->GetScanLine(linePtr1, TPoint(0, line), width, EColor16MA);

				storedBitmaps[fnum]->GetScanLine(linePtr2, TPoint(0, line), width, EColor16MA);

				const TUint32* pPtr1 = (const TUint32*)linePtr1.Ptr();

				const TUint32* pPtr2 = (const TUint32*)linePtr2.Ptr();

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

					{

					if((pPtr1[x] & cmpMask) != (pPtr2[x] & cmpMask))

						{

						pass = EFalse;

						break; // break inner loop

						}

					}

				if(!pass)

					break; // break outer loop if test failed in inner loop

				}

			if(!pass)

				{

				INFO_PRINTF2(_L("Frame %d not equal to previous one"), fnum);

				TEST(pass);

				}

			}

		else

			{

			// copy and store target bitmap

			storedBitmaps[fnum] = new(ELeave) CFbsBitmap();

			TESTL(storedBitmaps[fnum]->Create(targetBitmap->SizeInPixels(), targetBitmap->DisplayMode()) == KErrNone);

		    Mem::Copy((TUint8*)storedBitmaps[fnum]->DataAddress(),

		    		(TUint8*)targetBitmap->DataAddress(),

		    		storedBitmaps[fnum]->DataStride()*storedBitmaps[fnum]->SizeInPixels().iHeight);

			// save target

			TBuf<40> testName;

			testName.Append(KTestName);

			if(aDebug)

				{

				_LIT(KDebug, "Debug");

				testName.Append(KDebug);

				}

			testName.AppendNum(fnum);

			TESTNOERRORL(CTDirectGdiStepBase::WriteTargetOutput(iTestParams, testName));

			}

		}

	CleanupStack::PopAndDestroy(4, &eglContentSession);

	}

/**

Draw multicolor checkboard to gdi target.

*/

void CTInterleaving::DrawDirectGdiCheckboardToTarget()

	{

	const TInt width = iGdiTarget->SizeInPixels().iWidth;

	const TInt height = iGdiTarget->SizeInPixels().iHeight;

	const TInt rwidth = 13;

	const TInt rheight = 13;

	iGc->SetPenStyle(DirectGdi::ENullPen);

	iGc->SetBrushStyle(DirectGdi::ESolidBrush);

	TInt color = 0;

	for(TInt y=0; y<height; y+=rheight)

		{

		for(TInt x=0; x<width; x+=rwidth)

			{

			iGc->SetBrushColor(KColor16Table[color%16]);

			color++;

			iGc->DrawRect(TRect(TPoint(x, y), TSize(rwidth, rheight)));

			}

		}

	}

/**

Draw semi-transparent vertical bars to gdi target.

*/

void CTInterleaving::DrawDirectGdiBarsToTarget()

	{

	TPoint pos(40, 40);

	TSize size(iGdiTarget->SizeInPixels());

	size -= TSize(80, 80);

	TSize barSize(size.iWidth/10, size.iHeight);

	iGc->SetPenStyle(DirectGdi::ENullPen);

	iGc->SetBrushStyle(DirectGdi::ESolidBrush);

	for(TInt i=0; i<size.iWidth; i+=barSize.iWidth)

		{

		TRgb color(255, 0, 0, 25*i/barSize.iWidth);

		iGc->SetBrushColor(color);

		iGc->DrawRect(TRect(pos+TPoint(i, 0), barSize));

		}

	}

/**

Draw four rotated EGL images to gdi target.

*/

void CTInterleaving::DrawImageToTargetL(TSgDrawableId aImageId)

	{

	// prepare sgimage from id

	RSgImage image;	

	TESTNOERRORL(image.Open(aImageId));

	CleanupClosePushL(image);

	TESTNOERRORL(CDirectGdiDriver::Open());

	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

	TESTL(dgdiDriver != NULL);	

	CleanupClosePushL(*dgdiDriver);	

	// prepare DirectGdi image source

	RDirectGdiDrawableSource source(*dgdiDriver);

	TESTNOERRORL(source.Create(image));

	CleanupClosePushL(source);

	// draw sgimage resorce on gdi target

	TDrawableSourceAndEquivRotatedBmps imageSource;

	imageSource.iDrawableSrc = &source;

	TPoint pos(20, 20);

	TSize size(iGdiTarget->SizeInPixels());

	size -= TSize(40, 40);

	size.iWidth /= 2;

	size.iHeight /= 2;

	TSize size2(size);

	size2 -= TSize(10, 10);

	iGc->DrawResource(TRect(pos, size2), imageSource);

	TESTNOERRORL(iGc->GetError());

	iGc->DrawResource(TRect(pos+TPoint(size.iWidth, 0), size2), imageSource, DirectGdi::EGraphicsRotation90);

	TESTNOERRORL(iGc->GetError());

	iGc->DrawResource(TRect(pos+TPoint(0, size.iHeight), size2), imageSource, DirectGdi::EGraphicsRotation180);

	TESTNOERRORL(iGc->GetError());

	iGc->DrawResource(TRect(pos+size.AsPoint(), size2), imageSource, DirectGdi::EGraphicsRotation270);

	TESTNOERRORL(iGc->GetError());

	CleanupStack::PopAndDestroy(3, &image);

	}

/**

Override of base class virtual

@leave Gets system wide error code

@return - TVerdict code

*/

TVerdict CTInterleaving::doTestStepPreambleL()

	{

	CTDirectGdiStepBase::doTestStepPreambleL();	

	return TestStepResult();

	}

/** 

Override of base class pure virtual

Our implementation only gets called if the base class doTestStepPreambleL() did

not leave. That being the case, the current test result value will be EPass.

@leave Gets system wide error code

@return TVerdict code

*/	

TVerdict CTInterleaving::doTestStepL()

	{

	// Test for each target pixel format

	for(TInt targetPixelFormatIndex = iTargetPixelFormatArray.Count() - 1; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)

		{

		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];

		SetTargetL(iTestParams.iTargetPixelFormat, EOneContextOneTarget, TSize(400, 400));

		RunTestsL();

		}

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

/**

Override of base class virtual

@leave Gets system wide error code

@return - TVerdict code

*/

TVerdict CTInterleaving::doTestStepPostambleL()

	{

	CTDirectGdiStepBase::doTestStepPostambleL();

	return TestStepResult();

	}

/**

Override of base class pure virtual

Lists the tests to be run

*/

void CTInterleaving::RunTestsL()

	{

	if(iUseDirectGdi)

		{

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-INTERLEAVING-0001"));

		TestSyncL();

		RecordTestResultL();

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-INTERLEAVING-0002"));

		TestAsyncL();

		RecordTestResultL();

		SetTestStepID(_L("GRAPHICS-DIRECTGDI-INTERLEAVING-0002"));

		TestAsyncL(ETrue);

		RecordTestResultL();

		}

	}