[321/906] add OpenGL ES 2.x support.

In OpenGL 2.x for Embedded System, a lot of basic scene/draw functions
have been removed. It means that everything is made using vertex and
fragment shaders.
I have also added a gstglwindow backend for winCE that uses EGL
(Native Platform Graphics Intercace) (which is a full part of
OpenGL ES specification). It remove the use of wgl/glx functions.

gst-libs/gst/gl/gstgldisplay.h

@@ -96,6 +96,13 @@ struct _GstGLDisplay {
   GLuint redisplay_texture;
   GLuint redisplay_texture_width;
   GLuint redisplay_texture_height;
+#ifdef OPENGL_ES2
+  GstGLShader* redisplay_shader;
+  GLbyte* redisplay_vertex_shader_str;
+  GLbyte* redisplay_fragment_shader_str;
+  GLint redisplay_attr_position_loc;
+  GLint redisplay_attr_texture_loc;
+#endif
 
   //action gen and del texture
   GLuint gen_texture;
@@ -183,6 +190,12 @@ struct _GstGLDisplay {
   gchar* text_shader_upload_AYUV;
   GstGLShader* shader_upload_AYUV;
 
+#ifdef OPENGL_ES2
+  GLbyte* text_vertex_shader_upload;
+  GLint shader_upload_attr_position_loc;
+  GLint shader_upload_attr_texture_loc;
+#endif
+
   //fragement shader download
   gchar* text_shader_download_YUY2_UYVY;
   GstGLShader* shader_download_YUY2;
@@ -193,6 +206,15 @@ struct _GstGLDisplay {
 
   gchar* text_shader_download_AYUV;
   GstGLShader* shader_download_AYUV;
+
+#ifdef OPENGL_ES2
+  GLbyte* text_vertex_shader_download;
+  GLint shader_download_attr_position_loc;
+  GLint shader_download_attr_texture_loc;
+  GLbyte* text_fragment_shader_download_RGB;
+  GstGLShader* shader_download_RGB;
+#endif
+
 };
 
 

gst-libs/gst/gl/gstgles2.h

@@ -0,0 +1,117 @@
+/* 
+ * GStreamer
+ * Copyright (C) 2009 Julien Isorce <julien.isorce@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* Compatibility for OpenGL ES 2.0 */
+
+#ifndef __GST_GL_ES2__
+#define __GST_GL_ES2__
+
+/* GLEW */
+
+#define GLEW_OK 0
+#define GLEW_NO_ERROR 0
+static const char* glewGetString (GLenum name) { return "1.5.1"; };
+static unsigned int glewInit() { return GLEW_OK;};
+static const char* glewGetErrorString (GLenum error) { return GLEW_NO_ERROR; };
+
+#define GLEW_VERSION 1
+#define GLEW_VERSION_MAJOR 5
+#define GLEW_VERSION_MINOR 1
+#define GLEW_VERSION_MICRO 0
+
+/* SUPPORTED */
+
+//FIXME:
+#define GL_RGBA8 GL_RGBA
+#define GL_BGRA GL_RGBA
+#define GL_UNSIGNED_INT_8_8_8_8 GL_UNSIGNED_BYTE
+#define GL_UNSIGNED_INT_8_8_8_8_REV GL_UNSIGNED_BYTE
+//END FIXME
+
+#define GL_TEXTURE_RECTANGLE_ARB GL_TEXTURE_2D
+#define GL_TEXTURE0_ARB GL_TEXTURE0
+#define GL_TEXTURE1_ARB GL_TEXTURE1
+#define GL_TEXTURE2_ARB GL_TEXTURE2
+
+#define GLEW_EXT_framebuffer_object 1
+#define GL_FRAMEBUFFER_EXT GL_FRAMEBUFFER
+#define GL_RENDERBUFFER_EXT GL_RENDERBUFFER
+#define GL_DEPTH_ATTACHMENT_EXT GL_DEPTH_ATTACHMENT
+#define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+#define GL_FRAMEBUFFER_UNSUPPORTED_EXT GL_FRAMEBUFFER_UNSUPPORTED
+
+#define GL_COLOR_ATTACHMENT0_EXT GL_COLOR_ATTACHMENT0
+
+#define glFramebufferTexture2DEXT glFramebufferTexture2D
+#define glFramebufferRenderbufferEXT glFramebufferRenderbuffer
+#define glGenFramebuffersEXT glGenFramebuffers
+#define glBindFramebufferEXT glBindFramebuffer
+#define glRenderbufferStorageEXT glRenderbufferStorage
+#define glDeleteRenderbuffersEXT glDeleteRenderbuffers
+#define glDeleteFramebuffersEXT glDeleteFramebuffers
+#define glCheckFramebufferStatusEXT glCheckFramebufferStatus
+#define glGenRenderbuffersEXT glGenRenderbuffers
+#define glBindRenderbufferEXT glBindRenderbuffer
+#define glFramebufferTexture2DEXT glFramebufferTexture2D
+
+#define glActiveTextureARB glActiveTexture
+
+#define GLEW_ARB_fragment_shader 1
+#define GLhandleARB GLuint
+#define GL_FRAGMENT_SHADER_ARB GL_FRAGMENT_SHADER
+#define GL_VERTEX_SHADER_ARB GL_VERTEX_SHADER
+#define GL_OBJECT_COMPILE_STATUS_ARB GL_COMPILE_STATUS
+
+#define glUseProgramObjectARB glUseProgram
+#define glCreateProgramObjectARB glCreateProgram
+#define glCreateShaderObjectARB glCreateShader
+#define glCompileShaderARB glCompileShader
+#define glShaderSourceARB glShaderSource
+#define glGetInfoLogARB glGetProgramInfoLog
+#define glAttachObjectARB glAttachShader
+#define glDetachObjectARB glDetachShader
+#define glDeleteObjectARB glDeleteProgram
+#define glLinkProgramARB glLinkProgram
+#define glGetObjectParameterivARB glGetShaderiv
+#define glUniform1fARB glUniform1f
+#define glUniform1fvARB glUniform1fv
+#define glUniform1iARB glUniform1i
+#define glUniformMatrix4fvARB glUniformMatrix4fv
+#define glGetUniformLocationARB glGetUniformLocation
+#define glGetAttribLocationARB glGetAttribLocation
+
+/* UNSUPPORTED */
+
+#define GLEW_ARB_imaging 0
+#define GLEW_MESA_ycbcr_texture 0
+#define GL_BGR 0
+#define GL_YCBCR_MESA 0
+#define GL_UNSIGNED_SHORT_8_8_MESA 0
+#define GL_UNSIGNED_SHORT_8_8_MESA 0
+#define GL_UNSIGNED_SHORT_8_8_REV_MESA 0
+
+#define GL_COLOR_ATTACHMENT1_EXT 0
+#define GL_COLOR_ATTACHMENT2_EXT 0
+static void glReadBuffer(GLenum name) {};
+static void glTexEnvi(GLenum name1, GLenum name2, GLenum name3) {};
+#define GL_TEXTURE_ENV 0
+#define GL_TEXTURE_ENV_MODE 0
+
+#endif /* __GST_GL_ES2__ */

gst-libs/gst/gl/gstglshader.c

@@ -510,6 +510,22 @@ gst_gl_shader_set_uniform_1i (GstGLShader * shader, const gchar * name,
   glUniform1iARB (location, value);
 }
 
+void
+gst_gl_shader_set_uniform_matrix_4fv (GstGLShader * shader, const gchar * name,
+    GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+  GstGLShaderPrivate *priv;
+  GLint location = -1;
+
+  priv = shader->priv;
+
+  g_return_if_fail (priv->program_handle != 0);
+
+  location = glGetUniformLocationARB (priv->program_handle, name);
+
+  glUniformMatrix4fvARB (location, count, transpose, value);
+}
+
 GLint
 gst_gl_shader_get_attribute_location (GstGLShader * shader, const gchar * name)
 {

gst-libs/gst/gl/gstglshader.h

@@ -21,7 +21,14 @@
 #ifndef __GST_GL_SHADER_H__
 #define __GST_GL_SHADER_H__
 
+/* OpenGL 2.0 for Embedded Systems */
+#ifdef OPENGL_ES2
+#include <GLES2/gl2.h>
+#include "gstgles2.h"
+/* OpenGL for usual systems */
+#else
 #include <GL/glew.h>
+#endif
 #include <gst/gst.h>
 
 G_BEGIN_DECLS
@@ -88,6 +95,8 @@ void gst_gl_shader_use (GstGLShader *shader);
 void gst_gl_shader_set_uniform_1i (GstGLShader *shader, const gchar *name, gint value);
 void gst_gl_shader_set_uniform_1f (GstGLShader *shader, const gchar *name, gfloat value);
 void gst_gl_shader_set_uniform_1fv (GstGLShader *shader, const gchar *name, guint count, gfloat * value);
+void gst_gl_shader_set_uniform_matrix_4fv (GstGLShader * shader, const gchar * name,
+  GLsizei count, GLboolean transpose, const GLfloat* value);
 
 GLint gst_gl_shader_get_attribute_location (GstGLShader *shader, const gchar *name);
 

gst-libs/gst/gl/gstglwindow.h

@@ -21,6 +21,15 @@
 #ifndef __GST_GL_WINDOW_H__
 #define __GST_GL_WINDOW_H__
 
+/* OpenGL 2.0 for Embedded Systems */
+#ifdef OPENGL_ES2
+#undef UNICODE
+#include <EGL/egl.h>
+#define UNICODE
+#include <GLES2/gl2.h>
+#include "gstgles2.h"
+/* OpenGL for usual systems */
+#else
 #if (!GNUSTEP && MACOS)
 #include <OpenGL/glew.h>
 #include <OpenGL/OpenGL.h>
@@ -29,6 +38,7 @@
 #include <GL/glew.h>
 #include <GL/gl.h>
 #endif
+#endif
 
 #include <gst/gst.h>
 

gst-libs/gst/gl/gstglwindow_winCE.c

@@ -0,0 +1,610 @@
+/*
+ * GStreamer
+ * Copyright (C) 2009 Julien Isorce <julien.isorce@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstglwindow.h"
+
+#define WM_GST_GL_WINDOW_CUSTOM (WM_APP+1)
+#define WM_GST_GL_WINDOW_QUIT (WM_APP+2)
+
+LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+LRESULT FAR PASCAL sub_class_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+const gchar* EGLErrorString();
+
+#define GST_GL_WINDOW_GET_PRIVATE(o)  \
+  (G_TYPE_INSTANCE_GET_PRIVATE((o), GST_GL_TYPE_WINDOW, GstGLWindowPrivate))
+
+enum
+{
+  PROP_0
+};
+
+struct _GstGLWindowPrivate
+{
+  EGLNativeWindowType internal_win_id;
+  EGLDisplay display;
+  EGLSurface surface;
+  EGLContext gl_context;
+  GstGLWindowCB draw_cb;
+  gpointer draw_data;
+  GstGLWindowCB2 resize_cb;
+  gpointer resize_data;
+  GstGLWindowCB close_cb;
+  gpointer close_data;
+  gboolean is_closed;
+  gboolean visible;
+};
+
+G_DEFINE_TYPE (GstGLWindow, gst_gl_window, G_TYPE_OBJECT);
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "GstGLWindow"
+
+gboolean _gst_gl_window_debug = FALSE;
+
+HHOOK hHook;
+
+/* Must be called in the gl thread */
+static void
+gst_gl_window_finalize (GObject * object)
+{
+  GstGLWindow *window = GST_GL_WINDOW (object);
+  GstGLWindowPrivate *priv = window->priv;
+
+  G_OBJECT_CLASS (gst_gl_window_parent_class)->finalize (object);
+}
+
+static void
+gst_gl_window_log_handler (const gchar *domain, GLogLevelFlags flags,
+                           const gchar *message, gpointer user_data)
+{
+  if (_gst_gl_window_debug) {
+    g_log_default_handler (domain, flags, message, user_data);
+  }
+}
+
+static void
+gst_gl_window_base_init (gpointer g_class)
+{
+}
+
+static void
+gst_gl_window_class_init (GstGLWindowClass * klass)
+{
+  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+  WNDCLASS wc;
+  ATOM atom = 0;
+  HINSTANCE hinstance = GetModuleHandle (NULL);
+
+  g_type_class_add_private (klass, sizeof (GstGLWindowPrivate));
+
+  obj_class->finalize = gst_gl_window_finalize;
+
+  atom = GetClassInfo (hinstance, "GSTGL", &wc);
+
+  if (atom == 0)
+  {
+    ZeroMemory (&wc, sizeof(WNDCLASS));
+
+    wc.lpfnWndProc = window_proc;
+    wc.cbClsExtra = 0;
+    wc.cbWndExtra = 0;
+    wc.hInstance = hinstance;
+    wc.hIcon = LoadIcon (NULL, IDI_WINLOGO);
+    wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
+    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
+    wc.lpszMenuName = NULL;
+    wc.lpszClassName = "GSTGL";
+
+    atom = RegisterClass (&wc);
+
+    if (atom == 0)
+      g_error ("Failed to register window class %x\r\n", GetLastError());
+  }
+}
+
+static void
+gst_gl_window_init (GstGLWindow *window)
+{
+  window->priv = GST_GL_WINDOW_GET_PRIVATE (window);
+
+  if (g_getenv ("GST_GL_WINDOW_DEBUG") != NULL)
+    _gst_gl_window_debug = TRUE;
+
+  g_log_set_handler ("GstGLWindow", G_LOG_LEVEL_DEBUG,
+    gst_gl_window_log_handler, NULL);
+}
+
+/* Must be called in the gl thread */
+GstGLWindow *
+gst_gl_window_new (gint width, gint height)
+{
+  GstGLWindow *window = g_object_new (GST_GL_TYPE_WINDOW, NULL);
+  GstGLWindowPrivate *priv = window->priv;
+  GstGLWindowClass* klass = GST_GL_WINDOW_GET_CLASS (window);
+
+  HINSTANCE hinstance = GetModuleHandle (NULL);
+
+  static gint x = 0;
+  static gint y = 0;
+
+  x += 20;
+  y += 20;
+
+  priv->internal_win_id = 0;
+  priv->display = 0;
+  priv->surface = 0;
+  priv->gl_context = 0;
+  priv->draw_cb = NULL;
+  priv->draw_data = NULL;
+  priv->resize_cb = NULL;
+  priv->resize_data = NULL;
+  priv->close_cb = NULL;
+  priv->close_data = NULL;
+  priv->is_closed = FALSE;
+  priv->visible = FALSE;
+
+  width += 2 * GetSystemMetrics (SM_CXSIZEFRAME);
+  height += 2 * GetSystemMetrics (SM_CYSIZEFRAME) + GetSystemMetrics (SM_CYCAPTION);
+
+  priv->internal_win_id = CreateWindow (
+    "GSTGL",
+    "OpenGL renderer",
+    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW, //WS_POPUP | WS_BORDER | WS_SYSMENU | WS_CAPTION
+    x, y, width, height,
+    (HWND) NULL,
+    (HMENU) NULL,
+    hinstance,
+    window
+  );
+
+  if (!priv->internal_win_id)
+  {
+    g_debug ("failed to create gl window: %d\n", priv->internal_win_id);
+    return NULL;
+  }
+
+  g_debug ("gl window created: %d\n", priv->internal_win_id);
+
+  //display is set in the window_proc
+  if (!priv->display) {
+    g_object_unref (G_OBJECT (window));
+    return NULL;
+  }
+
+  ShowCursor (TRUE);
+
+  return window;
+}
+
+GQuark
+gst_gl_window_error_quark (void)
+{
+  return g_quark_from_static_string ("gst-gl-window-error");
+}
+
+void
+gst_gl_window_set_external_window_id (GstGLWindow *window, guint64 id)
+{
+  GstGLWindowPrivate *priv = window->priv;
+  WNDPROC window_parent_proc = (WNDPROC) (guint64) GetWindowLongPtr((HWND)id, GWL_WNDPROC);
+  RECT rect;
+
+  SetProp (priv->internal_win_id, "gl_window_parent_id", (HWND)id);
+  SetProp ((HWND)id, "gl_window_id", priv->internal_win_id);
+  SetProp ((HWND)id, "gl_window_parent_proc", (WNDPROC) window_parent_proc);
+  SetWindowLongPtr ((HWND)id, GWL_WNDPROC, (DWORD) (guint64) sub_class_proc);
+
+  SetWindowLongPtr (priv->internal_win_id, GWL_STYLE, WS_CHILD | WS_MAXIMIZE);
+  SetParent (priv->internal_win_id, (HWND)id);
+
+  //take changes into account: SWP_FRAMECHANGED
+  GetClientRect ((HWND)id, &rect);
+  SetWindowPos (priv->internal_win_id, HWND_TOP, rect.left, rect.top, rect.right, rect.bottom,
+    SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE);
+  MoveWindow (priv->internal_win_id, rect.left, rect.top, rect.right, rect.bottom, FALSE);
+}
+
+void
+gst_gl_window_set_external_gl_context (GstGLWindow *window, guint64 context)
+{
+  g_warning ("gst_gl_window_set_external_gl_context: not implemented\n");
+}
+
+/* Must be called in the gl thread */
+void
+gst_gl_window_set_draw_callback (GstGLWindow *window, GstGLWindowCB callback, gpointer data)
+{
+  GstGLWindowPrivate *priv = window->priv;
+
+  priv->draw_cb = callback;
+  priv->draw_data = data;
+}
+
+/* Must be called in the gl thread */
+void
+gst_gl_window_set_resize_callback (GstGLWindow *window, GstGLWindowCB2 callback , gpointer data)
+{
+  GstGLWindowPrivate *priv = window->priv;
+
+  priv->resize_cb = callback;
+  priv->resize_data = data;
+}
+
+/* Must be called in the gl thread */
+void
+gst_gl_window_set_close_callback (GstGLWindow *window, GstGLWindowCB callback, gpointer data)
+{
+  GstGLWindowPrivate *priv = window->priv;
+
+  priv->close_cb = callback;
+  priv->close_data = data;
+}
+
+void
+gst_gl_window_draw_unlocked (GstGLWindow *window)
+{
+  gst_gl_window_draw (window);
+}
+
+/* Thread safe */
+void
+gst_gl_window_draw (GstGLWindow *window)
+{
+  GstGLWindowPrivate *priv = window->priv;
+
+  if (!priv->visible)
+  {
+    ShowWindowAsync (priv->internal_win_id, SW_SHOW);
+    priv->visible = TRUE;
+  }
+
+  RedrawWindow (priv->internal_win_id, NULL, NULL,
+    RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE);
+}
+
+void
+gst_gl_window_run_loop (GstGLWindow *window)
+{
+  GstGLWindowPrivate *priv = window->priv;
+  gboolean running = TRUE;
+  gboolean bRet = FALSE;
+  MSG msg;
+
+  g_debug ("begin loop\n");
+
+  while (running && (bRet = GetMessage (&msg, NULL, 0, 0)) != 0)
+  {
+      if (bRet == -1)
+      {
+          g_error ("Failed to get message %x\r\n", GetLastError());
+          running = FALSE;
+      }
+      else
+      {
+          TranslateMessage (&msg);
+          DispatchMessage (&msg);
+      }
+  }
+
+  g_debug ("end loop\n");
+}
+
+/* Thread safe */
+void
+gst_gl_window_quit_loop (GstGLWindow *window, GstGLWindowCB callback, gpointer data)
+{
+  if (window)
+  {
+    GstGLWindowPrivate *priv = window->priv;
+    LRESULT res = PostMessage(priv->internal_win_id, WM_GST_GL_WINDOW_QUIT, (WPARAM) data, (LPARAM) callback);
+    g_assert (SUCCEEDED (res));
+    g_debug ("end loop requested\n");
+  }
+}
+
+/* Thread safe */
+void
+gst_gl_window_send_message (GstGLWindow *window, GstGLWindowCB callback, gpointer data)
+{
+  if (window)
+  {
+    GstGLWindowPrivate *priv = window->priv;
+    LRESULT res = SendMessage (priv->internal_win_id, WM_GST_GL_WINDOW_CUSTOM, (WPARAM) data, (LPARAM) callback);
+    g_assert (SUCCEEDED (res));
+  }
+}
+
+LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+  if (uMsg == WM_CREATE) {
+
+    GstGLWindow *window = (GstGLWindow *) (((LPCREATESTRUCT) lParam)->lpCreateParams);
+
+    g_debug ("WM_CREATE\n");
+
+    g_assert (window);
+
+    {
+      EGLint majorVersion;
+      EGLint minorVersion;
+      EGLint numConfigs;
+      EGLConfig config;
+      EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE };
+      
+      EGLint attribList[] =
+      {
+        EGL_RED_SIZE,       5,
+        EGL_GREEN_SIZE,     6,
+        EGL_BLUE_SIZE,      5,
+        EGL_ALPHA_SIZE,     8,
+        EGL_DEPTH_SIZE,     8,
+        EGL_STENCIL_SIZE,   8,
+        EGL_SAMPLE_BUFFERS, EGL_DONT_CARE, //1
+        EGL_NONE
+      };
+      
+      GstGLWindowPrivate *priv = window->priv;
+
+      priv->display = eglGetDisplay (GetDC (hWnd));
+      if (priv->display != EGL_NO_DISPLAY)
+        g_debug ("display retrieved: %d\n", priv->display);
+      else
+        g_debug ("failed to retrieve display %d, %s\n", hWnd, EGLErrorString());
+
+      if (eglInitialize (priv->display, &majorVersion, &minorVersion))
+        g_debug ("egl initialized: %d.%d\n", majorVersion, minorVersion);
+      else
+        g_debug ("failed to initialize egl %d, %s\n", priv->display, EGLErrorString());
+
+      if (eglGetConfigs (priv->display, NULL, 0, &numConfigs))
+        g_debug ("configs retrieved: %d\n", numConfigs);
+      else
+        g_debug ("failed to retrieve configs %d, %s\n", priv->display, EGLErrorString());
+
+      if (eglChooseConfig (priv->display, attribList, &config, 1, &numConfigs))
+        g_debug ("config set: %d, %d\n", config, numConfigs);
+      else
+        g_debug ("failed to set config %d, %s\n", priv->display, EGLErrorString());
+
+      priv->surface = eglCreateWindowSurface (priv->display, config, (EGLNativeWindowType)hWnd, NULL);
+      if (priv->surface != EGL_NO_SURFACE)
+        g_debug ("surface created: %d\n", priv->surface);
+      else
+        g_debug ("failed to create surface %d, %d, %d, %s\n", priv->display, priv->surface, hWnd, EGLErrorString());
+
+      priv->gl_context = eglCreateContext (priv->display, config, EGL_NO_CONTEXT, contextAttribs);
+      if (priv->gl_context != EGL_NO_CONTEXT)
+        g_debug ("gl context created: %d\n", priv->gl_context);
+      else
+        g_debug ("failed to create glcontext %d, %d, s\n", priv->gl_context, hWnd, EGLErrorString());
+
+      ReleaseDC (hWnd, priv->display);
+
+      if (!eglMakeCurrent (priv->display, priv->surface, priv->surface, priv->gl_context))
+        g_debug ("failed to make opengl context current %d, %s\n", hWnd, EGLErrorString());
+    }
+
+    SetProp (hWnd, "gl_window", window);
+
+    return 0;
+  }
+  else if (GetProp(hWnd, "gl_window")) {
+
+    GstGLWindow *window = GetProp(hWnd, "gl_window");
+    GstGLWindowPrivate *priv = NULL;
+
+    g_assert (window);
+
+    priv = window->priv;
+
+    g_assert (priv);
+
+    g_assert (priv->internal_win_id == hWnd);
+
+    g_assert (priv->gl_context == eglGetCurrentContext());
+
+    switch ( uMsg ) {
+
+      case WM_SIZE:
+      {
+        if (priv->resize_cb)
+          priv->resize_cb (priv->resize_data, LOWORD(lParam), HIWORD(lParam));
+        break;
+      }
+
+      case WM_PAINT:
+      {
+        if (priv->draw_cb)
+        {
+          priv->draw_cb (priv->draw_data);
+          eglSwapBuffers (priv->display, priv->surface);
+          ValidateRect (hWnd, NULL);
+        }
+        break;
+      }
+
+      case WM_CLOSE:
+      {
+        ShowWindowAsync (priv->internal_win_id, SW_HIDE);
+
+        if (priv->close_cb)
+            priv->close_cb (priv->close_data);
+
+          priv->draw_cb = NULL;
+          priv->draw_data = NULL;
+          priv->resize_cb = NULL;
+          priv->resize_data = NULL;
+          priv->close_cb = NULL;
+          priv->close_data = NULL;
+        break;
+      }
+
+      case WM_GST_GL_WINDOW_QUIT:
+      {
+        HWND parent_id = 0;
+        GstGLWindowCB destroy_cb = (GstGLWindowCB) lParam;
+
+        g_debug ("WM_CLOSE\n");
+
+        destroy_cb ((gpointer) wParam);
+
+        parent_id = GetProp (hWnd, "gl_window_parent_id");
+        if (parent_id)
+        {
+          WNDPROC parent_proc = GetProp (parent_id, "gl_window_parent_proc");
+
+          g_assert (parent_proc);
+
+          SetWindowLongPtr (parent_id, GWL_WNDPROC, (LONG) (guint64) parent_proc);
+          SetParent (hWnd, NULL);
+
+          RemoveProp (parent_id, "gl_window_parent_proc");
+          RemoveProp (hWnd, "gl_window_parent_id");
+        }
+
+        priv->is_closed = TRUE;
+        RemoveProp (hWnd, "gl_window");
+
+        if (!eglMakeCurrent (priv->display, priv->surface, priv->surface, EGL_NO_CONTEXT))
+          g_debug ("failed to make current null context %d, %s\n", priv->display, EGLErrorString());
+
+        if (priv->gl_context)
+        {
+          if (!eglDestroyContext (priv->display, priv->gl_context))
+            g_debug ("failed to destroy context %d, %s\n", priv->gl_context, EGLErrorString());
+          priv->gl_context = NULL;
+        }
+
+        if (priv->surface)
+        {
+          if (!eglDestroySurface (priv->display, priv->surface))
+            g_debug ("failed to destroy surface %d, %s\n", priv->surface, EGLErrorString());
+          priv->surface = NULL;
+        }
+
+        if (priv->surface)
+        {
+          if (!eglTerminate (priv->display))
+            g_debug ("failed to terminate display %d, %s\n", priv->display, EGLErrorString());
+          priv->surface = NULL;
+        }
+
+        if (priv->internal_win_id)
+        {
+          if (!DestroyWindow(priv->internal_win_id))
+            g_debug ("failed to destroy window %d, 0x%x\n", hWnd, GetLastError());
+        }
+
+        PostQuitMessage (0);
+        break;
+      }
+
+      case WM_CAPTURECHANGED:
+      {
+        g_debug ("WM_CAPTURECHANGED\n");
+        if (priv->draw_cb)
+          priv->draw_cb (priv->draw_data);
+        break;
+      }
+
+      case WM_GST_GL_WINDOW_CUSTOM:
+      {
+        if (!priv->is_closed)
+        {
+          GstGLWindowCB custom_cb = (GstGLWindowCB) lParam;
+          custom_cb ((gpointer) wParam);
+        }
+        break;
+      }
+
+      case WM_ERASEBKGND:
+        return TRUE;
+
+      default:
+      {
+        /* transmit messages to the parrent (ex: mouse/keyboard input) */
+        HWND parent_id = GetProp (hWnd, "gl_window_parent_id");
+        if (parent_id)
+          PostMessage (parent_id, uMsg, wParam, lParam);
+        return DefWindowProc (hWnd, uMsg, wParam, lParam);
+      }
+    }
+
+    return 0;
+  }
+  else
+    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+}
+
+LRESULT FAR PASCAL sub_class_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+  WNDPROC window_parent_proc = GetProp (hWnd, "gl_window_parent_proc");
+
+  if (uMsg == WM_SIZE)
+  {
+    HWND gl_window_id = GetProp (hWnd, "gl_window_id");
+    MoveWindow (gl_window_id, 0, 0, LOWORD(lParam), HIWORD(lParam), FALSE);
+  }
+
+  return CallWindowProc (window_parent_proc, hWnd, uMsg, wParam, lParam);
+}
+
+const gchar* EGLErrorString()
+{
+  EGLint nErr = eglGetError();
+  switch(nErr){
+    case EGL_SUCCESS:
+      return "EGL_SUCCESS";
+    case EGL_BAD_DISPLAY:
+      return "EGL_BAD_DISPLAY";
+    case EGL_NOT_INITIALIZED:
+      return "EGL_NOT_INITIALIZED";
+    case EGL_BAD_ACCESS:
+      return "EGL_BAD_ACCESS";
+    case EGL_BAD_ALLOC:
+      return "EGL_BAD_ALLOC";
+    case EGL_BAD_ATTRIBUTE:
+      return "EGL_BAD_ATTRIBUTE";
+    case EGL_BAD_CONFIG:
+      return "EGL_BAD_CONFIG";
+    case EGL_BAD_CONTEXT:
+      return "EGL_BAD_CONTEXT";
+    case EGL_BAD_CURRENT_SURFACE:
+      return "EGL_BAD_CURRENT_SURFACE";
+    case EGL_BAD_MATCH:
+      return "EGL_BAD_MATCH";
+    case EGL_BAD_NATIVE_PIXMAP:
+      return "EGL_BAD_NATIVE_PIXMAP";
+    case EGL_BAD_NATIVE_WINDOW:
+      return "EGL_BAD_NATIVE_WINDOW";
+    case EGL_BAD_PARAMETER:
+      return "EGL_BAD_PARAMETER";
+    case EGL_BAD_SURFACE:
+      return "EGL_BAD_SURFACE";
+    default:
+      return "unknown";
+  }
+}