gstreamer/gst-libs/gst/gl/gstgldisplay.c

/*
 * GStreamer
 * Copyright (C) 2008 Julien Isorce <julien.isorce@gmail.com>
 * Copyright (C) 2008 Filippo Argiolas <filippo.argiolas@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gstgldisplay.h"
#include <gst/gst.h>

GST_BOILERPLATE (GstGLDisplay, gst_gl_display, GObject, G_TYPE_OBJECT);
static void gst_gl_display_finalize (GObject* object);

/* GL thread loop */
static gpointer gst_gl_display_thread_func (GstGLDisplay* display);
static void gst_gl_display_thread_loop (void);
static void gst_gl_display_thread_dispatch_action (GstGLDisplayMsg *msg);
static gboolean gst_gl_display_thread_check_msg_validity (GstGLDisplayMsg *msg);

/* Called in the gl thread, protected by lock and unlock */
static void gst_gl_display_thread_create_context (GstGLDisplay* display);
static void gst_gl_display_thread_destroy_context (GstGLDisplay* display);
static void gst_gl_display_thread_change_context (GstGLDisplay* display);
static void gst_gl_display_thread_set_visible_context (GstGLDisplay* display);
static void gst_gl_display_thread_resize_context (GstGLDisplay* display);
static void gst_gl_display_thread_redisplay (GstGLDisplay* display);
static void gst_gl_display_thread_run_generic (GstGLDisplay *display);
static void gst_gl_display_thread_gen_texture (GstGLDisplay* display);
static void gst_gl_display_thread_del_texture (GstGLDisplay* display);
static void gst_gl_display_thread_init_upload (GstGLDisplay* display);
static void gst_gl_display_thread_do_upload (GstGLDisplay* display);
static void gst_gl_display_thread_init_download (GstGLDisplay *display);
static void gst_gl_display_thread_do_download (GstGLDisplay* display);
static void gst_gl_display_thread_gen_fbo (GstGLDisplay *display);
static void gst_gl_display_thread_use_fbo (GstGLDisplay *display);
static void gst_gl_display_thread_del_fbo (GstGLDisplay *display);
static void gst_gl_display_thread_gen_shader (GstGLDisplay *display);
static void gst_gl_display_thread_del_shader (GstGLDisplay *display);

/* private methods */
void gst_gl_display_lock (GstGLDisplay* display);
void gst_gl_display_unlock (GstGLDisplay* display);
void gst_gl_display_post_message (GstGLDisplayAction action, GstGLDisplay* display);
void gst_gl_display_on_resize(gint width, gint height);
void gst_gl_display_on_draw (void);
void gst_gl_display_on_close (void);
void gst_gl_display_glgen_texture (GstGLDisplay* display, GLuint* pTexture, GLint width, GLint height);
void gst_gl_display_gldel_texture (GstGLDisplay* display, GLuint* pTexture, GLint width, GLint height);
gboolean gst_gl_display_texture_pool_func_clean (gpointer key, gpointer value, gpointer data);
void gst_gl_display_check_framebuffer_status (void);

/* To not make gst_gl_display_thread_do_upload
 * and gst_gl_display_thread_do_download too big */
static void gst_gl_display_thread_do_upload_make (GstGLDisplay *display);
static void gst_gl_display_thread_do_upload_fill (GstGLDisplay *display);
static void gst_gl_display_thread_do_upload_draw (GstGLDisplay *display);
static void gst_gl_display_thread_do_download_draw_rgb (GstGLDisplay *display);
static void gst_gl_display_thread_do_download_draw_yuv (GstGLDisplay *display);

//------------------------------------------------------------
//-------------------- GL context management -----------------
//------------------------------------------------------------

//(key=int glutWinId) and (value=GstGLDisplay *display)
static GHashTable* gst_gl_display_map = NULL;

//all glut functions and opengl primitives are called in this thread
static GThread* gst_gl_display_gl_thread = NULL;

//-timepoped by glutIdleFunc
static GAsyncQueue* gst_gl_display_messageQueue = NULL;


//------------------------------------------------------------
//---------------------- For klass GstGLDisplay ---------------
//------------------------------------------------------------

static void
gst_gl_display_base_init (gpointer g_class)
{
}

static void
gst_gl_display_class_init (GstGLDisplayClass * klass)
{
  G_OBJECT_CLASS (klass)->finalize = gst_gl_display_finalize;
}


static void
gst_gl_display_init (GstGLDisplay *display, GstGLDisplayClass *klass)
{
  //thread safe
  display->mutex = g_mutex_new ();

  //gl context
  display->glutWinId = -1;
  display->winId = 0;
  display->title = g_string_new ("OpenGL renderer ");
  display->win_xpos = 0;
  display->win_ypos = 0;
  display->visible = FALSE;
  display->isAlive = TRUE;
  display->texture_pool = g_hash_table_new (g_str_hash, g_str_equal);

  //conditions
  display->cond_create_context = g_cond_new ();
  display->cond_destroy_context = g_cond_new ();
  display->cond_change_context = g_cond_new ();
  display->cond_generic = g_cond_new ();
  display->cond_gen_texture = g_cond_new ();
  display->cond_del_texture = g_cond_new ();
  display->cond_init_upload = g_cond_new ();
  display->cond_do_upload = g_cond_new ();
  display->cond_init_download = g_cond_new ();
  display->cond_do_download = g_cond_new ();
  display->cond_gen_fbo = g_cond_new ();
  display->cond_use_fbo = g_cond_new ();
  display->cond_del_fbo = g_cond_new ();
  display->cond_gen_shader = g_cond_new ();
  display->cond_del_shader = g_cond_new ();

  //action redisplay
  display->redisplay_texture = 0;
  display->redisplay_texture_width = 0;
  display->redisplay_texture_height = 0;

  //action resize
  display->resize_width = 0;
  display->resize_height = 0;

  //action gen and del texture
  display->gen_texture = 0;
  display->gen_texture_width = 0;
  display->gen_texture_height = 0;
  display->del_texture = 0;
  display->del_texture_width = 0;
  display->del_texture_height = 0;

  //client callbacks
  display->clientReshapeCallback = NULL;
  display->clientDrawCallback = NULL;

  //upload
  display->upload_fbo = 0;
  display->upload_depth_buffer = 0;
  display->upload_outtex = 0;
  display->upload_intex = 0;
  display->upload_intex_u = 0;
  display->upload_intex_v = 0;
  display->upload_width = 0;
  display->upload_height = 0;
  display->upload_video_format = 0;
  display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_MESA;
  display->upload_data_width = 0;
  display->upload_data_height = 0;
  display->upload_data = NULL;

  //filter gen fbo
  display->gen_fbo_width = 0;
  display->gen_fbo_height = 0;
  display->generated_fbo = 0;
  display->generated_depth_buffer = 0;

  //filter use fbo
  display->use_fbo = 0;
  display->use_depth_buffer = 0;
  display->use_fbo_texture = 0;
  display->use_fbo_width = 0;
  display->use_fbo_height = 0;
  display->use_fbo_scene_cb = NULL;
  display->use_fbo_proj_param1 = 0;
  display->use_fbo_proj_param2 = 0;
  display->use_fbo_proj_param3 = 0;
  display->use_fbo_proj_param4 = 0;
  display->use_fbo_projection = 0;
  display->use_fbo_stuff = NULL;
  display->input_texture_width = 0;
  display->input_texture_height = 0;
  display->input_texture = 0;

  //filter del fbo
  display->del_fbo = 0;
  display->del_depth_buffer = 0;

  //download
  display->download_fbo = 0;
  display->download_depth_buffer = 0;
  display->download_texture = 0;
  display->download_texture_u = 0;
  display->download_texture_v = 0;
  display->download_width = 0;
  display->download_height = 0;
  display->download_video_format = 0;
  display->download_data = NULL;
  display->ouput_texture = 0;
  display->ouput_texture_width = 0;
  display->ouput_texture_height = 0;

  //action gen and del shader
  display->gen_shader_fragment_source = NULL;
  display->gen_shader_vertex_source = NULL;
  display->gen_shader = NULL;
  display->del_shader = NULL;

  //fragement shader upload
  display->shader_upload_YUY2 = NULL;
  display->shader_upload_UYVY = NULL;
  display->shader_upload_I420_YV12 = NULL;
  display->shader_upload_AYUV = NULL;

  //fragement shader download
  display->shader_download_YUY2 = NULL;
  display->shader_download_UYVY = NULL;
  display->shader_download_I420_YV12 = NULL;
  display->shader_download_AYUV = NULL;

  //YUY2:r,g,a
  //UYVY:a,b,r
  display->text_shader_upload_YUY2_UYVY =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect Ytex, UVtex;\n"
    "void main(void) {\n"
    "  float fx, fy, y, u, v, r, g, b;\n"
    "  fx   = gl_TexCoord[0].x;\n"
    "  fy   = gl_TexCoord[0].y;\n"
    "  y = texture2DRect(Ytex,vec2(fx,fy)).%c;\n"
    "  u = texture2DRect(UVtex,vec2(fx*0.5,fy)).%c;\n"
    "  v = texture2DRect(UVtex,vec2(fx*0.5,fy)).%c;\n"
    "  y=1.164*(y-0.0627);\n"
    "  u=u-0.5;\n"
    "  v=v-0.5;\n"
    "  r = y+1.5958*v;\n"
    "  g = y-0.39173*u-0.81290*v;\n"
    "  b = y+2.017*u;\n"
    "  gl_FragColor = vec4(r, g, b, 1.0);\n"
    "}\n";

  //ATI: "*0.5", ""
  //normal: "", "*0.5"
  display->text_shader_upload_I420_YV12 =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect Ytex,Utex,Vtex;\n"
    "void main(void) {\n"
    "  float r,g,b,y,u,v;\n"
    "  vec2 nxy=gl_TexCoord[0].xy;\n"
    "  y=texture2DRect(Ytex,nxy%s).r;\n"
    "  u=texture2DRect(Utex,nxy%s).r;\n"
    "  v=texture2DRect(Vtex,nxy*0.5).r;\n"
    "  y=1.1643*(y-0.0625);\n"
    "  u=u-0.5;\n"
    "  v=v-0.5;\n"
    "  r=y+1.5958*v;\n"
    "  g=y-0.39173*u-0.81290*v;\n"
    "  b=y+2.017*u;\n"
    "  gl_FragColor=vec4(r,g,b,1.0);\n"
    "}\n";

  display->text_shader_upload_AYUV =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect tex;\n"
    "void main(void) {\n"
    "  float r,g,b,y,u,v;\n"
    "  vec2 nxy=gl_TexCoord[0].xy;\n"
    "  y=texture2DRect(tex,nxy).r;\n"
    "  u=texture2DRect(tex,nxy).g;\n"
    "  v=texture2DRect(tex,nxy).b;\n"
    "  y=1.1643*(y-0.0625);\n"
    "  u=u-0.5;\n"
    "  v=v-0.5;\n"
    "  r=y+1.5958*v;\n"
    "  g=y-0.39173*u-0.81290*v;\n"
    "  b=y+2.017*u;\n"
    "  gl_FragColor=vec4(r,g,b,1.0);\n"
    "}\n";

  //YUY2:y2,u,y1,v
  //UYVY:v,y1,u,y2
  display->text_shader_download_YUY2_UYVY =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect tex;\n"
    "void main(void) {\n"
    "  float fx,fy,r,g,b,r2,g2,b2,y1,y2,u,v;\n"
    "  fx = gl_TexCoord[0].x;\n"
    "  fy = gl_TexCoord[0].y;\n"
    "  r=texture2DRect(tex,vec2(fx*2.0,fy)).r;\n"
    "  g=texture2DRect(tex,vec2(fx*2.0,fy)).g;\n"
    "  b=texture2DRect(tex,vec2(fx*2.0,fy)).b;\n"
    "  r2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).r;\n"
    "  g2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).g;\n"
    "  b2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).b;\n"
    "  y1=0.299011*r + 0.586987*g + 0.114001*b;\n"
    "  y2=0.299011*r2 + 0.586987*g2 + 0.114001*b2;\n"
    "  u=-0.148246*r -0.29102*g + 0.439266*b;\n"
    "  v=0.439271*r - 0.367833*g - 0.071438*b ;\n"
    "  y1=0.858885*y1 + 0.0625;\n"
    "  y2=0.858885*y2 + 0.0625;\n"
    "  u=u + 0.5;\n"
    "  v=v + 0.5;\n"
    "  gl_FragColor=vec4(%s);\n"
    "}\n";

  display->text_shader_download_I420_YV12 =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect tex;\n"
    "uniform float w, h;\n"
    "void main(void) {\n"
    "  float r,g,b,r2,b2,g2,y,u,v;\n"
    "  vec2 nxy=gl_TexCoord[0].xy;\n"
    "  vec2 nxy2=mod(2.0*nxy, vec2(w, h));\n"
    "  r=texture2DRect(tex,nxy).r;\n"
    "  g=texture2DRect(tex,nxy).g;\n"
    "  b=texture2DRect(tex,nxy).b;\n"
    "  r2=texture2DRect(tex,nxy2).r;\n"
    "  g2=texture2DRect(tex,nxy2).g;\n"
    "  b2=texture2DRect(tex,nxy2).b;\n"
    "  y=0.299011*r + 0.586987*g + 0.114001*b;\n"
    "  u=-0.148246*r2 -0.29102*g2 + 0.439266*b2;\n"
    "  v=0.439271*r2 - 0.367833*g2 - 0.071438*b2 ;\n"
    "  y=0.858885*y + 0.0625;\n"
    "  u=u + 0.5;\n"
    "  v=v + 0.5;\n"
    "  gl_FragData[0] = vec4(y, 0.0, 0.0, 1.0);\n"
    "  gl_FragData[1] = vec4(u, 0.0, 0.0, 1.0);\n"
    "  gl_FragData[2] = vec4(v, 0.0, 0.0, 1.0);\n"
    "}\n";

  display->text_shader_download_AYUV =
    "#extension GL_ARB_texture_rectangle : enable\n"
    "uniform sampler2DRect tex;\n"
    "void main(void) {\n"
    "  float r,g,b,y,u,v;\n"
    "  vec2 nxy=gl_TexCoord[0].xy;\n"
    "  r=texture2DRect(tex,nxy).r;\n"
    "  g=texture2DRect(tex,nxy).g;\n"
    "  b=texture2DRect(tex,nxy).b;\n"
    "  y=0.299011*r + 0.586987*g + 0.114001*b;\n"
    "  u=-0.148246*r -0.29102*g + 0.439266*b;\n"
    "  v=0.439271*r - 0.367833*g - 0.071438*b ;\n"
    "  y=0.858885*y + 0.0625;\n"
    "  u=u + 0.5;\n"
    "  v=v + 0.5;\n"
    "  gl_FragColor=vec4(y,u,v,1.0);\n"
    "}\n";
}

