glfilter: rewrite subclasses for filter_texture() occuring on GL thread

There's no need for the jump to an extra thread in most cases, especially
when relying solely on a shader to render.  We can use the provided
render_to_target() functions to simplify filter writing.

ext/gl/effects/gstgleffectblur.c

@@ -40,79 +40,29 @@ gst_gl_effects_blur_kernel (void)
   return kernel;
 }
 
-static void
-gst_gl_effects_blur_callback_hconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "hconv0",
-              hconv7_fragment_source_gles2))) {
-    GstGLFilter *filter = GST_GL_FILTER (effects);
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1f (shader, "gauss_width", width);
-    gst_gl_shader_set_uniform_1fv (shader, "kernel", 7,
-        gst_gl_effects_blur_kernel ());
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
-static void
-gst_gl_effects_blur_callback_vconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "vconv0",
-              vconv7_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1f (shader, "gauss_height", height);
-    gst_gl_shader_set_uniform_1fv (shader, "kernel", 7,
-        gst_gl_effects_blur_kernel ());
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
 void
 gst_gl_effects_blur (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "hconv0",
-      effects->midtexture[0], gst_gl_effects_blur_callback_hconv, effects);
+      hconv7_fragment_source_gles2);
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[0],
+  gst_gl_shader_use (shader);
-      effects->outtexture, gst_gl_effects_blur_callback_vconv, effects);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_width",
+      GST_VIDEO_INFO_WIDTH (&filter->in_info));
+  gst_gl_shader_set_uniform_1fv (shader, "kernel", 7,
+      gst_gl_effects_blur_kernel ());
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->midtexture[0], shader);
+
+  shader = gst_gl_effects_get_fragment_shader (effects, "vconv0",
+      vconv7_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_height",
+      GST_VIDEO_INFO_HEIGHT (&filter->in_info));
+  gst_gl_shader_set_uniform_1fv (shader, "kernel", 7,
+      gst_gl_effects_blur_kernel ());
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[0],
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectbulge.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_bulge_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "bulge",
-      bulge_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_bulge (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "bulge",
-      effects->outtexture, gst_gl_effects_bulge_callback, effects);
+      bulge_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectfisheye.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_fisheye_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "fisheye",
-      fisheye_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_fisheye (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "fisheye",
-      effects->outtexture, gst_gl_effects_fisheye_callback, effects);
+      fisheye_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectglow.c

@@ -26,170 +26,61 @@
 static gboolean kernel_ready = FALSE;
 static float gauss_kernel[7];
 
-static void
+void
-gst_gl_effects_glow_step_one (gint width, gint height, guint texture,
+gst_gl_effects_glow (GstGLEffects * effects)
-    gpointer data)
 {
-  GstGLShader *shader;
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (effects)->context->gl_vtable;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "luma_threshold",
-      luma_threshold_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static void
-gst_gl_effects_glow_step_two (gint width, gint height, guint texture,
-    gpointer data)
-{
   GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "hconv7",
-      hconv7_fragment_source_gles2);
-
-  if (!shader)
-    return;
 
   if (!kernel_ready) {
     fill_gaussian_kernel (gauss_kernel, 7, 10.0);
     kernel_ready = TRUE;
   }
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
 
+  /* threshold */
+  shader = gst_gl_effects_get_fragment_shader (effects, "luma_threshold",
+      luma_threshold_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->midtexture[0], shader);
+
+  /* blur */
+  shader = gst_gl_effects_get_fragment_shader (effects, "hconv7",
+      hconv7_fragment_source_gles2);
   gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
   gst_gl_shader_set_uniform_1fv (shader, "kernel", 7, gauss_kernel);
-  gst_gl_shader_set_uniform_1f (shader, "gauss_width", width);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_width",
-
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
-  gst_gl_filter_draw_fullscreen_quad (filter);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[0],
-}
+      effects->midtexture[1], shader);
-
-static void
-gst_gl_effects_glow_step_three (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
 
   shader = gst_gl_effects_get_fragment_shader (effects, "vconv7",
       vconv7_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
   gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
   gst_gl_shader_set_uniform_1fv (shader, "kernel", 7, gauss_kernel);
-  gst_gl_shader_set_uniform_1f (shader, "gauss_height", height);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_height",
-
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
-  gst_gl_filter_draw_fullscreen_quad (filter);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[1],
-}
+      effects->midtexture[2], shader);
-
-static void
-gst_gl_effects_glow_step_four (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
 
+  /* add blurred luma to intexture */
   shader = gst_gl_effects_get_fragment_shader (effects, "sum",
       sum_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
   gst_gl_shader_use (shader);
 
   gl->ActiveTexture (GL_TEXTURE2);
-  gl->BindTexture (GL_TEXTURE_2D, effects->intexture->tex_id);
+  gl->BindTexture (GL_TEXTURE_2D,
+      gst_gl_memory_get_texture_id (effects->intexture));
 
   gst_gl_shader_set_uniform_1f (shader, "alpha", 1.0f);
   gst_gl_shader_set_uniform_1i (shader, "base", 2);
 
   gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D,
+      gst_gl_memory_get_texture_id (effects->midtexture[2]));
 
   gst_gl_shader_set_uniform_1f (shader, "beta", (gfloat) 1 / 3.5f);
   gst_gl_shader_set_uniform_1i (shader, "blend", 1);
-
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[2],
-  gst_gl_filter_draw_fullscreen_quad (filter);
+      effects->outtexture, shader);
-}
-
-void
-gst_gl_effects_glow (GstGLEffects * effects)
-{
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  /* threshold */
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->midtexture[0], gst_gl_effects_glow_step_one, effects);
-
-  /* blur */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[0],
-      effects->midtexture[1], gst_gl_effects_glow_step_two, effects);
-
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[1],
-      effects->midtexture[2], gst_gl_effects_glow_step_three, effects);
-
-  /* add blurred luma to intexture */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[2],
-      effects->outtexture, gst_gl_effects_glow_step_four, effects);
 }

ext/gl/effects/gstgleffectidentity.c

@@ -23,23 +23,13 @@
 
 #include "../gstgleffects.h"
 
-static void
+void
-gst_gl_effects_identity_callback (gint width, gint height, guint texture,
+gst_gl_effects_identity (GstGLEffects * effects)
-    gpointer data)
 {
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
+  GstGLContext *context = GST_GL_BASE_FILTER (effects)->context;
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
   GstGLShader *shader;
 
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
   shader = g_hash_table_lookup (effects->shaderstable, "identity0");
   if (!shader) {
     GError *error = NULL;
@@ -50,28 +40,10 @@ gst_gl_effects_identity_callback (gint width, gint height, guint texture,
       return;
     }
 
-    filter->draw_attr_position_loc =
-        gst_gl_shader_get_attribute_location (shader, "a_position");
-    filter->draw_attr_texture_loc =
-        gst_gl_shader_get_attribute_location (shader, "a_texcoord");
-
     g_hash_table_insert (effects->shaderstable, (gchar *) "identity0", shader);
   }
   gst_gl_shader_use (shader);
 
-  gl->ActiveTexture (GL_TEXTURE0);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+      effects->outtexture, shader);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-void
-gst_gl_effects_identity (GstGLEffects * effects)
-{
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->outtexture, gst_gl_effects_identity_callback, effects);
 }

ext/gl/effects/gstgleffectlaplacian.c

@@ -25,48 +25,28 @@
 
 #include "../gstgleffects.h"
 
