/*

 * GStreamer

 * Copyright (C) 2007 David A. Schleef <ds@schleef.org>

 * Copyright (C) 2008 Julien Isorce <julien.isorce@gmail.com>

 * Copyright (C) 2008 Filippo Argiolas <filippo.argiolas@gmail.com>

 * Copyright (C) 2013 Matthew Waters <ystreet00@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstgldisplay

 * @short_description: window system display connection abstraction

 * @title: GstGLDisplay

 * @see_also: #GstContext, #GstGLContext, #GstGLWindow

 *

 * #GstGLDisplay represents a connection to the underlying windowing system.

 * Elements are required to make use of #GstContext to share and propogate

 * a #GstGLDisplay.

 *

 * There are a number of environment variables that influence the choice of

 * platform and window system specific functionality.

 * - GST_GL_WINDOW influences the window system to use.  Common values are

 *   'x11', 'wayland', 'win32' or 'cocoa'.

 * - GST_GL_PLATFORM influences the OpenGL platform to use.  Common values are

 *   'egl', 'glx', 'wgl' or 'cgl'.

 * - GST_GL_API influences the OpenGL API requested by the OpenGL platform.

 *   Common values are 'opengl', 'opengl3' and 'gles2'.

 *

 * > Certain window systems require a special function to be called to

 * > initialize threading support.  As this GStreamer GL library does not preclude

 * > concurrent access to the windowing system, it is strongly advised that

 * > applications ensure that threading support has been initialized before any

 * > other toolkit/library functionality is accessed.  Failure to do so could

 * > result in sudden application abortion during execution.  The most notably

 * > example of such a function is X11's XInitThreads\().

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gl.h"

#include "gstgldisplay.h"

#if GST_GL_HAVE_WINDOW_COCOA

#include <gst/gl/cocoa/gstgldisplay_cocoa.h>

#endif

#if GST_GL_HAVE_WINDOW_X11

#include <gst/gl/x11/gstgldisplay_x11.h>

#endif

#if GST_GL_HAVE_WINDOW_WAYLAND

#include <gst/gl/wayland/gstgldisplay_wayland.h>

#endif

#if GST_GL_HAVE_PLATFORM_EGL

#include <gst/gl/egl/gstgldisplay_egl.h>

#include <gst/gl/egl/gsteglimage.h>

#include <gst/gl/egl/gstglmemoryegl.h>

#endif

#if GST_GL_HAVE_WINDOW_VIV_FB

#include <gst/gl/viv-fb/gstgldisplay_viv_fb.h>

#endif

#if GST_GL_HAVE_WINDOW_GBM

#include <gst/gl/gbm/gstgldisplay_gbm.h>

#endif

GST_DEBUG_CATEGORY_STATIC (gst_context);

GST_DEBUG_CATEGORY_STATIC (gst_gl_display_debug);

#define GST_CAT_DEFAULT gst_gl_display_debug

#define DEBUG_INIT \

  GST_DEBUG_CATEGORY_INIT (gst_gl_display_debug, "gldisplay", 0, "opengl display"); \

  GST_DEBUG_CATEGORY_GET (gst_context, "GST_CONTEXT");

G_DEFINE_TYPE_WITH_CODE (GstGLDisplay, gst_gl_display, GST_TYPE_OBJECT,

    DEBUG_INIT);

#define GST_GL_DISPLAY_GET_PRIVATE(o) \

  (G_TYPE_INSTANCE_GET_PRIVATE((o), GST_TYPE_GL_DISPLAY, GstGLDisplayPrivate))

enum

{

  SIGNAL_0,

  CREATE_CONTEXT,

  LAST_SIGNAL

};

static guint gst_gl_display_signals[LAST_SIGNAL] = { 0 };

static void gst_gl_display_dispose (GObject * object);

static void gst_gl_display_finalize (GObject * object);

static guintptr gst_gl_display_default_get_handle (GstGLDisplay * display);

static GstGLWindow *gst_gl_display_default_create_window (GstGLDisplay *

    display);

struct _GstGLDisplayPrivate

{

  GstGLAPI gl_api;

  GList *contexts;

  GThread *event_thread;

  GMutex thread_lock;

  GCond thread_cond;

};

static gboolean

_unlock_main_thread (GstGLDisplay * display)

{

  g_mutex_unlock (&display->priv->thread_lock);

  return G_SOURCE_REMOVE;

}

static gpointer

_event_thread_main (GstGLDisplay * display)

{

  g_mutex_lock (&display->priv->thread_lock);

  display->main_context = g_main_context_new ();

  display->main_loop = g_main_loop_new (display->main_context, FALSE);

  g_main_context_invoke (display->main_context,

      (GSourceFunc) _unlock_main_thread, display);

  g_cond_broadcast (&display->priv->thread_cond);

  g_main_loop_run (display->main_loop);

  g_mutex_lock (&display->priv->thread_lock);

  g_main_loop_unref (display->main_loop);

  g_main_context_unref (display->main_context);

  display->main_loop = NULL;

  display->main_context = NULL;

  g_cond_broadcast (&display->priv->thread_cond);

  g_mutex_unlock (&display->priv->thread_lock);

  return NULL;

}

static void

gst_gl_display_class_init (GstGLDisplayClass * klass)

{

  g_type_class_add_private (klass, sizeof (GstGLDisplayPrivate));

  /**

   * GstGLDisplay::create-context:

   * @object: the #GstGLDisplay

   * @context: (transfer none): other context to share resources with.

   *

   * Overrides the @GstGLContext creation mechanism.

   * It can be called in any thread and it is emitted with

   * display's object lock held.

   *

   * Returns: (transfer full): the new context.

   */

  gst_gl_display_signals[CREATE_CONTEXT] =

      g_signal_new ("create-context", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      GST_TYPE_GL_CONTEXT, 1, GST_TYPE_GL_CONTEXT);

  klass->get_handle = gst_gl_display_default_get_handle;

  klass->create_window = gst_gl_display_default_create_window;

  G_OBJECT_CLASS (klass)->finalize = gst_gl_display_finalize;

  G_OBJECT_CLASS (klass)->dispose = gst_gl_display_dispose;

}

