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

 *

 * 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 <e32debug.h>

namespace OpenVGRI

{

//using namespace OpenVGRI;

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		

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

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;

	}

RIEGLThread::RIEGLThread(void* currentThreadID) :

	m_context(NULL), m_surface(NULL), m_error(EGL_SUCCESS), m_threadID(

			currentThreadID), m_boundAPI(EGL_NONE)

	{

	}

RIEGLThread::~RIEGLThread()

	{

	}

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();

	//TODO do we need to associate EGL with session here Jose

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

		{

		//create TLS instance

		pEgl = RI_NEW(EGL, ());

		RDebug::Printf("---------- In getEGL()::Static(),Addr of pEgl Ptr = %x\n", &pEgl);

		RDebug::Printf("---------- In getEGL()::Static(),Addr of pEgl= %x\n", pEgl);

		//RDebug::Printf("In CEglThreadSession::Static(),Thread Id %Lu",(RThread().Id().Id()));

		RDebug::Printf("---------- In getEGL()::Static(),Thread Id %Lu",(RThread().Id()));

		Dll::SetTls(pEgl);

		}*/

	//return pEgl;

	}

static void releaseEGL()

	{

	/*

	 if(g_egl)

	 {

	 if(!g_egl->removeReference())

	 {

	 RI_DELETE(g_egl);

	 g_egl = NULL;

	 }

	 }

	 */

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

	if (pEgl)

		delete pEgl;

	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		

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

RIEGLThread* EGL::getCurrentThread() const

	{

	void* currentThreadID = OSGetCurrentThreadID();

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

		{

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

			return m_currentThreads[i];

		}

	return NULL; //thread is not current

	}

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

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

 * \param	

 * \return	

 * \note		

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

RIEGLThread* EGL::getThread()

	{

	void* currentThreadID = OSGetCurrentThreadID();

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

		{

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

			return m_threads[i];

		}

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

	RIEGLThread* newThread = NULL;

	try

		{

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

		m_threads.push_back(newThread); //throws bad_alloc

		return newThread;

		}

	catch (std::bad_alloc)

		{

		RI_DELETE(newThread);

		return NULL;

		}

	}

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

 * \brief	destroy an EGL thread struct

 * \param	

 * \return	

 * \note		

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

void EGL::destroyThread()

	{

	void* currentThreadID = OSGetCurrentThreadID();

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

		{

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

			{

			RIEGLThread* thread = m_threads[i];

			bool res = m_threads.remove(thread);

			RI_ASSERT(res);

			RI_UNREF(res);

			RI_DELETE(thread);

			break;

			}

		}

	}

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

 * \brief	

 * \param	

 * \return	

 * \note		

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

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

	{

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

		{

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

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

			return true;

		}

	return false;

	}

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

static void eglSetError(EGL* egl, EGLint error)

	{

	RIEGLThread* thread = egl->getThread();

	if (thread)

		thread->setError(error);

	}

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

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

 * \param	

 * \return	

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

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

void* eglvgGetCurrentVGContext(void)

	{

	EGL* egl = getEGL();

/*	RDebug::Printf(" \n");

	RDebug::Printf(" \n");

	RDebug::Printf(" \n");

	RDebug::Printf(" $$$$$$$$$$$$$ I am in function eglvgGetCurrentVGContext $$$$$$$$$$$$$$$$$\n");

	RDebug::Printf(" $$$$$$$$$$$$$ In eglvgGetCurrentVGContext,Thread Id %Lu  $$$$$$$$$$$$$ ",(RThread().Id()));*/

	if (egl)

		{

		RIEGLThread* thread = egl->getCurrentThread();

		//RDebug::Printf(" $$$$$$$$$$$$$ I am in function eglvgGetCurrentVGContext.EGL addr is %x = \n",egl);

		if (thread)

			{

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

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

			}

		}

	return NULL; //not initialized or made current

	}

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

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

 * \param	

 * \return	

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

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

bool eglvgIsInUse(void* image)

	{

	EGL* egl = getEGL();

	if (egl)

		{

		return egl->isInUse(image);

		}

	return false;

	}

 //helper functions

 RIEGLContext* CastToRIEGLContext(EGLContext aCtxId)

 {

 return (RIEGLContext*)(aCtxId);

 }