// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

/**
 @file
 @test
*/


#ifndef EGLTESTCOMMONUTILS_H
#define EGLTESTCOMMONUTILS_H

#include <w32std.h>
#include <pixelformats.h>
#include <EGL/eglext.h>
#include <VG/openvg.h>


/******************************************************************************/	
/***																		***/	
/*** 	Global constants and definitions for EGL Tests						***/
/***																		***/	
/******************************************************************************/	

const TUidPixelFormat KDefaultSourceFormat = EUidPixelFormatARGB_8888_PRE;
const VGImageFormat   KDefaultSurfaceFormat = VG_sARGB_8888_PRE;

const TInt KMaxEglConfigs = 1024;
const TInt KTestNoMatchingConfig = -1714;

enum TExtensionsGroups
	{
    EIsUndefined,
    EIsRSgImage,
	EIsEGL,
	EIsVG,	
	EIsGLES
	};
	
/**
 Provides an index into KConfigAttribs
 */
enum TEglTestConfig
	{ 
	EPixmapAttribsColor64K,
	EPixmapAttribsColor16MU,
	EPixmapAttribsColor16MAP,
	EWindowAttribsColor64K,
	EWindowAttribsColor16MA,
	EWindowAttribsColor16MAP,
	EPBufferAttribsColor64K,
	EPBufferAttribsColor16MU,
	EPBufferAttribsColor16MA,
	EPBufferAttribsColor16MAP,	
	EPBufferAttribsColorGles64K,
	EWindowAttribsColor16MA_Preserved,
	EEglTestConfigMax			// Must be the last item in the list. 
	};

// Symbian config attributes for pixmaps / pbuffers / windows
static const EGLint KConfigAttribs[EEglTestConfigMax][15] =
	{
		{
		//EColor64K - Pixmap
		EGL_BUFFER_SIZE,    16,
		EGL_RED_SIZE,		5,
		EGL_GREEN_SIZE, 	6,
		EGL_BLUE_SIZE,		5,
		EGL_ALPHA_SIZE, 	0,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PIXMAP_BIT,
		EGL_NONE
		},
		{
		//EColor16MU - Pixmap
		EGL_BUFFER_SIZE,    24,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE,     0,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PIXMAP_BIT,
		EGL_NONE
		},
		{
		//EColor16MAP - Pixmap
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PIXMAP_BIT | EGL_VG_COLORSPACE_LINEAR_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,
		EGL_NONE
		},
		{
		//EWindowAttribsColor64K - Window
		EGL_BUFFER_SIZE,    16,
		EGL_RED_SIZE,		5,
		EGL_GREEN_SIZE, 	6,
		EGL_BLUE_SIZE,		5,
		EGL_ALPHA_SIZE, 	0,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_WINDOW_BIT,
		EGL_NONE
		},
		{
		//EWindowAttribsColor16MA - Window
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_WINDOW_BIT,
		EGL_NONE
		},
		{
		//EWindowAttribsColor16MAP - Window
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_WINDOW_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,
		EGL_NONE
		},
		{
		// EPBufferAttribsColor64K - PBuffer
		EGL_BUFFER_SIZE,    16,
		EGL_RED_SIZE,		5,
		EGL_GREEN_SIZE, 	6,
		EGL_BLUE_SIZE,		5,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PBUFFER_BIT,
		EGL_NONE
		},
		{
		// EPBufferAttribsColor16MU - PBuffer
		EGL_BUFFER_SIZE,    24,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	0,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PBUFFER_BIT,
		EGL_NONE
		},
		{
		// EPBufferAttribsColor16MA - PBuffer
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PBUFFER_BIT,
		EGL_NONE
		},
		{
		// EPBufferAttribsColor16MAP - PBuffer
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,		8,
		EGL_GREEN_SIZE, 	8,
		EGL_BLUE_SIZE,		8,
		EGL_ALPHA_SIZE, 	8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,	EGL_PBUFFER_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT,
		EGL_NONE
		},
		{
		// EPBufferAttribsColorGles64K - PBuffer
		EGL_BUFFER_SIZE,    16,
		EGL_RED_SIZE,		5,
		EGL_GREEN_SIZE, 	6,
		EGL_BLUE_SIZE,		5,
		EGL_ALPHA_SIZE, 	0,
		EGL_RENDERABLE_TYPE,EGL_OPENGL_ES_BIT,
		EGL_SURFACE_TYPE,	EGL_PBUFFER_BIT,
		EGL_NONE
		},
		{
		//EWindowAttribsColor16MA Preserved - Window 
		EGL_BUFFER_SIZE,    32,
		EGL_RED_SIZE,       8,
		EGL_GREEN_SIZE,     8,
		EGL_BLUE_SIZE,      8,
		EGL_ALPHA_SIZE,     8,
		EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
		EGL_SURFACE_TYPE,   EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT,
		EGL_NONE
		},	
	};

