1 files changed, 65 insertions, 330 deletions

diff --git a/ext/eglgles/gstegladaptation.c b/ext/eglgles/gstegladaptation.c
index db6357d04..e075ea9f5 100644
--- a/ext/eglgles/gstegladaptation.c
+++ b/ext/eglgles/gstegladaptation.c
@@ -45,19 +45,6 @@
 #include <gst/video/video.h>
 #include "gstegladaptation.h"
 
-/* Some EGL implementations are reporting wrong
- * values for the display's EGL_PIXEL_ASPECT_RATIO.
- * They are required by the khronos specs to report
- * this value as w/h * EGL_DISPLAY_SCALING (Which is
- * a constant with value 10000) but at least the
- * Galaxy SIII (Android) is reporting just 1 when
- * w = h. We use these two to bound returned values to
- * sanity.
- */
-#define EGL_SANE_DAR_MIN ((EGL_DISPLAY_SCALING)/10)
-#define EGL_SANE_DAR_MAX ((EGL_DISPLAY_SCALING)*10)
-
-
 /* GLESv2 GLSL Shaders
  *
  * OpenGL ES Standard does not mandate YUV support. This is
@@ -212,35 +199,6 @@ static const char *frag_NV12_NV21_prog = {
 };
 /* *INDENT-ON* */
 
-/* will probably move elsewhere */
-static const EGLint eglglessink_RGBA8888_attribs[] = {
-  EGL_RED_SIZE, 8,
-  EGL_GREEN_SIZE, 8,
-  EGL_BLUE_SIZE, 8,
-  EGL_ALPHA_SIZE, 8,
-  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-  EGL_NONE
-};
-
-static const EGLint eglglessink_RGB888_attribs[] = {
-  EGL_RED_SIZE, 8,
-  EGL_GREEN_SIZE, 8,
-  EGL_BLUE_SIZE, 8,
-  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-  EGL_NONE
-};
-
-static const EGLint eglglessink_RGB565_attribs[] = {
-  EGL_RED_SIZE, 5,
-  EGL_GREEN_SIZE, 6,
-  EGL_BLUE_SIZE, 5,
-  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-  EGL_NONE
-};
-
 static gboolean
 create_shader_program (GstEglAdaptationContext * ctx, GLuint * prog,
     GLuint * vert, GLuint * frag, const gchar * vert_text,
@@ -337,62 +295,6 @@ HANDLE_ERROR:
 }
 
 
