Rewrote OpenGL output plugin.

CVS patchset: 7150
CVS date: 2004/11/23 15:01:07

4 files changed, 1266 insertions, 835 deletions

diff --git a/ChangeLog b/ChangeLog
index 07fa37dfb..5ef43aee8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,5 @@
 xine-lib (1-xxx)
+  * Rewrote OpenGL output plugin.
   * Fixed segfault when seeking with the "xvmc" and "xxmc" plugins playing 
     files with IDCT / mocomp XvMC acceleration. 
   * polypaudio sound server support
diff --git a/doc/README.opengl b/doc/README.opengl
index 85fd68c85..99bbf93f9 100644
--- a/doc/README.opengl
+++ b/doc/README.opengl
@@ -1,10 +1,3 @@
-Please Note:
-
-The 'opengl' output plugin is still in alpha stage.
-Expect crashes and strange behaviour.
-Most times it seems to run fine, though.
-
-
 Startup
 -------
 
@@ -13,32 +6,38 @@ different color depth than you would prefer.  Choose an appropriate visual
 with 'glxinfo' and select it with '-V opengl --visual xyz' in this case.
 
 
-Known Problems
---------------
+Problems you might encounter
+----------------------------
 
-* Sometimes I only see a black screen and no image
-* Sometimes xine crashes when changing the stream or the position in the stream
+* Output is extremely slow
 
-  This seems to relate to some race conditions that are still present
-  in the current code. This will change in time.
+  Run 'glxinfo' and check the third output line saying 'direct rendering:'
+  If it doesn't say 'Yes', you are not running an accelerated OpenGL setup.
+  Check your installation.
+  Image_Pipeline based rendering is typically slower than 2D_Textures.
+  Note that OpenGL output is always slower than XVideo, and often faster
+  than X shared memory.
 
-  Jun. 25, 2002: I think this issue is resolved now.  If you still encounter
-  any problems, please let me know.  Otherwise I will remove this statement
-  in the future.
+* xine complains about a memory leak
 
-* There is a (small) memory leak
-
-  This is known and - unfortunately - cannot be resolved right now.
+  This is known and - unfortunately - cannot be solved without changing
+  the user interface code. This will happen at least for xine-ui in the
+  near future.
   Background: The output plugin does not get notified, when the XWindow
-  is destroyed. But even when it would be notified, this wouldn't help,
-  as the OpenGL context could only be destroyed by the render thread.
+  is destroyed, and the OpenGL context can only be destroyed while the
+  drawable is still accessible.
+
 
-* Expose events just display a black image when playback is paused.
+Known issues
+------------
 
-  This is known and cannot be resolved right now.
-  Background: The OpenGL context can only be used by the render thread and
-  not by the GUI thread. I tried to use a second context within the same
-  drawable, but this destabilized the plugin to an unusable state.
+* GL_BGRA (used on little endian machines, i.e. ix86) needs an extension
+  check. This has not been implemented yet.
+* Big endian machines have not been checked yet.
+* VO_CAP_UNSCALED_OVERLAY reduces performance a lot during the first few
+  frames.
+* Cropping is not yet implemented - this is done by video_out.c
+* XINE_GUI_SEND_WILL_DESTROY_DRAWABLE not yet sent by any GUI, thus untested
 
 
 Matthias Hopf <mat@mshopf.de>
