// 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();

 		}

 	}