-static void
+static gfloat kernel[9] = {
-gst_gl_effects_laplacian_callback (gint width, gint height, guint texture,
+  0.0, -1.0, 0.0,
-    gpointer data)
+  -1.0, 4.0, -1.0,
-{
+  0.0, -1.0, 0.0
-  GstGLShader *shader = NULL;
+};
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "conv0",
-              conv9_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-    static gfloat kernel[9] = { 0.0, -1.0, 0.0,
-      -1.0, 4.0, -1.0,
-      0.0, -1.0, 0.0
-    };
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1f (shader, "height", height);
-    gst_gl_shader_set_uniform_1f (shader, "width", width);
-    gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, kernel);
-    gst_gl_shader_set_uniform_1i (shader, "invert", effects->invert);
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
 
 void
 gst_gl_effects_laplacian (GstGLEffects * effects)
 {
-  gst_gl_filter_render_to_target (GST_GL_FILTER (effects), TRUE,
+  GstGLFilter *filter = GST_GL_FILTER (effects);
-      effects->intexture, effects->outtexture,
+  GstGLShader *shader;
-      gst_gl_effects_laplacian_callback, effects);
+
+  shader = gst_gl_effects_get_fragment_shader (effects, "conv0",
+      conv9_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1f (shader, "height",
+      GST_VIDEO_INFO_HEIGHT (&filter->in_info));
+  gst_gl_shader_set_uniform_1f (shader, "width",
+      GST_VIDEO_INFO_WIDTH (&filter->in_info));
+  gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, kernel);
+  gst_gl_shader_set_uniform_1i (shader, "invert", effects->invert);
+
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectlumatocurve.c

@@ -26,13 +26,13 @@
 
 void
 gst_gl_effects_luma_to_curve (GstGLEffects * effects,
-    const GstGLEffectsCurve * curve,
+    const GstGLEffectsCurve * curve, gint curve_index, GstGLMemory * in_tex,
-    gint curve_index, gint width, gint height, GLuint texture)
+    GstGLMemory * out_tex)
 {
-  GstGLShader *shader;
+  GstGLContext *context = GST_GL_BASE_FILTER (effects)->context;
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
+  const GstGLFuncs *gl = context->gl_vtable;
-  GstGLFuncs *gl = context->gl_vtable;
+  GstGLShader *shader;
 
   shader = gst_gl_effects_get_fragment_shader (effects, "luma_to_curve",
       luma_to_curve_fragment_source_gles2);
@@ -47,112 +47,46 @@ gst_gl_effects_luma_to_curve (GstGLEffects * effects,
   }
 #endif
 
-  gst_gl_shader_use (shader);
-
   if (effects->curve[curve_index] == 0) {
     /* this parameters are needed to have a right, predictable, mapping */
     gl->GenTextures (1, &effects->curve[curve_index]);
 
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (context)) {
-      gl->BindTexture (GL_TEXTURE_1D, effects->curve[curve_index]);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-
-      gl->TexImage1D (GL_TEXTURE_1D, 0, curve->bytes_per_pixel,
-          curve->width, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
-    }
-#endif
-    if (USING_GLES2 (context) || USING_OPENGL3 (context)) {
-      gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-      gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
-          curve->width, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
-    }
-  }
-
-  gl->ActiveTexture (GL_TEXTURE2);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 2);
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->ActiveTexture (GL_TEXTURE1);
-    gl->BindTexture (GL_TEXTURE_1D, effects->curve[curve_index]);
-
-    gst_gl_shader_set_uniform_1i (shader, "curve", 1);
-  }
-#endif
-  if (USING_GLES2 (context) || USING_OPENGL3 (context)) {
-    gl->ActiveTexture (GL_TEXTURE1);
     gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-    gst_gl_shader_set_uniform_1i (shader, "curve", 1);
+    gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
+        curve->width, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
   }
 
-  gst_gl_filter_draw_fullscreen_quad (filter);
+  gst_gl_shader_use (shader);
-}
+  gl->ActiveTexture (GL_TEXTURE2);
+  gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
 
-static void
+  gst_gl_shader_set_uniform_1i (shader, "curve", 2);
-gst_gl_effects_heat_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
 
-  gst_gl_effects_luma_to_curve (effects, &heat_curve, GST_GL_EFFECTS_CURVE_HEAT,
+  gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex, shader);
-      width, height, texture);
 }
 
 void
 gst_gl_effects_heat (GstGLEffects * effects)
 {
-  GstGLFilter *filter = GST_GL_FILTER (effects);
+  gst_gl_effects_luma_to_curve (effects, &heat_curve,
-
+      GST_GL_EFFECTS_CURVE_HEAT, effects->intexture, effects->outtexture);
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->outtexture, gst_gl_effects_heat_callback, effects);
-}
-
-static void
-gst_gl_effects_sepia_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-
-  gst_gl_effects_luma_to_curve (effects, &sepia_curve,
-      GST_GL_EFFECTS_CURVE_SEPIA, width, height, texture);
 }
 
 void
 gst_gl_effects_sepia (GstGLEffects * effects)
 {
-  GstGLFilter *filter = GST_GL_FILTER (effects);
+  gst_gl_effects_luma_to_curve (effects, &sepia_curve,
-
+      GST_GL_EFFECTS_CURVE_SEPIA, effects->intexture, effects->outtexture);
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->outtexture, gst_gl_effects_sepia_callback, effects);
-}
-
-static void
-gst_gl_effects_luma_xpro_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-
-  gst_gl_effects_luma_to_curve (effects, &luma_xpro_curve,
-      GST_GL_EFFECTS_CURVE_LUMA_XPRO, width, height, texture);
 }
 
 void
 gst_gl_effects_luma_xpro (GstGLEffects * effects)
 {
-  GstGLFilter *filter = GST_GL_FILTER (effects);
+  gst_gl_effects_luma_to_curve (effects, &luma_xpro_curve,
-
+      GST_GL_EFFECTS_CURVE_LUMA_XPRO, effects->intexture, effects->outtexture);
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->outtexture, gst_gl_effects_luma_xpro_callback, effects);
 }

ext/gl/effects/gstgleffectlumatocurve.h

@@ -28,8 +28,8 @@ G_BEGIN_DECLS
 void gst_gl_effects_luma_to_curve (GstGLEffects *effects,
                                    const GstGLEffectsCurve *curve,
                                    gint curve_index,
-                                   gint width, gint height,
+                                   GstGLMemory *in_tex,
-                                   GLuint texture);
+                                   GstGLMemory *out_tex);
 G_END_DECLS
 
 #endif /* __GST_GL_LUMA_TO_CURVE_H__ */

ext/gl/effects/gstgleffectmirror.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLFilter *filter = GST_GL_FILTER (data);
-  GstGLEffects *effects = GST_GL_EFFECTS (filter);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "mirror",
-      mirror_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_mirror (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "mirror",
-      effects->outtexture, gst_gl_effects_mirror_callback, effects);
+      mirror_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectrgbtocurve.c

