// Copyright (c) 2009-2010 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 <iniparser.h>

#include <e32msgqueue.h>

#include "egltest_image_multiprocess.h"

#include <test/egltestcommonconversion.h>

#include <test/egltestcommoninisettings.h>

#include <test/egltestcommonsgimageinfo.h>

#include <test/egltestcommonprocess.h>

//

// Constant definitions

//

const TInt KNumProcesses = 8;

const TInt KNumImages = 4;

#define KImageSize TSize(100,100)	// use #define to avoid global temporary constructors

/**

@SYMTestCaseID GRAPHICS-EGL-0160

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

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

A process can create an EGLImage from the same RSgImage that already has been linked to an EGLImage by another process.

@SYMTestActions

Main Process: creates an RsgImage and starts Process and Process.

Process1: Creates an EGLImage from the RsgImage previous mentioned

--------

Process2: Creates an EGLImage from the RsgImage previous mentioned and check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR

--------

Process1: Closes the EGLImage

Process2: Closes the EGLImage

Main Process: Closes the RsgImage

@SYMTestExpectedResults

No errors within both processes.

No memory or handle leaks

*/

TVerdict CEglTest_EGL_Image_Multi_Process_Sibling_Basic::doTestStepL()

	{

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

	SetTestStepName(KEGL_Image_Multi_Process_Sibling_Basic);

	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_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();

    CreateEglSessionL();

	iEglSess->InitializeL();

	iEglSess->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 = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

	CleanupStack::PushL(bitmap);

    // Create an RSgImage

	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

	imageInfo.iShareable = ETrue;

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    RSgImage sgImage;

	CleanupClosePushL(sgImage);

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

	// launch 2 processes

	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName(), sgImage.Id());

	// destroy sgImage

	CleanupStack::PopAndDestroy(2, bitmap);

	// clean everything

	CleanAll();

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

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_EGL_Image_Multi_Process_Sibling_Basic::doProcessFunctionL(TInt aIdx,const TSgDrawableId& aSgId)

	{

	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_Sibling_Basic::doProcessFunctionL, Process %d"),aIdx);

	GetDisplayL();

	CreateEglSessionL(aIdx);

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

	RSgImage sgImageFromId;

	CleanupClosePushL(sgImageFromId);

	ASSERT_EQUALS(sgImageFromId.Open(aSgId),KErrNone);

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

	EGLImageKHR eglImage = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImageFromId, KEglImageAttribsPreservedTrue);

	ASSERT_EGL_TRUE(eglImage != EGL_NO_IMAGE_KHR);

	CleanupStack::PopAndDestroy(&sgImageFromId);

	INFO_PRINTF2(_L("Process %d, EGLImage successfully created, now destroying it"),aIdx);

	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, eglImage));

	// cleanup

	CleanAll();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0161

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

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

@SYMTestActions

Run two processes 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 processes (within tolerance)

No memory or handle leaks

*/

TVerdict CEglTest_EGL_Image_Multi_Process_Parallel::doTestStepL()

	{

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

	SetTestStepName(KEGL_Image_Multi_Process_Parallel);

	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_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();

		}

	// launch 2 processes

	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

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

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_EGL_Image_Multi_Process_Parallel::doProcessFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_Parallel::doProcessFunctionL, Process %d"),aIdx);

	GetDisplayL();

	CreateEglSessionL(aIdx);

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

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

	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 3);

	CleanupStack::PushL(bitmap);

	// Create an RSgImage

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

	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

    RSgImage rSgImageLocal;

	CleanupClosePushL(rSgImageLocal);

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

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

	EGLImageKHR eglImageLocal = iEglSess->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("Process %d, Creating a Surface and a Context bound to OpenVG"),aIdx);

	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

	TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

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

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

	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

	// Copy the source VGImage to the surface

	vgSetPixels(0, 0, vgImageLocal, 0, 0, KImageSize.iWidth, KImageSize.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 process

	CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 3);

	CleanupStack::PushL(refBitmap);

	iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

	CleanupStack::PopAndDestroy(refBitmap);

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

	// cleanup

	CleanAll();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0162

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

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