static void

gst_gl_display_init (GstGLDisplay * display)

{

  display->priv = GST_GL_DISPLAY_GET_PRIVATE (display);

  display->type = GST_GL_DISPLAY_TYPE_ANY;

  display->priv->gl_api = GST_GL_API_ANY;

  g_mutex_init (&display->priv->thread_lock);

  g_cond_init (&display->priv->thread_cond);

  display->priv->event_thread = g_thread_new ("gldisplay-event",

      (GThreadFunc) _event_thread_main, display);

  g_mutex_lock (&display->priv->thread_lock);

  while (!display->main_loop)

    g_cond_wait (&display->priv->thread_cond, &display->priv->thread_lock);

  g_mutex_unlock (&display->priv->thread_lock);

  GST_TRACE ("init %p", display);

  gst_gl_buffer_init_once ();

  gst_gl_memory_pbo_init_once ();

  gst_gl_renderbuffer_init_once ();

#if GST_GL_HAVE_PLATFORM_EGL

  gst_gl_memory_egl_init_once ();

#endif

}

static void

gst_gl_display_dispose (GObject * object)

{

  GstGLDisplay *display = GST_GL_DISPLAY (object);

  if (display->main_loop)

    g_main_loop_quit (display->main_loop);

  if (display->priv->event_thread) {

    /* can't use g_thread_join() as we could lose the last ref from a user

     * function */

    g_mutex_lock (&display->priv->thread_lock);

    while (display->main_loop)

      g_cond_wait (&display->priv->thread_cond, &display->priv->thread_lock);

    g_mutex_unlock (&display->priv->thread_lock);

    g_thread_unref (display->priv->event_thread);

  }

  display->priv->event_thread = NULL;

  if (display->event_source) {

    g_source_destroy (display->event_source);

    g_source_unref (display->event_source);

  }

  display->event_source = NULL;

  G_OBJECT_CLASS (gst_gl_display_parent_class)->dispose (object);

}

static void

gst_gl_display_finalize (GObject * object)

