/* * 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); if (vmem->cache) 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; }