diff --git a/src/video_out/Makefile.am b/src/video_out/Makefile.am
index 11b272ac2..f0258c24b 100644
--- a/src/video_out/Makefile.am
+++ b/src/video_out/Makefile.am
@@ -112,9 +112,9 @@ xineplug_vo_out_xxmc_la_LIBADD = $(XXMC_LIB) $(XV_LIB) $(X_LIBS) -lXext $(XINE_L
 xineplug_vo_out_xxmc_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
 
 xineplug_vo_out_opengl_la_SOURCES = yuv2rgb.c yuv2rgb_mmx.c yuv2rgb_mlib.c \
-	alphablend.c video_out_opengl.c
+	alphablend.c video_out_opengl.c $(X11OSD)
 xineplug_vo_out_opengl_la_LIBADD = $(MLIB_LIBS) $(OPENGL_LIBS) $(GLUT_LIBS) \
-	$(GLU_LIBS) $(X_LIBS) $(XINE_LIB)
+	$(GLU_LIBS) $(X_LIBS) -lXext $(XINE_LIB)
 xineplug_vo_out_opengl_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
 
 xineplug_vo_out_syncfb_la_SOURCES = alphablend.c video_out_syncfb.c 
diff --git a/src/video_out/video_out_opengl.c b/src/video_out/video_out_opengl.c
index d6365771a..c440002e3 100644
--- a/src/video_out/video_out_opengl.c
+++ b/src/video_out/video_out_opengl.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2000-2004 the xine project
+ * Copyright (C) 2000-2003 the xine project
  * 
  * This file is part of xine, a free video player.
  * 
@@ -17,40 +17,31 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  *
- * $Id: video_out_opengl.c,v 1.41 2004/10/09 06:45:48 mroi Exp $
+ * $Id: video_out_opengl.c,v 1.42 2004/11/23 15:01:23 mshopf Exp $
  * 
- * video_out_glut.c, glut based OpenGL rendering interface for xine
- * Matthias Hopf <mat@mshopf.de>
+ * video_out_opengl.c, OpenGL based interface for xine
  *
- * Based on video_out_xshm.c (1.70) and video_out_xv.c (1.108)
+ * Written by Matthias Hopf <mat@mshopf.de>,
+ * based on the xshm and xv video output plugins.
+ * 
  */
 
-/*
- * TODO:
- *
- * - BUG: xitk is creating images in the wrong visual type on e.g. SGI
- *   (due to driver visual selection?). this is a xitk issue.
- *   this creates a strange looking gui interface and all dialogs fail
- *   (X_PutImage: BadMatch).
- * - Rendering method to be chosen on runtime
- * - glut autoconf detection buggy
- * - Check extensions (GL_BGRA)
- * - Color conversion in hardware?
- *   - Video extension
- *   - ColorMatrix (OpenGL-1.2 or SGI_color_matrix) ?possible? don't think so
- * - Alpha Blending for overlays using texture hardware
- */
+/* #define LOG */
+#define LOG_MODULE "video_out_opengl"
 
 
-#if 1					/* set to 1 for debugging messages */
-#  define DEBUGF(x) fprintf x
-#else
-#  define DEBUGF(x) ((void) 0)
-#endif
+#define BYTES_PER_PIXEL      4
+#define NUM_FRAMES_BACKLOG   4	/* Allow thread some time to render frames */
 
+#define SECONDS_PER_CYCLE    60	/* Animation parameters */
+#define CYCLE_FACTOR1        3
+#define CYCLE_FACTOR2        5
 
-#define USE_SPHERE	0	/* 1 for some fun! */ /* FIXME: untested */
-#define USE_TEXTURES	1	/* 1 Use texture hardware   0 glDrawPixels */
+#ifdef NDEBUG
+#define CHECKERR(a) ((void)0)
+#else
+#define CHECKERR(a) do { int i = glGetError (); if (i != GL_NO_ERROR) fprintf (stderr, "   *** %s: 0x%x = %s\n", a, i, gluErrorString (i)); } while (0)
+#endif
 
 
 #ifdef HAVE_CONFIG_H
@@ -61,118 +52,106 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
-
-#include <X11/Xlib.h>
-
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#include <sys/time.h>
-
+#include <errno.h>
 #include <pthread.h>
-#include <netinet/in.h>
 
 #include <GL/gl.h>
 #include <GL/glx.h>
-#ifdef HAVE_GLUT
-#include <GL/glut.h>
-#else
-#define USE_SPHERE 0			/* unable to do that w/o glut */
-#ifdef HAVE_GLU
 #include <GL/glu.h>
-#endif
-#endif
 
 #include "xine.h"
 #include "video_out.h"
+
 #include "xine_internal.h"
 #include "alphablend.h"
 #include "yuv2rgb.h"
 #include "xineutils.h"
-#include "vo_scale.h"
-
-
-#define STRIPE_HEIGHT 16
-#define BYTES_PER_PIXEL 4
+#include "x11osd.h"
 
 
-# if (BYTES_PER_PIXEL != 4)
+#if (BYTES_PER_PIXEL != 4)
 /* currently nothing else is supported */
 #   error "BYTES_PER_PIXEL bad"
-# endif
+#endif
+/* TODO: haven't checked bigendian so far... */
 #ifdef WORDS_BIGENDIAN
 #  define RGB_TEXTURE_FORMAT GL_RGBA
 #  define YUV_FORMAT         MODE_32_BGR
 #  define YUV_SWAP_MODE      1
 #else
-/* FIXME: check extension */
+/* TODO: GL_BGRA needs extension check */
+/* TODO: GL_RGBA / MODE_32_BGR does not need extension, but might be slower
+ * on ix86, and overlays would use wrong pixel order */
+/* TODO:  MODE_32_BGR may not work with some accelerated yuv2rgb routines */
 #  define RGB_TEXTURE_FORMAT GL_BGRA
 #  define YUV_FORMAT         MODE_32_RGB
 #  define YUV_SWAP_MODE      0
 #endif
 
+#define MY_2PI               6.2831853
 
-typedef struct opengl_frame_s {
-    vo_frame_t         vo_frame;
-
-    /* frame properties as delivered by the decoder: */
-    int                width,  height;
-    double             ratio;
-    int                format, flags;
-
-    /* opengl only data */
-    uint8_t           *rgb_dst;
-    yuv2rgb_t         *yuv2rgb;
-    uint8_t	      *chunk[3];
-    int                stripe_inc;
-    uint8_t           *texture;
-} opengl_frame_t;
-
-typedef struct opengl_driver_s {
-
-    vo_driver_t      vo_driver;
-
-    vo_scale_t       sc;
-    vo_overlay_t    *overlay;
-    config_values_t *config;
-
-    /* X11 / Xv related stuff */
-    Display         *display;
-    int              screen;
-    Drawable         drawable;
+typedef struct {
+  vo_frame_t         vo_frame;
 
-    /* OpenGL related */
-    GLXContext       context;
-    volatile int     context_state;        /* is the context ok, or reload? */
-    XVisualInfo     *vinfo;
-    pthread_t        renderthread;
+  int                width, height, format, flags;
+  double             ratio;
 
-    /* current texture size - this is not frame dependend! */
-    int              texture_width, texture_height;
+  uint8_t           *chunk[4]; /* mem alloc by xmalloc_aligned           */
+  uint8_t           *rgb, *rgb_dst;
+    
+  yuv2rgb_t         *yuv2rgb; /* yuv2rgb converter set up for this frame */
 
-    /* last frame delivered from the decoder for frame change detection */
-    int              last_width;
-    int              last_height;
-    double           last_ratio;
+} opengl_frame_t;
 
-#if 0
-    /* ideal size */
-    int              ideal_width, ideal_height;
-    int              user_ratio;
 
-    /* gui size */
-    int              gui_width, gui_height;
-    int              gui_x, gui_y, gui_win_x, gui_win_y;
+/* RENDER_DRAW to RENDER_SETUP are asynchronous actions, but later actions
+ * imply former actions -> only check '>' on update */
+/* RENDER_CREATE and later are synchronous actions and override async ones */
+enum render_e { RENDER_NONE=0, RENDER_DRAW, RENDER_CLEAN, RENDER_SETUP,
+		RENDER_CREATE, RENDER_VISUAL, RENDER_RELEASE, RENDER_EXIT };
 
-    /* output size */
-    int              output_width, output_height;
-    int              output_xoffset, output_yoffset;
-#endif 
-    /* software yuv2rgb related */
-    int                yuv2rgb_brightness;
-    uint8_t           *yuv2rgb_cmap;
-    yuv2rgb_factory_t *yuv2rgb_factory;
+typedef struct {
 
-    xine_t            *xine;
+  vo_driver_t        vo_driver;
+  vo_scale_t         sc;
+
+  /* X11 related stuff */
+  Display           *display;
+  int                screen;
+  Drawable           drawable;
+
+  /* Render thread */
+  pthread_t          render_thread;
+  enum render_e      render_action;
+  int                render_frame_changed;
+  pthread_mutex_t    render_action_mutex;
+  pthread_cond_t     render_action_cond;
+  pthread_cond_t     render_return_cond;
+  int                last_width, last_height;
+
+  /* Render parameters */
+  int                render_fun_id;
+  int                render_min_fps;
+  int                render_double_buffer;
+  int                gui_width, gui_height;
+
+  /* OpenGL state */
+  GLXContext         context;
+  XVisualInfo       *vinfo;
+  int                tex_width, tex_height; /* independend of frame */
+
+  int                yuv2rgb_brightness;
+  int                yuv2rgb_contrast;
+  int                yuv2rgb_saturation;
+  uint8_t           *yuv2rgb_cmap;
+  yuv2rgb_factory_t *yuv2rgb_factory;
+
+  /* Frame state */
+  opengl_frame_t    *frame[NUM_FRAMES_BACKLOG];
+  x11osd            *xoverlay;
+  int                ovl_changed;
+
+  xine_t            *xine;
 } opengl_driver_t;
 
 typedef struct {
@@ -181,830 +160,1284 @@ typedef struct {
   xine_t              *xine;
 } opengl_class_t;
 
-
-enum { CONTEXT_BAD = 0, CONTEXT_SAME_DRAWABLE, CONTEXT_RELOAD, CONTEXT_SET };
+typedef void *(*thread_run_t)(void *);
 
 
 /*
- * and now, the driver functions
+ * Render functions
  */
 
-
-static uint32_t opengl_get_capabilities (vo_driver_t *this_gen) {
-    return VO_CAP_YV12 | VO_CAP_YUY2;
+/* Static 2d texture based display */
+static void render_tex2d (opengl_driver_t *this, opengl_frame_t *frame) {
+  int             x1, x2, y1, y2;
+  float           tx, ty;
+
+  /* Calc texture/rectangle coords */
+  x1 = this->sc.output_xoffset;
+  y1 = this->sc.output_yoffset;
+  x2 = x1 + this->sc.output_width;
+  y2 = y1 + this->sc.output_height;
+  tx = (float) frame->width  / this->tex_width;
+  ty = (float) frame->height / this->tex_height;
+  /* Draw quad */
+  glBegin (GL_QUADS);
+  glTexCoord2f (tx, ty);   glVertex2i   (x2, y2);
+  glTexCoord2f (0,  ty);   glVertex2i   (x1, y2);
+  glTexCoord2f (0,  0);    glVertex2i   (x1, y1);
+  glTexCoord2f (tx, 0);    glVertex2i   (x2, y1);
+  glEnd ();
 }
 
+/* Static image pipline based display */
+static void render_draw (opengl_driver_t *this, opengl_frame_t *frame) {
+  glPixelZoom   (((float)this->sc.output_width)    / frame->width,
+		 - ((float)this->sc.output_height) / frame->height);
+  glRasterPos2i (this->sc.output_xoffset, this->sc.output_yoffset);
+  glDrawPixels  (frame->width, frame->height, RGB_TEXTURE_FORMAT,
+		 GL_UNSIGNED_BYTE, frame->rgb);
+}
 
-static void opengl_frame_proc_slice (vo_frame_t *vo_img, uint8_t **src) {
-    opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
+/* Animated spinning cylinder */
+#define CYL_TESSELATION    128
+#define CYL_WIDTH          2.5
+#define CYL_HEIGHT         3.0
+static void render_cyl (opengl_driver_t *this, opengl_frame_t *frame) {
+  int             i;
+  float           off;
+  float           tx, ty;
+  struct timeval  curtime;
   
-    vo_img->proc_called = 1;
-
-/*  DEBUGF ((stderr, "*** %p: frame_copy src %p/%p/%p to %p\n", frame, src[0], src[1], src[2], frame->rgb_dst)); */
-
-    if ((char *) frame->rgb_dst + frame->stripe_inc > (char *) frame->texture
-        + frame->width * frame->height
-	* BYTES_PER_PIXEL) {
-        /* frame->rgb_dst can walk off the end of the frame's image data when
-         * xshm_frame_field, which resets it, is not called properly. This can
-         * happen with corrupt MPEG streams
-         * FIXME: Is there a way to ensure frame->rgb_dst validity?
-         */
-        DEBUGF ((stderr, "video_out_opengl: corrupt value of frame->rgb_dst -- skipping\n"));
-        return;
-    }
-    if (frame->format == XINE_IMGFMT_YV12) {
-	frame->yuv2rgb->yuv2rgb_fun (frame->yuv2rgb, frame->rgb_dst,
-				     src[0], src[1], src[2]);
-    } else {
-
-	frame->yuv2rgb->yuy22rgb_fun (frame->yuv2rgb, frame->rgb_dst,
-				      src[0]);
-				 
-    }
-
-    frame->rgb_dst += frame->stripe_inc; 
-/*  DEBUGF ((stderr, "frame_copy done\n")); */
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+  /* Calc timing + texture coords */
+  gettimeofday (&curtime, NULL);
+  off = ((curtime.tv_sec % SECONDS_PER_CYCLE) + curtime.tv_usec * 1e-6)
+    * (360.0 / SECONDS_PER_CYCLE);
+  tx = (float) frame->width  / this->tex_width;
+  ty = (float) frame->height / this->tex_height;
+
+  /* Spin it */
+  glMatrixMode   (GL_MODELVIEW);
+  glLoadIdentity ();
+  glTranslatef   (0, 0, -10);
+  glRotatef      (off * CYCLE_FACTOR1, 1, 0, 0);  
+  glRotatef      (off,                 0, 0, 1); 
+  glRotatef      (off * CYCLE_FACTOR2, 0, 1, 0);  
+ 
+  /* Note that this is not aspect ratio corrected */
+  glBegin (GL_QUADS);
+  for (i = 0; i < CYL_TESSELATION; i++) {
+    float x1 = CYL_WIDTH * sin (i     * MY_2PI / CYL_TESSELATION);
+    float x2 = CYL_WIDTH * sin ((i+1) * MY_2PI / CYL_TESSELATION);
+    float z1 = CYL_WIDTH * cos (i     * MY_2PI / CYL_TESSELATION);
+    float z2 = CYL_WIDTH * cos ((i+1) * MY_2PI / CYL_TESSELATION);
+    float tx1 = tx * i / CYL_TESSELATION;
+    float tx2 = tx * (i+1) / CYL_TESSELATION;
+    glTexCoord2f (tx1, 0);     glVertex3f (x1, CYL_HEIGHT, z1);
+    glTexCoord2f (tx2, 0);     glVertex3f (x2, CYL_HEIGHT, z2);
+    glTexCoord2f (tx2, ty);    glVertex3f (x2, -CYL_HEIGHT, z2);
+    glTexCoord2f (tx1, ty);    glVertex3f (x1, -CYL_HEIGHT, z1);
+  }
+  glEnd ();
 }
 
-static void opengl_frame_field (vo_frame_t *vo_img, int which_field) {
-
-    opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
+/* Animated spinning environment mapped torus */
+#define DIST_FACTOR   16.568542  	/* 2 * (sqrt(2)-1) * 20 */
+static void render_env_tor (opengl_driver_t *this, opengl_frame_t *frame) {
+  float           off;
+  float           x1, y1, x2, y2, tx, ty;
+  struct timeval  curtime;
+
+  /* No glClear() necessary - rendering background w/ depth test success */
+
+  /* Calc timing + texture coords */
+  gettimeofday (&curtime, NULL);
+  off = ((curtime.tv_sec % SECONDS_PER_CYCLE) + curtime.tv_usec * 1e-6)
+    * (360.0 / SECONDS_PER_CYCLE);
+  /* Fovy is angle in y direction */
+  x1 = (this->sc.output_xoffset - this->gui_width/2.0)
+    * DIST_FACTOR / this->gui_height;
+  x2 = (this->sc.output_xoffset+this->sc.output_width - this->gui_width/2.0)
+    * DIST_FACTOR / this->gui_height;
+  y1 = (this->sc.output_yoffset - this->gui_height/2.0)
+    * DIST_FACTOR / this->gui_height;
+  y2 = (this->sc.output_yoffset+this->sc.output_height - this->gui_height/2.0)
+    * DIST_FACTOR / this->gui_height;
+
+  tx = (float) frame->width  / this->tex_width;
+  ty = (float) frame->height / this->tex_height;
+
+  glMatrixMode   (GL_MODELVIEW);
+  glLoadIdentity ();
+
+  /* Draw background, Y swapped */
+  glMatrixMode   (GL_TEXTURE);
+  glPushMatrix   ();
+  glLoadIdentity ();
+  glDepthFunc    (GL_ALWAYS);
+  
+  glBegin        (GL_QUADS);
+  glColor3f      (1, 1, 1);
+  glTexCoord2f   (tx, 0);     glVertex3f   (x2, y2, -20);
+  glTexCoord2f   (0,  0);     glVertex3f   (x1, y2, -20);
+  glTexCoord2f   (0,  ty);    glVertex3f   (x1, y1, -20);
+  glTexCoord2f   (tx, ty);    glVertex3f   (x2, y1, -20);
+  glEnd          ();
+  
+  glPopMatrix    ();
+  glDepthFunc    (GL_LEQUAL);
+
+  /* Spin it */
+  glMatrixMode   (GL_MODELVIEW);
+  glLoadIdentity ();
+  glTranslatef   (0, 0, -10);
+  glRotatef      (off * CYCLE_FACTOR1, 1, 0, 0);
+  glRotatef      (off,                 0, 0, 1);
+  glRotatef      (off * CYCLE_FACTOR2, 0, 1, 0);
+  glEnable       (GL_TEXTURE_GEN_S);
+  glEnable       (GL_TEXTURE_GEN_T);
+  glColor3f      (1, 0.8, 0.6);
+  glCallList     (1);
+  glDisable      (GL_TEXTURE_GEN_S);
+  glDisable      (GL_TEXTURE_GEN_T);
+}
 
-    switch (which_field & VO_BOTH_FIELDS) {
-    case VO_TOP_FIELD:
-	frame->rgb_dst    = frame->texture;
-	frame->stripe_inc = 2 * STRIPE_HEIGHT * BYTES_PER_PIXEL * frame->width;
-	break;
-    case VO_BOTTOM_FIELD:
-	frame->rgb_dst    = frame->texture + BYTES_PER_PIXEL * frame->width;
-	frame->stripe_inc = 2 * STRIPE_HEIGHT * BYTES_PER_PIXEL * frame->width;
-	break;
-    case VO_BOTH_FIELDS:
-	frame->rgb_dst    = frame->texture;
-	frame->stripe_inc = STRIPE_HEIGHT * BYTES_PER_PIXEL * frame->width;
-	break;
-    }
-/*  DEBUGF ((stderr, "*** %p: frame_field: rgb_dst %p\n", frame, frame->rgb_dst)); */
+/*
+ * Image setup functions
+ */
+static void render_image_nop (opengl_driver_t *this, opengl_frame_t *frame) {
 }
 
+static void render_image_tex (opengl_driver_t *this, opengl_frame_t *frame) {
+  int tex_w, tex_h;
+
+  /* check necessary texture size and allocate */
+  if (frame->width != this->last_width ||
+      frame->height != this->last_height ||
+      ! this->tex_width || ! this->tex_height) {
+    tex_w = tex_h = 16;
+    while (tex_w < frame->width)
+      tex_w <<= 1;
+    while (tex_h < frame->height)
+      tex_h <<= 1;
+    
+    if (tex_w != this->tex_width || tex_h != this->tex_height) {
+      char *tmp = malloc (tex_w * tex_h * BYTES_PER_PIXEL);
+      glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB, tex_w, tex_h,
+		    0, RGB_TEXTURE_FORMAT, GL_UNSIGNED_BYTE, tmp);
+      CHECKERR ("texImage");
+      free (tmp);
+      this->tex_width  = tex_w;
+      this->tex_height = tex_h;
+      lprintf ("* new texsize: %dx%d\n", tex_w, tex_h);
+    }	
+    this->last_width  = frame->width;
+    this->last_height = frame->height;
+  }
+  /* Load texture */
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
+		   (GLsizei)(frame->width),
+		   (GLsizei)(frame->height),
+		   RGB_TEXTURE_FORMAT, GL_UNSIGNED_BYTE,
+		   frame->rgb);
+  CHECKERR ("texsubimage");
+}
 
-static void opengl_frame_dispose (vo_frame_t *vo_img) {
+static void render_image_envtex (opengl_driver_t *this, opengl_frame_t *frame) {
+  static float mTex[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
+
+  /* update texture matrix if frame size changed */
+  if (frame->width != this->last_width ||
+      frame->height != this->last_height ||
+      ! this->tex_width || ! this->tex_height) {
+    render_image_tex (this, frame);
+    /* Texture matrix has to skale/shift tex origin + swap y coords */
+    mTex[0]  =   1.0 * frame->width  / this->tex_width;
+    mTex[5]  =  -1.0 * frame->height / this->tex_height;
+    mTex[12] = (-2.0 * mTex[0]) / mTex[0];
+    mTex[13] =  -mTex[5];
+    glMatrixMode  (GL_TEXTURE);
+    glLoadMatrixf (mTex);
+  } else {
+    render_image_tex (this, frame);
+  }
+}
 
-    opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
-    opengl_driver_t *this = (opengl_driver_t *) vo_img->driver;
 
-    DEBUGF ((stderr, "*** frame_dispose ***\n"));
-    if (frame)
-    {
-	XLockDisplay (this->display);
-	free (frame->texture);
-	free (frame->chunk[0]);
-	free (frame->chunk[1]);
-	free (frame->chunk[2]);
-	frame->texture = NULL;
-	frame->chunk[0] = frame->chunk[1] = frame->chunk[2] = NULL;
-	XUnlockDisplay (this->display);
-    }
-    free (frame);
+/*
+ * Render setup functions
+ */
+static void render_help_setup_tex (opengl_driver_t *this) {
+  CHECKERR ("pre-tex_setup");
+  glEnable        (GL_TEXTURE_2D);
+  glTexParameteri (GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri (GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexEnvi       (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,   GL_REPLACE);
+  glMatrixMode    (GL_TEXTURE);
+  glLoadIdentity  ();
+  CHECKERR ("post-tex_setup");
 }
 
+static void render_setup_2d (opengl_driver_t *this) {
+  CHECKERR ("pre-frustum_setup");
+  glViewport   (0, 0, this->gui_width, this->gui_height);
+  glDepthRange (-1, 1);
+  glClearColor (0, 0, 0, 0);
+  glClearDepth (1.0f);
+  glMatrixMode (GL_PROJECTION);
+  glLoadIdentity ();
+  glOrtho      (0, this->gui_width, this->gui_height, 0, -1, 1);
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+  glDisable    (GL_BLEND);
+  glDisable    (GL_DEPTH_TEST);
+  glDepthMask  (GL_FALSE);
+  glDisable    (GL_CULL_FACE);
+  glShadeModel (GL_FLAT);
+  glDisable    (GL_TEXTURE_2D);
+  glHint       (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+  CHECKERR ("post-frustum_setup");
+}
 
-static vo_frame_t *opengl_alloc_frame (vo_driver_t *this_gen) {
+static void render_setup_tex2d (opengl_driver_t *this) {
+  render_setup_2d (this);
+  render_help_setup_tex (this);
+}
 
-    opengl_frame_t   *frame ;
-    opengl_driver_t  *this = (opengl_driver_t *) this_gen;
+static void render_setup_3d (opengl_driver_t *this) {
+  CHECKERR ("pre-3dfrustum_setup");
+  glViewport   (0, 0, this->gui_width, this->gui_height);
+  glDepthRange (0, 1);
+  glClearColor (0, 0, 0, 0);
+  glClearDepth (1.0f);
+  glMatrixMode (GL_PROJECTION);
+  glLoadIdentity ();
+  gluPerspective  (45.0f,
+		   (GLfloat)(this->gui_width) / (GLfloat)(this->gui_height),
+		   1.0f, 1000.0f);
+  glDisable    (GL_BLEND);
+  glEnable     (GL_DEPTH_TEST);
+  glDepthFunc  (GL_LEQUAL);
+  glDepthMask  (GL_TRUE);
+  glDisable    (GL_CULL_FACE);
+  glShadeModel (GL_FLAT);
+  glDisable    (GL_TEXTURE_2D);
+  glHint       (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+  CHECKERR ("post-3dfrustum_setup");
+}
 
-    DEBUGF ((stderr, "*** alloc_frame ***\n"));
-    frame = (opengl_frame_t *) xine_xmalloc (sizeof (opengl_frame_t));
-    if (!frame)
-      return NULL;
+static void render_setup_cyl (opengl_driver_t *this) {
+  render_setup_3d       (this);
+  render_help_setup_tex (this);
+  glClearColor  (0, .2, .3, 0);
+}
 
-    pthread_mutex_init (&frame->vo_frame.mutex, NULL);
+#define TOR_TESSELATION_B  128
+#define TOR_TESSELATION_S  64
+#define TOR_RADIUS_B       2.5
+#define TOR_RADIUS_S       1.0
 
-    /*
-     * supply required functions/fields
-     */
-    frame->vo_frame.proc_slice = opengl_frame_proc_slice;
-    frame->vo_frame.proc_frame = NULL;
-    frame->vo_frame.field      = opengl_frame_field; 
-    frame->vo_frame.dispose    = opengl_frame_dispose;
-    frame->vo_frame.driver     = this_gen;
+static void render_setup_torus (opengl_driver_t *this) {
+  int i, j, k;
   
-    /*
-     * colorspace converter for this frame
-     */
-    frame->yuv2rgb = this->yuv2rgb_factory->create_converter (this->yuv2rgb_factory);
-
-    return (vo_frame_t *) frame;
+  render_setup_3d       (this);
+  render_help_setup_tex (this);
+
+  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,   GL_MODULATE);
+  glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+  glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+
+  /* create display list */
+  glNewList (1, GL_COMPILE);
+  for (i = 0; i < TOR_TESSELATION_B; i++) {
+    glBegin (GL_QUAD_STRIP);
+    for (j = 0; j <= TOR_TESSELATION_S; j++) {
+      float phi = MY_2PI * j / TOR_TESSELATION_S;
+      for (k = 0; k <= 1; k++) {
+        float theta = MY_2PI * (i + k) / TOR_TESSELATION_B;
+	float nx    = TOR_RADIUS_S * cos(phi) * cos(theta);
+	float ny    = TOR_RADIUS_S * cos(phi) * sin(theta);
+	float nz    = TOR_RADIUS_S * sin(phi);
+	float nnorm = 1.0 / sqrt (nx*nx + ny*ny + nz*nz);
+	float x     = (TOR_RADIUS_B + TOR_RADIUS_S * cos(phi)) * cos(theta);
+	float y     = (TOR_RADIUS_B + TOR_RADIUS_S * cos(phi)) * sin(theta);
+	float z     = TOR_RADIUS_S * sin(phi);
+        glNormal3f (nx * nnorm, ny * nnorm, nz * nnorm);
+        glVertex3f (x, y, z);
+      }
+    }
+    glEnd   ();
+  }
+  glEndList ();
 }
 
+static char *opengl_render_fun_names[] = {
+  "2D_Textures", "Image_Pipeline", "Cylinder", "Environment_Mapped_Torus", NULL
+};
+static void (*opengl_display_funs[])(opengl_driver_t *, opengl_frame_t *) = {
+  render_tex2d, render_draw, render_cyl, render_env_tor
+};
+static void (*opengl_image_funs[])(opengl_driver_t *, opengl_frame_t *) = {
+  render_image_tex, render_image_nop, render_image_tex, render_image_envtex
+};
+static void (*opengl_setup_funs[])(opengl_driver_t *) = {
+  render_setup_tex2d, render_setup_2d, render_setup_cyl,
+  render_setup_torus
+};
+static enum render_e opengl_default_action[] = {
+    RENDER_NONE, RENDER_NONE, RENDER_DRAW, RENDER_DRAW
+};
 
-static void opengl_compute_ideal_size (opengl_driver_t *this) {
-
-    _x_vo_scale_compute_ideal_size (&this->sc);
+/*
+ * GFX state management
+ */
+static void render_gfx_vinfo (opengl_driver_t *this) {
+  static int glxAttrib[] = {
+    GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
+    GLX_DEPTH_SIZE, 1, None, None
+  } ;
+  if (this->render_double_buffer)
+    glxAttrib[9] = GLX_DOUBLEBUFFER;
+  else
+    glxAttrib[9] = None;
+  this->vinfo = glXChooseVisual (this->display, this->screen, glxAttrib);
+  CHECKERR ("choosevisual");
 }
 
-
-static void opengl_update_frame_format (vo_driver_t *this_gen,
-					vo_frame_t *frame_gen,
-					uint32_t width, uint32_t height,
-					double ratio, int format, int flags) {
-
-    opengl_driver_t  *this = (opengl_driver_t *) this_gen;
-    opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
-
-/*  DEBUGF ((stderr, "*** %p: update_frame_format ***\n", frame)); */
-    flags &= VO_BOTH_FIELDS;
-
-    if ((frame->width     != width)
-	|| (frame->height != height)
-	|| (frame->format != format)
-	|| (frame->flags  != flags)) {
-
-	int image_size = width * height;
-	
-	DEBUGF ((stderr, "video_out_opengl: updating frame to %dx%d (ratio=%f, format=%c%c%c%c)\n",
-		 width, height, ratio, format&0xff, (format>>8)&0xff,
-		 (format>>16)&0xff, (format>>24)&0xff));
-
-	/* update frame allocated data */
-
+/*
+ * Render thread
+ */
+static void *render_run (opengl_driver_t *this) {
+  int             action, changed;
+  opengl_frame_t *frame;
+  struct timeval  curtime;
+  struct timespec timeout;
+  
+  lprintf ("* render thread created\n");
+  while (1) {
+      
+    /* Wait for render action */
+    pthread_mutex_lock (&this->render_action_mutex);
+    if (! this->render_action) {
+      this->render_action = opengl_default_action [this->render_fun_id];
+      if (this->render_action) {
+	/* we have to animate even static images */
+	gettimeofday (&curtime, NULL);
+	timeout.tv_nsec = 1000 * curtime.tv_usec + 1e9L / this->render_min_fps;
+	timeout.tv_sec  = curtime.tv_sec;
+	if (timeout.tv_nsec > 1e9L) {
+	  timeout.tv_nsec -= 1e9L;
+	  timeout.tv_sec  += 1;
+	}
+	pthread_cond_timedwait (&this->render_action_cond,
+				&this->render_action_mutex, &timeout);
+      } else {
+	pthread_cond_wait (&this->render_action_cond,
+			   &this->render_action_mutex);
+      }
+    }
+    action  = this->render_action;
+    changed = this->render_frame_changed;
+    /* frame may be updated/deleted outside mutex, but still atomically */
+    /* we do not (yet) care to check frames for validity - this is a race.. */
+    /* but we do not delete/change frames for at least 4 frames after update */
+    frame  = this->frame[0];
+
+    lprintf ("* render action: %d   frame %d   changed %d   drawable %lx\n",
+	     action, frame ? frame->vo_frame.id : -1, changed, this->drawable);
+    switch (action) {
+
+    case RENDER_NONE:
+      pthread_mutex_unlock (&this->render_action_mutex);
+      break;
+
+    case RENDER_DRAW:
+      this->render_action = RENDER_NONE;
+      this->render_frame_changed = 0;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      if (this->context && frame) {
 	XLockDisplay (this->display);
+	CHECKERR ("pre-render");
+	if (changed)
+	  (opengl_image_funs   [this->render_fun_id]) (this, frame);
+	(opengl_display_funs [this->render_fun_id]) (this, frame);
+	glXSwapBuffers(this->display, this->drawable);
+	/* Note: no glFinish() - work concurrently to the graphics pipe */
+	CHECKERR ("post-render");
+	XUnlockDisplay (this->display);
+      }
+      break;
 
-	free (frame->texture);
-	free (frame->chunk[0]);
-	free (frame->chunk[1]);
-	free (frame->chunk[2]);
-	frame->chunk[0] = frame->chunk[1] = frame->chunk[2] = NULL;
-	
-	frame->texture = calloc (1, BYTES_PER_PIXEL * image_size);
-	_x_assert(frame->texture);
-
-	switch (format) {
-	case XINE_IMGFMT_YV12:
-	    frame->vo_frame.pitches[0] = 8*((width + 7) / 8);
-	    frame->vo_frame.pitches[1] = 8*((width + 15) / 16);
-	    frame->vo_frame.pitches[2] = 8*((width + 15) / 16);
-	    frame->vo_frame.base[0] = xine_xmalloc_aligned(16, frame->vo_frame.pitches[0] * height,         (void **) &frame->chunk[0]);
-	    frame->vo_frame.base[1] = xine_xmalloc_aligned(16, frame->vo_frame.pitches[1] * ((height+1)/2), (void **) &frame->chunk[1]);
-	    frame->vo_frame.base[2] = xine_xmalloc_aligned(16, frame->vo_frame.pitches[2] * ((height+1)/2), (void **) &frame->chunk[2]);
-	    break;
-	case XINE_IMGFMT_YUY2:
-	    frame->vo_frame.pitches[0] = 8*((width + 3) / 4);
-	    frame->vo_frame.base[0] = xine_xmalloc_aligned(16, frame->vo_frame.pitches[0] * height,         (void **) &frame->chunk[0]);
-	    break;
-	default:
-	    xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		     "video_out_opengl: image format %d not supported, update video driver!\n", format);
-	    return;
+    case RENDER_CLEAN:
+      this->render_action = RENDER_DRAW;
+      this->render_frame_changed = 0;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      if (this->context && frame) {
+	XLockDisplay (this->display);
+	CHECKERR ("pre-clean");
+	if (changed)
+	  (opengl_image_funs   [this->render_fun_id]) (this, frame);
+	if (this->render_double_buffer) {
+	  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+		   | GL_STENCIL_BUFFER_BIT);
+	  (opengl_display_funs [this->render_fun_id]) (this, frame);
+	  glXSwapBuffers(this->display, this->drawable);
 	}
+	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+		 | GL_STENCIL_BUFFER_BIT);
+	XUnlockDisplay (this->display);
+      }
+      break;
 
-	switch (flags) {
-	case VO_TOP_FIELD:
-	case VO_BOTTOM_FIELD:
-	    frame->yuv2rgb->configure (frame->yuv2rgb,
-				       width, 16, width*2, width, width,
-				       STRIPE_HEIGHT,
-				       width * BYTES_PER_PIXEL * 2);
-	    break;
-	case VO_BOTH_FIELDS:
-	    frame->yuv2rgb->configure (frame->yuv2rgb,
-				       width, 16, width, width/2, width,
-				       STRIPE_HEIGHT,
-				       width * BYTES_PER_PIXEL);
-	    break;
-	}
-	
-	frame->width  = width;
-	frame->height = height;
-	frame->format = format;
-	frame->flags  = flags;
-	
+    case RENDER_SETUP:
+      this->render_action = RENDER_CLEAN;
+      this->render_frame_changed = 1;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      if (this->context) {
+	XLockDisplay (this->display);
+	(opengl_setup_funs [this->render_fun_id]) (this);
 	XUnlockDisplay (this->display);
-    }
+	this->tex_width = this->tex_height = 0;
+      }
+      break;
+
+    case RENDER_CREATE:
+      this->render_action = RENDER_NONE;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      _x_assert (this->vinfo);
+      if (this->context)
+	xprintf (this->xine, XINE_VERBOSITY_LOG,
+		 "video_out_opengl: last context not destroyed\n"
+		 "   (frontend does not support XINE_GUI_SEND_WILL_DESTROY_DRAWABLE)\n"
+		 "   This will be a memory leak.\n");
+      XLockDisplay (this->display);
+      this->context = glXCreateContext (this->display, this->vinfo, NULL, True);
+      if (this->context) {
+        glXMakeCurrent (this->display, this->drawable, this->context);
+	CHECKERR ("create+makecurrent");
+      }
+      XUnlockDisplay (this->display);
+      break;
+
+    case RENDER_VISUAL:
+      this->render_action = RENDER_NONE;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      XLockDisplay (this->display);
+      render_gfx_vinfo (this);
+      XUnlockDisplay (this->display);
+      if (this->vinfo == NULL)
+	xprintf (this->xine, XINE_VERBOSITY_NONE,
+		 "video_out_opengl: no OpenGL support available (glXChooseVisual)\n");
+      else
+        lprintf ("* visual %p id %lx depth %d\n", this->vinfo->visual,
+		 this->vinfo->visualid, this->vinfo->depth);
+      break;
+
+    case RENDER_RELEASE:
+	this->render_action = RENDER_NONE;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      if (this->context) {
+	XLockDisplay (this->display);
+	glXMakeCurrent    (this->display, None, NULL);
+	glXDestroyContext (this->display, this->context);
+	CHECKERR ("release");
+	XUnlockDisplay (this->display);
+	this->context = NULL;
+      }
+      break;
 
-    frame->ratio = ratio;
-    opengl_frame_field ((vo_frame_t *)frame, flags);
-}
+    case RENDER_EXIT:
+      pthread_mutex_unlock (&this->render_action_mutex);
+      if (this->context) {
+	XLockDisplay (this->display);
+	glXMakeCurrent    (this->display, None, NULL);
+	glXDestroyContext (this->display, this->context);
+	CHECKERR ("exit");
+	XUnlockDisplay (this->display);
+      }
+      pthread_exit      (NULL);
+      break;
 
+    default:
+      this->render_action = RENDER_NONE;
+      pthread_mutex_unlock (&this->render_action_mutex);
+      _x_assert (!action);		/* unknown action */
+    }
+    lprintf ("* render action: %d   frame %d   done\n", action,
+	     frame ? frame->vo_frame.id : -1);
+    pthread_cond_signal (&this->render_return_cond);
+  }
+  /* NOTREACHED */
+  return NULL;
+}
 
-static void opengl_compute_output_size (opengl_driver_t *this) {
 
-    int old_width  = this->sc.output_width;
-    int old_height = this->sc.output_height;
-    int old_x      = this->sc.output_xoffset;
-    int old_y      = this->sc.output_yoffset;
+/*
+ * and now, the driver functions
+ */
 
-    _x_vo_scale_compute_output_size (&this->sc);
+static uint32_t opengl_get_capabilities (vo_driver_t *this_gen) {
+/*   opengl_driver_t *this = (opengl_driver_t *) this_gen; */
+  uint32_t capabilities = VO_CAP_YV12 | VO_CAP_YUY2;
 
-    /* avoid problems in yuv2rgb */
-    if (this->sc.output_height < ((this->sc.delivered_height + 15) >> 4))
-        this->sc.output_height = ((this->sc.delivered_height + 15) >> 4);
-    if (this->sc.output_width < 8)
-        this->sc.output_width = 8;
-    if (this->sc.output_width & 1) /* yuv2rgb_mlib needs an even YUV2 width */
-        this->sc.output_width++;
-    DEBUGF ((stderr, "video_out_opengl: this source %d x %d => screen output %d x %d\n",
-             this->sc.delivered_width, this->sc.delivered_height,
-             this->sc.output_width, this->sc.output_height));
+  /* TODO: somehow performance goes down during the first few frames */
+/*   if (this->xoverlay) */
+/*     capabilities |= VO_CAP_UNSCALED_OVERLAY; */
 
-    /* Force state reinitialization / clear */
-    if ( (old_width  != this->sc.output_width ||
-	  old_height != this->sc.output_height ||
-	  old_x   != this->sc.output_xoffset ||
-	  old_y   != this->sc.output_yoffset)
-	 && this->context_state == CONTEXT_SET)
-	this->context_state = CONTEXT_RELOAD;
+  return capabilities;
 }
 
+static void opengl_frame_proc_slice (vo_frame_t *vo_img, uint8_t **src) {
+  opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
+  /*opengl_driver_t *this = (opengl_driver_t *) vo_img->driver; */
+  
+  vo_img->proc_called = 1;                                    
 
-static void opengl_overlay_clut_yuv2rgb (opengl_driver_t  *this,
-					 vo_overlay_t *overlay,
-					 opengl_frame_t *frame) {
-    int i;
-    clut_t* clut = (clut_t*) overlay->color;
-    if (!overlay->rgb_clut) {
-	for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
-	    *((uint32_t *)&clut[i]) =
-		frame->yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb,
-							 clut[i].y, clut[i].cb, clut[i].cr);
-	}
-	overlay->rgb_clut++;
-    }
-    if (!overlay->clip_rgb_clut) {
-	clut = (clut_t*) overlay->clip_color;
-	for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
-	    *((uint32_t *)&clut[i]) =
-		frame->yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb,
-							 clut[i].y, clut[i].cb, clut[i].cr);
-	}
-	overlay->clip_rgb_clut++;
-    }
+/*   lprintf ("%p: frame_copy src %p/%p/%p to %p\n", frame, src[0], src[1], src[2], frame->rgb_dst); */
 
+  if( frame->vo_frame.crop_left || frame->vo_frame.crop_top || 
+      frame->vo_frame.crop_right || frame->vo_frame.crop_bottom )
+  {
+    /* TODO: opengl *could* support this?!? */
+    /* cropping will be performed by video_out.c */
+    return;
+  }
+  
+  if (frame->format == XINE_IMGFMT_YV12)
+    frame->yuv2rgb->yuv2rgb_fun (frame->yuv2rgb, frame->rgb_dst,
+				 src[0], src[1], src[2]);
+  else
+    frame->yuv2rgb->yuy22rgb_fun (frame->yuv2rgb, frame->rgb_dst,
+				  src[0]);
+  
+/*   lprintf ("frame_copy...done\n"); */
 }
 
+static void opengl_frame_field (vo_frame_t *vo_img, int which_field) {
+  opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
+  /* opengl_driver_t *this = (opengl_driver_t *) vo_img->driver; */
+
+/*   lprintf ("%p: frame_field image %p which_field %x\n", frame, frame->image->data, which_field); */
+
+  switch (which_field) {
+  case VO_TOP_FIELD:
+    frame->rgb_dst    = (uint8_t *)frame->rgb;
+    break;
+  case VO_BOTTOM_FIELD:
+    frame->rgb_dst    = (uint8_t *)frame->rgb + frame->width * BYTES_PER_PIXEL;
+    break;
+  case VO_BOTH_FIELDS:
+    frame->rgb_dst    = (uint8_t *)frame->rgb;
+    break;
+  }
+
+  frame->yuv2rgb->next_slice (frame->yuv2rgb, NULL);
+/*   lprintf ("frame_field...done\n"); */
+}
 
-static void opengl_overlay_blend (vo_driver_t *this_gen, vo_frame_t *frame_gen,
-				  vo_overlay_t *overlay) {
-    opengl_driver_t  *this = (opengl_driver_t *) this_gen;
-    opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
+static void opengl_frame_dispose (vo_frame_t *vo_img) {
+  opengl_frame_t  *frame = (opengl_frame_t *) vo_img ;
 
-    DEBUGF ((stderr, "*** overlay_blend\n"));
-    /* Alpha Blend here */
-    if (overlay->rle) {
-	if( !overlay->rgb_clut || !overlay->clip_rgb_clut)
-	    opengl_overlay_clut_yuv2rgb (this,overlay, frame);
+  frame->yuv2rgb->dispose (frame->yuv2rgb);
 
-#       if BYTES_PER_PIXEL == 3
-	    blend_rgb24 ((uint8_t *)frame->texture, overlay,
-		         frame->width, frame->height,
-		         frame->width, frame->height);
-#       elif BYTES_PER_PIXEL == 4
-	    blend_rgb32 ((uint8_t *)frame->texture, overlay,
-		         frame->width, frame->height,
-		         frame->width, frame->height);
-#       else
-#           error "bad BYTES_PER_PIXEL"
-#       endif
-    }
+  free (frame->chunk[0]);
+  free (frame->chunk[1]);
+  free (frame->chunk[2]);
+  free (frame->chunk[3]);
+  free (frame);
 }
 
 
-static int opengl_redraw_needed (vo_driver_t *this_gen) {
+static vo_frame_t *opengl_alloc_frame (vo_driver_t *this_gen) {
+  opengl_frame_t  *frame;
+  opengl_driver_t *this = (opengl_driver_t *) this_gen;
+
+  frame = (opengl_frame_t *) xine_xmalloc (sizeof (opengl_frame_t));
+  if (!frame)
+    return NULL;
+
+  pthread_mutex_init (&frame->vo_frame.mutex, NULL);
+
+  /*
+   * supply required functions/fields
+   */
+  frame->vo_frame.proc_slice = opengl_frame_proc_slice;
+  frame->vo_frame.proc_frame = NULL;
+  frame->vo_frame.field      = opengl_frame_field; 
+  frame->vo_frame.dispose    = opengl_frame_dispose;
+  frame->vo_frame.driver     = this_gen;
+
+  /*
+   * colorspace converter for this frame
+   */
+  frame->yuv2rgb = this->yuv2rgb_factory->create_converter (this->yuv2rgb_factory);
+
+  return (vo_frame_t *) frame;
+}
 
-    opengl_driver_t  *this = (opengl_driver_t *) this_gen;
+static void opengl_compute_ideal_size (opengl_driver_t *this) {
+  _x_vo_scale_compute_ideal_size( &this->sc );
+}
 
-    DEBUGF ((stderr, "*** redraw_needed %dx%d\n", this->sc.delivered_width, this->sc.delivered_height));
+static void opengl_compute_rgb_size (opengl_driver_t *this) {
+  _x_vo_scale_compute_output_size( &this->sc );
+}
 
-    if (_x_vo_scale_redraw_needed (&this->sc)) {
-	opengl_compute_output_size (this);
-	/* Actually, the output area is cleared in render_image */
-        return 1;
-    }
-    return 0;
-}
-
-
-static void opengl_render_image (opengl_driver_t *this, opengl_frame_t *frame,
-                                 GLXContext ctx)
-{
-    pthread_t       self = pthread_self ();
-
-    DEBUGF ((stderr, "*** render_image %p frame %p %dx%d ctx %p%s\n",
-	     this, frame, frame->width, frame->height, ctx,
-	     self != this->renderthread ?                   " THREAD"         :
-	     ctx && ctx != this->context ?                  " gui"            :
-	     this->context_state == CONTEXT_SET ?
-	     ctx ? " set, but reload anyway" : " set"                  :
-	     this->context_state == CONTEXT_RELOAD ?        " reload"         :
-	     this->context_state == CONTEXT_SAME_DRAWABLE ? " DESTROY+CREATE" :
-	     " CREATE" ));
-
-    /* already initialized? */
-    if (! this->drawable || ! this->vinfo)
-      {
-	xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		 "video_out_opengl: early exit due to missing drawable %lx vinfo %p\n", this->drawable, this->vinfo);
-	return;
+static void opengl_update_frame_format (vo_driver_t *this_gen,
+				      vo_frame_t *frame_gen,
+				      uint32_t width, uint32_t height,
+				      double ratio, int format, int flags) {
+  opengl_driver_t  *this = (opengl_driver_t *) this_gen;
+  opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
+  int     g_width, g_height;
+  double  g_pixel_aspect;
+
+  /* Check output size to signal render thread output size changes */
+  this->sc.dest_size_cb (this->sc.user_data, width, height,
+			 this->sc.video_pixel_aspect, &g_width, &g_height,
+			 &g_pixel_aspect);
+  lprintf ("update_frame_format %dx%d output %dx%d\n", width, height,
+	   g_width, g_height);
+
+  if (g_width != this->gui_width || g_height != this->gui_height) {
+      this->gui_width  = g_width;
+      this->gui_height = g_height;
+      pthread_mutex_lock (&this->render_action_mutex);
+      if (this->render_action <= RENDER_SETUP) {
+	  this->render_action = RENDER_SETUP;
+	  pthread_cond_signal  (&this->render_action_cond);
       }
-    
-    /*
-     * check for size changes
-     */
-    if (frame->width  != this->last_width    ||
-	frame->height != this->last_height   ||
-	frame->ratio  != this->last_ratio) {
-      
-      this->last_width  = frame->width;
-      this->last_height = frame->height;
-      this->last_ratio  = frame->ratio;
-      
-      DEBUGF ((stderr, "video_out_opengl: display format changed\n"));
-      opengl_compute_ideal_size  (this);
-      opengl_compute_output_size (this);
-    }
+      pthread_mutex_unlock (&this->render_action_mutex);
+  }
 
-    /*
-     * Check texture size
-     */
-    if (this->texture_width < frame->width || this->texture_height < frame->height)
-	this->context_state = CONTEXT_RELOAD;
-	
-    /*
-     * check whether a new context has to be created
-     */
-    DEBUGF ((stderr, "video_out_opengl: CHECK\n"));
-    if (((ctx == this->context || ! ctx) &&
-	 (this->context_state == CONTEXT_BAD ||
-	  this->context_state == CONTEXT_SAME_DRAWABLE)) ||
-	(self != this->renderthread))
-    {
-
-      static int glxAttrib[] = {
-	GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None
-      } ;
-
-      _x_assert(this->vinfo);
-
-      if ((this->context_state == CONTEXT_SAME_DRAWABLE) &&
-	  (self == this->renderthread))
-	{
-	  DEBUGF ((stderr, "destroy: %p\n", this->context));
-	  /* Unfortunately for _BAD the drawable is already destroyed.
-	   * This cannot be resolved right now and will be a memory leak. */
-	  if (this->context)
-	    glXDestroyContext (this->display, this->context);
-	}
-
-      DEBUGF ((stderr, "glXChooseVisual\n"));
+  /* Check frame size and format and reallocate if necessary */
+  if ((frame->width != width)
+      || (frame->height != height)
+      || (frame->format != format)
+      || (frame->flags  != flags)) {
+    lprintf ("updating frame to %d x %d (ratio=%g, format=%08x)\n",
+	     width, height, ratio, format);
 
-      this->vinfo = glXChooseVisual (this->display, this->screen, glxAttrib);
-      DEBUGF ((stderr, "create display %p vinfo %p\n", this->display, this->vinfo));
-      ctx = glXCreateContext (this->display, this->vinfo, NULL, True);
-      DEBUGF ((stderr, "created\n"));
-
-      _x_assert(ctx);
+    flags &= VO_BOTH_FIELDS;
+	
+    XLockDisplay (this->display);
 
-      this->context = ctx;
-      this->context_state = CONTEXT_RELOAD;
-      this->renderthread  = self;
+    /* (re-) allocate render space */
+    free (frame->chunk[0]);
+    free (frame->chunk[1]);
+    free (frame->chunk[2]);
+    free (frame->chunk[3]);
+
+    if (format == XINE_IMGFMT_YV12) {
+      frame->vo_frame.pitches[0] = 8*((width + 7) / 8);
+      frame->vo_frame.pitches[1] = 8*((width + 15) / 16);
+      frame->vo_frame.pitches[2] = 8*((width + 15) / 16);
+      frame->vo_frame.base[0] = xine_xmalloc_aligned (16, frame->vo_frame.pitches[0] * height,  (void **) &frame->chunk[0]);
+      frame->vo_frame.base[1] = xine_xmalloc_aligned (16, frame->vo_frame.pitches[1] * ((height+1)/2), (void **) &frame->chunk[1]);
+      frame->vo_frame.base[2] = xine_xmalloc_aligned (16, frame->vo_frame.pitches[2] * ((height+1)/2), (void **) &frame->chunk[2]);
+    } else {
+      frame->vo_frame.pitches[0] = 8*((width + 3) / 4);
+      frame->vo_frame.base[0] = xine_xmalloc_aligned (16, frame->vo_frame.pitches[0] * height, (void **) &frame->chunk[0]);
+      frame->chunk[1] = NULL;
+      frame->chunk[2] = NULL;
     }
+    frame->rgb = xine_xmalloc_aligned (16, BYTES_PER_PIXEL*width*height,
+				       (void **) &frame->chunk[3]);
 
-    if (this->context_state == CONTEXT_RELOAD && ! ctx)
-	ctx = this->context;
-
-    /*
-     * reload and initialize context and clear display
-     * this is handled together due to close relationship
-     */
-    if (ctx)
-    {
-	void *texture_data;
-
-	DEBUGF ((stderr, "set context %p\n", ctx));
-	/*
-	 * Set and initialize context
-	 */
-	if (! glXMakeCurrent (this->display, this->drawable, ctx)) {
-	    xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		     "video_out_opengl: no OpenGL support available (glXMakeCurrent)\n"
-		     "    The drawable does not seem to be updated correctly.\n");
-	    _x_abort();
-	}
-	DEBUGF ((stderr, "set context done\n"));
-	if (ctx == this->context)
-	    this->context_state = CONTEXT_SET;
-	else if (this->context_state == CONTEXT_SET ||
-		 this->context_state == CONTEXT_RELOAD)
-	    this->context_state = CONTEXT_RELOAD;
-	glViewport (0, 0, this->sc.gui_width, this->sc.gui_height);
-	glMatrixMode (GL_MODELVIEW);
-	glLoadIdentity ();
-	glClearColor (0, 0, 0, 0);
-	glClearDepth (1.0f);
-	glDisable    (GL_BLEND);
-	glDisable    (GL_DEPTH_TEST);
-	glDepthMask  (GL_FALSE);
-	glDisable    (GL_CULL_FACE);
-	glShadeModel (GL_FLAT);
-	glHint       (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
-
-#if USE_SPHERE
-	glDepthFunc     (GL_LEQUAL);
-	glEnable        (GL_DEPTH_TEST);
-	glMatrixMode(GL_TEXTURE);
-	glLoadIdentity();
-	glScalef((float)(frame->width)/(float)(this->texture_width),
-		 (float)(frame->height)/(float)(this->texture_height),
-		 1.0f);
-	glMatrixMode    (GL_PROJECTION);
-	glLoadIdentity  ();
-	gluPerspective  (45.0f, 
-			 (GLfloat)(this->gui_width)/
-			 (GLfloat)(this->gui_height),
-			 1.0f, 1000.0f);
-	glTexGeni       (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
-	glTexGeni       (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+    /* set up colorspace converter */
+    switch (flags) {
+    case VO_TOP_FIELD:
+    case VO_BOTTOM_FIELD:
+      frame->yuv2rgb->configure (frame->yuv2rgb,
+				 width,
+				 height,
+				 2*frame->vo_frame.pitches[0],
+				 2*frame->vo_frame.pitches[1],
+				 width,
+				 height,
+				 BYTES_PER_PIXEL*width * 2);
+      break;
+    case VO_BOTH_FIELDS:
+      frame->yuv2rgb->configure (frame->yuv2rgb,
+				 width,
+				 height,
+				 frame->vo_frame.pitches[0],
+				 frame->vo_frame.pitches[1],
+				 width,
+				 height,
+				 BYTES_PER_PIXEL*width);
+      break;
+    }
 
-#else
-	glMatrixMode (GL_PROJECTION);
-	glLoadIdentity ();
-	glOrtho (0, this->sc.gui_width, this->sc.gui_height, 0, -1, 1);
-#endif
+    frame->width = width;
+    frame->height = height;
+    frame->format = format;
 
-#if USE_TEXTURES
-	glEnable        (GL_TEXTURE_2D);
-	glTexParameteri (GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri (GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexEnvi       (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,   GL_REPLACE);
-
-	/*
-	 * check necessary texture size and allocate
-	 */
-	this->texture_width = 1;
-	while (this->texture_width < frame->width)
-	    this->texture_width <<= 1;
-	this->texture_height = 1;
-	while (this->texture_height < frame->height)
-	    this->texture_height <<= 1;
-
-	texture_data = malloc (this->texture_width * this->texture_height * 3);
-	glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
-		      this->texture_width, this->texture_height,
-		      0, GL_RGB, GL_UNSIGNED_BYTE, texture_data);
-	free (texture_data);
-#endif
-    }
+    XUnlockDisplay (this->display); 
 
-    if (ctx || opengl_redraw_needed ((vo_driver_t *) this)) {
-#if USE_SPHERE
-	glClear    (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-#else
-	glClear    (GL_COLOR_BUFFER_BIT);
-#endif
-    }
+    opengl_frame_field ((vo_frame_t *)frame, flags);
+  }
 
-    if (frame)
-    {
-	/*
-	 * Render one image
-	 */
-#if USE_TEXTURES
-        int x1 = this->sc.output_xoffset,    y1 = this->sc.output_yoffset;
-	int x2 = x1 + this->sc.output_width, y2 = y1 + this->sc.output_height;
-	float tx = (float) frame->width  / this->texture_width;
-	float ty = (float) frame->height / this->texture_height;
-
-	glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
-			 (GLsizei)(frame->width),
-			 (GLsizei)(frame->height),
-			 RGB_TEXTURE_FORMAT, GL_UNSIGNED_BYTE,
-			 frame->texture);
-	
-	glBegin (GL_QUADS);
-	glTexCoord2f (tx, ty);   glVertex2i   (x2, y2);
-	glTexCoord2f (0,  ty);   glVertex2i   (x1, y2);
-	glTexCoord2f (0,  0);    glVertex2i   (x1, y1);
-	glTexCoord2f (tx, 0);    glVertex2i   (x2, y1);
-	glEnd ();	
-	
-#if USE_SPHERE
-	glEnable(GL_TEXTURE_GEN_S);
-	glEnable(GL_TEXTURE_GEN_T);	
+  frame->ratio = ratio;
+  lprintf ("done...update_frame_format\n");
+}
 
-	glTranslatef(0.0f, 0.0f, -10.0f);
-	glutSolidSphere(3.0f, 20, 10);
 
-	glDisable(GL_TEXTURE_GEN_S);
-	glDisable(GL_TEXTURE_GEN_T);
-#endif
+static void opengl_overlay_clut_yuv2rgb(opengl_driver_t  *this, vo_overlay_t *overlay,
+				      opengl_frame_t *frame) {
+  int     i;
+  clut_t* clut = (clut_t*) overlay->color;
 
-#else
-	glPixelZoom (((float)this->output_width)    / frame->width,
-                 - ((float)this->output_height) / frame->height);
-	glRasterPos2i (this->output_xoffset, this->output_yoffset);
-	glDrawPixels (frame->width, frame->height, RGB_TEXTURE_FORMAT,
-		      GL_UNSIGNED_BYTE, frame->texture);
-#endif
-	DEBUGF ((stderr, "render done\n"));
+  if (!overlay->rgb_clut) {
+    for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
+      *((uint32_t *)&clut[i]) =
+	frame->yuv2rgb->yuv2rgb_single_pixel_fun (frame->yuv2rgb, clut[i].y,
+						  clut[i].cb, clut[i].cr);
     }
-  
-    glFlush ();
-    DEBUGF ((stderr, "video_output_opengl: OpenGL error: '%s'\n", gluErrorString (glGetError ())));
-    /* Note: no glFinish() - work concurrently to the graphics pipe */
+    overlay->rgb_clut++;
+  }
+  if (!overlay->clip_rgb_clut) {
+    clut = (clut_t*) overlay->clip_color;
+    for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) {
+      *((uint32_t *)&clut[i]) =
+	frame->yuv2rgb->yuv2rgb_single_pixel_fun(frame->yuv2rgb, clut[i].y,
+						 clut[i].cb, clut[i].cr);
+    }
+    overlay->clip_rgb_clut++;
+  }
 }
 
+static void opengl_overlay_begin (vo_driver_t *this_gen, 
+			      vo_frame_t *frame_gen, int changed) {
+  opengl_driver_t  *this  = (opengl_driver_t *) this_gen;
 
-static void opengl_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) {
-
-    opengl_driver_t  *this = (opengl_driver_t *) this_gen;
-    opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
+  this->ovl_changed += changed;
 
-    DEBUGF ((stderr, "*** display_frame ***\n"));
-    DEBUGF ((stderr, "video_out_opengl: about to draw frame %d x %d...\n", frame->width, frame->height));
+  if (this->ovl_changed && this->xoverlay) {
     XLockDisplay (this->display);
-    opengl_render_image (this, frame, NULL);
+    x11osd_clear(this->xoverlay); 
     XUnlockDisplay (this->display);
-    
-    /* Theoretically, the frame data is not used immedeately, and the
-     * graphics system might address altered data - but only if we
-     * are faster than the graphics hardware... */
-    /* If the image seems to be clobbered, remove the following two lines */
-    /* Note: We cannot do expose events, when the frame is deleted. */
-    /* Note: We cannot do expose events anyway right now (errors with
-     * multiple threads rendering in many OpenGL implementations) */
-    /* FIXME: check that */
-#if 1
-    frame->vo_frame.free (&frame->vo_frame);
-#endif
-    DEBUGF ((stderr, "done display_frame\n"));
+  }
 }
 
+static void opengl_overlay_end (vo_driver_t *this_gen, vo_frame_t *vo_img) {
+  opengl_driver_t  *this  = (opengl_driver_t *) this_gen;
 
-static int opengl_get_property (vo_driver_t *this_gen, int property) {
+  if (this->ovl_changed && this->xoverlay) {
+    XLockDisplay (this->display);
+    x11osd_expose(this->xoverlay);
+    XUnlockDisplay (this->display);
+  }
 
-    opengl_driver_t *this = (opengl_driver_t *) this_gen;
-
-    DEBUGF ((stderr, "*** get_property\n"));
-    switch (property) {
-    case VO_PROP_ASPECT_RATIO:
-	return this->sc.user_ratio ;
-    case VO_PROP_BRIGHTNESS:
-	return this->yuv2rgb_brightness;
-    case VO_PROP_WINDOW_WIDTH:
-        return this->sc.gui_width;
-    case VO_PROP_WINDOW_HEIGHT:
-        return this->sc.gui_height;
-    default:
-	xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		 "video_out_opengl: tried to get unsupported property %d\n", property);
+  this->ovl_changed = 0;
+}
+
+static void opengl_overlay_blend (vo_driver_t *this_gen, 
+				vo_frame_t *frame_gen, vo_overlay_t *overlay) {
+  opengl_driver_t  *this  = (opengl_driver_t *) this_gen;
+  opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
+
+  /* Alpha Blend here */
+  if (overlay->rle) {
+    if (overlay->unscaled) {
+      if (this->ovl_changed && this->xoverlay) {
+        XLockDisplay (this->display);
+        x11osd_blend (this->xoverlay, overlay); 
+        XUnlockDisplay (this->display);
+      }
+    } else {
+      if (!overlay->rgb_clut || !overlay->clip_rgb_clut)
+        opengl_overlay_clut_yuv2rgb (this, overlay, frame);
+
+#     if BYTES_PER_PIXEL == 3
+        blend_rgb24 ((uint8_t *)frame->rgb, overlay,
+		     frame->width, frame->height,
+		     frame->width, frame->height);
+#     elif BYTES_PER_PIXEL == 4
+	blend_rgb32 ((uint8_t *)frame->rgb, overlay,
+		     frame->width, frame->height,
+		     frame->width, frame->height);
+#     else
+#       error "bad BYTES_PER_PIXEL"
+#     endif
     }
+  }
+}
 
-    return 0;
+static int opengl_redraw_needed (vo_driver_t *this_gen) {
+  opengl_driver_t  *this = (opengl_driver_t *) this_gen;
+  int             ret = 0;
+
+/*   lprintf ("redraw_needed\n"); */
+  if (this->frame[0]) {
+    this->sc.delivered_height   = this->frame[0]->height;
+    this->sc.delivered_width    = this->frame[0]->width;
+    this->sc.delivered_ratio    = this->frame[0]->ratio;
+
+    this->sc.crop_left        = this->frame[0]->vo_frame.crop_left;
+    this->sc.crop_right       = this->frame[0]->vo_frame.crop_right;
+    this->sc.crop_top         = this->frame[0]->vo_frame.crop_top;
+    this->sc.crop_bottom      = this->frame[0]->vo_frame.crop_bottom;
+
+    opengl_compute_ideal_size(this);
+
+    if( _x_vo_scale_redraw_needed( &this->sc ) ) {  
+      opengl_compute_rgb_size(this);
+      pthread_mutex_lock (&this->render_action_mutex);
+      if (this->render_action <= RENDER_CLEAN) {
+	  this->render_action = RENDER_CLEAN;
+	  pthread_cond_signal  (&this->render_action_cond);
+      }
+      pthread_mutex_unlock (&this->render_action_mutex);
+      ret = 1;
+    }
+  } 
+  else
+    ret = 1;
+      
+/*   lprintf ("done...redraw_needed: %d\n", ret); */
+  return ret;
 }
 
+static void opengl_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) {
+  opengl_driver_t  *this  = (opengl_driver_t *) this_gen;
+  opengl_frame_t   *frame = (opengl_frame_t *) frame_gen;
+  int i;
+
+  lprintf ("about to draw frame (%d) %d x %d...\n", frame->vo_frame.id, frame->width, frame->height);
+
+/*   lprintf ("video_out_opengl: freeing frame %d\n", this->frame[NUM_FRAMES_BACKLOG-1] ? this->frame[NUM_FRAMES_BACKLOG-1]->vo_frame.id : -1); */
+  if (this->frame[NUM_FRAMES_BACKLOG-1])
+    this->frame[NUM_FRAMES_BACKLOG-1]->vo_frame.free (&this->frame[NUM_FRAMES_BACKLOG-1]->vo_frame);
+  for (i = NUM_FRAMES_BACKLOG-1; i > 0; i--)
+    this->frame[i] = this->frame[i-1];
+  this->frame[0] = frame;
+  this->render_frame_changed = 1;
+/*   lprintf ("video_out_opengl: cur_frame updated to %d\n", frame->vo_frame.id); */
+  
+  /*
+   * let's see if this frame is different in size / aspect
+   * ratio from the previous one
+   */
+  if ( (frame->width != this->sc.delivered_width)
+       || (frame->height != this->sc.delivered_height)
+       || (frame->ratio != this->sc.delivered_ratio) ) {
+    lprintf("frame format changed\n");
+    this->sc.force_redraw = 1;    /* trigger re-calc of output size */
+  }
+  
+  /*
+   * tell gui that we are about to display a frame,
+   * ask for offset and output size
+   */
+  opengl_redraw_needed (this_gen);
+
+  pthread_mutex_lock (&this->render_action_mutex);
+  if (this->render_action <= RENDER_DRAW) {
+      this->render_action = RENDER_DRAW;
+      pthread_cond_signal  (&this->render_action_cond);
+  }
+  pthread_mutex_unlock (&this->render_action_mutex);
+
+  lprintf ("display frame done\n");
+}
 
-static int opengl_set_property (vo_driver_t *this_gen, 
-				int property, int value) {
+static int opengl_get_property (vo_driver_t *this_gen, int property) {
+  opengl_driver_t *this = (opengl_driver_t *) this_gen;
+
+  switch (property) {
+  case VO_PROP_ASPECT_RATIO:
+    return this->sc.user_ratio;
+  case VO_PROP_MAX_NUM_FRAMES:
+    return 15;
+  case VO_PROP_BRIGHTNESS:
+    return this->yuv2rgb_brightness;
+  case VO_PROP_CONTRAST:
+    return this->yuv2rgb_contrast;
+  case VO_PROP_SATURATION:
+    return this->yuv2rgb_saturation;
+  case VO_PROP_WINDOW_WIDTH:
+    return this->sc.gui_width;
+  case VO_PROP_WINDOW_HEIGHT:
+    return this->sc.gui_height;
+  default:
+    xprintf(this->xine, XINE_VERBOSITY_DEBUG, 
+	    "video_out_opengl: tried to get unsupported property %d\n", property);
+  }
+
+  return 0;
+}
 
-    opengl_driver_t *this = (opengl_driver_t *) this_gen;
-    
-    DEBUGF ((stderr, "*** set_property\n"));
-    switch (property) {
-    case VO_PROP_ASPECT_RATIO:
-	if (value >= XINE_VO_ASPECT_NUM_RATIOS)
-	    value  = XINE_VO_ASPECT_AUTO;
-	this->sc.user_ratio = value;
-	xprintf (this->xine, XINE_VERBOSITY_DEBUG, "video_out_opengl: aspect ratio changed to %s\n",
-	         _x_vo_scale_aspect_ratio_name (value));
-	opengl_compute_ideal_size (this);
-//	opengl_redraw_needed      ((vo_driver_t *) this);
-	break;
-    case VO_PROP_BRIGHTNESS:
-	this->yuv2rgb_brightness = value;
-	this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory, value, 128, 128);
-	xprintf(this->xine, XINE_VERBOSITY_DEBUG, "video_out_opengl: brightness changed to %d\n",value);
-	break;
-    default:
-        xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		 "video_out_opengl: tried to set unsupported property %d\n", property);
-    }
-    
-    return value;
+static int opengl_set_property (vo_driver_t *this_gen, 
+			      int property, int value) {
+  opengl_driver_t *this = (opengl_driver_t *) this_gen;
+
+  switch (property) {
+  case VO_PROP_ASPECT_RATIO:
+    if (value>=XINE_VO_ASPECT_NUM_RATIOS)
+      value = XINE_VO_ASPECT_AUTO;
+    this->sc.user_ratio = value;
+    opengl_compute_ideal_size (this);
+    this->sc.force_redraw = 1;    /* trigger re-calc of output size */
+
+    xprintf(this->xine, XINE_VERBOSITY_DEBUG, 
+	    "video_out_opengl: aspect ratio changed to %s\n", _x_vo_scale_aspect_ratio_name(value));
+    break;
+  case VO_PROP_BRIGHTNESS:
+    this->yuv2rgb_brightness = value;
+    this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory,
+					   this->yuv2rgb_brightness,
+					   this->yuv2rgb_contrast,
+					   this->yuv2rgb_saturation);
+    this->sc.force_redraw = 1;
+    break;
+  case VO_PROP_CONTRAST:
+    this->yuv2rgb_contrast = value;
+    this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory,
+					   this->yuv2rgb_brightness,
+					   this->yuv2rgb_contrast,
+					   this->yuv2rgb_saturation);
+    this->sc.force_redraw = 1;
+    break;
+  case VO_PROP_SATURATION:
+    this->yuv2rgb_saturation = value;
+    this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory,
+					   this->yuv2rgb_brightness,
+					   this->yuv2rgb_contrast,
+					   this->yuv2rgb_saturation);
+    this->sc.force_redraw = 1;
+    break;
+  default:
+    xprintf (this->xine, XINE_VERBOSITY_DEBUG, 
+	     "video_out_opengl: tried to set unsupported property %d\n", property);
+  }
+
+  return value;
 }
 
 static void opengl_get_property_min_max (vo_driver_t *this_gen,
-					 int property, int *min, int *max) {
-
-    DEBUGF ((stderr, "get_property_min_max\n"));
-    /* opengl_driver_t *this = (opengl_driver_t *) this_gen;  */
-    if ( property == VO_PROP_BRIGHTNESS) {
-	*min = -100;
-	*max = +100;
-    } else {
-	*min = 0;
-	*max = 0;
-    }
+				     int property, int *min, int *max) {
+  /* opengl_driver_t *this = (opengl_driver_t *) this_gen;  */
+
+  switch (property) {
+  case VO_PROP_BRIGHTNESS:
+    *min = -128;    *max = 127;     break;
+  case VO_PROP_CONTRAST:
+    *min = 0;       *max = 255;     break;
+  case VO_PROP_SATURATION:
+    *min = 0;       *max = 255;     break;
+  default:
+    *min = 0;       *max = 0;
+  }
 }
 
-
 static int opengl_gui_data_exchange (vo_driver_t *this_gen, 
-				     int data_type, void *data) {
+				   int data_type, void *data) {
+  opengl_driver_t   *this = (opengl_driver_t *) this_gen;
 
-    opengl_driver_t   *this = (opengl_driver_t *) this_gen;
-    static int glxAttrib[] = {
-	GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None
-    } ;
-
-    DEBUGF ((stderr, "*** gui_data_exchange ***\n"));
+  switch (data_type) {
+#ifndef XINE_DISABLE_DEPRECATED_FEATURES
+  case XINE_GUI_SEND_COMPLETION_EVENT:
+    break;
+#endif
 
-    switch (data_type) {
+  case XINE_GUI_SEND_EXPOSE_EVENT:
+    
+    lprintf ("expose event\n");
 
-    case XINE_GUI_SEND_SELECT_VISUAL:
-	DEBUGF ((stderr, "*** gui_select_visual ***\n"));
-	XLockDisplay (this->display);
-	this->vinfo = glXChooseVisual (this->display, this->screen, glxAttrib);
-	XUnlockDisplay (this->display);
-	if (this->vinfo == NULL)
-	    xprintf (this->xine, XINE_VERBOSITY_DEBUG,
-		     "video_out_opengl: no OpenGL support available (glXChooseVisual)\n");
-	*(XVisualInfo**)data = this->vinfo;
-	DEBUGF ((stderr, "*** visual %p depth %d\n", this->vinfo->visual, this->vinfo->depth));
-	break;
+    if (this->frame[0]) {
+      XExposeEvent * xev = (XExposeEvent *) data;
       
-    case XINE_GUI_SEND_EXPOSE_EVENT:
-	DEBUGF ((stderr, "*** gui_expose ***\n"));
-
-	/* Note that the global GLX context is not available on all
-	 * architectures in this thread */
-	/* Note that using different contextes in different threads
-	 * for the same drawable seems to be broken with several
-	 * OpenGL implementations */
-	/* Thus nothing is updated here, just the render thread is
-	 * notified */
-	if (this->context_state == CONTEXT_SET)
-	    this->context_state = CONTEXT_RELOAD;
-	break;
-
-    case XINE_GUI_SEND_DRAWABLE_CHANGED:
-	DEBUGF ((stderr, "*** gui_drawable_changed: %ld\n", (Drawable) data));
+      if (xev && xev->count == 0) {
+	pthread_mutex_lock (&this->render_action_mutex);
+	if (this->render_action <= RENDER_CLEAN) {
+	    this->render_action = RENDER_CLEAN;
+	    pthread_cond_signal  (&this->render_action_cond);
+	}
+	pthread_mutex_unlock (&this->render_action_mutex);
 	XLockDisplay (this->display);
-	/* Unfortunately, the last drawable is already gone, so we cannot
-	 * destroy the former context. This is a memory leak. Unfortunately. */
-	/* Even if the drawable remains the same, this does not seem to
-	 * work :( */
-	/* FIXME: check that */
-#if 0
-	if (this->drawable == (Drawable) data)
-	    this->context_state = CONTEXT_SAME_DRAWABLE;
-	else
-	    this->context_state = CONTEXT_BAD;
-#else
-	this->context_state = CONTEXT_BAD;
-#endif
-	if (this->context_state == CONTEXT_BAD)
-	    DEBUGF ((stderr, "*** drawable changed, state now bad\n"));
-	this->drawable = (Drawable) data;
+        if(this->xoverlay)
+          x11osd_expose(this->xoverlay);
+	XSync(this->display, False);
 	XUnlockDisplay (this->display);
-	break;
-
-    case XINE_GUI_SEND_TRANSLATE_GUI_TO_VIDEO: {
-            x11_rectangle_t *rect = data;
-            int x1, y1, x2, y2;
-/*  	    DEBUGF ((stderr, "*** gui_translate_gui_to_video ***\n")); */
+      }
+    }
+    break;
+
+  case XINE_GUI_SEND_SELECT_VISUAL:
+    if (! this->context) {
+      pthread_mutex_lock   (&this->render_action_mutex);
+      this->render_action = RENDER_VISUAL;
+      pthread_cond_signal  (&this->render_action_cond);
+      pthread_cond_wait    (&this->render_return_cond,
+			    &this->render_action_mutex);
+      pthread_mutex_unlock (&this->render_action_mutex);
+      *(XVisualInfo**)data = this->vinfo;
+    }
+    break;
+    /* TODO: this event is yet to be implemented in the gui */
+  case XINE_GUI_SEND_WILL_DESTROY_DRAWABLE:
+    pthread_mutex_lock   (&this->render_action_mutex);
+    this->render_action = RENDER_RELEASE;
+    pthread_cond_signal  (&this->render_action_cond);
+    pthread_cond_wait    (&this->render_return_cond,
+			  &this->render_action_mutex);
+    pthread_mutex_unlock (&this->render_action_mutex);
+    break;
+    
+  case XINE_GUI_SEND_DRAWABLE_CHANGED:
       
-            _x_vo_scale_translate_gui2video(&this->sc, rect->x, rect->y,
-                                     &x1, &y1);
-            _x_vo_scale_translate_gui2video(&this->sc,
-                                     rect->x + rect->w, rect->y + rect->h,
-                                     &x2, &y2);
-            rect->x = x1;
-            rect->y = y1;
-            rect->w = x2-x1;
-            rect->h = y2-y1;
-        }
-	break;
+    this->drawable = (Drawable) data;
+    pthread_mutex_lock   (&this->render_action_mutex);
+    this->render_action = RENDER_CREATE;
+    pthread_cond_signal  (&this->render_action_cond);
+    pthread_cond_wait    (&this->render_return_cond,
+			  &this->render_action_mutex);
+    pthread_mutex_unlock (&this->render_action_mutex);
+    if (! this->context)
+      xprintf (this->xine, XINE_VERBOSITY_NONE,
+	       "video_out_opengl: cannot create OpenGL capable visual.\n"
+	       "   plugin will not work.\n");
+    XLockDisplay (this->display);
+    if(this->xoverlay)
+      x11osd_drawable_changed(this->xoverlay, this->drawable);
+    this->ovl_changed = 1;
+    XUnlockDisplay (this->display);
+    break;
 
-    default:
-	return -1;
+  case XINE_GUI_SEND_TRANSLATE_GUI_TO_VIDEO:
+
+    if (this->frame[0]) {
+      x11_rectangle_t *rect = data;
+      int              x1, y1, x2, y2;
+      
+      _x_vo_scale_translate_gui2video(&this->sc,
+			       rect->x, rect->y,
+			       &x1, &y1);
+      _x_vo_scale_translate_gui2video(&this->sc,
+			       rect->x + rect->w, rect->y + rect->h,
+			       &x2, &y2);
+      rect->x = x1;
+      rect->y = y1;
+      rect->w = x2-x1;
+      rect->h = y2-y1;
     }
+    break;
 
-/*      DEBUGF ((stderr, "done gui_data_exchange\n")); */
-    return 0;
-}
+  default:
+    return -1;
+  }
 
+  return 0;
+}
 
 static void opengl_dispose (vo_driver_t *this_gen) {
-    opengl_driver_t *this = (opengl_driver_t *) this_gen;
-
-//    XLockDisplay (this->display);
-//    if (this->cur_frame)
-//	this->cur_frame->vo_frame.dispose (&this->cur_frame->vo_frame);
-//    XUnlockDisplay (this->display);
-
-    glXMakeCurrent (this->display, None, NULL);
-    glXDestroyContext (this->display, this->context);
-    this->context = NULL;
-
-    free (this);
-}
-
-
-static vo_driver_t *opengl_open_plugin (video_driver_class_t *class_gen,
-                                        const void *visual_gen) {
-    opengl_class_t     *class   = (opengl_class_t *) class_gen;
-    x11_visual_t       *visual  = (x11_visual_t *) visual_gen;
-
-    opengl_driver_t    *this;
-
-    xprintf (class->xine, XINE_VERBOSITY_DEBUG, "EXPERIMENTAL opengl output plugin TNG\n");
-
-    /*
-     * allocate plugin struct
-     */
-    this = calloc (1, sizeof (opengl_driver_t));
-    _x_assert(this);
-
-    this->config		    = class->config;
-    this->xine                      = class->xine;
-    this->display		    = visual->display;
-    this->screen		    = visual->screen;
-
-    _x_vo_scale_init (&this->sc, 0, 0, class->config);
-
-    this->sc.frame_output_cb        = visual->frame_output_cb;
-    this->sc.dest_size_cb           = visual->dest_size_cb;
-    this->sc.user_data              = visual->user_data;
-    this->sc.user_ratio             = XINE_VO_ASPECT_AUTO;
-
-    /* We will not be able to use the current drawable... */
-    this->drawable	            = None;
-    this->context_state             = CONTEXT_BAD;
-
-    this->vo_driver.get_capabilities     = opengl_get_capabilities;
-    this->vo_driver.alloc_frame          = opengl_alloc_frame;
-    this->vo_driver.update_frame_format  = opengl_update_frame_format;
-    this->vo_driver.overlay_begin        = NULL; /* not used */
-    this->vo_driver.overlay_blend        = opengl_overlay_blend;
-    this->vo_driver.overlay_end          = NULL; /* not used */
-    this->vo_driver.display_frame        = opengl_display_frame;
-    this->vo_driver.get_property         = opengl_get_property;
-    this->vo_driver.set_property         = opengl_set_property;
-    this->vo_driver.get_property_min_max = opengl_get_property_min_max;
-    this->vo_driver.gui_data_exchange    = opengl_gui_data_exchange;
-    this->vo_driver.dispose              = opengl_dispose;
-    this->vo_driver.redraw_needed        = opengl_redraw_needed;
-
-    this->yuv2rgb_brightness =
-      this->config->register_range(this->config, "video.opengl_gamma", 0,
-			     -100, 100,
-			     _("brightness correction"),
-			     _("The brightness correction can be used to lighten or darken the image. "
-			       "It changes the blacklevel without modifying the contrast, but it "
-			       "limits the tonal range."),
-			     0, NULL, NULL);
-    this->yuv2rgb_factory = yuv2rgb_factory_init (YUV_FORMAT, YUV_SWAP_MODE, 
-						  this->yuv2rgb_cmap);
-    this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory,
-					   this->yuv2rgb_brightness, 128, 128);
-    return &this->vo_driver;
+  opengl_driver_t *this = (opengl_driver_t *) this_gen;
+  int i;
+
+  pthread_mutex_lock    (&this->render_action_mutex);
+  this->render_action = RENDER_EXIT;
+  pthread_cond_signal   (&this->render_action_cond);
+  pthread_mutex_unlock  (&this->render_action_mutex);
+  pthread_join          (this->render_thread, NULL);  
+  pthread_mutex_destroy (&this->render_action_mutex);
+  pthread_cond_destroy  (&this->render_action_cond);
+  pthread_cond_destroy  (&this->render_return_cond);
+
+  for (i = 0; i < NUM_FRAMES_BACKLOG; i++)
+    if (this->frame[i])
+      this->frame[i]->vo_frame.dispose (&this->frame[i]->vo_frame);
+
+  this->yuv2rgb_factory->dispose (this->yuv2rgb_factory);
+
+  if (this->xoverlay) {
+    XLockDisplay (this->display);
+    x11osd_destroy (this->xoverlay);
+    XUnlockDisplay (this->display);
+  }
+
+  free (this);
+}
+
+static void opengl_cb_render_fun (void *this_gen, xine_cfg_entry_t *entry) {
+  opengl_driver_t *this = (opengl_driver_t *) this_gen;
+  this->render_fun_id = entry->num_value;
+  pthread_mutex_lock (&this->render_action_mutex);
+  if (this->render_action <= RENDER_SETUP) {
+    this->render_action = RENDER_SETUP;
+    pthread_cond_signal  (&this->render_action_cond);
+  }
+  pthread_mutex_unlock (&this->render_action_mutex);
+}
+
+static void opengl_cb_default (void *val_gen, xine_cfg_entry_t *entry) {
+  int *val = (int *) val_gen;
+  *val = entry->num_value;
+}
+
+static vo_driver_t *opengl_open_plugin (video_driver_class_t *class_gen, const void *visual_gen) {
+  opengl_class_t       *class   = (opengl_class_t *) class_gen;
+  config_values_t      *config  = class->config;
+  x11_visual_t         *visual  = (x11_visual_t *) visual_gen;
+  opengl_driver_t      *this;
+  
+  this = (opengl_driver_t *) xine_xmalloc (sizeof (opengl_driver_t));
+
+  if (!this)
+    return NULL;
+
+  this->display		    = visual->display;
+  this->screen		    = visual->screen;
+
+  _x_vo_scale_init (&this->sc, 0, 0, config);
+  this->sc.frame_output_cb  = visual->frame_output_cb;
+  this->sc.dest_size_cb     = visual->dest_size_cb;
+  this->sc.user_data        = visual->user_data;
+  this->sc.user_ratio       = XINE_VO_ASPECT_AUTO;
+  
+  this->drawable	    = visual->d;
+  this->gui_width  = this->gui_height  = -1;
+  this->last_width = this->last_height = -1;
+
+  this->xoverlay                = NULL;
+  this->ovl_changed             = 0;
+  this->xine                  = class->xine;
+  
+  this->vo_driver.get_capabilities     = opengl_get_capabilities;
+  this->vo_driver.alloc_frame          = opengl_alloc_frame;
+  this->vo_driver.update_frame_format  = opengl_update_frame_format;
+  this->vo_driver.overlay_begin        = opengl_overlay_begin;
+  this->vo_driver.overlay_blend        = opengl_overlay_blend;
+  this->vo_driver.overlay_end          = opengl_overlay_end;
+  this->vo_driver.display_frame        = opengl_display_frame;
+  this->vo_driver.get_property         = opengl_get_property;
+  this->vo_driver.set_property         = opengl_set_property;
+  this->vo_driver.get_property_min_max = opengl_get_property_min_max;
+  this->vo_driver.gui_data_exchange    = opengl_gui_data_exchange;
+  this->vo_driver.dispose              = opengl_dispose;
+  this->vo_driver.redraw_needed        = opengl_redraw_needed;
+
+  this->yuv2rgb_brightness = config->register_range (config, "video.opengl_gamma", 0,
+						     -128, 127,
+						     _("brightness correction"),
+						     _("The brightness correction can be used to "
+						       "lighten or darken the image. It changes the "
+						       "blacklevel without modifying the contrast, "
+						       "but it limits the tonal range."),
+						     0, NULL, NULL);
+  this->yuv2rgb_contrast = 128;
+  this->yuv2rgb_saturation = 128;
+  
+  this->yuv2rgb_factory = yuv2rgb_factory_init (YUV_FORMAT, YUV_SWAP_MODE, 
+						NULL);
+  this->yuv2rgb_factory->set_csc_levels (this->yuv2rgb_factory,
+					 this->yuv2rgb_brightness,
+					 this->yuv2rgb_contrast,
+					 this->yuv2rgb_saturation);
+
+  XLockDisplay (this->display);
+  this->xoverlay = x11osd_create (this->xine, this->display, this->screen,
+                                  this->drawable, X11OSD_SHAPED);
+  XUnlockDisplay (this->display);
+
+  this->render_fun_id = config->register_enum (config, "video.opengl_renderer",
+					       0, opengl_render_fun_names,
+					       _("OpenGL renderer"),
+					       _("The OpenGL plugin provides several render modules:\n\n"
+						 "2D_Textures\n"
+						 "This module downloads the images as 2D textures and renders a textured slice.\n"
+						 "This is typically the fastest method.\n\n"
+						 "Image_Pipeline\n"
+						 "This module uses glDraw() to render the images.\n"
+						 "Only accelerated on few drivers.\n"
+						 "Does not interpolate on scaling.\n\n"
+						 "Cylinder\n"
+						 "Shows images on a rotating cylinder. Nice effect :)\n\n"
+						 "Environment_Mapped_Torus\n"
+						 "Show images reflected in a spinning torus. Way cool =)"),
+					       10, opengl_cb_render_fun, this);
+  this->render_min_fps = config->register_range (config,
+						 "video.opengl_min_fps",
+						 20, 1, 120,
+						 _("OpenGL minimum framerate"),
+						 _("Minimum framerate for animated render routines.\n"
+						   "Ignored for static render routines.\n"),
+						 20, opengl_cb_default,
+						 &this->render_min_fps);
+  this->render_double_buffer = config->register_bool (config, "video.opengl_double_buffer", 1,
+						      _("enable double buffering"),
+						      _("For OpenGL double buffering does not only remove tearing artifacts,\n"
+							"it also reduces flickering a lot.\n"
+							" It should not have any performance impact."),
+						      20, NULL, NULL);
+  
+  pthread_mutex_init (&this->render_action_mutex, NULL);
+  pthread_cond_init  (&this->render_action_cond, NULL);
+  pthread_cond_init  (&this->render_return_cond, NULL);
+  pthread_create (&this->render_thread, NULL, (thread_run_t) render_run, this);
+
+  /* Check for OpenGL capable visual */
+  pthread_mutex_lock   (&this->render_action_mutex);
+  this->render_action = RENDER_VISUAL;
+  pthread_cond_signal  (&this->render_action_cond);
+  pthread_cond_wait    (&this->render_return_cond,
+			&this->render_action_mutex);
+  if (this->vinfo) {
+    /* Create context if possible w/o drawable change */
+    this->render_action = RENDER_CREATE;
+    pthread_cond_signal  (&this->render_action_cond);
+    pthread_cond_wait    (&this->render_return_cond,
+			  &this->render_action_mutex);
+  }
+  pthread_mutex_unlock (&this->render_action_mutex);
+
+  if (! this->vinfo) {
+    /* no OpenGL capable visual available */
+    opengl_dispose (&this->vo_driver);
+    return NULL;
+  }
+  if (! this->context)
+    xprintf (this->xine, XINE_VERBOSITY_LOG,
+	     "video_out_opengl: default visual not OpenGL capable\n"
+	     "   plugin will only work with clients supporting XINE_GUI_SEND_SELECT_VISUAL.\n");
+    
+  return &this->vo_driver;
 }
 
 /*
- * Class Functions
+ * class functions
  */
+
 static char* opengl_get_identifier (video_driver_class_t *this_gen) {
-    return "OpenGL";
+  return "opengl";
 }
 
 static char* opengl_get_description (video_driver_class_t *this_gen) {
-    return _("xine video output plugin using OpenGL - TNG");
+  return _("xine video output plugin using the MIT X shared memory extension");
 }
 
-static void opengl_dispose_class (video_driver_class_t *this) {
+static void opengl_dispose_class (video_driver_class_t *this_gen) {
+  opengl_class_t         *this = (opengl_class_t *) this_gen;
 
-    free (this);
+  free (this);
 }
 
 static void *opengl_init_class (xine_t *xine, void *visual_gen) {
+  opengl_class_t	       *this = (opengl_class_t *) xine_xmalloc (sizeof (opengl_class_t));
 
-    opengl_class_t *this = (opengl_class_t *) xine_xmalloc (sizeof (opengl_class_t));
-
-    this->driver_class.open_plugin     = opengl_open_plugin;
-    this->driver_class.get_identifier  = opengl_get_identifier;
-    this->driver_class.get_description = opengl_get_description;
-    this->driver_class.dispose         = opengl_dispose_class;
+  this->driver_class.open_plugin     = opengl_open_plugin;
+  this->driver_class.get_identifier  = opengl_get_identifier;
+  this->driver_class.get_description = opengl_get_description;
+  this->driver_class.dispose         = opengl_dispose_class;
+  this->config                       = xine->config;
+  this->xine                         = xine;
 
-    this->config                       = xine->config;
-    this->xine                         = xine;
-
-    return this;
+  return this;
 }
 
 
 static vo_info_t vo_info_opengl = {
-  3,                    /* priority    */
+  7,                    /* priority    */
   XINE_VISUAL_TYPE_X11  /* visual type */
 };
 
@@ -1014,9 +1447,7 @@ static vo_info_t vo_info_opengl = {
  */
 
 plugin_info_t xine_plugin_info[] = {
-  /* type, API, "name", version, special_info, init_function */
-  { PLUGIN_VIDEO_OUT, 20, "opengl", XINE_VERSION_CODE,
-    &vo_info_opengl, opengl_init_class },
+  /* type, API, "name", version, special_info, init_function */  
+  { PLUGIN_VIDEO_OUT, 20, "opengl", XINE_VERSION_CODE, &vo_info_opengl, opengl_init_class },
   { PLUGIN_NONE, 0, "", 0, NULL, NULL }
 };
-