A process can create an EGLImage from the same RSgImage that already has been linked to an EGLImage by another process.

Both process can create a VGImage from it.

Another process uses the VGImage as a target

One process uses the VGImage as a source being able to see the drawing done by the other process

@SYMTestActions

Main Process: creates an RsgImage and starts Process and Process.

Process1: Creates an egl context and a pizmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

Process2: Creates an egl context and a pizmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

Process1: Changes the contents of the VGImage

--------

Process1: Closes the VGImage and the EGLImage

Process2: Draws the VGImage to the surface and checks if the contets match the reference bitmap plus the chages made by the first process.

Process2: Closes the VGImage and the EGLImage

Main Process: Closes the RsgImage

@SYMTestExpectedResults

No errors within both processes.

The content of the pixmap surface will match the one of the reference bitmap changed by the first process.

No memory or handle leaks.

*/

TVerdict CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::doTestStepL()

	{

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

	SetTestStepName(KEGL_Image_Multi_Process_Sibling_CheckContents);

	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::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();

    CreateEglSessionL();

	iEglSess->InitializeL();

	iEglSess->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 = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

	CleanupStack::PushL(bitmap);

    // Create an RSgImage

	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

	imageInfo.iShareable = ETrue;

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    RSgImage sgImage;

	CleanupClosePushL(sgImage);

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

	// launch 2 processes

	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName(), sgImage.Id());

	// destroy sgImage

	CleanupStack::PopAndDestroy(&sgImage);

	CleanupStack::PopAndDestroy(bitmap);

	// clean everything

	CleanAll();

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

    RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::doProcessFunctionL(TInt aIdx,const TSgDrawableId& aSgId)

	{

	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::doProcessFunctionL, Process %d"),aIdx);

	GetDisplayL();

	CreateEglSessionL(aIdx);

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

	RSgImage sgImageFromId;

	CleanupClosePushL(sgImageFromId);

	ASSERT_EQUALS(sgImageFromId.Open(aSgId),KErrNone);

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

	EGLImageKHR eglImageLocal = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImageFromId, KEglImageAttribsPreservedTrue);

	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

	CleanupStack::PopAndDestroy(&sgImageFromId);

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

	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

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

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

	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

	if(aIdx == 0)

		{

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 4);

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

		}

	// Wait for both processes to reach this point (process 0 will have updated the VGImage)

	Rendezvous(aIdx);

	if(aIdx == 1)

		{

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

		// Copy the source VGImage to the surface

    	vgSetPixels(0, 0, vgImageLocal, 0, 0, KImageSize.iWidth, KImageSize.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 process

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 4);

		CleanupStack::PushL(refBitmap);

		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

		CleanupStack::PopAndDestroy(refBitmap);

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

		}

	// destroy VGImage

	vgDestroyImage(vgImageLocal);

	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

	// cleanup

	CleanAll();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0350

@SYMTestPriority 1

@SYMPREQ 2637

@SYMTestCaseDesc

Check sharing SgImage between 2 processes where a writer process populates SgImage through VgImage and a reader process draws SgImage to window surface.

@SYMTestActions

Main Process: starts Process1 and Process2.

Process1: Creates an RsgImage and passes RsgImage ID to process2. Creates an egl context and a pixmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

Process2: Creates an RsgImage using RsgImage ID passed into it. Creates an egl context and a pixmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

--------

Process2: Draws the VGImage to the surface before Process1 changes the contents of the VGImage.

--------

Process1: Changes the contents of the VGImage

--------

Process2: Draws the VGImage to the surface after Process1 changes the contents of the VGImage and checks if the contets match the reference bitmap plus the chages made by the process1.

Process1: Closes the VGImage, the EGLImage, the RsgImage.

Process2: Closes the VGImage, the EGLImage, the RsgImage.

@SYMTestExpectedResults

No errors within both processes.

The content of the pixmap surface will match the one of the reference bitmap changed by the first process.

No memory or handle leaks.

*/

