gstreamer/gst-libs/gst/vaapi/gstvaapiwindow_glx.c

571 lines
17 KiB
C
Raw Normal View History

2010-03-25 17:28:49 +00:00
/*
* gstvaapiwindow_glx.c - VA/GLX window abstraction
*
* Copyright (C) 2010-2011 Splitted-Desktop Systems
* Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
2013-11-22 05:37:12 +00:00
* Copyright (C) 2012-2013 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
*/
/**
* SECTION:gstvaapiwindow_glx
* @short_description: VA/GLX window abstraction
*/
#include "sysdeps.h"
2010-03-25 17:28:49 +00:00
#include "gstvaapiwindow_glx.h"
#include "gstvaapiwindow_x11_priv.h"
2010-03-25 17:28:49 +00:00
#include "gstvaapidisplay_x11.h"
#include "gstvaapidisplay_x11_priv.h"
2013-05-27 15:18:40 +00:00
#include "gstvaapidisplay_glx_priv.h"
2010-03-25 17:28:49 +00:00
#include "gstvaapiutils_x11.h"
#include "gstvaapiutils_glx.h"
#define DEBUG 1
#include "gstvaapidebug.h"
#define GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window) \
(&GST_VAAPI_WINDOW_GLX(window)->priv)
2010-03-25 17:28:49 +00:00
#define GST_VAAPI_WINDOW_GLX_CLASS(klass) \
((GstVaapiWindowGLXClass *)(klass))
#define GST_VAAPI_WINDOW_GLX_GET_CLASS(obj) \
GST_VAAPI_WINDOW_GLX_CLASS(GST_VAAPI_OBJECT_GET_CLASS(obj))
typedef struct _GstVaapiWindowGLXPrivate GstVaapiWindowGLXPrivate;
typedef struct _GstVaapiWindowGLXClass GstVaapiWindowGLXClass;
2010-03-25 17:28:49 +00:00
struct _GstVaapiWindowGLXPrivate {
Colormap cmap;
2010-03-31 15:25:19 +00:00
GLContextState *gl_context;
2010-03-25 17:28:49 +00:00
};
/**
* GstVaapiWindowGLX:
*
* An X11 #Window suitable for GLX rendering.
*/
struct _GstVaapiWindowGLX {
/*< private >*/
GstVaapiWindowX11 parent_instance;
GstVaapiWindowGLXPrivate priv;
};
/**
* GstVaapiWindowGLXClass:
*
* An X11 #Window suitable for GLX rendering.
*/
struct _GstVaapiWindowGLXClass {
/*< private >*/
GstVaapiWindowX11Class parent_class;
2010-03-25 17:28:49 +00:00
GstVaapiObjectFinalizeFunc parent_finalize;
GstVaapiWindowResizeFunc parent_resize;
2010-03-25 17:28:49 +00:00
};
/* Fill rectangle coords with capped bounds */
static inline void
fill_rect(
GstVaapiRectangle *dst_rect,
const GstVaapiRectangle *src_rect,
guint width,
guint height
)
{
if (src_rect) {
dst_rect->x = src_rect->x > 0 ? src_rect->x : 0;
dst_rect->y = src_rect->y > 0 ? src_rect->y : 0;
if (src_rect->x + src_rect->width < width)
dst_rect->width = src_rect->width;
else
dst_rect->width = width - dst_rect->x;
if (src_rect->y + src_rect->height < height)
dst_rect->height = src_rect->height;
else
dst_rect->height = height - dst_rect->y;
}
else {
dst_rect->x = 0;
dst_rect->y = 0;
dst_rect->width = width;
dst_rect->height = height;
}
}
2010-03-25 17:28:49 +00:00
static void
_gst_vaapi_window_glx_destroy_context(GstVaapiWindow *window)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
2010-03-31 15:25:19 +00:00
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
if (priv->gl_context) {
gl_destroy_context(priv->gl_context);
priv->gl_context = NULL;
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
2010-03-25 17:28:49 +00:00
}
static gboolean
2010-03-31 15:25:19 +00:00
_gst_vaapi_window_glx_create_context(
GstVaapiWindow *window,
GLXContext foreign_context
2010-03-31 15:25:19 +00:00
)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
Display * const dpy = GST_VAAPI_OBJECT_XDISPLAY(window);
2010-03-31 15:25:19 +00:00
GLContextState parent_cs;
2010-03-25 17:28:49 +00:00
2010-03-31 15:25:19 +00:00
parent_cs.display = dpy;
parent_cs.window = None;
parent_cs.context = foreign_context;
2010-03-25 17:28:49 +00:00
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
priv->gl_context = gl_create_context(
dpy,
GST_VAAPI_OBJECT_XSCREEN(window),
&parent_cs
);
2010-03-31 15:25:19 +00:00
if (!priv->gl_context) {
GST_DEBUG("could not create GLX context");
goto end;
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
if (!glXIsDirect(dpy, priv->gl_context->context)) {
GST_DEBUG("could not create a direct-rendering GLX context");
goto out_destroy_context;
}
goto end;
out_destroy_context:
gl_destroy_context(priv->gl_context);
priv->gl_context = NULL;
end:
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
return priv->gl_context != NULL;
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
static gboolean
_gst_vaapi_window_glx_ensure_context(
GstVaapiWindow *window,
GLXContext foreign_context
2010-03-31 15:25:19 +00:00
)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
2010-03-31 15:25:19 +00:00
if (priv->gl_context) {
if (!foreign_context || foreign_context == priv->gl_context->context)
return TRUE;
_gst_vaapi_window_glx_destroy_context(window);
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
return _gst_vaapi_window_glx_create_context(window, foreign_context);
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
static gboolean
gst_vaapi_window_glx_ensure_context(
GstVaapiWindow *window,
GLXContext foreign_context
2010-03-31 15:25:19 +00:00
)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-31 15:25:19 +00:00
GLContextState old_cs;
guint width, height;
2010-03-25 17:28:49 +00:00
2010-03-31 15:25:19 +00:00
if (!_gst_vaapi_window_glx_ensure_context(window, foreign_context))
return FALSE;
priv->gl_context->window = GST_VAAPI_OBJECT_ID(window);
if (!gl_set_current_context(priv->gl_context, &old_cs)) {
GST_DEBUG("could not make newly created GLX context current");
return FALSE;
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
glDrawBuffer(GL_BACK);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
gst_vaapi_window_get_size(window, &width, &height);
2010-03-31 15:25:19 +00:00
gl_resize(width, height);
gl_set_bgcolor(0);
glClear(GL_COLOR_BUFFER_BIT);
gl_set_current_context(&old_cs, NULL);
return TRUE;
2010-03-25 17:28:49 +00:00
}
static Visual *
gst_vaapi_window_glx_get_visual(GstVaapiWindow *window)
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
if (!_gst_vaapi_window_glx_ensure_context(window, NULL))
2010-03-25 17:28:49 +00:00
return NULL;
return priv->gl_context->visual->visual;
2010-03-25 17:28:49 +00:00
}
static void
gst_vaapi_window_glx_destroy_colormap(GstVaapiWindow *window)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
Display * const dpy = GST_VAAPI_OBJECT_XDISPLAY(window);
if (priv->cmap) {
if (!window->use_foreign_window) {
2010-03-25 17:28:49 +00:00
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
XFreeColormap(dpy, priv->cmap);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
}
priv->cmap = None;
}
}
static Colormap
gst_vaapi_window_glx_create_colormap(GstVaapiWindow *window)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
2010-03-25 17:28:49 +00:00
Display * const dpy = GST_VAAPI_OBJECT_XDISPLAY(window);
int screen;
XWindowAttributes wattr;
2010-03-31 15:25:19 +00:00
gboolean success = FALSE;
2010-03-25 17:28:49 +00:00
if (!priv->cmap) {
if (!window->use_foreign_window) {
2010-03-31 15:25:19 +00:00
if (!_gst_vaapi_window_glx_ensure_context(window, NULL))
return None;
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
x11_trap_errors();
/* XXX: add a GstVaapiDisplayX11:x11-screen property? */
screen = GST_VAAPI_OBJECT_XSCREEN(window);
2010-03-31 15:25:19 +00:00
priv->cmap = XCreateColormap(
dpy,
RootWindow(dpy, screen),
priv->gl_context->visual->visual,
AllocNone
);
success = x11_untrap_errors() == 0;
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
2010-03-25 17:28:49 +00:00
}
else {
2010-03-31 15:25:19 +00:00
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
x11_trap_errors();
2010-03-25 17:28:49 +00:00
XGetWindowAttributes(dpy, GST_VAAPI_OBJECT_ID(window), &wattr);
priv->cmap = wattr.colormap;
2010-03-31 15:25:19 +00:00
success = x11_untrap_errors() == 0;
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
2010-03-25 17:28:49 +00:00
}
2010-03-31 15:25:19 +00:00
if (!success)
2010-03-25 17:28:49 +00:00
return None;
}
return priv->cmap;
}
static Colormap
gst_vaapi_window_glx_get_colormap(GstVaapiWindow *window)
{
return gst_vaapi_window_glx_create_colormap(window);
2010-03-25 17:28:49 +00:00
}
static gboolean
gst_vaapi_window_glx_resize(GstVaapiWindow *window,
guint width, guint height)
{
GstVaapiWindowGLXPrivate * const priv =
GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window);
const GstVaapiWindowGLXClass * const klass =
GST_VAAPI_WINDOW_GLX_GET_CLASS(window);
Display * const dpy = GST_VAAPI_OBJECT_XDISPLAY(window);
2010-03-31 15:25:19 +00:00
GLContextState old_cs;
if (!klass->parent_resize(window, width, height))
return FALSE;
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
XSync(dpy, False); /* make sure resize completed */
2010-03-31 15:25:19 +00:00
if (gl_set_current_context(priv->gl_context, &old_cs)) {
gl_resize(width, height);
2010-03-31 15:25:19 +00:00
gl_set_current_context(&old_cs, NULL);
}
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
return TRUE;
}
2010-03-25 17:28:49 +00:00
static void
gst_vaapi_window_glx_finalize(GstVaapiWindowGLX *window)
2010-03-25 17:28:49 +00:00
{
GstVaapiWindow * const base_window = GST_VAAPI_WINDOW(window);
2010-03-25 17:28:49 +00:00
_gst_vaapi_window_glx_destroy_context(base_window);
gst_vaapi_window_glx_destroy_colormap(base_window);
2010-03-25 17:28:49 +00:00
GST_VAAPI_WINDOW_GLX_GET_CLASS(window)->parent_finalize(
GST_VAAPI_OBJECT(window));
2010-03-25 17:28:49 +00:00
}
static void
gst_vaapi_window_glx_class_init(GstVaapiWindowGLXClass *klass)
{
GstVaapiWindowClass * const window_class =
GST_VAAPI_WINDOW_CLASS(klass);
GstVaapiWindowX11Class * const xwindow_class =
GST_VAAPI_WINDOW_X11_CLASS(klass);
gst_vaapi_window_x11_class_init(xwindow_class);
klass->parent_resize = window_class->resize;
klass->parent_finalize = GST_VAAPI_OBJECT_CLASS(klass)->finalize;
window_class->resize = gst_vaapi_window_glx_resize;
xwindow_class->get_visual = gst_vaapi_window_glx_get_visual;
xwindow_class->get_colormap = gst_vaapi_window_glx_get_colormap;
2010-03-25 17:28:49 +00:00
}
GST_VAAPI_OBJECT_DEFINE_CLASS_WITH_CODE(
GstVaapiWindowGLX,
gst_vaapi_window_glx,
gst_vaapi_window_glx_class_init(&g_class))
2010-03-25 17:28:49 +00:00
/**
* gst_vaapi_window_glx_new:
* @display: a #GstVaapiDisplay
* @width: the requested window width, in pixels
* @height: the requested windo height, in pixels
*
* Creates a window with the specified @width and @height. The window
* will be attached to the @display and remains invisible to the user
* until gst_vaapi_window_show() is called.
*
* Return value: the newly allocated #GstVaapiWindow object
*/
GstVaapiWindow *
gst_vaapi_window_glx_new(GstVaapiDisplay *display, guint width, guint height)
{
GstVaapiWindow *window;
2013-05-27 15:18:40 +00:00
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY_GLX(display), NULL);
window = gst_vaapi_window_new(GST_VAAPI_WINDOW_CLASS(
gst_vaapi_window_glx_class()), display, width, height);
if (!window)
return NULL;
if (!gst_vaapi_window_glx_ensure_context(window, NULL))
goto error;
return window;
error:
gst_vaapi_window_unref(window);
return NULL;
2010-03-25 17:28:49 +00:00
}
/**
* gst_vaapi_window_glx_new_with_xid:
* @display: a #GstVaapiDisplay
* @xid: an X11 #Window id
*
* Creates a #GstVaapiWindow using the X11 #Window @xid. The caller
* still owns the window and must call XDestroyWindow() when all
* #GstVaapiWindow references are released. Doing so too early can
* yield undefined behaviour.
*
* Return value: the newly allocated #GstVaapiWindow object
*/
GstVaapiWindow *
gst_vaapi_window_glx_new_with_xid(GstVaapiDisplay *display, Window xid)
{
GstVaapiWindow *window;
GST_DEBUG("new window from xid 0x%08x", (guint)xid);
2010-03-25 17:28:49 +00:00
2013-05-27 15:18:40 +00:00
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY_GLX(display), NULL);
2010-03-25 17:28:49 +00:00
g_return_val_if_fail(xid != None, NULL);
window = gst_vaapi_window_new_from_native(GST_VAAPI_WINDOW_CLASS(
gst_vaapi_window_glx_class()), display, GINT_TO_POINTER(xid));
if (!window)
return NULL;
if (!gst_vaapi_window_glx_ensure_context(window, NULL))
goto error;
return window;
error:
gst_vaapi_window_unref(window);
return NULL;
2010-03-25 17:28:49 +00:00
}
/**
* gst_vaapi_window_glx_get_context:
2010-03-29 09:09:30 +00:00
* @window: a #GstVaapiWindowGLX
2010-03-25 17:28:49 +00:00
*
* Returns the #GLXContext bound to the @window.
*
* Return value: the #GLXContext bound to the @window
*/
GLXContext
gst_vaapi_window_glx_get_context(GstVaapiWindowGLX *window)
{
g_return_val_if_fail(window != NULL, NULL);
2010-03-25 17:28:49 +00:00
return GST_VAAPI_WINDOW_GLX_GET_PRIVATE(window)->gl_context->context;
2010-03-25 17:28:49 +00:00
}
/**
* gst_vaapi_window_glx_set_context:
2010-03-29 09:09:30 +00:00
* @window: a #GstVaapiWindowGLX
2010-03-25 17:28:49 +00:00
* @ctx: a GLX context
*
* Binds GLX context @ctx to @window. If @ctx is non %NULL, the caller
* is responsible to making sure it has compatible visual with that of
* the underlying X window. If @ctx is %NULL, a new context is created
* and the @window owns it.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_window_glx_set_context(GstVaapiWindowGLX *window, GLXContext ctx)
{
g_return_val_if_fail(window != NULL, FALSE);
2010-03-25 17:28:49 +00:00
return gst_vaapi_window_glx_ensure_context(GST_VAAPI_WINDOW(window), ctx);
2010-03-25 17:28:49 +00:00
}
/**
* gst_vaapi_window_glx_make_current:
* @window: a #GstVaapiWindowGLX
*
* Makes the @window GLX context the current GLX rendering context of
* the calling thread, replacing the previously current context if
* there was one.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_window_glx_make_current(GstVaapiWindowGLX *window)
{
gboolean success;
g_return_val_if_fail(window != NULL, FALSE);
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
success = gl_set_current_context(window->priv.gl_context, NULL);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
return success;
}
2010-03-25 17:28:49 +00:00
/**
* gst_vaapi_window_glx_swap_buffers:
* @window: a #GstVaapiWindowGLX
*
* Promotes the contents of the back buffer of @window to become the
* contents of the front buffer of @window. This simply is wrapper
* around glXSwapBuffers().
*/
void
gst_vaapi_window_glx_swap_buffers(GstVaapiWindowGLX *window)
{
g_return_if_fail(window != NULL);
2010-03-25 17:28:49 +00:00
GST_VAAPI_OBJECT_LOCK_DISPLAY(window);
gl_swap_buffers(window->priv.gl_context);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY(window);
2010-03-25 17:28:49 +00:00
}
/**
* gst_vaapi_window_glx_put_texture:
* @window: a #GstVaapiWindowGLX
* @texture: a #GstVaapiTexture
* @src_rect: the sub-rectangle of the source texture to
* extract and process. If %NULL, the entire texture will be used.
* @dst_rect: the sub-rectangle of the destination
* window into which the texture is rendered. If %NULL, the entire
* window will be used.
*
* Renders the @texture region specified by @src_rect into the @window
* region specified by @dst_rect.
*
* NOTE: only GL_TEXTURE_2D textures are supported at this time.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_window_glx_put_texture(
GstVaapiWindowGLX *window,
GstVaapiTexture *texture,
const GstVaapiRectangle *src_rect,
const GstVaapiRectangle *dst_rect
)
{
GstVaapiRectangle tmp_src_rect, tmp_dst_rect;
GLTextureState ts;
GLenum tex_target;
GLuint tex_id;
guint tex_width, tex_height;
guint win_width, win_height;
g_return_val_if_fail(window != NULL, FALSE);
g_return_val_if_fail(texture != NULL, FALSE);
gst_vaapi_texture_get_size(texture, &tex_width, &tex_height);
fill_rect(&tmp_src_rect, src_rect, tex_width, tex_height);
src_rect = &tmp_src_rect;
gst_vaapi_window_get_size(GST_VAAPI_WINDOW(window), &win_width, &win_height);
fill_rect(&tmp_dst_rect, dst_rect, win_width, win_height);
dst_rect = &tmp_dst_rect;
/* XXX: only GL_TEXTURE_2D textures are supported at this time */
tex_target = gst_vaapi_texture_get_target(texture);
if (tex_target != GL_TEXTURE_2D)
return FALSE;
tex_id = gst_vaapi_texture_get_id(texture);
if (!gl_bind_texture(&ts, tex_target, tex_id))
return FALSE;
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glPushMatrix();
glTranslatef((GLfloat)dst_rect->x, (GLfloat)dst_rect->y, 0.0f);
glBegin(GL_QUADS);
{
const float tx1 = (float)src_rect->x / tex_width;
const float tx2 = (float)(src_rect->x + src_rect->width) / tex_width;
const float ty1 = (float)src_rect->y / tex_height;
const float ty2 = (float)(src_rect->y + src_rect->height) / tex_height;
const guint w = dst_rect->width;
const guint h = dst_rect->height;
glTexCoord2f(tx1, ty1); glVertex2i(0, 0);
glTexCoord2f(tx1, ty2); glVertex2i(0, h);
glTexCoord2f(tx2, ty2); glVertex2i(w, h);
glTexCoord2f(tx2, ty1); glVertex2i(w, 0);
}
glEnd();
glPopMatrix();
gl_unbind_texture(&ts);
return TRUE;
}