*
* 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
*
* GstMemory is a lightweight refcounted object that wraps a region of memory.
* They are typically used to manage the data of a #GstBuffer.
*
+ * A GstMemory object has an allocated region of memory of maxsize. The maximum
+ * size does not change during the lifetime of the memory object. The memory
+ * also has an offset and size property that specifies the valid range of memory
+ * 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().
* Allocators are identified by name and can be retrieved with
- * gst_allocator_find().
+ * gst_allocator_find(). gst_allocator_set_default() can be used to change the
+ * default allocator.
*
* New memory can be created with gst_memory_new_wrapped() that wraps the memory
* allocated elsewhere.
* gst_memory_get_sizes() and gst_memory_resize() respectively.
*
* Getting access to the data of the memory is performed with gst_memory_map().
+ * The call will return a pointer to offset bytes into the region of memory.
* After the memory access is completed, gst_memory_unmap() should be called.
*
- * Memory can be copied with gst_memory_copy(), which will returnn a writable
+ * Memory can be copied with gst_memory_copy(), which will return a writable
* copy. gst_memory_share() will create a new memory block that shares the
* 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 2011-06-08 (0.11.0)
+ * Memory can be efficiently merged when gst_memory_is_span() returns %TRUE.
*/
+#ifdef HAVE_CONFIG_H
#include "config.h"
-#include "gst_private.h"
-#include "gstmemory.h"
-
-G_DEFINE_BOXED_TYPE (GstMemory, gst_memory, (GBoxedCopyFunc) gst_memory_ref,
- (GBoxedFreeFunc) gst_memory_unref);
-
-/**
- * gst_memory_alignment:
- *
- * The default memory alignment in bytes - 1
- * an alignment of 7 would be the same as what malloc() guarantees.
- */
-#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
-{
- GQuark name;
-
- GstMemoryInfo info;
-};
-
-/* default memory implementation */
-typedef struct
-{
- GstMemory mem;
- gsize slice_size;
- guint8 *data;
- GFreeFunc free_func;
- gsize maxsize;
- gsize offset;
- gsize size;
-} GstMemoryDefault;
-
-/* the default allocator */
-static const GstAllocator *_default_allocator;
-
-/* our predefined allocators */
-static const GstAllocator *_default_mem_impl;
-
-/* initialize the fields */
-static void
-_default_mem_init (GstMemoryDefault * mem, GstMemoryFlags flags,
- GstMemory * parent, gsize slice_size, gpointer data,
- GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
-{
- mem->mem.allocator = _default_mem_impl;
- mem->mem.flags = flags;
- mem->mem.refcount = 1;
- mem->mem.parent = parent ? gst_memory_ref (parent) : NULL;
- mem->slice_size = slice_size;
- mem->data = data;
- mem->free_func = free_func;
- mem->maxsize = maxsize;
- mem->offset = offset;
- mem->size = size;
-}
-
-/* create a new memory block that manages the given memory */
-static GstMemoryDefault *
-_default_mem_new (GstMemoryFlags flags, GstMemory * parent, gpointer data,
- GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
-{
- GstMemoryDefault *mem;
- gsize slice_size;
-
- slice_size = sizeof (GstMemoryDefault);
-
- mem = g_slice_alloc (slice_size);
- _default_mem_init (mem, flags, parent, slice_size,
- data, free_func, maxsize, offset, size);
-
- return mem;
-}
-
-/* allocate the memory and structure in one block */
-static GstMemoryDefault *
-_default_mem_new_block (gsize maxsize, gsize align, gsize offset, gsize size)
-{
- GstMemoryDefault *mem;
- gsize aoffset, slice_size;
- 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);
-
- if ((aoffset = ((guintptr) data & align)))
- aoffset = (align + 1) - aoffset;
-
- _default_mem_init (mem, 0, NULL, slice_size, data, NULL, maxsize,
- aoffset + offset, size);
+#include "gst_private.h"
+#include "gstmemory.h"
- return mem;
-}
+GType _gst_memory_type = 0;
+GST_DEFINE_MINI_OBJECT_TYPE (GstMemory, gst_memory);
static GstMemory *
-_default_mem_alloc (const GstAllocator * allocator, gsize maxsize, gsize align)
-{
- return (GstMemory *) _default_mem_new_block (maxsize, align, 0, maxsize);
-}
-
-static gsize
-_default_mem_get_sizes (GstMemoryDefault * mem, gsize * offset, gsize * maxsize)
-{
- if (offset)
- *offset = mem->offset;
- if (maxsize)
- *maxsize = mem->maxsize;
-
- return mem->size;
-}
-
-static void
-_default_mem_resize (GstMemoryDefault * mem, gssize offset, gsize size)
-{
- g_return_if_fail (offset >= 0 || mem->offset >= -offset);
- g_return_if_fail (size + mem->offset + offset <= mem->maxsize);
-
- mem->offset += offset;
- mem->size = size;
-}
-
-static gpointer
-_default_mem_map (GstMemoryDefault * mem, gsize * size, gsize * maxsize,
- GstMapFlags flags)
-{
- if (size)
- *size = mem->size;
- if (maxsize)
- *maxsize = mem->maxsize - mem->offset;
-
- return mem->data + mem->offset;
-}
-
-static gboolean
-_default_mem_unmap (GstMemoryDefault * mem, gpointer data, gsize size)
+_gst_memory_copy (GstMemory * mem)
{
- g_return_val_if_fail ((guint8 *) data >= mem->data
- && (guint8 *) data < mem->data + mem->maxsize, FALSE);
-
- if (mem->data + mem->offset != data)
- mem->offset = (guint8 *) data - mem->data;
-
- if (size != -1) {
- g_return_val_if_fail (mem->offset + size <= mem->maxsize, FALSE);
- mem->size = size;
- }
-
- 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)
-{
- if (mem->mem.parent)
- gst_memory_unref (mem->mem.parent);
-
- if (mem->free_func)
- mem->free_func (mem->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->size > offset ? mem->size - offset : 0;
-
- copy = _default_mem_new_block (mem->maxsize, 0, mem->offset + offset, size);
- memcpy (copy->data, mem->data, mem->maxsize);
-
- return copy;
-}
-
-static GstMemoryDefault *
-_default_mem_share (GstMemoryDefault * mem, gssize offset, gsize size)
+_gst_memory_free (GstMemory * mem)
{
- GstMemoryDefault *sub;
- GstMemory *parent;
-
- /* find the real parent */
- if ((parent = mem->mem.parent) == NULL)
- parent = (GstMemory *) mem;
-
- if (size == -1)
- size = mem->size - offset;
-
- sub = _default_mem_new (parent->flags, parent, mem->data, NULL, mem->maxsize,
- mem->offset + offset, size);
-
- return sub;
-}
-
-static gboolean
-_default_mem_is_span (GstMemoryDefault * mem1, GstMemoryDefault * mem2,
- gsize * offset)
-{
-
- if (offset) {
- GstMemoryDefault *parent;
+ GstAllocator *allocator;
- parent = (GstMemoryDefault *) mem1->mem.parent;
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "free memory %p", mem);
- *offset = mem1->offset - parent->offset;
+ if (mem->parent) {
+ gst_memory_unlock (mem->parent, GST_LOCK_FLAG_EXCLUSIVE);
+ gst_memory_unref (mem->parent);
}
- /* and memory is contiguous */
- return mem1->data + mem1->offset + mem1->size == mem2->data + mem2->offset;
-}
+ allocator = mem->allocator;
-static GstMemory *
-_fallback_copy (GstMemory * mem, gssize offset, gssize size)
-{
- GstMemory *copy;
- guint8 *data, *dest;
- gsize msize;
-
- data = gst_memory_map (mem, &msize, NULL, GST_MAP_READ);
- if (size == -1)
- size = msize > offset ? msize - offset : 0;
- /* use the same allocator as the memory we copy, FIXME, alignment? */
- copy = gst_allocator_alloc (mem->allocator, size, 0);
- dest = gst_memory_map (copy, NULL, NULL, GST_MAP_WRITE);
- memcpy (dest, data + offset, size);
- gst_memory_unmap (copy, dest, size);
-
- gst_memory_unmap (mem, data, msize);
+ gst_allocator_free (allocator, mem);
- return (GstMemory *) copy;
-}
-
-static gboolean
-_fallback_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset)
-{
- return FALSE;
-}
-
-static GStaticRWLock lock = G_STATIC_RW_LOCK_INIT;
-static GHashTable *allocators;
-
-void
-_priv_gst_memory_initialize (void)
-{
- static const GstMemoryInfo _mem_info = {
- (GstMemoryAllocFunction) _default_mem_alloc,
- (GstMemoryGetSizesFunction) _default_mem_get_sizes,
- (GstMemoryResizeFunction) _default_mem_resize,
- (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,
- NULL
- };
-
- 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_DEBUG ("memory alignment: %" G_GSIZE_FORMAT, gst_memory_alignment);
-
- _default_mem_impl = gst_allocator_register (GST_ALLOCATOR_SYSMEM, &_mem_info);
-
- _default_allocator = _default_mem_impl;
+ gst_object_unref (allocator);
}
/**
- * gst_memory_new_wrapped:
+ * gst_memory_init: (skip)
+ * @mem: a #GstMemory
* @flags: #GstMemoryFlags
- * @data: data to wrap
- * @free_func: function to free @data
- * @maxsize: allocated size of @data
- * @offset: offset in @data
- * @size: size of valid data
- *
- * Allocate a new memory block that wraps the given @data.
- *
- * 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,
- GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
+void
+gst_memory_init (GstMemory * mem, GstMemoryFlags flags,
+ GstAllocator * allocator, GstMemory * parent, gsize maxsize, gsize align,
+ gsize offset, gsize size)
{
- GstMemoryDefault *mem;
-
- g_return_val_if_fail (data != NULL, NULL);
- g_return_val_if_fail (offset + size <= maxsize, NULL);
-
- mem = _default_mem_new (flags, NULL, data, free_func, maxsize, offset, size);
+ 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);
+
+ 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.
+ * Check if @mem if allocated with an allocator for @mem_type.
*
- * Returns: @mem with increased refcount
- */
-GstMemory *
-gst_memory_ref (GstMemory * mem)
-{
- g_return_val_if_fail (mem != NULL, NULL);
-
- g_atomic_int_inc (&mem->refcount);
-
- return mem;
-}
-
-/**
- * gst_memory_unref:
- * @mem: a #GstMemory
+ * Returns: %TRUE if @mem was allocated from an allocator for @mem_type.
*
- * Decreases the refcount of @mem. When the refcount reaches 0, the free
- * function of @mem will be called.
+ * Since: 1.2
*/
-void
-gst_memory_unref (GstMemory * mem)
+gboolean
+gst_memory_is_type (GstMemory * mem, const gchar * mem_type)
{
- g_return_if_fail (mem != NULL);
- g_return_if_fail (mem->allocator != NULL);
+ 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);
- if (g_atomic_int_dec_and_test (&mem->refcount))
- mem->allocator->info.free (mem);
+ 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.
*
{
g_return_val_if_fail (mem != NULL, 0);
- return mem->allocator->info.get_sizes (mem, offset, maxsize);
+ if (offset)
+ *offset = mem->offset;
+ if (maxsize)
+ *maxsize = mem->maxsize;
+
+ return mem->size;
}
/**
*
* Resize the memory region. @mem should be writable and offset + size should be
* less than the maxsize of @mem.
+ *
+ * #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED will be
+ * cleared when offset or padding is increased respectively.
*/
void
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 (gst_memory_is_writable (mem));
+ g_return_if_fail (offset >= 0 || mem->offset >= -offset);
+ g_return_if_fail (size + mem->offset + offset <= mem->maxsize);
+
+ /* if we increase the prefix, we can't guarantee it is still 0 filled */
+ if ((offset > 0) && GST_MEMORY_IS_ZERO_PREFIXED (mem))
+ GST_MEMORY_FLAG_UNSET (mem, GST_MEMORY_FLAG_ZERO_PREFIXED);
- mem->allocator->info.resize (mem, offset, size);
+ /* if we increase the padding, we can't guarantee it is still 0 filled */
+ if ((offset + size < mem->size) && GST_MEMORY_IS_ZERO_PADDED (mem))
+ GST_MEMORY_FLAG_UNSET (mem, GST_MEMORY_FLAG_ZERO_PADDED);
+
+ mem->offset += offset;
+ mem->size = size;
}
/**
- * gst_memory_map:
- * @mem: a #GstMemory
- * @size: (out) (allow-none): pointer for size
- * @maxsize: (out) (allow-none): pointer for maxsize
+ * gst_memory_make_mapped:
+ * @mem: (transfer full): a #GstMemory
+ * @info: (out): pointer for info
* @flags: mapping flags
*
- * Get a pointer to the memory of @mem that can be accessed according to @flags.
+ * Create a #GstMemory object that is mapped with @flags. If @mem is mappable
+ * with @flags, this function returns the mapped @mem directly. Otherwise a
+ * mapped copy of @mem is returned.
*
- * @size and @maxsize will contain the size of the memory and the maximum
- * allocated memory of @mem respectively. They can be set to NULL.
+ * This function takes ownership of old @mem and returns a reference to a new
+ * #GstMemory.
*
- * Returns: (transfer none): a pointer to the memory of @mem.
+ * Returns: (transfer full) (nullable): a #GstMemory object mapped
+ * with @flags or %NULL when a mapping is not possible.
*/
-gpointer
-gst_memory_map (GstMemory * mem, gsize * size, gsize * maxsize,
- GstMapFlags flags)
+GstMemory *
+gst_memory_make_mapped (GstMemory * mem, GstMapInfo * info, GstMapFlags flags)
{
- g_return_val_if_fail (mem != NULL, NULL);
- g_return_val_if_fail (!(flags & GST_MAP_WRITE) ||
- GST_MEMORY_IS_WRITABLE (mem), NULL);
+ GstMemory *result;
+
+ if (gst_memory_map (mem, info, flags)) {
+ result = mem;
+ } else {
+ result = gst_memory_copy (mem, 0, -1);
+ gst_memory_unref (mem);
- return mem->allocator->info.map (mem, size, maxsize, flags);
+ if (result == NULL)
+ goto cannot_copy;
+
+ if (!gst_memory_map (result, info, flags))
+ goto cannot_map;
+ }
+ return result;
+
+ /* ERRORS */
+cannot_copy:
+ {
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "cannot copy memory %p", mem);
+ return NULL;
+ }
+cannot_map:
+ {
+ GST_CAT_DEBUG (GST_CAT_MEMORY, "cannot map memory %p with flags %d", mem,
+ flags);
+ gst_memory_unref (result);
+ return NULL;
+ }
}
/**
- * gst_memory_unmap:
+ * gst_memory_map:
* @mem: a #GstMemory
- * @data: data to unmap
- * @size: new size of @mem, or -1
+ * @info: (out): pointer for info
+ * @flags: mapping flags
+ *
+ * Fill @info with the pointer and sizes of the memory in @mem that can be
+ * accessed according to @flags.
*
- * Release the memory pointer obtained with gst_memory_map() and set the size of
- * the memory to @size. @size can be set to -1 when the size should not be
- * updated.
+ * This function can return %FALSE for various reasons:
+ * - the memory backed by @mem is not accessible with the given @flags.
+ * - the memory was already mapped with a different mapping.
*
- * It is possible to pass a different @data than that obtained from
- * gst_memory_map() in which case the offset of @mem will be updated.
+ * @info and its contents remain valid for as long as @mem is valid and
+ * until gst_memory_unmap() is called.
*
- * Returns: TRUE when the memory was release successfully.
+ * For each gst_memory_map() call, a corresponding gst_memory_unmap() call
+ * should be done.
+ *
+ * Returns: %TRUE if the map operation was successful.
*/
gboolean
-gst_memory_unmap (GstMemory * mem, gpointer data, gssize size)
+gst_memory_map (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, (GstLockFlags) flags))
+ goto lock_failed;
+
+ 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->data = info->data + mem->offset;
+
+ return TRUE;
- return mem->allocator->info.unmap (mem, data, size);
+ /* ERRORS */
+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 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;
+ }
+}
+
+/**
+ * gst_memory_unmap:
+ * @mem: a #GstMemory
+ * @info: a #GstMapInfo
+ *
+ * Release the memory obtained with gst_memory_map()
+ */
+void
+gst_memory_unmap (GstMemory * mem, GstMapInfo * info)
+{
+ g_return_if_fail (mem != NULL);
+ g_return_if_fail (info != NULL);
+ g_return_if_fail (info->memory == 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.
*/
GstMemory *
gst_memory_copy (GstMemory * mem, gssize offset, gssize size)
{
+ GstMemory *copy;
+
g_return_val_if_fail (mem != NULL, NULL);
- return mem->allocator->info.copy (mem, offset, size);
+ 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.
*/
GstMemory *
gst_memory_share (GstMemory * mem, gssize offset, gssize size)
{
+ GstMemory *shared;
+
g_return_val_if_fail (mem != NULL, NULL);
+ g_return_val_if_fail (!GST_MEMORY_FLAG_IS_SET (mem, GST_MEMORY_FLAG_NO_SHARE),
+ NULL);
+
+ /* 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;
- return mem->allocator->info.share (mem, offset, size);
+ /* 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.is_span (mem1, mem2, offset))
+ if (!mem1->allocator->mem_is_span (mem1, mem2, offset))
return FALSE;
return TRUE;
}
-/**
- * gst_allocator_register:
- * @name: the name of the allocator
- * @info: #GstMemoryInfo
- *
- * Registers the memory allocator with @name and implementation functions
- * @info.
- *
- * 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 field in @info will be passed to all calls of the alloc
- * function.
- *
- * Returns: a new #GstAllocator.
- */
-const GstAllocator *
-gst_allocator_register (const gchar * name, const GstMemoryInfo * info)
-{
- GstAllocator *allocator;
-
-#define INSTALL_FALLBACK(_t) \
- if (allocator->info._t == NULL) allocator->info._t = _fallback_ ##_t;
-
- g_return_val_if_fail (name != NULL, NULL);
- g_return_val_if_fail (info != NULL, NULL);
- g_return_val_if_fail (info->alloc != NULL, NULL);
- g_return_val_if_fail (info->get_sizes != NULL, NULL);
- g_return_val_if_fail (info->resize != NULL, NULL);
- g_return_val_if_fail (info->map != NULL, NULL);
- g_return_val_if_fail (info->unmap != NULL, NULL);
- g_return_val_if_fail (info->free != NULL, NULL);
- g_return_val_if_fail (info->share != NULL, NULL);
-
- allocator = g_slice_new (GstAllocator);
- allocator->name = g_quark_from_string (name);
- allocator->info = *info;
- INSTALL_FALLBACK (copy);
- INSTALL_FALLBACK (is_span);
-#undef INSTALL_FALLBACK
-
- GST_DEBUG ("registering allocator \"%s\"", name);
-
- g_static_rw_lock_writer_lock (&lock);
- g_hash_table_insert (allocators, (gpointer) name, (gpointer) allocator);
- g_static_rw_lock_writer_unlock (&lock);
-
- return allocator;
-}
-
-/**
- * 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: a #GstAllocator or NULL when the allocator with @name was not
- * registered.
- */
-const GstAllocator *
-gst_allocator_find (const gchar * name)
-{
- const GstAllocator *allocator;
-
- g_static_rw_lock_reader_lock (&lock);
- if (name) {
- allocator = g_hash_table_lookup (allocators, (gconstpointer) name);
- } else {
- allocator = _default_allocator;
- }
- g_static_rw_lock_reader_unlock (&lock);
-
- return allocator;
-}
-
-/**
- * gst_allocator_set_default:
- * @allocator: a #GstAllocator
- *
- * Set the default allocator.
- */
void
-gst_allocator_set_default (const GstAllocator * allocator)
-{
- g_return_if_fail (allocator != NULL);
-
- g_static_rw_lock_writer_lock (&lock);
- _default_allocator = allocator;
- g_static_rw_lock_writer_unlock (&lock);
-}
-
-/**
- * gst_allocator_alloc:
- * @allocator: (transfer none) (allow-none): a #GstAllocator to use
- * @maxsize: allocated size of @data
- * @align: alignment for the data
- *
- * Use @allocator to allocate a new memory block with memory that is at least
- * @maxsize big and has the given alignment.
- *
- * When @allocator is NULL, the default allocator will be used.
- *
- * @align 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 (const GstAllocator * allocator, gsize maxsize, gsize align)
+_priv_gst_memory_initialize (void)
{
- g_return_val_if_fail (((align + 1) & align) == 0, NULL);
-
- if (allocator == NULL)
- allocator = _default_allocator;
-
- return allocator->info.alloc (allocator, maxsize, align,
- allocator->info.user_data);
+ _gst_memory_type = gst_memory_get_type ();
}
projects / platform / upstream / gstreamer.git / blobdiff