gstreamer/gst-libs/gst/vaapi/gstvaapiutils_egl.c
Matthew Waters d270654c48 gst: don't use volatile to mean atomic
volatile is not sufficient to provide atomic guarantees and real atomics
should be used instead.  GCC 11 has started warning about using volatile
with atomic operations.

https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1719

Discovered in https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/868

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-vaapi/-/merge_requests/418>
2021-03-19 19:03:54 +11:00

1485 lines
40 KiB
C

/*
* gstvaapiutils_egl.c - EGL utilities
*
* Copyright (C) 2014 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301
*/
#include "sysdeps.h"
#include "gstvaapiutils_egl.h"
#if USE_GST_GL_HELPERS
# include <gst/gl/gl.h>
# if GST_GL_HAVE_PLATFORM_EGL
# include <gst/gl/egl/gstgldisplay_egl.h>
# endif
#endif
#define DEBUG 1
#include "gstvaapidebug.h"
typedef struct egl_message_s EglMessage;
struct egl_message_s
{
EglObject base;
EglContextRunFunc func;
gpointer args;
};
static void
egl_message_finalize (EglMessage * msg)
{
}
/* ------------------------------------------------------------------------- */
// Utility functions
typedef struct gl_version_info_s GlVersionInfo;
struct gl_version_info_s
{
guint gles_version;
guint gl_api_bit;
guint gl_api;
const gchar *gl_api_name;
};
static const GlVersionInfo gl_version_info[] = {
{0, EGL_OPENGL_BIT, EGL_OPENGL_API, "OpenGL"},
{1, EGL_OPENGL_ES_BIT, EGL_OPENGL_ES_API, "OpenGL_ES"},
{2, EGL_OPENGL_ES2_BIT, EGL_OPENGL_ES_API, "OpenGL_ES2"},
{3, EGL_OPENGL_ES3_BIT_KHR, EGL_OPENGL_ES_API, "OpenGL_ES3"},
{0,}
};
static const GlVersionInfo *
gl_version_info_lookup (guint gles_version)
{
const GlVersionInfo *vinfo;
for (vinfo = gl_version_info; vinfo->gl_api_bit != 0; vinfo++) {
if (vinfo->gles_version == gles_version)
return vinfo;
}
return NULL;
}
static const GlVersionInfo *
gl_version_info_lookup_by_api (guint api)
{
const GlVersionInfo *vinfo;
for (vinfo = gl_version_info; vinfo->gl_api_bit != 0; vinfo++) {
if (api & vinfo->gl_api_bit)
return vinfo;
}
return NULL;
}
static const GlVersionInfo *
gl_version_info_lookup_by_api_name (const gchar * name)
{
const GlVersionInfo *vinfo;
for (vinfo = gl_version_info; vinfo->gl_api_bit != 0; vinfo++) {
if (g_strcmp0 (vinfo->gl_api_name, name) == 0)
return vinfo;
}
return NULL;
}
static gboolean
g_strv_match_string (gchar ** extensions_list, const gchar * name)
{
if (extensions_list) {
for (; *extensions_list != NULL; extensions_list++) {
if (g_strcmp0 (*extensions_list, name) == 0)
return TRUE;
}
}
return FALSE;
}
static gboolean
egl_find_attrib_value (const EGLint * attribs, EGLint type, EGLint * value_ptr)
{
while (attribs[0] != EGL_NONE) {
if (attribs[0] == type) {
if (value_ptr)
*value_ptr = attribs[1];
return TRUE;
}
attribs += 2;
}
return FALSE;
}
/* ------------------------------------------------------------------------- */
// Basic objects
#define EGL_OBJECT(object) ((EglObject *)(object))
#define EGL_OBJECT_CLASS(klass) ((EglObjectClass *)(klass))
#define EGL_OBJECT_DEFINE_CLASS_WITH_CODE(TN, t_n, code) \
static void \
G_PASTE(t_n,_finalize) (TN * object); \
\
static inline const EglObjectClass * \
G_PASTE(t_n,_class) (void) \
{ \
static G_PASTE(TN,Class) g_class; \
static gsize g_class_init = FALSE; \
\
if (g_once_init_enter (&g_class_init)) { \
GstVaapiMiniObjectClass *const object_class = \
GST_VAAPI_MINI_OBJECT_CLASS (&g_class); \
code; \
object_class->size = sizeof (TN); \
object_class->finalize = (GDestroyNotify) \
G_PASTE(t_n,_finalize); \
g_once_init_leave (&g_class_init, TRUE); \
} \
return EGL_OBJECT_CLASS (&g_class); \
}
#define EGL_OBJECT_DEFINE_CLASS(TN, t_n) \
EGL_OBJECT_DEFINE_CLASS_WITH_CODE (TN, t_n, /**/)
static inline gpointer
egl_object_new (const EglObjectClass * klass)
{
return gst_vaapi_mini_object_new (GST_VAAPI_MINI_OBJECT_CLASS (klass));
}
static inline gpointer
egl_object_new0 (const EglObjectClass * klass)
{
return gst_vaapi_mini_object_new0 (GST_VAAPI_MINI_OBJECT_CLASS (klass));
}
typedef struct egl_object_class_s EglMessageClass;
typedef struct egl_object_class_s EglVTableClass;
typedef struct egl_object_class_s EglDisplayClass;
typedef struct egl_object_class_s EglConfigClass;
typedef struct egl_object_class_s EglContextClass;
typedef struct egl_object_class_s EglSurfaceClass;
typedef struct egl_object_class_s EglProgramClass;
typedef struct egl_object_class_s EglWindowClass;
EGL_OBJECT_DEFINE_CLASS (EglMessage, egl_message);
EGL_OBJECT_DEFINE_CLASS (EglVTable, egl_vtable);
EGL_OBJECT_DEFINE_CLASS (EglDisplay, egl_display);
EGL_OBJECT_DEFINE_CLASS (EglConfig, egl_config);
EGL_OBJECT_DEFINE_CLASS (EglContext, egl_context);
EGL_OBJECT_DEFINE_CLASS (EglSurface, egl_surface);
EGL_OBJECT_DEFINE_CLASS (EglProgram, egl_program);
EGL_OBJECT_DEFINE_CLASS (EglWindow, egl_window);
/* ------------------------------------------------------------------------- */
// Desktop OpenGL and OpenGL|ES dispatcher (vtable)
static GMutex gl_vtables_lock;
static EglVTable *gl_vtables[4];
#if (USE_GLES_VERSION_MASK & (1U << 0))
static const gchar *gl_library_names[] = {
"libGL.la",
"libGL.so.1",
NULL
};
#endif
#if (USE_GLES_VERSION_MASK & (1U << 1))
static const gchar *gles1_library_names[] = {
"libGLESv1_CM.la",
"libGLESv1_CM.so.1",
NULL
};
#endif
#if (USE_GLES_VERSION_MASK & (1U << 2))
static const gchar *gles2_library_names[] = {
"libGLESv2.la",
"libGLESv2.so.2",
NULL
};
#endif
static const gchar **gl_library_names_group[] = {
#if (USE_GLES_VERSION_MASK & (1U << 0))
gl_library_names,
#endif
NULL
};
static const gchar **gles1_library_names_group[] = {
#if (USE_GLES_VERSION_MASK & (1U << 1))
gles1_library_names,
#endif
NULL
};
static const gchar **gles2_library_names_group[] = {
#if (USE_GLES_VERSION_MASK & (1U << 2))
gles2_library_names,
#endif
NULL
};
static const gchar **gles3_library_names_group[] = {
#if (USE_GLES_VERSION_MASK & (1U << 3))
gles2_library_names,
#endif
NULL
};
static const gchar ***
egl_vtable_get_library_names_group (guint gles_version)
{
const gchar ***library_names_group;
switch (gles_version) {
case 0:
library_names_group = gl_library_names_group;
break;
case 1:
library_names_group = gles1_library_names_group;
break;
case 2:
library_names_group = gles2_library_names_group;
break;
case 3:
library_names_group = gles3_library_names_group;
break;
default:
library_names_group = NULL;
break;
}
return library_names_group;
}
static gboolean
egl_vtable_check_extension (EglVTable * vtable, EGLDisplay display,
gboolean is_egl, const gchar * group_name, guint * group_ptr)
{
gchar ***extensions_list;
const gchar *extensions;
g_return_val_if_fail (group_name != NULL, FALSE);
g_return_val_if_fail (group_ptr != NULL, FALSE);
if (*group_ptr > 0)
return TRUE;
GST_DEBUG ("check for %s extension %s", is_egl ? "EGL" : "GL", group_name);
if (is_egl) {
if (!vtable->egl_extensions) {
extensions = eglQueryString (display, EGL_EXTENSIONS);
if (!extensions)
return FALSE;
GST_DEBUG ("EGL extensions: %s", extensions);
vtable->egl_extensions = g_strsplit (extensions, " ", 0);
}
extensions_list = &vtable->egl_extensions;
} else {
if (!vtable->gl_extensions) {
extensions = (const gchar *) vtable->glGetString (GL_EXTENSIONS);
if (!extensions)
return FALSE;
GST_DEBUG ("GL extensions: %s", extensions);
vtable->gl_extensions = g_strsplit (extensions, " ", 0);
}
extensions_list = &vtable->gl_extensions;
}
if (!g_strv_match_string (*extensions_list, group_name))
return FALSE;
GST_LOG (" found %s extension %s", is_egl ? "EGL" : "GL", group_name);
(*group_ptr)++;
return TRUE;
}
static gboolean
egl_vtable_load_symbol (EglVTable * vtable, EGLDisplay display, gboolean is_egl,
const gchar * symbol_name, gpointer * symbol_ptr,
const gchar * group_name, guint * group_ptr)
{
void (*symbol) (void);
if (group_ptr && !*group_ptr) {
if (!egl_vtable_check_extension (vtable, display, is_egl, group_name,
group_ptr))
return FALSE;
}
if (is_egl) {
symbol = eglGetProcAddress (symbol_name);
} else {
if (!g_module_symbol (vtable->base.handle.p, symbol_name,
(gpointer *) & symbol))
return FALSE;
}
if (!symbol)
return FALSE;
GST_LOG (" found symbol %s", symbol_name);
if (symbol_ptr)
*symbol_ptr = symbol;
if (group_ptr)
(*group_ptr)++;
return TRUE;
}
static gboolean
egl_vtable_load_egl_symbols (EglVTable * vtable, EGLDisplay display)
{
guint n = 0;
#define EGL_DEFINE_EXTENSION(NAME) do { \
egl_vtable_check_extension (vtable, display, TRUE, \
"EGL_" G_STRINGIFY (NAME), \
&vtable->GL_PROTO_GEN_CONCAT(has_EGL_,NAME)); \
} while (0);
#define EGL_PROTO_BEGIN(NAME, TYPE, EXTENSION) do { \
n += egl_vtable_load_symbol (vtable, display, TRUE, \
G_STRINGIFY(GL_PROTO_GEN_CONCAT(egl,NAME)), \
(gpointer *) &vtable->GL_PROTO_GEN_CONCAT(egl,NAME), \
"EGL_" G_STRINGIFY(EXTENSION), \
&vtable->GL_PROTO_GEN_CONCAT(has_EGL_,EXTENSION)); \
} while (0);
#include "egl_vtable.h"
vtable->num_egl_symbols = n;
return TRUE;
}
static gboolean
egl_vtable_load_gl_symbols (EglVTable * vtable, EGLDisplay display)
{
guint n = 0;
vtable->has_GL_CORE_1_0 = 1;
vtable->has_GL_CORE_1_1 = 1;
vtable->has_GL_CORE_1_3 = 1;
vtable->has_GL_CORE_2_0 = 1;
#define GL_DEFINE_EXTENSION(NAME) do { \
egl_vtable_check_extension (vtable, display, FALSE, \
"GL_" G_STRINGIFY (NAME), \
&vtable->GL_PROTO_GEN_CONCAT(has_GL_,NAME)); \
} while (0);
#define GL_PROTO_BEGIN(NAME, TYPE, EXTENSION) do { \
n += egl_vtable_load_symbol (vtable, display, FALSE, \
G_STRINGIFY(GL_PROTO_GEN_CONCAT(gl,NAME)), \
(gpointer *) &vtable->GL_PROTO_GEN_CONCAT(gl,NAME), \
"GL_" G_STRINGIFY(EXTENSION), \
&vtable->GL_PROTO_GEN_CONCAT(has_GL_,EXTENSION)); \
} while (0);
#include "egl_vtable.h"
--vtable->has_GL_CORE_1_0;
--vtable->has_GL_CORE_1_1;
--vtable->has_GL_CORE_1_3;
--vtable->has_GL_CORE_2_0;
vtable->num_gl_symbols = n;
return TRUE;
}
static gboolean
egl_vtable_try_load_library (EglVTable * vtable, const gchar * name)
{
if (vtable->base.handle.p)
g_module_close (vtable->base.handle.p);
vtable->base.handle.p = g_module_open (name,
G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
if (!vtable->base.handle.p)
return FALSE;
GST_DEBUG ("loaded backend: %s", g_module_name (vtable->base.handle.p));
return TRUE;
}
static gboolean
egl_vtable_find_library (EglVTable * vtable)
{
const gchar ***library_names_ptr =
egl_vtable_get_library_names_group (vtable->gles_version);
if (!library_names_ptr)
return FALSE;
for (; *library_names_ptr != NULL; library_names_ptr++) {
const gchar **library_name_ptr = *library_names_ptr;
for (; *library_name_ptr != NULL; library_name_ptr++) {
if (egl_vtable_try_load_library (vtable, *library_name_ptr))
return TRUE;
}
}
return FALSE;
}
static gboolean
egl_vtable_init (EglVTable * vtable, EGLDisplay display, guint gles_version)
{
GST_DEBUG ("initialize for OpenGL|ES API version %d", gles_version);
vtable->gles_version = gles_version;
if (!egl_vtable_find_library (vtable))
return FALSE;
if (!egl_vtable_load_egl_symbols (vtable, display))
return FALSE;
return TRUE;
}
static void
egl_vtable_finalize (EglVTable * vtable)
{
g_strfreev (vtable->egl_extensions);
g_strfreev (vtable->gl_extensions);
if (vtable->base.handle.p)
g_module_close (vtable->base.handle.p);
if (vtable->base.is_wrapped) {
g_mutex_lock (&gl_vtables_lock);
gl_vtables[vtable->gles_version] = NULL;
g_mutex_unlock (&gl_vtables_lock);
}
}
static EglVTable *
egl_vtable_new (EglDisplay * display, guint gles_version)
{
EglVTable *vtable;
g_return_val_if_fail (display != NULL, NULL);
vtable = egl_object_new0 (egl_vtable_class ());
if (!vtable
|| !egl_vtable_init (vtable, display->base.handle.p, gles_version))
goto error;
return vtable;
/* ERRORS */
error:
{
egl_object_replace (&vtable, NULL);
return NULL;
}
}
static EglVTable *
egl_vtable_new_cached (EglDisplay * display, guint gles_version)
{
EglVTable *vtable, **vtable_ptr;
g_return_val_if_fail (gles_version < G_N_ELEMENTS (gl_vtables), NULL);
vtable_ptr = &gl_vtables[gles_version];
g_mutex_lock (&gl_vtables_lock);
vtable = *vtable_ptr;
if (vtable)
egl_object_ref (vtable);
else {
vtable = egl_vtable_new (display, gles_version);
if (vtable) {
vtable->base.is_wrapped = TRUE;
*vtable_ptr = vtable;
}
}
g_mutex_unlock (&gl_vtables_lock);
return vtable;
}
/* ------------------------------------------------------------------------- */
// EGL Display
static gboolean
egl_display_run (EglDisplay * display, EglContextRunFunc func, gpointer args)
{
EglMessage *msg;
if (display->gl_thread == g_thread_self ()) {
func (args);
return TRUE;
}
msg = egl_object_new0 (egl_message_class ());
if (!msg)
return FALSE;
msg->base.is_valid = TRUE;
msg->func = func;
msg->args = args;
g_async_queue_push (display->gl_queue, egl_object_ref (msg));
g_mutex_lock (&display->mutex);
while (msg->base.is_valid)
g_cond_wait (&display->gl_thread_ready, &display->mutex);
g_mutex_unlock (&display->mutex);
egl_object_unref (msg);
return TRUE;
}
static gpointer
egl_get_display_from_native (guintptr native_display, guint gl_platform)
{
#if USE_GST_GL_HELPERS && GST_GL_HAVE_PLATFORM_EGL
EGLDisplay ret;
GstGLDisplayType display_type = GST_GL_DISPLAY_TYPE_ANY;
switch (gl_platform) {
case EGL_PLATFORM_X11:
display_type = GST_GL_DISPLAY_TYPE_X11;
break;
case EGL_PLATFORM_WAYLAND:
display_type = GST_GL_DISPLAY_TYPE_WAYLAND;
break;
default:
break;
}
ret = gst_gl_display_egl_get_from_native (display_type, native_display);
if (ret != EGL_NO_DISPLAY)
return ret;
#endif
return eglGetDisplay ((EGLNativeDisplayType) native_display);
}
static gpointer
egl_display_thread (gpointer data)
{
EglDisplay *const display = data;
EGLDisplay gl_display = display->base.handle.p;
EGLint major_version, minor_version;
gchar **gl_apis, **gl_api;
g_mutex_lock (&display->mutex);
if (!display->base.is_wrapped) {
gl_display = display->base.handle.p =
egl_get_display_from_native (display->base.handle.u,
display->gl_platform);
if (!gl_display)
goto error;
if (!eglInitialize (gl_display, &major_version, &minor_version))
goto error;
}
display->gl_vendor_string =
g_strdup (eglQueryString (gl_display, EGL_VENDOR));
display->gl_version_string =
g_strdup (eglQueryString (gl_display, EGL_VERSION));
display->gl_apis_string =
g_strdup (eglQueryString (gl_display, EGL_CLIENT_APIS));
GST_INFO ("EGL vendor: %s", display->gl_vendor_string);
GST_INFO ("EGL version: %s", display->gl_version_string);
GST_INFO ("EGL client APIs: %s", display->gl_apis_string);
gl_apis = g_strsplit (display->gl_apis_string, " ", 0);
if (!gl_apis)
goto error;
for (gl_api = gl_apis; *gl_api != NULL; gl_api++) {
const GlVersionInfo *const vinfo =
gl_version_info_lookup_by_api_name (*gl_api);
if (vinfo)
display->gl_apis |= vinfo->gl_api_bit;
}
g_strfreev (gl_apis);
if (!display->gl_apis)
goto error;
display->base.is_valid = TRUE;
display->created = TRUE;
g_cond_broadcast (&display->gl_thread_ready);
g_mutex_unlock (&display->mutex);
while (!g_atomic_int_get (&display->gl_thread_cancel)) {
EglMessage *const msg =
g_async_queue_timeout_pop (display->gl_queue, 100000);
if (msg) {
if (msg->base.is_valid) {
msg->func (msg->args);
msg->base.is_valid = FALSE;
g_cond_broadcast (&display->gl_thread_ready);
}
egl_object_unref (msg);
}
}
g_mutex_lock (&display->mutex);
done:
if (gl_display != EGL_NO_DISPLAY && !display->base.is_wrapped)
eglTerminate (gl_display);
display->base.handle.p = NULL;
g_cond_broadcast (&display->gl_thread_ready);
g_mutex_unlock (&display->mutex);
return NULL;
/* ERRORS */
error:
{
display->created = TRUE;
display->base.is_valid = FALSE;
goto done;
}
}
static gboolean
egl_display_init (EglDisplay * display)
{
display->gl_queue =
g_async_queue_new_full ((GDestroyNotify) gst_vaapi_mini_object_unref);
if (!display->gl_queue)
return FALSE;
g_mutex_init (&display->mutex);
g_cond_init (&display->gl_thread_ready);
display->gl_thread = g_thread_try_new ("OpenGL Thread", egl_display_thread,
display, NULL);
if (!display->gl_thread)
return FALSE;
g_mutex_lock (&display->mutex);
while (!display->created)
g_cond_wait (&display->gl_thread_ready, &display->mutex);
g_mutex_unlock (&display->mutex);
return display->base.is_valid;
}
static void
egl_display_finalize (EglDisplay * display)
{
g_atomic_int_set (&display->gl_thread_cancel, TRUE);
g_thread_join (display->gl_thread);
g_cond_clear (&display->gl_thread_ready);
g_mutex_clear (&display->mutex);
g_async_queue_unref (display->gl_queue);
g_free (display->gl_vendor_string);
g_free (display->gl_version_string);
g_free (display->gl_apis_string);
}
static EglDisplay *
egl_display_new_full (gpointer handle, gboolean is_wrapped, guint platform)
{
EglDisplay *display;
display = egl_object_new0 (egl_display_class ());
if (!display)
return NULL;
display->base.handle.p = handle;
display->base.is_wrapped = is_wrapped;
display->gl_platform = platform;
if (!egl_display_init (display))
goto error;
return display;
/* ERRORS */
error:
{
egl_object_unref (display);
return NULL;
}
}
EglDisplay *
egl_display_new (gpointer native_display, guint platform)
{
g_return_val_if_fail (native_display != NULL, NULL);
return egl_display_new_full (native_display, FALSE, platform);
}
EglDisplay *
egl_display_new_wrapped (EGLDisplay gl_display)
{
g_return_val_if_fail (gl_display != EGL_NO_DISPLAY, NULL);
return egl_display_new_full (gl_display, TRUE, EGL_PLATFORM_UNKNOWN);
}
/* ------------------------------------------------------------------------- */
// EGL Config
static gboolean
egl_config_init (EglConfig * config, EglDisplay * display,
const EGLint * attribs)
{
EGLDisplay const gl_display = display->base.handle.p;
const GlVersionInfo *vinfo;
EGLConfig gl_config;
EGLint v, gl_apis, num_configs;
egl_object_replace (&config->display, display);
if (!eglChooseConfig (gl_display, attribs, &gl_config, 1, &num_configs))
return FALSE;
if (num_configs != 1)
return FALSE;
config->base.handle.p = gl_config;
if (!eglGetConfigAttrib (gl_display, gl_config, EGL_CONFIG_ID, &v))
return FALSE;
config->config_id = v;
if (!eglGetConfigAttrib (gl_display, gl_config, EGL_NATIVE_VISUAL_ID, &v))
return FALSE;
config->visual_id = v;
if (!eglGetConfigAttrib (gl_display, gl_config, EGL_RENDERABLE_TYPE, &v))
return FALSE;
if (!egl_find_attrib_value (attribs, EGL_RENDERABLE_TYPE, &gl_apis))
return FALSE;
vinfo = gl_version_info_lookup_by_api (v & gl_apis);
if (!vinfo)
return FALSE;
config->gles_version = vinfo->gles_version;
config->gl_api = vinfo->gles_version > 0 ? EGL_OPENGL_ES_API : EGL_OPENGL_API;
return TRUE;
}
static void
egl_config_finalize (EglConfig * config)
{
egl_object_replace (&config->display, NULL);
}
EglConfig *
egl_config_new (EglDisplay * display, guint gles_version, GstVideoFormat format)
{
EGLint attribs[2 * 6 + 1], *attrib = attribs;
const GstVideoFormatInfo *finfo;
const GlVersionInfo *vinfo;
g_return_val_if_fail (display != NULL, NULL);
finfo = gst_video_format_get_info (format);
if (!finfo || !GST_VIDEO_FORMAT_INFO_IS_RGB (finfo))
return NULL;
vinfo = gl_version_info_lookup (gles_version);
if (!vinfo)
return NULL;
*attrib++ = EGL_COLOR_BUFFER_TYPE;
*attrib++ = EGL_RGB_BUFFER;
*attrib++ = EGL_RED_SIZE;
*attrib++ = GST_VIDEO_FORMAT_INFO_DEPTH (finfo, GST_VIDEO_COMP_R);
*attrib++ = EGL_GREEN_SIZE;
*attrib++ = GST_VIDEO_FORMAT_INFO_DEPTH (finfo, GST_VIDEO_COMP_G);
*attrib++ = EGL_BLUE_SIZE;
*attrib++ = GST_VIDEO_FORMAT_INFO_DEPTH (finfo, GST_VIDEO_COMP_B);
*attrib++ = EGL_ALPHA_SIZE;
*attrib++ = GST_VIDEO_FORMAT_INFO_DEPTH (finfo, GST_VIDEO_COMP_A);
*attrib++ = EGL_RENDERABLE_TYPE;
*attrib++ = vinfo->gl_api_bit;
*attrib++ = EGL_NONE;
g_assert (attrib - attribs <= G_N_ELEMENTS (attribs));
return egl_config_new_with_attribs (display, attribs);
}
EglConfig *
egl_config_new_with_attribs (EglDisplay * display, const EGLint * attribs)
{
EglConfig *config;
g_return_val_if_fail (display != NULL, NULL);
g_return_val_if_fail (attribs != NULL, NULL);
config = egl_object_new0 (egl_config_class ());
if (!config || !egl_config_init (config, display, attribs))
goto error;
return config;
/* ERRORS */
error:
{
egl_object_replace (&config, NULL);
return NULL;
}
}
static EglConfig *
egl_config_new_from_gl_context (EglDisplay * display, EGLContext gl_context)
{
EGLDisplay const gl_display = display->base.handle.p;
EGLint attribs[3 * 2 + 1], *attrib = attribs;
EGLint config_id, api, v;
guint gles_version;
const GlVersionInfo *vinfo;
if (!eglQueryContext (gl_display, gl_context, EGL_CONFIG_ID, &config_id))
return NULL;
if (!eglQueryContext (gl_display, gl_context, EGL_CONTEXT_CLIENT_TYPE, &api))
return NULL;
if (!eglQueryContext (gl_display, gl_context, EGL_CONTEXT_CLIENT_VERSION, &v))
return NULL;
if (api == EGL_OPENGL_API)
gles_version = 0;
else if (api == EGL_OPENGL_ES_API)
gles_version = v;
else {
GST_ERROR ("unsupported EGL client API (%d)", api);
return NULL;
}
vinfo = gl_version_info_lookup (gles_version);
if (!vinfo)
return NULL;
*attrib++ = EGL_COLOR_BUFFER_TYPE;
*attrib++ = EGL_RGB_BUFFER;
*attrib++ = EGL_CONFIG_ID;
*attrib++ = config_id;
*attrib++ = EGL_RENDERABLE_TYPE;
*attrib++ = vinfo->gl_api_bit;
*attrib++ = EGL_NONE;
g_assert (attrib - attribs <= G_N_ELEMENTS (attribs));
return egl_config_new_with_attribs (display, attribs);
}
/* ------------------------------------------------------------------------- */
// EGL Surface
static void
egl_surface_finalize (EglSurface * surface)
{
if (surface->base.handle.p != EGL_NO_SURFACE && !surface->base.is_wrapped)
eglDestroySurface (surface->display->base.handle.p, surface->base.handle.p);
egl_object_replace (&surface->display, NULL);
}
static EglSurface *
egl_surface_new_wrapped (EglDisplay * display, EGLSurface gl_surface)
{
EglSurface *surface;
g_return_val_if_fail (display != NULL, NULL);
surface = egl_object_new (egl_surface_class ());
if (!surface)
return NULL;
surface->base.is_wrapped = TRUE;
surface->base.handle.p = gl_surface;
surface->display = egl_object_ref (display);
return surface;
}
/* ------------------------------------------------------------------------- */
// EGL Context
static void egl_context_state_get_current (EglContextState * cs);
static gboolean
egl_context_state_set_current (EglContextState * new_cs,
EglContextState * old_cs);
static gboolean
ensure_vtable (EglContext * ctx)
{
if (!ctx->vtable) {
ctx->vtable = egl_vtable_new_cached (ctx->display,
ctx->config ? ctx->config->gles_version : 0);
if (!ctx->vtable)
return FALSE;
}
return TRUE;
}
static gboolean
ensure_context (EglContext * ctx, EGLContext gl_parent_context)
{
EGLDisplay *const gl_display = ctx->display->base.handle.p;
EGLContext gl_context = ctx->base.handle.p;
EGLint gles_attribs[3], *attribs = NULL;
if (!gl_context) {
if (ctx->config->gles_version >= 2) {
attribs = gles_attribs;
attribs[0] = EGL_CONTEXT_CLIENT_VERSION;
attribs[1] = ctx->config->gles_version;
attribs[2] = EGL_NONE;
}
gl_context = eglCreateContext (gl_display, ctx->config->base.handle.p,
gl_parent_context, attribs);
if (!gl_context)
goto error_create_context;
ctx->base.handle.p = gl_context;
}
return TRUE;
/* ERRORS */
error_create_context:
GST_ERROR ("failed to create EGL context");
return FALSE;
}
static inline gboolean
ensure_gl_is_surfaceless (EglContext * ctx)
{
return ctx->vtable->has_EGL_KHR_surfaceless_context ||
(ctx->read_surface && ctx->draw_surface);
}
static gboolean
ensure_gl_scene (EglContext * ctx)
{
EglVTable *vtable;
if (!ensure_gl_is_surfaceless (ctx))
return FALSE;
if (ctx->base.is_valid)
return TRUE;
vtable = egl_context_get_vtable (ctx, TRUE);
if (!vtable)
return FALSE;
vtable->glClearColor (0.0, 0.0, 0.0, 1.0);
if (ctx->config && ctx->config->gles_version == 0)
vtable->glEnable (GL_TEXTURE_2D);
vtable->glDisable (GL_BLEND);
vtable->glDisable (GL_DEPTH_TEST);
ctx->base.is_valid = TRUE;
return TRUE;
}
/**
* egl_context_state_get_current:
* @cs: return location to the current #EglContextState
*
* Retrieves the current EGL context, display and surface to pack into
* the #EglContextState struct.
*/
static void
egl_context_state_get_current (EglContextState * cs)
{
cs->display = eglGetCurrentDisplay ();
cs->context = eglGetCurrentContext ();
if (cs->context) {
cs->read_surface = eglGetCurrentSurface (EGL_READ);
cs->draw_surface = eglGetCurrentSurface (EGL_DRAW);
} else {
cs->read_surface = EGL_NO_SURFACE;
cs->draw_surface = EGL_NO_SURFACE;
}
}
/**
* egl_context_state_set_current:
* @new_cs: the requested new #EglContextState
* @old_cs: return location to the context that was previously current
*
* Makes the @new_cs EGL context the current EGL rendering context of
* the calling thread, replacing the previously current context if
* there was one.
*
* If @old_cs is non %NULL, the previously current EGL context and
* surface are recorded.
*
* Return value: %TRUE on success
*/
static gboolean
egl_context_state_set_current (EglContextState * new_cs,
EglContextState * old_cs)
{
/* If display is NULL, this could be that new_cs was retrieved from
egl_context_state_get_current() with none set previously. If that case,
the other fields are also NULL and we don't return an error */
if (!new_cs->display)
return !new_cs->context && !new_cs->read_surface && !new_cs->draw_surface;
if (old_cs) {
if (old_cs == new_cs)
return TRUE;
egl_context_state_get_current (old_cs);
if (old_cs->display == new_cs->display &&
old_cs->context == new_cs->context &&
old_cs->read_surface == new_cs->read_surface &&
old_cs->draw_surface == new_cs->draw_surface)
return TRUE;
}
return eglMakeCurrent (new_cs->display, new_cs->draw_surface,
new_cs->read_surface, new_cs->context);
}
static gboolean
egl_context_init (EglContext * ctx, EglDisplay * display, EglConfig * config,
EGLContext gl_parent_context)
{
egl_object_replace (&ctx->display, display);
egl_object_replace (&ctx->config, config);
if (config)
eglBindAPI (config->gl_api);
if (!ensure_vtable (ctx))
return FALSE;
if (!ensure_context (ctx, gl_parent_context))
return FALSE;
return TRUE;
}
static void
egl_context_finalize (EglContext * ctx)
{
if (ctx->base.handle.p && !ctx->base.is_wrapped)
eglDestroyContext (ctx->display->base.handle.p, ctx->base.handle.p);
egl_object_replace (&ctx->read_surface, NULL);
egl_object_replace (&ctx->draw_surface, NULL);
egl_object_replace (&ctx->config, NULL);
egl_object_replace (&ctx->display, NULL);
egl_object_replace (&ctx->vtable, NULL);
}
typedef struct
{
EglDisplay *display;
EglConfig *config;
EGLContext gl_parent_context;
EglContext *context; /* result */
} CreateContextArgs;
static void
do_egl_context_new (CreateContextArgs * args)
{
EglContext *ctx;
ctx = egl_object_new0 (egl_context_class ());
if (!ctx || !egl_context_init (ctx, args->display, args->config,
args->gl_parent_context))
goto error;
args->context = ctx;
return;
/* ERRORS */
error:
{
egl_object_replace (&ctx, NULL);
args->context = NULL;
}
}
EglContext *
egl_context_new (EglDisplay * display, EglConfig * config, EglContext * parent)
{
CreateContextArgs args;
g_return_val_if_fail (display != NULL, NULL);
g_return_val_if_fail (config != NULL, NULL);
args.display = display;
args.config = config;
args.gl_parent_context = parent ? parent->base.handle.p : EGL_NO_CONTEXT;
if (!egl_display_run (display, (EglContextRunFunc) do_egl_context_new, &args))
return NULL;
return args.context;
}
EglContext *
egl_context_new_wrapped (EglDisplay * display, EGLContext gl_context)
{
CreateContextArgs args;
EglConfig *config;
gboolean success;
g_return_val_if_fail (display != NULL, NULL);
g_return_val_if_fail (gl_context != EGL_NO_CONTEXT, NULL);
config = egl_config_new_from_gl_context (display, gl_context);
if (!config)
return NULL;
args.display = display;
args.config = config;
args.gl_parent_context = gl_context;
args.context = NULL;
success = egl_display_run (display, (EglContextRunFunc) do_egl_context_new,
&args);
egl_object_unref (config);
if (!success)
return NULL;
return args.context;
}
EglVTable *
egl_context_get_vtable (EglContext * ctx, gboolean need_gl_symbols)
{
g_return_val_if_fail (ctx != NULL, NULL);
g_return_val_if_fail (ctx->display->gl_thread == g_thread_self (), NULL);
if (!ensure_vtable (ctx))
return NULL;
if (need_gl_symbols && !(ctx->vtable->num_gl_symbols > 0 ||
egl_vtable_load_gl_symbols (ctx->vtable,
ctx->display->base.handle.p)))
return NULL;
return ctx->vtable;
}
static void
egl_context_set_surface (EglContext * ctx, EglSurface * surface)
{
g_return_if_fail (ctx != NULL);
g_return_if_fail (surface != NULL);
egl_object_replace (&ctx->read_surface, surface);
egl_object_replace (&ctx->draw_surface, surface);
}
gboolean
egl_context_set_current (EglContext * ctx, gboolean activate,
EglContextState * old_cs)
{
EglContextState cs, *new_cs;
g_return_val_if_fail (ctx != NULL, FALSE);
g_return_val_if_fail (ctx->display->gl_thread == g_thread_self (), FALSE);
if (activate) {
new_cs = &cs;
new_cs->display = ctx->display->base.handle.p;
new_cs->context = ctx->base.handle.p;
new_cs->draw_surface = ctx->draw_surface ?
ctx->draw_surface->base.handle.p : EGL_NO_SURFACE;
new_cs->read_surface = ctx->read_surface ?
ctx->read_surface->base.handle.p : EGL_NO_SURFACE;
} else if (old_cs) {
new_cs = old_cs;
old_cs = NULL;
} else {
new_cs = &cs;
new_cs->display = ctx->display->base.handle.p;
new_cs->context = EGL_NO_CONTEXT;
new_cs->draw_surface = EGL_NO_SURFACE;
new_cs->read_surface = EGL_NO_SURFACE;
old_cs = NULL;
}
if (!egl_context_state_set_current (new_cs, old_cs))
return FALSE;
if (activate && !ensure_gl_scene (ctx))
return FALSE;
return TRUE;
}
gboolean
egl_context_run (EglContext * ctx, EglContextRunFunc func, gpointer args)
{
g_return_val_if_fail (ctx != NULL, FALSE);
g_return_val_if_fail (func != NULL, FALSE);
return egl_display_run (ctx->display, func, args);
}
/* ------------------------------------------------------------------------- */
// EGL Program
static GLuint
egl_compile_shader (EglContext * ctx, GLenum type, const char *source)
{
EglVTable *const vtable = egl_context_get_vtable (ctx, TRUE);
GLuint shader;
GLint status;
char log[BUFSIZ];
GLsizei log_length;
shader = vtable->glCreateShader (type);
vtable->glShaderSource (shader, 1, &source, NULL);
vtable->glCompileShader (shader);
vtable->glGetShaderiv (shader, GL_COMPILE_STATUS, &status);
if (!status) {
GST_ERROR ("failed to compile %s shader",
type == GL_FRAGMENT_SHADER ? "fragment" :
type == GL_VERTEX_SHADER ? "vertex" : "<unknown>");
vtable->glGetShaderInfoLog (shader, sizeof (log), &log_length, log);
GST_ERROR ("info log: %s", log);
return 0;
}
return shader;
}
static void
egl_program_finalize (EglProgram * program)
{
EglVTable *const vtable = program->vtable;
if (program->base.handle.u)
vtable->glDeleteProgram (program->base.handle.u);
if (program->frag_shader)
vtable->glDeleteShader (program->frag_shader);
if (program->vert_shader)
vtable->glDeleteShader (program->vert_shader);
egl_object_replace (&program->vtable, NULL);
}
static gboolean
egl_program_init (EglProgram * program, EglContext * ctx,
const gchar * frag_shader_text, const gchar * vert_shader_text)
{
EglVTable *const vtable = egl_context_get_vtable (ctx, TRUE);
GLuint prog_id;
char msg[BUFSIZ];
GLsizei msglen;
GLint status;
if (ctx->config->gles_version == 1)
goto error_unsupported_gles_version;
program->vtable = egl_object_ref (vtable);
program->frag_shader =
egl_compile_shader (ctx, GL_FRAGMENT_SHADER, frag_shader_text);
if (!program->frag_shader)
return FALSE;
program->vert_shader =
egl_compile_shader (ctx, GL_VERTEX_SHADER, vert_shader_text);
if (!program->vert_shader)
return FALSE;
prog_id = vtable->glCreateProgram ();
if (!prog_id)
return FALSE;
program->base.handle.u = prog_id;
vtable->glAttachShader (prog_id, program->frag_shader);
vtable->glAttachShader (prog_id, program->vert_shader);
vtable->glBindAttribLocation (prog_id, 0, "position");
vtable->glBindAttribLocation (prog_id, 1, "texcoord");
vtable->glLinkProgram (prog_id);
vtable->glGetProgramiv (prog_id, GL_LINK_STATUS, &status);
if (!status)
goto error_link_program;
return TRUE;
/* ERRORS */
error_unsupported_gles_version:
GST_ERROR ("unsupported shader with OpenGL|ES version 1");
return FALSE;
error_link_program:
vtable->glGetProgramInfoLog (prog_id, sizeof (msg), &msglen, msg);
GST_ERROR ("failed to link program: %s", msg);
return FALSE;
}
EglProgram *
egl_program_new (EglContext * ctx, const gchar * frag_shader_text,
const gchar * vert_shader_text)
{
EglProgram *program;
g_return_val_if_fail (ctx != NULL, NULL);
g_return_val_if_fail (frag_shader_text != NULL, NULL);
g_return_val_if_fail (vert_shader_text != NULL, NULL);
program = egl_object_new0 (egl_program_class ());
if (!program
|| !egl_program_init (program, ctx, frag_shader_text, vert_shader_text))
goto error;
return program;
/* ERRORS */
error:
{
egl_object_replace (&program, NULL);
return NULL;
}
}
/* ------------------------------------------------------------------------- */
// EGL Window
static gboolean
egl_window_init (EglWindow * window, EglContext * ctx, gpointer native_window)
{
EGLSurface gl_surface;
window->context = egl_context_new (ctx->display, ctx->config, ctx);
if (!window->context)
return FALSE;
ctx = window->context;
gl_surface = eglCreateWindowSurface (ctx->display->base.handle.p,
ctx->config->base.handle.p, (EGLNativeWindowType) native_window, NULL);
if (!gl_surface)
return FALSE;
window->surface = egl_surface_new_wrapped (ctx->display, gl_surface);
if (!window->surface)
goto error_create_surface;
window->base.handle.p = gl_surface;
window->base.is_wrapped = FALSE;
egl_context_set_surface (ctx, window->surface);
return TRUE;
/* ERRORS */
error_create_surface:
GST_ERROR ("failed to create EGL wrapper surface");
eglDestroySurface (ctx->display->base.handle.p, gl_surface);
return FALSE;
}
static void
egl_window_finalize (EglWindow * window)
{
if (window->context && window->base.handle.p)
eglDestroySurface (window->context->display->base.handle.p,
window->base.handle.p);
egl_object_replace (&window->surface, NULL);
egl_object_replace (&window->context, NULL);
}
EglWindow *
egl_window_new (EglContext * ctx, gpointer native_window)
{
EglWindow *window;
g_return_val_if_fail (ctx != NULL, NULL);
g_return_val_if_fail (native_window != NULL, NULL);
window = egl_object_new0 (egl_window_class ());
if (!window || !egl_window_init (window, ctx, native_window))
goto error;
return window;
/* ERRORS */
error:
{
egl_object_replace (&window, NULL);
return NULL;
}
}
/* ------------------------------------------------------------------------- */
// Misc utility functions
void
egl_matrix_set_identity (gfloat m[16])
{
#define MAT(m,r,c) (m)[(c) * 4 + (r)]
MAT (m, 0, 0) = 1.0;
MAT (m, 0, 1) = 0.0;
MAT (m, 0, 2) = 0.0;
MAT (m, 0, 3) = 0.0;
MAT (m, 1, 0) = 0.0;
MAT (m, 1, 1) = 1.0;
MAT (m, 1, 2) = 0.0;
MAT (m, 1, 3) = 0.0;
MAT (m, 2, 0) = 0.0;
MAT (m, 2, 1) = 0.0;
MAT (m, 2, 2) = 1.0;
MAT (m, 2, 3) = 0.0;
MAT (m, 3, 0) = 0.0;
MAT (m, 3, 1) = 0.0;
MAT (m, 3, 2) = 0.0;
MAT (m, 3, 3) = 1.0;
#undef MAT
}
/**
* egl_create_texture:
* @ctx: the parent #EglContext object
* @target: the target to which the texture is bound
* @format: the format of the pixel data
* @width: the requested width, in pixels
* @height: the requested height, in pixels
*
* Creates a texture with the specified dimensions and @format. The
* internal format will be automatically derived from @format.
*
* Return value: the newly created texture name
*/
guint
egl_create_texture (EglContext * ctx, guint target, guint format,
guint width, guint height)
{
EglVTable *const vtable = egl_context_get_vtable (ctx, TRUE);
guint internal_format, texture, bytes_per_component;
internal_format = format;
switch (format) {
case GL_LUMINANCE:
bytes_per_component = 1;
break;
case GL_LUMINANCE_ALPHA:
bytes_per_component = 2;
break;
case GL_RGBA:
case GL_BGRA_EXT:
internal_format = GL_RGBA;
bytes_per_component = 4;
break;
default:
bytes_per_component = 0;
break;
}
g_assert (bytes_per_component > 0);
vtable->glGenTextures (1, &texture);
vtable->glBindTexture (target, texture);
if (width > 0 && height > 0)
vtable->glTexImage2D (target, 0, internal_format, width, height, 0,
format, GL_UNSIGNED_BYTE, NULL);
vtable->glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
vtable->glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
vtable->glTexParameteri (target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
vtable->glTexParameteri (target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
vtable->glPixelStorei (GL_UNPACK_ALIGNMENT, bytes_per_component);
return texture;
}
/**
* egl_destroy_texture:
* @ctx: the parent #EglContext object
* @texture: the texture name to delete
*
* Destroys the supplied @texture name.
*/
void
egl_destroy_texture (EglContext * ctx, guint texture)
{
EglVTable *const vtable = egl_context_get_vtable (ctx, TRUE);
vtable->glDeleteTextures (1, &texture);
}