egl/egltest/src/egltest_createpixmapsurface.cpp
changeset 0 5d03bc08d59c
equal deleted inserted replaced
-1:000000000000 0:5d03bc08d59c
       
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 //
       
    15 
       
    16 /**
       
    17  @file
       
    18  @test 
       
    19 */
       
    20 
       
    21 #include "egltest_createpixmapsurface.h"
       
    22 
       
    23 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
       
    24 #include <sgresource/sgimage.h>
       
    25 #else
       
    26 #include <graphics/sgimage.h>
       
    27 #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
       
    28 #include <test/tefunit.h> // for ASSERT macros
       
    29 
       
    30 #include <test/egltestcommonconversion.h>
       
    31 #include <test/egltestcommoninisettings.h>
       
    32 #include <test/egltestcommonsgimageinfo.h>
       
    33 
       
    34 
       
    35 
       
    36 /**
       
    37 @SYMTestCaseID GRAPHICS-EGL-0063
       
    38 
       
    39 @SYMTestPriority 1
       
    40 
       
    41 @SYMPREQ 39
       
    42 
       
    43 @SYMREQ See SGL.GT0386.401 document
       
    44 
       
    45 @SYMTestCaseDesc
       
    46 This test ensures the matching algorithm between EGLConfig and RSgImages when the RSgImage format is EUidPixelFormatARGB_8888_PRE.
       
    47 The algorithm is tested in both eglChooseConfig and eglCreatePixmap.
       
    48 
       
    49 @SYMTestActions
       
    50 Create an RSgImage format with the following parameters:
       
    51 * format: EUidPixelFormatARGB_8888_PRE
       
    52 * usage: ESgUsageBitOpenVgSurface
       
    53 Create second RSgImage format with the following parameters:
       
    54 * format: EUidPixelFormatXRGB_8888
       
    55 * usage: ESgUsageBitOpenVgSurface
       
    56 
       
    57 Query a compatible config via eglChooseConfig.
       
    58 If we get one compatible config check that is accepted by eglCreatePixmapSurface.
       
    59 1) call eglCreatePixmap with the just queried config and as attribute:
       
    60 	* EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_NONPRE
       
    61 	* as native pixmap format supply RSgImage with premultiply alpha   
       
    62 This call has to fail and give back a EGL_BAD_MATCH error.
       
    63 2) call eglCreatePixmapSurface with the just queried config and as attribute:
       
    64     * EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE
       
    65     * as native pixmap format supply RSgImage with non-premultiply alpha   
       
    66 This call has to fail and give back a EGL_BAD_MATCH error.
       
    67 3) call eglCreatePixmapSurface with the just queried config and as attribute:
       
    68 	* EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE
       
    69 This call has to succed.
       
    70 No memory or handle leaks.
       
    71 
       
    72 @SYMTestExpectedResults
       
    73 The first and second calls to eglCreatePixmapSurface have to fail and give back a EGL_BAD_MATCH error.
       
    74 The third call has to succed.
       
    75 No memory or handle leaks.
       
    76 */
       
    77 TVerdict CEglTest_CreatePixmapSurface_Alpha_bit_RSgImage::doTestStepL()
       
    78 	{
       
    79 	SetTestStepID(_L("GRAPHICS-EGL-0063"));
       
    80 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_Alpha_bit_RSgImage::doTestPartialStepL"));	
       
    81 
       
    82 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap);
       
    83 	if(!ret)
       
    84 		{
       
    85 		// The extension is not supported
       
    86 		RecordTestResultL();
       
    87 		CloseTMSGraphicsStep();
       
    88 		return TestStepResult();
       
    89 		}
       
    90 
       
    91 	// Create display object
       
    92 	GetDisplayL();
       
    93 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);
       
    94 	eglSess->InitializeL();
       
    95 	
       
    96 	eglSess->OpenSgDriverL();
       
    97 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(EUidPixelFormatARGB_8888_PRE);
       
    98     RSgImage sgImageWithPre;
       
    99     // Create a SgImage ARGB_8888_PRE
       
   100 	CleanupClosePushL(sgImageWithPre);
       
   101     ret = sgImageWithPre.Create(imageInfo, NULL, NULL);
       
   102     ASSERT_EQUALS(ret, KErrNone);
       
   103     
       
   104 	EGLint numConfigsWithPre = 0;		
       
   105 	EGLConfig configWithPre[KMaxEglConfigs];
       
   106 	const EGLint KAttrib_list_ImageWithPre[] = { EGL_MATCH_NATIVE_PIXMAP,	(TInt)&sgImageWithPre,
       
   107 												 EGL_RENDERABLE_TYPE, 		EGL_OPENVG_BIT,
       
   108 												 EGL_SURFACE_TYPE, 			EGL_PIXMAP_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,
       
   109 												 EGL_NONE };
       
   110 
       
   111 	INFO_PRINTF1(_L("Calling eglChooseConfig with the EGL_MATCH_NATIVE_PIXMAP flag set"));
       
   112 	eglChooseConfig(iDisplay,KAttrib_list_ImageWithPre,configWithPre,KMaxEglConfigs,&numConfigsWithPre);
       
   113     if(!numConfigsWithPre)
       
   114         {
       
   115         ERR_PRINTF1(_L("No EGL Config with EGL_VG_ALPHA_FORMAT_PRE available for EUidPixelFormatARGB_8888_PRE"));
       
   116         SetTestStepResult(EFail);           
       
   117         }
       
   118 
       
   119 	for(TInt index = 0; index < numConfigsWithPre; index++)
       
   120 	    {
       
   121 	    INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)"));
       
   122 	    ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));
       
   123 	
       
   124 	    INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));
       
   125 		eglSess->SetExpectedError(EGL_BAD_MATCH);
       
   126 		EGLSurface surface = eglCreatePixmapSurface(iDisplay, configWithPre[index],&sgImageWithPre, KPixmapAttribsVgAlphaFormatNonPre);
       
   127 		if ( !eglSess->CheckExpectedError(EGL_FALSE) )
       
   128 			{
       
   129 			ERR_PRINTF1(_L("eglCreatePixmapSurface didn't fail as expected."));
       
   130 			SetTestStepResult(EFail);			
       
   131 			if(surface != EGL_NO_SURFACE)
       
   132 				{
       
   133 				eglDestroySurface(iDisplay,surface);
       
   134 				eglSess->CheckExpectedError(EGL_SUCCESS);
       
   135 				surface = EGL_NO_SURFACE;
       
   136 				}
       
   137 			}		
       
   138 	
       
   139 		surface = eglCreatePixmapSurface(iDisplay, configWithPre[index],&sgImageWithPre, KPixmapAttribsVgAlphaFormatPre);
       
   140 		if ( !eglSess->CheckExpectedError(EGL_TRUE) )
       
   141 			{
       
   142 			ERR_PRINTF1(_L("eglCreatePixmapSurface failed."));
       
   143 			SetTestStepResult(EFail);			
       
   144 			}
       
   145 		if(surface != EGL_NO_SURFACE)
       
   146 			{
       
   147 			eglDestroySurface(iDisplay,surface);
       
   148 			eglSess->CheckExpectedError(EGL_SUCCESS);
       
   149 			surface = EGL_NO_SURFACE;
       
   150 			}		
       
   151 		}
       
   152 	
       
   153 	CleanupStack::PopAndDestroy(2,eglSess);
       
   154 	TerminateDisplayL();
       
   155 	RecordTestResultL();
       
   156 	CloseTMSGraphicsStep();
       
   157 	return TestStepResult();
       
   158 	}
       
   159 
       
   160 
       
   161 /**
       
   162 @SYMTestCaseID GRAPHICS-EGL-0066
       
   163 
       
   164 @SYMTestPriority 1
       
   165 
       
   166 @SYMPREQ 39
       
   167 
       
   168 @SYMREQ See SGL.GT0386.401 document
       
   169 
       
   170 @SYMTestCaseDesc
       
   171 Test passing a non-initialised RSgImage into eglCreatePixmapSurface()
       
   172 
       
   173 @SYMTestActions
       
   174 Initialise the thread to use RSgImage as the native pixmap type
       
   175 For each config returned from eglGetConfig() that supports OpenGLES or OpenVG rendering to pixmaps
       
   176 	*	Create an empty RSgImage object but do not initialize it
       
   177 	*	Use eglCreatePixmapSurface() to construct a surface from the RSgImage object.
       
   178 		o	Use a NULL attrib_list
       
   179 	*	Close the RSgImage object
       
   180 
       
   181 @SYMTestExpectedResults
       
   182 Check that eglCreatePixmapSurface() returns EGL_NO_SURFACE
       
   183 Check that eglGetError() returns EGL_BAD_NATIVE_PIXMAP
       
   184 Check for memory and handle leaks.
       
   185 */
       
   186 TVerdict CEglTest_CreatePixmapSurface_RSgImage_Negative_RSgImage_NotInitialised::doTestStepL()
       
   187 	{
       
   188 	SetTestStepID(_L("GRAPHICS-EGL-0066"));
       
   189 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_RSgImage_Negative_RSgImage_NotInitialised::doTestStepL"));
       
   190 
       
   191 	TBool ret = CheckForExtensionL(KEGL_RSgimage);
       
   192 	if(!ret)
       
   193 		{
       
   194 		// The extension is not supported
       
   195 		RecordTestResultL();
       
   196 		CloseTMSGraphicsStep();
       
   197 		return TestStepResult();
       
   198 		}
       
   199 
       
   200 	// Create display object
       
   201 	GetDisplayL();
       
   202 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);
       
   203 	eglSess->InitializeL();
       
   204 
       
   205 	EGLConfig configs[KMaxEglConfigs];
       
   206 	EGLint numConfigs=0;
       
   207 
       
   208 	// Query number of configs available
       
   209 	INFO_PRINTF1(_L("Calling eglGetConfigs to get the number of configs available..."));
       
   210 	ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, NULL, KMaxTInt, &numConfigs));
       
   211 
       
   212 	INFO_PRINTF1(_L("Checking number of configs..."));
       
   213 	ASSERT_TRUE(numConfigs >= 1);
       
   214 	ASSERT_TRUE(numConfigs <= KMaxEglConfigs);
       
   215 	INFO_PRINTF2(_L("Found %d configs"), numConfigs);
       
   216 		
       
   217 	// Get the configs
       
   218 	INFO_PRINTF1(_L("Calling eglGetConfigs to get configs..."));
       
   219 	ASSERT_EGL_TRUE(eglGetConfigs(iDisplay, configs, KMaxEglConfigs, &numConfigs));
       
   220 	
       
   221 	for(TUint index = 0; index < numConfigs; index++)
       
   222 		{
       
   223 		INFO_PRINTF2(_L("Getting Config Attributes for index %d"), index);
       
   224 		
       
   225 		EGLint surfaceType=0;
       
   226 		ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, configs[index], EGL_SURFACE_TYPE, &surfaceType));
       
   227 		if (!(surfaceType & EGL_PIXMAP_BIT))
       
   228 			{
       
   229 			// This is just an info print because we don't want to test surfaces that do not support pixmaps.
       
   230 			VERBOSE_INFO_PRINTF1(_L("Skipping config: Does not support pixmaps"));
       
   231 			continue;
       
   232 			}
       
   233 		
       
   234 		EGLint renderableType=0;
       
   235 		RSgImage sgImage; // Deliberately don't initialise it
       
   236 		ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, configs[index], EGL_RENDERABLE_TYPE, &renderableType));		
       
   237 		if (renderableType & EGL_OPENVG_BIT)
       
   238 			{
       
   239 			VERBOSE_INFO_PRINTF1(_L("...is OpenVg renderable"));
       
   240 			eglSess->OpenSgDriverL();
       
   241 			
       
   242 			// Need to set the API type before creating the context (H/W requires this to be done before the surface is created, rather than the context)
       
   243 			VERBOSE_INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENVG_API)"));
       
   244 			ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));
       
   245 			
       
   246 			// Create a pixmap surface from the native image
       
   247 			VERBOSE_INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));
       
   248 			EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[index], &sgImage, KPixmapAttribsNone);
       
   249 			
       
   250 			// Expect this to fail
       
   251 			ASSERT_EQUALS(surface, EGL_NO_SURFACE);
       
   252 	 		ASSERT_EGL_ERROR(EGL_BAD_NATIVE_PIXMAP);
       
   253 			eglSess->CloseSgDriver();
       
   254 			}
       
   255 		
       
   256 		if ((renderableType & EGL_OPENGL_ES_BIT) || (renderableType & EGL_OPENGL_ES2_BIT))
       
   257 			{
       
   258 			VERBOSE_INFO_PRINTF1(_L("...is OpenGles renderable"));
       
   259 			eglSess->OpenSgDriverL();
       
   260 			
       
   261 			// Need to set the API type before creating the context (H/W requires this to be done before the surface is created, rather than the context)
       
   262 			VERBOSE_INFO_PRINTF1(_L("Calling eglBindAPI(EGL_OPENGL_ES_API)"));
       
   263 			ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENGL_ES_API));
       
   264 			
       
   265 			// Create a pixmap surface from the native image
       
   266 			VERBOSE_INFO_PRINTF1(_L("Calling eglCreatePixmapSurface"));
       
   267 			EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[index], &sgImage, KPixmapAttribsNone);
       
   268 			
       
   269 			// Expect this to fail
       
   270 			ASSERT_EQUALS(surface, EGL_NO_SURFACE);
       
   271 	 		ASSERT_EGL_ERROR(EGL_BAD_NATIVE_PIXMAP);
       
   272 			eglSess->CloseSgDriver();
       
   273 			}
       
   274 		}	
       
   275 	
       
   276 	CleanupStack::PopAndDestroy(eglSess);
       
   277 	TerminateDisplayL();
       
   278 	RecordTestResultL();
       
   279 	CloseTMSGraphicsStep();
       
   280 	return TestStepResult();
       
   281 	}
       
   282 
       
   283 /**
       
   284 @SYMTestCaseID GRAPHICS-EGL-0075
       
   285 
       
   286 @SYMTestPriority 1
       
   287 
       
   288 @SYMPREQ 39
       
   289 
       
   290 @SYMREQ See SGL.GT0386.401 document
       
   291 
       
   292 @SYMTestCaseDesc
       
   293 Test that the system can detect obviously invalid pixmap objects 
       
   294 
       
   295 @SYMTestActions
       
   296 Try to create a pixmap surface from an odd integer
       
   297 
       
   298 @SYMTestExpectedResults
       
   299 This should fail with EGL_BAD_NATIVE_PIXMAP
       
   300 Check that all memory and handles have been deallocated.
       
   301 */
       
   302 TVerdict CEglTest_CreatePixmapSurface_Negative_Invalid_Pixmap_Type::doTestStepL()
       
   303 	{
       
   304 	SetTestStepID(_L("GRAPHICS-EGL-0075"));
       
   305 	INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_Negative_Invalid_Pixmap_Type::doTestStepL"));
       
   306 
       
   307 	// Create display object
       
   308 	GetDisplayL();
       
   309 	
       
   310 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);
       
   311 
       
   312 	// Initialise the display object
       
   313 	eglSess->InitializeL();
       
   314 	eglSess->OpenSgDriverL();
       
   315 	
       
   316     EGLConfig configs[KMaxEglConfigs];
       
   317 	EGLint numConfigs=0;
       
   318 
       
   319 	const EGLint KConfigAttribPixmapSurface[] = 
       
   320 		{
       
   321 		EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
       
   322 		EGL_SURFACE_TYPE, EGL_PIXMAP_BIT,
       
   323 		EGL_NONE
       
   324 		};
       
   325 	
       
   326 	// Query number of configs available
       
   327     INFO_PRINTF1(_L("Calling eglChooseConfig to get the number of configs available for pixmap surfaces..."));
       
   328 	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribPixmapSurface, NULL, KMaxTInt, &numConfigs));
       
   329 
       
   330 	INFO_PRINTF1(_L("Checking number of configs..."));
       
   331 	ASSERT_TRUE(numConfigs >= 1);
       
   332 	ASSERT_TRUE(numConfigs <= KMaxEglConfigs);
       
   333 	INFO_PRINTF2(_L("Found %d configs"), numConfigs);
       
   334 		
       
   335 	// Get the configs
       
   336 	INFO_PRINTF1(_L("Calling eglChooseConfig to get configs..."));
       
   337 	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribPixmapSurface, configs, KMaxEglConfigs, &numConfigs));
       
   338 	
       
   339 	EGLint badPixmap=12345;
       
   340 	
       
   341 	EGLSurface surface = eglCreatePixmapSurface(iDisplay, configs[0], &badPixmap, NULL);	
       
   342 	eglSess->SetExpectedError(EGL_BAD_NATIVE_PIXMAP);	
       
   343 	ASSERT_TRUE(eglSess->CheckExpectedError(surface));
       
   344 	
       
   345 	CleanupStack::PopAndDestroy(eglSess);
       
   346 	TerminateDisplayL();
       
   347 	RecordTestResultL();
       
   348 	CloseTMSGraphicsStep();
       
   349 	return TestStepResult();
       
   350 	}
       
   351 
       
   352 /**
       
   353 @SYMTestCaseID GRAPHICS-EGL-0420
       
   354 
       
   355 @SYMTestPriority 1
       
   356 
       
   357 @SYMPREQ 2637
       
   358 
       
   359 @SYMREQ See SGL.GT0386.401 document
       
   360 
       
   361 @SYMTestCaseDesc
       
   362 Test the successful creation and use of a pixmap surface for all supporting configs.
       
   363 
       
   364 @SYMTestActions
       
   365 Initialize the thread to use RSgImage as the native pixmap type.
       
   366 For each supported combination of pixel mode and usage bits (see Graphics Resource documentation for detail)
       
   367 •   Create an SgImage
       
   368 •   Choose EGL config, supplying in attribute list as EGL_MATCH_NATIVE_PIXMAP the SgImage created on the previous step
       
   369 •   For each configuration obtained on the previous step and for three possible resource close rules (close SgImage late, close SgImage early, close SgDriver and SgImage early):
       
   370 o   Use eglCreatePixmapSurface() to construct a surface from the RSgImage object and make it current
       
   371 o   Make some basic drawing to the surface (fill the area with pre-defined  colour)
       
   372 o   Call eglWaitClient() to finish the above drawing instructions synchronously.
       
   373 o   Deallocate the surface and the pixmap
       
   374 
       
   375 @SYMTestExpectedResults
       
   376 There is at least one configuration available for all mandatory combinations of pixel formats and usage bits.
       
   377 Use EGL client API to check that the surface with underlying SgImage has the expected pixel data.
       
   378 */
       
   379 TVerdict CEglTest_CreatePixmapSurface_RSgImage_Positive_MantadoryFormatUsageSupport::doTestStepL()
       
   380     {
       
   381     SetTestStepID(_L("GRAPHICS-EGL-0420"));
       
   382     INFO_PRINTF1(_L("CEglTest_CreatePixmapSurface_RSgImage_Positive_MantadoryFormatUsageSupport::doTestStepL"));
       
   383 
       
   384 	TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KEGL_KHR_image_pixmap);
       
   385 	if(!ret)
       
   386 		{
       
   387 		// The extension is not supported
       
   388 		RecordTestResultL();
       
   389 		CloseTMSGraphicsStep();
       
   390 		return TestStepResult();
       
   391 		}
       
   392 
       
   393 	// Create display object
       
   394 	GetDisplayL();
       
   395 	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);
       
   396 	eglSess->InitializeL();
       
   397 	eglSess->OpenSgDriverL();
       
   398 
       
   399     // Initialise ini parser
       
   400     CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();
       
   401     CleanupStack::PushL(iniParser);
       
   402     TInt numPixmapSgSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);
       
   403     
       
   404 #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
       
   405     const EGLint KSgPixmapUsageSupport[] =
       
   406         {
       
   407         ESgUsageBitOpenVgSurface,         
       
   408         ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface,
       
   409         ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Texture2D,
       
   410         ESgUsageBitOpenVgSurface | ESgUsageBitOpenVgImage| ESgUsageBitOpenGles2Texture2D,
       
   411         ESgUsageBitOpenGles2Surface,
       
   412         ESgUsageBitOpenGles2Surface | ESgUsageBitOpenVgImage,
       
   413         ESgUsageBitOpenGles2Texture2D |ESgUsageBitOpenGles2Surface,
       
   414         ESgUsageBitOpenVgImage | ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface
       
   415         };
       
   416 
       
   417     for(TInt i = 0; i < numPixmapSgSurfaceFormats; i++)
       
   418         {
       
   419         VGImageFormat surfaceFormat = iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);
       
   420         TSgImageInfoTest imageInfo = TSgImageInfoTest();
       
   421         imageInfo.iPixelFormat = EglTestConversion::VgFormatToSgPixelFormat(surfaceFormat);;
       
   422         EGLint alphaPreBit = (imageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) ? EGL_VG_ALPHA_FORMAT_PRE_BIT : 0;
       
   423         TInt numUsageCombinations = sizeof(KSgPixmapUsageSupport) / sizeof(KSgPixmapUsageSupport[0]);
       
   424         for(TUint32 j = 0; j < numUsageCombinations; j++)
       
   425             {
       
   426             if(KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface))
       
   427                 {
       
   428                 if(!eglSess->IsOpenGLES2Supported())
       
   429                     continue;
       
   430                 }
       
   431             if(KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface))
       
   432                 {
       
   433                 if(!eglSess->IsOpenGLESSupported())
       
   434                     continue;
       
   435                 }
       
   436 
       
   437             imageInfo.iUsage = KSgPixmapUsageSupport[j]; 
       
   438             RSgImage image;
       
   439             ASSERT_EQUALS(image.Create(imageInfo, NULL, NULL), KErrNone);
       
   440             CleanupClosePushL(image);
       
   441             TSgImageInfoTest imageInfoSupported; 
       
   442             ASSERT_EQUALS(image.GetInfo(imageInfoSupported), KErrNone);//returned info may include more usage bits than we actually requested
       
   443             if(((imageInfoSupported.iUsage & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface)) && 
       
   444                                (!eglSess->IsOpenGLES2Supported()) ||
       
   445                 ((imageInfoSupported.iUsage & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface)) && 
       
   446                                (!eglSess->IsOpenGLESSupported()))))
       
   447                 {
       
   448                 CleanupStack::PopAndDestroy(&image);
       
   449                 continue;
       
   450                 }	
       
   451             
       
   452             EGLint eglRenderableTypeValue = 0;
       
   453             if(imageInfoSupported.iUsage & ESgUsageBitOpenVgSurface)
       
   454                 {
       
   455                 eglRenderableTypeValue = EGL_OPENVG_BIT;
       
   456                 }
       
   457             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGles2Surface)
       
   458                 {
       
   459                 eglRenderableTypeValue = EGL_OPENGL_ES2_BIT;
       
   460                 }
       
   461             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGlesSurface)
       
   462                 {
       
   463                 eglRenderableTypeValue = EGL_OPENGL_ES_BIT;
       
   464                 }
       
   465             else if(imageInfoSupported.iUsage & ESgUsageBitOpenGlSurface)
       
   466                 {
       
   467                 eglRenderableTypeValue = EGL_OPENGL_BIT;
       
   468                 }
       
   469             TEST(eglRenderableTypeValue != 0);
       
   470 
       
   471             // only minimum amount of renderable type matching to Native pixmap will be passed into attribute list.
       
   472             // And egl will decide whatever configs include at least given renderable type.
       
   473             const EGLint KAttrib_list[] = { EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(&image),
       
   474 											EGL_RENDERABLE_TYPE, eglRenderableTypeValue,
       
   475 											EGL_SURFACE_TYPE, EGL_PIXMAP_BIT | alphaPreBit,
       
   476 											EGL_NONE };     
       
   477             
       
   478             EGLConfig configs[KMaxEglConfigs];
       
   479             EGLint numConfigs=0;
       
   480             ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_list,configs, KMaxEglConfigs,&numConfigs));
       
   481             CleanupStack::PopAndDestroy(&image);
       
   482             TEST(numConfigs > 0);
       
   483             
       
   484             for(TInt index = 0; index < numConfigs; index++)
       
   485                 {
       
   486                 const TInt numCloseRules = 3; 
       
   487                 for(TInt closeRule = 0; closeRule < numCloseRules; closeRule++)
       
   488                     {
       
   489                     CTestEglSession::TResourceCloseRule resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;
       
   490                     switch(closeRule)
       
   491                         {
       
   492                     case 0:
       
   493                         VERBOSE_INFO_PRINTF1(_L("Close Image Late"));
       
   494                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;
       
   495                         break;
       
   496                     case 1:
       
   497                         VERBOSE_INFO_PRINTF1(_L("Close Image Early"));
       
   498                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageEarly;
       
   499                         break;
       
   500                     case 2:
       
   501                         VERBOSE_INFO_PRINTF1(_L("Close Sg Driver and Image Early"));
       
   502                         resourceCloseRule = CTestEglSession::EResourceCloseSgDriverAndImageEarly;
       
   503                         break;
       
   504                     default:
       
   505                         break;
       
   506                         }
       
   507                 
       
   508                     if (KSgPixmapUsageSupport[j] & ESgUsageBitOpenVgSurface)
       
   509                         {
       
   510                         VERBOSE_INFO_PRINTF1(_L("...is OpenVG renderable"));
       
   511                         eglSess->TryUsePixmapRSgImageOpenVgL(configs[index], imageInfo, resourceCloseRule); // we can't fail to create an image as we have already tried it 
       
   512                         }
       
   513                     if (KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGlesSurface | ESgUsageBitOpenGlesTexture2D))
       
   514                         {
       
   515                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES renderable"));
       
   516                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 1); // we can't fail to create an image as we have already tried it
       
   517                         }
       
   518                     if (KSgPixmapUsageSupport[j] & (ESgUsageBitOpenGles2Surface | ESgUsageBitOpenGles2Texture2D))
       
   519                         {
       
   520                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES2 renderable"));
       
   521                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 2); // we can't fail to create an image as we have already tried it
       
   522                         }
       
   523                     }//for(TInt closeRule; closeRule < numCloseRules; closeRule++)
       
   524                 }//for(TInt index = 0; index < numConfigs; index++)
       
   525             }//for(TUint32 j = 0; j < numUsageCombinations; j++)
       
   526         }//for(TInt i = 0; i < numSgImagePixelFormatSupport; i++)
       
   527 #else
       
   528     const EGLint KSgPixmapUsageSupport[] =
       
   529         {
       
   530         ESgUsageOpenVgTarget,         
       
   531         ESgUsageOpenVgImage | ESgUsageOpenVgTarget,
       
   532         ESgUsageOpenVgTarget | ESgUsageOpenGles2Texture2D,
       
   533         ESgUsageOpenVgTarget | ESgUsageOpenVgImage| ESgUsageOpenGles2Texture2D,
       
   534         ESgUsageOpenGles2Target,
       
   535         ESgUsageOpenGles2Target | ESgUsageOpenVgImage,
       
   536         ESgUsageOpenGles2Texture2D |ESgUsageOpenGles2Target,
       
   537         ESgUsageOpenVgImage | ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target
       
   538         };
       
   539 
       
   540     for(TInt i = 0; i < numPixmapSgSurfaceFormats; i++)
       
   541         {
       
   542         VGImageFormat surfaceFormat = iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);
       
   543         TSgImageInfoTest imageInfo = TSgImageInfoTest();
       
   544         imageInfo.iPixelFormat = EglTestConversion::VgFormatToSgPixelFormat(surfaceFormat);;
       
   545         EGLint alphaPreBit = (imageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) ? EGL_VG_ALPHA_FORMAT_PRE_BIT : 0;
       
   546         TInt numUsageCombinations = sizeof(KSgPixmapUsageSupport) / sizeof(KSgPixmapUsageSupport[0]);
       
   547         for(TUint32 j = 0; j < numUsageCombinations; j++)
       
   548             {
       
   549             if(KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target))
       
   550                 {
       
   551                 if(!eglSess->IsOpenGLES2Supported())
       
   552                     continue;
       
   553                 }
       
   554             if(KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGlesTarget))
       
   555                 {
       
   556                 if(!eglSess->IsOpenGLESSupported())
       
   557                     continue;
       
   558                 }
       
   559             imageInfo.iUsage = KSgPixmapUsageSupport[j]; 
       
   560             RSgImage image;
       
   561             ASSERT_EQUALS(image.Create(imageInfo, NULL, NULL), KErrNone);
       
   562             CleanupClosePushL(image);
       
   563             TSgImageInfoTest imageInfoSupported; 
       
   564             ASSERT_EQUALS(image.GetInfo(imageInfoSupported), KErrNone);//returned info may include more usage bits than we actually requested
       
   565             if(((imageInfoSupported.iUsage & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGles2Target)) && 
       
   566                                (!eglSess->IsOpenGLES2Supported()) ||
       
   567                 ((imageInfoSupported.iUsage & (ESgUsageOpenGles2Texture2D | ESgUsageOpenGlesTarget)) && 
       
   568                                (!eglSess->IsOpenGLESSupported()))))
       
   569                 {
       
   570                 CleanupStack::PopAndDestroy(&image);
       
   571                 continue;
       
   572                 }   
       
   573             
       
   574             EGLint eglRenderableTypeValue = 0;
       
   575             if(imageInfoSupported.iUsage & ESgUsageOpenVgTarget)
       
   576                 {
       
   577                 eglRenderableTypeValue = EGL_OPENVG_BIT;
       
   578                 }
       
   579             else if(imageInfoSupported.iUsage & ESgUsageOpenGles2Target)
       
   580                 {
       
   581                 eglRenderableTypeValue = EGL_OPENGL_ES2_BIT;
       
   582                 }
       
   583             else if(imageInfoSupported.iUsage & ESgUsageOpenGlesTarget)
       
   584                 {
       
   585                 eglRenderableTypeValue = EGL_OPENGL_ES_BIT;
       
   586                 }
       
   587             TEST(eglRenderableTypeValue != 0);
       
   588             
       
   589             // only minimum amount of renderable type matching to Native pixmap will be passed into attribute list.
       
   590             // And egl will decide whatever configs include at least given renderable type.
       
   591             const EGLint KAttrib_list[] = { EGL_MATCH_NATIVE_PIXMAP, reinterpret_cast<EGLint>(&image),
       
   592                                             EGL_RENDERABLE_TYPE, eglRenderableTypeValue,
       
   593                                             EGL_SURFACE_TYPE, EGL_PIXMAP_BIT | alphaPreBit,
       
   594                                             EGL_NONE };     
       
   595             
       
   596             EGLConfig configs[KMaxEglConfigs];
       
   597             EGLint numConfigs=0;
       
   598             ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,KAttrib_list,configs, KMaxEglConfigs,&numConfigs));
       
   599             CleanupStack::PopAndDestroy(&image);
       
   600             TEST(numConfigs > 0);
       
   601             
       
   602             for(TInt index = 0; index < numConfigs; index++)
       
   603                 {
       
   604                 const TInt numCloseRules = 3; 
       
   605                 for(TInt closeRule = 0; closeRule < numCloseRules; closeRule++)
       
   606                     {
       
   607                     CTestEglSession::TResourceCloseRule resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;
       
   608                     switch(closeRule)
       
   609                         {
       
   610                     case 0:
       
   611                         VERBOSE_INFO_PRINTF1(_L("Close Image Late"));
       
   612                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageLate;
       
   613                         break;
       
   614                     case 1:
       
   615                         VERBOSE_INFO_PRINTF1(_L("Close Image Early"));
       
   616                         resourceCloseRule = CTestEglSession::EResourceCloseSgImageEarly;
       
   617                         break;
       
   618                     case 2:
       
   619                         VERBOSE_INFO_PRINTF1(_L("Close Sg Driver and Image Early"));
       
   620                         resourceCloseRule = CTestEglSession::EResourceCloseSgDriverAndImageEarly;
       
   621                         break;
       
   622                     default:
       
   623                         break;
       
   624                         }
       
   625                 
       
   626                     if (KSgPixmapUsageSupport[j] & ESgUsageOpenVgTarget)
       
   627                         {
       
   628                         VERBOSE_INFO_PRINTF1(_L("...is OpenVG renderable"));
       
   629                         eglSess->TryUsePixmapRSgImageOpenVgL(configs[index], imageInfo, resourceCloseRule); // we can't fail to create an image as we have already tried it 
       
   630                         }
       
   631                     if (KSgPixmapUsageSupport[j] & (ESgUsageOpenGlesTarget | ESgUsageOpenGles2Texture2D))
       
   632                         {
       
   633                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES renderable"));
       
   634                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 1); // we can't fail to create an image as we have already tried it
       
   635                         }
       
   636                     if (KSgPixmapUsageSupport[j] & (ESgUsageOpenGles2Target | ESgUsageOpenGles2Texture2D))
       
   637                         {
       
   638                         VERBOSE_INFO_PRINTF1(_L("...is OpenGLES2 renderable"));
       
   639                         eglSess->TryUsePixmapRSgImageOpenGlesL(configs[index], imageInfo, resourceCloseRule, 2); // we can't fail to create an image as we have already tried it
       
   640                         }
       
   641                     }//for(TInt closeRule; closeRule < numCloseRules; closeRule++)
       
   642                 }//for(TInt index = 0; index < numConfigs; index++)
       
   643             }//for(TUint32 j = 0; j < numUsageCombinations; j++)
       
   644         }//for(TInt i = 0; i < numSgImagePixelFormatSupport; i++)
       
   645     
       
   646  #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
       
   647     
       
   648     CleanupStack::PopAndDestroy(2, eglSess);//iniParser, eglSess
       
   649     TerminateDisplayL();
       
   650     RecordTestResultL();
       
   651     CloseTMSGraphicsStep();
       
   652     return TestStepResult();
       
   653     }