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

/*
 * GStreamer
 * Copyright (C) 2007 David A. Schleef <ds@schleef.org>
 * 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 <stdio.h>

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

#ifndef GLEW_VERSION_MAJOR
#define GLEW_VERSION_MAJOR 4
#endif

#ifndef GLEW_VERSION_MINOR
#define GLEW_VERSION_MINOR 0
#endif

/*
 * gst-launch-0.10 --gst-debug=gldisplay:N pipeline
 * N=1: errors
 * N=2: errors warnings
 * N=3: errors warnings infos
 * N=4: errors warnings infos
 * N=5: errors warnings infos logs
 */

GST_DEBUG_CATEGORY_STATIC (gst_gl_display_debug);
#define GST_CAT_DEFAULT gst_gl_display_debug

#define DEBUG_INIT(bla) \
  GST_DEBUG_CATEGORY_INIT (gst_gl_display_debug, "gldisplay", 0, "opengl display");

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

/* Called in the gl thread, protected by lock and unlock */
gpointer gst_gl_display_thread_create_context (GstGLDisplay * display);
void gst_gl_display_thread_destroy_context (GstGLDisplay * display);
void gst_gl_display_thread_run_generic (GstGLDisplay * display);
void gst_gl_display_thread_gen_texture (GstGLDisplay * display);
#ifdef OPENGL_ES2
void gst_gl_display_thread_init_redisplay (GstGLDisplay * display);
#endif
void gst_gl_display_thread_init_upload (GstGLDisplay * display);
void gst_gl_display_thread_do_upload (GstGLDisplay * display);
void gst_gl_display_thread_init_download (GstGLDisplay * display);
void gst_gl_display_thread_do_download (GstGLDisplay * display);
void gst_gl_display_thread_gen_fbo (GstGLDisplay * display);
void gst_gl_display_thread_use_fbo (GstGLDisplay * display);
void gst_gl_display_thread_use_fbo_v2 (GstGLDisplay * display);
void gst_gl_display_thread_del_fbo (GstGLDisplay * display);
void gst_gl_display_thread_gen_shader (GstGLDisplay * display);
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_on_resize (GstGLDisplay * display, gint width, gint height);
void gst_gl_display_on_draw (GstGLDisplay * display);
void gst_gl_display_on_close (GstGLDisplay * display);
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 */
void gst_gl_display_thread_init_upload_fbo (GstGLDisplay * display);
void gst_gl_display_thread_do_upload_make (GstGLDisplay * display);
void gst_gl_display_thread_do_upload_fill (GstGLDisplay * display);
void gst_gl_display_thread_do_upload_draw (GstGLDisplay * display);
void gst_gl_display_thread_do_download_draw_rgb (GstGLDisplay * display);
void gst_gl_display_thread_do_download_draw_yuv (GstGLDisplay * display);


//------------------------------------------------------------
//---------------------- 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;

  gst_gl_window_init_platform ();
}


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

  //gl context
  display->gl_thread = NULL;
  display->gl_window = NULL;
  display->isAlive = TRUE;
  display->texture_pool = g_hash_table_new (g_direct_hash, g_direct_equal);

  //conditions
  display->cond_create_context = g_cond_new ();
  display->cond_destroy_context = g_cond_new ();

  //action redisplay
  display->redisplay_texture = 0;
  display->redisplay_texture_width = 0;
  display->redisplay_texture_height = 0;
  display->keep_aspect_ratio = FALSE;
#ifdef OPENGL_ES2
  display->redisplay_shader = NULL;
  display->redisplay_attr_position_loc = 0;
  display->redisplay_attr_texture_loc = 0;
#endif

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

  //client callbacks
  display->clientReshapeCallback = NULL;
  display->clientDrawCallback = NULL;
  display->client_data = 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 = GST_VIDEO_FORMAT_RGBx;
  display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_MESA;
  display->upload_data_width = 0;
  display->upload_data_height = 0;
  display->upload_data = NULL;

  //foreign gl context
  display->external_gl_context = 0;

  //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_scene_cb_v2 = 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;

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

#ifdef OPENGL_ES2
  display->shader_upload_attr_position_loc = 0;
  display->shader_upload_attr_texture_loc = 0;
#endif

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

#ifdef OPENGL_ES2
  display->shader_download_attr_position_loc = 0;
  display->shader_download_attr_texture_loc = 0;
  display->shader_download_RGB = NULL;
#endif

  //YUY2:r,g,a
  //UYVY:a,b,r
  display->text_shader_upload_YUY2_UYVY =
#ifndef OPENGL_ES2
      "#extension GL_ARB_texture_rectangle : enable\n"
      "uniform sampler2DRect Ytex, UVtex;\n"
#else
      "precision mediump float;\n"
      "varying vec2 v_texCoord;\n" "uniform sampler2D Ytex, UVtex;\n"
#endif
      "void main(void) {\n" "  float fx, fy, y, u, v, r, g, b;\n"
#ifndef OPENGL_ES2
      "  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"
#else
      "  fx = v_texCoord.x;\n"
      "  fy = v_texCoord.y;\n"
      "  y = texture2D(Ytex,vec2(fx,fy)).%c;\n"
      "  u = texture2D(UVtex,vec2(fx*0.5,fy)).%c;\n"
      "  v = texture2D(UVtex,vec2(fx*0.5,fy)).%c;\n"
#endif
      "  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 =
#ifndef OPENGL_ES2
      "#extension GL_ARB_texture_rectangle : enable\n"
      "uniform sampler2DRect Ytex,Utex,Vtex;\n"
#else
      "precision mediump float;\n"
      "varying vec2 v_texCoord;\n" "uniform sampler2D Ytex,Utex,Vtex;\n"
#endif
      "void main(void) {\n" "  float r,g,b,y,u,v;\n"
#ifndef OPENGL_ES2
      "  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"
#else
      "  vec2 nxy = v_texCoord.xy;\n"
      "  y=texture2D(Ytex,nxy).r;\n"
      "  u=texture2D(Utex,nxy).r;\n" "  v=texture2D(Vtex,nxy).r;\n"
#endif
      "  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 =
#ifndef OPENGL_ES2
      "#extension GL_ARB_texture_rectangle : enable\n"
      "uniform sampler2DRect tex;\n"
#else
      "precision mediump float;\n"
      "varying vec2 v_texCoord;\n" "uniform sampler2D tex;\n"
#endif
      "void main(void) {\n" "  float r,g,b,y,u,v;\n"
#ifndef OPENGL_ES2
      "  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"
#else
      "  vec2 nxy = v_texCoord.xy;\n"
      "  y=texture2D(tex,nxy).g;\n"
      "  u=texture2D(tex,nxy).b;\n" "  v=texture2D(tex,nxy).a;\n"
#endif
      "  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 =
#ifndef OPENGL_ES2
      "#extension GL_ARB_texture_rectangle : enable\n"
      "uniform sampler2DRect tex;\n"
#else
      "precision mediump float;\n"
      "varying vec2 v_texCoord;\n" "uniform sampler2D tex;\n"
#endif
      "void main(void) {\n" "  float fx,fy,r,g,b,r2,g2,b2,y1,y2,u,v;\n"
#ifndef OPENGL_ES2
      "  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"
#else
      "  fx = v_texCoord.x;\n"
      "  fy = v_texCoord.y;\n"
      "  r=texture2D(tex,vec2(fx*2.0,fy)).r;\n"
      "  g=texture2D(tex,vec2(fx*2.0,fy)).g;\n"
      "  b=texture2D(tex,vec2(fx*2.0,fy)).b;\n"
      "  r2=texture2D(tex,vec2(fx*2.0+1.0,fy)).r;\n"
      "  g2=texture2D(tex,vec2(fx*2.0+1.0,fy)).g;\n"
      "  b2=texture2D(tex,vec2(fx*2.0+1.0,fy)).b;\n"
