X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fgstmemory.c;h=a68aa47a944e149b5ca3c0dd1ac84fa4fa4937fa;hb=dac5966da6a0f53d0443dfa1ac239289028c415d;hp=5172e978abd8bdd36c88e2b7dfcf513f30481428;hpb=a1d7bd02e4e48d9e525dcc5b79c3c97749c00d87;p=platform%2Fupstream%2Fgstreamer.git

diff --git a/gst/gstmemory.c b/gst/gstmemory.c
index 5172e97..a68aa47 100644
--- a/gst/gstmemory.c
+++ b/gst/gstmemory.c
@@ -15,12 +15,13 @@
  *
  * 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
  *
@@ -33,12 +34,13 @@
  * 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.
@@ -53,14 +55,12 @@
  * 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
@@ -70,327 +70,102 @@
 #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;
-} 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->mem.state = (flags & GST_MEMORY_FLAG_READONLY ? 0x5 : 0);
-  mem->mem.maxsize = maxsize;
-  mem->mem.offset = offset;
-  mem->mem.size = size;
-  mem->slice_size = slice_size;
-  mem->data = data;
-  mem->free_func = free_func;
-}
-
-/* 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);
-
-  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 gpointer
-_default_mem_map (GstMemoryDefault * mem, GstMapFlags flags)
-{
-  return mem->data;
-}
-
-static gboolean
-_default_mem_unmap (GstMemoryDefault * mem)
+_gst_memory_copy (GstMemory * 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)
-{
-  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)
+_gst_memory_free (GstMemory * mem)
 {
-  GstMemoryDefault *copy;
-
-  if (size == -1)
-    size = mem->mem.size > offset ? mem->mem.size - offset : 0;
-
-  copy =
-      _default_mem_new_block (mem->mem.maxsize, 0, mem->mem.offset + offset,
-      size);
-  memcpy (copy->data, mem->data, mem->mem.maxsize);
-
-  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, NULL,
-      mem->mem.maxsize, mem->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->mem.offset - parent->mem.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->mem.offset + mem1->mem.size ==
-      mem2->data + mem2->mem.offset;
-}
-
-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 (data == NULL)
-    return NULL;
-  if (size == -1)
-    size = msize > offset ? msize - offset : 0;
-  /* use the same allocator as the memory we copy  */
-  copy = gst_allocator_alloc (mem->allocator, size, mem->align);
-  dest = gst_memory_map (copy, NULL, NULL, GST_MAP_WRITE);
-  memcpy (dest, data + offset, size);
-  gst_memory_unmap (copy);
-  gst_memory_unmap (mem);
-
-  return (GstMemory *) copy;
-}
-
-static gboolean
-_fallback_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset)
-{
-  return FALSE;
-}
-
-static GRWLock lock;
-static GHashTable *allocators;
-
-void
-_priv_gst_memory_initialize (void)
-{
-  static const GstMemoryInfo _mem_info = {
-    (GstMemoryAllocFunction) _default_mem_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,
-    NULL
-  };
-
-  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_DEBUG ("memory alignment: %" G_GSIZE_FORMAT, gst_memory_alignment);
+  allocator = mem->allocator;
 
-  _default_mem_impl = gst_allocator_register (GST_ALLOCATOR_SYSMEM, &_mem_info);
+  gst_allocator_free (allocator, mem);
 
-  _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)
-{
-  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);
+void
+gst_memory_init (GstMemory * mem, GstMemoryFlags flags,
+    GstAllocator * allocator, GstMemory * parent, gsize maxsize, gsize align,
+    gsize offset, gsize 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.
  *
@@ -417,6 +192,9 @@ gst_memory_get_sizes (GstMemory * mem, gsize * offset, gsize * maxsize)
  *
  * 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)
@@ -426,162 +204,163 @@ gst_memory_resize (GstMemory * mem, gssize offset, gsize size)
   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);
+
+  /* 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_is_writable:
- * @mem: a #GstMemory
+ * gst_memory_make_mapped:
+ * @mem: (transfer full): a #GstMemory
+ * @info: (out): pointer for info
+ * @flags: mapping 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.
  *
- * Check if @mem is writable.
+ * This function takes ownership of old @mem and returns a reference to a new
+ * #GstMemory.
  *
- * Returns: %TRUE is @mem is writable.
+ * Returns: (transfer full) (nullable): a #GstMemory object mapped
+ * with @flags or %NULL when a mapping is not possible.
  */
