// Copyright (c) 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:

// Reference EGL implementation to support EGL sync objects and OpenWF extensions

#include "eglprivate.h"

#include <e32debug.h>

// Helper macros

//

#define GET_THREAD_SESSION(s,r) CEglThreadSession* s = CEglThreadSession::Static(); \

                                if (!s) \

                                    { \

                                    return r; \

                                    }

#define PANIC_NOT_SUPPORTED     RDebug::Printf("EGL Panic %s %s:%d\n",__func__,__FILE__,__LINE__);User::Panic(KEglPanicCategory, EEglPanicNotSupported); \

                                return 0;

// EGL API entrypoints

//

EXPORT_C EGLDisplay eglGetDisplay(NativeDisplayType display_id)

	{

	GET_THREAD_SESSION(session, EGL_NO_DISPLAY)

	return session->EglGetDisplay(display_id);

	}

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

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglInitialize(dpy, major, minor);

	}

EXPORT_C EGLBoolean eglTerminate(EGLDisplay dpy)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglTerminate(dpy);

	}

EXPORT_C EGLBoolean eglReleaseThread(void)

	{

	// do not call CEglThreadSession::Static() here as it may create thread state if it does not exist

	//

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

	if (session)

		{

		delete session;

		Dll::FreeTls();

		}

	return EGL_TRUE;

	}

EXPORT_C EGLint eglGetError(void)

	{

	// EGL spec section 3.11: GetError will create thread state object, 

	// it is recommended not to call this API immediately after calling ReleaseThread

	// for that reason.

	// If session creation fails, we returns BAD_ALLOC

	//

	GET_THREAD_SESSION(session, EGL_BAD_ALLOC)

	return session->EglGetError();

	}

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

	{

	GET_THREAD_SESSION(session, NULL)

	return session->EglQueryString(dpy, name);

	}

typedef void (*eglfPtr)(...);

EXPORT_C TFuncPtrEglProc eglGetProcAddress (const char *procname)

	{

	GET_THREAD_SESSION(session, NULL)

	return session->EglGetProcAddress(procname);

	//eglfPtr pname = do_eglGetProcAddress(procname);

	//return pname;

	}

// Unsupported EGL APIs

//

EXPORT_C EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,

			 EGLint config_size, EGLint *num_config)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglGetConfigs(dpy, configs,config_size, num_config);

	}

EXPORT_C EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,

			        EGLConfig *configs, EGLint config_size,EGLint *num_config)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglChooseConfig(dpy, attrib_list,configs, config_size,num_config);

	}

EXPORT_C EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,

									   EGLint attribute, EGLint *value)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglGetConfigAttrib(dpy, config,attribute,value);

	}

EXPORT_C EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win,

		                                   const EGLint *attrib_list)

	{

	GET_THREAD_SESSION(session, EGL_NO_SURFACE)

	return session->EglCreateWindowSurface(dpy, config,win,attrib_list);

	}

EXPORT_C EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,

				   const EGLint *attrib_list)

	{

	GET_THREAD_SESSION(session, EGL_NO_SURFACE)

	return session->EglCreatePbufferSurface(dpy, config,attrib_list);

	}

EXPORT_C EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,

				  EGLNativePixmapType pixmap,

				  const EGLint *attrib_list)

	{

	GET_THREAD_SESSION(session, EGL_NO_SURFACE)

	return session->EglCreatePixmapSurface(dpy, config,pixmap,attrib_list);

	}

EXPORT_C EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglDestroySurface(dpy, surface);

	}

EXPORT_C EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface,

			   EGLint attribute, EGLint *value)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglQuerySurface(dpy, surface,attribute, value);

	}

EXPORT_C EGLBoolean eglBindAPI(EGLenum api)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglBindAPI(api);

	}

EXPORT_C EGLenum eglQueryAPI(void)

	{

	GET_THREAD_SESSION(session, EGL_NONE)

	return session->EglQueryAPI();

	}

EXPORT_C EGLBoolean eglWaitClient(void)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglWaitClient();

	}

EXPORT_C EGLSurface eglCreatePbufferFromClientBuffer(

	      EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,

	      EGLConfig config, const EGLint *attrib_list)

	{

	GET_THREAD_SESSION(session, EGL_NO_SURFACE)

	return session->EglCreatePbufferFromClientBuffer(dpy, buftype, buffer,config, attrib_list);

	}