#endif
      "  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";

  //no OpenGL ES 2.0 support because for now it's not possible
  //to attach multiple textures to a frame buffer object
  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 =
#ifndef OPENGL_ES2
      "#extension GL_ARB_texture_rectangle : enable\n"
      "uniform sampler2DRect tex;\n"
#else
      "precision mediump float;\n"
      "varying vec2 v_texCoord;\n" "uniform sampler2D tex;\n"
#endif
      "void main(void) {\n" "  float r,g,b,y,u,v;\n"
#ifndef OPENGL_ES2
      "  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"
#else
      "  vec2 nxy=v_texCoord.xy;\n"
      "  r=texture2D(tex,nxy).r;\n"
      "  g=texture2D(tex,nxy).g;\n" "  b=texture2D(tex,nxy).b;\n"
#endif
      "  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"
#ifndef OPENGL_ES2
      "  gl_FragColor=vec4(y,u,v,1.0);\n"
#else
      "  gl_FragColor=vec4(1.0,y,u,v);\n"
#endif
      "}\n";

#ifdef OPENGL_ES2
  display->redisplay_vertex_shader_str =
      "attribute vec4 a_position;   \n"
      "attribute vec2 a_texCoord;   \n"
      "varying vec2 v_texCoord;     \n"
      "void main()                  \n"
      "{                            \n"
      "   gl_Position = a_position; \n"
      "   v_texCoord = a_texCoord;  \n" "}                            \n";

  display->redisplay_fragment_shader_str =
      "precision mediump float;                            \n"
      "varying vec2 v_texCoord;                            \n"
      "uniform sampler2D s_texture;                        \n"
      "void main()                                         \n"
      "{                                                   \n"
      "  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
      "}                                                   \n";

  display->text_vertex_shader_upload =
      "attribute vec4 a_position;   \n"
      "attribute vec2 a_texCoord;   \n"
      "varying vec2 v_texCoord;     \n"
      "void main()                  \n"
      "{                            \n"
      "   gl_Position = a_position; \n"
      "   v_texCoord = a_texCoord;  \n" "}                            \n";

  display->text_vertex_shader_download =
      "attribute vec4 a_position;   \n"
      "attribute vec2 a_texCoord;   \n"
      "varying vec2 v_texCoord;     \n"
      "void main()                  \n"
      "{                            \n"
      "   gl_Position = a_position; \n"
      "   v_texCoord = a_texCoord;  \n" "}                            \n";

  display->text_fragment_shader_download_RGB =
      "precision mediump float;                            \n"
      "varying vec2 v_texCoord;                            \n"
      "uniform sampler2D s_texture;                        \n"
      "void main()                                         \n"
      "{                                                   \n"
      "  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
      "}                                                   \n";
#endif

  display->error_message = NULL;
}

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

  if (display->mutex && display->gl_window) {

    gst_gl_display_lock (display);

    gst_gl_window_set_resize_callback (display->gl_window, NULL, NULL);
    gst_gl_window_set_draw_callback (display->gl_window, NULL, NULL);
    gst_gl_window_set_close_callback (display->gl_window, NULL, NULL);

    GST_INFO ("send quit gl window loop");

    gst_gl_window_quit_loop (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_destroy_context), display);

    GST_INFO ("quit sent to gl window loop");

    g_cond_wait (display->cond_destroy_context, display->mutex);
    GST_INFO ("quit received from gl window");
    gst_gl_display_unlock (display);
  }

  if (display->gl_thread) {
    gpointer ret = g_thread_join (display->gl_thread);
    GST_INFO ("gl thread joined");
    if (ret != NULL)
      GST_ERROR ("gl thread returned a not null pointer");
    display->gl_thread = NULL;
  }

  if (display->texture_pool) {
    //texture pool is empty after destroying the gl context
    if (g_hash_table_size (display->texture_pool) != 0)
      GST_ERROR ("texture pool is not empty");
    g_hash_table_unref (display->texture_pool);
    display->texture_pool = NULL;
  }
  if (display->mutex) {
    g_mutex_free (display->mutex);
    display->mutex = 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->client_data)
    display->client_data = NULL;
  if (display->use_fbo_scene_cb)
    display->use_fbo_scene_cb = NULL;
  if (display->use_fbo_scene_cb_v2)
    display->use_fbo_scene_cb_v2 = NULL;
  if (display->use_fbo_stuff)
    display->use_fbo_stuff = NULL;

  if (display->error_message) {
    g_free (display->error_message);
    display->error_message = NULL;
  }
}


//------------------------------------------------------------
//------------------ BEGIN GL THREAD PROCS -------------------
//------------------------------------------------------------

/* Called in the gl thread */

void
gst_gl_display_set_error (GstGLDisplay * display, const char *format, ...)
{
  va_list args;

  if (display->error_message)
    g_free (display->error_message);

  va_start (args, format);
  display->error_message = g_strdup_vprintf (format, args);
  va_end (args);

  display->isAlive = FALSE;
}

gpointer
gst_gl_display_thread_create_context (GstGLDisplay * display)
{
  GLenum err = GLEW_OK;

  gst_gl_display_lock (display);
  display->gl_window = gst_gl_window_new (display->external_gl_context);

  if (!display->gl_window) {
    gst_gl_display_set_error (display, "Failed to create gl window");
    g_cond_signal (display->cond_create_context);
    gst_gl_display_unlock (display);
    return NULL;
  }

  GST_INFO ("gl window created");

#ifndef OPENGL_ES2
  err = glewInit ();
#endif
  if (err != GLEW_OK) {
#ifndef OPENGL_ES2
    gst_gl_display_set_error (display, "Failed to init GLEW: %s",
        glewGetErrorString (err));
#endif
  } else {
#ifndef OPENGL_ES2
    //OpenGL > 1.2.0 and Glew > 1.4.0
    GString *opengl_version = NULL;
    gint opengl_version_major = 0;
    gint opengl_version_minor = 0;
#endif

    GLenum gl_err = GL_NO_ERROR;
    if (glGetString (GL_VERSION))
      GST_INFO ("GL_VERSION: %s", glGetString (GL_VERSION));

#ifndef OPENGL_ES2
    GST_INFO ("GLEW_VERSION: %s", glewGetString (GLEW_VERSION));
#endif
    if (glGetString (GL_SHADING_LANGUAGE_VERSION))
      GST_INFO ("GL_SHADING_LANGUAGE_VERSION: %s",
          glGetString (GL_SHADING_LANGUAGE_VERSION));
    else
      GST_INFO ("Your driver does not support GLSL (OpenGL Shading Language)");

    if (glGetString (GL_VENDOR))
      GST_INFO ("GL_VENDOR: %s", glGetString (GL_VENDOR));

    if (glGetString (GL_RENDERER))
      GST_INFO ("GL_RENDERER: %s", glGetString (GL_RENDERER));


    gl_err = glGetError ();
    if (gl_err != GL_NO_ERROR) {
      gst_gl_display_set_error (display, "glGetString error: 0x%x", gl_err);
    }
#ifndef OPENGL_ES2
    if (glGetString (GL_VERSION) && gl_err == GL_NO_ERROR) {

      opengl_version =
          g_string_truncate (g_string_new ((gchar *) glGetString (GL_VERSION)),
          3);

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

      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
        gst_gl_display_set_error (display,
            "Required OpenGL >= 1.2.0 and Glew >= 1.4.0");
      }
    }
#else
    if (!GL_ES_VERSION_2_0) {
      gst_gl_display_set_error (display, "Required OpenGL ES > 2.0");
    }
#endif
  }

  //setup callbacks
  gst_gl_window_set_resize_callback (display->gl_window,
      GST_GL_WINDOW_CB2 (gst_gl_display_on_resize), display);
  gst_gl_window_set_draw_callback (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_on_draw), display);
  gst_gl_window_set_close_callback (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_on_close), display);

  g_cond_signal (display->cond_create_context);

  gst_gl_display_unlock (display);

  gst_gl_window_run_loop (display->gl_window);

  GST_INFO ("loop exited\n");

  gst_gl_display_lock (display);

  display->isAlive = FALSE;

  g_object_unref (G_OBJECT (display->gl_window));

  display->gl_window = NULL;

  g_cond_signal (display->cond_destroy_context);

  gst_gl_display_unlock (display);

  return NULL;
}


