// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// main.cpp: DLL entry point and management of thread-local data.

#include "main.h"

#include "libEGL.hpp"
#include "Context.hpp"
#include "Surface.hpp"
#include "Display.h"

#include "resource.h"
#include "Common/Thread.hpp"
#include "Common/SharedLibrary.hpp"
#include "common/debug.h"

#include <EGL/eglext.h>

static sw::Thread::LocalStorageKey currentTLS = TLS_OUT_OF_INDEXES;

#if !defined(_MSC_VER)
#define CONSTRUCTOR __attribute__((constructor))
#define DESTRUCTOR __attribute__((destructor))
#else
#define CONSTRUCTOR
#define DESTRUCTOR
#endif

namespace egl
{
void releaseCurrent(void *storage)
{
	// This pthread destructor is called after the TLS is already reset to NULL,
	// so we can't call EGL functions here to do the cleanup.

	Current *current = (Current*)storage;

	if(current)
	{
		if(current->drawSurface)
		{
			current->drawSurface->release();
		}

		if(current->readSurface)
		{
			current->readSurface->release();
		}

		if(current->context)
		{
			current->context->release();
		}

		free(current);
	}
}

Current *attachThread()
{
	TRACE("()");

	if(currentTLS == TLS_OUT_OF_INDEXES)
	{
		currentTLS = sw::Thread::allocateLocalStorageKey(releaseCurrent);
	}

	Current *current = (Current*)sw::Thread::allocateLocalStorage(currentTLS, sizeof(Current));

	current->error = EGL_SUCCESS;
	current->API = EGL_OPENGL_ES_API;
	current->context = nullptr;
	current->drawSurface = nullptr;
	current->readSurface = nullptr;

	return current;
}

void detachThread()
{
	TRACE("()");

	eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);

	sw::Thread::freeLocalStorage(currentTLS);
}

CONSTRUCTOR void attachProcess()
{
	TRACE("()");

	#if !defined(ANGLE_DISABLE_TRACE) && defined(TRACE_OUTPUT_FILE)
		FILE *debug = fopen(TRACE_OUTPUT_FILE, "rt");

		if(debug)
		{
			fclose(debug);
			debug = fopen(TRACE_OUTPUT_FILE, "wt");   // Erase
			fclose(debug);
		}
	#endif

	attachThread();
}

DESTRUCTOR void detachProcess()
{
	TRACE("()");

	detachThread();
	sw::Thread::freeLocalStorageKey(currentTLS);
}
}

#if defined(_WIN32)
#ifdef DEBUGGER_WAIT_DIALOG
static INT_PTR CALLBACK DebuggerWaitDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	RECT rect;

	switch(uMsg)
	{
	case WM_INITDIALOG:
		GetWindowRect(GetDesktopWindow(), &rect);
		SetWindowPos(hwnd, HWND_TOP, rect.right / 2, rect.bottom / 2, 0, 0, SWP_NOSIZE);
		SetTimer(hwnd, 1, 100, NULL);
		return TRUE;
	case WM_COMMAND:
		if(LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hwnd, 0);
		}
		break;
	case WM_TIMER:
		if(IsDebuggerPresent())
		{
			EndDialog(hwnd, 0);
		}
	}

	return FALSE;
}

static void WaitForDebugger(HINSTANCE instance)
{
	if(!IsDebuggerPresent())
	{
		HRSRC dialog = FindResource(instance, MAKEINTRESOURCE(IDD_DIALOG1), RT_DIALOG);
		DLGTEMPLATE *dialogTemplate = (DLGTEMPLATE*)LoadResource(instance, dialog);
		DialogBoxIndirect(instance, dialogTemplate, NULL, DebuggerWaitDialogProc);
	}
}
#endif

extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
{
	switch(reason)
	{
	case DLL_PROCESS_ATTACH:
		#ifdef DEBUGGER_WAIT_DIALOG
		{
			char disable_debugger_wait_dialog[] = "0";
			GetEnvironmentVariable("SWIFTSHADER_DISABLE_DEBUGGER_WAIT_DIALOG", disable_debugger_wait_dialog, sizeof(disable_debugger_wait_dialog));

			if(disable_debugger_wait_dialog[0] != '1')
			{
				WaitForDebugger(instance);
			}
		}
		#endif
		egl::attachProcess();
		break;
	case DLL_THREAD_ATTACH:
		egl::attachThread();
		break;
	case DLL_THREAD_DETACH:
		egl::detachThread();
		break;
	case DLL_PROCESS_DETACH:
		egl::detachProcess();
		break;
	default:
		break;
	}

	return TRUE;
}
#endif

