GL sink plugin. (Bug #147302)

Original commit message from CVS:
Patch from Gernot Ziegler <gz@lysator.liu.se> rewriting the
GL sink plugin.  (Bug #147302)
* configure.ac: Test for OpenGL
* sys/Makefile.am: Use test for OpenGL
* sys/glsink/Makefile.am:
* sys/glsink/glimagesink.c: rewrite
* sys/glsink/glimagesink.h: rewrite

1 files changed, 1610 insertions, 0 deletions

diff --git a/sys/glsink/glimagesink.c b/sys/glsink/glimagesink.c
new file mode 100644
index 00000000..65c06f51
--- /dev/null
+++ b/sys/glsink/glimagesink.c
@@ -0,0 +1,1610 @@
+/* GStreamer
+ * Copyright (C) <2003> Julien Moutte <julien@moutte.net>
+ *
+ * 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
+
+/* Our interfaces */
+#include <gst/navigation/navigation.h>
+#include <gst/xoverlay/xoverlay.h>
+
+/* Object header */
+#include "glimagesink.h"
+
+/* Debugging category */
+#include <gst/gstinfo.h>
+GST_DEBUG_CATEGORY_STATIC (gst_debug_glimagesink);
+#define GST_CAT_DEFAULT gst_debug_glimagesink
+
+static void gst_glimagesink_buffer_free (GstBuffer * buffer);
+
+/* ElementFactory information */
+static GstElementDetails gst_glimagesink_details =
+GST_ELEMENT_DETAILS ("Video sink",
+    "Sink/Video",
+    "An OpenGL 1.2 based videosink",
+    "Gernot Ziegler <gz@lysator.liu.se>, Julien Moutte <julien@moutte.net>");
+
+/* Default template - initiated with class struct to allow gst-register to work
+   without X running */
+static GstStaticPadTemplate gst_glimagesink_sink_template_factory =
+    GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/x-raw-rgb, "
+        "framerate = (double) [ 1.0, 100.0 ], "
+        "width = (int) [ 1, MAX ], "
+        "height = (int) [ 1, MAX ]; "
+        "video/x-raw-yuv, "
+        "framerate = (double) [ 1.0, 100.0 ], "
+        "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]")
+    );
+
+/* GLImageSink signals and args */
+enum
+{
+  SIGNAL_HANDOFF,
+  SIGNAL_BUFALLOC,
+  LAST_SIGNAL
+      /* FILL ME */
+};
+
+static guint gst_glimagesink_signals[LAST_SIGNAL] = { 0 };
+
+enum
+{
+  ARG_0,
+  ARG_DISPLAY,
+  ARG_SYNCHRONOUS,
+  ARG_SIGNAL_HANDOFFS
+      /* FILL ME */
+};
+
+static GstVideoSinkClass *parent_class = NULL;
+
+/* ============================================================= */
+/*                                                               */
+/*                       Private Methods                         */
+/*                                                               */
+/* ============================================================= */
+
+/* X11 and GLX stuff */
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+
+/* This function handles GstGLImage creation 
+   it creates data buffers and corresponding texture IDs */
+static GstGLImage *
+gst_glimagesink_ximage_new (GstGLImageSink * glimagesink, gint width,
+    gint height)
+{
+  GstGLImage *ximage = NULL;
+
+  g_return_val_if_fail (GST_IS_GLIMAGESINK (glimagesink), NULL);
+
+  ximage = g_new0 (GstGLImage, 1);
+
+  ximage->width = width;
+  ximage->height = height;
+  ximage->data = NULL;
+  ximage->glimagesink = glimagesink;
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  ximage->size =
+      (glimagesink->xcontext->bpp / 8) * ximage->width * ximage->height;
+
+  printf ("No ximage_new yet !\n");
+
+  {
+    ximage->data = g_malloc (ximage->size);
+
+    ximage->texid = 1000;
+  }
+
+  if (0)                        // can't fail ! 
+  {
+    if (ximage->data)
+      g_free (ximage->data);
+
+    g_free (ximage);
+    //ximage = NULL;
+  }
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  return ximage;
+}
+
+/* This function destroys a GstGLImage handling XShm availability */
+static void
+gst_glimagesink_ximage_destroy (GstGLImageSink * glimagesink,
+    GstGLImage * ximage)
+{
+  g_return_if_fail (ximage != NULL);
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  /* If the destroyed image is the current one we destroy our reference too */
+  if (glimagesink->cur_image == ximage)
+    glimagesink->cur_image = NULL;
+
+  printf ("No ximage_destroy implemented yet !\n");
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  {
+    //if (ximage->ximage) // FIXME: doesnt exist - dealloc textures
+    //  XDestroyImage (ximage->ximage);
+  }
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  g_free (ximage);
+}
+
+/* This function puts a GstGLImage on a GstGLImagesink's window */
+static void
+gst_glimagesink_ximage_put (GstGLImageSink * glimagesink, GstGLImage * ximage)
+{
+  g_return_if_fail (ximage != NULL);
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  if (glimagesink->signal_handoffs) {
+    g_warning ("Not drawing anything due to signal_handoffs !\n");
+    return;
+  }
+
+  /* Store a reference to the last image we put */
+  if (glimagesink->cur_image != ximage)
+    glimagesink->cur_image = ximage;
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  // both upload the video, and redraw the screen
+
+  //printf("No ximage_put yet !\n");
+
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+  glMatrixMode (GL_PROJECTION);
+  glLoadIdentity ();
+
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+  //glTranslatef(0.0, 0.0, -5.0);
+
+  glEnable (GL_TEXTURE_2D);
+
+  glBindTexture (GL_TEXTURE_2D, ximage->texid);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, ximage->width, ximage->height,
+      GL_RGB, GL_UNSIGNED_BYTE, ximage->data);
+
+  float xmax = (float) ximage->width / TEX_XSIZE;
+  float ymax = (float) ximage->height / TEX_YSIZE;
+
+  //float aspect = ximage->width/(float)ximage->height;
+
+  // don't know what to do with pixel aspect yet.
+  //float pixel_aspect = glimagesink->pixel_width/(float)glimagesink->pixel_height;
+
+  //if (aspect != pixel_aspect)
+  //  g_warning("screen aspect %f differs from pixel_aspect %f !", aspect, pixel_aspect);
+
+  glColor4f (1, 1, 1, 1);
+  glBegin (GL_QUADS);
+
+  glNormal3f (0, -1, 0);
+
+  glTexCoord2f (xmax, 0);
+  glVertex3f (1, 1, 0);
+
+  glTexCoord2f (0, 0);
+  glVertex3f (-1, 1, 0);
+
+  glTexCoord2f (0, ymax);
+  glVertex3f (-1, -1, 0);
+
+  glTexCoord2f (xmax, ymax);
+  glVertex3f (1, -1, 0);
+  glEnd ();
+
+#if 1                           // for pointer feedback, later
+  glDisable (GL_TEXTURE_2D);
+  if (glimagesink->pointer_moved)
+    glColor3f (1, 1, 1);
+  else
+    glColor3f (1, 0, 1);
+
+  if (glimagesink->pointer_button[0])
+    glColor3f (1, 0, 0);
+
+  float px = 2 * glimagesink->pointer_x / (float) ximage->width - 1.0;
+  float py = 2 * glimagesink->pointer_y / (float) ximage->height - 1.0;
+
+  glPointSize (10);
+  glBegin (GL_POINTS);
+  glVertex2f (px, -py);
+  glEnd ();
+#endif
+
+  glXSwapBuffers (glimagesink->xcontext->disp, glimagesink->window->win);
+
+  g_mutex_unlock (glimagesink->x_lock);
+}
+
+/* This function handles a GstXWindow creation */
+static GstGLWindow *
+gst_glimagesink_xwindow_new (GstGLImageSink * glimagesink, gint width,
+    gint height)
+{
+  GstGLWindow *xwindow = NULL;
+  GstXContext *xcontext = glimagesink->xcontext;
+
+  if (glimagesink->signal_handoffs) {
+    g_warning ("NOT CREATING any window due to signal_handoffs !\n");
+    return NULL;
+  }
+
+  g_return_val_if_fail (GST_IS_GLIMAGESINK (glimagesink), NULL);
+
+  xwindow = g_new0 (GstGLWindow, 1);
+
+  xwindow->width = width;
+  xwindow->height = height;
+  xwindow->internal = TRUE;
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  Colormap cmap;
+
+  /* create a color map */
+  cmap =
+      XCreateColormap (xcontext->disp, RootWindow (xcontext->disp,
+          xcontext->visualinfo->screen), xcontext->visualinfo->visual,
+      AllocNone);
+  xwindow->attr.colormap = cmap;
+  xwindow->attr.border_pixel = 0;
+
+#if 0
+  /* set sizes */
+  xwindow->x = 0;
+  xwindow->y = 0;
+  xwindow->width = 10;
+  xwindow->height = 10;
+
+  xwindow->rotX = 0;
+  xwindow->rotY = 0;
+  xwindow->zoom = 1;
+  xwindow->zoomdir = 0.01;
+#endif
+
+  xwindow->attr.event_mask =
+      ExposureMask | KeyPressMask | ButtonPressMask | StructureNotifyMask;
+
+  /* create a window in window mode */
+  xwindow->win =
+      XCreateWindow (xcontext->disp, /*xcontext->root, */
+      RootWindow (xcontext->disp, xcontext->visualinfo->screen),
+      0, 0, xwindow->width, xwindow->height, 0, xcontext->visualinfo->depth,
+      InputOutput, xcontext->visualinfo->visual,
+      CWBorderPixel | CWColormap | CWEventMask, &xwindow->attr);
+
+  /* only set window title and handle wm_delete_events if in windowed mode */
+  Atom wmDelete = XInternAtom (xcontext->disp, "WM_DELETE_WINDOW", True);
+
+  XSetWMProtocols (xcontext->disp, xwindow->win, &wmDelete, 1);
+  XSetStandardProperties (xcontext->disp, xwindow->win, "glsink",
+      "glsink", None, NULL, 0, NULL);
+
+#if 0
+  XSelectInput (xcontext->disp, xwindow->win,
+      ExposureMask | StructureNotifyMask);
+#else // we want more than that
+  XSelectInput (glimagesink->xcontext->disp, xwindow->win, ExposureMask |
+      StructureNotifyMask | PointerMotionMask | KeyPressMask |
+      KeyReleaseMask | ButtonPressMask | ButtonReleaseMask);
+#endif
+
+  //xwindow->win = XCreateSimpleWindow (glimagesink->xcontext->disp,
+  //    glimagesink->xcontext->root,
+  //    0, 0, xwindow->width, xwindow->height, 0, 0, glimagesink->xcontext->black);
+
+  XMapRaised (glimagesink->xcontext->disp, xwindow->win);
+
+  /* connect the glx-context to the window */
+  glXMakeCurrent (xcontext->disp, xwindow->win, xcontext->glx);
+
+  printf ("Initializing OpenGL parameters\n");
+  /* initialize OpenGL drawing */
+  glDisable (GL_DEPTH_TEST);
+  //glShadeModel(GL_SMOOTH);
+
+  glDisable (GL_TEXTURE_2D);
+  glDisable (GL_CULL_FACE);
+  glClearDepth (1.0f);
+  glClearColor (0, 0.5, 0, 1);
+
+  // both upload the video, and redraw the screen
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+
+  //glEnable(GL_LIGHT0);                                        // Quick And Dirty Lighting (Assumes Light0 Is Set Up)
+  //glEnable(GL_LIGHTING);                                      // Enable Lighting
+  glDisable (GL_COLOR_MATERIAL);        // Enable Material Coloring
+  glEnable (GL_AUTO_NORMAL);    // let OpenGL generate the Normals
+
+  glDisable (GL_BLEND);
+
+  glPolygonMode (GL_FRONT, GL_FILL);
+  glPolygonMode (GL_BACK, GL_FILL);
+
+  glShadeModel (GL_SMOOTH);
+  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
+  glBindTexture (GL_TEXTURE_2D, 1000);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA,
+      GL_UNSIGNED_BYTE, NULL);
+
+  glXSwapBuffers (xcontext->disp, xwindow->win);
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  gst_x_overlay_got_xwindow_id (GST_X_OVERLAY (glimagesink), xwindow->win);
+
+  return xwindow;
+}
+
+/* This function destroys a GstGLWindow */
+static void
+gst_glimagesink_xwindow_destroy (GstGLImageSink * glimagesink,
+    GstGLWindow * xwindow)
+{
+  GstXContext *xcontext = glimagesink->xcontext;
+
+  g_return_if_fail (xwindow != NULL);
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  if (glimagesink->signal_handoffs) {
+    g_warning ("NOT DESTROYING any window due to signal_handoff !\n");
+    return;
+  }
+
+  if (xcontext->glx) {
+    if (!glXMakeCurrent (xcontext->disp, None, NULL)) {
+      printf ("Could not release drawing context.\n");
+    }
+    glXDestroyContext (xcontext->disp, xcontext->glx);
+    xcontext->glx = NULL;
+  }
+#if 0                           // not used: prepared for fs mode
+  /* switch back to original desktop resolution if we were in fs */
+  if (GLWin.fs) {
+    XF86VidModeSwitchToMode (GLWin.dpy, GLWin.screen, &GLWin.deskMode);
+    XF86VidModeSetViewPort (GLWin.dpy, GLWin.screen, 0, 0);
+  }
+#endif
+
+  /* If we did not create that window we just free the GC and let it live */
+  if (xwindow->internal)
+    XDestroyWindow (glimagesink->xcontext->disp, xwindow->win);
+  else
+    XSelectInput (glimagesink->xcontext->disp, xwindow->win, 0);
+
+  printf ("Check Xwindow destroy !\n");
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  g_free (xwindow);
+}
+
+/* This function resizes a GstGLWindow */
+static void
+gst_glimagesink_xwindow_resize (GstGLImageSink * glimagesink,
+    GstGLWindow * xwindow, guint width, guint height)
+{
+  g_return_if_fail (xwindow != NULL);
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  xwindow->width = width;
+  xwindow->height = height;
+
+  XResizeWindow (glimagesink->xcontext->disp, xwindow->win,
+      xwindow->width, xwindow->height);
+
+  printf ("No xwindow resize implemented yet !\n");
+
+  g_mutex_unlock (glimagesink->x_lock);
+}
+
+static void
+gst_glimagesink_xwindow_update_geometry (GstGLImageSink * glimagesink,
+    GstGLWindow * xwindow)
+{
+  XWindowAttributes attr;
+
+  g_return_if_fail (xwindow != NULL);
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  /* Update the window geometry */
+  g_mutex_lock (glimagesink->x_lock);
+  XGetWindowAttributes (glimagesink->xcontext->disp,
+      glimagesink->window->win, &attr);
+  g_mutex_unlock (glimagesink->x_lock);
+
+  // FIXME: Need to introduce OpenGL setup here if PROJECTION_MATRIX depends on width/height
+  //printf("No update geometry implemented yet !\n");
+
+  glimagesink->window->width = attr.width;
+  glimagesink->window->height = attr.height;
+}
+
+#if 0
+static void
+gst_glimagesink_renegotiate_size (GstGLImageSink * glimagesink)
+{
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  if (!glimagesink->window)
+    return;
+
+  gst_glimagesink_xwindow_update_geometry (glimagesink, glimagesink->window);
+
+  if (glimagesink->window->width <= 1 || glimagesink->window->height <= 1)
+    return;
+
+  if (GST_PAD_IS_NEGOTIATING (GST_VIDEOSINK_PAD (glimagesink)) ||
+      !gst_pad_is_negotiated (GST_VIDEOSINK_PAD (glimagesink)))
+    return;
+
+  /* Window got resized or moved. We do caps negotiation again to get video
+     scaler to fit that new size only if size of the window differs from our
+     size. */
+
+  if (GST_VIDEOSINK_WIDTH (glimagesink) != glimagesink->window->width ||
+      GST_VIDEOSINK_HEIGHT (glimagesink) != glimagesink->window->height) {
+    GstPadLinkReturn r;
+
+    r = gst_pad_try_set_caps (GST_VIDEOSINK_PAD (glimagesink),
+        gst_caps_new_simple ("video/x-raw-rgb",
+            "bpp", G_TYPE_INT, glimagesink->xcontext->bpp,
+            "depth", G_TYPE_INT, glimagesink->xcontext->depth,
+            "endianness", G_TYPE_INT, glimagesink->xcontext->endianness,
+            "red_mask", G_TYPE_INT, glimagesink->xcontext->visual->red_mask,
+            "green_mask", G_TYPE_INT, glimagesink->xcontext->visual->green_mask,
+            "blue_mask", G_TYPE_INT, glimagesink->xcontext->visual->blue_mask,
+            "width", G_TYPE_INT, glimagesink->window->width,
+            "height", G_TYPE_INT, glimagesink->window->height,
+            "framerate", G_TYPE_DOUBLE, glimagesink->framerate, NULL));
+
+    if ((r == GST_PAD_LINK_OK) || (r == GST_PAD_LINK_DONE)) {
+      /* Renegotiation succeeded, we update our size and image */
+      GST_VIDEOSINK_WIDTH (glimagesink) = glimagesink->window->width;
+      GST_VIDEOSINK_HEIGHT (glimagesink) = glimagesink->window->height;
+
+      if ((glimagesink->glimage) &&
+          ((GST_VIDEOSINK_WIDTH (glimagesink) != glimagesink->glimage->width) ||
+              (GST_VIDEOSINK_HEIGHT (glimagesink) !=
+                  glimagesink->glimage->height))) {
+        /* We renew our ximage only if size changed */
+        gst_glimagesink_ximage_destroy (glimagesink, glimagesink->glimage);
+
+        glimagesink->glimage = gst_glimagesink_ximage_new (glimagesink,
+            GST_VIDEOSINK_WIDTH (glimagesink),
+            GST_VIDEOSINK_HEIGHT (glimagesink));
+      }
+    }
+  }
+}
+#endif
+
+/* This function handles XEvents that might be in the queue. It generates
+   GstEvent that will be sent upstream in the pipeline to handle interactivity
+   and navigation. It will also listen for configure events on the window to
+   trigger caps renegotiation so on the fly software scaling can work. */
+static void
+gst_glimagesink_handle_xevents (GstGLImageSink * glimagesink, GstPad * pad)
+{
+  XEvent e;
+
+  glimagesink->pointer_moved = FALSE;
+
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  //printf("handling xevents\n");
+
+  //gst_glimagesink_renegotiate_size (glimagesink);
+
+  /* Then we get all pointer motion events, only the last position is
+     interesting. */
+  g_mutex_lock (glimagesink->x_lock);
+  while (XCheckWindowEvent (glimagesink->xcontext->disp,
+          glimagesink->window->win, PointerMotionMask, &e)) {
+    g_mutex_unlock (glimagesink->x_lock);
+
+    switch (e.type) {
+      case MotionNotify:
+        glimagesink->pointer_x = e.xmotion.x;
+        glimagesink->pointer_y = e.xmotion.y;
+        glimagesink->pointer_moved = TRUE;
+        break;
+      default:
+        break;
+    }
+
+    g_mutex_lock (glimagesink->x_lock);
+  }
+  g_mutex_unlock (glimagesink->x_lock);
+
+  if (glimagesink->pointer_moved) {
+    GST_DEBUG ("glimagesink pointer moved over window at %d,%d",
+        glimagesink->pointer_x, glimagesink->pointer_y);
+    gst_navigation_send_mouse_event (GST_NAVIGATION (glimagesink),
+        "mouse-move", 0, glimagesink->pointer_x, glimagesink->pointer_y);
+  }
+
+  /* We get all remaining events on our window to throw them upstream */
+  g_mutex_lock (glimagesink->x_lock);
+  while (XCheckWindowEvent (glimagesink->xcontext->disp,
+          glimagesink->window->win,
+          KeyPressMask | KeyReleaseMask |
+          ButtonPressMask | ButtonReleaseMask, &e)) {
+    KeySym keysym;
+
+    /* We lock only for the X function call */
+    g_mutex_unlock (glimagesink->x_lock);
+
+    switch (e.type) {
+      case ButtonPress:
+        /* Mouse button pressed/released over our window. We send upstream
+           events for interactivity/navigation */
+        GST_DEBUG ("glimagesink button %d pressed over window at %d,%d",
+            e.xbutton.button, e.xbutton.x, e.xbutton.x);
+        glimagesink->pointer_button[e.xbutton.button - Button1] = TRUE;
+        gst_navigation_send_mouse_event (GST_NAVIGATION (glimagesink),
+            "mouse-button-press", e.xbutton.button, e.xbutton.x, e.xbutton.y);
+        break;
+      case ButtonRelease:
+        GST_DEBUG ("glimagesink button %d release over window at %d,%d",
+            e.xbutton.button, e.xbutton.x, e.xbutton.x);
+        glimagesink->pointer_button[e.xbutton.button - Button1] = FALSE;
+        gst_navigation_send_mouse_event (GST_NAVIGATION (glimagesink),
+            "mouse-button-release", e.xbutton.button, e.xbutton.x, e.xbutton.y);
+        break;
+      case KeyPress:
+      case KeyRelease:
+        /* Key pressed/released over our window. We send upstream
+           events for interactivity/navigation */
+        GST_DEBUG ("glimagesink key %d released over window at %d,%d",
+            e.xkey.keycode, e.xkey.x, e.xkey.x);
+        keysym = XKeycodeToKeysym (glimagesink->xcontext->disp,
+            e.xkey.keycode, 0);
+        if (keysym != NoSymbol) {
+          gst_navigation_send_key_event (GST_NAVIGATION (glimagesink),
+              e.type == KeyPress ?
+              "key-press" : "key-release", XKeysymToString (keysym));
+        } else {
+          gst_navigation_send_key_event (GST_NAVIGATION (glimagesink),
+              e.type == KeyPress ? "key-press" : "key-release", "unknown");
+        }
+        break;
+      default:
+        GST_DEBUG ("glimagesink unhandled X event (%d)", e.type);
+    }
+
+    g_mutex_lock (glimagesink->x_lock);
+  }
+  g_mutex_unlock (glimagesink->x_lock);
+}
+
+/* attributes for a single buffered visual in RGBA format with at least
+ * 4 bits per color and a 16 bit depth buffer */
+static int attrListSingle[] = {
+  GLX_RGBA,
+  GLX_RED_SIZE, 4,
+  GLX_GREEN_SIZE, 4,
+  GLX_BLUE_SIZE, 4,
+  GLX_DEPTH_SIZE, 16,
+  None
+};
+
+/* attributes for a double buffered visual in RGBA format with at least
+ * 4 bits per color and a 16 bit depth buffer */
+static int attrListDouble[] = {
+  GLX_RGBA, GLX_DOUBLEBUFFER,
+  GLX_RED_SIZE, 4,
+  GLX_GREEN_SIZE, 4,
+  GLX_BLUE_SIZE, 4,
+  GLX_DEPTH_SIZE, 16,
+  None
+};
+
+/* This function get the X Display and global infos about it. Everything is
+   stored in our object and will be cleaned when the object is disposed. Note
+   here that caps for supported format are generated without any window or 
+   image creation */
+static GstXContext *
+gst_glimagesink_xcontext_get (GstGLImageSink * glimagesink)
+{
+  printf ("Acquiring X context\n");
+
+  GstXContext *xcontext = NULL;
+
+  g_return_val_if_fail (GST_IS_GLIMAGESINK (glimagesink), NULL);
+
+  xcontext = g_new0 (GstXContext, 1);
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  xcontext->disp = XOpenDisplay (glimagesink->display_name);
+
+  if (!xcontext->disp) {
+    g_mutex_unlock (glimagesink->x_lock);
+    g_free (xcontext);
+    GST_ELEMENT_ERROR (glimagesink, RESOURCE, TOO_LAZY, (NULL),
+        ("Could not open display"));
+    return NULL;
+  }
+
+  xcontext->screen_num = DefaultScreen (xcontext->disp);
+  xcontext->screen = DefaultScreenOfDisplay (xcontext->disp);
+
+  /* get an appropriate visual */
+  xcontext->visualinfo =
+      glXChooseVisual (xcontext->disp, xcontext->screen_num, attrListDouble);
+  if (xcontext->visualinfo == NULL) {
+    xcontext->visualinfo =
+        glXChooseVisual (xcontext->disp, xcontext->screen_num, attrListSingle);
+    GST_DEBUG ("Only Singlebuffered Visual!\n");
+
+    if (xcontext->visualinfo == NULL)
+      GST_ELEMENT_ERROR (glimagesink, RESOURCE, TOO_LAZY, (NULL),
+          ("Could not open GLX connection"));
+  } else {
+    GST_DEBUG ("Got Doublebuffered Visual!\n");
+  }
+  int glxMajorVersion, glxMinorVersion;
+
+  glXQueryVersion (xcontext->disp, &glxMajorVersion, &glxMinorVersion);
+  GST_DEBUG ("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
+
+  printf ("Creating GLX context\n");
+
+  /* create a GLX context */
+  xcontext->glx =
+      glXCreateContext (xcontext->disp, xcontext->visualinfo, 0, GL_TRUE);
+
+  if (glXIsDirect (xcontext->disp, xcontext->glx))
+    printf ("Congrats, you have Direct Rendering!\n");
+  else
+    printf ("Sorry, no Direct Rendering possible!\n");
+
+  xcontext->endianness =
+      (ImageByteOrder (xcontext->disp) ==
+      LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN;
+
+  xcontext->visual = DefaultVisual (xcontext->disp, xcontext->screen_num);
+  xcontext->root = DefaultRootWindow (xcontext->disp);
+
+#if 1
+  XPixmapFormatValues *px_formats = NULL;
+  gint nb_formats = 0, i;
+
+  xcontext->white = XWhitePixel (xcontext->disp, xcontext->screen_num);
+  xcontext->black = XBlackPixel (xcontext->disp, xcontext->screen_num);
+  xcontext->depth = DefaultDepthOfScreen (xcontext->screen);
+
+  /* We get supported pixmap formats at supported depth */
+  px_formats = XListPixmapFormats (xcontext->disp, &nb_formats);
+
+  if (!px_formats) {
+    XCloseDisplay (xcontext->disp);
+    g_mutex_unlock (glimagesink->x_lock);
+    g_free (xcontext);
+    return NULL;
+  }
+
+  /* We get bpp value corresponding to our running depth */
+  for (i = 0; i < nb_formats; i++) {
+    if (px_formats[i].depth == xcontext->depth)
+      xcontext->bpp = px_formats[i].bits_per_pixel;
+  }
+
+  XFree (px_formats);
+#endif
+
+  /* our caps system handles 24/32bpp RGB as big-endian. */
+  if ((xcontext->bpp == 24 || xcontext->bpp == 32) &&
+      xcontext->endianness == G_LITTLE_ENDIAN) {
+    xcontext->endianness = G_BIG_ENDIAN;
+    xcontext->visual->red_mask = GUINT32_TO_BE (xcontext->visual->red_mask);
+    xcontext->visual->green_mask = GUINT32_TO_BE (xcontext->visual->green_mask);
+    xcontext->visual->blue_mask = GUINT32_TO_BE (xcontext->visual->blue_mask);
+    if (xcontext->bpp == 24) {
+      xcontext->visual->red_mask >>= 8;
+      xcontext->visual->green_mask >>= 8;
+      xcontext->visual->blue_mask >>= 8;
+    }
+  }
+
+  xcontext->endianness = G_BIG_ENDIAN;
+  xcontext->visual->red_mask = 0xff0000;
+  xcontext->visual->green_mask = 0xff00;
+  xcontext->visual->blue_mask = 0xff;
+  xcontext->bpp = 24;
+  xcontext->depth = 24;
+
+  //char yuvformat[4] = {'Y', 'V', '1', '2'};
+
+  if (!glimagesink->signal_handoffs)
+    xcontext->caps = gst_caps_new_simple ("video/x-raw-rgb",
+        "bpp", G_TYPE_INT, xcontext->bpp,
+        "depth", G_TYPE_INT, xcontext->depth,
+        "endianness", G_TYPE_INT, xcontext->endianness,
+        "red_mask", G_TYPE_INT, xcontext->visual->red_mask,
+        "green_mask", G_TYPE_INT, xcontext->visual->green_mask,
+        "blue_mask", G_TYPE_INT, xcontext->visual->blue_mask,
+        "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+        "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+        "framerate", GST_TYPE_DOUBLE_RANGE, 1.0, 100.0, NULL);
+  else
+    xcontext->caps = gst_caps_new_simple ("video/x-raw-yuv",
+        //                                      "format", GST_TYPE_FOURCC, GST_PROPS_FOURCC (GST_STR_FOURCC ("YV12")),
+        "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+        "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+        "framerate", GST_TYPE_DOUBLE_RANGE, 1.0, 100.0, NULL);
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  return xcontext;
+}
+
+/* This function cleans the X context. Closing the Display and unrefing the
+   caps for supported formats. */
+static void
+gst_glimagesink_xcontext_clear (GstGLImageSink * glimagesink)
+{
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  gst_caps_free (glimagesink->xcontext->caps);
+
+  g_mutex_lock (glimagesink->x_lock);
+
+  XCloseDisplay (glimagesink->xcontext->disp);
+
+  g_mutex_unlock (glimagesink->x_lock);
+
+  glimagesink->xcontext = NULL;
+}
+
+static void
+gst_glimagesink_imagepool_clear (GstGLImageSink * glimagesink)
+{
+  g_mutex_lock (glimagesink->pool_lock);
+
+  while (glimagesink->image_pool) {
+    GstGLImage *ximage = glimagesink->image_pool->data;
+
+    glimagesink->image_pool = g_slist_delete_link (glimagesink->image_pool,
+        glimagesink->image_pool);
+    gst_glimagesink_ximage_destroy (glimagesink, ximage);
+  }
+
+  g_mutex_unlock (glimagesink->pool_lock);
+}
+
+/* 
+=================
+Element stuff 
+=================
+*/
+
+static GstCaps *
+gst_glimagesink_fixate (GstPad * pad, const GstCaps * caps)
+{
+  printf ("Linking the sink\n");
+
+  GstStructure *structure;
+  GstCaps *newcaps;
+
+  if (gst_caps_get_size (caps) > 1)
+    return NULL;
+
+  newcaps = gst_caps_copy (caps);
+  structure = gst_caps_get_structure (newcaps, 0);
+
+  if (gst_caps_structure_fixate_field_nearest_int (structure, "width", 320)) {
+    return newcaps;
+  }
+  if (gst_caps_structure_fixate_field_nearest_int (structure, "height", 240)) {
+    return newcaps;
+  }
+  if (gst_caps_structure_fixate_field_nearest_double (structure, "framerate",
+          30.0)) {
+    return newcaps;
+  }
+
+  gst_caps_free (newcaps);
+  return NULL;
+}
+
+static GstCaps *
+gst_glimagesink_getcaps (GstPad * pad)
+{
+  GstGLImageSink *glimagesink;
+
+  glimagesink = GST_GLIMAGESINK (gst_pad_get_parent (pad));
+
+  if (glimagesink->xcontext)
+    return gst_caps_copy (glimagesink->xcontext->caps);
+
+#if 0
+  if (!glimagesink->signal_handoffs)
+    return gst_caps_from_string ("video/x-raw-rgb, "
+        "framerate = (double) [ 1, 100 ], "
+        "width = (int) [ 0, MAX ], " "height = (int) [ 0, MAX ]");
+  else
+#endif
+    return gst_caps_from_string ("video/x-raw-yuv, "
+        "framerate = (double) [ 1, 100 ], "
+        "width = (int) [ 0, MAX ], " "height = (int) [ 0, MAX ]");
+}
+
+static GstPadLinkReturn
+gst_glimagesink_sink_link (GstPad * pad, const GstCaps * caps)
+{
+  GstGLImageSink *glimagesink;
+  gboolean ret;
+  GstStructure *structure;
+
+  glimagesink = GST_GLIMAGESINK (gst_pad_get_parent (pad));
+
+  if (!glimagesink->xcontext)
+    return GST_PAD_LINK_DELAYED;
+
+  GST_DEBUG_OBJECT (glimagesink,
+      "sinkconnect possible caps %" GST_PTR_FORMAT " with given caps %"
+      GST_PTR_FORMAT, glimagesink->xcontext->caps, caps);
+
+  structure = gst_caps_get_structure (caps, 0);
+  ret = gst_structure_get_int (structure, "width",
+      &(GST_VIDEOSINK_WIDTH (glimagesink)));
+  ret &= gst_structure_get_int (structure, "height",
+      &(GST_VIDEOSINK_HEIGHT (glimagesink)));
+  ret &= gst_structure_get_double (structure,
+      "framerate", &glimagesink->framerate);
+  if (!ret)
+    return GST_PAD_LINK_REFUSED;
+
+  glimagesink->pixel_width = 1;
+  gst_structure_get_int (structure, "pixel_width", &glimagesink->pixel_width);
+
+  glimagesink->pixel_height = 1;
+  gst_structure_get_int (structure, "pixel_height", &glimagesink->pixel_height);
+
+  /* Creating our window and our image */
+  if (!glimagesink->window)
+    glimagesink->window = gst_glimagesink_xwindow_new (glimagesink,
+        GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+  else {
+    if (glimagesink->window->internal)
+      gst_glimagesink_xwindow_resize (glimagesink, glimagesink->window,
+          GST_VIDEOSINK_WIDTH (glimagesink),
+          GST_VIDEOSINK_HEIGHT (glimagesink));
+  }
+
+  if ((glimagesink->glimage) && ((GST_VIDEOSINK_WIDTH (glimagesink) != glimagesink->glimage->width) || (GST_VIDEOSINK_HEIGHT (glimagesink) != glimagesink->glimage->height))) { /* We renew our ximage only if size changed */
+    gst_glimagesink_ximage_destroy (glimagesink, glimagesink->glimage);
+
+    glimagesink->glimage = gst_glimagesink_ximage_new (glimagesink,
+        GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+  } else if (!glimagesink->glimage)     /* If no ximage, creating one */
+    glimagesink->glimage = gst_glimagesink_ximage_new (glimagesink,
+        GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+
+  gst_x_overlay_got_desired_size (GST_X_OVERLAY (glimagesink),
+      GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+
+  return GST_PAD_LINK_OK;
+}
+
+static GstElementStateReturn
+gst_glimagesink_change_state (GstElement * element)
+{
+  GstGLImageSink *glimagesink;
+
+  printf ("change state\n");
+
+  glimagesink = GST_GLIMAGESINK (element);
+
+  switch (GST_STATE_TRANSITION (element)) {
+    case GST_STATE_NULL_TO_READY:
+      /* Initializing the XContext */
+      if (!glimagesink->xcontext) {
+        glimagesink->xcontext = gst_glimagesink_xcontext_get (glimagesink);
+        if (!glimagesink->xcontext)
+          return GST_STATE_FAILURE;
+      }
+      printf ("null to ready done\n");
+      break;
+    case GST_STATE_READY_TO_PAUSED:
+      printf ("ready to paused\n");
+      //if (glimagesink->window) // not needed with OpenGL
+      //  gst_glimagesink_xwindow_clear (glimagesink, glimagesink->window);
+      glimagesink->time = 0;
+      break;
+    case GST_STATE_PAUSED_TO_PLAYING:
+      break;
+    case GST_STATE_PLAYING_TO_PAUSED:
+      break;
+    case GST_STATE_PAUSED_TO_READY:
+      glimagesink->framerate = 0;
+      GST_VIDEOSINK_WIDTH (glimagesink) = 0;
+      GST_VIDEOSINK_HEIGHT (glimagesink) = 0;
+      break;
+    case GST_STATE_READY_TO_NULL:
+      if (glimagesink->glimage) {
+        gst_glimagesink_ximage_destroy (glimagesink, glimagesink->glimage);
+        glimagesink->glimage = NULL;
+      }
+
+      if (glimagesink->image_pool)
+        gst_glimagesink_imagepool_clear (glimagesink);
+
+      if (glimagesink->window) {
+        gst_glimagesink_xwindow_destroy (glimagesink, glimagesink->window);
+        glimagesink->window = NULL;
+      }
+
+      if (glimagesink->xcontext) {
+        gst_glimagesink_xcontext_clear (glimagesink);
+        glimagesink->xcontext = NULL;
+      }
+      break;
+  }
+
+  if (GST_ELEMENT_CLASS (parent_class)->change_state)
+    return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+
+  return GST_STATE_SUCCESS;
+}
+
+static void
+gst_glimagesink_chain (GstPad * pad, GstData * data)
+{
+  GstBuffer *buf = GST_BUFFER (data);
+  GstGLImageSink *glimagesink;
+
+  //printf("CHAIN CALL\n");
+
+  g_return_if_fail (GST_IS_PAD (pad));
+  g_return_if_fail (buf != NULL);
+
+  glimagesink = GST_GLIMAGESINK (gst_pad_get_parent (pad));
+
+  if (GST_IS_EVENT (data)) {
+    gst_pad_event_default (pad, GST_EVENT (data));
+    return;
+  }
+
+  buf = GST_BUFFER (data);
+  /* update time */
+  if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
+    glimagesink->time = GST_BUFFER_TIMESTAMP (buf);
+  }
+
+  if (glimagesink->signal_handoffs)
+    g_signal_emit (G_OBJECT (glimagesink),
+        gst_glimagesink_signals[SIGNAL_HANDOFF], 0, buf, pad);
+  else {
+    /* If this buffer has been allocated using our buffer management we simply
+       put the ximage which is in the PRIVATE pointer */
+    if (GST_BUFFER_FREE_DATA_FUNC (buf) == gst_glimagesink_buffer_free)
+      gst_glimagesink_ximage_put (glimagesink, GST_BUFFER_PRIVATE (buf));
+    else {                      /* Else we have to copy the data into our private image, */
+      /* if we have one... */
+      printf ("Non-locally allocated: Sub-optimal buffer transfer!\n");
+      if (glimagesink->glimage) {
+#if 0
+        memcpy (glimagesink->glimage->ximage->data,
+            GST_BUFFER_DATA (buf),
+            MIN (GST_BUFFER_SIZE (buf), glimagesink->glimage->size));
+#endif
+        gst_glimagesink_ximage_put (glimagesink, glimagesink->glimage);
+      } else {                  /* No image available. Something went wrong during capsnego ! */
+
+        gst_buffer_unref (buf);
+        GST_ELEMENT_ERROR (glimagesink, CORE, NEGOTIATION, (NULL),
+            ("no format defined before chain function"));
+        return;
+      }
+    }
+  }
+
+  GST_DEBUG ("clock wait: %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (glimagesink->time));
+
+  /// ah, BTW, I think the gst_element_wait should happen _before_ the ximage is shown
+  if (GST_VIDEOSINK_CLOCK (glimagesink))
+    gst_element_wait (GST_ELEMENT (glimagesink), glimagesink->time);
+
+  /* set correct time for next buffer */
+  if (!GST_BUFFER_TIMESTAMP_IS_VALID (buf) && glimagesink->framerate > 0)
+    glimagesink->time += GST_SECOND / glimagesink->framerate;
+
+  gst_buffer_unref (buf);
+
+  if (!glimagesink->signal_handoffs)
+    gst_glimagesink_handle_xevents (glimagesink, pad);
+}
+
+/* Buffer management */
+
+static void
+gst_glimagesink_buffer_free (GstBuffer * buffer)
+{
+  GstGLImageSink *glimagesink;
+  GstGLImage *ximage;
+
+  ximage = GST_BUFFER_PRIVATE (buffer);
+
+  g_assert (GST_IS_GLIMAGESINK (ximage->glimagesink));
+  glimagesink = ximage->glimagesink;
+
+  /* If our geometry changed we can't reuse that image. */
+  if ((ximage->width != GST_VIDEOSINK_WIDTH (glimagesink)) ||
+      (ximage->height != GST_VIDEOSINK_HEIGHT (glimagesink)))
+    gst_glimagesink_ximage_destroy (glimagesink, ximage);
+  else {                        /* In that case we can reuse the image and add it to our image pool. */
+
+    g_mutex_lock (glimagesink->pool_lock);
+    glimagesink->image_pool = g_slist_prepend (glimagesink->image_pool, ximage);
+    g_mutex_unlock (glimagesink->pool_lock);
+  }
+}
+
+static GstBuffer *
+gst_glimagesink_buffer_alloc (GstPad * pad, guint64 offset, guint size)
+{
+  GstGLImageSink *glimagesink;
+  GstBuffer *buffer;
+  GstGLImage *ximage = NULL;
+  gboolean not_found = TRUE;
+
+  //printf("Allocating new data buffer\n");
+
+  glimagesink = GST_GLIMAGESINK (gst_pad_get_parent (pad));
+
+  g_mutex_lock (glimagesink->pool_lock);
+
+  /* Walking through the pool cleaning unsuable images and searching for a
+     suitable one */
+  while (not_found && glimagesink->image_pool) {
+    ximage = glimagesink->image_pool->data;
+
+    if (ximage) {
+      /* Removing from the pool */
+      glimagesink->image_pool = g_slist_delete_link (glimagesink->image_pool,
+          glimagesink->image_pool);
+
+      if ((ximage->width != GST_VIDEOSINK_WIDTH (glimagesink)) || (ximage->height != GST_VIDEOSINK_HEIGHT (glimagesink))) {     /* This image is unusable. Destroying... */
+        gst_glimagesink_ximage_destroy (glimagesink, ximage);
+        ximage = NULL;
+      } else {                  /* We found a suitable image */
+
+        break;
+      }
+    }
+  }
+
+  g_mutex_unlock (glimagesink->pool_lock);
+
+  if (!ximage) {                /* We found no suitable image in the pool. Creating... */
+    ximage = gst_glimagesink_ximage_new (glimagesink,
+        GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+  }
+
+  if (ximage) {
+    buffer = gst_buffer_new ();
+
+    /* Storing some pointers in the buffer */
+    GST_BUFFER_PRIVATE (buffer) = ximage;
+
+    GST_BUFFER_DATA (buffer) = ximage->data;
+    GST_BUFFER_FREE_DATA_FUNC (buffer) = gst_glimagesink_buffer_free;
+    GST_BUFFER_SIZE (buffer) = ximage->size;
+    return buffer;
+  } else
+    return NULL;
+}
+
+/* Interfaces stuff */
+
+static gboolean
+gst_glimagesink_interface_supported (GstImplementsInterface * iface, GType type)
+{
+  g_assert (type == GST_TYPE_NAVIGATION || type == GST_TYPE_X_OVERLAY);
+  return TRUE;
+}
+
+static void
+gst_glimagesink_interface_init (GstImplementsInterfaceClass * klass)
+{
+  klass->supported = gst_glimagesink_interface_supported;
+}
+
+static void
+gst_glimagesink_navigation_send_event (GstNavigation * navigation,
+    GstStructure * structure)
+{
+  GstGLImageSink *glimagesink = GST_GLIMAGESINK (navigation);
+  GstEvent *event;
+  gint x_offset, y_offset;
+  double x, y;
+
+  event = gst_event_new (GST_EVENT_NAVIGATION);
+  event->event_data.structure.structure = structure;
+
+  /* We are not converting the pointer coordinates as there's no hardware 
+     scaling done here. The only possible scaling is done by videoscale and
+     videoscale will have to catch those events and tranform the coordinates
+     to match the applied scaling. So here we just add the offset if the image
+     is centered in the window.  */
+
+  x_offset = glimagesink->window->width - GST_VIDEOSINK_WIDTH (glimagesink);
+  y_offset = glimagesink->window->height - GST_VIDEOSINK_HEIGHT (glimagesink);
+
+  if (gst_structure_get_double (structure, "pointer_x", &x)) {
+    x += x_offset;
+    gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE, x, NULL);
+  }
+  if (gst_structure_get_double (structure, "pointer_y", &y)) {
+    y += y_offset;
+    gst_structure_set (structure, "pointer_y", G_TYPE_DOUBLE, y, NULL);
+  }
+
+  gst_pad_send_event (gst_pad_get_peer (GST_VIDEOSINK_PAD (glimagesink)),
+      event);
+}
+
+static void
+gst_glimagesink_navigation_init (GstNavigationInterface * iface)
+{
+  iface->send_event = gst_glimagesink_navigation_send_event;
+}
+
+static void
+gst_glimagesink_set_xwindow_id (GstXOverlay * overlay, XID xwindow_id)
+{
+  GstGLImageSink *glimagesink = GST_GLIMAGESINK (overlay);
+  GstGLWindow *xwindow = NULL;
+  XWindowAttributes attr;
+
+  printf ("set_xwindow_id\n");
+
+  g_return_if_fail (GST_IS_GLIMAGESINK (glimagesink));
+
+  /* If we already use that window return */
+  if (glimagesink->window && (xwindow_id == glimagesink->window->win))
+    return;
+
+  /* If the element has not initialized the X11 context try to do so */
+  if (!glimagesink->xcontext)
+    glimagesink->xcontext = gst_glimagesink_xcontext_get (glimagesink);
+
+  if (!glimagesink->xcontext) {
+    g_warning ("glimagesink was unable to obtain the X11 context.");
+    return;
+  }
+
+  /* Clear image pool as the images are unusable anyway */
+  gst_glimagesink_imagepool_clear (glimagesink);
+
+  /* Clear the ximage */
+  if (glimagesink->glimage) {
+    gst_glimagesink_ximage_destroy (glimagesink, glimagesink->glimage);
+    glimagesink->glimage = NULL;
+  }
+
+  /* If a window is there already we destroy it */
+  if (glimagesink->window) {
+    gst_glimagesink_xwindow_destroy (glimagesink, glimagesink->window);
+    glimagesink->window = NULL;
+  }
+
+  /* If the xid is 0 we go back to an internal window */
+  if (xwindow_id == 0) {
+    /* If no width/height caps nego did not happen window will be created
+       during caps nego then */
+    if (GST_VIDEOSINK_WIDTH (glimagesink) && GST_VIDEOSINK_HEIGHT (glimagesink)) {
+      xwindow = gst_glimagesink_xwindow_new (glimagesink,
+          GST_VIDEOSINK_WIDTH (glimagesink),
+          GST_VIDEOSINK_HEIGHT (glimagesink));
+    }
+  } else {
+    GST_ELEMENT_ERROR (glimagesink, RESOURCE, TOO_LAZY, (NULL),
+        ("glimagesink is incapable of connecting to other X windows !"));
+    exit (100);
+
+    xwindow = g_new0 (GstGLWindow, 1);
+
+    xwindow->win = xwindow_id;
+
+    /* We get window geometry, set the event we want to receive,
+       and create a GC */
+    g_mutex_lock (glimagesink->x_lock);
+    XGetWindowAttributes (glimagesink->xcontext->disp, xwindow->win, &attr);
+    xwindow->width = attr.width;
+    xwindow->height = attr.height;
+    xwindow->internal = FALSE;
+    XSelectInput (glimagesink->xcontext->disp, xwindow->win, ExposureMask |
+        StructureNotifyMask | PointerMotionMask | KeyPressMask |
+        KeyReleaseMask);
+
+    //xwindow->gc = XCreateGC (glimagesink->xcontext->disp, xwindow->win, 0, NULL);
+    g_mutex_unlock (glimagesink->x_lock);
+
+    /* If that new window geometry differs from our one we try to 
+       renegotiate caps */
+    if (gst_pad_is_negotiated (GST_VIDEOSINK_PAD (glimagesink)) &&
+        (xwindow->width != GST_VIDEOSINK_WIDTH (glimagesink) ||
+            xwindow->height != GST_VIDEOSINK_HEIGHT (glimagesink))) {
+      GstPadLinkReturn r;
+
+      r = gst_pad_try_set_caps (GST_VIDEOSINK_PAD (glimagesink),
+          gst_caps_new_simple ("video/x-raw-rgb",
+              "bpp", G_TYPE_INT, glimagesink->xcontext->bpp,
+              "depth", G_TYPE_INT, glimagesink->xcontext->depth,
+              "endianness", G_TYPE_INT, glimagesink->xcontext->endianness,
+              "red_mask", G_TYPE_INT, glimagesink->xcontext->visual->red_mask,
+              "green_mask", G_TYPE_INT,
+              glimagesink->xcontext->visual->green_mask, "blue_mask",
+              G_TYPE_INT, glimagesink->xcontext->visual->blue_mask, "width",
+              G_TYPE_INT, xwindow->width, "height", G_TYPE_INT, xwindow->height,
+              "framerate", G_TYPE_DOUBLE, glimagesink->framerate, NULL));
+
+      /* If caps nego succeded updating our size */
+      if ((r == GST_PAD_LINK_OK) || (r == GST_PAD_LINK_DONE)) {
+        GST_VIDEOSINK_WIDTH (glimagesink) = xwindow->width;
+        GST_VIDEOSINK_HEIGHT (glimagesink) = xwindow->height;
+      }
+    }
+  }
+
+  /* Recreating our ximage */
+  if (!glimagesink->glimage &&
+      GST_VIDEOSINK_WIDTH (glimagesink) && GST_VIDEOSINK_HEIGHT (glimagesink)) {
+    glimagesink->glimage = gst_glimagesink_ximage_new (glimagesink,
+        GST_VIDEOSINK_WIDTH (glimagesink), GST_VIDEOSINK_HEIGHT (glimagesink));
+  }
+
+  if (xwindow)
+    glimagesink->window = xwindow;
+}
+
+static void
+gst_glimagesink_get_desired_size (GstXOverlay * overlay,
+    guint * width, guint * height)
+{
+  GstGLImageSink *glimagesink = GST_GLIMAGESINK (overlay);
+
+  *width = GST_VIDEOSINK_WIDTH (glimagesink);
+  *height = GST_VIDEOSINK_HEIGHT (glimagesink);
+}
+
+static void
+gst_glimagesink_expose (GstXOverlay * overlay)
+{
+  GstGLImageSink *glimagesink = GST_GLIMAGESINK (overlay);
+
+  if (!glimagesink->window)
+    return;
+
+  gst_glimagesink_xwindow_update_geometry (glimagesink, glimagesink->window);
+
+  /* We don't act on internal window from outside that could cause some thread
+     race with the video sink own thread checking for configure event */
+  if (glimagesink->window->internal)
+    return;
+
+  //gst_glimagesink_xwindow_clear (glimagesink, glimagesink->window);
+
+  if (glimagesink->cur_image)
+    gst_glimagesink_ximage_put (glimagesink, glimagesink->cur_image);
+}
+
+static void
+gst_glimagesink_xoverlay_init (GstXOverlayClass * iface)
+{
+  iface->set_xwindow_id = gst_glimagesink_set_xwindow_id;
+  iface->get_desired_size = gst_glimagesink_get_desired_size;
+  iface->expose = gst_glimagesink_expose;
+}
+
+/* =========================================== */
+/*                                             */
+/*              Init & Class init              */
+/*                                             */
+/* =========================================== */
+
+static void
+gst_glimagesink_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstGLImageSink *glimagesink;
+
+  g_return_if_fail (GST_IS_GLIMAGESINK (object));
+
+  glimagesink = GST_GLIMAGESINK (object);
+
+  switch (prop_id) {
+    case ARG_DISPLAY:
+      glimagesink->display_name = g_strdup (g_value_get_string (value));
+      break;
+    case ARG_SYNCHRONOUS:
+      glimagesink->synchronous = g_value_get_boolean (value);
+      if (glimagesink->xcontext) {
+        XSynchronize (glimagesink->xcontext->disp, glimagesink->synchronous);
+    case ARG_SIGNAL_HANDOFFS:
+        glimagesink->signal_handoffs = g_value_get_boolean (value);
+        break;
+      }
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_glimagesink_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstGLImageSink *glimagesink;
+
+  g_return_if_fail (GST_IS_GLIMAGESINK (object));
+
+  glimagesink = GST_GLIMAGESINK (object);
+
+  switch (prop_id) {
+    case ARG_DISPLAY:
+      g_value_set_string (value, g_strdup (glimagesink->display_name));
+      break;
+    case ARG_SYNCHRONOUS:
+      g_value_set_boolean (value, glimagesink->synchronous);
+      break;
+    case ARG_SIGNAL_HANDOFFS:
+      g_value_set_boolean (value, glimagesink->signal_handoffs);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_glimagesink_dispose (GObject * object)
+{
+  GstGLImageSink *glimagesink;
+
+  glimagesink = GST_GLIMAGESINK (object);
+
+  if (glimagesink->display_name) {
+    g_free (glimagesink->display_name);
+    glimagesink->display_name = NULL;
+  }
+
+  g_mutex_free (glimagesink->x_lock);
+  g_mutex_free (glimagesink->pool_lock);
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gst_glimagesink_init (GstGLImageSink * glimagesink)
+{
+  GST_VIDEOSINK_PAD (glimagesink) =
+      gst_pad_new_from_template (gst_static_pad_template_get
+      (&gst_glimagesink_sink_template_factory), "sink");
+
+  gst_element_add_pad (GST_ELEMENT (glimagesink),
+      GST_VIDEOSINK_PAD (glimagesink));
+
+  gst_pad_set_chain_function (GST_VIDEOSINK_PAD (glimagesink),
+      gst_glimagesink_chain);
+  gst_pad_set_link_function (GST_VIDEOSINK_PAD (glimagesink),
+      gst_glimagesink_sink_link);
+  gst_pad_set_getcaps_function (GST_VIDEOSINK_PAD (glimagesink),
+      gst_glimagesink_getcaps);
+  gst_pad_set_fixate_function (GST_VIDEOSINK_PAD (glimagesink),
+      gst_glimagesink_fixate);
+  gst_pad_set_bufferalloc_function (GST_VIDEOSINK_PAD (glimagesink),
+      gst_glimagesink_buffer_alloc);
+
+  glimagesink->display_name = NULL;
+  glimagesink->xcontext = NULL;
+  glimagesink->window = NULL;
+  glimagesink->glimage = NULL;
+  glimagesink->cur_image = NULL;
+
+  glimagesink->framerate = 0;
+
+  glimagesink->x_lock = g_mutex_new ();
+
+  glimagesink->pixel_width = glimagesink->pixel_height = 1;
+
+  glimagesink->image_pool = NULL;
+  glimagesink->pool_lock = g_mutex_new ();
+
+  glimagesink->synchronous = FALSE;
+  glimagesink->signal_handoffs = FALSE;
+
+  GST_FLAG_SET (glimagesink, GST_ELEMENT_THREAD_SUGGESTED);
+  GST_FLAG_SET (glimagesink, GST_ELEMENT_EVENT_AWARE);
+}
+
+static void
+gst_glimagesink_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_set_details (element_class, &gst_glimagesink_details);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_glimagesink_sink_template_factory));
+}
+
+static void
+gst_glimagesink_class_init (GstGLImageSinkClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_ref (GST_TYPE_VIDEOSINK);
+
+  g_object_class_install_property (gobject_class, ARG_DISPLAY,
+      g_param_spec_string ("display", "Display", "X Display name",
+          NULL, G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class, ARG_SYNCHRONOUS,
+      g_param_spec_boolean ("synchronous", "Synchronous", "When enabled, runs "
+          "the X display in synchronous mode. (used only for debugging)", FALSE,
+          G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class, ARG_SIGNAL_HANDOFFS,
+      g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
+          "Send a signal before unreffing the buffer, forces YUV, no GL output",
+          FALSE, G_PARAM_READWRITE));
+#if 0                           // needed ?
+  g_object_class_install_property (gobject_class, ARG_SIGNAL_BUFFER_ALLOC,
+      g_param_spec_boolean ("signal-bufferalloc", "Signal buffer allocation",
+          "Asks the application for a buffer allocation", FALSE,
+          G_PARAM_READWRITE));
+#endif
+
+  gst_glimagesink_signals[SIGNAL_HANDOFF] =
+      g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+      G_STRUCT_OFFSET (GstGLImageSinkClass, handoff), NULL, NULL,
+      gst_marshal_VOID__POINTER_OBJECT, G_TYPE_NONE, 2,
+      GST_TYPE_BUFFER, GST_TYPE_PAD);
+  gst_glimagesink_signals[SIGNAL_BUFALLOC] =
+      g_signal_new ("bufferalloc", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
+      G_STRUCT_OFFSET (GstGLImageSinkClass, bufferalloc), NULL, NULL,
+      gst_marshal_VOID__POINTER_OBJECT, G_TYPE_NONE, 2,
+      GST_TYPE_BUFFER, GST_TYPE_PAD);
+
+  gobject_class->dispose = gst_glimagesink_dispose;
+  gobject_class->set_property = gst_glimagesink_set_property;
+  gobject_class->get_property = gst_glimagesink_get_property;
+
+  gstelement_class->change_state = gst_glimagesink_change_state;
+}
+
+/* ============================================================= */
+/*                                                               */
+/*                       Public Methods                          */
+/*                                                               */
+/* ============================================================= */
+
+/* =========================================== */
+/*                                             */
+/*          Object typing & Creation           */
+/*                                             */
+/* =========================================== */
+
+GType
+gst_glimagesink_get_type (void)
+{
+  static GType glimagesink_type = 0;
+
+  if (!glimagesink_type) {
+    static const GTypeInfo glimagesink_info = {
+      sizeof (GstGLImageSinkClass),
+      gst_glimagesink_base_init,
+      NULL,
+      (GClassInitFunc) gst_glimagesink_class_init,
+      NULL,
+      NULL,
+      sizeof (GstGLImageSink),
+      0,
+      (GInstanceInitFunc) gst_glimagesink_init,
+    };
+    static const GInterfaceInfo iface_info = {
+      (GInterfaceInitFunc) gst_glimagesink_interface_init,
+      NULL,
+      NULL,
+    };
+    static const GInterfaceInfo navigation_info = {
+      (GInterfaceInitFunc) gst_glimagesink_navigation_init,
+      NULL,
+      NULL,
+    };
+    static const GInterfaceInfo overlay_info = {
+      (GInterfaceInitFunc) gst_glimagesink_xoverlay_init,
+      NULL,
+      NULL,
+    };
+
+    glimagesink_type = g_type_register_static (GST_TYPE_VIDEOSINK,
+        "GstGLImageSink", &glimagesink_info, 0);
+
+    g_type_add_interface_static (glimagesink_type,
+        GST_TYPE_IMPLEMENTS_INTERFACE, &iface_info);
+    g_type_add_interface_static (glimagesink_type, GST_TYPE_NAVIGATION,
+        &navigation_info);
+    g_type_add_interface_static (glimagesink_type, GST_TYPE_X_OVERLAY,
+        &overlay_info);
+  }
+
+  return glimagesink_type;
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  /* Loading the library containing GstVideoSink, our parent object */
+  if (!gst_library_load ("gstvideo"))
+    return FALSE;
+
+  if (!gst_element_register (plugin, "glimagesink",
+          GST_RANK_SECONDARY, GST_TYPE_GLIMAGESINK))
+    return FALSE;
+
+  GST_DEBUG_CATEGORY_INIT (gst_debug_glimagesink, "glimagesink", 0,
+      "glimagesink element");
+
+  return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "glimagesink",
+    "OpenGL video output plugin based on OpenGL 1.2 calls",
+    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN)