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

diff --git a/gst/gstmemory.c b/gst/gstmemory.c
index 5a7f289..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,7 +34,7 @@
  * 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().
@@ -59,9 +60,7 @@
  * 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
@@ -71,425 +70,102 @@
 #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, &params);
-  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.
  *
@@ -524,6 +200,7 @@ 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 (offset >= 0 || mem->offset >= -offset);
   g_return_if_fail (size + mem->offset + offset <= mem->maxsize);
 
@@ -539,53 +216,6 @@ gst_memory_resize (GstMemory * mem, gssize offset, gsize size)
   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
@@ -599,8 +229,8 @@ gst_memory_unlock (GstMemory * mem)
  * 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)
@@ -663,18 +293,22 @@ 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, 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;
@@ -683,13 +317,16 @@ gst_memory_map (GstMemory * mem, GstMapInfo * info, GstMapFlags flags)
 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;
   }
 }
@@ -707,22 +344,23 @@ 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);
-  /* 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.
  */
@@ -733,11 +371,7 @@ gst_memory_copy (GstMemory * mem, gssize offset, gssize size)
 
   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;
 }
@@ -745,13 +379,13 @@ 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.
  */
@@ -764,11 +398,27 @@ gst_memory_share (GstMemory * mem, gssize offset, gssize size)
   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;
 }
@@ -777,7 +427,7 @@ gst_memory_share (GstMemory * mem, gssize offset, gssize size)
  * 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.
@@ -803,289 +453,14 @@ gst_memory_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset)
     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 ();
 }