TVerdict CEglTest_EGL_Image_Multi_Process_VgImage_Source::doTestStepL()

    {

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

	SetTestStepName(KEGL_Image_Multi_Process_VgImage_Source);

	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_VgImage_Source::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();

		}

	// launch 2 processes

	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

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

    RecordTestResultL();

    CloseTMSGraphicsStep();

    return TestStepResult();

    }

void CEglTest_EGL_Image_Multi_Process_VgImage_Source::doProcessFunctionL(TInt aIdx)

    {

    INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_VgImage_Source::doProcessFunctionL, Process %d"),aIdx);

	GetDisplayL();

	CreateEglSessionL(aIdx);

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

    RMsgQueue<TSgDrawableId> messageQueue;

    User::LeaveIfError(messageQueue.Open(EProcSlotMsgQueueSgId, EOwnerProcess));

    CleanupClosePushL(messageQueue);

    RSgImage rSgImageLocal;

	if(aIdx == 0)

        {

    	// 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 = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

    	CleanupStack::PushL(bitmap);

    	// Create an RSgImage

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

    	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    	imageInfo.iShareable = ETrue;

#endif

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

        CleanupStack::PopAndDestroy(bitmap);

        INFO_PRINTF2(_L("Process %d, Sending SgImage ID to other process..."), aIdx);

        messageQueue.SendBlocking(rSgImageLocal.Id());

        }

    else if(aIdx == 1)

        {

        INFO_PRINTF2(_L("Process %d, Receiving SgImage ID from other process..."), aIdx);

        TSgDrawableId sgImageId;

        messageQueue.ReceiveBlocking(sgImageId);

        ASSERT_EQUALS(rSgImageLocal.Open(sgImageId), KErrNone);

        }

	// Wait for both processes to reach this point

    Rendezvous(aIdx);

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

	CleanupClosePushL(rSgImageLocal);

	EGLImageKHR eglImageLocal = iEglSess->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("Creating a Surface and a Context bound to OpenVG, Process %d"),aIdx);

	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

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

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

	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

    if(aIdx == 1)

        {

        INFO_PRINTF2(_L("Process %d, Drawing the VGImage to the current surface before changing contents of the VGImage"),aIdx);

    	// Copy the source VGImage to the surface

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

    	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

    	eglWaitClient();

    	// we can now compare the VgImage to the one we expect before we apply any change to it

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

		CleanupStack::PushL(refBitmap);

		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

		CleanupStack::PopAndDestroy(refBitmap);

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

        }

	// Wait for both processes to reach this point

    Rendezvous(aIdx);

    if(aIdx == 0)

        {

        INFO_PRINTF2(_L("Process %d, Changing contents of the VGImage"),aIdx);

        TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

        CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 4);

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

        }

	// Wait for both processes to reach this point (process 0 will have updated the VGImage)

	Rendezvous(aIdx);

	if(aIdx == 1)

		{

        INFO_PRINTF2(_L("Drawing the VGImage to the current surface after changing contents of the VGImage, Process %d"),aIdx);

        // Copy the source VGImage to the surface

    	vgSetPixels(0, 0, vgImageLocal, 0, 0, KImageSize.iWidth, KImageSize.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 process

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 4);

		CleanupStack::PushL(refBitmap);

		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

		CleanupStack::PopAndDestroy(refBitmap);

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

        }

	vgDestroyImage(vgImageLocal);

	ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

	CleanupStack::PopAndDestroy(&messageQueue);

    CleanAll();

    }

/**

@SYMTestCaseID GRAPHICS-EGL-0351

@SYMTestPriority 1

@SYMPREQ 2637

@SYMTestCaseDesc

Check when sharing SgImage between 2 processes where a writer process populates SgImage through VgImage and a reader process draws SgImage to window surface,

process2 has reference to SgImage even after process1 loses all references to SgImage

@SYMTestActions

Main Process: starts Process1 and Process2.

Process1: Creates an RsgImage and passes RsgImage ID to process2. Creates an egl context and a pixmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

Process2: Creates an RsgImage using RsgImage ID passed into it. Creates an egl context and a pixmap surface linked to it. Creates an EGLImage from the RsgImage previous mentioned. Creates a VGImage from the EGLImage.

Process2: Drawss the VGImage to the surface before Process1 changes the contents of the VGImage.

--------

Process1: Changes the contents of the VGImage

Process1: Closes the VGImage, the EGLImage, the RsgImage.

--------

Process2: Draws the VGImage to the surface after Process1 changes the contents of the VGImage and checks if the contents match the reference bitmap plus the changes made by the process1.

Process2: Closes the VGImage, the EGLImage, the RsgImage.

@SYMTestExpectedResults

No errors within both processes.

The content of the pixmap surface will match the one of the reference bitmap changed by the process1.

No memory or handle leaks.

*/