static void
gst_gl_display_finalize (GObject* object)
{
  GstGLDisplay* display = GST_GL_DISPLAY (object);

  //request glut window destruction
  //blocking call because display must be alive
  gst_gl_display_lock (display);
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DESTROY_CONTEXT, display);
  g_cond_wait (display->cond_destroy_context, display->mutex);
  gst_gl_display_unlock (display);

  if (display->texture_pool) {
    //texture pool is empty after destroying the gl context
    g_assert (g_hash_table_size (display->texture_pool) == 0);
    g_hash_table_unref (display->texture_pool);
    display->texture_pool = NULL;
  }
  if (display->title) {
    g_string_free (display->title, TRUE);
    display->title = NULL;
  }
  if (display->mutex) {
    g_mutex_free (display->mutex);
    display->mutex = NULL;
  }
  if (display->cond_del_shader) {
    g_cond_free (display->cond_del_shader);
    display->cond_del_shader = NULL;
  }
  if (display->cond_gen_shader) {
    g_cond_free (display->cond_gen_shader);
    display->cond_gen_shader = NULL;
  }
  if (display->cond_del_fbo) {
    g_cond_free (display->cond_del_fbo);
    display->cond_del_fbo = NULL;
  }
  if (display->cond_use_fbo) {
    g_cond_free (display->cond_use_fbo);
    display->cond_use_fbo = NULL;
  }
  if (display->cond_gen_fbo) {
    g_cond_free (display->cond_gen_fbo);
    display->cond_gen_fbo = NULL;
  }
  if (display->cond_do_download) {
    g_cond_free (display->cond_do_download);
    display->cond_do_download = NULL;
  }
  if (display->cond_init_download) {
    g_cond_free (display->cond_init_download);
    display->cond_init_download = NULL;
  }
  if (display->cond_do_upload) {
    g_cond_free (display->cond_do_upload);
    display->cond_do_upload = NULL;
  }
  if (display->cond_init_upload) {
    g_cond_free (display->cond_init_upload);
    display->cond_init_upload = NULL;
  }
  if (display->cond_del_texture) {
    g_cond_free (display->cond_del_texture);
    display->cond_del_texture = NULL;
  }
  if (display->cond_gen_texture) {
    g_cond_free (display->cond_gen_texture);
    display->cond_gen_texture = NULL;
  }
  if (display->cond_gen_texture) {
    g_cond_free (display->cond_gen_texture);
    display->cond_gen_texture = NULL;
  }
  if (display->cond_change_context) {
    g_cond_free (display->cond_change_context);
    display->cond_change_context = NULL;
  }
  if (display->cond_destroy_context) {
    g_cond_free (display->cond_destroy_context);
    display->cond_destroy_context = NULL;
  }
  if (display->cond_create_context) {
    g_cond_free (display->cond_create_context);
    display->cond_create_context = NULL;
  }
  if (display->clientReshapeCallback)
    display->clientReshapeCallback = NULL;
  if (display->clientDrawCallback)
    display->clientDrawCallback = NULL;
  if (display->use_fbo_scene_cb)
    display->use_fbo_scene_cb = NULL;
  if (display->use_fbo_stuff)
    display->use_fbo_stuff = NULL;

  //at this step, the next condition implies that
  //the last display has been removed
  if (g_hash_table_size (gst_gl_display_map) == 0)
  {
    g_thread_join (gst_gl_display_gl_thread);
    g_print ("gl thread joined\n");
    gst_gl_display_gl_thread = NULL;
    g_async_queue_unref (gst_gl_display_messageQueue);
    g_hash_table_unref (gst_gl_display_map);
    gst_gl_display_map = NULL;
  }
}


//------------------------------------------------------------
//----------------- BEGIN GL THREAD LOOP ---------------------
//------------------------------------------------------------


/* The gl thread handles GstGLDisplayMsg messages
 * Every OpenGL code lines are called in the gl thread */
static gpointer
gst_gl_display_thread_func (GstGLDisplay *display)
{
  static char *argv = "gst-launch-0.10";
  static gint argc = 1;

  //-display  DISPLAY
  //Specify the X server to connect to. If not specified, the value of the DISPLAY environment variable is used.
  //Should be pass through a glimagesink property
  glutInit(&argc, &argv);
  glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
  //glutSetOption(GLUT_RENDERING_CONTEXT, GLUT_USE_CURRENT_CONTEXT);

  glutIdleFunc (gst_gl_display_thread_loop);

  gst_gl_display_lock (display);
  gst_gl_display_thread_create_context (display);
  gst_gl_display_unlock (display);

  g_print ("gl mainLoop started\n");
  glutMainLoop ();
  g_print ("gl mainLoop exited\n");

  return NULL;
}


/* Called in the gl thread */
static void
gst_gl_display_thread_loop (void)
{
  GTimeVal timeout;
  GstGLDisplayMsg *msg;

  //check for pending actions that require a glut context
  g_get_current_time (&timeout);
  g_time_val_add (&timeout, 1000000L); //timeout 1 sec
  msg = g_async_queue_timed_pop (gst_gl_display_messageQueue, &timeout);
  if (msg)
  {
    if (gst_gl_display_thread_check_msg_validity (msg))
      gst_gl_display_thread_dispatch_action (msg);
    while (g_async_queue_length (gst_gl_display_messageQueue))
    {
      msg = g_async_queue_pop (gst_gl_display_messageQueue);
      if (gst_gl_display_thread_check_msg_validity (msg))
	gst_gl_display_thread_dispatch_action (msg);
    }
  }
  else g_print ("timeout reached in idle func\n");
}


