glsink files checked in

Original commit message from CVS:
glsink files checked in

6 files changed, 1711 insertions, 0 deletions

diff --git a/sys/glsink/Makefile.am b/sys/glsink/Makefile.am
new file mode 100644
index 000000000..8c7838c8d
--- /dev/null
+++ b/sys/glsink/Makefile.am
@@ -0,0 +1,10 @@
+plugindir = $(libdir)/gstreamer-@GST_MAJORMINOR@
+
+plugin_LTLIBRARIES = libgstglsink.la
+
+libgstglsink_la_SOURCES = gstglsink.c gstglxwindow.c gstgl_rgbimage.c gstgl_nvimage.c
+libgstglsink_la_CFLAGS = $(GST_CFLAGS)
+libgstglsink_la_LIBADD = $(X_LIBS) $(XVIDEO_LIBS) -lGL -lGLU -lglut
+libgstglsink_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+
+noinst_HEADERS = gstglsink.h
diff --git a/sys/glsink/gstgl_nvimage.c b/sys/glsink/gstgl_nvimage.c
new file mode 100644
index 000000000..faa5224c7
--- /dev/null
+++ b/sys/glsink/gstgl_nvimage.c
@@ -0,0 +1,388 @@
+#include "config.h"
+
+#include <gst/gst.h>
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+#  define _XOPEN_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#define GL_GLEXT_PROTOTYPES
+
+// VERY dangerous:
+#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glu.h>
+#include <string.h>
+
+#include "gstglsink.h"
+
+typedef struct _GstGLImageConnection GstGLImageConnection;
+struct _GstGLImageConnection {
+  GstImageConnection conn;
+  Display *dpy;
+  gint w, h;
+  gint bpp;
+  
+  int ytex_id;
+  int uvtex_id;
+  int septex_id; 
+  unsigned char *m_memory;
+  int m_bufslots[4];
+};
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+#define YUVTEX_SIZE ((TEX_XSIZE * TEX_YSIZE) * 3 /2)
+
+#define AGP_BUFSLOTS 4
+
+typedef struct _GstNvImage GstNvImage;
+struct _GstNvImage
+{
+  GstImageData data;
+  int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
+  GstGLImageConnection *conn;
+};
+
+static GstGLImageInfo *		gst_gl_nvimage_info			(GstImageInfo *info);
+static GstGLImageConnection *	gst_gl_nvimage_connection 		(GstImageConnection *conn);
+static gboolean 		gst_gl_nvimage_check_xvideo	();
+
+static GstCaps * 		gst_gl_nvimage_get_caps		(GstImageInfo *info); 
+static GstImageConnection *	gst_gl_nvimage_set_caps		(GstImageInfo *info, GstCaps *caps);
+static GstImageData *		gst_gl_nvimage_get_image		(GstImageInfo *info, GstImageConnection *conn);
+static void 			gst_gl_nvimage_put_image		(GstImageInfo *info, GstImageData *image);
+static void 			gst_gl_nvimage_free_image		(GstImageData *image);
+static void 			gst_gl_nvimage_open_conn		(GstImageConnection *conn, GstImageInfo *info);
+static void 			gst_gl_nvimage_close_conn		(GstImageConnection *conn, GstImageInfo *info);
+static void 			gst_gl_nvimage_free_conn		(GstImageConnection *conn);
+
+GstImagePlugin* get_gl_nvimage_plugin(void)
+{
+  static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
+				   gst_gl_nvimage_set_caps,
+				   gst_gl_nvimage_get_image,
+				   gst_gl_nvimage_put_image,
+    				   gst_gl_nvimage_free_image};
+
+  return &plugin;
+}
+
+
+static GstGLImageInfo *
+gst_gl_nvimage_info (GstImageInfo *info)
+{
+  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
+  {
+    return NULL;
+  }
+  return (GstGLImageInfo *) info;
+}
+
+static GstGLImageConnection *
+gst_gl_nvimage_connection (GstImageConnection *conn)
+{
+  if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
+    return NULL; 
+  return (GstGLImageConnection *) conn;
+}
+
+gboolean
+gst_gl_nvimage_check_xvideo ()
+{
+  int ver, rel, req, ev, err;
+  
+#if 0 
+  if (display == NULL)
+    return FALSE;
+  if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
+    return TRUE;
+#endif
+
+  return FALSE;
+}
+
+static GstCaps * 	
+gst_gl_nvimage_get_caps (GstImageInfo *info)
+{
+  gint i;
+  int adaptors;
+  int formats;
+  GstCaps *caps = NULL;
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+  
+  /* we don't handle these image information */
+  if (xinfo == NULL) return NULL;
+
+  if (gst_gl_nvimage_check_xvideo () == FALSE)
+  {
+    g_warning("GL_NVImage: Server has no NVidia extension support\n");
+    return NULL;
+  }
+
+  caps = gst_caps_append (caps, GST_CAPS_NEW (
+					      "xvimage_caps",
+					      "video/raw",
+					      "format",  GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
+					      "width",   GST_PROPS_INT_RANGE (0, 1024),
+					      "height",  GST_PROPS_INT_RANGE (0, 1024))
+			  );
+  return caps;
+}
+
+static GstImageConnection *
+gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
+{
+  gint i, j = 0;
+  int adaptors;
+  int formats;
+  GstGLImageConnection *conn;
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+  guint32 format;
+  
+  /* we don't handle these image information */
+  if (xinfo == NULL) return NULL;
+  
+  conn = g_new0 (GstGLImageConnection, 1);
+  conn->conn.open_conn = gst_gl_nvimage_open_conn;
+  conn->conn.close_conn = gst_gl_nvimage_close_conn;
+  conn->conn.free_conn = gst_gl_nvimage_free_conn;
+
+  gst_caps_get (caps, 
+		  "width",  &conn->w,
+		  "height", &conn->h,
+		  "format", &format,
+                  NULL);
+
+  if (0) //conn->port == (XvPortID) -1)
+  {
+    /* this happens if the plugin can't handle the caps, so no warning */
+    g_free (conn);
+    return NULL;
+  }
+  
+  return (GstImageConnection *) conn;
+}
+
+static GstImageData *
+gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+{
+  GstNvImage *image;
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
+  int slot = 0;
+  
+  /* checks */
+  if (xinfo == NULL) return NULL;
+  if (nvconn == NULL) return NULL;
+
+  // I should also check the current GLX context ! Don't have to, I am guarantueed to always be in the same thread
+
+  image = g_new0(GstNvImage, 1);
+
+  for (slot = 0; slot < AGP_BUFSLOTS; slot++)
+    {
+      if (!nvconn->m_bufslots[slot]) break;
+    }
+
+  image->data.size = nvconn->w * nvconn->h * 3/2;
+
+  if (slot < AGP_BUFSLOTS) // found an AGP buffer slot
+    {
+      image->data.data = nvconn->m_memory + slot * YUVTEX_SIZE; 
+      image->slot = slot;  // store for freeing
+      nvconn->m_bufslots[slot] = 1; // it is now taken
+    }
+  else
+    {
+      g_warning("Allocating from main memory !");
+      image->data.data = g_malloc(image->data.size);
+      image->slot = AGP_BUFSLOTS; // no AGP slot
+    }
+  image->conn = nvconn;
+
+  if (image->data.data == NULL)
+  {
+    g_warning ("GL_NvImage: data allocation failed!");
+    g_free (image);
+    return NULL;
+  }
+
+  return (GstImageData *) image;
+}
+
+static void 		
+gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
+{
+  GstNvImage *im = (GstNvImage *) image;
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+  
+  /* checks omitted for speed (and lazyness), do we need them? */
+  g_assert (xinfo != NULL);
+  
+  /* Upload the texture here */
+  g_warning("PUTTING IMAGE - BROOOKEN");
+
+  // both upload the video, and redraw the screen
+  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+  glEnable(GL_TEXTURE_2D);
+
+  glPushMatrix();
+  //glTranslatef(0,1,0);
+  glRotatef(xinfo->rotX-250,1,0,0);
+  glRotatef(xinfo->rotY,0,1,0);
+  int zoom = xinfo->zoom;
+  glScaled(zoom,zoom,zoom);
+  //Draws the surface rectangle
+
+  glBindTexture(GL_TEXTURE_2D, im->conn->ytex_id);
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA, 
+  		  GL_UNSIGNED_BYTE, im->data.data);  
+  float xmax = (float)im->conn->w/TEX_XSIZE;
+  float ymax = (float)im->conn->h/TEX_YSIZE;
+
+  glColor4f(1,1,1,1);
+  glBegin(GL_QUADS);
+
+  glNormal3f(0, -1, 0);
+  
+  glTexCoord2f(xmax, 0);
+  glVertex3f(4,0,-4);
+
+  glTexCoord2f(0, 0);
+  glVertex3f(-4,0,-4);
+
+  glTexCoord2f(0, ymax);
+  glVertex3f(-4,0,4);
+
+  glTexCoord2f(xmax, ymax);
+  glVertex3f(4,0,4);
+
+  glEnd();
+
+  glPopMatrix();
+
+  glXSwapBuffers(xinfo->dpy, xinfo->win);
+}
+
+static void 		
+gst_gl_nvimage_free_image (GstImageData *image)
+{
+  GstNvImage *im = (GstNvImage *) image;
+  g_return_if_fail (im != NULL);
+  GstGLImageConnection *nvconn = im->conn;  
+
+  if (im->slot < AGP_BUFSLOTS)
+    {
+      nvconn->m_bufslots[im->slot] = 0;      
+    } 
+  else
+    g_free(im->data.data);
+
+  g_free (im);
+}
+
+static void
+gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+  GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
+
+  unsigned char data_sep[2][2] = {{0, 255}, {0, 255}}; 
+  int slot;
+
+  g_warning("Opening NVidia Connection");
+  xconn->m_memory = (unsigned char*)glXAllocateMemoryNV(AGP_BUFSLOTS*YUVTEX_SIZE, 0, 1.0, 1.0);
+  
+  if (!xconn->m_memory)
+    {
+      printf("Unable to acquire graphics card mem... will acquire in normal memory.\n");
+      for (slot = 0; slot < AGP_BUFSLOTS; slot++)
+	xconn->m_bufslots[slot] = 1;
+    }
+  else
+    {
+      // maybe this fast writable memory, awfully slow to read from, though
+      glPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV, AGP_BUFSLOTS*YUVTEX_SIZE, xconn->m_memory);
+      glEnableClientState(GL_WRITE_PIXEL_DATA_RANGE_NV);
+
+      for (slot = 0; slot < AGP_BUFSLOTS; slot++)
+	xconn->m_bufslots[slot] = 0;
+    }
+
+  glGenTextures(1, &xconn->ytex_id);
+  glBindTexture(GL_TEXTURE_2D, xconn->ytex_id);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  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_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+
+  glActiveTextureARB(GL_TEXTURE1_ARB);
+  glGenTextures(1, &xconn->uvtex_id);
+  glBindTexture(GL_TEXTURE_2D, xconn->uvtex_id);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE/2, TEX_YSIZE/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  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_ADD);
+
+  glActiveTextureARB(GL_TEXTURE2_ARB);
+  glGenTextures(1, &xconn->septex_id);
+  glBindTexture(GL_TEXTURE_2D, xconn->septex_id);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data_sep);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  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_ADD);
+
+  glFlushPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV);
+  //glEnable(GL_TEXTURE_2D);
+  glActiveTextureARB(GL_TEXTURE0_ARB);
+  glEnable(GL_TEXTURE_2D);
+  glActiveTextureARB(GL_TEXTURE1_ARB);
+  glEnable(GL_TEXTURE_2D);
+  glActiveTextureARB(GL_TEXTURE2_ARB);
+  glEnable(GL_TEXTURE_2D);
+  glActiveTextureARB(GL_TEXTURE0_ARB);
+}
+
+static void
+gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+  GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+
+  // anything needed in here ? Oh, maybe drawing de-init, or something
+  glDeleteTextures(1, &xconn->ytex_id);
+  glDeleteTextures(1, &xconn->uvtex_id);
+  glDeleteTextures(1, &xconn->septex_id);
+}
+
+static void 			
+gst_gl_nvimage_free_conn (GstImageConnection *conn)
+{
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
+
+  g_free (nvconn);
+}
+
diff --git a/sys/glsink/gstgl_rgbimage.c b/sys/glsink/gstgl_rgbimage.c
new file mode 100644
index 000000000..31ac16aea
--- /dev/null
+++ b/sys/glsink/gstgl_rgbimage.c
@@ -0,0 +1,330 @@
+#include <gst/gst.h>
+
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+#  define _XOPEN_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include "gstglsink.h"
+
+typedef struct _GstGLImageConnection GstGLImageConnection;
+
+// this contains everything to draw an image, including all necessary graphics card data. 
+struct _GstGLImageConnection {
+  GstImageConnection conn;
+  Display *dpy; // the Xlib drawing context
+  GLXContext ctx; // The GLX drawing context
+  gint w, h;
+  gint bpp;
+  
+  int rgbatex_id;
+  unsigned char *m_memory;
+};
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+
+
+typedef struct _GstGLImage GstGLImage;
+struct _GstGLImage
+{
+  GstImageData data;
+  GstGLImageConnection *conn;
+};
+
+static GstGLImageInfo *		gst_gl_rgbimage_info		(GstImageInfo *info);
+static GstGLImageConnection *	gst_gl_rgbimage_connection 	(GstImageConnection *conn);
+
+static GstCaps * 		gst_gl_rgbimage_get_caps	(GstImageInfo *info); 
+static GstImageConnection *	gst_gl_rgbimage_set_caps	(GstImageInfo *info, GstCaps *caps);
+static GstImageData *		gst_gl_rgbimage_get_image	(GstImageInfo *info, GstImageConnection *conn);
+static void 			gst_gl_rgbimage_put_image	(GstImageInfo *info, GstImageData *image);
+static void 			gst_gl_rgbimage_free_image	(GstImageData *image);
+static void 			gst_gl_rgbimage_open_conn	(GstImageConnection *conn, GstImageInfo *info);
+static void 			gst_gl_rgbimage_close_conn	(GstImageConnection *conn, GstImageInfo *info);
+static void 			gst_gl_rgbimage_free_conn	(GstImageConnection *conn);
+
+GstImagePlugin* get_gl_rgbimage_plugin(void)
+{
+  static GstImagePlugin plugin = { gst_gl_rgbimage_get_caps,
+				   gst_gl_rgbimage_set_caps,
+				   gst_gl_rgbimage_get_image,
+				   gst_gl_rgbimage_put_image,
+    				   gst_gl_rgbimage_free_image};
+
+  return &plugin;
+}
+
+static GstGLImageInfo *
+gst_gl_rgbimage_info (GstImageInfo *info)
+{
+  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
+  {
+    return NULL;
+  }
+  return (GstGLImageInfo *) info;
+}
+
+static GstGLImageConnection *
+gst_gl_rgbimage_connection (GstImageConnection *conn)
+{
+  if (conn == NULL || conn->free_conn != gst_gl_rgbimage_free_conn)
+    return NULL; 
+  return (GstGLImageConnection *) conn;
+}
+
+GstCaps *
+gst_gl_rgbimage_get_caps (GstImageInfo *info)
+{
+  GstCaps *caps = NULL;
+  Visual *visual;
+  int xpad;
+  XWindowAttributes attrib;
+  XImage *ximage;
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+  
+  /* we don't handle this image information */
+  if (xinfo == NULL) return NULL;
+
+  XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
+  
+  visual = attrib.visual;
+  if (attrib.depth <= 8)
+    xpad = 8;
+  else if (attrib.depth <= 16)
+    xpad = 16;
+  else
+    xpad = 32;
+  
+  // create a temporary image
+  ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL, 
+			      100, 100, xpad, (attrib.depth + 7) / 8 * 100);
+  if (ximage != NULL) {
+    caps = 
+      GST_CAPS_NEW (
+		    "forcing Video RGB",
+		    "video/raw",
+		    "format",          GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")),
+		    "bpp",          GST_PROPS_INT(32),
+		    "depth",        GST_PROPS_INT(24),
+		    "red_mask",        GST_PROPS_INT(0xff),
+		    "green_mask",        GST_PROPS_INT(0xff00),
+		    "blue_mask",        GST_PROPS_INT(0xff0000),
+		    "endianness",  GST_PROPS_INT(G_LITTLE_ENDIAN), /*= 1234/4321 (INT) <- endianness */
+		    
+		    "width",      GST_PROPS_INT_RANGE (0, TEX_XSIZE), /* can't have videos larger than TEX_SIZE */
+		    "height",     GST_PROPS_INT_RANGE (0, TEX_YSIZE) 
+		    );
+    XDestroyImage (ximage);
+  }
+  
+  GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_RGBImage: returning caps at %p", caps);
+  return caps;
+}
+
+static GstImageConnection *	
+gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
+{
+  GstGLImageConnection *new = NULL;
+  Visual *visual;
+  XWindowAttributes attrib;
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
+  guint32 format;
+  gint depth;
+  gint endianness;
+  gint red_mask, green_mask, blue_mask;
+  gint width, height, bpp;
+
+  /* check if this is the right image info */
+  if (xinfo == NULL) return NULL;
+    
+  XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
+  
+  visual = attrib.visual;
+
+  gst_caps_get (caps,
+		  "format", 	&format,
+		  "depth",  	&depth,
+		  "endianness", &endianness,
+		  "red_mask", 	&red_mask,
+		  "green_mask",	&green_mask,
+		  "blue_mask",	&blue_mask,
+		  "width",	&width,
+		  "height",	&height,
+		  "bpp",	&bpp,
+		  NULL);
+  
+  /* check if the caps are ok */
+  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) return NULL;
+  /* if (gst_caps_get_int (caps, "bpp") != ???) return NULL; */
+  //if (depth != attrib.depth) return NULL;
+  //if (endianness != ((ImageByteOrder (xinfo->dpy) == LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN)) return NULL;
+  //if (red_mask != visual->red_mask) return NULL;
+  //if (green_mask != visual->green_mask) return NULL;
+  //if (blue_mask != visual->blue_mask) return NULL;
+  GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_RGBImage: caps %p are ok, creating image", caps);
+  
+  new = g_new (GstGLImageConnection, 1);
+  new->conn.open_conn = gst_gl_rgbimage_open_conn;
+  new->conn.close_conn = gst_gl_rgbimage_close_conn;
+  new->conn.free_conn = gst_gl_rgbimage_free_conn;
+  new->dpy = xinfo->dpy;
+  new->ctx = xinfo->ctx;
+  new->w = width;
+  new->h = height;
+  new->bpp = bpp;
+  
+  return (GstImageConnection *) new;
+}
+
+static GstImageData *
+gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+{
+  GstGLImage *image;
+  XWindowAttributes attrib;
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
+  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);  
+  
+  image = g_new (GstGLImage, 1);
+
+  /* checks */
+  if (xinfo == NULL) return NULL;
+  if (xconn == NULL) return NULL;
+  if (xinfo->dpy != xconn->dpy)
+  {
+    g_warning ("XImage: wrong x display specified in 'get_image'\n");
+    return NULL;
+  }
+
+  image->conn = xconn;
+  image->data.size = xconn->w * xconn->h * 4;
+  image->data.data = g_malloc(image->data.size);
+  if (image->data.data == NULL)
+  {
+    g_warning ("GL_RGBImage: data allocation failed!");
+    g_free (image);
+    return NULL;
+  }
+
+  return (GstImageData *) image;
+}
+
+
+static void
+gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
+{
+  float xmax, ymax;
+
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+  GstGLImage *im = (GstGLImage *) image;
+
+  g_assert (xinfo != NULL);
+  g_warning("PUTTING IMAGE");
+
+  // both upload the video, and redraw the screen
+  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+  glEnable(GL_TEXTURE_2D);
+
+  glPushMatrix();
+  //glTranslatef(0,1,0);
+  glRotatef(xinfo->rotX-250,1,0,0);
+  glRotatef(xinfo->rotY,0,1,0);
+  int zoom = xinfo->zoom;
+  glScaled(zoom,zoom,zoom);
+  //Draws the surface rectangle
+
+  glBindTexture(GL_TEXTURE_2D, im->conn->rgbatex_id);
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA, 
+  		  GL_UNSIGNED_BYTE, im->data.data);  
+  xmax = (float)im->conn->w/TEX_XSIZE;
+  ymax = (float)im->conn->h/TEX_YSIZE;
+
+  glColor4f(1,1,1,1);
+  glBegin(GL_QUADS);
+
+  glNormal3f(0, -1, 0);
+  
+  glTexCoord2f(xmax, 0);
+  glVertex3f(4,0,-4);
+
+  glTexCoord2f(0, 0);
+  glVertex3f(-4,0,-4);
+
+  glTexCoord2f(0, ymax);
+  glVertex3f(-4,0,4);
+
+  glTexCoord2f(xmax, ymax);
+  glVertex3f(4,0,4);
+
+  glEnd();
+
+  glPopMatrix();
+
+  glXSwapBuffers(xinfo->dpy, xinfo->win);
+}
+
+void
+gst_gl_rgbimage_free_image (GstImageData *image)
+{
+  GstGLImage *im = (GstGLImage *) image;
+
+  g_warning ("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
+  g_free (im->data.data);
+  g_free (im);
+}
+
+/* Creates an OpenGL texture to upload the picture over */
+static void
+gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+  g_warning("!!! Opening Connection !!!");
+
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
+  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
+
+  glGenTextures(1, &xconn->rgbatex_id);
+  glBindTexture(GL_TEXTURE_2D, xconn->rgbatex_id);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  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);
+}
+
+/* Deletes the creates OpenGL textures */
+static void 
+gst_gl_rgbimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
+
+  glDeleteTextures(1, &xconn->rgbatex_id);
+ }
+
+static void
+gst_gl_rgbimage_free_conn (GstImageConnection *conn)
+{
+  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
+  
+  g_assert (xconn != NULL);
+  
+  g_free (xconn);
+}
+
+   
diff --git a/sys/glsink/gstglsink.c b/sys/glsink/gstglsink.c
new file mode 100644
index 000000000..d3e53f225
--- /dev/null
+++ b/sys/glsink/gstglsink.c
@@ -0,0 +1,650 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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.
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <sys/time.h>
+
+/*#define GST_DEBUG_FORCE_DISABLE*/
+
+#include "gstglsink.h"
+
+/* elementfactory information */
+static GstElementDetails gst_glsink_details = {
+  "OpenGL Sink/GLX",
+  "Sink/GLVideo",
+  "LGPL",
+  "An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
+  VERSION,
+  "Gernot Ziegler <gz@lysator.liu.se>",
+  "(C) 2002",
+};
+
+/* glsink signals and args */
+enum {
+  LAST_SIGNAL
+};
+
+
+enum {
+  ARG_0,
+  ARG_WIDTH,
+  ARG_HEIGHT,
+  ARG_FRAMES_DISPLAYED,
+  ARG_FRAME_TIME,
+  ARG_HOOK,
+  ARG_MUTE,
+  ARG_REPAINT
+};
+
+/* GLsink class */
+#define GST_TYPE_GLSINK		(gst_glsink_get_type())
+#define GST_GLSINK(obj)		(G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_GLSINK,GstGLSink))
+#define GST_GLSINK_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_GLSINK,GstGLSink))
+#define GST_IS_GLSINK(obj)		(G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_GLSINK))
+#define GST_IS_GLSINK_CLASS(obj)	(G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_GLSINK))
+
+typedef struct _GstGLSink GstGLSink;
+typedef struct _GstGLSinkClass GstGLSinkClass;
+
+struct _GstGLSink {
+  GstElement element;
+
+  GstPad *sinkpad;
+
+  gint frames_displayed;
+  guint64 frame_time;
+  gint width, height;
+  gboolean muted;
+  GstBuffer *last_image; /* not thread safe ? */
+  
+  GstClock *clock;
+
+  /* bufferpool stuff */
+  GstBufferPool *bufferpool;
+  GMutex *cache_lock;
+  GList *cache;
+  
+  /* plugins */
+  GstImagePlugin* plugin;
+  GstImageConnection *conn;
+  
+  /* allow anybody to hook in here */
+  GstImageInfo *hook;
+};
+
+struct _GstGLSinkClass {
+  GstElementClass parent_class;
+
+  /* plugins */
+  GList *plugins;
+};
+
+
+static GType 			gst_glsink_get_type		(void);
+static void			gst_glsink_class_init	(GstGLSinkClass *klass);
+static void			gst_glsink_init		(GstGLSink *sink);
+/* static void 			gst_glsink_dispose 		(GObject *object); */
+
+static void			gst_glsink_chain		(GstPad *pad, GstBuffer *buf);
+static void			gst_glsink_set_clock		(GstElement *element, GstClock *clock);
+static GstElementStateReturn	gst_glsink_change_state 	(GstElement *element);
+static GstPadLinkReturn	gst_glsink_sinkconnect	(GstPad *pad, GstCaps *caps);
+static GstCaps *		gst_glsink_getcaps		(GstPad *pad, GstCaps *caps);
+static GstBufferPool*		gst_glsink_get_bufferpool	(GstPad *pad);
+
+static void			gst_glsink_set_property	(GObject *object, guint prop_id, 
+								 const GValue *value, GParamSpec *pspec);
+static void			gst_glsink_get_property	(GObject *object, guint prop_id, 
+								 GValue *value, GParamSpec *pspec);
+
+static void			gst_glsink_release_conn	(GstGLSink *sink);
+static void			gst_glsink_append_cache	(GstGLSink *sink, GstImageData *image);
+static gboolean			gst_glsink_set_caps		(GstGLSink *sink, GstCaps *caps);
+/* bufferpool stuff */
+static GstBuffer*		gst_glsink_buffer_new 	(GstBufferPool *pool, 
+								 gint64 location, 
+								 guint size, gpointer user_data);
+static void			gst_glsink_buffer_free	(GstBufferPool *pool, 
+		                                                 GstBuffer *buffer, 
+								 gpointer user_data);
+
+/* prototypes from plugins */
+extern GstImagePlugin* 		get_gl_rgbimage_plugin		(void);
+extern GstImagePlugin* 		get_gl_nvimage_plugin		(void);
+/* default output */
+extern void			gst_glxwindow_new 		(GstGLSink *sink);
+
+
+static GstPadTemplate *sink_template;
+
+static GstElementClass *parent_class = NULL;
+/* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
+
+static GType
+gst_glsink_get_type (void)
+{
+  static GType videosink_type = 0;
+
+  if (!videosink_type) {
+    static const GTypeInfo videosink_info = {
+      sizeof(GstGLSinkClass),
+      NULL,
+      NULL,
+      (GClassInitFunc) gst_glsink_class_init,
+      NULL,
+      NULL,
+      sizeof(GstGLSink),
+      0,
+      (GInstanceInitFunc) gst_glsink_init,
+    };
+    videosink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstGLSink", &videosink_info, 0);
+  }
+  return videosink_type;
+}
+
+static void
+gst_glsink_class_init (GstGLSinkClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = gst_glsink_set_property;
+  gobject_class->get_property = gst_glsink_get_property;
+
+  g_object_class_install_property (gobject_class, ARG_WIDTH,
+    g_param_spec_int ("width", "Width", "The video width",
+                      G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
+  g_object_class_install_property (gobject_class, ARG_HEIGHT,
+    g_param_spec_int ("height", "Height", "The video height",
+                      G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
+  g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED,
+    g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far",
+                      G_MININT,G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
+  g_object_class_install_property (gobject_class, ARG_FRAME_TIME,
+    g_param_spec_int ("frame_time", "Frame time", "The interval between frames",
+                      G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
+  g_object_class_install_property (gobject_class, ARG_HOOK,
+    g_param_spec_pointer ("hook", "Hook", "The object receiving the output", G_PARAM_WRITABLE));
+  g_object_class_install_property (gobject_class, ARG_MUTE,
+    g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE, G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class, ARG_REPAINT,
+    g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame", FALSE, G_PARAM_WRITABLE));
+
+  /* gobject_class->dispose = gst_glsink_dispose; */
+  
+  gstelement_class->change_state = gst_glsink_change_state;
+  gstelement_class->set_clock = gst_glsink_set_clock;
+  
+  /* plugins */
+  klass->plugins = NULL;
+  //klass->plugins = g_list_append (klass->plugins, get_xvimage_plugin ());
+  klass->plugins = g_list_append (klass->plugins, get_gl_rgbimage_plugin ());
+}
+
+
+/*
+  GLSink has its own Buffer management - this allows special plugins to create special memory areas for
+  buffer upload 
+*/
+static void
+gst_glsink_init (GstGLSink *sink)
+{
+  sink->sinkpad = gst_pad_new_from_template (sink_template, "sink");
+  gst_element_add_pad (GST_ELEMENT (sink), sink->sinkpad);
+  gst_pad_set_chain_function (sink->sinkpad, gst_glsink_chain);
+  gst_pad_set_link_function (sink->sinkpad, gst_glsink_sinkconnect);
+  gst_pad_set_getcaps_function (sink->sinkpad, gst_glsink_getcaps);
+  gst_pad_set_bufferpool_function (sink->sinkpad, gst_glsink_get_bufferpool);
+
+  sink->last_image = NULL;
+  sink->width = 0;
+  sink->height = 0;
+  sink->muted = FALSE;
+  sink->clock = NULL;  
+  GST_FLAG_SET(sink, GST_ELEMENT_THREAD_SUGGESTED);
+  GST_FLAG_SET (sink, GST_ELEMENT_EVENT_AWARE);
+    
+  /* create bufferpool and image cache */
+  GST_DEBUG (0, "glsink: creating bufferpool");
+  sink->bufferpool = gst_buffer_pool_new (
+		    NULL,
+		    NULL,
+		    (GstBufferPoolBufferNewFunction)gst_glsink_buffer_new,
+		    NULL,
+		    (GstBufferPoolBufferFreeFunction)gst_glsink_buffer_free,
+		    sink);
+  sink->cache_lock = g_mutex_new();
+  sink->cache = NULL; 
+  
+  /* plugins */
+  sink->plugin = NULL;
+  sink->conn = NULL;
+  
+  /* do initialization of default hook here */
+  gst_glxwindow_new (sink);
+}
+
+static void
+gst_glsink_release_conn (GstGLSink *sink)
+{
+  if (sink->conn == NULL) return;
+  
+  /* free last image if any */
+  if (sink->last_image != NULL)
+  {
+    gst_buffer_unref (sink->last_image);
+    sink->last_image = NULL;
+  }
+  /* free cache */
+  g_mutex_lock (sink->cache_lock);
+  while (sink->cache)
+  {
+    sink->plugin->free_image ((GstImageData *) sink->cache->data);
+    sink->cache = g_list_delete_link (sink->cache, sink->cache);
+  }
+  g_mutex_unlock (sink->cache_lock);
+  
+  /* release connection */
+  sink->conn->free_conn (sink->conn);
+  sink->conn = NULL;
+}
+
+static void 		
+gst_glsink_append_cache (GstGLSink *sink, GstImageData *image)
+{
+  g_mutex_lock (sink->cache_lock);
+  sink->cache = g_list_prepend (sink->cache, image);
+  g_mutex_unlock (sink->cache_lock);
+}
+
+/* 
+   Create a new buffer to hand up the chain.
+   This allows the plugins to make its own decoding buffers
+ */
+static GstBuffer*
+gst_glsink_buffer_new (GstBufferPool *pool, gint64 location, 
+		          guint size, gpointer user_data)
+{
+  GstGLSink *sink;
+  GstBuffer *buffer;
+  GstImageData *image;
+  
+  sink = GST_GLSINK (user_data);
+  
+  if (sink->cache != NULL) {
+    g_mutex_lock (sink->cache_lock);
+    image = (GstImageData *) sink->cache->data;
+    sink->cache = g_list_delete_link (sink->cache, sink->cache);
+    g_mutex_unlock (sink->cache_lock);
+  } else {
+    image = sink->plugin->get_image (sink->hook, sink->conn);
+  }
+  
+  buffer = gst_buffer_new ();
+  GST_BUFFER_DATA (buffer) = image->data;
+  GST_BUFFER_SIZE (buffer) = image->size;
+  GST_BUFFER_POOL_PRIVATE (buffer) = image;
+  
+  return buffer;
+}
+
+/*
+  Free a buffer that the chain doesn't need anymore. 
+*/
+static void
+gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_data)
+{
+  GstGLSink *sink = GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL (buffer)));
+
+  gst_glsink_append_cache (sink, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
+
+  /* set to NULL so the data is not freed */
+  GST_BUFFER_DATA (buffer) = NULL;
+
+  gst_buffer_default_free (buffer);
+}
+
+static GstBufferPool*
+gst_glsink_get_bufferpool (GstPad *pad)
+{
+  GstGLSink *sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+  return sink->bufferpool;
+}
+
+/* 
+   Set the caps that the application desires. 
+   Go through the plugin list, finding the plugin that first fits the given parameters 
+*/
+static gboolean
+gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
+{
+  GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
+  GstImageConnection *conn = NULL;
+  while (list)    
+  {
+    GstImagePlugin *plugin = (GstImagePlugin *) list->data;
+    if ((conn = plugin->set_caps (sink->hook, caps)) != NULL)
+    {
+      gst_glsink_release_conn (sink);
+      sink->conn = conn;
+      sink->plugin = plugin;
+      sink->conn->open_conn (sink->conn, sink->hook);
+      return TRUE;
+    }
+    list = g_list_next (list);
+  }
+  return FALSE;
+}
+
+/**
+Link the input video sink internally.
+*/
+static GstPadLinkReturn
+gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
+{
+  GstGLSink *sink;
+  guint32 fourcc, print_format;
+
+  sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+  /* we are not going to act on variable caps */
+  if (!GST_CAPS_IS_FIXED (caps))
+    return GST_PAD_LINK_DELAYED;
+  
+  /* try to set the caps on the output */
+  if (gst_glsink_set_caps (sink, caps) == FALSE)
+  {
+    return GST_PAD_LINK_REFUSED;
+  }
+  
+  /* remember width & height */
+  gst_caps_get_int (caps, "width", &sink->width);
+  gst_caps_get_int (caps, "height", &sink->height);
+
+  gst_caps_get_fourcc_int (caps, "format", &fourcc);
+  print_format = GULONG_FROM_LE (fourcc);
+  GST_DEBUG (0, "glsink: setting %08x (%4.4s) %dx%d\n", 
+		  fourcc, (gchar*)&print_format, sink->width, sink->height);
+
+  /* emit signal */
+  g_object_freeze_notify (G_OBJECT (sink));
+  g_object_notify (G_OBJECT (sink), "width");
+  g_object_notify (G_OBJECT (sink), "height");
+  g_object_thaw_notify (G_OBJECT (sink));
+
+  return GST_PAD_LINK_OK;
+}
+static GstCaps *
+gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
+{
+  /* what is the "caps" parameter good for? */
+  GstGLSink *sink = GST_GLSINK (gst_pad_get_parent (pad));
+  GstCaps *ret = NULL;
+  GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
+  
+  while (list)    
+  {
+    ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
+    list = g_list_next (list);
+  }
+
+  return ret;
+}
+
+static void
+gst_glsink_set_clock (GstElement *element, GstClock *clock)
+{
+  GstGLSink *sink = GST_GLSINK (element);
+  
+  sink->clock = clock;
+}
+static void
+gst_glsink_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstGLSink *sink;
+  GstClockTime time = GST_BUFFER_TIMESTAMP (buf);
+  GstBuffer *buffer;
+  static int frame_drops = 0;
+
+  g_return_if_fail (pad != NULL);
+  g_return_if_fail (GST_IS_PAD (pad));
+  g_return_if_fail (buf != NULL);
+
+  sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+  if (GST_IS_EVENT (buf)) {
+    GstEvent *event = GST_EVENT (buf);
+
+    switch (GST_EVENT_TYPE (event)) {
+      default:
+        gst_pad_event_default (pad, event);
+    }
+    return;
+  }
+  GST_DEBUG (0,"glsink: clock wait: %llu %u", 
+		  GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
+
+#if 0 
+  if (sink->clock && time != -1) {
+    if (time < gst_clock_get_time(sink->clock))
+      {
+	g_warning("Frame drop (%d consecutive) !!", frame_drops);
+	/* we are going to drop late buffers */
+	gst_buffer_unref (buf);
+	frame_drops++;
+	return;
+      }
+    frame_drops = 0; // we made it - reset time
+
+    GstClockReturn ret;
+    GstClockID id = gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
+
+    ret = gst_element_clock_wait (GST_ELEMENT (sink), id, NULL);
+    gst_clock_id_free (id);
+
+    /* we are going to drop early buffers */
+    if (ret == GST_CLOCK_EARLY) {
+      gst_buffer_unref (buf);
+      return;
+    }
+  }
+#endif
+
+  /* call the notify _before_ displaying so the handlers can react */
+  sink->frames_displayed++;
+  g_object_notify (G_OBJECT (sink), "frames_displayed");
+
+  if (!sink->muted)
+  {
+    /* free last_image, if any */
+    if (sink->last_image != NULL)
+      gst_buffer_unref (sink->last_image);
+    if (sink->bufferpool && GST_BUFFER_BUFFERPOOL (buf) == sink->bufferpool) {
+      sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
+      sink->last_image = buf;
+    } else {
+      buffer = gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad), 
+		                         0, GST_BUFFER_SIZE (buf));
+      memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf), 
+	      GST_BUFFER_SIZE (buf) > GST_BUFFER_SIZE (buffer) ? 
+	        GST_BUFFER_SIZE (buffer) : GST_BUFFER_SIZE (buf));
+
+      sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
+
+      sink->last_image = buffer;
+      gst_buffer_unref (buf);
+    }
+  }
+  
+}
+
+
+static void
+gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstGLSink *sink;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail (GST_IS_GLSINK (object));
+
+  sink = GST_GLSINK (object);
+
+  switch (prop_id) {
+    case ARG_FRAMES_DISPLAYED:
+      sink->frames_displayed = g_value_get_int (value);
+      g_object_notify (object, "frames_displayed");
+      break;
+    case ARG_FRAME_TIME:
+      sink->frame_time = g_value_get_int (value);
+      break;
+    case ARG_HOOK:
+      if (sink->hook)
+      {
+	sink->hook->free_info (sink->hook);
+      }
+      sink->hook = g_value_get_pointer (value);
+      break;
+    case ARG_MUTE:
+      sink->muted = g_value_get_boolean (value);
+      g_object_notify (object, "mute");
+      break;
+    case ARG_REPAINT:
+      if (sink->last_image != NULL) {
+	sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
+      }
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstGLSink *sink;
+
+  /* it's not null if we got it, but it might not be ours */
+  sink = GST_GLSINK(object);
+
+  switch (prop_id) {
+    case ARG_WIDTH:
+      g_value_set_int (value, sink->width);
+      break;
+    case ARG_HEIGHT:
+      g_value_set_int (value, sink->height);
+      break;
+    case ARG_FRAMES_DISPLAYED:
+      g_value_set_int (value, sink->frames_displayed);
+      break;
+    case ARG_FRAME_TIME:
+      g_value_set_int (value, sink->frame_time/1000000);
+      break;
+    case ARG_MUTE:
+      g_value_set_boolean (value, sink->muted);
+      break;
+    default: 
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static GstElementStateReturn
+gst_glsink_change_state (GstElement *element)
+{
+  GstGLSink *sink;
+
+  sink = GST_GLSINK (element);
+
+  switch (GST_STATE_TRANSITION (element)) {
+    case GST_STATE_NULL_TO_READY:
+      break;
+    case GST_STATE_READY_TO_PAUSED:
+      {
+	//g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
+      }
+      break;
+    case GST_STATE_PAUSED_TO_PLAYING:
+      {
+	//g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
+      }
+      break;
+    case GST_STATE_PLAYING_TO_PAUSED:
+      break;
+    case GST_STATE_PAUSED_TO_READY:
+      if (sink->conn)
+        sink->conn->close_conn (sink->conn, sink->hook);
+      if (sink->last_image) {
+	gst_buffer_unref (sink->last_image);
+        sink->last_image = NULL;
+      }
+      break;
+    case GST_STATE_READY_TO_NULL:
+      gst_glsink_release_conn (sink);
+      break;
+  }
+
+  parent_class->change_state (element);
+
+  return GST_STATE_SUCCESS;
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the xvideosink element */
+  factory = gst_element_factory_new("glsink",GST_TYPE_GLSINK,
+                                   &gst_glsink_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  sink_template = gst_pad_template_new (
+		  "sink",
+                  GST_PAD_SINK,
+  		  GST_PAD_ALWAYS,
+		  NULL);
+
+  gst_element_factory_add_pad_template (factory, sink_template);
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "glsink",
+  plugin_init
+};
diff --git a/sys/glsink/gstglsink.h b/sys/glsink/gstglsink.h
new file mode 100644
index 000000000..8cedccc10
--- /dev/null
+++ b/sys/glsink/gstglsink.h
@@ -0,0 +1,94 @@
+/* GStreamer
+ * Copyright (C) 2002 The GStreamer Team 
+ *                           <gstreamer-devel@lists.sourceforge.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.
+ */
+
+
+#ifndef __GST_VIDEOSINK_H__
+#define __GST_VIDEOSINK_H__
+
+#include <gst/gst.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define MAX_FLIP_BUFFERS 1
+
+typedef struct _GstImageInfo GstImageInfo;
+struct _GstImageInfo {
+  gulong id;
+  void (*free_info) (GstImageInfo *info);
+};
+
+
+typedef struct _GstImageData GstImageData;
+struct _GstImageData {
+  gint size;
+  gchar *data;
+};
+
+typedef struct _GstImageConnection GstImageConnection;
+struct _GstImageConnection {
+  void (*open_conn) (GstImageConnection *conn, GstImageInfo *info);
+  void (*close_conn) (GstImageConnection *conn, GstImageInfo *info);  
+  void (*free_conn) (GstImageConnection *conn);
+};
+
+typedef GstCaps *		(*GstImagePluginGetCapsFunc)	(GstImageInfo *info); 
+typedef GstImageConnection *	(*GstImagePluginSetCapsFunc) 	(GstImageInfo *info, GstCaps *caps);
+typedef GstImageData*		(*GstImagePluginGetImageFunc)	(GstImageInfo *info, GstImageConnection *conn);
+typedef void 			(*GstImagePluginPutImageFunc)	(GstImageInfo *info, GstImageData *image);
+typedef void 			(*GstImagePluginFreeImageFunc)	(GstImageData *image);
+
+typedef struct _GstImagePlugin GstImagePlugin;
+struct _GstImagePlugin {
+  GstImagePluginGetCapsFunc	get_caps;
+  GstImagePluginSetCapsFunc	set_caps;
+  GstImagePluginGetImageFunc	get_image;
+  GstImagePluginPutImageFunc	put_image;
+  GstImagePluginFreeImageFunc	free_image;
+};
+
+typedef struct _GstGLImageInfo GstGLImageInfo;
+/* stuff about our window grouped together */
+struct _GstGLImageInfo {
+  GstImageInfo info;
+  Display *dpy;
+  int screen;
+  Window win;
+  GLXContext ctx;
+  XSetWindowAttributes attr;
+  Bool fs;
+  //XF86VidModeModeInfo deskMode;
+  int x, y;
+  unsigned int width, height;
+  unsigned int depth;    
+  /* window specific from here */
+  GstElement *sink;
+  gulong handler_id;
+  float rotX,rotY,zoom;
+};
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_VIDEOSINK_H__ */
diff --git a/sys/glsink/gstglxwindow.c b/sys/glsink/gstglxwindow.c
new file mode 100644
index 000000000..96ec673a0
--- /dev/null
+++ b/sys/glsink/gstglxwindow.c
@@ -0,0 +1,239 @@
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+#  define _XOPEN_SOURCE 1
+#endif
+
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include "gstglsink.h"
+#include <string.h> /* strncmp */
+
+/* attributes for a single buffered visual in RGBA format with at least
+ * 4 bits per color and a 16 bit depth buffer */
+static int attrListSgl[] = 
+{
+  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 attrListDbl[] = 
+  { 
+    GLX_RGBA, GLX_DOUBLEBUFFER, 
+    GLX_RED_SIZE, 4, 
+    GLX_GREEN_SIZE, 4, 
+    GLX_BLUE_SIZE, 4, 
+    GLX_DEPTH_SIZE, 16,
+    None 
+  };
+
+
+GLfloat LightAmbient[] = { 0.1, 0.1, 0.1, 1.0 };  /* reddish ambient light  */
+GLfloat LightDiffuse[] = { 0.6, 0.6, 0.6, 1.0 };  /* bluish  diffuse light. */
+GLfloat LightPosition[] = { 1.5, 1.5, 1.5, 0.0 };    /* position */
+
+
+static void
+gst_glxwindow_free (GstImageInfo *info)
+{
+  GstGLImageInfo *window = (GstGLImageInfo *) info;
+  
+  g_signal_handler_disconnect (window->sink, window->handler_id);
+
+  if (window->ctx)
+    {
+      if (!glXMakeCurrent(window->dpy, None, NULL))
+        {
+	  printf("Could not release drawing context.\n");
+        }
+      glXDestroyContext(window->dpy, window->ctx);
+      window->ctx = NULL;
+    }
+#if 0 
+    /* 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
+  XCloseDisplay (window->dpy);
+  g_free (window);
+}
+
+static void
+gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
+{
+  XWindowAttributes attr; 
+  XGetWindowAttributes(data->dpy, data->win, &attr); 
+
+  if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
+  {
+    gint w = 0;
+    gint h = 0;
+    g_object_get (object, "width", &w, NULL);
+    g_object_get (object, "height", &h, NULL);
+    if (w != attr.width || h != attr.height)
+    {
+      attr.width = w;
+      attr.height = h;
+      XResizeWindow (data->dpy, data->win, attr.width, attr.height);
+      XMapRaised (data->dpy, data->win);
+
+      // resize OpenGL
+      g_warning("resizing in OpenGL");
+      glViewport(0, 0, (GLint) w, (GLint) h);
+      glMatrixMode(GL_PROJECTION);
+      glLoadIdentity();
+      
+      GLfloat aspect = (GLfloat) h / (GLfloat) w;
+      glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
+
+      glMatrixMode(GL_MODELVIEW);
+      glLoadIdentity();
+      glTranslatef(0.0, -3.0, -50.0);
+    }
+  }
+  if (attr.width != data->width || attr.height != data->height)
+  {
+    data->width = attr.width;
+    data->height = attr.height;
+  }
+
+}
+
+void
+gst_glxwindow_new (GstElement *sink)
+{
+  XGCValues values;
+  GstGLImageInfo *new;
+  int glxMajorVersion, glxMinorVersion;
+  XSetWindowAttributes attrib;
+  XVisualInfo *vi;
+  Atom wmDelete;
+  Window winDummy;
+  unsigned int borderDummy;
+  Colormap cmap;
+  char* title = "GLSink (experimental)";
+
+  new = g_new0 (GstGLImageInfo, 1);
+
+  if (sink == NULL)
+  {
+    sink = gst_element_factory_make ("glsink", "glsink");
+    g_assert (sink != NULL);
+  }
+  
+  /* fill in the ImageInfo */
+  new->info.id = GST_MAKE_FOURCC ('X', 'l', 'i', 'b');
+  new->info.free_info = gst_glxwindow_free;
+  
+  new->dpy = XOpenDisplay (NULL);
+  if (!new->dpy) {
+    g_warning ("open display failed!\n");
+    g_free (new);
+    return;
+  }
+  new->screen = DefaultScreen(new->dpy);
+  /* get an appropriate visual */
+  vi = glXChooseVisual(new->dpy, new->screen, attrListDbl);
+  if (vi == NULL)
+    {
+      vi = glXChooseVisual(new->dpy, new->screen, attrListSgl);
+      g_warning("Only Singlebuffered Visual!\n");
+    }
+  else
+    {
+      g_warning("Got Doublebuffered Visual!\n");
+    }
+  glXQueryVersion(new->dpy, &glxMajorVersion, &glxMinorVersion);
+  g_warning("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
+  
+  /* create a GLX context */
+  new->ctx = glXCreateContext(new->dpy, vi, 0, GL_TRUE);
+  /* create a color map */
+  cmap = XCreateColormap(new->dpy, RootWindow(new->dpy, vi->screen),
+			 vi->visual, AllocNone);
+  new->attr.colormap = cmap;
+  new->attr.border_pixel = 0;
+
+  /* set sizes */
+  new->x = 0;
+  new->y = 0;
+  new->width = 10;
+  new->height = 10;
+
+  new->rotX = 0; 
+  new->rotY = 0; 
+  new->zoom = 2;
+
+  {
+        /* create a window in window mode*/
+    new->attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
+      StructureNotifyMask;
+    new->win = XCreateWindow(new->dpy, RootWindow(new->dpy, vi->screen),
+			      new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput, vi->visual,
+			      CWBorderPixel | CWColormap | CWEventMask, &new->attr);
+    if (!new->win) 
+      {
+	g_warning ("create window failed\n");
+	g_free (new);
+	return;
+      }
+    /* only set window title and handle wm_delete_events if in windowed mode */
+    wmDelete = XInternAtom(new->dpy, "WM_DELETE_WINDOW", True);
+    XSetWMProtocols(new->dpy, new->win, &wmDelete, 1);
+    XSetStandardProperties(new->dpy, new->win, title,
+			   title, None, NULL, 0, NULL);
+    XMapRaised(new->dpy, new->win);
+  }       
+  /* connect the glx-context to the window */
+  glXMakeCurrent(new->dpy, new->win, new->ctx);
+  XGetGeometry(new->dpy, new->win, &winDummy, &new->x, &new->y,
+	       &new->width, &new->height, &borderDummy, &new->depth);
+  printf("Depth %d\n", new->depth);
+  if (glXIsDirect(new->dpy, new->ctx)) 
+    g_warning("Congrats, you have Direct Rendering!\n");
+  else
+    g_warning("Sorry, no Direct Rendering possible!\n");
+
+  g_warning("Initializing OpenGL parameters");
+  /* initialize OpenGL drawing */
+  glEnable(GL_DEPTH_TEST);
+  //glShadeModel(GL_SMOOTH);
+
+  glEnable(GL_TEXTURE_2D);
+  glDisable(GL_CULL_FACE);
+  glClearDepth(1.0f);
+  glClearColor(0, 0, 0, 0);
+
+  glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);  /*  add lighting. (ambient) */
+  glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);  /*  add lighting. (diffuse). */
+  glLightfv(GL_LIGHT0, GL_POSITION,LightPosition); /*  set light position. */ 
+ 
+  //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);
+
+  XSelectInput (new->dpy, new->win, ExposureMask | StructureNotifyMask);
+
+  g_object_set (sink, "hook", new, NULL);
+  new->sink = sink;
+  new->handler_id = g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback), new);
+}
+