evas/gl_common: (GL thread) Add new files for API-level threading (1/5)

Following five patches are to add files related to API-level threading

patch 1: Wrapping APIs for GL glue layer (GLX/EGL)

  evas_gl_thread_egl.[ch]
  evas_gl_thread_glx.[ch]
    - Wrapper API implementation and link function for using GL-backend.
    - Currently only covers GLX/EGL layers.

patch 2: Wrapping APIs for GL API

  evas_gl_thread_gl.[ch]
    - Contains GL related wrapper APIs.
      Wrapper apis are automatically generated and included
      from the subsequent patch (3) except for one function.
    - User-defined copy macro.
      Mechanism to copy parameter data for complex case not handled
      in the script.

patch 3: Wrapping APIs for GL API (auto-generated files)

  evas_gl_thread_gl_generated.[ch]
    - Wrapper API for GL API used in Evas GL-backends.
      Has function bodies in the gl_generic and exposed to other engine.
  evas_gl_thread_gl_link_generated.[ch]
    - Same functions that links gl_generic to avoid duplicated body.
      Is used by gl_x11 and wayland_egl engines.

  evas_gl_thread_evgl_generated.[ch]
    - Wrapper API for GL API used in EvasGL APIs and logics.
      Has function bodies in the gl_generic and exposed to other engine.
  evas_gl_thread_evgl_link_generated.[ch]
    - Same functions that links gl_generic to avoid duplicated body.
      Is used by gl_x11 and wayland_egl engines.

  evas_gl_thread_evgl_api_generated.[ch]
    - Wrapper APIs for EvasGL APIs.

patch 4: Functions needed to use API-level threading

  evas_gl_thread.[ch]
    - Memory pool control, environment check, grouping mechanism
      for threading.
    - Link function for use GL-backend.

patch 5: Auto-generating python script & data file

  generate_gl_thread_api.py
    - It creates *_generated.[ch] files. (included by patch 3)
    - Path : $EFL_HOME/src/utils/evas
    - Usage :
      $ python $EFL_HOME/src/utils/evas/generate_gl_thread_api.py -i "data_file"
  gl_api_def.txt
    - Data file for generate wrapper APIs.
    - It contains API list and attribute for generate wrapper API
    - Path : $EFL_HOME/src/utils/evas

Change-Id: I6db9b718827b19bb6791a612ec73239de840aa28

4 files changed, 4212 insertions, 0 deletions

diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c
new file mode 100644
index 0000000000..ce7370d2a3
--- /dev/null
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.c
@@ -0,0 +1,763 @@
+#include "evas_gl_thread.h"
+
+#ifdef GL_GLES
+
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
+
+
+
+typedef struct
+{
+   EGLint return_value;
+} Evas_Thread_Command_eglGetError;
+
+static void
+_gl_thread_eglGetError(void *data)
+{
+   Evas_Thread_Command_eglGetError *thread_data = data;
+   thread_data->return_value = eglGetError();
+}
+
+EAPI EGLint
+evas_eglGetError_th(void)
+{
+   Evas_Thread_Command_eglGetError thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglGetError();
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglGetError,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLenum api;
+} Evas_Thread_Command_eglBindAPI;
+
+static void
+_gl_thread_eglBindAPI(void *data)
+{
+   Evas_Thread_Command_eglBindAPI *thread_data = data;
+
+   thread_data->return_value = eglBindAPI(thread_data->api);
+}
+
+EAPI EGLBoolean
+evas_eglBindAPI_th(EGLenum api)
+{
+   Evas_Thread_Command_eglBindAPI thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglBindAPI(api);
+
+   thread_data.api = api;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglBindAPI,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLenum return_value;
+} Evas_Thread_Command_eglQueryAPI;
+
+static void
+_gl_thread_eglQueryAPI(void *data)
+{
+   Evas_Thread_Command_eglQueryAPI *thread_data = data;
+
+   thread_data->return_value = eglQueryAPI();
+}
+
+EAPI EGLenum
+evas_eglQueryAPI_th(void)
+{
+   Evas_Thread_Command_eglQueryAPI thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglQueryAPI();
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQueryAPI,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface draw;
+   EGLSurface read;
+   EGLContext ctx;
+} Evas_Thread_Command_eglMakeCurrent;
+
+EGLDisplay current_thread_dpy  = EGL_NO_DISPLAY;
+EGLSurface current_thread_draw = EGL_NO_SURFACE;
+EGLSurface current_thread_read = EGL_NO_SURFACE;
+EGLContext current_thread_ctx  = EGL_NO_CONTEXT;
+
+static void
+_gl_thread_eglMakeCurrent(void *data)
+{
+   Evas_Thread_Command_eglMakeCurrent *thread_data = data;
+   DBG("THREAD >> OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_data->dpy,
+         thread_data->draw, thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = eglMakeCurrent(thread_data->dpy,
+                                              thread_data->draw,
+                                              thread_data->read,
+                                              thread_data->ctx);
+
+   if (thread_data->return_value == EGL_TRUE)
+     {
+        current_thread_dpy = thread_data->dpy;
+        current_thread_draw = thread_data->draw;
+        current_thread_read = thread_data->read;
+        current_thread_ctx = thread_data->ctx;
+     }
+}
+
+EAPI EGLBoolean
+evas_eglMakeCurrent_th(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+{
+   Evas_Thread_Command_eglMakeCurrent thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglMakeCurrent(dpy, draw, read, ctx);
+
+   thread_data.dpy = dpy;
+   thread_data.draw = draw;
+   thread_data.read = read;
+   thread_data.ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglMakeCurrent,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+EAPI EGLContext
+evas_eglGetCurrentContext_th(void)
+{
+   if (!evas_gl_thread_enabled())
+     return eglGetCurrentContext();
+
+   /* Current thread is one per thread */
+   return current_thread_ctx;
+}
+
+
+EAPI EGLSurface
+evas_eglGetCurrentSurface_th(EGLint readdraw)
+{
+   if (!evas_gl_thread_enabled())
+     return eglGetCurrentSurface(readdraw);
+
+   if (readdraw == EGL_READ)
+      return current_thread_read;
+   if (readdraw == EGL_DRAW)
+      return current_thread_draw;
+}
+
+
+EAPI EGLDisplay
+evas_eglGetCurrentDisplay_th(void)
+{
+   if (!evas_gl_thread_enabled())
+     return eglGetCurrentDisplay();
+
+   return current_thread_dpy;
+}
+
+typedef struct
+{
+   EGLBoolean return_value;
+} Evas_Thread_Command_eglReleaseThread;
+
+static void
+_gl_thread_eglReleaseThread(void *data)
+{
+   Evas_Thread_Command_eglReleaseThread *thread_data = data;
+
+   thread_data->return_value = eglReleaseThread();
+}
+
+EAPI EGLBoolean
+evas_eglReleaseThread_th(void)
+{
+   Evas_Thread_Command_eglReleaseThread thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglReleaseThread();
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglReleaseThread,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface surface;
+   EGLint attribute;
+   EGLint *value;
+} Evas_Thread_Command_eglQuerySurface;
+
+static void
+_gl_thread_eglQuerySurface(void *data)
+{
+   Evas_Thread_Command_eglQuerySurface *thread_data = data;
+
+   thread_data->return_value = eglQuerySurface(thread_data->dpy,
+                                               thread_data->surface,
+                                               thread_data->attribute,
+                                               thread_data->value);
+}
+
+EAPI EGLBoolean
+evas_eglQuerySurface_th(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
+{
+   Evas_Thread_Command_eglQuerySurface thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglQuerySurface(dpy, surface, attribute, value);
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.attribute = attribute;
+   thread_data.value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQuerySurface,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLint interval;
+} Evas_Thread_Command_eglSwapInterval;
+
+static void
+_gl_thread_eglSwapInterval(void *data)
+{
+   Evas_Thread_Command_eglSwapInterval *thread_data = data;
+
+   thread_data->return_value = eglSwapInterval(thread_data->dpy,
+                                               thread_data->interval);
+}
+
+EAPI EGLBoolean
+evas_eglSwapInterval_th(EGLDisplay dpy, EGLint interval)
+{
+   Evas_Thread_Command_eglSwapInterval thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglSwapInterval(dpy, interval);
+
+   thread_data.dpy = dpy;
+   thread_data.interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapInterval,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+} Evas_Thread_Command_eglWaitGL;
+
+static void
+_gl_thread_eglWaitGL(void *data)
+{
+   Evas_Thread_Command_eglWaitGL *thread_data = data;
+
+   thread_data->return_value = eglWaitGL();
+}
+
+EAPI EGLBoolean
+evas_eglWaitGL_th(void)
+{
+   Evas_Thread_Command_eglWaitGL thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglWaitGL();
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglWaitGL,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface surface;
+} Evas_Thread_Command_eglSwapBuffers;
+
+static void
+_gl_thread_eglSwapBuffers(void *data)
+{
+   Evas_Thread_Command_eglSwapBuffers *thread_data = data;
+
+   thread_data->return_value = eglSwapBuffers(thread_data->dpy,
+                                              thread_data->surface);
+}
+
+EAPI EGLBoolean
+evas_eglSwapBuffers_th(EGLDisplay dpy, EGLSurface surface)
+{
+   Evas_Thread_Command_eglSwapBuffers thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return eglSwapBuffers(dpy, surface);
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapBuffers,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface surface;
+   EGLint *rects;
+   EGLint n_rects;
+} Evas_Thread_Command_eglSwapBuffersWithDamage;
+
+EGLBoolean (*orig_evas_eglSwapBuffersWithDamage)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+EAPI void
+eglSwapBuffersWithDamage_orig_evas_set(void *func)
+{
+   orig_evas_eglSwapBuffersWithDamage = func;
+}
+
+EAPI void *
+eglSwapBuffersWithDamage_orig_evas_get()
+{
+   return orig_evas_eglSwapBuffersWithDamage;
+}
+
+static void
+_gl_thread_eglSwapBuffersWithDamage(void *data)
+{
+   Evas_Thread_Command_eglSwapBuffersWithDamage *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglSwapBuffersWithDamage(thread_data->dpy,
+                                                                  thread_data->surface,
+                                                                  thread_data->rects,
+                                                                  thread_data->n_rects);
+}
+
+EAPI EGLBoolean
+evas_eglSwapBuffersWithDamage_th(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects)
+{
+   Evas_Thread_Command_eglSwapBuffersWithDamage thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return orig_evas_eglSwapBuffersWithDamage(dpy, surface, rects, n_rects);
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.rects = rects;
+   thread_data.n_rects = n_rects;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSwapBuffersWithDamage,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface surface;
+   EGLint *rects;
+   EGLint n_rects;
+} Evas_Thread_Command_eglSetDamageRegion;
+
+EGLBoolean (*orig_evas_eglSetDamageRegion)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+EAPI void
+eglSetDamageRegion_orig_evas_set(void *func)
+{
+   orig_evas_eglSetDamageRegion = func;
+}
+
+EAPI void *
+eglSetDamageRegion_orig_evas_get()
+{
+   return orig_evas_eglSetDamageRegion;
+}
+
+static void
+_gl_thread_eglSetDamageRegion(void *data)
+{
+   Evas_Thread_Command_eglSetDamageRegion *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglSetDamageRegion(thread_data->dpy,
+                                                            thread_data->surface,
+                                                            thread_data->rects,
+                                                            thread_data->n_rects);
+}
+
+EAPI EGLBoolean
+evas_eglSetDamageRegion_th(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects)
+{
+   Evas_Thread_Command_eglSetDamageRegion thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return orig_evas_eglSetDamageRegion(dpy, surface, rects, n_rects);
+
+   thread_data.dpy = dpy;
+   thread_data.surface = surface;
+   thread_data.rects = rects;
+   thread_data.n_rects = n_rects;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglSetDamageRegion,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   void *buffer;
+   EGLint attribute;
+   EGLint *value;
+} Evas_Thread_Command_eglQueryWaylandBuffer;
+
+EGLBoolean (*orig_evas_eglQueryWaylandBuffer)(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
+
+EAPI void
+eglQueryWaylandBuffer_orig_evas_set(void *func)
+{
+   orig_evas_eglQueryWaylandBuffer = func;
+}
+
+EAPI void *
+eglQueryWaylandBuffer_orig_evas_get()
+{
+   return orig_evas_eglQueryWaylandBuffer;
+}
+
+static void
+_gl_thread_eglQueryWaylandBuffer(void *data)
+{
+   Evas_Thread_Command_eglQueryWaylandBuffer *thread_data = data;
+
+   thread_data->return_value = orig_evas_eglQueryWaylandBuffer(thread_data->dpy,
+                                                               thread_data->buffer,
+                                                               thread_data->attribute,
+                                                               thread_data->value);
+}
+
+EAPI EGLBoolean
+evas_eglQueryWaylandBuffer_th(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value)
+{
+   Evas_Thread_Command_eglQueryWaylandBuffer thread_data;
+
+   if (!evas_gl_thread_enabled())
+     return orig_evas_eglQueryWaylandBuffer(dpy, buffer, attribute, value);
+
+   thread_data.dpy = dpy;
+   thread_data.buffer = buffer;
+   thread_data.attribute = attribute;
+   thread_data.value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_eglQueryWaylandBuffer,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+/***** EVAS GL *****/
+
+typedef struct
+{
+   EGLint return_value;
+} Evas_GL_Thread_Command_eglGetError;
+
+static void
+_evgl_thread_eglGetError(void *data)
+{
+   Evas_GL_Thread_Command_eglGetError *thread_data = data;
+
+   thread_data->return_value = eglGetError();
+}
+
+EAPI EGLint
+evas_eglGetError_evgl_th(void)
+{
+   Evas_GL_Thread_Command_eglGetError thread_data;
+
+   if (!evas_evgl_thread_enabled())
+     return eglGetError();
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_eglGetError,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+EGLDisplay current_evgl_thread_dpy  = EGL_NO_DISPLAY;
+EGLSurface current_evgl_thread_draw = EGL_NO_SURFACE;
+EGLSurface current_evgl_thread_read = EGL_NO_SURFACE;
+EGLContext current_evgl_thread_ctx  = EGL_NO_CONTEXT;
+
+
+typedef struct
+{
+   EGLBoolean return_value;
+   EGLDisplay dpy;
+   EGLSurface draw;
+   EGLSurface read;
+   EGLContext ctx;
+} Evas_GL_Thread_Command_eglMakeCurrent;
+
+static void
+_evgl_thread_eglMakeCurrent(void *data)
+{
+   Evas_GL_Thread_Command_eglMakeCurrent *thread_data = data;
+
+   DBG("THREAD >> EVGL OTHER THREAD MAKECURRENT : (%p, %p, %p, %p)\n", thread_data->dpy,
+                     thread_data->draw, thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = eglMakeCurrent(thread_data->dpy,
+                                              thread_data->draw,
+                                              thread_data->read,
+                                              thread_data->ctx);
+
+   if (thread_data->return_value == EGL_TRUE)
+     {
+        current_evgl_thread_dpy = thread_data->dpy;
+        current_evgl_thread_draw = thread_data->draw;
+        current_evgl_thread_read = thread_data->read;
+        current_evgl_thread_ctx = thread_data->ctx;
+     }
+}
+
+EAPI EGLBoolean
+evas_eglMakeCurrent_evgl_th(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+{
+   Evas_GL_Thread_Command_eglMakeCurrent thread_data;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        if (eina_thread_self() == evas_gl_thread_get(EVAS_GL_THREAD_TYPE_EVGL))
+           DBG("THREAD >> EVGL OTHER THREAD MAKECURRENT(INNER) : (%p, %p, %p, %p)\n",
+                                                               dpy, draw, read, ctx);
+        return eglMakeCurrent(dpy, draw, read, ctx);
+     }
+
+   thread_data.dpy = dpy;
+   thread_data.draw = draw;
+   thread_data.read = read;
+   thread_data.ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_eglMakeCurrent,
+                              &thread_data,
+                              EVAS_GL_THREAD_MODE_FINISH);
+
+   return thread_data.return_value;
+}
+
+
+
+EAPI EGLContext
+evas_eglGetCurrentContext_evgl_th(void)
+{
+   if (!evas_evgl_thread_enabled())
+     return eglGetCurrentContext();
+
+   return current_evgl_thread_ctx;
+}
+
+
+EAPI EGLSurface
+evas_eglGetCurrentSurface_evgl_th(EGLint readdraw)
+{
+   if (!evas_evgl_thread_enabled())
+     return eglGetCurrentSurface(readdraw);
+
+   if (readdraw == EGL_READ)
+      return current_evgl_thread_read;
+   if (readdraw == EGL_DRAW)
+      return current_evgl_thread_draw;
+}
+
+
+EAPI EGLDisplay
+evas_eglGetCurrentDisplay_evgl_th(void)
+{
+   if (!evas_evgl_thread_enabled())
+     return eglGetCurrentDisplay();
+
+   return current_evgl_thread_dpy;
+}
+
+
+
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+      /* compiled for GL backend */
+
+
+#include <dlfcn.h>
+
+EGLint     (*evas_eglGetError_th)();
+EGLBoolean (*evas_eglBindAPI_th)(EGLenum api);
+EGLenum    (*evas_eglQueryAPI_th)();
+EGLBoolean (*evas_eglMakeCurrent_th)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EGLContext (*evas_eglGetCurrentContext_th)(void);
+EGLSurface (*evas_eglGetCurrentSurface_th)(EGLint readdraw);
+EGLDisplay (*evas_eglGetCurrentDisplay_th)(void);
+EGLBoolean (*evas_eglReleaseThread_th)();
+
+EGLBoolean (*evas_eglQuerySurface_th)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+EGLBoolean (*evas_eglSwapInterval_th)(EGLDisplay dpy, EGLint interval);
+EGLBoolean (*evas_eglWaitGL_th)(void);
+EGLBoolean (*evas_eglSwapBuffers_th)(EGLDisplay dpy, EGLSurface surface);
+
+void       (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
+void      *(*eglSwapBuffersWithDamage_orig_evas_get)();
+EGLBoolean (*evas_eglSwapBuffersWithDamage_th)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+void       (*eglSetDamageRegion_orig_evas_set)(void *func);
+void      *(*eglSetDamageRegion_orig_evas_get)();
+EGLBoolean (*evas_eglSetDamageRegion_th)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+void       (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
+void      *(*eglQueryWaylandBuffer_orig_evas_get)();
+EGLBoolean (*evas_eglQueryWaylandBuffer_th)(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
+
+
+/***** EVAS GL *****/
+
+EGLint     (*evas_eglGetError_evgl_th)();
+EGLBoolean (*evas_eglMakeCurrent_evgl_th)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EGLContext (*evas_eglGetCurrentContext_evgl_th)(void);
+EGLSurface (*evas_eglGetCurrentSurface_evgl_th)(EGLint readdraw);
+EGLDisplay (*evas_eglGetCurrentDisplay_evgl_th)(void);
+
+
+void _egl_thread_link_init()
+{
+#define LINK2GENERIC(sym) \
+   sym = dlsym(RTLD_DEFAULT, #sym); \
+   if (!sym) ERR("Could not find function '%s'", #sym);
+
+   // Get function pointer to evas_gl_common that is now provided through the link of GL_Generic.
+   LINK2GENERIC(evas_eglGetError_th);
+   LINK2GENERIC(evas_eglBindAPI_th);
+   LINK2GENERIC(evas_eglQueryAPI_th);
+   LINK2GENERIC(evas_eglMakeCurrent_th);
+   LINK2GENERIC(evas_eglGetCurrentContext_th);
+   LINK2GENERIC(evas_eglGetCurrentSurface_th);
+   LINK2GENERIC(evas_eglGetCurrentDisplay_th);
+   LINK2GENERIC(evas_eglReleaseThread_th);
+
+   LINK2GENERIC(evas_eglQuerySurface_th);
+   LINK2GENERIC(evas_eglSwapInterval_th);
+   LINK2GENERIC(evas_eglWaitGL_th);
+   LINK2GENERIC(evas_eglSwapBuffers_th);
+
+   LINK2GENERIC(eglSwapBuffersWithDamage_orig_evas_set);
+   LINK2GENERIC(eglSwapBuffersWithDamage_orig_evas_get);
+   LINK2GENERIC(evas_eglSwapBuffersWithDamage_th);
+
+   LINK2GENERIC(eglSetDamageRegion_orig_evas_set);
+   LINK2GENERIC(eglSetDamageRegion_orig_evas_get);
+   LINK2GENERIC(evas_eglSetDamageRegion_th);
+
+   LINK2GENERIC(eglQueryWaylandBuffer_orig_evas_set);
+   LINK2GENERIC(eglQueryWaylandBuffer_orig_evas_get);
+   LINK2GENERIC(evas_eglQueryWaylandBuffer_th);
+
+   /***** EVAS GL *****/
+
+   LINK2GENERIC(evas_eglGetError_evgl_th);
+   LINK2GENERIC(evas_eglMakeCurrent_evgl_th);
+   LINK2GENERIC(evas_eglGetCurrentContext_evgl_th);
+   LINK2GENERIC(evas_eglGetCurrentSurface_evgl_th);
+   LINK2GENERIC(evas_eglGetCurrentDisplay_evgl_th);
+}
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+#endif
diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h
new file mode 100644
index 0000000000..e24c67c268
--- /dev/null
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_egl.h
@@ -0,0 +1,125 @@
+#ifndef EVAS_GL_THREAD_EGL_H
+#define EVAS_GL_THREAD_EGL_H
+
+#ifdef GL_GLES
+
+#include <EGL/egl.h>
+
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
+
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EVAS_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVAS_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+/* EGL 1.4 Referencing to Thread Local Storage */
+EAPI EGLint     evas_eglGetError_th();
+EAPI EGLBoolean evas_eglBindAPI_th(EGLenum api);
+EAPI EGLenum    evas_eglQueryAPI_th();
+EAPI EGLBoolean evas_eglMakeCurrent_th(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EAPI EGLContext evas_eglGetCurrentContext_th(void);
+EAPI EGLSurface evas_eglGetCurrentSurface_th(EGLint readdraw);
+EAPI EGLDisplay evas_eglGetCurrentDisplay_th(void);
+EAPI EGLBoolean evas_eglReleaseThread_th();
+
+
+/* EGL 1.4 Sequential Operations */
+EAPI EGLBoolean evas_eglQuerySurface_th(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+EAPI EGLBoolean evas_eglSwapInterval_th(EGLDisplay dpy, EGLint interval);
+EAPI EGLBoolean evas_eglWaitGL_th(void);
+EAPI EGLBoolean evas_eglSwapBuffers_th(EGLDisplay dpy, EGLSurface surface);
+
+EAPI void       eglSwapBuffersWithDamage_orig_evas_set(void *func);
+EAPI void      *eglSwapBuffersWithDamage_orig_evas_get();
+EAPI EGLBoolean evas_eglSwapBuffersWithDamage_th(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+EAPI void       eglSetDamageRegion_orig_evas_set(void *func);
+EAPI void      *eglSetDamageRegion_orig_evas_get();
+EAPI EGLBoolean evas_eglSetDamageRegion_th(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+
+EAPI void       eglQueryWaylandBuffer_orig_evas_set(void *func);
+EAPI void      *eglQueryWaylandBuffer_orig_evas_get();
+EAPI EGLBoolean evas_eglQueryWaylandBuffer_th(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
+
+
+/***** EVAS GL *****/
+
+/* EGL 1.4 Referencing to Thread Local Storage */
+EAPI EGLint     evas_eglGetError_evgl_th();
+EAPI EGLBoolean evas_eglMakeCurrent_evgl_th(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EAPI EGLContext evas_eglGetCurrentContext_evgl_th(void);
+EAPI EGLSurface evas_eglGetCurrentSurface_evgl_th(EGLint readdraw);
+EAPI EGLDisplay evas_eglGetCurrentDisplay_evgl_th(void);
+
+
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+
+/* EGL 1.4 Referencing to Thread Local Storage */
+extern EGLint     (*evas_eglGetError_th)();
+extern EGLBoolean (*evas_eglBindAPI_th)(EGLenum api);
+extern EGLenum    (*evas_eglQueryAPI_th)();
+extern EGLBoolean (*evas_eglMakeCurrent_th)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+extern EGLContext (*evas_eglGetCurrentContext_th)(void);
+extern EGLSurface (*evas_eglGetCurrentSurface_th)(EGLint readdraw);
+extern EGLDisplay (*evas_eglGetCurrentDisplay_th)(void);
+extern EGLBoolean (*evas_eglReleaseThread_th)();
+
+
+/* EGL 1.4 Sequential Operations */
+extern EGLBoolean (*evas_eglQuerySurface_th)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+extern EGLBoolean (*evas_eglSwapInterval_th)(EGLDisplay dpy, EGLint interval);
+extern EGLBoolean (*evas_eglWaitGL_th)(void);
+extern EGLBoolean (*evas_eglSwapBuffers_th)(EGLDisplay dpy, EGLSurface surface);
+extern void       (*eglSwapBuffersWithDamage_orig_evas_set)(void *func);
+extern void      *(*eglSwapBuffersWithDamage_orig_evas_get)();
+extern EGLBoolean (*evas_eglSwapBuffersWithDamage_th)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+extern void       (*eglSetDamageRegion_orig_evas_set)(void *func);
+extern void      *(*eglSetDamageRegion_orig_evas_get)();
+extern EGLBoolean (*evas_eglSetDamageRegion_th)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
+extern void       (*eglQueryWaylandBuffer_orig_evas_set)(void *func);
+extern void      *(*eglQueryWaylandBuffer_orig_evas_get)();
+extern EGLBoolean (*evas_eglQueryWaylandBuffer_th)(EGLDisplay dpy, void *buffer, EGLint attribute, EGLint *value);
+
+
+/***** EVAS GL *****/
+
+/* EGL 1.4 Referencing to Thread Local Storage */
+extern EGLint     (*evas_eglGetError_evgl_th)();
+extern EGLBoolean (*evas_eglMakeCurrent_evgl_th)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+extern EGLContext (*evas_eglGetCurrentContext_evgl_th)(void);
+extern EGLSurface (*evas_eglGetCurrentSurface_evgl_th)(EGLint readdraw);
+extern EGLDisplay (*evas_eglGetCurrentDisplay_evgl_th)(void);
+
+
+
+extern void _egl_thread_link_init();
+
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+#endif /* GL_GLES */
+
+#endif
diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c
new file mode 100644
index 0000000000..b96db23323
--- /dev/null
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.c
@@ -0,0 +1,3068 @@
+#include "evas_gl_thread.h"
+
+
+#ifndef GL_GLES
+
+
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
+
+
+/*
+   void
+   glXBindTexImage(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int buffer;
+   const int *attrib_list;
+
+} Evas_Thread_Command_glXBindTexImage;
+
+void (*orig_evas_glXBindTexImage)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+
+EAPI void
+glXBindTexImage_orig_evas_set(void *func)
+{
+   orig_evas_glXBindTexImage = func;
+}
+
+EAPI void *
+glXBindTexImage_orig_evas_get(void)
+{
+   return orig_evas_glXBindTexImage;
+}
+
+static void
+_gl_thread_glXBindTexImage(void *data)
+{
+   Evas_Thread_Command_glXBindTexImage *thread_data =
+       (Evas_Thread_Command_glXBindTexImage *)data;
+
+   orig_evas_glXBindTexImage(thread_data->dpy,
+                             thread_data->drawable,
+                             thread_data->buffer,
+                             thread_data->attrib_list);
+
+}
+
+EAPI void
+evas_glXBindTexImage_th(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXBindTexImage thread_data_local;
+   Evas_Thread_Command_glXBindTexImage *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        orig_evas_glXBindTexImage(dpy, drawable, buffer, attrib_list);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXBindTexImage,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   GLXFBConfig *
+   glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems);
+ */
+
+typedef struct
+{
+   GLXFBConfig * return_value;
+   Display *dpy;
+   int screen;
+   const int *attribList;
+   int *nitems;
+
+} Evas_Thread_Command_glXChooseFBConfig;
+
+static void
+_gl_thread_glXChooseFBConfig(void *data)
+{
+   Evas_Thread_Command_glXChooseFBConfig *thread_data =
+       (Evas_Thread_Command_glXChooseFBConfig *)data;
+
+   thread_data->return_value = glXChooseFBConfig(thread_data->dpy,
+                                                 thread_data->screen,
+                                                 thread_data->attribList,
+                                                 thread_data->nitems);
+
+}
+
+EAPI GLXFBConfig *
+evas_glXChooseFBConfig_th(Display *dpy, int screen, const int *attribList, int *nitems)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXChooseFBConfig thread_data_local;
+   Evas_Thread_Command_glXChooseFBConfig *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXChooseFBConfig(dpy, screen, attribList, nitems);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+   thread_data->attribList = attribList;
+   thread_data->nitems = nitems;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXChooseFBConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+ */
+
+typedef struct
+{
+   GLXContext return_value;
+   Display *dpy;
+   XVisualInfo *vis;
+   GLXContext shareList;
+   Bool direct;
+
+} Evas_Thread_Command_glXCreateContext;
+
+static void
+_gl_thread_glXCreateContext(void *data)
+{
+   Evas_Thread_Command_glXCreateContext *thread_data =
+       (Evas_Thread_Command_glXCreateContext *)data;
+
+   thread_data->return_value = glXCreateContext(thread_data->dpy,
+                                                thread_data->vis,
+                                                thread_data->shareList,
+                                                thread_data->direct);
+
+}
+
+EAPI GLXContext
+evas_glXCreateContext_th(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXCreateContext thread_data_local;
+   Evas_Thread_Command_glXCreateContext *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXCreateContext(dpy, vis, shareList, direct);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->vis = vis;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXCreateContext,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+ */
+
+typedef struct
+{
+   GLXContext return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   int renderType;
+   GLXContext shareList;
+   Bool direct;
+
+} Evas_Thread_Command_glXCreateNewContext;
+
+static void
+_gl_thread_glXCreateNewContext(void *data)
+{
+   Evas_Thread_Command_glXCreateNewContext *thread_data =
+       (Evas_Thread_Command_glXCreateNewContext *)data;
+
+   thread_data->return_value = glXCreateNewContext(thread_data->dpy,
+                                                   thread_data->config,
+                                                   thread_data->renderType,
+                                                   thread_data->shareList,
+                                                   thread_data->direct);
+
+}
+
+EAPI GLXContext
+evas_glXCreateNewContext_th(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXCreateNewContext thread_data_local;
+   Evas_Thread_Command_glXCreateNewContext *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXCreateNewContext(dpy, config, renderType, shareList, direct);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->renderType = renderType;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXCreateNewContext,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXPbuffer
+   glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXPbuffer return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   const int *attribList;
+
+} Evas_Thread_Command_glXCreatePbuffer;
+
+static void
+_gl_thread_glXCreatePbuffer(void *data)
+{
+   Evas_Thread_Command_glXCreatePbuffer *thread_data =
+       (Evas_Thread_Command_glXCreatePbuffer *)data;
+
+   thread_data->return_value = glXCreatePbuffer(thread_data->dpy,
+                                                thread_data->config,
+                                                thread_data->attribList);
+
+}
+
+EAPI GLXPbuffer
+evas_glXCreatePbuffer_th(Display *dpy, GLXFBConfig config, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXCreatePbuffer thread_data_local;
+   Evas_Thread_Command_glXCreatePbuffer *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXCreatePbuffer(dpy, config, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXCreatePbuffer,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXPixmap
+   glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXPixmap return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   Pixmap pixmap;
+   const int *attribList;
+
+} Evas_Thread_Command_glXCreatePixmap;
+
+GLXPixmap (*orig_evas_glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+
+EAPI void
+glXCreatePixmap_orig_evas_set(void *func)
+{
+   orig_evas_glXCreatePixmap = func;
+}
+
+EAPI void *
+glXCreatePixmap_orig_evas_get(void)
+{
+   return orig_evas_glXCreatePixmap;
+}
+
+
+static void
+_gl_thread_glXCreatePixmap(void *data)
+{
+   Evas_Thread_Command_glXCreatePixmap *thread_data =
+       (Evas_Thread_Command_glXCreatePixmap *)data;
+
+   thread_data->return_value = orig_evas_glXCreatePixmap(thread_data->dpy,
+                                                         thread_data->config,
+                                                         thread_data->pixmap,
+                                                         thread_data->attribList);
+
+}
+
+EAPI GLXPixmap
+evas_glXCreatePixmap_th(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXCreatePixmap thread_data_local;
+   Evas_Thread_Command_glXCreatePixmap *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return orig_evas_glXCreatePixmap(dpy, config, pixmap, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->pixmap = pixmap;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXCreatePixmap,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXWindow
+   glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXWindow return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   Window win;
+   const int *attribList;
+
+} Evas_Thread_Command_glXCreateWindow;
+
+static void
+_gl_thread_glXCreateWindow(void *data)
+{
+   Evas_Thread_Command_glXCreateWindow *thread_data =
+       (Evas_Thread_Command_glXCreateWindow *)data;
+
+   thread_data->return_value = glXCreateWindow(thread_data->dpy,
+                                               thread_data->config,
+                                               thread_data->win,
+                                               thread_data->attribList);
+
+}
+
+EAPI GLXWindow
+evas_glXCreateWindow_th(Display *dpy, GLXFBConfig config, Window win, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXCreateWindow thread_data_local;
+   Evas_Thread_Command_glXCreateWindow *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXCreateWindow(dpy, config, win, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->win = win;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXCreateWindow,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   void
+   glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXPbuffer pbuf;
+
+} Evas_Thread_Command_glXDestroyPbuffer;
+
+static void
+_gl_thread_glXDestroyPbuffer(void *data)
+{
+   Evas_Thread_Command_glXDestroyPbuffer *thread_data =
+       (Evas_Thread_Command_glXDestroyPbuffer *)data;
+
+   glXDestroyPbuffer(thread_data->dpy,
+                     thread_data->pbuf);
+
+}
+
+EAPI void
+evas_glXDestroyPbuffer_th(Display *dpy, GLXPbuffer pbuf)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXDestroyPbuffer thread_data_local;
+   Evas_Thread_Command_glXDestroyPbuffer *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        glXDestroyPbuffer(dpy, pbuf);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->pbuf = pbuf;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXDestroyPbuffer,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXDestroyPixmap(Display *dpy, GLXPixmap pixmap);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXPixmap pixmap;
+
+} Evas_Thread_Command_glXDestroyPixmap;
+
+void (*orig_evas_glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap);
+
+EAPI void
+glXDestroyPixmap_orig_evas_set(void *func)
+{
+   orig_evas_glXDestroyPixmap = func;
+}
+
+EAPI void *
+glXDestroyPixmap_orig_evas_get(void)
+{
+   return orig_evas_glXDestroyPixmap;
+}
+
+static void
+_gl_thread_glXDestroyPixmap(void *data)
+{
+   Evas_Thread_Command_glXDestroyPixmap *thread_data =
+       (Evas_Thread_Command_glXDestroyPixmap *)data;
+
+   orig_evas_glXDestroyPixmap(thread_data->dpy,
+                              thread_data->pixmap);
+
+}
+
+EAPI void
+evas_glXDestroyPixmap_th(Display *dpy, GLXPixmap pixmap)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXDestroyPixmap thread_data_local;
+   Evas_Thread_Command_glXDestroyPixmap *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        orig_evas_glXDestroyPixmap(dpy, pixmap);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->pixmap = pixmap;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXDestroyPixmap,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXDestroyWindow(Display *dpy, GLXWindow window);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXWindow window;
+
+} Evas_Thread_Command_glXDestroyWindow;
+
+static void
+_gl_thread_glXDestroyWindow(void *data)
+{
+   Evas_Thread_Command_glXDestroyWindow *thread_data =
+       (Evas_Thread_Command_glXDestroyWindow *)data;
+
+   glXDestroyWindow(thread_data->dpy,
+                    thread_data->window);
+
+}
+
+EAPI void
+evas_glXDestroyWindow_th(Display *dpy, GLXWindow window)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXDestroyWindow thread_data_local;
+   Evas_Thread_Command_glXDestroyWindow *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        glXDestroyWindow(dpy, window);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->window = window;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXDestroyWindow,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   int
+   glXGetConfig(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+ */
+
+typedef struct
+{
+   int return_value;
+   Display *dpy;
+   XVisualInfo *visual;
+   int attrib;
+   int *value;
+
+} Evas_Thread_Command_glXGetConfig;
+
+static void
+_gl_thread_glXGetConfig(void *data)
+{
+   Evas_Thread_Command_glXGetConfig *thread_data =
+       (Evas_Thread_Command_glXGetConfig *)data;
+
+   thread_data->return_value = glXGetConfig(thread_data->dpy,
+                                            thread_data->visual,
+                                            thread_data->attrib,
+                                            thread_data->value);
+
+}
+
+EAPI int
+evas_glXGetConfig_th(Display *dpy, XVisualInfo *visual, int attrib, int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXGetConfig thread_data_local;
+   Evas_Thread_Command_glXGetConfig *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXGetConfig(dpy, visual, attrib, value);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->visual = visual;
+   thread_data->attrib = attrib;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXGetConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value);
+ */
+
+typedef struct
+{
+   int return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   int attribute;
+   int *value;
+
+} Evas_Thread_Command_glXGetFBConfigAttrib;
+
+static void
+_gl_thread_glXGetFBConfigAttrib(void *data)
+{
+   Evas_Thread_Command_glXGetFBConfigAttrib *thread_data =
+       (Evas_Thread_Command_glXGetFBConfigAttrib *)data;
+
+   thread_data->return_value = glXGetFBConfigAttrib(thread_data->dpy,
+                                                    thread_data->config,
+                                                    thread_data->attribute,
+                                                    thread_data->value);
+
+}
+
+EAPI int
+evas_glXGetFBConfigAttrib_th(Display *dpy, GLXFBConfig config, int attribute, int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXGetFBConfigAttrib thread_data_local;
+   Evas_Thread_Command_glXGetFBConfigAttrib *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXGetFBConfigAttrib(dpy, config, attribute, value);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXGetFBConfigAttrib,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXGetVideoSync(unsigned int *count);
+ */
+
+typedef struct
+{
+   int return_value;
+   unsigned int *count;
+
+} Evas_Thread_Command_glXGetVideoSync;
+
+int (*orig_evas_glXGetVideoSync)(unsigned int *count);
+
+EAPI void
+glXGetVideoSync_orig_evas_set(void *func)
+{
+   orig_evas_glXGetVideoSync = func;
+}
+
+EAPI void *
+glXGetVideoSync_orig_evas_get(void)
+{
+   return orig_evas_glXGetVideoSync;
+}
+
+static void
+_gl_thread_glXGetVideoSync(void *data)
+{
+   Evas_Thread_Command_glXGetVideoSync *thread_data =
+       (Evas_Thread_Command_glXGetVideoSync *)data;
+
+   thread_data->return_value = orig_evas_glXGetVideoSync(thread_data->count);
+
+}
+
+EAPI int
+evas_glXGetVideoSync_th(unsigned int *count)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXGetVideoSync thread_data_local;
+   Evas_Thread_Command_glXGetVideoSync *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return orig_evas_glXGetVideoSync(count);
+     }
+
+   thread_data->count = count;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXGetVideoSync,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   XVisualInfo *
+   glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config);
+ */
+
+typedef struct
+{
+   XVisualInfo * return_value;
+   Display *dpy;
+   GLXFBConfig config;
+
+} Evas_Thread_Command_glXGetVisualFromFBConfig;
+
+static void
+_gl_thread_glXGetVisualFromFBConfig(void *data)
+{
+   Evas_Thread_Command_glXGetVisualFromFBConfig *thread_data =
+       (Evas_Thread_Command_glXGetVisualFromFBConfig *)data;
+
+   thread_data->return_value = glXGetVisualFromFBConfig(thread_data->dpy,
+                                                        thread_data->config);
+
+}
+
+EAPI XVisualInfo *
+evas_glXGetVisualFromFBConfig_th(Display *dpy, GLXFBConfig config)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXGetVisualFromFBConfig thread_data_local;
+   Evas_Thread_Command_glXGetVisualFromFBConfig *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXGetVisualFromFBConfig(dpy, config);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXGetVisualFromFBConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   Bool
+   glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   GLXDrawable draw;
+   GLXDrawable read;
+   GLXContext ctx;
+
+} Evas_Thread_Command_glXMakeContextCurrent;
+
+
+GLXContext current_thread_ctx = (GLXContext)0;
+
+static void
+_gl_thread_glXMakeContextCurrent(void *data)
+{
+   Evas_Thread_Command_glXMakeContextCurrent *thread_data =
+       (Evas_Thread_Command_glXMakeContextCurrent *)data;
+
+   DBG("THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
+           thread_data->dpy, (void *)thread_data->draw,
+           (void* )thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = glXMakeContextCurrent(thread_data->dpy,
+                                                     thread_data->draw,
+                                                     thread_data->read,
+                                                     thread_data->ctx);
+
+   if (thread_data->return_value)
+     {
+        current_thread_ctx = thread_data->ctx;
+     }
+
+}
+
+EAPI Bool
+evas_glXMakeContextCurrent_th(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXMakeContextCurrent thread_data_local;
+   Evas_Thread_Command_glXMakeContextCurrent *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXMakeContextCurrent(dpy, draw, read, ctx);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->read = read;
+   thread_data->ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXMakeContextCurrent,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXGetCurrentContext(void);
+ */
+
+EAPI GLXContext
+evas_glXGetCurrentContext_th(void)
+{
+   if (!evas_gl_thread_enabled())
+     {
+        return glXGetCurrentContext();
+     }
+
+   return current_thread_ctx;
+}
+
+/*
+   void
+   glXDestroyContext(Display *dpy, GLXContext ctx);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXContext ctx;
+
+} Evas_Thread_Command_glXDestroyContext;
+
+static void
+_gl_thread_glXDestroyContext(void *data)
+{
+   Evas_Thread_Command_glXDestroyContext *thread_data =
+       (Evas_Thread_Command_glXDestroyContext *)data;
+
+   glXDestroyContext(thread_data->dpy,
+                     thread_data->ctx);
+
+}
+
+EAPI void
+evas_glXDestroyContext_th(Display *dpy, GLXContext ctx)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXDestroyContext thread_data_local;
+   Evas_Thread_Command_glXDestroyContext *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        glXDestroyContext(dpy, ctx);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXDestroyContext,
+                              thread_data,
+                              thread_mode);
+}
+
+
+/*
+   void
+   glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable draw;
+   int attribute;
+   unsigned int *value;
+
+} Evas_Thread_Command_glXQueryDrawable;
+
+void (*orig_evas_glXQueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+
+EAPI void
+glXQueryDrawable_orig_evas_set(void *func)
+{
+   orig_evas_glXQueryDrawable = func;
+}
+
+EAPI void *
+glXQueryDrawable_orig_evas_get(void)
+{
+   return orig_evas_glXQueryDrawable;
+}
+
+static void
+_gl_thread_glXQueryDrawable(void *data)
+{
+   Evas_Thread_Command_glXQueryDrawable *thread_data =
+       (Evas_Thread_Command_glXQueryDrawable *)data;
+
+   orig_evas_glXQueryDrawable(thread_data->dpy,
+                              thread_data->draw,
+                              thread_data->attribute,
+                              thread_data->value);
+
+}
+
+EAPI void
+evas_glXQueryDrawable_th(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXQueryDrawable thread_data_local;
+   Evas_Thread_Command_glXQueryDrawable *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        orig_evas_glXQueryDrawable(dpy, draw, attribute, value);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXQueryDrawable,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   Bool
+   glXQueryExtension(Display *dpy, int *errorb, int *event);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   int *errorb;
+   int *event;
+
+} Evas_Thread_Command_glXQueryExtension;
+
+static void
+_gl_thread_glXQueryExtension(void *data)
+{
+   Evas_Thread_Command_glXQueryExtension *thread_data =
+       (Evas_Thread_Command_glXQueryExtension *)data;
+
+   thread_data->return_value = glXQueryExtension(thread_data->dpy,
+                                                 thread_data->errorb,
+                                                 thread_data->event);
+
+}
+
+EAPI Bool
+evas_glXQueryExtension_th(Display *dpy, int *errorb, int *event)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXQueryExtension thread_data_local;
+   Evas_Thread_Command_glXQueryExtension *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXQueryExtension(dpy, errorb, event);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->errorb = errorb;
+   thread_data->event = event;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXQueryExtension,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   const char *
+   glXQueryExtensionsString(Display *dpy, int screen);
+ */
+
+typedef struct
+{
+   const char * return_value;
+   Display *dpy;
+   int screen;
+
+} Evas_Thread_Command_glXQueryExtensionsString;
+
+static void
+_gl_thread_glXQueryExtensionsString(void *data)
+{
+   Evas_Thread_Command_glXQueryExtensionsString *thread_data =
+       (Evas_Thread_Command_glXQueryExtensionsString *)data;
+
+   thread_data->return_value = glXQueryExtensionsString(thread_data->dpy,
+                                                        thread_data->screen);
+
+}
+
+EAPI const char *
+evas_glXQueryExtensionsString_th(Display *dpy, int screen)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXQueryExtensionsString thread_data_local;
+   Evas_Thread_Command_glXQueryExtensionsString *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return glXQueryExtensionsString(dpy, screen);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXQueryExtensionsString,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   Bool
+   glXReleaseBuffersMESA(Display *dpy, GLXDrawable drawable);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   GLXDrawable drawable;
+
+} Evas_Thread_Command_glXReleaseBuffersMESA;
+
+Bool (*orig_evas_glXReleaseBuffersMESA)(Display *dpy, GLXDrawable drawable);
+
+EAPI void
+glXReleaseBuffersMESA_orig_evas_set(void *func)
+{
+   orig_evas_glXReleaseBuffersMESA = func;
+}
+
+EAPI void *
+glXReleaseBuffersMESA_orig_evas_get(void)
+{
+   return orig_evas_glXReleaseBuffersMESA;
+}
+
+static void
+_gl_thread_glXReleaseBuffersMESA(void *data)
+{
+   Evas_Thread_Command_glXReleaseBuffersMESA *thread_data =
+       (Evas_Thread_Command_glXReleaseBuffersMESA *)data;
+
+   thread_data->return_value = orig_evas_glXReleaseBuffersMESA(thread_data->dpy,
+                                                               thread_data->drawable);
+
+}
+
+EAPI Bool
+evas_glXReleaseBuffersMESA_th(Display *dpy, GLXDrawable drawable)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXReleaseBuffersMESA thread_data_local;
+   Evas_Thread_Command_glXReleaseBuffersMESA *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return orig_evas_glXReleaseBuffersMESA(dpy, drawable);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXReleaseBuffersMESA,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   void
+   glXReleaseTexImage(Display *dpy, GLXDrawable drawable, int buffer);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int buffer;
+
+} Evas_Thread_Command_glXReleaseTexImage;
+
+void (*orig_evas_glXReleaseTexImage)(Display *dpy, GLXDrawable drawable, int buffer);
+
+EAPI void
+glXReleaseTexImage_orig_evas_set(void *func)
+{
+   orig_evas_glXReleaseTexImage = func;
+}
+
+EAPI void *
+glXReleaseTexImage_orig_evas_get(void)
+{
+   return orig_evas_glXReleaseTexImage;
+}
+
+static void
+_gl_thread_glXReleaseTexImage(void *data)
+{
+   Evas_Thread_Command_glXReleaseTexImage *thread_data =
+       (Evas_Thread_Command_glXReleaseTexImage *)data;
+
+   orig_evas_glXReleaseTexImage(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->buffer);
+
+}
+
+EAPI void
+evas_glXReleaseTexImage_th(Display *dpy, GLXDrawable drawable, int buffer)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXReleaseTexImage thread_data_local;
+   Evas_Thread_Command_glXReleaseTexImage *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        orig_evas_glXReleaseTexImage(dpy, drawable, buffer);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXReleaseTexImage,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXSwapBuffers(Display *dpy, GLXDrawable drawable);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+
+} Evas_Thread_Command_glXSwapBuffers;
+
+static void
+_gl_thread_glXSwapBuffers(void *data)
+{
+   Evas_Thread_Command_glXSwapBuffers *thread_data =
+       (Evas_Thread_Command_glXSwapBuffers *)data;
+
+   glXSwapBuffers(thread_data->dpy,
+                  thread_data->drawable);
+
+}
+
+EAPI void
+evas_glXSwapBuffers_th(Display *dpy, GLXDrawable drawable)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXSwapBuffers thread_data_local;
+   Evas_Thread_Command_glXSwapBuffers *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        glXSwapBuffers(dpy, drawable);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXSwapBuffers,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXSwapIntervalEXT(Display *dpy, GLXDrawable drawable, int interval);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int interval;
+
+} Evas_Thread_Command_glXSwapIntervalEXT;
+
+void (*orig_evas_glXSwapIntervalEXT)(Display *dpy, GLXDrawable drawable, int interval);
+
+EAPI void
+glXSwapIntervalEXT_orig_evas_set(void *func)
+{
+   orig_evas_glXSwapIntervalEXT = func;
+}
+
+EAPI void *
+glXSwapIntervalEXT_orig_evas_get(void)
+{
+   return orig_evas_glXSwapIntervalEXT;
+}
+
+static void
+_gl_thread_glXSwapIntervalEXT(void *data)
+{
+   Evas_Thread_Command_glXSwapIntervalEXT *thread_data =
+       (Evas_Thread_Command_glXSwapIntervalEXT *)data;
+
+   orig_evas_glXSwapIntervalEXT(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->interval);
+
+}
+
+EAPI void
+evas_glXSwapIntervalEXT_th(Display *dpy, GLXDrawable drawable, int interval)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXSwapIntervalEXT thread_data_local;
+   Evas_Thread_Command_glXSwapIntervalEXT *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        orig_evas_glXSwapIntervalEXT(dpy, drawable, interval);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXSwapIntervalEXT,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   int
+   glXSwapIntervalSGI(int interval);
+ */
+
+typedef struct
+{
+   int return_value;
+   int interval;
+
+} Evas_Thread_Command_glXSwapIntervalSGI;
+
+int (*orig_evas_glXSwapIntervalSGI)(int interval);
+
+EAPI void
+glXSwapIntervalSGI_orig_evas_set(void *func)
+{
+   orig_evas_glXSwapIntervalSGI = func;
+}
+
+EAPI void *
+glXSwapIntervalSGI_orig_evas_get(void)
+{
+   return orig_evas_glXSwapIntervalSGI;
+}
+
+static void
+_gl_thread_glXSwapIntervalSGI(void *data)
+{
+   Evas_Thread_Command_glXSwapIntervalSGI *thread_data =
+       (Evas_Thread_Command_glXSwapIntervalSGI *)data;
+
+   thread_data->return_value = orig_evas_glXSwapIntervalSGI(thread_data->interval);
+
+}
+
+EAPI int
+evas_glXSwapIntervalSGI_th(int interval)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXSwapIntervalSGI thread_data_local;
+   Evas_Thread_Command_glXSwapIntervalSGI *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return orig_evas_glXSwapIntervalSGI(interval);
+     }
+
+   thread_data->interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXSwapIntervalSGI,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXWaitVideoSync(int divisor, int remainder, unsigned int *count);
+ */
+
+typedef struct
+{
+   int return_value;
+   int divisor;
+   int remainder;
+   unsigned int *count;
+
+} Evas_Thread_Command_glXWaitVideoSync;
+
+int (*orig_evas_glXWaitVideoSync)(int divisor, int remainder, unsigned int *count);
+
+EAPI void
+glXWaitVideoSync_orig_evas_set(void *func)
+{
+   orig_evas_glXWaitVideoSync = func;
+}
+
+EAPI void *
+glXWaitVideoSync_orig_evas_get(void)
+{
+   return orig_evas_glXWaitVideoSync;
+}
+
+static void
+_gl_thread_glXWaitVideoSync(void *data)
+{
+   Evas_Thread_Command_glXWaitVideoSync *thread_data =
+       (Evas_Thread_Command_glXWaitVideoSync *)data;
+
+   thread_data->return_value = orig_evas_glXWaitVideoSync(thread_data->divisor,
+                                                          thread_data->remainder,
+                                                          thread_data->count);
+
+}
+
+EAPI int
+evas_glXWaitVideoSync_th(int divisor, int remainder, unsigned int *count)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   Evas_Thread_Command_glXWaitVideoSync thread_data_local;
+   Evas_Thread_Command_glXWaitVideoSync *thread_data = &thread_data_local;
+
+   if (!evas_gl_thread_enabled())
+     {
+        return orig_evas_glXWaitVideoSync(divisor, remainder, count);
+     }
+
+   thread_data->divisor = divisor;
+   thread_data->remainder = remainder;
+   thread_data->count = count;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_GL,
+                              _gl_thread_glXWaitVideoSync,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/****** EVAS GL ******/
+/*
+   void
+   glXBindTexImage(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int buffer;
+   const int *attrib_list;
+
+} EVGL_Thread_Command_glXBindTexImage;
+
+void (*orig_evgl_glXBindTexImage)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+
+void
+glXBindTexImage_orig_evgl_set(void *func)
+{
+   orig_evgl_glXBindTexImage = func;
+}
+
+void *
+glXBindTexImage_orig_evgl_get(void)
+{
+   return orig_evgl_glXBindTexImage;
+}
+
+static void
+_evgl_thread_glXBindTexImage(void *data)
+{
+   EVGL_Thread_Command_glXBindTexImage *thread_data =
+       (EVGL_Thread_Command_glXBindTexImage *)data;
+
+   orig_evgl_glXBindTexImage(thread_data->dpy,
+                             thread_data->drawable,
+                             thread_data->buffer,
+                             thread_data->attrib_list);
+
+}
+
+EAPI void
+evas_glXBindTexImage_evgl_th(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXBindTexImage thread_data_local;
+   EVGL_Thread_Command_glXBindTexImage *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        orig_evgl_glXBindTexImage(dpy, drawable, buffer, attrib_list);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+   thread_data->attrib_list = attrib_list;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXBindTexImage,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   GLXFBConfig *
+   glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems);
+ */
+
+typedef struct
+{
+   GLXFBConfig * return_value;
+   Display *dpy;
+   int screen;
+   const int *attribList;
+   int *nitems;
+
+} EVGL_Thread_Command_glXChooseFBConfig;
+
+static void
+_evgl_thread_glXChooseFBConfig(void *data)
+{
+   EVGL_Thread_Command_glXChooseFBConfig *thread_data =
+       (EVGL_Thread_Command_glXChooseFBConfig *)data;
+
+   thread_data->return_value = glXChooseFBConfig(thread_data->dpy,
+                                                 thread_data->screen,
+                                                 thread_data->attribList,
+                                                 thread_data->nitems);
+
+}
+
+EAPI GLXFBConfig *
+evas_glXChooseFBConfig_evgl_th(Display *dpy, int screen, const int *attribList, int *nitems)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXChooseFBConfig thread_data_local;
+   EVGL_Thread_Command_glXChooseFBConfig *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXChooseFBConfig(dpy, screen, attribList, nitems);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+   thread_data->attribList = attribList;
+   thread_data->nitems = nitems;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXChooseFBConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+ */
+
+typedef struct
+{
+   GLXContext return_value;
+   Display *dpy;
+   XVisualInfo *vis;
+   GLXContext shareList;
+   Bool direct;
+
+} EVGL_Thread_Command_glXCreateContext;
+
+static void
+_evgl_thread_glXCreateContext(void *data)
+{
+   EVGL_Thread_Command_glXCreateContext *thread_data =
+       (EVGL_Thread_Command_glXCreateContext *)data;
+
+   thread_data->return_value = glXCreateContext(thread_data->dpy,
+                                                thread_data->vis,
+                                                thread_data->shareList,
+                                                thread_data->direct);
+
+}
+
+EAPI GLXContext
+evas_glXCreateContext_evgl_th(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXCreateContext thread_data_local;
+   EVGL_Thread_Command_glXCreateContext *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXCreateContext(dpy, vis, shareList, direct);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->vis = vis;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXCreateContext,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+ */
+
+typedef struct
+{
+   GLXContext return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   int renderType;
+   GLXContext shareList;
+   Bool direct;
+
+} EVGL_Thread_Command_glXCreateNewContext;
+
+static void
+_evgl_thread_glXCreateNewContext(void *data)
+{
+   EVGL_Thread_Command_glXCreateNewContext *thread_data =
+       (EVGL_Thread_Command_glXCreateNewContext *)data;
+
+   thread_data->return_value = glXCreateNewContext(thread_data->dpy,
+                                                   thread_data->config,
+                                                   thread_data->renderType,
+                                                   thread_data->shareList,
+                                                   thread_data->direct);
+
+}
+
+EAPI GLXContext
+evas_glXCreateNewContext_evgl_th(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXCreateNewContext thread_data_local;
+   EVGL_Thread_Command_glXCreateNewContext *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXCreateNewContext(dpy, config, renderType, shareList, direct);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->renderType = renderType;
+   thread_data->shareList = shareList;
+   thread_data->direct = direct;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXCreateNewContext,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXPbuffer
+   glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXPbuffer return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   const int *attribList;
+
+} EVGL_Thread_Command_glXCreatePbuffer;
+
+static void
+_evgl_thread_glXCreatePbuffer(void *data)
+{
+   EVGL_Thread_Command_glXCreatePbuffer *thread_data =
+       (EVGL_Thread_Command_glXCreatePbuffer *)data;
+
+   thread_data->return_value = glXCreatePbuffer(thread_data->dpy,
+                                                thread_data->config,
+                                                thread_data->attribList);
+
+}
+
+EAPI GLXPbuffer
+evas_glXCreatePbuffer_evgl_th(Display *dpy, GLXFBConfig config, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXCreatePbuffer thread_data_local;
+   EVGL_Thread_Command_glXCreatePbuffer *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXCreatePbuffer(dpy, config, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXCreatePbuffer,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXPixmap
+   glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXPixmap return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   Pixmap pixmap;
+   const int *attribList;
+
+} EVGL_Thread_Command_glXCreatePixmap;
+
+GLXPixmap (*orig_evgl_glXCreatePixmap)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+
+void
+glXCreatePixmap_orig_evgl_set(void *func)
+{
+   orig_evgl_glXCreatePixmap = func;
+}
+
+void *
+glXCreatePixmap_orig_evgl_get(void)
+{
+   return orig_evgl_glXCreatePixmap;
+}
+
+static void
+_evgl_thread_glXCreatePixmap(void *data)
+{
+   EVGL_Thread_Command_glXCreatePixmap *thread_data =
+       (EVGL_Thread_Command_glXCreatePixmap *)data;
+
+   thread_data->return_value = orig_evgl_glXCreatePixmap(thread_data->dpy,
+                                                         thread_data->config,
+                                                         thread_data->pixmap,
+                                                         thread_data->attribList);
+
+}
+
+EAPI GLXPixmap
+evas_glXCreatePixmap_evgl_th(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXCreatePixmap thread_data_local;
+   EVGL_Thread_Command_glXCreatePixmap *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return orig_evgl_glXCreatePixmap(dpy, config, pixmap, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->pixmap = pixmap;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXCreatePixmap,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXWindow
+   glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+ */
+
+typedef struct
+{
+   GLXWindow return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   Window win;
+   const int *attribList;
+
+} EVGL_Thread_Command_glXCreateWindow;
+
+static void
+_evgl_thread_glXCreateWindow(void *data)
+{
+   EVGL_Thread_Command_glXCreateWindow *thread_data =
+       (EVGL_Thread_Command_glXCreateWindow *)data;
+
+   thread_data->return_value = glXCreateWindow(thread_data->dpy,
+                                               thread_data->config,
+                                               thread_data->win,
+                                               thread_data->attribList);
+
+}
+
+EAPI GLXWindow
+evas_glXCreateWindow_evgl_th(Display *dpy, GLXFBConfig config, Window win, const int *attribList)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXCreateWindow thread_data_local;
+   EVGL_Thread_Command_glXCreateWindow *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXCreateWindow(dpy, config, win, attribList);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->win = win;
+   thread_data->attribList = attribList;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXCreateWindow,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   void
+   glXDestroyContext(Display *dpy, GLXContext ctx);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXContext ctx;
+
+} EVGL_Thread_Command_glXDestroyContext;
+
+static void
+_evgl_thread_glXDestroyContext(void *data)
+{
+   EVGL_Thread_Command_glXDestroyContext *thread_data =
+       (EVGL_Thread_Command_glXDestroyContext *)data;
+
+   glXDestroyContext(thread_data->dpy,
+                     thread_data->ctx);
+
+}
+
+EAPI void
+evas_glXDestroyContext_evgl_th(Display *dpy, GLXContext ctx)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXDestroyContext thread_data_local;
+   EVGL_Thread_Command_glXDestroyContext *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        glXDestroyContext(dpy, ctx);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXDestroyContext,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXPbuffer pbuf;
+
+} EVGL_Thread_Command_glXDestroyPbuffer;
+
+static void
+_evgl_thread_glXDestroyPbuffer(void *data)
+{
+   EVGL_Thread_Command_glXDestroyPbuffer *thread_data =
+       (EVGL_Thread_Command_glXDestroyPbuffer *)data;
+
+   glXDestroyPbuffer(thread_data->dpy,
+                     thread_data->pbuf);
+
+}
+
+EAPI void
+evas_glXDestroyPbuffer_evgl_th(Display *dpy, GLXPbuffer pbuf)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXDestroyPbuffer thread_data_local;
+   EVGL_Thread_Command_glXDestroyPbuffer *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        glXDestroyPbuffer(dpy, pbuf);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->pbuf = pbuf;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXDestroyPbuffer,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXDestroyPixmap(Display *dpy, GLXPixmap pixmap);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXPixmap pixmap;
+
+} EVGL_Thread_Command_glXDestroyPixmap;
+
+void (*orig_evgl_glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap);
+
+void
+glXDestroyPixmap_orig_evgl_set(void *func)
+{
+   orig_evgl_glXDestroyPixmap = func;
+}
+
+void *
+glXDestroyPixmap_orig_evgl_get(void)
+{
+   return orig_evgl_glXDestroyPixmap;
+}
+
+static void
+_evgl_thread_glXDestroyPixmap(void *data)
+{
+   EVGL_Thread_Command_glXDestroyPixmap *thread_data =
+       (EVGL_Thread_Command_glXDestroyPixmap *)data;
+
+   orig_evgl_glXDestroyPixmap(thread_data->dpy,
+                              thread_data->pixmap);
+
+}
+
+EAPI void
+evas_glXDestroyPixmap_evgl_th(Display *dpy, GLXPixmap pixmap)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXDestroyPixmap thread_data_local;
+   EVGL_Thread_Command_glXDestroyPixmap *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        orig_evgl_glXDestroyPixmap(dpy, pixmap);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->pixmap = pixmap;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXDestroyPixmap,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXDestroyWindow(Display *dpy, GLXWindow window);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXWindow window;
+
+} EVGL_Thread_Command_glXDestroyWindow;
+
+static void
+_evgl_thread_glXDestroyWindow(void *data)
+{
+   EVGL_Thread_Command_glXDestroyWindow *thread_data =
+       (EVGL_Thread_Command_glXDestroyWindow *)data;
+
+   glXDestroyWindow(thread_data->dpy,
+                    thread_data->window);
+
+}
+
+EAPI void
+evas_glXDestroyWindow_evgl_th(Display *dpy, GLXWindow window)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXDestroyWindow thread_data_local;
+   EVGL_Thread_Command_glXDestroyWindow *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        glXDestroyWindow(dpy, window);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->window = window;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXDestroyWindow,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   int
+   glXGetConfig(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+ */
+
+typedef struct
+{
+   int return_value;
+   Display *dpy;
+   XVisualInfo *visual;
+   int attrib;
+   int *value;
+
+} EVGL_Thread_Command_glXGetConfig;
+
+static void
+_evgl_thread_glXGetConfig(void *data)
+{
+   EVGL_Thread_Command_glXGetConfig *thread_data =
+       (EVGL_Thread_Command_glXGetConfig *)data;
+
+   thread_data->return_value = glXGetConfig(thread_data->dpy,
+                                            thread_data->visual,
+                                            thread_data->attrib,
+                                            thread_data->value);
+
+}
+
+EAPI int
+evas_glXGetConfig_evgl_th(Display *dpy, XVisualInfo *visual, int attrib, int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXGetConfig thread_data_local;
+   EVGL_Thread_Command_glXGetConfig *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXGetConfig(dpy, visual, attrib, value);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->visual = visual;
+   thread_data->attrib = attrib;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXGetConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value);
+ */
+
+typedef struct
+{
+   int return_value;
+   Display *dpy;
+   GLXFBConfig config;
+   int attribute;
+   int *value;
+
+} EVGL_Thread_Command_glXGetFBConfigAttrib;
+
+static void
+_evgl_thread_glXGetFBConfigAttrib(void *data)
+{
+   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_data =
+       (EVGL_Thread_Command_glXGetFBConfigAttrib *)data;
+
+   thread_data->return_value = glXGetFBConfigAttrib(thread_data->dpy,
+                                                    thread_data->config,
+                                                    thread_data->attribute,
+                                                    thread_data->value);
+
+}
+
+EAPI int
+evas_glXGetFBConfigAttrib_evgl_th(Display *dpy, GLXFBConfig config, int attribute, int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXGetFBConfigAttrib thread_data_local;
+   EVGL_Thread_Command_glXGetFBConfigAttrib *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXGetFBConfigAttrib(dpy, config, attribute, value);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXGetFBConfigAttrib,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXGetVideoSync(unsigned int *count);
+ */
+
+typedef struct
+{
+   int return_value;
+   unsigned int *count;
+
+} EVGL_Thread_Command_glXGetVideoSync;
+
+int (*orig_evgl_glXGetVideoSync)(unsigned int *count);
+
+void
+glXGetVideoSync_orig_evgl_set(void *func)
+{
+   orig_evgl_glXGetVideoSync = func;
+}
+
+void *
+glXGetVideoSync_orig_evgl_get(void)
+{
+   return orig_evgl_glXGetVideoSync;
+}
+
+static void
+_evgl_thread_glXGetVideoSync(void *data)
+{
+   EVGL_Thread_Command_glXGetVideoSync *thread_data =
+       (EVGL_Thread_Command_glXGetVideoSync *)data;
+
+   thread_data->return_value = orig_evgl_glXGetVideoSync(thread_data->count);
+
+}
+
+EAPI int
+evas_glXGetVideoSync_evgl_th(unsigned int *count)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXGetVideoSync thread_data_local;
+   EVGL_Thread_Command_glXGetVideoSync *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return orig_evgl_glXGetVideoSync(count);
+     }
+
+   thread_data->count = count;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXGetVideoSync,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   XVisualInfo *
+   glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config);
+ */
+
+typedef struct
+{
+   XVisualInfo * return_value;
+   Display *dpy;
+   GLXFBConfig config;
+
+} EVGL_Thread_Command_glXGetVisualFromFBConfig;
+
+static void
+_evgl_thread_glXGetVisualFromFBConfig(void *data)
+{
+   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_data =
+       (EVGL_Thread_Command_glXGetVisualFromFBConfig *)data;
+
+   thread_data->return_value = glXGetVisualFromFBConfig(thread_data->dpy,
+                                                        thread_data->config);
+
+}
+
+EAPI XVisualInfo *
+evas_glXGetVisualFromFBConfig_evgl_th(Display *dpy, GLXFBConfig config)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXGetVisualFromFBConfig thread_data_local;
+   EVGL_Thread_Command_glXGetVisualFromFBConfig *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXGetVisualFromFBConfig(dpy, config);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->config = config;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXGetVisualFromFBConfig,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   Bool
+   glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   GLXDrawable draw;
+   GLXDrawable read;
+   GLXContext ctx;
+
+} EVGL_Thread_Command_glXMakeContextCurrent;
+
+GLXContext current_evgl_thread_ctx = (GLXContext)0;
+
+static void
+_evgl_thread_glXMakeContextCurrent(void *data)
+{
+   EVGL_Thread_Command_glXMakeContextCurrent *thread_data =
+       (EVGL_Thread_Command_glXMakeContextCurrent *)data;
+
+   DBG("EVGL THREAD >> OTHER THREAD MAKECONTEXTCURRENT : (%p, %p, %p, %p)\n",
+           thread_data->dpy, (void *)thread_data->draw,
+           (void* )thread_data->read, thread_data->ctx);
+
+   thread_data->return_value = glXMakeContextCurrent(thread_data->dpy,
+                                                     thread_data->draw,
+                                                     thread_data->read,
+                                                     thread_data->ctx);
+
+   if (thread_data->return_value)
+     {
+        current_evgl_thread_ctx = thread_data->ctx;
+     }
+
+}
+
+EAPI Bool
+evas_glXMakeContextCurrent_evgl_th(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXMakeContextCurrent thread_data_local;
+   EVGL_Thread_Command_glXMakeContextCurrent *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXMakeContextCurrent(dpy, draw, read, ctx);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->read = read;
+   thread_data->ctx = ctx;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXMakeContextCurrent,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   GLXContext
+   glXGetCurrentContext(void);
+ */
+
+EAPI GLXContext
+evas_glXGetCurrentContext_evgl_th(void)
+{
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXGetCurrentContext();
+     }
+
+   return current_evgl_thread_ctx;
+}
+
+
+/*
+   void
+   glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable draw;
+   int attribute;
+   unsigned int *value;
+
+} EVGL_Thread_Command_glXQueryDrawable;
+
+void (*orig_evgl_glXQueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+
+void
+glXQueryDrawable_orig_evgl_set(void *func)
+{
+   orig_evgl_glXQueryDrawable = func;
+}
+
+void *
+glXQueryDrawable_orig_evgl_get(void)
+{
+   return orig_evgl_glXQueryDrawable;
+}
+
+static void
+_evgl_thread_glXQueryDrawable(void *data)
+{
+   EVGL_Thread_Command_glXQueryDrawable *thread_data =
+       (EVGL_Thread_Command_glXQueryDrawable *)data;
+
+   orig_evgl_glXQueryDrawable(thread_data->dpy,
+                              thread_data->draw,
+                              thread_data->attribute,
+                              thread_data->value);
+
+}
+
+EAPI void
+evas_glXQueryDrawable_evgl_th(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXQueryDrawable thread_data_local;
+   EVGL_Thread_Command_glXQueryDrawable *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        orig_evgl_glXQueryDrawable(dpy, draw, attribute, value);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->draw = draw;
+   thread_data->attribute = attribute;
+   thread_data->value = value;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXQueryDrawable,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   Bool
+   glXQueryExtension(Display *dpy, int *errorb, int *event);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   int *errorb;
+   int *event;
+
+} EVGL_Thread_Command_glXQueryExtension;
+
+static void
+_evgl_thread_glXQueryExtension(void *data)
+{
+   EVGL_Thread_Command_glXQueryExtension *thread_data =
+       (EVGL_Thread_Command_glXQueryExtension *)data;
+
+   thread_data->return_value = glXQueryExtension(thread_data->dpy,
+                                                 thread_data->errorb,
+                                                 thread_data->event);
+
+}
+
+EAPI Bool
+evas_glXQueryExtension_evgl_th(Display *dpy, int *errorb, int *event)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXQueryExtension thread_data_local;
+   EVGL_Thread_Command_glXQueryExtension *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXQueryExtension(dpy, errorb, event);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->errorb = errorb;
+   thread_data->event = event;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXQueryExtension,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   const char *
+   glXQueryExtensionsString(Display *dpy, int screen);
+ */
+
+typedef struct
+{
+   const char * return_value;
+   Display *dpy;
+   int screen;
+
+} EVGL_Thread_Command_glXQueryExtensionsString;
+
+static void
+_evgl_thread_glXQueryExtensionsString(void *data)
+{
+   EVGL_Thread_Command_glXQueryExtensionsString *thread_data =
+       (EVGL_Thread_Command_glXQueryExtensionsString *)data;
+
+   thread_data->return_value = glXQueryExtensionsString(thread_data->dpy,
+                                                        thread_data->screen);
+
+}
+
+EAPI const char *
+evas_glXQueryExtensionsString_evgl_th(Display *dpy, int screen)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXQueryExtensionsString thread_data_local;
+   EVGL_Thread_Command_glXQueryExtensionsString *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return glXQueryExtensionsString(dpy, screen);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->screen = screen;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXQueryExtensionsString,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   Bool
+   glXReleaseBuffersMESA(Display *dpy, GLXDrawable drawable);
+ */
+
+typedef struct
+{
+   Bool return_value;
+   Display *dpy;
+   GLXDrawable drawable;
+
+} EVGL_Thread_Command_glXReleaseBuffersMESA;
+
+Bool (*orig_evgl_glXReleaseBuffersMESA)(Display *dpy, GLXDrawable drawable);
+
+void
+glXReleaseBuffersMESA_orig_evgl_set(void *func)
+{
+   orig_evgl_glXReleaseBuffersMESA = func;
+}
+
+void *
+glXReleaseBuffersMESA_orig_evgl_get(void)
+{
+   return orig_evgl_glXReleaseBuffersMESA;
+}
+
+static void
+_evgl_thread_glXReleaseBuffersMESA(void *data)
+{
+   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_data =
+       (EVGL_Thread_Command_glXReleaseBuffersMESA *)data;
+
+   thread_data->return_value = orig_evgl_glXReleaseBuffersMESA(thread_data->dpy,
+                                                               thread_data->drawable);
+
+}
+
+EAPI Bool
+evas_glXReleaseBuffersMESA_evgl_th(Display *dpy, GLXDrawable drawable)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXReleaseBuffersMESA thread_data_local;
+   EVGL_Thread_Command_glXReleaseBuffersMESA *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return orig_evgl_glXReleaseBuffersMESA(dpy, drawable);
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXReleaseBuffersMESA,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   void
+   glXReleaseTexImage(Display *dpy, GLXDrawable drawable, int buffer);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int buffer;
+
+} EVGL_Thread_Command_glXReleaseTexImage;
+
+void (*orig_evgl_glXReleaseTexImage)(Display *dpy, GLXDrawable drawable, int buffer);
+
+void
+glXReleaseTexImage_orig_evgl_set(void *func)
+{
+   orig_evgl_glXReleaseTexImage = func;
+}
+
+void *
+glXReleaseTexImage_orig_evgl_get(void)
+{
+   return orig_evgl_glXReleaseTexImage;
+}
+
+static void
+_evgl_thread_glXReleaseTexImage(void *data)
+{
+   EVGL_Thread_Command_glXReleaseTexImage *thread_data =
+       (EVGL_Thread_Command_glXReleaseTexImage *)data;
+
+   orig_evgl_glXReleaseTexImage(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->buffer);
+
+}
+
+EAPI void
+evas_glXReleaseTexImage_evgl_th(Display *dpy, GLXDrawable drawable, int buffer)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXReleaseTexImage thread_data_local;
+   EVGL_Thread_Command_glXReleaseTexImage *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        orig_evgl_glXReleaseTexImage(dpy, drawable, buffer);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->buffer = buffer;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXReleaseTexImage,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXSwapBuffers(Display *dpy, GLXDrawable drawable);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+
+} EVGL_Thread_Command_glXSwapBuffers;
+
+static void
+_evgl_thread_glXSwapBuffers(void *data)
+{
+   EVGL_Thread_Command_glXSwapBuffers *thread_data =
+       (EVGL_Thread_Command_glXSwapBuffers *)data;
+
+   glXSwapBuffers(thread_data->dpy,
+                  thread_data->drawable);
+
+}
+
+EAPI void
+evas_glXSwapBuffers_evgl_th(Display *dpy, GLXDrawable drawable)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXSwapBuffers thread_data_local;
+   EVGL_Thread_Command_glXSwapBuffers *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        glXSwapBuffers(dpy, drawable);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXSwapBuffers,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   void
+   glXSwapIntervalEXT(Display *dpy, GLXDrawable drawable, int interval);
+ */
+
+typedef struct
+{
+   Display *dpy;
+   GLXDrawable drawable;
+   int interval;
+
+} EVGL_Thread_Command_glXSwapIntervalEXT;
+
+void (*orig_evgl_glXSwapIntervalEXT)(Display *dpy, GLXDrawable drawable, int interval);
+
+void
+glXSwapIntervalEXT_orig_evgl_set(void *func)
+{
+   orig_evgl_glXSwapIntervalEXT = func;
+}
+
+void *
+glXSwapIntervalEXT_orig_evgl_get(void)
+{
+   return orig_evgl_glXSwapIntervalEXT;
+}
+
+static void
+_evgl_thread_glXSwapIntervalEXT(void *data)
+{
+   EVGL_Thread_Command_glXSwapIntervalEXT *thread_data =
+       (EVGL_Thread_Command_glXSwapIntervalEXT *)data;
+
+   orig_evgl_glXSwapIntervalEXT(thread_data->dpy,
+                                thread_data->drawable,
+                                thread_data->interval);
+
+}
+
+EAPI void
+evas_glXSwapIntervalEXT_evgl_th(Display *dpy, GLXDrawable drawable, int interval)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXSwapIntervalEXT thread_data_local;
+   EVGL_Thread_Command_glXSwapIntervalEXT *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        orig_evgl_glXSwapIntervalEXT(dpy, drawable, interval);
+        return;
+     }
+
+   thread_data->dpy = dpy;
+   thread_data->drawable = drawable;
+   thread_data->interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXSwapIntervalEXT,
+                              thread_data,
+                              thread_mode);
+}
+
+/*
+   int
+   glXSwapIntervalSGI(int interval);
+ */
+
+typedef struct
+{
+   int return_value;
+   int interval;
+
+} EVGL_Thread_Command_glXSwapIntervalSGI;
+
+int (*orig_evgl_glXSwapIntervalSGI)(int interval);
+
+void
+glXSwapIntervalSGI_orig_evgl_set(void *func)
+{
+   orig_evgl_glXSwapIntervalSGI = func;
+}
+
+void *
+glXSwapIntervalSGI_orig_evgl_get(void)
+{
+   return orig_evgl_glXSwapIntervalSGI;
+}
+
+static void
+_evgl_thread_glXSwapIntervalSGI(void *data)
+{
+   EVGL_Thread_Command_glXSwapIntervalSGI *thread_data =
+       (EVGL_Thread_Command_glXSwapIntervalSGI *)data;
+
+   thread_data->return_value = orig_evgl_glXSwapIntervalSGI(thread_data->interval);
+
+}
+
+EAPI int
+evas_glXSwapIntervalSGI_evgl_th(int interval)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXSwapIntervalSGI thread_data_local;
+   EVGL_Thread_Command_glXSwapIntervalSGI *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return orig_evgl_glXSwapIntervalSGI(interval);
+     }
+
+   thread_data->interval = interval;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXSwapIntervalSGI,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+/*
+   int
+   glXWaitVideoSync(int divisor, int remainder, unsigned int *count);
+ */
+
+typedef struct
+{
+   int return_value;
+   int divisor;
+   int remainder;
+   unsigned int *count;
+
+} EVGL_Thread_Command_glXWaitVideoSync;
+
+int (*orig_evgl_glXWaitVideoSync)(int divisor, int remainder, unsigned int *count);
+
+void
+glXWaitVideoSync_orig_evgl_set(void *func)
+{
+   orig_evgl_glXWaitVideoSync = func;
+}
+
+void *
+glXWaitVideoSync_orig_evgl_get(void)
+{
+   return orig_evgl_glXWaitVideoSync;
+}
+
+static void
+_evgl_thread_glXWaitVideoSync(void *data)
+{
+   EVGL_Thread_Command_glXWaitVideoSync *thread_data =
+       (EVGL_Thread_Command_glXWaitVideoSync *)data;
+
+   thread_data->return_value = orig_evgl_glXWaitVideoSync(thread_data->divisor,
+                                                          thread_data->remainder,
+                                                          thread_data->count);
+
+}
+
+EAPI int
+evas_glXWaitVideoSync_evgl_th(int divisor, int remainder, unsigned int *count)
+{
+   int thread_mode = EVAS_GL_THREAD_MODE_FINISH;
+
+   EVGL_Thread_Command_glXWaitVideoSync thread_data_local;
+   EVGL_Thread_Command_glXWaitVideoSync *thread_data = &thread_data_local;
+
+   if (!evas_evgl_thread_enabled())
+     {
+        return orig_evgl_glXWaitVideoSync(divisor, remainder, count);
+     }
+
+   thread_data->divisor = divisor;
+   thread_data->remainder = remainder;
+   thread_data->count = count;
+
+   evas_gl_thread_cmd_enqueue(EVAS_GL_THREAD_TYPE_EVGL,
+                              _evgl_thread_glXWaitVideoSync,
+                              thread_data,
+                              thread_mode);
+
+   return thread_data->return_value;
+}
+
+
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+/* compiled for GL backend */
+
+#include <dlfcn.h>
+
+
+void          (*glXBindTexImage_orig_evas_set)(void *func) = NULL;
+void         *(*glXBindTexImage_orig_evas_get)(void) = NULL;
+void          (*evas_glXBindTexImage_th)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
+GLXFBConfig  *(*evas_glXChooseFBConfig_th)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
+GLXContext    (*evas_glXCreateContext_th)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
+GLXContext    (*evas_glXCreateNewContext_th)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
+GLXPbuffer    (*evas_glXCreatePbuffer_th)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
+void          (*glXCreatePixmap_orig_evas_set)(void *func) = NULL;
+void         *(*glXCreatePixmap_orig_evas_get)(void) = NULL;
+GLXPixmap     (*evas_glXCreatePixmap_th)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
+GLXWindow     (*evas_glXCreateWindow_th)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
+void          (*evas_glXDestroyContext_th)(Display *dpy, GLXContext ctx) = NULL;
+void          (*evas_glXDestroyPbuffer_th)(Display *dpy, GLXPbuffer pbuf) = NULL;
+void          (*glXDestroyPixmap_orig_evas_set)(void *func) = NULL;
+void         *(*glXDestroyPixmap_orig_evas_get)(void) = NULL;
+void          (*evas_glXDestroyPixmap_th)(Display *dpy, GLXPixmap pixmap) = NULL;
+void          (*evas_glXDestroyWindow_th)(Display *dpy, GLXWindow window) = NULL;
+int           (*evas_glXGetConfig_th)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
+GLXContext    (*evas_glXGetCurrentContext_th)(void) = NULL;
+int           (*evas_glXGetFBConfigAttrib_th)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
+void          (*glXGetVideoSync_orig_evas_set)(void *func) = NULL;
+void         *(*glXGetVideoSync_orig_evas_get)(void) = NULL;
+int           (*evas_glXGetVideoSync_th)(unsigned int *count) = NULL;
+XVisualInfo  *(*evas_glXGetVisualFromFBConfig_th)(Display *dpy, GLXFBConfig config) = NULL;
+Bool          (*evas_glXMakeContextCurrent_th)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
+void          (*glXQueryDrawable_orig_evas_set)(void *func) = NULL;
+void         *(*glXQueryDrawable_orig_evas_get)(void) = NULL;
+void          (*evas_glXQueryDrawable_th)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
+Bool          (*evas_glXQueryExtension_th)(Display *dpy, int *errorb, int *event) = NULL;
+const char   *(*evas_glXQueryExtensionsString_th)(Display *dpy, int screen) = NULL;
+void          (*glXReleaseBuffersMESA_orig_evas_set)(void *func) = NULL;
+void         *(*glXReleaseBuffersMESA_orig_evas_get)(void) = NULL;
+Bool          (*evas_glXReleaseBuffersMESA_th)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXReleaseTexImage_orig_evas_set)(void *func) = NULL;
+void         *(*glXReleaseTexImage_orig_evas_get)(void) = NULL;
+void          (*evas_glXReleaseTexImage_th)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
+void          (*evas_glXSwapBuffers_th)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXSwapIntervalEXT_orig_evas_set)(void *func) = NULL;
+void         *(*glXSwapIntervalEXT_orig_evas_get)(void) = NULL;
+void          (*evas_glXSwapIntervalEXT_th)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
+void          (*glXSwapIntervalSGI_orig_evas_set)(void *func) = NULL;
+void         *(*glXSwapIntervalSGI_orig_evas_get)(void) = NULL;
+int           (*evas_glXSwapIntervalSGI_th)(int interval) = NULL;
+void          (*glXWaitVideoSync_orig_evas_set)(void *func) = NULL;
+void         *(*glXWaitVideoSync_orig_evas_get)(void) = NULL;
+int           (*evas_glXWaitVideoSync_th)(int divisor, int remainder, unsigned int *count) = NULL;
+
+/****** EVAS GL ******/
+
+void          (*glXBindTexImage_orig_evgl_set)(void *func) = NULL;
+void         *(*glXBindTexImage_orig_evgl_get)(void) = NULL;
+void          (*evas_glXBindTexImage_evgl_th)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list) = NULL;
+GLXFBConfig  *(*evas_glXChooseFBConfig_evgl_th)(Display *dpy, int screen, const int *attribList, int *nitems) = NULL;
+GLXContext    (*evas_glXCreateContext_evgl_th)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) = NULL;
+GLXContext    (*evas_glXCreateNewContext_evgl_th)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) = NULL;
+GLXPbuffer    (*evas_glXCreatePbuffer_evgl_th)(Display *dpy, GLXFBConfig config, const int *attribList) = NULL;
+void          (*glXCreatePixmap_orig_evgl_set)(void *func) = NULL;
+void         *(*glXCreatePixmap_orig_evgl_get)(void) = NULL;
+GLXPixmap     (*evas_glXCreatePixmap_evgl_th)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) = NULL;
+GLXWindow     (*evas_glXCreateWindow_evgl_th)(Display *dpy, GLXFBConfig config, Window win, const int *attribList) = NULL;
+void          (*evas_glXDestroyContext_evgl_th)(Display *dpy, GLXContext ctx) = NULL;
+void          (*evas_glXDestroyPbuffer_evgl_th)(Display *dpy, GLXPbuffer pbuf) = NULL;
+void          (*glXDestroyPixmap_orig_evgl_set)(void *func) = NULL;
+void         *(*glXDestroyPixmap_orig_evgl_get)(void) = NULL;
+void          (*evas_glXDestroyPixmap_evgl_th)(Display *dpy, GLXPixmap pixmap) = NULL;
+void          (*evas_glXDestroyWindow_evgl_th)(Display *dpy, GLXWindow window) = NULL;
+int           (*evas_glXGetConfig_evgl_th)(Display *dpy, XVisualInfo *visual, int attrib, int *value) = NULL;
+GLXContext    (*evas_glXGetCurrentContext_evgl_th)(void) = NULL;
+int           (*evas_glXGetFBConfigAttrib_evgl_th)(Display *dpy, GLXFBConfig config, int attribute, int *value) = NULL;
+void          (*glXGetVideoSync_orig_evgl_set)(void *func) = NULL;
+void         *(*glXGetVideoSync_orig_evgl_get)(void) = NULL;
+int           (*evas_glXGetVideoSync_evgl_th)(unsigned int *count) = NULL;
+XVisualInfo  *(*evas_glXGetVisualFromFBConfig_evgl_th)(Display *dpy, GLXFBConfig config) = NULL;
+Bool          (*evas_glXMakeContextCurrent_evgl_th)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) = NULL;
+void          (*glXQueryDrawable_orig_evgl_set)(void *func) = NULL;
+void         *(*glXQueryDrawable_orig_evgl_get)(void) = NULL;
+void          (*evas_glXQueryDrawable_evgl_th)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) = NULL;
+Bool          (*evas_glXQueryExtension_evgl_th)(Display *dpy, int *errorb, int *event) = NULL;
+const char   *(*evas_glXQueryExtensionsString_evgl_th)(Display *dpy, int screen) = NULL;
+void          (*glXReleaseBuffersMESA_orig_evgl_set)(void *func) = NULL;
+void         *(*glXReleaseBuffersMESA_orig_evgl_get)(void) = NULL;
+Bool          (*evas_glXReleaseBuffersMESA_evgl_th)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXReleaseTexImage_orig_evgl_set)(void *func) = NULL;
+void         *(*glXReleaseTexImage_orig_evgl_get)(void) = NULL;
+void          (*evas_glXReleaseTexImage_evgl_th)(Display *dpy, GLXDrawable drawable, int buffer) = NULL;
+void          (*evas_glXSwapBuffers_evgl_th)(Display *dpy, GLXDrawable drawable) = NULL;
+void          (*glXSwapIntervalEXT_orig_evgl_set)(void *func) = NULL;
+void         *(*glXSwapIntervalEXT_orig_evgl_get)(void) = NULL;
+void          (*evas_glXSwapIntervalEXT_evgl_th)(Display *dpy, GLXDrawable drawable, int interval) = NULL;
+void          (*glXSwapIntervalSGI_orig_evgl_set)(void *func) = NULL;
+void         *(*glXSwapIntervalSGI_orig_evgl_get)(void) = NULL;
+int           (*evas_glXSwapIntervalSGI_evgl_th)(int interval) = NULL;
+void          (*glXWaitVideoSync_orig_evgl_set)(void *func) = NULL;
+void         *(*glXWaitVideoSync_orig_evgl_get)(void) = NULL;
+int           (*evas_glXWaitVideoSync_evgl_th)(int divisor, int remainder, unsigned int *count) = NULL;
+
+
+
+void _glx_thread_link_init()
+{
+#define LINK2GENERIC(sym) \
+   sym = dlsym(RTLD_DEFAULT, #sym); \
+   if (!sym) ERR("Could not find function '%s'", #sym);
+
+   LINK2GENERIC(glXBindTexImage_orig_evas_set);
+   LINK2GENERIC(glXBindTexImage_orig_evas_get);
+   LINK2GENERIC(evas_glXBindTexImage_th);
+   LINK2GENERIC(evas_glXChooseFBConfig_th);
+   LINK2GENERIC(evas_glXCreateContext_th);
+   LINK2GENERIC(evas_glXCreateNewContext_th);
+   LINK2GENERIC(evas_glXCreatePbuffer_th);
+   LINK2GENERIC(glXCreatePixmap_orig_evas_set);
+   LINK2GENERIC(glXCreatePixmap_orig_evas_get);
+   LINK2GENERIC(evas_glXCreatePixmap_th);
+   LINK2GENERIC(evas_glXCreateWindow_th);
+   LINK2GENERIC(evas_glXDestroyContext_th);
+   LINK2GENERIC(evas_glXDestroyPbuffer_th);
+   LINK2GENERIC(glXDestroyPixmap_orig_evas_set);
+   LINK2GENERIC(glXDestroyPixmap_orig_evas_get);
+   LINK2GENERIC(evas_glXDestroyPixmap_th);
+   LINK2GENERIC(evas_glXDestroyWindow_th);
+   LINK2GENERIC(evas_glXGetConfig_th);
+   LINK2GENERIC(evas_glXGetCurrentContext_th);
+   LINK2GENERIC(evas_glXGetFBConfigAttrib_th);
+   LINK2GENERIC(glXGetVideoSync_orig_evas_set);
+   LINK2GENERIC(glXGetVideoSync_orig_evas_get);
+   LINK2GENERIC(evas_glXGetVideoSync_th);
+   LINK2GENERIC(evas_glXGetVisualFromFBConfig_th);
+   LINK2GENERIC(evas_glXMakeContextCurrent_th);
+   LINK2GENERIC(glXQueryDrawable_orig_evas_set);
+   LINK2GENERIC(glXQueryDrawable_orig_evas_get);
+   LINK2GENERIC(evas_glXQueryDrawable_th);
+   LINK2GENERIC(evas_glXQueryExtension_th);
+   LINK2GENERIC(evas_glXQueryExtensionsString_th);
+   LINK2GENERIC(glXReleaseBuffersMESA_orig_evas_set);
+   LINK2GENERIC(glXReleaseBuffersMESA_orig_evas_get);
+   LINK2GENERIC(evas_glXReleaseBuffersMESA_th);
+   LINK2GENERIC(glXReleaseTexImage_orig_evas_set);
+   LINK2GENERIC(glXReleaseTexImage_orig_evas_get);
+   LINK2GENERIC(evas_glXReleaseTexImage_th);
+   LINK2GENERIC(evas_glXSwapBuffers_th);
+   LINK2GENERIC(glXSwapIntervalEXT_orig_evas_set);
+   LINK2GENERIC(glXSwapIntervalEXT_orig_evas_get);
+   LINK2GENERIC(evas_glXSwapIntervalEXT_th);
+   LINK2GENERIC(glXSwapIntervalSGI_orig_evas_set);
+   LINK2GENERIC(glXSwapIntervalSGI_orig_evas_get);
+   LINK2GENERIC(evas_glXSwapIntervalSGI_th);
+   LINK2GENERIC(glXWaitVideoSync_orig_evas_set);
+   LINK2GENERIC(glXWaitVideoSync_orig_evas_get);
+   LINK2GENERIC(evas_glXWaitVideoSync_th);
+
+   /****** EVAS GL ******/
+
+   LINK2GENERIC(glXBindTexImage_orig_evgl_set);
+   LINK2GENERIC(glXBindTexImage_orig_evgl_get);
+   LINK2GENERIC(evas_glXBindTexImage_evgl_th);
+   LINK2GENERIC(evas_glXChooseFBConfig_evgl_th);
+   LINK2GENERIC(evas_glXCreateContext_evgl_th);
+   LINK2GENERIC(evas_glXCreateNewContext_evgl_th);
+   LINK2GENERIC(evas_glXCreatePbuffer_evgl_th);
+   LINK2GENERIC(glXCreatePixmap_orig_evgl_set);
+   LINK2GENERIC(glXCreatePixmap_orig_evgl_get);
+   LINK2GENERIC(evas_glXCreatePixmap_evgl_th);
+   LINK2GENERIC(evas_glXCreateWindow_evgl_th);
+   LINK2GENERIC(evas_glXDestroyContext_evgl_th);
+   LINK2GENERIC(evas_glXDestroyPbuffer_evgl_th);
+   LINK2GENERIC(glXDestroyPixmap_orig_evgl_set);
+   LINK2GENERIC(glXDestroyPixmap_orig_evgl_get);
+   LINK2GENERIC(evas_glXDestroyPixmap_evgl_th);
+   LINK2GENERIC(evas_glXDestroyWindow_evgl_th);
+   LINK2GENERIC(evas_glXGetConfig_evgl_th);
+   LINK2GENERIC(evas_glXGetCurrentContext_evgl_th);
+   LINK2GENERIC(evas_glXGetFBConfigAttrib_evgl_th);
+   LINK2GENERIC(glXGetVideoSync_orig_evgl_set);
+   LINK2GENERIC(glXGetVideoSync_orig_evgl_get);
+   LINK2GENERIC(evas_glXGetVideoSync_evgl_th);
+   LINK2GENERIC(evas_glXGetVisualFromFBConfig_evgl_th);
+   LINK2GENERIC(evas_glXMakeContextCurrent_evgl_th);
+   LINK2GENERIC(glXQueryDrawable_orig_evgl_set);
+   LINK2GENERIC(glXQueryDrawable_orig_evgl_get);
+   LINK2GENERIC(evas_glXQueryDrawable_evgl_th);
+   LINK2GENERIC(evas_glXQueryExtension_evgl_th);
+   LINK2GENERIC(evas_glXQueryExtensionsString_evgl_th);
+   LINK2GENERIC(glXReleaseBuffersMESA_orig_evgl_set);
+   LINK2GENERIC(glXReleaseBuffersMESA_orig_evgl_get);
+   LINK2GENERIC(evas_glXReleaseBuffersMESA_evgl_th);
+   LINK2GENERIC(glXReleaseTexImage_orig_evgl_set);
+   LINK2GENERIC(glXReleaseTexImage_orig_evgl_get);
+   LINK2GENERIC(evas_glXReleaseTexImage_evgl_th);
+   LINK2GENERIC(evas_glXSwapBuffers_evgl_th);
+   LINK2GENERIC(glXSwapIntervalEXT_orig_evgl_set);
+   LINK2GENERIC(glXSwapIntervalEXT_orig_evgl_get);
+   LINK2GENERIC(evas_glXSwapIntervalEXT_evgl_th);
+   LINK2GENERIC(glXSwapIntervalSGI_orig_evgl_set);
+   LINK2GENERIC(glXSwapIntervalSGI_orig_evgl_get);
+   LINK2GENERIC(evas_glXSwapIntervalSGI_evgl_th);
+   LINK2GENERIC(glXWaitVideoSync_orig_evgl_set);
+   LINK2GENERIC(glXWaitVideoSync_orig_evgl_get);
+   LINK2GENERIC(evas_glXWaitVideoSync_evgl_th);
+}
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+
+#endif /* ! GL_GLES */
diff --git a/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h
new file mode 100644
index 0000000000..07bae53919
--- /dev/null
+++ b/src/modules/evas/engines/gl_common/evas_gl_thread_glx.h
@@ -0,0 +1,256 @@
+#ifndef EVAS_GL_THREAD_GLX_H
+#define EVAS_GL_THREAD_GLX_H
+
+#ifndef GL_GLES
+
+# include <GL/glx.h>
+
+#ifdef EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC
+
+#define GL_GLEXT_PROTOTYPES
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EVAS_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVAS_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+
+EAPI void         glXBindTexImage_orig_evas_set(void *func);
+EAPI void        *glXBindTexImage_orig_evas_get(void);
+EAPI void         evas_glXBindTexImage_th(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+EAPI GLXFBConfig *evas_glXChooseFBConfig_th(Display *dpy, int screen, const int *attribList, int *nitems);
+EAPI GLXContext   evas_glXCreateContext_th(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+EAPI GLXContext   evas_glXCreateNewContext_th(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+EAPI GLXPbuffer   evas_glXCreatePbuffer_th(Display *dpy, GLXFBConfig config, const int *attribList);
+EAPI void         glXCreatePixmap_orig_evas_set(void *func);
+EAPI void        *glXCreatePixmap_orig_evas_get(void);
+EAPI GLXPixmap    evas_glXCreatePixmap_th(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+EAPI GLXWindow    evas_glXCreateWindow_th(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+EAPI void         evas_glXDestroyContext_th(Display *dpy, GLXContext ctx);
+EAPI void         evas_glXDestroyPbuffer_th(Display *dpy, GLXPbuffer pbuf);
+EAPI void         glXDestoyPixmap_orig_evas_set(void *func);
+EAPI void        *glXDestoyPixmap_orig_evas_get(void);
+EAPI void         evas_glXDestroyPixmap_th(Display *dpy, GLXPixmap pixmap);
+EAPI void         evas_glXDestroyWindow_th(Display *dpy, GLXWindow window);
+EAPI int          evas_glXGetConfig_th(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+EAPI GLXContext   evas_glXGetCurrentContext_th(void);
+EAPI int          evas_glXGetFBConfigAttrib_th(Display *dpy, GLXFBConfig config, int attribute, int *value);
+
+EAPI void         glXGetVideoSync_orig_evas_set(void *func);
+EAPI void        *glXGetVideoSync_orig_evas_get(void);
+EAPI int          evas_glXGetVideoSync_th(unsigned int *count);
+EAPI XVisualInfo *evas_glXGetVisualFromFBConfig_th(Display *dpy, GLXFBConfig config);
+EAPI Bool         evas_glXMakeContextCurrent_th(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+EAPI void         glXQueryDrawable_orig_evas_set(void *func);
+EAPI void        *glXQueryDrawable_orig_evas_get(void);
+EAPI void         evas_glXQueryDrawable_th(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+EAPI Bool         evas_glXQueryExtension_th(Display *dpy, int *errorb, int *event);
+EAPI const char  *evas_glXQueryExtensionsString_th(Display *dpy, int screen);
+
+EAPI void         glXReleaseBuffersMESA_orig_evas_set(void *func);
+EAPI void        *glXReleaseBuffersMESA_orig_evas_get(void);
+EAPI Bool         evas_glXReleaseBuffersMESA_th(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXReleaseTexImageEXT_orig_evas_set(void *func);
+EAPI void        *glXReleaseTexImageEXT_orig_evas_get(void);
+EAPI void         evas_glXReleaseTexImageEXT_th(Display *dpy, GLXDrawable drawable, int buffer);
+EAPI void         evas_glXSwapBuffers_th(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXSwapIntervalEXT_orig_evas_set(void *func);
+EAPI void        *glXSwapIntervalEXT_orig_evas_get(void);
+EAPI void         evas_glXSwapIntervalEXT_th(Display *dpy, GLXDrawable drawable, int interval);
+
+EAPI void         glXSwapIntervalSGI_orig_evas_set(void *func);
+EAPI void        *glXSwapIntervalSGI_orig_evas_get(void);
+EAPI int          evas_glXSwapIntervalSGI_th(int interval);
+
+EAPI void         glXWaitVideoSync_orig_evas_set(void *func);
+EAPI void        *glXWaitVideoSync_orig_evas_get(void);
+EAPI int          evas_glXWaitVideoSync_th(int divisor, int remainder, unsigned int *count);
+
+/****** EVAS GL ******/
+EAPI void         glXBindTexImage_orig_evgl_set(void *func);
+EAPI void        *glXBindTexImage_orig_evgl_get(void);
+EAPI void         evas_glXBindTexImage_evgl_th(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+EAPI GLXFBConfig *evas_glXChooseFBConfig_evgl_th(Display *dpy, int screen, const int *attribList, int *nitems);
+EAPI GLXContext   evas_glXCreateContext_evgl_th(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+EAPI GLXContext   evas_glXCreateNewContext_evgl_th(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+EAPI GLXPbuffer   evas_glXCreatePbuffer_evgl_th(Display *dpy, GLXFBConfig config, const int *attribList);
+
+EAPI void         glXCreatePixmap_orig_evgl_set(void *func);
+EAPI void        *glXCreatePixmap_orig_evgl_get(void);
+EAPI GLXPixmap    evas_glXCreatePixmap_evgl_th(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+EAPI GLXWindow    evas_glXCreateWindow_evgl_th(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+EAPI void         evas_glXDestroyContext_evgl_th(Display *dpy, GLXContext ctx);
+EAPI void         evas_glXDestroyPbuffer_evgl_th(Display *dpy, GLXPbuffer pbuf);
+
+EAPI void         glXDestroyPixmap_orig_evgl_set(void *func);
+EAPI void        *glXDestroyPixmap_orig_evgl_get(void);
+EAPI void         evas_glXDestroyPixmap_evgl_th(Display *dpy, GLXPixmap pixmap);
+EAPI void         evas_glXDestroyWindow_evgl_th(Display *dpy, GLXWindow window);
+EAPI int          evas_glXGetConfig_evgl_th(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+EAPI GLXContext   evas_glXGetCurrentContext_evgl_th(void);
+EAPI int          evas_glXGetFBConfigAttrib_evgl_th(Display *dpy, GLXFBConfig config, int attribute, int *value);
+
+EAPI void         glXGetVideoSync_orig_evgl_set(void *func);
+EAPI void        *glXGetVideoSync_orig_evgl_get(void);
+EAPI int          evas_glXGetVideoSync_evgl_th(unsigned int *count);
+EAPI XVisualInfo *evas_glXGetVisualFromFBConfig_evgl_th(Display *dpy, GLXFBConfig config);
+EAPI Bool         evas_glXMakeContextCurrent_evgl_th(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+
+EAPI void         glXQueryDrawable_orig_evgl_set(void *func);
+EAPI void        *glXQueryDrawable_orig_evgl_get(void);
+EAPI void         evas_glXQueryDrawable_evgl_th(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+EAPI Bool         evas_glXQueryExtension_evgl_th(Display *dpy, int *errorb, int *event);
+EAPI const char  *evas_glXQueryExtensionsString_evgl_th(Display *dpy, int screen);
+
+EAPI void         glXReleaseBuffersMESA_orig_evgl_set(void *func);
+EAPI void        *glXReleaseBuffersMESA_orig_evgl_get(void);
+EAPI Bool         evas_glXReleaseBuffersMESA_evgl_th(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXReleaseTexImage_orig_evgl_set(void *func);
+EAPI void        *glXReleaseTexImage_orig_evgl_get(void);
+EAPI void         evas_glXReleaseTexImage_evgl_th(Display *dpy, GLXDrawable drawable, int buffer);
+EAPI void         evas_glXSwapBuffers_evgl_th(Display *dpy, GLXDrawable drawable);
+
+EAPI void         glXSwapIntervalEXT_orig_evgl_set(void *func);
+EAPI void        *glXSwapIntervalEXT_orig_evgl_get(void);
+EAPI void         evas_glXSwapIntervalEXT_evgl_th(Display *dpy, GLXDrawable drawable, int interval);
+
+EAPI void         glXSwapIntervalSGI_orig_evgl_set(void *func);
+EAPI void        *glXSwapIntervalSGI_orig_evgl_get(void);
+EAPI int          evas_glXSwapIntervalSGI_evgl_th(int interval);
+
+EAPI void         glXWaitVideoSync_orig_evgl_set(void *func);
+EAPI void        *glXWaitVideoSync_orig_evgl_get(void);
+EAPI int          evas_glXWaitVideoSync_evgl_th(int divisor, int remainder, unsigned int *count);
+
+#else /* ! EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+
+extern void         (*glXBindTexImage_orig_evas_set)(void *func);
+extern void        *(*glXBindTexImage_orig_evas_get)(void);
+extern void         (*evas_glXBindTexImage_th)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+extern GLXFBConfig *(*evas_glXChooseFBConfig_th)(Display *dpy, int screen, const int *attribList, int *nitems);
+extern GLXContext   (*evas_glXCreateContext_th)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+extern GLXContext   (*evas_glXCreateNewContext_th)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+extern GLXPbuffer   (*evas_glXCreatePbuffer_th)(Display *dpy, GLXFBConfig config, const int *attribList);
+extern void         (*glXCreatePixmap_orig_evas_set)(void *func);
+extern void        *(*glXCreatePixmap_orig_evas_get)(void);
+extern GLXPixmap    (*evas_glXCreatePixmap_th)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+extern GLXWindow    (*evas_glXCreateWindow_th)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+extern void         (*evas_glXDestroyContext_th)(Display *dpy, GLXContext ctx);
+extern void         (*evas_glXDestroyPbuffer_th)(Display *dpy, GLXPbuffer pbuf);
+extern void         (*glXDestroyPixmap_orig_evas_set)(void *func);
+extern void        *(*glXDestroyPixmap_orig_evas_get)(void);
+extern void         (*evas_glXDestroyPixmap_th)(Display *dpy, GLXPixmap pixmap);
+extern void         (*evas_glXDestroyWindow_th)(Display *dpy, GLXWindow window);
+extern int          (*evas_glXGetConfig_th)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+extern GLXContext   (*evas_glXGetCurrentContext_th)(void);
+extern int          (*evas_glXGetFBConfigAttrib_th)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+extern void         (*glXGetVideoSync_orig_evas_set)(void *func);
+extern void        *(*glXGetVideoSync_orig_evas_get)(void);
+extern int          (*evas_glXGetVideoSync_th)(unsigned int *count);
+extern XVisualInfo *(*evas_glXGetVisualFromFBConfig_th)(Display *dpy, GLXFBConfig config);
+extern Bool         (*evas_glXMakeContextCurrent_th)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+extern void         (*glXQueryDrawable_orig_evas_set)(void *func);
+extern void        *(*glXQueryDrawable_orig_evas_get)(void);
+extern void         (*evas_glXQueryDrawable_th)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+extern Bool         (*evas_glXQueryExtension_th)(Display *dpy, int *errorb, int *event);
+extern const char  *(*evas_glXQueryExtensionsString_th)(Display *dpy, int screen);
+extern void         (*glXReleaseBuffersMESA_orig_evas_set)(void *func);
+extern void        *(*glXReleaseBuffersMESA_orig_evas_get)(void);
+extern Bool         (*evas_glXReleaseBuffersMESA_th)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXReleaseTexImage_orig_evas_set)(void *func);
+extern void        *(*glXReleaseTexImage_orig_evas_get)(void);
+extern void         (*evas_glXReleaseTexImage_th)(Display *dpy, GLXDrawable drawable, int buffer);
+extern void         (*evas_glXSwapBuffers_th)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXSwapIntervalEXT_orig_evas_set)(void *func);
+extern void        *(*glXSwapIntervalEXT_orig_evas_get)(void);
+extern void         (*evas_glXSwapIntervalEXT_th)(Display *dpy, GLXDrawable drawable, int interval);
+extern void         (*glXSwapIntervalSGI_orig_evas_set)(void *func);
+extern void        *(*glXSwapIntervalSGI_orig_evas_get)(void);
+extern int          (*evas_glXSwapIntervalSGI_th)(int interval);
+extern void         (*glXWaitVideoSync_orig_evas_set)(void *func);
+extern void        *(*glXWaitVideoSync_orig_evas_get)(void);
+extern int          (*evas_glXWaitVideoSync_th)(int divisor, int remainder, unsigned int *count);
+
+/****** EVAS GL ******/
+
+extern void         (*glXBindTexImage_orig_evgl_set)(void *func);
+extern void        *(*glXBindTexImage_orig_evgl_get)(void);
+extern void         (*evas_glXBindTexImage_evgl_th)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+extern GLXFBConfig *(*evas_glXChooseFBConfig_evgl_th)(Display *dpy, int screen, const int *attribList, int *nitems);
+extern GLXContext   (*evas_glXCreateContext_evgl_th)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+extern GLXContext   (*evas_glXCreateNewContext_evgl_th)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
+extern GLXPbuffer   (*evas_glXCreatePbuffer_evgl_th)(Display *dpy, GLXFBConfig config, const int *attribList);
+extern void         (*glXCreatePixmap_orig_evgl_set)(void *func);
+extern void        *(*glXCreatePixmap_orig_evgl_get)(void);
+extern GLXPixmap    (*evas_glXCreatePixmap_evgl_th)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList);
+extern GLXWindow    (*evas_glXCreateWindow_evgl_th)(Display *dpy, GLXFBConfig config, Window win, const int *attribList);
+extern void         (*evas_glXDestroyContext_evgl_th)(Display *dpy, GLXContext ctx);
+extern void         (*evas_glXDestroyPbuffer_evgl_th)(Display *dpy, GLXPbuffer pbuf);
+extern void         (*glXDestroyPixmap_orig_evgl_set)(void *func);
+extern void        *(*glXDestroyPixmap_orig_evgl_get)(void);
+extern void         (*evas_glXDestroyPixmap_evgl_th)(Display *dpy, GLXPixmap pixmap);
+extern void         (*evas_glXDestroyWindow_evgl_th)(Display *dpy, GLXWindow window);
+extern int          (*evas_glXGetConfig_evgl_th)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+extern GLXContext   (*evas_glXGetCurrentContext_evgl_th)(void);
+extern int          (*evas_glXGetFBConfigAttrib_evgl_th)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+extern void         (*glXGetVideoSync_orig_evgl_set)(void *func);
+extern void        *(*glXGetVideoSync_orig_evgl_get)(void);
+extern int          (*evas_glXGetVideoSync_evgl_th)(unsigned int *count);
+extern XVisualInfo *(*evas_glXGetVisualFromFBConfig_evgl_th)(Display *dpy, GLXFBConfig config);
+extern Bool         (*evas_glXMakeContextCurrent_evgl_th)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+extern void         (*glXQueryDrawable_orig_evgl_set)(void *func);
+extern void        *(*glXQueryDrawable_orig_evgl_get)(void);
+extern void         (*evas_glXQueryDrawable_evgl_th)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+extern Bool         (*evas_glXQueryExtension_evgl_th)(Display *dpy, int *errorb, int *event);
+extern const char  *(*evas_glXQueryExtensionsString_evgl_th)(Display *dpy, int screen);
+extern void         (*glXReleaseBuffersMESA_orig_evgl_set)(void *func);
+extern void        *(*glXReleaseBuffersMESA_orig_evgl_get)(void);
+extern Bool         (*evas_glXReleaseBuffersMESA_evgl_th)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXReleaseTexImage_orig_evgl_set)(void *func);
+extern void        *(*glXReleaseTexImage_orig_evgl_get)(void);
+extern void         (*evas_glXReleaseTexImage_evgl_th)(Display *dpy, GLXDrawable drawable, int buffer);
+extern void         (*evas_glXSwapBuffers_evgl_th)(Display *dpy, GLXDrawable drawable);
+extern void         (*glXSwapIntervalEXT_orig_evgl_set)(void *func);
+extern void        *(*glXSwapIntervalEXT_orig_evgl_get)(void);
+extern void         (*evas_glXSwapIntervalEXT_evgl_th)(Display *dpy, GLXDrawable drawable, int interval);
+extern void         (*glXSwapIntervalSGI_orig_evgl_set)(void *func);
+extern void        *(*glXSwapIntervalSGI_orig_evgl_get)(void);
+extern int          (*evas_glXSwapIntervalSGI_evgl_th)(int interval);
+extern void         (*glXWaitVideoSync_orig_evgl_set)(void *func);
+extern void        *(*glXWaitVideoSync_orig_evgl_get)(void);
+extern int          (*evas_glXWaitVideoSync_evgl_th)(int divisor, int remainder, unsigned int *count);
+
+
+extern void _glx_thread_link_init();
+
+
+#endif /* EVAS_GL_RENDER_THREAD_COMPILE_FOR_GL_GENERIC */
+
+#endif /* ! GL_GLES */
+
+#endif /* EVAS_GL_THREAD_GLX_H */