@@ -26,13 +26,13 @@
 
 static void
 gst_gl_effects_rgb_to_curve (GstGLEffects * effects,
-    const GstGLEffectsCurve * curve,
+    const GstGLEffectsCurve * curve, gint curve_index, GstGLMemory * in_tex,
-    gint curve_index, gint width, gint height, GLuint texture)
+    GstGLMemory * out_tex)
 {
-  GstGLShader *shader;
+  GstGLContext *context = GST_GL_BASE_FILTER (effects)->context;
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
+  const GstGLFuncs *gl = context->gl_vtable;
-  GstGLFuncs *gl = context->gl_vtable;
+  GstGLShader *shader;
 
   shader = gst_gl_effects_get_fragment_shader (effects, "rgb_to_curve",
       rgb_to_curve_fragment_source_gles2);
@@ -47,73 +47,32 @@ gst_gl_effects_rgb_to_curve (GstGLEffects * effects,
   }
 #endif
 
-  gst_gl_shader_use (shader);
-
   if (effects->curve[curve_index] == 0) {
     /* this parameters are needed to have a right, predictable, mapping */
     gl->GenTextures (1, &effects->curve[curve_index]);
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (context)) {
-      gl->BindTexture (GL_TEXTURE_1D, effects->curve[curve_index]);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-      gl->TexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
-      gl->TexImage1D (GL_TEXTURE_1D, 0, GL_RGB,
-          curve->width, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
-    }
-#endif
-    if (USING_GLES2 (context) || USING_OPENGL3 (context)) {
-      gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-      gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-      gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
-          curve->width, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
-    }
-  }
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->ActiveTexture (GL_TEXTURE1);
-    gl->BindTexture (GL_TEXTURE_1D, effects->curve[curve_index]);
-
-    gst_gl_shader_set_uniform_1i (shader, "curve", 1);
-  }
-#endif
-  if (USING_GLES2 (context) || USING_OPENGL3 (context)) {
-    gl->ActiveTexture (GL_TEXTURE1);
     gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-    gst_gl_shader_set_uniform_1i (shader, "curve", 1);
+    gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
+        curve->width, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, curve->pixel_data);
   }
 
-  gst_gl_filter_draw_fullscreen_quad (filter);
+  gst_gl_shader_use (shader);
-}
+  gl->ActiveTexture (GL_TEXTURE2);
+  gl->BindTexture (GL_TEXTURE_2D, effects->curve[curve_index]);
 
-static void
+  gst_gl_shader_set_uniform_1i (shader, "curve", 2);
-gst_gl_effects_xpro_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
 
-  gst_gl_effects_rgb_to_curve (effects, &xpro_curve, GST_GL_EFFECTS_CURVE_XPRO,
+  gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex, shader);
-      width, height, texture);
 }
 
 void
 gst_gl_effects_xpro (GstGLEffects * effects)
 {
-  GstGLFilter *filter = GST_GL_FILTER (effects);
+  gst_gl_effects_rgb_to_curve (effects, &xpro_curve, GST_GL_EFFECTS_CURVE_XPRO,
-
+      effects->intexture, effects->outtexture);
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
-      effects->outtexture, gst_gl_effects_xpro_callback, effects);
 }

ext/gl/effects/gstgleffectsin.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_sin_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "sin",
-      sin_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_sin (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "sin",
-      effects->outtexture, gst_gl_effects_sin_callback, effects);
+      sin_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectsobel.c

@@ -25,144 +25,37 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_sobel_callback_desaturate (gint width, gint height,
-    guint texture, gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "desat0",
-              desaturate_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
-static void
-gst_gl_effects_sobel_callback_hconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "hconv0",
-              sep_sobel_hconv3_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1f (shader, "width", width);
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
-static void
-gst_gl_effects_sobel_callback_vconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "vconv0",
-              sep_sobel_vconv3_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1f (shader, "height", height);
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
-static void
-gst_gl_effects_sobel_callback_length (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader = NULL;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-
-  if (NULL != (shader = gst_gl_effects_get_fragment_shader (effects, "len0",
-              sep_sobel_length_fragment_source_gles2))) {
-    GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-#if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (GST_GL_BASE_FILTER (filter)->context)) {
-      gl->MatrixMode (GL_PROJECTION);
-      gl->LoadIdentity ();
-    }
-#endif
-
-    gst_gl_shader_use (shader);
-
-    gl->ActiveTexture (GL_TEXTURE0);
-    gl->BindTexture (GL_TEXTURE_2D, texture);
-
-    gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-    gst_gl_shader_set_uniform_1i (shader, "invert", effects->invert);
-
-    gst_gl_filter_draw_fullscreen_quad (filter);
-  }
-}
-
 void
 gst_gl_effects_sobel (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE,
+  shader = gst_gl_effects_get_fragment_shader (effects, "desat0",
-      effects->intexture, effects->midtexture[0],
+      desaturate_fragment_source_gles2);
-      gst_gl_effects_sobel_callback_desaturate, effects);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
-  gst_gl_filter_render_to_target (filter, FALSE,
+      effects->midtexture[0], shader);
-      effects->midtexture[0], effects->midtexture[1],
+
-      gst_gl_effects_sobel_callback_hconv, effects);
+  shader = gst_gl_effects_get_fragment_shader (effects, "hconv0",
-  gst_gl_filter_render_to_target (filter, FALSE,
+      sep_sobel_hconv3_fragment_source_gles2);
-      effects->midtexture[1], effects->midtexture[0],
+  gst_gl_shader_use (shader);
-      gst_gl_effects_sobel_callback_vconv, effects);
+  gst_gl_shader_set_uniform_1f (shader, "height",
-  gst_gl_filter_render_to_target (filter, FALSE,
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
-      effects->midtexture[0], effects->outtexture,
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[0],
-      gst_gl_effects_sobel_callback_length, effects);
+      effects->midtexture[1], shader);
+
+  shader = gst_gl_effects_get_fragment_shader (effects, "vconv0",
+      sep_sobel_vconv3_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1f (shader, "width",
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[1],
+      effects->midtexture[0], shader);
+
+  shader = gst_gl_effects_get_fragment_shader (effects, "len0",
+      sep_sobel_length_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1i (shader, "invert", effects->invert);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[0],
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectsquare.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_square_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "square",
-      square_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_square (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "square",
-      effects->outtexture, gst_gl_effects_square_callback, effects);
+      square_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectsqueeze.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLFilter *filter = GST_GL_FILTER (data);
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "squeeze",
-      squeeze_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_squeeze (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "squeeze",
-      effects->outtexture, gst_gl_effects_squeeze_callback, effects);
+      squeeze_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectstretch.c

@@ -23,43 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_stretch_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "stretch",
-      stretch_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_stretch (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "stretch",
-      effects->outtexture, gst_gl_effects_stretch_callback, effects);
+      stretch_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffecttunnel.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_tunnel_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "tunnel",
-      tunnel_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_tunnel (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "tunnel",
-      effects->outtexture, gst_gl_effects_tunnel_callback, effects);
+      tunnel_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffecttwirl.c

@@ -23,44 +23,14 @@
 
 #include "../gstgleffects.h"
 
-static void
-gst_gl_effects_twirl_callback (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "twirl",
-      twirl_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
 void
 gst_gl_effects_twirl (GstGLEffects * effects)
 {
   GstGLFilter *filter = GST_GL_FILTER (effects);
+  GstGLShader *shader;
 
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "twirl",
-      effects->outtexture, gst_gl_effects_twirl_callback, effects);
+      twirl_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->outtexture, shader);
 }

ext/gl/effects/gstgleffectxray.c

@@ -28,297 +28,97 @@
 static gboolean kernel_ready = FALSE;
 static float gauss_kernel[7];
 
-static void
+void
-gst_gl_effects_xray_step_one (gint width, gint height, guint texture,
+gst_gl_effects_xray (GstGLEffects * effects)
-    gpointer data)
 {
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (effects)->context->gl_vtable;
-
-  gst_gl_effects_luma_to_curve (effects, &xray_curve, GST_GL_EFFECTS_CURVE_XRAY,
-      width, height, texture);
-}
-
-static void
-gst_gl_effects_xray_step_two (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
+  GstGLShader *shader;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "hconv7",
-      hconv7_fragment_source_gles2);
-
-  if (!shader)
-    return;
 
   if (!kernel_ready) {
     fill_gaussian_kernel (gauss_kernel, 7, 1.5);
     kernel_ready = TRUE;
   }
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, gauss_kernel);
-  gst_gl_shader_set_uniform_1f (shader, "gauss_width", width);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static void
-gst_gl_effects_xray_step_three (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "vconv7",
-      vconv7_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, gauss_kernel);
-  gst_gl_shader_set_uniform_1f (shader, "gauss_height", height);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-/* multipass separable sobel */
-static void
-gst_gl_effects_xray_desaturate (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "desaturate",
-      desaturate_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static void
-gst_gl_effects_xray_sobel_hconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_hconv3",
-      sep_sobel_hconv3_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_shader_set_uniform_1f (shader, "width", width);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static void
-gst_gl_effects_xray_sobel_vconv (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_vconv3",
-      sep_sobel_vconv3_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_shader_set_uniform_1f (shader, "height", height);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static void
-gst_gl_effects_xray_sobel_length (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_length",
-      sep_sobel_length_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (shader, "tex", 1);
-  gst_gl_shader_set_uniform_1i (shader, "invert", TRUE);
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-/* end of sobel passes */
-
-static void
-gst_gl_effects_xray_step_five (gint width, gint height, guint texture,
-    gpointer data)
-{
-  GstGLShader *shader;
-  GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
-
-  shader = gst_gl_effects_get_fragment_shader (effects, "multiply",
-      multiply_fragment_source_gles2);
-
-  if (!shader)
-    return;
-
-#if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (context)) {
-    gl->MatrixMode (GL_PROJECTION);
-    gl->LoadIdentity ();
-  }
-#endif
-
-  gst_gl_shader_use (shader);
-
-  gl->ActiveTexture (GL_TEXTURE2);
-  gl->BindTexture (GL_TEXTURE_2D, effects->midtexture[2]->tex_id);
-
-  gst_gl_shader_set_uniform_1i (shader, "base", 2);
-
-  gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1f (shader, "alpha", (gfloat) 0.5f);
-  gst_gl_shader_set_uniform_1i (shader, "blend", 1);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-void
-gst_gl_effects_xray (GstGLEffects * effects)
-{
-  GstGLFilter *filter = GST_GL_FILTER (effects);
 
   /* map luma to xray curve */
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  gst_gl_effects_luma_to_curve (effects, &xray_curve, GST_GL_EFFECTS_CURVE_XRAY,
-      effects->midtexture[0], gst_gl_effects_xray_step_one, effects);
+      effects->intexture, effects->midtexture[0]);
+
   /* horizontal blur */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[0],
+  shader = gst_gl_effects_get_fragment_shader (effects, "hconv7",
-      effects->midtexture[1], gst_gl_effects_xray_step_two, effects);
+      hconv7_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, gauss_kernel);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_width",
+      GST_VIDEO_INFO_WIDTH (&filter->in_info));
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[0],
+      effects->midtexture[1], shader);
+
   /* vertical blur */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[1],
