gstreamer/subprojects/gstreamer-vaapi/gst-libs/gst/vaapi/gstvaapiutils_glx.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1274 lines
31 KiB
C
Raw Normal View History

2010-03-25 17:28:49 +00:00
/*
* gstvaapiutils_glx.c - GLX utilties
*
* Copyright (C) 2010-2011 Splitted-Desktop Systems
* Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
* Copyright (C) 2011-2012 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2010-03-25 17:28:49 +00:00
*
2011-06-14 11:51:41 +00:00
* 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.
2010-03-25 17:28:49 +00:00
*
2011-06-14 11:51:41 +00:00
* This library is distributed in the hope that it will be useful,
2010-03-25 17:28:49 +00:00
* but WITHOUT ANY WARRANTY; without even the implied warranty of
2011-06-14 11:51:41 +00:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
2010-03-25 17:28:49 +00:00
*
2011-06-14 11:51:41 +00:00
* 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 USA
2010-03-25 17:28:49 +00:00
*/
#define _GNU_SOURCE 1 /* RTLD_DEFAULT */
#include "sysdeps.h"
#include <math.h>
2010-03-30 12:59:15 +00:00
#include <dlfcn.h>
2010-03-25 17:28:49 +00:00
#include "gstvaapiutils_glx.h"
2010-03-30 12:59:15 +00:00
#include "gstvaapiutils_x11.h"
2010-03-25 17:28:49 +00:00
#define DEBUG 1
#include "gstvaapidebug.h"
2010-03-30 12:59:15 +00:00
/** Lookup for substring NAME in string EXT using SEP as separators */
static gboolean
find_string (const gchar * name, const gchar * ext, const gchar * sep)
2010-03-30 12:59:15 +00:00
{
const gchar *end;
int name_len, n;
if (!name || !ext)
2010-03-30 12:59:15 +00:00
return FALSE;
end = ext + strlen (ext);
name_len = strlen (name);
while (ext < end) {
n = strcspn (ext, sep);
if (n == name_len && strncmp (name, ext, n) == 0)
return TRUE;
ext += (n + 1);
}
return FALSE;
2010-03-30 12:59:15 +00:00
}
2010-03-25 17:28:49 +00:00
/**
* gl_get_error_string:
* @error: an OpenGL error enumeration
*
* Retrieves the string representation the OpenGL @error.
*
* Return error: the static string representing the OpenGL @error
*/
const gchar *
gl_get_error_string (GLenum error)
2010-03-25 17:28:49 +00:00
{
switch (error) {
#define MAP(id, str) \
case id: return str " (" #id ")"
MAP (GL_NO_ERROR, "no error");
MAP (GL_INVALID_ENUM, "invalid enumerant");
MAP (GL_INVALID_VALUE, "invalid value");
MAP (GL_INVALID_OPERATION, "invalid operation");
MAP (GL_STACK_OVERFLOW, "stack overflow");
MAP (GL_STACK_UNDERFLOW, "stack underflow");
MAP (GL_OUT_OF_MEMORY, "out of memory");
2010-03-25 17:28:49 +00:00
#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
MAP (GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"invalid framebuffer operation");
2010-03-25 17:28:49 +00:00
#endif
#undef MAP
default:
break;
};
return "<unknown>";
2010-03-25 17:28:49 +00:00
}
/**
* gl_purge_errors:
*
* Purges all OpenGL errors. This function is generally useful to
* clear up the pending errors prior to calling gl_check_error().
*/
void
gl_purge_errors (void)
2010-03-25 17:28:49 +00:00
{
while (glGetError () != GL_NO_ERROR); /* nothing */
2010-03-25 17:28:49 +00:00
}
/**
* gl_check_error:
*
* Checks whether there is any OpenGL error pending.
*
* Return value: %TRUE if an error was encountered
*/
gboolean
gl_check_error (void)
2010-03-25 17:28:49 +00:00
{
GLenum error;
gboolean has_errors = FALSE;
while ((error = glGetError ()) != GL_NO_ERROR) {
GST_DEBUG ("glError: %s caught", gl_get_error_string (error));
has_errors = TRUE;
}
return has_errors;
2010-03-25 17:28:49 +00:00
}
/**
* gl_get_param:
* @param: the parameter name
* @pval: return location for the value
*
* This function is a wrapper around glGetIntegerv() that does extra
* error checking.
*
* Return value: %TRUE on success
*/
gboolean
gl_get_param (GLenum param, guint * pval)
2010-03-25 17:28:49 +00:00
{
GLint val;
2010-03-25 17:28:49 +00:00
gl_purge_errors ();
glGetIntegerv (param, &val);
if (gl_check_error ())
return FALSE;
2010-03-25 17:28:49 +00:00
if (pval)
*pval = val;
return TRUE;
2010-03-25 17:28:49 +00:00
}
/**
2010-03-29 12:51:38 +00:00
* gl_get_texture_param:
* @target: the target to which the texture is bound
2010-03-25 17:28:49 +00:00
* @param: the parameter name
* @pval: return location for the value
*
* This function is a wrapper around glGetTexLevelParameteriv() that
* does extra error checking.
*
* Return value: %TRUE on success
*/
gboolean
gl_get_texture_param (GLenum target, GLenum param, guint * pval)
2010-03-25 17:28:49 +00:00
{
GLint val;
2010-03-25 17:28:49 +00:00
gl_purge_errors ();
glGetTexLevelParameteriv (target, 0, param, &val);
if (gl_check_error ())
return FALSE;
2010-03-25 17:28:49 +00:00
if (pval)
*pval = val;
return TRUE;
2010-03-25 17:28:49 +00:00
}
/**
* gl_get_texture_binding:
* @target: a texture target
*
* Determines the texture binding type for the specified target.
*
* Return value: texture binding type for @target
*/
static GLenum
gl_get_texture_binding (GLenum target)
{
GLenum binding;
switch (target) {
case GL_TEXTURE_1D:
binding = GL_TEXTURE_BINDING_1D;
break;
case GL_TEXTURE_2D:
binding = GL_TEXTURE_BINDING_2D;
break;
case GL_TEXTURE_3D:
binding = GL_TEXTURE_BINDING_3D;
break;
case GL_TEXTURE_RECTANGLE_ARB:
binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
break;
default:
binding = 0;
break;
}
return binding;
}
2010-03-25 17:28:49 +00:00
/**
* gl_set_bgcolor:
* @color: the requested RGB color
*
* Sets background color to the RGB @color. This basically is a
* wrapper around glClearColor().
*/
void
gl_set_bgcolor (guint32 color)
2010-03-25 17:28:49 +00:00
{
glClearColor (
((color >> 16) & 0xff) / 255.0f,
((color >> 8) & 0xff) / 255.0f, (color & 0xff) / 255.0f, 1.0f);
2010-03-25 17:28:49 +00:00
}
/**
* gl_perspective:
* @fovy: the field of view angle, in degrees, in the y direction
* @aspect: the aspect ratio that determines the field of view in the
* x direction. The aspect ratio is the ratio of x (width) to y
* (height)
* @zNear: the distance from the viewer to the near clipping plane
* (always positive)
* @zFar: the distance from the viewer to the far clipping plane
* (always positive)
*
* Specified a viewing frustum into the world coordinate system. This
* basically is the Mesa implementation of gluPerspective().
*/
static void
gl_perspective (GLdouble fovy, GLdouble aspect, GLdouble near_val,
GLdouble far_val)
{
GLdouble left, right, top, bottom;
/* Source (Q 9.085):
<http://www.opengl.org/resources/faq/technical/transformations.htm> */
top = tan (fovy * M_PI / 360.0) * near_val;
bottom = -top;
left = aspect * bottom;
right = aspect * top;
glFrustum (left, right, bottom, top, near_val, far_val);
}
2010-03-25 17:28:49 +00:00
/**
* gl_resize:
* @width: the requested width, in pixels
* @height: the requested height, in pixels
*
* Resizes the OpenGL viewport to the specified dimensions, using an
* orthogonal projection. (0,0) represents the top-left corner of the
* window.
*/
void
gl_resize (guint width, guint height)
2010-03-25 17:28:49 +00:00
{
#define FOVY 60.0f
#define ASPECT 1.0f
#define Z_NEAR 0.1f
#define Z_FAR 100.0f
#define Z_CAMERA 0.869f
glViewport (0, 0, width, height);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gl_perspective (FOVY, ASPECT, Z_NEAR, Z_FAR);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (-0.5f, -0.5f, -Z_CAMERA);
glScalef (1.0f / width, -1.0f / height, 1.0f / width);
glTranslatef (0.0f, -1.0f * height, 0.0f);
2010-03-25 17:28:49 +00:00
}
/**
2010-03-31 15:25:19 +00:00
* gl_create_context:
* @dpy: an X11 #Display
2010-03-31 15:25:19 +00:00
* @screen: the associated screen of @dpy
* @parent: the parent #GLContextState, or %NULL if none is to be used
*
2010-03-31 15:25:19 +00:00
* Creates a GLX context sharing textures and displays lists with
* @parent, if not %NULL.
*
* Return value: the newly created GLX context
*/
GLContextState *
gl_create_context (Display * dpy, int screen, GLContextState * parent)
2010-03-31 15:25:19 +00:00
{
GLContextState *cs;
GLXFBConfig *fbconfigs = NULL;
int fbconfig_id, val, n, n_fbconfigs;
Status status;
static GLint fbconfig_attrs[] = {
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DOUBLEBUFFER, True,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
None
};
const GLint rgba_colors[4] = {
GLX_RED_SIZE,
GLX_GREEN_SIZE,
GLX_BLUE_SIZE,
GLX_ALPHA_SIZE
};
cs = malloc (sizeof (*cs));
if (!cs)
goto error;
if (parent) {
cs->display = parent->display;
cs->window = parent->window;
screen = DefaultScreen (parent->display);
} else {
cs->display = dpy;
cs->window = None;
}
cs->visual = NULL;
cs->context = NULL;
cs->swapped_buffers = FALSE;
if (parent && parent->context) {
status = glXQueryContext (parent->display,
parent->context, GLX_FBCONFIG_ID, &fbconfig_id);
if (status != Success)
goto error;
if (fbconfig_id == GLX_DONT_CARE)
goto choose_fbconfig;
fbconfigs = glXGetFBConfigs (parent->display, screen, &n_fbconfigs);
if (!fbconfigs)
goto error;
/* Find out a 8 bit GLXFBConfig compatible with the parent context */
for (n = 0; n < n_fbconfigs; n++) {
gboolean sizes_correct = FALSE;
int cn;
status = glXGetFBConfigAttrib (parent->display,
fbconfigs[n], GLX_FBCONFIG_ID, &val);
if (status != Success)
goto error;
if (val != fbconfig_id)
continue;
/* Iterate over RGBA sizes in fbconfig */
for (cn = 0; cn < 4; cn++) {
int size = 0;
status = glXGetFBConfigAttrib (parent->display,
fbconfigs[n], rgba_colors[cn], &size);
if (status != Success)
goto error;
/* Last check is for alpha
* and alpha is optional */
if (cn == 3) {
if (size == 0 || size == 8) {
sizes_correct = TRUE;
break;
}
} else if (size != 8)
break;
}
if (sizes_correct)
break;
}
if (n == n_fbconfigs)
goto error;
} else {
choose_fbconfig:
fbconfigs = glXChooseFBConfig (cs->display,
screen, fbconfig_attrs, &n_fbconfigs);
if (!fbconfigs)
goto error;
/* Select the first one */
n = 0;
}
cs->visual = glXGetVisualFromFBConfig (cs->display, fbconfigs[n]);
cs->context = glXCreateNewContext (cs->display,
fbconfigs[n], GLX_RGBA_TYPE, parent ? parent->context : NULL, True);
2016-10-19 17:04:20 +00:00
if (!cs->context)
goto error;
2010-03-31 15:25:19 +00:00
end:
if (fbconfigs)
XFree (fbconfigs);
return cs;
2016-10-19 17:04:20 +00:00
/* ERRORS */
error:
{
gl_destroy_context (cs);
cs = NULL;
goto end;
}
2010-03-31 15:25:19 +00:00
}
/**
* gl_destroy_context:
* @cs: a #GLContextState
*
* Destroys the GLX context @cs
*/
void
gl_destroy_context (GLContextState * cs)
2010-03-31 15:25:19 +00:00
{
if (!cs)
return;
if (cs->visual) {
XFree (cs->visual);
cs->visual = NULL;
}
if (cs->display && cs->context) {
if (glXGetCurrentContext () == cs->context) {
/* XXX: if buffers were never swapped, the application
will crash later with the NVIDIA driver */
if (!cs->swapped_buffers)
gl_swap_buffers (cs);
glXMakeCurrent (cs->display, None, NULL);
2010-03-31 15:25:19 +00:00
}
glXDestroyContext (cs->display, cs->context);
cs->display = NULL;
cs->context = NULL;
}
free (cs);
2010-03-31 15:25:19 +00:00
}
/**
* gl_get_current_context:
* @cs: return location to the current #GLContextState
*
* Retrieves the current GLX context, display and drawable packed into
* the #GLContextState struct.
*/
void
gl_get_current_context (GLContextState * cs)
2010-03-31 15:25:19 +00:00
{
cs->display = glXGetCurrentDisplay ();
cs->window = glXGetCurrentDrawable ();
cs->context = glXGetCurrentContext ();
2010-03-31 15:25:19 +00:00
}
/**
* gl_set_current_context:
* @new_cs: the requested new #GLContextState
* @old_cs: return location to the context that was previously current
*
* Makes the @new_cs GLX context the current GLX rendering context of
* the calling thread, replacing the previously current context if
* there was one.
*
2010-03-31 15:25:19 +00:00
* If @old_cs is non %NULL, the previously current GLX context and
* window are recorded.
*
* Return value: %TRUE on success
*/
gboolean
gl_set_current_context (GLContextState * new_cs, GLContextState * old_cs)
{
/* If display is NULL, this could be that new_cs was retrieved from
gl_get_current_context() 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->window && !new_cs->context;
if (old_cs) {
if (old_cs == new_cs)
return TRUE;
gl_get_current_context (old_cs);
if (old_cs->display == new_cs->display &&
old_cs->window == new_cs->window && old_cs->context == new_cs->context)
return TRUE;
}
return glXMakeCurrent (new_cs->display, new_cs->window, new_cs->context);
}
/**
* gl_swap_buffers:
2010-03-31 15:25:19 +00:00
* @cs: a #GLContextState
*
* Promotes the contents of the back buffer of the @win window to
* become the contents of the front buffer. This simply is wrapper
* around glXSwapBuffers().
*/
void
gl_swap_buffers (GLContextState * cs)
{
glXSwapBuffers (cs->display, cs->window);
cs->swapped_buffers = TRUE;
}
static inline gboolean
_init_texture_state (GLTextureState * ts, GLenum target, GLuint texture,
gboolean enabled)
{
GLenum binding;
ts->target = target;
if (enabled) {
binding = gl_get_texture_binding (target);
if (!binding)
return FALSE;
if (!gl_get_param (binding, &ts->old_texture))
return FALSE;
ts->was_enabled = TRUE;
ts->was_bound = texture == ts->old_texture;
} else {
ts->old_texture = 0;
ts->was_enabled = FALSE;
ts->was_bound = FALSE;
}
return TRUE;
}
static inline gboolean
_bind_enabled_texture (GLenum target, GLuint texture)
{
gl_purge_errors ();
glBindTexture (target, texture);
if (gl_check_error ())
return FALSE;
return TRUE;
}
/**
* gl_bind_texture:
* @ts: a #GLTextureState
* @target: the target to which the texture is bound
* @texture: the name of a texture
*
* Binds @texture to the specified @target, while recording the
* previous state in @ts.
*
* Return value: %TRUE on success
*/
gboolean
gl_bind_texture (GLTextureState * ts, GLenum target, GLuint texture)
{
gboolean enabled;
enabled = (gboolean) glIsEnabled (target);
if (!_init_texture_state (ts, target, texture, enabled))
return FALSE;
if (ts->was_bound)
return TRUE;
if (!enabled)
glEnable (target);
return _bind_enabled_texture (target, texture);
}
/**
* gl3_bind_texture_2d:
* @ts: a #GLTextureState
* @target: the target to which the texture is bound
* @texture: the name of a texture
*
* Binds @texture to the specified @target, while recording the
* previous state in @ts.
*
* This function is for OpenGL3 API and for targets type GL_TEXTURE_2D.
*
* Return value: %TRUE on success
*/
gboolean
gl3_bind_texture_2d (GLTextureState * ts, GLenum target, GLuint texture)
{
if (target != GL_TEXTURE_2D)
return FALSE;
if (!_init_texture_state (ts, target, texture, TRUE))
return FALSE;
if (ts->was_bound)
return TRUE;
return _bind_enabled_texture (target, texture);
}
/**
* gl_unbind_texture:
* @ts: a #GLTextureState
*
* Rebinds the texture that was previously bound and recorded in @ts.
*/
void
gl_unbind_texture (GLTextureState * ts)
{
if (!ts->was_bound && ts->old_texture)
glBindTexture (ts->target, ts->old_texture);
if (!ts->was_enabled)
glDisable (ts->target);
}
/**
* gl_create_texture:
* @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
*/
GLuint
gl_create_texture (GLenum target, GLenum format, guint width, guint height)
{
GLenum internal_format;
GLuint texture;
GLTextureState ts;
guint 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:
internal_format = GL_RGBA;
bytes_per_component = 4;
break;
default:
bytes_per_component = 0;
break;
}
g_assert (bytes_per_component > 0);
glGenTextures (1, &texture);
if (!gl_bind_texture (&ts, target, texture))
return 0;
glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei (GL_UNPACK_ALIGNMENT, bytes_per_component);
glTexImage2D (target,
0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
gl_unbind_texture (&ts);
return texture;
}
2010-03-30 12:59:15 +00:00
/**
* get_proc_address:
* @name: the name of the OpenGL extension function to lookup
*
* Returns the specified OpenGL extension function
*
* Return value: the OpenGL extension matching @name, or %NULL if none
* was found
*/
typedef void (*GLFuncPtr) (void);
typedef GLFuncPtr (*GLXGetProcAddressProc) (const gchar *);
2010-03-30 12:59:15 +00:00
static GLFuncPtr
get_proc_address_default (const gchar * name)
2010-03-30 12:59:15 +00:00
{
return NULL;
2010-03-30 12:59:15 +00:00
}
static GLXGetProcAddressProc
get_proc_address_func (void)
2010-03-30 12:59:15 +00:00
{
GLXGetProcAddressProc get_proc_func;
2010-03-30 12:59:15 +00:00
dlerror ();
*(void **) (&get_proc_func) = dlsym (RTLD_DEFAULT, "glXGetProcAddress");
if (!dlerror ())
return get_proc_func;
2010-03-30 12:59:15 +00:00
*(void **) (&get_proc_func) = dlsym (RTLD_DEFAULT, "glXGetProcAddressARB");
if (!dlerror ())
return get_proc_func;
2010-03-30 12:59:15 +00:00
return get_proc_address_default;
2010-03-30 12:59:15 +00:00
}
static inline GLFuncPtr
get_proc_address (const gchar * name)
2010-03-30 12:59:15 +00:00
{
static GLXGetProcAddressProc get_proc_func = NULL;
if (!get_proc_func)
get_proc_func = get_proc_address_func ();
return get_proc_func (name);
2010-03-30 12:59:15 +00:00
}
/**
* gl_init_vtable:
*
* Initializes the global #GLVTable.
*
* Return value: the #GLVTable filled in with OpenGL extensions, or
* %NULL on error.
*/
static GLVTable gl_vtable_static;
static GLVTable *
gl_init_vtable (void)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = &gl_vtable_static;
const gchar *gl_extensions = (const gchar *) glGetString (GL_EXTENSIONS);
gboolean has_extension;
/* GLX_EXT_texture_from_pixmap */
gl_vtable->glx_create_pixmap = (PFNGLXCREATEPIXMAPPROC)
get_proc_address ("glXCreatePixmap");
if (!gl_vtable->glx_create_pixmap)
return NULL;
gl_vtable->glx_destroy_pixmap = (PFNGLXDESTROYPIXMAPPROC)
get_proc_address ("glXDestroyPixmap");
if (!gl_vtable->glx_destroy_pixmap)
return NULL;
gl_vtable->glx_bind_tex_image = (PFNGLXBINDTEXIMAGEEXTPROC)
get_proc_address ("glXBindTexImageEXT");
if (!gl_vtable->glx_bind_tex_image)
return NULL;
gl_vtable->glx_release_tex_image = (PFNGLXRELEASETEXIMAGEEXTPROC)
get_proc_address ("glXReleaseTexImageEXT");
if (!gl_vtable->glx_release_tex_image)
return NULL;
/* GL_ARB_framebuffer_object */
has_extension = (find_string ("GL_ARB_framebuffer_object", gl_extensions, " ")
|| find_string ("GL_EXT_framebuffer_object", gl_extensions, " ")
);
if (has_extension) {
gl_vtable->gl_gen_framebuffers = (PFNGLGENFRAMEBUFFERSEXTPROC)
get_proc_address ("glGenFramebuffersEXT");
if (!gl_vtable->gl_gen_framebuffers)
return NULL;
gl_vtable->gl_delete_framebuffers = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
get_proc_address ("glDeleteFramebuffersEXT");
if (!gl_vtable->gl_delete_framebuffers)
return NULL;
gl_vtable->gl_bind_framebuffer = (PFNGLBINDFRAMEBUFFEREXTPROC)
get_proc_address ("glBindFramebufferEXT");
if (!gl_vtable->gl_bind_framebuffer)
return NULL;
gl_vtable->gl_gen_renderbuffers = (PFNGLGENRENDERBUFFERSEXTPROC)
get_proc_address ("glGenRenderbuffersEXT");
if (!gl_vtable->gl_gen_renderbuffers)
return NULL;
gl_vtable->gl_delete_renderbuffers = (PFNGLDELETERENDERBUFFERSEXTPROC)
get_proc_address ("glDeleteRenderbuffersEXT");
if (!gl_vtable->gl_delete_renderbuffers)
return NULL;
gl_vtable->gl_bind_renderbuffer = (PFNGLBINDRENDERBUFFEREXTPROC)
get_proc_address ("glBindRenderbufferEXT");
if (!gl_vtable->gl_bind_renderbuffer)
return NULL;
gl_vtable->gl_renderbuffer_storage = (PFNGLRENDERBUFFERSTORAGEEXTPROC)
get_proc_address ("glRenderbufferStorageEXT");
if (!gl_vtable->gl_renderbuffer_storage)
return NULL;
gl_vtable->gl_framebuffer_renderbuffer =
(PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
get_proc_address ("glFramebufferRenderbufferEXT");
if (!gl_vtable->gl_framebuffer_renderbuffer)
return NULL;
gl_vtable->gl_framebuffer_texture_2d = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
get_proc_address ("glFramebufferTexture2DEXT");
if (!gl_vtable->gl_framebuffer_texture_2d)
return NULL;
gl_vtable->gl_check_framebuffer_status =
(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
get_proc_address ("glCheckFramebufferStatusEXT");
if (!gl_vtable->gl_check_framebuffer_status)
return NULL;
gl_vtable->has_framebuffer_object = TRUE;
}
return gl_vtable;
2010-03-30 12:59:15 +00:00
}
/**
* gl_get_vtable:
*
* Retrieves a VTable for OpenGL extensions.
*
* Return value: VTable for OpenGL extensions
*/
GLVTable *
gl_get_vtable (void)
2010-03-30 12:59:15 +00:00
{
static gsize gl_vtable_init = FALSE;
static GLVTable *gl_vtable = NULL;
if (g_once_init_enter (&gl_vtable_init)) {
gl_vtable = gl_init_vtable ();
g_once_init_leave (&gl_vtable_init, TRUE);
}
return gl_vtable;
2010-03-30 12:59:15 +00:00
}
/**
* gl_create_pixmap_object:
* @dpy: an X11 #Display
* @width: the request width, in pixels
* @height: the request height, in pixels
*
* Creates a #GLPixmapObject of the specified dimensions. This
* requires the GLX_EXT_texture_from_pixmap extension.
*
* Return value: the newly created #GLPixmapObject object
*/
GLPixmapObject *
gl_create_pixmap_object (Display * dpy, guint width, guint height)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
GLPixmapObject *pixo;
GLXFBConfig *fbconfig;
int screen;
Window rootwin;
XWindowAttributes wattr;
int *attr;
int n_fbconfig_attrs;
int fbconfig_attrs[32] = {
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
GLX_DOUBLEBUFFER, GL_FALSE,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_X_RENDERABLE, GL_TRUE,
GLX_Y_INVERTED_EXT, GL_TRUE,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GL_NONE,
};
int pixmap_attrs[10] = {
GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_MIPMAP_TEXTURE_EXT, GL_FALSE,
GL_NONE,
};
if (!gl_vtable)
return NULL;
2010-03-30 12:59:15 +00:00
screen = DefaultScreen (dpy);
rootwin = RootWindow (dpy, screen);
/* XXX: this won't work for different displays */
if (!gl_vtable->has_texture_from_pixmap) {
const gchar *glx_extensions = glXQueryExtensionsString (dpy, screen);
if (!glx_extensions)
return NULL;
if (!find_string ("GLX_EXT_texture_from_pixmap", glx_extensions, " "))
return NULL;
gl_vtable->has_texture_from_pixmap = TRUE;
}
pixo = calloc (1, sizeof (*pixo));
if (!pixo)
return NULL;
pixo->dpy = dpy;
pixo->width = width;
pixo->height = height;
pixo->pixmap = None;
pixo->glx_pixmap = None;
pixo->is_bound = FALSE;
XGetWindowAttributes (dpy, rootwin, &wattr);
pixo->pixmap = XCreatePixmap (dpy, rootwin, width, height, wattr.depth);
if (!pixo->pixmap)
goto error;
/* Initialize FBConfig attributes */
for (attr = fbconfig_attrs; *attr != GL_NONE; attr += 2);
if (wattr.depth == 32) {
*attr++ = GLX_ALPHA_SIZE;
*attr++ = 8;
*attr++ = GLX_BIND_TO_TEXTURE_RGBA_EXT;
*attr++ = GL_TRUE;
} else {
*attr++ = GLX_BIND_TO_TEXTURE_RGB_EXT;
*attr++ = GL_TRUE;
}
*attr++ = GL_NONE;
fbconfig = glXChooseFBConfig (dpy, screen, fbconfig_attrs, &n_fbconfig_attrs);
if (!fbconfig)
goto error;
/* Initialize GLX Pixmap attributes */
for (attr = pixmap_attrs; *attr != GL_NONE; attr += 2);
*attr++ = GLX_TEXTURE_FORMAT_EXT;
if (wattr.depth == 32)
2010-03-30 12:59:15 +00:00
*attr++ = GLX_TEXTURE_FORMAT_RGBA_EXT;
else
2010-03-30 12:59:15 +00:00
*attr++ = GLX_TEXTURE_FORMAT_RGB_EXT;
*attr++ = GL_NONE;
x11_trap_errors ();
pixo->glx_pixmap = gl_vtable->glx_create_pixmap (dpy,
fbconfig[0], pixo->pixmap, pixmap_attrs);
free (fbconfig);
if (x11_untrap_errors () != 0)
goto error;
pixo->target = GL_TEXTURE_2D;
glGenTextures (1, &pixo->texture);
if (!gl_bind_texture (&pixo->old_texture, pixo->target, pixo->texture))
goto error;
glTexParameteri (pixo->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (pixo->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl_unbind_texture (&pixo->old_texture);
return pixo;
2010-03-30 12:59:15 +00:00
2016-10-19 17:04:20 +00:00
/* ERRORS */
2010-03-30 12:59:15 +00:00
error:
2016-10-19 17:04:20 +00:00
{
gl_destroy_pixmap_object (pixo);
return NULL;
}
2010-03-30 12:59:15 +00:00
}
/**
* gl_destroy_pixmap_object:
* @pixo: a #GLPixmapObject
*
* Destroys the #GLPixmapObject object.
*/
void
gl_destroy_pixmap_object (GLPixmapObject * pixo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
if (!pixo)
return;
2010-03-30 12:59:15 +00:00
gl_unbind_pixmap_object (pixo);
2010-03-30 12:59:15 +00:00
if (pixo->texture) {
glDeleteTextures (1, &pixo->texture);
pixo->texture = 0;
}
if (pixo->glx_pixmap) {
gl_vtable->glx_destroy_pixmap (pixo->dpy, pixo->glx_pixmap);
pixo->glx_pixmap = None;
}
2010-03-30 12:59:15 +00:00
if (pixo->pixmap) {
XFreePixmap (pixo->dpy, pixo->pixmap);
pixo->pixmap = None;
}
free (pixo);
2010-03-30 12:59:15 +00:00
}
/**
* gl_bind_pixmap_object:
* @pixo: a #GLPixmapObject
*
* Defines a two-dimensional texture image. The texture image is taken
* from the @pixo pixmap and need not be copied. The texture target,
* format and size are derived from attributes of the @pixo pixmap.
*
* Return value: %TRUE on success
*/
gboolean
gl_bind_pixmap_object (GLPixmapObject * pixo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
2010-03-30 12:59:15 +00:00
if (pixo->is_bound)
2010-03-30 12:59:15 +00:00
return TRUE;
if (!gl_bind_texture (&pixo->old_texture, pixo->target, pixo->texture))
return FALSE;
x11_trap_errors ();
gl_vtable->glx_bind_tex_image (pixo->dpy,
pixo->glx_pixmap, GLX_FRONT_LEFT_EXT, NULL);
XSync (pixo->dpy, False);
if (x11_untrap_errors () != 0) {
GST_DEBUG ("failed to bind pixmap");
return FALSE;
}
pixo->is_bound = TRUE;
return TRUE;
2010-03-30 12:59:15 +00:00
}
/**
* gl_unbind_pixmap_object:
* @pixo: a #GLPixmapObject
*
* Releases a color buffers that is being used as a texture.
*
* Return value: %TRUE on success
*/
gboolean
gl_unbind_pixmap_object (GLPixmapObject * pixo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
if (!pixo->is_bound)
2010-03-30 12:59:15 +00:00
return TRUE;
x11_trap_errors ();
gl_vtable->glx_release_tex_image (pixo->dpy,
pixo->glx_pixmap, GLX_FRONT_LEFT_EXT);
XSync (pixo->dpy, False);
if (x11_untrap_errors () != 0) {
GST_DEBUG ("failed to release pixmap");
return FALSE;
}
gl_unbind_texture (&pixo->old_texture);
pixo->is_bound = FALSE;
return TRUE;
2010-03-30 12:59:15 +00:00
}
/**
* gl_create_framebuffer_object:
* @target: the target to which the texture is bound
* @texture: the GL texture to hold the framebuffer
* @width: the requested width, in pixels
* @height: the requested height, in pixels
*
* Creates an FBO with the specified texture and size.
*
* Return value: the newly created #GLFramebufferObject, or %NULL if
* an error occurred
*/
GLFramebufferObject *
gl_create_framebuffer_object (GLenum target,
GLuint texture, guint width, guint height)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
GLFramebufferObject *fbo;
GLenum status;
2010-03-30 12:59:15 +00:00
if (!gl_vtable || !gl_vtable->has_framebuffer_object)
2010-03-30 12:59:15 +00:00
return NULL;
/* XXX: we only support GL_TEXTURE_2D at this time */
if (target != GL_TEXTURE_2D)
return NULL;
fbo = calloc (1, sizeof (*fbo));
if (!fbo)
return NULL;
fbo->width = width;
fbo->height = height;
fbo->fbo = 0;
fbo->old_fbo = 0;
fbo->is_bound = FALSE;
gl_get_param (GL_FRAMEBUFFER_BINDING, &fbo->old_fbo);
gl_vtable->gl_gen_framebuffers (1, &fbo->fbo);
gl_vtable->gl_bind_framebuffer (GL_FRAMEBUFFER_EXT, fbo->fbo);
gl_vtable->gl_framebuffer_texture_2d (GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT, target, texture, 0);
status = gl_vtable->gl_check_framebuffer_status (GL_DRAW_FRAMEBUFFER_EXT);
gl_vtable->gl_bind_framebuffer (GL_FRAMEBUFFER_EXT, fbo->old_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
goto error;
return fbo;
2016-10-19 17:04:20 +00:00
/* ERRORS */
error:
2016-10-19 17:04:20 +00:00
{
gl_destroy_framebuffer_object (fbo);
return NULL;
}
2010-03-30 12:59:15 +00:00
}
/**
* gl_destroy_framebuffer_object:
* @fbo: a #GLFramebufferObject
*
* Destroys the @fbo object.
*/
void
gl_destroy_framebuffer_object (GLFramebufferObject * fbo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
2010-03-30 12:59:15 +00:00
if (!fbo)
return;
2010-03-30 12:59:15 +00:00
gl_unbind_framebuffer_object (fbo);
2010-03-30 12:59:15 +00:00
if (fbo->fbo) {
gl_vtable->gl_delete_framebuffers (1, &fbo->fbo);
fbo->fbo = 0;
}
free (fbo);
2010-03-30 12:59:15 +00:00
}
/**
* gl_bind_framebuffer_object:
* @fbo: a #GLFramebufferObject
*
* Binds @fbo object.
*
* Return value: %TRUE on success
*/
gboolean
gl_bind_framebuffer_object (GLFramebufferObject * fbo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
const guint width = fbo->width;
const guint height = fbo->height;
const guint attribs = (GL_VIEWPORT_BIT |
GL_CURRENT_BIT | GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT);
if (fbo->is_bound)
2010-03-30 12:59:15 +00:00
return TRUE;
gl_get_param (GL_FRAMEBUFFER_BINDING, &fbo->old_fbo);
gl_vtable->gl_bind_framebuffer (GL_FRAMEBUFFER_EXT, fbo->fbo);
glPushAttrib (attribs);
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glLoadIdentity ();
glViewport (0, 0, width, height);
glTranslatef (-1.0f, -1.0f, 0.0f);
glScalef (2.0f / width, 2.0f / height, 1.0f);
fbo->is_bound = TRUE;
return TRUE;
2010-03-30 12:59:15 +00:00
}
/**
* gl_unbind_framebuffer_object:
* @fbo: a #GLFramebufferObject
*
* Releases @fbo object.
*
* Return value: %TRUE on success
*/
gboolean
gl_unbind_framebuffer_object (GLFramebufferObject * fbo)
2010-03-30 12:59:15 +00:00
{
GLVTable *const gl_vtable = gl_get_vtable ();
2010-03-30 12:59:15 +00:00
if (!fbo->is_bound)
return TRUE;
2010-03-30 12:59:15 +00:00
glPopAttrib ();
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
gl_vtable->gl_bind_framebuffer (GL_FRAMEBUFFER_EXT, fbo->old_fbo);
2010-03-30 12:59:15 +00:00
fbo->is_bound = FALSE;
return TRUE;
2010-03-30 12:59:15 +00:00
}
/**
* gl_get_current_api:
* @major: (out): (allow-none): the GL major version
* @minor: (out): (allow-none): the GL minor version
*
* If an error occurs, @major and @minor aren't modified and
* %GST_VAAPI_GL_API_NONE is returned.
*
* This is an adaptation of gst_gl_context_get_current_gl_api() from GstGL.
*
* Returns: The version supported by the OpenGL context current in the calling
* thread or %GST_VAAPI_GL_API_NONE
*/
GstVaapiGLApi
gl_get_current_api (guint * major, guint * minor)
{
const gchar *version;
gint maj, min, n, sret;
GstVaapiGLApi ret = (1 << 31);
while (ret != GST_VAAPI_GL_API_NONE) {
version = (const gchar *) glGetString (GL_VERSION);
if (!version)
goto next;
/* strlen (x.x) == 3 */
n = strlen (version);
if (n < 3)
goto next;
if (g_strstr_len (version, 9, "OpenGL ES")) {
/* strlen (OpenGL ES x.x) == 13 */
if (n < 13)
goto next;
sret = sscanf (&version[10], "%d.%d", &maj, &min);
if (sret != 2)
goto next;
if (maj <= 0 || min < 0)
goto next;
if (maj == 1) {
ret = GST_VAAPI_GL_API_GLES1;
break;
} else if (maj == 2 || maj == 3) {
ret = GST_VAAPI_GL_API_GLES2;
break;
}
goto next;
} else {
sret = sscanf (version, "%d.%d", &maj, &min);
if (sret != 2)
goto next;
if (maj <= 0 || min < 0)
goto next;
if (maj > 3 || (maj == 3 && min > 1)) {
GLuint context_flags = 0;
ret = GST_VAAPI_GL_API_NONE;
if (!gl_get_param (GL_CONTEXT_PROFILE_MASK, &context_flags))
break;
if (context_flags & GL_CONTEXT_CORE_PROFILE_BIT)
ret |= GST_VAAPI_GL_API_OPENGL3;
if (context_flags & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
ret |= GST_VAAPI_GL_API_OPENGL;
break;
}
ret = GST_VAAPI_GL_API_OPENGL;
break;
}
next:
/* iterate through the apis */
ret >>= 1;
}
if (ret == GST_VAAPI_GL_API_NONE)
return GST_VAAPI_GL_API_NONE;
if (major)
*major = maj;
if (minor)
*minor = min;
return ret;
}