1 // Copyright (c) 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 <test/tefunit.h> // for ASSERT macros

    22 #ifndef __INIPARSER_H__

    23 #include <cinidata.h>

    24 #endif // __INIPARSER_H__

    25 #include <e32msgqueue.h>

    26 

    27 #include "egltest_image_multiprocess.h"

    28 

    29 #include <test/egltestcommonconversion.h>

    30 #include <test/egltestcommoninisettings.h>

    31 #include <test/egltestcommonsgimageinfo.h>

    32 #include <test/egltestcommonprocess.h>

    33 

    34 //

    35 // Constant definitions

    36 //

    37 const TInt KNumProcesses = 8;

    38 const TInt KNumImages = 4;

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

    40 

    41 

    42 /**

    43 @SYMTestCaseID GRAPHICS-EGL-0160

    44 

    45 @SYMTestPriority 1

    46 

    47 @SYMPREQ 39

    48 

    49 @SYMREQ See SGL.GT0386.401 document

    50 

    51 @SYMTestCaseDesc

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

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

    54 

    55 @SYMTestActions

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

    57 Process1: Creates an EGLImage from the RsgImage previous mentioned

    58 --------

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

    60 --------

    61 Process1: Closes the EGLImage

    62 Process2: Closes the EGLImage

    63 Main Process: Closes the RsgImage

    64 

    65 @SYMTestExpectedResults

    66 No errors within both processes.

    67 No memory or handle leaks

    68 */

    69 TVerdict CEglTest_EGL_Image_Multi_Process_Sibling_Basic::doTestStepL()

    70 	{

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

    72 	SetTestStepName(KEGL_Image_Multi_Process_Sibling_Basic);

    73 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_Sibling_Basic::doTestStepL"));

    74 

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

    76 	if(!ret)

    77 		{

    78 		// The extension is not supported

    79 		RecordTestResultL();

    80 		CloseTMSGraphicsStep();

    81 		return TestStepResult();

    82 		}

    83 

    84 	// Create display object

    85 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

    86     GetDisplayL();

    87     CreateEglSessionL();

    88 	iEglSess->InitializeL();

    89 	iEglSess->OpenSgDriverL();

    90 

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

    92 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

    94 	CleanupStack::PushL(bitmap);

    95 

    96     // Create an RSgImage

    97 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

    98 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    99 	imageInfo.iShareable = ETrue;

   100 #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   101     RSgImage sgImage;

   102 	CleanupClosePushL(sgImage);

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

   104 

   105 	// launch 2 processes

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

   107 

   108 	// destroy sgImage

   109 	CleanupStack::PopAndDestroy(2, bitmap);

   110 	

   111 	// clean everything

   112 	CleanAll();

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

   114 	RecordTestResultL();

   115 	CloseTMSGraphicsStep();

   116 	return TestStepResult();

   117 	}

   118 

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

   120 	{	

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

   122 	GetDisplayL();

   123 	CreateEglSessionL(aIdx);

   124 	iEglSess->InitializeL();

   125 	iEglSess->OpenSgDriverL();

   126 

   127 	RSgImage sgImageFromId;

   128 	CleanupClosePushL(sgImageFromId);

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

   130 	

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

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

   133 	ASSERT_EGL_TRUE(eglImage != EGL_NO_IMAGE_KHR);

   134 	CleanupStack::PopAndDestroy(&sgImageFromId);

   135 	

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

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

   138 

   139 	// cleanup

   140 	CleanAll();

   141 	}

   142 

   143 

   144 /**

   145 @SYMTestCaseID GRAPHICS-EGL-0161

   146 

   147 @SYMTestPriority 1

   148 

   149 @SYMPREQ 39

   150 

   151 @SYMREQ See SGL.GT0386.401 document

   152 

   153 @SYMTestCaseDesc

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

   155 

   156 @SYMTestActions

   157 Run two processes that independently perform the same actions detailed below.

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

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

   160 Create and fully construct an RSgImage object

   161 •	Set the iUsage bits to ESgUsageBitOpenVgImage

   162 Pass the RSgImage object into eglCreateImageKHR() with

   163 •	The target parameter set to EGL_NATIVE_PIXMAP_KHR

   164 •	Use the current display and EGL_NO_CONTEXT

   165 •	Use a NULL attr_list

   166 Check that eglCreateImageKHR() does NOT return EGL_NO_IMAGE_KHR

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

   168 •	Check for errors (VGInvalidHandle is not returned)

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

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

   171 •	Set the iUsage bit to ESgUsageBitOpenVgSurface

   172 •	Use the same pixel format as the RSgImage above.

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

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

   175 returned by eglCreateImageKHR.

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

   177 linked to the context.

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

   179 Destroy the original image data

   180 •	Pass the VGImage into vgDestroyImage()

   181 •	Pass the EGLImage into eglDestroyImageKHR()

   182 •	Close the first RSgImage

   183 •	Check that the pixmap surface contains expected pixel values using 

   184 OpenVG APIs, vgReadPixels.

   185 Close the second RSgImage and destroy the pixmap surface

   186 Check for memory and handle leaks

   187 

   188 @SYMTestExpectedResults

   189 Pixmap surface has the expected contents in both processes (within tolerance)

   190 No memory or handle leaks

   191 */

   192 TVerdict CEglTest_EGL_Image_Multi_Process_Parallel::doTestStepL()

   193 	{

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

   195 	SetTestStepName(KEGL_Image_Multi_Process_Parallel);

   196 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_Parallel::doTestStepL"));

   197 	

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

   199 	if(!ret)

   200 		{

   201 		// The extension is not supported

   202 		RecordTestResultL();

   203 		CloseTMSGraphicsStep();

   204 		return TestStepResult();

   205 		}

   206 

   207 	// launch 2 processes

   208 	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

   209 	

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

   211 	RecordTestResultL();

   212 	CloseTMSGraphicsStep();

   213 	return TestStepResult();

   214 	}

   215 

   216 void CEglTest_EGL_Image_Multi_Process_Parallel::doProcessFunctionL(TInt aIdx)

   217 	{

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

   219 	GetDisplayL();

   220 	CreateEglSessionL(aIdx);

   221 	iEglSess->InitializeL();	

   222 	iEglSess->OpenSgDriverL();

   223 

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

   225 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   227 	CleanupStack::PushL(bitmap);

   228 

   229 	// Create an RSgImage

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

   231 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

   232     RSgImage rSgImageLocal;

   233 	CleanupClosePushL(rSgImageLocal);

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

   235 

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

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

   238 	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

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

   240 	CleanupStack::PopAndDestroy(bitmap);

   241 	

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

   243 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

   244 	TSgImageInfoOpenVgTarget imageInfo2 = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

   247 

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

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

   250 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

   252 

   253 	// Copy the source VGImage to the surface

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

   255 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   256 	eglWaitClient();

   257 

   258 	// destroy VGImage

   259 	vgDestroyImage(vgImageLocal);

   260 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   261 

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

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

   264 	CleanupStack::PushL(refBitmap);

   265 	iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   266 	CleanupStack::PopAndDestroy(refBitmap);

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

   268 	

   269 	// cleanup

   270 	CleanAll();

   271 	}

   272 

   273 /**

   274 @SYMTestCaseID GRAPHICS-EGL-0162

   275 

   276 @SYMTestPriority 1

   277 

   278 @SYMPREQ 39

   279 

   280 @SYMREQ See SGL.GT0386.401 document

   281 

   282 @SYMTestCaseDesc

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

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

   285 Both process can create a VGImage from it.

   286 Another process uses the VGImage as a target

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

   288 

   289 @SYMTestActions

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

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

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

   293 Process1: Changes the contents of the VGImage

   294 --------

   295 Process1: Closes the VGImage and the EGLImage

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

   297 Process2: Closes the VGImage and the EGLImage

   298 Main Process: Closes the RsgImage

   299 

   300 @SYMTestExpectedResults

   301 No errors within both processes.

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

   303 No memory or handle leaks.

   304 */

   305 TVerdict CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::doTestStepL()

   306 	{

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

   308 	SetTestStepName(KEGL_Image_Multi_Process_Sibling_CheckContents);

   309 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_Sibling_CheckContents::doTestStepL"));

   310 

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

   312 	if(!ret)

   313 		{

   314 		// The extension is not supported

   315 		RecordTestResultL();

   316 		CloseTMSGraphicsStep();

   317 		return TestStepResult();

   318 		}

   319 

   320 	// Create display object

   321 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

   322     GetDisplayL();

   323     CreateEglSessionL();

   324 	iEglSess->InitializeL();

   325 	iEglSess->OpenSgDriverL();

   326 

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

   328 	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   330 	CleanupStack::PushL(bitmap);

   331 

   332     // Create an RSgImage

   333 	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

   334 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   335 	imageInfo.iShareable = ETrue;

   336 #endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   337     RSgImage sgImage;

   338 	CleanupClosePushL(sgImage);

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

   340 

   341 	// launch 2 processes

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

   343 

   344 	// destroy sgImage

   345 	CleanupStack::PopAndDestroy(&sgImage);

   346 	CleanupStack::PopAndDestroy(bitmap);

   347 	

   348 	// clean everything

   349 	CleanAll();

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

   351     RecordTestResultL();

   352 	CloseTMSGraphicsStep();

   353 	return TestStepResult();

   354 	}

   355 

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

   357 	{

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

   359 	GetDisplayL();

   360 	CreateEglSessionL(aIdx);

   361 	iEglSess->InitializeL();

   362 	iEglSess->OpenSgDriverL();

   363 

   364 	RSgImage sgImageFromId;

   365 	CleanupClosePushL(sgImageFromId);

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

   367 	

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

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

   370 	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

   371 	CleanupStack::PopAndDestroy(&sgImageFromId);

   372 	

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

   374 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

   375 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

   378 	

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

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

   381 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

   383 	

   384 	if(aIdx == 0)

   385 		{

   386 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

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

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

   390 		TSize bitmapSize = bitmap->SizeInPixels();

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

   392     	TInt stride = bitmap->DataStride();

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

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

   395 		delete bitmap;

   396 		bitmap = NULL;

   397 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   398 		eglWaitClient();

   399 		}

   400 	

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

   402 	Rendezvous(aIdx);

   403 	

   404 	if(aIdx == 1)

   405 		{

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

   407 		// Copy the source VGImage to the surface

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

   409 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   410 		eglWaitClient();

   411 

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

   413 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   415 		CleanupStack::PushL(refBitmap);

   416 		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   417 		CleanupStack::PopAndDestroy(refBitmap);

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

   419 		}

   420 

   421 	// destroy VGImage

   422 	vgDestroyImage(vgImageLocal);

   423 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   424 

   425 	// cleanup

   426 	CleanAll();

   427 	}

   428 

   429 /**

   430 @SYMTestCaseID GRAPHICS-EGL-0350

   431 

   432 @SYMTestPriority 1

   433 

   434 @SYMPREQ 2637

   435 

   436 @SYMTestCaseDesc

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

   438 

   439 @SYMTestActions

   440 Main Process: starts Process1 and Process2.

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

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

   443 --------

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

   445 --------

   446 Process1: Changes the contents of the VGImage

   447 --------

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

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

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

   451 

   452 @SYMTestExpectedResults

   453 No errors within both processes.

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

   455 No memory or handle leaks.

   456 */

   457 TVerdict CEglTest_EGL_Image_Multi_Process_VgImage_Source::doTestStepL()

   458     {

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

   460 	SetTestStepName(KEGL_Image_Multi_Process_VgImage_Source);

   461 	INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_VgImage_Source::doTestStepL"));

   462 

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

   464 	if(!ret)

   465 		{

   466 		// The extension is not supported

   467 		RecordTestResultL();

   468 		CloseTMSGraphicsStep();

   469 		return TestStepResult();

   470 		}

   471 

   472 	// launch 2 processes

   473 	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

   474 

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

   476     RecordTestResultL();

   477     CloseTMSGraphicsStep();

   478     return TestStepResult();

   479     }

   480 

   481 void CEglTest_EGL_Image_Multi_Process_VgImage_Source::doProcessFunctionL(TInt aIdx)

   482     {

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

   484 	GetDisplayL();

   485 	CreateEglSessionL(aIdx);

   486 	iEglSess->InitializeL();	

   487 	iEglSess->OpenSgDriverL();

   488 

   489     RMsgQueue<TSgDrawableId> messageQueue;

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

   491     CleanupClosePushL(messageQueue);

   492 

   493     RSgImage rSgImageLocal;

   494 	if(aIdx == 0)

   495         {

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

   497     	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   499     	CleanupStack::PushL(bitmap);

   500 

   501     	// Create an RSgImage

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

   503     	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

   504 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   505     	imageInfo.iShareable = ETrue;

   506 #endif

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

   508         CleanupStack::PopAndDestroy(bitmap);

   509  

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

   511         messageQueue.SendBlocking(rSgImageLocal.Id());

   512         }

   513     else if(aIdx == 1)

   514         {

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

   516         TSgDrawableId sgImageId;

   517         messageQueue.ReceiveBlocking(sgImageId);

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

   519         }

   520 

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

   522 	CleanupClosePushL(rSgImageLocal);

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

   524 	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

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

   526 

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

   528 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

   529 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

   532 

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

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

   535 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

   537 

   538     if(aIdx == 1)

   539         {

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

   541     	// Copy the source VGImage to the surface

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

   543     	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   544     	eglWaitClient();

   545 

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

   547 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   549 		CleanupStack::PushL(refBitmap);

   550 		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   551 		CleanupStack::PopAndDestroy(refBitmap);

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

   553         }

   554 

   555 	// Wait for both processes to reach this point

   556     Rendezvous(aIdx);

   557 

   558     if(aIdx == 0)

   559         {

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

   561         TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

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

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

   565         TSize bitmapSize = bitmap->SizeInPixels();

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

   567     	TInt stride = bitmap->DataStride();

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

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

   570         delete bitmap;

   571         bitmap = NULL;

   572     	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   573     	eglWaitClient();

   574         }

   575 

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

   577 	Rendezvous(aIdx);

   578     

   579 	if(aIdx == 1)

   580 		{

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

   582         // Copy the source VGImage to the surface

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

   584 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   585 		eglWaitClient();

   586 

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

   588 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   590 		CleanupStack::PushL(refBitmap);

   591 		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   592 		CleanupStack::PopAndDestroy(refBitmap);

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

   594         }

   595 

   596 	vgDestroyImage(vgImageLocal);

   597 	ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

   598 

   599 	CleanupStack::PopAndDestroy(&messageQueue);

   600     CleanAll();

   601     }

   602 

   603 /**

   604 @SYMTestCaseID GRAPHICS-EGL-0351

   605 

   606 @SYMTestPriority 1

   607 

   608 @SYMPREQ 2637

   609 

   610 @SYMTestCaseDesc

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

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

   613 

   614 @SYMTestActions

   615 Main Process: starts Process1 and Process2.

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

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

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

   619 --------

   620 Process1: Changes the contents of the VGImage

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

   622 --------

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

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

   625 

   626 @SYMTestExpectedResults

   627 No errors within both processes.

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

   629 No memory or handle leaks.

   630 */

   631 TVerdict CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doTestStepL()

   632     {

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

   634 	SetTestStepName(KEGL_Image_Multi_Process_VgImage_DrawAfterTerminate);

   635     INFO_PRINTF1(_L("Enter: CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doTestStepL"));

   636 

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

   638 	if(!ret)

   639 		{

   640 		// The extension is not supported

   641 		RecordTestResultL();

   642 		CloseTMSGraphicsStep();

   643 		return TestStepResult();

   644 		}

   645 

   646 	// This test is performed for default pixel format

   647 	PrintUsedPixelConfiguration();

   648 

   649 	// launch 2 processes

   650  	Test_MultiProcessL(KEglTestStepDllName, 2, TestStepName());

   651 

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

   653     RecordTestResultL();

   654     CloseTMSGraphicsStep();

   655     return TestStepResult();

   656     }

   657 

   658 void CEglTest_EGL_Image_Multi_Process_VgImage_DrawAfterTerminate::doProcessFunctionL(TInt aIdx)

   659     {

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

   661     GetDisplayL();

   662     CreateEglSessionL(aIdx);

   663     iEglSess->InitializeL();

   664     iEglSess->OpenSgDriverL();

   665 

   666     RMsgQueue<TSgDrawableId> messageQueue;

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

   668     CleanupClosePushL(messageQueue);

   669     

   670     RSgImage rSgImageLocal;

   671     if(aIdx == 0)

   672         {

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

   674     	TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   676     	CleanupStack::PushL(bitmap);

   677 

   678     	// Create an RSgImage

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

   680     	TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(KDefaultSourceFormat, KImageSize);

   681 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   682     	imageInfo.iShareable = ETrue;

   683 #endif

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

   685         CleanupStack::PopAndDestroy(bitmap);

   686  

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

   688         messageQueue.SendBlocking(rSgImageLocal.Id());

   689         }

   690     else if(aIdx == 1)

   691         {

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

   693         TSgDrawableId sgImageId;

   694         messageQueue.ReceiveBlocking(sgImageId);

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

   696         }

   697     

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

   699 	CleanupClosePushL(rSgImageLocal);

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

   701 	ASSERT_EGL_TRUE(eglImageLocal != EGL_NO_IMAGE_KHR);

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

   703 

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

   705 	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(KDefaultSurfaceFormat);

   706 	TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

   709 

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

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

   712 	ASSERT_VG_TRUE(vgImageLocal != VG_INVALID_HANDLE);

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

   714     

   715     if(aIdx == 1)

   716         {

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

   718         // Copy the source VGImage to the surface

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

   720     	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   721     	eglWaitClient();

   722     	

   723 

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

   725 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   727 		CleanupStack::PushL(refBitmap);

   728 		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   729 		CleanupStack::PopAndDestroy(refBitmap);

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

   731         }

   732 

   733 	// Wait for both processes to reach this point

   734     Rendezvous(aIdx);

   735 

   736     if(aIdx == 0)

   737         {

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

   739         TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

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

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

   743 		TSize bitmapSize = bitmap->SizeInPixels();

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

   745     	TInt stride = bitmap->DataStride();

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

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

   748         delete bitmap;

   749         bitmap = NULL;

   750     	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   751     	eglWaitClient();

   752 

   753     	vgDestroyImage(vgImageLocal);

   754     	ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

   755     	CleanupStack::PopAndDestroy(&messageQueue);

   756         CleanAll();

   757         }

   758 

   759 	// Wait for both processes to reach this point

   760     Rendezvous(aIdx);

   761     

   762     if(aIdx == 1)

   763         {

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

   765  		// Copy the source VGImage to the surface

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

   767 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   768 		eglWaitClient();

   769 

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

   771 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(KDefaultSourceFormat);

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

   773 		CleanupStack::PushL(refBitmap);

   774 		iEglSess->CheckVgDrawingL(KDefaultSurfaceFormat, refBitmap);

   775 		CleanupStack::PopAndDestroy(refBitmap);

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

   777 

   778 		vgDestroyImage(vgImageLocal);

   779 		ASSERT_TRUE(vgGetError() == VG_NO_ERROR);

   780 

   781 		CleanupStack::PopAndDestroy(&messageQueue);

   782     	CleanAll();

   783         }

   784     }

   785 

   786 /**

   787 @SYMTestCaseID GRAPHICS-EGL-0406

   788 

   789 @SYMTestPriority 1

   790 

   791 @SYMPREQ PREQ2637

   792 

   793 @SYMTestCaseDesc

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

   795 To ensure that reference counting of RSgImage works correctly.

   796 

   797 @SYMTestActions

   798 From the main process:

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

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

   801 •	EUidPixelFormatRGB_565

   802 •	EUidPixelFormatXRGB_8888

   803 •	EUidPixelFormatARGB_8888 (source only)

   804 •	EUidPixelFormatARGB_8888_PRE

   805 •	EUidPixelFormatA_8  (source only)

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

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

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

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

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

   811 From processes 1 to N:

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

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

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

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

   816 - Close Sg and EGL images

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

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

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

   820   reference bitmap is used as an alpha mask).

   821 - Draw VGImage to the off-screen surface.

   822 - Retrieve surface data (see vgReadPixels() API)

   823 

   824 @SYMTestExpectedResults

   825 Creation of all drawable  resources have been completed without errors.

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

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

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

   829 */

   830 TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestStepL()

   831 	{

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

   833 	SetTestStepName(KEGL_Image_Multi_Process_FontServer_Upfront);

   834 	INFO_PRINTF1(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestStepL"));

   835 

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

   837 	if(!ret)

   838 		{

   839 		// The extension is not supported

   840 		RecordTestResultL();

   841 		CloseTMSGraphicsStep();

   842 		return TestStepResult();

   843 		}

   844 

   845 	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

   846 	CleanupStack::PushL(iniParser);

   847 

   848 	TInt numPixmapSgSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);

   849 	TInt numImageSourceFormats = iniParser->GetNumberOfFormats(KSectionImageSourceFormats);

   850 	if(!numImageSourceFormats && !numPixmapSgSurfaceFormats)

   851 		{

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

   853 		User::Leave(KErrArgument);

   854 		}

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

   856 		{

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

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

   859 			{

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

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

   862 				{

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

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

   865 				continue;

   866 				}

   867 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

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

   869 			if (iSourceFormat == EUidPixelFormatA_8)

   870 				continue;

   871 #endif	

   872 			doTestPartialStepL();

   873 			}

   874 		}

   875 

   876 	CleanupStack::PopAndDestroy(iniParser);

   877 	RecordTestResultL();

   878 	CloseTMSGraphicsStep();

   879 	return TestStepResult();

   880 	}

   881 

   882 TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Upfront::doTestPartialStepL()

   883 	{

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

   885 	PrintUsedPixelConfiguration();

   886 

   887 	// Create display object

   888 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

   889 	GetDisplayL();

   890 	CreateEglSessionL();

   891 	iEglSess->InitializeL();

   892 	iEglSess->OpenSgDriverL();

   893 

   894 	// list to maintain TSgDrawableId

   895 	RArray<TSgDrawableId> sgIdList;

   896 	CleanupClosePushL(sgIdList);

   897     RSgImage sgImages[KNumImages];

   898 

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

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

   901 		{

   902 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

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

   904 		CleanupStack::PushL(bitmap);

   905 

   906 		TSgImageInfoOpenVgImage imageInfo = TSgImageInfoOpenVgImage(iSourceFormat, KImageSize);

   907 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

   908     	imageInfo.iShareable = ETrue;

   909 #endif

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

   911         CleanupClosePushL(sgImages[i]);

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

   913 		}

   914 

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

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

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

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

   919 

   920 	CleanAll();

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

   922 	return TestStepResult();

   923 	}

   924 

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

   926 	{

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

   928 	GetDisplayL();

   929 	CreateEglSessionL(aIdx);

   930 	iEglSess->InitializeL();

   931 	iEglSess->OpenSgDriverL();

   932 

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

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

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

   936 

   937 	RSgImage sgImageFromId;

   938 	CleanupClosePushL(sgImageFromId);

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

   940 

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

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

   943 	ASSERT_EGL_TRUE(eglImage != EGL_NO_IMAGE_KHR);

   944 	CleanupStack::PopAndDestroy(&sgImageFromId);

   945 

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

   947     TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

   948     TSgImageInfoOpenVgTarget imageInfo = TSgImageInfoOpenVgTarget(pixelFormat, KImageSize);

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

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

   951 

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

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

   954 	ASSERT_VG_TRUE(vgImage != VG_INVALID_HANDLE);

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

   956 

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

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

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

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

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

   962 	if (iSourceFormat == EUidPixelFormatA_8)

   963 		{

   964 		// clear surface background

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

   966 		vgSetfv(VG_CLEAR_COLOR, 4, bgColor);

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

   968 		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

   969 

   970 		// fill paint

   971 		VGPaint fillPaint = vgCreatePaint();

   972 		vgSetPaint(fillPaint, VG_FILL_PATH);

   973 		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

   974 		vgSetParameteri(fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

   975 		VGuint fillColor = 0x008000ff; // opaque dark green

   976 		vgSetColor(fillPaint, fillColor);

   977 		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

   978 		

   979 		vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_STENCIL);

   980 		vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);

   981 		vgDrawImage(vgImage);

   982 		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

   983 		eglWaitClient();

   984 	    vgDestroyPaint(fillPaint);

   985 		ASSERT_EGL_TRUE(vgGetError() == VG_NO_ERROR);

   986 		}

   987 	else

   988 		{

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

   990 		ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

   991 		eglWaitClient();

   992 		}

   993 

   994 	// Check that the surface contains the expected pixels

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

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

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

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

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

  1000 	if (iSourceFormat == EUidPixelFormatA_8)

  1001 		{

  1002 		TDisplayMode maskMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

  1003 		CFbsBitmap* mask = iEglSess->CreateReferenceBitmapL(maskMode, KImageSize, ImageIndexFromProcessId(aIdx, KNumImages));

  1004 		CleanupStack::PushL(mask);

  1005 

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

  1007 		TUidPixelFormat format = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

  1008 		TDisplayMode refbitmapMode = EglTestConversion::PixelFormatToDisplayMode(format);

  1009 

  1010 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceMaskedBitmapL(refbitmapMode, KRgbDarkGreen, mask);

  1011 		CleanupStack::PushL(refBitmap);

  1012 		

  1013 		// compare the obtained reference bitmap with the surface drawn

  1014 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

  1015 		CleanupStack::PopAndDestroy(2, mask); //mask, refBitmap

  1016 		}

  1017 	else

  1018 		{

  1019 		TDisplayMode bitmapMode = EglTestConversion::PixelFormatToDisplayMode(iSourceFormat);

  1020 		CFbsBitmap* refBitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, KImageSize, ImageIndexFromProcessId(aIdx, KNumImages));

  1021 		CleanupStack::PushL(refBitmap);

  1022 		iEglSess->CheckVgDrawingL(iSurfaceFormat, refBitmap);

  1023 		CleanupStack::PopAndDestroy(refBitmap);

  1024 		}

  1025 	INFO_PRINTF2(_L("Process %d, VG drawing successfully completed and checked"),aIdx);

  1026 

  1027 	// destroy VGImage

  1028 	vgDestroyImage(vgImage);

  1029 	ASSERT_TRUE(vgGetError()==VG_NO_ERROR);

  1030 

  1031 	// cleanup

  1032 	CleanAll();

  1033 	}

  1034 

  1035 

  1036 /**

  1037 @SYMTestCaseID GRAPHICS-EGL-0410

  1038 

  1039 @SYMTestPriority 1

  1040 

  1041 @SYMPREQ PREQ2637

  1042 

  1043 @SYMTestCaseDesc

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

  1045 To ensure that reference counting of RSgImage works correctly

  1046 

  1047 @SYMTestActions

  1048 From the main process:

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

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

  1051 •	EUidPixelFormatRGB_565

  1052 •	EUidPixelFormatXRGB_8888

  1053 •	EUidPixelFormatARGB_8888_PRE

  1054 - Using EGL extension, create M EGLImage(s), specifying as EGLClientBuffer SgImage(s) which were created on 

  1055   first step and EGL_NATIVE_PIXMAP_KHR as a target

  1056 - Using VG extension, create VG images based on EGLImage(s) from the previous step

  1057 - Close Sg and EGL Images

  1058 - Populate data in VGImages (see vgImageSubData(..) API), there will be different data uploaded for each VGImage 

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

  1060   In order to define which SgImage(s) needs to be passed to the particular processes, there will be following 

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

  1062 From processes 1 to N:

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

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

  1065   EGL_NATIVE_PIXMAP_KHR as a target and EGL_IMAGE_PRESERVED_KHR as an attribute

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

  1067 - Close Sg and EGL images

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

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

  1070 - Draw VGImage to the off-screen surface.

  1071 - Retrieve surface data (see vgReadPixels() API)

  1072 

  1073 @SYMTestExpectedResults

  1074 Creation of all drawable  resources have been completed without errors.

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

  1076 process A. Reference counting works correctly and keep VG image alive although bound Sg and EGL images have been closed. 

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

  1078 */

  1079 TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Deferred::doTestStepL()

  1080 	{

  1081 	SetTestStepID(_L("GRAPHICS-EGL-0410"));

  1082 	SetTestStepName(KEGL_Image_Multi_Process_FontServer_Deferred);

  1083 	INFO_PRINTF1(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Deferred::doTestStepL"));

  1084 

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

  1086 	if(!ret)

  1087 		{

  1088 		// The extension is not supported

  1089 		RecordTestResultL();

  1090 		CloseTMSGraphicsStep();

  1091 		return TestStepResult();

  1092 		}

  1093 

  1094 	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

  1095 	CleanupStack::PushL(iniParser);

  1096 

  1097 	TInt numPixmapSgSurfaceFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);

  1098 	if(!numPixmapSgSurfaceFormats)

  1099 		{

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

  1101 		User::Leave(KErrArgument);

  1102 		}

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

  1104 		{

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

  1106 		iSourceFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

  1107 #ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

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

  1109 		if (iSourceFormat == EUidPixelFormatA_8)

  1110 			continue;

  1111 #endif	

  1112 		doTestPartialStepL();

  1113 		}

  1114 

  1115 	CleanupStack::PopAndDestroy(iniParser);

  1116 	RecordTestResultL();

  1117 	CloseTMSGraphicsStep();

  1118 	return TestStepResult();

  1119 	}

  1120 

  1121 TVerdict CEglTest_EGL_Image_Multi_Process_FontServer_Deferred::doTestPartialStepL()

  1122 	{

  1123 	INFO_PRINTF1(_L("CEglTest_EGL_Image_Multi_Process_FontServer_Deferred::doTestPartialStepL"));

  1124 	PrintUsedPixelConfiguration();

  1125 	

  1126 	// Create display object

  1127 	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

  1128 	GetDisplayL();

  1129 	CreateEglSessionL();

  1130 	iEglSess->InitializeL();

  1131 	iEglSess->OpenSgDriverL();

  1132 

  1133 	// Create RSgImage's attributes

  1134 	TSgImageInfoTest imageInfo = TSgImageInfoTest(iSourceFormat, KImageSize);