namespace egl
{
static Current *getCurrent(void)
{
	Current *current = (Current*)sw::Thread::getLocalStorage(currentTLS);

	if(!current)
	{
		current = attachThread();
	}

	return current;
}

void setCurrentError(EGLint error)
{
	Current *current = getCurrent();

	current->error = error;
}

EGLint getCurrentError()
{
	Current *current = getCurrent();

	return current->error;
}

void setCurrentAPI(EGLenum API)
{
	Current *current = getCurrent();

	current->API = API;
}

EGLenum getCurrentAPI()
{
	Current *current = getCurrent();

	return current->API;
}

void setCurrentContext(egl::Context *ctx)
{
	Current *current = getCurrent();

	if(ctx)
	{
		ctx->addRef();
	}

	if(current->context)
	{
		current->context->release();
	}

	current->context = ctx;
}

NO_SANITIZE_FUNCTION egl::Context *getCurrentContext()
{
	Current *current = getCurrent();

	return current->context;
}

void setCurrentDrawSurface(egl::Surface *surface)
{
	Current *current = getCurrent();

	if(surface)
	{
		surface->addRef();
	}

	if(current->drawSurface)
	{
		current->drawSurface->release();
	}

	current->drawSurface = surface;
}

egl::Surface *getCurrentDrawSurface()
{
	Current *current = getCurrent();

	return current->drawSurface;
}

void setCurrentReadSurface(egl::Surface *surface)
{
	Current *current = getCurrent();

	if(surface)
	{
		surface->addRef();
	}

	if(current->readSurface)
	{
		current->readSurface->release();
	}

	current->readSurface = surface;
}

egl::Surface *getCurrentReadSurface()
{
	Current *current = getCurrent();

	return current->readSurface;
}

void error(EGLint errorCode)
{
	egl::setCurrentError(errorCode);

	if(errorCode != EGL_SUCCESS)
	{
		switch(errorCode)
		{
		case EGL_NOT_INITIALIZED:     TRACE("\t! Error generated: not initialized\n");     break;
		case EGL_BAD_ACCESS:          TRACE("\t! Error generated: bad access\n");          break;
		case EGL_BAD_ALLOC:           TRACE("\t! Error generated: bad alloc\n");           break;
		case EGL_BAD_ATTRIBUTE:       TRACE("\t! Error generated: bad attribute\n");       break;
		case EGL_BAD_CONFIG:          TRACE("\t! Error generated: bad config\n");          break;
		case EGL_BAD_CONTEXT:         TRACE("\t! Error generated: bad context\n");         break;
		case EGL_BAD_CURRENT_SURFACE: TRACE("\t! Error generated: bad current surface\n"); break;
		case EGL_BAD_DISPLAY:         TRACE("\t! Error generated: bad display\n");         break;
		case EGL_BAD_MATCH:           TRACE("\t! Error generated: bad match\n");           break;
		case EGL_BAD_NATIVE_PIXMAP:   TRACE("\t! Error generated: bad native pixmap\n");   break;
		case EGL_BAD_NATIVE_WINDOW:   TRACE("\t! Error generated: bad native window\n");   break;
		case EGL_BAD_PARAMETER:       TRACE("\t! Error generated: bad parameter\n");       break;
		case EGL_BAD_SURFACE:         TRACE("\t! Error generated: bad surface\n");         break;
		case EGL_CONTEXT_LOST:        TRACE("\t! Error generated: context lost\n");        break;
		default:                      TRACE("\t! Error generated: <0x%X>\n", errorCode);   break;
		}
	}
}

sw::RecursiveLock *getDisplayLock(EGLDisplay dpy)
{
	auto display = Display::get(dpy);
	if (!display) return nullptr;
	return display->getLock();
}
}

