*
* 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.
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*/
/**
* SECTION:gstmemory
+ * @title: GstMemory
* @short_description: refcounted wrapper for memory blocks
* @see_also: #GstBuffer
*
* in the allocated region.
*
* Memory is usually created by allocators with a gst_allocator_alloc()
- * method call. When NULL is used as the allocator, the default allocator will
+ * method call. When %NULL is used as the allocator, the default allocator will
* be used.
*
* New allocators can be registered with gst_allocator_register().
* memory with an existing memory block at a custom offset and with a custom
* size.
*
- * Memory can be efficiently merged when gst_memory_is_span() returns TRUE.
- *
- * Last reviewed on 2012-03-28 (0.11.3)
+ * Memory can be efficiently merged when gst_memory_is_span() returns %TRUE.
*/
#ifdef HAVE_CONFIG_H
#include "gst_private.h"
#include "gstmemory.h"
-#ifndef GST_DISABLE_TRACE
-#include "gsttrace.h"
-static GstAllocTrace *_gst_memory_trace;
-static GstAllocTrace *_gst_allocator_trace;
-#endif
-
-G_DEFINE_BOXED_TYPE (GstMemory, gst_memory, (GBoxedCopyFunc) gst_memory_ref,
- (GBoxedFreeFunc) gst_memory_unref);
-
-G_DEFINE_BOXED_TYPE (GstAllocator, gst_allocator,
- (GBoxedCopyFunc) gst_allocator_ref, (GBoxedFreeFunc) gst_allocator_unref);
-
-G_DEFINE_BOXED_TYPE (GstAllocationParams, gst_allocation_params,
- (GBoxedCopyFunc) gst_allocation_params_copy,
- (GBoxedFreeFunc) gst_allocation_params_free);
-
-#if defined(MEMORY_ALIGNMENT_MALLOC)
-size_t gst_memory_alignment = 7;
-#elif defined(MEMORY_ALIGNMENT_PAGESIZE)
-/* we fill this in in the _init method */
-size_t gst_memory_alignment = 0;
-#elif defined(MEMORY_ALIGNMENT)
-size_t gst_memory_alignment = MEMORY_ALIGNMENT - 1;
-#else
-#error "No memory alignment configured"
-size_t gst_memory_alignment = 0;
-#endif
-
-struct _GstAllocator
-{
- gint refcount;
-
- GstMemoryInfo info;
-
- gpointer user_data;
- GDestroyNotify notify;
-};
-
-/* default memory implementation */
-typedef struct
-{
- GstMemory mem;
- gsize slice_size;
- guint8 *data;
- gpointer user_data;
- GDestroyNotify notify;
-} GstMemoryDefault;
-
-/* the default allocator */
-static GstAllocator *_default_allocator;
-
-/* our predefined allocators */
-static GstAllocator *_default_mem_impl;
-
-/* initialize the fields */
-static void
-_default_mem_init (GstMemoryDefault * mem, GstMemoryFlags flags,
- GstMemory * parent, gsize slice_size, gpointer data,
- gsize maxsize, gsize offset, gsize size, gsize align,
- gpointer user_data, GDestroyNotify notify)
-{
- mem->mem.allocator = _default_mem_impl;
- mem->mem.flags = flags;
- mem->mem.refcount = 1;
- mem->mem.parent = parent ? gst_memory_ref (parent) : NULL;
- mem->mem.state = (flags & GST_MEMORY_FLAG_READONLY ? 0x1 : 0);
- mem->mem.maxsize = maxsize;
- mem->mem.align = align;
- mem->mem.offset = offset;
- mem->mem.size = size;
- mem->slice_size = slice_size;
- mem->data = data;
- mem->user_data = user_data;
- mem->notify = notify;
-
- GST_CAT_DEBUG (GST_CAT_MEMORY, "new memory %p, maxsize:%" G_GSIZE_FORMAT
- " offset:%" G_GSIZE_FORMAT " size:%" G_GSIZE_FORMAT, mem, maxsize,
- offset, size);
-}
-
-/* create a new memory block that manages the given memory */
-static GstMemoryDefault *
-_default_mem_new (GstMemoryFlags flags, GstMemory * parent, gpointer data,
- gsize maxsize, gsize offset, gsize size, gsize align, gpointer user_data,
- GDestroyNotify notify)
-{
- GstMemoryDefault *mem;
- gsize slice_size;
-
- slice_size = sizeof (GstMemoryDefault);
-
- mem = g_slice_alloc (slice_size);
- _default_mem_init (mem, flags, parent, slice_size,
- data, maxsize, offset, size, align, user_data, notify);
-
- return mem;
-}
-
-/* allocate the memory and structure in one block */
-static GstMemoryDefault *
-_default_mem_new_block (GstMemoryFlags flags, gsize maxsize, gsize align,
- gsize offset, gsize size)
-{
- GstMemoryDefault *mem;
- gsize aoffset, slice_size, padding;
- guint8 *data;
-
- /* ensure configured alignment */
- align |= gst_memory_alignment;
- /* allocate more to compensate for alignment */
- maxsize += align;
- /* alloc header and data in one block */
- slice_size = sizeof (GstMemoryDefault) + maxsize;
-
- mem = g_slice_alloc (slice_size);
- if (mem == NULL)
- return NULL;
-
- data = (guint8 *) mem + sizeof (GstMemoryDefault);
-
- /* do alignment */
- if ((aoffset = ((guintptr) data & align))) {
- aoffset = (align + 1) - aoffset;
- data += aoffset;
- maxsize -= aoffset;
- }
-
- if (offset && (flags & GST_MEMORY_FLAG_ZERO_PREFIXED))
- memset (data, 0, offset);
-
- padding = maxsize - (offset + size);
- if (padding && (flags & GST_MEMORY_FLAG_ZERO_PADDED))
- memset (data + offset + size, 0, padding);
-
- _default_mem_init (mem, flags, NULL, slice_size, data, maxsize,
- offset, size, align, NULL, NULL);
-
- return mem;
-}
+GType _gst_memory_type = 0;
+GST_DEFINE_MINI_OBJECT_TYPE (GstMemory, gst_memory);
static GstMemory *
-_default_alloc_alloc (GstAllocator * allocator, gsize size,
- GstAllocationParams * params, gpointer user_data)
+_gst_memory_copy (GstMemory * mem)
{
- gsize maxsize = size + params->prefix + params->padding;
-
- return (GstMemory *) _default_mem_new_block (params->flags,
- maxsize, params->align, params->prefix, size);
-}
-
-static gpointer
-_default_mem_map (GstMemoryDefault * mem, GstMapFlags flags)
-{
- return mem->data;
-}
-
-static gboolean
-_default_mem_unmap (GstMemoryDefault * mem)
-{
- return TRUE;
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "copy memory %p", mem);
+ return gst_memory_copy (mem, 0, -1);
}
static void
-_default_mem_free (GstMemoryDefault * mem)
-{
- GST_CAT_DEBUG (GST_CAT_MEMORY, "free memory %p", mem);
-
- if (mem->mem.parent)
- gst_memory_unref (mem->mem.parent);
-
- if (mem->notify)
- mem->notify (mem->user_data);
-
- g_slice_free1 (mem->slice_size, mem);
-}
-
-static GstMemoryDefault *
-_default_mem_copy (GstMemoryDefault * mem, gssize offset, gsize size)
-{
- GstMemoryDefault *copy;
-
- if (size == -1)
- size = mem->mem.size > offset ? mem->mem.size - offset : 0;
-
- copy =
- _default_mem_new_block (0, mem->mem.maxsize, 0, mem->mem.offset + offset,
- size);
- memcpy (copy->data, mem->data, mem->mem.maxsize);
- GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy memory %p -> %p", mem, copy);
-
- return copy;
-}
-
-static GstMemoryDefault *
-_default_mem_share (GstMemoryDefault * mem, gssize offset, gsize size)
-{
- GstMemoryDefault *sub;
- GstMemory *parent;
-
- /* find the real parent */
- if ((parent = mem->mem.parent) == NULL)
- parent = (GstMemory *) mem;
-
- if (size == -1)
- size = mem->mem.size - offset;
-
- sub =
- _default_mem_new (parent->flags, parent, mem->data,
- mem->mem.maxsize, mem->mem.offset + offset, size, mem->mem.align, NULL,
- NULL);
-
- return sub;
-}
-
-static gboolean
-_default_mem_is_span (GstMemoryDefault * mem1, GstMemoryDefault * mem2,
- gsize * offset)
-{
-
- if (offset) {
- GstMemoryDefault *parent;
-
- parent = (GstMemoryDefault *) mem1->mem.parent;
-
- *offset = mem1->mem.offset - parent->mem.offset;
- }
-
- /* and memory is contiguous */
- return mem1->data + mem1->mem.offset + mem1->mem.size ==
- mem2->data + mem2->mem.offset;
-}
-
-static GstMemory *
-_fallback_mem_copy (GstMemory * mem, gssize offset, gssize size)
+_gst_memory_free (GstMemory * mem)
{
- GstMemory *copy;
- GstMapInfo sinfo, dinfo;
- GstAllocationParams params = { 0, 0, 0, mem->align, };
-
- if (!gst_memory_map (mem, &sinfo, GST_MAP_READ))
- return NULL;
+ GstAllocator *allocator;
- if (size == -1)
- size = sinfo.size > offset ? sinfo.size - offset : 0;
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "free memory %p", mem);
- /* use the same allocator as the memory we copy */
- copy = gst_allocator_alloc (mem->allocator, size, ¶ms);
- if (!gst_memory_map (copy, &dinfo, GST_MAP_WRITE)) {
- GST_CAT_WARNING (GST_CAT_MEMORY, "could not write map memory %p", copy);
- gst_memory_unmap (mem, &sinfo);
- return NULL;
+ if (mem->parent) {
+ gst_memory_unlock (mem->parent, GST_LOCK_FLAG_EXCLUSIVE);
+ gst_memory_unref (mem->parent);
}
- memcpy (dinfo.data, sinfo.data + offset, size);
- GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy memory %p -> %p", mem, copy);
- gst_memory_unmap (copy, &dinfo);
- gst_memory_unmap (mem, &sinfo);
-
- return copy;
-}
-
-static gboolean
-_fallback_mem_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset)
-{
- return FALSE;
-}
-
-static GRWLock lock;
-static GHashTable *allocators;
-
-static void
-_priv_sysmem_notify (gpointer user_data)
-{
- g_warning ("The default memory allocator was freed!");
-}
-
-void
-_priv_gst_memory_initialize (void)
-{
- static const GstMemoryInfo _mem_info = {
- GST_ALLOCATOR_SYSMEM,
- (GstAllocatorAllocFunction) _default_alloc_alloc,
- (GstMemoryMapFunction) _default_mem_map,
- (GstMemoryUnmapFunction) _default_mem_unmap,
- (GstMemoryFreeFunction) _default_mem_free,
- (GstMemoryCopyFunction) _default_mem_copy,
- (GstMemoryShareFunction) _default_mem_share,
- (GstMemoryIsSpanFunction) _default_mem_is_span,
- };
+ allocator = mem->allocator;
-#ifndef GST_DISABLE_TRACE
- _gst_memory_trace = _gst_alloc_trace_register ("GstMemory", -1);
- _gst_allocator_trace = _gst_alloc_trace_register ("GstAllocator", -1);
-#endif
+ gst_allocator_free (allocator, mem);
- g_rw_lock_init (&lock);
- allocators = g_hash_table_new (g_str_hash, g_str_equal);
-
-#ifdef HAVE_GETPAGESIZE
-#ifdef MEMORY_ALIGNMENT_PAGESIZE
- gst_memory_alignment = getpagesize () - 1;
-#endif
-#endif
-
- GST_CAT_DEBUG (GST_CAT_MEMORY, "memory alignment: %" G_GSIZE_FORMAT,
- gst_memory_alignment);
-
- _default_mem_impl = gst_allocator_new (&_mem_info, NULL, _priv_sysmem_notify);
-
- _default_allocator = gst_allocator_ref (_default_mem_impl);
- gst_allocator_register (GST_ALLOCATOR_SYSMEM,
- gst_allocator_ref (_default_mem_impl));
+ gst_object_unref (allocator);
}
/**
- * gst_memory_new_wrapped:
+ * gst_memory_init: (skip)
+ * @mem: a #GstMemory
* @flags: #GstMemoryFlags
- * @data: data to wrap
- * @maxsize: allocated size of @data
- * @offset: offset in @data
- * @size: size of valid data
- * @user_data: user_data
- * @notify: called with @user_data when the memory is freed
- *
- * Allocate a new memory block that wraps the given @data.
- *
- * The prefix/padding must be filled with 0 if @flags contains
- * #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED respectively.
- *
- * Returns: a new #GstMemory.
+ * @allocator: the #GstAllocator
+ * @parent: the parent of @mem
+ * @maxsize: the total size of the memory
+ * @align: the alignment of the memory
+ * @offset: The offset in the memory
+ * @size: the size of valid data in the memory
+
+ * Initializes a newly allocated @mem with the given parameters. This function
+ * will call gst_mini_object_init() with the default memory parameters.
*/
-GstMemory *
-gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data,
- gsize maxsize, gsize offset, gsize size, gpointer user_data,
- GDestroyNotify notify)
+void
+gst_memory_init (GstMemory * mem, GstMemoryFlags flags,
+ GstAllocator * allocator, GstMemory * parent, gsize maxsize, gsize align,
+ gsize offset, gsize size)
{
- GstMemoryDefault *mem;
+ gst_mini_object_init (GST_MINI_OBJECT_CAST (mem),
+ flags | GST_MINI_OBJECT_FLAG_LOCKABLE, GST_TYPE_MEMORY,
+ (GstMiniObjectCopyFunction) _gst_memory_copy, NULL,
+ (GstMiniObjectFreeFunction) _gst_memory_free);
- g_return_val_if_fail (data != NULL, NULL);
- g_return_val_if_fail (offset + size <= maxsize, NULL);
-
- mem =
- _default_mem_new (flags, NULL, data, maxsize, offset, size, 0, user_data,
- notify);
-
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_new (_gst_memory_trace, mem);
-#endif
+ mem->allocator = gst_object_ref (allocator);
+ if (parent) {
+ /* FIXME 2.0: this can fail if the memory is already write locked */
+ gst_memory_lock (parent, GST_LOCK_FLAG_EXCLUSIVE);
+ gst_memory_ref (parent);
+ }
+ mem->parent = parent;
+ mem->maxsize = maxsize;
+ mem->align = align;
+ mem->offset = offset;
+ mem->size = size;
- return (GstMemory *) mem;
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "new memory %p, maxsize:%" G_GSIZE_FORMAT
+ " offset:%" G_GSIZE_FORMAT " size:%" G_GSIZE_FORMAT, mem, maxsize,
+ offset, size);
}
/**
- * gst_memory_ref:
+ * gst_memory_is_type:
* @mem: a #GstMemory
+ * @mem_type: a memory type
*
- * Increases the refcount of @mem.
- *
- * Returns: @mem with increased refcount
- */
-GstMemory *
-gst_memory_ref (GstMemory * mem)
-{
- g_return_val_if_fail (mem != NULL, NULL);
-
- GST_CAT_TRACE (GST_CAT_MEMORY, "memory %p, %d->%d", mem, mem->refcount,
- mem->refcount + 1);
-
- g_atomic_int_inc (&mem->refcount);
-
- return mem;
-}
-
-/**
- * gst_memory_unref:
- * @mem: a #GstMemory
+ * Check if @mem if allocated with an allocator for @mem_type.
*
- * Decreases the refcount of @mem. When the refcount reaches 0, the free
- * function of @mem will be called.
- */
-void
-gst_memory_unref (GstMemory * mem)
-{
- g_return_if_fail (mem != NULL);
- g_return_if_fail (mem->allocator != NULL);
-
- GST_CAT_TRACE (GST_CAT_MEMORY, "memory %p, %d->%d", mem, mem->refcount,
- mem->refcount - 1);
-
- if (g_atomic_int_dec_and_test (&mem->refcount)) {
- /* there should be no outstanding mappings */
- g_return_if_fail (g_atomic_int_get (&mem->state) < 4);
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_free (_gst_memory_trace, mem);
-#endif
- mem->allocator->info.mem_free (mem);
- }
-}
-
-/**
- * gst_memory_is_exclusive:
- * @mem: a #GstMemory
+ * Returns: %TRUE if @mem was allocated from an allocator for @mem_type.
*
- * Check if the current ref to @mem is exclusive, this means that no other
- * references exist other than @mem.
+ * Since: 1.2
*/
gboolean
-gst_memory_is_exclusive (GstMemory * mem)
+gst_memory_is_type (GstMemory * mem, const gchar * mem_type)
{
g_return_val_if_fail (mem != NULL, FALSE);
+ g_return_val_if_fail (mem->allocator != NULL, FALSE);
+ g_return_val_if_fail (mem_type != NULL, FALSE);
- return (g_atomic_int_get (&mem->refcount) == 1);
+ return (g_strcmp0 (mem->allocator->mem_type, mem_type) == 0);
}
/**
* gst_memory_get_sizes:
* @mem: a #GstMemory
- * @offset: pointer to offset
- * @maxsize: pointer to maxsize
+ * @offset: (out) (allow-none): pointer to offset
+ * @maxsize: (out) (allow-none): pointer to maxsize
*
* Get the current @size, @offset and @maxsize of @mem.
*
gst_memory_resize (GstMemory * mem, gssize offset, gsize size)
{
g_return_if_fail (mem != NULL);
+ g_return_if_fail (gst_memory_is_writable (mem));
g_return_if_fail (offset >= 0 || mem->offset >= -offset);
g_return_if_fail (size + mem->offset + offset <= mem->maxsize);
mem->size = size;
}
-static gboolean
-gst_memory_lock (GstMemory * mem, GstMapFlags flags)
-{
- gint access_mode, state, newstate;
-
- access_mode = flags & 3;
-
- do {
- state = g_atomic_int_get (&mem->state);
- if (state == 0) {
- /* nothing mapped, set access_mode and refcount */
- newstate = 4 | access_mode;
- } else {
- /* access_mode must match */
- if ((state & access_mode) != access_mode)
- goto lock_failed;
- /* increase refcount */
- newstate = state + 4;
- }
- } while (!g_atomic_int_compare_and_exchange (&mem->state, state, newstate));
-
- return TRUE;
-
-lock_failed:
- {
- GST_CAT_DEBUG (GST_CAT_MEMORY, "lock failed %p: state %d, access_mode %d",
- mem, state, access_mode);
- return FALSE;
- }
-}
-
-static void
-gst_memory_unlock (GstMemory * mem)
-{
- gint state, newstate;
-
- do {
- state = g_atomic_int_get (&mem->state);
- /* decrease the refcount */
- newstate = state - 4;
- /* last refcount, unset access_mode */
- if (newstate < 4)
- newstate = 0;
- } while (!g_atomic_int_compare_and_exchange (&mem->state, state, newstate));
-}
-
-
/**
* gst_memory_make_mapped:
* @mem: (transfer full): a #GstMemory
* This function takes ownership of old @mem and returns a reference to a new
* #GstMemory.
*
- * Returns: (transfer full): a #GstMemory object mapped with @flags or NULL when
- * a mapping is not possible.
+ * Returns: (transfer full) (nullable): a #GstMemory object mapped
+ * with @flags or %NULL when a mapping is not possible.
*/
GstMemory *
gst_memory_make_mapped (GstMemory * mem, GstMapInfo * info, GstMapFlags flags)
g_return_val_if_fail (mem != NULL, FALSE);
g_return_val_if_fail (info != NULL, FALSE);
- if (!gst_memory_lock (mem, flags))
+ if (!gst_memory_lock (mem, (GstLockFlags) flags))
goto lock_failed;
- info->data = mem->allocator->info.mem_map (mem, mem->maxsize, flags);
+ info->flags = flags;
+ info->memory = mem;
+ info->size = mem->size;
+ info->maxsize = mem->maxsize - mem->offset;
+
+ if (mem->allocator->mem_map_full)
+ info->data = mem->allocator->mem_map_full (mem, info, mem->maxsize);
+ else
+ info->data = mem->allocator->mem_map (mem, mem->maxsize, flags);
if (G_UNLIKELY (info->data == NULL))
goto error;
- info->memory = mem;
- info->flags = flags;
- info->size = mem->size;
- info->maxsize = mem->maxsize - mem->offset;
info->data = info->data + mem->offset;
return TRUE;
lock_failed:
{
GST_CAT_DEBUG (GST_CAT_MEMORY, "mem %p: lock %d failed", mem, flags);
+ memset (info, 0, sizeof (GstMapInfo));
return FALSE;
}
error:
{
- /* something went wrong, restore the orginal state again */
- GST_CAT_ERROR (GST_CAT_MEMORY, "mem %p: map failed", mem);
- gst_memory_unlock (mem);
+ /* something went wrong, restore the original state again
+ * it is up to the subclass to log an error if needed. */
+ GST_CAT_INFO (GST_CAT_MEMORY, "mem %p: subclass map failed", mem);
+ gst_memory_unlock (mem, (GstLockFlags) flags);
+ memset (info, 0, sizeof (GstMapInfo));
return FALSE;
}
}
g_return_if_fail (mem != NULL);
g_return_if_fail (info != NULL);
g_return_if_fail (info->memory == mem);
- /* there must be a ref */
- g_return_if_fail (g_atomic_int_get (&mem->state) >= 4);
- mem->allocator->info.mem_unmap (mem);
- gst_memory_unlock (mem);
+ if (mem->allocator->mem_unmap_full)
+ mem->allocator->mem_unmap_full (mem, info);
+ else
+ mem->allocator->mem_unmap (mem);
+ gst_memory_unlock (mem, (GstLockFlags) info->flags);
}
/**
* gst_memory_copy:
* @mem: a #GstMemory
- * @offset: an offset to copy
- * @size: size to copy or -1 to copy all bytes from offset
+ * @offset: offset to copy from
+ * @size: size to copy, or -1 to copy to the end of the memory region
*
* Return a copy of @size bytes from @mem starting from @offset. This copy is
- * guaranteed to be writable. @size can be set to -1 to return a copy all bytes
- * from @offset.
+ * guaranteed to be writable. @size can be set to -1 to return a copy
+ * from @offset to the end of the memory region.
*
* Returns: a new #GstMemory.
*/
g_return_val_if_fail (mem != NULL, NULL);
- copy = mem->allocator->info.mem_copy (mem, offset, size);
-
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_new (_gst_memory_trace, copy);
-#endif
+ copy = mem->allocator->mem_copy (mem, offset, size);
return copy;
}
/**
* gst_memory_share:
* @mem: a #GstMemory
- * @offset: an offset to share
- * @size: size to share or -1 to share bytes from offset
+ * @offset: offset to share from
+ * @size: size to share, or -1 to share to the end of the memory region
*
* Return a shared copy of @size bytes from @mem starting from @offset. No
* memory copy is performed and the memory region is simply shared. The result
- * is guaranteed to be not-writable. @size can be set to -1 to return a share
- * all bytes from @offset.
+ * is guaranteed to be non-writable. @size can be set to -1 to return a shared
+ * copy from @offset to the end of the memory region.
*
* Returns: a new #GstMemory.
*/
g_return_val_if_fail (!GST_MEMORY_FLAG_IS_SET (mem, GST_MEMORY_FLAG_NO_SHARE),
NULL);
- shared = mem->allocator->info.mem_share (mem, offset, size);
+ /* whether we can lock the memory exclusively */
+ /* in order to maintain backwards compatibility by not requiring subclasses
+ * to lock the memory themselves and propagate the possible failure in their
+ * mem_share implementation */
+ /* FIXME 2.0: remove and fix gst_memory_init() and/or all memory subclasses
+ * to propagate this failure case */
+ if (!gst_memory_lock (mem, GST_LOCK_FLAG_EXCLUSIVE))
+ return NULL;
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_new (_gst_memory_trace, shared);
-#endif
+ /* double lock to ensure we are not mapped writable without an
+ * exclusive lock. */
+ if (!gst_memory_lock (mem, GST_LOCK_FLAG_EXCLUSIVE)) {
+ gst_memory_unlock (mem, GST_LOCK_FLAG_EXCLUSIVE);
+ return NULL;
+ }
+
+ shared = mem->allocator->mem_share (mem, offset, size);
+
+ /* unlocking before calling the subclass would be racy */
+ gst_memory_unlock (mem, GST_LOCK_FLAG_EXCLUSIVE);
+ gst_memory_unlock (mem, GST_LOCK_FLAG_EXCLUSIVE);
return shared;
}
* gst_memory_is_span:
* @mem1: a #GstMemory
* @mem2: a #GstMemory
- * @offset: a pointer to a result offset
+ * @offset: (out): a pointer to a result offset
*
* Check if @mem1 and mem2 share the memory with a common parent memory object
* and that the memory is contiguous.
return FALSE;
/* and memory is contiguous */
- if (!mem1->allocator->info.mem_is_span (mem1, mem2, offset))
+ if (!mem1->allocator->mem_is_span (mem1, mem2, offset))
return FALSE;
return TRUE;
}
-/**
- * gst_allocator_new:
- * @info: a #GstMemoryInfo
- * @user_data: user data
- * @notify: a #GDestroyNotify for @user_data
- *
- * Create a new memory allocator with @info and @user_data.
- *
- * All functions in @info are mandatory exept the copy and is_span
- * functions, which will have a default implementation when left NULL.
- *
- * The @user_data will be passed to all calls of the alloc function. @notify
- * will be called with @user_data when the allocator is freed.
- *
- * Returns: a new #GstAllocator.
- */
-GstAllocator *
-gst_allocator_new (const GstMemoryInfo * info, gpointer user_data,
- GDestroyNotify notify)
-{
- GstAllocator *allocator;
-
-#define INSTALL_FALLBACK(_t) \
- if (allocator->info._t == NULL) allocator->info._t = _fallback_ ##_t;
-
- g_return_val_if_fail (info != NULL, NULL);
- g_return_val_if_fail (info->alloc != NULL, NULL);
- g_return_val_if_fail (info->mem_map != NULL, NULL);
- g_return_val_if_fail (info->mem_unmap != NULL, NULL);
- g_return_val_if_fail (info->mem_free != NULL, NULL);
- g_return_val_if_fail (info->mem_share != NULL, NULL);
-
- allocator = g_slice_new (GstAllocator);
- allocator->refcount = 1;
- allocator->info = *info;
- allocator->user_data = user_data;
- allocator->notify = notify;
- INSTALL_FALLBACK (mem_copy);
- INSTALL_FALLBACK (mem_is_span);
-#undef INSTALL_FALLBACK
-
- GST_CAT_DEBUG (GST_CAT_MEMORY, "new allocator %p", allocator);
-
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_new (_gst_allocator_trace, allocator);
-#endif
-
- return allocator;
-}
-
-/**
- * gst_allocator_get_memory_type:
- * @allocator: a #GstAllocator
- *
- * Get the memory type allocated by this allocator
- *
- * Returns: the memory type provided by @allocator
- */
-const gchar *
-gst_allocator_get_memory_type (GstAllocator * allocator)
-{
- g_return_val_if_fail (allocator != NULL, NULL);
-
- return allocator->info.mem_type;
-}
-
-/**
- * gst_allocator_ref:
- * @allocator: a #GstAllocator
- *
- * Increases the refcount of @allocator.
- *
- * Returns: @allocator with increased refcount
- */
-GstAllocator *
-gst_allocator_ref (GstAllocator * allocator)
-{
- g_return_val_if_fail (allocator != NULL, NULL);
-
- GST_CAT_TRACE (GST_CAT_MEMORY, "allocator %p, %d->%d", allocator,
- allocator->refcount, allocator->refcount + 1);
-
- g_atomic_int_inc (&allocator->refcount);
-
- return allocator;
-}
-
-/**
- * gst_allocator_unref:
- * @allocator: a #GstAllocator
- *
- * Decreases the refcount of @allocator. When the refcount reaches 0, the notify
- * function of @allocator will be called and the allocator will be freed.
- */
-void
-gst_allocator_unref (GstAllocator * allocator)
-{
- g_return_if_fail (allocator != NULL);
-
- GST_CAT_TRACE (GST_CAT_MEMORY, "allocator %p, %d->%d", allocator,
- allocator->refcount, allocator->refcount - 1);
-
- if (g_atomic_int_dec_and_test (&allocator->refcount)) {
- if (allocator->notify)
- allocator->notify (allocator->user_data);
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_free (_gst_allocator_trace, allocator);
-#endif
- g_slice_free1 (sizeof (GstAllocator), allocator);
- }
-}
-
-/**
- * gst_allocator_register:
- * @name: the name of the allocator
- * @allocator: (transfer full): #GstAllocator
- *
- * Registers the memory @allocator with @name. This function takes ownership of
- * @allocator.
- */
-void
-gst_allocator_register (const gchar * name, GstAllocator * allocator)
-{
- g_return_if_fail (name != NULL);
- g_return_if_fail (allocator != NULL);
-
- GST_CAT_DEBUG (GST_CAT_MEMORY, "registering allocator %p with name \"%s\"",
- allocator, name);
-
- g_rw_lock_writer_lock (&lock);
- g_hash_table_insert (allocators, (gpointer) name, (gpointer) allocator);
- g_rw_lock_writer_unlock (&lock);
-}
-
-/**
- * gst_allocator_find:
- * @name: the name of the allocator
- *
- * Find a previously registered allocator with @name. When @name is NULL, the
- * default allocator will be returned.
- *
- * Returns: (transfer full): a #GstAllocator or NULL when the allocator with @name was not
- * registered. Use gst_allocator_unref() to release the allocator after usage.
- */
-GstAllocator *
-gst_allocator_find (const gchar * name)
-{
- GstAllocator *allocator;
-
- g_rw_lock_reader_lock (&lock);
- if (name) {
- allocator = g_hash_table_lookup (allocators, (gconstpointer) name);
- } else {
- allocator = _default_allocator;
- }
- if (allocator)
- gst_allocator_ref (allocator);
- g_rw_lock_reader_unlock (&lock);
-
- return allocator;
-}
-
-/**
- * gst_allocator_set_default:
- * @allocator: (transfer full): a #GstAllocator
- *
- * Set the default allocator. This function takes ownership of @allocator.
- */
-void
-gst_allocator_set_default (GstAllocator * allocator)
-{
- GstAllocator *old;
- g_return_if_fail (allocator != NULL);
-
- g_rw_lock_writer_lock (&lock);
- old = _default_allocator;
- _default_allocator = allocator;
- g_rw_lock_writer_unlock (&lock);
-
- if (old)
- gst_allocator_unref (old);
-}
-
-/**
- * gst_allocation_params_init:
- * @params: a #GstAllocationParams
- *
- * Initialize @params to its default values
- */
-void
-gst_allocation_params_init (GstAllocationParams * params)
-{
- g_return_if_fail (params != NULL);
-
- memset (params, 0, sizeof (GstAllocationParams));
-}
-
-/**
- * gst_allocation_params_copy:
- * @params: (transfer none): a #GstAllocationParams
- *
- * Create a copy of @params.
- *
- * Free-function: gst_allocation_params_free
- *
- * Returns: (transfer full): a new ##GstAllocationParams, free with
- * gst_allocation_params_free().
- */
-GstAllocationParams *
-gst_allocation_params_copy (const GstAllocationParams * params)
-{
- GstAllocationParams *result = NULL;
-
- if (params) {
- result =
- (GstAllocationParams *) g_slice_copy (sizeof (GstAllocationParams),
- params);
- }
- return result;
-}
-
-/**
- * gst_allocation_params_free:
- * @params: (in) (transfer full): a #GstAllocationParams
- *
- * Free @params
- */
void
-gst_allocation_params_free (GstAllocationParams * params)
-{
- g_slice_free (GstAllocationParams, params);
-}
-
-/**
- * gst_allocator_alloc:
- * @allocator: (transfer none) (allow-none): a #GstAllocator to use
- * @size: size of the visible memory area
- * @params: (transfer none) (allow-none): optional parameters
- *
- * Use @allocator to allocate a new memory block with memory that is at least
- * @size big.
- *
- * The optional @params can specify the prefix and padding for the memory. If
- * NULL is passed, no flags, no extra prefix/padding and a default alignment is
- * used.
- *
- * The prefix/padding will be filled with 0 if flags contains
- * #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED respectively.
- *
- * When @allocator is NULL, the default allocator will be used.
- *
- * The alignment in @params is given as a bitmask so that @align + 1 equals
- * the amount of bytes to align to. For example, to align to 8 bytes,
- * use an alignment of 7.
- *
- * Returns: (transfer full): a new #GstMemory.
- */
-GstMemory *
-gst_allocator_alloc (GstAllocator * allocator, gsize size,
- GstAllocationParams * params)
+_priv_gst_memory_initialize (void)
{
- GstMemory *mem;
- static GstAllocationParams defparams = { 0, 0, 0, 0, };
-
- if (params) {
- g_return_val_if_fail (((params->align + 1) & params->align) == 0, NULL);
- } else {
- params = &defparams;
- }
-
- if (allocator == NULL)
- allocator = _default_allocator;
-
- mem = allocator->info.alloc (allocator, size, params, allocator->user_data);
-
-#ifndef GST_DISABLE_TRACE
- _gst_alloc_trace_new (_gst_memory_trace, mem);
-#endif
- return mem;
+ _gst_memory_type = gst_memory_get_type ();
}
projects / platform / upstream / gstreamer.git / blobdiff