gstreamer/subprojects/gstreamer-vaapi/gst/vaapi/gstvaapivideobufferpool.c

638 lines
20 KiB
C
Raw Normal View History

/*
* gstvaapivideobufferpool.c - Gstreamer/VA video buffer pool
*
* Copyright (C) 2013 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gstcompat.h"
#include "gstvaapivideobufferpool.h"
#include "gstvaapivideobuffer.h"
#include "gstvaapivideomemory.h"
#include "gstvaapipluginutil.h"
#if (USE_GLX || USE_EGL)
#include "gstvaapivideometa_texture.h"
#endif
GST_DEBUG_CATEGORY_STATIC (gst_debug_vaapivideopool);
#define GST_CAT_DEFAULT gst_debug_vaapivideopool
enum
{
PROP_0,
PROP_DISPLAY,
};
struct _GstVaapiVideoBufferPoolPrivate
{
GstAllocator *allocator;
GstVideoInfo vmeta_vinfo;
GstVaapiDisplay *display;
guint options;
guint use_dmabuf_memory:1;
guint forced_video_meta:1;
/* Map between surface and GstMemory, only DMA */
GHashTable *dma_mem_map;
};
G_DEFINE_TYPE_WITH_PRIVATE (GstVaapiVideoBufferPool,
gst_vaapi_video_buffer_pool, GST_TYPE_BUFFER_POOL);
static void
gst_vaapi_video_buffer_pool_finalize (GObject * object)
{
GstVaapiVideoBufferPoolPrivate *const priv =
GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;
gst_vaapi_display_replace (&priv->display, NULL);
gst_clear_object (&priv->allocator);
if (priv->dma_mem_map)
g_hash_table_destroy (priv->dma_mem_map);
G_OBJECT_CLASS (gst_vaapi_video_buffer_pool_parent_class)->finalize (object);
}
static void
gst_vaapi_video_buffer_pool_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstVaapiVideoBufferPoolPrivate *const priv =
GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;
switch (prop_id) {
case PROP_DISPLAY:
priv->display = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_vaapi_video_buffer_pool_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstVaapiVideoBufferPoolPrivate *const priv =
GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;
switch (prop_id) {
case PROP_DISPLAY:
g_value_set_pointer (value, priv->display);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
fill_video_alignment (GstVaapiVideoBufferPool * pool, GstVideoAlignment * align)
{
GstVideoInfo *const vip = &pool->priv->vmeta_vinfo;
guint i;
gint nth_bit;
gst_video_alignment_reset (align);
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (vip); i++) {
nth_bit = g_bit_nth_lsf (GST_VIDEO_INFO_PLANE_STRIDE (vip, i), 0);
if (nth_bit >= 0)
align->stride_align[i] = (1U << nth_bit) - 1;
}
}
static const gchar **
gst_vaapi_video_buffer_pool_get_options (GstBufferPool * pool)
{
static const gchar *g_options[] = {
GST_BUFFER_POOL_OPTION_VIDEO_META,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT,
NULL,
};
return g_options;
}
static gboolean
gst_vaapi_video_buffer_pool_set_config (GstBufferPool * pool,
GstStructure * config)
{
GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
GstCaps *caps;
GstVideoInfo new_allocation_vinfo;
const GstVideoInfo *allocator_vinfo;
const GstVideoInfo *negotiated_vinfo;
GstVideoAlignment align;
GstAllocator *allocator;
gboolean ret;
guint size, min_buffers, max_buffers;
guint surface_alloc_flags;
GST_DEBUG_OBJECT (base_pool, "config %" GST_PTR_FORMAT, config);
caps = NULL;
if (!gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers,
&max_buffers))
goto error_invalid_config;
if (!caps)
goto error_no_caps;
if (!gst_video_info_from_caps (&new_allocation_vinfo, caps))
goto error_invalid_caps;
if (!gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META))
goto error_no_vaapi_video_meta_option;
allocator = NULL;
if (!gst_buffer_pool_config_get_allocator (config, &allocator, NULL))
goto error_invalid_allocator;
/* it is a valid allocator? */
if (allocator
&& (g_strcmp0 (allocator->mem_type, GST_VAAPI_VIDEO_MEMORY_NAME) != 0
&& g_strcmp0 (allocator->mem_type,
GST_VAAPI_DMABUF_ALLOCATOR_NAME) != 0))
goto error_invalid_allocator;
/* get the allocator properties */
if (allocator) {
priv->use_dmabuf_memory = gst_vaapi_is_dmabuf_allocator (allocator);
negotiated_vinfo =
gst_allocator_get_vaapi_negotiated_video_info (allocator);
allocator_vinfo =
gst_allocator_get_vaapi_video_info (allocator, &surface_alloc_flags);
} else {
priv->use_dmabuf_memory = FALSE;
negotiated_vinfo = NULL;
allocator_vinfo = NULL;
surface_alloc_flags = 0;
}
/* reset or update the allocator if video resolution changed */
if (allocator_vinfo
&& gst_video_info_changed (allocator_vinfo, &new_allocation_vinfo)) {
gst_object_replace ((GstObject **) & priv->allocator, NULL);
/* dmabuf allocator can change its parameters: no need to create a
* new one */
if (priv->use_dmabuf_memory) {
gst_allocator_set_vaapi_video_info (allocator, &new_allocation_vinfo,
surface_alloc_flags);
} else {
allocator = NULL;
}
}
/* create a new allocator if needed */
if (!allocator) {
/* if no allocator set, let's create a VAAPI one */
allocator = gst_vaapi_video_allocator_new (priv->display,
&new_allocation_vinfo, surface_alloc_flags, 0);
if (!allocator)
goto error_no_allocator;
if (negotiated_vinfo) {
gst_allocator_set_vaapi_negotiated_video_info (allocator,
negotiated_vinfo);
}
GST_INFO_OBJECT (base_pool, "created new allocator %" GST_PTR_FORMAT,
allocator);
gst_buffer_pool_config_set_allocator (config, allocator, NULL);
gst_object_unref (allocator);
}
/* use the allocator and set the video info for the vmeta */
if (allocator) {
if (priv->allocator)
gst_object_unref (priv->allocator);
if ((priv->allocator = allocator))
gst_object_ref (allocator);
negotiated_vinfo =
gst_allocator_get_vaapi_negotiated_video_info (priv->allocator);
allocator_vinfo = gst_allocator_get_vaapi_video_info (allocator, NULL);
priv->vmeta_vinfo = (negotiated_vinfo) ?
*negotiated_vinfo : *allocator_vinfo;
/* last resource to set the correct buffer size */
if (GST_VIDEO_INFO_SIZE (allocator_vinfo) != size) {
gst_buffer_pool_config_set_params (config, caps,
GST_VIDEO_INFO_SIZE (allocator_vinfo), min_buffers, max_buffers);
}
}
if (!priv->allocator)
goto error_no_allocator;
priv->options = 0;
if (gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META)) {
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
} else if (gst_caps_is_video_raw (caps) && !priv->use_dmabuf_memory) {
gint i;
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&new_allocation_vinfo); i++) {
if (GST_VIDEO_INFO_PLANE_OFFSET (&new_allocation_vinfo, i) !=
GST_VIDEO_INFO_PLANE_OFFSET (&priv->vmeta_vinfo, i) ||
GST_VIDEO_INFO_PLANE_STRIDE (&new_allocation_vinfo, i) !=
GST_VIDEO_INFO_PLANE_STRIDE (&priv->vmeta_vinfo, i) ||
GST_VIDEO_INFO_SIZE (&new_allocation_vinfo) !=
GST_VIDEO_INFO_SIZE (&priv->vmeta_vinfo)) {
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
priv->forced_video_meta = TRUE;
GST_INFO_OBJECT (base_pool, "adding unrequested video meta");
break;
}
}
}
if (gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)) {
fill_video_alignment (GST_VAAPI_VIDEO_BUFFER_POOL (pool), &align);
gst_buffer_pool_config_set_video_alignment (config, &align);
}
if (!priv->use_dmabuf_memory && gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META))
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD;
ret =
GST_BUFFER_POOL_CLASS
(gst_vaapi_video_buffer_pool_parent_class)->set_config (pool, config);
return ret;
/* ERRORS */
error_invalid_config:
{
GST_WARNING_OBJECT (base_pool, "invalid config");
return FALSE;
}
error_no_caps:
{
GST_WARNING_OBJECT (base_pool, "no caps in config");
return FALSE;
}
error_invalid_caps:
{
GST_WARNING_OBJECT (base_pool, "invalid caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
error_invalid_allocator:
{
GST_INFO_OBJECT (base_pool, "no allocator in config");
return FALSE;
}
error_no_vaapi_video_meta_option:
{
GST_WARNING_OBJECT (base_pool, "no GstVaapiVideoMeta option in config");
return FALSE;
}
error_no_allocator:
{
GST_WARNING_OBJECT (base_pool, "no allocator defined");
return FALSE;
}
}
static void
vaapi_buffer_pool_cache_dma_mem (GstVaapiVideoBufferPool * pool,
GstVaapiSurfaceProxy * proxy, GstMemory * mem)
{
GstVaapiVideoBufferPoolPrivate *const priv = pool->priv;
GstVaapiSurface *surface;
surface = GST_VAAPI_SURFACE_PROXY_SURFACE (proxy);
g_assert (surface);
g_assert (gst_vaapi_surface_peek_buffer_proxy (surface));
if (!priv->dma_mem_map)
priv->dma_mem_map = g_hash_table_new_full (g_direct_hash,
g_direct_equal, NULL, (GDestroyNotify) gst_memory_unref);
if (!g_hash_table_contains (priv->dma_mem_map, surface)) {
g_hash_table_insert (priv->dma_mem_map, surface, gst_memory_ref (mem));
} else {
g_assert (g_hash_table_lookup (priv->dma_mem_map, surface) == mem);
}
}
static GstMemory *
vaapi_buffer_pool_lookup_dma_mem (GstVaapiVideoBufferPool * pool,
GstVaapiSurfaceProxy * proxy)
{
GstVaapiSurface *surface;
GstVaapiVideoBufferPoolPrivate *const priv = pool->priv;
GstVaapiBufferProxy *buf_proxy;
GstMemory *mem;
g_assert (priv->use_dmabuf_memory);
if (!priv->dma_mem_map)
return NULL;
surface = GST_VAAPI_SURFACE_PROXY_SURFACE (proxy);
g_assert (surface);
buf_proxy = gst_vaapi_surface_peek_buffer_proxy (surface);
/* Have not exported yet */
if (!buf_proxy) {
g_assert (!g_hash_table_contains (priv->dma_mem_map, surface));
return NULL;
}
mem = g_hash_table_lookup (priv->dma_mem_map, surface);
g_assert (mem);
return gst_memory_ref (mem);
}
static GstFlowReturn
gst_vaapi_video_buffer_pool_alloc_buffer (GstBufferPool * pool,
GstBuffer ** out_buffer_ptr, GstBufferPoolAcquireParams * params)
{
GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
GstVaapiVideoBufferPoolAcquireParams *const priv_params =
(GstVaapiVideoBufferPoolAcquireParams *) params;
GstVaapiVideoMeta *meta;
GstMemory *mem;
GstBuffer *buffer;
if (!priv->allocator)
goto error_no_allocator;
meta = gst_vaapi_video_meta_new (priv->display);
if (!meta)
goto error_create_meta;
buffer = gst_vaapi_video_buffer_new (meta);
if (!buffer)
goto error_create_buffer;
if (priv_params && priv_params->proxy)
gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);
if (priv->use_dmabuf_memory) {
mem = NULL;
if (priv_params && priv_params->proxy) {
mem = vaapi_buffer_pool_lookup_dma_mem (base_pool, priv_params->proxy);
if (!mem) {
mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
if (!mem)
goto error_create_memory;
vaapi_buffer_pool_cache_dma_mem (base_pool, priv_params->proxy, mem);
}
} else {
mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
}
} else {
mem = gst_vaapi_video_memory_new (priv->allocator, meta);
}
if (!mem)
goto error_create_memory;
gst_vaapi_video_meta_replace (&meta, NULL);
gst_buffer_append_memory (buffer, mem);
if (priv->options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META) {
GstVideoInfo *const vip = &priv->vmeta_vinfo;
GstVideoMeta *vmeta;
vmeta = gst_buffer_add_video_meta_full (buffer, 0,
GST_VIDEO_INFO_FORMAT (vip), GST_VIDEO_INFO_WIDTH (vip),
GST_VIDEO_INFO_HEIGHT (vip), GST_VIDEO_INFO_N_PLANES (vip),
&GST_VIDEO_INFO_PLANE_OFFSET (vip, 0),
&GST_VIDEO_INFO_PLANE_STRIDE (vip, 0));
if (GST_VAAPI_IS_VIDEO_MEMORY (mem)) {
vmeta->map = gst_video_meta_map_vaapi_memory;
vmeta->unmap = gst_video_meta_unmap_vaapi_memory;
}
GST_META_FLAG_SET (vmeta, GST_META_FLAG_POOLED);
}
#if (USE_GLX || USE_EGL)
if (priv->options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD) {
GstMeta *tex_meta = gst_buffer_add_texture_upload_meta (buffer);
if (tex_meta)
GST_META_FLAG_SET (tex_meta, GST_META_FLAG_POOLED);
}
#endif
*out_buffer_ptr = buffer;
return GST_FLOW_OK;
/* ERRORS */
error_no_allocator:
{
GST_ERROR_OBJECT (base_pool, "no GstAllocator in buffer pool");
return GST_FLOW_ERROR;
}
error_create_meta:
{
GST_ERROR_OBJECT (base_pool, "failed to allocate vaapi video meta");
return GST_FLOW_ERROR;
}
error_create_buffer:
{
GST_ERROR_OBJECT (base_pool, "failed to create video buffer");
gst_vaapi_video_meta_unref (meta);
return GST_FLOW_ERROR;
}
error_create_memory:
{
GST_ERROR_OBJECT (base_pool, "failed to create video memory");
gst_buffer_unref (buffer);
gst_vaapi_video_meta_unref (meta);
return GST_FLOW_ERROR;
}
}
static GstFlowReturn
gst_vaapi_video_buffer_pool_acquire_buffer (GstBufferPool * pool,
GstBuffer ** out_buffer_ptr, GstBufferPoolAcquireParams * params)
{
GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
GstVaapiVideoBufferPoolAcquireParams *const priv_params =
(GstVaapiVideoBufferPoolAcquireParams *) params;
GstFlowReturn ret;
GstBuffer *buffer;
GstMemory *mem;
GstVaapiVideoMeta *meta;
GstVaapiSurface *surface;
ret =
GST_BUFFER_POOL_CLASS
(gst_vaapi_video_buffer_pool_parent_class)->acquire_buffer (pool, &buffer,
params);
if (!priv->use_dmabuf_memory || !params || !priv_params->proxy
|| ret != GST_FLOW_OK) {
*out_buffer_ptr = buffer;
return ret;
}
/* Some pool users, such as decode, needs to acquire a buffer for a
* specified surface (via surface proxy). If not it is a DMABuf, we
* just replace the underlying surface proxy of buffer's
* GstVaapiVideoMeta. But in DMABuf case, the thing is a little bit
* more complicated:
*
* For DMABuf, GstMemory is-a GstFdMemory, which doesn't provide a
* way to change its FD, thus once created it's bound to a
* surface. On the other side, for performace reason, when the
* buffer is released, the buffer and its memory are cached in the
* buffer pool, and at next acquire_buffer() may still reuse a
* buffer and its memory. But the pushed surface by the decoder may
* be different from the one popped by the pool, so we need to
* replace the buffer's memory with the correct one. */
g_assert (gst_buffer_n_memory (buffer) == 1);
/* Update the underlying surface proxy */
meta = gst_buffer_get_vaapi_video_meta (buffer);
if (!meta) {
*out_buffer_ptr = buffer;
return GST_FLOW_ERROR;
}
gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);
mem = vaapi_buffer_pool_lookup_dma_mem (base_pool, priv_params->proxy);
if (mem) {
if (mem == gst_buffer_peek_memory (buffer, 0)) {
gst_memory_unref (mem);
*out_buffer_ptr = buffer;
return GST_FLOW_OK;
}
} else {
/* Should be an unexported surface */
surface = GST_VAAPI_SURFACE_PROXY_SURFACE (priv_params->proxy);
g_assert (surface);
g_assert (gst_vaapi_surface_peek_buffer_proxy (surface) == NULL);
gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);
mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
if (mem)
vaapi_buffer_pool_cache_dma_mem (base_pool, priv_params->proxy, mem);
}
if (mem) {
gst_buffer_replace_memory (buffer, 0, mem);
gst_buffer_unset_flags (buffer, GST_BUFFER_FLAG_TAG_MEMORY);
*out_buffer_ptr = buffer;
return GST_FLOW_OK;
} else {
gst_buffer_unref (buffer);
*out_buffer_ptr = NULL;
return GST_FLOW_ERROR;
}
}
static void
gst_vaapi_video_buffer_pool_reset_buffer (GstBufferPool * pool,
GstBuffer * buffer)
{
GstMemory *const mem = gst_buffer_peek_memory (buffer, 0);
GstVaapiVideoMeta *meta;
/* Release the underlying surface proxy */
if (GST_VAAPI_IS_VIDEO_MEMORY (mem)) {
gst_vaapi_video_memory_reset_surface (GST_VAAPI_VIDEO_MEMORY_CAST (mem));
} else if (!gst_vaapi_dmabuf_memory_holds_surface (mem)) {
/* If mem holds an internally created surface, don't reset it!
* While surface is passed, we should clear it to avoid wrong
* reference. */
meta = gst_buffer_get_vaapi_video_meta (buffer);
g_assert (meta);
gst_vaapi_video_meta_set_surface_proxy (meta, NULL);
}
GST_BUFFER_POOL_CLASS (gst_vaapi_video_buffer_pool_parent_class)->reset_buffer
(pool, buffer);
}
static void
gst_vaapi_video_buffer_pool_class_init (GstVaapiVideoBufferPoolClass * klass)
{
GObjectClass *const object_class = G_OBJECT_CLASS (klass);
GstBufferPoolClass *const pool_class = GST_BUFFER_POOL_CLASS (klass);
GST_DEBUG_CATEGORY_INIT (gst_debug_vaapivideopool,
"vaapivideopool", 0, "VA-API video pool");
object_class->finalize = gst_vaapi_video_buffer_pool_finalize;
object_class->set_property = gst_vaapi_video_buffer_pool_set_property;
object_class->get_property = gst_vaapi_video_buffer_pool_get_property;
pool_class->get_options = gst_vaapi_video_buffer_pool_get_options;
pool_class->set_config = gst_vaapi_video_buffer_pool_set_config;
pool_class->alloc_buffer = gst_vaapi_video_buffer_pool_alloc_buffer;
pool_class->acquire_buffer = gst_vaapi_video_buffer_pool_acquire_buffer;
pool_class->reset_buffer = gst_vaapi_video_buffer_pool_reset_buffer;
/**
* GstVaapiVideoBufferPool:display:
*
* The #GstVaapiDisplay this object is bound to.
*/
g_object_class_install_property
(object_class,
PROP_DISPLAY,
g_param_spec_object ("display", "Display",
"The GstVaapiDisplay to use for this video pool",
GST_TYPE_VAAPI_DISPLAY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}
static void
gst_vaapi_video_buffer_pool_init (GstVaapiVideoBufferPool * pool)
{
pool->priv = gst_vaapi_video_buffer_pool_get_instance_private (pool);
pool->priv->dma_mem_map = NULL;
}
GstBufferPool *
gst_vaapi_video_buffer_pool_new (GstVaapiDisplay * display)
{
return g_object_new (GST_VAAPI_TYPE_VIDEO_BUFFER_POOL,
"display", display, NULL);
}
/**
* gst_vaapi_video_buffer_pool_copy_buffer:
* @pool: a #GstVaapiVideoBufferPool
*
* Returns if the @pool force set of #GstVideoMeta. If so, the element
* should copy the generated buffer by the pool to a system allocated
* buffer. Otherwise, downstream could not display correctly the
* frame.
*
* Returns: %TRUE if #GstVideoMeta is forced.
**/
gboolean
gst_vaapi_video_buffer_pool_copy_buffer (GstBufferPool * pool)
{
GstVaapiVideoBufferPool *va_pool = (GstVaapiVideoBufferPool *) pool;
g_return_val_if_fail (GST_VAAPI_IS_VIDEO_BUFFER_POOL (pool), FALSE);
return va_pool->priv->forced_video_meta;
}