/* Called in the gl thread loop */
static void
gst_gl_display_thread_dispatch_action (GstGLDisplayMsg* msg)
{
  gst_gl_display_lock (msg->display);
  switch (msg->action)
  {
  case GST_GL_DISPLAY_ACTION_CREATE_CONTEXT:
    gst_gl_display_thread_create_context (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DESTROY_CONTEXT:
    gst_gl_display_thread_destroy_context (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_CHANGE_CONTEXT:
    gst_gl_display_thread_change_context (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_VISIBLE_CONTEXT:
    gst_gl_display_thread_set_visible_context (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_RESIZE_CONTEXT:
    gst_gl_display_thread_resize_context (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_REDISPLAY_CONTEXT:
    gst_gl_display_thread_redisplay (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_GENERIC:
    gst_gl_display_thread_run_generic (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_GEN_TEXTURE:
    gst_gl_display_thread_gen_texture (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DEL_TEXTURE:
    gst_gl_display_thread_del_texture (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_INIT_UPLOAD:
    gst_gl_display_thread_init_upload (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DO_UPLOAD:
    gst_gl_display_thread_do_upload (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_INIT_DOWNLOAD:
    gst_gl_display_thread_init_download (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DO_DOWNLOAD:
    gst_gl_display_thread_do_download (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_GEN_FBO:
    gst_gl_display_thread_gen_fbo (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_USE_FBO:
    gst_gl_display_thread_use_fbo (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DEL_FBO:
    gst_gl_display_thread_del_fbo (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_GEN_SHADER:
    gst_gl_display_thread_gen_shader (msg->display);
    break;
  case GST_GL_DISPLAY_ACTION_DEL_SHADER:
    gst_gl_display_thread_del_shader (msg->display);
    break;
  default:
    g_assert_not_reached ();
  }
  gst_gl_display_unlock (msg->display);
  g_free (msg);
}


/* Called in the gl thread loop
 * Return false if the message is out of date */
static gboolean
gst_gl_display_thread_check_msg_validity (GstGLDisplayMsg *msg)
{
  gboolean valid = TRUE;

  switch (msg->action)
  {
  case GST_GL_DISPLAY_ACTION_CREATE_CONTEXT:
    //display is not in the map only when we want create one
    valid = TRUE;
    break;
  case GST_GL_DISPLAY_ACTION_DESTROY_CONTEXT:
  case GST_GL_DISPLAY_ACTION_CHANGE_CONTEXT:
  case GST_GL_DISPLAY_ACTION_VISIBLE_CONTEXT:
  case GST_GL_DISPLAY_ACTION_RESIZE_CONTEXT:
  case GST_GL_DISPLAY_ACTION_REDISPLAY_CONTEXT:
  case GST_GL_DISPLAY_ACTION_GENERIC:
  case GST_GL_DISPLAY_ACTION_GEN_TEXTURE:
  case GST_GL_DISPLAY_ACTION_DEL_TEXTURE:
  case GST_GL_DISPLAY_ACTION_INIT_UPLOAD:
  case GST_GL_DISPLAY_ACTION_DO_UPLOAD:
  case GST_GL_DISPLAY_ACTION_INIT_DOWNLOAD:
  case GST_GL_DISPLAY_ACTION_DO_DOWNLOAD:
  case GST_GL_DISPLAY_ACTION_GEN_FBO:
  case GST_GL_DISPLAY_ACTION_USE_FBO:
  case GST_GL_DISPLAY_ACTION_DEL_FBO:
  case GST_GL_DISPLAY_ACTION_GEN_SHADER:
  case GST_GL_DISPLAY_ACTION_DEL_SHADER:
    //msg is out of date if the associated display is not in the map
    if (!g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (msg->glutWinId)))
      valid = FALSE;
    break;
  default:
    g_assert_not_reached ();
  }

  return valid;
}


//------------------------------------------------------------
//------------------ END GL THREAD LOOP ----------------------
//------------------------------------------------------------


//------------------------------------------------------------
//------------------ BEGIN GL THREAD ACTIONS -----------------
//------------------------------------------------------------

//The following functions are thread safe because
//called by the "gst_gl_display_thread_dispatch_action"
//in a lock/unlock scope.

/* Called in the gl thread */
static void
gst_gl_display_thread_create_context (GstGLDisplay *display)
{
  gint glutWinId = 0;
  gchar buffer[5];
  GLenum err = 0;

  //prepare opengl context
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
  glutInitWindowPosition(display->win_xpos, display->win_ypos);
  glutInitWindowSize(display->upload_width, display->upload_height);

  //create opengl context
  sprintf(buffer, "%d", glutWinId);

  display->title =  g_string_append (display->title, buffer);
  glutWinId = glutCreateWindow (display->title->str, display->winId);

  g_print ("Context %d created\n", glutWinId);

  if (display->visible)
    glutShowWindow ();
  else
    glutHideWindow ();

  //Init glew
  err = glewInit();
  if (err != GLEW_OK)
  {
    g_print ("Error: %s\n", glewGetErrorString(err));
    display->isAlive = FALSE;
  }
  else
  {
    //OpenGL > 1.2.0 and Glew > 1.4.0
    GString* opengl_version = g_string_truncate (g_string_new ((gchar*) glGetString (GL_VERSION)), 3);
    gint opengl_version_major = 0;
    gint opengl_version_minor = 0;

    sscanf(opengl_version->str, "%d.%d", &opengl_version_major, &opengl_version_minor);

    g_print ("GL_VERSION: %s\n", glGetString (GL_VERSION));
    g_print ("GLEW_VERSION: %s\n", glewGetString (GLEW_VERSION));
    if (glGetString (GL_SHADING_LANGUAGE_VERSION))
      g_print ("GL_SHADING_LANGUAGE_VERSION: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION));

    g_print ("GL_VENDOR: %s\n", glGetString (GL_VENDOR));
    g_print ("GL_RENDERER: %s\n", glGetString (GL_RENDERER));

    g_string_free (opengl_version, TRUE);

    if ((opengl_version_major  < 1) ||
	(GLEW_VERSION_MAJOR    < 1) ||
	(opengl_version_major < 2 && opengl_version_major >= 1 && opengl_version_minor < 2) ||
	(GLEW_VERSION_MAJOR   < 2 && GLEW_VERSION_MAJOR   >= 1 && GLEW_VERSION_MINOR   < 4) )
    {
      //turn off the pipeline, the old drivers are not yet supported
      g_warning ("Required OpenGL >= 1.2.0 and Glew >= 1.4.0\n");
      display->isAlive = FALSE;
    }
  }

  //setup callbacks
  glutReshapeFunc (gst_gl_display_on_resize);
  glutDisplayFunc (gst_gl_display_on_draw);
  glutCloseFunc (gst_gl_display_on_close);

  //insert glut context to the map
  display->glutWinId = glutWinId;
  g_hash_table_insert (gst_gl_display_map, GUINT_TO_POINTER (glutWinId), display);

  //check glut id validity
  g_assert (glutGetWindow() == glutWinId);
  g_print ("Context %d initialized\n", display->glutWinId);

  //release display constructor
  g_cond_signal (display->cond_create_context);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_destroy_context (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);
  glutReshapeFunc (NULL);
  glutDestroyWindow (display->glutWinId);

  //colorspace_conversion specific
  switch (display->upload_colorspace_conversion)
  {
  case GST_GL_DISPLAY_CONVERSION_MESA:
  case GST_GL_DISPLAY_CONVERSION_MATRIX:
    break;
  case GST_GL_DISPLAY_CONVERSION_GLSL:
  {
    glUseProgramObjectARB (0);
    if (display->shader_upload_YUY2)
    {
      g_object_unref (G_OBJECT (display->shader_upload_YUY2));
      display->shader_upload_YUY2 = NULL;
    }
    if (display->shader_upload_UYVY)
    {
      g_object_unref (G_OBJECT (display->shader_upload_UYVY));
      display->shader_upload_UYVY = NULL;
    }
    if (display->shader_upload_I420_YV12)
    {
      g_object_unref (G_OBJECT (display->shader_upload_I420_YV12));
      display->shader_upload_I420_YV12 = NULL;
    }
    if (display->shader_upload_AYUV)
    {
      g_object_unref (G_OBJECT (display->shader_upload_AYUV));
      display->shader_upload_AYUV = NULL;
    }
    if (display->shader_download_YUY2)
    {
      g_object_unref (G_OBJECT (display->shader_download_YUY2));
      display->shader_download_YUY2 = NULL;
    }
    if (display->shader_download_UYVY)
    {
      g_object_unref (G_OBJECT (display->shader_download_UYVY));
      display->shader_download_UYVY = NULL;
    }
    if (display->shader_download_I420_YV12)
    {
      g_object_unref (G_OBJECT (display->shader_download_I420_YV12));
      display->shader_download_I420_YV12 = NULL;
    }
    if (display->shader_download_AYUV)
    {
      g_object_unref (G_OBJECT (display->shader_download_AYUV));
      display->shader_download_AYUV = NULL;
    }
  }
  break;
  default:
    g_assert_not_reached ();
  }

  if (display->upload_fbo)
  {
    glDeleteFramebuffersEXT (1, &display->upload_fbo);
    display->upload_fbo = 0;
  }
  if (display->upload_depth_buffer)
  {
    glDeleteRenderbuffersEXT(1, &display->upload_depth_buffer);
    display->upload_depth_buffer = 0;
  }
  if (display->download_fbo)
  {
    glDeleteFramebuffersEXT (1, &display->download_fbo);
    display->download_fbo = 0;
  }
  if (display->download_depth_buffer)
  {
    glDeleteRenderbuffersEXT(1, &display->download_depth_buffer);
    display->download_depth_buffer = 0;
  }
  if (display->download_texture)
  {
    glDeleteTextures (1, &display->download_texture);
    display->download_texture = 0;
  }
  if (display->download_texture_u)
  {
    glDeleteTextures (1, &display->download_texture_u);
    display->download_texture_u = 0;
  }
  if (display->download_texture_v)
  {
    glDeleteTextures (1, &display->download_texture_v);
    display->download_texture_v = 0;
  }
  if (display->upload_intex != 0)
  {
    glDeleteTextures (1, &display->upload_intex);
    display->upload_intex = 0;
  }
  if (display->upload_intex_v != 0)
  {
    glDeleteTextures (1, &display->upload_intex_v);
    display->upload_intex = 0;
  }
  if (display->upload_intex_v != 0)
  {
    glDeleteTextures (1, &display->upload_intex_v);
    display->upload_intex = 0;
  }

  //clean up the texture pool
  g_hash_table_foreach_remove (display->texture_pool, gst_gl_display_texture_pool_func_clean,
    NULL);

  g_hash_table_remove (gst_gl_display_map, GINT_TO_POINTER (display->glutWinId));
  g_print ("Context %d destroyed\n", display->glutWinId);

  //if the map is empty, leaveMainloop and join the thread
  if (g_hash_table_size (gst_gl_display_map) == 0)
    glutLeaveMainLoop ();

  //release display destructor
  g_cond_signal (display->cond_destroy_context);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_change_context (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);
  glutChangeWindow (display->winId);
  g_cond_signal (display->cond_change_context);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_set_visible_context (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);
  if (display->visible)
    glutShowWindow ();
  else
    glutHideWindow ();
}


/* Called by the idle function */
static void
gst_gl_display_thread_resize_context (GstGLDisplay* display)
{
  glutSetWindow (display->glutWinId);
  glutReshapeWindow (display->resize_width, display->resize_height);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_redisplay (GstGLDisplay * display)
{
  glutSetWindow (display->glutWinId);
  glutPostRedisplay ();
}

static void
gst_gl_display_thread_run_generic (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);
  display->generic_callback (display, display->data);
  g_cond_signal (display->cond_generic);
}

/* Called in the gl thread */
static void
gst_gl_display_thread_gen_texture (GstGLDisplay * display)
{
  glutSetWindow (display->glutWinId);
  //setup a texture to render to (this one will be in a gl buffer)
  gst_gl_display_glgen_texture (display, &display->gen_texture,
    display->gen_texture_width, display->gen_texture_height);
  g_cond_signal (display->cond_gen_texture);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_del_texture (GstGLDisplay* display)
{
  glutSetWindow (display->glutWinId);
  gst_gl_display_gldel_texture (display, &display->del_texture,
    display->del_texture_width, display->del_texture_height);
  g_cond_signal (display->cond_del_texture);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_init_upload (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);

  switch (display->upload_video_format)
  {
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
    //color space conversion is not needed
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    //color space conversion is needed
  {
	  //check if fragment shader is available, then load them
    /* shouldn't we require ARB_shading_language_100? --Filippo */
    if (GLEW_ARB_fragment_shader)
    {
      g_print ("Context %d, ARB_fragment_shader supported: yes\n", display->glutWinId);

      //Frame buffer object is a requirement for every cases
      if (GLEW_EXT_framebuffer_object)
      {
	      //a texture must be attached to the FBO
	      GLuint fake_texture = 0;

	      g_print ("Context %d, EXT_framebuffer_object supported: yes\n", display->glutWinId);

	      //-- init intput frame buffer object (video -> GL)

	      //setup FBO
	      glGenFramebuffersEXT (1, &display->upload_fbo);
	      glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->upload_fbo);

	      //setup the render buffer for depth
	      glGenRenderbuffersEXT(1, &display->upload_depth_buffer);
	      glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->upload_depth_buffer);
	      glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
				       display->upload_width, display->upload_height);

	      //a fake texture is attached to the upload FBO (cannot init without it)
	      glGenTextures (1, &fake_texture);
	      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, fake_texture);
	      glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
		       display->upload_width, display->upload_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

	      //attach the texture to the FBO to renderer to
	      glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
				        GL_TEXTURE_RECTANGLE_ARB, fake_texture, 0);

	      //attach the depth render buffer to the FBO
	      glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
				       GL_RENDERBUFFER_EXT, display->upload_depth_buffer);

	      gst_gl_display_check_framebuffer_status();

	      g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
		        GL_FRAMEBUFFER_COMPLETE_EXT);

	      //unbind the FBO
	      glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

	      glDeleteTextures (1, &fake_texture);
      }
      else
      {
	      //turn off the pipeline because Frame buffer object is a not present
	      g_print ("Context %d, EXT_framebuffer_object supported: no\n", display->glutWinId);
	      display->isAlive = FALSE;
        break;
      }

      display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_GLSL;

      switch (display->upload_video_format)
      {
      case GST_VIDEO_FORMAT_YUY2:
      {
	gchar text_shader_upload_YUY2[2048];
	sprintf (text_shader_upload_YUY2, display->text_shader_upload_YUY2_UYVY, 'r', 'g', 'a');

	display->shader_upload_YUY2 = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_upload_YUY2,
					     text_shader_upload_YUY2, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_upload_YUY2));
	  display->shader_upload_YUY2 = NULL;
	}
      }
      break;
      case GST_VIDEO_FORMAT_UYVY:
      {
	gchar text_shader_upload_UYVY[2048];
	sprintf (text_shader_upload_UYVY, display->text_shader_upload_YUY2_UYVY, 'a', 'b', 'r');

	display->shader_upload_UYVY = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_upload_UYVY,
					     text_shader_upload_UYVY, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_upload_UYVY));
	  display->shader_upload_UYVY = NULL;
	}
      }
      break;
      case GST_VIDEO_FORMAT_I420:
      case GST_VIDEO_FORMAT_YV12:
      {
    gchar text_shader_upload_I420_YV12[2048];
    if (g_ascii_strncasecmp ("ATI", (gchar *) glGetString (GL_VENDOR), 3) == 0)
        sprintf (text_shader_upload_I420_YV12, display->text_shader_upload_I420_YV12, "*0.5", "");
    else
        sprintf (text_shader_upload_I420_YV12, display->text_shader_upload_I420_YV12, "", "*0.5");

	display->shader_upload_I420_YV12 = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_upload_I420_YV12,
					     text_shader_upload_I420_YV12, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_upload_I420_YV12));
	  display->shader_upload_I420_YV12 = NULL;
	}
      }
	  break;
      case GST_VIDEO_FORMAT_AYUV:
	display->shader_upload_AYUV = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_upload_AYUV,
					     display->text_shader_upload_AYUV, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_upload_AYUV));
	  display->shader_upload_AYUV = NULL;
	}
	break;
      default:
	g_assert_not_reached ();
      }

      //alloc texture (related to upload) memory only on time
      gst_gl_display_thread_do_upload_make (display);
    }
    //check if YCBCR MESA is available
    else if (GLEW_MESA_ycbcr_texture)
    {
      //GLSL and Color Matrix are not available on your drivers, switch to YCBCR MESA
      g_print ("Context %d, ARB_fragment_shader supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_ARB_imaging supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_MESA_ycbcr_texture supported: yes\n", display->glutWinId);

      display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_MESA;

      switch (display->upload_video_format)
      {
      case GST_VIDEO_FORMAT_YUY2:
      case GST_VIDEO_FORMAT_UYVY:
	break;
      case GST_VIDEO_FORMAT_I420:
      case GST_VIDEO_FORMAT_YV12:
      case GST_VIDEO_FORMAT_AYUV:
	//turn off the pipeline because
	//MESA only support YUY2 and UYVY
	display->isAlive = FALSE;
	break;
      default:
	g_assert_not_reached ();
      }
    }
    //check if color matrix is available
    else if (GLEW_ARB_imaging)
    {
      //GLSL is not available on your drivers, switch to Color Matrix
      g_print ("Context %d, ARB_fragment_shader supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_MESA_ycbcr_texture supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_ARB_imaging supported: yes\n", display->glutWinId);

      display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_MATRIX;

      //turn off the pipeline because we do not support it yet
      display->isAlive = FALSE;
    }
    else
    {
      g_print ("Context %d, ARB_fragment_shader supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_ARB_imaging supported: no\n", display->glutWinId);
      g_print ("Context %d, GLEW_MESA_ycbcr_texture supported: no\n", display->glutWinId);

      //turn off the pipeline because colorspace conversion is not possible
      display->isAlive = FALSE;
    }
  }
  break;
  default:
    g_assert_not_reached ();
  }

  g_cond_signal (display->cond_init_upload);
}