/* Called in the gl thread */
void
gst_gl_display_thread_destroy_context (GstGLDisplay * display)
{
  //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;
      }
#ifdef OPENGL_ES2
      if (display->shader_download_RGB) {
        g_object_unref (G_OBJECT (display->shader_download_RGB));
        display->shader_download_RGB = NULL;
      }
#endif
    }
      break;
    default:
      GST_ERROR ("Unknow colorspace conversion %d",
          display->upload_colorspace_conversion);
  }

  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_u != 0) {
    glDeleteTextures (1, &display->upload_intex_u);
    display->upload_intex_u = 0;
  }
  if (display->upload_intex_v != 0) {
    glDeleteTextures (1, &display->upload_intex_v);
    display->upload_intex_v = 0;
  }
#ifdef OPENGL_ES2
  if (display->redisplay_shader) {
    g_object_unref (G_OBJECT (display->redisplay_shader));
    display->redisplay_shader = NULL;
  }
#endif

  GST_INFO ("Cleaning texture pool");

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

  GST_INFO ("Context destroyed");
}


void
gst_gl_display_thread_run_generic (GstGLDisplay * display)
{
  display->generic_callback (display, display->data);
}


/* Called in the gl thread */
void
gst_gl_display_thread_gen_texture (GstGLDisplay * display)
{
  //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);
}


#ifdef OPENGL_ES2
/* Called in the gl thread */
void
gst_gl_display_thread_init_redisplay (GstGLDisplay * display)
{
  GError *error = NULL;
  display->redisplay_shader = gst_gl_shader_new ();

  gst_gl_shader_set_vertex_source (display->redisplay_shader,
      display->redisplay_vertex_shader_str);
  gst_gl_shader_set_fragment_source (display->redisplay_shader,
      display->redisplay_fragment_shader_str);

  gst_gl_shader_compile (display->redisplay_shader, &error);
  if (error) {
    gst_gl_display_set_error (display, "%s", error->message);
    g_error_free (error);
    error = NULL;
    gst_gl_shader_use (NULL);
  } else {
    display->redisplay_attr_position_loc =
        gst_gl_shader_get_attribute_location (display->redisplay_shader,
        "a_position");
    display->redisplay_attr_texture_loc =
        gst_gl_shader_get_attribute_location (display->redisplay_shader,
        "a_texCoord");
  }
}
#endif


/* Called in the gl thread */
void
gst_gl_display_thread_init_upload (GstGLDisplay * 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
      //but if the size is different we need to redraw it
      //using fbo
      if (display->upload_width != display->upload_data_width ||
          display->upload_height != display->upload_data_height)
        gst_gl_display_thread_init_upload_fbo (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
    {
      //check if fragment shader is available, then load them
      /* shouldn't we require ARB_shading_language_100? --Filippo */
      if (GLEW_ARB_fragment_shader) {

#ifdef OPENGL_ES2
        GError *error = NULL;
#endif

        GST_INFO ("Context, ARB_fragment_shader supported: yes");

        display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_GLSL;

        gst_gl_display_thread_init_upload_fbo (display);
        if (!display->isAlive)
          break;

        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 ();
#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_upload_YUY2,
                    text_shader_upload_YUY2, GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for uploading YUY2");
              g_object_unref (G_OBJECT (display->shader_upload_YUY2));
              display->shader_upload_YUY2 = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_upload_YUY2,
                display->text_vertex_shader_upload);
            gst_gl_shader_set_fragment_source (display->shader_upload_YUY2,
                text_shader_upload_YUY2);

            gst_gl_shader_compile (display->shader_upload_YUY2, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_upload_YUY2));
              display->shader_upload_YUY2 = NULL;
            } else {
              display->shader_upload_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_YUY2, "a_position");
              display->shader_upload_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_YUY2, "a_texCoord");
            }
#endif
          }
            break;
          case GST_VIDEO_FORMAT_UYVY:
          {
            gchar text_shader_upload_UYVY[2048];
            sprintf (text_shader_upload_UYVY,
#ifndef OPENGL_ES2
                display->text_shader_upload_YUY2_UYVY, 'a', 'b', 'r');
#else
                display->text_shader_upload_YUY2_UYVY, 'a', 'r', 'b');
#endif

            display->shader_upload_UYVY = gst_gl_shader_new ();

#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_upload_UYVY,
                    text_shader_upload_UYVY, GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for uploading UYVY");
              g_object_unref (G_OBJECT (display->shader_upload_UYVY));
              display->shader_upload_UYVY = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_upload_UYVY,
                display->text_vertex_shader_upload);
            gst_gl_shader_set_fragment_source (display->shader_upload_UYVY,
                text_shader_upload_UYVY);

            gst_gl_shader_compile (display->shader_upload_UYVY, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_upload_UYVY));
              display->shader_upload_UYVY = NULL;
            } else {
              display->shader_upload_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_UYVY, "a_position");
              display->shader_upload_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_UYVY, "a_texCoord");
            }
#endif
          }
            break;
          case GST_VIDEO_FORMAT_I420:
          case GST_VIDEO_FORMAT_YV12:
          {
#ifndef OPENGL_ES2
            gchar text_shader_upload_I420_YV12[2048];
            if ((g_ascii_strncasecmp ("ATI", (gchar *) glGetString (GL_VENDOR),
                        3) == 0)
                && (g_ascii_strncasecmp ("ATI Mobility Radeon HD",
                        (gchar *) glGetString (GL_RENDERER), 22) != 0)
                && (g_ascii_strncasecmp ("ATI Radeon HD",
                        (gchar *) glGetString (GL_RENDERER), 13) != 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");
#endif

            display->shader_upload_I420_YV12 = gst_gl_shader_new ();

#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check
                (display->shader_upload_I420_YV12, text_shader_upload_I420_YV12,
                    GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for uploading I420 or YV12");
              g_object_unref (G_OBJECT (display->shader_upload_I420_YV12));
              display->shader_upload_I420_YV12 = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_upload_I420_YV12,
                display->text_vertex_shader_upload);
            gst_gl_shader_set_fragment_source (display->shader_upload_I420_YV12,
                display->text_shader_upload_I420_YV12);

            gst_gl_shader_compile (display->shader_upload_I420_YV12, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_upload_I420_YV12));
              display->shader_upload_I420_YV12 = NULL;
            } else {
              display->shader_upload_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_I420_YV12, "a_position");
              display->shader_upload_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_I420_YV12, "a_texCoord");
            }
#endif
          }
            break;
          case GST_VIDEO_FORMAT_AYUV:
          {
            display->shader_upload_AYUV = gst_gl_shader_new ();

#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_upload_AYUV,
                    display->text_shader_upload_AYUV,
                    GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for uploading AYUV");
              g_object_unref (G_OBJECT (display->shader_upload_AYUV));
              display->shader_upload_AYUV = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_upload_AYUV,
                display->text_vertex_shader_upload);
            gst_gl_shader_set_fragment_source (display->shader_upload_AYUV,
                display->text_shader_upload_AYUV);

            gst_gl_shader_compile (display->shader_upload_AYUV, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_upload_AYUV));
              display->shader_upload_AYUV = NULL;
            } else {
              display->shader_upload_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_AYUV, "a_position");
              display->shader_upload_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_upload_AYUV, "a_texCoord");
            }