-gboolean
-gst_egl_adaptation_init_display (GstEglAdaptationContext * ctx)
-{
-  EGLDisplay display;
-  GST_DEBUG_OBJECT (ctx->element, "Enter EGL initial configuration");
-
-#ifdef USE_EGL_RPI
-  /* See https://github.com/raspberrypi/firmware/issues/99 */
-  if (!eglMakeCurrent ((EGLDisplay) 1, EGL_NO_SURFACE, EGL_NO_SURFACE,
-          EGL_NO_CONTEXT)) {
-    got_egl_error ("eglMakeCurrent");
-    GST_ERROR_OBJECT (ctx->element, "Couldn't unbind context");
-    return FALSE;
-  }
-#endif
-
-  display = eglGetDisplay (EGL_DEFAULT_DISPLAY);
-  if (display == EGL_NO_DISPLAY) {
-    GST_ERROR_OBJECT (ctx->element, "Could not get EGL display connection");
-    goto HANDLE_ERROR;          /* No EGL error is set by eglGetDisplay() */
-  }
-  ctx->eglglesctx.display = display;
-
-  if (!eglInitialize (display,
-          &ctx->eglglesctx.egl_major,
-          &ctx->eglglesctx.egl_minor)) {
-    got_egl_error ("eglInitialize");
-    GST_ERROR_OBJECT (ctx->element, "Could not init EGL display connection");
-    goto HANDLE_EGL_ERROR;
-  }
-
-  /* Check against required EGL version
-   * XXX: Need to review the version requirement in terms of the needed API
-   */
-  if (ctx->eglglesctx.egl_major < GST_EGLGLESSINK_EGL_MIN_VERSION) {
-    GST_ERROR_OBJECT (ctx->element, "EGL v%d needed, but you only have v%d.%d",
-        GST_EGLGLESSINK_EGL_MIN_VERSION, ctx->eglglesctx.egl_major,
-        ctx->eglglesctx.egl_minor);
-    goto HANDLE_ERROR;
-  }
-
-  GST_INFO_OBJECT (ctx->element, "System reports supported EGL version v%d.%d",
-      ctx->eglglesctx.egl_major, ctx->eglglesctx.egl_minor);
-
-  eglBindAPI (EGL_OPENGL_ES_API);
-
-  return TRUE;
-
-  /* Errors */
-HANDLE_EGL_ERROR:
-  GST_ERROR_OBJECT (ctx->element, "EGL call returned error %x", eglGetError ());
-HANDLE_ERROR:
-  GST_ERROR_OBJECT (ctx->element, "Couldn't setup window/surface from handle");
-  return FALSE;
-}
-
 GstEglAdaptationContext *
 gst_egl_adaptation_context_new (GstElement * element)
 {
@@ -427,12 +329,9 @@ got_egl_error (const char *wtf)
 gboolean
 gst_egl_adaptation_choose_config (GstEglAdaptationContext * ctx)
 {
-  EGLint con_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
-  GLint egl_configs;
+  gint egl_configs;
 
-  if ((eglChooseConfig (ctx->eglglesctx.display,
-              eglglessink_RGBA8888_attribs,
-              &ctx->eglglesctx.config, 1, &egl_configs)) == EGL_FALSE) {
+  if (!_gst_egl_choose_config (ctx, FALSE, &egl_configs)) {
     got_egl_error ("eglChooseConfig");
     GST_ERROR_OBJECT (ctx->element, "eglChooseConfig failed");
     goto HANDLE_EGL_ERROR;
@@ -444,18 +343,11 @@ gst_egl_adaptation_choose_config (GstEglAdaptationContext * ctx)
     goto HANDLE_ERROR;
   }
 
-  ctx->eglglesctx.eglcontext =
-      eglCreateContext (ctx->eglglesctx.display,
-      ctx->eglglesctx.config, EGL_NO_CONTEXT, con_attribs);
-
-  if (ctx->eglglesctx.eglcontext == EGL_NO_CONTEXT) {
+  if (!gst_egl_adaptation_create_egl_context (ctx)) {
     GST_ERROR_OBJECT (ctx->element, "Error getting context, eglCreateContext");
     goto HANDLE_EGL_ERROR;
   }
 
-  GST_DEBUG_OBJECT (ctx->element, "EGL Context: %p",
-      ctx->eglglesctx.eglcontext);
-
   return TRUE;
 
   /* Errors */
@@ -470,7 +362,6 @@ gint gst_egl_adaptation_context_fill_supported_fbuffer_configs
     (GstEglAdaptationContext * ctx, GstCaps ** ret_caps)
 {
   gboolean ret = FALSE;
-  EGLint cfg_number;
   GstCaps *caps;
 
   GST_DEBUG_OBJECT (ctx->element,
@@ -479,8 +370,7 @@ gint gst_egl_adaptation_context_fill_supported_fbuffer_configs
   /* Init supported format/caps list */
   caps = gst_caps_new_empty ();
 
-  if (eglChooseConfig (ctx->eglglesctx.display,
-          eglglessink_RGBA8888_attribs, NULL, 1, &cfg_number) != EGL_FALSE) {
+  if (_gst_egl_choose_config (ctx, TRUE, NULL)) {
     gst_caps_append (caps,
         gst_video_format_new_template_caps (GST_VIDEO_FORMAT_RGBA));
     gst_caps_append (caps,
@@ -533,45 +423,6 @@ gint gst_egl_adaptation_context_fill_supported_fbuffer_configs
   return ret;
 }
 
-gboolean
-gst_egl_adaptation_context_make_current (GstEglAdaptationContext * ctx,
-    gboolean bind)
-{
-  g_assert (ctx->eglglesctx.display != NULL);
-
-  if (bind && ctx->eglglesctx.surface &&
-      ctx->eglglesctx.eglcontext) {
-    EGLContext *cur_ctx = eglGetCurrentContext ();
-
-    if (cur_ctx == ctx->eglglesctx.eglcontext) {
-      GST_DEBUG_OBJECT (ctx->element,
-          "Already attached the context to thread %p", g_thread_self ());
-      return TRUE;
-    }
-
-    GST_DEBUG_OBJECT (ctx->element, "Attaching context to thread %p",
-        g_thread_self ());
-    if (!eglMakeCurrent (ctx->eglglesctx.display,
-            ctx->eglglesctx.surface, ctx->eglglesctx.surface,
-            ctx->eglglesctx.eglcontext)) {
-      got_egl_error ("eglMakeCurrent");
-      GST_ERROR_OBJECT (ctx->element, "Couldn't bind context");
-      return FALSE;
-    }
-  } else {
-    GST_DEBUG_OBJECT (ctx->element, "Detaching context from thread %p",
-        g_thread_self ());
-    if (!eglMakeCurrent (ctx->eglglesctx.display, EGL_NO_SURFACE,
-            EGL_NO_SURFACE, EGL_NO_CONTEXT)) {
-      got_egl_error ("eglMakeCurrent");
-      GST_ERROR_OBJECT (ctx->element, "Couldn't unbind context");
-      return FALSE;
-    }
-  }
-
-  return TRUE;
-}
-
 void
 gst_egl_adaptation_context_cleanup (GstEglAdaptationContext * ctx)
 {
@@ -580,144 +431,58 @@ gst_egl_adaptation_context_cleanup (GstEglAdaptationContext * ctx)
   glUseProgram (0);
 
   if (ctx->have_vbo) {
-    glDeleteBuffers (1, &ctx->eglglesctx.position_buffer);
-    glDeleteBuffers (1, &ctx->eglglesctx.index_buffer);
+    glDeleteBuffers (1, &ctx->position_buffer);
+    glDeleteBuffers (1, &ctx->index_buffer);
     ctx->have_vbo = FALSE;
   }
 
   if (ctx->have_texture) {
-    glDeleteTextures (ctx->eglglesctx.n_textures,
-        ctx->eglglesctx.texture);
+    glDeleteTextures (ctx->n_textures, ctx->texture);
     ctx->have_texture = FALSE;
-    ctx->eglglesctx.n_textures = 0;
+    ctx->n_textures = 0;
   }
 
   for (i = 0; i < 2; i++) {
-    if (ctx->eglglesctx.glslprogram[i]) {
-      glDetachShader (ctx->eglglesctx.glslprogram[i],
-          ctx->eglglesctx.fragshader[i]);
-      glDetachShader (ctx->eglglesctx.glslprogram[i],
-          ctx->eglglesctx.vertshader[i]);
-      glDeleteProgram (ctx->eglglesctx.glslprogram[i]);
-      glDeleteShader (ctx->eglglesctx.fragshader[i]);
-      glDeleteShader (ctx->eglglesctx.vertshader[i]);
-      ctx->eglglesctx.glslprogram[i] = 0;
-      ctx->eglglesctx.fragshader[i] = 0;
-      ctx->eglglesctx.vertshader[i] = 0;
+    if (ctx->glslprogram[i]) {
+      glDetachShader (ctx->glslprogram[i], ctx->fragshader[i]);
+      glDetachShader (ctx->glslprogram[i], ctx->vertshader[i]);
+      glDeleteProgram (ctx->glslprogram[i]);
+      glDeleteShader (ctx->fragshader[i]);
+      glDeleteShader (ctx->vertshader[i]);
+      ctx->glslprogram[i] = 0;
+      ctx->fragshader[i] = 0;
+      ctx->vertshader[i] = 0;
     }
   }
 
   gst_egl_adaptation_context_make_current (ctx, FALSE);
 
-  if (ctx->eglglesctx.surface) {
-    eglDestroySurface (ctx->eglglesctx.display,
-        ctx->eglglesctx.surface);
-    ctx->eglglesctx.surface = NULL;
-    ctx->have_surface = FALSE;
-  }
-
-  if (ctx->eglglesctx.eglcontext) {
-    eglDestroyContext (ctx->eglglesctx.display,
-        ctx->eglglesctx.eglcontext);
-    ctx->eglglesctx.eglcontext = NULL;
-  }
+  gst_egl_adaptation_destroy_surface (ctx);
+  gst_egl_adaptation_destroy_context (ctx);
 }
 
-/* XXX: Lock eglgles context? */
-gboolean
-gst_egl_adaptation_context_update_surface_dimensions (GstEglAdaptationContext *
-    ctx)
-{
-  gint width, height;
-
-  /* Save surface dims */
-  eglQuerySurface (ctx->eglglesctx.display,
-      ctx->eglglesctx.surface, EGL_WIDTH, &width);
-  eglQuerySurface (ctx->eglglesctx.display,
-      ctx->eglglesctx.surface, EGL_HEIGHT, &height);
-
-  if (width != ctx->eglglesctx.surface_width ||
-      height != ctx->eglglesctx.surface_height) {
-    ctx->eglglesctx.surface_width = width;
-    ctx->eglglesctx.surface_height = height;
-    GST_INFO_OBJECT (ctx->element, "Got surface of %dx%d pixels", width, height);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-
 gboolean
 gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     GstVideoFormat format)
 {
   GLboolean ret;
-  EGLint display_par;
   const gchar *texnames[3] = { NULL, };
   gchar *frag_prog = NULL;
   gboolean free_frag_prog = FALSE;
-  EGLint swap_behavior;
   gint i;
 
   GST_DEBUG_OBJECT (ctx->element, "Enter EGL surface setup");
 
-  ctx->eglglesctx.surface =
-      eglCreateWindowSurface (ctx->eglglesctx.display,
-      ctx->eglglesctx.config, ctx->eglglesctx.used_window,
-      NULL);
-
-  if (ctx->eglglesctx.surface == EGL_NO_SURFACE) {
-    got_egl_error ("eglCreateWindowSurface");
-    GST_ERROR_OBJECT (ctx->element, "Can't create surface");
+  if (!gst_egl_adaptation_create_surface (ctx)) {
     goto HANDLE_EGL_ERROR_LOCKED;
   }
 
-  ctx->eglglesctx.buffer_preserved = FALSE;
-  if (eglQuerySurface (ctx->eglglesctx.display,
-          ctx->eglglesctx.surface, EGL_SWAP_BEHAVIOR, &swap_behavior)) {
-    GST_DEBUG_OBJECT (ctx->element, "Buffer swap behavior %x", swap_behavior);
-    ctx->eglglesctx.buffer_preserved =
-        swap_behavior == EGL_BUFFER_PRESERVED;
-  } else {
-    GST_DEBUG_OBJECT (ctx->element, "Can't query buffer swap behavior");
-  }
+  gst_egl_adaptation_query_buffer_preserved (ctx);
 
   if (!gst_egl_adaptation_context_make_current (ctx, TRUE))
     goto HANDLE_EGL_ERROR_LOCKED;
 
-  /* Save display's pixel aspect ratio
-   *
-   * DAR is reported as w/h * EGL_DISPLAY_SCALING wich is
-   * a constant with value 10000. This attribute is only
-   * supported if the EGL version is >= 1.2
-   * XXX: Setup this as a property.
-   * or some other one time check. Right now it's being called once
-   * per frame.
-   */
-  if (ctx->eglglesctx.egl_major == 1 &&
-      ctx->eglglesctx.egl_minor < 2) {
-    GST_DEBUG_OBJECT (ctx->element, "Can't query PAR. Using default: %dx%d",
-        EGL_DISPLAY_SCALING, EGL_DISPLAY_SCALING);
-    ctx->eglglesctx.pixel_aspect_ratio = EGL_DISPLAY_SCALING;
-  } else {
-    eglQuerySurface (ctx->eglglesctx.display,
-        ctx->eglglesctx.surface, EGL_PIXEL_ASPECT_RATIO, &display_par);
-    /* Fix for outbound DAR reporting on some implementations not
-     * honoring the 'should return w/h * EGL_DISPLAY_SCALING' spec
-     * requirement
-     */
-    if (display_par == EGL_UNKNOWN || display_par < EGL_SANE_DAR_MIN ||
-        display_par > EGL_SANE_DAR_MAX) {
-      GST_DEBUG_OBJECT (ctx->element, "Nonsensical PAR value returned: %d. "
-          "Bad EGL implementation? "
-          "Will use default: %d/%d", ctx->eglglesctx.pixel_aspect_ratio,
-          EGL_DISPLAY_SCALING, EGL_DISPLAY_SCALING);
-      ctx->eglglesctx.pixel_aspect_ratio = EGL_DISPLAY_SCALING;
-    } else {
-      ctx->eglglesctx.pixel_aspect_ratio = display_par;
-    }
-  }
+  gst_egl_adaptation_query_par (ctx);
 
   /* Save surface dims */
   gst_egl_adaptation_context_update_surface_dimensions (ctx);
@@ -741,7 +506,7 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     case GST_VIDEO_FORMAT_AYUV:
       frag_prog = (gchar *) frag_AYUV_prog;
       free_frag_prog = FALSE;
-      ctx->eglglesctx.n_textures = 1;
+      ctx->n_textures = 1;
       texnames[0] = "tex";
       break;
     case GST_VIDEO_FORMAT_Y444:
@@ -751,7 +516,7 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     case GST_VIDEO_FORMAT_Y41B:
       frag_prog = (gchar *) frag_PLANAR_YUV_prog;
       free_frag_prog = FALSE;
-      ctx->eglglesctx.n_textures = 3;
+      ctx->n_textures = 3;
       texnames[0] = "Ytex";
       texnames[1] = "Utex";
       texnames[2] = "Vtex";
@@ -759,35 +524,35 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     case GST_VIDEO_FORMAT_YUY2:
       frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'r', 'g', 'a');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 2;
+      ctx->n_textures = 2;
       texnames[0] = "Ytex";
       texnames[1] = "UVtex";
       break;
     case GST_VIDEO_FORMAT_YVYU:
       frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'r', 'a', 'g');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 2;
+      ctx->n_textures = 2;
       texnames[0] = "Ytex";
       texnames[1] = "UVtex";
       break;
     case GST_VIDEO_FORMAT_UYVY:
       frag_prog = g_strdup_printf (frag_YUY2_YVYU_UYVY_prog, 'a', 'r', 'b');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 2;
+      ctx->n_textures = 2;
       texnames[0] = "Ytex";
       texnames[1] = "UVtex";
       break;
     case GST_VIDEO_FORMAT_NV12:
       frag_prog = g_strdup_printf (frag_NV12_NV21_prog, 'r', 'a');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 2;
+      ctx->n_textures = 2;
       texnames[0] = "Ytex";
       texnames[1] = "UVtex";
       break;
     case GST_VIDEO_FORMAT_NV21:
       frag_prog = g_strdup_printf (frag_NV12_NV21_prog, 'a', 'r');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 2;
+      ctx->n_textures = 2;
       texnames[0] = "Ytex";
       texnames[1] = "UVtex";
       break;
@@ -796,21 +561,21 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     case GST_VIDEO_FORMAT_BGRA:
       frag_prog = g_strdup_printf (frag_REORDER_prog, 'b', 'g', 'r');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 1;
+      ctx->n_textures = 1;
       texnames[0] = "tex";
       break;
     case GST_VIDEO_FORMAT_xRGB:
     case GST_VIDEO_FORMAT_ARGB:
       frag_prog = g_strdup_printf (frag_REORDER_prog, 'g', 'b', 'a');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 1;
+      ctx->n_textures = 1;
       texnames[0] = "tex";
       break;
     case GST_VIDEO_FORMAT_xBGR:
     case GST_VIDEO_FORMAT_ABGR:
       frag_prog = g_strdup_printf (frag_REORDER_prog, 'a', 'b', 'g');
       free_frag_prog = TRUE;
-      ctx->eglglesctx.n_textures = 1;
+      ctx->n_textures = 1;
       texnames[0] = "tex";
       break;
     case GST_VIDEO_FORMAT_RGB:
@@ -819,7 +584,7 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     case GST_VIDEO_FORMAT_RGB16:
       frag_prog = (gchar *) frag_COPY_prog;
       free_frag_prog = FALSE;
-      ctx->eglglesctx.n_textures = 1;
+      ctx->n_textures = 1;
       texnames[0] = "tex";
       break;
     default:
@@ -828,9 +593,9 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
   }
 
   if (!create_shader_program (ctx,
-          &ctx->eglglesctx.glslprogram[0],
-          &ctx->eglglesctx.vertshader[0],
-          &ctx->eglglesctx.fragshader[0], vert_COPY_prog, frag_prog)) {
+          &ctx->glslprogram[0],
+          &ctx->vertshader[0],
+          &ctx->fragshader[0], vert_COPY_prog, frag_prog)) {
     if (free_frag_prog)
       g_free (frag_prog);
     frag_prog = NULL;
@@ -840,39 +605,34 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
     g_free (frag_prog);
   frag_prog = NULL;
 
-  ctx->eglglesctx.position_loc[0] =
-      glGetAttribLocation (ctx->eglglesctx.glslprogram[0], "position");
-  ctx->eglglesctx.texpos_loc[0] =
-      glGetAttribLocation (ctx->eglglesctx.glslprogram[0], "texpos");
+  ctx->position_loc[0] = glGetAttribLocation (ctx->glslprogram[0], "position");
+  ctx->texpos_loc[0] = glGetAttribLocation (ctx->glslprogram[0], "texpos");
 
-  glEnableVertexAttribArray (ctx->eglglesctx.position_loc[0]);
+  glEnableVertexAttribArray (ctx->position_loc[0]);
   if (got_gl_error ("glEnableVertexAttribArray"))
     goto HANDLE_ERROR;
 
-  glEnableVertexAttribArray (ctx->eglglesctx.texpos_loc[0]);
+  glEnableVertexAttribArray (ctx->texpos_loc[0]);
   if (got_gl_error ("glEnableVertexAttribArray"))
     goto HANDLE_ERROR;
 
-  for (i = 0; i < ctx->eglglesctx.n_textures; i++) {
-    ctx->eglglesctx.tex_loc[0][i] =
-        glGetUniformLocation (ctx->eglglesctx.glslprogram[0],
-        texnames[i]);
+  for (i = 0; i < ctx->n_textures; i++) {
+    ctx->tex_loc[0][i] =
+        glGetUniformLocation (ctx->glslprogram[0], texnames[i]);
   }
 
-  if (!ctx->eglglesctx.buffer_preserved) {
+  if (!ctx->buffer_preserved) {
     /* Build shader program for black borders */
     if (!create_shader_program (ctx,
-            &ctx->eglglesctx.glslprogram[1],
-            &ctx->eglglesctx.vertshader[1],
-            &ctx->eglglesctx.fragshader[1], vert_COPY_prog_no_tex,
-            frag_BLACK_prog))
+            &ctx->glslprogram[1],
+            &ctx->vertshader[1],
+            &ctx->fragshader[1], vert_COPY_prog_no_tex, frag_BLACK_prog))
       goto HANDLE_ERROR;
 
-    ctx->eglglesctx.position_loc[1] =
-        glGetAttribLocation (ctx->eglglesctx.glslprogram[1],
-        "position");
+    ctx->position_loc[1] =
+        glGetAttribLocation (ctx->glslprogram[1], "position");
 
-    glEnableVertexAttribArray (ctx->eglglesctx.position_loc[1]);
+    glEnableVertexAttribArray (ctx->position_loc[1]);
     if (got_gl_error ("glEnableVertexAttribArray"))
       goto HANDLE_ERROR;
   }
@@ -881,13 +641,12 @@ gst_egl_adaptation_init_egl_surface (GstEglAdaptationContext * ctx,
   if (!ctx->have_texture) {
     GST_INFO_OBJECT (ctx->element, "Performing initial texture setup");
 
-    glGenTextures (ctx->eglglesctx.n_textures,
-        ctx->eglglesctx.texture);
+    glGenTextures (ctx->n_textures, ctx->texture);
     if (got_gl_error ("glGenTextures"))
       goto HANDLE_ERROR_LOCKED;
 
-    for (i = 0; i < ctx->eglglesctx.n_textures; i++) {
-      glBindTexture (GL_TEXTURE_2D, ctx->eglglesctx.texture[i]);
+    for (i = 0; i < ctx->n_textures; i++) {
+      glBindTexture (GL_TEXTURE_2D, ctx->texture[i]);
       if (got_gl_error ("glBindTexture"))
         goto HANDLE_ERROR;
 
@@ -932,51 +691,27 @@ got_gl_error (const char *wtf)
   return FALSE;
 }
 
-
 void
-gst_egl_adaptation_context_terminate_display (GstEglAdaptationContext * ctx)
+gst_egl_adaptation_context_set_window (GstEglAdaptationContext * ctx,
+    EGLNativeWindowType window)
 {
-  if (ctx->eglglesctx.display) {
-    eglTerminate (ctx->eglglesctx.display);
-    ctx->eglglesctx.display = NULL;
-  }
+  ctx->window = window;
 }
 
-void
-gst_egl_adaptation_context_bind_API (GstEglAdaptationContext * ctx)
+GLuint
+gst_egl_adaptation_context_get_texture (GstEglAdaptationContext * ctx, gint i)
 {
-  eglBindAPI (EGL_OPENGL_ES_API);
+  return ctx->texture[i];
 }
 
-gboolean
-gst_egl_adaptation_context_swap_buffers (GstEglAdaptationContext * ctx)
+gint
+gst_egl_adaptation_context_get_surface_width (GstEglAdaptationContext * ctx)
 {
-  gboolean ret =
-      eglSwapBuffers (ctx->eglglesctx.display, ctx->eglglesctx.surface);
-  if (ret == EGL_FALSE) {
-    got_egl_error ("eglSwapBuffers");
-  }
-  return ret;
+  return ctx->surface_width;
 }
 
-/* Prints avilable EGL/GLES extensions 
- * If another rendering path is implemented this is the place
- * where you want to check for the availability of its supporting
- * EGL/GLES extensions.
- */
-void
-gst_egl_adaptation_context_init_egl_exts (GstEglAdaptationContext * ctx)
+gint
+gst_egl_adaptation_context_get_surface_height (GstEglAdaptationContext * ctx)
 {
-  const char *eglexts;
-  unsigned const char *glexts;
-
-  eglexts = eglQueryString (ctx->eglglesctx.display, EGL_EXTENSIONS);
-  glexts = glGetString (GL_EXTENSIONS);
-
-  GST_DEBUG_OBJECT (ctx->element, "Available EGL extensions: %s\n",
-      GST_STR_NULL (eglexts));
-  GST_DEBUG_OBJECT (ctx->element, "Available GLES extensions: %s\n",
-      GST_STR_NULL ((const char *) glexts));
-
-  return;
+  return ctx->surface_height;
 }