Symaptic: os/graphics/egl/egltest/src/egltestcommonsession.cpp@bde4ae8d615e (annotated)

sl@0	1	// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15
sl@0	16	/**
sl@0	17	@file
sl@0	18	@test
sl@0	19	*/
sl@0	20
sl@0	21	#include "egltestcommonsession.h"
sl@0	22	#include "egltestcommonutils.h"
sl@0	23	#include "egltestcommonsgimageinfo.h"
sl@0	24
sl@0	25	#include <test/tefunit.h>
sl@0	26	#include <e32cmn.h>
sl@0	27	#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	28	#include <sgresource/sgresource.h>
sl@0	29	#else
sl@0	30	#include <graphics/sgresourceinternal.h>
sl@0	31	#include <graphics/sgresource.h>
sl@0	32	#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	33	#include <VG/openvg.h>
sl@0	34	#include <GLES/gl.h>
sl@0	35
sl@0	36
sl@0	37	#define CHECK_EXPECTED_ERROR(aFunctionReturnValue) \
sl@0	38	if(!(CheckExpectedError(aFunctionReturnValue))) \
sl@0	39	{ \
sl@0	40	ERR_PRINTF2(_L("thread %d: Unexpected EGL error information"), iThreadIdx); \
sl@0	41	User::Leave(KErrTEFUnitFail); \
sl@0	42	}
sl@0	43
sl@0	44	const TMapEglConfigToPixelFormat KMapEglConfigToPixelFormat[] =
sl@0	45	{
sl@0	46	{16, 0, 5,6,5, 0, EGL_RGB_BUFFER, EUidPixelFormatRGB_565, EColor64K},
sl@0	47	{32, 0, 8,8,8, 0, EGL_RGB_BUFFER, EUidPixelFormatXRGB_8888, EColor16MU},
sl@0	48	{32, 8, 8,8,8, EGL_VG_ALPHA_FORMAT_NONPRE, EGL_RGB_BUFFER, EUidPixelFormatARGB_8888, EColor16MA},
sl@0	49	{32, 8, 8,8,8, EGL_VG_ALPHA_FORMAT_PRE, EGL_RGB_BUFFER, EUidPixelFormatARGB_8888_PRE, EColor16MAP}
sl@0	50	};
sl@0	51
sl@0	52	EXPORT_C CTestEglSession::CTestEglSession(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)
sl@0	53	: iLogger(aLogger), iThreadIdx(aThreadIdx), iExtensionGroupCached(EIsUndefined), iDisplay(aDisplay), iExpectedErrorCode(EGL_SUCCESS)
sl@0	54	{}
sl@0	55
sl@0	56	EXPORT_C CTestEglSession* CTestEglSession::NewLC(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)
sl@0	57	{
sl@0	58	CTestEglSession* self = new (ELeave) CTestEglSession(aLogger, aDisplay, aThreadIdx);
sl@0	59	CleanupStack::PushL(self);
sl@0	60	return self;
sl@0	61	}
sl@0	62
sl@0	63	EXPORT_C CTestEglSession* CTestEglSession::NewL(CTestExecuteLogger& aLogger, EGLDisplay& aDisplay, TInt aThreadIdx)
sl@0	64	{
sl@0	65	CTestEglSession* self = CTestEglSession::NewLC(aLogger, aDisplay, aThreadIdx);
sl@0	66	CleanupStack::Pop(self);
sl@0	67	return self;
sl@0	68	}
sl@0	69
sl@0	70	EXPORT_C CTestEglSession::~CTestEglSession()
sl@0	71	{
sl@0	72	iExtensionStrings.Reset();
sl@0	73	EGLBoolean ret;
sl@0	74	if (iDisplay != EGL_NO_DISPLAY)
sl@0	75	{
sl@0	76	// Unbind and destroy context only if we successfuly created it
sl@0	77	if (iContext != EGL_NO_CONTEXT)
sl@0	78	{
sl@0	79	INFO_PRINTF2(_L("thread %d: Calling eglMakeCurrent(NULL values) from ~CTestEglSession..."), iThreadIdx);
sl@0	80	ret = eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
sl@0	81	if(ret == EGL_FALSE)
sl@0	82	{
sl@0	83	WARN_PRINTF3(_L("thread %d: eglMakeCurrent returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());
sl@0	84	}
sl@0	85
sl@0	86	// Warn because this should be done by the test, rather than relying on the d'tor
sl@0	87	// which may not leave if there is an error (so no CHECK_EXPECTED_ERROR)
sl@0	88	WARN_PRINTF2(_L("thread %d: Calling eglDestroyContext() from ~CTestEglSession..."), iThreadIdx);
sl@0	89	ret = eglDestroyContext(iDisplay, iContext);
sl@0	90	if(ret == EGL_FALSE)
sl@0	91	{
sl@0	92	WARN_PRINTF3(_L("thread %d: eglDestroyContext returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());
sl@0	93	}
sl@0	94	}
sl@0	95
sl@0	96	if (iSurface != EGL_NO_SURFACE)
sl@0	97	{
sl@0	98	// Warn because this should be done by the test, rather than relying on the d'tor
sl@0	99	// which may not leave if there is an error (so no CHECK_EXPECTED_ERROR)
sl@0	100	WARN_PRINTF2(_L("thread %d: Calling eglDestroySurface() from ~CTestEglSession..."), iThreadIdx);
sl@0	101	ret = eglDestroySurface(iDisplay, iSurface);
sl@0	102	if(ret == EGL_FALSE)
sl@0	103	{
sl@0	104	WARN_PRINTF3(_L("thread %d: eglDestroySurface returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());
sl@0	105	}
sl@0	106	}
sl@0	107
sl@0	108	if (iTerminateDisplay)
sl@0	109	{
sl@0	110	INFO_PRINTF1(_L("Calling eglTerminate..."));
sl@0	111	ret = eglTerminate(iDisplay);
sl@0	112	iDisplay = EGL_NO_DISPLAY;
sl@0	113	if(ret == EGL_FALSE)
sl@0	114	{
sl@0	115	WARN_PRINTF3(_L("thread %d: eglTerminate returned error = %x ~CTestEglSession..."), iThreadIdx, eglGetError());
sl@0	116	}
sl@0	117	}
sl@0	118	}
sl@0	119
sl@0	120	// Only destroy native resource after the surface and context that wraps it has been destroyed.
sl@0	121	delete iFbsBitmap;
sl@0	122	CloseFbsSession();
sl@0	123
sl@0	124	iSgImage.Close();
sl@0	125	CloseSgDriver();
sl@0	126	}
sl@0	127
sl@0	128	EXPORT_C void CTestEglSession::SetExpectedError(EGLint aExpectedErrorCode)
sl@0	129	{
sl@0	130	VERBOSE_INFO_PRINTF3(_L("thread %d: Setting the expected error code for the next EGL call to %x"), iThreadIdx, aExpectedErrorCode);
sl@0	131	{
sl@0	132	iExpectedErrorCode = aExpectedErrorCode;
sl@0	133	}
sl@0	134	}
sl@0	135
sl@0	136	EXPORT_C void CTestEglSession::ResetExpectedError()
sl@0	137	{
sl@0	138	iExpectedErrorCode = EGL_SUCCESS;
sl@0	139	}
sl@0	140
sl@0	141	/**
sl@0	142	Checks whether the call to an EGL method returned the correct error information.
sl@0	143	The method checks whether eglGetError() returns the expected error value as specified by calling SetExpectedError()
sl@0	144	It also checks that the value returned by the EGL method was appropriate for the expected error value.
sl@0	145	@param aFunctionReturnValue Pass in the value retured from the EGL method
sl@0	146	@return Whether the expected error information was returned from a call to an EGL method.
sl@0	147	*/
sl@0	148	EXPORT_C TBool CTestEglSession::CheckExpectedError(EGLint aFunctionReturnValue)
sl@0	149	{
sl@0	150	TBool isExpectedError = ETrue;
sl@0	151	EGLint eglErr = eglGetError();
sl@0	152
sl@0	153	// First check that we got the correct return value
sl@0	154	if ((iExpectedErrorCode == EGL_SUCCESS) && !aFunctionReturnValue)
sl@0	155	{
sl@0	156	ERR_PRINTF3(_L("thread %d: Wrong function return value: %d"), iThreadIdx, aFunctionReturnValue);
sl@0	157	isExpectedError = EFalse;
sl@0	158	}
sl@0	159	// Also check that we got the
sl@0	160	if (eglErr != iExpectedErrorCode)
sl@0	161	{
sl@0	162	ERR_PRINTF4(_L("thread %d: eglGetError() returned %x, but expected %x"), iThreadIdx, eglErr, iExpectedErrorCode);
sl@0	163	isExpectedError = EFalse;
sl@0	164	}
sl@0	165	else if (eglErr != EGL_SUCCESS)
sl@0	166	{
sl@0	167	VERBOSE_INFO_PRINTF3(_L("thread %d: eglGetError() returned %x, as expected"), iThreadIdx, eglErr);
sl@0	168	}
sl@0	169
sl@0	170	// Reset the expected error
sl@0	171	ResetExpectedError();
sl@0	172
sl@0	173	return isExpectedError;
sl@0	174	}
sl@0	175
sl@0	176	EXPORT_C void CTestEglSession::CheckExpectedErrorL(EGLint aExpectedErrorCode)
sl@0	177	{
sl@0	178	EGLint eglErr = eglGetError();
sl@0	179	// check that we got the expected error
sl@0	180	if (eglErr != aExpectedErrorCode)
sl@0	181	{
sl@0	182	ERR_PRINTF4(_L("thread %d: eglGetError() returned %x, but expected %x"), iThreadIdx, eglErr, aExpectedErrorCode);
sl@0	183	User::Leave(KErrTEFUnitFail);
sl@0	184	}
sl@0	185	}
sl@0	186
sl@0	187	void CTestEglSession::QueryExtensionsL(TExtensionsGroups aExtensionBelongsTo)
sl@0	188	{
sl@0	189	// reset the cached extensions
sl@0	190	iExtensionStrings.Reset();
sl@0	191
sl@0	192	const char* extensionsString = NULL;
sl@0	193	if(aExtensionBelongsTo == EIsEGL)
sl@0	194	{
sl@0	195	INFO_PRINTF2(_L("thread %d: Calling eglQueryString for EGL_EXTENSIONS)"), iThreadIdx);
sl@0	196	extensionsString = eglQueryString(iDisplay, EGL_EXTENSIONS);
sl@0	197	}
sl@0	198	else if(aExtensionBelongsTo == EIsVG)
sl@0	199	{
sl@0	200	INFO_PRINTF2(_L("thread %d: Calling vgGetString for VG_EXTENSIONS)"), iThreadIdx);
sl@0	201
sl@0	202	// OpenVG needs a current VG context before it will allow the call to vgGetString
sl@0	203	// The created surface will remain un-used, hence we create it with an arbitrary pixel format
sl@0	204	EGLConfig currentConfig = GetConfigExactMatchL(EPBufferAttribsColor64K);
sl@0	205	CreatePbufferSurfaceAndMakeCurrentL(currentConfig, TSize(1,1), EGL_OPENVG_API);
sl@0	206
sl@0	207	extensionsString = (const char*) vgGetString(VG_EXTENSIONS);
sl@0	208
sl@0	209	//cleanup the context & surface
sl@0	210	CleanupSurfaceSgImageL();
sl@0	211	}
sl@0	212	else
sl@0	213	{
sl@0	214	ERR_PRINTF2(_L("CTestEglSession::QueryExtensionsL() - Unknown extension group provided (%d)."), aExtensionBelongsTo);
sl@0	215	User::Leave(KErrArgument);
sl@0	216	}
sl@0	217	CHECK_EXPECTED_ERROR(extensionsString!=NULL);
sl@0	218
sl@0	219	TPtrC8 ptrExtensions((const TUint8 *) extensionsString );
sl@0	220
sl@0	221	RBuf buffer;
sl@0	222	buffer.CreateL(ptrExtensions.Length());
sl@0	223	buffer.CleanupClosePushL();
sl@0	224	buffer.Copy(ptrExtensions);
sl@0	225	INFO_PRINTF3(_L("thread %d: QueryExtensionsL: \"%S\""), iThreadIdx, &buffer);
sl@0	226	CleanupStack::PopAndDestroy(&buffer);
sl@0	227
sl@0	228	TInt posSpace=1;
sl@0	229	while (posSpace > 0 && ptrExtensions.Length() > 0)
sl@0	230	{
sl@0	231	posSpace = ptrExtensions.Locate(' '); // strictly looking for a single space
sl@0	232	ASSERT_FALSE(posSpace==0); // Would imply extension starting with a space or with 2 spaces in a row
sl@0	233	if (posSpace > 0)
sl@0	234	{
sl@0	235	iExtensionStrings.Append(ptrExtensions.Left(posSpace));
sl@0	236	if (posSpace <= ptrExtensions.Length())
sl@0	237	{
sl@0	238	ptrExtensions.Set(ptrExtensions.Mid(posSpace+1));
sl@0	239	}
sl@0	240	}
sl@0	241	else
sl@0	242	{
sl@0	243	iExtensionStrings.Append(ptrExtensions);
sl@0	244	}
sl@0	245	}
sl@0	246	}
sl@0	247
sl@0	248	TBool CTestEglSession::FindExtensionStringL(TExtensionsGroups aExtensionBelongsTo, const TDesC8& aExtensionString)
sl@0	249	{
sl@0	250	//Load the extensions for this group if not already cached
sl@0	251	if (iExtensionGroupCached != aExtensionBelongsTo)
sl@0	252	{
sl@0	253	QueryExtensionsL(aExtensionBelongsTo); // Load extension info
sl@0	254	iExtensionGroupCached = aExtensionBelongsTo;
sl@0	255	}
sl@0	256
sl@0	257	TInt countExtensionStrings = iExtensionStrings.Count();
sl@0	258	for(TUint i=0; i<countExtensionStrings; i++)
sl@0	259	{
sl@0	260	if (iExtensionStrings[i].Compare(aExtensionString)==0)
sl@0	261	{
sl@0	262	// We have a match!
sl@0	263	return ETrue;
sl@0	264	}
sl@0	265	}
sl@0	266
sl@0	267	// No match: copy the extension string into a 16 bit buffer for logging
sl@0	268	const TInt KBufLenMissingExtension=128;
sl@0	269	TBuf16<KBufLenMissingExtension> bufMissingExtension16;
sl@0	270	bufMissingExtension16.Copy(aExtensionString.Left(KBufLenMissingExtension));
sl@0	271
sl@0	272	WARN_PRINTF2(_L("EGL extension missing: [%S]"), &bufMissingExtension16);
sl@0	273	return EFalse;
sl@0	274	}
sl@0	275
sl@0	276	/**
sl@0	277	Converts from TRgb space to Vg floating point colour
sl@0	278	*/
sl@0	279	EXPORT_C void CTestEglSession::ConvertColor(const TRgb& aSource, VGfloat* aTarget)
sl@0	280	//static
sl@0	281	{
sl@0	282	aTarget[0] = (VGfloat)aSource.Red() / 255.f;
sl@0	283	aTarget[1] = (VGfloat)aSource.Green() / 255.f;
sl@0	284	aTarget[2] = (VGfloat)aSource.Blue() / 255.f;
sl@0	285	aTarget[3] = (VGfloat)aSource.Alpha() / 255.f;
sl@0	286	}
sl@0	287
sl@0	288	/** Breakpoint to manually view available configs while debugging */
sl@0	289	EXPORT_C void CTestEglSession::ViewConfigsL()
sl@0	290	{
sl@0	291	EGLConfig configs[KMaxEglConfigs];
sl@0	292	EGLint numConfigs=0;
sl@0	293
sl@0	294	// Query number of configs available
sl@0	295	INFO_PRINTF1(_L("Calling eglGetConfigs to get the number of configs available..."));
sl@0	296	CHECK_EXPECTED_ERROR(eglGetConfigs(iDisplay, NULL, KMaxTInt, &numConfigs));
sl@0	297
sl@0	298	INFO_PRINTF1(_L("Checking number of configs..."));
sl@0	299	ASSERT_TRUE(numConfigs >= 1);
sl@0	300	INFO_PRINTF2(_L("Found %d configs"), numConfigs);
sl@0	301
sl@0	302	// Get the configs
sl@0	303	INFO_PRINTF1(_L("Calling eglGetConfigs to get configs..."));
sl@0	304	CHECK_EXPECTED_ERROR(eglGetConfigs(iDisplay, configs, KMaxEglConfigs, &numConfigs));
sl@0	305
sl@0	306	for(TUint index = 0; index < numConfigs; index++)
sl@0	307	{
sl@0	308	EGLint EGL_BUFFER_SIZE_value;
sl@0	309	EGLint EGL_ALPHA_SIZE_value;
sl@0	310	EGLint EGL_BLUE_SIZE_value;
sl@0	311	EGLint EGL_GREEN_SIZE_value;
sl@0	312	EGLint EGL_RED_SIZE_value;
sl@0	313	#ifdef PRINT_ALL_CONFIGS_DETAILS
sl@0	314	EGLint EGL_DEPTH_SIZE_value;
sl@0	315	EGLint EGL_STENCIL_SIZE_value;
sl@0	316	EGLint EGL_CONFIG_CAVEAT_value;
sl@0	317	EGLint EGL_CONFIG_ID_value;
sl@0	318	EGLint EGL_LEVEL_value;
sl@0	319	EGLint EGL_MAX_PBUFFER_HEIGHT_value;
sl@0	320	EGLint EGL_MAX_PBUFFER_PIXELS_value;
sl@0	321	EGLint EGL_MAX_PBUFFER_WIDTH_value;
sl@0	322	EGLint EGL_NATIVE_RENDERABLE_value;
sl@0	323	EGLint EGL_NATIVE_VISUAL_ID_value;
sl@0	324	EGLint EGL_NATIVE_VISUAL_TYPE_value;
sl@0	325	EGLint EGL_SAMPLES_value;
sl@0	326	EGLint EGL_SAMPLE_BUFFERS_value;
sl@0	327	#endif
sl@0	328	EGLint EGL_SURFACE_TYPE_value;
sl@0	329	#ifdef PRINT_ALL_CONFIGS_DETAILS
sl@0	330	EGLint EGL_TRANSPARENT_TYPE_value;
sl@0	331	EGLint EGL_TRANSPARENT_BLUE_VALUE_value;
sl@0	332	EGLint EGL_TRANSPARENT_GREEN_VALUE_value;
sl@0	333	EGLint EGL_TRANSPARENT_RED_VALUE_value;
sl@0	334	EGLint EGL_BIND_TO_TEXTURE_RGB_value;
sl@0	335	EGLint EGL_BIND_TO_TEXTURE_RGBA_value;
sl@0	336	EGLint EGL_MIN_SWAP_INTERVAL_value;
sl@0	337	EGLint EGL_MAX_SWAP_INTERVAL_value;
sl@0	338	EGLint EGL_LUMINANCE_SIZE_value;
sl@0	339	EGLint EGL_ALPHA_MASK_SIZE_value;
sl@0	340	EGLint EGL_COLOR_BUFFER_TYPE_value;
sl@0	341	#endif
sl@0	342	EGLint EGL_RENDERABLE_TYPE_value;
sl@0	343
sl@0	344	eglGetConfigAttrib(iDisplay, configs[index], EGL_BUFFER_SIZE, &EGL_BUFFER_SIZE_value);
sl@0	345	eglGetConfigAttrib(iDisplay, configs[index], EGL_ALPHA_SIZE, &EGL_ALPHA_SIZE_value);
sl@0	346	eglGetConfigAttrib(iDisplay, configs[index], EGL_BLUE_SIZE, &EGL_BLUE_SIZE_value);
sl@0	347	eglGetConfigAttrib(iDisplay, configs[index], EGL_GREEN_SIZE, &EGL_GREEN_SIZE_value);
sl@0	348	eglGetConfigAttrib(iDisplay, configs[index], EGL_RED_SIZE, &EGL_RED_SIZE_value);
sl@0	349	#ifdef PRINT_ALL_CONFIGS_DETAILS
sl@0	350	eglGetConfigAttrib(iDisplay, configs[index], EGL_DEPTH_SIZE, &EGL_DEPTH_SIZE_value);
sl@0	351	eglGetConfigAttrib(iDisplay, configs[index], EGL_STENCIL_SIZE, &EGL_STENCIL_SIZE_value);
sl@0	352	eglGetConfigAttrib(iDisplay, configs[index], EGL_CONFIG_CAVEAT, &EGL_CONFIG_CAVEAT_value);
sl@0	353	eglGetConfigAttrib(iDisplay, configs[index], EGL_CONFIG_ID, &EGL_CONFIG_ID_value);
sl@0	354	eglGetConfigAttrib(iDisplay, configs[index], EGL_LEVEL, &EGL_LEVEL_value);
sl@0	355	eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_HEIGHT, &EGL_MAX_PBUFFER_HEIGHT_value);
sl@0	356	eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_PIXELS, &EGL_MAX_PBUFFER_PIXELS_value);
sl@0	357	eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_PBUFFER_WIDTH, &EGL_MAX_PBUFFER_WIDTH_value);
sl@0	358	eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_RENDERABLE, &EGL_NATIVE_RENDERABLE_value);
sl@0	359	eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_VISUAL_ID, &EGL_NATIVE_VISUAL_ID_value);
sl@0	360	eglGetConfigAttrib(iDisplay, configs[index], EGL_NATIVE_VISUAL_TYPE, &EGL_NATIVE_VISUAL_TYPE_value);
sl@0	361	eglGetConfigAttrib(iDisplay, configs[index], EGL_SAMPLES, &EGL_SAMPLES_value);
sl@0	362	eglGetConfigAttrib(iDisplay, configs[index], EGL_SAMPLE_BUFFERS, &EGL_SAMPLE_BUFFERS_value);
sl@0	363	#endif
sl@0	364	eglGetConfigAttrib(iDisplay, configs[index], EGL_SURFACE_TYPE, &EGL_SURFACE_TYPE_value);
sl@0	365	#ifdef PRINT_ALL_CONFIGS_DETAILS
sl@0	366	eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_TYPE, &EGL_TRANSPARENT_TYPE_value);
sl@0	367	eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_BLUE_VALUE, &EGL_TRANSPARENT_BLUE_VALUE_value);
sl@0	368	eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_GREEN_VALUE, &EGL_TRANSPARENT_GREEN_VALUE_value);
sl@0	369	eglGetConfigAttrib(iDisplay, configs[index], EGL_TRANSPARENT_RED_VALUE, &EGL_TRANSPARENT_RED_VALUE_value);
sl@0	370	eglGetConfigAttrib(iDisplay, configs[index], EGL_BIND_TO_TEXTURE_RGB, &EGL_BIND_TO_TEXTURE_RGB_value);
sl@0	371	eglGetConfigAttrib(iDisplay, configs[index], EGL_BIND_TO_TEXTURE_RGBA, &EGL_BIND_TO_TEXTURE_RGBA_value);
sl@0	372	eglGetConfigAttrib(iDisplay, configs[index], EGL_MIN_SWAP_INTERVAL, &EGL_MIN_SWAP_INTERVAL_value);
sl@0	373	eglGetConfigAttrib(iDisplay, configs[index], EGL_MAX_SWAP_INTERVAL, &EGL_MAX_SWAP_INTERVAL_value);
sl@0	374	eglGetConfigAttrib(iDisplay, configs[index], EGL_LUMINANCE_SIZE, &EGL_LUMINANCE_SIZE_value);
sl@0	375	eglGetConfigAttrib(iDisplay, configs[index], EGL_ALPHA_MASK_SIZE, &EGL_ALPHA_MASK_SIZE_value);
sl@0	376	eglGetConfigAttrib(iDisplay, configs[index], EGL_COLOR_BUFFER_TYPE, &EGL_COLOR_BUFFER_TYPE_value);
sl@0	377	#endif
sl@0	378	eglGetConfigAttrib(iDisplay, configs[index], EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value);
sl@0	379
sl@0	380	TBool good = ETrue;
sl@0	381
sl@0	382	INFO_PRINTF7(_L("(idx: %3d) RGBA=(%2d) %2d,%2d,%2d,%2d"), index, EGL_BUFFER_SIZE_value,
sl@0	383	EGL_RED_SIZE_value, EGL_GREEN_SIZE_value, EGL_BLUE_SIZE_value,
sl@0	384	EGL_ALPHA_SIZE_value);
sl@0	385	if (!(EGL_RED_SIZE_value == 8 && EGL_GREEN_SIZE_value == 8 && EGL_BLUE_SIZE_value == 8 && EGL_ALPHA_SIZE_value == 0))
sl@0	386	{
sl@0	387	continue;
sl@0	388	}
sl@0	389
sl@0	390	INFO_PRINTF2(_L("\n\n^^^^^^ CONFIG [%d] VALUES ******"), index);
sl@0	391	if (EGL_SURFACE_TYPE_value & EGL_PIXMAP_BIT)
sl@0	392	{
sl@0	393	INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d. <<< Has EGL_PIXMAP_BIT"), EGL_SURFACE_TYPE_value);
sl@0	394	}
sl@0	395	else
sl@0	396	{
sl@0	397	INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d. <<< BAD (not pixmap)"), EGL_SURFACE_TYPE_value);
sl@0	398	good = EFalse;
sl@0	399	}
sl@0	400
sl@0	401	if (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)
sl@0	402	{
sl@0	403	INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d. <<< Has EGL_OPENVG_BIT"), EGL_RENDERABLE_TYPE_value);
sl@0	404	}
sl@0	405	else
sl@0	406	{
sl@0	407	INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d. <<< BAD (not open vg)"), EGL_RENDERABLE_TYPE_value);
sl@0	408	good = EFalse;
sl@0	409	}
sl@0	410
sl@0	411	if (good)
sl@0	412	{
sl@0	413	INFO_PRINTF1(_L("^^^^^^^ GOOD ^^^^^^^"));
sl@0	414	}
sl@0	415
sl@0	416	#ifdef PRINT_ALL_CONFIGS_DETAILS
sl@0	417	INFO_PRINTF2(_L("\n\n*** CONFIG [%d] VALUES ****"), index);
sl@0	418	INFO_PRINTF2(_L("EGL_BUFFER_SIZE=%d."), EGL_BUFFER_SIZE_value);
sl@0	419	INFO_PRINTF2(_L("EGL_ALPHA_SIZE=%d."), EGL_ALPHA_SIZE_value);
sl@0	420	INFO_PRINTF2(_L("EGL_BLUE_SIZE=%d."), EGL_BLUE_SIZE_value);
sl@0	421	INFO_PRINTF2(_L("EGL_GREEN_SIZE=%d."), EGL_GREEN_SIZE_value);
sl@0	422	INFO_PRINTF2(_L("EGL_RED_SIZE=%d."), EGL_RED_SIZE_value);
sl@0	423	INFO_PRINTF2(_L("EGL_DEPTH_SIZE=%d."), EGL_DEPTH_SIZE_value);
sl@0	424	INFO_PRINTF2(_L("EGL_STENCIL_SIZE=%d."), EGL_STENCIL_SIZE_value);
sl@0	425	INFO_PRINTF2(_L("EGL_CONFIG_CAVEAT=%d."), EGL_CONFIG_CAVEAT_value);
sl@0	426	INFO_PRINTF2(_L("EGL_CONFIG_ID=%d."), EGL_CONFIG_ID_value);
sl@0	427	INFO_PRINTF2(_L("EGL_LEVEL=%d."), EGL_LEVEL_value);
sl@0	428	INFO_PRINTF2(_L("EGL_MAX_PBUFFER_HEIGHT=%d."), EGL_MAX_PBUFFER_HEIGHT_value);
sl@0	429	INFO_PRINTF2(_L("EGL_MAX_PBUFFER_PIXELS=%d."), EGL_MAX_PBUFFER_PIXELS_value);
sl@0	430	INFO_PRINTF2(_L("EGL_MAX_PBUFFER_WIDTH=%d."), EGL_MAX_PBUFFER_WIDTH_value);
sl@0	431	INFO_PRINTF2(_L("EGL_NATIVE_RENDERABLE=%d."), EGL_NATIVE_RENDERABLE_value);
sl@0	432	INFO_PRINTF2(_L("EGL_NATIVE_VISUAL_ID=%d."), EGL_NATIVE_VISUAL_ID_value);
sl@0	433	INFO_PRINTF2(_L("EGL_NATIVE_VISUAL_TYPE=%d."), EGL_NATIVE_VISUAL_TYPE_value);
sl@0	434	INFO_PRINTF2(_L("EGL_SAMPLES=%d."), EGL_SAMPLES_value);
sl@0	435	INFO_PRINTF2(_L("EGL_SAMPLE_BUFFERS=%d."), EGL_SAMPLE_BUFFERS_value);
sl@0	436	INFO_PRINTF2(_L("EGL_SURFACE_TYPE=%d."), EGL_SURFACE_TYPE_value);
sl@0	437	INFO_PRINTF2(_L("EGL_TRANSPARENT_TYPE=%d."), EGL_TRANSPARENT_TYPE_value);
sl@0	438	INFO_PRINTF2(_L("EGL_TRANSPARENT_BLUE_VALUE=%d."), EGL_TRANSPARENT_BLUE_VALUE_value);
sl@0	439	INFO_PRINTF2(_L("EGL_TRANSPARENT_GREEN_VALUE=%d."), EGL_TRANSPARENT_GREEN_VALUE_value);
sl@0	440	INFO_PRINTF2(_L("EGL_TRANSPARENT_RED_VALUE=%d."), EGL_TRANSPARENT_RED_VALUE_value);
sl@0	441	INFO_PRINTF2(_L("EGL_BIND_TO_TEXTURE_RGB=%d."), EGL_BIND_TO_TEXTURE_RGB_value);
sl@0	442	INFO_PRINTF2(_L("EGL_BIND_TO_TEXTURE_RGBA=%d."), EGL_BIND_TO_TEXTURE_RGBA_value);
sl@0	443	INFO_PRINTF2(_L("EGL_MIN_SWAP_INTERVAL=%d."), EGL_MIN_SWAP_INTERVAL_value);
sl@0	444	INFO_PRINTF2(_L("EGL_MAX_SWAP_INTERVAL=%d."), EGL_MAX_SWAP_INTERVAL_value);
sl@0	445	INFO_PRINTF2(_L("EGL_LUMINANCE_SIZE=%d."), EGL_LUMINANCE_SIZE_value);
sl@0	446	INFO_PRINTF2(_L("EGL_ALPHA_MASK_SIZE=%d."), EGL_ALPHA_MASK_SIZE_value);
sl@0	447	INFO_PRINTF2(_L("EGL_COLOR_BUFFER_TYPE=%d."), EGL_COLOR_BUFFER_TYPE_value);
sl@0	448	INFO_PRINTF2(_L("EGL_RENDERABLE_TYPE=%d."), EGL_RENDERABLE_TYPE_value);
sl@0	449	INFO_PRINTF2(_L("\n*********************************\n\n"), index);
sl@0	450	#endif
sl@0	451	}
sl@0	452	}
sl@0	453
sl@0	454	LOCAL_C TEglConfigMatchType GetMatchType(EGLint aAttrib, TEglConfigMatchRule aMatchRule)
sl@0	455	{
sl@0	456	const TConfigMatchRuleItem* curMatchRuleItem = KConfigMatchRules[aMatchRule];
sl@0	457
sl@0	458	while(curMatchRuleItem->iAttrib != EGL_NONE)
sl@0	459	{
sl@0	460	if (aAttrib == curMatchRuleItem->iAttrib)
sl@0	461	{
sl@0	462	return curMatchRuleItem->iMatchType;
sl@0	463	}
sl@0	464	curMatchRuleItem++;
sl@0	465	}
sl@0	466
sl@0	467	RDebug::Printf("Unknown attrib %x", aAttrib);
sl@0	468	return eMatchUnknown;
sl@0	469	}
sl@0	470
sl@0	471	/**
sl@0	472	Returns the first index of a config that matches the requested config extactly
sl@0	473	*/
sl@0	474	TInt CTestEglSession::GetFullMatchConfigIndex(EGLDisplay aDisplay, EGLConfig *aConfigs, TInt aNumConfigs,
sl@0	475	const EGLint aWantedAttribs[], TEglConfigMatchRule aMatchRule)
sl@0	476	{
sl@0	477	EGLint value=0;
sl@0	478	for(TUint idxConfig=0; idxConfig<aNumConfigs; idxConfig++)
sl@0	479	{
sl@0	480	const EGLint *curAttrib = aWantedAttribs;
sl@0	481	TBool match = ETrue;
sl@0	482
sl@0	483	while(*curAttrib != EGL_NONE && match)
sl@0	484	{
sl@0	485	ASSERT_EGL_TRUE(eglGetConfigAttrib(aDisplay, aConfigs[idxConfig], *curAttrib, &value));
sl@0	486
sl@0	487	switch(GetMatchType(*curAttrib, aMatchRule))
sl@0	488	{
sl@0	489	case eMatchEqual:
sl@0	490	if (value != curAttrib[1])
sl@0	491	{
sl@0	492	match = EFalse;
sl@0	493	}
sl@0	494	break;
sl@0	495	case eMatchAtLeast:
sl@0	496	if (value < curAttrib[1]) // Note, we detect "failure to match", hence "<" not ">="!
sl@0	497	{
sl@0	498	match = EFalse;
sl@0	499	}
sl@0	500	break;
sl@0	501	case eMatchBitMask:
sl@0	502	if ((value & curAttrib[1]) != curAttrib[1])
sl@0	503	{
sl@0	504	match = EFalse;
sl@0	505	}
sl@0	506	break;
sl@0	507	case eMatchAlways:
sl@0	508	break;
sl@0	509
sl@0	510	default:
sl@0	511	// We should not get here.
sl@0	512	ASSERT(FALSE);
sl@0	513	break;
sl@0	514	}
sl@0	515	curAttrib += 2;
sl@0	516	}
sl@0	517
sl@0	518	// If we get here with match set, we have matched all attributes, and have found a match.
sl@0	519	if (match)
sl@0	520	{
sl@0	521	return idxConfig;
sl@0	522	}
sl@0	523	}
sl@0	524	return KErrNotFound;
sl@0	525	}
sl@0	526
sl@0	527	TInt CTestEglSession::ConfigToPixelFormatTableLength() const
sl@0	528	{
sl@0	529	return sizeof(KMapEglConfigToPixelFormat) / sizeof(TMapEglConfigToPixelFormat);
sl@0	530	}
sl@0	531
sl@0	532	const TMapEglConfigToPixelFormat& CTestEglSession::ConfigToPixelFormatTable(TInt aIndex) const
sl@0	533	{
sl@0	534	return KMapEglConfigToPixelFormat[aIndex];
sl@0	535	}
sl@0	536
sl@0	537	/**
sl@0	538	Returns pixel format inforamtion for a given EGL config.
sl@0	539	@param aConfig The EGL config for which pixel format information will be returned.
sl@0	540	@return A pointer to the pixel format information for the given EGL config.
sl@0	541	Tf the config cannot be mapped, then NULL is returned.
sl@0	542	*/
sl@0	543	EXPORT_C const TMapEglConfigToPixelFormat* CTestEglSession::GetPixelFormatFromEglConfigL(EGLConfig aConfig)
sl@0	544	{
sl@0	545	EGLint bufferSize=0;
sl@0	546	EGLint alphaSize=0;
sl@0	547	EGLint redSize=0;
sl@0	548	EGLint greenSize=0;
sl@0	549	EGLint blueSize=0;
sl@0	550	EGLint colorBufferType=0;
sl@0	551	EGLint surfaceType = 0;
sl@0	552
sl@0	553	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_BUFFER_SIZE, &bufferSize));
sl@0	554	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_ALPHA_SIZE, &alphaSize));
sl@0	555	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_RED_SIZE, &redSize));
sl@0	556	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_GREEN_SIZE, &greenSize));
sl@0	557	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_BLUE_SIZE, &blueSize));
sl@0	558	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_COLOR_BUFFER_TYPE, &colorBufferType));
sl@0	559	CHECK_EXPECTED_ERROR(eglGetConfigAttrib(iDisplay, aConfig, EGL_SURFACE_TYPE, &surfaceType));
sl@0	560
sl@0	561	INFO_PRINTF7(_L(">>>>> Config info: %d, %d, %d,%d,%d, 0x%x"), bufferSize, alphaSize, redSize, greenSize, blueSize, colorBufferType);
sl@0	562
sl@0	563	for(TUint i=0; i<ConfigToPixelFormatTableLength(); i++)
sl@0	564	{
sl@0	565	if ((ConfigToPixelFormatTable(i).iBufferSize == bufferSize)
sl@0	566	&& (ConfigToPixelFormatTable(i).iAlphaSize == alphaSize)
sl@0	567	&& (ConfigToPixelFormatTable(i).iRedSize == redSize)
sl@0	568	&& (ConfigToPixelFormatTable(i).iGreenSize == greenSize)
sl@0	569	&& (ConfigToPixelFormatTable(i).iBlueSize == blueSize)
sl@0	570	&& (ConfigToPixelFormatTable(i).iColorBufferType == colorBufferType)
sl@0	571	&& ((ConfigToPixelFormatTable(i).iSurfaceTypeFlags & surfaceType) == ConfigToPixelFormatTable(i).iSurfaceTypeFlags))
sl@0	572	{
sl@0	573	return &ConfigToPixelFormatTable(i);
sl@0	574	}
sl@0	575	}
sl@0	576
sl@0	577	return NULL;
sl@0	578	}
sl@0	579
sl@0	580	EXPORT_C void CTestEglSession::CleanupSurfaceFbsBitmapL()
sl@0	581	{
sl@0	582	CleanupSurfaceAndContextL();
sl@0	583
sl@0	584	delete iFbsBitmap;
sl@0	585	iFbsBitmap = NULL;
sl@0	586	}
sl@0	587
sl@0	588	EXPORT_C void CTestEglSession::CleanupSurfaceAndContextL()
sl@0	589	{
sl@0	590	ASSERT_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	591	ASSERT_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	592
sl@0	593	// Clean up
sl@0	594	INFO_PRINTF1(_L("Calling eglMakeCurrent(NULL values)..."));
sl@0	595	CHECK_EXPECTED_ERROR(eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
sl@0	596
sl@0	597	INFO_PRINTF1(_L("Calling eglDestroyContext()..."));
sl@0	598	CHECK_EXPECTED_ERROR(eglDestroyContext(iDisplay, iContext));
sl@0	599	iContext = EGL_NO_CONTEXT;
sl@0	600
sl@0	601	INFO_PRINTF1(_L("Calling eglDestroySurface()..."));
sl@0	602	CHECK_EXPECTED_ERROR(eglDestroySurface(iDisplay, iSurface));
sl@0	603	iSurface = EGL_NO_SURFACE;
sl@0	604	}
sl@0	605
sl@0	606	EXPORT_C CFbsBitmap* CTestEglSession::NativeFbsBitmap()
sl@0	607	{
sl@0	608	return iFbsBitmap;
sl@0	609	}
sl@0	610
sl@0	611	EXPORT_C RSgImage& CTestEglSession::NativeSgImage()
sl@0	612	{
sl@0	613	return iSgImage;
sl@0	614	}
sl@0	615
sl@0	616	EXPORT_C EGLSurface CTestEglSession::Surface() const
sl@0	617	{
sl@0	618	return iSurface;
sl@0	619	}
sl@0	620
sl@0	621	EXPORT_C EGLContext CTestEglSession::Context() const
sl@0	622	{
sl@0	623	return iContext;
sl@0	624	}
sl@0	625
sl@0	626	EXPORT_C EGLConfig CTestEglSession::GetConfigExactMatchL(TEglTestConfig aConfigAttribIndex, TEglConfigMatchRule aMatchRule)
sl@0	627	{
sl@0	628	if(aConfigAttribIndex >= EEglTestConfigMax )
sl@0	629	{
sl@0	630	ERR_PRINTF1(_L("Attribute index out of range, please check the INI file"));
sl@0	631	User::Leave(KErrArgument);
sl@0	632	}
sl@0	633
sl@0	634	EGLConfig configs[KMaxEglConfigs];
sl@0	635	EGLint numConfigs=0;
sl@0	636	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay, KConfigAttribs[aConfigAttribIndex], configs, KMaxEglConfigs, &numConfigs));
sl@0	637	if (numConfigs <= 0)
sl@0	638	{
sl@0	639	// we just WARN, as we don't know if this is expected yet (if it is, then catch the leaving error)
sl@0	640	WARN_PRINTF1(_L("GetConfigExactMatchL - Could not find a matching config, eglChooseConfig returned 0 configs!"));
sl@0	641	User::Leave(KTestNoMatchingConfig);
sl@0	642	}
sl@0	643
sl@0	644	// Check that any of the configs returned matches the desired attributes
sl@0	645	TInt match = GetFullMatchConfigIndex(iDisplay, configs, numConfigs, KConfigAttribs[aConfigAttribIndex], aMatchRule);
sl@0	646	if (match == KErrNotFound)
sl@0	647	{
sl@0	648	// we just WARN, as we don't know if this is expected yet (if it is, then catch the leaving error)
sl@0	649	WARN_PRINTF1(_L("GetConfigExactMatchL - Could not find a matching config amongst those returned by eglChooseConfig!"));
sl@0	650	User::Leave(KTestNoMatchingConfig);
sl@0	651	}
sl@0	652	return configs[match];
sl@0	653	}
sl@0	654
sl@0	655	/**
sl@0	656	Creates a pixmap surface from a CFbsBitmap, draws to it and checks that the drawing operation succeeded.
sl@0	657	*/
sl@0	658	EXPORT_C void CTestEglSession::TryUsePixmapCFbsBitmapL()
sl@0	659	{
sl@0	660	INFO_PRINTF2(_L("thread %d: TryUsePixmapCFbsBitmapL"), iThreadIdx);
sl@0	661	EGLConfig currentConfig = GetConfigExactMatchL(EPixmapAttribsColor64K);
sl@0	662	TryUsePixmapCFbsBitmapOpenVgL(currentConfig, KPixmapSize, EColor64K);
sl@0	663	}
sl@0	664
sl@0	665	/**
sl@0	666	Creates a pixmap surface from a CFbsBitmap, draws to it and checks that the drawing operation succeeded.
sl@0	667	*/
sl@0	668	EXPORT_C void CTestEglSession::TryUsePixmapCFbsBitmapOpenVgL(EGLConfig aConfig, const TSize& aSize, TDisplayMode aDisplayMode)
sl@0	669	{
sl@0	670	CreatePixmapSurfaceAndMakeCurrentL(aConfig, aSize, aDisplayMode);
sl@0	671	DrawOpenVgL();
sl@0	672
sl@0	673	// Wait for the drawing to complete
sl@0	674	eglWaitClient();
sl@0	675
sl@0	676	CheckImageDataL(iFbsBitmap);
sl@0	677	CheckImageDataVgL(VG_sRGB_565);
sl@0	678	CleanupSurfaceFbsBitmapL();
sl@0	679	CloseFbsSession();
sl@0	680	}
sl@0	681
sl@0	682	/**
sl@0	683	Creates a pixmap surface from a CFbsBitmap, draws to it and checks that the drawing operation succeeded.
sl@0	684	*/
sl@0	685	EXPORT_C void CTestEglSession::TryUsePixmapCFbsBitmapOpenGlesL(EGLConfig aConfig, const TSize& aSize, TDisplayMode aDisplayMode, TInt aRenderVersion)
sl@0	686	{
sl@0	687	CreatePixmapSurfaceAndMakeCurrentL(aConfig, aSize, aDisplayMode,EGL_OPENGL_ES_API, aRenderVersion);
sl@0	688	DrawOpenGLesL();
sl@0	689
sl@0	690	// Wait for the drawing to complete
sl@0	691	eglWaitClient();
sl@0	692
sl@0	693	CheckImageDataFullRedishL(iFbsBitmap);
sl@0	694	CleanupSurfaceFbsBitmapL();
sl@0	695	CloseFbsSession();
sl@0	696	}
sl@0	697
sl@0	698	/**
sl@0	699	Creates a pixmap surface from a RSgImage, draws to it and checks that the drawing operation succeeded.
sl@0	700	*/
sl@0	701	EXPORT_C void CTestEglSession::TryUsePixmapRSgImageL()
sl@0	702	{
sl@0	703	INFO_PRINTF2(_L("thread %d: TryUsePixmapRSgImageL"), iThreadIdx);
sl@0	704	TSgImageInfo imageInfo;
sl@0	705	imageInfo.iSizeInPixels = KPixmapSize;
sl@0	706	imageInfo.iPixelFormat = EUidPixelFormatXRGB_8888;
sl@0	707	// will draw to and read from the image using OpenVg
sl@0	708	#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	709	imageInfo.iUsage = ESgUsageBitOpenVgSurface \| ESgUsageBitOpenVgImage;
sl@0	710	#else
sl@0	711	// will also read from the image using DirectGdi
sl@0	712	imageInfo.iUsage = ESgUsageOpenVgTarget \| ESgUsageDirectGdiSource;
sl@0	713	imageInfo.iShareable = EFalse;
sl@0	714	imageInfo.iCpuAccess = ESgCpuAccessNone;
sl@0	715	imageInfo.iScreenId = KSgScreenIdMain;
sl@0	716	imageInfo.iUserAttributes = NULL;
sl@0	717	imageInfo.iUserAttributeCount=0;
sl@0	718	#endif
sl@0	719	CreatePixmapSurfaceAndMakeCurrentAndMatchL(imageInfo, EResourceCloseSgImageLate);
sl@0	720	DrawOpenVgL();
sl@0	721
sl@0	722	// Wait for the drawing to complete
sl@0	723	eglWaitClient();
sl@0	724
sl@0	725	//we can't retrieve data directly from the SgImage as
sl@0	726	//non-unified architecture doesn't allow readback from the GPU
sl@0	727	CheckImageDataVgL(VG_sXRGB_8888);
sl@0	728	CleanupSurfaceSgImageL();
sl@0	729	CloseSgDriver();
sl@0	730	}
sl@0	731
sl@0	732	EXPORT_C TBool CTestEglSession::TryUsePixmapRSgImageOpenGlesL(EGLConfig aConfig, const TSgImageInfo& aImageInfo, TResourceCloseRule aResourceCloseRule, TInt aRenderVersion)
sl@0	733	{
sl@0	734	CreatePixmapSurfaceAndMakeCurrentL(aConfig, aImageInfo, aResourceCloseRule ,EGL_OPENGL_ES_API, aRenderVersion);
sl@0	735
sl@0	736	DrawOpenGLesL();
sl@0	737
sl@0	738	// Wait for the drawing to complete
sl@0	739	eglWaitClient();
sl@0	740
sl@0	741	//we can't retrieve data directly from SgImage as non-unified
sl@0	742	//architecture doesn't allow readback from the GPU
sl@0	743
sl@0	744	if (aImageInfo.iPixelFormat == EUidPixelFormatXRGB_8888 \|\|
sl@0	745	aImageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE)
sl@0	746	{
sl@0	747	CheckImageDataGLesL();
sl@0	748	}
sl@0	749
sl@0	750	CleanupSurfaceSgImageL();
sl@0	751	CloseSgDriver();
sl@0	752	return ETrue;
sl@0	753	}
sl@0	754
sl@0	755	/**
sl@0	756	Compound operation that constructs an RSgImage and uses it to create a pixmap suface.
sl@0	757	It then draws to the surface using OpenVG and checks whether the drawing succeeded.
sl@0	758	It cleans up the pixmap surface it destroyed.
sl@0	759	@param aConfig The EGL config to be used when creating the pixmap surface
sl@0	760	@param aImageInfo Used to create the RSgImage pixmap
sl@0	761	@param aCloseNativeImageEarly When ETrue, the RSgImage is closed as soon as the pixmap surface has been
sl@0	762	created. Otherwise, the RSgImage is closed during cleanup, when the pixmap surface is destroyed.
sl@0	763	@return Whether it was possible to create an iSgImage for the given aImageInfo
sl@0	764	*/
sl@0	765	EXPORT_C TBool CTestEglSession::TryUsePixmapRSgImageOpenVgL(EGLConfig aConfig, const TSgImageInfo& aImageInfo, TResourceCloseRule aResourceCloseRule)
sl@0	766	{
sl@0	767	CreatePixmapSurfaceAndMakeCurrentL(aConfig, aImageInfo, aResourceCloseRule);
sl@0	768
sl@0	769	DrawOpenVgL();
sl@0	770
sl@0	771	// Wait for the drawing to complete
sl@0	772	eglWaitClient();
sl@0	773
sl@0	774	//we can't retrieve data directly from the SgImage as
sl@0	775	//non-unified architecture doesn't allow readback from the GPU
sl@0	776	CheckImageDataVgL(VG_sXRGB_8888);
sl@0	777	CleanupSurfaceSgImageL();
sl@0	778	CloseSgDriver();
sl@0	779	return ETrue;
sl@0	780	}
sl@0	781
sl@0	782	EXPORT_C void CTestEglSession::CreateWindowSurfaceAndMakeCurrentL(EGLConfig aConfig, RWindow& aWindow, TBool aVgAlphaFormatPre, EGLenum aBindAPI, TInt aRenderVersionNumber, EGLint* aAttribList)
sl@0	783	{
sl@0	784	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	785	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	786
sl@0	787	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	788
sl@0	789	// Create a Window surface from the native image
sl@0	790	const EGLint* windowAttribs = aAttribList;
sl@0	791	if(!windowAttribs)
sl@0	792	{
sl@0	793	windowAttribs = (aVgAlphaFormatPre && aBindAPI == EGL_OPENVG_API) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
sl@0	794	}
sl@0	795	iSurface = eglCreateWindowSurface(iDisplay, aConfig, &aWindow, windowAttribs);
sl@0	796	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	797
sl@0	798	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	799	const EGLint KAttribsListCtxNone[] = { EGL_NONE };
sl@0	800	const EGLint KAttribsListCtxGles2[] = { EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE };
sl@0	801	const EGLint* attrib_list_ctx = (aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber == 2) ? KAttribsListCtxGles2 : KAttribsListCtxNone;
sl@0	802	iContext = eglCreateContext(iDisplay, aConfig, EGL_NO_CONTEXT, attrib_list_ctx);
sl@0	803	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	804	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	805	}
sl@0	806
sl@0	807
sl@0	808	EXPORT_C TBool CTestEglSession::CongfigSupportsOpenVgL(EGLConfig aConfig)
sl@0	809	{
sl@0	810	EGLint EGL_RENDERABLE_TYPE_value = 0;
sl@0	811	ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, aConfig, EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value));
sl@0	812	return (EGL_RENDERABLE_TYPE_value&EGL_OPENVG_BIT)>0;
sl@0	813	}
sl@0	814
sl@0	815	EXPORT_C void CTestEglSession::CreatePixmapSurfaceAndMakeCurrentAndMatchL(const TSgImageInfo& aImageInfo, TResourceCloseRule aResourceCloseRule, EGLenum aBindAPI, TInt aRenderVersionNumber)
sl@0	816	{
sl@0	817	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	818	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	819
sl@0	820	OpenSgDriverL();
sl@0	821	ASSERT_EQUALS(iSgImage.Create(aImageInfo, NULL, 0), KErrNone);
sl@0	822
sl@0	823	EGLint renderableType = 0;
sl@0	824	if(aBindAPI == EGL_OPENVG_API)
sl@0	825	{
sl@0	826	renderableType = EGL_OPENVG_BIT;
sl@0	827	}
sl@0	828	else if(aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber==1)
sl@0	829	{
sl@0	830	renderableType = EGL_OPENGL_ES_BIT;
sl@0	831	}
sl@0	832	else if(aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber==2)
sl@0	833	{
sl@0	834	renderableType = EGL_OPENGL_ES2_BIT;
sl@0	835	}
sl@0	836	else
sl@0	837	{
sl@0	838	ERR_PRINTF1(_L("CreatePixmapSurfaceAndMakeCurrentAndMatchL - Unkown API requested!"));
sl@0	839	User::Leave(KErrArgument);
sl@0	840	}
sl@0	841	EGLint attrib_list[] = {
sl@0	842	EGL_MATCH_NATIVE_PIXMAP,(TInt)&iSgImage,
sl@0	843	EGL_RENDERABLE_TYPE,renderableType,
sl@0	844	EGL_SURFACE_TYPE,EGL_PIXMAP_BIT,
sl@0	845	EGL_NONE};
sl@0	846
sl@0	847	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	848
sl@0	849	EGLConfig config;
sl@0	850	EGLint numConfigs;
sl@0	851	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,attrib_list,&config,1,&numConfigs));
sl@0	852	if (numConfigs <= 0)
sl@0	853	{
sl@0	854	// we just WARN, as we don't know if this is expected yet (if it is, then catch the leaving error)
sl@0	855	WARN_PRINTF1(_L("CreatePixmapSurfaceAndMakeCurrentAndMatchL - Could not find a matching config!"));
sl@0	856	iSgImage.Close();
sl@0	857	CloseSgDriver();
sl@0	858	// Leave with a unique knonwn error code - useful to catch this error in negative tests
sl@0	859	User::Leave(KTestNoMatchingConfig);
sl@0	860	}
sl@0	861
sl@0	862	// Create a pixmap surface from the native image
sl@0	863	EGLint EGL_RENDERABLE_TYPE_value = 0;
sl@0	864	ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, config, EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value));
sl@0	865	const EGLint* pixmapAttribs = ((aImageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) && (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
sl@0	866	iSurface = eglCreatePixmapSurface(iDisplay, config, &iSgImage, pixmapAttribs);
sl@0	867	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	868
sl@0	869	if (aResourceCloseRule == EResourceCloseSgImageEarly)
sl@0	870	{
sl@0	871	// EGL should have taken its own reference to the SgImage, so it should be able to continue
sl@0	872	// to use the underlying data after this local image has been closed.
sl@0	873	iSgImage.Close();
sl@0	874	}
sl@0	875
sl@0	876	if (aResourceCloseRule == EResourceCloseSgDriverAndImageEarly)
sl@0	877	{
sl@0	878	// EGL should have taken its own reference to the SgDriver, so it should be able to continue
sl@0	879	// to use its reference to the image resource after this local reference to the driver has
sl@0	880	// been closed.
sl@0	881	iSgImage.Close();
sl@0	882	CloseSgDriver();
sl@0	883	}
sl@0	884
sl@0	885	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	886	const EGLint KAttribsListCtxNone[] = { EGL_NONE };
sl@0	887	const EGLint KAttribsListCtxGles2[] = { EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE };
sl@0	888	const EGLint* attrib_list_ctx = (aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber == 2) ? KAttribsListCtxGles2 : KAttribsListCtxNone;
sl@0	889	iContext = eglCreateContext(iDisplay, config, EGL_NO_CONTEXT, attrib_list_ctx);
sl@0	890	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	891	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	892	}
sl@0	893
sl@0	894	/**
sl@0	895	Compound operation that constructs an RSgImage and uses it to create a pixmap suface.
sl@0	896	It then makes it current to the thread.
sl@0	897	@param aConfig The EGL config to be used when creating the pixmap surface
sl@0	898	@param aImageInfo Used to create the RSgImage pixmap
sl@0	899	@param aCloseNativeImageEarly When ETrue, the RSgImage is closed as soon as the pixmap surface has been
sl@0	900	created. Otherwise, the RSgImage is left to be destroyed later by some other method
sl@0	901	- e.g at the same time as destroying the surface.
sl@0	902	@return Whether it was possible to create an iSgImage for the given aImageInfo
sl@0	903	*/
sl@0	904	EXPORT_C void CTestEglSession::CreatePixmapSurfaceAndMakeCurrentL(EGLConfig aConfig, const TSgImageInfo& aImageInfo, TResourceCloseRule aResourceCloseRule, EGLenum aBindAPI, TInt aRenderVersionNumber)
sl@0	905	{
sl@0	906	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	907	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	908
sl@0	909	OpenSgDriverL();
sl@0	910	ASSERT_EQUALS(iSgImage.Create(aImageInfo, NULL, 0), KErrNone);
sl@0	911
sl@0	912	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	913
sl@0	914	// Create a pixmap surface from the native image
sl@0	915	EGLint EGL_RENDERABLE_TYPE_value = 0;
sl@0	916	ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, aConfig, EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value));
sl@0	917	const EGLint* pixmapAttribs = ((aImageInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE) && (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
sl@0	918	iSurface = eglCreatePixmapSurface(iDisplay, aConfig, &iSgImage, pixmapAttribs);
sl@0	919	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	920
sl@0	921	if (aResourceCloseRule == EResourceCloseSgImageEarly)
sl@0	922	{
sl@0	923	// EGL should have taken its own reference to the SgImage, so it should be able to continue
sl@0	924	// to use the underlying data after this local image has been closed.
sl@0	925	iSgImage.Close();
sl@0	926	}
sl@0	927	if (aResourceCloseRule == EResourceCloseSgDriverAndImageEarly)
sl@0	928	{
sl@0	929	// EGL should have taken its own reference to the SgDriver, so it should be able to continue
sl@0	930	// to use its reference to the image resource after this local reference to the driver has
sl@0	931	// been closed.
sl@0	932	iSgImage.Close();
sl@0	933	CloseSgDriver();
sl@0	934	}
sl@0	935
sl@0	936	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	937	const EGLint KAttribsListCtxNone[] = { EGL_NONE };
sl@0	938	const EGLint KAttribsListCtxGles2[] = { EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE };
sl@0	939	const EGLint* attrib_list_ctx = (aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber == 2) ? KAttribsListCtxGles2 : KAttribsListCtxNone;
sl@0	940	iContext = eglCreateContext(iDisplay, aConfig, EGL_NO_CONTEXT, attrib_list_ctx);
sl@0	941	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	942	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	943	}
sl@0	944
sl@0	945	EXPORT_C TInt CTestEglSession::CreateBitmap(CFbsBitmap* aFbsBitmap, const TSize& aSize, TDisplayMode aDisplayMode)
sl@0	946	{
sl@0	947	//Fist try with CreateHardwareBitmap to check whether we are on hardware
sl@0	948	TInt result = aFbsBitmap->CreateHardwareBitmap(aSize, aDisplayMode, KUidEglTestServer);
sl@0	949
sl@0	950	if(result == KErrNotSupported)
sl@0	951	{
sl@0	952	//we are not on hardware
sl@0	953	result = aFbsBitmap->Create(aSize, aDisplayMode);
sl@0	954	}
sl@0	955	return result;
sl@0	956	}
sl@0	957
sl@0	958	EXPORT_C void CTestEglSession::CreatePixmapSurfaceAndMakeCurrentL(EGLConfig aConfig, const TSize& aSize, TDisplayMode displayMode, EGLenum aBindAPI, TInt aRenderVersionNumber)
sl@0	959	{
sl@0	960	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	961	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	962
sl@0	963	// Create an empty native CFbsBitmap
sl@0	964	OpenFbsSessionL();
sl@0	965	iFbsBitmap = new(ELeave)CFbsBitmap;
sl@0	966	ASSERT_EQUALS(CreateBitmap(iFbsBitmap, aSize, displayMode), KErrNone);
sl@0	967
sl@0	968	const EGLint* attrib_list = NULL;
sl@0	969	if(aBindAPI == EGL_OPENVG_API)
sl@0	970	{
sl@0	971	// no attribs to modify
sl@0	972	}
sl@0	973	else if(aBindAPI == EGL_OPENGL_ES_API)
sl@0	974	{
sl@0	975	// no attribs to modify
sl@0	976	}
sl@0	977	else if(aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber==2)
sl@0	978	{
sl@0	979	const EGLint KAttribGLES2[] = {EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE};
sl@0	980	attrib_list=KAttribGLES2;
sl@0	981	}
sl@0	982	else
sl@0	983	{
sl@0	984	ERR_PRINTF1(_L("CreatePixmapSurfaceAndMakeCurrentL - Unkown API requested!"));
sl@0	985	User::Leave(KErrArgument);
sl@0	986	}
sl@0	987	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	988
sl@0	989	// Create a pixmap surface from the native image
sl@0	990	EGLint EGL_RENDERABLE_TYPE_value = 0;
sl@0	991	ASSERT_EGL_TRUE(eglGetConfigAttrib(iDisplay, aConfig, EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value));
sl@0	992	const EGLint* pixmapAttribs = ((displayMode == EColor16MAP) && (EGL_RENDERABLE_TYPE_value & EGL_OPENVG_BIT)) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
sl@0	993	iSurface = eglCreatePixmapSurface(iDisplay, aConfig, iFbsBitmap, pixmapAttribs);
sl@0	994	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	995
sl@0	996	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	997	iContext = eglCreateContext(iDisplay, aConfig, EGL_NO_CONTEXT, attrib_list);
sl@0	998	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	999	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	1000	}
sl@0	1001
sl@0	1002	EXPORT_C void CTestEglSession::CreatePixmapSurfaceAndMakeCurrentAndMatchL(const TSize& aSize, TDisplayMode aDisplayMode, EGLenum aBindAPI, TInt aRenderVersionNumber)
sl@0	1003	{
sl@0	1004	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	1005	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	1006
sl@0	1007	OpenFbsSessionL();
sl@0	1008	iFbsBitmap = new(ELeave)CFbsBitmap;
sl@0	1009	ASSERT_EQUALS(CreateBitmap(iFbsBitmap, aSize, aDisplayMode), KErrNone);
sl@0	1010
sl@0	1011	EGLint renderableType = 0;
sl@0	1012	if(aBindAPI == EGL_OPENVG_API)
sl@0	1013	{
sl@0	1014	renderableType = EGL_OPENVG_BIT;
sl@0	1015	}
sl@0	1016	else if(aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber==1)
sl@0	1017	{
sl@0	1018	renderableType = EGL_OPENGL_ES_BIT;
sl@0	1019	}
sl@0	1020	else if(aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber==2)
sl@0	1021	{
sl@0	1022	renderableType = EGL_OPENGL_ES2_BIT;
sl@0	1023	}
sl@0	1024	else
sl@0	1025	{
sl@0	1026	ERR_PRINTF1(_L("CreatePixmapSurfaceAndMakeCurrentAndMatchL - Unkown API requested!"));
sl@0	1027	User::Leave(KErrArgument);
sl@0	1028	}
sl@0	1029	EGLint attrib_list[] = {
sl@0	1030	EGL_MATCH_NATIVE_PIXMAP,(TInt)iFbsBitmap,
sl@0	1031	EGL_RENDERABLE_TYPE,renderableType,
sl@0	1032	EGL_SURFACE_TYPE,EGL_PIXMAP_BIT,
sl@0	1033	EGL_NONE};
sl@0	1034
sl@0	1035	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	1036
sl@0	1037	EGLConfig config;
sl@0	1038	EGLint numConfigs;
sl@0	1039	ASSERT_EGL_TRUE(eglChooseConfig(iDisplay,attrib_list,&config,1,&numConfigs));
sl@0	1040	if (numConfigs <= 0)
sl@0	1041	{
sl@0	1042	// we just WARN, as we don't know if this is expected yet (if it is, then catch the leaving error)
sl@0	1043	WARN_PRINTF1(_L("CreatePixmapSurfaceAndMakeCurrentAndMatchL - Could not find a matching config!"));
sl@0	1044	iSgImage.Close();
sl@0	1045	CloseSgDriver();
sl@0	1046	// Leave with a unique knonwn error code - useful to catch this error in negative tests
sl@0	1047	User::Leave(KTestNoMatchingConfig);
sl@0	1048	}
sl@0	1049
sl@0	1050	// Create a pixmap surface from the native image
sl@0	1051	const EGLint* pixmapAttribs = (aDisplayMode == EColor16MAP && aBindAPI == EGL_OPENVG_API) ? KPixmapAttribsVgAlphaFormatPre : KPixmapAttribsNone;
sl@0	1052	iSurface = eglCreatePixmapSurface(iDisplay, config, iFbsBitmap, pixmapAttribs);
sl@0	1053	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	1054
sl@0	1055	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	1056	const EGLint KAttribsListCtxNone[] = { EGL_NONE };
sl@0	1057	const EGLint KAttribsListCtxGles2[] = { EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE };
sl@0	1058	const EGLint* attrib_list_ctx = (aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber == 2) ? KAttribsListCtxGles2 : KAttribsListCtxNone;
sl@0	1059	iContext = eglCreateContext(iDisplay, config, EGL_NO_CONTEXT, attrib_list_ctx);
sl@0	1060	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	1061	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	1062	}
sl@0	1063
sl@0	1064	EXPORT_C void CTestEglSession::CreatePbufferSurfaceAndMakeCurrentL(EGLConfig aConfig, const TSize& aSize, EGLenum aBindAPI, TInt aRenderVersionNumber)
sl@0	1065	{
sl@0	1066	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	1067	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	1068
sl@0	1069	ASSERT_EQUALS(iSurface, EGL_NO_SURFACE);
sl@0	1070	ASSERT_EQUALS(iContext, EGL_NO_CONTEXT);
sl@0	1071
sl@0	1072	ASSERT_EGL_TRUE(eglBindAPI(aBindAPI));
sl@0	1073
sl@0	1074	// PBuffer attribs options are:
sl@0	1075	// EGL_WIDTH, EGL_HEIGHT, EGL_LARGEST_PBUFFER,
sl@0	1076	// EGL_TEXTURE_FORMAT, EGL_TEXTURE_TARGET, EGL_MIPMAP_TEXTURE,
sl@0	1077	// EGL_VG_COLORSPACE, and EGL_VG_ALPHA_FORMAT
sl@0	1078	// Create a pbuffer surface of the given size
sl@0	1079	const EGLint KPbufferAttribs[] = {
sl@0	1080	EGL_WIDTH, aSize.iWidth,
sl@0	1081	EGL_HEIGHT, aSize.iHeight,
sl@0	1082	EGL_NONE };
sl@0	1083	iSurface = eglCreatePbufferSurface(iDisplay, aConfig, KPbufferAttribs);
sl@0	1084	ASSERT_EGL_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	1085
sl@0	1086	// Create a context for drawing to/reading from the pixmap surface and make it current
sl@0	1087	const EGLint KAttribsListCtxNone[] = { EGL_NONE };
sl@0	1088	const EGLint KAttribsListCtxGles2[] = { EGL_CONTEXT_CLIENT_VERSION, aRenderVersionNumber, EGL_NONE };
sl@0	1089	const EGLint* attrib_list_ctx = (aBindAPI == EGL_OPENGL_ES_API && aRenderVersionNumber == 2) ? KAttribsListCtxGles2 : KAttribsListCtxNone;
sl@0	1090	iContext = eglCreateContext(iDisplay, aConfig, EGL_NO_CONTEXT, attrib_list_ctx);
sl@0	1091	ASSERT_EGL_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	1092	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
sl@0	1093	}
sl@0	1094
sl@0	1095	EXPORT_C void CTestEglSession::DrawOpenVgL()
sl@0	1096	{
sl@0	1097	ASSERT_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	1098	ASSERT_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	1099
sl@0	1100	// Draw to the pixmap surface
sl@0	1101	// Clear it: redish
sl@0	1102	VGfloat colorBackground[4];
sl@0	1103	ConvertColor(KRgbReddish, colorBackground);
sl@0	1104	vgSetfv(VG_CLEAR_COLOR, 4, colorBackground);
sl@0	1105	vgClear(0, 0, KPixmapSize.iWidth, KPixmapSize.iHeight);
sl@0	1106
sl@0	1107	// And add a square: greenish
sl@0	1108	VGfloat colorSquare[4];
sl@0	1109	ConvertColor(KRgbGreenish, colorSquare);
sl@0	1110	vgSetfv(VG_CLEAR_COLOR, 4, colorSquare);
sl@0	1111	vgClear(KPixmapSquare.iTl.iX, KPixmapSquare.iTl.iX, KPixmapSquare.Width(), KPixmapSquare.Height());
sl@0	1112	}
sl@0	1113
sl@0	1114	EXPORT_C void CTestEglSession::DrawOpenGLesL()
sl@0	1115	{
sl@0	1116	ASSERT_TRUE(iSurface != EGL_NO_SURFACE);
sl@0	1117	ASSERT_TRUE(iContext != EGL_NO_CONTEXT);
sl@0	1118	//GreenishRGB 0x46, 0xDC, 0x78
sl@0	1119	const GLfloat glRed = KRgbReddish.Red();
sl@0	1120	const GLfloat glGreen = KRgbReddish.Green();
sl@0	1121	const GLfloat glBlue = KRgbReddish.Blue();
sl@0	1122	const GLfloat glAlpha = KRgbReddish.Alpha();
sl@0	1123	const GLfloat glRedBits = 255.f;
sl@0	1124	const GLfloat glGreenBits = 255.f;
sl@0	1125	const GLfloat glBlueBits = 255.f;
sl@0	1126	const GLfloat glAlphaBits = 255.f;
sl@0	1127
sl@0	1128	// Disable cdither - when using exact comparison to reference bitmap
sl@0	1129	// because reference bitmap cannot be created to match dither exactly
sl@0	1130	glDisable(GL_DITHER);
sl@0	1131	// Clear the surface to the colour specified
sl@0	1132	glClearColor((glRed)/glRedBits, (glGreen)/glGreenBits, (glBlue)/glBlueBits, glAlpha/glAlphaBits);
sl@0	1133
sl@0	1134	//glColor3f(KRgbGreenish.Red(),KRgbGreenish.Green(),KRgbGreenish.Blue());
sl@0	1135	//glRectf(KPixmapSquare.iTl.iX, KPixmapSquare.iTl.iY,KPixmapSquare.iTl.iX + KPixmapSquare.Width(),KPixmapSquare.iTl.iY + KPixmapSquare.Height());
sl@0	1136
sl@0	1137	glClear(GL_COLOR_BUFFER_BIT);
sl@0	1138	}
sl@0	1139
sl@0	1140	EXPORT_C void CTestEglSession::CheckImageDataL(CFbsBitmap* aFbsBitmap)
sl@0	1141	{
sl@0	1142	// Use native API's to check pixel values in the surface - note that this is not an OpenVG test, so no boundary pixels are tested
sl@0	1143	TRgb rgbPixelSample;
sl@0	1144	// Outside the square
sl@0	1145	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(10,10));
sl@0	1146	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1147	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(90,90));
sl@0	1148	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1149
sl@0	1150	// Inside the square
sl@0	1151	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(30,30));
sl@0	1152	ASSERT_TRUE(PixelsMatch(KRgbGreenish, rgbPixelSample, EFalse));
sl@0	1153	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(70,70));
sl@0	1154	ASSERT_TRUE(PixelsMatch(KRgbGreenish, rgbPixelSample, EFalse));
sl@0	1155	}
sl@0	1156
sl@0	1157	EXPORT_C void CTestEglSession::CheckImageDataFullRedishL(CFbsBitmap* aFbsBitmap)
sl@0	1158	{
sl@0	1159	// Use native API's to check pixel values in the surface - note that this is not an OpenVG test, so no boundary pixels are tested
sl@0	1160	TRgb rgbPixelSample;
sl@0	1161	// Outside the square
sl@0	1162	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(10,10));
sl@0	1163	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1164	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(90,90));
sl@0	1165	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1166
sl@0	1167	// Inside the square
sl@0	1168	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(30,30));
sl@0	1169	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1170	aFbsBitmap->GetPixel(rgbPixelSample, TPoint(70,70));
sl@0	1171	ASSERT_TRUE(PixelsMatch(KRgbReddish, rgbPixelSample, EFalse));
sl@0	1172	}
sl@0	1173
sl@0	1174	/**
sl@0	1175	Use OpenVG to check pixel values
sl@0	1176	@param aDataFormat The VG image data format of the current surface
sl@0	1177	*/
sl@0	1178	EXPORT_C void CTestEglSession::CheckImageDataVgL(VGImageFormat aDataFormat)
sl@0	1179	{
sl@0	1180	switch(aDataFormat)
sl@0	1181	{
sl@0	1182	case VG_sRGB_565:
sl@0	1183	{
sl@0	1184	TUint16 intPixelSample=0;
sl@0	1185
sl@0	1186	// Outside the square
sl@0	1187	vgReadPixels(&intPixelSample, 1, aDataFormat, 10,10, 1,1);
sl@0	1188	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color64K(intPixelSample), EFalse));
sl@0	1189	vgReadPixels(&intPixelSample, 1, aDataFormat, 90,90, 1,1);
sl@0	1190	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color64K(intPixelSample), EFalse));
sl@0	1191
sl@0	1192	// Inside the square
sl@0	1193	vgReadPixels(&intPixelSample, 1, aDataFormat, 30,30, 1,1);
sl@0	1194	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color64K(intPixelSample), EFalse));
sl@0	1195	vgReadPixels(&intPixelSample, 1, aDataFormat, 70,70, 1,1);
sl@0	1196	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color64K(intPixelSample), EFalse));
sl@0	1197	break;
sl@0	1198	}
sl@0	1199	case VG_sXRGB_8888:
sl@0	1200	{
sl@0	1201	TUint32 intPixelSample=0;
sl@0	1202
sl@0	1203	// Outside the square
sl@0	1204	vgReadPixels(&intPixelSample, 1, aDataFormat, 10,10, 1,1);
sl@0	1205	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1206	vgReadPixels(&intPixelSample, 1, aDataFormat, 90,90, 1,1);
sl@0	1207	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1208
sl@0	1209	// Inside the square
sl@0	1210	vgReadPixels(&intPixelSample, 1, aDataFormat, 30,30, 1,1);
sl@0	1211	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1212	vgReadPixels(&intPixelSample, 1, aDataFormat, 70,70, 1,1);
sl@0	1213	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1214	break;
sl@0	1215	}
sl@0	1216	case VG_sARGB_8888:
sl@0	1217	{
sl@0	1218	TUint32 intPixelSample=0;
sl@0	1219
sl@0	1220	// Outside the square
sl@0	1221	vgReadPixels(&intPixelSample, 1, aDataFormat, 10,10, 1,1);
sl@0	1222	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MA(intPixelSample), EFalse));
sl@0	1223	vgReadPixels(&intPixelSample, 1, aDataFormat, 90,90, 1,1);
sl@0	1224	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MA(intPixelSample), EFalse));
sl@0	1225
sl@0	1226	// Inside the square
sl@0	1227	vgReadPixels(&intPixelSample, 1, aDataFormat, 30,30, 1,1);
sl@0	1228	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color16MA(intPixelSample), EFalse));
sl@0	1229	vgReadPixels(&intPixelSample, 1, aDataFormat, 70,70, 1,1);
sl@0	1230	ASSERT_TRUE(PixelsMatch(KRgbGreenish, TRgb::Color16MA(intPixelSample), EFalse));
sl@0	1231	break;
sl@0	1232	}
sl@0	1233	default:
sl@0	1234	WARN_PRINTF2(_L("Unexpected image data format %d in CTestEglSession::CheckImageDataVgL"), aDataFormat);
sl@0	1235	ASSERT_TRUE(EFalse);
sl@0	1236	}
sl@0	1237	}
sl@0	1238
sl@0	1239	/**
sl@0	1240	Use OpenGLes to check pixel values
sl@0	1241	@param aDataFormat The VG image data format of the current surface
sl@0	1242	*/
sl@0	1243	EXPORT_C void CTestEglSession::CheckImageDataGLesL()
sl@0	1244	{
sl@0	1245	TUint32 intPixelSample;
sl@0	1246	glReadPixels(10,10,1,1,GL_RGBA,GL_UNSIGNED_BYTE ,&intPixelSample);
sl@0	1247	SwapChannels(intPixelSample);
sl@0	1248	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1249
sl@0	1250	glReadPixels(45,45,1,1,GL_RGBA,GL_UNSIGNED_BYTE ,&intPixelSample);
sl@0	1251	SwapChannels(intPixelSample);
sl@0	1252	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1253
sl@0	1254	glReadPixels(55,55,1,1,GL_RGBA,GL_UNSIGNED_BYTE ,&intPixelSample);
sl@0	1255	SwapChannels(intPixelSample);
sl@0	1256	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1257
sl@0	1258	glReadPixels(99,99,1,1,GL_RGBA,GL_UNSIGNED_BYTE ,&intPixelSample);
sl@0	1259	SwapChannels(intPixelSample);
sl@0	1260	ASSERT_TRUE(PixelsMatch(KRgbReddish, TRgb::Color16MU(intPixelSample), EFalse));
sl@0	1261
sl@0	1262	}
sl@0	1263
sl@0	1264	EXPORT_C void CTestEglSession::SwapChannels(TUint32 &aSwapMe)
sl@0	1265	{
sl@0	1266	TUint32 buff = aSwapMe;
sl@0	1267
sl@0	1268	aSwapMe = 0;
sl@0	1269	aSwapMe \|= (buff & 0x000000FF) << 16;
sl@0	1270	aSwapMe \|= (buff & 0x0000FF00);
sl@0	1271	aSwapMe \|= (buff & 0x00FF0000) >> 16;
sl@0	1272	aSwapMe \|= (buff & 0xFF000000);
sl@0	1273	}
sl@0	1274
sl@0	1275	/**
sl@0	1276	Destroys the surface and underlying RSgImage object.
sl@0	1277	Nulls the current context.
sl@0	1278	*/
sl@0	1279	EXPORT_C void CTestEglSession::CleanupSurfaceSgImageL()
sl@0	1280	{
sl@0	1281	CleanupSurfaceAndContextL();
sl@0	1282
sl@0	1283	iSgImage.Close();
sl@0	1284	}
sl@0	1285
sl@0	1286	/**
sl@0	1287	Resets the internal surface and context handles without destroying them.
sl@0	1288	Also closes the internal RSgImage handled that is associated to the surface.
sl@0	1289
sl@0	1290	EGL destroys all surface and context handles associated with a display when
sl@0	1291	eglTerminate() is called.
sl@0	1292	*/
sl@0	1293	EXPORT_C void CTestEglSession::ResetSurfaceAndContextSgImageL()
sl@0	1294	{
sl@0	1295	INFO_PRINTF1(_L("CTestEglSession::ResetSurfaceAndContextSgImageL()"));
sl@0	1296
sl@0	1297	iContext = EGL_NO_CONTEXT;
sl@0	1298	iSurface = EGL_NO_SURFACE;
sl@0	1299	iSgImage.Close();
sl@0	1300	}
sl@0	1301
sl@0	1302	/**
sl@0	1303	Check that the pixel values match within a predefined tolerance
sl@0	1304	@param aExpected the expected pixel colour vaule
sl@0	1305	@param aActual the actual pixel colour value
sl@0	1306	@param aCheckAlpha Whether to check the alpha channel value
sl@0	1307	@return Whether the pixel values match - within the allowed tolerance
sl@0	1308	*/
sl@0	1309	EXPORT_C TBool CTestEglSession::PixelsMatch(const TRgb& aExpected, const TRgb& aActual, TBool aCheckAlpha)
sl@0	1310	{
sl@0	1311	// This value has been carefully selected. If it is too high it could be hidding genuine pixel value
sl@0	1312	// differences, while too low will be too strict to allow for pixel conversions, i.e. from 16bpp to 32bpp
sl@0	1313	const TInt KPixelTolerance = 8;
sl@0	1314
sl@0	1315	if (aCheckAlpha && aExpected.Alpha()== 0 &&
sl@0	1316	aActual.Red() == 0 &&
sl@0	1317	aActual.Green() == 0 &&
sl@0	1318	aActual.Blue() == 0 &&
sl@0	1319	aActual.Alpha() == 0)
sl@0	1320	{
sl@0	1321	// if the expected value for alpha is 0, all actual values should be 0
sl@0	1322	return ETrue;
sl@0	1323	}
sl@0	1324	else if (Abs(aExpected.Red() - aActual.Red()) > KPixelTolerance \|\|
sl@0	1325	Abs(aExpected.Green() - aActual.Green()) > KPixelTolerance \|\|
sl@0	1326	Abs(aExpected.Blue() - aActual.Blue()) > KPixelTolerance \|\|
sl@0	1327	aCheckAlpha && Abs(aExpected.Alpha() - aActual.Alpha()) > KPixelTolerance)
sl@0	1328	{
sl@0	1329	// one or more of the actual values differ by more than the allowed tolerance
sl@0	1330	ERR_PRINTF6(_L("thread %d: Expected r:%d g:%d b:%d a:%d"), iThreadIdx, aExpected.Red(), aExpected.Green(), aExpected.Blue(), aExpected.Alpha());
sl@0	1331	ERR_PRINTF6(_L("thread %d: Actual r:%d g:%d b:%d a:%d"), iThreadIdx, aActual.Red(), aActual.Green(), aActual.Blue(), aActual.Alpha());
sl@0	1332	ERR_PRINTF6(_L("thread %d: diff r:%d g:%d b:%d a:%d"), iThreadIdx, Abs(aExpected.Red() - aActual.Red()), Abs(aExpected.Green() - aActual.Green()), Abs(aExpected.Blue() - aActual.Blue()), Abs(aExpected.Alpha() - aActual.Alpha()));
sl@0	1333	return EFalse;
sl@0	1334	}
sl@0	1335	return ETrue;
sl@0	1336	}
sl@0	1337
sl@0	1338	EXPORT_C void CTestEglSession::InitializeL(TBool aTerminateDisplay)
sl@0	1339	{
sl@0	1340	// Initialize display object
sl@0	1341	INFO_PRINTF2(_L("thread %d: Calling eglInitialize..."), iThreadIdx);
sl@0	1342	EGLint major=0;
sl@0	1343	EGLint minor=0;
sl@0	1344	CHECK_EXPECTED_ERROR(eglInitialize(iDisplay, &major, &minor));
sl@0	1345	// Remember if the user wants us to terminate the display.
sl@0	1346	iTerminateDisplay = aTerminateDisplay;
sl@0	1347
sl@0	1348	INFO_PRINTF4(_L("thread %d: Initialised: EGL Version %d.%d"), iThreadIdx, major, minor);
sl@0	1349	}
sl@0	1350
sl@0	1351
sl@0	1352	EXPORT_C void CTestEglSession::TerminateDisplayL()
sl@0	1353	{
sl@0	1354	if (iSurface != EGL_NO_SURFACE)
sl@0	1355	{
sl@0	1356	WARN_PRINTF2(_L("thread %d: iSurface has not been destoroyed in TerminateDisplayL..."), iThreadIdx);
sl@0	1357	}
sl@0	1358	if (iContext != EGL_NO_CONTEXT)
sl@0	1359	{
sl@0	1360	WARN_PRINTF2(_L("thread %d: iContext has not been destoroyed in TerminateDisplayL..."), iThreadIdx);
sl@0	1361	}
sl@0	1362	if (iDisplay != EGL_NO_DISPLAY)
sl@0	1363	{
sl@0	1364	INFO_PRINTF2(_L("thread %d: Calling eglMakeCurrent(NULL values) from TerminateDisplayL..."), iThreadIdx);
sl@0	1365
sl@0	1366	ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
sl@0	1367
sl@0	1368	INFO_PRINTF1(_L("Calling eglTerminate..."));
sl@0	1369	ASSERT_EGL_TRUE(eglTerminate(iDisplay));
sl@0	1370	iDisplay = EGL_NO_DISPLAY;
sl@0	1371	}
sl@0	1372	iTerminateDisplay = EFalse;
sl@0	1373	}
sl@0	1374
sl@0	1375	EXPORT_C void CTestEglSession::OpenSgDriverL()
sl@0	1376	{
sl@0	1377	if (!iSgDriverOpen)
sl@0	1378	{
sl@0	1379	VERBOSE_INFO_PRINTF2(_L("CTestEglSession<0x%08x> Opening SgDriver"), this);
sl@0	1380	#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1381	TInt ret=iSgDriver.Open();
sl@0	1382	#else
sl@0	1383	TInt ret=SgDriver::Open();
sl@0	1384	#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1385	ASSERT_EQUALS(ret, KErrNone);
sl@0	1386	iSgDriverOpen = ETrue;
sl@0	1387	}
sl@0	1388	}
sl@0	1389
sl@0	1390	EXPORT_C void CTestEglSession::CloseSgDriver()
sl@0	1391	{
sl@0	1392	if (iSgDriverOpen)
sl@0	1393	{
sl@0	1394	VERBOSE_INFO_PRINTF2(_L("CTestEglSession<0x%08x> Closing SgDriver"), this);
sl@0	1395	#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1396	iSgDriver.Close();
sl@0	1397	#else
sl@0	1398	SgDriver::Close();
sl@0	1399	#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1400	iSgDriverOpen = EFalse;
sl@0	1401	}
sl@0	1402	}
sl@0	1403
sl@0	1404	EXPORT_C void CTestEglSession::OpenFbsSessionL()
sl@0	1405	{
sl@0	1406	if (!iFbsSessionOpen)
sl@0	1407	{
sl@0	1408	INFO_PRINTF2(_L("CTestEglSession<0x%08x> Opening FbsSession"), this);
sl@0	1409	TInt ret=RFbsSession::Connect();
sl@0	1410	ASSERT_EQUALS(ret, KErrNone);
sl@0	1411	iFbsSessionOpen = ETrue;
sl@0	1412	}
sl@0	1413	}
sl@0	1414
sl@0	1415	EXPORT_C void CTestEglSession::CloseFbsSession()
sl@0	1416	{
sl@0	1417	if (iFbsSessionOpen)
sl@0	1418	{
sl@0	1419	INFO_PRINTF2(_L("CTestEglSession<0x%08x> Closing FbsSession"), this);
sl@0	1420	RFbsSession::Disconnect();
sl@0	1421	iFbsSessionOpen = EFalse;
sl@0	1422	}
sl@0	1423	}
sl@0	1424
sl@0	1425	EXPORT_C TBool CTestEglSession::FetchProcEglCreateImageKhr()
sl@0	1426	{
sl@0	1427	if (!ipfnEglCreateImageKHR)
sl@0	1428	{
sl@0	1429	INFO_PRINTF2(_L("thread %d: Calling eglGetProcAddress(\"eglCreateImageKHR\")"), iThreadIdx);
sl@0	1430	ipfnEglCreateImageKHR = reinterpret_cast<TFPtrEglCreateImageKhr>(eglGetProcAddress("eglCreateImageKHR"));
sl@0	1431	if (ipfnEglCreateImageKHR==NULL)
sl@0	1432	{
sl@0	1433	EGLint eglError = eglGetError();
sl@0	1434	WARN_PRINTF2(_L("eglCreateImageKHR() not found - EGL Error: 0x%x"), eglError);
sl@0	1435	}
sl@0	1436	}
sl@0	1437	return (ipfnEglCreateImageKHR!=NULL);
sl@0	1438	}
sl@0	1439
sl@0	1440	EXPORT_C EGLImageKHR CTestEglSession::eglCreateImageKhrL(EGLDisplay aDisplay,EGLContext aContext,EGLenum aTarget,RSgImage* aSgImage,const EGLint *aAttr_List)
sl@0	1441	{
sl@0	1442	TBool bSuccess = FetchProcEglCreateImageKhr();
sl@0	1443	ASSERT_TRUE(bSuccess);
sl@0	1444	VERBOSE_INFO_PRINTF2(_L("thread %d: Calling eglCreateImageKHR"), iThreadIdx);
sl@0	1445	EGLImageKHR eglImage = ipfnEglCreateImageKHR(aDisplay,aContext,aTarget,reinterpret_cast<EGLClientBuffer>(aSgImage),const_cast<EGLint *>(aAttr_List));
sl@0	1446	return eglImage;
sl@0	1447	}
sl@0	1448
sl@0	1449	EXPORT_C EGLImageKHR CTestEglSession::eglCreateImageKhrL(EGLDisplay aDisplay,EGLContext aContext,EGLenum aTarget,CFbsBitmap &aCFbsBitmap, const EGLint *aAttr_List)
sl@0	1450	{
sl@0	1451	TBool bSuccess = FetchProcEglCreateImageKhr();
sl@0	1452	ASSERT_TRUE(bSuccess);
sl@0	1453	INFO_PRINTF2(_L("thread %d: Calling eglCreateImageKHR, with CFBsBitmap)"), iThreadIdx);
sl@0	1454	//the following call to eglCreateImageKHR MUST fail, error handling is made outside
sl@0	1455	EGLImageKHR eglImage = ipfnEglCreateImageKHR(aDisplay,aContext,aTarget,reinterpret_cast<EGLClientBuffer>(&aCFbsBitmap),const_cast<EGLint *>(aAttr_List));
sl@0	1456	return eglImage;
sl@0	1457	}
sl@0	1458
sl@0	1459	EXPORT_C TBool CTestEglSession::FetchProcEglDestroyImageKhr()
sl@0	1460	{
sl@0	1461	if (!ipfnEglDestroyImageKHR)
sl@0	1462	{
sl@0	1463	INFO_PRINTF2(_L("thread %d: Calling eglGetProcAddress(\"eglDestroyImageKHR\")"), iThreadIdx);
sl@0	1464	ipfnEglDestroyImageKHR = reinterpret_cast<TFPtrEglDestroyImageKhr>(eglGetProcAddress("eglDestroyImageKHR"));
sl@0	1465	if (ipfnEglDestroyImageKHR==NULL)
sl@0	1466	{
sl@0	1467	EGLint eglError = eglGetError();
sl@0	1468	WARN_PRINTF2(_L("eglDestroyImageKHR() not found - EGL Error: 0x%x"), eglError);
sl@0	1469	}
sl@0	1470	}
sl@0	1471	return (ipfnEglDestroyImageKHR!=NULL);
sl@0	1472	}
sl@0	1473
sl@0	1474	EXPORT_C TBool CTestEglSession::DestroyEGLImage(EGLDisplay aDisplay, EGLImageKHR aEGLImageKHR)
sl@0	1475	{
sl@0	1476	TBool bSuccess = FetchProcEglDestroyImageKhr();
sl@0	1477	ASSERT_TRUE(bSuccess);
sl@0	1478	VERBOSE_INFO_PRINTF2(_L("thread %d: Calling eglDestroyImageKHR"), iThreadIdx);
sl@0	1479	return ipfnEglDestroyImageKHR(aDisplay,aEGLImageKHR);
sl@0	1480	}
sl@0	1481
sl@0	1482	EXPORT_C TBool CTestEglSession::FetchProcvgCreateImageTargetKhr()
sl@0	1483	{
sl@0	1484	if (!ipfnvgCreateImageTargetKHR)
sl@0	1485	{
sl@0	1486	INFO_PRINTF2(_L("thread %d: Calling eglGetProcAddress (\"vgCreateEGLImageTargetKHR\")"), iThreadIdx);
sl@0	1487	ipfnvgCreateImageTargetKHR = reinterpret_cast<TFPtrVgCreateEglImageTargetKhr>(eglGetProcAddress("vgCreateEGLImageTargetKHR"));
sl@0	1488	if (ipfnvgCreateImageTargetKHR==NULL)
sl@0	1489	{
sl@0	1490	EGLint eglError = eglGetError();
sl@0	1491	WARN_PRINTF2(_L("vgCreateImageTargetKHR() not found - EGL Error: 0x%x"), eglError);
sl@0	1492	}
sl@0	1493	}
sl@0	1494	return (ipfnvgCreateImageTargetKHR!=NULL);
sl@0	1495	}
sl@0	1496
sl@0	1497	EXPORT_C VGImage CTestEglSession::vgCreateImageTargetKHR(VGeglImageKHR aImage)
sl@0	1498	{
sl@0	1499	TBool bSuccess = FetchProcvgCreateImageTargetKhr();
sl@0	1500	ASSERT_TRUE(bSuccess);
sl@0	1501	VERBOSE_INFO_PRINTF2(_L("thread %d: Calling vgCreateEGLImageTargetKHR"), iThreadIdx);
sl@0	1502	return ipfnvgCreateImageTargetKHR(aImage);
sl@0	1503	}
sl@0	1504
sl@0	1505	EXPORT_C TBool CTestEglSession::IsACompatibleConfig(EGLConfig aConfig,RSgImage& aImage,TBool aLog)
sl@0	1506	{
sl@0	1507	EGLint EGL_BUFFER_SIZE_value;
sl@0	1508	EGLint EGL_ALPHA_SIZE_value;
sl@0	1509	EGLint EGL_BLUE_SIZE_value;
sl@0	1510	EGLint EGL_GREEN_SIZE_value;
sl@0	1511	EGLint EGL_RED_SIZE_value;
sl@0	1512	EGLint EGL_SURFACE_TYPE_value;
sl@0	1513	EGLint EGL_RENDERABLE_TYPE_value;
sl@0	1514	EGLint EGL_CONFIG_ID_value;
sl@0	1515
sl@0	1516	eglGetConfigAttrib(iDisplay, aConfig, EGL_CONFIG_ID, &EGL_CONFIG_ID_value);
sl@0	1517	eglGetConfigAttrib(iDisplay, aConfig, EGL_BUFFER_SIZE, &EGL_BUFFER_SIZE_value);
sl@0	1518	eglGetConfigAttrib(iDisplay, aConfig, EGL_ALPHA_SIZE, &EGL_ALPHA_SIZE_value);
sl@0	1519	eglGetConfigAttrib(iDisplay, aConfig, EGL_BLUE_SIZE, &EGL_BLUE_SIZE_value);
sl@0	1520	eglGetConfigAttrib(iDisplay, aConfig, EGL_GREEN_SIZE, &EGL_GREEN_SIZE_value);
sl@0	1521	eglGetConfigAttrib(iDisplay, aConfig, EGL_RED_SIZE, &EGL_RED_SIZE_value);
sl@0	1522	eglGetConfigAttrib(iDisplay, aConfig, EGL_SURFACE_TYPE, &EGL_SURFACE_TYPE_value);
sl@0	1523	eglGetConfigAttrib(iDisplay, aConfig, EGL_RENDERABLE_TYPE, &EGL_RENDERABLE_TYPE_value);
sl@0	1524	#ifdef PRINTG_CONFIGS_LOG
sl@0	1525	INFO_PRINTF7(_L("(Config: %3d) RGBA=(%2d) %2d,%2d,%2d,%2d"), EGL_CONFIG_ID_value, EGL_BUFFER_SIZE_value,
sl@0	1526	EGL_RED_SIZE_value, EGL_GREEN_SIZE_value, EGL_BLUE_SIZE_value,
sl@0	1527	EGL_ALPHA_SIZE_value);
sl@0	1528	INFO_PRINTF2(_L("RENDERABLE_TYPE %d"),EGL_RENDERABLE_TYPE_value);
sl@0	1529	#endif
sl@0	1530
sl@0	1531	if(!(EGL_SURFACE_TYPE_value & EGL_PIXMAP_BIT))
sl@0	1532	{
sl@0	1533	return EFalse;
sl@0	1534	}
sl@0	1535
sl@0	1536	TBool good = ETrue;
sl@0	1537	//requested usage bits
sl@0	1538	TSgImageInfo requestedImageInfo;
sl@0	1539	aImage.GetInfo(requestedImageInfo);
sl@0	1540
sl@0	1541	#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1542	//potential usage bits
sl@0	1543	RSgImage potential;
sl@0	1544	potential.Open(aImage.Id(),ESgDoNotRestrictUsage);
sl@0	1545	TSgImageInfo potentialImageInfo;
sl@0	1546	potential.GetInfo(potentialImageInfo);
sl@0	1547	potential.Close();
sl@0	1548	#endif
sl@0	1549
sl@0	1550	switch(requestedImageInfo.iPixelFormat)
sl@0	1551	{
sl@0	1552	case EUidPixelFormatRGB_565:
sl@0	1553	if (!(EGL_RED_SIZE_value == 5 && EGL_GREEN_SIZE_value == 6 && EGL_BLUE_SIZE_value == 5 && EGL_ALPHA_SIZE_value == 0))
sl@0	1554	{
sl@0	1555	good = EFalse;
sl@0	1556	}
sl@0	1557	break;
sl@0	1558	case EUidPixelFormatXRGB_8888:
sl@0	1559	if (!(EGL_RED_SIZE_value == 8 && EGL_GREEN_SIZE_value == 8 && EGL_BLUE_SIZE_value == 8 && EGL_ALPHA_SIZE_value == 0))
sl@0	1560	{
sl@0	1561	good = EFalse;
sl@0	1562	}
sl@0	1563	break;
sl@0	1564	case EUidPixelFormatARGB_8888_PRE:
sl@0	1565	if (!(EGL_RED_SIZE_value == 8 && EGL_GREEN_SIZE_value == 8 && EGL_BLUE_SIZE_value == 8 && EGL_ALPHA_SIZE_value == 8))
sl@0	1566	{
sl@0	1567	good = EFalse;
sl@0	1568	}
sl@0	1569	//just OVG cares about the premultiplied alpha
sl@0	1570	if(EGL_RENDERABLE_TYPE_value& EGL_OPENVG_BIT)
sl@0	1571	//if(requestedImageInfo.iUsage & ESgUsageBitOpenVgSurface)
sl@0	1572	{
sl@0	1573	if(!(EGL_SURFACE_TYPE_value & EGL_VG_ALPHA_FORMAT_PRE_BIT))
sl@0	1574	{
sl@0	1575	if(aLog)
sl@0	1576	{
sl@0	1577	WARN_PRINTF2(_L("This Config can't be used with Pre-multipliedAlpha becasue EGL_SURFACE_TYPE has the wrong bits = %x"), EGL_SURFACE_TYPE_value);
sl@0	1578	}
sl@0	1579	good = EFalse;
sl@0	1580	}
sl@0	1581	}
sl@0	1582	break;
sl@0	1583	default:
sl@0	1584	if(aLog)
sl@0	1585	{
sl@0	1586	ERR_PRINTF2(_L("Wrong PixelFormat for a target, %x"), requestedImageInfo.iPixelFormat);
sl@0	1587	}
sl@0	1588	good = EFalse;
sl@0	1589	}
sl@0	1590	if(!good)
sl@0	1591	{
sl@0	1592	return EFalse;
sl@0	1593	}
sl@0	1594
sl@0	1595	#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1596	//
sl@0	1597	//Check if strict matching requirements are met:
sl@0	1598	//- All the supported APIs included in the EGL_RENDERABLE_TYPE of the
sl@0	1599	// EGLConfig must be matched by the corresponding iUsage of RSgImage
sl@0	1600	//- The following usages included in the iUsage of the RSgImage must be
sl@0	1601	// matched by the corresponding API in EGL_RENDERABLE_TYPE of the EGLConfig:
sl@0	1602	// ESgUsageBitOpenGlSurface-> EGL_OPENGL_BIT
sl@0	1603	// ESgUsageBitOpenGlesSurface-> EGL_OPENGL_ES_BIT
sl@0	1604	// ESgUsageBitOpenGles2Surface-> EGL_OPENGL_ES2_BIT
sl@0	1605	// ESgUsageBitOpenVgSurface->EGL_OPENVG_BIT
sl@0	1606
sl@0	1607	EGLint usageBitsMask = 0;
sl@0	1608	if(requestedImageInfo.iUsage & ESgUsageBitOpenVgSurface)
sl@0	1609	{
sl@0	1610	usageBitsMask \|= EGL_OPENVG_BIT;
sl@0	1611	}
sl@0	1612	if(requestedImageInfo.iUsage & ESgUsageBitOpenGles2Surface)
sl@0	1613	{
sl@0	1614	usageBitsMask \|= EGL_OPENGL_ES2_BIT;
sl@0	1615	}
sl@0	1616	if(requestedImageInfo.iUsage & ESgUsageBitOpenGlesSurface)
sl@0	1617	{
sl@0	1618	usageBitsMask \|= EGL_OPENGL_ES_BIT;
sl@0	1619	}
sl@0	1620	if(requestedImageInfo.iUsage & ESgUsageBitOpenGlSurface)
sl@0	1621	{
sl@0	1622	usageBitsMask \|= EGL_OPENGL_BIT;
sl@0	1623	}
sl@0	1624
sl@0	1625	if(usageBitsMask != EGL_RENDERABLE_TYPE_value)
sl@0	1626	{
sl@0	1627	return EFalse;
sl@0	1628	}
sl@0	1629	#else
sl@0	1630	// requested usage & RENDERABLE_TYPE > 0
sl@0	1631	EGLint usageBitsMask = 0;
sl@0	1632	if(requestedImageInfo.iUsage & ESgUsageOpenVgTarget)
sl@0	1633	{
sl@0	1634	usageBitsMask \|= EGL_OPENVG_BIT;
sl@0	1635	}
sl@0	1636	if(requestedImageInfo.iUsage & ESgUsageOpenGlesTarget)
sl@0	1637	{
sl@0	1638	usageBitsMask \|= EGL_OPENGL_ES_BIT;
sl@0	1639	}
sl@0	1640	if(requestedImageInfo.iUsage & ESgUsageOpenGles2Target)
sl@0	1641	{
sl@0	1642	usageBitsMask \|= EGL_OPENGL_ES2_BIT;
sl@0	1643	}
sl@0	1644	if(!(usageBitsMask & EGL_RENDERABLE_TYPE_value))
sl@0	1645	{
sl@0	1646	return EFalse;
sl@0	1647	}
sl@0	1648
sl@0	1649	// potential usage >= RENDERABLE_TYPE
sl@0	1650
sl@0	1651	EGLint potentialUsageBitsMask = 0;
sl@0	1652	if(potentialImageInfo.iUsage & ESgUsageOpenVgTarget)
sl@0	1653	{
sl@0	1654	potentialUsageBitsMask \|= EGL_OPENVG_BIT;
sl@0	1655	}
sl@0	1656	if(potentialImageInfo.iUsage & ESgUsageOpenGlesTarget)
sl@0	1657	{
sl@0	1658	potentialUsageBitsMask \|= EGL_OPENGL_ES_BIT;
sl@0	1659	}
sl@0	1660	if(potentialImageInfo.iUsage & ESgUsageOpenGles2Target)
sl@0	1661	{
sl@0	1662	potentialUsageBitsMask \|= EGL_OPENGL_ES2_BIT;
sl@0	1663	}
sl@0	1664
sl@0	1665	potentialUsageBitsMask = EGL_RENDERABLE_TYPE_value &~ potentialUsageBitsMask;
sl@0	1666	if(potentialUsageBitsMask)
sl@0	1667	{
sl@0	1668	return EFalse;
sl@0	1669	}
sl@0	1670	#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1671	return good;
sl@0	1672	}
sl@0	1673
sl@0	1674	EXPORT_C TBool CTestEglSession::CheckNeededExtensionL(TInt aExtension, const TDesC& aExtensionName)
sl@0	1675	{
sl@0	1676	TBuf8<128> extensionName;
sl@0	1677	extensionName.Copy(aExtensionName);
sl@0	1678	if(aExtension & KEGL_RSgimage \|\| extensionName.Compare(KEglRSgImage)==0)
sl@0	1679	{
sl@0	1680	TBool bFoundExtensionEGL_NOK_pixmap_type_rsgimage = FindExtensionStringL(EIsEGL,KEglRSgImage);
sl@0	1681	if (!bFoundExtensionEGL_NOK_pixmap_type_rsgimage)
sl@0	1682	{
sl@0	1683	// The extension is not supported
sl@0	1684	return EFalse;
sl@0	1685	}
sl@0	1686	}
sl@0	1687	if(aExtension & KEGL_KHR_image_base \|\| extensionName.Compare(KEglKhrImageBase)==0)
sl@0	1688	{
sl@0	1689	TBool bFoundExtensionEGL_KHR_image = FindExtensionStringL(EIsEGL,KEglKhrImageBase);
sl@0	1690	if (!bFoundExtensionEGL_KHR_image)
sl@0	1691	{
sl@0	1692	// The extension is not supported
sl@0	1693	return EFalse;
sl@0	1694	}
sl@0	1695	}
sl@0	1696	if(aExtension & KEGL_KHR_image_pixmap \|\| extensionName.Compare(KEglKhrImagePixmap)==0)
sl@0	1697	{
sl@0	1698	TBool bFoundExtensionEGL_KHR_image = FindExtensionStringL(EIsEGL,KEglKhrImagePixmap);
sl@0	1699	if (!bFoundExtensionEGL_KHR_image)
sl@0	1700	{
sl@0	1701	// The extension is not supported
sl@0	1702	return EFalse;
sl@0	1703	}
sl@0	1704	}
sl@0	1705	if(aExtension & KVG_KHR_EGL_image \|\| extensionName.Compare(KVgKhrEglImage)==0)
sl@0	1706	{
sl@0	1707	TBool bFoundExtensionVG_KHR_EGL_image = FindExtensionStringL(EIsVG,KVgKhrEglImage);
sl@0	1708	if (!bFoundExtensionVG_KHR_EGL_image)
sl@0	1709	{
sl@0	1710	// The extension is not supported
sl@0	1711	return EFalse;
sl@0	1712	}
sl@0	1713	}
sl@0	1714	if(aExtension & KEGL_KHR_reusable_sync \|\| extensionName.Compare(KEglKhrReusableSync)==0)
sl@0	1715	{
sl@0	1716	TBool bFoundExtensionEGL_KHR_reusable_sync = FindExtensionStringL(EIsEGL,KEglKhrReusableSync);
sl@0	1717	if (!bFoundExtensionEGL_KHR_reusable_sync)
sl@0	1718	{
sl@0	1719	// The extension is not supported
sl@0	1720	return EFalse;
sl@0	1721	}
sl@0	1722	}
sl@0	1723	if(aExtension & KEGL_NOK__private__signal_sync \|\| extensionName.Compare(KEglNokPrivateSignalSync)==0)
sl@0	1724	{
sl@0	1725	TBool bFoundExtensionEGL_NOK__private__signal_sync = FindExtensionStringL(EIsEGL,KEglNokPrivateSignalSync);
sl@0	1726	if (!bFoundExtensionEGL_NOK__private__signal_sync)
sl@0	1727	{
sl@0	1728	// The extension is not supported
sl@0	1729	return EFalse;
sl@0	1730	}
sl@0	1731	}
sl@0	1732	if(aExtension & KEGL_NOKIA_swap_buffers \|\| extensionName.Compare(KEglNokiaSwapBuffers)==0)
sl@0	1733	{
sl@0	1734	TBool bFoundExtensionEGL_NOKIA_swap_buffer = FindExtensionStringL(EIsEGL,KEglNokiaSwapBuffers);
sl@0	1735	if (!bFoundExtensionEGL_NOKIA_swap_buffer)
sl@0	1736	{
sl@0	1737	// The extension is not supported
sl@0	1738	return EFalse;
sl@0	1739	}
sl@0	1740	}
sl@0	1741	#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1742	if(aExtension & KEGL_SYMBIAN_image_preserved \|\| extensionName.Compare(KEglSymbianImagePreserved)
sl@0	1743	{
sl@0	1744	TBool bFoundExtensionEGL_SYMBIAN_image_preserved = FindExtensionStringL(EIsEGL,KEglSymbianImagePreserved);
sl@0	1745	if (!bFoundExtensionEGL_SYMBIAN_image_preserved)
sl@0	1746	{
sl@0	1747	// The extension is not supported
sl@0	1748	return EFalse;
sl@0	1749	}
sl@0	1750	}
sl@0	1751	#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
sl@0	1752	if(aExtension & KEGL_NOK_image_endpoint \|\| extensionName.Compare(KEglNokiaImageEndpoint)==0)
sl@0	1753	{
sl@0	1754	TBool bFoundExtensionEGL_NOK_image_endpoint = FindExtensionStringL(EIsEGL,KEglNokiaImageEndpoint);
sl@0	1755	if (!bFoundExtensionEGL_NOK_image_endpoint)
sl@0	1756	{
sl@0	1757	// The extension is not supported
sl@0	1758	return EFalse;
sl@0	1759	}
sl@0	1760	}
sl@0	1761	if(aExtension & KEGL_NOK_surface_scaling \|\| extensionName.Compare(KEglNokiaSurfaceScaling)==0)
sl@0	1762	{
sl@0	1763	TBool bFoundExtensionEGL_NOK_surface_scaling = FindExtensionStringL(EIsEGL,KEglNokiaSurfaceScaling);
sl@0	1764	if (!bFoundExtensionEGL_NOK_surface_scaling)
sl@0	1765	{
sl@0	1766	// The extension is not supported
sl@0	1767	return EFalse;
sl@0	1768	}
sl@0	1769	}
sl@0	1770	return ETrue;
sl@0	1771	}
sl@0	1772
sl@0	1773	EXPORT_C CFbsBitmap* CTestEglSession::CreateReferenceBitmapL(TDisplayMode aMode)
sl@0	1774	{
sl@0	1775	if(aMode == ENone )
sl@0	1776	{
sl@0	1777	ERR_PRINTF1(_L("Queried Reference Bitmap dispaly mode equal to ENone"));
sl@0	1778	User::Leave(KErrTEFUnitFail);
sl@0	1779	}
sl@0	1780	return CreateReferenceBitmapL(aMode,KRgbGreenish);
sl@0	1781	}
sl@0	1782
sl@0	1783	EXPORT_C CFbsBitmap* CTestEglSession::CreateReferenceBitmapL(TDisplayMode aMode,const TRgb& aColour)
sl@0	1784	{
sl@0	1785	OpenFbsSessionL();
sl@0	1786	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();
sl@0	1787	CleanupStack::PushL(bitmap);
sl@0	1788	if(bitmap->Create(KPixmapSize,aMode) != KErrNone)
sl@0	1789	{
sl@0	1790	return NULL;
sl@0	1791	}
sl@0	1792	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap);
sl@0	1793	CleanupStack::PushL(bitmapDevice);
sl@0	1794	CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();
sl@0	1795	CleanupStack::PushL(fbsBitGc);
sl@0	1796	fbsBitGc->Activate(bitmapDevice);
sl@0	1797	fbsBitGc->SetBrushColor(aColour);
sl@0	1798	fbsBitGc->Clear();
sl@0	1799	CleanupStack::PopAndDestroy(2,bitmapDevice);
sl@0	1800	CleanupStack::Pop(bitmap);
sl@0	1801	return bitmap;
sl@0	1802	}
sl@0	1803
sl@0	1804	EXPORT_C CFbsBitmap* CTestEglSession::CreateReferenceMaskedBitmapL(TDisplayMode aRefBitmapMode, const TRgb& aPenBitmapColor, const CFbsBitmap* aMaskBitmap)
sl@0	1805	{
sl@0	1806	OpenFbsSessionL();
sl@0	1807
sl@0	1808	// create the refBitmat (same size as the mask bitmap)
sl@0	1809	// Note that we clear it to 'opaque black' as we assume the target surface has been cleared to 'opaque black' too
sl@0	1810	// If either the surface or the refBitmap are cleared to another colour, update the other accordingly
sl@0	1811	CFbsBitmap* refBitmap = new(ELeave) CFbsBitmap();
sl@0	1812	CleanupStack::PushL(refBitmap);
sl@0	1813	User::LeaveIfError(refBitmap->Create(aMaskBitmap->SizeInPixels(), aRefBitmapMode));
sl@0	1814	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(refBitmap);
sl@0	1815	CleanupStack::PushL(bitmapDevice);
sl@0	1816	CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();
sl@0	1817	CleanupStack::PushL(fbsBitGc);
sl@0	1818	fbsBitGc->Activate(bitmapDevice);
sl@0	1819	fbsBitGc->SetBrushColor(KRgbBlack);
sl@0	1820	fbsBitGc->Clear();
sl@0	1821
sl@0	1822	// create the penBitmap (same size as the mask bitmap)
sl@0	1823	CFbsBitmap* penBitmap = new(ELeave) CFbsBitmap();
sl@0	1824	CleanupStack::PushL(penBitmap);
sl@0	1825	User::LeaveIfError(penBitmap->Create(aMaskBitmap->SizeInPixels(), aRefBitmapMode));
sl@0	1826	CFbsBitmapDevice* penbitmapDevice = CFbsBitmapDevice::NewL(penBitmap);
sl@0	1827	CleanupStack::PushL(penbitmapDevice);
sl@0	1828	CFbsBitGc* penBitGc = CFbsBitGc::NewL();
sl@0	1829	CleanupStack::PushL(penBitGc);
sl@0	1830	penBitGc->Activate(penbitmapDevice);
sl@0	1831	penBitGc->SetBrushColor(aPenBitmapColor);
sl@0	1832	penBitGc->Clear();
sl@0	1833
sl@0	1834	// perform a masked bitmap transfer to the active refBitmap
sl@0	1835	TRect bmpRect(TPoint(0, 0), refBitmap->SizeInPixels());
sl@0	1836	fbsBitGc->Activate(bitmapDevice);
sl@0	1837	fbsBitGc->BitBltMasked(TPoint(0, 0), penBitmap, bmpRect, aMaskBitmap, EFalse);
sl@0	1838
sl@0	1839	CleanupStack::PopAndDestroy(5, bitmapDevice);
sl@0	1840	CleanupStack::Pop(refBitmap);
sl@0	1841	return refBitmap;
sl@0	1842	}
sl@0	1843
sl@0	1844
sl@0	1845	EXPORT_C CFbsBitmap* CTestEglSession::CreateReferenceBitmapL(TDisplayMode aMode, const TSize &aSize, const TInt aIndex)
sl@0	1846	{
sl@0	1847	OpenFbsSessionL();
sl@0	1848	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();
sl@0	1849	CleanupStack::PushL(bitmap);
sl@0	1850	User::LeaveIfError(bitmap->Create(aSize,aMode));
sl@0	1851
sl@0	1852	TInt height = bitmap->SizeInPixels().iHeight;
sl@0	1853	TInt width = bitmap->SizeInPixels().iWidth;
sl@0	1854
sl@0	1855	// Initialise colour values to a random value (guarantees pixel uniqueness if update is done accordingly)
sl@0	1856	TInt red=0;
sl@0	1857	TInt green=127;
sl@0	1858	TInt blue=127;
sl@0	1859	TInt alpha=255;
sl@0	1860
sl@0	1861	TBitmapUtil bmpUtil(bitmap);
sl@0	1862	bmpUtil.Begin(TPoint(0,0));
sl@0	1863	for (TInt colIndex = 0; colIndex < width; ++colIndex)
sl@0	1864	{
sl@0	1865	bmpUtil.SetPos(TPoint(colIndex, 0));
sl@0	1866	for (TInt rowIndex =0; rowIndex < height; ++rowIndex)
sl@0	1867	{
sl@0	1868	TRgb rgb(red, green, blue, alpha);
sl@0	1869	switch(bitmap->DisplayMode())
sl@0	1870	{
sl@0	1871	case EColor64K:
sl@0	1872	{
sl@0	1873	bmpUtil.SetPixel(rgb.Color64K());
sl@0	1874	break;
sl@0	1875	}
sl@0	1876	case EColor16MU:
sl@0	1877	{
sl@0	1878	bmpUtil.SetPixel(rgb.Color16MU());
sl@0	1879	break;
sl@0	1880	}
sl@0	1881	case EColor16MA:
sl@0	1882	{
sl@0	1883	bmpUtil.SetPixel(rgb.Color16MA());
sl@0	1884	break;
sl@0	1885	}
sl@0	1886	case EColor16MAP:
sl@0	1887	{
sl@0	1888	bmpUtil.SetPixel(rgb.Color16MAP());
sl@0	1889	break;
sl@0	1890	}
sl@0	1891	case EGray256:
sl@0	1892	{
sl@0	1893	bmpUtil.SetPixel(rgb.Gray256());
sl@0	1894	break;
sl@0	1895	}
sl@0	1896	default:
sl@0	1897	{
sl@0	1898	// We should not get here - colour mode not supported by these tests
sl@0	1899	ERR_PRINTF1(_L("CTestEglSession::CreateReferenceBitmapL - Colour mode not supported!"));
sl@0	1900	ASSERT(FALSE);
sl@0	1901	}
sl@0	1902	}
sl@0	1903	bmpUtil.IncYPos();
sl@0	1904
sl@0	1905	// Update red bit
sl@0	1906	red = ++red + aIndex;
sl@0	1907	if (red>255)
sl@0	1908	red = red - 256;
sl@0	1909
sl@0	1910	// Update green bit
sl@0	1911	green = --green - aIndex;
sl@0	1912	if (green<0)
sl@0	1913	green = green + 256;
sl@0	1914
sl@0	1915	// Update blue bit
sl@0	1916	blue = ++blue + aIndex;
sl@0	1917	if (blue>255)
sl@0	1918	blue = blue - 256;
sl@0	1919
sl@0	1920	// Update alpha bit
sl@0	1921	alpha = --alpha - aIndex;
sl@0	1922	if (alpha<0)
sl@0	1923	alpha = alpha + 256;
sl@0	1924	}
sl@0	1925	}
sl@0	1926	bmpUtil.End();
sl@0	1927	CleanupStack::Pop(bitmap);
sl@0	1928	return bitmap;
sl@0	1929	}
sl@0	1930
sl@0	1931	EXPORT_C void CTestEglSession::CheckVgDrawingL(VGImageFormat aDataFormat, const CFbsBitmap* aReferenceBitmap)
sl@0	1932	{
sl@0	1933	TRgb refPixel;
sl@0	1934	TInt height = aReferenceBitmap->SizeInPixels().iHeight;
sl@0	1935	TInt width = aReferenceBitmap->SizeInPixels().iWidth;
sl@0	1936
sl@0	1937	switch(aDataFormat)
sl@0	1938	{
sl@0	1939	case VG_sRGB_565:
sl@0	1940	{
sl@0	1941	TUint16* vgPixel = new(ELeave) TUint16[width];
sl@0	1942	CleanupArrayDeletePushL(vgPixel);
sl@0	1943	for (TInt y=0; y < height; y++)
sl@0	1944	{
sl@0	1945	// Mind the fact that CFbsBitmap and VGImages use different coordinates origin!
sl@0	1946	vgReadPixels(vgPixel, 1, aDataFormat, 0,height-y-1, width,1);
sl@0	1947
sl@0	1948	for (TInt x=0; x < width; x++)
sl@0	1949	{
sl@0	1950	aReferenceBitmap->GetPixel(refPixel, TPoint(x,y));
sl@0	1951	if(!PixelsMatch(refPixel, TRgb::Color64K(vgPixel[x]), EFalse))
sl@0	1952	{
sl@0	1953	User::Leave(KErrTEFUnitFail);
sl@0	1954	}
sl@0	1955	}
sl@0	1956	}
sl@0	1957	CleanupStack::PopAndDestroy(vgPixel);
sl@0	1958	break;
sl@0	1959	}
sl@0	1960
sl@0	1961	case VG_sXRGB_8888:
sl@0	1962	{
sl@0	1963	TUint32* vgPixel = new(ELeave) TUint32[width];
sl@0	1964	CleanupArrayDeletePushL(vgPixel);
sl@0	1965	for (TInt y=0; y < height; y++)
sl@0	1966	{
sl@0	1967	// Mind the fact that CFbsBitmap and VGImages use different coordinates origin!
sl@0	1968	vgReadPixels(vgPixel, 1, aDataFormat, 0,height-y-1, width,1);
sl@0	1969
sl@0	1970	for (TInt x=0; x < width; x++)
sl@0	1971	{
sl@0	1972	aReferenceBitmap->GetPixel(refPixel, TPoint(x,y));
sl@0	1973	if(!PixelsMatch(refPixel, TRgb::Color16MU(vgPixel[x]), EFalse))
sl@0	1974	{
sl@0	1975	User::Leave(KErrTEFUnitFail);
sl@0	1976	}
sl@0	1977	}
sl@0	1978	}
sl@0	1979	CleanupStack::PopAndDestroy(vgPixel);
sl@0	1980	break;
sl@0	1981	}
sl@0	1982
sl@0	1983	case VG_sARGB_8888:
sl@0	1984	{
sl@0	1985	TUint32* vgPixel = new(ELeave) TUint32[width];
sl@0	1986	CleanupArrayDeletePushL(vgPixel);
sl@0	1987	for (TInt y=0; y < height; y++)
sl@0	1988	{
sl@0	1989	// Mind the fact that CFbsBitmap and VGImages use different coordinates origin!
sl@0	1990	vgReadPixels(vgPixel, 1, aDataFormat, 0,height-y-1, width,1);
sl@0	1991
sl@0	1992	for (TInt x=0; x < width; x++)
sl@0	1993	{
sl@0	1994	aReferenceBitmap->GetPixel(refPixel, TPoint(x,y));
sl@0	1995	if(!PixelsMatch(refPixel, TRgb::Color16MA(vgPixel[x]), ETrue))
sl@0	1996	{
sl@0	1997	User::Leave(KErrTEFUnitFail);
sl@0	1998	}
sl@0	1999	}
sl@0	2000	}
sl@0	2001	CleanupStack::PopAndDestroy(vgPixel);
sl@0	2002	break;
sl@0	2003	}
sl@0	2004
sl@0	2005	case VG_sARGB_8888_PRE:
sl@0	2006	{
sl@0	2007	TUint32* vgPixel = new(ELeave) TUint32[width];
sl@0	2008	CleanupArrayDeletePushL(vgPixel);
sl@0	2009	for (TInt y=0; y < height; y++)
sl@0	2010	{
sl@0	2011	// Mind the fact that CFbsBitmap and VGImages use different coordinates origin!
sl@0	2012	vgReadPixels(vgPixel, 1, aDataFormat, 0,height-y-1, width,1);
sl@0	2013
sl@0	2014	for (TInt x=0; x < width; x++)
sl@0	2015	{
sl@0	2016	aReferenceBitmap->GetPixel(refPixel, TPoint(x,y));
sl@0	2017	if(!PixelsMatch(refPixel, TRgb::Color16MAP(vgPixel[x]), ETrue))
sl@0	2018	{
sl@0	2019	User::Leave(KErrTEFUnitFail);
sl@0	2020	}
sl@0	2021	}
sl@0	2022	}
sl@0	2023	CleanupStack::PopAndDestroy(vgPixel);
sl@0	2024	break;
sl@0	2025	}
sl@0	2026
sl@0	2027	default:
sl@0	2028	// We should not get here - colour mode not supported by these tests
sl@0	2029	ERR_PRINTF1(_L("CTestEglSession::CheckVgDrawingL - Colour mode not supported!"));
sl@0	2030	ASSERT(FALSE);
sl@0	2031	break;
sl@0	2032	}
sl@0	2033	}
sl@0	2034
sl@0	2035	EXPORT_C TBool CTestEglSession::IsOpenGLESSupported()
sl@0	2036	{
sl@0	2037	if(!iIsSupportedRenderInitialized)
sl@0	2038	{
sl@0	2039	CheckAllAvailableRenders();
sl@0	2040	}
sl@0	2041	return iIsOpenGLESSupported;
sl@0	2042	}
sl@0	2043
sl@0	2044	EXPORT_C TBool CTestEglSession::IsOpenGLES2Supported()
sl@0	2045	{
sl@0	2046	if(!iIsSupportedRenderInitialized)
sl@0	2047	{
sl@0	2048	CheckAllAvailableRenders();
sl@0	2049	}
sl@0	2050	return iIsOpenGLES2Supported;
sl@0	2051	}
sl@0	2052	EXPORT_C TBool CTestEglSession::IsOpenVGSupported()
sl@0	2053	{
sl@0	2054	if(!iIsSupportedRenderInitialized)
sl@0	2055	{
sl@0	2056	CheckAllAvailableRenders();
sl@0	2057	}
sl@0	2058	return iIsOpenVGSupported;
sl@0	2059	}
sl@0	2060
sl@0	2061	void CTestEglSession::CheckAllAvailableRenders()
sl@0	2062	{
sl@0	2063	ASSERT_EGL_TRUE(iDisplay != EGL_NO_DISPLAY);
sl@0	2064	TPtrC8 ptrEglClientApis((const TText8 *)eglQueryString(iDisplay, EGL_CLIENT_APIS));
sl@0	2065	_LIT8(KOpenGLES, "OpenGL_ES");
sl@0	2066	EGLint numConfigs= 0;
sl@0	2067	EGLConfig config;
sl@0	2068	if(ptrEglClientApis.Find(KOpenGLES) != KErrNotFound)
sl@0	2069	{
sl@0	2070	//check GLES2
sl@0	2071	const EGLint KAttrib_list_gles2[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
sl@0	2072	EGL_NONE };
sl@0	2073	EGLBoolean eglRes = eglChooseConfig(iDisplay, KAttrib_list_gles2, &config,1, &numConfigs);
sl@0	2074	ASSERT_EGL_TRUE(eglRes == EGL_TRUE);
sl@0	2075	if(numConfigs > 0)
sl@0	2076	{
sl@0	2077	iIsOpenGLES2Supported = ETrue;
sl@0	2078	}
sl@0	2079	//check GLES
sl@0	2080	numConfigs = 0;
sl@0	2081	const EGLint KAttrib_list_gles[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
sl@0	2082	EGL_NONE };
sl@0	2083	eglRes = eglChooseConfig(iDisplay, KAttrib_list_gles, &config,1, &numConfigs);
sl@0	2084	ASSERT_EGL_TRUE(eglRes == EGL_TRUE);
sl@0	2085	if(numConfigs > 0)
sl@0	2086	{
sl@0	2087	iIsOpenGLESSupported = ETrue;
sl@0	2088	}
sl@0	2089	}
sl@0	2090	_LIT8(KOpenVG, "OpenVG");
sl@0	2091	if(ptrEglClientApis.Find(KOpenVG) != KErrNotFound)
sl@0	2092	{
sl@0	2093	numConfigs= 0;
sl@0	2094	//check VG
sl@0	2095	const EGLint KAttrib_list_vg[] = { EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
sl@0	2096	EGL_NONE };
sl@0	2097	EGLBoolean eglRes = eglChooseConfig(iDisplay, KAttrib_list_vg, &config,1, &numConfigs);
sl@0	2098	ASSERT_EGL_TRUE(eglRes == EGL_TRUE);
sl@0	2099	if(numConfigs > 0)
sl@0	2100	{
sl@0	2101	iIsOpenVGSupported = ETrue;
sl@0	2102	}
sl@0	2103	}
sl@0	2104	iIsSupportedRenderInitialized = ETrue;
sl@0	2105	}
sl@0	2106
sl@0	2107

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--