TVerdict CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doTestStepL()

    {

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

	SetTestStepName(KEGL_Image_Multi_Process_VgImage_DrawAfterTerminate);

    INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_VgImage_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();

		}

	// This test is performed for default pixel format

	PrintUsedPixelConfiguration();

	// launch 2 processes

 	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

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

    RecordTestResultL();

    CloseTMSGraphicsStep();

    return TestStepResult();

    }

void CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doProcessFunctionL(TInt aIdx)

    {

    INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doProcessFunctionL, Process %d"),aIdx);

    GetDisplayL();

    CreateEglSessionL(aIdx);

    iEglSess->InitializeL();

    iEglSess->OpenSgDriverL();

    RMsgQueue<TSgDrawableId> messageQueue;

    User::LeaveIfError(messageQueue.Open(EProcSlotMsgQueueSgId, EOwnerProcess));

    CleanupClosePushL(messageQueue);

    RSgImage rSgImageLocal;

    if(aIdx == 0)

        {

    	// 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 = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

    	CleanupStack::PushL(bitmap);

    	// Create an RSgImage

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

    	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    	imageInfo.iShareable = ETrue;

#endif

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

        CleanupStack::PopAndDestroy(bitmap);

        INFO_PRINTF2(_L("Process %d, Sending SgImage ID to other process..."), aIdx);

        messageQueue.SendBlocking(rSgImageLocal.Id());

        }

    else if(aIdx == 1)

        {

        INFO_PRINTF2(_L("Process %d: Receiving SgImage ID from other process..."), aIdx);

        TSgDrawableId sgImageId;

        messageQueue.ReceiveBlocking(sgImageId);

        ASSERT_EQUALS(rSgImageLocal.Open(sgImageId),KErrNone);

        }

	// Wait for both processes to reach this point

    Rendezvous(aIdx);

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

	CleanupClosePushL(rSgImageLocal);

	EGLImageKHR eglImageLocal = iEglSess->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("Creating a Surface and a Context bound to OpenVG, Process %d"),aIdx);

	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

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

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

	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

    if(aIdx == 1)

        {

        INFO_PRINTF2(_L("Process %d, Drawing the VGImage to the current surface before changing contents of the VGImage"),aIdx);

        // Copy the source VGImage to the surface

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

    	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

    	eglWaitClient();

    	// we can now compare the VgImage to the one we expect before we apply any change to it

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 0);

		CleanupStack::PushL(refBitmap);

		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

		CleanupStack::PopAndDestroy(refBitmap);

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

        }

	// Wait for both processes to reach this point

    Rendezvous(aIdx);

    if(aIdx == 0)

        {

        INFO_PRINTF2(_L("Process %d, Changing contents of the VGImage"),aIdx);

        TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

        CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 2);

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

    	vgDestroyImage(vgImageLocal);

    	ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

    	CleanupStack::PopAndDestroy(&messageQueue);

        CleanAll();

        }

	// Wait for both processes to reach this point

    Rendezvous(aIdx);

    if(aIdx == 1)

        {

        INFO_PRINTF2(_L("Drawing the VGImage to the current surface after changing contents of the VGImage, Process %d"),aIdx);

 		// Copy the source VGImage to the surface

    	vgSetPixels(0, 0, vgImageLocal, 0, 0, KImageSize.iWidth, KImageSize.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 process

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, 2);

		CleanupStack::PushL(refBitmap);

		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

		CleanupStack::PopAndDestroy(refBitmap);

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

		vgDestroyImage(vgImageLocal);

		ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

		CleanupStack::PopAndDestroy(&messageQueue);

    	CleanAll();

        }

    }