/* Called by the idle function */
static void
gst_gl_display_thread_do_upload (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);

  gst_gl_display_thread_do_upload_fill (display);

  switch (display->upload_video_format)
  {
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
    //color space conversion is not needed
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    {
      switch (display->upload_colorspace_conversion)
      {
      case GST_GL_DISPLAY_CONVERSION_GLSL:
        //color space conversion is needed
        gst_gl_display_thread_do_upload_draw (display);
        break;
      case GST_GL_DISPLAY_CONVERSION_MATRIX:
        //color space conversion is needed
        //not yet supported
        break;
      case GST_GL_DISPLAY_CONVERSION_MESA:
        //color space conversion is not needed
        break;
      default:
	      g_assert_not_reached ();
      }
    }
    break;
  default:
	  g_assert_not_reached ();
  }

  g_cond_signal (display->cond_do_upload);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_init_download (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);

  switch (display->download_video_format)
  {
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
    //color space conversion is not needed
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    //color space conversion is needed
  {

    if (GLEW_EXT_framebuffer_object)
    {
      GST_DEBUG ("Context %d, EXT_framebuffer_object supported: yes", display->glutWinId);

      //-- init output frame buffer object (GL -> video)

      //setup FBO
      glGenFramebuffersEXT (1, &display->download_fbo);
      glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->download_fbo);

      //setup the render buffer for depth
      glGenRenderbuffersEXT(1, &display->download_depth_buffer);
      glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->download_depth_buffer);
      glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
			       display->download_width, display->download_height);

      //setup a first texture to render to
      glGenTextures (1, &display->download_texture);
      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->download_texture);
      glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
		   display->download_width, display->download_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

      //attach the first texture to the FBO to renderer to
      glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
			        GL_TEXTURE_RECTANGLE_ARB, display->download_texture, 0);

      switch (display->download_video_format)
      {
      case GST_VIDEO_FORMAT_YUY2:
      case GST_VIDEO_FORMAT_UYVY:
      case GST_VIDEO_FORMAT_AYUV:
        //only one attached texture is needed
        break;

      case GST_VIDEO_FORMAT_I420:
      case GST_VIDEO_FORMAT_YV12:
        //setup a second texture to render to
        glGenTextures (1, &display->download_texture_u);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->download_texture_u);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
		     display->download_width, display->download_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //attach the second texture to the FBO to renderer to
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT,
				  GL_TEXTURE_RECTANGLE_ARB, display->download_texture_u, 0);

        //setup a third texture to render to
        glGenTextures (1, &display->download_texture_v);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->download_texture_v);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
		     display->download_width, display->download_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //attach the third texture to the FBO to renderer to
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT2_EXT,
				  GL_TEXTURE_RECTANGLE_ARB, display->download_texture_v, 0);

        display->multipleRT[0] = GL_COLOR_ATTACHMENT0_EXT;
        display->multipleRT[1] = GL_COLOR_ATTACHMENT1_EXT;
        display->multipleRT[2] = GL_COLOR_ATTACHMENT2_EXT;
        break;
      default:
        g_assert_not_reached ();
      }

      //attach the depth render buffer to the FBO
      glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
				   GL_RENDERBUFFER_EXT, display->download_depth_buffer);

      gst_gl_display_check_framebuffer_status();

      g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
	        GL_FRAMEBUFFER_COMPLETE_EXT);

      //unbind the FBO
      glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
      }
      else
      {
        //turn off the pipeline because Frame buffer object is a requirement
        g_print ("Context %d, EXT_framebuffer_object supported: no\n", display->glutWinId);
        display->isAlive = FALSE;
      }
    }
    break;
  default:
    g_assert_not_reached ();
  }

  switch (display->download_video_format)
  {
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
    //color space conversion is not needed
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    //color space conversion is needed
  {
    //check if fragment shader is available, then load them
    //GLSL is a requirement for donwload
    if (GLEW_ARB_fragment_shader)
    {
      switch (display->download_video_format)
      {
      case GST_VIDEO_FORMAT_YUY2:
      {
	gchar text_shader_download_YUY2[2048];
	sprintf (text_shader_download_YUY2, display->text_shader_download_YUY2_UYVY, "y2,u,y1,v");

	display->shader_download_YUY2 = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_download_YUY2,
					     text_shader_download_YUY2, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_download_YUY2));
	  display->shader_download_YUY2 = NULL;
	}
      }
      break;
      case GST_VIDEO_FORMAT_UYVY:
      {
	gchar text_shader_download_UYVY[2048];
	sprintf (text_shader_download_UYVY, display->text_shader_download_YUY2_UYVY, "v,y1,u,y2");

	display->shader_download_UYVY = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_download_UYVY,
					     text_shader_download_UYVY, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_download_UYVY));
	  display->shader_download_UYVY = NULL;
	}
      }
      break;
      case GST_VIDEO_FORMAT_I420:
      case GST_VIDEO_FORMAT_YV12:
	display->shader_download_I420_YV12 = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_download_I420_YV12,
					     display->text_shader_download_I420_YV12, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_download_I420_YV12));
	  display->shader_download_I420_YV12 = NULL;
	}
	break;
      case GST_VIDEO_FORMAT_AYUV:
	display->shader_download_AYUV = gst_gl_shader_new ();
	if(!gst_gl_shader_compile_and_check (display->shader_download_AYUV,
					     display->text_shader_download_AYUV, GST_GL_SHADER_FRAGMENT_SOURCE))
	{
	  display->isAlive = FALSE;
	  g_object_unref (G_OBJECT (display->shader_download_AYUV));
	  display->shader_download_AYUV = NULL;
	}
	break;
      default:
	g_assert_not_reached ();
      }
    }
    else
    {
      //turn off the pipeline because colorspace conversion is not possible
      GST_DEBUG ("Context %d, ARB_fragment_shader supported: no", display->glutWinId);
      display->isAlive = FALSE;
    }
  }
  break;
  default:
    g_assert_not_reached ();
  }

  g_cond_signal (display->cond_init_download);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_do_download (GstGLDisplay * display)
{
  glutSetWindow (display->glutWinId);

  switch (display->download_video_format)
  {
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
    //color space conversion is not needed
    gst_gl_display_thread_do_download_draw_rgb (display);
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    //color space conversion is needed
    gst_gl_display_thread_do_download_draw_yuv (display);
    break;
  default:
    g_assert_not_reached ();
  }
  g_cond_signal (display->cond_do_download);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_gen_fbo (GstGLDisplay *display)
{
  //a texture must be attached to the FBO
  GLuint fake_texture = 0;

  glutSetWindow (display->glutWinId);

  //-- generate frame buffer object

  //setup FBO
  glGenFramebuffersEXT (1, &display->generated_fbo);
  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->generated_fbo);

  //setup the render buffer for depth
  glGenRenderbuffersEXT(1, &display->generated_depth_buffer);
  glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->generated_depth_buffer);
  glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
			   display->gen_fbo_width, display->gen_fbo_height);

  //setup a texture to render to
  glGenTextures (1, &fake_texture);
  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, fake_texture);
  glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
	       display->gen_fbo_width, display->gen_fbo_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

  //attach the texture to the FBO to renderer to
  glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
			    GL_TEXTURE_RECTANGLE_ARB, fake_texture, 0);

  //attach the depth render buffer to the FBO
  glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
			       GL_RENDERBUFFER_EXT, display->generated_depth_buffer);

  g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
	    GL_FRAMEBUFFER_COMPLETE_EXT);

  //unbind the FBO
  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

  glDeleteTextures (1, &fake_texture);

  g_cond_signal (display->cond_gen_fbo);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_use_fbo (GstGLDisplay *display)
{
  glutSetWindow (display->glutWinId);

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->use_fbo);

  //setup a texture to render to
  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->use_fbo_texture);

  //attach the texture to the FBO to renderer to
  glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
			    GL_TEXTURE_RECTANGLE_ARB, display->use_fbo_texture, 0);

  if (GLEW_ARB_fragment_shader)
    gst_gl_shader_use (NULL);


  glPushAttrib(GL_VIEWPORT_BIT);

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();

  switch (display->use_fbo_projection)
  {
  case GST_GL_DISPLAY_PROJECTION_ORTHO2D:
    gluOrtho2D(display->use_fbo_proj_param1, display->use_fbo_proj_param2,
	       display->use_fbo_proj_param3, display->use_fbo_proj_param4);
    break;
  case GST_GL_DISPLAY_PROJECTION_PERSPECIVE:
    gluPerspective(display->use_fbo_proj_param1, display->use_fbo_proj_param2,
		   display->use_fbo_proj_param3, display->use_fbo_proj_param4);
    break;
  default:
    g_assert_not_reached ();
  }

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  glViewport(0, 0, display->use_fbo_width, display->use_fbo_height);

  glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //the opengl scene
  display->use_fbo_scene_cb (display->input_texture_width, display->input_texture_height,
			     display->input_texture, display->use_fbo_stuff);

  glDrawBuffer(GL_NONE);

  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glPopAttrib();

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

  g_cond_signal (display->cond_use_fbo);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_del_fbo (GstGLDisplay* display)
{
  glutSetWindow (display->glutWinId);

  if (display->del_fbo)
  {
    glDeleteFramebuffersEXT (1, &display->del_fbo);
    display->del_fbo = 0;
  }
  if (display->del_depth_buffer)
  {
    glDeleteRenderbuffersEXT(1, &display->del_depth_buffer);
    display->del_depth_buffer = 0;
  }

  g_cond_signal (display->cond_del_fbo);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_gen_shader (GstGLDisplay* display)
{
  glutSetWindow (display->glutWinId);
  if (GLEW_ARB_fragment_shader)
  {
    gboolean isAlive = TRUE;
    GError *error = NULL;
    
    display->gen_shader = gst_gl_shader_new ();

    if (display->gen_shader_vertex_source)
      gst_gl_shader_set_vertex_source(display->gen_shader, display->gen_shader_vertex_source);

    if (display->gen_shader_fragment_source)
      gst_gl_shader_set_fragment_source(display->gen_shader, display->gen_shader_fragment_source);

    gst_gl_shader_compile (display->gen_shader, &error);
    if (error) 
    {
      g_warning ("%s", error->message);
      g_error_free (error);
      error = NULL;
      gst_gl_shader_use (NULL);
      isAlive = FALSE;
    }

    if (!isAlive)
    {
      display->isAlive = FALSE;
      g_object_unref (G_OBJECT (display->gen_shader));
      display->gen_shader = NULL;
    }
  }
  else
  {
    g_warning ("One of the filter required ARB_fragment_shader\n");
    display->isAlive = FALSE;
    display->gen_shader = NULL;
  }
  g_cond_signal (display->cond_gen_shader);
}


/* Called in the gl thread */
static void
gst_gl_display_thread_del_shader (GstGLDisplay* display)
{
  glutSetWindow (display->glutWinId);
  if (display->del_shader)
  {
    g_object_unref (G_OBJECT (display->del_shader));
    display->del_shader = NULL;
  }
  g_cond_signal (display->cond_del_shader);
}


//------------------------------------------------------------
//------------------ BEGIN GL THREAD ACTIONS -----------------
//------------------------------------------------------------


//------------------------------------------------------------
//---------------------- BEGIN PRIVATE -----------------------
//------------------------------------------------------------


void
gst_gl_display_lock (GstGLDisplay * display)
{
  g_mutex_lock (display->mutex);
}


void
gst_gl_display_unlock (GstGLDisplay * display)
{
  g_mutex_unlock (display->mutex);
}


/* Post a message that will be handled by the gl thread
 * Must be preceded by gst_gl_display_lock
 * and followed by gst_gl_display_unlock
 * Called in the public functions */
void
gst_gl_display_post_message (GstGLDisplayAction action, GstGLDisplay* display)
{
  GstGLDisplayMsg* msg = g_new0 (GstGLDisplayMsg, 1);
  msg->action = action;
  msg->glutWinId = display->glutWinId;
  msg->display = display;
  g_async_queue_push (gst_gl_display_messageQueue, msg);
}


/* glutReshapeFunc callback */
void
gst_gl_display_on_resize (gint width, gint height)
{
  gint glutWinId = 0;
  GstGLDisplay *display = NULL;

  //retrieve the display associated to the glut context
  glutWinId = glutGetWindow ();
  display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));

  //glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
  if (display == NULL) return;

  gst_gl_display_lock (display);

  //check if a client reshape callback is registered
  if (display->clientReshapeCallback)
    display->clientReshapeCallback(width, height);

  //default reshape
  else
  {
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, width, 0, height);
    glMatrixMode(GL_MODELVIEW);
  }

  gst_gl_display_unlock (display);
}

