mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-02 22:46:35 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/gl/gstglutils.c
Matthew Waters 479dcdc3b4 glupload: always add texture-target field to GL caps 
1. Various elements/base classes only perform a subset check on accept-caps
2. Some GL elements have texture-target in their pad template
3. When checking subsets, only the caps to check are allowed to contain extra
   fields.  If the 'template' caps have extra fields, the subset fails.
Thus without texture-target on the caps, various accept-caps implementations
were failing.

Also, add some convenience functions for setting and retrieving
texture targets to/from GValue.

https://bugzilla.gnome.org/show_bug.cgi?id=759860
2016-01-05 13:28:19 +11:00

1078 lines
30 KiB
C
Raw Blame History

/*
* 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.
*/
#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"
#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
#ifndef GL_FRAMEBUFFER_UNDEFINED
#define GL_FRAMEBUFFER_UNDEFINED 0x8219
#endif
#ifndef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
#endif
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
#endif
#ifndef GL_FRAMEBUFFER_UNSUPPORTED
#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
#endif
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9
#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))
static gchar *error_message;
/* called in the gl thread */
gboolean
gst_gl_context_check_framebuffer_status (GstGLContext * context)
{
GLenum status = 0;
status = context->gl_vtable->CheckFramebufferStatus (GL_FRAMEBUFFER);
switch (status) {
case GL_FRAMEBUFFER_COMPLETE:
return TRUE;
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
GST_ERROR ("GL_FRAMEBUFFER_UNSUPPORTED");
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
GST_ERROR ("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
break;
#if GST_GL_HAVE_OPENGL
case GL_FRAMEBUFFER_UNDEFINED:
GST_ERROR ("GL_FRAMEBUFFER_UNDEFINED");
break;
#endif
default:
GST_ERROR ("General FBO error");
}
return FALSE;
}
typedef struct _GenTexture
{
guint width, height;
GstVideoFormat format;
guint result;
} GenTexture;
static void
_gen_texture (GstGLContext * context, GenTexture * data)
{
const GstGLFuncs *gl = context->gl_vtable;
GLenum internal_format;
GST_TRACE ("Generating texture format:%u dimensions:%ux%u", data->format,
data->width, data->height);
gl->GenTextures (1, &data->result);
gl->BindTexture (GL_TEXTURE_2D, data->result);
internal_format =
gst_gl_sized_gl_format_from_gl_format_type (context, GL_RGBA,
GL_UNSIGNED_BYTE);
if (data->width > 0 && data->height > 0)
gl->TexImage2D (GL_TEXTURE_2D, 0, internal_format,
data->width, data->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GST_LOG ("generated texture id:%d", data->result);
}
/* deprecated. replaced by GstGLMemory */
void
gst_gl_context_gen_texture (GstGLContext * context, GLuint * pTexture,
GstVideoFormat v_format, GLint width, GLint height)
{
GenTexture data = { width, height, v_format, 0 };
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _gen_texture,
&data);
*pTexture = data.result;
}
static void
_del_texture (GstGLContext * context, guint * texture)
{
context->gl_vtable->DeleteTextures (1, texture);
}
/* deprecated. replaced by GstGLMemory */
void
gst_gl_context_del_texture (GstGLContext * context, GLuint * pTexture)
{
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _del_texture,
pTexture);
}
typedef struct _GenTextureFull
{
const GstVideoInfo *info;
const gint comp;
guint result;
} GenTextureFull;
static void
_gen_texture_full (GstGLContext * context, GenTextureFull * data)
{
const GstGLFuncs *gl = context->gl_vtable;
GstVideoGLTextureType tex_type;
GstVideoFormat v_format;
GLint glinternalformat = 0;
GLenum glformat = 0;
GLenum gltype = 0;
gl->GenTextures (1, &data->result);
gl->BindTexture (GL_TEXTURE_2D, data->result);
v_format = GST_VIDEO_INFO_FORMAT (data->info);
tex_type = gst_gl_texture_type_from_format (context, v_format, data->comp);
glformat = gst_gl_format_from_gl_texture_type (tex_type);
gltype = GL_UNSIGNED_BYTE;
if (v_format == GST_VIDEO_FORMAT_RGB16)
gltype = GL_UNSIGNED_SHORT_5_6_5;
glinternalformat = gst_gl_sized_gl_format_from_gl_format_type (context,
glformat, gltype);
gl->TexImage2D (GL_TEXTURE_2D, 0, glinternalformat,
GST_VIDEO_INFO_COMP_WIDTH (data->info, data->comp),
GST_VIDEO_INFO_COMP_HEIGHT (data->info, data->comp), 0, glformat, gltype,
NULL);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
/* deprecated. replaced by GstGLMemory */
void
gst_gl_generate_texture_full (GstGLContext * context, const GstVideoInfo * info,
const guint comp, gint stride[], gsize offset[], gsize size[],
GLuint * pTexture)
{
GenTextureFull data = { info, comp, 0 };
switch (GST_VIDEO_INFO_FORMAT (info)) {
case GST_VIDEO_FORMAT_RGB:
case GST_VIDEO_FORMAT_BGR:
{
stride[0] = GST_ROUND_UP_4 (GST_VIDEO_INFO_WIDTH (info) * 3);
offset[0] = 0;
size[0] = stride[0] * GST_VIDEO_INFO_HEIGHT (info);
break;
}
case GST_VIDEO_FORMAT_RGB16:
{
stride[0] = GST_ROUND_UP_4 (GST_VIDEO_INFO_WIDTH (info) * 2);
offset[0] = 0;
size[0] = stride[0] * GST_VIDEO_INFO_HEIGHT (info);
break;
}
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_ARGB:
case GST_VIDEO_FORMAT_ABGR:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
case GST_VIDEO_FORMAT_AYUV:
{
stride[0] = GST_ROUND_UP_4 (GST_VIDEO_INFO_WIDTH (info) * 4);
offset[0] = 0;
size[0] = stride[0] * GST_VIDEO_INFO_HEIGHT (info);
break;
}
case GST_VIDEO_FORMAT_NV12:
case GST_VIDEO_FORMAT_NV21:
{
size[comp] = stride[comp] * GST_VIDEO_INFO_COMP_HEIGHT (info, comp);
if (comp == 0) {
stride[0] = GST_ROUND_UP_4 (GST_VIDEO_INFO_COMP_WIDTH (info, 1));
offset[0] = 0;
} else {
stride[1] = GST_ROUND_UP_4 (GST_VIDEO_INFO_COMP_WIDTH (info, 1) * 2);
offset[1] = size[0];
}
break;
}
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
case GST_VIDEO_FORMAT_Y444:
case GST_VIDEO_FORMAT_Y42B:
case GST_VIDEO_FORMAT_Y41B:
{
stride[comp] = GST_ROUND_UP_4 (GST_VIDEO_INFO_COMP_WIDTH (info, comp));
size[comp] = stride[comp] * GST_VIDEO_INFO_COMP_HEIGHT (info, comp);
if (comp == 0)
offset[0] = 0;
else if (comp == 1)
offset[1] = size[0];
else
offset[2] = offset[1] + size[1];
break;
}
default:
GST_WARNING ("unsupported %s",
gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (info)));
break;
}
gst_gl_context_thread_add (context,
(GstGLContextThreadFunc) _gen_texture_full, &data);
*pTexture = data.result;
}
typedef struct _GenFBO
{
GstGLFramebuffer *frame;
gint width, height;
GLuint *fbo, *depth;
} GenFBO;
static void
_gen_fbo (GstGLContext * context, GenFBO * data)
{
gst_gl_framebuffer_generate (data->frame, data->width, data->height,
data->fbo, data->depth);
}
gboolean
gst_gl_context_gen_fbo (GstGLContext * context, gint width, gint height,
GLuint * fbo, GLuint * depthbuffer)
{
GstGLFramebuffer *frame = gst_gl_framebuffer_new (context);
GenFBO data = { frame, width, height, fbo, depthbuffer };
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _gen_fbo, &data);
gst_object_unref (frame);
return TRUE;
}
typedef struct _UseFBO2
{
GstGLFramebuffer *frame;
gint texture_fbo_width;
gint texture_fbo_height;
GLuint fbo;
GLuint depth_buffer;
GLuint texture_fbo;
GLCB_V2 cb;
gpointer stuff;
} UseFBO2;
static void
_use_fbo_v2 (GstGLContext * context, UseFBO2 * data)
{
gst_gl_framebuffer_use_v2 (data->frame, data->texture_fbo_width,
data->texture_fbo_height, data->fbo, data->depth_buffer,
data->texture_fbo, data->cb, data->stuff);
}
gboolean
gst_gl_context_use_fbo_v2 (GstGLContext * context, gint texture_fbo_width,
gint texture_fbo_height, GLuint fbo, GLuint depth_buffer,
GLuint texture_fbo, GLCB_V2 cb, gpointer stuff)
{
GstGLFramebuffer *frame = gst_gl_framebuffer_new (context);
UseFBO2 data =
{ frame, texture_fbo_width, texture_fbo_height, fbo, depth_buffer,
texture_fbo, cb, stuff
};
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _use_fbo_v2,
&data);
gst_object_unref (frame);
return TRUE;
}
typedef struct _DelFBO
{
GstGLFramebuffer *frame;
GLuint fbo;
GLuint depth;
} DelFBO;
/* Called in the gl thread */
static void
_del_fbo (GstGLContext * context, DelFBO * data)
{
gst_gl_framebuffer_delete (data->frame, data->fbo, data->depth);
}
/* Called by gltestsrc and glfilter */
void
gst_gl_context_del_fbo (GstGLContext * context, GLuint fbo, GLuint depth_buffer)
{
GstGLFramebuffer *frame = gst_gl_framebuffer_new (context);
DelFBO data = { frame, fbo, depth_buffer };
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _del_fbo, &data);
gst_object_unref (frame);
}
struct _compile_shader
{
GstGLShader **shader;
const gchar *vertex_src;
const gchar *fragment_src;
};
static void
_compile_shader (GstGLContext * context, struct _compile_shader *data)
{
GstGLShader *shader;
GstGLSLStage *vert, *frag;
GError *error = NULL;
shader = gst_gl_shader_new (context);
if (data->vertex_src) {
vert = gst_glsl_stage_new_with_string (context, GL_VERTEX_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, data->vertex_src);
if (!gst_glsl_stage_compile (vert, &error)) {
GST_ERROR_OBJECT (vert, "%s", error->message);
gst_object_unref (vert);
gst_object_unref (shader);
return;
}
if (!gst_gl_shader_attach (shader, vert)) {
gst_object_unref (shader);
return;
}
}
if (data->fragment_src) {
frag = gst_glsl_stage_new_with_string (context, GL_FRAGMENT_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY,
data->fragment_src);
if (!gst_glsl_stage_compile (frag, &error)) {
GST_ERROR_OBJECT (frag, "%s", error->message);
gst_object_unref (frag);
gst_object_unref (shader);
return;
}
if (!gst_gl_shader_attach (shader, frag)) {
gst_object_unref (shader);
return;
}
}
if (!gst_gl_shader_link (shader, &error)) {
GST_ERROR_OBJECT (shader, "%s", error->message);
g_error_free (error);
error = NULL;
gst_gl_context_clear_shader (context);
gst_object_unref (shader);
return;
}
*data->shader = shader;
}
/* Called by glfilter */
gboolean
gst_gl_context_gen_shader (GstGLContext * context, const gchar * vert_src,
const gchar * frag_src, GstGLShader ** shader)
{
struct _compile_shader data;
g_return_val_if_fail (frag_src != NULL || vert_src != NULL, FALSE);
g_return_val_if_fail (shader != NULL, FALSE);
data.shader = shader;
data.vertex_src = vert_src;
data.fragment_src = frag_src;
gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _compile_shader,
&data);
return *shader != NULL;
}
void
gst_gl_context_set_error (GstGLContext * context, const char *format, ...)
{
va_list args;
g_free (error_message);
va_start (args, format);
error_message = g_strdup_vprintf (format, args);
va_end (args);
GST_WARNING ("%s", error_message);
}
gchar *
gst_gl_context_get_error (void)
{
return error_message;
}
/* Called by glfilter */
void
gst_gl_context_del_shader (GstGLContext * context, GstGLShader * shader)
{
gst_object_unref (shader);
}
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.
*/
static void
gst_gl_display_context_propagate (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);
}
gboolean
gst_gl_ensure_element_data (gpointer element, GstGLDisplay ** display_ptr,
GstGLContext ** 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 (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_display_context_propagate (element, display);
get_gl_context:
if (*context_ptr)
goto done;
gst_gl_context_query (element);
done:
return *display_ptr != NULL;
}
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_GL_TYPE_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;
}
gboolean
gst_gl_handle_context_query (GstElement * element, GstQuery * query,
GstGLDisplay ** display, GstGLContext ** other_context)
{
gboolean res = FALSE;
const gchar *context_type;
GstContext *context, *old_context;
g_return_val_if_fail (element != NULL, FALSE);
g_return_val_if_fail (query != NULL, FALSE);
g_return_val_if_fail (display != NULL, FALSE);
g_return_val_if_fail (other_context != NULL, FALSE);
gst_query_parse_context_type (query, &context_type);
if (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);
res = *display != NULL;
}
#if GST_GL_HAVE_WINDOW_X11
else if (g_strcmp0 (context_type, "gst.x11.display.handle") == 0) {
GstStructure *s;
Display *x11_display = NULL;
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 (*display
&& ((*display)->type & GST_GL_DISPLAY_TYPE_X11) ==
GST_GL_DISPLAY_TYPE_X11)
x11_display = (Display *) gst_gl_display_get_handle (*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);
res = x11_display != NULL;
}
#endif
#if GST_GL_HAVE_WINDOW_WAYLAND
else if (g_strcmp0 (context_type, "GstWaylandDisplayHandleContextType") == 0) {
GstStructure *s;
struct wl_display *wayland_display = NULL;
gst_query_parse_context (query, &old_context);
if (old_context)
context = gst_context_copy (old_context);
else
context = gst_context_new ("GstWaylandDisplayHandleContextType", TRUE);
if (*display
&& ((*display)->type & GST_GL_DISPLAY_TYPE_WAYLAND) ==
GST_GL_DISPLAY_TYPE_WAYLAND)
wayland_display =
(struct wl_display *) gst_gl_display_get_handle (*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);
res = wayland_display != NULL;
}
#endif
else if (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_GL_TYPE_CONTEXT, *other_context, NULL);
gst_query_set_context (query, context);
gst_context_unref (context);
res = *other_context != NULL;
}
return res;
}
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;
}
/* find the difference between the start of the plane and where the video
* data starts in the plane */
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;
}
GstCaps *
gst_gl_caps_replace_all_caps_features (const GstCaps * caps,
const gchar * feature_name)
{
GstCaps *tmp = gst_caps_copy (caps);
guint n = gst_caps_get_size (tmp);
guint i = 0;
for (i = 0; i < n; i++) {
GstCapsFeatures *features = gst_caps_get_features (tmp, i);
if (features) {
guint n_f = gst_caps_features_get_size (features);
guint j = 0;
for (j = 0; j < n_f; j++) {
gst_caps_features_remove_id (features,
gst_caps_features_get_nth_id (features, j));
}
}
gst_caps_features_add (features, feature_name);
}
return tmp;
}
/**
* gst_gl_value_get_texture_target_mask:
* @value: an initialized #GValue of type G_TYPE_STRING
*
* See gst_gl_value_set_texture_target_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;
}
return ret;
}
}
Reference in a new issue View git blame Copy permalink