+  shader = gst_gl_effects_get_fragment_shader (effects, "vconv7",
-      effects->midtexture[2], gst_gl_effects_xray_step_three, effects);
+      vconv7_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1fv (shader, "kernel", 9, gauss_kernel);
+  gst_gl_shader_set_uniform_1f (shader, "gauss_height",
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[1],
+      effects->midtexture[2], shader);
+
   /* detect edges with Sobel */
   /* the old version used edges from the blurred texture, this uses
    * the ones from original texture, still not sure what I like
    * more. This one gives better edges obviously but behaves badly
    * with noise */
   /* desaturate */
-  gst_gl_filter_render_to_target (filter, TRUE, effects->intexture,
+  shader = gst_gl_effects_get_fragment_shader (effects, "desaturate",
-      effects->midtexture[3], gst_gl_effects_xray_desaturate, effects);
+      desaturate_fragment_source_gles2);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->intexture,
+      effects->midtexture[3], shader);
+
   /* horizonal convolution */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[3],
+  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_hconv3",
-      effects->midtexture[4], gst_gl_effects_xray_sobel_hconv, effects);
+      sep_sobel_hconv3_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1f (shader, "width",
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[3],
+      effects->midtexture[4], shader);
+
   /* vertical convolution */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[4],
+  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_vconv3",
-      effects->midtexture[3], gst_gl_effects_xray_sobel_vconv, effects);
+      sep_sobel_vconv3_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1f (shader, "height",
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[4],
+      effects->midtexture[3], shader);
+
   /* gradient length */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[3],
+  shader = gst_gl_effects_get_fragment_shader (effects, "sobel_length",
-      effects->midtexture[4], gst_gl_effects_xray_sobel_length, effects);
+      sep_sobel_length_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+  gst_gl_shader_set_uniform_1i (shader, "invert", TRUE);
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[3],
+      effects->midtexture[4], shader);
+
   /* multiply edges with the blurred image */
-  gst_gl_filter_render_to_target (filter, FALSE, effects->midtexture[4],
+  shader = gst_gl_effects_get_fragment_shader (effects, "multiply",
-      effects->outtexture, gst_gl_effects_xray_step_five, effects);
+      multiply_fragment_source_gles2);
+  gst_gl_shader_use (shader);
+
+  gl->ActiveTexture (GL_TEXTURE2);
+  gl->BindTexture (GL_TEXTURE_2D,
+      gst_gl_memory_get_texture_id (effects->midtexture[2]));
+
+  gst_gl_shader_set_uniform_1i (shader, "base", 2);
+
+  gl->ActiveTexture (GL_TEXTURE1);
+  gl->BindTexture (GL_TEXTURE_2D,
+      gst_gl_memory_get_texture_id (effects->midtexture[4]));
+
+  gst_gl_shader_set_uniform_1f (shader, "alpha", (gfloat) 0.5f);
+  gst_gl_shader_set_uniform_1i (shader, "blend", 1);
+
+  gst_gl_filter_render_to_target_with_shader (filter, effects->midtexture[4],
+      effects->outtexture, shader);
 }

ext/gl/gstglcolorbalance.c

@@ -231,13 +231,11 @@ gst_gl_color_balance_before_transform (GstBaseTransform * base, GstBuffer * buf)
     gst_object_sync_values (GST_OBJECT (balance), stream_time);
 }
 
-static void
+static gboolean
-gst_gl_color_balance_callback (gint width, gint height, guint tex_id,
+gst_gl_color_balance_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
-    gpointer data)
+    GstGLMemory * out_tex)
 {
-  GstGLColorBalance *balance = GST_GL_COLOR_BALANCE (data);
+  GstGLColorBalance *balance = GST_GL_COLOR_BALANCE (filter);
-  GstGLFilter *filter = GST_GL_FILTER (data);
-  const GstGLFuncs *gl = GST_GL_BASE_FILTER (data)->context->gl_vtable;
 
   if (!balance->shader)
     _create_shader (balance);
@@ -252,17 +250,8 @@ gst_gl_color_balance_callback (gint width, gint height, guint tex_id,
   gst_gl_shader_set_uniform_1f (balance->shader, "hue", balance->hue);
   GST_OBJECT_UNLOCK (balance);
 
-  gl->BindTexture (GL_TEXTURE_2D, tex_id);
+  gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex,
-
+      balance->shader);
-  gst_gl_filter_draw_fullscreen_quad (filter);
-}
-
-static gboolean
-gst_gl_color_balance_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
-    GstGLMemory * out_tex)
-{
-  gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
-      (GLCB) gst_gl_color_balance_callback, filter);
 
   return TRUE;
 }

ext/gl/gstglcolorscale.c