/* glutDisplayFunc callback */
void gst_gl_display_on_draw(void)
{
  gint glutWinId = 0;
  GstGLDisplay *display = NULL;

  //retrieve the display associated to the glut context
  glutWinId = glutGetWindow ();
  display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));

  //glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
  if (display == NULL) return;

  //lock the display because gstreamer elements
  //(and so the main thread) may modify it
  gst_gl_display_lock (display);

  //check if video format has been setup
  if (!display->redisplay_texture)
  {
    gst_gl_display_unlock (display);
    return;
  }

  //opengl scene

  //make sure that the environnement is clean
  if (display->upload_colorspace_conversion == GST_GL_DISPLAY_CONVERSION_GLSL)
    glUseProgramObjectARB (0);
  glDisable (GL_TEXTURE_RECTANGLE_ARB);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);

  //check if a client draw callback is registered
  if (display->clientDrawCallback)
  {
    gboolean doRedisplay =
      display->clientDrawCallback(display->redisplay_texture,
				  display->redisplay_texture_width, display->redisplay_texture_height);

    glFlush();
    glutSwapBuffers();

    if (doRedisplay)
      gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_REDISPLAY_CONTEXT, display);
  }
  //default opengl scene
  else
  {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->redisplay_texture);
    glEnable (GL_TEXTURE_RECTANGLE_ARB);

    glBegin (GL_QUADS);
    glTexCoord2i (display->redisplay_texture_width, 0);
    glVertex2f (1.0f, 1.0f);
    glTexCoord2i (0, 0);
    glVertex2f (-1.0f, 1.0f);
    glTexCoord2i (0, display->redisplay_texture_height);
    glVertex2f (-1.0f, -1.0f);
    glTexCoord2i (display->redisplay_texture_width, display->redisplay_texture_height);
    glVertex2f (1.0f, -1.0f);
    glEnd ();

    glDisable(GL_TEXTURE_RECTANGLE_ARB);

    glFlush();
    glutSwapBuffers();

  }//end default opengl scene

  gst_gl_display_unlock (display);
}


