X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fgstmemory.c;h=d5811f6817bd25630e0e35a5e5905ce6b1ecc2f1;hb=e10266e3f3cf9b05b69198b1ac6faa9a62840e30;hp=4092d9457d7c48b32c0e6b8609b69c5aff6f18e0;hpb=4b322e37f85a0a403aa604cc709ab333308cdb19;p=platform%2Fupstream%2Fgstreamer.git

diff --git a/gst/gstmemory.c b/gst/gstmemory.c
index 4092d94..d5811f6 100644
--- a/gst/gstmemory.c
+++ b/gst/gstmemory.c
@@ -15,8 +15,8 @@
  *
  * 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.
  */
 
 /**
@@ -33,7 +33,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 +59,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
@@ -73,384 +71,90 @@
 
 GST_DEFINE_MINI_OBJECT_TYPE (GstMemory, gst_memory);
 
-GST_DEFINE_MINI_OBJECT_TYPE (GstAllocator, gst_allocator);
-
-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
-{
-  GstMiniObject mini_object;
-
-  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;
-
-#define SHARE_ONE (1 << 16)
-#define SHARE_MASK (~(SHARE_ONE - 1))
-#define LOCK_ONE (GST_LOCK_FLAG_LAST)
-#define FLAG_MASK (GST_LOCK_FLAG_LAST - 1)
-#define LOCK_MASK ((SHARE_ONE - 1) - FLAG_MASK)
-#define LOCK_FLAG_MASK (SHARE_ONE - 1)
-
 static GstMemory *
 _gst_memory_copy (GstMemory * mem)
 {
+  GST_CAT_DEBUG (GST_CAT_MEMORY, "copy memory %p", mem);
   return gst_memory_copy (mem, 0, -1);
 }
 
 static void
 _gst_memory_free (GstMemory * mem)
 {
-  /* there should be no outstanding mappings */
-  g_return_if_fail ((g_atomic_int_get (&mem->state) & LOCK_MASK) < 4);
-  mem->allocator->info.mem_free (mem);
-}
-
-/* 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)
-{
-  gst_mini_object_init (GST_MINI_OBJECT_CAST (mem), GST_TYPE_MEMORY,
-      (GstMiniObjectCopyFunction) _gst_memory_copy, NULL,
-      (GstMiniObjectFreeFunction) _gst_memory_free);
-
-  mem->mem.mini_object.flags = flags;
-
-  mem->mem.allocator = _default_mem_impl;
-  mem->mem.parent = parent ? gst_memory_ref (parent) : NULL;
-  mem->mem.state = (flags & GST_MEMORY_FLAG_READONLY ? GST_LOCK_FLAG_READ : 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;
-}
-
-static GstMemory *
-_default_alloc_alloc (GstAllocator * allocator, gsize size,
-    GstAllocationParams * params, gpointer user_data)
-{
-  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, gsize maxsize, GstMapFlags flags)
-{
-  return mem->data;
-}
-
-static gboolean
-_default_mem_unmap (GstMemoryDefault * mem)
-{
-  return TRUE;
-}
+  GstAllocator *allocator;
 
-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);
-  GST_CAT_DEBUG (GST_CAT_PERFORMANCE,
-      "memcpy %" G_GSIZE_FORMAT " memory %p -> %p", mem->mem.maxsize, mem,
-      copy);
-  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 (GST_MINI_OBJECT_FLAGS (parent), 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;
+  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_mem_copy (GstMemory * mem, gssize offset, gssize size)
-{
-  GstMemory *copy;
-  GstMapInfo sinfo, dinfo;
-  GstAllocationParams params = { 0, 0, 0, mem->align, };
-
-  if (!gst_memory_map (mem, &sinfo, GST_MAP_READ))
-    return NULL;
-
-  if (size == -1)
-    size = sinfo.size > offset ? sinfo.size - offset : 0;
-
-  /* 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;
-  }
-
-  GST_CAT_DEBUG (GST_CAT_PERFORMANCE,
-      "memcpy %" G_GSSIZE_FORMAT " memory %p -> %p", size, mem, copy);
-  memcpy (dinfo.data, sinfo.data + offset, size);
-  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;
+  allocator = mem->allocator;
 
-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,
-  };
-
-  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_allocator_free (allocator, mem);
+  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;
-
-  g_return_val_if_fail (data != NULL, NULL);
-  g_return_val_if_fail (offset + size <= maxsize, NULL);
+  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 =
-      _default_mem_new (flags, NULL, data, maxsize, offset, size, 0, user_data,
-      notify);
+  mem->allocator = gst_object_ref (allocator);
+  if (parent) {
+    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_is_exclusive:
+ * gst_memory_is_type:
  * @mem: a #GstMemory
+ * @mem_type: a memory type
+ *
+ * Check if @mem if allocated with an allocator for @mem_type.
+ *
+ * Returns: %TRUE if @mem was allocated from an allocator for @mem_type.
  *
- * Check if the current EXCLUSIVE lock on @mem is the only one, this means that
- * changes to the object will not be visible to any other object.
+ * Since: 1.2
  */
 gboolean
-gst_memory_is_exclusive (GstMemory * mem)
+gst_memory_is_type (GstMemory * mem, const gchar * mem_type)
 {
-  gint state;
-
   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);
 
