// 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 <iniparser.h>

 #include "egltest_vgimagetosurfaces.h"

 #include <test/egltestcommonsgimageinfo.h>

 #include <test/egltestcommonconversion.h>

 #include <test/egltestcommoninisettings.h>

 /**

 @SYMTestCaseID GRAPHICS-EGL-0170

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check that it is possible to draw a VGImage (created from an RSgImage) to a pBuffer Surface.

 @SYMTestActions

 Create a reference Bitmap

 Create and fully construct an RSgImage object having the same content as the reference bitmap 

 •	Set the iUsage bit to ESgUsageBitOpenVgImage

 Create and make current and EGL context bound to OVG APIs and linked to a pBuffer surface.

 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

 Use OpenVG to draw the just created VGImage to the pBuffer 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 RSgImage 

 Check that the pBuffer surface matches the content from the reference bitmap.

 Destroy the pBuffer surface

 Check for memory and handle leaks

 @SYMTestExpectedResults

 pBuffer surface matches the content from the reference bitmap.

 The test will loop through all the possible PixelFormat available for source RSgImages and Destination Surfaces

 •	EUidPixelFormatRGB_565

 •	EUidPixelFormatXRGB_8888

 •	EUidPixelFormatARGB_8888 (source only)

 •	EUidPixelFormatARGB_8888_PRE

 •	EUidPixelFormatA_8  (source only)

 */

 TVerdict CEglTest_EGL_Image_VgImage_To_pBuffer::doTestStepL()

 	{

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

 	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 numPBufferSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPBufferSurfaceFormats);

 	TInt numImageSourceFormats = iniParser->GetNumberOfFormats(KSectionImageSourceFormats);

 	if(!numImageSourceFormats && !numPBufferSurfaceFormats)

 		{

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

 		User::Leave(KErrArgument);

 		}

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

 		{

 		iSurfaceFormat = iniParser->GetVgFormat(KSectionPBufferSurfaceFormats,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_VgImage_To_pBuffer::doTestPartialStepL()

 	{

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

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create a reference bitmap which we use to init the SgImage (we use index=7)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

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

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 1 RSgImage"));

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	TInt ret = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 	ASSERT_EQUALS(ret, KErrNone);

 	// If create pbuffer surface fails, don't fail if there's no matching config (but fail in any other situation):

     //		Support for a window surface is not mandated any pixel format

     //		We should not enforce it in the tests

     //		Silently terminate the test without failing.

 	TEglTestConfig pbufferFormat = EglTestConversion::VgFormatToPBufferSurfaceFormat(iSurfaceFormat);

 	EGLConfig currentConfig = 0;

 	TRAPD(res, currentConfig = iEglSess->GetConfigExactMatchL( pbufferFormat ));

 	if(res == KTestNoMatchingConfig)

 	    {

         INFO_PRINTF1(_L("Creation of pBuffer has failed, the test case for that configuration will be skipped"));

 		CleanupStack::PopAndDestroy(2, bitmap); // bitmap, sgimage

 		CleanAll();

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 	    }

 	User::LeaveIfError(res); // leave here if any other error was raised other than the one above.

 	iEglSess->CreatePbufferSurfaceAndMakeCurrentL(currentConfig, KPixmapSize, EGL_OPENVG_API);

 	INFO_PRINTF1(_L("Creating 1 EGLImage from the RSgImage"));

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage"));

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

 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

 	// 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, KPixmapSize.iWidth, KPixmapSize.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 = 0x00ff00ff; // opaque 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, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		}

 	// destroy eglimage and vgimage

 	vgDestroyImage(vgImage);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

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

 	// Check that the surface contains the expected pixels

 	//  # if the source is a A_8, to compare the surface with a reference bitmap, the following is needed:

 	//    a) a reference bitmap needs to be cleared to black (same colour as the surface was cleared to)

 	//    b) a Pen bitmap, that we clear to green (same colour as the fillPaint used to draw to the surface)

 	//    c) a mask bitmap, which is the reference bitmap used to create the SgImage

 	//  # otherwise, the surface must contain the same pixels as the bitmap used to create the SgImage 

 	if (iSourceFormat == EUidPixelFormatA_8)

 		{

 		// we need a reference bitmap with the same pixel format as the target surface

 		TUidPixelFormat format = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 		TDisplayMode refbitmapMode = EglTestConversion::PixelFormatToDisplayMode(format);

 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceMaskedBitmapL(refbitmapMode, KRgbGreen, bitmap);

 		CleanupStack::PushL(refBitmap);

 		// compare the obtained reference bitmap with the surface drawn

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		}

 	else

 		{

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 		}

 	INFO_PRINTF1(_L("Content is as expected"));

 	//cleanup

 	CleanupStack::PopAndDestroy(2, bitmap); // bitmap, sgImage

 	CleanAll();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0171

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check that it is possible to draw a VGImage (created from an RSgImage) to a Window Surface.

 @SYMTestActions

 Create a reference Bitmap

 Create an RWindow.

 Create and fully construct an RSgImage object having the same content as the reference bitmap 

 •	Set the iUsage bit to ESgUsageBitOpenVgImage

 Create and make current and EGL context bound to OVG APIs and linked to a Window Surface 

 (linked to the previously created RWindow).

 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

 Use OpenVG to draw the just drawn VGImage to the Window 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 RSgImage 

 Check that the Window surface matches the content from the reference bitmap.

 Destroy the Window surface

 Check for memory and handle leaks

 @SYMTestExpectedResults

 Window surface matches the content from the reference bitmap.

 The test will loop through all the possible PixelFormat available for source 

 RSgImages and Destination Surfaces (accordingly to whether or not the test 

 is being run on hardware where just the 16MU format is supported for window surfaces)

 •	EUidPixelFormatRGB_565

 •	EUidPixelFormatXRGB_8888

 •	EUidPixelFormatARGB_8888 (source only)

 •	EUidPixelFormatARGB_8888_PRE

 •	EUidPixelFormatA_8  (source only)

 No memory or handle leaks.

 */

 TVerdict CEglTest_EGL_Image_VgImage_To_Window::doTestStepL()

 	{

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

 	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 numWindowSurfaceFormats = iniParser->GetNumberOfFormats(KSectionWindowSurfaceFormats);

 	TInt numImageSourceFormats = iniParser->GetNumberOfFormats(KSectionImageSourceFormats);

 	if(!numImageSourceFormats && !numWindowSurfaceFormats)

 		{

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

 		User::Leave(KErrArgument);

 		}

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

 		{

 		iSurfaceFormat = iniParser->GetVgFormat(KSectionWindowSurfaceFormats,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_VgImage_To_Window::doTestPartialStepL()

 	{

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

 	PrintUsedPixelConfiguration();

 	OpenWsSessionL(KDefaultWindowGroupId);

 	RWindow window;

 	ConstructWindowL(window, KPixmapSize);

 	CleanupClosePushL(window);

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create a reference bitmap which we use to init the SgImage (we use index=2)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

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

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 1 RSgImage"));

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	TInt ret = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 	ASSERT_EQUALS(ret, KErrNone);

 	// If create window surface fails, don't fail if there's no matching config (but fail in any other situation):

     //		Support for a window surface is not mandated any pixel format

     //		We should not enforce it in the tests

     //		Silently terminate the test without failing.

 	TEglTestConfig windowFormat = EglTestConversion::VgFormatToWindowSurfaceFormat(iSurfaceFormat);

 	EGLConfig config = 0;

 	TRAPD(res, config = iEglSess->GetConfigExactMatchL( windowFormat ));

 	if(res == KTestNoMatchingConfig)

 		{

 		INFO_PRINTF1(_L("Creation of window surface has failed, the test case for that configuration will be skipped"));

 		CleanupStack::PopAndDestroy(3, &window); // window, bitmap, sgimage

 		CloseWsSession();

 		CleanAll();

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

     User::LeaveIfError(res); // leave here if any other error was raised other than the one above.

 	iEglSess->CreateWindowSurfaceAndMakeCurrentL(config, window, windowFormat == EWindowAttribsColor16MAP);

 	INFO_PRINTF1(_L("Creating 1 EGLImage from the RSgImage"));

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage"));

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

 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

 	// 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, KPixmapSize.iWidth, KPixmapSize.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 = 0x00ff00ff; // opaque 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, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		}

 	// destroy eglimage and vgimage

 	vgDestroyImage(vgImage);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

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

 	// Check that the surface contains the expected pixels

 	//  # if the source is a A_8, to compare the surface with a reference bitmap, the following is needed:

 	//    a) a reference bitmap needs to be cleared to black (same colour as the surface was cleared to)

 	//    b) a Pen bitmap, that we clear to green (same colour as the fillPaint used to draw to the surface)

 	//    c) a mask bitmap, which is the reference bitmap used to create the SgImage

 	//  # otherwise, the surface must contain the same pixels as the bitmap used to create the SgImage 

 	if (iSourceFormat == EUidPixelFormatA_8)

 		{

 		// we need a reference bitmap with the same pixel format as the target surface

 		TUidPixelFormat format = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 		TDisplayMode refbitmapMode = EglTestConversion::PixelFormatToDisplayMode(format);

 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceMaskedBitmapL(refbitmapMode, KRgbGreen, bitmap);

 		CleanupStack::PushL(refBitmap);

 		// compare the obtained reference bitmap with the surface drawn

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		}

 	else

 		{

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 		}

 	INFO_PRINTF1(_L("Content is as expected"));

     eglSwapBuffers(iDisplay,iEglSess->Surface());

     // cleanup, destroy the window surface before native window.

     iEglSess->CleanupSurfaceAndContextL();

 	CleanupStack::PopAndDestroy(3, &window); // window, bitmap, sgimage

 	CloseWsSession();

 	CleanAll();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0172

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check that it is possible to draw a VGImage (created from an RSgImage) to a pixmap surface created from an RSGImage

 @SYMTestActions

 Create a reference Bitmap

 Create and fully construct an RSgImage object having the same content as the reference bitmap 

 •	Set the iUsage bit 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

 Create and make current and EGL context bound to OVG APIs and linked to a pixmap surface.

 •	Set the iUsage bit of the underlying RSgImage to ESgUsageBitOpenVgSurface 

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

 •	Check for errors

 Use OpenVG to copy the 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 RSgImage 

 Check that the pixmap surface matches the content from the reference bitmap.

 Destroy the pixmap surface

 Destroy the RSgImage

 Check for memory and handle leaks

 @SYMTestExpectedResults

 pixmap surface matches the content from the reference bitmap 

 The test will loop through all the possible PixelFormat available for source 

 RSgImages and Destination Surfaces

 •	EUidPixelFormatRGB_565

 •	EUidPixelFormatXRGB_8888

 •	EUidPixelFormatARGB_8888 (source only)

 •	EUidPixelFormatARGB_8888_PRE

 •	EUidPixelFormatA_8  (source only)

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_VgImage_To_Pixmap::doTestStepL()

 	{

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

 	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_VgImage_To_Pixmap::doTestPartialStepL()

 	{

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

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create a reference bitmap which we use to init the SgImage (we use index=7)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

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

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 1 RSgImage"));

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	TInt ret = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 	ASSERT_EQUALS(ret, KErrNone);

 	INFO_PRINTF1(_L("Creating 1 EGLImage from it"));

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 	TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KPixmapSize);

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

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

 	INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage"));

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

 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

 	// 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, KPixmapSize.iWidth, KPixmapSize.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 = 0x00ff00ff; // opaque 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, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		}

 	// destroy eglimage and vgimage

 	vgDestroyImage(vgImage);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

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

 	// Check that the surface contains the expected pixels

 	//  # if the source is a A_8, to compare the surface with a reference bitmap, the following is needed:

 	//    a) a reference bitmap needs to be cleared to black (same colour as the surface was cleared to)

 	//    b) a Pen bitmap, that we clear to green (same colour as the fillPaint used to draw to the surface)

 	//    c) a mask bitmap, which is the reference bitmap used to create the SgImage

 	//  # otherwise, the surface must contain the same pixels as the bitmap used to create the SgImage 

 	if (iSourceFormat == EUidPixelFormatA_8)

 		{

 		// we need a reference bitmap with the same pixel format as the target surface

 		TUidPixelFormat format = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 		TDisplayMode refbitmapMode = EglTestConversion::PixelFormatToDisplayMode(format);

 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceMaskedBitmapL(refbitmapMode, KRgbGreen, bitmap);

 		CleanupStack::PushL(refBitmap);

 		// compare the obtained reference bitmap with the surface drawn

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		}

 	else

 		{

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 		}

 	INFO_PRINTF1(_L("Content is as expected"));

 	//cleanup

 	CleanupStack::PopAndDestroy(2, bitmap); // bitmap, sgImage

 	CleanAll();

 	return TestStepResult();

 	}

 /**

 @SYMTestCaseID GRAPHICS-EGL-0173

 @SYMTestPriority 1

 @SYMPREQ 39

 @SYMREQ See SGL.GT0386.401 document

 @SYMTestCaseDesc

 Check that it is possible to draw a VGImage (created from an RSgImage) to a pixmap surface based upon a CFbsBitmap, created from a CFbsBitmap Surface,.

 @SYMTestActions

 Create a reference Bitmap

 Create and fully construct an RSgImage object having the same content as the reference bitmap 

 •	Set the iUsage bit to ESgUsageBitOpenVgImage

 Create and make current and EGL context bound to OVG APIs and linked to a pixmap surface based upon a CFbsBitmap.

 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

 Use OpenVG to copy the 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 RSgImage 

 Check that the pixmap surface matches the content from the reference bitmap.

 Destroy the pixmap surface

 Destroy the CFbsBitmap

 Check for memory and handle leaks

 @SYMTestExpectedResults

 pixmap surface matches the content from the reference bitmap

 The test will loop through all the possible PixelFormat available for source RSgImages and Destination Surfaces

 •	EUidPixelFormatRGB_565

 •	EUidPixelFormatXRGB_8888

 •	EUidPixelFormatARGB_8888 (source only)

 •	EUidPixelFormatARGB_8888_PRE

 •	EUidPixelFormatA_8  (source only)

 No memory or handle leaks

 */

 TVerdict CEglTest_EGL_Image_VGImage_To_Pixmap_CFbs::doTestStepL()

 	{

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

 	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 numPixmapFbsSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapFbsSurfaceFormats);

 	TInt numImageSourceFormats = iniParser->GetNumberOfFormats(KSectionImageSourceFormats);

 	if(!numImageSourceFormats && !numPixmapFbsSurfaceFormats)

 		{

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

 		User::Leave(KErrArgument);

 		}

 	for(TUint j=0; j < numPixmapFbsSurfaceFormats; 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_VGImage_To_Pixmap_CFbs::doTestPartialStepL()

 	{

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

 	PrintUsedPixelConfiguration();

 	// Create display object

 	GetDisplayL();

 	CreateEglSessionL();

 	iEglSess->InitializeL();

 	iEglSess->OpenSgDriverL();

 	// Create a reference bitmap which we use to init the SgImage (we use index=7)

 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

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

 	CleanupStack::PushL(bitmap);

 	INFO_PRINTF1(_L("Creating 1 RSgImage"));

 	RSgImage sgImage;

 	CleanupClosePushL(sgImage);

 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KPixmapSize);

 	TInt ret = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 	ASSERT_EQUALS(ret, KErrNone);

 	// If create pixmap fails, don't fail if there's no matching config (but fail in any other situation):

     //		Support for a pixmap surface from CFbsBitmap is not mandatory

     //		We should not enforce it in the tests

     //		Silently terminate the test without failing.

 	TDisplayMode surfaceBitmapMode = EglTestConversion::VgFormatToDisplayMode(iSurfaceFormat);

 	TRAPD(res, iEglSess->CreatePixmapSurfaceAndMakeCurrentAndMatchL(KPixmapSize, surfaceBitmapMode, EGL_OPENVG_API));

     if(res == KTestNoMatchingConfig)

 		{

 	    WARN_PRINTF2(_L("Can't create pixmap surface based on bitmap in mode %d, the test will be skipped"), surfaceBitmapMode);

 		CleanupStack::PopAndDestroy(bitmap); 

 		CleanAll();

 		RecordTestResultL();

 		CloseTMSGraphicsStep();

 		return TestStepResult();

 		}

     User::LeaveIfError(res); // leave here if any other error was raised other than the one above.

 	INFO_PRINTF1(_L("Creating 1 EGLImage from the RSgImage"));

 	// Create an EGLImage from the RSgImage

 	EGLImageKHR imageKHR = iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &sgImage, KEglImageAttribsPreservedTrue);

 	ASSERT_EGL_TRUE(imageKHR != EGL_NO_IMAGE_KHR);

 	INFO_PRINTF1(_L("Creating 1 VGImage from the EGLImage"));

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

 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

 	// 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, KPixmapSize.iWidth, KPixmapSize.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 = 0x00ff00ff; // opaque 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, KPixmapSize.iWidth, KPixmapSize.iHeight);

 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

 		eglWaitClient();

 		}

 	// destroy eglimage and vgimage

 	vgDestroyImage(vgImage);

 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

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

 	// Check that the surface contains the expected pixels

 	//  # if the source is a A_8, to compare the surface with a reference bitmap, the following is needed:

 	//    a) a reference bitmap needs to be cleared to black (same colour as the surface was cleared to)

 	//    b) a Pen bitmap, that we clear to green (same colour as the fillPaint used to draw to the surface)

 	//    c) a mask bitmap, which is the original reference bitmap used to create the SgImage

 	//  # otherwise, the surface must contain the same pixels as the bitmap used to create the SgImage 

 	if (iSourceFormat == EUidPixelFormatA_8)

 		{

 		// we need a reference bitmap with the same pixel format as the target surface

 		TUidPixelFormat format = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

 		TDisplayMode refbitmapMode = EglTestConversion::PixelFormatToDisplayMode(format);

 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceMaskedBitmapL(refbitmapMode, KRgbGreen, bitmap);

 		CleanupStack::PushL(refBitmap);

 		// compare the obtained reference bitmap with the surface drawn

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

 		CleanupStack::PopAndDestroy(refBitmap);

 		}

 	else

 		{

 		iEglSess->CheckVgDrawingL(iSurfaceFormat, bitmap);

 		}

 	INFO_PRINTF1(_L("Content is as expected"));

 	//cleanup

 	CleanupStack::PopAndDestroy(2, bitmap); //bitmap, sgImage 

 	CleanAll();

 	return TestStepResult();

 	}