/* glutCloseFunc callback */
void gst_gl_display_on_close (void)
{
  gint glutWinId = 0;
  GstGLDisplay* display = NULL;

  //retrieve the display associated to the glut context
  glutWinId = glutGetWindow ();
  display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));

  //glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
  if (display == NULL) return;

  g_print ("on close\n");

  gst_gl_display_lock (display);
  display->isAlive = FALSE;
  gst_gl_display_unlock (display);
}


/* Generate a texture if no one is available in the pool
 * Called in the gl thread */
void
gst_gl_display_glgen_texture (GstGLDisplay* display, GLuint* pTexture, GLint width, GLint height)
{
  if (display->isAlive)
  {

    gchar string_size[512];
    GQueue* sub_texture_pool = NULL;

    sprintf (string_size, "%dx%d", width, height);
    sub_texture_pool = g_hash_table_lookup (display->texture_pool, string_size);
    //if the size is known
    if (sub_texture_pool)
    {
      //check if there is a texture available in the pool
      GstGLDisplayTex* tex = g_queue_pop_head (sub_texture_pool);
      if (tex)
      {
        *pTexture = tex->texture;
        g_free (tex);
      }
      //otherwise one more texture is generated
      //note that this new texture is added in the pool
      //only after being used
      else
      {
        glGenTextures (1, pTexture);
        glBindTexture (GL_TEXTURE_RECTANGLE_ARB, *pTexture);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
          width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
      }

    }
    //should be factorized
    else
    {
      glGenTextures (1, pTexture);
      glBindTexture (GL_TEXTURE_RECTANGLE_ARB, *pTexture);
      glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
        width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    }

  }
  else
    *pTexture = 0;
}


/* Delete a texture, actually the texture is just added to the pool
 * Called in the gl thread */
void
gst_gl_display_gldel_texture (GstGLDisplay* display, GLuint* pTexture, GLint width, GLint height)
{
  //Each existing texture is destroyed only when the pool is destroyed
  //The pool of textures is deleted in the GstGLDisplay destructor

  gchar string_size[512];
  GQueue* sub_texture_pool = NULL;
  GstGLDisplayTex* tex = NULL;

  sprintf (string_size, "%dx%d", width, height);
  sub_texture_pool = g_hash_table_lookup (display->texture_pool, string_size);
  //if the size is known
  if (!sub_texture_pool)
  {
    sub_texture_pool = g_queue_new ();
    g_hash_table_insert (display->texture_pool, string_size, sub_texture_pool);

    g_print ("texture pool insert: %s\n", string_size);
    g_print ("texture pool size: %d\n", g_hash_table_size (display->texture_pool));
  }

  //contruct a sub texture pool element
  tex = g_new0 (GstGLDisplayTex, 1);
  tex->texture = *pTexture;
  *pTexture = 0;

  //add tex to the pool, it makes texture allocation reusable
  g_queue_push_tail (sub_texture_pool, tex);
}


/* call when a sub texture pool is removed from the texture pool (ghash table) */
gboolean gst_gl_display_texture_pool_func_clean (gpointer key, gpointer value, gpointer data)
{
  GQueue* sub_texture_pool = (GQueue*) value;

  while (g_queue_get_length (sub_texture_pool) > 0)
  {
    GstGLDisplayTex* tex = g_queue_pop_head (sub_texture_pool);
    glDeleteTextures (1, &tex->texture);
    g_free (tex);
  }

  g_queue_free (sub_texture_pool);

  return TRUE;
}


/* called in the gl thread */
void
gst_gl_display_check_framebuffer_status(void)
{
  GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

  switch(status)
  {
  case GL_FRAMEBUFFER_COMPLETE_EXT:
    break;

  case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
    g_print ("GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");
    break;

  default:
    g_print ("General FBO error\n");
  }
}


//------------------------------------------------------------
//---------------------  END PRIVATE -------------------------
//------------------------------------------------------------


//------------------------------------------------------------
//---------------------- BEGIN PUBLIC ------------------------
//------------------------------------------------------------


/* Called by the first gl element of a video/x-raw-gl flow */
GstGLDisplay*
gst_gl_display_new (void)
{
  return g_object_new (GST_TYPE_GL_DISPLAY, NULL);
}


/* Create an opengl context (one context for one GstGLDisplay)
 * Called by the first gl element of a video/x-raw-gl flow */
void
gst_gl_display_create_context (GstGLDisplay *display,
                               GLint x, GLint y,
                               GLint width, GLint height,
                               gulong winId,
                               gboolean visible)
{
  gst_gl_display_lock (display);

  display->winId = winId;
  display->win_xpos = x;
  display->win_ypos = y;
  display->upload_width = width;
  display->upload_height = height;
  display->visible = visible;

  //if no glut_thread exists, create it with a window associated to the display
  if (!gst_gl_display_map)
  {
    gst_gl_display_messageQueue = g_async_queue_new ();
    gst_gl_display_map = g_hash_table_new (g_direct_hash, g_direct_equal);
    gst_gl_display_gl_thread = g_thread_create (
      (GThreadFunc) gst_gl_display_thread_func, display, TRUE, NULL);
    g_cond_wait (display->cond_create_context, display->mutex);
  }
  //request glut window creation
  else
  {
    //blocking call because glut context must be alive
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_CREATE_CONTEXT, display);
    g_cond_wait (display->cond_create_context, display->mutex);
  }
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink element */
void
gst_gl_display_set_visible_context (GstGLDisplay* display, gboolean visible)
{
  gst_gl_display_lock (display);
  if (display->visible != visible)
  {
    display->visible = visible;
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_VISIBLE_CONTEXT, display);
  }
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink element */
void
gst_gl_display_resize_context (GstGLDisplay* display, gint width, gint height)
{
  gst_gl_display_lock (display);
  display->resize_width = width;
  display->resize_height = height;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_RESIZE_CONTEXT, display);
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink element */
gboolean
gst_gl_display_redisplay (GstGLDisplay* display, GLuint texture, gint width , gint height)
{
  gboolean isAlive = TRUE;

  gst_gl_display_lock (display);
  isAlive = display->isAlive;
  if (isAlive)
  {
    if (texture)
    {
      display->redisplay_texture = texture;
      display->redisplay_texture_width = width;
      display->redisplay_texture_height = height;
    }
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_REDISPLAY_CONTEXT, display);
  }
  gst_gl_display_unlock (display);

  return isAlive;
}

void
gst_gl_display_thread_add (GstGLDisplay *display,
			   GstGLDisplayThreadFunc func, gpointer data)
{
  gst_gl_display_lock (display);
  display->data = data;
  display->generic_callback = func;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_GENERIC, display);
  g_cond_wait (display->cond_generic, display->mutex);
  gst_gl_display_unlock (display);
}

/* Called by gst_gl_buffer_new */
void
gst_gl_display_gen_texture (GstGLDisplay* display, GLuint* pTexture, GLint width, GLint height)
{
  gst_gl_display_lock (display);
  display->gen_texture_width = width;
  display->gen_texture_height = height;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_GEN_TEXTURE, display);
  g_cond_wait (display->cond_gen_texture, display->mutex);
  *pTexture = display->gen_texture;
  gst_gl_display_unlock (display);
}