#endif
          }
            break;
          default:
            gst_gl_display_set_error (display,
                "Unsupported upload video format %d",
                display->upload_video_format);
        }
      }
      //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
        GST_INFO ("Context, ARB_fragment_shader supported: no");
        GST_INFO ("Context, GLEW_MESA_ycbcr_texture supported: yes");

        display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_MESA;

        switch (display->upload_video_format) {
          case GST_VIDEO_FORMAT_YUY2:
          case GST_VIDEO_FORMAT_UYVY:
            //color space conversion is not needed
            //but if the size is different we need to redraw it
            //using fbo
            if (display->upload_width != display->upload_data_width ||
                display->upload_height != display->upload_data_height)
              gst_gl_display_thread_init_upload_fbo (display);
            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
            gst_gl_display_set_error (display,
                "Your MESA version only supports YUY2 and UYVY (GLSL is required for others yuv formats)");
            break;
          default:
            gst_gl_display_set_error (display,
                "Unsupported upload video format %d",
                display->upload_video_format);
        }
      }
      //check if color matrix is available
      else if (GLEW_ARB_imaging) {
        //GLSL is not available on your drivers, switch to Color Matrix
        GST_INFO ("Context, ARB_fragment_shader supported: no");
        GST_INFO ("Context, GLEW_MESA_ycbcr_texture supported: no");
        GST_INFO ("Context, GLEW_ARB_imaging supported: yes");

        display->upload_colorspace_conversion =
            GST_GL_DISPLAY_CONVERSION_MATRIX;

        //turn off the pipeline because we do not support it yet
        gst_gl_display_set_error (display,
            "Colorspace conversion using Color Matrix is not yet supported");
      } else {
        //turn off the pipeline because colorspace conversion is not possible
        gst_gl_display_set_error (display,
            "ARB_fragment_shader supported, GLEW_ARB_imaging supported, GLEW_MESA_ycbcr_texture supported, not supported");
      }
    }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }
}


/* Called by the idle function */
void
gst_gl_display_thread_do_upload (GstGLDisplay * display)
{
  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
      //but if the size is different we need to redraw it
      //using fbo
      if (display->upload_width != display->upload_data_width ||
          display->upload_height != display->upload_data_height)
        gst_gl_display_thread_do_upload_draw (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:
    {
      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
          //but if the size is different we need to redraw it
          //using fbo
          if (display->upload_width != display->upload_data_width ||
              display->upload_height != display->upload_data_height)
            gst_gl_display_thread_do_upload_draw (display);
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
    }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }
}


/* Called in the gl thread */
void
gst_gl_display_thread_init_download (GstGLDisplay * display)
{
  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_INFO ("Context, EXT_framebuffer_object supported: yes");

        //-- 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);
#ifndef OPENGL_ES2
        glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
            display->download_width, display->download_height);
        glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
            display->download_width, display->download_height);
#else
        glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16,
            display->download_width, display->download_height);
#endif

        //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:
            gst_gl_display_set_error (display,
                "Unsupported download video format %d",
                display->download_video_format);
        }

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

#ifndef OPENGL_ES2
        glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT,
            GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT,
            display->download_depth_buffer);
#endif

        gst_gl_display_check_framebuffer_status ();

        if (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) !=
            GL_FRAMEBUFFER_COMPLETE_EXT)
          gst_gl_display_set_error (display,
              "GL framebuffer status incomplete");

        //unbind the FBO
        glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
      } else {
        //turn off the pipeline because Frame buffer object is a requirement when using filters
        //or when using GLSL colorspace conversion
        gst_gl_display_set_error (display,
            "Context, EXT_framebuffer_object supported: no");
      }
    }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported download video format %d",
          display->download_video_format);
  }

  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
#ifdef OPENGL_ES2
    {
      //glGetTexImage2D no available in OpenGL ES 2.0
      GError *error = NULL;
      display->shader_download_RGB = gst_gl_shader_new ();

      gst_gl_shader_set_vertex_source (display->shader_download_RGB,
          display->text_vertex_shader_download);
      gst_gl_shader_set_fragment_source (display->shader_download_RGB,
          display->text_fragment_shader_download_RGB);

      gst_gl_shader_compile (display->shader_download_RGB, &error);
      if (error) {
        gst_gl_display_set_error (display, "%s", error->message);
        g_error_free (error);
        error = NULL;
        gst_gl_shader_use (NULL);
        g_object_unref (G_OBJECT (display->shader_download_RGB));
        display->shader_download_RGB = NULL;
      } else {
        display->shader_download_attr_position_loc =
            gst_gl_shader_get_attribute_location (display->shader_download_RGB,
            "a_position");
        display->shader_download_attr_texture_loc =
            gst_gl_shader_get_attribute_location (display->shader_download_RGB,
            "a_texCoord");
      }
    }
#endif
      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) {

#ifdef OPENGL_ES2
        GError *error = NULL;
#endif

        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 ();
#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_download_YUY2,
                    text_shader_download_YUY2, GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for downloading YUY2");
              g_object_unref (G_OBJECT (display->shader_download_YUY2));
              display->shader_download_YUY2 = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_download_YUY2,
                display->text_vertex_shader_download);
            gst_gl_shader_set_fragment_source (display->shader_download_YUY2,
                text_shader_download_YUY2);

            gst_gl_shader_compile (display->shader_download_YUY2, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_download_YUY2));
              display->shader_download_YUY2 = NULL;
            } else {
              display->shader_download_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_YUY2, "a_position");
              display->shader_download_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_YUY2, "a_texCoord");
            }
#endif
          }
            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 ();

#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_download_UYVY,
                    text_shader_download_UYVY, GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for downloading UYVY");
              g_object_unref (G_OBJECT (display->shader_download_UYVY));
              display->shader_download_UYVY = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_download_UYVY,
                display->text_vertex_shader_download);
            gst_gl_shader_set_fragment_source (display->shader_download_UYVY,
                text_shader_download_UYVY);

            gst_gl_shader_compile (display->shader_download_UYVY, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_download_UYVY));
              display->shader_download_UYVY = NULL;
            } else {
              display->shader_download_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_UYVY, "a_position");
              display->shader_download_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_UYVY, "a_texCoord");
            }
#endif

          }
            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)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for downloading I420 or YV12");
              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 ();

#ifndef OPENGL_ES2
            if (!gst_gl_shader_compile_and_check (display->shader_download_AYUV,
                    display->text_shader_download_AYUV,
                    GST_GL_SHADER_FRAGMENT_SOURCE)) {
              gst_gl_display_set_error (display,
                  "Failed to initialize shader for downloading AYUV");
              g_object_unref (G_OBJECT (display->shader_download_AYUV));
              display->shader_download_AYUV = NULL;
            }
#else
            gst_gl_shader_set_vertex_source (display->shader_download_AYUV,
                display->text_vertex_shader_download);
            gst_gl_shader_set_fragment_source (display->shader_download_AYUV,
                display->text_shader_download_AYUV);

            gst_gl_shader_compile (display->shader_download_AYUV, &error);
            if (error) {
              gst_gl_display_set_error (display, "%s", error->message);
              g_error_free (error);
              error = NULL;
              gst_gl_shader_use (NULL);
              g_object_unref (G_OBJECT (display->shader_download_AYUV));
              display->shader_download_AYUV = NULL;
            } else {
              display->shader_download_attr_position_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_AYUV, "a_position");
              display->shader_download_attr_texture_loc =
                  gst_gl_shader_get_attribute_location
                  (display->shader_download_AYUV, "a_texCoord");
            }
#endif
            break;
          default:
            gst_gl_display_set_error (display,
                "Unsupported download video format %d",
                display->download_video_format);
        }
      } else {
        //turn off the pipeline because colorspace conversion is not possible
        gst_gl_display_set_error (display,
            "Context, ARB_fragment_shader supported: no");
      }
    }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported download video format %d",
          display->download_video_format);
  }
}