@@ -181,7 +181,7 @@ gst_gl_colorscale_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
   GstGLColorscale *colorscale = GST_GL_COLORSCALE (filter);
 
   if (gst_gl_context_get_gl_api (GST_GL_BASE_FILTER (filter)->context))
-    gst_gl_filter_render_to_target_with_shader (filter, TRUE, in_tex, out_tex,
+    gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex,
         colorscale->shader);
 
   return TRUE;

ext/gl/gstgldeinterlace.c

@@ -65,10 +65,10 @@ static gboolean gst_gl_deinterlace_filter (GstGLFilter * filter,
     GstBuffer * inbuf, GstBuffer * outbuf);
 static gboolean gst_gl_deinterlace_filter_texture (GstGLFilter * filter,
     GstGLMemory * in_tex, GstGLMemory * out_tex);
-static void gst_gl_deinterlace_vfir_callback (gint width, gint height,
+static gboolean gst_gl_deinterlace_vfir_callback (GstGLFilter * filter,
-    guint texture, gpointer stuff);
+    GstGLMemory * in_tex, gpointer stuff);
-static void gst_gl_deinterlace_greedyh_callback (gint width, gint height,
+static gboolean gst_gl_deinterlace_greedyh_callback (GstGLFilter * filter,
-    guint texture, gpointer stuff);
+    GstGLMemory * in_tex, gpointer stuff);
 
 /* *INDENT-OFF* */
 static const gchar *greedyh_fragment_source =
@@ -276,7 +276,7 @@ gst_gl_deinterlace_init (GstGLDeinterlace * filter)
   filter->deinterlacefunc = gst_gl_deinterlace_vfir_callback;
   filter->current_method = GST_GL_DEINTERLACE_VFIR;
   filter->prev_buffer = NULL;
-  filter->prev_tex = 0;
+  filter->prev_tex = NULL;
 }
 
 static gboolean
@@ -370,7 +370,7 @@ gst_gl_deinterlace_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
   GstGLDeinterlace *deinterlace_filter = GST_GL_DEINTERLACE (filter);
 
   //blocking call, use a FBO
-  gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
+  gst_gl_filter_render_to_target (filter, in_tex, out_tex,
       deinterlace_filter->deinterlacefunc, deinterlace_filter);
 
   return TRUE;
@@ -424,20 +424,19 @@ gst_gl_deinterlace_get_fragment_shader (GstGLFilter * filter,
   return shader;
 }
 
