mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-07-03 21:25:54 +00:00
bcad005d05
None of the GL allocators actually offer a generic alloc() implementation. As a side effect, they cannot be offered as they don't work with generic video buffer pool. Our specialized buffer pool can be dropped by tee or alphacombine as sharing the same buffer pool over two branch is not supported by the pool API. Fixes #3372 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6327>
3701 lines
104 KiB
C
3701 lines
104 KiB
C
/*
|
|
* GStreamer
|
|
* Copyright (C) 2012-2014 Matthew Waters <ystree00@gmail.com>
|
|
* Copyright (C) 2017 Sebastian Dröge <sebastian@centricular.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 "gl.h"
|
|
#include "gstglupload.h"
|
|
#include "gstglfuncs.h"
|
|
|
|
#if GST_GL_HAVE_PLATFORM_EGL
|
|
#include "egl/gsteglimage.h"
|
|
#include "egl/gsteglimage_private.h"
|
|
#include "egl/gstglmemoryegl.h"
|
|
#include "egl/gstglcontext_egl.h"
|
|
#endif
|
|
|
|
#if GST_GL_HAVE_DMABUF
|
|
#include <gst/allocators/gstdmabuf.h>
|
|
#include <libdrm/drm_fourcc.h>
|
|
#else
|
|
/* to avoid ifdef in _gst_gl_upload_set_caps_unlocked() */
|
|
#define DRM_FORMAT_MOD_LINEAR 0ULL
|
|
#endif
|
|
|
|
#if GST_GL_HAVE_VIV_DIRECTVIV
|
|
#include <gst/allocators/gstphysmemory.h>
|
|
#include <gst/gl/gstglfuncs.h>
|
|
#endif
|
|
|
|
/**
|
|
* SECTION:gstglupload
|
|
* @title: GstGLUpload
|
|
* @short_description: an object that uploads to GL textures
|
|
* @see_also: #GstGLDownload, #GstGLMemory
|
|
*
|
|
* #GstGLUpload is an object that uploads data from system memory into GL textures.
|
|
*
|
|
* A #GstGLUpload can be created with gst_gl_upload_new()
|
|
*/
|
|
|
|
#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))
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_gl_upload_debug);
|
|
#define GST_CAT_DEFAULT gst_gl_upload_debug
|
|
|
|
static void gst_gl_upload_finalize (GObject * object);
|
|
|
|
static GstGLTextureTarget
|
|
_caps_get_texture_target (GstCaps * caps, GstGLTextureTarget default_target)
|
|
{
|
|
GstGLTextureTarget ret = 0;
|
|
GstStructure *s = gst_caps_get_structure (caps, 0);
|
|
|
|
if (gst_structure_has_field_typed (s, "texture-target", G_TYPE_STRING)) {
|
|
const gchar *target_str = gst_structure_get_string (s, "texture-target");
|
|
ret = gst_gl_texture_target_from_string (target_str);
|
|
}
|
|
|
|
if (!ret)
|
|
ret = default_target;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Define the maximum number of planes we can upload - handle 2 views per buffer */
|
|
#define GST_GL_UPLOAD_MAX_PLANES (GST_VIDEO_MAX_PLANES * 2)
|
|
|
|
typedef struct _UploadMethod UploadMethod;
|
|
|
|
struct _GstGLUploadPrivate
|
|
{
|
|
union
|
|
{
|
|
GstVideoInfo in_info;
|
|
GstVideoInfoDmaDrm in_info_drm;
|
|
};
|
|
GstVideoInfo out_info;
|
|
GstCaps *in_caps;
|
|
GstCaps *out_caps;
|
|
|
|
GstBuffer *outbuf;
|
|
|
|
/* all method impl pointers */
|
|
gpointer *upload_impl;
|
|
|
|
/* current method */
|
|
const UploadMethod *method;
|
|
gpointer method_impl;
|
|
int method_i;
|
|
|
|
/* saved method for reconfigure */
|
|
int saved_method_i;
|
|
};
|
|
|
|
#define DEBUG_INIT \
|
|
GST_DEBUG_CATEGORY_INIT (gst_gl_upload_debug, "glupload", 0, "upload");
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GstGLUpload, gst_gl_upload, GST_TYPE_OBJECT,
|
|
G_ADD_PRIVATE (GstGLUpload) DEBUG_INIT);
|
|
|
|
static gboolean
|
|
filter_features (GstCapsFeatures * features,
|
|
G_GNUC_UNUSED GstStructure * structure, gpointer user_data)
|
|
{
|
|
const GstCapsFeatures *user_features = user_data;
|
|
GQuark feature;
|
|
guint i, num;
|
|
|
|
if (gst_caps_features_is_any (features))
|
|
return TRUE;
|
|
|
|
num = gst_caps_features_get_size (user_features);
|
|
for (i = 0; i < num; i++) {
|
|
feature = gst_caps_features_get_nth_id (user_features, i);
|
|
if (gst_caps_features_contains_id (features, feature))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_filter_caps_with_features (const GstCaps * caps,
|
|
const GstCapsFeatures * features, GstCaps ** ret_caps)
|
|
{
|
|
GstCaps *tmp = NULL;
|
|
gboolean ret = TRUE;
|
|
|
|
if (gst_caps_is_empty (caps))
|
|
return FALSE;
|
|
|
|
if (gst_caps_is_any (caps)) {
|
|
if (ret_caps) {
|
|
tmp = gst_caps_new_empty ();
|
|
gst_caps_set_features_simple (tmp, gst_caps_features_copy (features));
|
|
*ret_caps = tmp;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
tmp = gst_caps_copy (caps);
|
|
gst_caps_filter_and_map_in_place (tmp, filter_features, (gpointer) features);
|
|
|
|
if (gst_caps_is_empty (tmp)) {
|
|
gst_clear_caps (&tmp);
|
|
ret = FALSE;
|
|
}
|
|
|
|
if (ret_caps)
|
|
*ret_caps = tmp;
|
|
else
|
|
gst_clear_caps (&tmp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstCaps *
|
|
_set_caps_features_with_passthrough (const GstCaps * caps,
|
|
const gchar * feature_name, GstCapsFeatures * passthrough)
|
|
{
|
|
guint i, j, m, n;
|
|
GstCaps *tmp;
|
|
|
|
tmp = gst_caps_new_empty ();
|
|
|
|
n = gst_caps_get_size (caps);
|
|
for (i = 0; i < n; i++) {
|
|
GstCapsFeatures *features, *orig_features;
|
|
GstStructure *s = gst_caps_get_structure (caps, i);
|
|
|
|
orig_features = gst_caps_get_features (caps, i);
|
|
features = gst_caps_features_new (feature_name, NULL);
|
|
|
|
if (gst_caps_features_is_any (orig_features)) {
|
|
/* if we have any features, we add both the features with and without @passthrough */
|
|
gst_caps_append_structure_full (tmp, gst_structure_copy (s),
|
|
gst_caps_features_copy (features));
|
|
|
|
m = gst_caps_features_get_size (passthrough);
|
|
for (j = 0; j < m; j++) {
|
|
const gchar *feature = gst_caps_features_get_nth (passthrough, j);
|
|
|
|
/* if we already have the features */
|
|
if (gst_caps_features_contains (features, feature))
|
|
continue;
|
|
|
|
gst_caps_features_add (features, feature);
|
|
}
|
|
} else {
|
|
m = gst_caps_features_get_size (orig_features);
|
|
for (j = 0; j < m; j++) {
|
|
const gchar *feature = gst_caps_features_get_nth (orig_features, j);
|
|
|
|
/* if we already have the features */
|
|
if (gst_caps_features_contains (features, feature))
|
|
continue;
|
|
|
|
if (g_strcmp0 (feature, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY) == 0)
|
|
continue;
|
|
|
|
if (gst_caps_features_contains (passthrough, feature)) {
|
|
gst_caps_features_add (features, feature);
|
|
}
|
|
}
|
|
}
|
|
|
|
gst_caps_append_structure_full (tmp, gst_structure_copy (s), features);
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
static GstCaps *
|
|
_caps_intersect_texture_target (GstCaps * caps, GstGLTextureTarget target_mask)
|
|
{
|
|
GValue targets = G_VALUE_INIT;
|
|
GstCaps *ret, *target;
|
|
|
|
target = gst_caps_copy (caps);
|
|
gst_gl_value_set_texture_target_from_mask (&targets, target_mask);
|
|
gst_caps_set_value (target, "texture-target", &targets);
|
|
|
|
ret = gst_caps_intersect_full (caps, target, GST_CAPS_INTERSECT_FIRST);
|
|
|
|
g_value_unset (&targets);
|
|
gst_caps_unref (target);
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_structure_check_target (GstStructure * structure,
|
|
GstGLTextureTarget target_mask)
|
|
{
|
|
const GValue *target_val;
|
|
const gchar *target_str;
|
|
GstGLTextureTarget target;
|
|
guint i;
|
|
|
|
target_val = gst_structure_get_value (structure, "texture-target");
|
|
|
|
/* If no texture-target set, it means a default of 2D. */
|
|
if (!target_val)
|
|
return (1 << GST_GL_TEXTURE_TARGET_2D) & target_mask;
|
|
|
|
if (G_VALUE_HOLDS_STRING (target_val)) {
|
|
target_str = g_value_get_string (target_val);
|
|
target = gst_gl_texture_target_from_string (target_str);
|
|
|
|
return (1 << target) & target_mask;
|
|
} else if (GST_VALUE_HOLDS_LIST (target_val)) {
|
|
guint num_values = gst_value_list_get_size (target_val);
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
const GValue *val = gst_value_list_get_value (target_val, i);
|
|
|
|
target_str = g_value_get_string (val);
|
|
target = gst_gl_texture_target_from_string (target_str);
|
|
if ((1 << target) & target_mask)
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
typedef enum
|
|
{
|
|
METHOD_FLAG_CAN_SHARE_CONTEXT = 1,
|
|
METHOD_FLAG_CAN_ACCEPT_RAW = 2, /* This method can accept raw memory input caps */
|
|
} GstGLUploadMethodFlags;
|
|
|
|
struct _UploadMethod
|
|
{
|
|
const gchar *name;
|
|
GstGLUploadMethodFlags flags;
|
|
|
|
GstStaticCaps *input_template_caps;
|
|
|
|
gpointer (*new) (GstGLUpload * upload);
|
|
GstCaps *(*transform_caps) (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps);
|
|
gboolean (*accept) (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps);
|
|
void (*propose_allocation) (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query);
|
|
GstGLUploadReturn (*perform) (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf);
|
|
void (*free) (gpointer impl);
|
|
} _UploadMethod;
|
|
|
|
struct PassthroughUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
};
|
|
|
|
static gpointer
|
|
_passthrough_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct PassthroughUpload *passthrough = g_new0 (struct PassthroughUpload, 1);
|
|
|
|
passthrough->upload = upload;
|
|
|
|
return passthrough;
|
|
}
|
|
|
|
static GstStaticCaps _passthrough_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_DMA_DRM_CAPS_MAKE);
|
|
|
|
static GstCaps *
|
|
_passthrough_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
GstCaps *passthrough_caps = gst_static_caps_get (&_passthrough_upload_caps);
|
|
GstCaps *out_caps;
|
|
|
|
out_caps = gst_caps_intersect_full (caps, passthrough_caps,
|
|
GST_CAPS_INTERSECT_FIRST);
|
|
gst_caps_unref (passthrough_caps);
|
|
|
|
return out_caps;
|
|
}
|
|
|
|
static gboolean
|
|
_passthrough_upload_accept (gpointer impl, GstBuffer * buffer,
|
|
GstCaps * in_caps, GstCaps * out_caps)
|
|
{
|
|
GstCaps *caps;
|
|
gboolean res;
|
|
|
|
caps = gst_caps_intersect (in_caps, out_caps);
|
|
res = !gst_caps_is_empty (caps);
|
|
gst_caps_unref (caps);
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
_passthrough_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_passthrough_upload_perform (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
*outbuf = gst_buffer_ref (buffer);
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_passthrough_upload_free (gpointer impl)
|
|
{
|
|
g_free (impl);
|
|
}
|
|
|
|
static const UploadMethod _passthrough_upload = {
|
|
"Dmabuf Passthrough",
|
|
0,
|
|
&_passthrough_upload_caps,
|
|
&_passthrough_upload_new,
|
|
&_passthrough_upload_transform_caps,
|
|
&_passthrough_upload_accept,
|
|
&_passthrough_upload_propose_allocation,
|
|
&_passthrough_upload_perform,
|
|
&_passthrough_upload_free
|
|
};
|
|
|
|
struct GLMemoryUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
GstGLTextureTarget input_target;
|
|
GstGLTextureTarget output_target;
|
|
};
|
|
|
|
static gpointer
|
|
_gl_memory_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct GLMemoryUpload *mem = g_new0 (struct GLMemoryUpload, 1);
|
|
|
|
mem->upload = upload;
|
|
mem->input_target = GST_GL_TEXTURE_TARGET_NONE;
|
|
mem->output_target = GST_GL_TEXTURE_TARGET_NONE;
|
|
|
|
return mem;
|
|
}
|
|
|
|
static GstCaps *
|
|
_gl_memory_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
struct GLMemoryUpload *upload = impl;
|
|
GstCapsFeatures *passthrough =
|
|
gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
GstCaps *ret;
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstCaps *tmp;
|
|
GstCapsFeatures *filter_features;
|
|
GstGLTextureTarget target_mask;
|
|
|
|
filter_features = gst_caps_features_new (GST_CAPS_FEATURE_MEMORY_GL_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, NULL);
|
|
if (!_filter_caps_with_features (caps, filter_features, &tmp)) {
|
|
gst_caps_features_free (filter_features);
|
|
gst_caps_features_free (passthrough);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (filter_features);
|
|
|
|
ret = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
gst_caps_unref (tmp);
|
|
|
|
if (upload->input_target != GST_GL_TEXTURE_TARGET_NONE) {
|
|
target_mask = 1 << upload->input_target;
|
|
} else {
|
|
target_mask = 1 << GST_GL_TEXTURE_TARGET_2D |
|
|
1 << GST_GL_TEXTURE_TARGET_RECTANGLE |
|
|
1 << GST_GL_TEXTURE_TARGET_EXTERNAL_OES;
|
|
}
|
|
|
|
tmp = _caps_intersect_texture_target (ret, target_mask);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
|
|
ret = _set_caps_features_with_passthrough (caps,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
gst_caps_features_free (passthrough);
|
|
|
|
GST_DEBUG_OBJECT (upload->upload, "direction %s, transformed %"
|
|
GST_PTR_FORMAT " into %" GST_PTR_FORMAT,
|
|
direction == GST_PAD_SRC ? "src" : "sink", caps, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_gl_memory_upload_accept (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
struct GLMemoryUpload *upload = impl;
|
|
GstCapsFeatures *features;
|
|
int i;
|
|
|
|
features = gst_caps_get_features (out_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_GL_MEMORY))
|
|
return FALSE;
|
|
|
|
features = gst_caps_get_features (in_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_GL_MEMORY)
|
|
&& !gst_caps_features_contains (features,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY))
|
|
return FALSE;
|
|
|
|
if (buffer) {
|
|
GstVideoInfo *in_info = &upload->upload->priv->in_info;
|
|
guint expected_memories = GST_VIDEO_INFO_N_PLANES (in_info);
|
|
|
|
/* Support stereo views for separated multiview mode */
|
|
if (GST_VIDEO_INFO_MULTIVIEW_MODE (in_info) ==
|
|
GST_VIDEO_MULTIVIEW_MODE_SEPARATED)
|
|
expected_memories *= GST_VIDEO_INFO_VIEWS (in_info);
|
|
|
|
if (gst_buffer_n_memory (buffer) != expected_memories)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < expected_memories; i++) {
|
|
GstMemory *mem = gst_buffer_peek_memory (buffer, i);
|
|
|
|
if (!gst_is_gl_memory (mem))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_gl_memory_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
struct GLMemoryUpload *upload = impl;
|
|
GstBufferPool *pool = NULL;
|
|
guint n_pools, i;
|
|
GstCaps *caps;
|
|
GstCapsFeatures *features_gl, *features_sys;
|
|
GstAllocator *allocator = NULL;
|
|
GstAllocationParams params;
|
|
gboolean use_sys_mem = FALSE;
|
|
const gchar *target_pool_option_str = NULL;
|
|
|
|
gst_query_parse_allocation (query, &caps, NULL);
|
|
if (caps == NULL)
|
|
goto invalid_caps;
|
|
|
|
g_assert (gst_caps_is_fixed (caps));
|
|
|
|
features_gl = gst_caps_features_new (GST_CAPS_FEATURE_MEMORY_GL_MEMORY, NULL);
|
|
features_sys =
|
|
gst_caps_features_new (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, NULL);
|
|
/* Only offer our custom allocator if that type of memory was negotiated. */
|
|
if (_filter_caps_with_features (caps, features_sys, NULL)) {
|
|
use_sys_mem = TRUE;
|
|
} else if (!_filter_caps_with_features (caps, features_gl, NULL)) {
|
|
gst_caps_features_free (features_gl);
|
|
gst_caps_features_free (features_sys);
|
|
return;
|
|
}
|
|
gst_caps_features_free (features_gl);
|
|
gst_caps_features_free (features_sys);
|
|
|
|
if (upload->upload->priv->out_caps) {
|
|
GstGLTextureTarget target;
|
|
|
|
target = _caps_get_texture_target (upload->upload->priv->out_caps,
|
|
GST_GL_TEXTURE_TARGET_2D);
|
|
|
|
/* Do not provide the allocator and pool for system memory caps
|
|
because the external oes kind GL memory can not be mapped. */
|
|
if (target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES && use_sys_mem)
|
|
return;
|
|
|
|
target_pool_option_str =
|
|
gst_gl_texture_target_to_buffer_pool_option (target);
|
|
}
|
|
|
|
gst_allocation_params_init (¶ms);
|
|
|
|
|
|
if (!use_sys_mem) {
|
|
allocator =
|
|
GST_ALLOCATOR (gst_gl_memory_allocator_get_default (upload->
|
|
upload->context));
|
|
}
|
|
|
|
gst_query_add_allocation_param (query, allocator, ¶ms);
|
|
gst_clear_object (&allocator);
|
|
|
|
#if GST_GL_HAVE_PLATFORM_EGL
|
|
if (upload->upload->context
|
|
&& gst_gl_context_get_gl_platform (upload->upload->context) ==
|
|
GST_GL_PLATFORM_EGL) {
|
|
if (!use_sys_mem) {
|
|
allocator =
|
|
GST_ALLOCATOR (gst_allocator_find (GST_GL_MEMORY_EGL_ALLOCATOR_NAME));
|
|
}
|
|
gst_query_add_allocation_param (query, allocator, ¶ms);
|
|
gst_clear_object (&allocator);
|
|
}
|
|
#endif
|
|
|
|
n_pools = gst_query_get_n_allocation_pools (query);
|
|
for (i = 0; i < n_pools; i++) {
|
|
gst_query_parse_nth_allocation_pool (query, i, &pool, NULL, NULL, NULL);
|
|
if (!GST_IS_GL_BUFFER_POOL (pool)) {
|
|
gst_object_unref (pool);
|
|
pool = NULL;
|
|
}
|
|
}
|
|
|
|
if (!pool) {
|
|
GstStructure *config;
|
|
GstVideoInfo info;
|
|
gsize size;
|
|
|
|
if (!gst_video_info_from_caps (&info, caps))
|
|
goto invalid_caps;
|
|
|
|
pool = gst_gl_buffer_pool_new (upload->upload->context);
|
|
config = gst_buffer_pool_get_config (pool);
|
|
|
|
/* the normal size of a frame */
|
|
size = info.size;
|
|
gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
|
|
/* keep one buffer around before allowing acquire */
|
|
gst_buffer_pool_config_set_gl_min_free_queue_size (config, 1);
|
|
gst_buffer_pool_config_add_option (config,
|
|
GST_BUFFER_POOL_OPTION_GL_SYNC_META);
|
|
if (target_pool_option_str)
|
|
gst_buffer_pool_config_add_option (config, target_pool_option_str);
|
|
|
|
if (!gst_buffer_pool_set_config (pool, config)) {
|
|
gst_object_unref (pool);
|
|
goto config_failed;
|
|
}
|
|
|
|
gst_query_add_allocation_pool (query, pool, size, 1, 0);
|
|
}
|
|
|
|
if (pool)
|
|
gst_object_unref (pool);
|
|
|
|
return;
|
|
|
|
invalid_caps:
|
|
{
|
|
GST_WARNING_OBJECT (upload->upload, "invalid caps specified");
|
|
return;
|
|
}
|
|
config_failed:
|
|
{
|
|
GST_WARNING_OBJECT (upload->upload, "failed setting config");
|
|
return;
|
|
}
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_gl_memory_upload_perform (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
struct GLMemoryUpload *upload = impl;
|
|
GstGLMemory *gl_mem;
|
|
int i, n;
|
|
|
|
n = gst_buffer_n_memory (buffer);
|
|
for (i = 0; i < n; i++) {
|
|
GstMemory *mem = gst_buffer_peek_memory (buffer, i);
|
|
|
|
gl_mem = (GstGLMemory *) mem;
|
|
if (!gst_gl_context_can_share (upload->upload->context,
|
|
gl_mem->mem.context))
|
|
return GST_GL_UPLOAD_UNSHARED_GL_CONTEXT;
|
|
|
|
if (upload->output_target == GST_GL_TEXTURE_TARGET_NONE &&
|
|
upload->upload->priv->out_caps) {
|
|
upload->output_target =
|
|
_caps_get_texture_target (upload->upload->priv->out_caps,
|
|
GST_GL_TEXTURE_TARGET_NONE);
|
|
}
|
|
|
|
/* always track the last input texture target so ::transform_caps() can
|
|
* use it to build the output caps */
|
|
upload->input_target = gl_mem->tex_target;
|
|
if (upload->output_target != gl_mem->tex_target) {
|
|
*outbuf = NULL;
|
|
return GST_GL_UPLOAD_RECONFIGURE;
|
|
}
|
|
|
|
if (gst_is_gl_memory_pbo (mem))
|
|
gst_gl_memory_pbo_upload_transfer ((GstGLMemoryPBO *) mem);
|
|
}
|
|
|
|
*outbuf = gst_buffer_ref (buffer);
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_gl_memory_upload_free (gpointer impl)
|
|
{
|
|
g_free (impl);
|
|
}
|
|
|
|
|
|
static GstStaticCaps _gl_memory_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
|
|
(GST_CAPS_FEATURE_MEMORY_GL_MEMORY, GST_GL_MEMORY_VIDEO_FORMATS_STR));
|
|
|
|
static const UploadMethod _gl_memory_upload = {
|
|
"GLMemory",
|
|
METHOD_FLAG_CAN_SHARE_CONTEXT,
|
|
&_gl_memory_upload_caps,
|
|
&_gl_memory_upload_new,
|
|
&_gl_memory_upload_transform_caps,
|
|
&_gl_memory_upload_accept,
|
|
&_gl_memory_upload_propose_allocation,
|
|
&_gl_memory_upload_perform,
|
|
&_gl_memory_upload_free
|
|
};
|
|
|
|
#if GST_GL_HAVE_DMABUF
|
|
|
|
typedef enum
|
|
{
|
|
INCLUDE_EXTERNAL = 1 << 1,
|
|
LINEAR_ONLY = 2 << 1,
|
|
} GstGLUploadDrmFormatFlags;
|
|
|
|
typedef struct _GstEGLImageCacheEntry
|
|
{
|
|
GstEGLImage *eglimage[GST_VIDEO_MAX_PLANES];
|
|
} GstEGLImageCacheEntry;
|
|
|
|
typedef struct _GstEGLImageCache
|
|
{
|
|
gint ref_count;
|
|
GHashTable *hash_table; /* for GstMemory -> GstEGLImageCacheEntry lookup */
|
|
GMutex lock; /* protects hash_table */
|
|
} GstEGLImageCache;
|
|
|
|
struct DmabufUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
|
|
GstEGLImage *eglimage[GST_VIDEO_MAX_PLANES];
|
|
GstEGLImageCache *eglimage_cache;
|
|
GstGLFormat formats[GST_VIDEO_MAX_PLANES];
|
|
GstBuffer *outbuf;
|
|
GstGLVideoAllocationParams *params;
|
|
guint n_mem;
|
|
|
|
gboolean direct;
|
|
GstGLTextureTarget target;
|
|
GstVideoInfo out_info;
|
|
/* only used for pointer comparison */
|
|
gpointer out_caps;
|
|
};
|
|
|
|
static void
|
|
gst_egl_image_cache_ref (GstEGLImageCache * cache)
|
|
{
|
|
g_atomic_int_inc (&cache->ref_count);
|
|
}
|
|
|
|
static void
|
|
gst_egl_image_cache_unref (GstEGLImageCache * cache)
|
|
{
|
|
if (g_atomic_int_dec_and_test (&cache->ref_count)) {
|
|
g_hash_table_unref (cache->hash_table);
|
|
g_mutex_clear (&cache->lock);
|
|
g_free (cache);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_egl_image_cache_entry_remove (GstEGLImageCache * cache, GstMiniObject * mem)
|
|
{
|
|
g_mutex_lock (&cache->lock);
|
|
g_hash_table_remove (cache->hash_table, mem);
|
|
g_mutex_unlock (&cache->lock);
|
|
gst_egl_image_cache_unref (cache);
|
|
}
|
|
|
|
static GstEGLImageCacheEntry *
|
|
gst_egl_image_cache_entry_new (GstEGLImageCache * cache, GstMemory * mem)
|
|
{
|
|
GstEGLImageCacheEntry *cache_entry;
|
|
|
|
cache_entry = g_new0 (GstEGLImageCacheEntry, 1);
|
|
gst_egl_image_cache_ref (cache);
|
|
gst_mini_object_weak_ref (GST_MINI_OBJECT (mem),
|
|
(GstMiniObjectNotify) gst_egl_image_cache_entry_remove, cache);
|
|
g_mutex_lock (&cache->lock);
|
|
g_hash_table_insert (cache->hash_table, mem, cache_entry);
|
|
g_mutex_unlock (&cache->lock);
|
|
|
|
return cache_entry;
|
|
}
|
|
|
|
static void
|
|
gst_egl_image_cache_entry_free (GstEGLImageCacheEntry * cache_entry)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
|
|
if (cache_entry->eglimage[i])
|
|
gst_egl_image_unref (cache_entry->eglimage[i]);
|
|
}
|
|
g_free (cache_entry);
|
|
}
|
|
|
|
/*
|
|
* Looks up a cache_entry for mem if mem is different from previous_mem.
|
|
* If mem is the same as previous_mem, the costly lookup is skipped and the
|
|
* provided (previous) cache_entry is used instead.
|
|
*
|
|
* Returns the cached eglimage for the given plane from the cache_entry, or
|
|
* NULL. previous_mem is set to mem.
|
|
*/
|
|
static GstEGLImage *
|
|
gst_egl_image_cache_lookup (GstEGLImageCache * cache, GstMemory * mem,
|
|
gint plane, GstMemory ** previous_mem, GstEGLImageCacheEntry ** cache_entry)
|
|
{
|
|
if (mem != *previous_mem) {
|
|
g_mutex_lock (&cache->lock);
|
|
*cache_entry = g_hash_table_lookup (cache->hash_table, mem);
|
|
g_mutex_unlock (&cache->lock);
|
|
*previous_mem = mem;
|
|
}
|
|
|
|
if (*cache_entry)
|
|
return (*cache_entry)->eglimage[plane];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Creates a new cache_entry for mem if no cache_entry is provided.
|
|
* Stores the eglimage for the given plane in the cache_entry.
|
|
*/
|
|
static void
|
|
gst_egl_image_cache_store (GstEGLImageCache * cache, GstMemory * mem,
|
|
gint plane, GstEGLImage * eglimage, GstEGLImageCacheEntry ** cache_entry)
|
|
{
|
|
if (!(*cache_entry))
|
|
*cache_entry = gst_egl_image_cache_entry_new (cache, mem);
|
|
(*cache_entry)->eglimage[plane] = eglimage;
|
|
}
|
|
|
|
static GstEGLImageCache *
|
|
gst_egl_image_cache_new (void)
|
|
{
|
|
GstEGLImageCache *cache;
|
|
|
|
cache = g_new0 (GstEGLImageCache, 1);
|
|
cache->ref_count = 1;
|
|
|
|
cache->hash_table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
|
|
NULL, (GDestroyNotify) gst_egl_image_cache_entry_free);
|
|
g_mutex_init (&cache->lock);
|
|
|
|
return cache;
|
|
}
|
|
|
|
static GstStaticCaps _dma_buf_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_DMA_DRM_CAPS_MAKE ";"
|
|
GST_VIDEO_CAPS_MAKE (GST_GL_MEMORY_VIDEO_FORMATS_STR));
|
|
|
|
static gpointer
|
|
_dma_buf_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct DmabufUpload *dmabuf = g_new0 (struct DmabufUpload, 1);
|
|
dmabuf->upload = upload;
|
|
dmabuf->eglimage_cache = gst_egl_image_cache_new ();
|
|
dmabuf->target = GST_GL_TEXTURE_TARGET_2D;
|
|
return dmabuf;
|
|
}
|
|
|
|
/* Append all drm format strings to drm_formats array. */
|
|
static void
|
|
_append_drm_formats_from_video_format (GstGLContext * context,
|
|
GstVideoFormat format, GstGLUploadDrmFormatFlags flags,
|
|
GPtrArray * drm_formats)
|
|
{
|
|
gint32 i, fourcc;
|
|
const GArray *dma_modifiers = NULL;
|
|
char *drm_format;
|
|
|
|
fourcc = gst_video_dma_drm_fourcc_from_format (format);
|
|
if (fourcc == DRM_FORMAT_INVALID)
|
|
return;
|
|
|
|
if (!gst_gl_context_egl_get_format_modifiers (context, fourcc,
|
|
&dma_modifiers))
|
|
return;
|
|
|
|
/* No modifier info, lets warn and move on */
|
|
if (!dma_modifiers) {
|
|
GST_WARNING_OBJECT (context, "Undefined modifiers list for %"
|
|
GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < dma_modifiers->len; i++) {
|
|
GstGLDmaModifier *mod = &g_array_index (dma_modifiers, GstGLDmaModifier, i);
|
|
|
|
if (!(flags & INCLUDE_EXTERNAL) && mod->external_only)
|
|
continue;
|
|
|
|
if (flags & LINEAR_ONLY && mod->modifier != DRM_FORMAT_MOD_LINEAR)
|
|
continue;
|
|
|
|
drm_format = gst_video_dma_drm_fourcc_to_string (fourcc, mod->modifier);
|
|
g_ptr_array_add (drm_formats, drm_format);
|
|
}
|
|
}
|
|
|
|
/* Given the video formats in src GValue, collecting all the according
|
|
drm formats to dst GValue. Return FALSE if no valid drm formats found. */
|
|
static gboolean
|
|
_dma_buf_transform_gst_formats_to_drm_formats (GstGLContext * context,
|
|
const GValue * video_value, GstGLUploadDrmFormatFlags flags,
|
|
GValue * drm_value)
|
|
{
|
|
GstVideoFormat gst_format;
|
|
GPtrArray *all_drm_formats = NULL;
|
|
guint i;
|
|
|
|
all_drm_formats = g_ptr_array_new ();
|
|
|
|
if (G_VALUE_HOLDS_STRING (video_value)) {
|
|
gst_format =
|
|
gst_video_format_from_string (g_value_get_string (video_value));
|
|
if (gst_format != GST_VIDEO_FORMAT_UNKNOWN) {
|
|
_append_drm_formats_from_video_format (context, gst_format,
|
|
flags, all_drm_formats);
|
|
}
|
|
} else if (GST_VALUE_HOLDS_LIST (video_value)) {
|
|
guint num_values = gst_value_list_get_size (video_value);
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
const GValue *val = gst_value_list_get_value (video_value, i);
|
|
|
|
gst_format = gst_video_format_from_string (g_value_get_string (val));
|
|
if (gst_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
continue;
|
|
|
|
_append_drm_formats_from_video_format (context, gst_format,
|
|
flags, all_drm_formats);
|
|
}
|
|
}
|
|
|
|
if (all_drm_formats->len == 0) {
|
|
g_ptr_array_unref (all_drm_formats);
|
|
return FALSE;
|
|
}
|
|
|
|
if (all_drm_formats->len == 1) {
|
|
g_value_init (drm_value, G_TYPE_STRING);
|
|
g_value_take_string (drm_value, g_ptr_array_index (all_drm_formats, 0));
|
|
} else {
|
|
GValue item = G_VALUE_INIT;
|
|
|
|
gst_value_list_init (drm_value, all_drm_formats->len);
|
|
|
|
for (i = 0; i < all_drm_formats->len; i++) {
|
|
g_value_init (&item, G_TYPE_STRING);
|
|
g_value_take_string (&item, g_ptr_array_index (all_drm_formats, i));
|
|
gst_value_list_append_value (drm_value, &item);
|
|
g_value_unset (&item);
|
|
}
|
|
}
|
|
|
|
/* The strings are already token by the GValue, no need to free. */
|
|
g_ptr_array_unref (all_drm_formats);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_check_modifier (GstGLContext * context, guint32 fourcc,
|
|
guint64 modifier, gboolean include_external)
|
|
{
|
|
const GArray *dma_modifiers;
|
|
guint i;
|
|
|
|
/* If no context provide, no further check. */
|
|
if (!context)
|
|
return TRUE;
|
|
|
|
if (!gst_gl_context_egl_get_format_modifiers (context, fourcc,
|
|
&dma_modifiers))
|
|
return FALSE;
|
|
|
|
if (!dma_modifiers) {
|
|
/* recognize the fourcc but no modifier info, consider it as linear */
|
|
if (modifier == DRM_FORMAT_MOD_LINEAR)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < dma_modifiers->len; i++) {
|
|
GstGLDmaModifier *mod = &g_array_index (dma_modifiers, GstGLDmaModifier, i);
|
|
|
|
if (!mod->external_only || include_external) {
|
|
if (mod->modifier == modifier)
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
_set_default_formats_list (GstStructure * structure)
|
|
{
|
|
GValue formats = G_VALUE_INIT;
|
|
|
|
g_value_init (&formats, GST_TYPE_LIST);
|
|
gst_value_deserialize (&formats, GST_GL_MEMORY_VIDEO_FORMATS_STR);
|
|
gst_structure_take_value (structure, "format", &formats);
|
|
}
|
|
|
|
static GstVideoFormat
|
|
_get_video_format_from_drm_format (GstGLContext * context,
|
|
const gchar * drm_format, GstGLUploadDrmFormatFlags flags)
|
|
{
|
|
GstVideoFormat gst_format;
|
|
guint32 fourcc;
|
|
guint64 modifier;
|
|
|
|
fourcc = gst_video_dma_drm_fourcc_from_string (drm_format, &modifier);
|
|
if (fourcc == DRM_FORMAT_INVALID)
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
if (flags & LINEAR_ONLY && modifier != DRM_FORMAT_MOD_LINEAR)
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
gst_format = gst_video_dma_drm_fourcc_to_format (fourcc);
|
|
if (gst_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
if (!_check_modifier (context, fourcc, modifier, flags & INCLUDE_EXTERNAL))
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
return gst_format;
|
|
}
|
|
|
|
/* Given the drm formats in src GValue, collecting all the according
|
|
gst formats to dst GValue. Return FALSE if no valid drm formats found. */
|
|
static gboolean
|
|
_dma_buf_transform_drm_formats_to_gst_formats (GstGLContext * context,
|
|
const GValue * drm_value, GstGLUploadDrmFormatFlags flags,
|
|
GValue * video_value)
|
|
{
|
|
GstVideoFormat gst_format;
|
|
GArray *all_formats = NULL;
|
|
guint i;
|
|
|
|
all_formats = g_array_new (FALSE, FALSE, sizeof (GstVideoFormat));
|
|
|
|
if (G_VALUE_HOLDS_STRING (drm_value)) {
|
|
gst_format = _get_video_format_from_drm_format (context,
|
|
g_value_get_string (drm_value), flags);
|
|
|
|
if (gst_format != GST_VIDEO_FORMAT_UNKNOWN)
|
|
g_array_append_val (all_formats, gst_format);
|
|
} else if (GST_VALUE_HOLDS_LIST (drm_value)) {
|
|
guint num_values = gst_value_list_get_size (drm_value);
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
const GValue *val = gst_value_list_get_value (drm_value, i);
|
|
|
|
gst_format = _get_video_format_from_drm_format (context,
|
|
g_value_get_string (val), flags);
|
|
if (gst_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
continue;
|
|
|
|
g_array_append_val (all_formats, gst_format);
|
|
}
|
|
}
|
|
|
|
if (all_formats->len == 0) {
|
|
g_array_unref (all_formats);
|
|
return FALSE;
|
|
}
|
|
|
|
if (all_formats->len == 1) {
|
|
g_value_init (video_value, G_TYPE_STRING);
|
|
gst_format = g_array_index (all_formats, GstVideoFormat, 0);
|
|
g_value_set_string (video_value, gst_video_format_to_string (gst_format));
|
|
} else {
|
|
GValue item = G_VALUE_INIT;
|
|
|
|
gst_value_list_init (video_value, all_formats->len);
|
|
|
|
for (i = 0; i < all_formats->len; i++) {
|
|
g_value_init (&item, G_TYPE_STRING);
|
|
gst_format = g_array_index (all_formats, GstVideoFormat, i);
|
|
g_value_set_string (&item, gst_video_format_to_string (gst_format));
|
|
gst_value_list_append_value (video_value, &item);
|
|
g_value_unset (&item);
|
|
}
|
|
}
|
|
|
|
g_array_unref (all_formats);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_dma_buf_convert_format_field_in_structure (GstGLContext * context,
|
|
GstStructure * structure, GstPadDirection direction,
|
|
GstGLUploadDrmFormatFlags flags)
|
|
{
|
|
const GValue *val;
|
|
|
|
if (direction == GST_PAD_SRC) {
|
|
GValue drm_formats = G_VALUE_INIT;
|
|
|
|
/* No context available, we can not know the real modifiers.
|
|
Just leaving all format related fields blank. */
|
|
if (!context) {
|
|
gst_structure_set (structure, "format", G_TYPE_STRING, "DMA_DRM", NULL);
|
|
gst_structure_remove_field (structure, "drm-format");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* When no format provided, just list all supported formats
|
|
and find all the possible drm-format. */
|
|
if (!(val = gst_structure_get_value (structure, "format"))) {
|
|
_set_default_formats_list (structure);
|
|
val = gst_structure_get_value (structure, "format");
|
|
}
|
|
|
|
if (_dma_buf_transform_gst_formats_to_drm_formats (context,
|
|
val, flags, &drm_formats)) {
|
|
gst_structure_take_value (structure, "drm-format", &drm_formats);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
gst_structure_set (structure, "format", G_TYPE_STRING, "DMA_DRM", NULL);
|
|
} else {
|
|
GValue gst_formats = G_VALUE_INIT;
|
|
|
|
/* Reject the traditional "format" field directly. */
|
|
if (g_strcmp0 (gst_structure_get_string (structure, "format"),
|
|
"DMA_DRM") != 0)
|
|
return FALSE;
|
|
|
|
/* If no drm-field in the src, we just list all
|
|
supported formats in dst. */
|
|
if (!(val = gst_structure_get_value (structure, "drm-format"))) {
|
|
gst_structure_remove_field (structure, "format");
|
|
gst_structure_remove_field (structure, "drm-format");
|
|
_set_default_formats_list (structure);
|
|
return TRUE;
|
|
}
|
|
|
|
if (_dma_buf_transform_drm_formats_to_gst_formats (context,
|
|
val, flags, &gst_formats)) {
|
|
gst_structure_take_value (structure, "format", &gst_formats);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
gst_structure_remove_field (structure, "drm-format");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_dma_buf_check_formats_in_structure (GstGLContext * context,
|
|
GstStructure * structure, gboolean include_external)
|
|
{
|
|
const GValue *all_formats;
|
|
GstVideoFormat gst_format;
|
|
guint32 fourcc;
|
|
|
|
all_formats = gst_structure_get_value (structure, "format");
|
|
if (!all_formats)
|
|
return FALSE;
|
|
|
|
if (G_VALUE_HOLDS_STRING (all_formats)) {
|
|
gst_format =
|
|
gst_video_format_from_string (g_value_get_string (all_formats));
|
|
if (gst_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return FALSE;
|
|
|
|
fourcc = gst_video_dma_drm_fourcc_from_format (gst_format);
|
|
if (fourcc == DRM_FORMAT_INVALID)
|
|
return FALSE;
|
|
|
|
if (!_check_modifier (context, fourcc,
|
|
DRM_FORMAT_MOD_LINEAR, include_external))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
} else if (GST_VALUE_HOLDS_LIST (all_formats)) {
|
|
GValue video_value = G_VALUE_INIT;
|
|
guint num_values = gst_value_list_get_size (all_formats);
|
|
GArray *gst_formats = g_array_new (FALSE, FALSE, sizeof (GstVideoFormat));
|
|
guint i;
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
const GValue *val = gst_value_list_get_value (all_formats, i);
|
|
|
|
gst_format = gst_video_format_from_string (g_value_get_string (val));
|
|
if (gst_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
continue;
|
|
|
|
fourcc = gst_video_dma_drm_fourcc_from_format (gst_format);
|
|
if (fourcc == DRM_FORMAT_INVALID)
|
|
continue;
|
|
|
|
if (!_check_modifier (context, fourcc,
|
|
DRM_FORMAT_MOD_LINEAR, include_external))
|
|
continue;
|
|
|
|
g_array_append_val (gst_formats, gst_format);
|
|
}
|
|
|
|
if (gst_formats->len == 0) {
|
|
g_array_unref (gst_formats);
|
|
return FALSE;
|
|
}
|
|
|
|
if (gst_formats->len == 1) {
|
|
g_value_init (&video_value, G_TYPE_STRING);
|
|
gst_format = g_array_index (gst_formats, GstVideoFormat, 0);
|
|
g_value_set_string (&video_value,
|
|
gst_video_format_to_string (gst_format));
|
|
} else {
|
|
GValue item = G_VALUE_INIT;
|
|
|
|
gst_value_list_init (&video_value, gst_formats->len);
|
|
|
|
for (i = 0; i < gst_formats->len; i++) {
|
|
g_value_init (&item, G_TYPE_STRING);
|
|
|
|
gst_format = g_array_index (gst_formats, GstVideoFormat, i);
|
|
g_value_set_string (&item, gst_video_format_to_string (gst_format));
|
|
gst_value_list_append_value (&video_value, &item);
|
|
g_value_unset (&item);
|
|
}
|
|
}
|
|
|
|
g_array_unref (gst_formats);
|
|
|
|
gst_structure_take_value (structure, "format", &video_value);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static GstCaps *
|
|
_dma_buf_upload_transform_caps_common (GstCaps * caps,
|
|
GstGLContext * context, GstPadDirection direction,
|
|
GstGLUploadDrmFormatFlags flags,
|
|
GstGLTextureTarget target_mask,
|
|
const gchar * from_feature, const gchar * to_feature)
|
|
{
|
|
guint i, n;
|
|
GstCaps *ret_caps, *tmp_caps, *caps_to_transform;
|
|
GstCapsFeatures *passthrough, *features;
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
g_return_val_if_fail
|
|
(!g_strcmp0 (from_feature, GST_CAPS_FEATURE_MEMORY_DMABUF) ||
|
|
!g_strcmp0 (from_feature, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY), NULL);
|
|
g_return_val_if_fail
|
|
(!g_strcmp0 (to_feature, GST_CAPS_FEATURE_MEMORY_GL_MEMORY), NULL);
|
|
} else {
|
|
g_return_val_if_fail
|
|
(!g_strcmp0 (to_feature, GST_CAPS_FEATURE_MEMORY_DMABUF) ||
|
|
!g_strcmp0 (to_feature, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY), NULL);
|
|
g_return_val_if_fail
|
|
(!g_strcmp0 (from_feature, GST_CAPS_FEATURE_MEMORY_GL_MEMORY), NULL);
|
|
}
|
|
|
|
features = gst_caps_features_new (from_feature, NULL);
|
|
if (!_filter_caps_with_features (caps, features, &caps_to_transform)) {
|
|
gst_caps_features_free (features);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (features);
|
|
|
|
if (gst_caps_is_any (caps_to_transform)) {
|
|
tmp_caps = caps_to_transform;
|
|
goto passthrough;
|
|
}
|
|
|
|
tmp_caps = gst_caps_new_empty ();
|
|
n = gst_caps_get_size (caps_to_transform);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s;
|
|
GstCapsFeatures *features;
|
|
|
|
features = gst_caps_get_features (caps_to_transform, i);
|
|
g_assert (gst_caps_features_contains (features, from_feature));
|
|
|
|
s = gst_caps_get_structure (caps_to_transform, i);
|
|
|
|
if (direction == GST_PAD_SRC && !_structure_check_target (s, target_mask))
|
|
continue;
|
|
|
|
s = gst_structure_copy (s);
|
|
|
|
if (!g_strcmp0 (from_feature, GST_CAPS_FEATURE_MEMORY_DMABUF) ||
|
|
!g_strcmp0 (to_feature, GST_CAPS_FEATURE_MEMORY_DMABUF)) {
|
|
/* Convert drm-format/format fields for DMABuf */
|
|
if (!_dma_buf_convert_format_field_in_structure (context, s,
|
|
direction, flags)) {
|
|
gst_structure_free (s);
|
|
continue;
|
|
}
|
|
} else {
|
|
if (!_dma_buf_check_formats_in_structure (context, s,
|
|
flags & INCLUDE_EXTERNAL)) {
|
|
gst_structure_free (s);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
gst_caps_append_structure_full (tmp_caps, s,
|
|
gst_caps_features_copy (features));
|
|
}
|
|
|
|
gst_caps_unref (caps_to_transform);
|
|
|
|
if (gst_caps_is_empty (tmp_caps)) {
|
|
gst_caps_unref (tmp_caps);
|
|
return NULL;
|
|
}
|
|
|
|
passthrough:
|
|
/* Change the feature name. */
|
|
passthrough = gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
ret_caps = _set_caps_features_with_passthrough (tmp_caps,
|
|
to_feature, passthrough);
|
|
|
|
gst_caps_features_free (passthrough);
|
|
gst_caps_unref (tmp_caps);
|
|
|
|
return ret_caps;
|
|
}
|
|
|
|
static GstCaps *
|
|
_dma_buf_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
struct DmabufUpload *dmabuf = impl;
|
|
GstCaps *ret, *tmp;
|
|
|
|
if (context) {
|
|
const GstGLFuncs *gl = context->gl_vtable;
|
|
|
|
if (!gl->EGLImageTargetTexture2D)
|
|
return NULL;
|
|
|
|
/* Don't propose DMABuf caps feature unless it can be supported */
|
|
if (gst_gl_context_get_gl_platform (context) != GST_GL_PLATFORM_EGL)
|
|
return NULL;
|
|
|
|
if (!gst_gl_context_check_feature (context, "EGL_KHR_image_base"))
|
|
return NULL;
|
|
|
|
if (!gst_gl_context_egl_supports_modifier (context))
|
|
return NULL;
|
|
}
|
|
|
|
g_assert (dmabuf->target == GST_GL_TEXTURE_TARGET_2D);
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstGLUploadDrmFormatFlags flags = INCLUDE_EXTERNAL | LINEAR_ONLY;
|
|
|
|
ret = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_DMABUF,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY);
|
|
tmp = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY);
|
|
if (!ret) {
|
|
ret = tmp;
|
|
tmp = NULL;
|
|
}
|
|
if (tmp)
|
|
ret = gst_caps_merge (ret, tmp);
|
|
|
|
if (!ret) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"direction %s, fails to transformed DMA caps %" GST_PTR_FORMAT,
|
|
"sink", caps);
|
|
return NULL;
|
|
}
|
|
|
|
tmp = _caps_intersect_texture_target (ret, 1 << GST_GL_TEXTURE_TARGET_2D);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
|
|
ret = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
INCLUDE_EXTERNAL | LINEAR_ONLY, 1 << dmabuf->target,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, GST_CAPS_FEATURE_MEMORY_DMABUF);
|
|
tmp = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
INCLUDE_EXTERNAL | LINEAR_ONLY, 1 << dmabuf->target,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
if (!ret) {
|
|
ret = tmp;
|
|
tmp = NULL;
|
|
}
|
|
if (tmp)
|
|
ret = gst_caps_merge (ret, tmp);
|
|
|
|
if (!ret) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"direction %s, fails to transformed DMA caps %" GST_PTR_FORMAT,
|
|
"src", caps);
|
|
return NULL;
|
|
}
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "direction %s, \n\ttransformed %"
|
|
GST_PTR_FORMAT "\n\tinto %" GST_PTR_FORMAT,
|
|
direction == GST_PAD_SRC ? "src" : "sink", caps, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_dma_buf_upload_accept (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
struct DmabufUpload *dmabuf = impl;
|
|
GstVideoInfoDmaDrm *in_info_drm = &dmabuf->upload->priv->in_info_drm;
|
|
GstVideoInfo *in_info = &in_info_drm->vinfo;
|
|
GstVideoInfo *out_info = &dmabuf->out_info;
|
|
guint n_planes;
|
|
GstVideoMeta *meta;
|
|
guint n_mem;
|
|
GstMemory *mems[GST_VIDEO_MAX_PLANES];
|
|
GstMemory *previous_mem = NULL;
|
|
GstEGLImageCacheEntry *cache_entry = NULL;
|
|
gsize offset[GST_VIDEO_MAX_PLANES];
|
|
gint fd[GST_VIDEO_MAX_PLANES];
|
|
guint i;
|
|
|
|
n_mem = gst_buffer_n_memory (buffer);
|
|
meta = gst_buffer_get_video_meta (buffer);
|
|
|
|
if (!dmabuf->upload->context->gl_vtable->EGLImageTargetTexture2D)
|
|
return FALSE;
|
|
|
|
/* dmabuf upload is only supported with EGL contexts. */
|
|
if (gst_gl_context_get_gl_platform (dmabuf->upload->context) !=
|
|
GST_GL_PLATFORM_EGL)
|
|
return FALSE;
|
|
|
|
if (!gst_gl_context_check_feature (dmabuf->upload->context,
|
|
"EGL_KHR_image_base")) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "no EGL_KHR_image_base extension");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!gst_gl_context_egl_supports_modifier (dmabuf->upload->context)) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "no modifier support");
|
|
return FALSE;
|
|
}
|
|
|
|
if (dmabuf->target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES &&
|
|
!gst_gl_context_check_feature (dmabuf->upload->context,
|
|
"GL_OES_EGL_image_external")) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "no GL_OES_EGL_image_external extension");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!gst_caps_features_contains (gst_caps_get_features (in_caps, 0),
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY) &&
|
|
!gst_caps_features_contains (gst_caps_get_features (in_caps, 0),
|
|
GST_CAPS_FEATURE_MEMORY_DMABUF)) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"Not a DMABuf or SystemMemory caps %" GST_PTR_FORMAT, in_caps);
|
|
return FALSE;
|
|
}
|
|
|
|
if (dmabuf->direct && !gst_egl_image_check_dmabuf_direct_with_dma_drm
|
|
(dmabuf->upload->context, in_info_drm, dmabuf->target)) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"Direct mode does not support %" GST_FOURCC_FORMAT ":0x%016"
|
|
G_GINT64_MODIFIER "x with target: %s",
|
|
GST_FOURCC_ARGS (in_info_drm->drm_fourcc), in_info_drm->drm_modifier,
|
|
gst_gl_texture_target_to_string (dmabuf->target));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!dmabuf->direct && in_info_drm->drm_modifier != DRM_FORMAT_MOD_LINEAR) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"Indirect uploads are only support for linear formats.");
|
|
return FALSE;
|
|
}
|
|
|
|
/* This will eliminate most non-dmabuf out there */
|
|
if (!gst_is_dmabuf_memory (gst_buffer_peek_memory (buffer, 0))) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "input not dmabuf");
|
|
return FALSE;
|
|
}
|
|
|
|
n_planes = GST_VIDEO_INFO_N_PLANES (in_info);
|
|
|
|
/* Update video info based on video meta */
|
|
if (meta) {
|
|
in_info->width = meta->width;
|
|
in_info->height = meta->height;
|
|
n_planes = meta->n_planes;
|
|
|
|
for (i = 0; i < meta->n_planes; i++) {
|
|
in_info->offset[i] = meta->offset[i];
|
|
in_info->stride[i] = meta->stride[i];
|
|
}
|
|
}
|
|
|
|
/* We cannot have multiple dmabuf per plane */
|
|
if (n_mem > n_planes) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"number of memory (%u) != number of planes (%u)", n_mem, n_planes);
|
|
return FALSE;
|
|
}
|
|
|
|
if (out_caps != dmabuf->out_caps) {
|
|
dmabuf->out_caps = out_caps;
|
|
if (!gst_video_info_from_caps (out_info, out_caps))
|
|
return FALSE;
|
|
|
|
/*
|
|
* When we zero-copy tiles, we need to propagate the strides, which contains
|
|
* the tile dimension. This is because the shader needs to know the padded
|
|
* size in order to correctly sample into these special buffer.
|
|
*/
|
|
if (meta && GST_VIDEO_FORMAT_INFO_IS_TILED (out_info->finfo)) {
|
|
out_info->width = meta->width;
|
|
out_info->height = meta->height;
|
|
|
|
for (i = 0; i < meta->n_planes; i++) {
|
|
out_info->offset[i] = meta->offset[i];
|
|
out_info->stride[i] = meta->stride[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dmabuf->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) dmabuf->params);
|
|
if (!(dmabuf->params = gst_gl_video_allocation_params_new_wrapped_gl_handle
|
|
(dmabuf->upload->context, NULL, out_info, -1, NULL, dmabuf->target,
|
|
0, NULL, NULL, NULL)))
|
|
return FALSE;
|
|
|
|
/* Find and validate all memories */
|
|
for (i = 0; i < n_planes; i++) {
|
|
guint plane_size;
|
|
guint length;
|
|
guint mem_idx;
|
|
gsize mem_skip;
|
|
|
|
if (GST_VIDEO_INFO_FORMAT (in_info) == GST_VIDEO_FORMAT_DMA_DRM)
|
|
plane_size = 1;
|
|
else
|
|
plane_size = gst_gl_get_plane_data_size (in_info, NULL, i);
|
|
|
|
if (!gst_buffer_find_memory (buffer, in_info->offset[i], plane_size,
|
|
&mem_idx, &length, &mem_skip)) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "could not find memory %u", i);
|
|
return FALSE;
|
|
}
|
|
|
|
/* We can't have more then one dmabuf per plane */
|
|
if (length != 1) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "data for plane %u spans %u memories",
|
|
i, length);
|
|
return FALSE;
|
|
}
|
|
|
|
mems[i] = gst_buffer_peek_memory (buffer, mem_idx);
|
|
|
|
/* And all memory found must be dmabuf */
|
|
if (!gst_is_dmabuf_memory (mems[i])) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "memory %u is not dmabuf", i);
|
|
return FALSE;
|
|
}
|
|
|
|
offset[i] = mems[i]->offset + mem_skip;
|
|
fd[i] = gst_dmabuf_memory_get_fd (mems[i]);
|
|
}
|
|
|
|
if (dmabuf->direct) {
|
|
dmabuf->n_mem = 1;
|
|
} else {
|
|
dmabuf->n_mem = n_planes;
|
|
}
|
|
|
|
/* Now create an EGLImage for each dmabuf */
|
|
for (i = 0; i < dmabuf->n_mem; i++) {
|
|
/*
|
|
* Check if an EGLImage is cached. Remember the previous memory and cache
|
|
* entry to avoid repeated lookups if all mems[i] point to the same memory.
|
|
*/
|
|
dmabuf->eglimage[i] = gst_egl_image_cache_lookup (dmabuf->eglimage_cache,
|
|
mems[i], i, &previous_mem, &cache_entry);
|
|
if (dmabuf->eglimage[i]) {
|
|
dmabuf->formats[i] = dmabuf->eglimage[i]->format;
|
|
continue;
|
|
}
|
|
|
|
/* otherwise create one and cache it */
|
|
if (dmabuf->direct) {
|
|
dmabuf->eglimage[i] = gst_egl_image_from_dmabuf_direct_target_with_dma_drm
|
|
(dmabuf->upload->context, n_planes, fd, offset, in_info_drm,
|
|
dmabuf->target);
|
|
} else {
|
|
dmabuf->eglimage[i] = gst_egl_image_from_dmabuf
|
|
(dmabuf->upload->context, fd[i], in_info, i, offset[i]);
|
|
}
|
|
|
|
if (!dmabuf->eglimage[i]) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "could not create eglimage");
|
|
return FALSE;
|
|
}
|
|
|
|
gst_egl_image_cache_store (dmabuf->eglimage_cache, mems[i], i,
|
|
dmabuf->eglimage[i], &cache_entry);
|
|
dmabuf->formats[i] = dmabuf->eglimage[i]->format;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_dma_buf_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
/* nothing to do for now. */
|
|
}
|
|
|
|
static void
|
|
_dma_buf_upload_perform_gl_thread (GstGLContext * context,
|
|
struct DmabufUpload *dmabuf)
|
|
{
|
|
GstGLMemoryAllocator *allocator;
|
|
|
|
allocator =
|
|
GST_GL_MEMORY_ALLOCATOR (gst_allocator_find
|
|
(GST_GL_MEMORY_EGL_ALLOCATOR_NAME));
|
|
|
|
/* FIXME: buffer pool */
|
|
dmabuf->outbuf = gst_buffer_new ();
|
|
gst_gl_memory_setup_buffer (allocator, dmabuf->outbuf, dmabuf->params,
|
|
dmabuf->formats, (gpointer *) dmabuf->eglimage, dmabuf->n_mem);
|
|
gst_object_unref (allocator);
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_dma_buf_upload_perform (gpointer impl, GstBuffer * buffer, GstBuffer ** outbuf)
|
|
{
|
|
struct DmabufUpload *dmabuf = impl;
|
|
|
|
/* The direct path sets sinkpad caps to RGBA but this may be incorrect for
|
|
* the non-direct path, if that path fails to accept. In that case, we need
|
|
* to reconfigure.
|
|
*/
|
|
if (!dmabuf->direct &&
|
|
GST_VIDEO_INFO_FORMAT (&dmabuf->upload->priv->in_info) !=
|
|
GST_VIDEO_INFO_FORMAT (&dmabuf->out_info))
|
|
return GST_GL_UPLOAD_RECONFIGURE;
|
|
|
|
gst_gl_context_thread_add (dmabuf->upload->context,
|
|
(GstGLContextThreadFunc) _dma_buf_upload_perform_gl_thread, dmabuf);
|
|
|
|
if (!dmabuf->outbuf)
|
|
return GST_GL_UPLOAD_ERROR;
|
|
|
|
gst_buffer_add_parent_buffer_meta (dmabuf->outbuf, buffer);
|
|
|
|
*outbuf = dmabuf->outbuf;
|
|
dmabuf->outbuf = NULL;
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_dma_buf_upload_free (gpointer impl)
|
|
{
|
|
struct DmabufUpload *dmabuf = impl;
|
|
|
|
if (dmabuf->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) dmabuf->params);
|
|
gst_egl_image_cache_unref (dmabuf->eglimage_cache);
|
|
|
|
g_free (impl);
|
|
}
|
|
|
|
static const UploadMethod _dma_buf_upload = {
|
|
"Dmabuf",
|
|
0,
|
|
&_dma_buf_upload_caps,
|
|
&_dma_buf_upload_new,
|
|
&_dma_buf_upload_transform_caps,
|
|
&_dma_buf_upload_accept,
|
|
&_dma_buf_upload_propose_allocation,
|
|
&_dma_buf_upload_perform,
|
|
&_dma_buf_upload_free
|
|
};
|
|
|
|
/* a variant of the DMABuf uploader that relies on HW color conversion instead
|
|
* of shaders */
|
|
|
|
static gpointer
|
|
_direct_dma_buf_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct DmabufUpload *dmabuf = _dma_buf_upload_new (upload);
|
|
dmabuf->direct = TRUE;
|
|
gst_video_info_init (&dmabuf->out_info);
|
|
return dmabuf;
|
|
}
|
|
|
|
static GstCaps *
|
|
_direct_dma_buf_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
struct DmabufUpload *dmabuf = impl;
|
|
GstCaps *ret, *tmp;
|
|
GstGLUploadDrmFormatFlags flags = 0;
|
|
|
|
if (dmabuf->target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES)
|
|
flags |= INCLUDE_EXTERNAL;
|
|
|
|
if (context) {
|
|
const GstGLFuncs *gl = context->gl_vtable;
|
|
|
|
if (!gl->EGLImageTargetTexture2D)
|
|
return NULL;
|
|
|
|
/* Don't propose direct DMABuf caps feature unless it can be supported */
|
|
if (gst_gl_context_get_gl_platform (context) != GST_GL_PLATFORM_EGL)
|
|
return NULL;
|
|
|
|
if (dmabuf->target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES &&
|
|
!gst_gl_context_check_feature (context, "GL_OES_EGL_image_external"))
|
|
return NULL;
|
|
|
|
if (!gst_gl_context_egl_supports_modifier (context))
|
|
return NULL;
|
|
}
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
gint i, n;
|
|
GstGLTextureTarget target_mask;
|
|
|
|
ret = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_DMABUF,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY);
|
|
tmp = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY);
|
|
if (!ret) {
|
|
ret = tmp;
|
|
tmp = NULL;
|
|
}
|
|
if (tmp)
|
|
ret = gst_caps_merge (ret, tmp);
|
|
|
|
if (!ret) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"direction %s, fails to transformed DMA caps %" GST_PTR_FORMAT,
|
|
"sink", caps);
|
|
return NULL;
|
|
}
|
|
|
|
/* The direct mode, sampling an imported texture will return an RGBA
|
|
vector in the same colorspace as the source image. If the source
|
|
image is stored in YUV(or some other basis) then the YUV values will
|
|
be transformed to RGB values. So, any input format is transformed to:
|
|
"video/x-raw(memory:GLMemory), format=(string)RGBA" as output. */
|
|
gst_caps_set_simple (ret, "format", G_TYPE_STRING, "RGBA", NULL);
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "chroma-site", NULL);
|
|
gst_structure_remove_fields (s, "colorimetry", NULL);
|
|
}
|
|
|
|
target_mask = 1 << dmabuf->target;
|
|
tmp = _caps_intersect_texture_target (ret, target_mask);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
GstCaps *tmp_caps;
|
|
|
|
/* The src caps may only contain RGBA format, and we should list
|
|
all possible supported formats to detect the conversion for
|
|
DMABuf kind memory. */
|
|
tmp_caps = gst_caps_copy (caps);
|
|
for (i = 0; i < gst_caps_get_size (tmp_caps); i++)
|
|
_set_default_formats_list (gst_caps_get_structure (tmp_caps, i));
|
|
|
|
ret = _dma_buf_upload_transform_caps_common (tmp_caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_GL_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_DMABUF);
|
|
gst_caps_unref (tmp_caps);
|
|
|
|
tmp = _dma_buf_upload_transform_caps_common (caps, context, direction,
|
|
flags, 1 << dmabuf->target, GST_CAPS_FEATURE_MEMORY_GL_MEMORY,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
|
|
if (!ret) {
|
|
ret = tmp;
|
|
tmp = NULL;
|
|
}
|
|
if (tmp)
|
|
ret = gst_caps_merge (ret, tmp);
|
|
|
|
if (!ret) {
|
|
GST_DEBUG_OBJECT (dmabuf->upload,
|
|
"direction %s, fails to transformed DMA caps %" GST_PTR_FORMAT,
|
|
"src", caps);
|
|
return NULL;
|
|
}
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (dmabuf->upload, "direction %s, transformed %"
|
|
GST_PTR_FORMAT " into %" GST_PTR_FORMAT,
|
|
direction == GST_PAD_SRC ? "src" : "sink", caps, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const UploadMethod _direct_dma_buf_upload = {
|
|
"DirectDmabuf",
|
|
0,
|
|
&_dma_buf_upload_caps,
|
|
&_direct_dma_buf_upload_new,
|
|
&_direct_dma_buf_upload_transform_caps,
|
|
&_dma_buf_upload_accept,
|
|
&_dma_buf_upload_propose_allocation,
|
|
&_dma_buf_upload_perform,
|
|
&_dma_buf_upload_free
|
|
};
|
|
|
|
/* a variant of the direct DMABuf uploader that uses external OES textures */
|
|
|
|
static gpointer
|
|
_direct_dma_buf_external_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct DmabufUpload *dmabuf = _direct_dma_buf_upload_new (upload);
|
|
dmabuf->target = GST_GL_TEXTURE_TARGET_EXTERNAL_OES;
|
|
return dmabuf;
|
|
}
|
|
|
|
static const UploadMethod _direct_dma_buf_external_upload = {
|
|
"DirectDmabufExternal",
|
|
0,
|
|
&_dma_buf_upload_caps,
|
|
&_direct_dma_buf_external_upload_new,
|
|
&_direct_dma_buf_upload_transform_caps,
|
|
&_dma_buf_upload_accept,
|
|
&_dma_buf_upload_propose_allocation,
|
|
&_dma_buf_upload_perform,
|
|
&_dma_buf_upload_free
|
|
};
|
|
|
|
#endif /* GST_GL_HAVE_DMABUF */
|
|
|
|
struct GLUploadMeta
|
|
{
|
|
GstGLUpload *upload;
|
|
|
|
gboolean result;
|
|
GstVideoGLTextureUploadMeta *meta;
|
|
guint texture_ids[GST_GL_UPLOAD_MAX_PLANES];
|
|
GstBufferPool *pool;
|
|
};
|
|
|
|
static gpointer
|
|
_upload_meta_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct GLUploadMeta *meta = g_new0 (struct GLUploadMeta, 1);
|
|
|
|
meta->upload = upload;
|
|
meta->pool = NULL;
|
|
|
|
return meta;
|
|
}
|
|
|
|
static GstCaps *
|
|
_upload_meta_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
GstCapsFeatures *passthrough =
|
|
gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
GstCapsFeatures *filter_features;
|
|
GstCaps *ret;
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstCaps *tmp;
|
|
|
|
filter_features = gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META);
|
|
if (!_filter_caps_with_features (caps, filter_features, &tmp)) {
|
|
gst_caps_features_free (filter_features);
|
|
gst_caps_features_free (passthrough);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (filter_features);
|
|
|
|
ret = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
gst_caps_unref (tmp);
|
|
|
|
tmp = _caps_intersect_texture_target (ret, 1 << GST_GL_TEXTURE_TARGET_2D);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
|
|
ret =
|
|
_set_caps_features_with_passthrough (caps,
|
|
GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, passthrough);
|
|
gst_caps_set_simple (ret, "format", G_TYPE_STRING, "RGBA", NULL);
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
gst_caps_features_free (passthrough);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_upload_meta_upload_accept (gpointer impl, GstBuffer * buffer,
|
|
GstCaps * in_caps, GstCaps * out_caps)
|
|
{
|
|
struct GLUploadMeta *upload = impl;
|
|
GstCapsFeatures *features;
|
|
GstVideoGLTextureUploadMeta *meta;
|
|
gboolean ret = TRUE;
|
|
GstStructure *config;
|
|
gsize size;
|
|
|
|
features = gst_caps_get_features (in_caps, 0);
|
|
|
|
if (!gst_caps_features_contains (features,
|
|
GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META))
|
|
ret = FALSE;
|
|
|
|
features = gst_caps_get_features (out_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_GL_MEMORY))
|
|
ret = FALSE;
|
|
|
|
if (!ret)
|
|
return ret;
|
|
|
|
if (upload->pool == NULL)
|
|
upload->pool = gst_gl_buffer_pool_new (upload->upload->context);
|
|
|
|
if (!gst_buffer_pool_is_active (upload->pool)) {
|
|
config = gst_buffer_pool_get_config (upload->pool);
|
|
|
|
size = upload->upload->priv->in_info.size;
|
|
gst_buffer_pool_config_set_params (config, in_caps, size, 0, 0);
|
|
|
|
if (!gst_buffer_pool_set_config (upload->pool, config)) {
|
|
GST_WARNING_OBJECT (upload->upload, "failed to set bufferpool config");
|
|
return FALSE;
|
|
}
|
|
gst_buffer_pool_set_active (upload->pool, TRUE);
|
|
}
|
|
|
|
if (buffer) {
|
|
if ((meta = gst_buffer_get_video_gl_texture_upload_meta (buffer)) == NULL)
|
|
return FALSE;
|
|
|
|
if (meta->texture_type[0] != GST_VIDEO_GL_TEXTURE_TYPE_RGBA) {
|
|
GST_FIXME_OBJECT (upload, "only single rgba texture supported");
|
|
return FALSE;
|
|
}
|
|
|
|
if (meta->texture_orientation !=
|
|
GST_VIDEO_GL_TEXTURE_ORIENTATION_X_NORMAL_Y_NORMAL) {
|
|
GST_FIXME_OBJECT (upload, "only x-normal, y-normal textures supported");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_upload_meta_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
struct GLUploadMeta *upload = impl;
|
|
GstStructure *gl_context;
|
|
gchar *platform, *gl_apis;
|
|
gpointer handle;
|
|
|
|
gl_apis =
|
|
gst_gl_api_to_string (gst_gl_context_get_gl_api (upload->upload->
|
|
context));
|
|
platform =
|
|
gst_gl_platform_to_string (gst_gl_context_get_gl_platform (upload->
|
|
upload->context));
|
|
handle = (gpointer) gst_gl_context_get_gl_context (upload->upload->context);
|
|
|
|
gl_context =
|
|
gst_structure_new ("GstVideoGLTextureUploadMeta", "gst.gl.GstGLContext",
|
|
GST_TYPE_GL_CONTEXT, upload->upload->context, "gst.gl.context.handle",
|
|
G_TYPE_POINTER, handle, "gst.gl.context.type", G_TYPE_STRING, platform,
|
|
"gst.gl.context.apis", G_TYPE_STRING, gl_apis, NULL);
|
|
gst_query_add_allocation_meta (query,
|
|
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, gl_context);
|
|
|
|
g_free (gl_apis);
|
|
g_free (platform);
|
|
gst_structure_free (gl_context);
|
|
}
|
|
|
|
/*
|
|
* Uploads using gst_video_gl_texture_upload_meta_upload().
|
|
* i.e. consumer of GstVideoGLTextureUploadMeta
|
|
*/
|
|
static void
|
|
_do_upload_with_meta (GstGLContext * context, struct GLUploadMeta *upload)
|
|
{
|
|
if (!gst_video_gl_texture_upload_meta_upload (upload->meta,
|
|
upload->texture_ids)) {
|
|
upload->result = FALSE;
|
|
return;
|
|
}
|
|
|
|
upload->result = TRUE;
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_upload_meta_upload_perform (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
struct GLUploadMeta *upload = impl;
|
|
int i;
|
|
GstVideoInfo *in_info = &upload->upload->priv->in_info;
|
|
guint max_planes = GST_VIDEO_INFO_N_PLANES (in_info);
|
|
|
|
/* Support stereo views for separated multiview mode */
|
|
if (GST_VIDEO_INFO_MULTIVIEW_MODE (in_info) ==
|
|
GST_VIDEO_MULTIVIEW_MODE_SEPARATED)
|
|
max_planes *= GST_VIDEO_INFO_VIEWS (in_info);
|
|
|
|
GST_LOG_OBJECT (upload, "Attempting upload with GstVideoGLTextureUploadMeta");
|
|
|
|
upload->meta = gst_buffer_get_video_gl_texture_upload_meta (buffer);
|
|
|
|
if (gst_buffer_pool_acquire_buffer (upload->pool, outbuf,
|
|
NULL) != GST_FLOW_OK) {
|
|
GST_WARNING_OBJECT (upload, "failed to acquire buffer from bufferpool");
|
|
return GST_GL_UPLOAD_ERROR;
|
|
}
|
|
|
|
for (i = 0; i < GST_GL_UPLOAD_MAX_PLANES; i++) {
|
|
guint tex_id = 0;
|
|
|
|
if (i < max_planes) {
|
|
GstMemory *mem = gst_buffer_peek_memory (*outbuf, i);
|
|
tex_id = ((GstGLMemory *) mem)->tex_id;
|
|
}
|
|
|
|
upload->texture_ids[i] = tex_id;
|
|
}
|
|
|
|
GST_LOG ("Uploading with GLTextureUploadMeta with textures "
|
|
"%i,%i,%i,%i / %i,%i,%i,%i",
|
|
upload->texture_ids[0], upload->texture_ids[1],
|
|
upload->texture_ids[2], upload->texture_ids[3],
|
|
upload->texture_ids[4], upload->texture_ids[5],
|
|
upload->texture_ids[6], upload->texture_ids[7]);
|
|
|
|
gst_gl_context_thread_add (upload->upload->context,
|
|
(GstGLContextThreadFunc) _do_upload_with_meta, upload);
|
|
|
|
if (!upload->result)
|
|
return GST_GL_UPLOAD_ERROR;
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_upload_meta_upload_free (gpointer impl)
|
|
{
|
|
struct GLUploadMeta *upload = impl;
|
|
|
|
g_return_if_fail (impl != NULL);
|
|
|
|
if (upload->pool)
|
|
gst_object_unref (upload->pool);
|
|
|
|
g_free (upload);
|
|
}
|
|
|
|
static GstStaticCaps _upload_meta_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, "RGBA"));
|
|
|
|
static const UploadMethod _upload_meta_upload = {
|
|
"UploadMeta",
|
|
METHOD_FLAG_CAN_SHARE_CONTEXT,
|
|
&_upload_meta_upload_caps,
|
|
&_upload_meta_upload_new,
|
|
&_upload_meta_upload_transform_caps,
|
|
&_upload_meta_upload_accept,
|
|
&_upload_meta_upload_propose_allocation,
|
|
&_upload_meta_upload_perform,
|
|
&_upload_meta_upload_free
|
|
};
|
|
|
|
struct RawUploadFrame
|
|
{
|
|
gint ref_count;
|
|
GstVideoFrame frame;
|
|
};
|
|
|
|
struct RawUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
struct RawUploadFrame *in_frame;
|
|
GstGLVideoAllocationParams *params;
|
|
};
|
|
|
|
static struct RawUploadFrame *
|
|
_raw_upload_frame_new (struct RawUpload *raw, GstBuffer * buffer)
|
|
{
|
|
struct RawUploadFrame *frame;
|
|
GstVideoInfo *info;
|
|
gint i;
|
|
|
|
if (!buffer)
|
|
return NULL;
|
|
|
|
frame = g_new (struct RawUploadFrame, 1);
|
|
frame->ref_count = 1;
|
|
|
|
if (!gst_video_frame_map (&frame->frame, &raw->upload->priv->in_info,
|
|
buffer, GST_MAP_READ)) {
|
|
g_free (frame);
|
|
return NULL;
|
|
}
|
|
|
|
raw->upload->priv->in_info = frame->frame.info;
|
|
info = &raw->upload->priv->in_info;
|
|
|
|
/* Recalculate the offsets (and size) */
|
|
info->size = 0;
|
|
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
|
|
info->offset[i] = info->size;
|
|
info->size += gst_gl_get_plane_data_size (info, NULL, i);
|
|
}
|
|
|
|
return frame;
|
|
}
|
|
|
|
static void
|
|
_raw_upload_frame_ref (struct RawUploadFrame *frame)
|
|
{
|
|
g_atomic_int_inc (&frame->ref_count);
|
|
}
|
|
|
|
static void
|
|
_raw_upload_frame_unref (struct RawUploadFrame *frame)
|
|
{
|
|
if (g_atomic_int_dec_and_test (&frame->ref_count)) {
|
|
gst_video_frame_unmap (&frame->frame);
|
|
g_free (frame);
|
|
}
|
|
}
|
|
|
|
static gpointer
|
|
_raw_data_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct RawUpload *raw = g_new0 (struct RawUpload, 1);
|
|
|
|
raw->upload = upload;
|
|
|
|
return raw;
|
|
}
|
|
|
|
static GstCaps *
|
|
_raw_data_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
GstCapsFeatures *passthrough =
|
|
gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
GstCaps *ret;
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstGLTextureTarget target_mask = 0;
|
|
GstCapsFeatures *filter_features;
|
|
GstCaps *tmp;
|
|
|
|
filter_features =
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
if (!_filter_caps_with_features (caps, filter_features, &tmp)) {
|
|
gst_caps_features_free (filter_features);
|
|
gst_caps_features_free (passthrough);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (filter_features);
|
|
|
|
ret = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
gst_caps_unref (tmp);
|
|
|
|
target_mask |= 1 << GST_GL_TEXTURE_TARGET_2D;
|
|
target_mask |= 1 << GST_GL_TEXTURE_TARGET_RECTANGLE;
|
|
tmp = _caps_intersect_texture_target (ret, target_mask);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
|
|
ret =
|
|
_set_caps_features_with_passthrough (caps,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, passthrough);
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
gst_caps_features_free (passthrough);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_raw_data_upload_accept (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
struct RawUpload *raw = impl;
|
|
GstCapsFeatures *features;
|
|
|
|
features =
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
/* Also consider the omited system memory feature cases, such as
|
|
video/x-raw(meta:GstVideoOverlayComposition) */
|
|
if (!_filter_caps_with_features (in_caps, features, NULL)) {
|
|
gst_caps_features_free (features);
|
|
return FALSE;
|
|
}
|
|
gst_caps_features_free (features);
|
|
|
|
features = gst_caps_get_features (out_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_GL_MEMORY))
|
|
return FALSE;
|
|
|
|
if (raw->in_frame)
|
|
_raw_upload_frame_unref (raw->in_frame);
|
|
raw->in_frame = _raw_upload_frame_new (raw, buffer);
|
|
|
|
if (raw->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) raw->params);
|
|
if (!(raw->params =
|
|
gst_gl_video_allocation_params_new_wrapped_data (raw->upload->context,
|
|
NULL, &raw->upload->priv->in_info, -1, NULL,
|
|
GST_GL_TEXTURE_TARGET_2D, 0, NULL, raw->in_frame,
|
|
(GDestroyNotify) _raw_upload_frame_unref)))
|
|
return FALSE;
|
|
|
|
return (raw->in_frame != NULL);
|
|
}
|
|
|
|
static void
|
|
_raw_data_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0);
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_raw_data_upload_perform (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
GstGLBaseMemoryAllocator *allocator;
|
|
struct RawUpload *raw = impl;
|
|
int i;
|
|
GstVideoInfo *in_info = &raw->upload->priv->in_info;
|
|
guint n_mem = GST_VIDEO_INFO_N_PLANES (in_info);
|
|
|
|
allocator =
|
|
GST_GL_BASE_MEMORY_ALLOCATOR (gst_gl_memory_allocator_get_default
|
|
(raw->upload->context));
|
|
|
|
/* FIXME Use a buffer pool to cache the generated textures */
|
|
*outbuf = gst_buffer_new ();
|
|
raw->params->parent.context = raw->upload->context;
|
|
if (gst_gl_memory_setup_buffer ((GstGLMemoryAllocator *) allocator, *outbuf,
|
|
raw->params, NULL, raw->in_frame->frame.data, n_mem)) {
|
|
|
|
for (i = 0; i < n_mem; i++)
|
|
_raw_upload_frame_ref (raw->in_frame);
|
|
gst_buffer_add_gl_sync_meta (raw->upload->context, *outbuf);
|
|
} else {
|
|
GST_ERROR_OBJECT (raw->upload, "Failed to allocate wrapped texture");
|
|
gst_buffer_unref (*outbuf);
|
|
gst_object_unref (allocator);
|
|
return GST_GL_UPLOAD_ERROR;
|
|
}
|
|
gst_object_unref (allocator);
|
|
_raw_upload_frame_unref (raw->in_frame);
|
|
raw->in_frame = NULL;
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_raw_data_upload_free (gpointer impl)
|
|
{
|
|
struct RawUpload *raw = impl;
|
|
|
|
if (raw->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) raw->params);
|
|
|
|
g_free (raw);
|
|
}
|
|
|
|
static GstStaticCaps _raw_data_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (GST_GL_MEMORY_VIDEO_FORMATS_STR));
|
|
|
|
static const UploadMethod _raw_data_upload = {
|
|
"Raw Data",
|
|
0,
|
|
&_raw_data_upload_caps,
|
|
&_raw_data_upload_new,
|
|
&_raw_data_upload_transform_caps,
|
|
&_raw_data_upload_accept,
|
|
&_raw_data_upload_propose_allocation,
|
|
&_raw_data_upload_perform,
|
|
&_raw_data_upload_free
|
|
};
|
|
|
|
#if GST_GL_HAVE_VIV_DIRECTVIV
|
|
#ifndef GL_BGRA_EXT
|
|
#define GL_BGRA_EXT 0x80E1
|
|
#endif
|
|
#ifndef GL_VIV_YV12
|
|
#define GL_VIV_YV12 0x8FC0
|
|
#endif
|
|
#ifndef GL_VIV_NV12
|
|
#define GL_VIV_NV12 0x8FC1
|
|
#endif
|
|
#ifndef GL_VIV_YUY2
|
|
#define GL_VIV_YUY2 0x8FC2
|
|
#endif
|
|
#ifndef GL_VIV_UYVY
|
|
#define GL_VIV_UYVY 0x8FC3
|
|
#endif
|
|
#ifndef GL_VIV_NV21
|
|
#define GL_VIV_NV21 0x8FC4
|
|
#endif
|
|
#ifndef GL_VIV_I420
|
|
#define GL_VIV_I420 0x8FC5
|
|
#endif
|
|
|
|
struct DirectVIVUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
|
|
GstGLVideoAllocationParams *params;
|
|
GstBuffer *inbuf, *outbuf;
|
|
void (*TexDirectVIVMap) (GLenum Target, GLsizei Width, GLsizei Height,
|
|
GLenum Format, GLvoid ** Logical, const GLuint * Physical);
|
|
void (*TexDirectInvalidateVIV) (GLenum Target);
|
|
gboolean loaded_functions;
|
|
};
|
|
|
|
#define GST_GL_DIRECTVIV_FORMAT "{RGBA, I420, YV12, NV12, NV21, YUY2, UYVY, BGRA, RGB16}"
|
|
|
|
static GstStaticCaps _directviv_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (GST_GL_DIRECTVIV_FORMAT));
|
|
|
|
static gpointer
|
|
_directviv_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct DirectVIVUpload *directviv = g_new0 (struct DirectVIVUpload, 1);
|
|
directviv->upload = upload;
|
|
directviv->loaded_functions = FALSE;
|
|
|
|
return directviv;
|
|
}
|
|
|
|
static GstCaps *
|
|
_directviv_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
GstCapsFeatures *passthrough =
|
|
gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
GstCaps *ret;
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstCaps *tmp;
|
|
GstCapsFeatures *filter_features;
|
|
|
|
filter_features =
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
if (!_filter_caps_with_features (caps, filter_features, &tmp)) {
|
|
gst_caps_features_free (filter_features);
|
|
gst_caps_features_free (passthrough);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (filter_features);
|
|
|
|
ret = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
gst_caps_unref (tmp);
|
|
|
|
gst_caps_set_simple (ret, "format", G_TYPE_STRING, "RGBA", NULL);
|
|
tmp = _caps_intersect_texture_target (ret, 1 << GST_GL_TEXTURE_TARGET_2D);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
ret = gst_caps_from_string (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
|
|
(GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, GST_GL_DIRECTVIV_FORMAT));
|
|
}
|
|
|
|
gst_caps_features_free (passthrough);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
_directviv_upload_load_functions_gl_thread (GstGLContext * context,
|
|
struct DirectVIVUpload *directviv)
|
|
{
|
|
directviv->TexDirectVIVMap =
|
|
gst_gl_context_get_proc_address (context, "glTexDirectVIVMap");
|
|
directviv->TexDirectInvalidateVIV =
|
|
gst_gl_context_get_proc_address (context, "glTexDirectInvalidateVIV");
|
|
}
|
|
|
|
static gboolean
|
|
_directviv_upload_accept (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
struct DirectVIVUpload *directviv = impl;
|
|
GstCapsFeatures *features;
|
|
guint n_mem;
|
|
GstMemory *mem;
|
|
|
|
if (!directviv->loaded_functions && (!directviv->TexDirectInvalidateVIV ||
|
|
!directviv->TexDirectVIVMap)) {
|
|
gst_gl_context_thread_add (directviv->upload->context,
|
|
(GstGLContextThreadFunc) _directviv_upload_load_functions_gl_thread,
|
|
directviv);
|
|
directviv->loaded_functions = TRUE;
|
|
}
|
|
if (!directviv->TexDirectInvalidateVIV || !directviv->TexDirectVIVMap)
|
|
return FALSE;
|
|
|
|
features =
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
|
|
/* Also consider the omited system memory feature cases, such as
|
|
video/x-raw(meta:GstVideoOverlayComposition) */
|
|
if (!_filter_caps_with_features (in_caps, features, NULL)) {
|
|
gst_caps_features_free (features);
|
|
return FALSE;
|
|
}
|
|
gst_caps_features_free (features);
|
|
|
|
features = gst_caps_get_features (out_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_GL_MEMORY))
|
|
return FALSE;
|
|
|
|
if (directviv->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) directviv->params);
|
|
if (!(directviv->params =
|
|
gst_gl_video_allocation_params_new (directviv->upload->context, NULL,
|
|
&directviv->upload->priv->out_info, -1, NULL,
|
|
GST_GL_TEXTURE_TARGET_2D, GST_VIDEO_GL_TEXTURE_TYPE_RGBA)))
|
|
return FALSE;
|
|
|
|
/* We only support a single memory per buffer at this point */
|
|
n_mem = gst_buffer_n_memory (buffer);
|
|
if (n_mem == 1) {
|
|
mem = gst_buffer_peek_memory (buffer, 0);
|
|
} else {
|
|
mem = NULL;
|
|
}
|
|
|
|
return n_mem == 1 && mem && gst_is_phys_memory (mem);
|
|
}
|
|
|
|
static void
|
|
_directviv_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
}
|
|
|
|
static GLenum
|
|
_directviv_upload_video_format_to_gl_format (GstVideoFormat format)
|
|
{
|
|
switch (format) {
|
|
case GST_VIDEO_FORMAT_I420:
|
|
return GL_VIV_I420;
|
|
case GST_VIDEO_FORMAT_YV12:
|
|
return GL_VIV_YV12;
|
|
case GST_VIDEO_FORMAT_NV12:
|
|
return GL_VIV_NV12;
|
|
case GST_VIDEO_FORMAT_NV21:
|
|
return GL_VIV_NV21;
|
|
case GST_VIDEO_FORMAT_YUY2:
|
|
return GL_VIV_YUY2;
|
|
case GST_VIDEO_FORMAT_UYVY:
|
|
return GL_VIV_UYVY;
|
|
case GST_VIDEO_FORMAT_RGB16:
|
|
return GL_RGB565;
|
|
case GST_VIDEO_FORMAT_RGBA:
|
|
return GL_RGBA;
|
|
case GST_VIDEO_FORMAT_BGRA:
|
|
return GL_BGRA_EXT;
|
|
case GST_VIDEO_FORMAT_RGBx:
|
|
return GL_RGBA;
|
|
case GST_VIDEO_FORMAT_BGRx:
|
|
return GL_BGRA_EXT;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
GstBuffer *buffer;
|
|
GstMemory *memory;
|
|
GstMapInfo map;
|
|
guintptr phys_addr;
|
|
} DirectVIVUnmapData;
|
|
|
|
static void
|
|
_directviv_memory_unmap (DirectVIVUnmapData * data)
|
|
{
|
|
gst_memory_unmap (data->memory, &data->map);
|
|
gst_memory_unref (data->memory);
|
|
gst_buffer_unref (data->buffer);
|
|
g_free (data);
|
|
}
|
|
|
|
static void
|
|
_directviv_upload_perform_gl_thread (GstGLContext * context,
|
|
struct DirectVIVUpload *directviv)
|
|
{
|
|
static GQuark directviv_unmap_quark = 0;
|
|
GstGLMemoryAllocator *allocator;
|
|
GstMemory *in_mem;
|
|
GstGLMemory *out_gl_mem;
|
|
GstVideoInfo *in_info;
|
|
DirectVIVUnmapData *unmap_data;
|
|
GstVideoMeta *vmeta;
|
|
gint width, height, gl_format;
|
|
const GstGLFuncs *gl;
|
|
|
|
if (!directviv_unmap_quark)
|
|
directviv_unmap_quark = g_quark_from_static_string ("GstGLDirectVIVUnmap");
|
|
|
|
gl = context->gl_vtable;
|
|
|
|
g_assert (gst_buffer_n_memory (directviv->inbuf) == 1);
|
|
in_info = &directviv->upload->priv->in_info;
|
|
in_mem = gst_buffer_peek_memory (directviv->inbuf, 0);
|
|
unmap_data = g_new0 (DirectVIVUnmapData, 1);
|
|
if (!gst_memory_map (in_mem, &unmap_data->map, GST_MAP_READ)) {
|
|
g_free (unmap_data);
|
|
return;
|
|
}
|
|
unmap_data->phys_addr = gst_phys_memory_get_phys_addr (in_mem);
|
|
if (!unmap_data->phys_addr) {
|
|
gst_memory_unmap (in_mem, &unmap_data->map);
|
|
g_free (unmap_data);
|
|
return;
|
|
}
|
|
unmap_data->memory = gst_memory_ref (in_mem);
|
|
unmap_data->buffer = gst_buffer_ref (directviv->inbuf);
|
|
|
|
allocator =
|
|
GST_GL_MEMORY_ALLOCATOR (gst_allocator_find
|
|
(GST_GL_MEMORY_PBO_ALLOCATOR_NAME));
|
|
|
|
/* FIXME: buffer pool */
|
|
directviv->outbuf = gst_buffer_new ();
|
|
gst_gl_memory_setup_buffer (allocator, directviv->outbuf, directviv->params,
|
|
NULL, NULL, 0);
|
|
gst_object_unref (allocator);
|
|
|
|
out_gl_mem = (GstGLMemory *) gst_buffer_peek_memory (directviv->outbuf, 0);
|
|
|
|
/* Need to keep the input memory and buffer mapped and valid until
|
|
* the GL memory is not used anymore */
|
|
gst_mini_object_set_qdata ((GstMiniObject *) out_gl_mem,
|
|
directviv_unmap_quark, unmap_data,
|
|
(GDestroyNotify) _directviv_memory_unmap);
|
|
gst_buffer_add_parent_buffer_meta (directviv->outbuf, directviv->inbuf);
|
|
|
|
/* width/height need to compensate for stride/padding */
|
|
vmeta = gst_buffer_get_video_meta (directviv->inbuf);
|
|
if (vmeta) {
|
|
width = vmeta->stride[0];
|
|
if (GST_VIDEO_INFO_N_PLANES (in_info) == 1)
|
|
height = gst_memory_get_sizes (in_mem, NULL, NULL) / width;
|
|
else
|
|
height = vmeta->offset[1] / width;
|
|
} else {
|
|
width = GST_VIDEO_INFO_PLANE_STRIDE (in_info, 0);
|
|
if (GST_VIDEO_INFO_N_PLANES (in_info) == 1)
|
|
height = gst_memory_get_sizes (in_mem, NULL, NULL) / width;
|
|
else
|
|
height = GST_VIDEO_INFO_PLANE_OFFSET (in_info, 1) / width;
|
|
}
|
|
width /= GST_VIDEO_INFO_COMP_PSTRIDE (in_info, 0);
|
|
|
|
gl_format =
|
|
_directviv_upload_video_format_to_gl_format (GST_VIDEO_INFO_FORMAT
|
|
(in_info));
|
|
|
|
gl->BindTexture (GL_TEXTURE_2D, out_gl_mem->tex_id);
|
|
directviv->TexDirectVIVMap (GL_TEXTURE_2D, width, height,
|
|
gl_format, (void **) &unmap_data->map.data,
|
|
(GLuint *) & unmap_data->phys_addr);
|
|
directviv->TexDirectInvalidateVIV (GL_TEXTURE_2D);
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_directviv_upload_perform (gpointer impl, GstBuffer * buffer,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
struct DirectVIVUpload *directviv = impl;
|
|
|
|
directviv->inbuf = buffer;
|
|
directviv->outbuf = NULL;
|
|
gst_gl_context_thread_add (directviv->upload->context,
|
|
(GstGLContextThreadFunc) _directviv_upload_perform_gl_thread, directviv);
|
|
directviv->inbuf = NULL;
|
|
|
|
if (!directviv->outbuf)
|
|
return GST_GL_UPLOAD_ERROR;
|
|
|
|
*outbuf = directviv->outbuf;
|
|
directviv->outbuf = NULL;
|
|
|
|
return GST_GL_UPLOAD_DONE;
|
|
}
|
|
|
|
static void
|
|
_directviv_upload_free (gpointer impl)
|
|
{
|
|
struct DirectVIVUpload *directviv = impl;
|
|
|
|
if (directviv->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) directviv->params);
|
|
|
|
g_free (impl);
|
|
}
|
|
|
|
static const UploadMethod _directviv_upload = {
|
|
"DirectVIV",
|
|
0,
|
|
&_directviv_upload_caps,
|
|
&_directviv_upload_new,
|
|
&_directviv_upload_transform_caps,
|
|
&_directviv_upload_accept,
|
|
&_directviv_upload_propose_allocation,
|
|
&_directviv_upload_perform,
|
|
&_directviv_upload_free
|
|
};
|
|
|
|
#endif /* GST_GL_HAVE_VIV_DIRECTVIV */
|
|
|
|
#if defined(HAVE_NVMM)
|
|
#include "nvbuf_utils.h"
|
|
|
|
struct NVMMUpload
|
|
{
|
|
GstGLUpload *upload;
|
|
|
|
GstGLVideoAllocationParams *params;
|
|
guint n_mem;
|
|
|
|
GstGLTextureTarget target;
|
|
GstVideoInfo out_info;
|
|
/* only used for pointer comparison */
|
|
gpointer out_caps;
|
|
};
|
|
|
|
#define GST_CAPS_FEATURE_MEMORY_NVMM "memory:NVMM"
|
|
|
|
/* FIXME: other formats? */
|
|
static GstStaticCaps _nvmm_upload_caps =
|
|
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
|
|
(GST_CAPS_FEATURE_MEMORY_NVMM,
|
|
"RGBA"));
|
|
|
|
static gpointer
|
|
_nvmm_upload_new (GstGLUpload * upload)
|
|
{
|
|
struct NVMMUpload *nvmm = g_new0 (struct NVMMUpload, 1);
|
|
nvmm->upload = upload;
|
|
nvmm->target = GST_GL_TEXTURE_TARGET_EXTERNAL_OES;
|
|
return nvmm;
|
|
}
|
|
|
|
static GstCaps *
|
|
_nvmm_upload_transform_caps (gpointer impl, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
struct NVMMUpload *nvmm = impl;
|
|
GstCapsFeatures *passthrough;
|
|
GstCaps *ret;
|
|
|
|
if (context) {
|
|
const GstGLFuncs *gl = context->gl_vtable;
|
|
|
|
if (!gl->EGLImageTargetTexture2D)
|
|
return NULL;
|
|
|
|
/* Don't propose NVMM caps feature unless it can be supported */
|
|
if (gst_gl_context_get_gl_platform (context) != GST_GL_PLATFORM_EGL)
|
|
return NULL;
|
|
|
|
if (!gst_gl_context_check_feature (context, "EGL_KHR_image_base"))
|
|
return NULL;
|
|
}
|
|
|
|
passthrough = gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
|
|
if (direction == GST_PAD_SINK) {
|
|
GstCaps *tmp;
|
|
GstCapsFeatures *filter_features;
|
|
|
|
filter_features =
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_NVMM);
|
|
if (!_filter_caps_with_features (caps, filter_features, &tmp)) {
|
|
gst_caps_features_free (filter_features);
|
|
gst_caps_features_free (passthrough);
|
|
return NULL;
|
|
}
|
|
gst_caps_features_free (filter_features);
|
|
|
|
ret = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_GL_MEMORY, passthrough);
|
|
gst_caps_unref (tmp);
|
|
|
|
tmp = _caps_intersect_texture_target (ret,
|
|
1 << GST_GL_TEXTURE_TARGET_EXTERNAL_OES);
|
|
gst_caps_unref (ret);
|
|
ret = tmp;
|
|
} else {
|
|
gint i, n;
|
|
|
|
ret =
|
|
_set_caps_features_with_passthrough (caps,
|
|
GST_CAPS_FEATURE_MEMORY_NVMM, passthrough);
|
|
|
|
n = gst_caps_get_size (ret);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s = gst_caps_get_structure (ret, i);
|
|
|
|
gst_structure_remove_fields (s, "texture-target", NULL);
|
|
}
|
|
}
|
|
|
|
gst_caps_features_free (passthrough);
|
|
|
|
GST_DEBUG_OBJECT (nvmm->upload, "transformed %" GST_PTR_FORMAT " into %"
|
|
GST_PTR_FORMAT, caps, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_nvmm_upload_accept (gpointer impl, GstBuffer * buffer, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
struct NVMMUpload *nvmm = impl;
|
|
GstVideoInfo *in_info = &nvmm->upload->priv->in_info;
|
|
GstVideoInfo *out_info = &nvmm->out_info;
|
|
GstVideoMeta *meta;
|
|
GstMapInfo in_map_info = GST_MAP_INFO_INIT;
|
|
GstCapsFeatures *features;
|
|
guint n_mem;
|
|
guint i;
|
|
|
|
n_mem = gst_buffer_n_memory (buffer);
|
|
if (n_mem != 1) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "NVMM uploader only supports "
|
|
"1 memory, not %u", n_mem);
|
|
return FALSE;
|
|
}
|
|
|
|
meta = gst_buffer_get_video_meta (buffer);
|
|
|
|
if (!nvmm->upload->context->gl_vtable->EGLImageTargetTexture2D)
|
|
return FALSE;
|
|
|
|
/* NVMM upload is only supported with EGL contexts. */
|
|
if (gst_gl_context_get_gl_platform (nvmm->upload->context) !=
|
|
GST_GL_PLATFORM_EGL)
|
|
return FALSE;
|
|
|
|
if (!gst_gl_context_check_feature (nvmm->upload->context,
|
|
"EGL_KHR_image_base"))
|
|
return FALSE;
|
|
|
|
features = gst_caps_get_features (in_caps, 0);
|
|
if (!gst_caps_features_contains (features, GST_CAPS_FEATURE_MEMORY_NVMM))
|
|
return FALSE;
|
|
|
|
if (!gst_buffer_map (buffer, &in_map_info, GST_MAP_READ)) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "Failed to map readonly NvBuffer");
|
|
return FALSE;
|
|
}
|
|
if (in_map_info.size != NvBufferGetSize ()) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "Memory size (%" G_GSIZE_FORMAT ") is "
|
|
"not the same as what NvBuffer advertises (%u)", in_map_info.size,
|
|
NvBufferGetSize ());
|
|
gst_buffer_unmap (buffer, &in_map_info);
|
|
return FALSE;
|
|
}
|
|
gst_buffer_unmap (buffer, &in_map_info);
|
|
|
|
/* Update video info based on video meta */
|
|
if (meta) {
|
|
in_info->width = meta->width;
|
|
in_info->height = meta->height;
|
|
|
|
for (i = 0; i < meta->n_planes; i++) {
|
|
in_info->offset[i] = meta->offset[i];
|
|
in_info->stride[i] = meta->stride[i];
|
|
}
|
|
}
|
|
|
|
if (out_caps != nvmm->out_caps) {
|
|
nvmm->out_caps = out_caps;
|
|
if (!gst_video_info_from_caps (out_info, out_caps))
|
|
return FALSE;
|
|
}
|
|
|
|
if (nvmm->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) nvmm->params);
|
|
if (!(nvmm->params =
|
|
gst_gl_video_allocation_params_new_wrapped_gl_handle (nvmm->
|
|
upload->context, NULL, out_info, -1, NULL, nvmm->target, 0, NULL,
|
|
NULL, NULL))) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_nvmm_upload_propose_allocation (gpointer impl, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
/* nothing to do for now. */
|
|
}
|
|
|
|
static void
|
|
_egl_image_mem_unref (GstEGLImage * image, GstMemory * mem)
|
|
{
|
|
GstGLDisplayEGL *egl_display = NULL;
|
|
EGLDisplay display;
|
|
|
|
egl_display = gst_gl_display_egl_from_gl_display (image->context->display);
|
|
if (!egl_display) {
|
|
GST_ERROR ("Could not retrieve GstGLDisplayEGL from GstGLDisplay");
|
|
return;
|
|
}
|
|
display =
|
|
(EGLDisplay) gst_gl_display_get_handle (GST_GL_DISPLAY (egl_display));
|
|
|
|
if (NvDestroyEGLImage (display, image->image)) {
|
|
GST_ERROR ("Failed to destroy EGLImage %p from NvBuffer", image->image);
|
|
} else {
|
|
GST_DEBUG ("destroyed EGLImage %p from NvBuffer", image->image);
|
|
}
|
|
|
|
gst_memory_unref (mem);
|
|
gst_object_unref (egl_display);
|
|
}
|
|
|
|
static const char *
|
|
payload_type_to_string (NvBufferPayloadType ptype)
|
|
{
|
|
switch (ptype) {
|
|
case NvBufferPayload_SurfArray:
|
|
return "SurfArray";
|
|
case NvBufferPayload_MemHandle:
|
|
return "MemHandle";
|
|
default:
|
|
return "<unknown>";
|
|
}
|
|
}
|
|
|
|
static const char *
|
|
pixel_format_to_string (NvBufferColorFormat fmt)
|
|
{
|
|
switch (fmt) {
|
|
case NvBufferColorFormat_YUV420:
|
|
return "YUV420";
|
|
case NvBufferColorFormat_YVU420:
|
|
return "YVU420";
|
|
case NvBufferColorFormat_YUV422:
|
|
return "YUV422";
|
|
case NvBufferColorFormat_YUV420_ER:
|
|
return "YUV420_ER";
|
|
case NvBufferColorFormat_YVU420_ER:
|
|
return "YVU420_ER";
|
|
case NvBufferColorFormat_NV12:
|
|
return "NV12";
|
|
case NvBufferColorFormat_NV12_ER:
|
|
return "NV12_ER";
|
|
case NvBufferColorFormat_NV21:
|
|
return "NV21";
|
|
case NvBufferColorFormat_NV21_ER:
|
|
return "NV21_ER";
|
|
case NvBufferColorFormat_UYVY:
|
|
return "UYVY";
|
|
case NvBufferColorFormat_UYVY_ER:
|
|
return "UYVY_ER";
|
|
case NvBufferColorFormat_VYUY:
|
|
return "VYUY";
|
|
case NvBufferColorFormat_VYUY_ER:
|
|
return "VYUY_ER";
|
|
case NvBufferColorFormat_YUYV:
|
|
return "YUYV";
|
|
case NvBufferColorFormat_YUYV_ER:
|
|
return "YUYV_ER";
|
|
case NvBufferColorFormat_YVYU:
|
|
return "YVYU";
|
|
case NvBufferColorFormat_YVYU_ER:
|
|
return "YVYU_ER";
|
|
case NvBufferColorFormat_ABGR32:
|
|
return "ABGR32";
|
|
case NvBufferColorFormat_XRGB32:
|
|
return "XRGB32";
|
|
case NvBufferColorFormat_ARGB32:
|
|
return "ARGB32";
|
|
case NvBufferColorFormat_NV12_10LE:
|
|
return "NV12_10LE";
|
|
case NvBufferColorFormat_NV12_10LE_709:
|
|
return "NV12_10LE_709";
|
|
case NvBufferColorFormat_NV12_10LE_709_ER:
|
|
return "NV12_10LE_709_ER";
|
|
case NvBufferColorFormat_NV12_10LE_2020:
|
|
return "NV12_2020";
|
|
case NvBufferColorFormat_NV21_10LE:
|
|
return "NV21_10LE";
|
|
case NvBufferColorFormat_NV12_12LE:
|
|
return "NV12_12LE";
|
|
case NvBufferColorFormat_NV12_12LE_2020:
|
|
return "NV12_12LE_2020";
|
|
case NvBufferColorFormat_NV21_12LE:
|
|
return "NV21_12LE";
|
|
case NvBufferColorFormat_YUV420_709:
|
|
return "YUV420_709";
|
|
case NvBufferColorFormat_YUV420_709_ER:
|
|
return "YUV420_709_ER";
|
|
case NvBufferColorFormat_NV12_709:
|
|
return "NV12_709";
|
|
case NvBufferColorFormat_NV12_709_ER:
|
|
return "NV12_709_ER";
|
|
case NvBufferColorFormat_YUV420_2020:
|
|
return "YUV420_2020";
|
|
case NvBufferColorFormat_NV12_2020:
|
|
return "NV12_2020";
|
|
case NvBufferColorFormat_SignedR16G16:
|
|
return "SignedR16G16";
|
|
case NvBufferColorFormat_A32:
|
|
return "A32";
|
|
case NvBufferColorFormat_YUV444:
|
|
return "YUV444";
|
|
case NvBufferColorFormat_GRAY8:
|
|
return "GRAY8";
|
|
case NvBufferColorFormat_NV16:
|
|
return "NV16";
|
|
case NvBufferColorFormat_NV16_10LE:
|
|
return "NV16_10LE";
|
|
case NvBufferColorFormat_NV24:
|
|
return "NV24";
|
|
case NvBufferColorFormat_NV16_ER:
|
|
return "NV16_ER";
|
|
case NvBufferColorFormat_NV24_ER:
|
|
return "NV24_ER";
|
|
case NvBufferColorFormat_NV16_709:
|
|
return "NV16_709";
|
|
case NvBufferColorFormat_NV24_709:
|
|
return "NV24_709";
|
|
case NvBufferColorFormat_NV16_709_ER:
|
|
return "NV16_709_ER";
|
|
case NvBufferColorFormat_NV24_709_ER:
|
|
return "NV24_709_ER";
|
|
case NvBufferColorFormat_NV24_10LE_709:
|
|
return "NV24_10LE_709";
|
|
case NvBufferColorFormat_NV24_10LE_709_ER:
|
|
return "NV24_10LE_709_ER";
|
|
case NvBufferColorFormat_NV24_10LE_2020:
|
|
return "NV24_10LE_2020";
|
|
case NvBufferColorFormat_NV24_12LE_2020:
|
|
return "NV24_12LE_2020";
|
|
case NvBufferColorFormat_RGBA_10_10_10_2_709:
|
|
return "RGBA_10_10_10_2_709";
|
|
case NvBufferColorFormat_RGBA_10_10_10_2_2020:
|
|
return "RGBA_10_10_10_2_2020";
|
|
case NvBufferColorFormat_BGRA_10_10_10_2_709:
|
|
return "BGRA_10_10_10_2_709";
|
|
case NvBufferColorFormat_BGRA_10_10_10_2_2020:
|
|
return "BGRA_10_10_10_2_2020";
|
|
case NvBufferColorFormat_Invalid:
|
|
return "Invalid";
|
|
default:
|
|
return "<unknown>";
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_nv_buf_params (GstObject * debug_object, NvBufferParamsEx * params)
|
|
{
|
|
GST_DEBUG_OBJECT (debug_object, "nvbuffer fd: %u size %i nv_buffer: %p of "
|
|
"size %u, payload: (0x%x) %s, pixel format: (0x%x) %s, n_planes: %u, "
|
|
"plane 0 { wxh: %ux%u, pitch: %u, offset: %u, psize: %u, layout: %u } "
|
|
"plane 1 { wxh: %ux%u, pitch: %u, offset: %u, psize: %u, layout: %u } "
|
|
"plane 2 { wxh: %ux%u, pitch: %u, offset: %u, psize: %u, layout: %u }",
|
|
params->params.dmabuf_fd, params->params.memsize,
|
|
params->params.nv_buffer, params->params.nv_buffer_size,
|
|
params->params.payloadType,
|
|
payload_type_to_string (params->params.payloadType),
|
|
params->params.pixel_format,
|
|
pixel_format_to_string (params->params.pixel_format),
|
|
params->params.num_planes, params->params.width[0],
|
|
params->params.height[0], params->params.pitch[0],
|
|
params->params.offset[0], params->params.psize[0],
|
|
params->params.offset[0], params->params.width[1],
|
|
params->params.height[1], params->params.pitch[1],
|
|
params->params.offset[1], params->params.psize[1],
|
|
params->params.offset[1], params->params.width[2],
|
|
params->params.height[2], params->params.pitch[2],
|
|
params->params.offset[2], params->params.psize[2],
|
|
params->params.offset[2]);
|
|
}
|
|
|
|
static GstGLUploadReturn
|
|
_nvmm_upload_perform (gpointer impl, GstBuffer * buffer, GstBuffer ** outbuf)
|
|
{
|
|
struct NVMMUpload *nvmm = impl;
|
|
GstGLMemoryAllocator *allocator = NULL;
|
|
GstMapInfo in_map_info = GST_MAP_INFO_INIT;
|
|
GstGLDisplayEGL *egl_display = NULL;
|
|
GstEGLImage *eglimage = NULL;
|
|
EGLDisplay display = EGL_NO_DISPLAY;
|
|
EGLImageKHR image = EGL_NO_IMAGE;
|
|
int in_dmabuf_fd;
|
|
NvBufferParamsEx params = { 0, };
|
|
GstGLUploadReturn ret = GST_GL_UPLOAD_ERROR;
|
|
|
|
if (!gst_buffer_map (buffer, &in_map_info, GST_MAP_READ)) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "Failed to map readonly NvBuffer");
|
|
goto done;
|
|
}
|
|
|
|
if (ExtractFdFromNvBuffer (in_map_info.data, &in_dmabuf_fd)) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "Failed to extract fd from NvBuffer");
|
|
goto done;
|
|
}
|
|
if (NvBufferGetParamsEx (in_dmabuf_fd, ¶ms)) {
|
|
GST_WARNING_OBJECT (nvmm->upload, "Failed to get NvBuffer params");
|
|
goto done;
|
|
}
|
|
dump_nv_buf_params ((GstObject *) nvmm->upload, ¶ms);
|
|
|
|
egl_display =
|
|
gst_gl_display_egl_from_gl_display (nvmm->upload->context->display);
|
|
if (!egl_display) {
|
|
GST_WARNING ("Failed to retrieve GstGLDisplayEGL from GstGLDisplay");
|
|
goto done;
|
|
}
|
|
display =
|
|
(EGLDisplay) gst_gl_display_get_handle (GST_GL_DISPLAY (egl_display));
|
|
|
|
image = NvEGLImageFromFd (display, in_dmabuf_fd);
|
|
if (!image) {
|
|
GST_DEBUG_OBJECT (nvmm->upload, "Failed construct EGLImage "
|
|
"from NvBuffer fd %i", in_dmabuf_fd);
|
|
goto done;
|
|
}
|
|
GST_DEBUG_OBJECT (nvmm->upload, "constructed EGLImage %p "
|
|
"from NvBuffer fd %i", image, in_dmabuf_fd);
|
|
|
|
eglimage = gst_egl_image_new_wrapped (nvmm->upload->context, image,
|
|
GST_GL_RGBA, gst_memory_ref (in_map_info.memory),
|
|
(GstEGLImageDestroyNotify) _egl_image_mem_unref);
|
|
if (!eglimage) {
|
|
GST_WARNING_OBJECT (nvmm->upload, "Failed to wrap constructed "
|
|
"EGLImage from NvBuffer");
|
|
goto done;
|
|
}
|
|
|
|
gst_buffer_unmap (buffer, &in_map_info);
|
|
in_map_info = (GstMapInfo) GST_MAP_INFO_INIT;
|
|
|
|
allocator =
|
|
GST_GL_MEMORY_ALLOCATOR (gst_allocator_find
|
|
(GST_GL_MEMORY_EGL_ALLOCATOR_NAME));
|
|
|
|
/* TODO: buffer pool */
|
|
*outbuf = gst_buffer_new ();
|
|
if (!gst_gl_memory_setup_buffer (allocator, *outbuf, nvmm->params,
|
|
NULL, (gpointer *) & eglimage, 1)) {
|
|
GST_WARNING_OBJECT (nvmm->upload, "Failed to setup "
|
|
"NVMM -> EGLImage buffer");
|
|
goto done;
|
|
}
|
|
gst_egl_image_unref (eglimage);
|
|
|
|
gst_buffer_add_parent_buffer_meta (*outbuf, buffer);
|
|
|
|
/* TODO: NvBuffer has some sync functions that may be more useful here */
|
|
{
|
|
GstGLSyncMeta *sync_meta;
|
|
|
|
sync_meta = gst_buffer_add_gl_sync_meta (nvmm->upload->context, *outbuf);
|
|
if (sync_meta) {
|
|
gst_gl_sync_meta_set_sync_point (sync_meta, nvmm->upload->context);
|
|
}
|
|
}
|
|
|
|
ret = GST_GL_UPLOAD_DONE;
|
|
|
|
done:
|
|
if (in_map_info.memory)
|
|
gst_buffer_unmap (buffer, &in_map_info);
|
|
|
|
gst_clear_object (&egl_display);
|
|
gst_clear_object (&allocator);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
_nvmm_upload_free (gpointer impl)
|
|
{
|
|
struct NVMMUpload *nvmm = impl;
|
|
|
|
if (nvmm->params)
|
|
gst_gl_allocation_params_free ((GstGLAllocationParams *) nvmm->params);
|
|
|
|
g_free (impl);
|
|
}
|
|
|
|
static const UploadMethod _nvmm_upload = {
|
|
"NVMM",
|
|
0,
|
|
&_nvmm_upload_caps,
|
|
&_nvmm_upload_new,
|
|
&_nvmm_upload_transform_caps,
|
|
&_nvmm_upload_accept,
|
|
&_nvmm_upload_propose_allocation,
|
|
&_nvmm_upload_perform,
|
|
&_nvmm_upload_free
|
|
};
|
|
|
|
#endif /* HAVE_NVMM */
|
|
|
|
static const UploadMethod *upload_methods[] = {
|
|
&_passthrough_upload,
|
|
&_gl_memory_upload,
|
|
#if GST_GL_HAVE_DMABUF
|
|
&_direct_dma_buf_upload,
|
|
&_direct_dma_buf_external_upload,
|
|
&_dma_buf_upload,
|
|
#endif
|
|
#if GST_GL_HAVE_VIV_DIRECTVIV
|
|
&_directviv_upload,
|
|
#endif
|
|
#if defined(HAVE_NVMM)
|
|
&_nvmm_upload,
|
|
#endif /* HAVE_NVMM */
|
|
&_upload_meta_upload,
|
|
/* Raw data must always be last / least preferred */
|
|
&_raw_data_upload
|
|
};
|
|
|
|
static GMutex upload_global_lock;
|
|
|
|
GstCaps *
|
|
gst_gl_upload_get_input_template_caps (void)
|
|
{
|
|
GstCaps *ret = NULL;
|
|
gint i;
|
|
|
|
g_mutex_lock (&upload_global_lock);
|
|
|
|
/* FIXME: cache this and invalidate on changes to upload_methods */
|
|
for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
|
|
GstCaps *template =
|
|
gst_static_caps_get (upload_methods[i]->input_template_caps);
|
|
ret = ret == NULL ? template : gst_caps_merge (ret, template);
|
|
}
|
|
|
|
ret = gst_caps_simplify (ret);
|
|
ret = gst_gl_overlay_compositor_add_caps (ret);
|
|
g_mutex_unlock (&upload_global_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_gl_upload_class_init (GstGLUploadClass * klass)
|
|
{
|
|
G_OBJECT_CLASS (klass)->finalize = gst_gl_upload_finalize;
|
|
}
|
|
|
|
static void
|
|
gst_gl_upload_init (GstGLUpload * upload)
|
|
{
|
|
upload->priv = gst_gl_upload_get_instance_private (upload);
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_new:
|
|
* @context: a #GstGLContext
|
|
*
|
|
* Returns: (transfer full): a new #GstGLUpload object
|
|
*/
|
|
GstGLUpload *
|
|
gst_gl_upload_new (GstGLContext * context)
|
|
{
|
|
GstGLUpload *upload = g_object_new (GST_TYPE_GL_UPLOAD, NULL);
|
|
gint i, n;
|
|
|
|
gst_object_ref_sink (upload);
|
|
|
|
if (context)
|
|
gst_gl_upload_set_context (upload, context);
|
|
else
|
|
upload->context = NULL;
|
|
|
|
n = G_N_ELEMENTS (upload_methods);
|
|
upload->priv->upload_impl = g_malloc (sizeof (gpointer) * n);
|
|
for (i = 0; i < n; i++) {
|
|
upload->priv->upload_impl[i] = upload_methods[i]->new (upload);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (upload, "Created new GLUpload for context %" GST_PTR_FORMAT,
|
|
context);
|
|
|
|
return upload;
|
|
}
|
|
|
|
void
|
|
gst_gl_upload_set_context (GstGLUpload * upload, GstGLContext * context)
|
|
{
|
|
g_return_if_fail (upload != NULL);
|
|
|
|
gst_object_replace ((GstObject **) & upload->context, (GstObject *) context);
|
|
}
|
|
|
|
static void
|
|
gst_gl_upload_finalize (GObject * object)
|
|
{
|
|
GstGLUpload *upload;
|
|
gint i, n;
|
|
|
|
upload = GST_GL_UPLOAD (object);
|
|
|
|
upload->priv->method_i = 0;
|
|
|
|
if (upload->context) {
|
|
gst_object_unref (upload->context);
|
|
upload->context = NULL;
|
|
}
|
|
|
|
if (upload->priv->in_caps) {
|
|
gst_caps_unref (upload->priv->in_caps);
|
|
upload->priv->in_caps = NULL;
|
|
}
|
|
|
|
if (upload->priv->out_caps) {
|
|
gst_caps_unref (upload->priv->out_caps);
|
|
upload->priv->out_caps = NULL;
|
|
}
|
|
|
|
n = G_N_ELEMENTS (upload_methods);
|
|
for (i = 0; i < n; i++) {
|
|
if (upload->priv->upload_impl[i])
|
|
upload_methods[i]->free (upload->priv->upload_impl[i]);
|
|
}
|
|
g_free (upload->priv->upload_impl);
|
|
|
|
G_OBJECT_CLASS (gst_gl_upload_parent_class)->finalize (object);
|
|
}
|
|
|
|
GstCaps *
|
|
gst_gl_upload_transform_caps (GstGLUpload * upload, GstGLContext * context,
|
|
GstPadDirection direction, GstCaps * caps, GstCaps * filter)
|
|
{
|
|
GstCaps *result, *tmp;
|
|
gint i;
|
|
|
|
if (upload->priv->method) {
|
|
tmp = upload->priv->method->transform_caps (upload->priv->method_impl,
|
|
context, direction, caps);
|
|
|
|
if (tmp) {
|
|
/* If we're generating sink pad caps, make sure to include raw caps if needed by
|
|
* the current method */
|
|
if (direction == GST_PAD_SRC
|
|
&& (upload->priv->method->flags & METHOD_FLAG_CAN_ACCEPT_RAW)) {
|
|
GstCapsFeatures *passthrough =
|
|
gst_caps_features_from_string
|
|
(GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);
|
|
GstCaps *raw_tmp = _set_caps_features_with_passthrough (tmp,
|
|
GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, passthrough);
|
|
gst_caps_append (tmp, raw_tmp);
|
|
gst_caps_features_free (passthrough);
|
|
}
|
|
|
|
if (filter) {
|
|
result =
|
|
gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
|
|
gst_caps_unref (tmp);
|
|
} else {
|
|
result = tmp;
|
|
}
|
|
if (!gst_caps_is_empty (result))
|
|
return result;
|
|
else
|
|
gst_caps_unref (result);
|
|
}
|
|
}
|
|
|
|
tmp = gst_caps_new_empty ();
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
|
|
GstCaps *tmp2;
|
|
|
|
tmp2 =
|
|
upload_methods[i]->transform_caps (upload->priv->upload_impl[i],
|
|
context, direction, caps);
|
|
|
|
if (tmp2)
|
|
tmp = gst_caps_merge (tmp, tmp2);
|
|
}
|
|
|
|
if (filter) {
|
|
result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
|
|
gst_caps_unref (tmp);
|
|
} else {
|
|
result = tmp;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_propose_allocation:
|
|
* @upload: a #GstGLUpload
|
|
* @decide_query: (allow-none): a #GstQuery from a decide allocation
|
|
* @query: the proposed allocation query
|
|
*
|
|
* Adds the required allocation parameters to support uploading.
|
|
*/
|
|
void
|
|
gst_gl_upload_propose_allocation (GstGLUpload * upload, GstQuery * decide_query,
|
|
GstQuery * query)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (upload_methods); i++)
|
|
upload_methods[i]->propose_allocation (upload->priv->upload_impl[i],
|
|
decide_query, query);
|
|
}
|
|
|
|
static gboolean
|
|
_gst_gl_upload_set_caps_unlocked (GstGLUpload * upload, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
g_return_val_if_fail (upload != NULL, FALSE);
|
|
g_return_val_if_fail (gst_caps_is_fixed (in_caps), FALSE);
|
|
|
|
if (upload->priv->in_caps && upload->priv->out_caps
|
|
&& gst_caps_is_equal (upload->priv->in_caps, in_caps)
|
|
&& gst_caps_is_equal (upload->priv->out_caps, out_caps))
|
|
return TRUE;
|
|
|
|
gst_caps_replace (&upload->priv->in_caps, in_caps);
|
|
gst_caps_replace (&upload->priv->out_caps, out_caps);
|
|
|
|
gst_video_info_dma_drm_init (&upload->priv->in_info_drm);
|
|
if (gst_video_is_dma_drm_caps (in_caps)) {
|
|
gst_video_info_dma_drm_from_caps (&upload->priv->in_info_drm, in_caps);
|
|
} else {
|
|
gst_video_info_from_caps (&upload->priv->in_info, in_caps);
|
|
gst_video_info_dma_drm_from_video_info (&upload->priv->in_info_drm,
|
|
&upload->priv->in_info, DRM_FORMAT_MOD_LINEAR);
|
|
}
|
|
gst_video_info_from_caps (&upload->priv->out_info, out_caps);
|
|
|
|
upload->priv->method = NULL;
|
|
upload->priv->method_impl = NULL;
|
|
upload->priv->method_i = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_set_caps:
|
|
* @upload: a #GstGLUpload
|
|
* @in_caps: input #GstCaps
|
|
* @out_caps: output #GstCaps
|
|
*
|
|
* Initializes @upload with the information required for upload.
|
|
*
|
|
* Returns: whether @in_caps and @out_caps could be set on @upload
|
|
*/
|
|
gboolean
|
|
gst_gl_upload_set_caps (GstGLUpload * upload, GstCaps * in_caps,
|
|
GstCaps * out_caps)
|
|
{
|
|
gboolean ret;
|
|
|
|
GST_OBJECT_LOCK (upload);
|
|
ret = _gst_gl_upload_set_caps_unlocked (upload, in_caps, out_caps);
|
|
GST_OBJECT_UNLOCK (upload);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_get_caps:
|
|
* @upload: a #GstGLUpload
|
|
* @in_caps: (transfer full) (allow-none) (out): the input #GstCaps
|
|
* @out_caps: (transfer full) (allow-none) (out): the output #GstCaps
|
|
*/
|
|
void
|
|
gst_gl_upload_get_caps (GstGLUpload * upload, GstCaps ** in_caps,
|
|
GstCaps ** out_caps)
|
|
{
|
|
GST_OBJECT_LOCK (upload);
|
|
if (in_caps)
|
|
*in_caps =
|
|
upload->priv->in_caps ? gst_caps_ref (upload->priv->in_caps) : NULL;
|
|
if (out_caps)
|
|
*out_caps =
|
|
upload->priv->out_caps ? gst_caps_ref (upload->priv->out_caps) : NULL;
|
|
GST_OBJECT_UNLOCK (upload);
|
|
}
|
|
|
|
static gboolean
|
|
_upload_find_method (GstGLUpload * upload, gpointer last_impl)
|
|
{
|
|
gint method_i;
|
|
|
|
/* start with the last used method after explicitly reconfiguring to
|
|
* negotiate caps for this method */
|
|
if (upload->priv->method_i == 0) {
|
|
upload->priv->method_i = upload->priv->saved_method_i;
|
|
upload->priv->saved_method_i = 0;
|
|
}
|
|
|
|
if (upload->priv->method_i >= G_N_ELEMENTS (upload_methods)) {
|
|
if (last_impl)
|
|
upload->priv->method_i = 0;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
method_i = upload->priv->method_i;
|
|
|
|
if (last_impl == upload->priv->upload_impl[method_i])
|
|
return FALSE;
|
|
|
|
upload->priv->method = upload_methods[method_i];
|
|
upload->priv->method_impl = upload->priv->upload_impl[method_i];
|
|
|
|
GST_DEBUG_OBJECT (upload, "attempting upload with uploader %s",
|
|
upload->priv->method->name);
|
|
|
|
upload->priv->method_i++;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_perform_with_buffer:
|
|
* @upload: a #GstGLUpload
|
|
* @buffer: input #GstBuffer
|
|
* @outbuf_ptr: (out): resulting #GstBuffer
|
|
*
|
|
* Uploads @buffer using the transformation specified by
|
|
* gst_gl_upload_set_caps() creating a new #GstBuffer in @outbuf_ptr.
|
|
*
|
|
* Returns: whether the upload was successful
|
|
*/
|
|
GstGLUploadReturn
|
|
gst_gl_upload_perform_with_buffer (GstGLUpload * upload, GstBuffer * buffer,
|
|
GstBuffer ** outbuf_ptr)
|
|
{
|
|
GstGLUploadReturn ret = GST_GL_UPLOAD_ERROR;
|
|
GstBuffer *outbuf = NULL;
|
|
gpointer last_impl = upload->priv->method_impl;
|
|
#if !defined (GST_DISABLE_DEBUG)
|
|
const UploadMethod *last_method = upload->priv->method;
|
|
#endif
|
|
|
|
g_return_val_if_fail (GST_IS_GL_UPLOAD (upload), FALSE);
|
|
g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
|
|
g_return_val_if_fail (outbuf_ptr != NULL, FALSE);
|
|
|
|
GST_OBJECT_LOCK (upload);
|
|
|
|
#define NEXT_METHOD \
|
|
do { \
|
|
if (!_upload_find_method (upload, last_impl)) { \
|
|
GST_OBJECT_UNLOCK (upload); \
|
|
return FALSE; \
|
|
} \
|
|
goto restart; \
|
|
} while (0)
|
|
|
|
if (!upload->priv->method_impl)
|
|
_upload_find_method (upload, last_impl);
|
|
|
|
restart:
|
|
if (!upload->priv->method->accept (upload->priv->method_impl, buffer,
|
|
upload->priv->in_caps, upload->priv->out_caps))
|
|
NEXT_METHOD;
|
|
|
|
ret =
|
|
upload->priv->method->perform (upload->priv->method_impl, buffer,
|
|
&outbuf);
|
|
GST_LOG_OBJECT (upload, "uploader %s returned %u, buffer: %p",
|
|
upload->priv->method->name, ret, outbuf);
|
|
if (ret == GST_GL_UPLOAD_UNSHARED_GL_CONTEXT) {
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
|
|
if (upload_methods[i] == &_raw_data_upload) {
|
|
upload->priv->method = &_raw_data_upload;
|
|
upload->priv->method_impl = upload->priv->upload_impl[i];
|
|
upload->priv->method_i = i;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
gst_buffer_replace (&outbuf, NULL);
|
|
goto restart;
|
|
} else if (ret == GST_GL_UPLOAD_DONE || ret == GST_GL_UPLOAD_RECONFIGURE) {
|
|
if (last_impl != upload->priv->method_impl
|
|
&& upload->priv->method_impl != NULL) {
|
|
/* Transform the input caps using the new method. If they are compatible with the
|
|
* existing upload method, we can skip reconfiguration */
|
|
GstCaps *caps =
|
|
upload->priv->method->transform_caps (upload->priv->method_impl,
|
|
upload->context, GST_PAD_SINK, upload->priv->in_caps);
|
|
|
|
GST_LOG_OBJECT (upload,
|
|
"Changing uploader from %s to %s with src caps %" GST_PTR_FORMAT
|
|
" and old src caps %" GST_PTR_FORMAT,
|
|
last_method != NULL ? last_method->name : "None",
|
|
upload->priv->method->name, caps, upload->priv->out_caps);
|
|
|
|
if (caps == NULL || !gst_caps_is_subset (caps, upload->priv->out_caps)) {
|
|
gst_buffer_replace (&outbuf, NULL);
|
|
ret = GST_GL_UPLOAD_RECONFIGURE;
|
|
}
|
|
gst_caps_replace (&caps, NULL);
|
|
}
|
|
/* we are done */
|
|
} else {
|
|
upload->priv->method_impl = NULL;
|
|
gst_buffer_replace (&outbuf, NULL);
|
|
NEXT_METHOD;
|
|
}
|
|
|
|
if (outbuf && buffer != outbuf)
|
|
gst_buffer_copy_into (outbuf, buffer,
|
|
GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
|
|
*outbuf_ptr = outbuf;
|
|
|
|
if (ret == GST_GL_UPLOAD_RECONFIGURE)
|
|
upload->priv->saved_method_i = upload->priv->method_i - 1;
|
|
|
|
GST_OBJECT_UNLOCK (upload);
|
|
|
|
return ret;
|
|
|
|
#undef NEXT_METHOD
|
|
}
|
|
|
|
/**
|
|
* gst_gl_upload_fixate_caps:
|
|
* @upload: a #GstGLUpload
|
|
* @direction: the pad #GstPadDirection
|
|
* @caps: a #GstCaps as the reference
|
|
* @othercaps: (transfer full): a #GstCaps to fixate
|
|
*
|
|
* Fixate the @othercaps based on the information of the @caps.
|
|
*
|
|
* Returns: (transfer full): the fixated caps
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
GstCaps *
|
|
gst_gl_upload_fixate_caps (GstGLUpload * upload, GstPadDirection direction,
|
|
GstCaps * caps, GstCaps * othercaps)
|
|
{
|
|
guint n, i;
|
|
GstGLTextureTarget target;
|
|
GstCaps *ret_caps = NULL;
|
|
|
|
GST_DEBUG_OBJECT (upload, "Fixate caps %" GST_PTR_FORMAT ", using caps %"
|
|
GST_PTR_FORMAT ", direction is %s.", othercaps, caps,
|
|
direction == GST_PAD_SRC ? "src" : "sink");
|
|
|
|
if (direction == GST_PAD_SRC) {
|
|
ret_caps = gst_caps_fixate (othercaps);
|
|
goto out;
|
|
}
|
|
|
|
if (gst_caps_is_fixed (othercaps)) {
|
|
ret_caps = othercaps;
|
|
goto out;
|
|
}
|
|
|
|
/* Prefer target 2D->rectangle->oes */
|
|
for (target = GST_GL_TEXTURE_TARGET_2D;
|
|
target <= GST_GL_TEXTURE_TARGET_EXTERNAL_OES; target++) {
|
|
n = gst_caps_get_size (othercaps);
|
|
for (i = 0; i < n; i++) {
|
|
GstStructure *s;
|
|
|
|
s = gst_caps_get_structure (othercaps, i);
|
|
if (_structure_check_target (s, 1 << target))
|
|
break;
|
|
}
|
|
|
|
/* If the target is found, fixate the other fields */
|
|
if (i < n) {
|
|
ret_caps = gst_caps_new_empty ();
|
|
gst_caps_append_structure_full (ret_caps,
|
|
gst_structure_copy (gst_caps_get_structure (othercaps, i)),
|
|
gst_caps_features_copy (gst_caps_get_features (othercaps, i)));
|
|
|
|
ret_caps = gst_caps_fixate (ret_caps);
|
|
gst_caps_set_simple (ret_caps, "texture-target", G_TYPE_STRING,
|
|
gst_gl_texture_target_to_string (target), NULL);
|
|
|
|
gst_caps_unref (othercaps);
|
|
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret_caps = gst_caps_fixate (othercaps);
|
|
|
|
out:
|
|
GST_DEBUG_OBJECT (upload, "Fixate return %" GST_PTR_FORMAT, ret_caps);
|
|
return ret_caps;
|
|
}
|