/*------------------------------------------------------------------------

 *

 * EGL 1.3

 * -------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 *

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

 * copy of this software and /or associated documentation files

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

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

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

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

 * subject to the following conditions: 

 *

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

 * in all copies or substantial portions of the Materials. 

 *

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

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

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

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

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

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

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 *//**

 * \file

 * \brief	Simple implementation of EGL 1.3

 * \note	caveats:

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

			- no native Windows or Mac OS X pixmap support

			- no power management events

			- no support for swap interval

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

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

 *//*-------------------------------------------------------------------*/

//#include "riMiniEGL.h"

#include "eglprivate.h"

#include "riMath.h"

#include <e32debug.h>

//==============================================================================================

namespace OpenVGRI

{

void* OSGetCurrentThreadID(void);

void OSAcquireMutex(void);

void OSReleaseMutex(void);

void OSDeinitMutex(void);

EGLDisplay OSGetDisplay(EGLNativeDisplayType display_id);

void* OSCreateWindowContext(EGLNativeWindowType window);

void OSDestroyWindowContext(void* context);

bool OSIsWindow(const void* context);

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

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

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

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

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLContext

{

public:

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

	~RIEGLContext();

	void	addReference()				{ m_referenceCount++; }

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

    VGContext*      getVGContext() const      { return m_vgContext; }

    EGLConfig getConfig() const         { return m_config; }

private:

	RIEGLContext(const RIEGLContext&);

	RIEGLContext& operator=(const RIEGLContext&);

	VGContext*		m_vgContext;

	const EGLConfig	m_config;

	int				m_referenceCount;

};

RIEGLContext* CastToRIEGLContext(EGLContext aCtxId);

EGLContext CastFromRIEGLContext(RIEGLContext* aCtx);

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

	m_vgContext(vgctx),

	m_config(config),

	m_referenceCount(0)

{

}

RIEGLContext::~RIEGLContext()

{

	RI_ASSERT(m_referenceCount == 0);

	RI_DELETE(m_vgContext);

}

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

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLSurface

{

public:

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

	~RIEGLSurface();

	void	addReference()				{ m_referenceCount++; }

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

    void*           getOSWindowContext() const { return m_OSWindowContext; }

    EGLConfig       getConfig() const          { return m_config; }

    Drawable*       getDrawable() const        { return m_drawable; }

    bool            isLargestPbuffer() const   { return m_largestPbuffer; }

    int             getRenderBuffer() const    { return m_renderBuffer; }

private:

	RIEGLSurface(const RIEGLSurface&);

	RIEGLSurface& operator=(const RIEGLSurface&);

    void*            m_OSWindowContext;

	const EGLConfig	 m_config;

	Drawable*        m_drawable;

	bool			 m_largestPbuffer;

	int				 m_renderBuffer;		//EGL_BACK_BUFFER or EGL_SINGLE_BUFFER

	int				 m_referenceCount;

};

RIEGLSurface* CastToRIEGLSurface(EGLSurface aSurfaceId);

EGLSurface CastFromRIEGLSurface(RIEGLSurface* aSurface);

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

    m_OSWindowContext(OSWindowContext),

	m_config(config),

	m_drawable(drawable),

	m_largestPbuffer(largestPbuffer),

	m_renderBuffer(renderBuffer),

	m_referenceCount(0)

{

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

    m_drawable->addReference();

}

RIEGLSurface::~RIEGLSurface()

{

	RI_ASSERT(m_referenceCount == 0);

    OSDestroyWindowContext(m_OSWindowContext);

	if(m_drawable)

	{

		if(!m_drawable->removeReference())

			RI_DELETE(m_drawable);

	}

}

RIEGLDisplay::RIEGLDisplay(EGLDisplay id) :

	m_id(id),

	m_contexts(),