{

  GstGLDisplay *display = GST_GL_DISPLAY (object);

  GList *l;

  GST_TRACE_OBJECT (object, "finalizing");

  for (l = display->priv->contexts; l; l = l->next) {

    g_weak_ref_clear ((GWeakRef *) l->data);

    g_free (l->data);

  }

  g_list_free (display->windows);

  g_list_free (display->priv->contexts);

  g_cond_clear (&display->priv->thread_cond);

  g_mutex_clear (&display->priv->thread_lock);

  G_OBJECT_CLASS (gst_gl_display_parent_class)->finalize (object);

}

/**

 * gst_gl_display_new:

 *

 * Returns: (transfer full): a new #GstGLDisplay

 *

 * Since: 1.4

 */

GstGLDisplay *

gst_gl_display_new (void)

{

  GstGLDisplay *display = NULL;

  const gchar *user_choice, *platform_choice;

  static volatile gsize _init = 0;

  if (g_once_init_enter (&_init)) {

    GST_DEBUG_CATEGORY_INIT (gst_gl_display_debug, "gldisplay", 0,

        "gldisplay element");

    g_once_init_leave (&_init, 1);

  }

  user_choice = g_getenv ("GST_GL_WINDOW");

  platform_choice = g_getenv ("GST_GL_PLATFORM");

  GST_INFO ("creating a display, user choice:%s (platform: %s)",

      GST_STR_NULL (user_choice), GST_STR_NULL (platform_choice));

#if GST_GL_HAVE_WINDOW_COCOA

  if (!display && (!user_choice || g_strstr_len (user_choice, 5, "cocoa"))) {

    display = GST_GL_DISPLAY (gst_gl_display_cocoa_new ());

    if (!display)

      return NULL;

  }

#endif

#if GST_GL_HAVE_WINDOW_WAYLAND

  if (!display && (!user_choice || g_strstr_len (user_choice, 7, "wayland")))

    display = GST_GL_DISPLAY (gst_gl_display_wayland_new (NULL));

#endif

#if GST_GL_HAVE_WINDOW_X11

  if (!display && (!user_choice || g_strstr_len (user_choice, 3, "x11")))

    display = GST_GL_DISPLAY (gst_gl_display_x11_new (NULL));

#endif

#if GST_GL_HAVE_WINDOW_VIV_FB

  if (!display && (!user_choice || g_strstr_len (user_choice, 6, "viv-fb"))) {

    const gchar *disp_idx_str = NULL;

    gint disp_idx = 0;

    disp_idx_str = g_getenv ("GST_GL_VIV_FB");

    if (disp_idx_str) {

      gint64 v = g_ascii_strtoll (disp_idx_str, NULL, 10);

      if (v >= G_MININT && v <= G_MAXINT)

        disp_idx = v;

    }

    display = GST_GL_DISPLAY (gst_gl_display_viv_fb_new (disp_idx));

  }

#endif

#if GST_GL_HAVE_WINDOW_GBM

  if (!display && (!user_choice || g_strstr_len (user_choice, 3, "gbm"))) {

    display = GST_GL_DISPLAY (gst_gl_display_gbm_new ());

  }

#endif

#if GST_GL_HAVE_PLATFORM_EGL

  if (!display && (!platform_choice

          || g_strstr_len (platform_choice, 3, "egl")))

    display = GST_GL_DISPLAY (gst_gl_display_egl_new ());

#endif

  if (!display) {

    GST_INFO ("Could not create platform/winsys display. user specified %s "

        "(platform: %s), creating dummy",

        GST_STR_NULL (user_choice), GST_STR_NULL (platform_choice));

    display = g_object_new (GST_TYPE_GL_DISPLAY, NULL);

    gst_object_ref_sink (display);

  }

  return display;

}

/**

 * gst_gl_display_get_handle:

 * @display: a #GstGLDisplay

 *

 * Returns: the native handle for the display

 *

 * Since: 1.4

 */

guintptr

gst_gl_display_get_handle (GstGLDisplay * display)

{

  GstGLDisplayClass *klass;

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), 0);

  klass = GST_GL_DISPLAY_GET_CLASS (display);

  g_return_val_if_fail (klass->get_handle != NULL, 0);

  return klass->get_handle (display);

}

