gstreamer/sys/vdpau/gstvdpvideomemory.c
2017-04-12 12:57:57 -03:00

333 lines
9 KiB
C

/*
* GStreamer
* Copyright (C) 2012 Edward Hervey <edward@collabora.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., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/video/video.h>
#include "gstvdpvideomemory.h"
#include "gstvdputils.h"
GST_DEBUG_CATEGORY_STATIC (GST_CAT_PERFORMANCE);
GST_DEBUG_CATEGORY_STATIC (gst_vdp_video_mem_debug);
#define GST_CAT_DEFAULT gst_vdp_video_mem_debug
static GstAllocator *_vdp_video_allocator;
static void
_vdp_video_mem_init (GstVdpVideoMemory * mem, GstAllocator * allocator,
GstMemory * parent, GstVdpDevice * device, GstVideoInfo * info)
{
gst_memory_init (GST_MEMORY_CAST (mem), GST_MEMORY_FLAG_NO_SHARE,
allocator, parent, GST_VIDEO_INFO_SIZE (info), 0, 0,
GST_VIDEO_INFO_SIZE (info));
mem->device = gst_object_ref (device);
mem->info = info;
mem->chroma_type = gst_video_info_to_vdp_chroma_type (info);
mem->ycbcr_format =
gst_video_format_to_vdp_ycbcr (GST_VIDEO_INFO_FORMAT (info));
mem->refcount = 0;
GST_DEBUG ("new VdpVideo memory");
}
static GstVdpVideoMemory *
_vdp_video_mem_new (GstAllocator * allocator, GstMemory * parent,
GstVdpDevice * device, GstVideoInfo * info)
{
VdpStatus status;
GstVdpVideoMemory *mem;
VdpVideoSurface surface;
mem = g_slice_new0 (GstVdpVideoMemory);
_vdp_video_mem_init (mem, allocator, parent, device, info);
GST_TRACE
("Calling VdpVideoSurfaceCreate(chroma_type:%d, width:%d, height:%d)",
mem->chroma_type, mem->info->width, mem->info->height);
status =
device->vdp_video_surface_create (device->device, mem->chroma_type,
mem->info->width, mem->info->height, &surface);
if (status != VDP_STATUS_OK)
goto create_error;
/* device->vdp_video_surface_get_parameters (device->device, &chroma_type, */
/* &width, &height); */
GST_TRACE ("created surface %u", surface);
mem->surface = surface;
return mem;
/* ERRORS */
create_error:
{
GST_ERROR ("Failed to create video surface: %s",
device->vdp_get_error_string (status));
g_slice_free (GstVdpVideoMemory, mem);
return NULL;
}
}
static gboolean
ensure_data (GstVdpVideoMemory * vmem)
{
VdpStatus vdp_stat;
GstVideoInfo *info = vmem->info;
#ifndef GST_DISABLE_GST_DEBUG
GstClockTime before, after;
#endif
if (g_atomic_int_add (&vmem->refcount, 1) > 1)
return TRUE;
/* Allocate enough room to store data */
vmem->cache = g_malloc (GST_VIDEO_INFO_SIZE (info));
vmem->cached_data[0] = vmem->cache;
vmem->cached_data[1] = vmem->cache + GST_VIDEO_INFO_PLANE_OFFSET (info, 1);
vmem->cached_data[2] = vmem->cache + GST_VIDEO_INFO_PLANE_OFFSET (info, 2);
vmem->destination_pitches[0] = GST_VIDEO_INFO_PLANE_STRIDE (info, 0);
vmem->destination_pitches[1] = GST_VIDEO_INFO_PLANE_STRIDE (info, 1);
vmem->destination_pitches[2] = GST_VIDEO_INFO_PLANE_STRIDE (info, 2);
GST_DEBUG ("cached_data %p %p %p",
vmem->cached_data[0], vmem->cached_data[1], vmem->cached_data[2]);
GST_DEBUG ("pitches %d %d %d",
vmem->destination_pitches[0],
vmem->destination_pitches[1], vmem->destination_pitches[2]);
#ifndef GST_DISABLE_GST_DEBUG
before = gst_util_get_timestamp ();
#endif
vdp_stat =
vmem->device->vdp_video_surface_get_bits_ycbcr (vmem->surface,
vmem->ycbcr_format, vmem->cached_data, vmem->destination_pitches);
#ifndef GST_DISABLE_GST_DEBUG
after = gst_util_get_timestamp ();
#endif
GST_CAT_WARNING (GST_CAT_PERFORMANCE, "Downloading took %" GST_TIME_FORMAT,
GST_TIME_ARGS (after - before));
if (vdp_stat != VDP_STATUS_OK) {
GST_ERROR ("Failed to get bits : %s",
vmem->device->vdp_get_error_string (vdp_stat));
g_free (vmem->cache);
vmem->cache = NULL;
return FALSE;
}
return TRUE;
}
static void
release_data (GstVdpVideoMemory * vmem)
{
g_return_if_fail (vmem->refcount > 0);
if (g_atomic_int_dec_and_test (&vmem->refcount)) {
g_free (vmem->cache);
}
}
static gpointer
_vdp_video_mem_map (GstVdpVideoMemory * vmem, gsize maxsize, GstMapFlags flags)
{
GST_DEBUG ("surface:%d, maxsize:%" G_GSIZE_FORMAT ", flags:%d",
vmem->surface, maxsize, flags);
if (!ensure_data (vmem))
return NULL;
return vmem->cache;
}
static void
_vdp_video_mem_unmap (GstVdpVideoMemory * vmem)
{
GST_DEBUG ("surface:%d", vmem->surface);
release_data (vmem);
}
static GstMemory *
_vdp_video_mem_copy (GstVdpVideoMemory * src, gssize offset, gssize size)
{
GST_FIXME ("Implement !");
return NULL;
}
static GstMemory *
_vdp_video_mem_share (GstVdpVideoMemory * mem, gssize offset, gssize size)
{
GST_FIXME ("Implement !");
return NULL;
}
static gboolean
_vdp_video_mem_is_span (GstVdpVideoMemory * mem1, GstVdpVideoMemory * mem2,
gsize * offset)
{
return FALSE;
}
static GstMemory *
_vdp_video_mem_alloc (GstAllocator * allocator, gsize size,
GstAllocationParams * params)
{
g_warning ("use gst_vdp_video_memory_alloc () to allocate from this "
"GstVdpVideoMemory allocator");
return NULL;
}
static void
_vdp_video_mem_free (GstAllocator * allocator, GstMemory * mem)
{
GstVdpVideoMemory *vmem = (GstVdpVideoMemory *) mem;
VdpStatus status;
GST_DEBUG ("Destroying surface %d", vmem->surface);
status = vmem->device->vdp_video_surface_destroy (vmem->surface);
if (status != VDP_STATUS_OK)
GST_ERROR ("Couldn't destroy the VdpVideoSurface: %s",
vmem->device->vdp_get_error_string (status));
gst_object_unref (vmem->device);
g_free (vmem->cache);
g_slice_free (GstVdpVideoMemory, vmem);
}
/**
* gst_vdp_video_memory_alloc:
* @device: a #GstVdpDevice
* @info: the #GstVideoInfo describing the format to use
*
* Returns: a GstMemory object with a VdpVideoSurface specified by @info
* from @device
*/
GstMemory *
gst_vdp_video_memory_alloc (GstVdpDevice * device, GstVideoInfo * info)
{
return (GstMemory *) _vdp_video_mem_new (_vdp_video_allocator, NULL, device,
info);
}
G_DEFINE_TYPE (GstVdpVideoAllocator, gst_vdp_video_allocator,
GST_TYPE_ALLOCATOR);
static void
gst_vdp_video_allocator_class_init (GstVdpVideoAllocatorClass * klass)
{
GstAllocatorClass *allocator_class;
allocator_class = (GstAllocatorClass *) klass;
allocator_class->alloc = _vdp_video_mem_alloc;
allocator_class->free = _vdp_video_mem_free;
}
static void
gst_vdp_video_allocator_init (GstVdpVideoAllocator * allocator)
{
GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);
alloc->mem_type = GST_VDP_VIDEO_MEMORY_ALLOCATOR;
alloc->mem_map = (GstMemoryMapFunction) _vdp_video_mem_map;
alloc->mem_unmap = (GstMemoryUnmapFunction) _vdp_video_mem_unmap;
alloc->mem_copy = (GstMemoryCopyFunction) _vdp_video_mem_copy;
alloc->mem_share = (GstMemoryShareFunction) _vdp_video_mem_share;
alloc->mem_is_span = (GstMemoryIsSpanFunction) _vdp_video_mem_is_span;
}
/**
* gst_vdp_video_memory_init:
*
* Initializes the GL Memory allocator. It is safe to call this function
* multiple times. This must be called before any other GstVdpVideoMemory operation.
*/
void
gst_vdp_video_memory_init (void)
{
static volatile gsize _init = 0;
if (g_once_init_enter (&_init)) {
_vdp_video_allocator =
g_object_new (gst_vdp_video_allocator_get_type (), NULL);
gst_allocator_register (GST_VDP_VIDEO_MEMORY_ALLOCATOR,
gst_object_ref (_vdp_video_allocator));
GST_DEBUG_CATEGORY_INIT (gst_vdp_video_mem_debug, "vdpvideomem", 0,
"VDPAU VideoSurface Memory/Allocator");
GST_DEBUG_CATEGORY_GET (GST_CAT_PERFORMANCE, "GST_PERFORMANCE");
g_once_init_leave (&_init, 1);
}
}
gboolean
gst_vdp_video_memory_map (GstVideoMeta * meta, guint plane, GstMapInfo * info,
gpointer * data, gint * stride, GstMapFlags flags)
{
GstBuffer *buffer = meta->buffer;
GstVdpVideoMemory *vmem =
(GstVdpVideoMemory *) gst_buffer_get_memory (buffer, 0);
/* Only handle GstVdpVideoMemory */
g_return_val_if_fail (((GstMemory *) vmem)->allocator == _vdp_video_allocator,
FALSE);
GST_DEBUG ("plane:%d", plane);
/* download if not already done */
if (!ensure_data (vmem))
return FALSE;
*data = vmem->cached_data[plane];
*stride = vmem->destination_pitches[plane];
return TRUE;
}
gboolean
gst_vdp_video_memory_unmap (GstVideoMeta * meta, guint plane, GstMapInfo * info)
{
GstVdpVideoMemory *vmem =
(GstVdpVideoMemory *) gst_buffer_get_memory (meta->buffer, 0);
GST_DEBUG ("plane:%d", plane);
GST_FIXME ("implement unmap (and potential upload on last unmap)");
release_data (vmem);
return TRUE;
}