gstreamer/gst/vaapi/gstvaapivideomemory.c
Gwenole Beauchesne e712abba11 plugins: allow buffer mappings to GstVaapiSurfaceProxy.
Allow plain gst_buffer_map() interface to work with gstreamer-vaapi
video buffers, i.e. expose the underlying GstVaapiSurfaceProxy to the
caller. This is the only sensible enough thing to do in this mode as
the underlying surface pixels need to be extracted through an explicit
call to the gst_video_frame_map() function instead.

A possible use-case of this is to implement a "handoff" signal handler
to fakesink or identity element for further processing.
2013-06-05 11:09:37 +02:00

491 lines
15 KiB
C

/*
* gstvaapivideomemory.c - Gstreamer/VA video memory
*
* Copyright (C) 2013 Intel Corporation
*
* 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 "gst/vaapi/sysdeps.h"
#include "gstvaapivideomemory.h"
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 GstVaapiImage *
new_image(GstVaapiDisplay *display, const GstVideoInfo *vip)
{
GstVaapiImageFormat format;
format = gst_vaapi_image_format_from_video(GST_VIDEO_INFO_FORMAT(vip));
if (!format)
return NULL;
return gst_vaapi_image_new(display, format,
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
}
static gboolean
ensure_image(GstVaapiVideoMemory *mem)
{
if (!mem->image && mem->use_direct_rendering) {
mem->image = gst_vaapi_surface_derive_image(mem->surface);
if (!mem->image) {
GST_WARNING("failed to derive image, fallbacking to copy");
mem->use_direct_rendering = FALSE;
}
}
if (!mem->image) {
GstVaapiDisplay * const display =
gst_vaapi_video_meta_get_display(mem->meta);
mem->image = new_image(display, mem->image_info);
if (!mem->image)
return FALSE;
}
gst_vaapi_video_meta_set_image(mem->meta, mem->image);
return TRUE;
}
static GstVaapiSurface *
new_surface(GstVaapiDisplay *display, const GstVideoInfo *vip)
{
if (GST_VIDEO_INFO_FORMAT(vip) != GST_VIDEO_FORMAT_NV12)
return NULL;
return gst_vaapi_surface_new(display, GST_VAAPI_CHROMA_TYPE_YUV420,
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
}
static gboolean
ensure_surface(GstVaapiVideoMemory *mem)
{
if (!mem->surface) {
GstVaapiDisplay * const display =
gst_vaapi_video_meta_get_display(mem->meta);
mem->surface = new_surface(display, mem->surface_info);
if (!mem->surface)
return FALSE;
}
gst_vaapi_video_meta_set_surface(mem->meta, mem->surface);
return TRUE;
}
gboolean
gst_video_meta_map_vaapi_memory(GstVideoMeta *meta, guint plane,
GstMapInfo *info, gpointer *data, gint *stride, GstMapFlags flags)
{
GstVaapiVideoMemory * const mem =
GST_VAAPI_VIDEO_MEMORY_CAST(gst_buffer_get_memory(meta->buffer, 0));
g_return_val_if_fail(mem, FALSE);
g_return_val_if_fail(GST_VAAPI_IS_VIDEO_ALLOCATOR(mem->parent_instance.
allocator), FALSE);
g_return_val_if_fail(mem->meta, FALSE);
if (mem->map_type &&
mem->map_type != GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR)
goto error_incompatible_map;
if ((flags & GST_MAP_READWRITE) != GST_MAP_WRITE)
goto error_unsupported_map;
/* Map for writing */
if (++mem->map_count == 1) {
if (!ensure_surface(mem))
goto error_ensure_surface;
if (!ensure_image(mem))
goto error_ensure_image;
if (!gst_vaapi_image_map(mem->image))
goto error_map_image;
mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR;
}
*data = gst_vaapi_image_get_plane(mem->image, plane);
*stride = gst_vaapi_image_get_pitch(mem->image, plane);
info->flags = flags;
return TRUE;
/* ERRORS */
error_incompatible_map:
{
GST_ERROR("incompatible map type (%d)", mem->map_type);
return FALSE;
}
error_unsupported_map:
{
GST_ERROR("unsupported map flags (0x%x)", flags);
return FALSE;
}
error_ensure_surface:
{
const GstVideoInfo * const vip = mem->surface_info;
GST_ERROR("failed to create %s surface of size %ux%u",
GST_VIDEO_INFO_FORMAT_STRING(vip),
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
return FALSE;
}
error_ensure_image:
{
const GstVideoInfo * const vip = mem->image_info;
GST_ERROR("failed to create %s image of size %ux%u",
GST_VIDEO_INFO_FORMAT_STRING(vip),
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
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;
}
}
gboolean
gst_video_meta_unmap_vaapi_memory(GstVideoMeta *meta, guint plane,
GstMapInfo *info)
{
GstVaapiVideoMemory * const mem =
GST_VAAPI_VIDEO_MEMORY_CAST(gst_buffer_get_memory(meta->buffer, 0));
g_return_val_if_fail(mem, FALSE);
g_return_val_if_fail(GST_VAAPI_IS_VIDEO_ALLOCATOR(mem->parent_instance.
allocator), 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);
if (--mem->map_count == 0) {
mem->map_type = 0;
/* Unmap VA image used for read/writes */
if (info->flags & GST_MAP_READWRITE)
gst_vaapi_image_unmap(mem->image);
/* Commit VA image to surface */
if ((info->flags & GST_MAP_WRITE) && !mem->use_direct_rendering) {
if (!gst_vaapi_surface_put_image(mem->surface, mem->image))
goto error_upload_image;
}
}
return TRUE;
/* ERRORS */
error_upload_image:
{
GST_ERROR("failed to upload image");
return FALSE;
}
}
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;
mem = g_slice_new(GstVaapiVideoMemory);
if (!mem)
return NULL;
vip = &allocator->image_info;
gst_memory_init(&mem->parent_instance, 0, 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 = gst_vaapi_video_meta_ref(meta);
mem->map_type = 0;
mem->map_count = 0;
mem->use_direct_rendering = allocator->has_direct_rendering;
return GST_MEMORY_CAST(mem);
}
static void
gst_vaapi_video_memory_free(GstVaapiVideoMemory *mem)
{
gst_vaapi_object_replace(&mem->surface, NULL);
gst_vaapi_object_replace(&mem->image, NULL);
gst_vaapi_video_meta_unref(mem->meta);
g_slice_free(GstVaapiVideoMemory, mem);
}
static gpointer
gst_vaapi_video_memory_map(GstVaapiVideoMemory *mem, gsize maxsize, guint flags)
{
if (mem->map_type &&
mem->map_type != GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE)
goto error_incompatible_map;
if (mem->map_count == 0) {
gst_vaapi_surface_proxy_replace(&mem->proxy,
gst_vaapi_video_meta_get_surface_proxy(mem->meta));
if (!mem->proxy)
goto error_no_surface_proxy;
mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE;
}
mem->map_count++;
return mem->proxy;
/* ERRORS */
error_incompatible_map:
GST_ERROR("failed to map memory to a GstVaapiSurfaceProxy");
return NULL;
error_no_surface_proxy:
GST_ERROR("failed to extract GstVaapiSurfaceProxy from video meta");
return NULL;
}
static void
gst_vaapi_video_memory_unmap(GstVaapiVideoMemory *mem)
{
if (mem->map_type &&
mem->map_type != GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE)
goto error_incompatible_map;
if (--mem->map_count == 0) {
gst_vaapi_surface_proxy_replace(&mem->proxy, NULL);
mem->map_type = 0;
}
return;
/* ERRORS */
error_incompatible_map:
GST_ERROR("incompatible map type (%d)", mem->map_type);
return;
}
static GstVaapiVideoMemory *
gst_vaapi_video_memory_copy(GstVaapiVideoMemory *mem,
gssize offset, gssize size)
{
GstMemory *out_mem;
if (offset != 0 || size != -1)
goto error_unsupported;
out_mem = gst_vaapi_video_memory_new(mem->parent_instance.allocator,
mem->meta);
if (!out_mem)
goto error_allocate_memory;
return GST_VAAPI_VIDEO_MEMORY_CAST(out_mem);
/* ERRORS */
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;
}
static GstVaapiVideoMemory *
gst_vaapi_video_memory_share(GstVaapiVideoMemory *mem,
gssize offset, gssize size)
{
GST_FIXME("unimplemented GstVaapiVideoAllocator::mem_share() hook");
return NULL;
}
static gboolean
gst_vaapi_video_memory_is_span(GstVaapiVideoMemory *mem1,
GstVaapiVideoMemory *mem2, gsize *offset_ptr)
{
GST_FIXME("unimplemented GstVaapiVideoAllocator::mem_is_span() hook");
return FALSE;
}
/* ------------------------------------------------------------------------ */
/* --- GstVaapiVideoAllocator --- */
/* ------------------------------------------------------------------------ */
#define GST_VAAPI_VIDEO_ALLOCATOR_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), \
GST_VAAPI_TYPE_VIDEO_ALLOCATOR, \
GstVaapiVideoAllocatorClass))
#define GST_VAAPI_IS_VIDEO_ALLOCATOR_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass), GST_VAAPI_TYPE_VIDEO_ALLOCATOR))
G_DEFINE_TYPE(GstVaapiVideoAllocator,
gst_vaapi_video_allocator,
GST_TYPE_ALLOCATOR)
static GstMemory *
gst_vaapi_video_allocator_alloc(GstAllocator *allocator, gsize size,
GstAllocationParams *params)
{
g_warning("use gst_vaapi_video_memory_new() to allocate from "
"GstVaapiVideoMemory allocator");
return NULL;
}
static void
gst_vaapi_video_allocator_free(GstAllocator *allocator, GstMemory *mem)
{
gst_vaapi_video_memory_free(GST_VAAPI_VIDEO_MEMORY_CAST(mem));
}
static void
gst_vaapi_video_allocator_class_init(GstVaapiVideoAllocatorClass *klass)
{
GstAllocatorClass * const allocator_class = GST_ALLOCATOR_CLASS(klass);
GST_DEBUG_CATEGORY_INIT(gst_debug_vaapivideomemory,
"vaapivideomemory", 0, "VA-API video memory allocator");
allocator_class->alloc = gst_vaapi_video_allocator_alloc;
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 = (GstMemoryMapFunction)
gst_vaapi_video_memory_map;
base_allocator->mem_unmap = (GstMemoryUnmapFunction)
gst_vaapi_video_memory_unmap;
base_allocator->mem_copy = (GstMemoryCopyFunction)
gst_vaapi_video_memory_copy;
base_allocator->mem_share = (GstMemoryShareFunction)
gst_vaapi_video_memory_share;
base_allocator->mem_is_span = (GstMemoryIsSpanFunction)
gst_vaapi_video_memory_is_span;
}
static gboolean
gst_video_info_update_from_image(GstVideoInfo *vip, GstVaapiImage *image)
{
const guchar *data;
guint i, num_planes, data_size;
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 = gst_vaapi_image_get_plane(image, 0);
for (i = 1; i < num_planes; i++) {
const guchar * const plane = gst_vaapi_image_get_plane(image, i);
if (data > plane)
data = plane;
}
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;
}
GstAllocator *
gst_vaapi_video_allocator_new(GstVaapiDisplay *display, GstCaps *caps)
{
GstVaapiVideoAllocator *allocator;
GstVideoInfo *vip;
GstVaapiSurface *surface;
GstVaapiImage *image;
g_return_val_if_fail(display != NULL, NULL);
g_return_val_if_fail(GST_IS_CAPS(caps), NULL);
allocator = g_object_new(GST_VAAPI_TYPE_VIDEO_ALLOCATOR, NULL);
if (!allocator)
return NULL;
vip = &allocator->video_info;
gst_video_info_init(vip);
gst_video_info_from_caps(vip, caps);
gst_video_info_set_format(&allocator->surface_info, GST_VIDEO_FORMAT_NV12,
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
if (GST_VIDEO_INFO_FORMAT(vip) != GST_VIDEO_FORMAT_ENCODED) {
image = NULL;
do {
surface = new_surface(display, vip);
if (!surface)
break;
image = gst_vaapi_surface_derive_image(surface);
if (!image)
break;
if (!gst_vaapi_image_map(image))
break;
allocator->has_direct_rendering = gst_video_info_update_from_image(
&allocator->surface_info, image);
gst_vaapi_image_unmap(image);
GST_INFO("has direct-rendering for %s surfaces: %s",
GST_VIDEO_INFO_FORMAT_STRING(&allocator->surface_info),
allocator->has_direct_rendering ? "yes" : "no");
} while (0);
if (surface)
gst_vaapi_object_unref(surface);
if (image)
gst_vaapi_object_unref(image);
}
allocator->image_info = *vip;
if (GST_VIDEO_INFO_FORMAT(vip) == GST_VIDEO_FORMAT_ENCODED)
gst_video_info_set_format(&allocator->image_info, GST_VIDEO_FORMAT_NV12,
GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
if (allocator->has_direct_rendering)
allocator->image_info = allocator->surface_info;
else {
do {
image = new_image(display, &allocator->image_info);
if (!image)
break;
if (!gst_vaapi_image_map(image))
break;
gst_video_info_update_from_image(&allocator->image_info, image);
gst_vaapi_image_unmap(image);
} while (0);
gst_vaapi_object_unref(image);
}
return GST_ALLOCATOR_CAST(allocator);
}