/* Called by gst_gl_buffer_finalize */
void
gst_gl_display_del_texture (GstGLDisplay* display, GLuint texture, GLint width, GLint height)
{
  gst_gl_display_lock (display);
  display->del_texture = texture;
  display->del_texture_width = width;
  display->del_texture_height = height;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DEL_TEXTURE, display);
  g_cond_wait (display->cond_del_texture, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by the first gl element of a video/x-raw-gl flow */
void
gst_gl_display_init_upload (GstGLDisplay* display, GstVideoFormat video_format,
                            guint gl_width, guint gl_height,
                            gint video_width, gint video_height)
{
  gst_gl_display_lock (display);
  display->upload_video_format = video_format;
  display->upload_width = gl_width;
  display->upload_height = gl_height;
  display->upload_data_width = video_width;
  display->upload_data_height = video_height;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_INIT_UPLOAD, display);
  g_cond_wait (display->cond_init_upload, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by the first gl element of a video/x-raw-gl flow */
gboolean
gst_gl_display_do_upload (GstGLDisplay *display, GLuint texture,
                          gint data_width, gint data_height,
                          gpointer data)
{
  gboolean isAlive = TRUE;

  gst_gl_display_lock (display);
  isAlive = display->isAlive;
  if (isAlive)
  {
    display->upload_outtex = texture;
    display->upload_data_width = data_width;
    display->upload_data_height = data_height;
    display->upload_data = data;
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DO_UPLOAD, display);
    g_cond_wait (display->cond_do_upload, display->mutex);
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by the gldownload and glcolorscale element */
void
gst_gl_display_init_download (GstGLDisplay* display, GstVideoFormat video_format,
                              gint width, gint height)
{
  gst_gl_display_lock (display);
  display->download_video_format = video_format;
  display->download_width = width;
  display->download_height = height;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_INIT_DOWNLOAD, display);
  g_cond_wait (display->cond_init_download, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by the gldownload and glcolorscale element */
gboolean
gst_gl_display_do_download (GstGLDisplay* display, GLuint texture,
                            gint width, gint height,
                            gpointer data)
{
  gboolean isAlive = TRUE;

  gst_gl_display_lock (display);
  isAlive = display->isAlive;
  if (isAlive)
  {
    //data size is aocciated to the glcontext size
    display->download_data = data;
    display->ouput_texture = texture;
    display->ouput_texture_width = width;
    display->ouput_texture_height = height;
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DO_DOWNLOAD, display);
    g_cond_wait (display->cond_do_download, display->mutex);
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by gltestsrc and glfilter */
void
gst_gl_display_gen_fbo (GstGLDisplay* display, gint width, gint height,
                        GLuint* fbo, GLuint* depthbuffer)
{
  gst_gl_display_lock (display);
  if (display->isAlive)
  {
    display->gen_fbo_width = width;
    display->gen_fbo_height = height;
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_GEN_FBO, display);
    g_cond_wait (display->cond_gen_fbo, display->mutex);
    *fbo = display->generated_fbo;
    *depthbuffer = display->generated_depth_buffer;
  }
  gst_gl_display_unlock (display);
}


/* Called by glfilter */
/* this function really has to be simplified...  do we really need to
   set projection this way? Wouldn't be better a set_projection
   separate call? or just make glut functions available out of
   gst-libs and call it if needed on drawcallback? -- Filippo */
/* GLCB too.. I think that only needed parameters should be
 * GstGLDisplay *display and gpointer data, or just gpointer data */
/* ..everything here has to be simplified! */
gboolean
gst_gl_display_use_fbo (GstGLDisplay* display, gint texture_fbo_width, gint texture_fbo_height,
                        GLuint fbo, GLuint depth_buffer, GLuint texture_fbo, GLCB cb,
                        gint input_texture_width, gint input_texture_height, GLuint input_texture,
                        gdouble proj_param1, gdouble proj_param2,
                        gdouble proj_param3, gdouble proj_param4,
                        GstGLDisplayProjection projection, gpointer* stuff)
{
  gboolean isAlive = TRUE;

  gst_gl_display_lock (display);
  isAlive = display->isAlive;
  if (isAlive)
  {
    display->use_fbo = fbo;
    display->use_depth_buffer = depth_buffer;
    display->use_fbo_texture = texture_fbo;
    display->use_fbo_width = texture_fbo_width;
    display->use_fbo_height = texture_fbo_height;
    display->use_fbo_scene_cb = cb;
    display->use_fbo_proj_param1 = proj_param1;
    display->use_fbo_proj_param2 = proj_param2;
    display->use_fbo_proj_param3 = proj_param3;
    display->use_fbo_proj_param4 = proj_param4;
    display->use_fbo_projection = projection;
    display->use_fbo_stuff = stuff;
    display->input_texture_width = input_texture_width;
    display->input_texture_height = input_texture_height;
    display->input_texture = input_texture;
    gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_USE_FBO, display);
    g_cond_wait (display->cond_use_fbo, display->mutex);
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by gltestsrc and glfilter */
void
gst_gl_display_del_fbo (GstGLDisplay* display, GLuint fbo,
                        GLuint depth_buffer)
{
  gst_gl_display_lock (display);
  display->del_fbo = fbo;
  display->del_depth_buffer = depth_buffer;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DEL_FBO, display);
  g_cond_wait (display->cond_del_fbo, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by glfilter */
void
gst_gl_display_gen_shader (GstGLDisplay* display, 
                           const gchar* shader_vertex_source,
                           const gchar* shader_fragment_source,
                           GstGLShader** shader)
{
  gst_gl_display_lock (display);
  display->gen_shader_vertex_source = shader_vertex_source;
  display->gen_shader_fragment_source = shader_fragment_source;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_GEN_SHADER, display);
  g_cond_wait (display->cond_gen_shader, display->mutex);
  *shader = display->gen_shader;
  display->gen_shader = NULL;
  display->gen_shader_vertex_source = NULL;
  display->gen_shader_fragment_source = NULL;
  gst_gl_display_unlock (display);
}


/* Called by glfilter */
void
gst_gl_display_del_shader (GstGLDisplay* display, GstGLShader* shader)
{
  gst_gl_display_lock (display);
  display->del_shader = shader;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_DEL_SHADER, display);
  g_cond_wait (display->cond_del_shader, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink */
void
gst_gl_display_set_window_id (GstGLDisplay* display, gulong winId)
{
  //used only when glimagesink is connected to a gl flow
  //otehrwise it can directly create the gl context using the winId
  gst_gl_display_lock (display);
  display->winId = winId;
  gst_gl_display_post_message (GST_GL_DISPLAY_ACTION_CHANGE_CONTEXT, display);
  g_cond_wait (display->cond_change_context, display->mutex);
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink */
void
gst_gl_display_set_client_reshape_callback (GstGLDisplay * display, CRCB cb)
{
  gst_gl_display_lock (display);
  display->clientReshapeCallback = cb;
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink */
void
gst_gl_display_set_client_draw_callback (GstGLDisplay * display, CDCB cb)
{
  gst_gl_display_lock (display);
  display->clientDrawCallback = cb;
  gst_gl_display_unlock (display);
}


//------------------------------------------------------------
//------------------------ END PUBLIC ------------------------
//------------------------------------------------------------


/* called by gst_gl_display_thread_do_upload (in the gl thread) */
void gst_gl_display_thread_do_upload_make (GstGLDisplay *display)
{
  gint width = display->upload_data_width;
  gint height = display->upload_data_height;

  glGenTextures (1, &display->upload_intex);

  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
  switch (display->upload_video_format)
  {
  case GST_VIDEO_FORMAT_AYUV:
		glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
	    width, height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, NULL);
    break;
  case GST_VIDEO_FORMAT_YUY2:
  glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE_ALPHA,
        width, height,
        0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
  glGenTextures (1, &display->upload_intex_u);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
  glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
    width, height,
    0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
    break;
  case GST_VIDEO_FORMAT_UYVY:
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE_ALPHA,
        width, height,
        0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
  glGenTextures (1, &display->upload_intex_u);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
  glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
    width, height,
    0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
    break;

  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
    glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
      width, height,
      0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);

glGenTextures (1, &display->upload_intex_u);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
        GST_ROUND_UP_2 (width) / 2,
        GST_ROUND_UP_2 (height) / 2,
        0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);

glGenTextures (1, &display->upload_intex_v);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_v);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
        GST_ROUND_UP_2 (width) / 2,
        GST_ROUND_UP_2 (height) / 2,
        0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
    break;

  default:
    g_assert_not_reached ();
  }
}


/* called by gst_gl_display_thread_do_upload (in the gl thread) */
void
gst_gl_display_thread_do_upload_fill (GstGLDisplay *display)
{
  gint width = display->upload_data_width;
  gint height = display->upload_data_height;
  gpointer data = display->upload_data;

  switch (display->upload_video_format)
  {
  case GST_VIDEO_FORMAT_RGB:
  case GST_VIDEO_FORMAT_BGR:
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_ARGB:
  case GST_VIDEO_FORMAT_ABGR:
    //color space conversion is not needed
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_outtex);
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  case GST_VIDEO_FORMAT_AYUV:
    //color space conversion is needed
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
    break;
  default:
	  g_assert_not_reached ();
  }

  switch (display->upload_video_format) {
  case GST_VIDEO_FORMAT_RGB:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_RGB, GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_BGR:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_BGR, GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_RGBx:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_RGBA, GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_BGRx:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_BGRA, GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_AYUV:
  case GST_VIDEO_FORMAT_xRGB:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, data);
    break;
  case GST_VIDEO_FORMAT_xBGR:
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, data);
    break;
  case GST_VIDEO_FORMAT_YUY2:
    switch (display->upload_colorspace_conversion)
    {
    case GST_GL_DISPLAY_CONVERSION_GLSL:
    case GST_GL_DISPLAY_CONVERSION_MATRIX:
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		       GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);

      glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
		       GST_ROUND_UP_2 (width) / 2, height,
		       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
      break;
    case GST_GL_DISPLAY_CONVERSION_MESA:
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		       GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_REV_MESA, data);
      break;
    default:
      g_assert_not_reached ();
    }
    break;
  case GST_VIDEO_FORMAT_UYVY:
    switch (display->upload_colorspace_conversion)
    {
    case GST_GL_DISPLAY_CONVERSION_GLSL:
    case GST_GL_DISPLAY_CONVERSION_MATRIX:
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		       GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);

      glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
		       GST_ROUND_UP_2 (width) / 2, height,
		       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
      break;
    case GST_GL_DISPLAY_CONVERSION_MESA:
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		       GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, data);
      break;
    default:
      g_assert_not_reached ();
    }
    break;
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  {
    gint offsetU = 0;
    gint offsetV = 0;

    switch (display->upload_video_format)
    {
    case GST_VIDEO_FORMAT_I420:
      offsetU = 1;
      offsetV = 2;
      break;
    case GST_VIDEO_FORMAT_YV12:
      //WIN32
#if defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__)
      offsetU = 2;
      offsetV = 1;
      //LINUX
#else
      if (g_ascii_strncasecmp ("ATI", (gchar *) glGetString (GL_VENDOR), 3) == 0)
      {
        offsetU = 2;
        offsetV = 1;
      }
      else
      {
        offsetU = 1;
        offsetV = 2;
      }
#endif
      break;
    default:
      g_assert_not_reached ();
    }

    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
		     GL_LUMINANCE, GL_UNSIGNED_BYTE, data);

    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
		     GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
		     GL_LUMINANCE, GL_UNSIGNED_BYTE,
		     (guint8 *) data +
		     gst_video_format_get_component_offset (display->upload_video_format, offsetU, width, height));

    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_v);
    glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
		     GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
		     GL_LUMINANCE, GL_UNSIGNED_BYTE,
		     (guint8 *) data +
		     gst_video_format_get_component_offset (display->upload_video_format, offsetV, width, height));
  }
  break;
  default:
    g_assert_not_reached ();
  }
}


