move the GL vtable from GstGLDisplay to GstGLContext

Conflicts:
	tests/check/libs/gstglcontext.c

32 files changed, 318 insertions, 327 deletions

diff --git a/gst/gl/effects/gstgleffectbulge.c b/gst/gl/effects/gstgleffectbulge.c
index 02934e6..80b85a9 100644
--- a/gst/gl/effects/gstgleffectbulge.c
+++ b/gst/gl/effects/gstgleffectbulge.c
@@ -29,21 +29,21 @@ gst_gl_effects_bulge_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "bulge0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "bulge0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           bulge_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize bulge shader");
+    gst_gl_context_set_error (context, "Failed to initialize bulge shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectfisheye.c b/gst/gl/effects/gstgleffectfisheye.c
index 801f62b..8f38f46 100644
--- a/gst/gl/effects/gstgleffectfisheye.c
+++ b/gst/gl/effects/gstgleffectfisheye.c
@@ -29,21 +29,21 @@ gst_gl_effects_fisheye_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "fisheye0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "fisheye0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           fisheye_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize fisheye shader");
+    gst_gl_context_set_error (context, "Failed to initialize fisheye shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectglow.c b/gst/gl/effects/gstgleffectglow.c
index b3488c9..109f3a1 100644
--- a/gst/gl/effects/gstgleffectglow.c
+++ b/gst/gl/effects/gstgleffectglow.c
@@ -32,22 +32,22 @@ gst_gl_effects_glow_step_one (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "glow0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "glow0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           luma_threshold_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize luma threshold shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -71,13 +71,13 @@ gst_gl_effects_glow_step_two (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "glow1");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "glow1", shader);
   }
 
@@ -88,9 +88,9 @@ gst_gl_effects_glow_step_two (gint width, gint height, guint texture,
 
   if (!gst_gl_shader_compile_and_check (shader,
           hconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize hconv7 shader");
+    gst_gl_context_set_error (context, "Failed to initialize hconv7 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -116,21 +116,21 @@ gst_gl_effects_glow_step_three (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "glow2");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "glow2", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           vconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize vcon7 shader");
+    gst_gl_context_set_error (context, "Failed to initialize vcon7 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -156,21 +156,21 @@ gst_gl_effects_glow_step_four (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "glow3");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "glow3", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           sum_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize sum shader");
+    gst_gl_context_set_error (context, "Failed to initialize sum shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectidentity.c b/gst/gl/effects/gstgleffectidentity.c
index c55b1a2..7f36325 100644
--- a/gst/gl/effects/gstgleffectidentity.c
+++ b/gst/gl/effects/gstgleffectidentity.c
@@ -23,11 +23,11 @@
 
 #include "../gstgleffects.h"
 
-#define USING_OPENGL(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL)
-#define USING_OPENGL3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL3)
-#define USING_GLES(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES)
-#define USING_GLES2(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES2)
-#define USING_GLES3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES3)
+#define USING_OPENGL(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL)
+#define USING_OPENGL3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL3)
+#define USING_GLES(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES)
+#define USING_GLES2(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2)
+#define USING_GLES3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES3)
 
 static void
 gst_gl_effects_identity_callback (gint width, gint height, guint texture,
@@ -35,22 +35,22 @@ gst_gl_effects_identity_callback (gint width, gint height, guint texture,
 {
   GstGLEffects *effects = GST_GL_EFFECTS (data);
   GstGLFilter *filter = GST_GL_FILTER (effects);
-  GstGLDisplay *display = filter->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = filter->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (display)) {
+  if (USING_OPENGL (context)) {
     gl->MatrixMode (GL_PROJECTION);
     gl->LoadIdentity ();
   }
 #endif
 #if GST_GL_HAVE_GLES2
-  if (USING_GLES2 (display)) {
+  if (USING_GLES2 (context)) {
     GstGLShader *shader =
         g_hash_table_lookup (effects->shaderstable, "identity0");
 
     if (!shader) {
-      shader = gst_gl_shader_new (display);
+      shader = gst_gl_shader_new (context);
       g_hash_table_insert (effects->shaderstable, "identity0", shader);
 
       if (shader) {
diff --git a/gst/gl/effects/gstgleffectlumatocurve.c b/gst/gl/effects/gstgleffectlumatocurve.c
index 8847bce..5100681 100644
--- a/gst/gl/effects/gstgleffectlumatocurve.c
+++ b/gst/gl/effects/gstgleffectlumatocurve.c
@@ -30,22 +30,22 @@ gst_gl_effects_luma_to_curve (GstGLEffects * effects,
     gint curve_index, gint width, gint height, GLuint texture)
 {
   GstGLShader *shader;
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "lumamap0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "lumamap0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           luma_to_curve_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize luma to curve shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectmirror.c b/gst/gl/effects/gstgleffectmirror.c
index 2ec225c..548e833 100644
--- a/gst/gl/effects/gstgleffectmirror.c
+++ b/gst/gl/effects/gstgleffectmirror.c
@@ -23,11 +23,11 @@
 
 #include "../gstgleffects.h"
 
-#define USING_OPENGL(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL)
-#define USING_OPENGL3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL3)
-#define USING_GLES(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES)
-#define USING_GLES2(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES2)
-#define USING_GLES3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES3)
+#define USING_OPENGL(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL)
+#define USING_OPENGL3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL3)
+#define USING_GLES(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES)
+#define USING_GLES2(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2)
+#define USING_GLES3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES3)
 
 static void
 gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
@@ -36,17 +36,17 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
   GstGLShader *shader;
   GstGLFilter *filter = GST_GL_FILTER (data);
   GstGLEffects *effects = GST_GL_EFFECTS (filter);
-  GstGLDisplay *display = filter->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = filter->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "mirror0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "mirror0", shader);
 
 #if GST_GL_HAVE_GLES2
-    if (USING_GLES2 (display)) {
+    if (USING_GLES2 (context)) {
       if (shader) {
         GError *error = NULL;
         gst_gl_shader_set_vertex_source (shader, vertex_shader_source);
@@ -55,13 +55,13 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
 
         gst_gl_shader_compile (shader, &error);
         if (error) {
-          gst_gl_display_set_error (display,
+          gst_gl_context_set_error (context,
               "Failed to initialize mirror shader, %s", error->message);
           g_error_free (error);
           error = NULL;
           gst_gl_shader_use (NULL);
           GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-              ("%s", gst_gl_display_get_error ()), (NULL));
+              ("%s", gst_gl_context_get_error ()), (NULL));
         } else {
           effects->draw_attr_position_loc =
               gst_gl_shader_get_attribute_location (shader, "a_position");
@@ -72,13 +72,13 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
     }
 #endif
 #if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (display)) {
+    if (USING_OPENGL (context)) {
       if (!gst_gl_shader_compile_and_check (shader,
               mirror_fragment_source_opengl, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-        gst_gl_display_set_error (display,
+        gst_gl_context_set_error (context,
             "Failed to initialize mirror shader");
         GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-            ("%s", gst_gl_display_get_error ()), (NULL));
+            ("%s", gst_gl_context_get_error ()), (NULL));
         return;
       }
 
@@ -86,7 +86,7 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
 #endif
   }
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (display)) {
+  if (USING_OPENGL (context)) {
     gl->MatrixMode (GL_PROJECTION);
     gl->LoadIdentity ();
   }
@@ -101,7 +101,7 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
   gst_gl_shader_set_uniform_1i (shader, "tex", 0);
 
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (filter->display)) {
+  if (USING_OPENGL (filter->context)) {
     gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f);
     gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f);
   }
diff --git a/gst/gl/effects/gstgleffectrgbtocurve.c b/gst/gl/effects/gstgleffectrgbtocurve.c
index f268187..e07c516 100644
--- a/gst/gl/effects/gstgleffectrgbtocurve.c
+++ b/gst/gl/effects/gstgleffectrgbtocurve.c
@@ -30,22 +30,22 @@ gst_gl_effects_rgb_to_curve (GstGLEffects * effects,
     gint curve_index, gint width, gint height, GLuint texture)
 {
   GstGLShader *shader;
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "rgbmap0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "rgbmap0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           rgb_to_curve_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize rgb to curve shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectsin.c b/gst/gl/effects/gstgleffectsin.c
index f546085..7875757 100644
--- a/gst/gl/effects/gstgleffectsin.c
+++ b/gst/gl/effects/gstgleffectsin.c
@@ -29,21 +29,21 @@ gst_gl_effects_sin_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "sin0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "sin0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           sin_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize sin shader");
+    gst_gl_context_set_error (context, "Failed to initialize sin shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectsquare.c b/gst/gl/effects/gstgleffectsquare.c
index 0d8312a..afb13dd 100644
--- a/gst/gl/effects/gstgleffectsquare.c
+++ b/gst/gl/effects/gstgleffectsquare.c
@@ -29,21 +29,21 @@ gst_gl_effects_square_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "square0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "square0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           square_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize square shader");
+    gst_gl_context_set_error (context, "Failed to initialize square shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectsqueeze.c b/gst/gl/effects/gstgleffectsqueeze.c
index 162ce42..bf47097 100644
--- a/gst/gl/effects/gstgleffectsqueeze.c
+++ b/gst/gl/effects/gstgleffectsqueeze.c
@@ -23,11 +23,11 @@
 
 #include "../gstgleffects.h"
 
-#define USING_OPENGL(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL)
-#define USING_OPENGL3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL3)
-#define USING_GLES(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES)
-#define USING_GLES2(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES2)
-#define USING_GLES3(display) (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES3)
+#define USING_OPENGL(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL)
+#define USING_OPENGL3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL3)
+#define USING_GLES(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES)
+#define USING_GLES2(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2)
+#define USING_GLES3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES3)
 
 static void
 gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
@@ -36,17 +36,17 @@ gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
   GstGLShader *shader;
   GstGLFilter *filter = GST_GL_FILTER (data);
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = filter->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = filter->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "squeeze0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "squeeze0", shader);
 
 #if GST_GL_HAVE_GLES2
-    if (USING_GLES2 (display)) {
+    if (USING_GLES2 (context)) {
       if (shader) {
         GError *error = NULL;
         gst_gl_shader_set_vertex_source (shader, vertex_shader_source);
@@ -55,13 +55,13 @@ gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
 
         gst_gl_shader_compile (shader, &error);
         if (error) {
-          gst_gl_display_set_error (display,
+          gst_gl_context_set_error (context,
               "Failed to initialize squeeze shader, %s", error->message);
           g_error_free (error);
           error = NULL;
           gst_gl_shader_use (NULL);
           GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-              ("%s", gst_gl_display_get_error ()), (NULL));
+              ("%s", gst_gl_context_get_error ()), (NULL));
         } else {
           effects->draw_attr_position_loc =
               gst_gl_shader_get_attribute_location (shader, "a_position");
@@ -72,20 +72,20 @@ gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
     }
 #endif
 #if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (display)) {
+    if (USING_OPENGL (context)) {
       if (!gst_gl_shader_compile_and_check (shader,
               squeeze_fragment_source_opengl, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-        gst_gl_display_set_error (display,
+        gst_gl_context_set_error (context,
             "Failed to initialize squeeze shader");
         GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-            ("%s", gst_gl_display_get_error ()), (NULL));
+            ("%s", gst_gl_context_get_error ()), (NULL));
         return;
       }
     }
 #endif
   }
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (display)) {
+  if (USING_OPENGL (context)) {
     gl->MatrixMode (GL_PROJECTION);
     gl->LoadIdentity ();
   }
@@ -100,7 +100,7 @@ gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
   gst_gl_shader_set_uniform_1i (shader, "tex", 0);
 
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (filter->display)) {
+  if (USING_OPENGL (filter->context)) {
     gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f);
     gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f);
   }
diff --git a/gst/gl/effects/gstgleffectstretch.c b/gst/gl/effects/gstgleffectstretch.c
index 1291b09..e31f7ce 100644
--- a/gst/gl/effects/gstgleffectstretch.c
+++ b/gst/gl/effects/gstgleffectstretch.c
@@ -29,21 +29,21 @@ gst_gl_effects_stretch_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "stretch0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "stretch0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           stretch_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize stretch shader");
+    gst_gl_context_set_error (context, "Failed to initialize stretch shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffecttunnel.c b/gst/gl/effects/gstgleffecttunnel.c
index 25a521f..fd57e9a 100644
--- a/gst/gl/effects/gstgleffecttunnel.c
+++ b/gst/gl/effects/gstgleffecttunnel.c
@@ -29,21 +29,21 @@ gst_gl_effects_tunnel_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "tunnel0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "tunnel0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           tunnel_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize tunnel shader");
+    gst_gl_context_set_error (context, "Failed to initialize tunnel shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffecttwirl.c b/gst/gl/effects/gstgleffecttwirl.c
index 88da80a..86fef32 100644
--- a/gst/gl/effects/gstgleffecttwirl.c
+++ b/gst/gl/effects/gstgleffecttwirl.c
@@ -29,21 +29,21 @@ gst_gl_effects_twirl_callback (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "twirl0");
 
   if (!shader) {
-    shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
+    shader = gst_gl_shader_new (GST_GL_FILTER (effects)->context);
     g_hash_table_insert (effects->shaderstable, "twirl0", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           twirl_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize twirl shader");
+    gst_gl_context_set_error (context, "Failed to initialize twirl shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/effects/gstgleffectxray.c b/gst/gl/effects/gstgleffectxray.c
index 0712672..1cc3049 100644
--- a/gst/gl/effects/gstgleffectxray.c
+++ b/gst/gl/effects/gstgleffectxray.c
@@ -44,13 +44,13 @@ gst_gl_effects_xray_step_two (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray1");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray1", shader);
   }
 
@@ -61,9 +61,9 @@ gst_gl_effects_xray_step_two (gint width, gint height, guint texture,
 
   if (!gst_gl_shader_compile_and_check (shader,
           hconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize hconv7 shader");
+    gst_gl_context_set_error (context, "Failed to initialize hconv7 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -89,21 +89,21 @@ gst_gl_effects_xray_step_three (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray2");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray2", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           vconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize vconv7 shader");
+    gst_gl_context_set_error (context, "Failed to initialize vconv7 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -130,22 +130,22 @@ gst_gl_effects_xray_desaturate (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray_desat");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray_desat", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           desaturate_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize desaturate shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -169,22 +169,22 @@ gst_gl_effects_xray_sobel_hconv (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_hconv");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray_sob_hconv", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           sep_sobel_hconv3_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize sobel hvonc3 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -208,22 +208,22 @@ gst_gl_effects_xray_sobel_vconv (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_vconv");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray_sob_vconv", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           sep_sobel_vconv3_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize sobel vconv3 shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -247,22 +247,22 @@ gst_gl_effects_xray_sobel_length (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_len");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray_sob_len", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           sep_sobel_length_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display,
+    gst_gl_context_set_error (context,
         "Failed to initialize seobel length shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
@@ -289,21 +289,21 @@ gst_gl_effects_xray_step_five (gint width, gint height, guint texture,
 {
   GstGLShader *shader;
   GstGLEffects *effects = GST_GL_EFFECTS (data);
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
   shader = g_hash_table_lookup (effects->shaderstable, "xray4");
 
   if (!shader) {
-    shader = gst_gl_shader_new (display);
+    shader = gst_gl_shader_new (context);
     g_hash_table_insert (effects->shaderstable, "xray4", shader);
   }
 
   if (!gst_gl_shader_compile_and_check (shader,
           multiply_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (display, "Failed to initialize multiply shader");
+    gst_gl_context_set_error (context, "Failed to initialize multiply shader");
     GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
diff --git a/gst/gl/gstglbumper.c b/gst/gl/gstglbumper.c
index fe7dba0..0643b38 100644
--- a/gst/gl/gstglbumper.c
+++ b/gst/gl/gstglbumper.c
@@ -139,7 +139,7 @@ static const gchar *bumper_f_src =
     "  gl_FragColor = vec4(irradiance * textureColor.rgb, textureColor.w);\n"
     "}\n";
 
-#define LOAD_ERROR(display, msg) { gst_gl_display_set_error (display, "unable to load %s: %s", bumper->location, msg); return; }
+#define LOAD_ERROR(context, msg) { gst_gl_context_set_error (context, "unable to load %s: %s", bumper->location, msg); return; }
 
 //png reading error handler
 static void
@@ -153,7 +153,7 @@ static void
 gst_gl_bumper_init_resources (GstGLFilter * filter)
 {
   GstGLBumper *bumper = GST_GL_BUMPER (filter);
-  GstGLDisplay *display = filter->display;
+  GstGLContext *context = filter->context;
 
   png_structp png_ptr;
   png_infop info_ptr;
@@ -169,37 +169,37 @@ gst_gl_bumper_init_resources (GstGLFilter * filter)
   png_byte magic[8];
   gint n_read;
 
-  if (!display)
+  if (!context)
     return;
 
   if (!bumper->location) {
-    gst_gl_display_set_error (display, "A filename is required");
+    gst_gl_context_set_error (context, "A filename is required");
     return;
   }
 
   /* BEGIN load png image file */
 
   if ((fp = fopen (bumper->location, "rb")) == NULL)
-    LOAD_ERROR (display, "file not found");
+    LOAD_ERROR (context, "file not found");
 
   /* Read magic number */
   n_read = fread (magic, 1, sizeof (magic), fp);
   if (n_read != sizeof (magic)) {
     fclose (fp);
-    LOAD_ERROR (display, "can't read PNG magic number");
+    LOAD_ERROR (context, "can't read PNG magic number");
   }
 
   /* Check for valid magic number */
   if (png_sig_cmp (magic, 0, sizeof (magic))) {
     fclose (fp);
-    LOAD_ERROR (display, "not a valid PNG image");
+    LOAD_ERROR (context, "not a valid PNG image");
   }
 
   png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
   if (png_ptr == NULL) {
     fclose (fp);
-    LOAD_ERROR (display, "failed to initialize the png_struct");
+    LOAD_ERROR (context, "failed to initialize the png_struct");
   }
 
   png_set_error_fn (png_ptr, NULL, NULL, user_warning_fn);
@@ -208,7 +208,7 @@ gst_gl_bumper_init_resources (GstGLFilter * filter)
   if (info_ptr == NULL) {
     fclose (fp);
     png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
-    LOAD_ERROR (display,
+    LOAD_ERROR (context,
         "failed to initialize the memory for image information");
   }
 
@@ -224,7 +224,7 @@ gst_gl_bumper_init_resources (GstGLFilter * filter)
   if (color_type != PNG_COLOR_TYPE_RGB) {
     fclose (fp);
     png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
-    LOAD_ERROR (display, "color type is not rgb");
+    LOAD_ERROR (context, "color type is not rgb");
   }
 
   raw_data = (guchar *) malloc (sizeof (guchar) * width * height * 3);
@@ -313,7 +313,7 @@ gst_gl_bumper_reset (GstGLFilter * filter)
   GstGLBumper *bumper_filter = GST_GL_BUMPER (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, bumper_filter->shader);
+  gst_gl_context_del_shader (filter->context, bumper_filter->shader);
 }
 
 static void
@@ -356,7 +356,7 @@ gst_gl_bumper_init_shader (GstGLFilter * filter)
   GstGLBumper *bumper = GST_GL_BUMPER (filter);
 
   //blocking call, wait the opengl thread has compiled the shader
-  return gst_gl_display_gen_shader (filter->display, bumper_v_src, bumper_f_src,
+  return gst_gl_context_gen_shader (filter->context, bumper_v_src, bumper_f_src,
       &bumper->shader);
 }
 
@@ -366,7 +366,7 @@ gst_gl_bumper_filter_texture (GstGLFilter * filter, guint in_tex, guint out_tex)
   gpointer bumper_filter = GST_GL_BUMPER (filter);
 
   //blocking call, use a FBO
-  gst_gl_display_use_fbo (filter->display,
+  gst_gl_context_use_fbo (filter->context,
       GST_VIDEO_INFO_WIDTH (&filter->out_info),
       GST_VIDEO_INFO_HEIGHT (&filter->out_info),
       filter->fbo, filter->depthbuffer, out_tex, gst_gl_bumper_callback,
@@ -399,7 +399,7 @@ gst_gl_bumper_callback (gint width, gint height, guint texture, gpointer stuff)
 
   GstGLFuncs *gl;
   GstGLBumper *bumper = GST_GL_BUMPER (stuff);
-  GstGLDisplay *display = GST_GL_FILTER (bumper)->display;
+  GstGLContext *context = GST_GL_FILTER (bumper)->context;
   GLint locTangent = 0;
 
   //choose the lights
@@ -462,7 +462,7 @@ gst_gl_bumper_callback (gint width, gint height, guint texture, gpointer stuff)
 
 /* *INDENT-ON* */
 
-  gl = GST_GL_FILTER (bumper)->display->gl_vtable;
+  gl = GST_GL_FILTER (bumper)->context->gl_vtable;
 
   //eye point
   gl->MatrixMode (GL_PROJECTION);
@@ -534,7 +534,7 @@ gst_gl_bumper_callback (gint width, gint height, guint texture, gpointer stuff)
 
   gl->DisableVertexAttribArray (locTangent);
 
-  gst_gl_display_clear_shader (display);
+  gst_gl_context_clear_shader (context);
 
   gl->Disable (GL_LIGHT0);
   gl->Disable (GL_LIGHT1);
diff --git a/gst/gl/gstgldeinterlace.c b/gst/gl/gstgldeinterlace.c
index 6edd177..6604551 100644
--- a/gst/gl/gstgldeinterlace.c
+++ b/gst/gl/gstgldeinterlace.c
@@ -189,7 +189,7 @@ gst_gl_deinterlace_reset (GstGLFilter * filter)
     deinterlace_filter->prev_buffer = NULL;
   }
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, deinterlace_filter->shader);
+  gst_gl_context_del_shader (filter->context, deinterlace_filter->shader);
 }
 
 static void
@@ -224,7 +224,7 @@ gst_gl_deinterlace_init_shader (GstGLFilter * filter)
   GstGLDeinterlace *deinterlace_filter = GST_GL_DEINTERLACE (filter);
 
   //blocking call, wait the opengl thread has compiled the shader
-  return gst_gl_display_gen_shader (filter->display, 0, greedyh_fragment_source,
+  return gst_gl_context_gen_shader (filter->context, 0, greedyh_fragment_source,
       &deinterlace_filter->shader);
 }
 
@@ -264,7 +264,7 @@ gst_gl_deinterlace_callback (gint width, gint height, guint texture,
 {
   GstGLDeinterlace *deinterlace_filter = GST_GL_DEINTERLACE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   guint temp;
 
   GLfloat verts[] = { -1.0, -1.0,
@@ -291,7 +291,7 @@ gst_gl_deinterlace_callback (gint width, gint height, guint texture,
   gl->Enable (GL_TEXTURE_RECTANGLE_ARB);
 
   if (G_UNLIKELY (deinterlace_filter->prev_tex == 0)) {
-    gst_gl_display_gen_texture_thread (filter->display,
+    gst_gl_context_gen_texture_thread (filter->context,
         &deinterlace_filter->prev_tex,
         GST_VIDEO_INFO_FORMAT (&filter->out_info),
         GST_VIDEO_INFO_WIDTH (&filter->out_info),
diff --git a/gst/gl/gstgldifferencematte.c b/gst/gl/gstgldifferencematte.c
index 22c185c..d88e727 100644
--- a/gst/gl/gstgldifferencematte.c
+++ b/gst/gl/gstgldifferencematte.c
@@ -81,7 +81,7 @@ static void
 gst_gl_differencematte_init_gl_resources (GstGLFilter * filter)
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   gint i;
 
   for (i = 0; i < 4; i++) {
@@ -99,42 +99,42 @@ gst_gl_differencematte_init_gl_resources (GstGLFilter * filter)
         GL_CLAMP_TO_EDGE);
     gl->TexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
-    differencematte->shader[i] = gst_gl_shader_new (filter->display);
+    differencematte->shader[i] = gst_gl_shader_new (filter->context);
   }
 
   if (!gst_gl_shader_compile_and_check (differencematte->shader[0],
           difference_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (GST_GL_FILTER (differencematte)->display,
+    gst_gl_context_set_error (GST_GL_FILTER (differencematte)->context,
         "Failed to initialize difference shader");
     GST_ELEMENT_ERROR (differencematte, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
   if (!gst_gl_shader_compile_and_check (differencematte->shader[1],
           hconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (GST_GL_FILTER (differencematte)->display,
+    gst_gl_context_set_error (GST_GL_FILTER (differencematte)->context,
         "Failed to initialize hconv7 shader");
     GST_ELEMENT_ERROR (differencematte, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
   if (!gst_gl_shader_compile_and_check (differencematte->shader[2],
           vconv7_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (GST_GL_FILTER (differencematte)->display,
+    gst_gl_context_set_error (GST_GL_FILTER (differencematte)->context,
         "Failed to initialize vconv7 shader");
     GST_ELEMENT_ERROR (differencematte, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 
   if (!gst_gl_shader_compile_and_check (differencematte->shader[3],
           texture_interp_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) {
-    gst_gl_display_set_error (GST_GL_FILTER (differencematte)->display,
+    gst_gl_context_set_error (GST_GL_FILTER (differencematte)->context,
         "Failed to initialize interp shader");
     GST_ELEMENT_ERROR (differencematte, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return;
   }
 }
@@ -144,7 +144,7 @@ static void
 gst_gl_differencematte_reset_gl_resources (GstGLFilter * filter)
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   gint i;
 
   gl->DeleteTextures (1, &differencematte->savedbgtexture);
@@ -267,7 +267,7 @@ gst_gl_differencematte_save_texture (gint width, gint height, guint texture,
     gpointer stuff)
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -276,11 +276,11 @@ gst_gl_differencematte_save_texture (gint width, gint height, guint texture,
 }
 
 static void
-init_pixbuf_texture (GstGLDisplay * display, gpointer data)
+init_pixbuf_texture (GstGLContext * context, gpointer data)
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (data);
   GstGLFilter *filter = GST_GL_FILTER (data);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->DeleteTextures (1, &differencematte->newbgtexture);
   gl->GenTextures (1, &differencematte->newbgtexture);
@@ -313,7 +313,7 @@ gst_gl_differencematte_diff (gint width, gint height, guint texture,
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -343,7 +343,7 @@ gst_gl_differencematte_hblur (gint width, gint height, guint texture,
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -369,7 +369,7 @@ gst_gl_differencematte_vblur (gint width, gint height, guint texture,
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -395,7 +395,7 @@ gst_gl_differencematte_interp (gint width, gint height, guint texture,
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   glLoadIdentity ();
@@ -441,7 +441,7 @@ gst_gl_differencematte_identity (gint width, gint height, guint texture,
 {
   GstGLDifferenceMatte *differencematte = GST_GL_DIFFERENCEMATTE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (differencematte);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -462,8 +462,8 @@ gst_gl_differencematte_filter_texture (GstGLFilter * filter, guint in_tex,
     if (!gst_gl_differencematte_loader (filter))
       differencematte->pixbuf = NULL;
 
-    /* if loader failed then display is turned off */
-    gst_gl_display_thread_add (filter->display, init_pixbuf_texture,
+    /* if loader failed then context is turned off */
+    gst_gl_context_thread_add (filter->context, init_pixbuf_texture,
         differencematte);
 
     /* save current frame, needed to calculate difference between
@@ -526,7 +526,7 @@ gst_gl_differencematte_loader (GstGLFilter * filter)
   guchar **rows = NULL;
   gint filler;
 
-  if (!filter->display)
+  if (!filter->context)
     return TRUE;
 
   if ((fp = fopen (differencematte->location, "rb")) == NULL)
diff --git a/gst/gl/gstgleffects.c b/gst/gl/gstgleffects.c
index 6649b71..8b3056a 100644
--- a/gst/gl/gstgleffects.c
+++ b/gst/gl/gstgleffects.c
@@ -275,11 +275,11 @@ void
 gst_gl_effects_draw_texture (GstGLEffects * effects, GLuint tex, guint width,
     guint height)
 {
-  GstGLDisplay *display = GST_GL_FILTER (effects)->display;
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLContext *context = GST_GL_FILTER (effects)->context;
+  GstGLFuncs *gl = context->gl_vtable;
 
 #if GST_GL_HAVE_OPENGL
-  if (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL) {
+  if (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL) {
     GLfloat verts[] = { -1.0f, -1.0f,
       1.0f, -1.0f,
       1.0f, 1.0f,
@@ -309,7 +309,7 @@ gst_gl_effects_draw_texture (GstGLEffects * effects, GLuint tex, guint width,
   }
 #endif
 #if GST_GL_HAVE_GLES2
-  if (gst_gl_display_get_gl_api (display) & GST_GL_API_GLES2) {
+  if (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2) {
     const GLfloat vVertices[] = {
       -1.0f, -1.0f, 0.0f,
       0.0f, 0.0f,
@@ -337,16 +337,16 @@ gst_gl_effects_draw_texture (GstGLEffects * effects, GLuint tex, guint width,
   }
 #endif
 
-  gst_gl_display_clear_shader (display);
+  gst_gl_context_clear_shader (context);
 }
 
 static void
-set_horizontal_swap (GstGLDisplay * display, gpointer data)
+set_horizontal_swap (GstGLContext * context, gpointer data)
 {
 #if GST_GL_HAVE_OPENGL
-  GstGLFuncs *gl = display->gl_vtable;
+  GstGLFuncs *gl = context->gl_vtable;
 
-  if (gst_gl_display_get_gl_api (display) & GST_GL_API_OPENGL) {
+  if (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL) {
     const gfloat mirrormatrix[16] = {
       -1.0, 0.0, 0.0, 0.0,
       0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
@@ -372,7 +372,7 @@ gst_gl_effects_ghash_func_clean (gpointer key, gpointer value, gpointer data)
   GstGLFilter *filter = (GstGLFilter *) data;
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, shader);
+  gst_gl_context_del_shader (filter->context, shader);
 
   value = NULL;
 }
@@ -463,7 +463,7 @@ gst_gl_effects_filter_texture (GstGLFilter * filter, guint in_tex,
   effects->outtexture = out_tex;
 
   if (effects->horizontal_swap == TRUE)
-    gst_gl_display_thread_add (filter->display, set_horizontal_swap, effects);
+    gst_gl_context_thread_add (filter->context, set_horizontal_swap, effects);
 
   effects->effect (effects);
 
diff --git a/gst/gl/gstglfilterapp.c b/gst/gl/gstglfilterapp.c
index e98bc53..ba60a46 100644
--- a/gst/gl/gstglfilterapp.c
+++ b/gst/gl/gstglfilterapp.c
@@ -176,7 +176,7 @@ gst_gl_filter_app_filter_texture (GstGLFilter * filter, guint in_tex,
 
   if (app_filter->clientDrawCallback) {
     //blocking call, use a FBO
-    gst_gl_display_use_fbo (filter->display,
+    gst_gl_context_use_fbo (filter->context,
         GST_VIDEO_INFO_WIDTH (&filter->out_info),
         GST_VIDEO_INFO_HEIGHT (&filter->out_info),
         filter->fbo, filter->depthbuffer, out_tex,
@@ -205,7 +205,7 @@ gst_gl_filter_app_callback (gint width, gint height, guint texture,
     gpointer stuff)
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
diff --git a/gst/gl/gstglfilterblur.c b/gst/gl/gstglfilterblur.c
index 98dc4f3..8d9c933 100644
--- a/gst/gl/gstglfilterblur.c
+++ b/gst/gl/gstglfilterblur.c
@@ -67,7 +67,7 @@ static void
 gst_gl_filterblur_init_resources (GstGLFilter * filter)
 {
   GstGLFilterBlur *filterblur = GST_GL_FILTERBLUR (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->GenTextures (1, &filterblur->midtexture);
   gl->BindTexture (GL_TEXTURE_RECTANGLE_ARB, filterblur->midtexture);
@@ -89,7 +89,7 @@ static void
 gst_gl_filterblur_reset_resources (GstGLFilter * filter)
 {
   GstGLFilterBlur *filterblur = GST_GL_FILTERBLUR (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->DeleteTextures (1, &filterblur->midtexture);
 }
@@ -138,10 +138,10 @@ gst_gl_filter_filterblur_reset (GstGLFilter * filter)
   GstGLFilterBlur *filterblur = GST_GL_FILTERBLUR (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, filterblur->shader0);
+  gst_gl_context_del_shader (filter->context, filterblur->shader0);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, filterblur->shader1);
+  gst_gl_context_del_shader (filter->context, filterblur->shader1);
 }
 
 static void
@@ -176,12 +176,12 @@ gst_gl_filterblur_init_shader (GstGLFilter * filter)
   GstGLFilterBlur *blur_filter = GST_GL_FILTERBLUR (filter);
 
   //blocking call, wait the opengl thread has compiled the shader
-  if (!gst_gl_display_gen_shader (filter->display, 0, hconv7_fragment_source,
+  if (!gst_gl_context_gen_shader (filter->context, 0, hconv7_fragment_source,
           &blur_filter->shader0))
     return FALSE;
 
   //blocking call, wait the opengl thread has compiled the shader
-  if (!gst_gl_display_gen_shader (filter->display, 0, vconv7_fragment_source,
+  if (!gst_gl_context_gen_shader (filter->context, 0, vconv7_fragment_source,
           &blur_filter->shader1))
     return FALSE;
 
@@ -209,7 +209,7 @@ gst_gl_filterblur_hcallback (gint width, gint height, guint texture,
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterBlur *filterblur = GST_GL_FILTERBLUR (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -235,7 +235,7 @@ gst_gl_filterblur_vcallback (gint width, gint height, guint texture,
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterBlur *filterblur = GST_GL_FILTERBLUR (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
diff --git a/gst/gl/gstglfiltercube.c b/gst/gl/gstglfiltercube.c
index 96c040c..cca61fe 100644
--- a/gst/gl/gstglfiltercube.c
+++ b/gst/gl/gstglfiltercube.c
@@ -287,7 +287,7 @@ gst_gl_filter_cube_reset (GstGLFilter * filter)
 
   /* blocking call, wait the opengl thread has destroyed the shader */
   if (cube_filter->shader)
-    gst_gl_display_del_shader (filter->display, cube_filter->shader);
+    gst_gl_context_del_shader (filter->context, cube_filter->shader);
 }
 
 static gboolean
@@ -295,9 +295,9 @@ gst_gl_filter_cube_init_shader (GstGLFilter * filter)
 {
   GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
 
-  if (gst_gl_display_get_gl_api (filter->display) & GST_GL_API_GLES2) {
+  if (gst_gl_context_get_gl_api (filter->context) & GST_GL_API_GLES2) {
     /* blocking call, wait the opengl thread has compiled the shader */
-    return gst_gl_display_gen_shader (filter->display, cube_v_src, cube_f_src,
+    return gst_gl_context_gen_shader (filter->context, cube_v_src, cube_f_src,
         &cube_filter->shader);
   }
   return TRUE;
@@ -312,7 +312,7 @@ gst_gl_filter_cube_filter_texture (GstGLFilter * filter, guint in_tex,
   GLCB cb = NULL;
   GstGLAPI api;
 
-  api = gst_gl_display_get_gl_api (GST_GL_FILTER (cube_filter)->display);
+  api = gst_gl_context_get_gl_api (GST_GL_FILTER (cube_filter)->context);
 
 #if GST_GL_HAVE_OPENGL
   if (api & GST_GL_API_OPENGL)
@@ -324,7 +324,7 @@ gst_gl_filter_cube_filter_texture (GstGLFilter * filter, guint in_tex,
 #endif
 
   /* blocking call, use a FBO */
-  gst_gl_display_use_fbo (filter->display,
+  gst_gl_context_use_fbo (filter->context,
       GST_VIDEO_INFO_WIDTH (&filter->out_info),
       GST_VIDEO_INFO_HEIGHT (&filter->out_info),
       filter->fbo, filter->depthbuffer, out_tex,
@@ -345,7 +345,7 @@ _callback_opengl (gint width, gint height, guint texture, gpointer stuff)
 {
   GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (stuff);
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   static GLfloat xrot = 0;
   static GLfloat yrot = 0;
@@ -450,7 +450,7 @@ _callback_gles2 (gint width, gint height, guint texture, gpointer stuff)
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   static GLfloat xrot = 0;
   static GLfloat yrot = 0;
diff --git a/gst/gl/gstglfilterglass.c b/gst/gl/gstglfilterglass.c
index 99b3b95..19b7644 100644
--- a/gst/gl/gstglfilterglass.c
+++ b/gst/gl/gstglfilterglass.c
@@ -180,8 +180,8 @@ gst_gl_filter_glass_reset (GstGLFilter * filter)
   GstGLFilterGlass *glass_filter = GST_GL_FILTER_GLASS (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, glass_filter->shader);
-  gst_gl_display_del_shader (filter->display, glass_filter->passthrough_shader);
+  gst_gl_context_del_shader (filter->context, glass_filter->shader);
+  gst_gl_context_del_shader (filter->context, glass_filter->passthrough_shader);
 }
 
 static void
@@ -218,11 +218,11 @@ gst_gl_filter_glass_init_shader (GstGLFilter * filter)
 
   //blocking call, wait the opengl thread has compiled the shader
   ret =
-      gst_gl_display_gen_shader (filter->display, glass_vertex_source,
+      gst_gl_context_gen_shader (filter->context, glass_vertex_source,
       glass_fragment_source, &glass_filter->shader);
   if (ret)
     ret =
-        gst_gl_display_gen_shader (filter->display, passthrough_vertex,
+        gst_gl_context_gen_shader (filter->context, passthrough_vertex,
         passthrough_fragment, &glass_filter->passthrough_shader);
 
   return ret;
@@ -236,7 +236,7 @@ gst_gl_filter_glass_filter_texture (GstGLFilter * filter, guint in_tex,
   glass_filter->in_tex = in_tex;
 
   //blocking call, use a FBO
-  gst_gl_display_use_fbo_v2 (filter->display,
+  gst_gl_context_use_fbo_v2 (filter->context,
       GST_VIDEO_INFO_WIDTH (&filter->out_info),
       GST_VIDEO_INFO_HEIGHT (&filter->out_info),
       filter->fbo, filter->depthbuffer, out_tex,
@@ -258,7 +258,7 @@ static void
 gst_gl_filter_glass_draw_background_gradient (GstGLFilterGlass * glass)
 {
   GstGLFilter *filter = GST_GL_FILTER (glass);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
 /* *INDENT-OFF* */
   gfloat mesh[] = {
@@ -299,7 +299,7 @@ gst_gl_filter_glass_draw_video_plane (GstGLFilter * filter,
     gfloat start_alpha, gfloat stop_alpha, gboolean reversed, gfloat rotation)
 {
   GstGLFilterGlass *glass_filter = GST_GL_FILTER_GLASS (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gfloat w = (gfloat) width;
   gfloat h = (gfloat) height;
@@ -357,7 +357,7 @@ gst_gl_filter_glass_callback (gpointer stuff)
 
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterGlass *glass_filter = GST_GL_FILTER_GLASS (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gint width = GST_VIDEO_INFO_WIDTH (&filter->out_info);
   gint height = GST_VIDEO_INFO_HEIGHT (&filter->out_info);
@@ -400,7 +400,7 @@ gst_gl_filter_glass_callback (gpointer stuff)
   gst_gl_filter_glass_draw_video_plane (filter, width, height, texture,
       0.0f, 0.0f, 1.0f, 1.0f, FALSE, rotation);
 
-  gst_gl_display_clear_shader (filter->display);
+  gst_gl_context_clear_shader (filter->context);
 
   gl->Disable (GL_TEXTURE_RECTANGLE_ARB);
   gl->Disable (GL_BLEND);
diff --git a/gst/gl/gstglfilterlaplacian.c b/gst/gl/gstglfilterlaplacian.c
index 1a95bf9..0879389 100644
--- a/gst/gl/gstglfilterlaplacian.c
+++ b/gst/gl/gstglfilterlaplacian.c
@@ -131,7 +131,7 @@ gst_gl_filter_laplacian_reset (GstGLFilter * filter)
   GstGLFilterLaplacian *laplacian_filter = GST_GL_FILTER_LAPLACIAN (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, laplacian_filter->shader);
+  gst_gl_context_del_shader (filter->context, laplacian_filter->shader);
 }
 
 static void
@@ -166,7 +166,7 @@ gst_gl_filter_laplacian_init_shader (GstGLFilter * filter)
   GstGLFilterLaplacian *laplacian_filter = GST_GL_FILTER_LAPLACIAN (filter);
 
   //blocking call, wait the opengl thread has compiled the shader
-  return gst_gl_display_gen_shader (filter->display, 0,
+  return gst_gl_context_gen_shader (filter->context, 0,
       convolution_fragment_source, &laplacian_filter->shader);
 }
 
@@ -191,7 +191,7 @@ gst_gl_filter_laplacian_callback (gint width, gint height, guint texture,
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterLaplacian *laplacian_filter = GST_GL_FILTER_LAPLACIAN (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gfloat kernel[9] = { 0.0, -1.0, 0.0,
     -1.0, 4.0, -1.0,
diff --git a/gst/gl/gstglfilterreflectedscreen.c b/gst/gl/gstglfilterreflectedscreen.c
index da6a12d..0afeaf6 100644
--- a/gst/gl/gstglfilterreflectedscreen.c
+++ b/gst/gl/gstglfilterreflectedscreen.c
@@ -228,7 +228,7 @@ gst_gl_filter_reflected_screen_filter_texture (GstGLFilter * filter,
       GST_GL_FILTER_REFLECTED_SCREEN (filter);
 
   //blocking call, use a FBO
-  gst_gl_display_use_fbo (filter->display,
+  gst_gl_context_use_fbo (filter->context,
       GST_VIDEO_INFO_WIDTH (&filter->out_info),
       GST_VIDEO_INFO_HEIGHT (&filter->out_info),
       filter->fbo, filter->depthbuffer, out_tex,
diff --git a/gst/gl/gstglfiltershader.c b/gst/gl/gstglfiltershader.c
index e3824fa..ab6f341 100644
--- a/gst/gl/gstglfiltershader.c
+++ b/gst/gl/gstglfiltershader.c
@@ -160,7 +160,7 @@ gst_gl_filter_filtershader_reset (GstGLFilter * filter)
   GstGLFilterShader *filtershader = GST_GL_FILTERSHADER (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, filtershader->shader0);
+  gst_gl_context_del_shader (filter->context, filtershader->shader0);
 
 }
 
@@ -178,7 +178,7 @@ gst_gl_filtershader_set_property (GObject * object, guint prop_id,
         g_free (filtershader->filename);
       }
       if (filtershader->compiled) {
-        //gst_gl_display_del_shader (filtershader->filter.display, filtershader->shader0);
+        //gst_gl_context_del_shader (filtershader->filter.context, filtershader->shader0);
         gst_gl_filter_filtershader_reset (&filtershader->filter);
         filtershader->shader0 = 0;
       }
@@ -319,7 +319,7 @@ gst_gl_filtershader_init_shader (GstGLFilter * filter)
     return FALSE;
 
   //blocking call, wait the opengl thread has compiled the shader
-  if (!gst_gl_display_gen_shader (filter->display, 0, hfilter_fragment_source,
+  if (!gst_gl_context_gen_shader (filter->context, 0, hfilter_fragment_source,
           &filtershader->shader0))
     return FALSE;
 
@@ -351,7 +351,7 @@ gst_gl_filtershader_hcallback (gint width, gint height, guint texture,
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
   GstGLFilterShader *filtershader = GST_GL_FILTERSHADER (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
diff --git a/gst/gl/gstglfiltersobel.c b/gst/gl/gstglfiltersobel.c
index a41f150..35845fe 100644
--- a/gst/gl/gstglfiltersobel.c
+++ b/gst/gl/gstglfiltersobel.c
@@ -71,7 +71,7 @@ static void
 gst_gl_filtersobel_init_resources (GstGLFilter * filter)
 {
   GstGLFilterSobel *filtersobel = GST_GL_FILTERSOBEL (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   int i;
 
   for (i = 0; i < 2; i++) {
@@ -96,7 +96,7 @@ static void
 gst_gl_filtersobel_reset_resources (GstGLFilter * filter)
 {
   GstGLFilterSobel *filtersobel = GST_GL_FILTERSOBEL (filter);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   int i;
 
   for (i = 0; i < 2; i++) {
@@ -155,10 +155,10 @@ gst_gl_filter_filtersobel_reset (GstGLFilter * filter)
   GstGLFilterSobel *filtersobel = GST_GL_FILTERSOBEL (filter);
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (filter->display, filtersobel->desat);
-  gst_gl_display_del_shader (filter->display, filtersobel->hconv);
-  gst_gl_display_del_shader (filter->display, filtersobel->vconv);
-  gst_gl_display_del_shader (filter->display, filtersobel->len);
+  gst_gl_context_del_shader (filter->context, filtersobel->desat);
+  gst_gl_context_del_shader (filter->context, filtersobel->hconv);
+  gst_gl_context_del_shader (filter->context, filtersobel->vconv);
+  gst_gl_context_del_shader (filter->context, filtersobel->len);
 }
 
 static void
@@ -201,16 +201,16 @@ gst_gl_filtersobel_init_shader (GstGLFilter * filter)
 
   //blocking call, wait the opengl thread has compiled the shader
   ret =
-      gst_gl_display_gen_shader (filter->display, 0, desaturate_fragment_source,
+      gst_gl_context_gen_shader (filter->context, 0, desaturate_fragment_source,
       &filtersobel->desat);
   ret &=
-      gst_gl_display_gen_shader (filter->display, 0,
+      gst_gl_context_gen_shader (filter->context, 0,
       sep_sobel_hconv3_fragment_source, &filtersobel->hconv);
   ret &=
-      gst_gl_display_gen_shader (filter->display, 0,
+      gst_gl_context_gen_shader (filter->context, 0,
       sep_sobel_vconv3_fragment_source, &filtersobel->vconv);
   ret &=
-      gst_gl_display_gen_shader (filter->display, 0,
+      gst_gl_context_gen_shader (filter->context, 0,
       sep_sobel_length_fragment_source, &filtersobel->len);
 
   return ret;
@@ -241,7 +241,7 @@ gst_gl_filtersobel_length (gint width, gint height, guint texture,
     gpointer stuff)
 {
   GstGLFilter *filter = GST_GL_FILTER (stuff);
-  GstGLFuncs *gl = filter->display->gl_vtable;
+  GstGLFuncs *gl = filter->context->gl_vtable;
   GstGLFilterSobel *filtersobel = GST_GL_FILTERSOBEL (filter);
 
   glMatrixMode (GL_PROJECTION);
diff --git a/gst/gl/gstglimagesink.c b/gst/gl/gstglimagesink.c
index 89857f5..04ad4cf 100644
--- a/gst/gl/gstglimagesink.c
+++ b/gst/gl/gstglimagesink.c
@@ -97,11 +97,11 @@ GST_DEBUG_CATEGORY (gst_debug_glimage_sink);
 #define GST_GLIMAGE_SINK_UNLOCK(glsink) \
   (g_mutex_unlock(&GST_GLIMAGE_SINK_GET_LOCK (glsink)))
 
-#define USING_OPENGL(display) (display->gl_api & GST_GL_API_OPENGL)
-#define USING_OPENGL3(display) (display->gl_api & GST_GL_API_OPENGL3)
-#define USING_GLES(display) (display->gl_api & GST_GL_API_GLES)
-#define USING_GLES2(display) (display->gl_api & GST_GL_API_GLES2)
-#define USING_GLES3(display) (display->gl_api & GST_GL_API_GLES3)
+#define USING_OPENGL(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL)
+#define USING_OPENGL3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL3)
+#define USING_GLES(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES)
+#define USING_GLES2(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2)
+#define USING_GLES3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES3)
 
 #if GST_GL_HAVE_GLES2
 static void gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink);
@@ -426,14 +426,14 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
       g_atomic_int_set (&glimage_sink->to_quit, 0);
       if (!glimage_sink->display) {
         GstGLWindow *window;
-        GstGLContext *context;
         GError *error = NULL;
 
         GST_INFO ("Creating GstGLDisplay");
         glimage_sink->display = gst_gl_display_new ();
-        context = gst_gl_context_new (glimage_sink->display);
-        gst_gl_display_set_context (glimage_sink->display, context);
-        window = gst_gl_context_get_window (context);
+        glimage_sink->context = gst_gl_context_new (glimage_sink->display);
+        gst_gl_display_set_context (glimage_sink->display,
+            glimage_sink->context);
+        window = gst_gl_context_get_window (glimage_sink->context);
 
         if (!glimage_sink->window_id && !glimage_sink->new_window_id)
           gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY
@@ -444,7 +444,7 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
           gst_gl_window_set_window_handle (window, glimage_sink->window_id);
         }
 
-        if (!gst_gl_context_create (context, 0, &error)) {
+        if (!gst_gl_context_create (glimage_sink->context, 0, &error)) {
           GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
               ("%s", error->message), (NULL));
 
@@ -452,7 +452,7 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
             gst_object_unref (glimage_sink->display);
             glimage_sink->display = NULL;
           }
-          gst_object_unref (context);
+          gst_object_unref (glimage_sink->context);
 
           return GST_STATE_CHANGE_FAILURE;
         }
@@ -469,7 +469,6 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
             gst_object_ref (glimage_sink), (GDestroyNotify) gst_object_unref);
 
         gst_object_unref (window);
-        gst_object_unref (context);
       }
       break;
     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
@@ -514,10 +513,8 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
 
       GST_VIDEO_SINK_WIDTH (glimage_sink) = 1;
       GST_VIDEO_SINK_HEIGHT (glimage_sink) = 1;
-      if (glimage_sink->display) {
-        GstGLContext *context =
-            gst_gl_display_get_context (glimage_sink->display);
-        GstGLWindow *window = gst_gl_context_get_window (context);
+      if (glimage_sink->context) {
+        GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
 
         gst_gl_window_send_message (window,
             GST_GL_WINDOW_CB (gst_glimage_sink_cleanup_glthread), glimage_sink);
@@ -527,7 +524,8 @@ gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
         gst_gl_window_set_close_callback (window, NULL, NULL, NULL);
 
         gst_object_unref (window);
-        gst_object_unref (context);
+        gst_object_unref (glimage_sink->context);
+        glimage_sink->context = NULL;
         gst_object_unref (glimage_sink->display);
         glimage_sink->display = NULL;
       }
@@ -591,9 +589,9 @@ gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
   height = GST_VIDEO_INFO_HEIGHT (&vinfo);
 
   if (glimage_sink->tex_id)
-    gst_gl_display_del_texture (glimage_sink->display, &glimage_sink->tex_id);
+    gst_gl_context_del_texture (glimage_sink->context, &glimage_sink->tex_id);
   //FIXME: this texture seems to be never deleted when going to STATE_NULL
-  gst_gl_display_gen_texture (glimage_sink->display, &glimage_sink->tex_id,
+  gst_gl_context_gen_texture (glimage_sink->context, &glimage_sink->tex_id,
       GST_VIDEO_INFO_FORMAT (&vinfo), width, height);
 
   par_n = GST_VIDEO_INFO_PAR_N (&vinfo);
@@ -644,7 +642,7 @@ gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
 
   glimage_sink->info = vinfo;
 
-  newpool = gst_gl_buffer_pool_new (glimage_sink->display);
+  newpool = gst_gl_buffer_pool_new (glimage_sink->context);
   structure = gst_buffer_pool_get_config (newpool);
   gst_buffer_pool_config_set_params (structure, caps, vinfo.size, 2, 0);
   gst_buffer_pool_set_config (newpool, structure);
@@ -694,7 +692,7 @@ gst_glimage_sink_render (GstBaseSink * bsink, GstBuffer * buf)
         "attempting to wrap for upload");
 
     if (!glimage_sink->upload) {
-      glimage_sink->upload = gst_gl_upload_new (glimage_sink->display);
+      glimage_sink->upload = gst_gl_upload_new (glimage_sink->context);
 
       if (!gst_gl_upload_init_format (glimage_sink->upload,
               GST_VIDEO_FRAME_FORMAT (&frame), GST_VIDEO_FRAME_WIDTH (&frame),
@@ -718,14 +716,12 @@ gst_glimage_sink_render (GstBaseSink * bsink, GstBuffer * buf)
   }
 
   if (glimage_sink->window_id != glimage_sink->new_window_id) {
-    GstGLContext *context = gst_gl_display_get_context (glimage_sink->display);
-    GstGLWindow *window = gst_gl_context_get_window (context);
+    GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
 
     glimage_sink->window_id = glimage_sink->new_window_id;
     gst_gl_window_set_window_handle (window, glimage_sink->window_id);
 
     gst_object_unref (window);
-    gst_object_unref (context);
   }
 
   GST_TRACE ("redisplay texture:%u of size:%ux%u, window size:%ux%u", tex_id,
@@ -750,7 +746,7 @@ gst_glimage_sink_render (GstBaseSink * bsink, GstBuffer * buf)
 
   if (g_atomic_int_get (&glimage_sink->to_quit) != 0) {
     GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return GST_FLOW_ERROR;
   }
 
@@ -761,7 +757,7 @@ redisplay_failed:
   {
     gst_video_frame_unmap (&frame);
     GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return GST_FLOW_ERROR;
   }
 }
@@ -798,15 +794,12 @@ gst_glimage_sink_expose (GstVideoOverlay * overlay)
   if (glimage_sink->display && glimage_sink->window_id) {
 
     if (glimage_sink->window_id != glimage_sink->new_window_id) {
-      GstGLContext *context =
-          gst_gl_display_get_context (glimage_sink->display);
-      GstGLWindow *window = gst_gl_context_get_window (context);
+      GstGLWindow *window = gst_gl_context_get_window (glimage_sink->context);
 
       glimage_sink->window_id = glimage_sink->new_window_id;
       gst_gl_window_set_window_handle (window, glimage_sink->window_id);
 
       gst_object_unref (window);
-      gst_object_unref (context);
     }
 
     gst_glimage_sink_redisplay (glimage_sink);
@@ -854,7 +847,7 @@ gst_glimage_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
       goto invalid_caps;
 
     GST_DEBUG_OBJECT (glimage_sink, "create new pool");
-    pool = gst_gl_buffer_pool_new (glimage_sink->display);
+    pool = gst_gl_buffer_pool_new (glimage_sink->context);
 
     /* the normal size of a frame */
     size = info.size;
@@ -898,7 +891,7 @@ static void
 gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink)
 {
   GError *error = NULL;
-  gl_sink->redisplay_shader = gst_gl_shader_new (gl_sink->display);
+  gl_sink->redisplay_shader = gst_gl_shader_new (gl_sink->context);
 
   gst_gl_shader_set_vertex_source (gl_sink->redisplay_shader,
       redisplay_vertex_shader_str_gles2);
@@ -907,10 +900,10 @@ gst_glimage_sink_thread_init_redisplay (GstGLImageSink * gl_sink)
 
   gst_gl_shader_compile (gl_sink->redisplay_shader, &error);
   if (error) {
-    gst_gl_display_set_error (gl_sink->display, "%s", error->message);
+    gst_gl_context_set_error (gl_sink->context, "%s", error->message);
     g_error_free (error);
     error = NULL;
-    gst_gl_display_clear_shader (gl_sink->display);
+    gst_gl_context_clear_shader (gl_sink->context);
   } else {
     gl_sink->redisplay_attr_position_loc =
         gst_gl_shader_get_attribute_location (gl_sink->redisplay_shader,
@@ -929,7 +922,7 @@ gst_glimage_sink_on_resize (const GstGLImageSink * gl_sink, gint width,
   /* Here gl_sink members (ex:gl_sink->info) have a life time of set_caps.
    * It means that they cannot not change between two set_caps
    */
-  const GstGLFuncs *gl = gl_sink->display->gl_vtable;
+  const GstGLFuncs *gl = gl_sink->context->gl_vtable;
 
   GST_TRACE ("GL Window resized to %ux%u", width, height);
 
@@ -958,7 +951,7 @@ gst_glimage_sink_on_resize (const GstGLImageSink * gl_sink, gint width,
       gl->Viewport (0, 0, width, height);
     }
 #if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (gl_sink->display)) {
+    if (USING_OPENGL (gl_sink->context)) {
       gl->MatrixMode (GL_PROJECTION);
       gl->LoadIdentity ();
       gluOrtho2D (0, width, 0, height);
@@ -982,7 +975,7 @@ gst_glimage_sink_on_draw (const GstGLImageSink * gl_sink)
 
   g_return_if_fail (GST_IS_GLIMAGE_SINK (gl_sink));
 
-  gl = gl_sink->display->gl_vtable;
+  gl = gl_sink->context->gl_vtable;
 
   GST_GLIMAGE_SINK_LOCK (gl_sink);
 
@@ -996,10 +989,10 @@ gst_glimage_sink_on_draw (const GstGLImageSink * gl_sink)
   GST_TRACE ("redrawing texture:%u", gl_sink->redisplay_texture);
 
   /* make sure that the environnement is clean */
-  gst_gl_display_clear_shader (gl_sink->display);
+  gst_gl_context_clear_shader (gl_sink->context);
 
 #if GST_GL_HAVE_OPENGL
-  if (USING_OPENGL (gl_sink->display))
+  if (USING_OPENGL (gl_sink->context))
     gl->Disable (GL_TEXTURE_RECTANGLE_ARB);
 #endif
 
@@ -1015,22 +1008,19 @@ gst_glimage_sink_on_draw (const GstGLImageSink * gl_sink)
         gl_sink->client_data);
 
     if (doRedisplay) {
-      GstGLContext *context =
-          gst_gl_display_get_context_unlocked (gl_sink->display);
-      GstGLWindow *window = gst_gl_context_get_window (context);
+      GstGLWindow *window = gst_gl_context_get_window (gl_sink->context);
 
       gst_gl_window_draw_unlocked (window,
           GST_VIDEO_INFO_WIDTH (&gl_sink->info),
           GST_VIDEO_INFO_HEIGHT (&gl_sink->info));
 
       gst_object_unref (window);
-      gst_object_unref (context);
     }
   }
   /* default opengl scene */
   else {
 #if GST_GL_HAVE_OPENGL
-    if (USING_OPENGL (gl_sink->display)) {
+    if (USING_OPENGL (gl_sink->context)) {
       GLfloat verts[8] = { 1.0f, 1.0f,
         -1.0f, 1.0f,
         -1.0f, -1.0f,
@@ -1064,7 +1054,7 @@ gst_glimage_sink_on_draw (const GstGLImageSink * gl_sink)
     }
 #endif
 #if GST_GL_HAVE_GLES2
-    if (USING_GLES2 (gl_sink->display)) {
+    if (USING_GLES2 (gl_sink->context)) {
       const GLfloat vVertices[] = { 1.0f, 1.0f, 0.0f,
         1.0f, 0.0f,
         -1.0f, 1.0f, 0.0f,
@@ -1107,7 +1097,7 @@ gst_glimage_sink_on_draw (const GstGLImageSink * gl_sink)
 static void
 gst_glimage_sink_on_close (GstGLImageSink * gl_sink)
 {
-  gst_gl_display_set_error (gl_sink->display, "Output window was closed");
+  gst_gl_context_set_error (gl_sink->context, "Output window was closed");
 
   g_atomic_int_set (&gl_sink->to_quit, 1);
 }
@@ -1115,17 +1105,15 @@ gst_glimage_sink_on_close (GstGLImageSink * gl_sink)
 static gboolean
 gst_glimage_sink_redisplay (GstGLImageSink * gl_sink)
 {
-  GstGLContext *context;
   GstGLWindow *window;
   gboolean alive;
 
-  context = gst_gl_display_get_context (gl_sink->display);
-  window = gst_gl_context_get_window (context);
+  window = gst_gl_context_get_window (gl_sink->context);
 
   if (window && gst_gl_window_is_running (window)) {
 
 #if GST_GL_HAVE_GLES2
-    if (USING_GLES2 (gl_sink->display)) {
+    if (USING_GLES2 (gl_sink->context)) {
       if (!gl_sink->redisplay_shader) {
         gst_gl_window_send_message (window,
             GST_GL_WINDOW_CB (gst_glimage_sink_thread_init_redisplay), gl_sink);
@@ -1141,7 +1129,6 @@ gst_glimage_sink_redisplay (GstGLImageSink * gl_sink)
   }
   alive = gst_gl_window_is_running (window);
   gst_object_unref (window);
-  gst_object_unref (context);
 
   return alive;
 }
diff --git a/gst/gl/gstglimagesink.h b/gst/gl/gstglimagesink.h
index 6371666..63809da 100644
--- a/gst/gl/gstglimagesink.h
+++ b/gst/gl/gstglimagesink.h
@@ -61,6 +61,7 @@ struct _GstGLImageSink
     GstVideoInfo info;
 
     GstGLDisplay *display;
+    GstGLContext *context;
     GstGLUpload *upload;
     GLuint     tex_id;
 
diff --git a/gst/gl/gstglmosaic.c b/gst/gl/gstglmosaic.c
index 293d7c7..09ec07c 100644
--- a/gst/gl/gstglmosaic.c
+++ b/gst/gl/gstglmosaic.c
@@ -176,7 +176,7 @@ gst_gl_mosaic_reset (GstGLMixer * mixer)
   mosaic->input_frames = NULL;
 
   //blocking call, wait the opengl thread has destroyed the shader
-  gst_gl_display_del_shader (mixer->display, mosaic->shader);
+  gst_gl_context_del_shader (mixer->context, mosaic->shader);
 }
 
 static gboolean
@@ -185,7 +185,7 @@ gst_gl_mosaic_init_shader (GstGLMixer * mixer, GstCaps * outcaps)
   GstGLMosaic *mosaic = GST_GL_MOSAIC (mixer);
 
   //blocking call, wait the opengl thread has compiled the shader
-  return gst_gl_display_gen_shader (mixer->display, mosaic_v_src, mosaic_f_src,
+  return gst_gl_context_gen_shader (mixer->context, mosaic_v_src, mosaic_f_src,
       &mosaic->shader);
 }
 
@@ -199,7 +199,7 @@ gst_gl_mosaic_process_textures (GstGLMixer * mix, GArray * in_textures,
   mosaic->input_frames = in_frames;
 
   //blocking call, use a FBO
-  gst_gl_display_use_fbo_v2 (mix->display,
+  gst_gl_context_use_fbo_v2 (mix->context,
       GST_VIDEO_INFO_WIDTH (&mix->out_info),
       GST_VIDEO_INFO_HEIGHT (&mix->out_info), mix->fbo, mix->depthbuffer,
       out_tex, gst_gl_mosaic_callback, (gpointer) mosaic);
@@ -213,7 +213,7 @@ gst_gl_mosaic_callback (gpointer stuff)
 {
   GstGLMosaic *mosaic = GST_GL_MOSAIC (stuff);
   GstGLMixer *mixer = GST_GL_MIXER (mosaic);
-  GstGLFuncs *gl = mixer->display->gl_vtable;
+  GstGLFuncs *gl = mixer->context->gl_vtable;
 
   static GLfloat xrot = 0;
   static GLfloat yrot = 0;
@@ -235,7 +235,7 @@ gst_gl_mosaic_callback (gpointer stuff)
 
   guint count = 0;
 
-  gst_gl_display_clear_shader (mixer->display);
+  gst_gl_context_clear_shader (mixer->context);
   gl->BindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
   gl->Disable (GL_TEXTURE_RECTANGLE_ARB);
 
@@ -360,7 +360,7 @@ gst_gl_mosaic_callback (gpointer stuff)
 
   gl->Disable (GL_DEPTH_TEST);
 
-  gst_gl_display_clear_shader (mixer->display);
+  gst_gl_context_clear_shader (mixer->context);
 
   xrot += 0.6f;
   yrot += 0.4f;
diff --git a/gst/gl/gstgloverlay.c b/gst/gl/gstgloverlay.c
index 81f6686..88b91cb 100644
--- a/gst/gl/gstgloverlay.c
+++ b/gst/gl/gstgloverlay.c
@@ -108,7 +108,7 @@ static void
 gst_gl_overlay_reset_gl_resources (GstGLFilter * filter)
 {
   GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->DeleteTextures (1, &overlay->pbuftexture);
 }
@@ -266,7 +266,7 @@ static void
 gst_gl_overlay_init_texture (GstGLOverlay * o, GLuint tex, int flag)
 {
   GstGLFilter *filter = GST_GL_FILTER (o);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   if (flag == 0 && o->type_file == 2) {
     gl->Enable (GL_TEXTURE_2D);
@@ -281,7 +281,7 @@ static void
 gst_gl_overlay_draw (GstGLOverlay * o, int flag)
 {
   GstGLFilter *filter = GST_GL_FILTER (o);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   float y = 0.0f;
   float width = 0.0f;
@@ -325,7 +325,7 @@ gst_gl_overlay_draw (GstGLOverlay * o, int flag)
   v_vertices[11] = y;
   v_vertices[16] = y;
 
-  gst_gl_display_clear_shader (filter->display);
+  gst_gl_context_clear_shader (filter->context);
 
   gl->ClientActiveTexture (GL_TEXTURE0);
   gl->EnableClientState (GL_TEXTURE_COORD_ARRAY);
@@ -368,7 +368,7 @@ static void
 gst_gl_overlay_load_texture (GstGLOverlay * o, GLuint tex, int flag)
 {
   GstGLFilter *filter = GST_GL_FILTER (o);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   gfloat video_ratio_w;
   gfloat video_ratio_h;
@@ -578,7 +578,7 @@ gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
 {
   GstGLOverlay *overlay = GST_GL_OVERLAY (stuff);
   GstGLFilter *filter = GST_GL_FILTER (overlay);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   gl->MatrixMode (GL_PROJECTION);
   gl->LoadIdentity ();
@@ -610,11 +610,11 @@ gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
 }
 
 static void
-init_pixbuf_texture (GstGLDisplay * display, gpointer data)
+init_pixbuf_texture (GstGLContext * context, gpointer data)
 {
   GstGLOverlay *overlay = GST_GL_OVERLAY (data);
   GstGLFilter *filter = GST_GL_FILTER (overlay);
-  const GstGLFuncs *gl = filter->display->gl_vtable;
+  const GstGLFuncs *gl = filter->context->gl_vtable;
 
   if (overlay->pixbuf) {
     gl->DeleteTextures (1, &overlay->pbuftexture);
@@ -633,8 +633,6 @@ init_pixbuf_texture (GstGLDisplay * display, gpointer data)
       gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     }
   }
-  //else
-  //  display->isAlive = FALSE;
 }
 
 static gboolean
@@ -647,8 +645,8 @@ gst_gl_overlay_filter_texture (GstGLFilter * filter, guint in_tex,
     if ((overlay->type_file = gst_gl_overlay_load_png (filter)) == 0)
       if ((overlay->type_file = gst_gl_overlay_load_jpeg (filter)) == 0)
         overlay->pixbuf = NULL;
-    /* if loader failed then display is turned off */
-    gst_gl_display_thread_add (filter->display, init_pixbuf_texture, overlay);
+    /* if loader failed then context is turned off */
+    gst_gl_context_thread_add (filter->context, init_pixbuf_texture, overlay);
     if (overlay->pixbuf) {
       free (overlay->pixbuf);
       overlay->pixbuf = NULL;
@@ -731,7 +729,7 @@ gst_gl_overlay_load_png (GstGLFilter * filter)
   png_byte magic[8];
   gint n_read;
 
-  if (!filter->display)
+  if (!filter->context)
     return 1;
 
   if ((fp = fopen (overlay->location, "rb")) == NULL)
diff --git a/gst/gl/gstgltestsrc.c b/gst/gl/gstgltestsrc.c
index 2f169b8..1aab25c 100644
--- a/gst/gl/gstgltestsrc.c
+++ b/gst/gl/gstgltestsrc.c
@@ -315,9 +315,9 @@ gst_gl_test_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps)
   out_width = GST_VIDEO_INFO_WIDTH (&gltestsrc->out_info);
   out_height = GST_VIDEO_INFO_HEIGHT (&gltestsrc->out_info);
 
-  if (!gst_gl_display_gen_fbo (gltestsrc->display, out_width, out_height,
+  if (!gst_gl_context_gen_fbo (gltestsrc->context, out_width, out_height,
           &gltestsrc->fbo, &gltestsrc->depthbuffer))
-    goto display_error;
+    goto context_error;
 
   return TRUE;
 
@@ -328,10 +328,10 @@ wrong_caps:
     return FALSE;
   }
 
-display_error:
+context_error:
   {
     GST_ELEMENT_ERROR (gltestsrc, RESOURCE, NOT_FOUND,
-        ("%s", gst_gl_display_get_error ()), (NULL));
+        ("%s", gst_gl_context_get_error ()), (NULL));
     return FALSE;
   }
 }
@@ -467,14 +467,14 @@ gst_gl_test_src_fill (GstPushSrc * psrc, GstBuffer * buffer)
         "attempting to wrap for download");
 
     if (!src->out_tex_id) {
-      gst_gl_display_gen_texture (src->display, &src->out_tex_id,
+      gst_gl_context_gen_texture (src->context, &src->out_tex_id,
           GST_VIDEO_FORMAT_RGBA, GST_VIDEO_FRAME_WIDTH (&out_frame),
           GST_VIDEO_FRAME_HEIGHT (&out_frame));
     }
     out_tex = src->out_tex_id;
 
     if (!src->download) {
-      src->download = gst_gl_download_new (src->display);
+      src->download = gst_gl_download_new (src->context);
 
       if (!gst_gl_download_init_format (src->download,
               GST_VIDEO_FRAME_FORMAT (&out_frame),
@@ -492,7 +492,7 @@ gst_gl_test_src_fill (GstPushSrc * psrc, GstBuffer * buffer)
   gst_buffer_replace (&src->buffer, buffer);
 
   //blocking call, generate a FBO
-  if (!gst_gl_display_use_fbo_v2 (src->display, width, height, src->fbo,
+  if (!gst_gl_context_use_fbo_v2 (src->context, width, height, src->fbo,
           src->depthbuffer, out_tex, gst_gl_test_src_callback,
           (gpointer) src)) {
     goto not_negotiated;
@@ -556,21 +556,20 @@ gst_gl_test_src_start (GstBaseSrc * basesrc)
   }
 
   id_value = gst_structure_get_value (structure, "gstgldisplay");
-  if (G_VALUE_HOLDS_POINTER (id_value))
+  if (G_VALUE_HOLDS_POINTER (id_value)) {
     /* at least one gl element is after in our gl chain */
     src->display =
         gst_object_ref (GST_GL_DISPLAY (g_value_get_pointer (id_value)));
-  else {
-    GstGLContext *context;
+    src->context = gst_gl_display_get_context (src->display);
+  } else {
     GError *error = NULL;
 
     GST_INFO ("Creating GstGLDisplay");
     src->display = gst_gl_display_new ();
-    context = gst_gl_context_new (src->display);
-    gst_gl_display_set_context (src->display, context);
-    gst_object_unref (context);
+    src->context = gst_gl_context_new (src->display);
+    gst_gl_display_set_context (src->display, src->context);
 
-    if (!gst_gl_context_create (context, 0, &error)) {
+    if (!gst_gl_context_create (src->context, 0, &error)) {
       GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
           ("%s", error->message), (NULL));
       return FALSE;
@@ -589,9 +588,9 @@ gst_gl_test_src_stop (GstBaseSrc * basesrc)
 {
   GstGLTestSrc *src = GST_GL_TEST_SRC (basesrc);
 
-  if (src->display) {
+  if (src->context) {
     if (src->out_tex_id) {
-      gst_gl_display_del_texture (src->display, &src->out_tex_id);
+      gst_gl_context_del_texture (src->context, &src->out_tex_id);
     }
 
     if (src->download) {
@@ -599,7 +598,12 @@ gst_gl_test_src_stop (GstBaseSrc * basesrc)
       src->download = NULL;
     }
     //blocking call, delete the FBO
-    gst_gl_display_del_fbo (src->display, src->fbo, src->depthbuffer);
+    gst_gl_context_del_fbo (src->context, src->fbo, src->depthbuffer);
+    gst_object_unref (src->context);
+    src->context = NULL;
+  }
+
+  if (src->display) {
     gst_object_unref (src->display);
     src->display = NULL;
   }
@@ -634,7 +638,7 @@ gst_gl_test_src_decide_allocation (GstBaseSrc * basesrc, GstQuery * query)
   }
 
   if (!pool)
-    pool = gst_gl_buffer_pool_new (src->display);
+    pool = gst_gl_buffer_pool_new (src->context);
 
   config = gst_buffer_pool_get_config (pool);
   gst_buffer_pool_config_set_params (config, caps, size, min, max);
diff --git a/gst/gl/gstgltestsrc.h b/gst/gl/gstgltestsrc.h
index 1f065a9..48e4d86 100644
--- a/gst/gl/gstgltestsrc.h
+++ b/gst/gl/gstgltestsrc.h
@@ -105,6 +105,7 @@ struct _GstGLTestSrc {
     GstGLDownload *download;
 
     GstGLDisplay *display;
+    GstGLContext *context;
     gint64 timestamp_offset;              /* base offset */
     GstClockTime running_time;            /* total running time */
     gint64 n_frames;                      /* total frames sent */