// 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:

 //

 /**

  @file

  @test

 */

 #include <test/tefunit.h> // for ASSERT macros

 #include "egltest_image_multithread.h"

 #include <test/egltestcommonconversion.h>

 #include <test/egltestcommonsgimageinfo.h>

 CEglTest_MThread_Image_Base::CEglTest_MThread_Image_Base()

 	{

 	}

 CEglTest_MThread_Image_Base::~CEglTest_MThread_Image_Base()

 	{

 	iSgImageShared.Close();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0155

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check if EGL Implementation allows two threads to work in parallel.

 @SYMTestActions

 Run two threads that independently perform the same actions detailed below.

 This test will check for the “VG_KHR_EGL_image” extension, if it is not 

 supported on this platform then the test will return immediately without failure.

 Create and fully construct an RSgImage object

 •	Set the iUsage bits to ESgUsageBitOpenVgImage

 Pass the RSgImage object into eglCreateImageKHR() with

 •	The target parameter set to EGL_NATIVE_PIXMAP_KHR

 •	Use the current display and EGL_NO_CONTEXT

 •	Use a NULL attr_list

 Check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR

 Use vgCreateEGLImageTargetKHR() to construct a VGImage object from the EGLImage.

 •	Check for errors (VGInvalidHandle is not returned)

 Create a second RSgImage, and use it to create a pixmap surface that is 

 compatible as a target for the VGImage to be drawn to.

 •	Set the iUsage bit to ESgUsageBitOpenVgSurface

 •	Use the same pixel format as the RSgImage above.

 Now that a eglContext and an OpenVG context have been created, use the 

 OpenVG API vgClearImage to clear to a chosen colour the VGImage previously 

 returned by eglCreateImageKHR.

 Use OpenVG to draw the just drawn VGImage to the pixmap surface currently 

 linked to the context.

 Call eglWaitClient() to finish the above drawing instructions synchronously.

 Destroy the original image data

 •	Pass the VGImage into vgDestroyImage()

 •	Pass the EGLImage into eglDestroyImageKHR()

 •	Close the first RSgImage

 •	Check that the pixmap surface contains expected pixel values using 

 OpenVG APIs, vgReadPixels.

 Close the second RSgImage and destroy the pixmap surface

 Check for memory and handle leaks

 @SYMTestExpectedResults

 Pixmap surface has the expected contents in both threads (within tolerance).

 No memory or handle leaks.

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_Parallel::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0155"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_Parallel::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	Test_MultiThreadL(2, ETrue);

 	TerminateDisplayL();

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_Parallel::doTestStepL"));

 	RecordTestResultL();	

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_Parallel::doThreadFunctionL(TInt aIdx)

 	{

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Parallel::doThreadFunctionL, Thread %d"),aIdx);

 	GetDisplayL();

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();	

 	eglSess->OpenSgDriverL();

 	// create a reference bitmap (we give index 7, as there's only 1 image in this test case)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 	CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 7);

 	CleanupStack::PushL(bitmap);

 	// Create an RSgImage

 	INFO_PRINTF2(_L("Thread %d, Creating a RSgImage having the reference bitmap's content"),aIdx);

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

     RSgImage rSgImageLocal;

 	CleanupClosePushL(rSgImageLocal);

 	ASSERT_EQUALS(rSgImageLocal.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 	INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx);

 	EGLImageKHR eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &rSgImageLocal, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

 	CleanupStack::PopAndDestroy(&rSgImageLocal); 	//transferring ownership of the buffer to the EGLImage

 	CleanupStack::PopAndDestroy(bitmap);

 	INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

 	TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 	// Create a pixmap surface matching the native image pixel format

 	eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2,CTestEglSession::EResourceCloseSgImageEarly);

 	INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the EGLImage"),aIdx);

 	VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)eglImageLocal);	

 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

 	ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, eglImageLocal));

 	// Copy the source VGImage to the surface

 	vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	eglWaitClient();

 	// destroy VGImage

 	vgDestroyImage(vgImageLocal);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 	// we can now compare the VgImage to the one we would expect for this particular thread

 	CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 7);

 	CleanupStack::PushL(refBitmap);

 	eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

 	CleanupStack::PopAndDestroy(refBitmap);

 	INFO_PRINTF2(_L("Drawing successful, Thread %d"),aIdx);

 	// cleanup

 	eglSess->CloseSgDriver();

   	CleanupStack::PopAndDestroy(eglSess);	

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0156

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check if EGL Implementation allows two threads to work in parallel.

 EGLImage can’t be created from an RSgImage that already has been linked to an EGLImage by another thread.

 @SYMTestActions

 Main Thread: creates an RSgImage and starts thread1 and thread2.

 Thread1: Creates an EGLImage from the RSgImage previous mentioned

 --------

 Thread2: Creates an EGLImage from the RSgImage previous mentioned and check that eglCreateImageKHR() does return EGL_NO_IMAGE_KHR

 --------

 Thread1: Closes the EGLImage

 Main Thread: Closes the RSgImage.

 @SYMTestExpectedResults

 eglCreateImageKHR() does return EGL_NO_IMAGE_KHR in the 2nd thread and EGL_BAD_ACCESS error is generated.

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_Sibling_Basic::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0156"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_Sibling_Basic::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

     GetDisplayL();

     CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	// Make sure the driver is ready

 	eglSess->OpenSgDriverL();

 	// create a reference bitmap (we give index 0, as there's only 1 image in this test case)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 	CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 0);

 	CleanupStack::PushL(bitmap);

 	// Create an RSgImage (member variable as it is 'shared' in the thread funtion...) 

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

 	ASSERT_EQUALS(iSgImageShared.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 	CleanupStack::PopAndDestroy(bitmap);

 	// launch 2 threads

 	Test_MultiThreadL(2, ETrue);

 	// clean everything

 	iSgImageShared.Close();

 	CleanupStack::PopAndDestroy(eglSess);

 	TerminateDisplayL();

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_Sibling_Basic::doTestStepL"));

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_Sibling_Basic::doThreadFunctionL(TInt aIdx)

 	{

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Sibling_Basic::doThreadFunctionL, Thread %d"),aIdx);

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

 	EGLImageKHR eglImageLocal = EGL_NO_IMAGE_KHR;

 	if(aIdx == 0)

 		{

 		INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx);

 		eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue);

 		ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

 		}

 	Rendezvous(aIdx);

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx);

 		eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue);

 		ASSERT_EGL_TRUE(eglImageLocal == EGL_NO_IMAGE_KHR);

 		ASSERT_EGL_ERROR(EGL_BAD_ACCESS);

 		}

 	Rendezvous(aIdx);

 	// cleanup

 	if(aIdx == 0)

 		{

 		ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, eglImageLocal));

 		}

 	eglSess->CloseSgDriver();

 	CleanupStack::PopAndDestroy(eglSess);

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0157

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check if EGL Implementation allows two threads to work in parallel.

 Each thread is allowed to create a VGImage from the same EGLImage

 @SYMTestActions

 Main Thread: creates an RSgImage with the same content as the reference bitmap and creates an EGLImage from it; starts thread1 and thread2.

 Thread1: Creates an egl context and a pixmap surface linked to it. Creates an VGImage from the EGLImage previous mentioned

 Thread2: Creates an egl context and a pixmap surface linked to it. Creates an VGImage from the EGLImage previous mentioned

 --------

 Thread 1: Changes the content of the RSgImage by using the VGImage that has a reference to it.

 --------

 Thread1: Passes the VGImage into vgDestroyImage()

 Thread2: Copies the VGImage to the pixmap surface and checks the contents

 Thread2: Passes the VGImage into vgDestroyImage()

 Main Thread: Closes the EGLImage

 Main Thread: Closes the RSgImage

 @SYMTestExpectedResults

 No error is generated within both threads. The changes apported by the first thread affects the second thread. The content the pixmap surface will matches the one of the reference bitmap changed by the first thread.

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0157"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

     GetDisplayL();

     CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	// Make sure the driver is ready

 	eglSess->OpenSgDriverL();

 	// create a reference bitmap (we give index 3, as there's only 1 image in this test case)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 	CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 3);

 	CleanupStack::PushL(bitmap);

 	// Create an RSgImage (member variable as it is 'shared' in the thread funtion...) 

 	INFO_PRINTF1(_L("Parent Thread, Creating the shared RSgImage"));

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

 	ASSERT_EQUALS(iSgImageShared.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 	CleanupStack::PopAndDestroy(bitmap);

 	// Create an EGLImage from the RSgImage (member variable as it is 'shared' in the thread funtion...) 

 	INFO_PRINTF1(_L("Parent Thread, Creating the shared EGLImage"));

 	iEGLImageShared = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(iEGLImageShared != EGL_NO_IMAGE_KHR);

 	iSgImageShared.Close();

 	// launch 2 threads

 	Test_MultiThreadL(2, ETrue);

 	// cleanup

 	ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, iEGLImageShared));

 	CleanupStack::PopAndDestroy(eglSess);

 	TerminateDisplayL();	

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doTestStepL"));	

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doThreadFunctionL(TInt aIdx)

 	{	

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage::doThreadFunctionL, Thread %d"),aIdx);

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

 	INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 	// Create a pixmap surface matching the native image pixel format

 	eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly);

 	// Create a VGImage from the EGLImage

 	INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx);

 	VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared);	

 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

 	Rendezvous(aIdx);

 	if(aIdx == 0)

 		{

 		INFO_PRINTF2(_L("Thread %d, Updating contents of the VGImage from the shared EGLImage"),aIdx);

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8);

     	// Add pixel data to the VGImage reference from the bitmap reference. 

         // Mind the fact that CFbsBitmap and VGImages use different coordinates origin!

 		TSize bitmapSize = bitmap->SizeInPixels();

     	TUint8* address = reinterpret_cast<TUint8*>(bitmap->DataAddress());

     	TInt stride = bitmap->DataStride();

     	address += (bitmapSize.iHeight - 1) * stride;

         vgImageSubData(vgImageLocal, address, -stride, KDefaultSurfaceFormat, 0,0, bitmapSize.iWidth, bitmapSize.iHeight);

 		delete bitmap;

         bitmap = NULL;

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		}

 	Rendezvous(aIdx);

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx);

 		// Copy the source VGImage to the surface

     	vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		// we can now compare the VgImage to the one we expect after changing it in the other thread

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 8);

 		CleanupStack::PushL(refBitmap);

 		eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx);

 		}		

 	// cleanup

 	vgDestroyImage(vgImageLocal);

 	ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

 	eglSess->CloseSgDriver();

 	CleanupStack::PopAndDestroy(eglSess);

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0158

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check if EGL Implementation allows two threads to work in parallel.

 Each thread is allowed to create a VGImage from an EGLImage created by another thread.

 @SYMTestActions

 Main Thread: creates an RSgImage ; starts thread1 and thread2.

 Thread1: Creates an EGLImage from the previous mentioned RSgImage

 --------

 Thread2: Creates an VGImage from the EGLImage created by the other thread

 --------

 Thread1: Passes the EGLImage into eglDestroyImageKHR ()

 Thread2: Passes the VGImage into vgDestroyImage()

 Main Thread: Closes the RSgImage

 @SYMTestExpectedResults

 No error is generated within both threads

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0158"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

     GetDisplayL();

     CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	// Make sure the driver is ready

 	eglSess->OpenSgDriverL();

 	// create a reference bitmap (we give index 5, as there's only 1 image in this test case)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 	CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 5);

 	CleanupStack::PushL(bitmap);

 	// Create an RSgImage (member variable as it is 'shared' in the thread funtion...) 

 	INFO_PRINTF1(_L("Parent Thread, Creating the shared RSgImage"));

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

 	ASSERT_EQUALS(iSgImageShared.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 	CleanupStack::PopAndDestroy(bitmap);

 	// launch 2 threads

 	Test_MultiThreadL(2, ETrue);

 	// cleanup

 	iSgImageShared.Close();

 	CleanupStack::PopAndDestroy(eglSess);

 	TerminateDisplayL();	

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doTestStepL"));	

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doThreadFunctionL(TInt aIdx)

 	{	

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Sibling_VGImage_PassingEGLImage::doThreadFunctionL, Thread %d"),aIdx);

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();	

 	// check there is no eglImage at the start of either thread

 	ASSERT_EGL_TRUE(iEGLImageShared == EGL_NO_IMAGE_KHR);

 	// Wait for both thread to reach this point

 	//	This is important for multicore platforms (i.e., naviengine) as the execution order is not known and it could

 	//	happen that the first thread has already created the image before the second checks there is no eglImage 

 	Rendezvous(aIdx);

 	if(aIdx == 0)

 		{

 		// Create an EGLImage from the RSgImage (member variable as it is 'shared' in the thread function...) 

 		INFO_PRINTF2(_L("Thread %d, Creating the shared EGLImage"),aIdx);

 		iEGLImageShared = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue);

 		ASSERT_EGL_TRUE(iEGLImageShared != EGL_NO_IMAGE_KHR);

 		iSgImageShared.Close();

 		}

 	Rendezvous(aIdx);

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

 		TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

 		TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 		// Create a pixmap surface matching the native image pixel format

 		eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly);

 		// Create a VGImage from the EGLImage

 		INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx);

 		VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared);	

 		ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

 		INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx);

 		// Copy the source VGImage to the surface

     	vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		// we can now compare the VgImage to the one we expect from the main thread

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 5);

 		CleanupStack::PushL(refBitmap);

 		eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx);

 		vgDestroyImage(vgImageLocal);

 		ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

 		}

 	Rendezvous(aIdx);

 	if(aIdx == 0)

 		{

 		ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, iEGLImageShared));

 		iEGLImageShared = EGL_NO_IMAGE_KHR;

 		}

 	// cleanup

 	eglSess->CloseSgDriver();

 	CleanupStack::PopAndDestroy(eglSess);

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0159

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check if EGL Implementation allows two threads to work in parallel.

 If the thread that has created the EGLImage terminates without destroying it the other thread can still use it.

 @SYMTestActions

 Main Thread: Creates an RSgImage ; starts thread1 and thread2.

 Thread1: An EGLImage from the previous mentioned RSgImage

 --------

 Thread1: Calls eglReleaseThread()

 Thread1: Finishes gracefully

 Thread2: Creates an VGImage the EGLImage created by the other thread

 Thread2: Passes the VGImage into vgDestroyImage()

 Thread2: Passes the EGLImage into eglDestroyImageKHR ()

 Main Thread: Closes the RSgImage.

 @SYMTestExpectedResults

 No error is generated within both threads

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-EGL-0159"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	// Create display object

 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

     GetDisplayL();

     CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

 	eglSess->InitializeL();

 	// Make sure the driver is ready

 	eglSess->OpenSgDriverL();

 	// create a reference bitmap (we give index 2, as there's only 1 image in this test case)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 	CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 2);

 	CleanupStack::PushL(bitmap);

 	// Create an RSgImage (member variable as it is 'shared' in the thread funtion...) 

 	INFO_PRINTF1(_L("Parent Thread, Creating the shared RSgImage"));

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

 	ASSERT_EQUALS(iSgImageShared.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 	CleanupStack::PopAndDestroy(bitmap);

 	// launch 2 threads

 	Test_MultiThreadL(2, ETrue);

 	// cleanup

 	iSgImageShared.Close();

 	CleanupStack::PopAndDestroy(eglSess);	

 	TerminateDisplayL();

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doTestStepL"));	

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doThreadFunctionL(TInt aIdx)

 	{	

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_Exit_Thread::doThreadFunctionL, Thread %d"),aIdx);

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

 	// check there is no eglImage at the start of either thread

 	ASSERT_EGL_TRUE(iEGLImageShared == EGL_NO_IMAGE_KHR);

 	TRequestStatus statusThread0;

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L("Thread %d, Asking to be notified when thread 0 exits"),aIdx);

 		iThreadStatus[0].iThread.Logon(statusThread0);

 		}

 	Rendezvous(aIdx);

 	//Thread 0 creates the EGLImage and exit

 	if(aIdx == 0)	

 		{

 		// Create an EGLImage from the RSgImage (member variable as it is 'shared' in the thread function...) 

 		INFO_PRINTF2(_L("Thread %d, Creating the shared EGLImage"),aIdx);

 		iEGLImageShared = eglSess->eglCreateImageKhrL(iDisplay,EGL_NO_CONTEXT,EGL_NATIVE_PIXMAP_KHR,&iSgImageShared,KEglImageAttribsPreservedTrue);

 		ASSERT_EGL_TRUE(iEGLImageShared != EGL_NO_IMAGE_KHR);

 		iSgImageShared.Close();

 		INFO_PRINTF2(_L("Thread %d -----  Exiting ---- EGLImage should be kept alive"),aIdx);

 		}

 	//Thread1 waits for Thread0 to exit and then uses the EGLImage and performs some drawing

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L("Thread %d, Waiting for thread 0 to exit"),aIdx);

 		User::WaitForRequest(statusThread0);

 		INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

 		TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

 		TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 		// Create a pixmap surface matching the native image pixel format

 		eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo,CTestEglSession::EResourceCloseSgImageEarly);

 		// Create a VGImage from the EGLImage

 		INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the shared EGLImage"),aIdx);

 		VGImage vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)iEGLImageShared);	

 		ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

 		INFO_PRINTF2(_L("Thread %d, Drawing the VGImage to the current surface"),aIdx);

 		// Copy the source VGImage to the surface

     	vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		// we can now compare the VgImage to the one we expect after changing it in the other thread

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 2);

 		CleanupStack::PushL(refBitmap);

 		eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		INFO_PRINTF2(_L("Thread %d, Drawing successful"),aIdx);

 		vgDestroyImage(vgImageLocal);

 		ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

 		ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, iEGLImageShared));

 		iEGLImageShared = EGL_NO_IMAGE_KHR;

 		}

 	// cleanup

 	eglSess->CloseSgDriver();

 	CleanupStack::PopAndDestroy(eglSess);

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0163

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 All the EGL resources may be used implicitly by a thread even after another thread has terminated the display.

 @SYMTestActions

 Thread0: Asks to be notified when Thread1 exits

 Thread0: Creates a RSgImage having the reference bitmap as content

 Thread0: Creates a EGLImage from the RSgImage

 Thread0: Creates a surface

 Thread0: Creates a VGImage from the EGLImage

 --------

 Thread1: Calls eglTerminate

 --------

 Thread1: Exits

 Thread0: Resumes when Thread1 exits

 Thread0: Uses the VGImage and draw it to the surface

 Thread0: Checks the contents

 @SYMTestExpectedResults

 Thread0 is able to use successfully the VGmage and the surface's content are the ones expected.

 */

 TVerdict CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doTestStepL()

 	{

     SetTestStepID(_L("GRAPHICS-EGL-0163"));

 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doTestStepL"));

 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap | KVG_KHR_EGL_image);

 	if(!ret)

 		{

 		// The extension is not supported

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

 	Test_MultiThreadL(2, ETrue);

 	INFO_PRINTF1(_L("Exit: CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doTestStepL"));	

 	RecordTestResultL();

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 void CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doThreadFunctionL(TInt aIdx)

 	{

 	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Thread_DrawAfterTerminate::doThreadFunctionL, Thread %d"),aIdx);

 	GetDisplayL();

 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

 	eglSess->InitializeL();

 	eglSess->OpenSgDriverL();

 	TRequestStatus statusThread1;

 	VGImage vgImageLocal = VG_INVALID_HANDLE;

 	EGLint surfaceWidth;

 	EGLint surfaceHeigth;

 	//Thread0 asks to be notified when Thread1 exits

 	//Creates a RSgImage having the reference bitmap as content

 	//Creates a EGLImage from the RSgImage

 	//Creates a surface

 	//Creates a VGImage from the EGLImage

 	if(aIdx == 0)

 		{

 		// Thread0 asks to be notified when Thread1 exits

 		iThreadStatus[1].iThread.Logon(statusThread1);

 	    RSgImage rSgImageLocal;

 		CleanupClosePushL(rSgImageLocal);

 		// create a reference bitmap (we give index 9, as there's only 1 image in this test case)

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* bitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 9);

 		CleanupStack::PushL(bitmap);

 		// Create an RSgImage

 		INFO_PRINTF2(_L("Thread %d, Creating a RSgImage having the reference bitmap's content"),aIdx);

 		TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KPixmapSize);

 		ASSERT_EQUALS(rSgImageLocal.Create(imageInfo,bitmap->DataAddress(),bitmap->DataStride()), KErrNone);

 		CleanupStack::PopAndDestroy(bitmap);

 		INFO_PRINTF2(_L("Thread %d, Creating an EGLImage from the shared RSgImage"),aIdx);

 		EGLImageKHR eglImageLocal = eglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &rSgImageLocal, KEglImageAttribsPreservedTrue);

 		ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

 		CleanupStack::PopAndDestroy(&rSgImageLocal); 	//transferring ownership of the buffer to the EGLImage

 		INFO_PRINTF2(_L("Thread %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

 		TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

 		TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

 		// Create a pixmap surface matching the native image pixel format

 		eglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo2,CTestEglSession::EResourceCloseSgImageEarly);

 		//We now store the size of the surface because after eglTerminate is called on the display

 		//it will not be possible to use explicitly all the resources linked to it

 		//i.e. every call to an EGL API who takes a display as an argument will raise a EGL_BAD_DISPLAY error

 		eglQuerySurface(iDisplay, eglSess->Surface(), EGL_WIDTH, &surfaceWidth);

 		eglQuerySurface(iDisplay, eglSess->Surface(), EGL_HEIGHT, &surfaceHeigth);		

 		INFO_PRINTF2(_L("Thread %d, Creating one VGImage from the EGLImage"),aIdx);

 		vgImageLocal = eglSess->vgCreateImageTargetKHR((VGeglImageKHR)eglImageLocal);	

 		ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

 		ASSERT_EGL_TRUE(eglSess->DestroyEGLImage(iDisplay, eglImageLocal));

 		}

 	Rendezvous(aIdx);

 	//Thread1 calls eglTerminate and exit

 	if(aIdx == 1)

 		{

 		INFO_PRINTF2(_L(", Thread %d, Calling eglTerminate and exiting"),aIdx);

 		TerminateDisplayL();

 		}

 	Rendezvous(aIdx);

 	//Thread0 resumes when Thread1 exits

 	//and it uses the resources that are linked to the just destroyed display

 	if(aIdx == 0)

 		{

 		User::WaitForRequest(statusThread1);

 		// It's still possible to use the current context, surface and VGImage even though the display has been terminated

 		//Copy the source VGImage to the surface

     	vgSetPixels(0, 0, vgImageLocal, 0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		// we can now compare the VgImage to the one we would expect for this particular thread

 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

 		CFbsBitmap* refBitmap = eglSess->CreateReferenceBitmapL(bitmapMode, KPixmapSize, 9);

 		CleanupStack::PushL(refBitmap);

 		eglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		INFO_PRINTF2(_L("Drawing successful, Thread %d"),aIdx);

 		vgDestroyImage(vgImageLocal);

 		ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

 		eglReleaseThread();

 		}

 	// cleanup

 	eglSess->CloseSgDriver();

 	CleanupStack::PopAndDestroy(eglSess);

 	}