/* called by gst_gl_display_thread_do_upload (in the gl thread) */
void
gst_gl_display_thread_do_upload_draw (GstGLDisplay *display)
{
  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->upload_fbo);

  //attach the texture to the FBO to renderer to
  glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
			    GL_TEXTURE_RECTANGLE_ARB, display->upload_outtex, 0);

  if (GLEW_ARB_fragment_shader)
    gst_gl_shader_use (NULL);

  glPushAttrib(GL_VIEWPORT_BIT);

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D(0.0, display->upload_width, 0.0, display->upload_height);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  glViewport(0, 0, display->upload_width, display->upload_height);

  glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  switch (display->upload_video_format)
  {
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  {
    GstGLShader* shader_upload_YUY2_UYVY = NULL;

    switch (display->upload_video_format)
    {
    case GST_VIDEO_FORMAT_YUY2:
      shader_upload_YUY2_UYVY = display->shader_upload_YUY2;
      break;
    case GST_VIDEO_FORMAT_UYVY:
      shader_upload_YUY2_UYVY = display->shader_upload_UYVY;
      break;
    default:
      g_assert_not_reached ();
    }

    gst_gl_shader_use (shader_upload_YUY2_UYVY);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE1_ARB);
    gst_gl_shader_set_uniform_1i (shader_upload_YUY2_UYVY, "UVtex", 1);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (shader_upload_YUY2_UYVY, "Ytex", 0);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  }
  break;

  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  {
    gst_gl_shader_use (display->shader_upload_I420_YV12);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE1_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_upload_I420_YV12, "Utex", 1);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_u);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glActiveTextureARB(GL_TEXTURE2_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_upload_I420_YV12, "Vtex", 2);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex_v);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_upload_I420_YV12, "Ytex", 0);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  }
  break;

  case GST_VIDEO_FORMAT_AYUV:
  {
    gst_gl_shader_use (display->shader_upload_AYUV);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_upload_AYUV, "tex", 0);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  }
  break;

  default:
    g_assert_not_reached ();

  }//end switch display->currentVideo_format

  glBegin (GL_QUADS);
  glTexCoord2i (display->upload_data_width, 0);
  glVertex2f (1.0f, -1.0f);
  glTexCoord2i (0, 0);
  glVertex2f (-1.0f, -1.0f);
  glTexCoord2i (0, display->upload_data_height);
  glVertex2f (-1.0f, 1.0f);
  glTexCoord2i (display->upload_data_width, display->upload_data_height);
  glVertex2f (1.0f, 1.0f);
  glEnd ();

  glDrawBuffer(GL_NONE);

  //we are done with the shader
  if (display->upload_colorspace_conversion == GST_GL_DISPLAY_CONVERSION_GLSL)
    glUseProgramObjectARB (0);

  glDisable(GL_TEXTURE_RECTANGLE_ARB);

  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glPopAttrib();

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

  gst_gl_display_check_framebuffer_status();
}


/* called by gst_gl_display_thread_do_download (in the gl thread) */
void
gst_gl_display_thread_do_download_draw_rgb (GstGLDisplay *display)
{
  GstVideoFormat video_format = display->download_video_format;
  gpointer data = display->download_data;

  glEnable (GL_TEXTURE_RECTANGLE_ARB);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);

  switch (video_format)
  {
  case GST_VIDEO_FORMAT_RGBA:
  case GST_VIDEO_FORMAT_RGBx:
  case GST_VIDEO_FORMAT_xRGB:
  case GST_VIDEO_FORMAT_ARGB:
    glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
		  GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_BGRx:
  case GST_VIDEO_FORMAT_BGRA:
  case GST_VIDEO_FORMAT_xBGR:
  case GST_VIDEO_FORMAT_ABGR:
    glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGRA,
		  GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_RGB:
    glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB,
		  GL_UNSIGNED_BYTE, data);
    break;
  case GST_VIDEO_FORMAT_BGR:
    glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGR,
		  GL_UNSIGNED_BYTE, data);
    break;
  default:
      g_assert_not_reached ();
    }
}


/* called by gst_gl_display_thread_do_download (in the gl thread) */
void
gst_gl_display_thread_do_download_draw_yuv (GstGLDisplay *display)
{
  gint width = display->download_width;
  gint height = display->download_height;
  GstVideoFormat video_format = display->download_video_format;
  gpointer data = display->download_data;

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->download_fbo);

  glPushAttrib(GL_VIEWPORT_BIT);

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D(0.0, width, 0.0, height);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  glViewport(0, 0, width, height);

  switch (video_format)
  {
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
  {
    GstGLShader* shader_download_YUY2_UYVY = NULL;

    switch (video_format)
    {
    case GST_VIDEO_FORMAT_YUY2:
      shader_download_YUY2_UYVY = display->shader_download_YUY2;
      break;
    case GST_VIDEO_FORMAT_UYVY:
      shader_download_YUY2_UYVY = display->shader_download_UYVY;
      break;
    default:
      g_assert_not_reached ();
    }

    glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    gst_gl_shader_use (shader_download_YUY2_UYVY);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (shader_download_YUY2_UYVY, "tex", 0);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);
  }
  break;

  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  {
    glDrawBuffers(3, display->multipleRT);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    gst_gl_shader_use (display->shader_download_I420_YV12);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_download_I420_YV12, "tex", 0);
    gst_gl_shader_set_uniform_1f (display->shader_download_I420_YV12, "w",
				  (gfloat)display->ouput_texture_width);
    gst_gl_shader_set_uniform_1f (display->shader_download_I420_YV12, "h",
				  (gfloat)display->ouput_texture_height);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);
  }
  break;

  case GST_VIDEO_FORMAT_AYUV:
  {
    glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    gst_gl_shader_use (display->shader_download_AYUV);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();

    glActiveTextureARB(GL_TEXTURE0_ARB);
    gst_gl_shader_set_uniform_1i (display->shader_download_AYUV, "tex", 0);
    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);
  }
  break;

  default:
    g_assert_not_reached ();

  }//end switch display->currentVideo_format

  glBegin (GL_QUADS);
  glTexCoord2i (0, 0);
  glVertex2f (-1.0f, -1.0f);
  glTexCoord2i (width, 0);
  glVertex2f (1.0f, -1.0f);
  glTexCoord2i (width, height);
  glVertex2f (1.0f, 1.0f);
  glTexCoord2i (0, height);
  glVertex2f (-1.0f, 1.0f);
  glEnd ();

  glDrawBuffer(GL_NONE);

  //dot not check if GLSL is available
  //because for now download is not available
  //without GLSL
  glUseProgramObjectARB (0);

  glDisable(GL_TEXTURE_RECTANGLE_ARB);

  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  glPopAttrib();

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);

  gst_gl_display_check_framebuffer_status();

  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->download_fbo);
  glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);

  switch (video_format)
  {
  case GST_VIDEO_FORMAT_AYUV:
  case GST_VIDEO_FORMAT_xRGB:
    glReadPixels (0, 0, width, height, GL_BGRA,
		  GL_UNSIGNED_INT_8_8_8_8, data);
    break;
  case GST_VIDEO_FORMAT_YUY2:
  case GST_VIDEO_FORMAT_UYVY:
    glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, height, GL_BGRA,
		  GL_UNSIGNED_INT_8_8_8_8_REV, data);
    break;
  case GST_VIDEO_FORMAT_I420:
  case GST_VIDEO_FORMAT_YV12:
  {
    gint offsetU = 0;
    gint offsetV = 0;

    switch (video_format)
    {
    case GST_VIDEO_FORMAT_I420:
      offsetU = 1;
      offsetV = 2;
      break;
    case GST_VIDEO_FORMAT_YV12:
      //WIN32
#if defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__)
      offsetU = 2;
      offsetV = 1;
      //LINUX
#else
      if (g_ascii_strncasecmp ("ATI", (gchar *) glGetString (GL_VENDOR), 3) == 0)
      {
        offsetU = 2;
        offsetV = 1;
      }
      else
      {
        offsetU = 1;
        offsetV = 2;
      }
#endif
      break;
    default:
      g_assert_not_reached ();
    }

    glReadPixels (0, 0, width, height, GL_LUMINANCE,
		  GL_UNSIGNED_BYTE, data);

    glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
    glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
		  GL_LUMINANCE, GL_UNSIGNED_BYTE,
		  (guint8 *) data +
		  gst_video_format_get_component_offset (video_format, offsetU, width, height));

    glReadBuffer(GL_COLOR_ATTACHMENT2_EXT);
    glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
		  GL_LUMINANCE, GL_UNSIGNED_BYTE,
		  (guint8 *) data +
		  gst_video_format_get_component_offset (video_format, offsetV, width, height));
  }
  break;
  default:
    g_assert_not_reached ();
  }

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
  gst_gl_display_check_framebuffer_status();
}