-gboolean
-gst_memory_is_writable (GstMemory * mem)
+GstMemory *
+gst_memory_make_mapped (GstMemory * mem, GstMapInfo * info, GstMapFlags flags)
 {
-  g_return_val_if_fail (mem != NULL, FALSE);
+  GstMemory *result;
 
-  return (mem->refcount == 1) &&
-      ((mem->parent == NULL) || (mem->parent->refcount == 1)) &&
-      ((mem->flags & GST_MEMORY_FLAG_READONLY) == 0);
-}
+  if (gst_memory_map (mem, info, flags)) {
+    result = mem;
+  } else {
+    result = gst_memory_copy (mem, 0, -1);
+    gst_memory_unref (mem);
 
-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));
+    if (result == NULL)
+      goto cannot_copy;
 
-  return TRUE;
+    if (!gst_memory_map (result, info, flags))
+      goto cannot_map;
+  }
+  return result;
 
-lock_failed:
+  /* ERRORS */
+cannot_copy:
   {
-    GST_DEBUG ("lock failed %p: state %d, access_mode %d", mem, state,
-        access_mode);
-    return FALSE;
+    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;
   }
-}
-
-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_map:
  * @mem: a #GstMemory
- * @size: (out) (allow-none): pointer for size
- * @maxsize: (out) (allow-none): pointer for maxsize
+ * @info: (out): pointer for info
  * @flags: mapping flags
  *
- * Get a pointer to the memory of @mem that can be accessed according to @flags.
- *
- * @size and @maxsize will contain the size of the memory and the maximum
- * allocated memory of @mem respectively. They can be set to NULL.
+ * Fill @info with the pointer and sizes of the memory in @mem that can be
+ * accessed according to @flags.
  *
- * This function can return NULL for various reasons:
+ * 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.
  *
- * @pointer remains valid for as long as @mem is alive and until
- * gst_memory_unmap() is called.
+ * @info and its contents remain valid for as long as @mem is valid and
+ * until gst_memory_unmap() is called.
  *
  * For each gst_memory_map() call, a corresponding gst_memory_unmap() call
  * should be done.
  *
- * Returns: (transfer none): a pointer to the memory of @mem.
+ * Returns: %TRUE if the map operation was successful.
  */
-gpointer
-gst_memory_map (GstMemory * mem, gsize * size, gsize * maxsize,
-    GstMapFlags flags)
+gboolean
+gst_memory_map (GstMemory * mem, GstMapInfo * info, GstMapFlags flags)
 {
-  guint8 *res;
-
-  g_return_val_if_fail (mem != NULL, NULL);
+  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;
 
-  res = mem->allocator->info.map (mem, mem->maxsize, flags);
+  info->flags = flags;
+  info->memory = mem;
+  info->size = mem->size;
+  info->maxsize = mem->maxsize - mem->offset;
 
-  if (G_UNLIKELY (res == NULL))
+  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;
 
-  if (size)
-    *size = mem->size;
-  if (maxsize)
-    *maxsize = mem->maxsize - mem->offset;
+  info->data = info->data + mem->offset;
 
-  return res + mem->offset;
+  return TRUE;
 
   /* ERRORS */
 lock_failed:
   {
-    g_critical ("memory %p: failed to lock memory", mem);
-    return NULL;
+    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_ERROR ("mem %p: map failed", mem);
-    gst_memory_unlock (mem);
-    return NULL;
+    /* 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)
+gst_memory_unmap (GstMemory * mem, GstMapInfo * info)
 {
   g_return_if_fail (mem != NULL);
-  /* there must be a ref */
-  g_return_if_fail (g_atomic_int_get (&mem->state) >= 4);
-
-  mem->allocator->info.unmap (mem);
-  gst_memory_unlock (mem);
+  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.
  */
@@ -591,11 +370,8 @@ gst_memory_copy (GstMemory * mem, gssize offset, gssize size)
   GstMemory *copy;
 
   g_return_val_if_fail (mem != NULL, NULL);
-  g_return_val_if_fail (gst_memory_lock (mem, GST_MAP_READ), NULL);
-
-  copy = mem->allocator->info.copy (mem, offset, size);
 
-  gst_memory_unlock (mem);
+  copy = mem->allocator->mem_copy (mem, offset, size);
 
   return copy;
 }
@@ -603,29 +379,55 @@ gst_memory_copy (GstMemory * mem, gssize offset, gssize size)
 /**
  * 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.
@@ -651,126 +453,14 @@ gst_memory_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset)
     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->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_rw_lock_writer_lock (&lock);
-  g_hash_table_insert (allocators, (gpointer) name, (gpointer) allocator);
-  g_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_rw_lock_reader_lock (&lock);
-  if (name) {
-    allocator = g_hash_table_lookup (allocators, (gconstpointer) name);
-  } else {
-    allocator = _default_allocator;
-  }
-  g_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_rw_lock_writer_lock (&lock);
-  _default_allocator = allocator;
-  g_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 ();
 }