EXPORT_C EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,

			    EGLint attribute, EGLint value)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglSurfaceAttrib(dpy, surface,attribute, value);

	}

EXPORT_C EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglBindTexImage(dpy, surface, buffer);

	}

EXPORT_C EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglReleaseTexImage(dpy, surface, buffer);

	}

EXPORT_C EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglSwapInterval(dpy, interval);

	}

EXPORT_C EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,

			    EGLContext share_context,

			    const EGLint *attrib_list)

	{

	GET_THREAD_SESSION(session, EGL_NO_CONTEXT)

	return session->EglCreateContext(dpy, config,share_context,attrib_list);

	}

EXPORT_C EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglDestroyContext(dpy, ctx);

	}

EXPORT_C EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,

			  EGLSurface read, EGLContext ctx)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglMakeCurrent(dpy, draw,read, ctx);

	}

EXPORT_C EGLContext eglGetCurrentContext(void)

	{

	GET_THREAD_SESSION(session, EGL_NO_CONTEXT)

	return session->EglGetCurrentContext();

	}

EXPORT_C EGLSurface eglGetCurrentSurface(EGLint readdraw)

	{

	GET_THREAD_SESSION(session, EGL_NO_SURFACE)

	return session->EglGetCurrentSurface(readdraw);

	}

EXPORT_C EGLDisplay eglGetCurrentDisplay(void)

	{

	GET_THREAD_SESSION(session, EGL_NO_DISPLAY)

	return session->EglGetCurrentDisplay();

	}

EXPORT_C EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx,

			   EGLint attribute, EGLint *value)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglQueryContext(dpy, ctx,attribute, value);

	}

EXPORT_C EGLBoolean eglWaitGL(void)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglWaitGL();

	}

EXPORT_C EGLBoolean eglWaitNative(EGLint engine)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglWaitNative(engine);

	}

EXPORT_C EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglSwapBuffers(dpy, surface);

	}

EXPORT_C EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,

			  EGLNativePixmapType target)

	{

	GET_THREAD_SESSION(session, EGL_FALSE)

	return session->EglCopyBuffers(dpy, surface,target);

	}

// EGL_KHR_reusable_sync APIs

//

EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)

    {

    GET_THREAD_SESSION(session, EGL_NO_SYNC_KHR)

    return session->EglCreateSyncKhr(dpy, type, attrib_list);

    }

EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)

    {

    GET_THREAD_SESSION(session, EGL_FALSE)

    return session->EglDestroySyncKhr(dpy, sync);

    }

EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)

    {

    GET_THREAD_SESSION(session, EGL_FALSE)

    return session->EglClientWaitSyncKhr(dpy, sync, flags, timeout);

    }

EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)

    {

    GET_THREAD_SESSION(session, EGL_FALSE)

    return session->EglSignalSyncKhr(dpy, sync, mode);

    }

EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)

    {

    GET_THREAD_SESSION(session, EGL_FALSE)

    return session->EglGetSyncAttribKhr(dpy, sync, attribute, value);

    }

// Private extensions

//

EGLint egl_Private_SignalSyncNOK(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)

    {

    GET_THREAD_SESSION(session, EGL_BAD_ALLOC)

    return session->EglSignalSyncInternal(dpy, sync, mode);

    }

// Debug APIs

//

#ifdef _DEBUG

#define GET_THREAD_SESSION_ASSERT(s)    CEglThreadSession* s = CEglThreadSession::Static(); \

                                        __ASSERT_DEBUG(s, User::Panic(KEglPanicCategory, EEglPanicInvalidSession));

void egliDebugHeapMarkStart()

    {

    GET_THREAD_SESSION_ASSERT(session)

    session->EglHeapMarkStart();

    }

EGLint egliDebugHeapMarkEnd(EGLint count)

    {

    GET_THREAD_SESSION_ASSERT(session)    

    return session->EglHeapMarkEnd(count);

    }

void egliDebugSetBurstAllocFail(EGLenum type, EGLint rate, EGLint burst)

    {

    GET_THREAD_SESSION_ASSERT(session)

    session->EglHeapSetBurstAllocFail(type, rate, burst);

}

#endif //_DEBUG