/* Called in the gl thread */
void
gst_gl_display_thread_do_download (GstGLDisplay * display)
{
  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:
      gst_gl_display_set_error (display, "Unsupported download video format %d",
          display->download_video_format);
  }
}


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

  //-- generate frame buffer object

  if (!GLEW_EXT_framebuffer_object) {
    //turn off the pipeline because Frame buffer object is a not present
    gst_gl_display_set_error (display,
        "Context, EXT_framebuffer_object not supported");
    return;
  }
  //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);
#ifndef OPENGL_ES2
  glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
      display->gen_fbo_width, display->gen_fbo_height);
  glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
      display->gen_fbo_width, display->gen_fbo_height);
#else
  glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16,
      display->gen_fbo_width, display->gen_fbo_height);
#endif

  //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);
  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 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);

#ifndef OPENGL_ES2
  glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
      GL_RENDERBUFFER_EXT, display->generated_depth_buffer);
#endif

  if (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) !=
      GL_FRAMEBUFFER_COMPLETE_EXT)
    gst_gl_display_set_error (display, "GL framebuffer status incomplete");

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

  glDeleteTextures (1, &fake_texture);
}


/* Called in the gl thread */
void
gst_gl_display_thread_use_fbo (GstGLDisplay * display)
{
#ifdef OPENGL_ES2
  GLint viewport_dim[4];
#endif

  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);

#ifndef OPENGL_ES2
  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_PERSPECTIVE:
      gluPerspective (display->use_fbo_proj_param1,
          display->use_fbo_proj_param2, display->use_fbo_proj_param3,
          display->use_fbo_proj_param4);
      break;
    default:
      gst_gl_display_set_error (display, "Unknow fbo projection %d",
          display->use_fbo_projection);
  }

  glMatrixMode (GL_MODELVIEW);
  glPushMatrix ();
  glLoadIdentity ();
#else // OPENGL_ES2
  glGetIntegerv (GL_VIEWPORT, viewport_dim);
#endif

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

#ifndef OPENGL_ES2
  glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

  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);

#ifndef OPENGL_ES2
  glDrawBuffer (GL_NONE);
  glMatrixMode (GL_PROJECTION);
  glPopMatrix ();
  glMatrixMode (GL_MODELVIEW);
  glPopMatrix ();
  glPopAttrib ();
#else
  glViewport (viewport_dim[0], viewport_dim[1], viewport_dim[2],
      viewport_dim[3]);
#endif

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
}


/* Called in a gl thread
 * Need full shader support */
void
gst_gl_display_thread_use_fbo_v2 (GstGLDisplay * display)
{
  GLint viewport_dim[4];

  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);

  glGetIntegerv (GL_VIEWPORT, viewport_dim);

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

#ifndef OPENGL_ES2
  glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

  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_v2 (display->use_fbo_stuff);

#ifndef OPENGL_ES2
  glDrawBuffer (GL_NONE);
#endif

  glViewport (viewport_dim[0], viewport_dim[1],
      viewport_dim[2], viewport_dim[3]);

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
}


/* Called in the gl thread */
void
gst_gl_display_thread_del_fbo (GstGLDisplay * display)
{
  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;
  }
}


/* Called in the gl thread */
void
gst_gl_display_thread_gen_shader (GstGLDisplay * display)
{
  if (GLEW_ARB_fragment_shader) {
    if (display->gen_shader_vertex_source ||
        display->gen_shader_fragment_source) {
      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) {
        gst_gl_display_set_error (display, "%s", error->message);
        g_error_free (error);
        error = NULL;
        gst_gl_shader_use (NULL);
        g_object_unref (G_OBJECT (display->gen_shader));
        display->gen_shader = NULL;
      }
    }
  } else {
    gst_gl_display_set_error (display,
        "One of the filter required ARB_fragment_shader");
    display->gen_shader = NULL;
  }
}


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


//------------------------------------------------------------
//------------------ 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);
}


void
gst_gl_display_on_resize (GstGLDisplay * display, gint width, gint height)
{
  //check if a client reshape callback is registered
  if (display->clientReshapeCallback)
    display->clientReshapeCallback (width, height, display->client_data);

  //default reshape
  else {
    if (display->keep_aspect_ratio) {
      GstVideoRectangle src, dst, result;

      src.x = 0;
      src.y = 0;
      src.w = display->redisplay_texture_width;
      src.h = display->redisplay_texture_height;

      dst.x = 0;
      dst.y = 0;
      dst.w = width;
      dst.h = height;

      gst_video_sink_center_rect (src, dst, &result, TRUE);
      glViewport (result.x, result.y, result.w, result.h);
    } else {
      glViewport (0, 0, width, height);
    }
#ifndef OPENGL_ES2
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    gluOrtho2D (0, width, 0, height);
    glMatrixMode (GL_MODELVIEW);
#endif
  }
}