-static void
+static gboolean
-gst_gl_deinterlace_vfir_callback (gint width, gint height, guint texture,
+gst_gl_deinterlace_vfir_callback (GstGLFilter * filter, GstGLMemory * in_tex,
-    gpointer stuff)
+    gpointer user_data)
 {
-  GstGLShader *shader;
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
-  GstGLFuncs *gl = context->gl_vtable;
+  const GstGLFuncs *gl = context->gl_vtable;
+  GstGLShader *shader;
 
   shader = gst_gl_deinterlace_get_fragment_shader (filter, "vfir",
       vfir_fragment_source);
 
   if (!shader)
-    return;
+    return FALSE;
 
 #if GST_GL_HAVE_OPENGL
   if (USING_OPENGL (context)) {
@@ -449,7 +448,7 @@ gst_gl_deinterlace_vfir_callback (gint width, gint height, guint texture,
   gst_gl_shader_use (shader);
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (shader, "tex", 0);
   gst_gl_shader_set_uniform_1f (shader, "width",
@@ -458,14 +457,15 @@ gst_gl_deinterlace_vfir_callback (gint width, gint height, guint texture,
       GST_VIDEO_INFO_HEIGHT (&filter->out_info));
 
   gst_gl_filter_draw_fullscreen_quad (filter);
+
+  return TRUE;
 }
 
-static void
+static gboolean
-gst_gl_deinterlace_greedyh_callback (gint width, gint height, guint texture,
+gst_gl_deinterlace_greedyh_callback (GstGLFilter * filter, GstGLMemory * in_tex,
-    gpointer stuff)
+    gpointer user_data)
 {
   GstGLShader *shader;
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLDeinterlace *deinterlace_filter = GST_GL_DEINTERLACE (filter);
   GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
   GstGLFuncs *gl = context->gl_vtable;
@@ -475,7 +475,7 @@ gst_gl_deinterlace_greedyh_callback (gint width, gint height, guint texture,
       greedyh_fragment_source);
 
   if (!shader)
-    return;
+    return FALSE;
 
 #if GST_GL_HAVE_OPENGL
   if (USING_OPENGL (context)) {
@@ -486,14 +486,15 @@ gst_gl_deinterlace_greedyh_callback (gint width, gint height, guint texture,
 
   gst_gl_shader_use (shader);
 
-  if (G_LIKELY (deinterlace_filter->prev_tex != 0)) {
+  if (G_LIKELY (deinterlace_filter->prev_tex != NULL)) {
     gl->ActiveTexture (GL_TEXTURE1);
     gst_gl_shader_set_uniform_1i (shader, "tex_prev", 1);
-    gl->BindTexture (GL_TEXTURE_2D, deinterlace_filter->prev_tex);
+    gl->BindTexture (GL_TEXTURE_2D,
+        gst_gl_memory_get_texture_id (deinterlace_filter->prev_tex));
   }
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (shader, "tex", 0);
   gst_gl_shader_set_uniform_1f (shader, "max_comb", 5.0f / 255.0f);
@@ -508,5 +509,7 @@ gst_gl_deinterlace_greedyh_callback (gint width, gint height, guint texture,
   gst_gl_filter_draw_fullscreen_quad (filter);
 
   /* we keep the previous buffer around so this is safe */
-  deinterlace_filter->prev_tex = texture;
+  deinterlace_filter->prev_tex = in_tex;
+
+  return TRUE;
 }

ext/gl/gstgldeinterlace.h

@@ -39,14 +39,14 @@ typedef struct _GstGLDeinterlaceClass GstGLDeinterlaceClass;
 
 struct _GstGLDeinterlace
 {
-  GstGLFilter  filter;
+  GstGLFilter               filter;
 
-  GLCB	       deinterlacefunc; 
+  GstGLFilterRenderFunc     deinterlacefunc; 
-  GHashTable   *shaderstable;
+  GHashTable               *shaderstable;
-  GstBuffer    *prev_buffer;
+  GstBuffer                *prev_buffer;
-  guint         prev_tex;
+  GstGLMemory *             prev_tex;
 
-  gint	       current_method;
+  gint	                    current_method;
 };
 
 struct _GstGLDeinterlaceClass

ext/gl/gstgldifferencematte.c

@@ -319,87 +319,90 @@ init_pixbuf_texture (GstGLDifferenceMatte * differencematte)
   gst_object_unref (tex_alloc);
 }
 
-static void
+static gboolean
-gst_gl_differencematte_diff (gint width, gint height, guint texture,
+gst_gl_differencematte_diff (GstGLFilter * filter, GstGLMemory * in_tex,
     gpointer stuff)
 {
-  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
+  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-  GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
 
   gst_gl_shader_use (differencematte->shader[0]);
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (differencematte->shader[0], "current", 0);
 
   gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, differencematte->savedbgtexture->tex_id);
+  gl->BindTexture (GL_TEXTURE_2D,
+      gst_gl_memory_get_texture_id (differencematte->savedbgtexture));
 
   gst_gl_shader_set_uniform_1i (differencematte->shader[0], "saved", 1);
 
   gst_gl_filter_draw_fullscreen_quad (filter);
+
+  return TRUE;
 }
 
-static void
+static gboolean
-gst_gl_differencematte_hblur (gint width, gint height, guint texture,
+gst_gl_differencematte_hblur (GstGLFilter * filter, GstGLMemory * in_tex,
     gpointer stuff)
 {
-  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
+  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-  GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
 
   gst_gl_shader_use (differencematte->shader[1]);
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (differencematte->shader[1], "tex", 0);
 
   gst_gl_shader_set_uniform_1fv (differencematte->shader[1], "kernel", 7,
       differencematte->kernel);
   gst_gl_shader_set_uniform_1f (differencematte->shader[1], "gauss_width",
-      width);
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
 
   gst_gl_filter_draw_fullscreen_quad (filter);
+
+  return TRUE;
 }
 
-static void
+static gboolean
-gst_gl_differencematte_vblur (gint width, gint height, guint texture,
+gst_gl_differencematte_vblur (GstGLFilter * filter, GstGLMemory * in_tex,
     gpointer stuff)
 {
-  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
+  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-  GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
 
   gst_gl_shader_use (differencematte->shader[2]);
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (differencematte->shader[2], "tex", 0);
 
   gst_gl_shader_set_uniform_1fv (differencematte->shader[2], "kernel", 7,
       differencematte->kernel);
   gst_gl_shader_set_uniform_1f (differencematte->shader[2], "gauss_height",
-      height);
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
 
   gst_gl_filter_draw_fullscreen_quad (filter);
+
+  return TRUE;
 }
 
-static void
+static gboolean
-gst_gl_differencematte_interp (gint width, gint height, guint texture,
+gst_gl_differencematte_interp (GstGLFilter * filter, GstGLMemory * in_tex,
     gpointer stuff)
 {
-  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
+  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
+  const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-  GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
 
   gst_gl_shader_use (differencematte->shader[3]);
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (differencematte->shader[3], "blend", 0);
 
@@ -414,24 +417,8 @@ gst_gl_differencematte_interp (gint width, gint height, guint texture,
   gst_gl_shader_set_uniform_1i (differencematte->shader[3], "alpha", 2);
 
   gst_gl_filter_draw_fullscreen_quad (filter);
-}
 
-static void
+  return TRUE;
-gst_gl_differencematte_identity (gint width, gint height, guint texture,
-    gpointer stuff)
-{
-  GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
-  GstGLFilter *filter = GST_GL_FILTER (differencematte);
-  GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
-
-  gst_gl_shader_use (differencematte->identity_shader);
-
-  gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
-
-  gst_gl_shader_set_uniform_1i (differencematte->identity_shader, "tex", 0);
-
-  gst_gl_filter_draw_fullscreen_quad (filter);
 }
 
 static gboolean
@@ -451,9 +438,8 @@ gst_gl_differencematte_filter_texture (GstGLFilter * filter,
 
     /* save current frame, needed to calculate difference between
      * this frame and next ones */
-    gst_gl_filter_render_to_target (filter, TRUE, in_tex,
+    gst_gl_filter_render_to_target_with_shader (filter, in_tex,
-        differencematte->savedbgtexture,
+        differencematte->savedbgtexture, differencematte->identity_shader);
-        gst_gl_differencematte_identity, differencematte);
 
     if (differencematte->pixbuf) {
       free (differencematte->pixbuf);
@@ -464,20 +450,17 @@ gst_gl_differencematte_filter_texture (GstGLFilter * filter,
   }
 
   if (differencematte->savedbgtexture != NULL) {
-    gst_gl_filter_render_to_target (filter, TRUE, in_tex,
+    gst_gl_filter_render_to_target (filter, in_tex,
-        differencematte->midtexture[0], gst_gl_differencematte_diff,
+        differencematte->midtexture[0], gst_gl_differencematte_diff, NULL);
-        differencematte);
+    gst_gl_filter_render_to_target (filter, differencematte->midtexture[0],
-    gst_gl_filter_render_to_target (filter, FALSE,
+        differencematte->midtexture[1], gst_gl_differencematte_hblur, NULL);
-        differencematte->midtexture[0], differencematte->midtexture[1],
+    gst_gl_filter_render_to_target (filter, differencematte->midtexture[1],
-        gst_gl_differencematte_hblur, differencematte);
+        differencematte->midtexture[2], gst_gl_differencematte_vblur, NULL);
-    gst_gl_filter_render_to_target (filter, FALSE,
+    gst_gl_filter_render_to_target (filter, in_tex, out_tex,
-        differencematte->midtexture[1], differencematte->midtexture[2],
+        gst_gl_differencematte_interp, NULL);
-        gst_gl_differencematte_vblur, differencematte);
-    gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
-        gst_gl_differencematte_interp, differencematte);
   } else {
-    gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
+    gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex,
-        gst_gl_differencematte_identity, differencematte);
+        differencematte->identity_shader);
   }
 
   return TRUE;

ext/gl/gstglfilterapp.c

@@ -221,7 +221,7 @@ gst_gl_filter_app_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
       out_tex, _emit_draw_signal, &cb);
 
   if (default_draw) {
-    gst_gl_filter_render_to_target_with_shader (filter, TRUE, in_tex, out_tex,
+    gst_gl_filter_render_to_target_with_shader (filter, in_tex, out_tex,
         filter->default_shader);
   }
 

ext/gl/gstglfiltershader.c

@@ -83,8 +83,8 @@ static gboolean gst_gl_filtershader_filter (GstGLFilter * filter,
     GstBuffer * inbuf, GstBuffer * outbuf);
 static gboolean gst_gl_filtershader_filter_texture (GstGLFilter * filter,
     GstGLMemory * in_tex, GstGLMemory * out_tex);
-static void gst_gl_filtershader_hcallback (gint width, gint height,
+static gboolean gst_gl_filtershader_hcallback (GstGLFilter * filter,
-    guint texture, gpointer stuff);
+    GstGLMemory * in_tex, gpointer stuff);
 
 static void
 gst_gl_filtershader_class_init (GstGLFilterShaderClass * klass)
@@ -318,8 +318,8 @@ gst_gl_filtershader_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
 {
   GstGLFilterShader *filtershader = GST_GL_FILTERSHADER (filter);
 
-  gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
+  gst_gl_filter_render_to_target (filter, in_tex, out_tex,
-      gst_gl_filtershader_hcallback, filtershader);
+      gst_gl_filtershader_hcallback, NULL);
 
   if (!filtershader->shader)
     return FALSE;
@@ -493,17 +493,16 @@ print_error:
   return NULL;
 }
 
-static void
+static gboolean
-gst_gl_filtershader_hcallback (gint width, gint height, guint texture,
+gst_gl_filtershader_hcallback (GstGLFilter * filter, GstGLMemory * in_tex,
     gpointer stuff)
 {
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterShader *filtershader = GST_GL_FILTERSHADER (filter);
   GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
   GstGLShader *shader;
 
   if (!(shader = _maybe_recompile_shader (filtershader)))
-    return;
+    return FALSE;
 
   gl->ClearColor (0.0, 0.0, 0.0, 1.0);
   gl->Clear (GL_COLOR_BUFFER_BIT);
@@ -512,8 +511,10 @@ gst_gl_filtershader_hcallback (gint width, gint height, guint texture,
 
   /* FIXME: propertise these */
   gst_gl_shader_set_uniform_1i (shader, "tex", 0);
-  gst_gl_shader_set_uniform_1f (shader, "width", width);
+  gst_gl_shader_set_uniform_1f (shader, "width",
-  gst_gl_shader_set_uniform_1f (shader, "height", height);
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
+  gst_gl_shader_set_uniform_1f (shader, "height",
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
   gst_gl_shader_set_uniform_1f (shader, "time", filtershader->time);
 
   /* FIXME: propertise these */
@@ -523,9 +524,11 @@ gst_gl_filtershader_hcallback (gint width, gint height, guint texture,
       gst_gl_shader_get_attribute_location (shader, "a_texcoord");
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_filter_draw_fullscreen_quad (filter);
 
   gst_object_unref (shader);
+
+  return TRUE;
 }

ext/gl/gstgloverlay.c

@@ -372,29 +372,31 @@ gst_gl_overlay_set_caps (GstGLFilter * filter, GstCaps * incaps,
 static void
 _unbind_buffer (GstGLOverlay * overlay)
 {
+  GstGLFilter *filter = GST_GL_FILTER (overlay);
   const GstGLFuncs *gl = GST_GL_BASE_FILTER (overlay)->context->gl_vtable;
 
   gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
   gl->BindBuffer (GL_ARRAY_BUFFER, 0);
 
-  gl->DisableVertexAttribArray (overlay->attr_position);
+  gl->DisableVertexAttribArray (filter->draw_attr_position_loc);
-  gl->DisableVertexAttribArray (overlay->attr_texture);
+  gl->DisableVertexAttribArray (filter->draw_attr_texture_loc);
 }
 
 static void
 _bind_buffer (GstGLOverlay * overlay, GLuint vbo)
 {
+  GstGLFilter *filter = GST_GL_FILTER (overlay);
   const GstGLFuncs *gl = GST_GL_BASE_FILTER (overlay)->context->gl_vtable;
 
   gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->vbo_indices);
   gl->BindBuffer (GL_ARRAY_BUFFER, vbo);
 
-  gl->EnableVertexAttribArray (overlay->attr_position);
+  gl->EnableVertexAttribArray (filter->draw_attr_position_loc);
-  gl->EnableVertexAttribArray (overlay->attr_texture);
+  gl->EnableVertexAttribArray (filter->draw_attr_texture_loc);
 
-  gl->VertexAttribPointer (overlay->attr_position, 3, GL_FLOAT,
+  gl->VertexAttribPointer (filter->draw_attr_position_loc, 3, GL_FLOAT,
       GL_FALSE, 5 * sizeof (GLfloat), (void *) 0);
-  gl->VertexAttribPointer (overlay->attr_texture, 2, GL_FLOAT,
+  gl->VertexAttribPointer (filter->draw_attr_texture_loc, 2, GL_FLOAT,
       GL_FALSE, 5 * sizeof (GLfloat), (void *) (3 * sizeof (GLfloat)));
 }
 
@@ -410,15 +412,16 @@ float v_vertices[] = {
 static const GLushort indices[] = { 0, 1, 2, 0, 2, 3, };
 /* *INDENT-ON* */
 
-static void
+static gboolean
-gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
+gst_gl_overlay_callback (GstGLFilter * filter, GstGLMemory * in_tex,
+    gpointer stuff)
 {
-  GstGLOverlay *overlay = GST_GL_OVERLAY (stuff);
+  GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
-  GstGLFilter *filter = GST_GL_FILTER (overlay);
   GstMapInfo map_info;
   guint image_tex;
   gboolean memory_mapped = FALSE;
   const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable;
+  gboolean ret = FALSE;
 
 #if GST_GL_HAVE_OPENGL
   if (gst_gl_context_get_gl_api (GST_GL_BASE_FILTER (filter)->context) &
@@ -430,49 +433,19 @@ gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
 #endif
 
   gl->ActiveTexture (GL_TEXTURE0);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_use (overlay->shader);
 
   gst_gl_shader_set_uniform_1f (overlay->shader, "alpha", 1.0f);
   gst_gl_shader_set_uniform_1i (overlay->shader, "texture", 0);
 
-  overlay->attr_position =
+  filter->draw_attr_position_loc =
       gst_gl_shader_get_attribute_location (overlay->shader, "a_position");
-  overlay->attr_texture =
+  filter->draw_attr_texture_loc =
       gst_gl_shader_get_attribute_location (overlay->shader, "a_texcoord");
 
-  if (!overlay->vbo) {
+  gst_gl_filter_draw_fullscreen_quad (filter);
-    if (gl->GenVertexArrays) {
-      gl->GenVertexArrays (1, &overlay->vao);
-      gl->BindVertexArray (overlay->vao);
-    }
-
-    gl->GenBuffers (1, &overlay->vbo);
-    gl->BindBuffer (GL_ARRAY_BUFFER, overlay->vbo);
-    gl->BufferData (GL_ARRAY_BUFFER, 4 * 5 * sizeof (GLfloat), v_vertices,
-        GL_STATIC_DRAW);
-
-    gl->GenBuffers (1, &overlay->vbo_indices);
-    gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->vbo_indices);
-    gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices,
-        GL_STATIC_DRAW);
-
-    if (gl->GenVertexArrays) {
-      _bind_buffer (overlay, overlay->vbo);
-      gl->BindVertexArray (0);
-    }
-
-    gl->BindBuffer (GL_ARRAY_BUFFER, 0);
-    gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
-  }
-
-  if (gl->GenVertexArrays)
-    gl->BindVertexArray (overlay->vao);
-  else
-    _bind_buffer (overlay, overlay->vbo);
-
-  gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 
   if (!overlay->image_memory)
     goto out;
@@ -490,6 +463,11 @@ gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
       gl->BindVertexArray (overlay->overlay_vao);
     }
 
+    gl->GenBuffers (1, &overlay->vbo_indices);
+    gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->vbo_indices);
+    gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices,
+        GL_STATIC_DRAW);
+
     gl->GenBuffers (1, &overlay->overlay_vbo);
     gl->BindBuffer (GL_ARRAY_BUFFER, overlay->overlay_vbo);
     gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->vbo_indices);
@@ -553,6 +531,7 @@ gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
   gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 
   gl->Disable (GL_BLEND);
+  ret = TRUE;
 
 out:
   if (gl->GenVertexArrays) {
@@ -567,6 +546,8 @@ out:
     gst_memory_unmap ((GstMemory *) overlay->image_memory, &map_info);
 
   overlay->geometry_change = FALSE;
+
+  return ret;
 }
 
 static gboolean
@@ -641,7 +622,7 @@ gst_gl_overlay_filter_texture (GstGLFilter * filter, GstGLMemory * in_tex,
     overlay->location_has_changed = FALSE;
   }
 
-  gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
+  gst_gl_filter_render_to_target (filter, in_tex, out_tex,
       gst_gl_overlay_callback, overlay);
 
   return TRUE;

gst-libs/gst/gl/gstglfilter.c

@@ -996,66 +996,46 @@ gst_gl_filter_transform (GstBaseTransform * bt, GstBuffer * inbuf,
   return ret ? GST_FLOW_OK : GST_FLOW_ERROR;
 }
 
-struct glcb2
+struct glcb
 {
-  GLCB func;
+  GstGLFilter *filter;
+  GstGLFilterRenderFunc func;
+  GstGLMemory *in_tex;
   gpointer data;
-  guint texture;
-  guint width;
-  guint height;
 };
 
-/* convenience functions to simplify filter development */
 static gboolean
-_glcb2 (gpointer data)
+_glcb (gpointer data)
 {
-  struct glcb2 *cb = data;
+  struct glcb *cb = data;
 
-  cb->func (cb->width, cb->height, cb->texture, cb->data);
+  return cb->func (cb->filter, cb->in_tex, cb->data);
-
-  return TRUE;
 }
 
 /**
  * gst_gl_filter_render_to_target:
  * @filter: a #GstGLFilter
- * @resize: whether to automatically resize the texture between the input size
- *          and the output size
  * @input: the input texture
- * @target: the output texture
+ * @output: the output texture
  * @func: the function to transform @input into @output. called with @data
  * @data: the data associated with @func
  *
- * Transforms @input into @output using @func on through FBO.  @resize should
+ * Transforms @input into @output using @func on through FBO.
- * only ever be %TRUE whenever @input is the input texture of @filter.
+ *
+ * Returns: the return value of @func
  */
-void
+gboolean
-gst_gl_filter_render_to_target (GstGLFilter * filter, gboolean resize,
+gst_gl_filter_render_to_target (GstGLFilter * filter, GstGLMemory * input,
-    GstGLMemory * input, GstGLMemory * output, GLCB func, gpointer data)
+    GstGLMemory * output, GstGLFilterRenderFunc func, gpointer data)
 {
-  guint in_width, in_height, out_width, out_height;
+  struct glcb cb;
-  struct glcb2 cb;
-
-  out_width = GST_VIDEO_INFO_WIDTH (&filter->out_info);
-  out_height = GST_VIDEO_INFO_HEIGHT (&filter->out_info);
-  if (resize) {
-    in_width = GST_VIDEO_INFO_WIDTH (&filter->in_info);
-    in_height = GST_VIDEO_INFO_HEIGHT (&filter->in_info);
-  } else {
-    in_width = out_width;
-    in_height = out_height;
-  }
-
-  GST_LOG ("rendering to target. in %u, %ux%u out %u, %ux%u", input->tex_id,
-      in_width, in_height, output->tex_id, out_width, out_height);
 
+  cb.filter = filter;
   cb.func = func;
+  cb.in_tex = input;
   cb.data = data;
-  cb.texture = input->tex_id;
-  cb.width = in_width;
-  cb.height = in_height;
 
-  gst_gl_framebuffer_draw_to_texture (filter->fbo, output, _glcb2, &cb);
+  return gst_gl_framebuffer_draw_to_texture (filter->fbo, output, _glcb, &cb);
 }
 
 static void
@@ -1080,10 +1060,10 @@ _get_attributes (GstGLFilter * filter)
   filter->valid_attributes = TRUE;
 }
 
-static void
+static gboolean
-_draw_with_shader_cb (gint width, gint height, guint texture, gpointer stuff)
+_draw_with_shader_cb (GstGLFilter * filter, GstGLMemory * in_tex,
+    gpointer unused)
 {
-  GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLContext *context = GST_GL_BASE_FILTER (filter)->context;
   GstGLFuncs *gl = context->gl_vtable;
 
@@ -1098,26 +1078,27 @@ _draw_with_shader_cb (gint width, gint height, guint texture, gpointer stuff)
   gst_gl_shader_use (filter->default_shader);
 
   gl->ActiveTexture (GL_TEXTURE1);
-  gl->BindTexture (GL_TEXTURE_2D, texture);
+  gl->BindTexture (GL_TEXTURE_2D, gst_gl_memory_get_texture_id (in_tex));
 
   gst_gl_shader_set_uniform_1i (filter->default_shader, "tex", 1);
-  gst_gl_shader_set_uniform_1f (filter->default_shader, "width", width);
+  gst_gl_shader_set_uniform_1f (filter->default_shader, "width",
-  gst_gl_shader_set_uniform_1f (filter->default_shader, "height", height);
+      GST_VIDEO_INFO_WIDTH (&filter->out_info));
+  gst_gl_shader_set_uniform_1f (filter->default_shader, "height",
+      GST_VIDEO_INFO_HEIGHT (&filter->out_info));
 
   gst_gl_filter_draw_fullscreen_quad (filter);
+
+  return TRUE;
 }
 
 /**
  * gst_gl_filter_render_to_target_with_shader:
  * @filter: a #GstGLFilter
- * @resize: whether to automatically resize the texture between the input size
- *          and the output size
  * @input: the input texture
- * @target: the output texture
+ * @output: the output texture
  * @shader: the shader to use.
  *
- * Transforms @input into @output using @shader on FBO.  @resize should
+ * Transforms @input into @output using @shader with a FBO.
- * only ever be %TRUE whenever @input is the input texture of @filter.
  *
  * See also: gst_gl_filter_render_to_target()
  */
@@ -1125,15 +1106,14 @@ _draw_with_shader_cb (gint width, gint height, guint texture, gpointer stuff)
  * the shader, render input to a quad */
 void
 gst_gl_filter_render_to_target_with_shader (GstGLFilter * filter,
-    gboolean resize, GstGLMemory * input, GstGLMemory * output,
+    GstGLMemory * input, GstGLMemory * output, GstGLShader * shader)
-    GstGLShader * shader)
 {
   if (filter->default_shader != shader)
     filter->valid_attributes = FALSE;
   filter->default_shader = shader;
 
-  gst_gl_filter_render_to_target (filter, resize, input, output,
+  gst_gl_filter_render_to_target (filter, input, output, _draw_with_shader_cb,
-      _draw_with_shader_cb, filter);
+      NULL);
 }
 
 /* *INDENT-OFF* */

gst-libs/gst/gl/gstglfilter.h

@@ -38,6 +38,8 @@ GType gst_gl_filter_get_type(void);
 #define GST_IS_GL_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_GL_FILTER))
 #define GST_GL_FILTER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_GL_FILTER,GstGLFilterClass))
 
+typedef gboolean (*GstGLFilterRenderFunc) (GstGLFilter * filter, GstGLMemory * in_tex, gpointer user_data);
+
 /**
  * GstGLFilter:
  * @base_transform: parent #GstBaseTransform
@@ -117,16 +119,14 @@ struct _GstGLFilterClass
 gboolean gst_gl_filter_filter_texture (GstGLFilter * filter, GstBuffer * inbuf,
                                        GstBuffer * outbuf);
 
-void gst_gl_filter_render_to_target                 (GstGLFilter *filter,
+gboolean gst_gl_filter_render_to_target             (GstGLFilter *filter,
-                                                     gboolean resize,
                                                      GstGLMemory * input,
                                                      GstGLMemory * output,
-                                                     GLCB func,
+                                                     GstGLFilterRenderFunc func,
                                                      gpointer data);
 
 void gst_gl_filter_draw_fullscreen_quad             (GstGLFilter *filter);
 void gst_gl_filter_render_to_target_with_shader     (GstGLFilter * filter,
-                                                     gboolean resize,
                                                      GstGLMemory * input,
                                                      GstGLMemory * output,
                                                      GstGLShader *shader);

gst-libs/gst/gl/gstglpixelformat.c

@@ -0,0 +1,23 @@
+/*
+ * GStreamer
+ * Copyright (C) 2015 Matthew Waters <matthew@centricular.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., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif

gst-libs/gst/gl/gstglutils.h

@@ -28,27 +28,6 @@
 
 G_BEGIN_DECLS
 
-/**
- * CDCB:
- * @texture: texture to draw
- * @width: new width
- * @height: new height:
- * @data: user data
- *
- * client draw callback
- */
-typedef gboolean (*CDCB) (GLuint texture, GLuint width, GLuint height, gpointer data);
-/**
- * GLCB:
- * @width: the width
- * @height: the height
- * @texture: texture
- * @stuff: user data
- *
- * callback definition for operating on textures
- */
-typedef void (*GLCB) (gint, gint, guint, gpointer stuff);
-
 gboolean gst_gl_context_gen_shader (GstGLContext * context,
     const gchar * shader_vertex_source,
     const gchar * shader_fragment_source, GstGLShader ** shader);