enum TEglConfigMatchType
{
	/** Dummy, used for "uninitialized/unknowns/error" situations */
    eMatchUnknown,			
    /** Matches whatever - don't actually compare anything. */
    eMatchAlways,   		
    /** Matches equal values - config must match requested value. */
    eMatchEqual,			
    /** Matches greater or equal - config must be equal or greater than requested value. */
    eMatchAtLeast,			
    /** Match bitmask - config bits must have the requested bits. */
    eMatchBitMask			
};

const TInt KNumConfigMatchRules = 2;

struct TConfigMatchRuleItem
	{
	EGLint 				iAttrib;
	TEglConfigMatchType iMatchType;
	};

/**
 Defines rules for how to match a requested config with the configs returned by eglChooseConfig.
 */
static const TConfigMatchRuleItem KConfigMatchRules[KNumConfigMatchRules][15] =
{
	{
		// EConfigMatchStandard
		{ EGL_BUFFER_SIZE, eMatchAtLeast },
		{ EGL_RED_SIZE, eMatchEqual },
		{ EGL_GREEN_SIZE, eMatchEqual },
		{ EGL_BLUE_SIZE, eMatchEqual },
		{ EGL_ALPHA_SIZE, eMatchEqual },		
		{ EGL_RENDERABLE_TYPE, eMatchBitMask },
		{ EGL_SURFACE_TYPE, eMatchBitMask },
		{ EGL_NONE, eMatchUnknown }
	},
	{
		// EConfigMatchIgnoreAlpha
		{ EGL_BUFFER_SIZE, eMatchAtLeast },
		{ EGL_RED_SIZE, eMatchEqual },
		{ EGL_GREEN_SIZE, eMatchEqual },
		{ EGL_BLUE_SIZE, eMatchEqual },
		{ EGL_ALPHA_SIZE, eMatchAlways },		
		{ EGL_RENDERABLE_TYPE, eMatchBitMask },
		{ EGL_SURFACE_TYPE, eMatchBitMask },
		{ EGL_NONE, eMatchUnknown }
	}
};

/**
 Provides an index into KConfigMatchRules
 */
enum TEglConfigMatchRule
	{ 
	EConfigMatchStandard,
	EConfigMatchIgnoreAlpha,
	};

// Attributes that can be passed into eglCreatePixmapSurface()
const EGLint KPixmapAttribsNone[] = { EGL_NONE };
const EGLint KPixmapAttribsVgAlphaFormatPre[] = 
	{
	EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE,
	EGL_NONE
	};

const EGLint KPixmapAttribsVgAlphaFormatNonPre[] = 
    {
    EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_NONPRE,
    EGL_NONE
    };

// Attributes that can be passed into eglCreateImageKHR()
const EGLint KEglImageAttribsNone[] = { EGL_NONE };
const EGLint KEglImageAttribsPreservedTrue[] = 
	{
	EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
	EGL_NONE
	};
const EGLint KEglImageAttribsPreservedFalse[] = 
	{
	EGL_IMAGE_PRESERVED_KHR, EGL_FALSE,
	EGL_NONE
	};

// Attributes that can be passed into eglCreateSyncKHR()
const EGLint KEglSyncAttribsNone[] = {EGL_NONE};

/**
 Performs a TEFUNIT style ASSERT, but also outputs the last EGL error code.
 Use this macro to check that EGL function calls have succeeded.
 */
