mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-13 03:46:34 +00:00
1475 lines
42 KiB
C
1475 lines
42 KiB
C
/*
|
|
* gstvaapivideomemory.c - Gstreamer/VA video memory
|
|
*
|
|
* 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 <unistd.h>
|
|
#include <gst/vaapi/gstvaapisurface_drm.h>
|
|
#include <gst/vaapi/gstvaapisurfacepool.h>
|
|
#include <gst/vaapi/gstvaapiimagepool.h>
|
|
#include "gstvaapivideomemory.h"
|
|
#include "gstvaapipluginutil.h"
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (CAT_PERFORMANCE);
|
|
GST_DEBUG_CATEGORY_STATIC (gst_debug_vaapivideomemory);
|
|
#define GST_CAT_DEFAULT gst_debug_vaapivideomemory
|
|
|
|
#ifndef GST_VIDEO_INFO_FORMAT_STRING
|
|
#define GST_VIDEO_INFO_FORMAT_STRING(vip) \
|
|
gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (vip))
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* --- GstVaapiVideoMemory --- */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static void gst_vaapi_video_memory_reset_image (GstVaapiVideoMemory * mem);
|
|
|
|
static void
|
|
_init_performance_debug (void)
|
|
{
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_GET (CAT_PERFORMANCE, "GST_PERFORMANCE");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
_init_vaapi_video_memory_debug (void)
|
|
{
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_INIT (gst_debug_vaapivideomemory, "vaapivideomemory", 0,
|
|
"VA-API video memory allocator");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static inline void
|
|
reset_image_usage (GstVaapiImageUsageFlags * flag)
|
|
{
|
|
_init_performance_debug ();
|
|
GST_CAT_INFO (CAT_PERFORMANCE, "derive image failed, fallbacking to copy");
|
|
*flag = GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
}
|
|
|
|
static inline gboolean
|
|
use_native_formats (GstVaapiImageUsageFlags flag)
|
|
{
|
|
return flag == GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
}
|
|
|
|
static inline gboolean
|
|
use_direct_rendering (GstVaapiImageUsageFlags flag)
|
|
{
|
|
return flag == GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_RENDER;
|
|
}
|
|
|
|
static inline gboolean
|
|
use_direct_uploading (GstVaapiImageUsageFlags flag)
|
|
{
|
|
return flag == GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_UPLOAD;
|
|
}
|
|
|
|
static guchar *
|
|
get_image_data (GstVaapiImage * image)
|
|
{
|
|
guchar *data;
|
|
VAImage va_image;
|
|
|
|
data = gst_vaapi_image_get_plane (image, 0);
|
|
if (!data || !gst_vaapi_image_get_image (image, &va_image))
|
|
return NULL;
|
|
|
|
data -= va_image.offsets[0];
|
|
return data;
|
|
}
|
|
|
|
static GstVaapiImage *
|
|
new_image (GstVaapiDisplay * display, const GstVideoInfo * vip)
|
|
{
|
|
if (!GST_VIDEO_INFO_WIDTH (vip) || !GST_VIDEO_INFO_HEIGHT (vip))
|
|
return NULL;
|
|
return gst_vaapi_image_new (display, GST_VIDEO_INFO_FORMAT (vip),
|
|
GST_VIDEO_INFO_WIDTH (vip), GST_VIDEO_INFO_HEIGHT (vip));
|
|
}
|
|
|
|
static gboolean
|
|
ensure_image (GstVaapiVideoMemory * mem)
|
|
{
|
|
if (!mem->image && !use_native_formats (mem->usage_flag)) {
|
|
mem->image = gst_vaapi_surface_derive_image (mem->surface);
|
|
if (!mem->image) {
|
|
reset_image_usage (&mem->usage_flag);
|
|
} else if (gst_vaapi_surface_get_format (mem->surface) !=
|
|
GST_VIDEO_INFO_FORMAT (mem->image_info)) {
|
|
gst_mini_object_replace ((GstMiniObject **) & mem->image, NULL);
|
|
reset_image_usage (&mem->usage_flag);
|
|
}
|
|
}
|
|
|
|
if (!mem->image) {
|
|
GstVaapiVideoAllocator *const allocator =
|
|
GST_VAAPI_VIDEO_ALLOCATOR_CAST (GST_MEMORY_CAST (mem)->allocator);
|
|
|
|
mem->image = gst_vaapi_video_pool_get_object (allocator->image_pool);
|
|
if (!mem->image)
|
|
return FALSE;
|
|
}
|
|
gst_vaapi_video_meta_set_image (mem->meta, mem->image);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
ensure_image_is_current (GstVaapiVideoMemory * mem)
|
|
{
|
|
if (!use_native_formats (mem->usage_flag))
|
|
return TRUE;
|
|
|
|
if (!GST_VAAPI_VIDEO_MEMORY_FLAG_IS_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_IMAGE_IS_CURRENT)) {
|
|
if (!gst_vaapi_surface_get_image (mem->surface, mem->image))
|
|
return FALSE;
|
|
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_IMAGE_IS_CURRENT);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static GstVaapiSurfaceProxy *
|
|
new_surface_proxy (GstVaapiVideoMemory * mem)
|
|
{
|
|
GstVaapiVideoAllocator *const allocator =
|
|
GST_VAAPI_VIDEO_ALLOCATOR_CAST (GST_MEMORY_CAST (mem)->allocator);
|
|
|
|
return
|
|
gst_vaapi_surface_proxy_new_from_pool (GST_VAAPI_SURFACE_POOL
|
|
(allocator->surface_pool));
|
|
}
|
|
|
|
static gboolean
|
|
ensure_surface (GstVaapiVideoMemory * mem)
|
|
{
|
|
if (!mem->proxy) {
|
|
gst_vaapi_surface_proxy_replace (&mem->proxy,
|
|
gst_vaapi_video_meta_get_surface_proxy (mem->meta));
|
|
|
|
if (!mem->proxy) {
|
|
mem->proxy = new_surface_proxy (mem);
|
|
if (!mem->proxy)
|
|
return FALSE;
|
|
gst_vaapi_video_meta_set_surface_proxy (mem->meta, mem->proxy);
|
|
}
|
|
}
|
|
mem->surface = GST_VAAPI_SURFACE_PROXY_SURFACE (mem->proxy);
|
|
return mem->surface != NULL;
|
|
}
|
|
|
|
static gboolean
|
|
ensure_surface_is_current (GstVaapiVideoMemory * mem)
|
|
{
|
|
if (!use_native_formats (mem->usage_flag))
|
|
return TRUE;
|
|
|
|
if (!GST_VAAPI_VIDEO_MEMORY_FLAG_IS_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SURFACE_IS_CURRENT)) {
|
|
if (GST_VAAPI_VIDEO_MEMORY_FLAG_IS_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_IMAGE_IS_CURRENT)
|
|
&& !gst_vaapi_surface_put_image (mem->surface, mem->image))
|
|
return FALSE;
|
|
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SURFACE_IS_CURRENT);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static inline gboolean
|
|
map_vaapi_memory (GstVaapiVideoMemory * mem, GstMapFlags flags)
|
|
{
|
|
if (!ensure_surface (mem))
|
|
goto error_no_surface;
|
|
if (!ensure_image (mem))
|
|
goto error_no_image;
|
|
|
|
/* Load VA image from surface only for read flag since it returns
|
|
* raw pixels */
|
|
if ((flags & GST_MAP_READ) && !ensure_image_is_current (mem))
|
|
goto error_no_current_image;
|
|
|
|
if (!gst_vaapi_image_map (mem->image))
|
|
goto error_map_image;
|
|
|
|
/* Mark surface as dirty and expect updates from image */
|
|
if (flags & GST_MAP_WRITE)
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_UNSET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SURFACE_IS_CURRENT);
|
|
|
|
return TRUE;
|
|
|
|
error_no_surface:
|
|
{
|
|
const GstVideoInfo *const vip = mem->surface_info;
|
|
GST_ERROR ("failed to extract VA surface of size %ux%u and format %s",
|
|
GST_VIDEO_INFO_WIDTH (vip), GST_VIDEO_INFO_HEIGHT (vip),
|
|
GST_VIDEO_INFO_FORMAT_STRING (vip));
|
|
return FALSE;
|
|
}
|
|
error_no_image:
|
|
{
|
|
const GstVideoInfo *const vip = mem->image_info;
|
|
GST_ERROR ("failed to extract VA image of size %ux%u and format %s",
|
|
GST_VIDEO_INFO_WIDTH (vip), GST_VIDEO_INFO_HEIGHT (vip),
|
|
GST_VIDEO_INFO_FORMAT_STRING (vip));
|
|
return FALSE;
|
|
}
|
|
error_no_current_image:
|
|
{
|
|
GST_ERROR ("failed to make image current");
|
|
return FALSE;
|
|
}
|
|
error_map_image:
|
|
{
|
|
GST_ERROR ("failed to map image %" GST_VAAPI_ID_FORMAT,
|
|
GST_VAAPI_ID_ARGS (gst_vaapi_image_get_id (mem->image)));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
unmap_vaapi_memory (GstVaapiVideoMemory * mem, GstMapFlags flags)
|
|
{
|
|
gst_vaapi_image_unmap (mem->image);
|
|
|
|
if (flags & GST_MAP_WRITE) {
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_IMAGE_IS_CURRENT);
|
|
}
|
|
|
|
if (!use_native_formats (mem->usage_flag)) {
|
|
gst_vaapi_video_meta_set_image (mem->meta, NULL);
|
|
gst_vaapi_video_memory_reset_image (mem);
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gst_video_meta_map_vaapi_memory (GstVideoMeta * meta, guint plane,
|
|
GstMapInfo * info, gpointer * data, gint * stride, GstMapFlags flags)
|
|
{
|
|
gboolean ret = FALSE;
|
|
GstAllocator *allocator;
|
|
GstVaapiVideoMemory *const mem =
|
|
GST_VAAPI_VIDEO_MEMORY_CAST (gst_buffer_peek_memory (meta->buffer, 0));
|
|
|
|
g_return_val_if_fail (mem, FALSE);
|
|
g_return_val_if_fail (mem->meta, FALSE);
|
|
|
|
allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
g_return_val_if_fail (GST_VAAPI_IS_VIDEO_ALLOCATOR (allocator), FALSE);
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
if (mem->map_type && mem->map_type != GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR)
|
|
goto error_incompatible_map;
|
|
|
|
/* Map for writing */
|
|
if (mem->map_count == 0) {
|
|
if (!map_vaapi_memory (mem, flags))
|
|
goto out;
|
|
mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR;
|
|
}
|
|
mem->map_count++;
|
|
|
|
*data = gst_vaapi_image_get_plane (mem->image, plane);
|
|
*stride = gst_vaapi_image_get_pitch (mem->image, plane);
|
|
info->flags = flags;
|
|
ret = (*data != NULL);
|
|
|
|
out:
|
|
g_mutex_unlock (&mem->lock);
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
error_incompatible_map:
|
|
{
|
|
GST_ERROR ("incompatible map type (%d)", mem->map_type);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gst_video_meta_unmap_vaapi_memory (GstVideoMeta * meta, guint plane,
|
|
GstMapInfo * info)
|
|
{
|
|
GstAllocator *allocator;
|
|
GstVaapiVideoMemory *const mem =
|
|
GST_VAAPI_VIDEO_MEMORY_CAST (gst_buffer_peek_memory (meta->buffer, 0));
|
|
|
|
g_return_val_if_fail (mem, FALSE);
|
|
g_return_val_if_fail (mem->meta, FALSE);
|
|
g_return_val_if_fail (mem->surface, FALSE);
|
|
g_return_val_if_fail (mem->image, FALSE);
|
|
|
|
allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
g_return_val_if_fail (GST_VAAPI_IS_VIDEO_ALLOCATOR (allocator), FALSE);
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
if (--mem->map_count == 0) {
|
|
mem->map_type = 0;
|
|
|
|
/* Unmap VA image used for read/writes */
|
|
if (info->flags & GST_MAP_READWRITE)
|
|
unmap_vaapi_memory (mem, info->flags);
|
|
}
|
|
g_mutex_unlock (&mem->lock);
|
|
return TRUE;
|
|
}
|
|
|
|
GstMemory *
|
|
gst_vaapi_video_memory_new (GstAllocator * base_allocator,
|
|
GstVaapiVideoMeta * meta)
|
|
{
|
|
GstVaapiVideoAllocator *const allocator =
|
|
GST_VAAPI_VIDEO_ALLOCATOR_CAST (base_allocator);
|
|
const GstVideoInfo *vip;
|
|
GstVaapiVideoMemory *mem;
|
|
|
|
g_return_val_if_fail (GST_VAAPI_IS_VIDEO_ALLOCATOR (allocator), NULL);
|
|
|
|
mem = g_slice_new (GstVaapiVideoMemory);
|
|
if (!mem)
|
|
return NULL;
|
|
|
|
vip = &allocator->image_info;
|
|
gst_memory_init (&mem->parent_instance, GST_MEMORY_FLAG_NO_SHARE,
|
|
base_allocator, NULL, GST_VIDEO_INFO_SIZE (vip), 0,
|
|
0, GST_VIDEO_INFO_SIZE (vip));
|
|
|
|
mem->proxy = NULL;
|
|
mem->surface_info = &allocator->surface_info;
|
|
mem->surface = NULL;
|
|
mem->image_info = &allocator->image_info;
|
|
mem->image = NULL;
|
|
mem->meta = meta ? gst_vaapi_video_meta_ref (meta) : NULL;
|
|
mem->map_type = 0;
|
|
mem->map_count = 0;
|
|
mem->map_surface_id = VA_INVALID_ID;
|
|
mem->usage_flag = allocator->usage_flag;
|
|
g_mutex_init (&mem->lock);
|
|
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SURFACE_IS_CURRENT);
|
|
return GST_MEMORY_CAST (mem);
|
|
}
|
|
|
|
void
|
|
gst_vaapi_video_memory_reset_image (GstVaapiVideoMemory * mem)
|
|
{
|
|
GstVaapiVideoAllocator *const allocator =
|
|
GST_VAAPI_VIDEO_ALLOCATOR_CAST (GST_MEMORY_CAST (mem)->allocator);
|
|
|
|
if (!use_native_formats (mem->usage_flag))
|
|
gst_mini_object_replace ((GstMiniObject **) & mem->image, NULL);
|
|
else if (mem->image) {
|
|
gst_vaapi_video_pool_put_object (allocator->image_pool, mem->image);
|
|
mem->image = NULL;
|
|
}
|
|
|
|
/* Don't synchronize to surface, this shall have happened during
|
|
* unmaps */
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_UNSET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_IMAGE_IS_CURRENT);
|
|
}
|
|
|
|
void
|
|
gst_vaapi_video_memory_reset_surface (GstVaapiVideoMemory * mem)
|
|
{
|
|
mem->surface = NULL;
|
|
gst_vaapi_video_memory_reset_image (mem);
|
|
gst_vaapi_surface_proxy_replace (&mem->proxy, NULL);
|
|
if (mem->meta)
|
|
gst_vaapi_video_meta_set_surface_proxy (mem->meta, NULL);
|
|
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_UNSET (mem,
|
|
GST_VAAPI_VIDEO_MEMORY_FLAG_SURFACE_IS_CURRENT);
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_video_memory_sync (GstVaapiVideoMemory * mem)
|
|
{
|
|
g_return_val_if_fail (mem, FALSE);
|
|
|
|
return ensure_surface_is_current (mem);
|
|
}
|
|
|
|
static gpointer
|
|
gst_vaapi_video_memory_map (GstMemory * base_mem, gsize maxsize, guint flags)
|
|
{
|
|
gpointer data = NULL;
|
|
GstVaapiVideoMemory *const mem = GST_VAAPI_VIDEO_MEMORY_CAST (base_mem);
|
|
|
|
g_return_val_if_fail (mem, NULL);
|
|
g_return_val_if_fail (mem->meta, NULL);
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
if (mem->map_count == 0) {
|
|
switch (flags & (GST_MAP_READWRITE | GST_MAP_VAAPI)) {
|
|
case 0:
|
|
case GST_MAP_VAAPI:
|
|
// No flags set: return a GstVaapiSurfaceProxy
|
|
gst_vaapi_surface_proxy_replace (&mem->proxy,
|
|
gst_vaapi_video_meta_get_surface_proxy (mem->meta));
|
|
if (!mem->proxy)
|
|
goto error_no_surface_proxy;
|
|
if (!ensure_surface_is_current (mem))
|
|
goto error_no_current_surface;
|
|
mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE;
|
|
break;
|
|
case GST_MAP_READ:
|
|
if (!map_vaapi_memory (mem, flags))
|
|
goto out;
|
|
mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR;
|
|
break;
|
|
default:
|
|
goto error_unsupported_map;
|
|
}
|
|
}
|
|
|
|
switch (mem->map_type) {
|
|
case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE:
|
|
if (!mem->proxy)
|
|
goto error_no_surface_proxy;
|
|
|
|
if (flags == GST_MAP_VAAPI) {
|
|
mem->map_surface_id = GST_VAAPI_SURFACE_PROXY_SURFACE_ID (mem->proxy);
|
|
if (mem->map_surface_id == VA_INVALID_ID)
|
|
goto error_no_current_surface;
|
|
|
|
data = &mem->map_surface_id;
|
|
} else {
|
|
data = mem->proxy;
|
|
}
|
|
break;
|
|
case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR:
|
|
if (!mem->image)
|
|
goto error_no_image;
|
|
data = get_image_data (mem->image);
|
|
break;
|
|
default:
|
|
goto error_unsupported_map_type;
|
|
}
|
|
mem->map_count++;
|
|
|
|
out:
|
|
g_mutex_unlock (&mem->lock);
|
|
return data;
|
|
|
|
/* ERRORS */
|
|
error_unsupported_map:
|
|
{
|
|
GST_ERROR ("unsupported map flags (0x%x)", flags);
|
|
goto out;
|
|
}
|
|
error_unsupported_map_type:
|
|
{
|
|
GST_ERROR ("unsupported map type (%d)", mem->map_type);
|
|
goto out;
|
|
}
|
|
error_no_surface_proxy:
|
|
{
|
|
GST_ERROR ("failed to extract GstVaapiSurfaceProxy from video meta");
|
|
goto out;
|
|
}
|
|
error_no_current_surface:
|
|
{
|
|
GST_ERROR ("failed to make surface current");
|
|
goto out;
|
|
}
|
|
error_no_image:
|
|
{
|
|
GST_ERROR ("failed to extract VA image from video buffer");
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_video_memory_unmap_full (GstMemory * base_mem, GstMapInfo * info)
|
|
{
|
|
GstVaapiVideoMemory *const mem = GST_VAAPI_VIDEO_MEMORY_CAST (base_mem);
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
if (mem->map_count == 1) {
|
|
switch (mem->map_type) {
|
|
case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE:
|
|
mem->map_surface_id = VA_INVALID_ID;
|
|
gst_vaapi_surface_proxy_replace (&mem->proxy, NULL);
|
|
break;
|
|
case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR:
|
|
unmap_vaapi_memory (mem, info->flags);
|
|
break;
|
|
default:
|
|
goto error_incompatible_map;
|
|
}
|
|
mem->map_type = 0;
|
|
}
|
|
mem->map_count--;
|
|
|
|
out:
|
|
g_mutex_unlock (&mem->lock);
|
|
return;
|
|
|
|
/* ERRORS */
|
|
error_incompatible_map:
|
|
{
|
|
GST_ERROR ("incompatible map type (%d)", mem->map_type);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
static GstMemory *
|
|
gst_vaapi_video_memory_copy (GstMemory * base_mem, gssize offset, gssize size)
|
|
{
|
|
GstVaapiVideoMemory *const mem = GST_VAAPI_VIDEO_MEMORY_CAST (base_mem);
|
|
GstVaapiVideoMeta *meta;
|
|
GstAllocator *allocator;
|
|
GstMemory *out_mem;
|
|
gsize maxsize;
|
|
|
|
g_return_val_if_fail (mem, NULL);
|
|
g_return_val_if_fail (mem->meta, NULL);
|
|
|
|
allocator = base_mem->allocator;
|
|
g_return_val_if_fail (GST_VAAPI_IS_VIDEO_ALLOCATOR (allocator), FALSE);
|
|
|
|
/* XXX: this implements a soft-copy, i.e. underlying VA surfaces
|
|
are not copied */
|
|
(void) gst_memory_get_sizes (base_mem, NULL, &maxsize);
|
|
if (offset != 0 || (size != -1 && (gsize) size != maxsize))
|
|
goto error_unsupported;
|
|
|
|
if (!ensure_surface_is_current (mem))
|
|
goto error_no_current_surface;
|
|
|
|
meta = gst_vaapi_video_meta_copy (mem->meta);
|
|
if (!meta)
|
|
goto error_allocate_memory;
|
|
|
|
out_mem = gst_vaapi_video_memory_new (allocator, meta);
|
|
gst_vaapi_video_meta_unref (meta);
|
|
if (!out_mem)
|
|
goto error_allocate_memory;
|
|
return out_mem;
|
|
|
|
/* ERRORS */
|
|
error_no_current_surface:
|
|
{
|
|
GST_ERROR ("failed to make surface current");
|
|
return NULL;
|
|
}
|
|
error_unsupported:
|
|
{
|
|
GST_ERROR ("failed to copy partial memory (unsupported operation)");
|
|
return NULL;
|
|
}
|
|
error_allocate_memory:
|
|
{
|
|
GST_ERROR ("failed to allocate GstVaapiVideoMemory copy");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* --- GstVaapiVideoAllocator --- */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
G_DEFINE_TYPE (GstVaapiVideoAllocator, gst_vaapi_video_allocator,
|
|
GST_TYPE_ALLOCATOR);
|
|
|
|
static void
|
|
gst_vaapi_video_allocator_free (GstAllocator * allocator, GstMemory * base_mem)
|
|
{
|
|
GstVaapiVideoMemory *const mem = GST_VAAPI_VIDEO_MEMORY_CAST (base_mem);
|
|
|
|
mem->surface = NULL;
|
|
gst_vaapi_video_memory_reset_image (mem);
|
|
gst_vaapi_surface_proxy_replace (&mem->proxy, NULL);
|
|
gst_vaapi_video_meta_replace (&mem->meta, NULL);
|
|
g_mutex_clear (&mem->lock);
|
|
g_slice_free (GstVaapiVideoMemory, mem);
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_video_allocator_finalize (GObject * object)
|
|
{
|
|
GstVaapiVideoAllocator *const allocator =
|
|
GST_VAAPI_VIDEO_ALLOCATOR_CAST (object);
|
|
|
|
gst_vaapi_video_pool_replace (&allocator->surface_pool, NULL);
|
|
gst_vaapi_video_pool_replace (&allocator->image_pool, NULL);
|
|
|
|
G_OBJECT_CLASS (gst_vaapi_video_allocator_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_video_allocator_class_init (GstVaapiVideoAllocatorClass * klass)
|
|
{
|
|
GObjectClass *const object_class = G_OBJECT_CLASS (klass);
|
|
GstAllocatorClass *const allocator_class = GST_ALLOCATOR_CLASS (klass);
|
|
|
|
_init_vaapi_video_memory_debug ();
|
|
|
|
object_class->finalize = gst_vaapi_video_allocator_finalize;
|
|
allocator_class->free = gst_vaapi_video_allocator_free;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_video_allocator_init (GstVaapiVideoAllocator * allocator)
|
|
{
|
|
GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator);
|
|
|
|
base_allocator->mem_type = GST_VAAPI_VIDEO_MEMORY_NAME;
|
|
base_allocator->mem_map = gst_vaapi_video_memory_map;
|
|
base_allocator->mem_unmap_full = gst_vaapi_video_memory_unmap_full;
|
|
base_allocator->mem_copy = gst_vaapi_video_memory_copy;
|
|
|
|
GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
|
|
}
|
|
|
|
static gboolean
|
|
gst_video_info_update_from_image (GstVideoInfo * vip, GstVaapiImage * image)
|
|
{
|
|
GstVideoFormat format;
|
|
const guchar *data;
|
|
guint i, num_planes, data_size, width, height;
|
|
|
|
/* Reset format from image */
|
|
format = gst_vaapi_image_get_format (image);
|
|
gst_vaapi_image_get_size (image, &width, &height);
|
|
gst_video_info_set_format (vip, format, width, height);
|
|
|
|
num_planes = gst_vaapi_image_get_plane_count (image);
|
|
g_return_val_if_fail (num_planes == GST_VIDEO_INFO_N_PLANES (vip), FALSE);
|
|
|
|
/* Determine the base data pointer */
|
|
data = get_image_data (image);
|
|
g_return_val_if_fail (data != NULL, FALSE);
|
|
data_size = gst_vaapi_image_get_data_size (image);
|
|
|
|
/* Check that we don't have disjoint planes */
|
|
for (i = 0; i < num_planes; i++) {
|
|
const guchar *const plane = gst_vaapi_image_get_plane (image, i);
|
|
if (plane - data > data_size)
|
|
return FALSE;
|
|
}
|
|
|
|
/* Update GstVideoInfo structure */
|
|
for (i = 0; i < num_planes; i++) {
|
|
const guchar *const plane = gst_vaapi_image_get_plane (image, i);
|
|
GST_VIDEO_INFO_PLANE_OFFSET (vip, i) = plane - data;
|
|
GST_VIDEO_INFO_PLANE_STRIDE (vip, i) = gst_vaapi_image_get_pitch (image, i);
|
|
}
|
|
GST_VIDEO_INFO_SIZE (vip) = data_size;
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_video_info_update_from_surface (GstVideoInfo * vip,
|
|
GstVaapiSurface * surface)
|
|
{
|
|
GstVaapiImage *image;
|
|
gboolean ret;
|
|
|
|
ret = FALSE;
|
|
image = gst_vaapi_surface_derive_image (surface);
|
|
if (!image)
|
|
goto error_no_derive_image;
|
|
if (!gst_vaapi_image_map (image))
|
|
goto error_cannot_map;
|
|
ret = gst_video_info_update_from_image (vip, image);
|
|
gst_vaapi_image_unmap (image);
|
|
|
|
bail:
|
|
gst_vaapi_image_unref (image);
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
error_no_derive_image:
|
|
{
|
|
GST_INFO ("Cannot create a VA derived image from surface %p", surface);
|
|
return FALSE;
|
|
}
|
|
error_cannot_map:
|
|
{
|
|
GST_ERROR ("Cannot map VA derived image %p", image);
|
|
goto bail;
|
|
}
|
|
}
|
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static const gchar *
|
|
gst_vaapi_image_usage_flags_to_string (GstVaapiImageUsageFlags usage_flag)
|
|
{
|
|
switch (usage_flag) {
|
|
case GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS:
|
|
return "native uploading";
|
|
case GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_RENDER:
|
|
return "direct rendering";
|
|
case GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_UPLOAD:
|
|
return "direct uploading";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static inline gboolean
|
|
allocator_configure_surface_try_specified_format (GstVaapiDisplay * display,
|
|
const GstVideoInfo * allocation_info, GstVaapiImageUsageFlags usage_flag,
|
|
guint surface_alloc_flag, GstVideoInfo * ret_surface_info,
|
|
GstVaapiImageUsageFlags * ret_usage_flag)
|
|
{
|
|
GstVaapiImageUsageFlags rflag;
|
|
GstVaapiSurface *surface;
|
|
GstVideoInfo sinfo, rinfo;
|
|
|
|
/* Try to create a surface with the given allocation info */
|
|
surface =
|
|
gst_vaapi_surface_new_full (display, allocation_info, surface_alloc_flag);
|
|
if (!surface)
|
|
return FALSE;
|
|
|
|
/* surface created and just native format usage was requested */
|
|
if (use_native_formats (usage_flag)) {
|
|
rflag = GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
rinfo = *allocation_info;
|
|
goto out;
|
|
}
|
|
|
|
/* Further checks whether that surface can support direct
|
|
* upload/render */
|
|
if (gst_video_info_update_from_surface (&sinfo, surface)) {
|
|
if (GST_VIDEO_INFO_FORMAT (&sinfo) ==
|
|
GST_VIDEO_INFO_FORMAT (allocation_info)) {
|
|
/* Set the correct flag */
|
|
if (use_direct_rendering (usage_flag)
|
|
&& !use_direct_uploading (usage_flag)) {
|
|
rflag = GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_RENDER;
|
|
} else if (!use_direct_rendering (usage_flag)
|
|
&& use_direct_uploading (usage_flag)) {
|
|
rflag = GST_VAAPI_IMAGE_USAGE_FLAG_DIRECT_UPLOAD;
|
|
} else {
|
|
g_assert_not_reached ();
|
|
}
|
|
} else {
|
|
/* It shouldn't happen, but still it's possible. Just use
|
|
* native. */
|
|
GST_FIXME ("Got a derive image with different format!");
|
|
rflag = GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
}
|
|
|
|
rinfo = sinfo;
|
|
goto out;
|
|
}
|
|
|
|
/* Can not derive image or not the same format, don't use derived
|
|
images, just fallback to use native */
|
|
rflag = GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
rinfo = *allocation_info;
|
|
|
|
out:
|
|
gst_vaapi_surface_unref (surface);
|
|
|
|
*ret_surface_info = rinfo;
|
|
*ret_usage_flag = rflag;
|
|
return TRUE;
|
|
}
|
|
|
|
static inline gboolean
|
|
allocator_configure_surface_try_other_format (GstVaapiDisplay * display,
|
|
const GstVideoInfo * allocation_info, GstVideoInfo * ret_surface_info)
|
|
{
|
|
GstVaapiSurface *surface;
|
|
GstVideoFormat fmt;
|
|
GstVideoInfo sinfo;
|
|
|
|
/* Find a best native surface format if possible */
|
|
fmt = gst_vaapi_video_format_get_best_native
|
|
(GST_VIDEO_INFO_FORMAT (allocation_info));
|
|
if (fmt == GST_VIDEO_FORMAT_UNKNOWN
|
|
|| fmt == GST_VIDEO_INFO_FORMAT (allocation_info))
|
|
goto error_invalid_format;
|
|
|
|
/* create a info with "best native" format */
|
|
gst_video_info_set_format (&sinfo, fmt,
|
|
GST_VIDEO_INFO_WIDTH (allocation_info),
|
|
GST_VIDEO_INFO_HEIGHT (allocation_info));
|
|
|
|
/* try it */
|
|
surface = gst_vaapi_surface_new_full (display, &sinfo, 0);
|
|
if (!surface)
|
|
goto error_no_surface;
|
|
gst_vaapi_surface_unref (surface);
|
|
|
|
*ret_surface_info = sinfo;
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
error_invalid_format:
|
|
{
|
|
GST_ERROR ("Cannot handle format %s",
|
|
GST_VIDEO_INFO_FORMAT_STRING (allocation_info));
|
|
return FALSE;
|
|
}
|
|
error_no_surface:
|
|
{
|
|
GST_ERROR ("Cannot create a VA Surface");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static inline gboolean
|
|
allocator_configure_surface_info (GstVaapiDisplay * display,
|
|
GstVaapiVideoAllocator * allocator, GstVaapiImageUsageFlags req_usage_flag,
|
|
guint surface_alloc_flags)
|
|
{
|
|
GstVaapiImageUsageFlags usage_flag;
|
|
GstVideoInfo allocation_info, surface_info;
|
|
|
|
/* get rid of possible encoded format and assume NV12 */
|
|
allocation_info = allocator->allocation_info;
|
|
gst_video_info_force_nv12_if_encoded (&allocation_info);
|
|
|
|
/* Step1: Try the specified format and flag. May fallback to native if
|
|
direct upload/rendering is unavailable. */
|
|
if (allocator_configure_surface_try_specified_format (display,
|
|
&allocation_info, req_usage_flag, surface_alloc_flags,
|
|
&surface_info, &usage_flag)) {
|
|
allocator->usage_flag = usage_flag;
|
|
allocator->surface_info = surface_info;
|
|
goto success;
|
|
}
|
|
|
|
/* Step2: Try other surface format. Because format is different,
|
|
direct upload/rendering is unavailable, always use native */
|
|
if (allocator_configure_surface_try_other_format (display, &allocation_info,
|
|
&surface_info)) {
|
|
allocator->usage_flag = GST_VAAPI_IMAGE_USAGE_FLAG_NATIVE_FORMATS;
|
|
allocator->surface_info = surface_info;
|
|
goto success;
|
|
}
|
|
|
|
GST_INFO_OBJECT (allocator, "Failed to configure the video format: %s"
|
|
" with usage flag: %s",
|
|
GST_VIDEO_INFO_FORMAT_STRING (&allocator->allocation_info),
|
|
gst_vaapi_image_usage_flags_to_string (req_usage_flag));
|
|
return FALSE;
|
|
|
|
success:
|
|
GST_DEBUG_OBJECT (allocator, "success to set the surface format %s"
|
|
" for video format %s with %s",
|
|
GST_VIDEO_INFO_FORMAT_STRING (&allocator->surface_info),
|
|
GST_VIDEO_INFO_FORMAT_STRING (&allocator->allocation_info),
|
|
gst_vaapi_image_usage_flags_to_string (allocator->usage_flag));
|
|
return TRUE;
|
|
}
|
|
|
|
static inline gboolean
|
|
allocator_configure_image_info (GstVaapiDisplay * display,
|
|
GstVaapiVideoAllocator * allocator)
|
|
{
|
|
GstVaapiImage *image = NULL;
|
|
const GstVideoInfo *vinfo;
|
|
gboolean ret = FALSE;
|
|
|
|
if (!use_native_formats (allocator->usage_flag)) {
|
|
allocator->image_info = allocator->surface_info;
|
|
return TRUE;
|
|
}
|
|
|
|
vinfo = &allocator->allocation_info;
|
|
allocator->image_info = *vinfo;
|
|
gst_video_info_force_nv12_if_encoded (&allocator->image_info);
|
|
|
|
image = new_image (display, &allocator->image_info);
|
|
if (!image)
|
|
goto error_no_image;
|
|
if (!gst_vaapi_image_map (image))
|
|
goto error_cannot_map;
|
|
|
|
gst_video_info_update_from_image (&allocator->image_info, image);
|
|
gst_vaapi_image_unmap (image);
|
|
ret = TRUE;
|
|
|
|
bail:
|
|
if (image)
|
|
gst_vaapi_image_unref (image);
|
|
return ret;
|
|
|
|
/* ERRORS */
|
|
error_no_image:
|
|
{
|
|
GST_ERROR ("Cannot create VA image");
|
|
return ret;
|
|
}
|
|
error_cannot_map:
|
|
{
|
|
GST_ERROR ("Failed to map VA image %p", image);
|
|
goto bail;
|
|
}
|
|
}
|
|
|
|
static inline gboolean
|
|
allocator_params_init (GstVaapiVideoAllocator * allocator,
|
|
GstVaapiDisplay * display, const GstVideoInfo * alloc_info,
|
|
guint surface_alloc_flags, GstVaapiImageUsageFlags req_usage_flag)
|
|
{
|
|
allocator->allocation_info = *alloc_info;
|
|
|
|
if (!allocator_configure_surface_info (display, allocator, req_usage_flag,
|
|
surface_alloc_flags))
|
|
return FALSE;
|
|
allocator->surface_pool = gst_vaapi_surface_pool_new_full (display,
|
|
&allocator->surface_info, surface_alloc_flags);
|
|
if (!allocator->surface_pool)
|
|
goto error_create_surface_pool;
|
|
|
|
if (!allocator_configure_image_info (display, allocator))
|
|
return FALSE;
|
|
allocator->image_pool = gst_vaapi_image_pool_new (display,
|
|
&allocator->image_info);
|
|
if (!allocator->image_pool)
|
|
goto error_create_image_pool;
|
|
|
|
gst_allocator_set_vaapi_video_info (GST_ALLOCATOR_CAST (allocator),
|
|
&allocator->image_info, surface_alloc_flags);
|
|
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
error_create_surface_pool:
|
|
{
|
|
GST_ERROR ("failed to allocate VA surface pool");
|
|
return FALSE;
|
|
}
|
|
error_create_image_pool:
|
|
{
|
|
GST_ERROR ("failed to allocate VA image pool");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
GstAllocator *
|
|
gst_vaapi_video_allocator_new (GstVaapiDisplay * display,
|
|
const GstVideoInfo * alloc_info, guint surface_alloc_flags,
|
|
GstVaapiImageUsageFlags req_usage_flag)
|
|
{
|
|
GstVaapiVideoAllocator *allocator;
|
|
|
|
g_return_val_if_fail (display != NULL, NULL);
|
|
g_return_val_if_fail (alloc_info != NULL, NULL);
|
|
|
|
allocator = g_object_new (GST_VAAPI_TYPE_VIDEO_ALLOCATOR, NULL);
|
|
if (!allocator)
|
|
return NULL;
|
|
|
|
if (!allocator_params_init (allocator, display, alloc_info,
|
|
surface_alloc_flags, req_usage_flag)) {
|
|
g_object_unref (allocator);
|
|
return NULL;
|
|
}
|
|
|
|
return GST_ALLOCATOR_CAST (allocator);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* --- GstVaapiDmaBufMemory --- */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
#define GST_VAAPI_BUFFER_PROXY_QUARK gst_vaapi_buffer_proxy_quark_get ()
|
|
static GQuark
|
|
gst_vaapi_buffer_proxy_quark_get (void)
|
|
{
|
|
static gsize g_quark;
|
|
|
|
if (g_once_init_enter (&g_quark)) {
|
|
gsize quark = (gsize) g_quark_from_static_string ("GstVaapiBufferProxy");
|
|
g_once_init_leave (&g_quark, quark);
|
|
}
|
|
return g_quark;
|
|
}
|
|
|
|
/* Whether @mem holds an internal VA surface proxy created at
|
|
* gst_vaapi_dmabuf_memory_new(). */
|
|
gboolean
|
|
gst_vaapi_dmabuf_memory_holds_surface (GstMemory * mem)
|
|
{
|
|
g_return_val_if_fail (mem != NULL, FALSE);
|
|
|
|
return
|
|
GPOINTER_TO_INT (gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (mem),
|
|
GST_VAAPI_BUFFER_PROXY_QUARK)) == TRUE;
|
|
}
|
|
|
|
GstMemory *
|
|
gst_vaapi_dmabuf_memory_new (GstAllocator * base_allocator,
|
|
GstVaapiVideoMeta * meta)
|
|
{
|
|
GstMemory *mem;
|
|
GstVaapiDisplay *display;
|
|
GstVaapiSurface *surface;
|
|
GstVaapiSurfaceProxy *proxy;
|
|
GstVaapiBufferProxy *dmabuf_proxy;
|
|
gint dmabuf_fd;
|
|
const GstVideoInfo *surface_info;
|
|
guint surface_alloc_flags;
|
|
gboolean needs_surface;
|
|
GstVaapiDmaBufAllocator *const allocator =
|
|
GST_VAAPI_DMABUF_ALLOCATOR_CAST (base_allocator);
|
|
|
|
g_return_val_if_fail (allocator != NULL, NULL);
|
|
g_return_val_if_fail (meta != NULL, NULL);
|
|
|
|
surface_info = gst_allocator_get_vaapi_video_info (base_allocator,
|
|
&surface_alloc_flags);
|
|
if (!surface_info)
|
|
return NULL;
|
|
|
|
display = gst_vaapi_video_meta_get_display (meta);
|
|
if (!display)
|
|
return NULL;
|
|
|
|
proxy = gst_vaapi_video_meta_get_surface_proxy (meta);
|
|
needs_surface = (proxy == NULL);
|
|
|
|
if (needs_surface) {
|
|
/* When exporting output VPP surfaces, or when exporting input
|
|
* surfaces to be filled/imported by an upstream element, such as
|
|
* v4l2src, we have to instantiate a VA surface to store it. */
|
|
surface = gst_vaapi_surface_new_full (display, surface_info,
|
|
surface_alloc_flags);
|
|
if (!surface)
|
|
goto error_create_surface;
|
|
proxy = gst_vaapi_surface_proxy_new (surface);
|
|
if (!proxy)
|
|
goto error_create_surface_proxy;
|
|
/* The proxy has incremented the surface ref count. */
|
|
gst_vaapi_surface_unref (surface);
|
|
} else {
|
|
/* When exporting existing surfaces that come from decoder's
|
|
* context. */
|
|
surface = GST_VAAPI_SURFACE_PROXY_SURFACE (proxy);
|
|
}
|
|
|
|
dmabuf_proxy = gst_vaapi_surface_peek_dma_buf_handle (surface);
|
|
if (!dmabuf_proxy)
|
|
goto error_create_dmabuf_proxy;
|
|
|
|
if (needs_surface) {
|
|
gst_vaapi_video_meta_set_surface_proxy (meta, proxy);
|
|
/* meta holds the proxy's reference */
|
|
gst_vaapi_surface_proxy_unref (proxy);
|
|
}
|
|
|
|
/* Need dup because GstDmabufMemory creates the GstFdMemory with flag
|
|
* GST_FD_MEMORY_FLAG_NONE. So when being freed it calls close on the fd
|
|
* because GST_FD_MEMORY_FLAG_DONT_CLOSE is not set. */
|
|
dmabuf_fd = gst_vaapi_buffer_proxy_get_handle (dmabuf_proxy);
|
|
if (dmabuf_fd < 0 || (dmabuf_fd = dup (dmabuf_fd)) < 0)
|
|
goto error_create_dmabuf_handle;
|
|
|
|
mem = gst_dmabuf_allocator_alloc (base_allocator, dmabuf_fd,
|
|
gst_vaapi_buffer_proxy_get_size (dmabuf_proxy));
|
|
if (!mem)
|
|
goto error_create_dmabuf_memory;
|
|
|
|
if (needs_surface) {
|
|
/* qdata express that memory has an associated surface. */
|
|
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (mem),
|
|
GST_VAAPI_BUFFER_PROXY_QUARK, GINT_TO_POINTER (TRUE), NULL);
|
|
}
|
|
|
|
/* When a VA surface is going to be filled by a VAAPI element
|
|
* (decoder or VPP), it has _not_ be marked as busy in the driver.
|
|
* Releasing the surface's derived image, held by the buffer proxy,
|
|
* the surface will be unmarked as busy. */
|
|
if (allocator->direction == GST_PAD_SRC)
|
|
gst_vaapi_buffer_proxy_release_data (dmabuf_proxy);
|
|
|
|
return mem;
|
|
|
|
/* ERRORS */
|
|
error_create_surface:
|
|
{
|
|
GST_ERROR ("failed to create VA surface (format:%s size:%ux%u)",
|
|
GST_VIDEO_INFO_FORMAT_STRING (surface_info),
|
|
GST_VIDEO_INFO_WIDTH (surface_info),
|
|
GST_VIDEO_INFO_HEIGHT (surface_info));
|
|
return NULL;
|
|
}
|
|
error_create_surface_proxy:
|
|
{
|
|
GST_ERROR ("failed to create VA surface proxy");
|
|
gst_vaapi_surface_unref (surface);
|
|
return NULL;
|
|
}
|
|
error_create_dmabuf_proxy:
|
|
{
|
|
GST_ERROR ("failed to export VA surface to DMABUF");
|
|
if (surface)
|
|
gst_vaapi_surface_unref (surface);
|
|
if (proxy)
|
|
gst_vaapi_surface_proxy_unref (proxy);
|
|
return NULL;
|
|
}
|
|
error_create_dmabuf_handle:
|
|
{
|
|
GST_ERROR ("failed to duplicate DMABUF handle");
|
|
gst_vaapi_buffer_proxy_unref (dmabuf_proxy);
|
|
return NULL;
|
|
}
|
|
error_create_dmabuf_memory:
|
|
{
|
|
GST_ERROR ("failed to create DMABUF memory");
|
|
close (dmabuf_fd);
|
|
gst_vaapi_buffer_proxy_unref (dmabuf_proxy);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* --- GstVaapiDmaBufAllocator --- */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
G_DEFINE_TYPE (GstVaapiDmaBufAllocator,
|
|
gst_vaapi_dmabuf_allocator, GST_TYPE_DMABUF_ALLOCATOR);
|
|
|
|
static void
|
|
gst_vaapi_dmabuf_allocator_class_init (GstVaapiDmaBufAllocatorClass * klass)
|
|
{
|
|
_init_vaapi_video_memory_debug ();
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_dmabuf_allocator_init (GstVaapiDmaBufAllocator * allocator)
|
|
{
|
|
GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator);
|
|
|
|
base_allocator->mem_type = GST_VAAPI_DMABUF_ALLOCATOR_NAME;
|
|
allocator->direction = GST_PAD_SINK;
|
|
}
|
|
|
|
GstAllocator *
|
|
gst_vaapi_dmabuf_allocator_new (GstVaapiDisplay * display,
|
|
const GstVideoInfo * alloc_info, guint surface_alloc_flags,
|
|
GstPadDirection direction)
|
|
{
|
|
GstVaapiDmaBufAllocator *allocator = NULL;
|
|
GstVaapiSurface *surface = NULL;
|
|
GstVideoInfo surface_info;
|
|
GstAllocator *base_allocator;
|
|
|
|
g_return_val_if_fail (display != NULL, NULL);
|
|
g_return_val_if_fail (alloc_info != NULL, NULL);
|
|
|
|
allocator = g_object_new (GST_VAAPI_TYPE_DMABUF_ALLOCATOR, NULL);
|
|
if (!allocator)
|
|
goto error_no_allocator;
|
|
|
|
base_allocator = GST_ALLOCATOR_CAST (allocator);
|
|
|
|
gst_video_info_set_format (&surface_info, GST_VIDEO_INFO_FORMAT (alloc_info),
|
|
GST_VIDEO_INFO_WIDTH (alloc_info), GST_VIDEO_INFO_HEIGHT (alloc_info));
|
|
surface = gst_vaapi_surface_new_full (display, alloc_info,
|
|
surface_alloc_flags);
|
|
if (!surface)
|
|
goto error_no_surface;
|
|
if (!gst_video_info_update_from_surface (&surface_info, surface))
|
|
goto fail;
|
|
gst_mini_object_replace ((GstMiniObject **) & surface, NULL);
|
|
|
|
gst_allocator_set_vaapi_video_info (base_allocator, &surface_info,
|
|
surface_alloc_flags);
|
|
|
|
allocator->direction = direction;
|
|
|
|
return base_allocator;
|
|
|
|
/* ERRORS */
|
|
fail:
|
|
{
|
|
gst_mini_object_replace ((GstMiniObject **) & surface, NULL);
|
|
gst_object_replace ((GstObject **) & base_allocator, NULL);
|
|
return NULL;
|
|
}
|
|
error_no_allocator:
|
|
{
|
|
GST_ERROR ("failed to create a new dmabuf allocator");
|
|
return NULL;
|
|
}
|
|
error_no_surface:
|
|
{
|
|
GST_ERROR ("failed to create a new surface");
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* --- GstVaapiVideoInfo = { GstVideoInfo, flags } --- */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
#define GST_VAAPI_VIDEO_INFO_QUARK gst_vaapi_video_info_quark_get ()
|
|
static GQuark
|
|
gst_vaapi_video_info_quark_get (void)
|
|
{
|
|
static gsize g_quark;
|
|
|
|
if (g_once_init_enter (&g_quark)) {
|
|
gsize quark = (gsize) g_quark_from_static_string ("GstVaapiVideoInfo");
|
|
g_once_init_leave (&g_quark, quark);
|
|
}
|
|
return g_quark;
|
|
}
|
|
|
|
#define ALLOCATION_VINFO_QUARK allocation_vinfo_quark_get ()
|
|
static GQuark
|
|
allocation_vinfo_quark_get (void)
|
|
{
|
|
static gsize g_quark;
|
|
|
|
if (g_once_init_enter (&g_quark)) {
|
|
gsize quark = (gsize) g_quark_from_static_string ("allocation-vinfo");
|
|
g_once_init_leave (&g_quark, quark);
|
|
}
|
|
return g_quark;
|
|
}
|
|
|
|
#define SURFACE_ALLOC_FLAGS_QUARK surface_alloc_flags_quark_get ()
|
|
static GQuark
|
|
surface_alloc_flags_quark_get (void)
|
|
{
|
|
static gsize g_quark;
|
|
|
|
if (g_once_init_enter (&g_quark)) {
|
|
gsize quark = (gsize) g_quark_from_static_string ("surface-alloc-flags");
|
|
g_once_init_leave (&g_quark, quark);
|
|
}
|
|
return g_quark;
|
|
}
|
|
|
|
#define NEGOTIATED_VINFO_QUARK negotiated_vinfo_quark_get ()
|
|
static GQuark
|
|
negotiated_vinfo_quark_get (void)
|
|
{
|
|
static gsize g_quark;
|
|
|
|
if (g_once_init_enter (&g_quark)) {
|
|
gsize quark = (gsize) g_quark_from_static_string ("negotiated-vinfo");
|
|
g_once_init_leave (&g_quark, quark);
|
|
}
|
|
return g_quark;
|
|
}
|
|
|
|
/**
|
|
* gst_allocator_get_vaapi_video_info:
|
|
* @allocator: a #GstAllocator
|
|
* @out_flags_ptr: (out): the stored surface allocation flags
|
|
*
|
|
* Will get the @allocator qdata to fetch the flags and the
|
|
* allocation's #GstVideoInfo stored in it.
|
|
*
|
|
* The allocation video info, is the image video info in the case of
|
|
* the #GstVaapiVideoAllocator; and the allocation video info in the
|
|
* case of #GstVaapiDmaBufAllocator.
|
|
*
|
|
* Returns: the stored #GstVideoInfo
|
|
**/
|
|
const GstVideoInfo *
|
|
gst_allocator_get_vaapi_video_info (GstAllocator * allocator,
|
|
guint * out_flags_ptr)
|
|
{
|
|
const GstStructure *structure;
|
|
const GValue *value;
|
|
|
|
g_return_val_if_fail (GST_IS_ALLOCATOR (allocator), NULL);
|
|
|
|
structure =
|
|
g_object_get_qdata (G_OBJECT (allocator), GST_VAAPI_VIDEO_INFO_QUARK);
|
|
if (!structure)
|
|
return NULL;
|
|
|
|
if (out_flags_ptr) {
|
|
value = gst_structure_id_get_value (structure, SURFACE_ALLOC_FLAGS_QUARK);
|
|
if (!value)
|
|
return NULL;
|
|
*out_flags_ptr = g_value_get_uint (value);
|
|
}
|
|
|
|
value = gst_structure_id_get_value (structure, ALLOCATION_VINFO_QUARK);
|
|
if (!value)
|
|
return NULL;
|
|
return g_value_get_boxed (value);
|
|
}
|
|
|
|
/**
|
|
* gst_allocator_set_vaapi_video_info:
|
|
* @allocator: a #GstAllocator
|
|
* @alloc_info: the allocation #GstVideoInfo to store
|
|
* @surface_alloc_flags: the flags to store
|
|
*
|
|
* Stores as GObject's qdata the @alloc_info and the
|
|
* @surface_alloc_flags in the allocator. This will "decorate" the
|
|
* allocator as a GstVaapi one.
|
|
*
|
|
* Returns: always %TRUE
|
|
**/
|
|
gboolean
|
|
gst_allocator_set_vaapi_video_info (GstAllocator * allocator,
|
|
const GstVideoInfo * alloc_info, guint surface_alloc_flags)
|
|
{
|
|
g_return_val_if_fail (GST_IS_ALLOCATOR (allocator), FALSE);
|
|
g_return_val_if_fail (alloc_info != NULL, FALSE);
|
|
|
|
g_object_set_qdata_full (G_OBJECT (allocator), GST_VAAPI_VIDEO_INFO_QUARK,
|
|
gst_structure_new_id (GST_VAAPI_VIDEO_INFO_QUARK,
|
|
ALLOCATION_VINFO_QUARK, GST_TYPE_VIDEO_INFO, alloc_info,
|
|
SURFACE_ALLOC_FLAGS_QUARK, G_TYPE_UINT, surface_alloc_flags, NULL),
|
|
(GDestroyNotify) gst_structure_free);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_allocator_set_vaapi_negotiated_video_info:
|
|
* @allocator: a #GstAllocator
|
|
* @negotiated_vinfo: the negotiated #GstVideoInfo to store. If NULL, then
|
|
* removes any previously set value.
|
|
*
|
|
* Stores as GObject's qdata the @negotiated_vinfo in the allocator
|
|
* instance.
|
|
*
|
|
* The @negotiated_vinfo is different of the @alloc_info from
|
|
* gst_allocator_set_vaapi_video_info(), and might not be set.
|
|
**/
|
|
void
|
|
gst_allocator_set_vaapi_negotiated_video_info (GstAllocator * allocator,
|
|
const GstVideoInfo * negotiated_vinfo)
|
|
{
|
|
g_return_if_fail (allocator && GST_IS_ALLOCATOR (allocator));
|
|
|
|
if (negotiated_vinfo)
|
|
g_object_set_qdata_full (G_OBJECT (allocator), NEGOTIATED_VINFO_QUARK,
|
|
gst_video_info_copy (negotiated_vinfo),
|
|
(GDestroyNotify) gst_video_info_free);
|
|
else
|
|
g_object_set_qdata (G_OBJECT (allocator), NEGOTIATED_VINFO_QUARK, NULL);
|
|
}
|
|
|
|
/**
|
|
* gst_allocator_get_vaapi_negotiated_video_info:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Returns: the stored negotiation #GstVideoInfo, if it was stored
|
|
* previously. Otherwise, %NULL
|
|
**/
|
|
GstVideoInfo *
|
|
gst_allocator_get_vaapi_negotiated_video_info (GstAllocator * allocator)
|
|
{
|
|
g_return_val_if_fail (GST_IS_ALLOCATOR (allocator), NULL);
|
|
|
|
return g_object_get_qdata (G_OBJECT (allocator), NEGOTIATED_VINFO_QUARK);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_is_dmabuf_allocator:
|
|
* @allocator: an #GstAllocator
|
|
*
|
|
* Checks if the allocator is DMABuf allocator with the GstVaapi
|
|
* decorator.
|
|
*
|
|
* Returns: %TRUE if @allocator is a DMABuf allocator type with
|
|
* GstVaapi decorator.
|
|
**/
|
|
gboolean
|
|
gst_vaapi_is_dmabuf_allocator (GstAllocator * allocator)
|
|
{
|
|
GstStructure *st;
|
|
|
|
g_return_val_if_fail (GST_IS_ALLOCATOR (allocator), FALSE);
|
|
|
|
if (g_strcmp0 (allocator->mem_type, GST_VAAPI_DMABUF_ALLOCATOR_NAME) != 0)
|
|
return FALSE;
|
|
st = g_object_get_qdata (G_OBJECT (allocator), GST_VAAPI_VIDEO_INFO_QUARK);
|
|
return (st != NULL);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_dmabuf_can_map:
|
|
* @display: a #GstVaapiDisplay
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* It will create a dmabuf-based buffer using @allocator, and it will
|
|
* try to map it using gst_memory_map().
|
|
*
|
|
* Returns: %TRUE if the internal dummy buffer can be
|
|
* mapped. Otherwise %FALSE.
|
|
**/
|
|
gboolean
|
|
gst_vaapi_dmabuf_can_map (GstVaapiDisplay * display, GstAllocator * allocator)
|
|
{
|
|
GstVaapiVideoMeta *meta;
|
|
GstMemory *mem;
|
|
GstMapInfo info;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (display != NULL, FALSE);
|
|
|
|
ret = FALSE;
|
|
mem = NULL;
|
|
meta = NULL;
|
|
if (!gst_vaapi_is_dmabuf_allocator (allocator))
|
|
return FALSE;
|
|
meta = gst_vaapi_video_meta_new (display);
|
|
if (!meta)
|
|
return FALSE;
|
|
mem = gst_vaapi_dmabuf_memory_new (allocator, meta);
|
|
if (!mem)
|
|
goto bail;
|
|
|
|
if (!gst_memory_map (mem, &info, GST_MAP_READWRITE) || info.size == 0)
|
|
goto bail;
|
|
|
|
gst_memory_unmap (mem, &info);
|
|
ret = TRUE;
|
|
|
|
bail:
|
|
if (mem)
|
|
gst_memory_unref (mem);
|
|
if (meta)
|
|
gst_vaapi_video_meta_unref (meta);
|
|
return ret;
|
|
}
|