void
gst_gl_display_on_draw (GstGLDisplay * display)
{
  //check if tecture is ready for being drawn
  if (!display->redisplay_texture)
    return;

  //opengl scene
  GST_DEBUG ("on draw");

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

#ifndef OPENGL_ES2
  glDisable (GL_TEXTURE_RECTANGLE_ARB);
#endif

  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,
        display->client_data);

    if (doRedisplay && display->gl_window)
      gst_gl_window_draw_unlocked (display->gl_window,
          display->redisplay_texture_width, display->redisplay_texture_height);
  }
  //default opengl scene
  else {

#ifndef OPENGL_ES2
    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);
    /* gst images are top-down while opengl plane is bottom-up */
    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);
    /*glTexCoord2i (display->redisplay_texture_width, 0);
       glVertex2i (1, -1);
       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);

#else //OPENGL_ES2

    const GLfloat vVertices[] = { 1.0f, 1.0f, 0.0f,
      1.0f, 0.0f,
      -1.0f, 1.0f, 0.0f,
      0.0f, 0.0f,
      -1.0f, -1.0f, 0.0f,
      0.0f, 1.0f,
      1.0f, -1.0f, 0.0f,
      1.0f, 1.0f
    };

    GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

    glClear (GL_COLOR_BUFFER_BIT);

    gst_gl_shader_use (display->redisplay_shader);

    //Load the vertex position
    glVertexAttribPointer (display->redisplay_attr_position_loc, 3, GL_FLOAT,
        GL_FALSE, 5 * sizeof (GLfloat), vVertices);

    //Load the texture coordinate
    glVertexAttribPointer (display->redisplay_attr_texture_loc, 2, GL_FLOAT,
        GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

    glEnableVertexAttribArray (display->redisplay_attr_position_loc);
    glEnableVertexAttribArray (display->redisplay_attr_texture_loc);

    glActiveTexture (GL_TEXTURE0);
    glBindTexture (GL_TEXTURE_2D, display->redisplay_texture);
    gst_gl_shader_set_uniform_1i (display->redisplay_shader, "s_texture", 0);

    glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
#endif

  }                             //end default opengl scene
}


void
gst_gl_display_on_close (GstGLDisplay * display)
{
  gst_gl_display_set_error (display, "Output window was closed");
}


/* 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)
{
  glGenTextures (1, pTexture);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, *pTexture);

  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:
      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
          width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      break;
    case GST_VIDEO_FORMAT_YUY2:
    case GST_VIDEO_FORMAT_UYVY:
      switch (display->upload_colorspace_conversion) {
        case GST_GL_DISPLAY_CONVERSION_GLSL:
        case GST_GL_DISPLAY_CONVERSION_MATRIX:
          glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
              width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
          break;
        case GST_GL_DISPLAY_CONVERSION_MESA:
          if (display->upload_width != display->upload_data_width ||
              display->upload_height != display->upload_data_height)
            glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
                width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
          else
            glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_YCBCR_MESA, width,
                height, 0, GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, NULL);
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      break;
    case GST_VIDEO_FORMAT_I420:
    case GST_VIDEO_FORMAT_YV12:
    case GST_VIDEO_FORMAT_AYUV:
      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
          width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }

  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);

  GST_LOG ("generated texture id:%d", *pTexture);
}


/* 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

  GQueue *sub_texture_pool = NULL;
  GstGLDisplayTex *tex = NULL;

  //make a unique key from w and h
  //the key cannot be w*h because (4*6 = 6*4 = 2*12 = 12*2)
  guint key = (gint) width;
  key <<= 16;
  key |= (gint) height;
  sub_texture_pool =
      g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER (key));

  //if the size is known
  if (!sub_texture_pool) {
    sub_texture_pool = g_queue_new ();
    g_hash_table_insert (display->texture_pool, GUINT_TO_POINTER (key),
        sub_texture_pool);

    GST_INFO ("one more sub texture pool inserted: %d ", key);
    GST_INFO ("nb sub texture pools: %d",
        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);
  GST_LOG ("texture id:%d added to the sub texture pool: %d",
      tex->texture, key);
  GST_LOG ("%d texture(s) in the sub texture pool: %d",
      g_queue_get_length (sub_texture_pool), key);
}


/* 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);
    GST_INFO ("trying to delete texture id: %d deleted", tex->texture);
    glDeleteTextures (1, &tex->texture);
    GST_INFO ("texture id: %d deleted", 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:
      GST_ERROR ("GL_FRAMEBUFFER_UNSUPPORTED");
      break;

    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
      GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
      break;

    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
      GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
      break;

    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
      GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
      break;

    case GL_FRAMEBUFFER_UNDEFINED:
      GST_ERROR ("GL_FRAMEBUFFER_UNDEFINED");
      break;

    default:
      GST_ERROR ("General FBO error");
  }
}


//------------------------------------------------------------
//---------------------  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) */
gboolean
gst_gl_display_create_context (GstGLDisplay * display,
    gulong external_gl_context)
{
  gboolean isAlive = FALSE;

  gst_gl_display_lock (display);

  if (!display->gl_window) {
    display->external_gl_context = external_gl_context;

    display->gl_thread = g_thread_create (
        (GThreadFunc) gst_gl_display_thread_create_context, display, TRUE,
        NULL);

    g_cond_wait (display->cond_create_context, display->mutex);

    GST_INFO ("gl thread created");
  }

  isAlive = display->isAlive;

  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by the glimagesink element */
gboolean
gst_gl_display_redisplay (GstGLDisplay * display, GLuint texture,
    gint gl_width, gint gl_height, gint window_width, gint window_height,
    gboolean keep_aspect_ratio)
{
  gboolean isAlive = TRUE;

  gst_gl_display_lock (display);
  isAlive = display->isAlive;
  if (isAlive) {

#ifdef OPENGL_ES2
    if (!display->redisplay_shader) {
      gst_gl_window_send_message (display->gl_window,
          GST_GL_WINDOW_CB (gst_gl_display_thread_init_redisplay), display);
    }
#endif

    if (texture) {
      display->redisplay_texture = texture;
      display->redisplay_texture_width = gl_width;
      display->redisplay_texture_height = gl_height;
    }
    display->keep_aspect_ratio = keep_aspect_ratio;
    if (display->gl_window)
      gst_gl_window_draw (display->gl_window, window_width, window_height);
    isAlive = display->isAlive;
  }
  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_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_run_generic), display);
  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);

  if (display->isAlive) {
    GQueue *sub_texture_pool = NULL;

    //make a unique key from w and h
    //the key cannot be w*h because (4*6 = 6*4 = 2*12 = 12*2)
    guint key = (gint) width;
    key <<= 16;
    key |= (gint) height;
    sub_texture_pool =
        g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER (key));

    //if there is a sub texture pool associated to the given key
    if (sub_texture_pool && g_queue_get_length (sub_texture_pool) > 0) {
      //a texture is available in the pool
      GstGLDisplayTex *tex = g_queue_pop_head (sub_texture_pool);
      *pTexture = tex->texture;
      g_free (tex);
      GST_LOG ("get texture id:%d from the sub texture pool: %d",
          *pTexture, key);
    } else {
      //only in this case we want to ask a texture from the gl thread
      display->gen_texture_width = width;
      display->gen_texture_height = height;
      gst_gl_window_send_message (display->gl_window,
          GST_GL_WINDOW_CB (gst_gl_display_thread_gen_texture), display);
      *pTexture = display->gen_texture;
    }

  } else
    *pTexture = 0;

  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);
  if (texture) {
    gst_gl_display_gldel_texture (display, &texture, width, height);
  }
  gst_gl_display_unlock (display);
}


/* Called by the first gl element of a video/x-raw-gl flow */
gboolean
gst_gl_display_init_upload (GstGLDisplay * display, GstVideoFormat video_format,
    guint gl_width, guint gl_height, gint video_width, gint video_height)
{
  gboolean isAlive = FALSE;

  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_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_init_upload), display);
  isAlive = display->isAlive;
  gst_gl_display_unlock (display);

  return isAlive;
}


/* 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_window_send_message (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_do_upload), display);
    isAlive = display->isAlive;
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by the gldownload and glcolorscale element */
gboolean
gst_gl_display_init_download (GstGLDisplay * display,
    GstVideoFormat video_format, gint width, gint height)
{
  gboolean isAlive = FALSE;

  gst_gl_display_lock (display);
  display->download_video_format = video_format;
  display->download_width = width;
  display->download_height = height;
  gst_gl_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_init_download), display);
  isAlive = display->isAlive;
  gst_gl_display_unlock (display);

  return isAlive;
}


/* 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_window_send_message (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_do_download), display);
    isAlive = display->isAlive;
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* Called by gltestsrc and glfilter */
gboolean
gst_gl_display_gen_fbo (GstGLDisplay * display, gint width, gint height,
    GLuint * fbo, GLuint * depthbuffer)
{
  gboolean isAlive = FALSE;

  gst_gl_display_lock (display);
  if (display->isAlive) {
    display->gen_fbo_width = width;
    display->gen_fbo_height = height;
    gst_gl_window_send_message (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_gen_fbo), display);
    *fbo = display->generated_fbo;
    *depthbuffer = display->generated_depth_buffer;
    isAlive = display->isAlive;
  }
  gst_gl_display_unlock (display);

  return isAlive;
}


/* 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_window_send_message (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_use_fbo), display);
    isAlive = display->isAlive;
  }
  gst_gl_display_unlock (display);

  return isAlive;
}

gboolean
gst_gl_display_use_fbo_v2 (GstGLDisplay * display, gint texture_fbo_width,
    gint texture_fbo_height, GLuint fbo, GLuint depth_buffer,
    GLuint texture_fbo, GLCB_V2 cb, 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_v2 = cb;
    display->use_fbo_stuff = stuff;
    gst_gl_window_send_message (display->gl_window,
        GST_GL_WINDOW_CB (gst_gl_display_thread_use_fbo_v2), display);
    isAlive = display->isAlive;
  }
  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_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_del_fbo), display);
  gst_gl_display_unlock (display);
}


/* Called by glfilter */
gboolean
gst_gl_display_gen_shader (GstGLDisplay * display,
    const gchar * shader_vertex_source,
    const gchar * shader_fragment_source, GstGLShader ** shader)
{
  gboolean isAlive = FALSE;

  gst_gl_display_lock (display);
  display->gen_shader_vertex_source = shader_vertex_source;
  display->gen_shader_fragment_source = shader_fragment_source;
  gst_gl_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_gen_shader), display);
  isAlive = display->isAlive;
  if (shader)
    *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);

  return isAlive;
}


