mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-08 13:18:52 +00:00
e4bf9ed8f0
was not quite right and changed
the wrong thing. Intead we needed to change the multiplication order
and should have kept the previous to/from matrices as is done in this
patch.
874 lines
25 KiB
C
874 lines
25 KiB
C
/*
|
|
* GStreamer
|
|
* 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:gstglutils
|
|
* @title: GstGLUtils
|
|
* @short_description: some miscellaneous utilities for OpenGL
|
|
* @see_also: #GstGLContext
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <gst/gst.h>
|
|
#include <glib/gprintf.h>
|
|
|
|
#include "gl.h"
|
|
#include "gstglutils.h"
|
|
#include "gstglutils_private.h"
|
|
|
|
#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
|
|
|
|
#define USING_OPENGL(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL, 1, 0))
|
|
#define USING_OPENGL3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL3, 3, 1))
|
|
#define USING_GLES(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES, 1, 0))
|
|
#define USING_GLES2(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 2, 0))
|
|
#define USING_GLES3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 3, 0))
|
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
GST_DEBUG_CATEGORY_STATIC (gst_gl_utils_debug);
|
|
static GstDebugCategory *
|
|
_init_gl_utils_debug_category (void)
|
|
{
|
|
static volatile gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_INIT (gst_gl_utils_debug, "glutils", 0,
|
|
"OpenGL Utilities");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
|
|
return gst_gl_utils_debug;
|
|
}
|
|
|
|
#define GST_CAT_DEFAULT _init_gl_utils_debug_category()
|
|
#endif
|
|
|
|
static gboolean
|
|
gst_gl_display_found (GstElement * element, GstGLDisplay * display)
|
|
{
|
|
if (display) {
|
|
GST_LOG_OBJECT (element, "already have a display (%p)", display);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (GST_CAT_CONTEXT);
|
|
|
|
static void
|
|
_init_context_debug (void)
|
|
{
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static volatile gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_GET (GST_CAT_CONTEXT, "GST_CONTEXT");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static gboolean
|
|
pad_query (const GValue * item, GValue * value, gpointer user_data)
|
|
{
|
|
GstPad *pad = g_value_get_object (item);
|
|
GstQuery *query = user_data;
|
|
gboolean res;
|
|
|
|
_init_context_debug ();
|
|
|
|
res = gst_pad_peer_query (pad, query);
|
|
|
|
if (res) {
|
|
g_value_set_boolean (value, TRUE);
|
|
return FALSE;
|
|
}
|
|
|
|
GST_CAT_INFO_OBJECT (GST_CAT_CONTEXT, pad, "pad peer query failed");
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_gl_run_query (GstElement * element, GstQuery * query,
|
|
GstPadDirection direction)
|
|
{
|
|
GstIterator *it;
|
|
GstIteratorFoldFunction func = pad_query;
|
|
GValue res = { 0 };
|
|
|
|
g_value_init (&res, G_TYPE_BOOLEAN);
|
|
g_value_set_boolean (&res, FALSE);
|
|
|
|
/* Ask neighbor */
|
|
if (direction == GST_PAD_SRC)
|
|
it = gst_element_iterate_src_pads (element);
|
|
else
|
|
it = gst_element_iterate_sink_pads (element);
|
|
|
|
while (gst_iterator_fold (it, func, &res, query) == GST_ITERATOR_RESYNC)
|
|
gst_iterator_resync (it);
|
|
|
|
gst_iterator_free (it);
|
|
|
|
return g_value_get_boolean (&res);
|
|
}
|
|
|
|
static void
|
|
_gst_context_query (GstElement * element, const gchar * display_type)
|
|
{
|
|
GstQuery *query;
|
|
GstContext *ctxt;
|
|
|
|
_init_context_debug ();
|
|
|
|
/* 2a) Query downstream with GST_QUERY_CONTEXT for the context and
|
|
* check if downstream already has a context of the specific type
|
|
* 2b) Query upstream as above.
|
|
*/
|
|
query = gst_query_new_context (display_type);
|
|
if (gst_gl_run_query (element, query, GST_PAD_SRC)) {
|
|
gst_query_parse_context (query, &ctxt);
|
|
GST_CAT_INFO_OBJECT (GST_CAT_CONTEXT, element,
|
|
"found context (%p) in downstream query", ctxt);
|
|
gst_element_set_context (element, ctxt);
|
|
} else if (gst_gl_run_query (element, query, GST_PAD_SINK)) {
|
|
gst_query_parse_context (query, &ctxt);
|
|
GST_CAT_INFO_OBJECT (GST_CAT_CONTEXT, element,
|
|
"found context (%p) in upstream query", ctxt);
|
|
gst_element_set_context (element, ctxt);
|
|
} else {
|
|
/* 3) Post a GST_MESSAGE_NEED_CONTEXT message on the bus with
|
|
* the required context type and afterwards check if a
|
|
* usable context was set now as in 1). The message could
|
|
* be handled by the parent bins of the element and the
|
|
* application.
|
|
*/
|
|
GstMessage *msg;
|
|
|
|
GST_CAT_INFO_OBJECT (GST_CAT_CONTEXT, element,
|
|
"posting need context message");
|
|
msg = gst_message_new_need_context (GST_OBJECT_CAST (element),
|
|
display_type);
|
|
gst_element_post_message (element, msg);
|
|
}
|
|
|
|
/*
|
|
* Whomever responds to the need-context message performs a
|
|
* GstElement::set_context() with the required context in which the element
|
|
* is required to update the display_ptr or call gst_gl_handle_set_context().
|
|
*/
|
|
|
|
gst_query_unref (query);
|
|
}
|
|
|
|
static void
|
|
gst_gl_display_context_query (GstElement * element, GstGLDisplay ** display_ptr)
|
|
{
|
|
_gst_context_query (element, GST_GL_DISPLAY_CONTEXT_TYPE);
|
|
if (*display_ptr)
|
|
return;
|
|
|
|
#if GST_GL_HAVE_WINDOW_X11
|
|
_gst_context_query (element, "gst.x11.display.handle");
|
|
if (*display_ptr)
|
|
return;
|
|
#endif
|
|
|
|
#if GST_GL_HAVE_WINDOW_WAYLAND
|
|
_gst_context_query (element, "GstWaylandDisplayHandleContextType");
|
|
if (*display_ptr)
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
gst_gl_context_query (GstElement * element)
|
|
{
|
|
_gst_context_query (element, "gst.gl.app_context");
|
|
}
|
|
|
|
/* 4) Create a context by itself and post a GST_MESSAGE_HAVE_CONTEXT
|
|
* message.
|
|
*/
|
|
void
|
|
gst_gl_element_propagate_display_context (GstElement * element,
|
|
GstGLDisplay * display)
|
|
{
|
|
GstContext *context;
|
|
GstMessage *msg;
|
|
|
|
if (!display) {
|
|
GST_ERROR_OBJECT (element, "Could not get GL display connection");
|
|
return;
|
|
}
|
|
|
|
_init_context_debug ();
|
|
|
|
context = gst_context_new (GST_GL_DISPLAY_CONTEXT_TYPE, TRUE);
|
|
gst_context_set_gl_display (context, display);
|
|
|
|
gst_element_set_context (element, context);
|
|
|
|
GST_CAT_INFO_OBJECT (GST_CAT_CONTEXT, element,
|
|
"posting have context (%p) message with display (%p)", context, display);
|
|
msg = gst_message_new_have_context (GST_OBJECT_CAST (element), context);
|
|
gst_element_post_message (GST_ELEMENT_CAST (element), msg);
|
|
}
|
|
|
|
/**
|
|
* gst_gl_ensure_element_data:
|
|
* @element: the #GstElement running the query
|
|
* @display_ptr: (inout): the resulting #GstGLDisplay
|
|
* @other_context_ptr: (inout): the resulting #GstGLContext
|
|
*
|
|
* Perform the steps necessary for retrieving a #GstGLDisplay and (optionally)
|
|
* an application provided #GstGLContext from the surrounding elements or from
|
|
* the application using the #GstContext mechanism.
|
|
*
|
|
* If the contents of @display_ptr or @other_context_ptr are not %NULL, then no
|
|
* #GstContext query is necessary for #GstGLDisplay or #GstGLContext retrieval
|
|
* or is performed.
|
|
*
|
|
* This performs #GstContext queries (if necessary) for a winsys display
|
|
* connection with %GST_GL_DISPLAY_CONTEXT_TYPE, "gst.x11.display.handle", and
|
|
* "GstWaylandDisplayHandleContextType" stopping after the first successful
|
|
* retrieval.
|
|
*
|
|
* This also performs a #GstContext query (if necessary) for an optional
|
|
* application provided #GstGLContext using the name "gst.gl.app_context".
|
|
* The returned #GstGLContext will be shared with a GStreamer created OpenGL context.
|
|
*
|
|
* Returns: whether a #GstGLDisplay exists in @display_ptr
|
|
*/
|
|
gboolean
|
|
gst_gl_ensure_element_data (gpointer element, GstGLDisplay ** display_ptr,
|
|
GstGLContext ** other_context_ptr)
|
|
{
|
|
GstGLDisplay *display;
|
|
|
|
g_return_val_if_fail (element != NULL, FALSE);
|
|
g_return_val_if_fail (display_ptr != NULL, FALSE);
|
|
g_return_val_if_fail (other_context_ptr != NULL, FALSE);
|
|
|
|
/* 1) Check if the element already has a context of the specific
|
|
* type.
|
|
*/
|
|
display = *display_ptr;
|
|
if (gst_gl_display_found (element, display))
|
|
goto done;
|
|
|
|
gst_gl_display_context_query (element, display_ptr);
|
|
|
|
/* Neighbour found and it updated the display */
|
|
if (gst_gl_display_found (element, *display_ptr))
|
|
goto get_gl_context;
|
|
|
|
/* If no neighboor, or application not interested, use system default */
|
|
display = gst_gl_display_new ();
|
|
|
|
*display_ptr = display;
|
|
|
|
gst_gl_element_propagate_display_context (element, display);
|
|
|
|
get_gl_context:
|
|
if (*other_context_ptr)
|
|
goto done;
|
|
|
|
gst_gl_context_query (element);
|
|
|
|
done:
|
|
return *display_ptr != NULL;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_handle_set_context:
|
|
* @element: a #GstElement
|
|
* @context: a #GstContext
|
|
* @display: (inout) (transfer full): location of a #GstGLDisplay
|
|
* @other_context: (inout) (transfer full): location of a #GstGLContext
|
|
*
|
|
* Helper function for implementing #GstElementClass.set_context() in
|
|
* OpenGL capable elements.
|
|
*
|
|
* Retrieve's the #GstGLDisplay or #GstGLContext in @context and places the
|
|
* result in @display or @other_context respectively.
|
|
*
|
|
* Returns: whether the @display or @other_context could be set successfully
|
|
*/
|
|
gboolean
|
|
gst_gl_handle_set_context (GstElement * element, GstContext * context,
|
|
GstGLDisplay ** display, GstGLContext ** other_context)
|
|
{
|
|
GstGLDisplay *display_replacement = NULL;
|
|
GstGLContext *context_replacement = NULL;
|
|
const gchar *context_type;
|
|
|
|
g_return_val_if_fail (display != NULL, FALSE);
|
|
g_return_val_if_fail (other_context != NULL, FALSE);
|
|
|
|
if (!context)
|
|
return FALSE;
|
|
|
|
context_type = gst_context_get_context_type (context);
|
|
|
|
if (g_strcmp0 (context_type, GST_GL_DISPLAY_CONTEXT_TYPE) == 0) {
|
|
if (!gst_context_get_gl_display (context, &display_replacement)) {
|
|
GST_WARNING_OBJECT (element, "Failed to get display from context");
|
|
return FALSE;
|
|
}
|
|
}
|
|
#if GST_GL_HAVE_WINDOW_X11
|
|
else if (g_strcmp0 (context_type, "gst.x11.display.handle") == 0) {
|
|
const GstStructure *s;
|
|
Display *display;
|
|
|
|
s = gst_context_get_structure (context);
|
|
if (gst_structure_get (s, "display", G_TYPE_POINTER, &display, NULL))
|
|
display_replacement =
|
|
(GstGLDisplay *) gst_gl_display_x11_new_with_display (display);
|
|
}
|
|
#endif
|
|
#if GST_GL_HAVE_WINDOW_WAYLAND
|
|
else if (g_strcmp0 (context_type, "GstWaylandDisplayHandleContextType") == 0) {
|
|
const GstStructure *s;
|
|
struct wl_display *display;
|
|
|
|
s = gst_context_get_structure (context);
|
|
if (gst_structure_get (s, "display", G_TYPE_POINTER, &display, NULL))
|
|
display_replacement =
|
|
(GstGLDisplay *) gst_gl_display_wayland_new_with_display (display);
|
|
}
|
|
#endif
|
|
else if (g_strcmp0 (context_type, "gst.gl.app_context") == 0) {
|
|
const GstStructure *s = gst_context_get_structure (context);
|
|
GstGLDisplay *context_display;
|
|
GstGLDisplay *element_display;
|
|
|
|
if (gst_structure_get (s, "context", GST_TYPE_GL_CONTEXT,
|
|
&context_replacement, NULL)) {
|
|
context_display = gst_gl_context_get_display (context_replacement);
|
|
element_display = display_replacement ? display_replacement : *display;
|
|
if (element_display
|
|
&& (gst_gl_display_get_handle_type (element_display) &
|
|
gst_gl_display_get_handle_type (context_display)) == 0) {
|
|
GST_ELEMENT_WARNING (element, LIBRARY, SETTINGS, ("%s",
|
|
"Cannot set a GL context with a different display type"), ("%s",
|
|
"Cannot set a GL context with a different display type"));
|
|
gst_object_unref (context_replacement);
|
|
context_replacement = NULL;
|
|
}
|
|
gst_object_unref (context_display);
|
|
}
|
|
}
|
|
|
|
if (display_replacement) {
|
|
GstGLDisplay *old = *display;
|
|
*display = display_replacement;
|
|
|
|
if (old)
|
|
gst_object_unref (old);
|
|
}
|
|
|
|
if (context_replacement) {
|
|
GstGLContext *old = *other_context;
|
|
*other_context = context_replacement;
|
|
|
|
if (old)
|
|
gst_object_unref (old);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_handle_context_query:
|
|
* @element: a #GstElement
|
|
* @query: a #GstQuery of type %GST_QUERY_CONTEXT
|
|
* @display: (transfer none) (nullable): a #GstGLDisplay
|
|
* @context: (transfer none) (nullable): a #GstGLContext
|
|
* @other_context: (transfer none) (nullable): application provided #GstGLContext
|
|
*
|
|
* Returns: Whether the @query was successfully responded to from the passed
|
|
* @display, @context, and @other_context.
|
|
*/
|
|
gboolean
|
|
gst_gl_handle_context_query (GstElement * element, GstQuery * query,
|
|
GstGLDisplay * display, GstGLContext * gl_context,
|
|
GstGLContext * other_context)
|
|
{
|
|
const gchar *context_type;
|
|
GstContext *context, *old_context;
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
|
|
g_return_val_if_fail (GST_IS_QUERY (query), FALSE);
|
|
g_return_val_if_fail (display == NULL || GST_IS_GL_DISPLAY (display), FALSE);
|
|
g_return_val_if_fail (gl_context == NULL
|
|
|| GST_IS_GL_CONTEXT (gl_context), FALSE);
|
|
g_return_val_if_fail (other_context == NULL
|
|
|| GST_IS_GL_CONTEXT (other_context), FALSE);
|
|
|
|
GST_LOG_OBJECT (element, "handle context query %" GST_PTR_FORMAT, query);
|
|
gst_query_parse_context_type (query, &context_type);
|
|
|
|
if (display && g_strcmp0 (context_type, GST_GL_DISPLAY_CONTEXT_TYPE) == 0) {
|
|
gst_query_parse_context (query, &old_context);
|
|
|
|
if (old_context)
|
|
context = gst_context_copy (old_context);
|
|
else
|
|
context = gst_context_new (GST_GL_DISPLAY_CONTEXT_TYPE, TRUE);
|
|
|
|
gst_context_set_gl_display (context, display);
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
GST_DEBUG_OBJECT (element, "successfully set %" GST_PTR_FORMAT
|
|
" on %" GST_PTR_FORMAT, display, query);
|
|
|
|
return TRUE;
|
|
}
|
|
#if GST_GL_HAVE_WINDOW_X11
|
|
else if (display && g_strcmp0 (context_type, "gst.x11.display.handle") == 0) {
|
|
GstStructure *s;
|
|
|
|
gst_query_parse_context (query, &old_context);
|
|
|
|
if (old_context)
|
|
context = gst_context_copy (old_context);
|
|
else
|
|
context = gst_context_new ("gst.x11.display.handle", TRUE);
|
|
|
|
if (gst_gl_display_get_handle_type (display) & GST_GL_DISPLAY_TYPE_X11) {
|
|
Display *x11_display = (Display *) gst_gl_display_get_handle (display);
|
|
|
|
if (x11_display) {
|
|
s = gst_context_writable_structure (context);
|
|
gst_structure_set (s, "display", G_TYPE_POINTER, x11_display, NULL);
|
|
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
|
|
GST_DEBUG_OBJECT (element, "successfully set x11 display %p (from %"
|
|
GST_PTR_FORMAT ") on %" GST_PTR_FORMAT, x11_display, display,
|
|
query);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#if GST_GL_HAVE_WINDOW_WAYLAND
|
|
else if (display
|
|
&& g_strcmp0 (context_type, "GstWaylandDisplayHandleContextType") == 0) {
|
|
GstStructure *s;
|
|
|
|
gst_query_parse_context (query, &old_context);
|
|
|
|
if (old_context)
|
|
context = gst_context_copy (old_context);
|
|
else
|
|
context = gst_context_new ("GstWaylandDisplayHandleContextType", TRUE);
|
|
|
|
if (gst_gl_display_get_handle_type (display) & GST_GL_DISPLAY_TYPE_WAYLAND) {
|
|
struct wl_display *wayland_display =
|
|
(struct wl_display *) gst_gl_display_get_handle (display);
|
|
|
|
if (wayland_display) {
|
|
s = gst_context_writable_structure (context);
|
|
gst_structure_set (s, "display", G_TYPE_POINTER, wayland_display, NULL);
|
|
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
|
|
GST_DEBUG_OBJECT (element, "successfully set wayland display %p (from %"
|
|
GST_PTR_FORMAT ") on %" GST_PTR_FORMAT, wayland_display, display,
|
|
query);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
else if (other_context && g_strcmp0 (context_type, "gst.gl.app_context") == 0) {
|
|
GstStructure *s;
|
|
|
|
gst_query_parse_context (query, &old_context);
|
|
|
|
if (old_context)
|
|
context = gst_context_copy (old_context);
|
|
else
|
|
context = gst_context_new ("gst.gl.app_context", TRUE);
|
|
|
|
s = gst_context_writable_structure (context);
|
|
gst_structure_set (s, "context", GST_TYPE_GL_CONTEXT, other_context, NULL);
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
|
|
GST_DEBUG_OBJECT (element, "successfully set application GL context %"
|
|
GST_PTR_FORMAT " on %" GST_PTR_FORMAT, other_context, query);
|
|
|
|
return TRUE;
|
|
} else if (gl_context
|
|
&& g_strcmp0 (context_type, "gst.gl.local_context") == 0) {
|
|
GstStructure *s;
|
|
|
|
gst_query_parse_context (query, &old_context);
|
|
|
|
if (old_context)
|
|
context = gst_context_copy (old_context);
|
|
else
|
|
context = gst_context_new ("gst.gl.local_context", TRUE);
|
|
|
|
s = gst_context_writable_structure (context);
|
|
gst_structure_set (s, "context", GST_TYPE_GL_CONTEXT, gl_context, NULL);
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
|
|
GST_DEBUG_OBJECT (element, "successfully set GL context %"
|
|
GST_PTR_FORMAT " on %" GST_PTR_FORMAT, gl_context, query);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_query_local_gl_context:
|
|
* @element: a #GstElement to query from
|
|
* @direction: the #GstPadDirection to query
|
|
* @context_ptr: (inout): location containing the current and/or resulting
|
|
* #GstGLContext
|
|
*
|
|
* Performs a GST_QUERY_CONTEXT query of type "gst.gl.local_context" on all
|
|
* #GstPads in @element of @direction for the local OpenGL context used by
|
|
* GStreamer elements.
|
|
*
|
|
* Returns: whether @context_ptr contains a #GstGLContext
|
|
*/
|
|
gboolean
|
|
gst_gl_query_local_gl_context (GstElement * element, GstPadDirection direction,
|
|
GstGLContext ** context_ptr)
|
|
{
|
|
GstQuery *query;
|
|
GstContext *context;
|
|
const GstStructure *s;
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
|
|
g_return_val_if_fail (context_ptr != NULL, FALSE);
|
|
|
|
if (*context_ptr)
|
|
return TRUE;
|
|
|
|
query = gst_query_new_context ("gst.gl.local_context");
|
|
if (gst_gl_run_query (GST_ELEMENT (element), query, direction)) {
|
|
gst_query_parse_context (query, &context);
|
|
if (context) {
|
|
s = gst_context_get_structure (context);
|
|
gst_structure_get (s, "context", GST_TYPE_GL_CONTEXT, context_ptr, NULL);
|
|
}
|
|
}
|
|
|
|
gst_query_unref (query);
|
|
|
|
return *context_ptr != NULL;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_get_plane_data_size:
|
|
* @info: a #GstVideoInfo
|
|
* @align: a #GstVideoAlignment or %NULL
|
|
* @plane: plane number in @info to retrieve the data size of
|
|
*
|
|
* Retrieve the size in bytes of a video plane of data with a certain alignment
|
|
*/
|
|
gsize
|
|
gst_gl_get_plane_data_size (GstVideoInfo * info, GstVideoAlignment * align,
|
|
guint plane)
|
|
{
|
|
gint padded_height;
|
|
gsize plane_size;
|
|
|
|
padded_height = info->height;
|
|
|
|
if (align)
|
|
padded_height += align->padding_top + align->padding_bottom;
|
|
|
|
padded_height =
|
|
GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (info->finfo, plane, padded_height);
|
|
|
|
plane_size = GST_VIDEO_INFO_PLANE_STRIDE (info, plane) * padded_height;
|
|
|
|
return plane_size;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_get_plane_start:
|
|
* @info: a #GstVideoInfo
|
|
* @valign: a #GstVideoAlignment or %NULL
|
|
* @plane: plane number in @info to retrieve the data size of
|
|
*
|
|
* Returns: difference between the supposed start of the plane from the @info
|
|
* and where the data from the previous plane ends.
|
|
*/
|
|
gsize
|
|
gst_gl_get_plane_start (GstVideoInfo * info, GstVideoAlignment * valign,
|
|
guint plane)
|
|
{
|
|
gsize plane_start;
|
|
gint i;
|
|
|
|
/* find the start of the plane data including padding */
|
|
plane_start = 0;
|
|
for (i = 0; i < plane; i++) {
|
|
plane_start += gst_gl_get_plane_data_size (info, valign, i);
|
|
}
|
|
|
|
/* offset between the plane data start and where the video frame starts */
|
|
return (GST_VIDEO_INFO_PLANE_OFFSET (info, plane)) - plane_start;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_value_get_texture_target_mask:
|
|
* @value: an initialized #GValue of type G_TYPE_STRING
|
|
*
|
|
* See gst_gl_value_set_texture_target_from_mask() for what entails a mask
|
|
*
|
|
* Returns: the mask of #GstGLTextureTarget's in @value
|
|
*/
|
|
GstGLTextureTarget
|
|
gst_gl_value_get_texture_target_mask (const GValue * targets)
|
|
{
|
|
guint new_targets = 0;
|
|
|
|
g_return_val_if_fail (targets != NULL, GST_GL_TEXTURE_TARGET_NONE);
|
|
|
|
if (G_TYPE_CHECK_VALUE_TYPE (targets, G_TYPE_STRING)) {
|
|
GstGLTextureTarget target;
|
|
const gchar *str;
|
|
|
|
str = g_value_get_string (targets);
|
|
target = gst_gl_texture_target_from_string (str);
|
|
|
|
if (target)
|
|
new_targets |= 1 << target;
|
|
} else if (G_TYPE_CHECK_VALUE_TYPE (targets, GST_TYPE_LIST)) {
|
|
gint j, m;
|
|
|
|
m = gst_value_list_get_size (targets);
|
|
for (j = 0; j < m; j++) {
|
|
const GValue *val = gst_value_list_get_value (targets, j);
|
|
GstGLTextureTarget target;
|
|
const gchar *str;
|
|
|
|
str = g_value_get_string (val);
|
|
target = gst_gl_texture_target_from_string (str);
|
|
if (target)
|
|
new_targets |= 1 << target;
|
|
}
|
|
}
|
|
|
|
return new_targets;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_value_set_texture_target:
|
|
* @value: an initialized #GValue of type G_TYPE_STRING
|
|
* @target: a #GstGLTextureTarget's
|
|
*
|
|
* Returns: whether the @target could be set on @value
|
|
*/
|
|
gboolean
|
|
gst_gl_value_set_texture_target (GValue * value, GstGLTextureTarget target)
|
|
{
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
g_return_val_if_fail (target != GST_GL_TEXTURE_TARGET_NONE, FALSE);
|
|
|
|
if (target == GST_GL_TEXTURE_TARGET_2D) {
|
|
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_2D_STR);
|
|
} else if (target == GST_GL_TEXTURE_TARGET_RECTANGLE) {
|
|
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_RECTANGLE_STR);
|
|
} else if (target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES) {
|
|
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static guint64
|
|
_gst_gl_log2_int64 (guint64 value)
|
|
{
|
|
guint64 ret = 0;
|
|
|
|
while (value >>= 1)
|
|
ret++;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_value_set_texture_target_from_mask:
|
|
* @value: an uninitialized #GValue
|
|
* @target_mask: a bitwise mask of #GstGLTextureTarget's
|
|
*
|
|
* A mask is a bitwise OR of (1 << target) where target is a valid
|
|
* #GstGLTextureTarget
|
|
*
|
|
* Returns: whether the @target_mask could be set on @value
|
|
*/
|
|
gboolean
|
|
gst_gl_value_set_texture_target_from_mask (GValue * value,
|
|
GstGLTextureTarget target_mask)
|
|
{
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
g_return_val_if_fail (target_mask != GST_GL_TEXTURE_TARGET_NONE, FALSE);
|
|
|
|
if ((target_mask & (target_mask - 1)) == 0) {
|
|
/* only one texture target set */
|
|
g_value_init (value, G_TYPE_STRING);
|
|
return gst_gl_value_set_texture_target (value,
|
|
_gst_gl_log2_int64 (target_mask));
|
|
} else {
|
|
GValue item = G_VALUE_INIT;
|
|
gboolean ret = FALSE;
|
|
|
|
g_value_init (value, GST_TYPE_LIST);
|
|
g_value_init (&item, G_TYPE_STRING);
|
|
if (target_mask & (1 << GST_GL_TEXTURE_TARGET_2D)) {
|
|
gst_gl_value_set_texture_target (&item, GST_GL_TEXTURE_TARGET_2D);
|
|
gst_value_list_append_value (value, &item);
|
|
ret = TRUE;
|
|
}
|
|
if (target_mask & (1 << GST_GL_TEXTURE_TARGET_RECTANGLE)) {
|
|
gst_gl_value_set_texture_target (&item, GST_GL_TEXTURE_TARGET_RECTANGLE);
|
|
gst_value_list_append_value (value, &item);
|
|
ret = TRUE;
|
|
}
|
|
if (target_mask & (1 << GST_GL_TEXTURE_TARGET_EXTERNAL_OES)) {
|
|
gst_gl_value_set_texture_target (&item,
|
|
GST_GL_TEXTURE_TARGET_EXTERNAL_OES);
|
|
gst_value_list_append_value (value, &item);
|
|
ret = TRUE;
|
|
}
|
|
|
|
g_value_unset (&item);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
static const gfloat identity_matrix[] = {
|
|
1.0, 0.0, 0.0, 0.0,
|
|
0.0, 1.0, 0.0, 0.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
0.0, 0.0, 0.0, 1.0,
|
|
};
|
|
|
|
static const gfloat from_ndc_matrix[] = {
|
|
0.5, 0.0, 0.0, 0.0,
|
|
0.0, 0.5, 0.0, 0.0,
|
|
0.0, 0.0, 0.5, 0.0,
|
|
0.5, 0.5, 0.5, 1.0,
|
|
};
|
|
|
|
static const gfloat to_ndc_matrix[] = {
|
|
2.0, 0.0, 0.0, 0.0,
|
|
0.0, 2.0, 0.0, 0.0,
|
|
0.0, 0.0, 2.0, 0.0,
|
|
-1.0, -1.0, -1.0, 1.0,
|
|
};
|
|
|
|
/* multiplies two 4x4 matrices, @a X @b, and stores the result in @result
|
|
* https://en.wikipedia.org/wiki/Matrix_multiplication
|
|
*/
|
|
static void
|
|
gst_gl_multiply_matrix4 (const gfloat * a, const gfloat * b, gfloat * result)
|
|
{
|
|
int i, j, k;
|
|
gfloat tmp[16] = { 0.0f };
|
|
|
|
if (!a || !b || !result)
|
|
return;
|
|
for (i = 0; i < 4; i++) { /* column */
|
|
for (j = 0; j < 4; j++) { /* row */
|
|
for (k = 0; k < 4; k++) {
|
|
tmp[j + (i * 4)] += a[k + (i * 4)] * b[j + (k * 4)];
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < 16; i++)
|
|
result[i] = tmp[i];
|
|
}
|
|
|
|
/*
|
|
* gst_gl_get_affine_transformation_meta_as_ndc:
|
|
* @meta: (nullable): a #GstVideoAffineTransformationMeta
|
|
* @matrix: (out): result of the 4x4 matrix
|
|
*
|
|
* Retrieves the stored 4x4 affine transformation matrix stored in @meta in
|
|
* NDC coordinates. if @meta is NULL, an identity matrix is returned.
|
|
*
|
|
* NDC is a left-handed coordinate sytem
|
|
* - x - [-1, 1] - +ve X moves right
|
|
* - y - [-1, 1] - +ve Y moves up
|
|
* - z - [-1, 1] - +ve Z moves into
|
|
*/
|
|
void
|
|
gst_gl_get_affine_transformation_meta_as_ndc (GstVideoAffineTransformationMeta *
|
|
meta, gfloat * matrix)
|
|
{
|
|
if (!meta) {
|
|
int i;
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
matrix[i] = identity_matrix[i];
|
|
}
|
|
} else {
|
|
float tmp[16];
|
|
|
|
/* change of basis multiplications */
|
|
gst_gl_multiply_matrix4 (from_ndc_matrix, meta->matrix, tmp);
|
|
gst_gl_multiply_matrix4 (tmp, to_ndc_matrix, matrix);
|
|
}
|
|
}
|
|
|
|
void gst_gl_set_affine_transformation_meta_from_ndc
|
|
(GstVideoAffineTransformationMeta * meta, const gfloat * matrix)
|
|
{
|
|
float tmp[16];
|
|
|
|
g_return_if_fail (meta != NULL);
|
|
|
|
/* change of basis multiplications */
|
|
gst_gl_multiply_matrix4 (to_ndc_matrix, matrix, tmp);
|
|
gst_gl_multiply_matrix4 (tmp, from_ndc_matrix, meta->matrix);
|
|
}
|