static guintptr

gst_gl_display_default_get_handle (GstGLDisplay * display)

{

  return 0;

}

/**

 * gst_gl_display_filter_gl_api:

 * @display: a #GstGLDisplay

 * @gl_api: a #GstGLAPI to filter with

 *

 * limit the use of OpenGL to the requested @gl_api.  This is intended to allow

 * application and elements to request a specific set of OpenGL API's based on

 * what they support.  See gst_gl_context_get_gl_api() for the retreiving the

 * API supported by a #GstGLContext.

 */

void

gst_gl_display_filter_gl_api (GstGLDisplay * display, GstGLAPI gl_api)

{

  gchar *gl_api_s;

  g_return_if_fail (GST_IS_GL_DISPLAY (display));

  gl_api_s = gst_gl_api_to_string (gl_api);

  GST_TRACE_OBJECT (display, "filtering with api %s", gl_api_s);

  g_free (gl_api_s);

  GST_OBJECT_LOCK (display);

  display->priv->gl_api &= gl_api;

  GST_OBJECT_UNLOCK (display);

}

GstGLAPI

gst_gl_display_get_gl_api_unlocked (GstGLDisplay * display)

{

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), GST_GL_API_NONE);

  return display->priv->gl_api;

}

/**

 * gst_gl_display_get_gl_api:

 * @display: a #GstGLDisplay

 *

 * see gst_gl_display_filter_gl_api() for what the returned value represents

 *

 * Returns: the #GstGLAPI configured for @display

 */

GstGLAPI

gst_gl_display_get_gl_api (GstGLDisplay * display)

{

  GstGLAPI ret;

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), GST_GL_API_NONE);

  GST_OBJECT_LOCK (display);

  ret = display->priv->gl_api;

  GST_OBJECT_UNLOCK (display);

  return ret;

}

/**

 * gst_gl_display_get_handle_type:

 * @display: a #GstGLDisplay

 *

 * Returns: the #GstGLDisplayType of @display

 *

 * Since: 1.4

 */

GstGLDisplayType

gst_gl_display_get_handle_type (GstGLDisplay * display)

{

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), GST_GL_DISPLAY_TYPE_NONE);

  return display->type;

}

/**

 * gst_context_set_gl_display:

 * @context: a #GstContext

 * @display: (transfer none): resulting #GstGLDisplay

 *

 * Sets @display on @context

 *

 * Since: 1.4

 */

void

gst_context_set_gl_display (GstContext * context, GstGLDisplay * display)

{

  GstStructure *s;

  g_return_if_fail (context != NULL);

  if (display)

    GST_CAT_LOG (gst_context,

        "setting GstGLDisplay(%" GST_PTR_FORMAT ") on context(%" GST_PTR_FORMAT

        ")", display, context);

  s = gst_context_writable_structure (context);

  gst_structure_set (s, GST_GL_DISPLAY_CONTEXT_TYPE, GST_TYPE_GL_DISPLAY,

      display, NULL);

}

/**

 * gst_context_get_gl_display:

 * @context: a #GstContext

 * @display: (out) (transfer full): resulting #GstGLDisplay

 *

 * Returns: Whether @display was in @context

 *

 * Since: 1.4

 */

gboolean

gst_context_get_gl_display (GstContext * context, GstGLDisplay ** display)

{

  const GstStructure *s;

  gboolean ret;

  g_return_val_if_fail (display != NULL, FALSE);

  g_return_val_if_fail (context != NULL, FALSE);

  s = gst_context_get_structure (context);

  ret = gst_structure_get (s, GST_GL_DISPLAY_CONTEXT_TYPE,

      GST_TYPE_GL_DISPLAY, display, NULL);

  GST_CAT_LOG (gst_context, "got GstGLDisplay(%p) from context(%p)", *display,

      context);

  return ret;

}

/**

 * gst_gl_display_create_context:

 * @display: a #GstGLDisplay

 * @other_context: (transfer none): other #GstGLContext to share resources with.

 * @p_context: (transfer full) (out): resulting #GstGLContext

 * @error: (allow-none): resulting #GError

 *

 * It requires the display's object lock to be held.

 *

 * Returns: whether a new context could be created.

 *

 * Since: 1.6

 */