/* Called by glfilter */
void
gst_gl_display_del_shader (GstGLDisplay * display, GstGLShader * shader)
{
  gst_gl_display_lock (display);
  display->del_shader = shader;
  gst_gl_window_send_message (display->gl_window,
      GST_GL_WINDOW_CB (gst_gl_display_thread_del_shader), display);
  gst_gl_display_unlock (display);
}


/* Called by the glimagesink */
void
gst_gl_display_set_window_id (GstGLDisplay * display, gulong window_id)
{
  gst_gl_display_lock (display);
  gst_gl_window_set_external_window_id (display->gl_window, window_id);
  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);
}

void
gst_gl_display_set_client_data (GstGLDisplay * display, gpointer data)
{
  gst_gl_display_lock (display);
  display->client_data = data;
  gst_gl_display_unlock (display);
}

gulong
gst_gl_display_get_internal_gl_context (GstGLDisplay * display)
{
  gulong external_gl_context = 0;
  gst_gl_display_lock (display);
  external_gl_context =
      gst_gl_window_get_internal_gl_context (display->gl_window);
  gst_gl_display_unlock (display);
  return external_gl_context;
}

void
gst_gl_display_activate_gl_context (GstGLDisplay * display, gboolean activate)
{
  if (!activate)
    gst_gl_display_lock (display);
  gst_gl_window_activate_gl_context (display->gl_window, activate);
  if (activate)
    gst_gl_display_unlock (display);
}


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

/* called by gst_gl_display_thread_init_upload (in the gl thread) */
void
gst_gl_display_thread_init_upload_fbo (GstGLDisplay * display)
{
  //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;

    GST_INFO ("Context, EXT_framebuffer_object supported: yes");

    //-- 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);
#ifndef OPENGL_ES2
    glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
        display->upload_width, display->upload_height);
    glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
        display->upload_width, display->upload_height);
#else
    glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16,
        display->upload_width, display->upload_height);
#endif

    //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);
    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 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);

#ifndef OPENGL_ES2
    glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
        GL_RENDERBUFFER_EXT, display->upload_depth_buffer);
#endif

    gst_gl_display_check_framebuffer_status ();

    if (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) !=
        GL_FRAMEBUFFER_COMPLETE_EXT)
      gst_gl_display_set_error (display, "GL framebuffer status incomplete");

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

    glDeleteTextures (1, &fake_texture);

    //alloc texture (related to upload) memory only on time
    gst_gl_display_thread_do_upload_make (display);
  } else {
    //turn off the pipeline because Frame buffer object is a not present
    gst_gl_display_set_error (display,
        "Context, EXT_framebuffer_object supported: no");
  }
}

/* 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_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:
      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
          width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      break;
    case GST_VIDEO_FORMAT_RGB:
    case GST_VIDEO_FORMAT_BGR:
      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB,
          width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
      break;
    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:
      switch (display->upload_colorspace_conversion) {
        case GST_GL_DISPLAY_CONVERSION_GLSL:
        case GST_GL_DISPLAY_CONVERSION_MATRIX:
          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_GL_DISPLAY_CONVERSION_MESA:
          glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_YCBCR_MESA, width,
              height, 0, GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, NULL);
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      break;
    case GST_VIDEO_FORMAT_UYVY:
      switch (display->upload_colorspace_conversion) {
        case GST_GL_DISPLAY_CONVERSION_GLSL:
        case GST_GL_DISPLAY_CONVERSION_MATRIX:
          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_GL_DISPLAY_CONVERSION_MESA:
          glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_YCBCR_MESA, width,
              height, 0, GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, NULL);
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      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:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }
}


/* 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
      if (display->upload_width != display->upload_data_width ||
          display->upload_height != display->upload_data_height)
        glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
      else
        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:
      switch (display->upload_colorspace_conversion) {
        case GST_GL_DISPLAY_CONVERSION_GLSL:
        case GST_GL_DISPLAY_CONVERSION_MATRIX:
          glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
          break;
        case GST_GL_DISPLAY_CONVERSION_MESA:
          if (display->upload_width != display->upload_data_width ||
              display->upload_height != display->upload_data_height)
            glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_intex);
          else
            glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_outtex);
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }

  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:
    case GST_VIDEO_FORMAT_RGBA:
      glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
          GL_RGBA, GL_UNSIGNED_BYTE, data);
      break;
    case GST_VIDEO_FORMAT_BGRx:
    case GST_VIDEO_FORMAT_BGRA:
      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:
    case GST_VIDEO_FORMAT_ARGB:
      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:
    case GST_VIDEO_FORMAT_ABGR:
      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:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      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:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
      break;
    case GST_VIDEO_FORMAT_I420:
    case GST_VIDEO_FORMAT_YV12:
    {
      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,
              1, 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,
              2, width, height));
    }
      break;
    default:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);
  }

  //make sure no texture is in use in our opengl context
  //in case we want to use the upload texture in an other opengl context
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
}


/* called by gst_gl_display_thread_do_upload (in the gl thread) */
void
gst_gl_display_thread_do_upload_draw (GstGLDisplay * display)
{

#ifdef OPENGL_ES2
  GLint viewport_dim[4];

  const GLfloat vVertices[] = { 1.0f, -1.0f, 0.0f,
    1.0f, 0.0f,
    -1.0f, -1.0f, 0.0f,
    0.0f, .0f,
    -1.0f, 1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f, 0.0f,
    1.0f, 1.0f
  };

  GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
#endif

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->upload_fbo);

  //setup a texture to render to
#ifndef OPENGL_ES2
  glEnable (GL_TEXTURE_RECTANGLE_ARB);
#endif
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->upload_outtex);

  //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);

#ifndef OPENGL_ES2
  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 ();
#else // OPENGL_ES2
  glGetIntegerv (GL_VIEWPORT, viewport_dim);
#endif

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