/**

@SYMTestCaseID GRAPHICS-EGL-0406

@SYMTestPriority 1

@SYMPREQ PREQ2637

@SYMTestCaseDesc

To ensure that RSgImage with uploaded data can be shared across processes.

To ensure that reference counting of RSgImage works correctly.

@SYMTestActions

From the main process:

- Create M SgImage(s) with the flag ESgUsageBitOpenVgImage. The size are all the same.

  We are running through all the possible configurations, with the values assumed being:

•	EUidPixelFormatRGB_565

•	EUidPixelFormatXRGB_8888

•	EUidPixelFormatARGB_8888 (source only)

•	EUidPixelFormatARGB_8888_PRE

•	EUidPixelFormatA_8  (source only)

- Note that when using EUidPixelFormatA_8 as a source, the reference bitmap display mode used is EGray256,

  This is to enable using the reference bitmap as an alpha mask.

- Spawn N client processes. During the process launching, pass to each process single drawable ID from the SgImages.

  In order to define which SgImage needs to be passed to the particular process, there will be following

  formula applied: J = P Mod (M), where J is the sequence number of the image, P is the particular process number.

From processes 1 to N:

- Open SgImage by using TSgDrawableId, obtained from the SgImage which was passed from the process A.

- Using EGL extension, create EGLImage specifying as EGLClientBuffer SgImage which was created on

  previous step,  EGL_NATIVE_PIXMAP_KHR as a target and EGL_IMAGE_PRESERVED_KHR as an attribute

- Using VG extension, create VG image based on EGLImage from the previous step.

- Close Sg and EGL images

- Create second SgImage with the same size and pixel format as first SgImage and usage flag is set to ESgUsageBitOpenVgSurface.

- Create off-screen pixmap surface with underlining second SgImage and make it current for the drawing context.

- Draw VGImage to the off-screen surface (note that when using EUidPixelFormatA_8 as a source, the

  reference bitmap is used as an alpha mask).

- Draw VGImage to the off-screen surface.

- Retrieve surface data (see vgReadPixels() API)

@SYMTestExpectedResults

Creation of all drawable  resources have been completed without errors.

Image data obtained in client processes 1-N matches to the data which have been uploaded to the SgImages buffer from

process A. Reference counting works correctly and keeps VG image alive although bound Sg and EGL images have been destroyed.

When all resources are closed, resource count maintained by RSgDriver extension is zero in all processes.

*/

TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestStepL()

	{

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

	SetTestStepName(KEGL_Image_Multi_Process_FontServer_Upfront);

	INFO_PRINTF1(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::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();

		}

	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

	CleanupStack::PushL(iniParser);

	TInt numPixmapSgSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);

	TInt numImageSourceFormats = iniParser->GetNumberOfFormats(KSectionImageSourceFormats);

	if(!numImageSourceFormats && !numPixmapSgSurfaceFormats)

		{

		ERR_PRINTF1(_L("No formats to iterate through"));

		User::Leave(KErrArgument);

		}

	for(TUint j=0; j < numPixmapSgSurfaceFormats; j++)

		{

		iSurfaceFormat = iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,j);

		for(TUint i=0; i < numImageSourceFormats; i++)

			{

			iSourceFormat = iniParser->GetPixelFormat(KSectionImageSourceFormats,i);

			if (iSourceFormat == EUidPixelFormatARGB_8888 && (iSurfaceFormat == VG_sARGB_8888_PRE || iSurfaceFormat == VG_sARGB_8888))

				{

				// Don't perform the test for this particular format combination

				//  Causes issues converting pixel values from non-pre to pre

				continue;

				}

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

			// A_8 related tests are only performed for SgImage-Lite

			if (iSourceFormat == EUidPixelFormatA_8)

				continue;

#endif

			doTestPartialStepL();

			}

		}

	CleanupStack::PopAndDestroy(iniParser);

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestPartialStepL()

	{

	INFO_PRINTF1(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestPartialStepL"));

	PrintUsedPixelConfiguration();

	// Create display object

	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

	GetDisplayL();

	CreateEglSessionL();

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

	// list to maintain TSgDrawableId

	RArray<TSgDrawableId> sgIdList;

	CleanupClosePushL(sgIdList);

    RSgImage sgImages[KNumImages];

	INFO_PRINTF2(_L("MAIN PROCESS: Creating %d RSgImage(s)..."), KNumImages);

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

		{

		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

		CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, i);

		CleanupStack::PushL(bitmap);

		TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KImageSize);

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    	imageInfo.iShareable = ETrue;

#endif

		ASSERT_EQUALS(sgImages[i].Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

        CleanupClosePushL(sgImages[i]);

		ASSERT_EQUALS(sgIdList.Insert(sgImages[i].Id(),i), KErrNone);

		}

	INFO_PRINTF2(_L("MAIN PROCESS: About to launch %d processes..."), KNumProcesses);

	Test_MultiProcessL(KEglTestStepDllName, KNumProcesses, TestStepName(), sgIdList); //the function will guarantee that all images will be opened before it returns

    CleanupStack::PopAndDestroy(2 * KNumImages + 1, &sgIdList); // KNumImages SgImages, KNumImages bitmaps, sgIdList

	INFO_PRINTF2(_L("MAIN PROCESS: All %d launched processes have completed!"), KNumProcesses);

	CleanAll();

	INFO_PRINTF1(_L("End of CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestPartialStepL"));

	return TestStepResult();

	}

void CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doProcessFunctionL(TInt aIdx,const TSgDrawableId& aSgId)

	{

	INFO_PRINTF2(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doProcessFunctionL, Process %d"),aIdx);

	GetDisplayL();

	CreateEglSessionL(aIdx);

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

	//Retrieve source formats for the launched process from the process parameters.

	User::LeaveIfError(User::GetTIntParameter(EProcSlotSourceFormat, reinterpret_cast<TInt&>(iSourceFormat)));

	User::LeaveIfError(User::GetTIntParameter(EProcSlotSurfaceFormat, reinterpret_cast<TInt&>(iSurfaceFormat)));

	RSgImage sgImageFromId;

	CleanupClosePushL(sgImageFromId);

	ASSERT_EQUALS(sgImageFromId.Open(aSgId), KErrNone);

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

	EGLImageKHR eglImage = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImageFromId, KEglImageAttribsPreservedTrue);

	ASSERT_EGL_TRUE(eglImage != EGL_NO_IMAGE_KHR);

	CleanupStack::PopAndDestroy(&sgImageFromId);

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

    TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

    TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

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

    VGImage vgImage = iEglSess->vgCreateImageTargetKHR((VGeglImageKHR)eglImage);

	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

	ASSERT_EGL_TRUE(iEglSess->DestroyEGLImage(iDisplay, eglImage));

	// At this point we draw the VGImage created from the SgImage to the current surface.

	//	# if the source is a A_8, the VGImage acts as a mask and the target surface must contain

	//		as a result the pen colour set above blended with the mask

	//	# otherwise, drawing the VGImage is just a simple copy via vgSetPixels (no blending required)

	INFO_PRINTF1(_L("Copying the VGImage to the surface"));

	if (iSourceFormat == EUidPixelFormatA_8)

		{

		// clear surface background

		VGfloat bgColor[] = {0.0, 0.0, 0.0, 1.0}; // opaque black

		vgSetfv(VG_CLEAR_COLOR, 4, bgColor);

		vgClear(0, 0, KImageSize.iWidth, KImageSize.iHeight);

		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

		// fill paint

		VGPaint fillPaint = vgCreatePaint();

		vgSetPaint(fillPaint, VG_FILL_PATH);

		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

		vgSetParameteri(fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

		VGuint fillColor = 0x008000ff; // opaque dark green

		vgSetColor(fillPaint, fillColor);

		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

		vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_STENCIL);

		vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);

		vgDrawImage(vgImage);

		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

		eglWaitClient();

	    vgDestroyPaint(fillPaint);

		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

		}

	else

		{

		vgSetPixels(0, 0, vgImage, 0, 0, KImageSize.iWidth, KImageSize.iHeight);

		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);