gboolean

gst_gl_display_create_context (GstGLDisplay * display,

    GstGLContext * other_context, GstGLContext ** p_context, GError ** error)

{

  GstGLContext *context = NULL;

  gboolean ret = FALSE;

  g_return_val_if_fail (display != NULL, FALSE);

  g_return_val_if_fail (p_context != NULL, FALSE);

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  g_signal_emit (display, gst_gl_display_signals[CREATE_CONTEXT], 0,

      other_context, &context);

  if (context) {

    *p_context = context;

    return TRUE;

  }

  context = gst_gl_context_new (display);

  if (!context) {

    g_set_error (error, GST_GL_CONTEXT_ERROR, GST_GL_CONTEXT_ERROR_FAILED,

        "Failed to create GL context");

    return FALSE;

  }

  GST_DEBUG_OBJECT (display,

      "creating context %" GST_PTR_FORMAT " from other context %"

      GST_PTR_FORMAT, context, other_context);

  ret = gst_gl_context_create (context, other_context, error);

  if (ret)

    *p_context = context;

  return ret;

}

/**

 * gst_gl_display_create_window:

 * @display: a #GstGLDisplay

 *

 * It requires the display's object lock to be held.

 *

 * Returns: (transfer full): a new #GstGLWindow for @display or %NULL.

 */

GstGLWindow *

gst_gl_display_create_window (GstGLDisplay * display)

{

  GstGLDisplayClass *klass;

  GstGLWindow *window;

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), NULL);

  klass = GST_GL_DISPLAY_GET_CLASS (display);

  g_return_val_if_fail (klass->create_window != NULL, NULL);

  window = klass->create_window (display);

  if (window)

    display->windows = g_list_prepend (display->windows, window);

  return window;

}

static GstGLWindow *

gst_gl_display_default_create_window (GstGLDisplay * display)

{

  return gst_gl_window_new (display);

}

/**

 * gst_gl_display_remove_window:

 * @display: a #GstGLDisplay

 * @window: a #GstGLWindow to remove

 *

 * Returns: if @window could be removed from @display

 *

 * Since: 1.12

 */

gboolean

gst_gl_display_remove_window (GstGLDisplay * display, GstGLWindow * window)

{

  gboolean ret = FALSE;

  GList *l;

  GST_OBJECT_LOCK (display);

  l = g_list_find (display->windows, window);

  if (l) {

    display->windows = g_list_delete_link (display->windows, l);

    ret = TRUE;

  }

  GST_OBJECT_UNLOCK (display);

  return ret;

}

/**

 * gst_gl_display_find_window:

 * @display: a #GstGLDisplay

 * @data: (closure): some data to pass to @compare_func

 * @compare_func: (scope call): a comparison function to run

 *

 * Execute @compare_func over the list of windows stored by @display.  The

 * first argment to @compare_func is the #GstGLWindow being checked and the

 * second argument is @data.

 *

 * Returns: (transfer none): The first #GstGLWindow that causes a match

 *          from @compare_func

 *

 * Since: 1.12

 */

GstGLWindow *

gst_gl_display_find_window (GstGLDisplay * display, gpointer data,

    GCompareFunc compare_func)

{

  GstGLWindow *ret = NULL;

  GList *l;

  GST_OBJECT_LOCK (display);

  l = g_list_find_custom (display->windows, data, compare_func);

  if (l)

    ret = l->data;

  GST_OBJECT_UNLOCK (display);

  return ret;

}

static GstGLContext *

_get_gl_context_for_thread_unlocked (GstGLDisplay * display, GThread * thread)

