mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
8faefccfd5
Moved the close loop into a function guarded for non-win32 platforms. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7254>
2278 lines
60 KiB
C
2278 lines
60 KiB
C
/* GStreamer
|
|
* Copyright (C) 2020 Igalia, S.L.
|
|
* Author: Víctor Jáquez <vjaquez@igalia.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.
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gstvaallocator
|
|
* @title: VA allocators
|
|
* @short_description: VA allocators
|
|
* @sources:
|
|
* - gstvaallocator.h
|
|
*
|
|
* There are two types of VA allocators:
|
|
*
|
|
* * #GstVaAllocator
|
|
* * #GstVaDmabufAllocator
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstvaallocator.h"
|
|
|
|
#ifndef G_OS_WIN32
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "gstvasurfacecopy.h"
|
|
#include "gstvavideoformat.h"
|
|
#include "vasurfaceimage.h"
|
|
|
|
#ifndef DRM_FORMAT_INVALID
|
|
#define DRM_FORMAT_INVALID 0
|
|
#endif
|
|
|
|
#define GST_CAT_DEFAULT gst_va_memory_debug
|
|
GST_DEBUG_CATEGORY (gst_va_memory_debug);
|
|
|
|
static void
|
|
_init_debug_category (void)
|
|
{
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_INIT (gst_va_memory_debug, "vamemory", 0, "VA memory");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*=========================== Quarks for GstMemory ===========================*/
|
|
|
|
static GQuark
|
|
gst_va_buffer_surface_quark (void)
|
|
{
|
|
static gsize surface_quark = 0;
|
|
|
|
if (g_once_init_enter (&surface_quark)) {
|
|
GQuark quark = g_quark_from_string ("GstVaBufferSurface");
|
|
g_once_init_leave (&surface_quark, quark);
|
|
}
|
|
|
|
return surface_quark;
|
|
}
|
|
|
|
static GQuark
|
|
gst_va_buffer_aux_surface_quark (void)
|
|
{
|
|
static gsize surface_quark = 0;
|
|
|
|
if (g_once_init_enter (&surface_quark)) {
|
|
GQuark quark = g_quark_from_string ("GstVaBufferAuxSurface");
|
|
g_once_init_leave (&surface_quark, quark);
|
|
}
|
|
|
|
return surface_quark;
|
|
}
|
|
|
|
/*========================= GstVaBufferSurface ===============================*/
|
|
|
|
typedef struct _GstVaBufferSurface GstVaBufferSurface;
|
|
struct _GstVaBufferSurface
|
|
{
|
|
GstVaDisplay *display;
|
|
VASurfaceID surface;
|
|
guint n_mems;
|
|
GstMemory *mems[GST_VIDEO_MAX_PLANES];
|
|
gint ref_count;
|
|
gint ref_mems_count;
|
|
};
|
|
|
|
static void
|
|
gst_va_buffer_surface_unref (gpointer data)
|
|
{
|
|
GstVaBufferSurface *buf = data;
|
|
|
|
g_return_if_fail (buf && GST_IS_VA_DISPLAY (buf->display));
|
|
|
|
if (g_atomic_int_dec_and_test (&buf->ref_count)) {
|
|
GST_LOG_OBJECT (buf->display, "Destroying surface %#x", buf->surface);
|
|
va_destroy_surfaces (buf->display, &buf->surface, 1);
|
|
gst_clear_object (&buf->display);
|
|
g_free (buf);
|
|
}
|
|
}
|
|
|
|
static GstVaBufferSurface *
|
|
gst_va_buffer_surface_new (VASurfaceID surface)
|
|
{
|
|
GstVaBufferSurface *buf = g_new (GstVaBufferSurface, 1);
|
|
|
|
g_atomic_int_set (&buf->ref_count, 0);
|
|
g_atomic_int_set (&buf->ref_mems_count, 0);
|
|
buf->surface = surface;
|
|
buf->display = NULL;
|
|
buf->n_mems = 0;
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*=========================== GstVaMemoryPool ================================*/
|
|
|
|
/* queue for disposed surfaces */
|
|
typedef struct _GstVaMemoryPool GstVaMemoryPool;
|
|
struct _GstVaMemoryPool
|
|
{
|
|
GstAtomicQueue *queue;
|
|
gint surface_count;
|
|
|
|
GMutex lock;
|
|
};
|
|
|
|
#define GST_VA_MEMORY_POOL_CAST(obj) ((GstVaMemoryPool *)obj)
|
|
#define GST_VA_MEMORY_POOL_LOCK(obj) g_mutex_lock (&GST_VA_MEMORY_POOL_CAST(obj)->lock)
|
|
#define GST_VA_MEMORY_POOL_UNLOCK(obj) g_mutex_unlock (&GST_VA_MEMORY_POOL_CAST(obj)->lock)
|
|
|
|
static void
|
|
gst_va_memory_pool_init (GstVaMemoryPool * self)
|
|
{
|
|
self->queue = gst_atomic_queue_new (2);
|
|
|
|
g_mutex_init (&self->lock);
|
|
|
|
self->surface_count = 0;
|
|
}
|
|
|
|
static void
|
|
gst_va_memory_pool_finalize (GstVaMemoryPool * self)
|
|
{
|
|
g_mutex_clear (&self->lock);
|
|
|
|
gst_atomic_queue_unref (self->queue);
|
|
}
|
|
|
|
static void
|
|
gst_va_memory_pool_flush_unlocked (GstVaMemoryPool * self,
|
|
GstVaDisplay * display)
|
|
{
|
|
GstMemory *mem;
|
|
GstVaBufferSurface *buf;
|
|
|
|
while ((mem = gst_atomic_queue_pop (self->queue))) {
|
|
/* destroy the surface */
|
|
buf = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_surface_quark ());
|
|
if (buf) {
|
|
if (g_atomic_int_dec_and_test (&buf->ref_count)) {
|
|
GST_LOG ("Destroying surface %#x", buf->surface);
|
|
va_destroy_surfaces (display, &buf->surface, 1);
|
|
self->surface_count -= 1; /* GstVaDmabufAllocator */
|
|
g_free (buf);
|
|
}
|
|
} else {
|
|
self->surface_count -= 1; /* GstVaAllocator */
|
|
}
|
|
|
|
GST_MINI_OBJECT_CAST (mem)->dispose = NULL;
|
|
/* when mem are pushed available queue its allocator is unref,
|
|
* then now it is required to ref the allocator here because
|
|
* memory's finalize will unref it again */
|
|
gst_object_ref (mem->allocator);
|
|
gst_memory_unref (mem);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_va_memory_pool_flush (GstVaMemoryPool * self, GstVaDisplay * display)
|
|
{
|
|
GST_VA_MEMORY_POOL_LOCK (self);
|
|
gst_va_memory_pool_flush_unlocked (self, display);
|
|
GST_VA_MEMORY_POOL_UNLOCK (self);
|
|
}
|
|
|
|
static inline void
|
|
gst_va_memory_pool_push (GstVaMemoryPool * self, GstMemory * mem)
|
|
{
|
|
gst_atomic_queue_push (self->queue, gst_memory_ref (mem));
|
|
}
|
|
|
|
static inline GstMemory *
|
|
gst_va_memory_pool_pop (GstVaMemoryPool * self)
|
|
{
|
|
return gst_atomic_queue_pop (self->queue);
|
|
}
|
|
|
|
static inline GstMemory *
|
|
gst_va_memory_pool_peek (GstVaMemoryPool * self)
|
|
{
|
|
return gst_atomic_queue_peek (self->queue);
|
|
}
|
|
|
|
static inline guint
|
|
gst_va_memory_pool_surface_count (GstVaMemoryPool * self)
|
|
{
|
|
return g_atomic_int_get (&self->surface_count);
|
|
}
|
|
|
|
static inline void
|
|
gst_va_memory_pool_surface_inc (GstVaMemoryPool * self)
|
|
{
|
|
g_atomic_int_inc (&self->surface_count);
|
|
}
|
|
|
|
/*=========================== GstVaDmabufAllocator ===========================*/
|
|
|
|
/**
|
|
* GstVaDmabufAllocator:
|
|
*
|
|
* A pooled memory allocator backed by the DMABufs exported from a
|
|
* VASurfaceID. Also it is possible to import DMAbufs into a
|
|
* VASurfaceID.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
typedef struct _GstVaDmabufAllocator GstVaDmabufAllocator;
|
|
typedef struct _GstVaDmabufAllocatorClass GstVaDmabufAllocatorClass;
|
|
|
|
struct _GstVaDmabufAllocator
|
|
{
|
|
GstDmaBufAllocator parent;
|
|
|
|
GstVaDisplay *display;
|
|
|
|
GstMemoryMapFunction parent_map;
|
|
GstMemoryCopyFunction parent_copy;
|
|
|
|
GstVideoInfoDmaDrm info;
|
|
guint usage_hint;
|
|
|
|
GstVaSurfaceCopy *copy;
|
|
|
|
GstVaMemoryPool pool;
|
|
};
|
|
|
|
struct _GstVaDmabufAllocatorClass
|
|
{
|
|
GstDmaBufAllocatorClass parent_class;
|
|
};
|
|
|
|
#define gst_va_dmabuf_allocator_parent_class dmabuf_parent_class
|
|
G_DEFINE_TYPE_WITH_CODE (GstVaDmabufAllocator, gst_va_dmabuf_allocator,
|
|
GST_TYPE_DMABUF_ALLOCATOR, _init_debug_category ());
|
|
|
|
static GstVaSurfaceCopy *
|
|
_ensure_surface_copy (GstVaSurfaceCopy ** old, GstVaDisplay * display,
|
|
GstVideoInfo * info)
|
|
{
|
|
GstVaSurfaceCopy *surface_copy;
|
|
|
|
surface_copy = g_atomic_pointer_get (old);
|
|
if (!surface_copy) {
|
|
surface_copy = gst_va_surface_copy_new (display, info);
|
|
|
|
/* others create a new one and set it before us */
|
|
if (surface_copy &&
|
|
!g_atomic_pointer_compare_and_exchange (old, NULL, surface_copy)) {
|
|
gst_va_surface_copy_free (surface_copy);
|
|
surface_copy = g_atomic_pointer_get (old);
|
|
}
|
|
}
|
|
|
|
return surface_copy;
|
|
}
|
|
|
|
/* If a buffer contains multiple memories (dmabuf objects) its very
|
|
* difficult to provide a realiable way to fast-copy single memories:
|
|
* While VA API sees surfaces with dependant dmabufs, GStreamer only
|
|
* copies dmabufs in isolation; trying to solve it while keeping a
|
|
* reference of the copied buffer and dmabuf index is very fragile. */
|
|
static GstMemory *
|
|
gst_va_dmabuf_mem_copy (GstMemory * gmem, gssize offset, gssize size)
|
|
{
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (gmem->allocator);
|
|
GstVaBufferSurface *buf;
|
|
gsize mem_size;
|
|
|
|
buf = gst_mini_object_get_qdata (GST_MINI_OBJECT (gmem),
|
|
gst_va_buffer_surface_quark ());
|
|
|
|
if (buf->n_mems > 1 && self->info.drm_modifier != DRM_FORMAT_MOD_LINEAR) {
|
|
GST_ERROR_OBJECT (self, "Failed to copy multi-dmabuf because non-linear "
|
|
"modifier: %#" G_GINT64_MODIFIER "x.", self->info.drm_modifier);
|
|
return NULL;
|
|
}
|
|
|
|
/* check if it's full memory copy */
|
|
mem_size = gst_memory_get_sizes (gmem, NULL, NULL);
|
|
|
|
if (size == -1)
|
|
size = mem_size > offset ? mem_size - offset : 0;
|
|
|
|
/* @XXX: if one-memory buffer it's possible to copy */
|
|
if (offset == 0 && size == mem_size && buf->n_mems == 1) {
|
|
GstVaBufferSurface *buf_copy = NULL;
|
|
GstMemory *copy;
|
|
GstVaSurfaceCopy *copy_func;
|
|
|
|
GST_VA_MEMORY_POOL_LOCK (&self->pool);
|
|
copy = gst_va_memory_pool_pop (&self->pool);
|
|
GST_VA_MEMORY_POOL_UNLOCK (&self->pool);
|
|
|
|
if (copy) {
|
|
gst_object_ref (copy->allocator);
|
|
|
|
buf_copy = gst_mini_object_get_qdata (GST_MINI_OBJECT (copy),
|
|
gst_va_buffer_surface_quark ());
|
|
|
|
g_assert (g_atomic_int_get (&buf_copy->ref_mems_count) == 0);
|
|
|
|
g_atomic_int_add (&buf_copy->ref_mems_count, 1);
|
|
} else {
|
|
GstBuffer *buffer = gst_buffer_new ();
|
|
|
|
if (!gst_va_dmabuf_allocator_setup_buffer (gmem->allocator, buffer)) {
|
|
GST_WARNING_OBJECT (self, "Failed to create a new dmabuf memory");
|
|
return NULL;
|
|
}
|
|
|
|
copy = gst_buffer_get_memory (buffer, 0);
|
|
gst_buffer_unref (buffer);
|
|
|
|
buf_copy = gst_mini_object_get_qdata (GST_MINI_OBJECT (copy),
|
|
gst_va_buffer_surface_quark ());
|
|
}
|
|
|
|
g_assert (buf_copy->n_mems == 1);
|
|
|
|
copy_func =
|
|
_ensure_surface_copy (&self->copy, self->display, &self->info.vinfo);
|
|
if (copy_func
|
|
&& gst_va_surface_copy (copy_func, buf_copy->surface, buf->surface))
|
|
return copy;
|
|
|
|
gst_memory_unref (copy);
|
|
|
|
/* try system memory */
|
|
}
|
|
|
|
if (self->info.drm_modifier != DRM_FORMAT_MOD_LINEAR) {
|
|
GST_ERROR_OBJECT (self, "Failed to copy dmabuf because non-linear "
|
|
"modifier: %#" G_GINT64_MODIFIER "x.", self->info.drm_modifier);
|
|
return NULL;
|
|
}
|
|
|
|
/* fallback to system memory */
|
|
return self->parent_copy (gmem, offset, size);
|
|
|
|
}
|
|
|
|
static gpointer
|
|
gst_va_dmabuf_mem_map (GstMemory * gmem, gsize maxsize, GstMapFlags flags)
|
|
{
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (gmem->allocator);
|
|
VASurfaceID surface = gst_va_memory_get_surface (gmem);
|
|
|
|
if (flags & GST_MAP_READWRITE) {
|
|
if (self->info.drm_modifier != DRM_FORMAT_MOD_LINEAR) {
|
|
GST_ERROR_OBJECT (self, "Failed to map the dmabuf because the modifier "
|
|
"is: %#" G_GINT64_MODIFIER "x, which is not linear.",
|
|
self->info.drm_modifier);
|
|
return NULL;
|
|
}
|
|
|
|
if (!va_sync_surface (self->display, surface))
|
|
return NULL;
|
|
}
|
|
|
|
return self->parent_map (gmem, maxsize, flags);
|
|
}
|
|
|
|
static void
|
|
gst_va_dmabuf_allocator_finalize (GObject * object)
|
|
{
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (object);
|
|
|
|
g_clear_pointer (&self->copy, gst_va_surface_copy_free);
|
|
gst_va_memory_pool_finalize (&self->pool);
|
|
gst_clear_object (&self->display);
|
|
|
|
G_OBJECT_CLASS (dmabuf_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_va_dmabuf_allocator_dispose (GObject * object)
|
|
{
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (object);
|
|
|
|
gst_va_memory_pool_flush_unlocked (&self->pool, self->display);
|
|
if (gst_va_memory_pool_surface_count (&self->pool) != 0) {
|
|
GST_WARNING_OBJECT (self, "Surfaces leaked: %d",
|
|
gst_va_memory_pool_surface_count (&self->pool));
|
|
}
|
|
|
|
G_OBJECT_CLASS (dmabuf_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
gst_va_dmabuf_allocator_class_init (GstVaDmabufAllocatorClass * klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->dispose = gst_va_dmabuf_allocator_dispose;
|
|
object_class->finalize = gst_va_dmabuf_allocator_finalize;
|
|
}
|
|
|
|
static void
|
|
gst_va_dmabuf_allocator_init (GstVaDmabufAllocator * self)
|
|
{
|
|
GstAllocator *allocator = GST_ALLOCATOR (self);
|
|
|
|
self->parent_map = allocator->mem_map;
|
|
allocator->mem_map = gst_va_dmabuf_mem_map;
|
|
self->parent_copy = allocator->mem_copy;
|
|
allocator->mem_copy = gst_va_dmabuf_mem_copy;
|
|
|
|
gst_video_info_dma_drm_init (&self->info);
|
|
|
|
gst_va_memory_pool_init (&self->pool);
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_new:
|
|
* @display: a #GstVaDisplay
|
|
*
|
|
* Instanciate a new pooled allocator backed with both DMABuf and
|
|
* VASurfaceID.
|
|
*
|
|
* Returns: a new allocated #GstAllocator
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstAllocator *
|
|
gst_va_dmabuf_allocator_new (GstVaDisplay * display)
|
|
{
|
|
GstVaDmabufAllocator *self;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DISPLAY (display), NULL);
|
|
|
|
self = g_object_new (GST_TYPE_VA_DMABUF_ALLOCATOR, NULL);
|
|
self->display = gst_object_ref (display);
|
|
gst_object_ref_sink (self);
|
|
|
|
return GST_ALLOCATOR (self);
|
|
}
|
|
|
|
static inline goffset
|
|
_get_fd_size (gint fd)
|
|
{
|
|
#ifndef G_OS_WIN32
|
|
return lseek (fd, 0, SEEK_END);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
static gboolean
|
|
gst_va_dmabuf_memory_release (GstMiniObject * mini_object)
|
|
{
|
|
GstMemory *mem = GST_MEMORY_CAST (mini_object);
|
|
GstVaBufferSurface *buf;
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (mem->allocator);
|
|
guint i;
|
|
|
|
buf = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_surface_quark ());
|
|
if (!buf)
|
|
return TRUE; /* free this unknown buffer */
|
|
|
|
/* if this is the last reference to the GstVaBufferSurface, iterates
|
|
* its array of memories to push them into the queue with thread
|
|
* safetly. */
|
|
GST_VA_MEMORY_POOL_LOCK (&self->pool);
|
|
if (g_atomic_int_dec_and_test (&buf->ref_mems_count)) {
|
|
for (i = 0; i < buf->n_mems; i++) {
|
|
GST_LOG_OBJECT (self, "releasing %p: dmabuf %d, va surface %#x",
|
|
buf->mems[i], gst_dmabuf_memory_get_fd (buf->mems[i]), buf->surface);
|
|
gst_va_memory_pool_push (&self->pool, buf->mems[i]);
|
|
}
|
|
}
|
|
GST_VA_MEMORY_POOL_UNLOCK (&self->pool);
|
|
|
|
/* note: if ref_mem_count doesn't reach zero, that memory will
|
|
* "float" until it's pushed back into the pool by the last va
|
|
* buffer surface ref */
|
|
|
|
/* Keep last in case we are holding on the last allocator ref */
|
|
gst_object_unref (mem->allocator);
|
|
|
|
/* don't call mini_object's free */
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_modifier_found (guint64 modifier, guint64 * modifiers, guint num_modifiers)
|
|
{
|
|
guint i;
|
|
|
|
/* user doesn't care the returned modifier */
|
|
if (num_modifiers == 0)
|
|
return TRUE;
|
|
|
|
for (i = 0; i < num_modifiers; i++)
|
|
if (modifier == modifiers[i])
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
_close_fds (VADRMPRIMESurfaceDescriptor * desc)
|
|
{
|
|
#ifndef G_OS_WIN32
|
|
for (guint32 i = 0; i < desc->num_objects; i++) {
|
|
gint fd = desc->objects[i].fd;
|
|
close (fd);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static gboolean
|
|
_va_create_surface_and_export_to_dmabuf (GstVaDisplay * display,
|
|
guint usage_hint, guint64 * modifiers, guint num_modifiers,
|
|
GstVideoInfo * info, VASurfaceID * ret_surface,
|
|
VADRMPRIMESurfaceDescriptor * ret_desc)
|
|
{
|
|
VADRMPRIMESurfaceDescriptor desc = { 0, };
|
|
guint32 i, fourcc, rt_format, export_flags;
|
|
GstVideoFormat format;
|
|
VASurfaceID surface;
|
|
guint64 prev_modifier = DRM_FORMAT_MOD_INVALID;
|
|
|
|
_init_debug_category ();
|
|
|
|
format = GST_VIDEO_INFO_FORMAT (info);
|
|
|
|
fourcc = gst_va_fourcc_from_video_format (format);
|
|
rt_format = gst_va_chroma_from_video_format (format);
|
|
if (fourcc == 0 || rt_format == 0)
|
|
return FALSE;
|
|
|
|
if (!va_create_surfaces (display, rt_format, fourcc,
|
|
GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info),
|
|
usage_hint, modifiers, num_modifiers, NULL, &surface, 1))
|
|
return FALSE;
|
|
|
|
/* workaround for missing layered dmabuf formats in i965 */
|
|
if (GST_VA_DISPLAY_IS_IMPLEMENTATION (display, INTEL_I965)
|
|
&& (fourcc == VA_FOURCC_YUY2 || fourcc == VA_FOURCC_UYVY)) {
|
|
/* These are not representable as separate planes */
|
|
export_flags = VA_EXPORT_SURFACE_COMPOSED_LAYERS;
|
|
} else {
|
|
/* Each layer will contain exactly one plane. For example, an NV12
|
|
* surface will be exported as two layers */
|
|
export_flags = VA_EXPORT_SURFACE_SEPARATE_LAYERS;
|
|
}
|
|
|
|
export_flags |= VA_EXPORT_SURFACE_READ_WRITE;
|
|
|
|
if (!va_export_surface_to_dmabuf (display, surface, export_flags, &desc))
|
|
goto failed;
|
|
|
|
if (GST_VIDEO_INFO_N_PLANES (info) != desc.num_layers)
|
|
goto failed;
|
|
|
|
/* YUY2 and YUYV are the same. radeonsi returns always YUYV.
|
|
* There's no reason to fail if the different fourcc if there're dups.
|
|
* https://fourcc.org/pixel-format/yuv-yuy2/ */
|
|
if (fourcc != desc.fourcc) {
|
|
GST_INFO ("Different fourcc: requested %" GST_FOURCC_FORMAT " - returned %"
|
|
GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc),
|
|
GST_FOURCC_ARGS (desc.fourcc));
|
|
}
|
|
|
|
if (desc.num_objects == 0) {
|
|
GST_ERROR ("Failed to export surface to dmabuf");
|
|
goto failed;
|
|
}
|
|
|
|
for (i = 0; i < desc.num_objects; i++) {
|
|
guint64 modifier = desc.objects[i].drm_format_modifier;
|
|
|
|
if (!_modifier_found (modifier, modifiers, num_modifiers)) {
|
|
GST_ERROR ("driver set a modifier different from allowed list: "
|
|
"0x%016" G_GINT64_MODIFIER "x", modifier);
|
|
goto failed;
|
|
}
|
|
/* XXX: all dmabufs in buffer have to have the same modifier, otherwise the
|
|
* drm-format field in caps is ill-designed */
|
|
if (i > 0 && modifier != prev_modifier) {
|
|
GST_ERROR ("Different objects have different modifier");
|
|
goto failed;
|
|
}
|
|
|
|
prev_modifier = modifier;
|
|
}
|
|
|
|
*ret_surface = surface;
|
|
if (ret_desc)
|
|
*ret_desc = desc;
|
|
|
|
return TRUE;
|
|
|
|
failed:
|
|
{
|
|
/* Free DMAbufs on failure */
|
|
_close_fds (&desc);
|
|
va_destroy_surfaces (display, &surface, 1);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_get_modifier_for_format:
|
|
* @display: a #GstVaDisplay
|
|
* @format: a #GstVideoFormat
|
|
* @usage_hint: VA usage hint
|
|
*
|
|
* Get the underlying modifier for specified @format and @usage_hint.
|
|
*
|
|
* Returns: the underlying modifier.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
guint64
|
|
gst_va_dmabuf_get_modifier_for_format (GstVaDisplay * display,
|
|
GstVideoFormat format, guint usage_hint)
|
|
{
|
|
VADRMPRIMESurfaceDescriptor desc = { 0, };
|
|
VASurfaceID surface;
|
|
GstVideoInfo info;
|
|
|
|
gst_video_info_init (&info);
|
|
gst_video_info_set_format (&info, format, 64, 64);
|
|
|
|
if (!_va_create_surface_and_export_to_dmabuf (display, usage_hint,
|
|
NULL, 0, &info, &surface, &desc))
|
|
return DRM_FORMAT_MOD_INVALID;
|
|
|
|
/* Close the fds we won't be using */
|
|
_close_fds (&desc);
|
|
va_destroy_surfaces (display, &surface, 1);
|
|
|
|
return desc.objects[0].drm_format_modifier;
|
|
}
|
|
|
|
/* Creates an exported VASurfaceID and adds it as @buffer's memories
|
|
* qdata
|
|
*
|
|
* If @info is not NULL, a dummy (non-pooled) buffer is created to
|
|
* update offsets and strides, and it has to be unrefed immediately.
|
|
*/
|
|
static gboolean
|
|
gst_va_dmabuf_allocator_setup_buffer_full (GstAllocator * allocator,
|
|
GstBuffer * buffer, GstVideoInfoDmaDrm * info)
|
|
{
|
|
GstVaBufferSurface *buf;
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
VADRMPRIMESurfaceDescriptor desc = { 0, };
|
|
VASurfaceID surface;
|
|
guint32 i;
|
|
GDestroyNotify buffer_destroy = NULL;
|
|
gsize object_offset[4];
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DMABUF_ALLOCATOR (allocator), FALSE);
|
|
|
|
if (!_va_create_surface_and_export_to_dmabuf (self->display, self->usage_hint,
|
|
&self->info.drm_modifier, 1, &self->info.vinfo, &surface, &desc))
|
|
return FALSE;
|
|
|
|
buf = gst_va_buffer_surface_new (surface);
|
|
if (G_UNLIKELY (info))
|
|
*info = self->info;
|
|
|
|
buf->n_mems = desc.num_objects;
|
|
|
|
for (i = 0; i < desc.num_objects; i++) {
|
|
gint fd = desc.objects[i].fd;
|
|
/* prime descriptor reports the total size of the object, including regions
|
|
* which aren't part surface's space. Let's just grab the surface's size: */
|
|
gsize size = _get_fd_size (fd);
|
|
GstMemory *mem = gst_dmabuf_allocator_alloc (allocator, fd, size);
|
|
|
|
if (desc.objects[i].size < size) {
|
|
GST_WARNING_OBJECT (self, "driver bug: fd size (%" G_GSIZE_FORMAT
|
|
") is bigger than object descriptor size (%" G_GUINT32_FORMAT ")",
|
|
size, desc.objects[i].size);
|
|
}
|
|
|
|
object_offset[i] = gst_buffer_get_size (buffer);
|
|
gst_buffer_append_memory (buffer, mem);
|
|
buf->mems[i] = mem;
|
|
|
|
if (G_LIKELY (!info)) {
|
|
GST_MINI_OBJECT (mem)->dispose = gst_va_dmabuf_memory_release;
|
|
g_atomic_int_add (&buf->ref_mems_count, 1);
|
|
} else {
|
|
/* if no @info, surface will be destroyed as soon as buffer is
|
|
* destroyed (e.g. gst_va_dmabuf_allocator_try()) */
|
|
buf->display = gst_object_ref (self->display);
|
|
buffer_destroy = gst_va_buffer_surface_unref;
|
|
}
|
|
|
|
g_atomic_int_add (&buf->ref_count, 1);
|
|
gst_mini_object_set_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_surface_quark (), buf, buffer_destroy);
|
|
|
|
if (G_UNLIKELY (info)) {
|
|
GST_VIDEO_INFO_PLANE_OFFSET (&info->vinfo, i) =
|
|
GST_VIDEO_INFO_SIZE (&info->vinfo);
|
|
}
|
|
|
|
GST_LOG_OBJECT (self, "buffer %p: new dmabuf %d / surface %#x [%dx%d] "
|
|
"size %" G_GSIZE_FORMAT " drm mod %#" G_GINT64_MODIFIER "x",
|
|
buffer, fd, surface, GST_VIDEO_INFO_WIDTH (&self->info.vinfo),
|
|
GST_VIDEO_INFO_HEIGHT (&self->info.vinfo), size,
|
|
self->info.drm_modifier);
|
|
}
|
|
|
|
if (G_UNLIKELY (info)) {
|
|
if (desc.num_objects > 0) {
|
|
/* update drm modifier and format */
|
|
info->drm_modifier = desc.objects[0].drm_format_modifier;
|
|
info->drm_fourcc = gst_va_drm_fourcc_from_video_format
|
|
(GST_VIDEO_INFO_FORMAT (&self->info.vinfo));
|
|
}
|
|
|
|
GST_VIDEO_INFO_SIZE (&info->vinfo) = gst_buffer_get_size (buffer);
|
|
|
|
for (i = 0; i < desc.num_layers; i++) {
|
|
g_assert (desc.layers[i].num_planes == 1);
|
|
GST_VIDEO_INFO_PLANE_OFFSET (&info->vinfo, i) =
|
|
object_offset[desc.layers[i].object_index[0]] +
|
|
desc.layers[i].offset[0];
|
|
GST_VIDEO_INFO_PLANE_STRIDE (&info->vinfo, i) = desc.layers[i].pitch[0];
|
|
}
|
|
} else {
|
|
gst_va_memory_pool_surface_inc (&self->pool);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_setup_buffer:
|
|
* @allocator: a #GstAllocator
|
|
* @buffer: an empty #GstBuffer
|
|
*
|
|
* This function creates a new VASurfaceID and exposes its DMABufs,
|
|
* later it populates the @buffer with those DMABufs.
|
|
*
|
|
* Return: %TRUE if @buffer is populated correctly; %FALSE otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_dmabuf_allocator_setup_buffer (GstAllocator * allocator,
|
|
GstBuffer * buffer)
|
|
{
|
|
return gst_va_dmabuf_allocator_setup_buffer_full (allocator, buffer, NULL);
|
|
}
|
|
|
|
static VASurfaceID
|
|
gst_va_dmabuf_allocator_prepare_buffer_unlocked (GstVaDmabufAllocator * self,
|
|
GstBuffer * buffer)
|
|
{
|
|
GstMemory *mems[GST_VIDEO_MAX_PLANES] = { 0, };
|
|
GstVaBufferSurface *buf;
|
|
gint i, j, idx;
|
|
|
|
mems[0] = gst_va_memory_pool_pop (&self->pool);
|
|
if (!mems[0])
|
|
return VA_INVALID_ID;
|
|
|
|
buf = gst_mini_object_get_qdata (GST_MINI_OBJECT (mems[0]),
|
|
gst_va_buffer_surface_quark ());
|
|
if (!buf)
|
|
return VA_INVALID_ID;
|
|
|
|
if (buf->surface == VA_INVALID_ID)
|
|
return VA_INVALID_ID;
|
|
|
|
for (idx = 1; idx < buf->n_mems; idx++) {
|
|
/* grab next memory from queue */
|
|
{
|
|
GstMemory *mem;
|
|
GstVaBufferSurface *pbuf;
|
|
|
|
mem = gst_va_memory_pool_peek (&self->pool);
|
|
if (!mem)
|
|
return VA_INVALID_ID;
|
|
|
|
pbuf = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_surface_quark ());
|
|
if (!pbuf)
|
|
return VA_INVALID_ID;
|
|
|
|
if (pbuf->surface != buf->surface) {
|
|
GST_WARNING_OBJECT (self,
|
|
"expecting memory with surface %#x but got %#x: "
|
|
"possible memory interweaving", buf->surface, pbuf->surface);
|
|
return VA_INVALID_ID;
|
|
}
|
|
}
|
|
|
|
mems[idx] = gst_va_memory_pool_pop (&self->pool);
|
|
};
|
|
|
|
/* append memories */
|
|
for (i = 0; i < buf->n_mems; i++) {
|
|
gboolean found = FALSE;
|
|
|
|
/* find next memory to append */
|
|
for (j = 0; j < idx; j++) {
|
|
if (buf->mems[i] == mems[j]) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if not found, free all the popped memories and bail */
|
|
if (!found) {
|
|
if (!buf->display)
|
|
buf->display = gst_object_ref (self->display);
|
|
for (j = 0; j < idx; j++) {
|
|
gst_object_ref (buf->mems[j]->allocator);
|
|
GST_MINI_OBJECT (mems[j])->dispose = NULL;
|
|
gst_memory_unref (mems[j]);
|
|
}
|
|
return VA_INVALID_ID;
|
|
}
|
|
|
|
g_atomic_int_add (&buf->ref_mems_count, 1);
|
|
gst_object_ref (buf->mems[i]->allocator);
|
|
gst_buffer_append_memory (buffer, buf->mems[i]);
|
|
|
|
GST_LOG ("bufer %p: memory %p - dmabuf %d / surface %#x", buffer,
|
|
buf->mems[i], gst_dmabuf_memory_get_fd (buf->mems[i]),
|
|
gst_va_memory_get_surface (buf->mems[i]));
|
|
}
|
|
|
|
return buf->surface;
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_prepare_buffer:
|
|
* @allocator: a #GstAllocator
|
|
* @buffer: an empty #GstBuffer
|
|
*
|
|
* This method will populate @buffer with pooled VASurfaceID/DMABuf
|
|
* memories. It doesn't allocate new VASurfacesID.
|
|
*
|
|
* Returns: %TRUE if @buffer was populated correctly; %FALSE
|
|
* otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_dmabuf_allocator_prepare_buffer (GstAllocator * allocator,
|
|
GstBuffer * buffer)
|
|
{
|
|
GstVaDmabufAllocator *self;
|
|
VASurfaceID surface;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DMABUF_ALLOCATOR (allocator), FALSE);
|
|
|
|
self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
|
|
GST_VA_MEMORY_POOL_LOCK (&self->pool);
|
|
surface = gst_va_dmabuf_allocator_prepare_buffer_unlocked (self, buffer);
|
|
GST_VA_MEMORY_POOL_UNLOCK (&self->pool);
|
|
|
|
return (surface != VA_INVALID_ID);
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_flush:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Removes all the memories in @allocator's pool.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
void
|
|
gst_va_dmabuf_allocator_flush (GstAllocator * allocator)
|
|
{
|
|
GstVaDmabufAllocator *self;
|
|
|
|
g_return_if_fail (GST_IS_VA_DMABUF_ALLOCATOR (allocator));
|
|
|
|
self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
|
|
gst_va_memory_pool_flush (&self->pool, self->display);
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_try:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Try to allocate a test buffer in order to verify that the
|
|
* allocator's configuration is valid.
|
|
*
|
|
* Returns: %TRUE if the configuration is valid; %FALSE otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
static gboolean
|
|
gst_va_dmabuf_allocator_try (GstAllocator * allocator)
|
|
{
|
|
GstBuffer *buffer;
|
|
GstVaDmabufAllocator *self;
|
|
GstVideoInfoDmaDrm info;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DMABUF_ALLOCATOR (allocator), FALSE);
|
|
|
|
self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
info = self->info;
|
|
|
|
buffer = gst_buffer_new ();
|
|
ret = gst_va_dmabuf_allocator_setup_buffer_full (allocator, buffer, &info);
|
|
gst_buffer_unref (buffer);
|
|
|
|
if (ret)
|
|
self->info = info;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_set_format:
|
|
* @allocator: a #GstAllocator
|
|
* @info: (in) (out caller-allocates) (not nullable): a #GstVideoInfoDmaDrm
|
|
* @usage_hint: VA usage hint
|
|
*
|
|
* Sets the configuration defined by @info and @usage_hint for
|
|
* @allocator, and it tries the configuration, if @allocator has not
|
|
* allocated memories yet.
|
|
*
|
|
* If @allocator has memory allocated already, and frame size, format
|
|
* and modifier in @info are the same as currently configured in
|
|
* @allocator, the rest of @info parameters are updated internally.
|
|
*
|
|
* Returns: %TRUE if the configuration is valid or updated; %FALSE if
|
|
* configuration is not valid or not updated.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_dmabuf_allocator_set_format (GstAllocator * allocator,
|
|
GstVideoInfoDmaDrm * info, guint usage_hint)
|
|
{
|
|
GstVaDmabufAllocator *self;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DMABUF_ALLOCATOR (allocator), FALSE);
|
|
g_return_val_if_fail (info, FALSE);
|
|
|
|
self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
|
|
if (gst_va_memory_pool_surface_count (&self->pool) != 0) {
|
|
if (info->drm_modifier == self->info.drm_modifier
|
|
&& GST_VIDEO_INFO_FORMAT (&info->vinfo)
|
|
== GST_VIDEO_INFO_FORMAT (&self->info.vinfo)
|
|
&& GST_VIDEO_INFO_WIDTH (&info->vinfo)
|
|
== GST_VIDEO_INFO_WIDTH (&self->info.vinfo)
|
|
&& GST_VIDEO_INFO_HEIGHT (&info->vinfo)
|
|
== GST_VIDEO_INFO_HEIGHT (&self->info.vinfo)
|
|
&& usage_hint == self->usage_hint) {
|
|
*info = self->info; /* update callee info (offset & stride) */
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
self->usage_hint = usage_hint;
|
|
self->info = *info;
|
|
|
|
g_clear_pointer (&self->copy, gst_va_surface_copy_free);
|
|
|
|
ret = gst_va_dmabuf_allocator_try (allocator);
|
|
|
|
if (ret)
|
|
*info = self->info;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_allocator_get_format:
|
|
* @allocator: a #GstAllocator
|
|
* @info: (out) (optional): a #GstVideoInfoDmaDrm
|
|
* @usage_hint: (out) (optional): VA usage hint
|
|
*
|
|
* Gets current internal configuration of @allocator.
|
|
*
|
|
* Returns: %TRUE if @allocator is already configured; %FALSE
|
|
* otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_dmabuf_allocator_get_format (GstAllocator * allocator,
|
|
GstVideoInfoDmaDrm * info, guint * usage_hint)
|
|
{
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (allocator);
|
|
|
|
if (GST_VIDEO_INFO_FORMAT (&self->info.vinfo) == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return FALSE;
|
|
|
|
if (info)
|
|
*info = self->info;
|
|
if (usage_hint)
|
|
*usage_hint = self->usage_hint;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_is_fd_repeated (uintptr_t fds[GST_VIDEO_MAX_PLANES], guint cur, guint * prev)
|
|
{
|
|
guint i;
|
|
|
|
g_assert (cur <= GST_VIDEO_MAX_PLANES);
|
|
|
|
if (cur == 0)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < cur; i++) {
|
|
if (fds[i] == fds[cur]) {
|
|
if (prev)
|
|
*prev = i;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_dmabuf_memories_setup:
|
|
* @display: a #GstVaDisplay
|
|
* @drm_info: a #GstVideoInfoDmaDrm
|
|
* @mem: (array fixed-size=4) (element-type GstMemory): Memories. One
|
|
* per plane.
|
|
* @fds: (array fixed-size=4) (element-type uintptr_t): array of
|
|
* DMABuf file descriptors.
|
|
* @offset: (array fixed-size=4) (element-type gsize): array of memory
|
|
* offsets.
|
|
* @usage_hint: VA usage hint.
|
|
*
|
|
* It imports the array of @mem, representing a single frame, into a
|
|
* VASurfaceID and it's attached into every @mem.
|
|
*
|
|
* Returns: %TRUE if frame is imported correctly into a VASurfaceID;
|
|
* %FALSE otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
/* XXX: use a surface pool to control the created surfaces */
|
|
gboolean
|
|
gst_va_dmabuf_memories_setup (GstVaDisplay * display,
|
|
GstVideoInfoDmaDrm * drm_info, GstMemory * mem[GST_VIDEO_MAX_PLANES],
|
|
uintptr_t fds[GST_VIDEO_MAX_PLANES], gsize offset[GST_VIDEO_MAX_PLANES],
|
|
guint usage_hint)
|
|
{
|
|
GstVideoFormat format;
|
|
GstVaBufferSurface *buf;
|
|
GstVideoInfo *info = &drm_info->vinfo;
|
|
/* *INDENT-OFF* */
|
|
VADRMPRIMESurfaceDescriptor desc = {
|
|
.width = GST_VIDEO_INFO_WIDTH (info),
|
|
.height = GST_VIDEO_INFO_HEIGHT (info),
|
|
/* GStreamer can only describe one PRIME layer */
|
|
.num_layers = 1,
|
|
};
|
|
/* *INDENT-ON* */
|
|
VASurfaceID surface;
|
|
guint32 fourcc, rt_format, drm_fourcc;
|
|
guint64 drm_modifier;
|
|
guint i, j, prev, n_planes;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DISPLAY (display), FALSE);
|
|
|
|
n_planes = GST_VIDEO_INFO_N_PLANES (info);
|
|
|
|
format = (drm_info->drm_fourcc == DRM_FORMAT_INVALID) ?
|
|
GST_VIDEO_INFO_FORMAT (info) :
|
|
gst_va_video_format_from_drm_fourcc (drm_info->drm_fourcc);
|
|
if (format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return FALSE;
|
|
|
|
drm_fourcc = (drm_info->drm_fourcc == DRM_FORMAT_INVALID) ?
|
|
gst_va_drm_fourcc_from_video_format (format) : drm_info->drm_fourcc;
|
|
if (drm_fourcc == 0)
|
|
return FALSE;
|
|
|
|
rt_format = gst_va_chroma_from_video_format (format);
|
|
if (rt_format == 0)
|
|
return FALSE;
|
|
|
|
fourcc = gst_va_fourcc_from_video_format (format);
|
|
if (fourcc == 0)
|
|
return FALSE;
|
|
|
|
drm_modifier = (drm_info->drm_modifier == DRM_FORMAT_MOD_INVALID) ?
|
|
DRM_FORMAT_MOD_LINEAR : drm_info->drm_modifier;
|
|
|
|
desc.fourcc = fourcc;
|
|
desc.layers[0].num_planes = n_planes;
|
|
desc.layers[0].drm_format = drm_fourcc;
|
|
|
|
for (i = j = 0; i < n_planes; i++) {
|
|
desc.layers[0].pitch[i] = GST_VIDEO_INFO_PLANE_STRIDE (info, i);
|
|
desc.layers[0].offset[i] = offset[i];
|
|
|
|
if (_is_fd_repeated (fds, i, &prev)) {
|
|
desc.layers[0].object_index[i] = prev;
|
|
continue;
|
|
}
|
|
|
|
desc.objects[j].fd = fds[i];
|
|
desc.objects[j].size = _get_fd_size (fds[i]);
|
|
desc.objects[j].drm_format_modifier = drm_modifier;
|
|
|
|
desc.layers[0].object_index[i] = j;
|
|
j++;
|
|
}
|
|
|
|
desc.num_objects = j;
|
|
|
|
ret = va_create_surfaces (display, rt_format, fourcc, desc.width, desc.height,
|
|
usage_hint, NULL, 0, &desc, &surface, 1);
|
|
if (!ret)
|
|
return FALSE;
|
|
|
|
GST_LOG_OBJECT (display, "Created surface %#x [%dx%d]", surface, desc.width,
|
|
desc.height);
|
|
|
|
buf = gst_va_buffer_surface_new (surface);
|
|
buf->display = gst_object_ref (display);
|
|
buf->n_mems = n_planes;
|
|
memcpy (buf->mems, mem, sizeof (buf->mems));
|
|
|
|
for (i = 0; i < n_planes; i++) {
|
|
g_atomic_int_add (&buf->ref_count, 1);
|
|
gst_mini_object_set_qdata (GST_MINI_OBJECT (mem[i]),
|
|
gst_va_buffer_surface_quark (), buf, gst_va_buffer_surface_unref);
|
|
GST_INFO_OBJECT (display, "setting surface %#x to dmabuf fd %d",
|
|
buf->surface, gst_dmabuf_memory_get_fd (mem[i]));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*===================== GstVaAllocator / GstVaMemory =========================*/
|
|
|
|
/**
|
|
* GstVaAllocator:
|
|
*
|
|
* A pooled memory allocator backed by VASurfaceID.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
typedef struct _GstVaAllocator GstVaAllocator;
|
|
typedef struct _GstVaAllocatorClass GstVaAllocatorClass;
|
|
|
|
struct _GstVaAllocator
|
|
{
|
|
GstAllocator parent;
|
|
|
|
GstVaDisplay *display;
|
|
|
|
gboolean use_derived;
|
|
GArray *surface_formats;
|
|
|
|
GstVideoFormat surface_format;
|
|
GstVideoFormat img_format;
|
|
guint32 fourcc;
|
|
guint32 rt_format;
|
|
|
|
GstVideoInfo info;
|
|
guint usage_hint;
|
|
|
|
guint32 hacks;
|
|
|
|
GstVaSurfaceCopy *copy;
|
|
|
|
GstVaMemoryPool pool;
|
|
};
|
|
|
|
struct _GstVaAllocatorClass
|
|
{
|
|
GstAllocatorClass parent_class;
|
|
};
|
|
|
|
typedef struct _GstVaMemory GstVaMemory;
|
|
struct _GstVaMemory
|
|
{
|
|
GstMemory mem;
|
|
|
|
VASurfaceID surface;
|
|
GstVideoFormat surface_format;
|
|
VAImage image;
|
|
gpointer mapped_data;
|
|
|
|
GstMapFlags prev_mapflags;
|
|
gint map_count;
|
|
|
|
gboolean is_derived;
|
|
gboolean is_dirty;
|
|
GMutex lock;
|
|
};
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GstVaAllocator, gst_va_allocator, GST_TYPE_ALLOCATOR,
|
|
_init_debug_category ());
|
|
|
|
static gboolean _va_unmap (GstVaMemory * mem);
|
|
|
|
static void
|
|
gst_va_allocator_finalize (GObject * object)
|
|
{
|
|
GstVaAllocator *self = GST_VA_ALLOCATOR (object);
|
|
|
|
g_clear_pointer (&self->copy, gst_va_surface_copy_free);
|
|
gst_va_memory_pool_finalize (&self->pool);
|
|
g_clear_pointer (&self->surface_formats, g_array_unref);
|
|
gst_clear_object (&self->display);
|
|
|
|
G_OBJECT_CLASS (gst_va_allocator_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_va_allocator_dispose (GObject * object)
|
|
{
|
|
GstVaAllocator *self = GST_VA_ALLOCATOR (object);
|
|
|
|
gst_va_memory_pool_flush_unlocked (&self->pool, self->display);
|
|
if (gst_va_memory_pool_surface_count (&self->pool) != 0) {
|
|
GST_WARNING_OBJECT (self, "Surfaces leaked: %d",
|
|
gst_va_memory_pool_surface_count (&self->pool));
|
|
}
|
|
|
|
G_OBJECT_CLASS (gst_va_allocator_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
_va_free (GstAllocator * allocator, GstMemory * mem)
|
|
{
|
|
GstVaAllocator *self = GST_VA_ALLOCATOR (allocator);
|
|
GstVaMemory *va_mem = (GstVaMemory *) mem;
|
|
|
|
if (va_mem->mapped_data) {
|
|
g_warning (G_STRLOC ":%s: Freeing memory %p still mapped", G_STRFUNC,
|
|
va_mem);
|
|
_va_unmap (va_mem);
|
|
}
|
|
|
|
if (va_mem->surface != VA_INVALID_ID && mem->parent == NULL) {
|
|
GST_LOG_OBJECT (self, "Destroying surface %#x", va_mem->surface);
|
|
va_destroy_surfaces (self->display, &va_mem->surface, 1);
|
|
}
|
|
|
|
g_mutex_clear (&va_mem->lock);
|
|
|
|
g_free (va_mem);
|
|
}
|
|
|
|
static void
|
|
gst_va_allocator_class_init (GstVaAllocatorClass * klass)
|
|
{
|
|
GstAllocatorClass *allocator_class = GST_ALLOCATOR_CLASS (klass);
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->dispose = gst_va_allocator_dispose;
|
|
object_class->finalize = gst_va_allocator_finalize;
|
|
allocator_class->free = _va_free;
|
|
}
|
|
|
|
static inline void
|
|
_clean_mem (GstVaMemory * mem)
|
|
{
|
|
memset (&mem->image, 0, sizeof (mem->image));
|
|
mem->image.image_id = VA_INVALID_ID;
|
|
mem->image.buf = VA_INVALID_ID;
|
|
|
|
mem->is_derived = FALSE;
|
|
mem->is_dirty = FALSE;
|
|
mem->prev_mapflags = 0;
|
|
mem->mapped_data = NULL;
|
|
}
|
|
|
|
static void
|
|
_reset_mem (GstVaMemory * mem, GstAllocator * allocator, gsize size)
|
|
{
|
|
_clean_mem (mem);
|
|
g_atomic_int_set (&mem->map_count, 0);
|
|
g_mutex_init (&mem->lock);
|
|
|
|
gst_memory_init (GST_MEMORY_CAST (mem), 0, allocator, NULL, size,
|
|
0 /* align */ , 0 /* offset */ , size);
|
|
}
|
|
|
|
#ifndef G_OS_WIN32
|
|
static inline gboolean
|
|
_is_old_mesa (GstVaAllocator * va_allocator)
|
|
{
|
|
return GST_VA_DISPLAY_IS_IMPLEMENTATION (va_allocator->display, MESA_GALLIUM)
|
|
&& !gst_va_display_check_version (va_allocator->display, 23, 3);
|
|
}
|
|
#endif /* G_OS_WIN32 */
|
|
|
|
static inline void
|
|
_update_info (GstVideoInfo * info, const VAImage * image)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < image->num_planes; i++) {
|
|
GST_VIDEO_INFO_PLANE_OFFSET (info, i) = image->offsets[i];
|
|
GST_VIDEO_INFO_PLANE_STRIDE (info, i) = image->pitches[i];
|
|
}
|
|
|
|
/* Don't update image size for one planed images since drivers might add extra
|
|
* bits which will drop wrong raw images with filesink, for example. Multiple
|
|
* plane images require video meta */
|
|
if (image->num_planes > 1)
|
|
GST_VIDEO_INFO_SIZE (info) = image->data_size;
|
|
}
|
|
|
|
static inline gboolean
|
|
_update_image_info (GstVaAllocator * va_allocator,
|
|
GstVaFeature feat_use_derived)
|
|
{
|
|
VASurfaceID surface;
|
|
VAImage image = {.image_id = VA_INVALID_ID, };
|
|
|
|
/* Create a test surface first */
|
|
if (!va_create_surfaces (va_allocator->display, va_allocator->rt_format,
|
|
va_allocator->fourcc, GST_VIDEO_INFO_WIDTH (&va_allocator->info),
|
|
GST_VIDEO_INFO_HEIGHT (&va_allocator->info), va_allocator->usage_hint,
|
|
NULL, 0, NULL, &surface, 1)) {
|
|
GST_ERROR_OBJECT (va_allocator, "Failed to create a test surface");
|
|
return FALSE;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (va_allocator, "Created surface %#x [%dx%d]", surface,
|
|
GST_VIDEO_INFO_WIDTH (&va_allocator->info),
|
|
GST_VIDEO_INFO_HEIGHT (&va_allocator->info));
|
|
|
|
#ifdef G_OS_WIN32
|
|
/* XXX: Derived image is problematic for D3D backend */
|
|
if (feat_use_derived != GST_VA_FEATURE_DISABLED) {
|
|
GST_INFO_OBJECT (va_allocator, "Disable image derive on Windows.");
|
|
feat_use_derived = GST_VA_FEATURE_DISABLED;
|
|
}
|
|
va_allocator->use_derived = FALSE;
|
|
#else
|
|
/* XXX: Derived in radeonsi Mesa <23.3 can't use derived images for several
|
|
* cases
|
|
* https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24381
|
|
* https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26174
|
|
*/
|
|
if (_is_old_mesa (va_allocator)) {
|
|
if (feat_use_derived != GST_VA_FEATURE_DISABLED) {
|
|
GST_INFO_OBJECT (va_allocator,
|
|
"Disable image derive on old Mesa (< 23.3).");
|
|
feat_use_derived = GST_VA_FEATURE_DISABLED;
|
|
}
|
|
va_allocator->use_derived = FALSE;
|
|
}
|
|
#endif
|
|
/* Try derived first, but different formats can never derive */
|
|
if (feat_use_derived != GST_VA_FEATURE_DISABLED
|
|
&& va_allocator->surface_format == va_allocator->img_format) {
|
|
va_allocator->use_derived =
|
|
va_get_derive_image (va_allocator->display, surface, &image);
|
|
if (va_allocator->use_derived)
|
|
goto done;
|
|
image.image_id = VA_INVALID_ID; /* reset it */
|
|
}
|
|
|
|
if (feat_use_derived == GST_VA_FEATURE_ENABLED && !va_allocator->use_derived)
|
|
GST_WARNING_OBJECT (va_allocator, "Derived images are disabled.");
|
|
|
|
/* Then we try to create a image. */
|
|
if (!va_create_image (va_allocator->display, va_allocator->img_format,
|
|
GST_VIDEO_INFO_WIDTH (&va_allocator->info),
|
|
GST_VIDEO_INFO_HEIGHT (&va_allocator->info), &image)) {
|
|
va_destroy_surfaces (va_allocator->display, &surface, 1);
|
|
return FALSE;
|
|
}
|
|
|
|
done:
|
|
_update_info (&va_allocator->info, &image);
|
|
if (GST_VIDEO_INFO_SIZE (&va_allocator->info) > image.data_size) {
|
|
GST_WARNING_OBJECT (va_allocator,
|
|
"image size is lesser than the minimum required");
|
|
}
|
|
|
|
va_destroy_image (va_allocator->display, image.image_id);
|
|
va_destroy_surfaces (va_allocator->display, &surface, 1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gpointer
|
|
_va_map_unlocked (GstVaMemory * mem, GstMapFlags flags)
|
|
{
|
|
GstAllocator *allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
GstVaAllocator *va_allocator;
|
|
GstVaDisplay *display;
|
|
|
|
g_return_val_if_fail (mem->surface != VA_INVALID_ID, NULL);
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), NULL);
|
|
|
|
if (g_atomic_int_get (&mem->map_count) > 0) {
|
|
if (!(mem->prev_mapflags & flags) || !mem->mapped_data)
|
|
return NULL;
|
|
else
|
|
goto success;
|
|
}
|
|
|
|
va_allocator = GST_VA_ALLOCATOR (allocator);
|
|
display = va_allocator->display;
|
|
|
|
if (flags & GST_MAP_WRITE) {
|
|
mem->is_dirty = TRUE;
|
|
} else { /* GST_MAP_READ only */
|
|
mem->is_dirty = FALSE;
|
|
}
|
|
|
|
if (flags & GST_MAP_VA) {
|
|
mem->mapped_data = &mem->surface;
|
|
goto success;
|
|
}
|
|
|
|
mem->is_derived = va_allocator->use_derived;
|
|
|
|
if (!va_ensure_image (display, mem->surface, &va_allocator->info, &mem->image,
|
|
va_allocator->use_derived))
|
|
return NULL;
|
|
|
|
if (!mem->is_derived) {
|
|
if (!va_get_image (display, mem->surface, &mem->image))
|
|
goto fail;
|
|
}
|
|
|
|
if (!va_map_buffer (display, mem->image.buf, flags, &mem->mapped_data))
|
|
goto fail;
|
|
|
|
success:
|
|
{
|
|
mem->prev_mapflags = flags;
|
|
g_atomic_int_add (&mem->map_count, 1);
|
|
return mem->mapped_data;
|
|
}
|
|
|
|
fail:
|
|
{
|
|
va_destroy_image (display, mem->image.image_id);
|
|
_clean_mem (mem);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static gpointer
|
|
_va_map (GstVaMemory * mem, gsize maxsize, GstMapFlags flags)
|
|
{
|
|
gpointer data;
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
data = _va_map_unlocked (mem, flags);
|
|
g_mutex_unlock (&mem->lock);
|
|
|
|
return data;
|
|
}
|
|
|
|
static gboolean
|
|
_va_unmap_unlocked (GstVaMemory * mem)
|
|
{
|
|
GstAllocator *allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
GstVaDisplay *display;
|
|
gboolean ret = TRUE;
|
|
|
|
if (!g_atomic_int_dec_and_test (&mem->map_count))
|
|
return TRUE;
|
|
|
|
if (mem->prev_mapflags & GST_MAP_VA)
|
|
goto bail;
|
|
|
|
display = GST_VA_ALLOCATOR (allocator)->display;
|
|
|
|
if (mem->image.image_id != VA_INVALID_ID) {
|
|
if (mem->is_dirty && !mem->is_derived) {
|
|
ret = va_put_image (display, mem->surface, &mem->image);
|
|
mem->is_dirty = FALSE;
|
|
}
|
|
/* XXX(victor): if is derived and is dirty, create another surface
|
|
* an replace it in mem */
|
|
}
|
|
|
|
ret &= va_unmap_buffer (display, mem->image.buf);
|
|
ret &= va_destroy_image (display, mem->image.image_id);
|
|
|
|
bail:
|
|
_clean_mem (mem);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
_va_unmap (GstVaMemory * mem)
|
|
{
|
|
gboolean ret;
|
|
|
|
g_mutex_lock (&mem->lock);
|
|
ret = _va_unmap_unlocked (mem);
|
|
g_mutex_unlock (&mem->lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstMemory *
|
|
_va_share (GstMemory * mem, gssize offset, gssize size)
|
|
{
|
|
GstVaMemory *vamem = (GstVaMemory *) mem;
|
|
GstVaMemory *sub;
|
|
GstMemory *parent;
|
|
|
|
GST_DEBUG ("%p: share %" G_GSSIZE_FORMAT ", %" G_GSIZE_FORMAT, mem, offset,
|
|
size);
|
|
|
|
/* find real parent */
|
|
if ((parent = vamem->mem.parent) == NULL)
|
|
parent = (GstMemory *) vamem;
|
|
|
|
if (size == -1)
|
|
size = mem->maxsize - offset;
|
|
|
|
sub = g_new (GstVaMemory, 1);
|
|
|
|
/* the shared memory is alwyas readonly */
|
|
gst_memory_init (GST_MEMORY_CAST (sub), GST_MINI_OBJECT_FLAGS (parent) |
|
|
GST_MINI_OBJECT_FLAG_LOCK_READONLY, vamem->mem.allocator, parent,
|
|
vamem->mem.maxsize, vamem->mem.align, vamem->mem.offset + offset, size);
|
|
|
|
sub->surface = vamem->surface;
|
|
sub->surface_format = vamem->surface_format;
|
|
|
|
_clean_mem (sub);
|
|
|
|
g_atomic_int_set (&sub->map_count, 0);
|
|
g_mutex_init (&sub->lock);
|
|
|
|
return GST_MEMORY_CAST (sub);
|
|
}
|
|
|
|
/* XXX(victor): deep copy implementation. */
|
|
static GstMemory *
|
|
_va_copy (GstMemory * mem, gssize offset, gssize size)
|
|
{
|
|
GstMemory *copy;
|
|
GstMapInfo sinfo, dinfo;
|
|
GstVaAllocator *va_allocator = GST_VA_ALLOCATOR (mem->allocator);
|
|
GstVaMemory *va_copy, *va_mem = (GstVaMemory *) mem;
|
|
gsize mem_size;
|
|
|
|
GST_DEBUG ("%p: copy %" G_GSSIZE_FORMAT ", %" G_GSIZE_FORMAT, mem, offset,
|
|
size);
|
|
|
|
{
|
|
GST_VA_MEMORY_POOL_LOCK (&va_allocator->pool);
|
|
copy = gst_va_memory_pool_pop (&va_allocator->pool);
|
|
GST_VA_MEMORY_POOL_UNLOCK (&va_allocator->pool);
|
|
|
|
if (!copy) {
|
|
copy = gst_va_allocator_alloc (mem->allocator);
|
|
if (!copy) {
|
|
GST_WARNING ("failed to allocate new memory");
|
|
return NULL;
|
|
}
|
|
} else {
|
|
gst_object_ref (mem->allocator);
|
|
}
|
|
}
|
|
|
|
va_copy = (GstVaMemory *) copy;
|
|
mem_size = gst_memory_get_sizes (mem, NULL, NULL);
|
|
|
|
if (size == -1)
|
|
size = mem_size > offset ? mem_size - offset : 0;
|
|
|
|
if (offset == 0 && size == mem_size) {
|
|
GstVaSurfaceCopy *copy_func;
|
|
|
|
copy_func = _ensure_surface_copy (&va_allocator->copy,
|
|
va_allocator->display, &va_allocator->info);
|
|
if (copy_func
|
|
&& gst_va_surface_copy (copy_func, va_copy->surface, va_mem->surface))
|
|
return copy;
|
|
}
|
|
|
|
if (!gst_memory_map (mem, &sinfo, GST_MAP_READ)) {
|
|
GST_WARNING ("failed to map memory to copy");
|
|
return NULL;
|
|
}
|
|
|
|
if (!gst_memory_map (copy, &dinfo, GST_MAP_WRITE)) {
|
|
GST_WARNING ("could not write map memory %p", copy);
|
|
gst_allocator_free (mem->allocator, copy);
|
|
gst_memory_unmap (mem, &sinfo);
|
|
return NULL;
|
|
}
|
|
|
|
memcpy (dinfo.data, sinfo.data + offset, size);
|
|
gst_memory_unmap (copy, &dinfo);
|
|
gst_memory_unmap (mem, &sinfo);
|
|
|
|
return copy;
|
|
}
|
|
|
|
static void
|
|
gst_va_allocator_init (GstVaAllocator * self)
|
|
{
|
|
GstAllocator *allocator = GST_ALLOCATOR (self);
|
|
|
|
allocator->mem_type = GST_ALLOCATOR_VASURFACE;
|
|
allocator->mem_map = (GstMemoryMapFunction) _va_map;
|
|
allocator->mem_unmap = (GstMemoryUnmapFunction) _va_unmap;
|
|
allocator->mem_share = _va_share;
|
|
allocator->mem_copy = _va_copy;
|
|
|
|
gst_va_memory_pool_init (&self->pool);
|
|
|
|
GST_OBJECT_FLAG_SET (self, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
|
|
}
|
|
|
|
static gboolean
|
|
gst_va_memory_release (GstMiniObject * mini_object)
|
|
{
|
|
GstMemory *mem = GST_MEMORY_CAST (mini_object);
|
|
GstVaAllocator *self = GST_VA_ALLOCATOR (mem->allocator);
|
|
|
|
GST_LOG ("releasing %p: surface %#x", mem, gst_va_memory_get_surface (mem));
|
|
|
|
gst_va_memory_pool_push (&self->pool, mem);
|
|
|
|
/* Keep last in case we are holding on the last allocator ref */
|
|
gst_object_unref (mem->allocator);
|
|
|
|
/* don't call mini_object's free */
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_alloc:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Allocate a new VASurfaceID backed #GstMemory.
|
|
*
|
|
* Returns: a #GstMemory backed with a VASurfaceID; %NULL, otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstMemory *
|
|
gst_va_allocator_alloc (GstAllocator * allocator)
|
|
{
|
|
GstVaAllocator *self;
|
|
GstVaMemory *mem;
|
|
VASurfaceID surface;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), NULL);
|
|
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
if (self->rt_format == 0) {
|
|
GST_ERROR_OBJECT (self, "Unknown fourcc or chroma format");
|
|
return NULL;
|
|
}
|
|
|
|
if (!va_create_surfaces (self->display, self->rt_format, self->fourcc,
|
|
GST_VIDEO_INFO_WIDTH (&self->info),
|
|
GST_VIDEO_INFO_HEIGHT (&self->info), self->usage_hint, NULL, 0, NULL,
|
|
&surface, 1))
|
|
return NULL;
|
|
|
|
mem = g_new (GstVaMemory, 1);
|
|
|
|
mem->surface = surface;
|
|
mem->surface_format = self->surface_format;
|
|
|
|
_reset_mem (mem, allocator, GST_VIDEO_INFO_SIZE (&self->info));
|
|
|
|
GST_MINI_OBJECT (mem)->dispose = gst_va_memory_release;
|
|
gst_va_memory_pool_surface_inc (&self->pool);
|
|
|
|
GST_LOG_OBJECT (self, "Created surface %#x [%dx%d]", mem->surface,
|
|
GST_VIDEO_INFO_WIDTH (&self->info), GST_VIDEO_INFO_HEIGHT (&self->info));
|
|
|
|
return GST_MEMORY_CAST (mem);
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_new:
|
|
* @display: a #GstVaDisplay
|
|
* @surface_formats: (element-type guint) (transfer full): a #GArray
|
|
* of valid #GstVideoFormat for surfaces in current VA context.
|
|
*
|
|
* Instanciate a new pooled #GstAllocator backed by VASurfaceID.
|
|
*
|
|
* Returns: a #GstVaDisplay
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstAllocator *
|
|
gst_va_allocator_new (GstVaDisplay * display, GArray * surface_formats)
|
|
{
|
|
GstVaAllocator *self;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_DISPLAY (display), NULL);
|
|
|
|
self = g_object_new (GST_TYPE_VA_ALLOCATOR, NULL);
|
|
self->display = gst_object_ref (display);
|
|
self->surface_formats = surface_formats;
|
|
gst_object_ref_sink (self);
|
|
|
|
return GST_ALLOCATOR (self);
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_setup_buffer:
|
|
* @allocator: a #GstAllocator
|
|
* @buffer: a #GstBuffer
|
|
*
|
|
* Populates an empty @buffer with a VASuface backed #GstMemory.
|
|
*
|
|
* Returns: %TRUE if @buffer is populated; %FALSE otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_allocator_setup_buffer (GstAllocator * allocator, GstBuffer * buffer)
|
|
{
|
|
GstMemory *mem = gst_va_allocator_alloc (allocator);
|
|
if (!mem)
|
|
return FALSE;
|
|
|
|
gst_buffer_append_memory (buffer, mem);
|
|
return TRUE;
|
|
}
|
|
|
|
static VASurfaceID
|
|
gst_va_allocator_prepare_buffer_unlocked (GstVaAllocator * self,
|
|
GstBuffer * buffer)
|
|
{
|
|
GstMemory *mem;
|
|
VASurfaceID surface;
|
|
|
|
mem = gst_va_memory_pool_pop (&self->pool);
|
|
if (!mem)
|
|
return VA_INVALID_ID;
|
|
|
|
gst_object_ref (mem->allocator);
|
|
surface = gst_va_memory_get_surface (mem);
|
|
gst_buffer_append_memory (buffer, mem);
|
|
|
|
GST_LOG ("buffer %p: memory %p - surface %#x", buffer, mem, surface);
|
|
|
|
return surface;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_prepare_buffer:
|
|
* @allocator: a #GstAllocator
|
|
* @buffer: an empty #GstBuffer
|
|
*
|
|
* This method will populate @buffer with pooled VASurfaceID
|
|
* memories. It doesn't allocate new VASurfacesID.
|
|
*
|
|
* Returns: %TRUE if @buffer was populated correctly; %FALSE
|
|
* otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_allocator_prepare_buffer (GstAllocator * allocator, GstBuffer * buffer)
|
|
{
|
|
GstVaAllocator *self;
|
|
VASurfaceID surface;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), FALSE);
|
|
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
GST_VA_MEMORY_POOL_LOCK (&self->pool);
|
|
surface = gst_va_allocator_prepare_buffer_unlocked (self, buffer);
|
|
GST_VA_MEMORY_POOL_UNLOCK (&self->pool);
|
|
|
|
return (surface != VA_INVALID_ID);
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_flush:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Removes all the memories in @allocator's pool.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
void
|
|
gst_va_allocator_flush (GstAllocator * allocator)
|
|
{
|
|
GstVaAllocator *self;
|
|
|
|
g_return_if_fail (GST_IS_VA_ALLOCATOR (allocator));
|
|
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
gst_va_memory_pool_flush (&self->pool, self->display);
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_try:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Try to allocate a test buffer in order to verify that the
|
|
* allocator's configuration is valid.
|
|
*
|
|
* Returns: %TRUE if the configuration is valid; %FALSE otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
static gboolean
|
|
gst_va_allocator_try (GstAllocator * allocator, GstVaFeature feat_use_derived)
|
|
{
|
|
GstVaAllocator *self;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), FALSE);
|
|
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
self->fourcc = 0;
|
|
self->rt_format = 0;
|
|
self->use_derived = FALSE;
|
|
self->img_format = GST_VIDEO_INFO_FORMAT (&self->info);
|
|
|
|
self->surface_format =
|
|
gst_va_video_surface_format_from_image_format (self->img_format,
|
|
self->surface_formats);
|
|
if (self->surface_format == GST_VIDEO_FORMAT_UNKNOWN) {
|
|
/* try a surface without fourcc but rt_format only */
|
|
self->fourcc = 0;
|
|
self->rt_format = gst_va_chroma_from_video_format (self->img_format);
|
|
} else {
|
|
if (G_LIKELY (!(self->hacks & GST_VA_HACK_SURFACE_NO_FOURCC)))
|
|
self->fourcc = gst_va_fourcc_from_video_format (self->surface_format);
|
|
self->rt_format = gst_va_chroma_from_video_format (self->surface_format);
|
|
}
|
|
|
|
if (self->rt_format == 0) {
|
|
GST_ERROR_OBJECT (allocator, "Unsupported image format: %s",
|
|
gst_video_format_to_string (self->img_format));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!_update_image_info (self, feat_use_derived)) {
|
|
GST_ERROR_OBJECT (allocator, "Failed to update allocator info");
|
|
return FALSE;
|
|
}
|
|
|
|
GST_INFO_OBJECT (self,
|
|
"va allocator info, surface format: %s, image format: %s, "
|
|
"use derived: %s, rt format: 0x%x, fourcc: %" GST_FOURCC_FORMAT,
|
|
(self->surface_format == GST_VIDEO_FORMAT_UNKNOWN) ? "unknown"
|
|
: gst_video_format_to_string (self->surface_format),
|
|
gst_video_format_to_string (self->img_format),
|
|
self->use_derived ? "true" : "false", self->rt_format,
|
|
GST_FOURCC_ARGS (self->fourcc));
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_set_format:
|
|
* @allocator: a #GstAllocator
|
|
* @info: (inout): a #GstVideoInfo
|
|
* @usage_hint: VA usage hint
|
|
* @feat_use_derived: a #GstVaFeature
|
|
*
|
|
* Sets the configuration defined by @info, @usage_hint and
|
|
* @use_derived for @allocator, and it tries the configuration, if
|
|
* @allocator has not allocated memories yet.
|
|
*
|
|
* If @allocator has memory allocated already, and frame size and
|
|
* format in @info are the same as currently configured in @allocator,
|
|
* the rest of @info parameters are updated internally.
|
|
*
|
|
* Returns: %TRUE if the configuration is valid or updated; %FALSE if
|
|
* configuration is not valid or not updated.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_allocator_set_format (GstAllocator * allocator, GstVideoInfo * info,
|
|
guint usage_hint, GstVaFeature feat_use_derived)
|
|
{
|
|
GstVaAllocator *self;
|
|
gboolean use_derived;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), FALSE);
|
|
g_return_val_if_fail (info, FALSE);
|
|
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
use_derived = feat_use_derived == GST_VA_FEATURE_AUTO ? self->use_derived
|
|
: feat_use_derived == GST_VA_FEATURE_DISABLED ? FALSE : TRUE;
|
|
|
|
if (gst_va_memory_pool_surface_count (&self->pool) != 0) {
|
|
if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_INFO_FORMAT (&self->info)
|
|
&& GST_VIDEO_INFO_WIDTH (info) == GST_VIDEO_INFO_WIDTH (&self->info)
|
|
&& GST_VIDEO_INFO_HEIGHT (info) == GST_VIDEO_INFO_HEIGHT (&self->info)
|
|
&& usage_hint == self->usage_hint && use_derived == self->use_derived) {
|
|
*info = self->info; /* update callee info (offset & stride) */
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
self->usage_hint = usage_hint;
|
|
self->info = *info;
|
|
|
|
g_clear_pointer (&self->copy, gst_va_surface_copy_free);
|
|
|
|
ret = gst_va_allocator_try (allocator, feat_use_derived);
|
|
if (ret)
|
|
*info = self->info;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_get_format:
|
|
* @allocator: a #GstAllocator
|
|
* @info: (out) (optional): a #GstVideoInfo
|
|
* @usage_hint: (out) (optional): VA usage hint
|
|
* @use_derived: (out) (optional): whether derived images are used for buffer
|
|
* mapping.
|
|
*
|
|
* Gets current internal configuration of @allocator.
|
|
*
|
|
* Returns: %TRUE if @allocator is already configured; %FALSE
|
|
* otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_allocator_get_format (GstAllocator * allocator, GstVideoInfo * info,
|
|
guint * usage_hint, gboolean * use_derived)
|
|
{
|
|
GstVaAllocator *self;
|
|
|
|
g_return_val_if_fail (GST_IS_VA_ALLOCATOR (allocator), FALSE);
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
if (GST_VIDEO_INFO_FORMAT (&self->info) == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return FALSE;
|
|
|
|
if (info)
|
|
*info = self->info;
|
|
if (usage_hint)
|
|
*usage_hint = self->usage_hint;
|
|
if (use_derived)
|
|
*use_derived = self->use_derived;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_set_hacks: (skip)
|
|
* @allocator: a #GstAllocator
|
|
* @hacks: hacks id to set
|
|
*
|
|
* Internal method to set allocator specific logic changes.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
void
|
|
gst_va_allocator_set_hacks (GstAllocator * allocator, guint32 hacks)
|
|
{
|
|
GstVaAllocator *self;
|
|
|
|
g_return_if_fail (GST_IS_VA_ALLOCATOR (allocator));
|
|
self = GST_VA_ALLOCATOR (allocator);
|
|
|
|
self->hacks = hacks;
|
|
}
|
|
|
|
/**
|
|
* gst_va_allocator_peek_display:
|
|
* @allocator: a #GstAllocator
|
|
*
|
|
* Returns: (transfer none): the display which this
|
|
* @allocator belongs to. The reference of the display is unchanged.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstVaDisplay *
|
|
gst_va_allocator_peek_display (GstAllocator * allocator)
|
|
{
|
|
if (!allocator)
|
|
return NULL;
|
|
|
|
if (GST_IS_VA_DMABUF_ALLOCATOR (allocator)) {
|
|
return GST_VA_DMABUF_ALLOCATOR (allocator)->display;
|
|
} else if (GST_IS_VA_ALLOCATOR (allocator)) {
|
|
return GST_VA_ALLOCATOR (allocator)->display;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*============ Utilities =====================================================*/
|
|
|
|
/**
|
|
* gst_va_memory_get_surface: (skip)
|
|
* @mem: a #GstMemory
|
|
*
|
|
* Returns: (type guint): the VASurfaceID in @mem.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
VASurfaceID
|
|
gst_va_memory_get_surface (GstMemory * mem)
|
|
{
|
|
VASurfaceID surface = VA_INVALID_ID;
|
|
|
|
if (!mem->allocator)
|
|
return VA_INVALID_ID;
|
|
|
|
if (GST_IS_DMABUF_ALLOCATOR (mem->allocator)) {
|
|
GstVaBufferSurface *buf;
|
|
|
|
buf = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_surface_quark ());
|
|
if (buf)
|
|
surface = buf->surface;
|
|
} else if (GST_IS_VA_ALLOCATOR (mem->allocator)) {
|
|
GstVaMemory *va_mem = (GstVaMemory *) mem;
|
|
surface = va_mem->surface;
|
|
}
|
|
|
|
return surface;
|
|
}
|
|
|
|
/**
|
|
* gst_va_memory_peek_display:
|
|
* @mem: a #GstMemory
|
|
*
|
|
* Returns: (transfer none): the display which
|
|
* this @mem belongs to. The reference of the display is unchanged.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstVaDisplay *
|
|
gst_va_memory_peek_display (GstMemory * mem)
|
|
{
|
|
GstAllocator *allocator;
|
|
|
|
if (!mem)
|
|
return NULL;
|
|
|
|
allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
/* no allocator, not VA kind memory. */
|
|
if (!allocator)
|
|
return NULL;
|
|
|
|
return gst_va_allocator_peek_display (allocator);
|
|
}
|
|
|
|
/**
|
|
* gst_va_buffer_get_surface: (skip)
|
|
* @buffer: a #GstBuffer
|
|
*
|
|
* Returns: (type guint): the VASurfaceID in @buffer.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
VASurfaceID
|
|
gst_va_buffer_get_surface (GstBuffer * buffer)
|
|
{
|
|
GstMemory *mem;
|
|
|
|
mem = gst_buffer_peek_memory (buffer, 0);
|
|
if (!mem)
|
|
return VA_INVALID_ID;
|
|
|
|
return gst_va_memory_get_surface (mem);
|
|
}
|
|
|
|
/**
|
|
* gst_va_buffer_create_aux_surface:
|
|
* @buffer: a #GstBuffer
|
|
*
|
|
* Creates a new VASurfaceID with @buffer's allocator and attached it
|
|
* to it.
|
|
*
|
|
* *This method is used only by plugin's internal VA decoder.*
|
|
*
|
|
* Returns: %TRUE if the new VASurfaceID is attached to @buffer
|
|
* correctly; %FALSE, otherwise.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
gboolean
|
|
gst_va_buffer_create_aux_surface (GstBuffer * buffer)
|
|
{
|
|
GstMemory *mem;
|
|
VASurfaceID surface = VA_INVALID_ID;
|
|
GstVaDisplay *display = NULL;
|
|
GstVideoFormat format;
|
|
GstVaBufferSurface *surface_buffer;
|
|
|
|
mem = gst_buffer_peek_memory (buffer, 0);
|
|
if (!mem)
|
|
return FALSE;
|
|
|
|
/* Already created. */
|
|
surface_buffer = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_aux_surface_quark ());
|
|
if (surface_buffer)
|
|
return TRUE;
|
|
|
|
if (!mem->allocator)
|
|
return FALSE;
|
|
|
|
if (GST_IS_VA_DMABUF_ALLOCATOR (mem->allocator)) {
|
|
GstVaDmabufAllocator *self = GST_VA_DMABUF_ALLOCATOR (mem->allocator);
|
|
guint32 fourcc, rt_format;
|
|
|
|
format = GST_VIDEO_INFO_FORMAT (&self->info.vinfo);
|
|
fourcc = gst_va_fourcc_from_video_format (format);
|
|
rt_format = gst_va_chroma_from_video_format (format);
|
|
if (fourcc == 0 || rt_format == 0) {
|
|
GST_ERROR_OBJECT (self, "Unsupported format: %s",
|
|
gst_video_format_to_string (format));
|
|
return FALSE;
|
|
}
|
|
|
|
display = self->display;
|
|
if (!va_create_surfaces (self->display, rt_format, fourcc,
|
|
GST_VIDEO_INFO_WIDTH (&self->info.vinfo),
|
|
GST_VIDEO_INFO_HEIGHT (&self->info.vinfo), self->usage_hint, NULL,
|
|
0, NULL, &surface, 1))
|
|
return FALSE;
|
|
} else if (GST_IS_VA_ALLOCATOR (mem->allocator)) {
|
|
GstVaAllocator *self = GST_VA_ALLOCATOR (mem->allocator);
|
|
|
|
if (self->rt_format == 0) {
|
|
GST_ERROR_OBJECT (self, "Unknown fourcc or chroma format");
|
|
return FALSE;
|
|
}
|
|
|
|
display = self->display;
|
|
format = GST_VIDEO_INFO_FORMAT (&self->info);
|
|
if (!va_create_surfaces (self->display, self->rt_format, self->fourcc,
|
|
GST_VIDEO_INFO_WIDTH (&self->info),
|
|
GST_VIDEO_INFO_HEIGHT (&self->info), self->usage_hint, NULL, 0,
|
|
NULL, &surface, 1))
|
|
return FALSE;
|
|
} else {
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
if (!display || surface == VA_INVALID_ID)
|
|
return FALSE;
|
|
|
|
surface_buffer = gst_va_buffer_surface_new (surface);
|
|
surface_buffer->display = gst_object_ref (display);
|
|
g_atomic_int_add (&surface_buffer->ref_count, 1);
|
|
|
|
gst_mini_object_set_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_aux_surface_quark (), surface_buffer,
|
|
gst_va_buffer_surface_unref);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_va_buffer_get_aux_surface: (skip)
|
|
* @buffer: a #GstBuffer
|
|
*
|
|
* Returns: (type guint): the VASurfaceID attached to
|
|
* @buffer.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
VASurfaceID
|
|
gst_va_buffer_get_aux_surface (GstBuffer * buffer)
|
|
{
|
|
GstVaBufferSurface *surface_buffer;
|
|
GstMemory *mem;
|
|
|
|
mem = gst_buffer_peek_memory (buffer, 0);
|
|
if (!mem)
|
|
return VA_INVALID_ID;
|
|
|
|
surface_buffer = gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
gst_va_buffer_aux_surface_quark ());
|
|
if (!surface_buffer)
|
|
return VA_INVALID_ID;
|
|
|
|
/* No one increments it, and its lifetime is the same with the
|
|
gstmemory itself */
|
|
g_assert (g_atomic_int_get (&surface_buffer->ref_count) == 1);
|
|
|
|
return surface_buffer->surface;
|
|
}
|
|
|
|
/**
|
|
* gst_va_buffer_peek_display:
|
|
* @buffer: a #GstBuffer
|
|
*
|
|
* Returns: (transfer none): the display which this
|
|
* @buffer belongs to. The reference of the display is unchanged.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
GstVaDisplay *
|
|
gst_va_buffer_peek_display (GstBuffer * buffer)
|
|
{
|
|
GstMemory *mem;
|
|
|
|
if (!buffer)
|
|
return NULL;
|
|
|
|
mem = gst_buffer_peek_memory (buffer, 0);
|
|
/* Buffer without mem, not VA kind memory. */
|
|
if (!mem)
|
|
return NULL;
|
|
|
|
return gst_va_memory_peek_display (mem);
|
|
}
|