diff --git a/lib/gst/plugin/gstclapperdmabufbaseimport.c b/lib/gst/plugin/gstclapperdmabufbaseimport.c new file mode 100644 index 00000000..c9f39e1a --- /dev/null +++ b/lib/gst/plugin/gstclapperdmabufbaseimport.c @@ -0,0 +1,464 @@ +/* + * Copyright (C) 2022 Rafał Dzięgiel + * + * 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 +#include +#include + +#include "gstclapperdmabufbaseimport.h" +#include "gstgtkutils.h" + +#define GST_CAT_DEFAULT gst_clapper_dmabuf_base_import_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); + +static const GLfloat vertices[] = { + 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, -1.0f, 0.0f, 1.0f, 1.0f +}; +static const GLushort indices[] = { + 0, 1, 2, 0, 2, 3 +}; + +/* GTK4 renders things upside down ¯\_(ツ)_/¯ */ +static const gfloat vertical_flip_matrix[] = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, -1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f, +}; + +typedef struct +{ + GstClapperDmabufBaseImport *dmabuf_bi; + GLuint id; + guint width; + guint height; +} GstClapperDmabufTexData; + +#define parent_class gst_clapper_dmabuf_base_import_parent_class +G_DEFINE_TYPE (GstClapperDmabufBaseImport, gst_clapper_dmabuf_base_import, GST_TYPE_CLAPPER_GL_BASE_IMPORT); + +static void +gst_clapper_dmabuf_base_import_init (GstClapperDmabufBaseImport *self) +{ + g_mutex_init (&self->lock); + + self->gst_tex_target = GST_GL_TEXTURE_TARGET_EXTERNAL_OES; + self->gl_tex_target = gst_gl_texture_target_to_gl (self->gst_tex_target); +} + +static void +gst_clapper_dmabuf_base_import_finalize (GObject *object) +{ + GstClapperDmabufBaseImport *self = GST_CLAPPER_DMABUF_BASE_IMPORT_CAST (object); + + gst_clear_object (&self->shader); + + g_mutex_clear (&self->lock); + + GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); +} + +static void +gst_clapper_dmabuf_base_import_bind_buffer (GstClapperDmabufBaseImport *self) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + const GstGLFuncs *gl = gl_bi->gst_context->gl_vtable; + + gl->BindBuffer (GL_ARRAY_BUFFER, self->vertex_buffer); + + /* Load the vertex position */ + gl->VertexAttribPointer (self->attr_position, 3, GL_FLOAT, GL_FALSE, + 5 * sizeof (GLfloat), (void *) 0); + + /* Load the texture coordinate */ + gl->VertexAttribPointer (self->attr_texture, 2, GL_FLOAT, GL_FALSE, + 5 * sizeof (GLfloat), (void *) (3 * sizeof (GLfloat))); + + gl->EnableVertexAttribArray (self->attr_position); + gl->EnableVertexAttribArray (self->attr_texture); +} + +static void +gst_clapper_dmabuf_base_import_unbind_buffer (GstClapperDmabufBaseImport *self) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + const GstGLFuncs *gl = gl_bi->gst_context->gl_vtable; + + gl->BindBuffer (GL_ARRAY_BUFFER, 0); + gl->DisableVertexAttribArray (self->attr_position); + gl->DisableVertexAttribArray (self->attr_texture); +} + +static gboolean +prepare_on_main (GstClapperDmabufBaseImport *self) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + GstGLSLStage *frag_stage, *vert_stage; + GError *error = NULL; + gchar *frag_str; + const GstGLFuncs *gl; + + GST_CLAPPER_GL_BASE_IMPORT_LOCK (gl_bi); + + gdk_gl_context_make_current (gl_bi->gdk_context); + gst_gl_context_activate (gl_bi->gst_context, TRUE); + + if (!((vert_stage = gst_glsl_stage_new_with_string (gl_bi->gst_context, + GL_VERTEX_SHADER, GST_GLSL_VERSION_NONE, + GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, + gst_gl_shader_string_vertex_mat4_vertex_transform)))) { + gdk_gl_context_make_current (gl_bi->gdk_context); + gst_gl_context_activate (gl_bi->gst_context, TRUE); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + GST_ERROR ("Failed to retrieve vertex shader for texture target"); + + return FALSE; + } + + frag_str = gst_gl_shader_string_fragment_external_oes_get_default ( + gl_bi->gst_context, GST_GLSL_VERSION_NONE, + GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY); + frag_stage = gst_glsl_stage_new_with_string (gl_bi->gst_context, + GL_FRAGMENT_SHADER, GST_GLSL_VERSION_NONE, + GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, frag_str); + + g_free (frag_str); + + if (!frag_stage) { + gst_gl_context_activate (gl_bi->gst_context, FALSE); + gdk_gl_context_clear_current (); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + GST_ERROR ("Failed to retrieve fragment shader for texture target"); + + return FALSE; + } + + GST_CLAPPER_DMABUF_BASE_IMPORT_LOCK (self); + + if (!((self->shader = gst_gl_shader_new_link_with_stages (gl_bi->gst_context, + &error, vert_stage, frag_stage, NULL)))) { + GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK (self); + + gst_gl_context_activate (gl_bi->gst_context, FALSE); + gdk_gl_context_clear_current (); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + + GST_ERROR ("Failed to initialize shader: %s", error->message); + g_clear_error (&error); + + return FALSE; + } + + self->attr_position = + gst_gl_shader_get_attribute_location (self->shader, "a_position"); + self->attr_texture = + gst_gl_shader_get_attribute_location (self->shader, "a_texcoord"); + + gl = gl_bi->gst_context->gl_vtable; + + if (gl->GenVertexArrays) { + gl->GenVertexArrays (1, &self->vao); + gl->BindVertexArray (self->vao); + } + + gl->GenBuffers (1, &self->vertex_buffer); + gl->BindBuffer (GL_ARRAY_BUFFER, self->vertex_buffer); + gl->BufferData (GL_ARRAY_BUFFER, 4 * 5 * sizeof (GLfloat), vertices, GL_STATIC_DRAW); + + if (gl->GenVertexArrays) { + gst_clapper_dmabuf_base_import_bind_buffer (self); + gl->BindVertexArray (0); + } + + gl->BindBuffer (GL_ARRAY_BUFFER, 0); + self->prepared = TRUE; + + GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK (self); + + gst_gl_context_activate (gl_bi->gst_context, FALSE); + gdk_gl_context_clear_current (); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + + return TRUE; +} + +static gboolean +ensure_prepared (GstClapperDmabufBaseImport *self) +{ + GST_CLAPPER_DMABUF_BASE_IMPORT_LOCK (self); + + if (self->prepared) { + GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK (self); + + return TRUE; + } + + if (self->gst_tex_target != GST_GL_TEXTURE_TARGET_EXTERNAL_OES) { + /* We do not need shaders if texture target is 2D */ + self->prepared = TRUE; + GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK (self); + + return TRUE; + } + + GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK (self); + + if (!(! !gst_gtk_invoke_on_main ( + (GThreadFunc) (GCallback) prepare_on_main, self))) { + GST_ERROR_OBJECT (self, "Could not ensure prepared"); + + return FALSE; + } + + return TRUE; +} + +static GstStateChangeReturn +gst_clapper_dmabuf_base_import_change_state (GstElement *element, GstStateChange transition) +{ + GstClapperDmabufBaseImport *self = GST_CLAPPER_DMABUF_BASE_IMPORT_CAST (element); + GstStateChangeReturn ret; + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + if (ret == GST_STATE_CHANGE_FAILURE) + return ret; + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + if (!ensure_prepared (self)) + return GST_STATE_CHANGE_FAILURE; + break; + default: + break; + } + + return ret; +} + +static gboolean +_dmabuf_into_texture (GstClapperDmabufBaseImport *self, gint *fds, GstVideoInfo *v_info, + gsize *offsets, GstClapperDmabufTexData *tex_data) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + GstEGLImage *image; + const GstGLFuncs *gl; + + image = gst_egl_image_from_dmabuf_direct_target (gl_bi->gst_context, + fds, offsets, v_info, self->gst_tex_target); + + /* If HW colorspace conversion failed and there is only one + * plane, we can just make it into single EGLImage as is */ + if (!image && GST_VIDEO_INFO_N_PLANES (v_info) == 1) + image = gst_egl_image_from_dmabuf (gl_bi->gst_context, + fds[0], v_info, 0, offsets[0]); + + if (!image) + return FALSE; + + gl = gl_bi->gst_context->gl_vtable; + + gl->GenTextures (1, &tex_data->id); + tex_data->width = GST_VIDEO_INFO_WIDTH (v_info); + tex_data->height = GST_VIDEO_INFO_HEIGHT (v_info); + + gl->BindTexture (self->gl_tex_target, tex_data->id); + + gl->TexParameteri (self->gl_tex_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl->TexParameteri (self->gl_tex_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + gl->TexParameteri (self->gl_tex_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + gl->TexParameteri (self->gl_tex_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + gl->EGLImageTargetTexture2D (self->gl_tex_target, gst_egl_image_get_image (image)); + + gl->BindTexture (GL_TEXTURE_2D, 0); + gst_egl_image_unref (image); + + return TRUE; +} + +static gboolean +_oes_texture_into_2d (GstClapperDmabufBaseImport *self, GstClapperDmabufTexData *tex_data) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + GLuint framebuffer, tex_id; + GLenum status; + const GstGLFuncs *gl; + + gl = gl_bi->gst_context->gl_vtable; + + gl->GenFramebuffers (1, &framebuffer); + gl->BindFramebuffer (GL_FRAMEBUFFER, framebuffer); + + gl->GenTextures (1, &tex_id); + gl->BindTexture (GL_TEXTURE_2D, tex_id); + + 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); + + gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, tex_data->width, tex_data->height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, NULL); + + gl->FramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, tex_id, 0); + + status = gl->CheckFramebufferStatus (GL_FRAMEBUFFER); + if (G_UNLIKELY (status != GL_FRAMEBUFFER_COMPLETE)) { + GST_ERROR ("Invalid framebuffer status: %u", status); + + gl->BindTexture (GL_TEXTURE_2D, 0); + gl->DeleteTextures (1, &tex_id); + + gl->BindFramebuffer (GL_FRAMEBUFFER, 0); + gl->DeleteFramebuffers (1, &framebuffer); + + return FALSE; + } + + gl->Viewport (0, 0, tex_data->width, tex_data->height); + + gst_gl_shader_use (self->shader); + + if (gl->BindVertexArray) + gl->BindVertexArray (self->vao); + + gst_clapper_dmabuf_base_import_bind_buffer (self); + + gl->ActiveTexture (GL_TEXTURE0); + gl->BindTexture (self->gl_tex_target, tex_data->id); + + gst_gl_shader_set_uniform_1i (self->shader, "tex", 0); + gst_gl_shader_set_uniform_matrix_4fv (self->shader, + "u_transformation", 1, FALSE, vertical_flip_matrix); + + gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); + + if (gl->BindVertexArray) + gl->BindVertexArray (0); + else + gst_clapper_dmabuf_base_import_unbind_buffer (self); + + gl->BindTexture (self->gl_tex_target, 0); + + /* Replace External OES texture with newly created 2D */ + gl->DeleteTextures (1, &tex_data->id); + tex_data->id = tex_id; + + gl->BindFramebuffer (GL_FRAMEBUFFER, 0); + gl->DeleteFramebuffers (1, &framebuffer); + + return TRUE; +} + +static void +_tex_data_free (GstClapperDmabufTexData *tex_data) +{ + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (tex_data->dmabuf_bi); + + if (G_LIKELY (tex_data->id > 0)) { + const GstGLFuncs *gl; + + GST_CLAPPER_GL_BASE_IMPORT_LOCK (gl_bi); + + gl = gl_bi->gst_context->gl_vtable; + + gdk_gl_context_make_current (gl_bi->gdk_context); + gst_gl_context_activate (gl_bi->gst_context, TRUE); + + gl->DeleteTextures (1, &tex_data->id); + + gst_gl_context_activate (gl_bi->gst_context, FALSE); + gdk_gl_context_clear_current (); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + } + + gst_object_unref (tex_data->dmabuf_bi); + g_slice_free (GstClapperDmabufTexData, tex_data); +} + +GdkTexture * +gst_clapper_dmabuf_base_import_fds_into_texture (GstClapperDmabufBaseImport *self, gint *fds, gsize *offsets) +{ + GstClapperBaseImport *bi = GST_CLAPPER_BASE_IMPORT_CAST (self); + GstClapperGLBaseImport *gl_bi = GST_CLAPPER_GL_BASE_IMPORT_CAST (self); + GdkTexture *texture = NULL; + GstClapperDmabufTexData *tex_data; + + tex_data = g_slice_new (GstClapperDmabufTexData); + tex_data->dmabuf_bi = gst_object_ref (self); + + GST_CLAPPER_GL_BASE_IMPORT_LOCK (gl_bi); + + gdk_gl_context_make_current (gl_bi->gdk_context); + gst_gl_context_activate (gl_bi->gst_context, TRUE); + + if (!_dmabuf_into_texture (self, fds, &bi->in_info, offsets, tex_data)) + goto finish; + + /* GTK4 does not support External OES textures. + * Make it into 2D using framebuffer + shader */ + if (self->gst_tex_target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES) { + if (G_UNLIKELY (!_oes_texture_into_2d (self, tex_data))) + goto finish; + } + + texture = gdk_gl_texture_new (gl_bi->gdk_context, + tex_data->id, + tex_data->width, + tex_data->height, + (GDestroyNotify) _tex_data_free, + tex_data); + +finish: + gst_gl_context_activate (gl_bi->gst_context, FALSE); + gdk_gl_context_clear_current (); + + GST_CLAPPER_GL_BASE_IMPORT_UNLOCK (gl_bi); + + return texture; +} + +static void +gst_clapper_dmabuf_base_import_class_init (GstClapperDmabufBaseImportClass *klass) +{ + GObjectClass *gobject_class = (GObjectClass *) klass; + GstElementClass *gstelement_class = (GstElementClass *) klass; + + GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperdmabufbaseimport", 0, + "Clapper DMABuf Base Import"); + + gobject_class->finalize = gst_clapper_dmabuf_base_import_finalize; + + gstelement_class->change_state = gst_clapper_dmabuf_base_import_change_state; +} diff --git a/lib/gst/plugin/gstclapperdmabufbaseimport.h b/lib/gst/plugin/gstclapperdmabufbaseimport.h new file mode 100644 index 00000000..f77b67e1 --- /dev/null +++ b/lib/gst/plugin/gstclapperdmabufbaseimport.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2022 Rafał Dzięgiel + * + * 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. + */ + +#pragma once + +#include + +#include "gstclapperglbaseimport.h" + +G_BEGIN_DECLS + +#define GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT (gst_clapper_dmabuf_base_import_get_type()) +#define GST_IS_CLAPPER_DMABUF_BASE_IMPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT)) +#define GST_IS_CLAPPER_DMABUF_BASE_IMPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT)) +#define GST_CLAPPER_DMABUF_BASE_IMPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT, GstClapperDmabufBaseImportClass)) +#define GST_CLAPPER_DMABUF_BASE_IMPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT, GstClapperDmabufBaseImport)) +#define GST_CLAPPER_DMABUF_BASE_IMPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT, GstClapperDmabufBaseImportClass)) +#define GST_CLAPPER_DMABUF_BASE_IMPORT_CAST(obj) ((GstClapperDmabufBaseImport *)(obj)) + +#define GST_CLAPPER_DMABUF_BASE_IMPORT_GET_LOCK(obj) (&GST_CLAPPER_DMABUF_BASE_IMPORT_CAST(obj)->lock) +#define GST_CLAPPER_DMABUF_BASE_IMPORT_LOCK(obj) g_mutex_lock (GST_CLAPPER_DMABUF_BASE_IMPORT_GET_LOCK(obj)) +#define GST_CLAPPER_DMABUF_BASE_IMPORT_UNLOCK(obj) g_mutex_unlock (GST_CLAPPER_DMABUF_BASE_IMPORT_GET_LOCK(obj)) + +typedef struct _GstClapperDmabufBaseImport GstClapperDmabufBaseImport; +typedef struct _GstClapperDmabufBaseImportClass GstClapperDmabufBaseImportClass; + +#ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GstClapperDmabufBaseImport, gst_object_unref) +#endif + +struct _GstClapperDmabufBaseImport +{ + GstClapperGLBaseImport parent; + + GMutex lock; + + gboolean prepared; + + GstGLTextureTarget gst_tex_target; + guint gl_tex_target; + + GstGLShader *shader; + + GLuint vao; + GLuint vertex_buffer; + GLint attr_position; + GLint attr_texture; +}; + +struct _GstClapperDmabufBaseImportClass +{ + GstClapperGLBaseImportClass parent_class; +}; + +GType gst_clapper_dmabuf_base_import_get_type (void); + +GdkTexture * gst_clapper_dmabuf_base_import_fds_into_texture (GstClapperDmabufBaseImport *dmabuf_bi, gint *fds, gsize *offsets); + +G_END_DECLS diff --git a/lib/gst/plugin/gstclapperdmabufimport.c b/lib/gst/plugin/gstclapperdmabufimport.c new file mode 100644 index 00000000..ecadb9b8 --- /dev/null +++ b/lib/gst/plugin/gstclapperdmabufimport.c @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2022 Rafał Dzięgiel + * + * 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 +#include + +#include "gstclapperdmabufimport.h" +#include "gstclappergdkmemory.h" + +#define GST_CAT_DEFAULT gst_clapper_dmabuf_import_debug +GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); + +#ifndef GST_CAPS_FEATURE_MEMORY_DMABUF +#define GST_CAPS_FEATURE_MEMORY_DMABUF "memory:DMABuf" +#endif + +static GstStaticPadTemplate gst_clapper_dmabuf_import_sink_template = + GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ( + GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_DMABUF, + "{ " GST_CLAPPER_GDK_GL_TEXTURE_FORMATS ", NV12 }") + "; " + GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_DMABUF ", " + GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, + "{ " GST_CLAPPER_GDK_GL_TEXTURE_FORMATS ", NV12 }"))); + +static GstStaticPadTemplate gst_clapper_dmabuf_import_src_template = + GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ( + GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_CLAPPER_GDK_MEMORY, + "{ " GST_CLAPPER_GDK_GL_TEXTURE_FORMATS ", NV12 }") + "; " + GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_CLAPPER_GDK_MEMORY ", " + GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, + "{ " GST_CLAPPER_GDK_GL_TEXTURE_FORMATS ", NV12 }"))); + +#define parent_class gst_clapper_dmabuf_import_parent_class +G_DEFINE_TYPE (GstClapperDmabufImport, gst_clapper_dmabuf_import, GST_TYPE_CLAPPER_DMABUF_BASE_IMPORT); +GST_ELEMENT_REGISTER_DEFINE (clapperdmabufimport, "clapperdmabufimport", GST_RANK_NONE, + GST_TYPE_CLAPPER_DMABUF_IMPORT); + +static gboolean +verify_dmabuf_memory (GstBuffer *buffer, GstVideoInfo *info, gint *fds, gsize *offsets) +{ + guint i, n_planes = GST_VIDEO_INFO_N_PLANES (info); + + for (i = 0; i < n_planes; i++) { + GstMemory *memory; + gsize plane_size, mem_skip; + guint mem_idx, length; + + plane_size = gst_gl_get_plane_data_size (info, NULL, i); + + if (!gst_buffer_find_memory (buffer, + GST_VIDEO_INFO_PLANE_OFFSET (info, i), + plane_size, &mem_idx, &length, &mem_skip)) { + GST_DEBUG ("Could not find memory %u", i); + return FALSE; + } + + /* We cannot have more then one DMABuf per plane */ + if (length != 1) { + GST_DEBUG ("Data for plane %u spans %u memories", i, length); + return FALSE; + } + + memory = gst_buffer_peek_memory (buffer, mem_idx); + + offsets[i] = memory->offset + mem_skip; + fds[i] = gst_dmabuf_memory_get_fd (memory); + } + + return TRUE; +} + +static GstBufferPool * +gst_clapper_dmabuf_import_create_upstream_pool (GstClapperBaseImport *bi, GstStructure **config) +{ + return NULL; +} + +static GstFlowReturn +gst_clapper_dmabuf_import_transform (GstBaseTransform *bt, + GstBuffer *in_buf, GstBuffer *out_buf) +{ + GstClapperDmabufBaseImport *dmabuf_bi = GST_CLAPPER_DMABUF_BASE_IMPORT_CAST (bt); + GstClapperBaseImport *bi = GST_CLAPPER_BASE_IMPORT_CAST (bt); + GstMapInfo info; + GstMemory *memory; + GstVideoMeta *meta; + GstFlowReturn ret = GST_FLOW_ERROR; + + GST_LOG_OBJECT (bt, "Transforming from %" GST_PTR_FORMAT + " into %" GST_PTR_FORMAT, in_buf, out_buf); + + if ((meta = gst_buffer_get_video_meta (in_buf))) { + guint i; + + GST_VIDEO_INFO_WIDTH (&bi->in_info) = meta->width; + GST_VIDEO_INFO_HEIGHT (&bi->in_info) = meta->height; + + for (i = 0; i < meta->n_planes; i++) { + GST_VIDEO_INFO_PLANE_OFFSET (&bi->in_info, i) = meta->offset[i]; + GST_VIDEO_INFO_PLANE_STRIDE (&bi->in_info, i) = meta->stride[i]; + } + } + + memory = gst_buffer_peek_memory (out_buf, 0); + + if (G_LIKELY (gst_memory_map (memory, &info, GST_MAP_WRITE))) { + gint fds[GST_VIDEO_MAX_PLANES]; + gsize offsets[GST_VIDEO_MAX_PLANES]; + + if (verify_dmabuf_memory (in_buf, &bi->in_info, fds, offsets)) { + GstClapperGdkMemory *clapper_memory = GST_CLAPPER_GDK_MEMORY_CAST (memory); + + if (G_LIKELY ((clapper_memory->texture = gst_clapper_dmabuf_base_import_fds_into_texture ( + dmabuf_bi, fds, offsets)))) + ret = GST_FLOW_OK; + } + + gst_memory_unmap (memory, &info); + } + + return ret; +} + +static void +gst_clapper_dmabuf_import_init (GstClapperDmabufImport *self) +{ +} + +static void +gst_clapper_dmabuf_import_class_init (GstClapperDmabufImportClass *klass) +{ + GstElementClass *gstelement_class = (GstElementClass *) klass; + GstBaseTransformClass *gstbasetransform_class = (GstBaseTransformClass *) klass; + GstClapperBaseImportClass *bi_class = (GstClapperBaseImportClass *) klass; + + GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "clapperdmabufimport", 0, + "Clapper DMABuf Import"); + + gstbasetransform_class->transform = gst_clapper_dmabuf_import_transform; + + bi_class->create_upstream_pool = gst_clapper_dmabuf_import_create_upstream_pool; + + gst_element_class_set_metadata (gstelement_class, + "Clapper DMABuf import", + "Filter/Video", "Imports DMABuf into ClapperGdkMemory", + "Rafał Dzięgiel "); + + gst_element_class_add_static_pad_template (gstelement_class, + &gst_clapper_dmabuf_import_sink_template); + gst_element_class_add_static_pad_template (gstelement_class, + &gst_clapper_dmabuf_import_src_template); +} diff --git a/lib/gst/plugin/gstclapperdmabufimport.h b/lib/gst/plugin/gstclapperdmabufimport.h new file mode 100644 index 00000000..9a11c61b --- /dev/null +++ b/lib/gst/plugin/gstclapperdmabufimport.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 Rafał Dzięgiel + * + * 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. + */ + +#pragma once + +#include "gstclapperdmabufbaseimport.h" + +G_BEGIN_DECLS + +#define GST_TYPE_CLAPPER_DMABUF_IMPORT (gst_clapper_dmabuf_import_get_type()) +G_DECLARE_FINAL_TYPE (GstClapperDmabufImport, gst_clapper_dmabuf_import, GST, CLAPPER_DMABUF_IMPORT, GstClapperDmabufBaseImport) + +#define GST_CLAPPER_DMABUF_IMPORT_CAST(obj) ((GstClapperDmabufImport *)(obj)) + +struct _GstClapperDmabufImport +{ + GstClapperDmabufBaseImport parent; +}; + +GST_ELEMENT_REGISTER_DECLARE (clapperdmabufimport); + +G_END_DECLS diff --git a/lib/gst/plugin/gstclappersink.c b/lib/gst/plugin/gstclappersink.c index cf2bef4a..e68d3874 100644 --- a/lib/gst/plugin/gstclappersink.c +++ b/lib/gst/plugin/gstclappersink.c @@ -52,11 +52,11 @@ static GstStaticPadTemplate gst_clapper_sink_template = GST_PAD_ALWAYS, GST_STATIC_CAPS ( GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_CLAPPER_GDK_MEMORY, - "{ " GST_CLAPPER_GDK_MEMORY_FORMATS " }") + "{ " GST_CLAPPER_GDK_MEMORY_FORMATS ", NV12 }") "; " GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_CLAPPER_GDK_MEMORY ", " GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, - "{ " GST_CLAPPER_GDK_MEMORY_FORMATS " }"))); + "{ " GST_CLAPPER_GDK_MEMORY_FORMATS ", NV12 }"))); static void gst_clapper_sink_navigation_interface_init ( GstNavigationInterface *iface); diff --git a/lib/gst/plugin/gstplugin.c b/lib/gst/plugin/gstplugin.c index 01d5b3d9..ead9829c 100644 --- a/lib/gst/plugin/gstplugin.c +++ b/lib/gst/plugin/gstplugin.c @@ -23,6 +23,7 @@ #include "gstclapperimport.h" #include "gstclapperglimport.h" +#include "gstclapperdmabufimport.h" #include "gstclappersink.h" #include "gstclappergdkmemory.h" @@ -33,6 +34,7 @@ plugin_init (GstPlugin *plugin) res |= GST_ELEMENT_REGISTER (clapperimport, plugin); res |= GST_ELEMENT_REGISTER (clapperglimport, plugin); + res |= GST_ELEMENT_REGISTER (clapperdmabufimport, plugin); res |= GST_ELEMENT_REGISTER (clappersink, plugin); if (res) diff --git a/lib/gst/plugin/meson.build b/lib/gst/plugin/meson.build index e8c4f1a7..bcd6c5d5 100644 --- a/lib/gst/plugin/meson.build +++ b/lib/gst/plugin/meson.build @@ -51,8 +51,10 @@ gst_clapper_plugin_sources = [ 'gstclappergdkbufferpool.c', 'gstclapperbaseimport.c', 'gstclapperglbaseimport.c', + 'gstclapperdmabufbaseimport.c', 'gstclapperimport.c', 'gstclapperglimport.c', + 'gstclapperdmabufimport.c', 'gstclappersink.c', 'gstclapperpaintable.c', 'gstgtkutils.c',