namespace egl
{
EGLint EGLAPIENTRY GetError(void);
EGLDisplay EGLAPIENTRY GetDisplay(EGLNativeDisplayType display_id);
EGLBoolean EGLAPIENTRY Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLBoolean EGLAPIENTRY Terminate(EGLDisplay dpy);
const char *EGLAPIENTRY QueryString(EGLDisplay dpy, EGLint name);
EGLBoolean EGLAPIENTRY GetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLBoolean EGLAPIENTRY ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLBoolean EGLAPIENTRY GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
EGLSurface EGLAPIENTRY CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY DestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLBoolean EGLAPIENTRY QuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY BindAPI(EGLenum api);
EGLenum EGLAPIENTRY QueryAPI(void);
EGLBoolean EGLAPIENTRY WaitClient(void);
EGLBoolean EGLAPIENTRY ReleaseThread(void);
EGLSurface EGLAPIENTRY CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean EGLAPIENTRY BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean EGLAPIENTRY ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean EGLAPIENTRY SwapInterval(EGLDisplay dpy, EGLint interval);
EGLContext EGLAPIENTRY CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
EGLBoolean EGLAPIENTRY DestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
EGLContext EGLAPIENTRY GetCurrentContext(void);
EGLSurface EGLAPIENTRY GetCurrentSurface(EGLint readdraw);
EGLDisplay EGLAPIENTRY GetCurrentDisplay(void);
EGLBoolean EGLAPIENTRY QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY WaitGL(void);
EGLBoolean EGLAPIENTRY WaitNative(EGLint engine);
EGLBoolean EGLAPIENTRY SwapBuffers(EGLDisplay dpy, EGLSurface surface);
EGLBoolean EGLAPIENTRY CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
EGLImageKHR EGLAPIENTRY CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
EGLBoolean EGLAPIENTRY DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);
EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list);
EGLDisplay EGLAPIENTRY GetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
EGLSurface EGLAPIENTRY CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
EGLSyncKHR EGLAPIENTRY CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
EGLSyncKHR EGLAPIENTRY CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
EGLBoolean EGLAPIENTRY DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
EGLint EGLAPIENTRY ClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
EGLBoolean EGLAPIENTRY GetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
EGLBoolean EGLAPIENTRY GetSyncAttrib(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLAttrib *value);
__eglMustCastToProperFunctionPointerType EGLAPIENTRY GetProcAddress(const char *procname);
}

extern "C"
{
EGLAPI EGLint EGLAPIENTRY eglGetError(void)
{
	return egl::GetError();
}

EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
{
	return egl::GetDisplay(display_id);
}

EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::Initialize(dpy, major, minor);
}

EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::Terminate(dpy);
}

EGLAPI const char *EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::QueryString(dpy, name);
}

EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::GetConfigs(dpy, configs, config_size, num_config);
}

EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
}

EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::GetConfigAttrib(dpy, config, attribute, value);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType window, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateWindowSurface(dpy, config, window, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePbufferSurface(dpy, config, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroySurface(dpy, surface);
}

EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::QuerySurface(dpy, surface, attribute, value);
}

EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
{
	return egl::BindAPI(api);
}

EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void)
{
	return egl::QueryAPI();
}

EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void)
{
	return egl::WaitClient();
}

EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void)
{
	return egl::ReleaseThread();
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
}

EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::SurfaceAttrib(dpy, surface, attribute, value);
}

EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::BindTexImage(dpy, surface, buffer);
}

EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ReleaseTexImage(dpy, surface, buffer);
}

EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::SwapInterval(dpy, interval);
}

EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateContext(dpy, config, share_context, attrib_list);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroyContext(dpy, ctx);
}

EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::MakeCurrent(dpy, draw, read, ctx);
}

EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void)
{
	return egl::GetCurrentContext();
}

EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
{
	return egl::GetCurrentSurface(readdraw);
}

EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
{
	return egl::GetCurrentDisplay();
}

EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::QueryContext(dpy, ctx, attribute, value);
}

EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void)
{
	return egl::WaitClient();
}

EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
{
	return egl::WaitNative(engine);
}

EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::SwapBuffers(dpy, surface);
}

EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CopyBuffers(dpy, surface, target);
}

EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);
}

EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateImage(dpy, ctx, target, buffer, attrib_list);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroyImageKHR(dpy, image);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImage(EGLDisplay dpy, EGLImageKHR image)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroyImageKHR(dpy, image);
}

EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
{
	return egl::GetPlatformDisplayEXT(platform, native_display, attrib_list);
}

EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list)
{
	return egl::GetPlatformDisplay(platform, native_display, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePlatformWindowSurfaceEXT(dpy, config, native_window, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePlatformPixmapSurfaceEXT(dpy, config, native_pixmap, attrib_list);
}

EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
}

EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateSyncKHR(dpy, type, attrib_list);
}

EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::CreateSync(dpy, type, attrib_list);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroySyncKHR(dpy, sync);
}

EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync(EGLDisplay dpy, EGLSyncKHR sync)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::DestroySyncKHR(dpy, sync);
}

EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
}

EGLAPI EGLint EGLAPIENTRY eglClientWaitSync(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ClientWaitSyncKHR(dpy, sync, flags, timeout);
}

EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::GetSyncAttribKHR(dpy, sync, attribute, value);
}

EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLAttrib *value)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::GetSyncAttrib(dpy, sync, attribute, value);
}

EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
}

EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
{
	RecursiveLockGuard lock(egl::getDisplayLock(dpy));
	return egl::ClientWaitSyncKHR(dpy, sync, flags, EGL_FOREVER_KHR);
}

EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
{
	return egl::GetProcAddress(procname);
}
}

LibEGLexports::LibEGLexports()
{
	this->eglGetError = egl::GetError;
	this->eglGetDisplay = egl::GetDisplay;
	this->eglInitialize = egl::Initialize;
	this->eglTerminate = egl::Terminate;
	this->eglQueryString = egl::QueryString;
	this->eglGetConfigs = egl::GetConfigs;
	this->eglChooseConfig = egl::ChooseConfig;
	this->eglGetConfigAttrib = egl::GetConfigAttrib;
	this->eglCreateWindowSurface = egl::CreateWindowSurface;
	this->eglCreatePbufferSurface = egl::CreatePbufferSurface;
	this->eglCreatePixmapSurface = egl::CreatePixmapSurface;
	this->eglDestroySurface = egl::DestroySurface;
	this->eglQuerySurface = egl::QuerySurface;
	this->eglBindAPI = egl::BindAPI;
	this->eglQueryAPI = egl::QueryAPI;
	this->eglWaitClient = egl::WaitClient;
	this->eglReleaseThread = egl::ReleaseThread;
	this->eglCreatePbufferFromClientBuffer = egl::CreatePbufferFromClientBuffer;
	this->eglSurfaceAttrib = egl::SurfaceAttrib;
	this->eglBindTexImage = egl::BindTexImage;
	this->eglReleaseTexImage = egl::ReleaseTexImage;
	this->eglSwapInterval = egl::SwapInterval;
	this->eglCreateContext = egl::CreateContext;
	this->eglDestroyContext = egl::DestroyContext;
	this->eglMakeCurrent = egl::MakeCurrent;
	this->eglGetCurrentContext = egl::GetCurrentContext;
	this->eglGetCurrentSurface = egl::GetCurrentSurface;
	this->eglGetCurrentDisplay = egl::GetCurrentDisplay;
	this->eglQueryContext = egl::QueryContext;
	this->eglWaitGL = egl::WaitGL;
	this->eglWaitNative = egl::WaitNative;
	this->eglSwapBuffers = egl::SwapBuffers;
	this->eglCopyBuffers = egl::CopyBuffers;
	this->eglCreateImageKHR = egl::CreateImageKHR;
	this->eglDestroyImageKHR = egl::DestroyImageKHR;
	this->eglGetProcAddress = egl::GetProcAddress;
	this->eglCreateSyncKHR = egl::CreateSyncKHR;
	this->eglDestroySyncKHR = egl::DestroySyncKHR;
	this->eglClientWaitSyncKHR = egl::ClientWaitSyncKHR;
	this->eglGetSyncAttribKHR = egl::GetSyncAttribKHR;

	this->clientGetCurrentContext = egl::getCurrentContext;
}

extern "C" EGLAPI LibEGLexports *libEGL_swiftshader()
{
	static LibEGLexports libEGL;
	return &libEGL;
}

LibGLES_CM libGLES_CM;
LibGLESv2 libGLESv2;
