// 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
#ifndef __INIPARSER_H__
#include <cinidata.h>
#endif // __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();
	}