{

  GstGLContext *context = NULL;

  GList *prev = NULL, *l = display->priv->contexts;

  while (l) {

    GWeakRef *ref = l->data;

    GThread *context_thread;

    context = g_weak_ref_get (ref);

    if (!context) {

      /* remove dead contexts */

      g_weak_ref_clear (l->data);

      g_free (l->data);

      display->priv->contexts = g_list_delete_link (display->priv->contexts, l);

      l = prev ? prev->next : display->priv->contexts;

      continue;

    }

    if (thread == NULL) {

      GST_DEBUG_OBJECT (display, "Returning GL context %" GST_PTR_FORMAT " for "

          "NULL thread", context);

      return context;

    }

    context_thread = gst_gl_context_get_thread (context);

    if (thread != context_thread) {

      g_thread_unref (context_thread);

      gst_object_unref (context);

      prev = l;

      l = l->next;

      continue;

    }

    if (context_thread)

      g_thread_unref (context_thread);

    GST_DEBUG_OBJECT (display, "Returning GL context %" GST_PTR_FORMAT " for "

        "thread %p", context, thread);

    return context;

  }

  GST_DEBUG_OBJECT (display, "No GL context for thread %p", thread);

  return NULL;

}

/**

 * gst_gl_display_get_gl_context_for_thread:

 * @display: a #GstGLDisplay

 * @thread: a #GThread

 *

 * Returns: (transfer full): the #GstGLContext current on @thread or %NULL

 *

 * Must be called with the object lock held.

 *

 * Since: 1.6

 */

GstGLContext *

gst_gl_display_get_gl_context_for_thread (GstGLDisplay * display,

    GThread * thread)

{

  GstGLContext *context;

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), NULL);

  context = _get_gl_context_for_thread_unlocked (display, thread);

  GST_DEBUG_OBJECT (display, "returning context %" GST_PTR_FORMAT " for thread "

      "%p", context, thread);

  return context;

}

static gboolean

_check_collision (GstGLContext * context, GstGLContext * collision)

{

  GThread *thread, *collision_thread;

  gboolean ret = FALSE;

  if (!context || !collision)

    return FALSE;

  thread = gst_gl_context_get_thread (context);

  collision_thread = gst_gl_context_get_thread (collision);

  if (!thread || !collision_thread) {

    ret = FALSE;

    goto out;

  }

  if (thread == collision_thread) {

    ret = TRUE;

    goto out;

  }

out:

  if (thread)

    g_thread_unref (thread);

  if (collision_thread)

    g_thread_unref (collision_thread);

  return ret;

}

/**

 * gst_gl_display_add_context:

 * @display: a #GstGLDisplay

 * @context: (transfer none): a #GstGLContext

 *

 * Returns: whether @context was successfully added. %FALSE may be returned

 * if there already exists another context for @context's active thread.

 *

 * Must be called with the object lock held.

 *

 * Since: 1.6

 */

gboolean

gst_gl_display_add_context (GstGLDisplay * display, GstGLContext * context)

{

  GstGLContext *collision = NULL;

  GstGLDisplay *context_display;

  gboolean ret = TRUE;

  GThread *thread;

  GWeakRef *ref;

  g_return_val_if_fail (GST_IS_GL_DISPLAY (display), FALSE);

  g_return_val_if_fail (GST_IS_GL_CONTEXT (context), FALSE);

  context_display = gst_gl_context_get_display (context);

  g_assert (context_display == display);

  gst_object_unref (context_display);

  thread = gst_gl_context_get_thread (context);

  if (thread) {

    collision = _get_gl_context_for_thread_unlocked (display, thread);

    g_thread_unref (thread);

    /* adding the same context is a no-op */

    if (context == collision) {

      GST_LOG_OBJECT (display, "Attempting to add the same GL context %"

          GST_PTR_FORMAT ". Ignoring", context);

      ret = TRUE;

      goto out;

    }

    if (_check_collision (context, collision)) {

      GST_DEBUG_OBJECT (display, "Collision detected adding GL context "

          "%" GST_PTR_FORMAT, context);

      ret = FALSE;

      goto out;

    }

  }

  ref = g_new0 (GWeakRef, 1);

  g_weak_ref_init (ref, context);

  GST_DEBUG_OBJECT (display, "Adding GL context %" GST_PTR_FORMAT, context);

  display->priv->contexts = g_list_prepend (display->priv->contexts, ref);

out:

  if (collision)

    gst_object_unref (collision);

  GST_DEBUG_OBJECT (display, "%ssuccessfully inserted context %" GST_PTR_FORMAT,

      ret ? "" : "un", context);

  return ret;

}