-  state = g_atomic_int_get (&mem->state);
-
-  return (state & SHARE_MASK) < 2;
+  return (g_strcmp0 (mem->allocator->mem_type, mem_type) == 0);
 }
 
 /**
@@ -508,99 +212,6 @@ gst_memory_resize (GstMemory * mem, gssize offset, gsize size)
 }
 
 /**
- * gst_memory_lock:
- * @mem: a #GstMemory
- * @flags: #GstLockFlags
- *
- * Lock the memory with the specified access mode in @flags.
- *
- * Returns: %TRUE if the memory could be locked.
- */
-gboolean
-gst_memory_lock (GstMemory * mem, GstLockFlags flags)
-{
-  gint access_mode, state, newstate;
-
-  access_mode = flags & FLAG_MASK;
-
-  do {
-    newstate = state = g_atomic_int_get (&mem->state);
-
-    GST_CAT_TRACE (GST_CAT_MEMORY, "lock %p: state %08x, access_mode %d",
-        mem, state, access_mode);
-
-    if (access_mode & GST_LOCK_FLAG_EXCLUSIVE) {
-      /* shared ref */
-      newstate += SHARE_ONE;
-      access_mode &= ~GST_LOCK_FLAG_EXCLUSIVE;
-    }
-
-    if (access_mode) {
-      if ((state & LOCK_FLAG_MASK) == 0) {
-        /* shared counter > 1 and write access */
-        if (state > SHARE_ONE && access_mode & GST_LOCK_FLAG_WRITE)
-          goto lock_failed;
-        /* nothing mapped, set access_mode */
-        newstate |= access_mode;
-      } else {
-        /* access_mode must match */
-        if ((state & access_mode) != access_mode)
-          goto lock_failed;
-      }
-      /* increase refcount */
-      newstate += LOCK_ONE;
-    }
-  } 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 %08x, access_mode %d",
-        mem, state, access_mode);
-    return FALSE;
-  }
-}
-
-/**
- * gst_memory_unlock:
- * @mem: a #GstMemory
- * @flags: #GstLockFlags
- *
- * Unlock the memory with the specified access mode in @flags.
- */
-void
-gst_memory_unlock (GstMemory * mem, GstLockFlags flags)
-{
-  gint access_mode, state, newstate;
-
-  access_mode = flags & FLAG_MASK;
-
-  do {
-    newstate = state = g_atomic_int_get (&mem->state);
-
-    GST_CAT_TRACE (GST_CAT_MEMORY, "unlock %p: state %08x, access_mode %d",
-        mem, state, access_mode);
-
-    if (access_mode & GST_LOCK_FLAG_EXCLUSIVE) {
-      /* shared counter */
-      g_return_if_fail (state >= SHARE_ONE);
-      newstate -= SHARE_ONE;
-      access_mode &= ~GST_LOCK_FLAG_EXCLUSIVE;
-    }
-
-    if (access_mode) {
-      g_return_if_fail ((state & access_mode) == access_mode);
-      /* decrease the refcount */
-      newstate -= LOCK_ONE;
-      /* last refcount, unset access_mode */
-      if ((newstate & LOCK_FLAG_MASK) == access_mode)
-        newstate &= ~LOCK_FLAG_MASK;
-    }
-  } while (!g_atomic_int_compare_and_exchange (&mem->state, state, newstate));
-}
-
-/**
  * gst_memory_make_mapped:
  * @mem: (transfer full): a #GstMemory
  * @info: (out): pointer for info
@@ -613,7 +224,7 @@ gst_memory_unlock (GstMemory * mem, GstLockFlags flags)
  * 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
+ * Returns: (transfer full): a #GstMemory object mapped with @flags or %NULL when
  * a mapping is not possible.
  */
 GstMemory *
@@ -677,10 +288,10 @@ 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->data = mem->allocator->mem_map (mem, mem->maxsize, flags);
 
   if (G_UNLIKELY (info->data == NULL))
     goto error;
@@ -697,13 +308,15 @@ 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, flags);
+    GST_CAT_ERROR (GST_CAT_MEMORY, "mem %p: subclass map failed", mem);
+    gst_memory_unlock (mem, (GstLockFlags) flags);
+    memset (info, 0, sizeof (GstMapInfo));
     return FALSE;
   }
 }
@@ -721,11 +334,9 @@ 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, info->flags);
+  mem->allocator->mem_unmap (mem);
+  gst_memory_unlock (mem, (GstLockFlags) info->flags);
 }
 
 /**
@@ -747,7 +358,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);
+  copy = mem->allocator->mem_copy (mem, offset, size);
 
   return copy;
 }
@@ -774,7 +385,7 @@ 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);
+  shared = mem->allocator->mem_share (mem, offset, size);
 
   return shared;
 }
@@ -809,255 +420,8 @@ 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;
 }
-
-static void
-_gst_allocator_free (GstAllocator * allocator)
-{
-  if (allocator->notify)
-    allocator->notify (allocator->user_data);
-
-  g_slice_free1 (sizeof (GstAllocator), allocator);
-}
-
-static GstAllocator *
-_gst_allocator_copy (GstAllocator * allocator)
-{
-  return gst_allocator_ref (allocator);
-}
-
-/**
- * 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;
-
-  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_new0 (GstAllocator);
-
-  gst_mini_object_init (GST_MINI_OBJECT_CAST (allocator), GST_TYPE_ALLOCATOR,
-      (GstMiniObjectCopyFunction) _gst_allocator_copy, NULL,
-      (GstMiniObjectFreeFunction) _gst_allocator_free);
-
-  allocator->info = *info;
-  allocator->user_data = user_data;
-  allocator->notify = notify;
-
-#define INSTALL_FALLBACK(_t) \
-  if (allocator->info._t == NULL) allocator->info._t = _fallback_ ##_t;
-  INSTALL_FALLBACK (mem_copy);
-  INSTALL_FALLBACK (mem_is_span);
-#undef INSTALL_FALLBACK
-
-  GST_CAT_DEBUG (GST_CAT_MEMORY, "new allocator %p", allocator);
-
-  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_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)
-{
-  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);
-
-  return mem;
-}