#define ASSERT_EGL_TRUE(aFunction) \
	if(!(aFunction)) \
		{ \
		EGLint eglError = eglGetError(); \
		ERR_PRINTF2(_L("EGL Error: 0x%x"), eglError); \
		User::Leave(KErrTEFUnitFail); \
		}

/**
 Performs a TEFUNIT style ASSERT, but also outputs the last EGL error code.
 Use this macro to check that the expected EGL error has occurred.
*/
#define ASSERT_EGL_ERROR(aExpectedError) \
		{ \
		EGLint eglError = eglGetError(); \
		if (eglError != aExpectedError) \
			{ \
			ERR_PRINTF3(_L("Actual EGL Error: 0x%x, but Expected EGL Error: 0x%x"), eglError, aExpectedError); \
			User::Leave(KErrTEFUnitFail); \
			} \
		}

/**
  Performs a TEFUNIT style TEST. Use this macro to check that 
  EGL function calls have succeeded and the expected EGL error has occurred.
 */
#define TEST_EGL_ERROR(aFunction, aExpectedError) \
    TEST(aFunction); \
    TEST(eglGetError() == aExpectedError);

/**
 Performs a TEFUNIT style ASSERT, but also outputs the last VG error code.
 Use this macro to check that VG function calls have succeeded.
 */
#define ASSERT_VG_TRUE(aFunction) \
	if(!(aFunction)) \
		{ \
		VGErrorCode vgError = vgGetError(); \
		ERR_PRINTF2(_L("VG Error: 0x%x"), vgError); \
		User::Leave(KErrTEFUnitFail); \
		}

/**
 Performs a TEFUNIT style ASSERT, but also outputs the last VG error code.
 Use this macro to check that the expected VG error has occurred.
*/
#define ASSERT_VG_ERROR(aExpectedError) \
		{ \
		VGErrorCode vgError = vgGetError(); \
		if (vgError != aExpectedError) \
			{ \
			ERR_PRINTF3(_L("Actual VG Error: 0x%x, but Expected VG Error: 0x%x"), vgError, aExpectedError); \
			User::Leave(KErrTEFUnitFail); \
			} \
		}


// The following macros allow verbose logging to be switched on and off programmatically. 
#define VERBOSE_INFO_PRINTF1(p1)		if (iVerboseLogging) { INFO_PRINTF1(p1); }
#define VERBOSE_INFO_PRINTF2(p1, p2)	if (iVerboseLogging) { INFO_PRINTF2(p1, p2); }
#define VERBOSE_INFO_PRINTF3(p1, p2, p3)	if (iVerboseLogging) { INFO_PRINTF3(p1, p2, p3); }

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
_LIT8(KEglRSgImage,"EGL_NOK_pixmap_type_rsgimage");
#else
_LIT8(KEglRSgImage,"EGL_SYMBIAN_PIXMAP_TYPE_RSGIMAGE");
#endif
_LIT8(KEglKhrImageBase,"EGL_KHR_image_base");
_LIT8(KEglKhrImagePixmap,"EGL_KHR_image_pixmap");
_LIT8(KVgKhrEglImage,"VG_KHR_EGL_image");
_LIT8(KEglKhrReusableSync,"EGL_KHR_reusable_sync");
_LIT8(KEglNokPrivateSignalSync,"EGL_NOK__private__signal_sync");
_LIT8(KEglNokiaSwapBuffers,"EGL_NOKIA_swap_buffers");
#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
_LIT8(KEglSymbianImagePreserved,"EGL_SYMBIAN_image_preserved");
#endif


enum TExtensionsId
	{
	KEGLUndefined,
    KEGL_RSgimage 					= 0x01,
    KEGL_KHR_image_base				= 0x02,
    KEGL_KHR_image_pixmap			= 0x04,	
    KVG_KHR_EGL_image				= 0x08,
	KEGL_KHR_reusable_sync			= 0x10,
	KEGL_NOK__private__signal_sync  = 0x20,
	KEGL_NOKIA_swap_buffers         = 0x40,
	KEGL_SYMBIAN_image_preserved	= 0x80
	};

const TUid KUidEglTestServer={0x10281B40};
const TUid KUidEglTestServerNga={0x10285DC0};

#endif	// EGLTESTCOMMONUTILS_H