1 /*------------------------------------------------------------------------

     2  *

     3  * EGL 1.3

     4  * -------

     5  *

     6  * Copyright (c) 2007 The Khronos Group Inc.

     7  *

     8  * Permission is hereby granted, free of charge, to any person obtaining a

     9  * copy of this software and /or associated documentation files

    10  * (the "Materials "), to deal in the Materials without restriction,

    11  * including without limitation the rights to use, copy, modify, merge,

    12  * publish, distribute, sublicense, and/or sell copies of the Materials,

    13  * and to permit persons to whom the Materials are furnished to do so,

    14  * subject to the following conditions: 

    15  *

    16  * The above copyright notice and this permission notice shall be included 

    17  * in all copies or substantial portions of the Materials. 

    18  *

    19  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    22  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    25  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    26  *

    27  *//**

    28  * \file

    29  * \brief	Simple implementation of EGL 1.3

    30  * \note	caveats:

    31 			- always renders into the backbuffer and blits it to window (no single buffered rendering)

    32 			- no native Windows or Mac OS X pixmap support

    33 			- no power management events

    34 			- no support for swap interval

    35  * \todo	what happens in egl functions when eglTerminate has been called but the context and surface are still in use?

    36  * \todo	OSDeinitMutex should be called in case getEGL fails.

    37  *//*-------------------------------------------------------------------*/

    38 

    39 #include "egl.h"

    40 #include "openvg.h"

    41 #include "riArray.h"

    42 #include "riMath.h"

    43 #include "riContext.h"

    44 #include "riImage.h"

    45 

    46 #ifdef BUILD_WITH_PRIVATE_EGL 

    47 #include "eglinternal.h"

    48 #endif

    49 

    50 #ifdef BUILD_WITH_PRIVATE_OPENVG

    51 #include "openvginternal.h"

    52 #endif

    53 

    54 //==============================================================================================

    55 

    56 namespace OpenVGRI

    57 {

    58 

    59 void* OSGetCurrentThreadID(void);

    60 void OSAcquireMutex(void);

    61 void OSReleaseMutex(void);

    62 void OSDeinitMutex(void);

    63 

    64 EGLDisplay OSGetDisplay(EGLNativeDisplayType display_id);

    65 void* OSCreateWindowContext(EGLNativeWindowType window);

    66 void OSDestroyWindowContext(void* context);

    67 bool OSIsWindow(const void* context);

    68 void OSGetWindowSize(const void* context, int& width, int& height);

    69 void OSBlitToWindow(void* context, const Drawable* drawable);

    70 EGLBoolean OSGetNativePixmapInfo(NativePixmapType pixmap, int* width, int* height, int* stride, VGImageFormat* format, int** data);

    71 

    72 

    73 /*-------------------------------------------------------------------*//*!

    74 * \brief	

    75 * \param	

    76 * \return	

    77 * \note		

    78 *//*-------------------------------------------------------------------*/

    79 

    80 class RIEGLConfig

    81 {

    82 public:

    83 	RIEGLConfig() : m_desc(Color::formatToDescriptor(VG_sRGBA_8888)), m_configID(0)	{}

    84 	~RIEGLConfig()							{}

    85 	void		set(int r, int g, int b, int a, int l, int bpp, int samples, int maskBits, int ID)

    86 	{

    87 		m_desc.redBits = r;

    88 		m_desc.greenBits = g;

    89 		m_desc.blueBits = b;

    90 		m_desc.alphaBits = a;

    91 		m_desc.luminanceBits = l;

    92 		m_desc.alphaShift = 0;

    93 		m_desc.luminanceShift = 0;

    94 		m_desc.blueShift = b ? a : 0;

    95 		m_desc.greenShift = g ? a + b : 0;

    96 		m_desc.redShift = r ? a + b + g : 0;

    97 		m_desc.format = (VGImageFormat)-1;

    98 		m_desc.internalFormat = l ? Color::sLA : Color::sRGBA;

    99 		m_desc.bitsPerPixel = bpp;

   100 		RI_ASSERT(Color::isValidDescriptor(m_desc));

   101 		m_samples = samples;

   102         m_maskBits = maskBits;

   103 		m_configID = ID;

   104         m_config = (EGLConfig)ID;

   105 	}

   106 

   107     Color::Descriptor configToDescriptor(bool sRGB, bool premultiplied) const

   108     {

   109         Color::Descriptor desc = m_desc;

   110         unsigned int f = m_desc.luminanceBits ? Color::LUMINANCE : 0;

   111         f |= sRGB ? Color::NONLINEAR : 0;

   112         f |= premultiplied ? Color::PREMULTIPLIED : 0;

   113         desc.internalFormat = (Color::InternalFormat)f;

   114         return desc;

   115     }

   116 

   117 	//EGL RED SIZE bits of Red in the color buffer

   118 	//EGL GREEN SIZE bits of Green in the color buffer

   119 	//EGL BLUE SIZE bits of Blue in the color buffer

   120 	//EGL ALPHA SIZE bits of Alpha in the color buffer

   121 	//EGL LUMINANCE SIZE bits of Luminance in the color buffer

   122 	Color::Descriptor	m_desc;

   123 	int					m_samples;

   124     int                 m_maskBits;

   125 	EGLint				m_configID;			//EGL CONFIG ID unique EGLConfig identifier

   126     EGLConfig           m_config;

   127 	//EGL BUFFER SIZE depth of the color buffer (sum of channel bits)

   128 	//EGL ALPHA MASK SIZE number alpha mask bits (always 8)

   129 	//EGL BIND TO TEXTURE RGB boolean True if bindable to RGB textures. (always EGL_FALSE)

   130 	//EGL BIND TO TEXTURE RGBA boolean True if bindable to RGBA textures. (always EGL_FALSE)

   131 	//EGL COLOR BUFFER TYPE enum color buffer type (EGL_RGB_BUFFER, EGL_LUMINANCE_BUFFER)

   132 	//EGL CONFIG CAVEAT enum any caveats for the configuration (always EGL_NONE)

   133 	//EGL DEPTH SIZE integer bits of Z in the depth buffer (always 0)

   134 	//EGL LEVEL integer frame buffer level (always 0)

   135 	//EGL MAX PBUFFER WIDTH integer maximum width of pbuffer (always INT_MAX)

   136 	//EGL MAX PBUFFER HEIGHT integer maximum height of pbuffer (always INT_MAX)

   137 	//EGL MAX PBUFFER PIXELS integer maximum size of pbuffer (always INT_MAX)

   138 	//EGL MAX SWAP INTERVAL integer maximum swap interval (always 1)

   139 	//EGL MIN SWAP INTERVAL integer minimum swap interval (always 1)

   140 	//EGL NATIVE RENDERABLE boolean EGL TRUE if native rendering APIs can render to surface (always EGL_FALSE)

   141 	//EGL NATIVE VISUAL ID integer handle of corresponding native visual (always 0)

   142 	//EGL NATIVE VISUAL TYPE integer native visual type of the associated visual (always EGL_NONE)

   143 	//EGL RENDERABLE TYPE bitmask which client rendering APIs are supported. (always EGL_OPENVG_BIT)

   144 	//EGL SAMPLE BUFFERS integer number of multisample buffers (always 0)

   145 	//EGL SAMPLES integer number of samples per pixel (always 0)

   146 	//EGL STENCIL SIZE integer bits of Stencil in the stencil buffer (always 0)

   147 	//EGL SURFACE TYPE bitmask which types of EGL surfaces are supported. (always EGL WINDOW BIT | EGL PIXMAP BIT | EGL PBUFFER BIT)

   148 	//EGL TRANSPARENT TYPE enum type of transparency supported (always EGL_NONE)

   149 	//EGL TRANSPARENT RED VALUE integer transparent red value (undefined)

   150 	//EGL TRANSPARENT GREEN VALUE integer transparent green value (undefined)

   151 	//EGL TRANSPARENT BLUE VALUE integer transparent blue value (undefined)

   152 };

   153 

   154 /*-------------------------------------------------------------------*//*!

   155 * \brief	

   156 * \param	

   157 * \return	

   158 * \note		

   159 *//*-------------------------------------------------------------------*/

   160 

   161 class RIEGLContext

   162 {

   163 public:

   164 	RIEGLContext(OpenVGRI::VGContext* vgctx, const EGLConfig config);

   165 	~RIEGLContext();

   166 	void	addReference()				{ m_referenceCount++; }

   167 	int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

   168 

   169     VGContext*      getVGContext() const      { return m_vgContext; }

   170     EGLConfig getConfig() const         { return m_config; }

   171 private:

   172 	RIEGLContext(const RIEGLContext&);

   173 	RIEGLContext& operator=(const RIEGLContext&);

   174 	VGContext*		m_vgContext;

   175 	const EGLConfig	m_config;

   176 	int				m_referenceCount;

   177 };

   178 

   179 RIEGLContext* CastToRIEGLContext(EGLContext aCtxId);

   180 EGLContext CastFromRIEGLContext(RIEGLContext* aCtx);

   181 

   182 RIEGLContext::RIEGLContext(OpenVGRI::VGContext* vgctx, const EGLConfig config) :

   183 	m_vgContext(vgctx),

   184 	m_config(config),

   185 	m_referenceCount(0)

   186 {

   187 }

   188 RIEGLContext::~RIEGLContext()

   189 {

   190 	RI_ASSERT(m_referenceCount == 0);

   191 	RI_DELETE(m_vgContext);

   192 }

   193 

   194 /*-------------------------------------------------------------------*//*!

   195 * \brief	

   196 * \param	

   197 * \return	

   198 * \note		

   199 *//*-------------------------------------------------------------------*/

   200 

   201 class RIEGLSurface

   202 {

   203 public:

   204     RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer);

   205 	~RIEGLSurface();

   206 	void	addReference()				{ m_referenceCount++; }

   207 	int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

   208 

   209     void*           getOSWindowContext() const { return m_OSWindowContext; }

   210     EGLConfig       getConfig() const          { return m_config; }

   211     Drawable*       getDrawable() const        { return m_drawable; }

   212     bool            isLargestPbuffer() const   { return m_largestPbuffer; }

   213     int             getRenderBuffer() const    { return m_renderBuffer; }

   214 

   215 private:

   216 	RIEGLSurface(const RIEGLSurface&);

   217 	RIEGLSurface& operator=(const RIEGLSurface&);

   218     void*            m_OSWindowContext;

   219 	const EGLConfig	 m_config;

   220 	Drawable*        m_drawable;

   221 	bool			 m_largestPbuffer;

   222 	int				 m_renderBuffer;		//EGL_BACK_BUFFER or EGL_SINGLE_BUFFER

   223 	int				 m_referenceCount;

   224 };

   225 

   226 RIEGLSurface* CastToRIEGLSurface(EGLSurface aSurfaceId);

   227 EGLSurface CastFromRIEGLSurface(RIEGLSurface* aSurface);

   228 

   229 RIEGLSurface::RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer) :

   230     m_OSWindowContext(OSWindowContext),

   231 	m_config(config),

   232 	m_drawable(drawable),

   233 	m_largestPbuffer(largestPbuffer),

   234 	m_renderBuffer(renderBuffer),

   235 	m_referenceCount(0)

   236 {

   237     RI_ASSERT(m_renderBuffer == EGL_BACK_BUFFER);   //only back buffer rendering is supported

   238     m_drawable->addReference();

   239 }

   240 

   241 RIEGLSurface::~RIEGLSurface()

   242 {

   243 	RI_ASSERT(m_referenceCount == 0);

   244     OSDestroyWindowContext(m_OSWindowContext);

   245 	if(m_drawable)

   246 	{

   247 		if(!m_drawable->removeReference())

   248 			RI_DELETE(m_drawable);

   249 	}

   250 }

   251 

   252 /*-------------------------------------------------------------------*//*!

   253 * \brief	

   254 * \param	

   255 * \return	

   256 * \note		

   257 *//*-------------------------------------------------------------------*/

   258 

   259 #define EGL_NUMCONFIGS		60

   260 

   261 class RIEGLDisplay

   262 {

   263 public:

   264 	RIEGLDisplay(EGLDisplay id);

   265 	~RIEGLDisplay();

   266 

   267 	int                getNumConfigs() const              { return EGL_NUMCONFIGS; }

   268     const RIEGLConfig& getConfigByIdx(int i) const             { RI_ASSERT(i >= 0 && i < EGL_NUMCONFIGS); return m_configs[i]; }

   269     const RIEGLConfig& getConfig(const EGLConfig config) const        { for(int i=0;i<EGL_NUMCONFIGS;i++) { if(m_configs[i].m_config == config) return m_configs[i]; } RI_ASSERT(0); return m_configs[0]; }

   270 

   271     EGLDisplay        getID() const                       { return m_id; }

   272 

   273     void              addContext(RIEGLContext* ctx)       { RI_ASSERT(ctx); m_contexts.push_back(ctx); }  //throws bad_alloc

   274     void              removeContext(RIEGLContext* ctx)    { RI_ASSERT(ctx); bool res = m_contexts.remove(ctx); RI_ASSERT(res); RI_UNREF(res); }

   275 

   276     void              addSurface(RIEGLSurface* srf)       { RI_ASSERT(srf); m_surfaces.push_back(srf); }  //throws bad_alloc

   277     void              removeSurface(RIEGLSurface* srf)    { RI_ASSERT(srf); bool res = m_surfaces.remove(srf); RI_ASSERT(res); RI_UNREF(res); }

   278 

   279     EGLBoolean        contextExists(const EGLContext ctx) const;

   280     EGLBoolean        surfaceExists(const EGLSurface srf) const;

   281     EGLBoolean        configExists(const EGLConfig cfg) const;

   282 

   283 private:

   284 	RIEGLDisplay(const RIEGLDisplay& t);

   285 	RIEGLDisplay& operator=(const RIEGLDisplay&t);

   286 

   287 	EGLDisplay              m_id;

   288 

   289 	Array<RIEGLContext*>	m_contexts;

   290 	Array<RIEGLSurface*>	m_surfaces;

   291 

   292 	RIEGLConfig             m_configs[EGL_NUMCONFIGS];

   293 };

   294 

   295 RIEGLDisplay::RIEGLDisplay(EGLDisplay id) :

   296 	m_id(id),

   297 	m_contexts(),

   298 	m_surfaces()

   299 {

   300 	RI_ASSERT(EGL_NUMCONFIGS == 60);

   301 

   302 	//sorted by RGB/LUMINANCE (exact), larger total number of color bits (at least), buffer size (at least), config ID (exact)

   303 	//NOTE: 16 bit configs need to be sorted on the fly if the request ignores some channels

   304 	//NOTE: config IDs start from 1

   305 	//               R  B  G  A  L  bpp samples maskBits ID

   306 	m_configs[0].set(8, 8, 8, 8, 0, 32, 1, 8, 1);	//EGL_RGB_BUFFER, buffer size = 32

   307 	m_configs[1].set(8, 8, 8, 0, 0, 32, 1, 8, 2);	//EGL_RGB_BUFFER, buffer size = 24

   308 	m_configs[2].set(5, 5, 5, 1, 0, 16, 1, 4, 3);	//EGL_RGB_BUFFER, buffer size = 16

   309 	m_configs[3].set(5, 6, 5, 0, 0, 16, 1, 4, 4);	//EGL_RGB_BUFFER, buffer size = 16

   310 	m_configs[4].set(4, 4, 4, 4, 0, 16, 1, 4, 5);	//EGL_RGB_BUFFER, buffer size = 16

   311 	m_configs[5].set(0, 0, 0, 8, 0, 8,  1, 8, 6);	//EGL_RGB_BUFFER, buffer size = 8

   312 	m_configs[6].set(0, 0, 0, 4, 0, 4,  1, 4, 7);	//EGL_RGB_BUFFER, buffer size = 8

   313 	m_configs[7].set(0, 0, 0, 1, 0, 1,  1, 1, 8);	//EGL_RGB_BUFFER, buffer size = 8

   314 	m_configs[8].set(0, 0, 0, 0, 8, 8,  1, 8, 9);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   315 	m_configs[9].set(0, 0, 0, 0, 1, 1,  1, 1, 10);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   316 

   317 	m_configs[10].set(8, 8, 8, 8, 0, 32, 4, 1, 11);	//EGL_RGB_BUFFER, buffer size = 32

   318 	m_configs[11].set(8, 8, 8, 0, 0, 32, 4, 1, 12);	//EGL_RGB_BUFFER, buffer size = 24

   319 	m_configs[12].set(5, 5, 5, 1, 0, 16, 4, 1, 13);	//EGL_RGB_BUFFER, buffer size = 16

   320 	m_configs[13].set(5, 6, 5, 0, 0, 16, 4, 1, 14);	//EGL_RGB_BUFFER, buffer size = 16

   321 	m_configs[14].set(4, 4, 4, 4, 0, 16, 4, 1, 15);	//EGL_RGB_BUFFER, buffer size = 16

   322 	m_configs[15].set(0, 0, 0, 8, 0, 8,  4, 1, 16);	//EGL_RGB_BUFFER, buffer size = 8

   323 	m_configs[16].set(0, 0, 0, 4, 0, 4,  4, 1, 17);	//EGL_RGB_BUFFER, buffer size = 8

   324 	m_configs[17].set(0, 0, 0, 1, 0, 1,  4, 1, 18);	//EGL_RGB_BUFFER, buffer size = 8

   325 	m_configs[18].set(0, 0, 0, 0, 8, 8,  4, 1, 19);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   326 	m_configs[19].set(0, 0, 0, 0, 1, 1,  4, 1, 20);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   327 

   328 	m_configs[20].set(8, 8, 8, 8, 0, 32, 32, 1, 21);	//EGL_RGB_BUFFER, buffer size = 32

   329 	m_configs[21].set(8, 8, 8, 0, 0, 32, 32, 1, 22);	//EGL_RGB_BUFFER, buffer size = 24

   330 	m_configs[22].set(5, 5, 5, 1, 0, 16, 32, 1, 23);	//EGL_RGB_BUFFER, buffer size = 16

   331 	m_configs[23].set(5, 6, 5, 0, 0, 16, 32, 1, 24);	//EGL_RGB_BUFFER, buffer size = 16

   332 	m_configs[24].set(4, 4, 4, 4, 0, 16, 32, 1, 25);	//EGL_RGB_BUFFER, buffer size = 16

   333 	m_configs[25].set(0, 0, 0, 8, 0, 8,  32, 1, 26);	//EGL_RGB_BUFFER, buffer size = 8

   334 	m_configs[26].set(0, 0, 0, 4, 0, 4,  32, 1, 27);	//EGL_RGB_BUFFER, buffer size = 8

   335 	m_configs[27].set(0, 0, 0, 1, 0, 1,  32, 1, 28);	//EGL_RGB_BUFFER, buffer size = 8

   336 	m_configs[28].set(0, 0, 0, 0, 8, 8,  32, 1, 29);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   337 	m_configs[29].set(0, 0, 0, 0, 1, 1,  32, 1, 30);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   338 

   339     //configs without mask

   340 	m_configs[30].set(8, 8, 8, 8, 0, 32, 1, 0, 31);	//EGL_RGB_BUFFER, buffer size = 32

   341 	m_configs[31].set(8, 8, 8, 0, 0, 32, 1, 0, 32);	//EGL_RGB_BUFFER, buffer size = 24

   342 	m_configs[32].set(5, 5, 5, 1, 0, 16, 1, 0, 33);	//EGL_RGB_BUFFER, buffer size = 16

   343 	m_configs[33].set(5, 6, 5, 0, 0, 16, 1, 0, 34);	//EGL_RGB_BUFFER, buffer size = 16

   344 	m_configs[34].set(4, 4, 4, 4, 0, 16, 1, 0, 35);	//EGL_RGB_BUFFER, buffer size = 16

   345 	m_configs[35].set(0, 0, 0, 8, 0, 8,  1, 0, 36);	//EGL_RGB_BUFFER, buffer size = 8

   346 	m_configs[36].set(0, 0, 0, 4, 0, 4,  1, 0, 37);	//EGL_RGB_BUFFER, buffer size = 8

   347 	m_configs[37].set(0, 0, 0, 1, 0, 1,  1, 0, 38);	//EGL_RGB_BUFFER, buffer size = 8

   348 	m_configs[38].set(0, 0, 0, 0, 8, 8,  1, 0, 39);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   349 	m_configs[39].set(0, 0, 0, 0, 1, 1,  1, 0, 40);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   350 

   351 	m_configs[40].set(8, 8, 8, 8, 0, 32, 4, 0, 41);	//EGL_RGB_BUFFER, buffer size = 32

   352 	m_configs[41].set(8, 8, 8, 0, 0, 32, 4, 0, 42);	//EGL_RGB_BUFFER, buffer size = 24

   353 	m_configs[42].set(5, 5, 5, 1, 0, 16, 4, 0, 43);	//EGL_RGB_BUFFER, buffer size = 16

   354 	m_configs[43].set(5, 6, 5, 0, 0, 16, 4, 0, 44);	//EGL_RGB_BUFFER, buffer size = 16

   355 	m_configs[44].set(4, 4, 4, 4, 0, 16, 4, 0, 45);	//EGL_RGB_BUFFER, buffer size = 16

   356 	m_configs[45].set(0, 0, 0, 8, 0, 8,  4, 0, 46);	//EGL_RGB_BUFFER, buffer size = 8

   357 	m_configs[46].set(0, 0, 0, 4, 0, 4,  4, 0, 47);	//EGL_RGB_BUFFER, buffer size = 8

   358 	m_configs[47].set(0, 0, 0, 1, 0, 1,  4, 0, 48);	//EGL_RGB_BUFFER, buffer size = 8

   359 	m_configs[48].set(0, 0, 0, 0, 8, 8,  4, 0, 49);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   360 	m_configs[49].set(0, 0, 0, 0, 1, 1,  4, 0, 50);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   361 

   362 	m_configs[50].set(8, 8, 8, 8, 0, 32, 32, 0, 51);	//EGL_RGB_BUFFER, buffer size = 32

   363 	m_configs[51].set(8, 8, 8, 0, 0, 32, 32, 0, 52);	//EGL_RGB_BUFFER, buffer size = 24

   364 	m_configs[52].set(5, 5, 5, 1, 0, 16, 32, 0, 53);	//EGL_RGB_BUFFER, buffer size = 16

   365 	m_configs[53].set(5, 6, 5, 0, 0, 16, 32, 0, 54);	//EGL_RGB_BUFFER, buffer size = 16

   366 	m_configs[54].set(4, 4, 4, 4, 0, 16, 32, 0, 55);	//EGL_RGB_BUFFER, buffer size = 16

   367 	m_configs[55].set(0, 0, 0, 8, 0, 8,  32, 0, 56);	//EGL_RGB_BUFFER, buffer size = 8

   368 	m_configs[56].set(0, 0, 0, 4, 0, 4,  32, 0, 57);	//EGL_RGB_BUFFER, buffer size = 8

   369 	m_configs[57].set(0, 0, 0, 1, 0, 1,  32, 0, 58);	//EGL_RGB_BUFFER, buffer size = 8

   370 	m_configs[58].set(0, 0, 0, 0, 8, 8,  32, 0, 59);	//EGL_LUMINANCE_BUFFER, buffer size = 8

   371 	m_configs[59].set(0, 0, 0, 0, 1, 1,  32, 0, 60);	//EGL_LUMINANCE_BUFFER, buffer size = 1

   372 /*

   373 attrib                default        criteria order   priority

   374 --------------------------------------------------------------

   375 EGL_COLOR_BUFFER_TYPE EGL_RGB_BUFFER Exact    None    2 

   376 EGL_RED_SIZE          0              AtLeast  Special 3 

   377 EGL_GREEN_SIZE        0              AtLeast  Special 3 

   378 EGL_BLUE_SIZE         0              AtLeast  Special 3 

   379 EGL_LUMINANCE_SIZE    0              AtLeast  Special 3 

   380 EGL_ALPHA_SIZE        0              AtLeast  Special 3 

   381 EGL_BUFFER_SIZE       0              AtLeast  Smaller 4 

   382 EGL_CONFIG_ID         EGL_DONT_CARE  Exact    Smaller 11

   383 */

   384 }

   385 

   386 RIEGLDisplay::~RIEGLDisplay()

   387 {

   388 	//mark everything for deletion, but don't delete the current context and surface

   389 	for(int i=0;i<m_contexts.size();i++)

   390 	{

   391 		if(!m_contexts[i]->removeReference())

   392 			RI_DELETE(m_contexts[i]);

   393 	}

   394 	m_contexts.clear();	//remove all contexts from the list (makes further references to the current contexts invalid)

   395 

   396 	for(int i=0;i<m_surfaces.size();i++)

   397 	{

   398 		if(!m_surfaces[i]->removeReference())

   399 			RI_DELETE(m_surfaces[i]);

   400 	}

   401 	m_surfaces.clear();	//remove all surfaces from the list (makes further references to the current surfaces invalid)

   402 }

   403 

   404 EGLBoolean RIEGLDisplay::contextExists(const EGLContext ctx) const

   405 {

   406 	for(int i=0;i<m_contexts.size();i++)

   407 	{

   408 		if(m_contexts[i] == CastToRIEGLContext(ctx))

   409 			return EGL_TRUE;

   410 	}

   411 	return EGL_FALSE;

   412 }

   413 

   414 EGLBoolean RIEGLDisplay::surfaceExists(const EGLSurface surf) const

   415 {

   416 	for(int i=0;i<m_surfaces.size();i++)

   417 	{

   418 		if(m_surfaces[i] == CastToRIEGLSurface(surf))

   419 			return EGL_TRUE;

   420 	}

   421 	return EGL_FALSE;

   422 }

   423 

   424 EGLBoolean RIEGLDisplay::configExists(const EGLConfig config) const

   425 {

   426     for(int i=0;i<EGL_NUMCONFIGS;i++)

   427     {

   428         if(m_configs[i].m_config == config)

   429 		return EGL_TRUE;

   430     }

   431 	return EGL_FALSE;

   432 }

   433 

   434 /*-------------------------------------------------------------------*//*!

   435 * \brief	

   436 * \param	

   437 * \return	

   438 * \note		

   439 *//*-------------------------------------------------------------------*/

   440 

   441 class RIEGLThread

   442 {

   443 public:

   444 	RIEGLThread(void* currentThreadID);

   445 	~RIEGLThread();

   446 

   447     void*           getThreadID() const       { return m_threadID; }

   448 

   449     void            makeCurrent(RIEGLContext* c, RIEGLSurface* s)       { m_context = c; m_surface = s; }

   450 	RIEGLContext*	getCurrentContext() const   { return m_context; }

   451 	RIEGLSurface*	getCurrentSurface() const   { return m_surface; }

   452 

   453     void            setError(EGLint error)      { m_error = error; }

   454     EGLint          getError() const            { return m_error; }

   455 

   456     void            bindAPI(EGLint api)         { m_boundAPI = api; }

   457     EGLint          getBoundAPI() const         { return m_boundAPI; }

   458 

   459 private:

   460 	RIEGLThread(const RIEGLThread&);

   461 	RIEGLThread operator=(const RIEGLThread&);

   462 

   463 	RIEGLContext*		m_context;

   464 	RIEGLSurface*		m_surface;

   465 	EGLint              m_error;

   466 	void*               m_threadID;

   467 	EGLint              m_boundAPI;

   468 };

   469 

   470 RIEGLThread::RIEGLThread(void* currentThreadID) :

   471 	m_context(NULL),

   472 	m_surface(NULL),

   473 	m_error(EGL_SUCCESS),

   474 	m_threadID(currentThreadID),

   475 	m_boundAPI(EGL_NONE)

   476 {

   477 }

   478 

   479 RIEGLThread::~RIEGLThread()

   480 {

   481 }

   482 

   483 

   484 

   485 

   486 

   487 Image* CastToImage(EGLClientBuffer aBufferId);

   488 EGLClientBuffer CastFromImage(Image* aBUffer);

   489 

   490 /*-------------------------------------------------------------------*//*!

   491 * \brief	

   492 * \param	

   493 * \return	

   494 * \note		

   495 *//*-------------------------------------------------------------------*/

   496 

   497 class EGL

   498 {

   499 public:

   500 	EGL();

   501 	~EGL();

   502 

   503 	void	addReference()				{ m_referenceCount++; }

   504 	int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

   505 

   506     void                addDisplay(RIEGLDisplay* display)           { RI_ASSERT(display); m_displays.push_back(display); }  //throws bad alloc

   507     void                removeDisplay(RIEGLDisplay* display)        { RI_ASSERT(display); bool res = m_displays.remove(display); RI_ASSERT(res); RI_UNREF(res); }

   508     RIEGLDisplay*       getDisplay(const EGLDisplay displayID) const;

   509     EGLDisplay          findDisplay(const EGLContext ctx) const;

   510 

   511     void                addCurrentThread(RIEGLThread* thread)       { RI_ASSERT(thread); m_currentThreads.push_back(thread); }  //throws bad alloc

   512     void                removeCurrentThread(RIEGLThread* thread)    { RI_ASSERT(thread); bool res = m_currentThreads.remove(thread); RI_ASSERT(res); RI_UNREF(res); }

   513     RIEGLThread*        getCurrentThread() const;

   514 

   515     RIEGLThread*        getThread();

   516     void                destroyThread();

   517 

   518     bool                isInUse(const void* image) const;

   519 

   520 private:

   521 	EGL(const EGL&);						// Not allowed.

   522 	const EGL& operator=(const EGL&);		// Not allowed.

   523 

   524 	Array<RIEGLThread*>		m_threads;			//threads that have called EGL

   525 	Array<RIEGLThread*>		m_currentThreads;	//threads that have a bound context

   526 	Array<RIEGLDisplay*>	m_displays;

   527 

   528 	int                     m_referenceCount;

   529 };

   530 

   531 EGL::EGL() :

   532 	m_threads(),

   533 	m_currentThreads(),

   534 	m_displays(),

   535 	m_referenceCount(0)

   536 {

   537 }

   538 EGL::~EGL()

   539 {

   540 	for(int i=0;i<m_displays.size();i++)

   541 	{

   542 		RI_DELETE(m_displays[i]);

   543 	}

   544 	for(int i=0;i<m_threads.size();i++)

   545 	{

   546 		RI_DELETE(m_threads[i]);

   547 	}

   548 	//currentThreads contain just pointers to threads we just deleted

   549 }

   550 

   551 /*-------------------------------------------------------------------*//*!

   552 * \brief	

   553 * \param	

   554 * \return	

   555 * \note		

   556 *//*-------------------------------------------------------------------*/

   557 

   558 //static EGL* g_egl = NULL;	//never use this directly

   559 EGL* getEGL()

   560 {

   561 	/*if(!g_egl)

   562 	{

   563 		try

   564 		{

   565 			g_egl = RI_NEW(EGL, ());				//throws bad_alloc

   566 			g_egl->addReference();

   567 		}

   568 		catch(std::bad_alloc)

   569 		{

   570 			g_egl = NULL;

   571 		}

   572 	}

   573 	return g_egl;

   574 	*/

   575 

   576 

   577 	//use TLS to store static global g_egl

   578 	EGL* pEgl=NULL; 

   579 	if((pEgl = static_cast<EGL*>(Dll::Tls()))==NULL)

   580 		{

   581 		//create TLS instance

   582 		pEgl = RI_NEW(EGL, ());

   583 		Dll::SetTls(pEgl);

   584 		}

   585 	return pEgl;

   586 

   587 	

   588 }

   589 static void releaseEGL()

   590 {

   591 /*

   592 	if(g_egl)

   593 	{

   594 		if(!g_egl->removeReference())

   595 		{

   596 			RI_DELETE(g_egl);

   597 			g_egl = NULL;

   598 		}

   599 	}

   600 	*/

   601 	EGL* pEgl = static_cast<EGL*>(Dll::Tls());

   602 	if (pEgl)

   603 		delete pEgl; 

   604 	Dll::SetTls(NULL);

   605 

   606 }

   607 

   608 /*-------------------------------------------------------------------*//*!

   609 * \brief	Given a display ID, return the corresponding object, or NULL

   610 *			if the ID hasn't been initialized.

   611 * \param	

   612 * \return	

   613 * \note		if egl has been initialized for this display, the display ID can

   614 *			be found from egl->m_displays

   615 *//*-------------------------------------------------------------------*/

   616 

   617 RIEGLDisplay* EGL::getDisplay(EGLDisplay displayID) const

   618 {

   619 	for(int i=0;i<m_displays.size();i++)

   620 	{

   621 		if(displayID == m_displays[i]->getID())

   622 			return m_displays[i];

   623 	}

   624 	return NULL;		//error: the display hasn't been eglInitialized

   625 }

   626 

   627 /*-------------------------------------------------------------------*//*!

   628 * \brief	return EGLDisplay for the current context

   629 * \param	

   630 * \return	

   631 * \note		

   632 *//*-------------------------------------------------------------------*/

   633 

   634 EGLDisplay EGL::findDisplay(EGLContext ctx) const

   635 {

   636 	for(int i=0;i<m_displays.size();i++)

   637 	{

   638         if(m_displays[i]->contextExists(ctx))

   639             return m_displays[i]->getID();

   640 	}

   641     return EGL_NO_DISPLAY;

   642 }

   643 

   644 /*-------------------------------------------------------------------*//*!

   645 * \brief	return an EGL thread struct for the thread made current, or

   646 *            NULL if there's no current context.

   647 * \param	

   648 * \return	

   649 * \note		

   650 *//*-------------------------------------------------------------------*/

   651 

   652 RIEGLThread* EGL::getCurrentThread() const

   653 {

   654 	void* currentThreadID = OSGetCurrentThreadID();

   655 	for(int i=0;i<m_currentThreads.size();i++)

   656 	{

   657 		if(currentThreadID == m_currentThreads[i]->getThreadID())

   658 			return m_currentThreads[i];

   659 	}

   660 	return NULL;		//thread is not current

   661 }

   662 

   663 /*-------------------------------------------------------------------*//*!

   664 * \brief	return an EGL thread struct corresponding to current OS thread.

   665 * \param	

   666 * \return	

   667 * \note		

   668 *//*-------------------------------------------------------------------*/

   669 

   670 RIEGLThread* EGL::getThread()

   671 {

   672 	void* currentThreadID = OSGetCurrentThreadID();

   673 	for(int i=0;i<m_threads.size();i++)

   674 	{

   675 		if(currentThreadID == m_threads[i]->getThreadID())

   676 			return m_threads[i];

   677 	}

   678 

   679 	//EGL doesn't have a struct for the thread yet, add it to EGL's list

   680 	RIEGLThread* newThread = NULL;

   681 	try

   682 	{

   683 		newThread = RI_NEW(RIEGLThread, (OSGetCurrentThreadID()));	//throws bad_alloc

   684 		m_threads.push_back(newThread);	//throws bad_alloc

   685 		return newThread;

   686 	}

   687 	catch(std::bad_alloc)

   688 	{

   689 		RI_DELETE(newThread);

   690 		return NULL;

   691 	}

   692 }

   693 

   694 /*-------------------------------------------------------------------*//*!

   695 * \brief	destroy an EGL thread struct

   696 * \param	

   697 * \return	

   698 * \note		

   699 *//*-------------------------------------------------------------------*/

   700 

   701 void EGL::destroyThread()

   702 {

   703 	void* currentThreadID = OSGetCurrentThreadID();

   704 	for(int i=0;i<m_threads.size();i++)

   705 	{

   706 		if(currentThreadID == m_threads[i]->getThreadID())

   707         {

   708             RIEGLThread* thread = m_threads[i];

   709             bool res = m_threads.remove(thread);

   710             RI_ASSERT(res);

   711             RI_UNREF(res);

   712             RI_DELETE(thread);

   713             break;

   714         }

   715 	}

   716 }

   717 

   718 /*-------------------------------------------------------------------*//*!

   719 * \brief	

   720 * \param	

   721 * \return	

   722 * \note		

   723 *//*-------------------------------------------------------------------*/

   724 

   725 bool EGL::isInUse(const void* image) const

   726 {

   727     for(int i=0;i<m_currentThreads.size();i++)

   728     {

   729         RIEGLSurface* s = m_currentThreads[i]->getCurrentSurface();

   730         if(s && s->getDrawable() && s->getDrawable()->isInUse((Image*)image))

   731             return true;

   732     }

   733     return false;

   734 }

   735 

   736 /*-------------------------------------------------------------------*//*!

   737 * \brief	

   738 * \param	

   739 * \return	

   740 * \note		

   741 *//*-------------------------------------------------------------------*/

   742 

   743 #define EGL_GET_DISPLAY(DISPLAY, RETVAL) \

   744 	OSAcquireMutex(); \

   745 	EGL* egl = getEGL(); \

   746     if(!egl) \

   747     { \

   748 		OSReleaseMutex(); \

   749 		return RETVAL; \

   750     } \

   751 	RIEGLDisplay* display = egl->getDisplay(DISPLAY); \

   752 

   753 #define EGL_GET_EGL(RETVAL) \

   754 	OSAcquireMutex(); \

   755 	EGL* egl = getEGL(); \

   756     if(!egl) \

   757     { \

   758 		OSReleaseMutex(); \

   759 		return RETVAL; \

   760     } \

   761 

   762 #define EGL_IF_ERROR(COND, ERRORCODE, RETVAL) \

   763 	if(COND) { eglSetError(egl, ERRORCODE); OSReleaseMutex(); return RETVAL; } \

   764 

   765 #define EGL_RETURN(ERRORCODE, RETVAL) \

   766 	{ \

   767 		eglSetError(egl, ERRORCODE); \

   768 		OSReleaseMutex(); \

   769 		return RETVAL; \

   770 	}

   771 

   772 // Note: egl error handling model differs from OpenVG. The latest error is stored instead of the oldest one.

   773 static void eglSetError(EGL* egl, EGLint error)

   774 {

   775 	RIEGLThread* thread = egl->getThread();

   776 	if(thread)

   777 		thread->setError(error);

   778 }

   779 

   780 /*-------------------------------------------------------------------*//*!

   781 * \brief	Returns the OpenVG context current to the calling thread.

   782 * \param	

   783 * \return	

   784 * \note		This function is always called from a mutexed API function

   785 *//*-------------------------------------------------------------------*/

   786 

   787 void* eglvgGetCurrentVGContext(void)

   788 {

   789 	EGL* egl = getEGL();

   790     if(egl)

   791     {

   792         RIEGLThread* thread = egl->getCurrentThread();

   793         if(thread)

   794         {

   795             RI_ASSERT(thread->getCurrentContext() && thread->getCurrentSurface());

   796             return thread->getCurrentContext()->getVGContext();

   797         }

   798     }

   799 	return NULL;	//not initialized or made current

   800 }

   801 

   802 /*-------------------------------------------------------------------*//*!

   803 * \brief	Check if the image is current in any of the displays

   804 * \param	

   805 * \return	

   806 * \note		This function is always called from a mutexed API function

   807 *//*-------------------------------------------------------------------*/

   808 

   809 bool eglvgIsInUse(void* image)

   810 {

   811 	EGL* egl = getEGL();

   812     if(egl)

   813     {

   814         return egl->isInUse(image);

   815     }

   816 	return false;

   817 }

   818 

   819 //helper functions

   820 RIEGLContext* CastToRIEGLContext(EGLContext aCtxId)

   821   {

   822   return (RIEGLContext*)(aCtxId);

   823   }

   824 EGLContext CastFromRIEGLContext(RIEGLContext* aCtx)

   825   {

   826   return (EGLContext)(aCtx);

   827   }

   828 

   829 RIEGLSurface* CastToRIEGLSurface(EGLSurface aSurfaceId)

   830   {

   831   return (RIEGLSurface*)(aSurfaceId);

   832   }

   833 EGLSurface CastFromRIEGLSurface(RIEGLSurface* aSurface)

   834   {

   835   return (EGLSurface)(aSurface);

   836   }

   837 

   838 Image* CastToImage(EGLClientBuffer aBufferId)

   839   {

   840   return (Image*)(aBufferId);

   841   }

   842 

   843 EGLClientBuffer CastFromImage(Image* aBUffer)

   844   {

   845   return (EGLClientBuffer)(aBUffer);

   846   }

   847 

   848 //==============================================================================================

   849 

   850 }	//namespace OpenVGRI

   851 

   852 using namespace OpenVGRI;

   853 

   854 

   855 

   856 

   857 

   858 /*-------------------------------------------------------------------*//*!

   859 * \brief	

   860 * \param	

   861 * \return	

   862 * \note		

   863 *//*-------------------------------------------------------------------*/

   864 

   865 #ifdef BUILD_WITH_PRIVATE_EGL

   866 RI_APIENTRY EGLint do_eglGetError()

   867 #else

   868 EGLint eglGetError()

   869 #endif

   870 {

   871     OSAcquireMutex();

   872     EGLint ret = EGL_SUCCESS;

   873 	EGL* egl = getEGL();

   874     if(egl)

   875     {

   876         RIEGLThread* thread = egl->getThread();

   877         if(thread)

   878             ret = thread->getError();	//initialized, return error code

   879     }

   880     else ret = EGL_NOT_INITIALIZED;

   881     OSReleaseMutex();

   882     return ret;

   883 }

   884 

   885 /*-------------------------------------------------------------------*//*!

   886 * \brief	

   887 * \param	

   888 * \return	

   889 * \note		

   890 *//*-------------------------------------------------------------------*/

   891 

   892 #ifdef BUILD_WITH_PRIVATE_EGL

   893 RI_APIENTRY EGLDisplay do_eglGetDisplay(EGLNativeDisplayType display_id)

   894 #else

   895 EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)

   896 #endif

   897 {

   898     return OSGetDisplay(display_id);

   899 }

   900 

   901 /*-------------------------------------------------------------------*//*!

   902 * \brief	

   903 * \param	

   904 * \return	

   905 * \note		

   906 *//*-------------------------------------------------------------------*/

   907 

   908 #ifdef BUILD_WITH_PRIVATE_EGL

   909 RI_APIENTRY EGLBoolean do_eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)

   910 #else

   911 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)

   912 #endif

   913 {

   914 	EGL_GET_DISPLAY(dpy, EGL_FALSE);

   915 	EGL_IF_ERROR(display, EGL_SUCCESS, EGL_TRUE);	//already initialized

   916 

   917 	//create the current display

   918 	//if a context and a surface are bound by the time of eglTerminate, they remain bound until eglMakeCurrent is called

   919 	RIEGLDisplay* newDisplay = NULL;

   920 	try

   921 	{

   922 		newDisplay = RI_NEW(RIEGLDisplay, (dpy));	//throws bad_alloc

   923 		egl->addDisplay(newDisplay);	//throws bad_alloc

   924 		display = newDisplay;

   925 		RI_ASSERT(display);

   926 	}

   927 	catch(std::bad_alloc)

   928 	{

   929 		RI_DELETE(newDisplay);

   930 		EGL_RETURN(EGL_BAD_ALLOC, EGL_FALSE);

   931 	}

   932 

   933 	if(major) *major = 1;

   934 	if(minor) *minor = 2;

   935 	EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

   936 }

   937 

   938 /*-------------------------------------------------------------------*//*!

   939 * \brief	

   940 * \param	

   941 * \return	

   942 * \note		

   943 *//*-------------------------------------------------------------------*/

   944 

   945 #ifdef BUILD_WITH_PRIVATE_EGL

   946 RI_APIENTRY EGLBoolean do_eglTerminate(EGLDisplay dpy)

   947 #else

   948 EGLBoolean eglTerminate(EGLDisplay dpy)

   949 #endif

   950 {

   951 	EGL_GET_DISPLAY(dpy, EGL_FALSE);

   952 	EGL_IF_ERROR(!display, EGL_SUCCESS, EGL_TRUE);

   953     egl->removeDisplay(display);

   954     RI_DELETE(display);

   955 	EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

   956 }

   957 

   958 /*-------------------------------------------------------------------*//*!

   959 * \brief	

   960 * \param	

   961 * \return	

   962 * \note		

   963 *//*-------------------------------------------------------------------*/

   964 

   965 #ifdef BUILD_WITH_PRIVATE_EGL

   966 RI_APIENTRY const char *do_eglQueryString(EGLDisplay dpy, EGLint name)

   967 #else

   968 const char *eglQueryString(EGLDisplay dpy, EGLint name)

   969 #endif

   970 {

   971 	EGL_GET_DISPLAY(dpy, NULL);

   972 	EGL_IF_ERROR(!display, EGL_NOT_INITIALIZED, NULL);

   973 

   974 	static const char apis[] = "OpenVG";

   975 	static const char extensions[] = "";

   976 	static const char vendor[] = "Khronos Group";

   977 	static const char version[] = "1.3";

   978 

   979 	const char* ret = NULL;

   980 	switch(name)

   981 	{

   982 	case EGL_CLIENT_APIS:

   983 		ret = apis;

   984 		break;

   985 

   986 	case EGL_EXTENSIONS:

   987 		ret = extensions;

   988 		break;

   989 

   990 	case EGL_VENDOR:

   991 		ret = vendor;

   992 		break;

   993 

   994 	case EGL_VERSION:

   995 		ret = version;

   996 		break;

   997 

   998 	default:

   999 		EGL_RETURN(EGL_BAD_PARAMETER, NULL);

  1000 	}

  1001 	EGL_RETURN(EGL_SUCCESS, ret);

  1002 }

  1003 

  1004 /*-------------------------------------------------------------------*//*!

  1005 * \brief	

  1006 * \param	

  1007 * \return	

  1008 * \note		

  1009 *//*-------------------------------------------------------------------*/

  1010 

  1011 #ifdef BUILD_WITH_PRIVATE_EGL

  1012 RI_APIENTRY EGLBoolean do_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)

  1013 #else

  1014 EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)

  1015 #endif

  1016 {

  1017 	EGL_GET_DISPLAY(dpy, EGL_FALSE);

  1018 	EGL_IF_ERROR(!display, EGL_NOT_INITIALIZED, EGL_FALSE);

  1019 	EGL_IF_ERROR(!num_config, EGL_BAD_PARAMETER, EGL_FALSE);

  1020 	if(!configs)

  1021 	{

  1022 		*num_config = display->getNumConfigs();

  1023 		EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

  1024 	}

  1025 	*num_config = RI_INT_MIN(config_size, display->getNumConfigs());

  1026 	for(int i=0;i<*num_config;i++)

  1027 		configs[i] = display->getConfigByIdx(i).m_config;

  1028 

  1029 	EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

  1030 }

  1031 

  1032 /*-------------------------------------------------------------------*//*!

  1033 * \brief	

  1034 * \param	

  1035 * \return	

  1036 * \note		

  1037 *//*-------------------------------------------------------------------*/

  1038 

  1039 static bool smaller(EGLint c, EGLint filter)

  1040 {

  1041 	return (filter != EGL_DONT_CARE) && (c < filter);

  1042 }

  1043 

  1044 #ifdef BUILD_WITH_PRIVATE_EGL

  1045 RI_APIENTRY EGLBoolean do_eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)

  1046 #else

  1047 EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)

  1048 #endif

  1049 {

  1050 	EGL_GET_DISPLAY(dpy, EGL_FALSE);

  1051 	EGL_IF_ERROR(!display, EGL_NOT_INITIALIZED, EGL_FALSE);

  1052 	EGL_IF_ERROR(!num_config, EGL_BAD_PARAMETER, EGL_FALSE);

  1053 

  1054 	if(!configs)

  1055 	{

  1056 		*num_config = display->getNumConfigs();

  1057 		EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

  1058 	}

  1059 	*num_config = 0;

  1060 	if(!config_size)

  1061 		EGL_RETURN(EGL_SUCCESS, EGL_TRUE);

  1062 

  1063 	int bufferSize = 0;

  1064 	int redSize = 0;

  1065 	int greenSize = 0;

  1066 	int blueSize = 0;

  1067 	int luminanceSize = 0;

  1068 	int alphaSize = 0;

  1069 	int colorBufferType = EGL_RGB_BUFFER;

  1070 	int configID = EGL_DONT_CARE;

  1071 	int sampleBuffers = 0;

  1072 	int samples = 0;

  1073 	if(attrib_list)

  1074 	{

  1075 		for(int i=0;attrib_list[i] != EGL_NONE;i+=2)

  1076 		{

  1077 			switch(attrib_list[i])

  1078 			{

  1079 			case EGL_BUFFER_SIZE:				//depth of the color buffer

  1080 				bufferSize = attrib_list[i+1];

  1081 				break;

  1082 			case EGL_RED_SIZE:					//bits of Red in the color buffer

  1083 				redSize = attrib_list[i+1];

  1084 				break;

  1085 			case EGL_GREEN_SIZE:				//bits of Green in the color buffer

  1086 				greenSize = attrib_list[i+1];

  1087 				break;

  1088 			case EGL_BLUE_SIZE:					//bits of Blue in the color buffer

  1089 				blueSize = attrib_list[i+1];

  1090 				break;

  1091 			case EGL_LUMINANCE_SIZE:			//bits of Luminance in the color buffer

  1092 				luminanceSize = attrib_list[i+1];

  1093 				break;

  1094 			case EGL_ALPHA_SIZE:				//bits of Alpha in the color buffer

  1095 				alphaSize = attrib_list[i+1];

  1096 				break;

  1097 			case EGL_ALPHA_MASK_SIZE:			//bits of Alpha in the alpha mask buffer

  1098 				if(attrib_list[i+1] > 8)

  1099 					EGL_RETURN(EGL_SUCCESS, EGL_TRUE);	//not supported

  1100 				break;

  1101 			case EGL_COLOR_BUFFER_TYPE:			//enum color buffer type (EGL_RGB_BUFFER, EGL_LUMINANCE_BUFFER)

  1102 				EGL_IF_ERROR(attrib_list[i+1] != EGL_RGB_BUFFER && attrib_list[i+1] != EGL_LUMINANCE_BUFFER && attrib_list[i+1] != EGL_DONT_CARE, EGL_BAD_ATTRIBUTE, EGL_FALSE);

  1103 				colorBufferType = attrib_list[i+1];

  1104 				break;

  1105 			case EGL_CONFIG_ID:					//unique EGLConfig identifier

  1106 				configID = attrib_list[i+1];

  1107 				break;

  1108 

  1109 			case EGL_SAMPLE_BUFFERS:			//integer number of multisample buffers

  1110 				sampleBuffers = attrib_list[i+1];

  1111 				break;

  1112 			case EGL_SAMPLES:					//integer number of samples per pixel

  1113 				samples = attrib_list[i+1];

  1114 				break;

  1115 

  1116 			case EGL_BIND_TO_TEXTURE_RGB:		//boolean True if bindable to RGB textures. (always EGL_FALSE)

  1117 			case EGL_BIND_TO_TEXTURE_RGBA:		//boolean True if bindable to RGBA textures. (always EGL_FALSE)

  1118 			case EGL_DEPTH_SIZE:				//integer bits of Z in the depth buffer (always 0)

  1119 			case EGL_LEVEL:						//integer frame buffer level (always 0)

  1120 			case EGL_NATIVE_RENDERABLE:			//boolean EGL TRUE if native rendering APIs can render to surface (always EGL_FALSE)

  1121 			case EGL_STENCIL_SIZE:				//integer bits of Stencil in the stencil buffer (always 0)

  1122 				if(attrib_list[i+1])

  1123 					EGL_RETURN(EGL_SUCCESS, EGL_TRUE);	//not supported

  1124 				break;

  1125 

  1126 			case EGL_CONFIG_CAVEAT:				//enum any caveats for the configuration (always EGL_NONE)

  1127 			case EGL_NATIVE_VISUAL_TYPE:		//integer native visual type of the associated visual (always EGL_NONE)

  1128 				if(attrib_list[i+1] != EGL_NONE)

  1129 					EGL_RETURN(EGL_SUCCESS, EGL_TRUE);	//not supported

  1130 				break;

  1131 

  1132 			case EGL_MAX_SWAP_INTERVAL:			//integer maximum swap interval (always 1)

  1133 			case EGL_MIN_SWAP_INTERVAL:			//integer minimum swap interval (always 1)