	m_surfaces()

{

	RI_ASSERT(EGL_NUMCONFIGS == 60);

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

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

	//NOTE: config IDs start from 1

	//               R  B  G  A  L  bpp samples maskBits ID

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    //configs without mask

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*

attrib                default        criteria order   priority

--------------------------------------------------------------

EGL_COLOR_BUFFER_TYPE EGL_RGB_BUFFER Exact    None    2 

EGL_RED_SIZE          0              AtLeast  Special 3 

EGL_GREEN_SIZE        0              AtLeast  Special 3 

EGL_BLUE_SIZE         0              AtLeast  Special 3 

EGL_LUMINANCE_SIZE    0              AtLeast  Special 3 

EGL_ALPHA_SIZE        0              AtLeast  Special 3 

EGL_BUFFER_SIZE       0              AtLeast  Smaller 4 

EGL_CONFIG_ID         EGL_DONT_CARE  Exact    Smaller 11

*/

}

RIEGLDisplay::~RIEGLDisplay()

{

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

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

	{

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

			RI_DELETE(m_contexts[i]);

	}

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

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

	{

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

			RI_DELETE(m_surfaces[i]);

	}

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

}

EGLBoolean RIEGLDisplay::contextExists(const EGLContext ctx) const

{

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

	{

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

			return EGL_TRUE;

	}

	return EGL_FALSE;

}

EGLBoolean RIEGLDisplay::surfaceExists(const EGLSurface surf) const

{

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

	{

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

			return EGL_TRUE;

	}

	return EGL_FALSE;

}

EGLBoolean RIEGLDisplay::configExists(const EGLConfig config) const

{

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

    {

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

		return EGL_TRUE;

    }

	return EGL_FALSE;

}

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

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

class RIEGLThread

{

public:

	RIEGLThread(void* currentThreadID);

	~RIEGLThread();

    void*           getThreadID() const       { return m_threadID; }

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

	RIEGLContext*	getCurrentContext() const   { return m_context; }

	RIEGLSurface*	getCurrentSurface() const   { return m_surface; }

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

    EGLint          getError() const            { return m_error; }

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

    EGLint          getBoundAPI() const         { return m_boundAPI; }

private:

	RIEGLThread(const RIEGLThread&);

	RIEGLThread operator=(const RIEGLThread&);

	RIEGLContext*		m_context;

	RIEGLSurface*		m_surface;

	EGLint              m_error;

	void*               m_threadID;

	EGLint              m_boundAPI;

};

RIEGLThread::RIEGLThread(void* currentThreadID) :

	m_context(NULL),

	m_surface(NULL),

	m_error(EGL_SUCCESS),

	m_threadID(currentThreadID),

	m_boundAPI(EGL_NONE)

{

}

RIEGLThread::~RIEGLThread()

{

}

Image* CastToImage(EGLClientBuffer aBufferId);

EGLClientBuffer CastFromImage(Image* aBUffer);

EGL::EGL() :

	m_threads(),

	m_currentThreads(),

	m_displays(),

	m_referenceCount(0)

{

}

EGL::~EGL()

{

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

	{

		RI_DELETE(m_displays[i]);

	}

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

	{

		RI_DELETE(m_threads[i]);

	}

	//currentThreads contain just pointers to threads we just deleted

}

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

* \brief	

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

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

EGL* getEGL()

{

	/*if(!g_egl)

	{

		try

		{

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

			g_egl->addReference();

		}

		catch(std::bad_alloc)

		{

			g_egl = NULL;

		}

	}

	return g_egl;

	*/

	//use TLS to store static global g_egl

	EGL* pEgl = NULL;

	CEglThreadSession* es = reinterpret_cast<CEglThreadSession*>(Dll::Tls());

	if (es)

		{

		return es->getEgl();

		}

	const TInt err = CEglDriver::Open();

	if (err != KErrNone)

		{

		return NULL;

		}

	// CEglDriver is reference counted. As we successfuly open the driver, pls.iDriver will be non-null

	// and it should be safe to cache the pointer inside CEglThreadSession

	CEglDriver* drv = CEglDriver::GetDriver();

	__ASSERT_DEBUG(drv, User::Panic(KEglPanicCategory, EEglPanicDriverNull));

	// create session object on default thread's heap

	es = new CEglThreadSession(*drv);

	if (!es || Dll::SetTls(es)!= KErrNone)

		{

		delete es;

		return NULL;

		}

	return es->getEgl();

}

static void releaseEGL()

{

/*

	if(g_egl)

	{

		if(!g_egl->removeReference())

		{

			RI_DELETE(g_egl);

			g_egl = NULL;

		}

	}

	*/

	CEglThreadSession* es = reinterpret_cast<CEglThreadSession*>(Dll::Tls());

	if (es)

		{

		delete es;

		}

	Dll::SetTls(NULL);

}

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

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

*			if the ID hasn't been initialized.

* \param	

* \return	

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

*			be found from egl->m_displays

*//*-------------------------------------------------------------------*/

RIEGLDisplay* EGL::getDisplay(EGLDisplay displayID) const

{

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

	{

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

			return m_displays[i];

	}

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

}

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

* \brief	return EGLDisplay for the current context

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

EGLDisplay EGL::findDisplay(EGLContext ctx) const

{

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

	{

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

            return m_displays[i]->getID();

	}

    return EGL_NO_DISPLAY;

}

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

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

*            NULL if there's no current context.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/