#ifndef OPENGL_ES2
  glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

  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_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:
    {
#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#else
      glVertexAttribPointer (display->shader_upload_attr_position_loc, 3,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
      glVertexAttribPointer (display->shader_upload_attr_texture_loc, 2,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

      glEnableVertexAttribArray (display->shader_upload_attr_position_loc);
      glEnableVertexAttribArray (display->shader_upload_attr_texture_loc);
#endif

#ifndef OPENGL_ES2
      glEnable (GL_TEXTURE_RECTANGLE_ARB);
#endif
      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);
#ifndef OPENGL_ES2
      glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#endif
    }
      break;

    case GST_VIDEO_FORMAT_YUY2:
    case GST_VIDEO_FORMAT_UYVY:
    {
      switch (display->upload_colorspace_conversion) {
        case GST_GL_DISPLAY_CONVERSION_GLSL:
        case GST_GL_DISPLAY_CONVERSION_MATRIX:
        {
          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:
              gst_gl_display_set_error (display,
                  "Upload video format inconsistency %d",
                  display->upload_video_format);
          }

          gst_gl_shader_use (shader_upload_YUY2_UYVY);

#ifndef OPENGL_ES2
          glMatrixMode (GL_PROJECTION);
          glLoadIdentity ();
#else
          glVertexAttribPointer (display->shader_upload_attr_position_loc, 3,
              GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
          glVertexAttribPointer (display->shader_upload_attr_texture_loc, 2,
              GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

          glEnableVertexAttribArray (display->shader_upload_attr_position_loc);
          glEnableVertexAttribArray (display->shader_upload_attr_texture_loc);
#endif

          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_GL_DISPLAY_CONVERSION_MESA:
        {

#ifndef OPENGL_ES2
          glMatrixMode (GL_PROJECTION);
          glLoadIdentity ();
          glEnable (GL_TEXTURE_RECTANGLE_ARB);
#endif
          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);
#ifndef OPENGL_ES2
          glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#endif
        }
          break;
        default:
          gst_gl_display_set_error (display, "Unknow colorspace conversion %d",
              display->upload_colorspace_conversion);
      }
    }
      break;

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

#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#else
      glVertexAttribPointer (display->shader_upload_attr_position_loc, 3,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
      glVertexAttribPointer (display->shader_upload_attr_texture_loc, 2,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

      glEnableVertexAttribArray (display->shader_upload_attr_position_loc);
      glEnableVertexAttribArray (display->shader_upload_attr_texture_loc);
#endif

      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);

#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#else
      glVertexAttribPointer (display->shader_upload_attr_position_loc, 3,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
      glVertexAttribPointer (display->shader_upload_attr_texture_loc, 2,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

      glEnableVertexAttribArray (display->shader_upload_attr_position_loc);
      glEnableVertexAttribArray (display->shader_upload_attr_texture_loc);
#endif

      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:
      gst_gl_display_set_error (display, "Unsupported upload video format %d",
          display->upload_video_format);

  }                             //end switch display->currentVideo_format

#ifndef OPENGL_ES2
  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);
#else //OPENGL_ES2
  glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
#endif

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

#ifndef OPENGL_ES2
  glDisable (GL_TEXTURE_RECTANGLE_ARB);

  glMatrixMode (GL_PROJECTION);
  glPopMatrix ();
  glMatrixMode (GL_MODELVIEW);
  glPopMatrix ();
  glPopAttrib ();
#else
  glViewport (viewport_dim[0], viewport_dim[1], viewport_dim[2],
      viewport_dim[3]);
#endif

  gst_gl_display_check_framebuffer_status ();

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
}


/* 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;

#ifndef OPENGL_ES2
  if (display->upload_colorspace_conversion == GST_GL_DISPLAY_CONVERSION_GLSL)
    glUseProgramObjectARB (0);
  glEnable (GL_TEXTURE_RECTANGLE_ARB);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);
#else
  gint width = display->ouput_texture_width;
  gint height = display->ouput_texture_height;

  const GLfloat vVertices[] = { 1.0f, -1.0f, 0.0f,
    1.0f, 0.0f,
    -1.0f, -1.0f, 0.0f,
    0.0f, 0.0f,
    -1.0f, 1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f, 0.0f,
    1.0f, 1.0f
  };

  GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

  glViewport (0, 0, width, height);

  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_RGB);

  glVertexAttribPointer (display->shader_download_attr_position_loc, 3,
      GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
  glVertexAttribPointer (display->shader_download_attr_texture_loc, 2,
      GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

  glEnableVertexAttribArray (display->shader_download_attr_position_loc);
  glEnableVertexAttribArray (display->shader_download_attr_texture_loc);

  glActiveTextureARB (GL_TEXTURE0_ARB);
  gst_gl_shader_set_uniform_1i (display->shader_download_RGB, "s_texture", 0);
  glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->ouput_texture);

  glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);

  glUseProgramObjectARB (0);
#endif

  switch (video_format) {
    case GST_VIDEO_FORMAT_RGBA:
    case GST_VIDEO_FORMAT_RGBx:
    case GST_VIDEO_FORMAT_xRGB:
    case GST_VIDEO_FORMAT_ARGB:
#ifndef OPENGL_ES2
      glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
          GL_UNSIGNED_BYTE, data);
#else
      glReadPixels (0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
#endif
      break;
    case GST_VIDEO_FORMAT_BGRx:
    case GST_VIDEO_FORMAT_BGRA:
    case GST_VIDEO_FORMAT_xBGR:
    case GST_VIDEO_FORMAT_ABGR:
#ifndef OPENGL_ES2
      glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGRA,
          GL_UNSIGNED_BYTE, data);
#endif
      break;
    case GST_VIDEO_FORMAT_RGB:
#ifndef OPENGL_ES2
      glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB,
          GL_UNSIGNED_BYTE, data);
#else
      glReadPixels (0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
#endif
      break;
    case GST_VIDEO_FORMAT_BGR:
#ifndef OPENGL_ES2
      glGetTexImage (GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGR,
          GL_UNSIGNED_BYTE, data);
#endif
      break;
    default:
      gst_gl_display_set_error (display,
          "Download video format inconsistency %d", video_format);
  }

#ifndef OPENGL_ES2
  glReadBuffer (GL_NONE);
  glDisable (GL_TEXTURE_RECTANGLE_ARB);
#endif
}


/* 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;

#ifdef OPENGL_ES2
  GLint viewport_dim[4];

  const GLfloat vVertices[] = { 1.0f, -1.0f, 0.0f,
    1.0f, 0.0f,
    -1.0f, -1.0f, 0.0f,
    0.0f, .0f,
    -1.0f, 1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f, 0.0f,
    1.0f, 1.0f
  };

  GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
#endif

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->download_fbo);

#ifndef OPENGL_ES2
  glPushAttrib (GL_VIEWPORT_BIT);

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

  glMatrixMode (GL_MODELVIEW);
  glPushMatrix ();
  glLoadIdentity ();
#else // OPENGL_ES2
  glGetIntegerv (GL_VIEWPORT, viewport_dim);
#endif

  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:
          gst_gl_display_set_error (display,
              "Download video format inconsistensy %d", video_format);
      }
#ifndef OPENGL_ES2
      glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

      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);

#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#else
      glVertexAttribPointer (display->shader_download_attr_position_loc, 3,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
      glVertexAttribPointer (display->shader_download_attr_texture_loc, 2,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

      glEnableVertexAttribArray (display->shader_download_attr_position_loc);
      glEnableVertexAttribArray (display->shader_download_attr_texture_loc);
#endif

      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:
    {
#ifndef OPENGL_ES2
      glDrawBuffers (3, display->multipleRT);
#endif

      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);

#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#endif

      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:
    {
#ifndef OPENGL_ES2
      glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

      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);

#ifndef OPENGL_ES2
      glMatrixMode (GL_PROJECTION);
      glLoadIdentity ();
#else
      glVertexAttribPointer (display->shader_download_attr_position_loc, 3,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices);
      glVertexAttribPointer (display->shader_download_attr_texture_loc, 2,
          GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);

      glEnableVertexAttribArray (display->shader_download_attr_position_loc);
      glEnableVertexAttribArray (display->shader_download_attr_texture_loc);
#endif

      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:
      gst_gl_display_set_error (display,
          "Download video format inconsistensy %d", video_format);

  }                             //end switch display->currentVideo_format

#ifndef OPENGL_ES2
  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);
#else //OPENGL_ES2
  glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
#endif

  //dot not check if GLSL is available
  //because download yuv is not available
  //without GLSL (whereas rgb is)
  glUseProgramObjectARB (0);

#ifndef OPENGL_ES2
  glDisable (GL_TEXTURE_RECTANGLE_ARB);
  glMatrixMode (GL_PROJECTION);
  glPopMatrix ();
  glMatrixMode (GL_MODELVIEW);
  glPopMatrix ();
  glPopAttrib ();
#else
  glViewport (viewport_dim[0], viewport_dim[1], viewport_dim[2],
      viewport_dim[3]);
#endif

  gst_gl_display_check_framebuffer_status ();

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->download_fbo);
#ifndef OPENGL_ES2
  glReadBuffer (GL_COLOR_ATTACHMENT0_EXT);
#endif

  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:
    {
      glReadPixels (0, 0, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);

#ifndef OPENGL_ES2
      glReadBuffer (GL_COLOR_ATTACHMENT1_EXT);
#endif
      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,
              1, width, height));
#ifndef OPENGL_ES2
      glReadBuffer (GL_COLOR_ATTACHMENT2_EXT);
#endif
      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,
              2, width, height));
    }
      break;
    default:
      gst_gl_display_set_error (display,
          "Download video format inconsistensy %d", video_format);
  }
#ifndef OPENGL_ES2
  glReadBuffer (GL_NONE);
#endif

  gst_gl_display_check_framebuffer_status ();

  glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
}