From: Wim Taymans <wim.taymans@collabora.co.uk>
Date: Wed, 23 Mar 2011 19:52:27 +0000 (+0100)
Subject: memory: more work on implementing buffer memory
X-Git-Tag: RELEASE-0.11.0~504
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=38ffe3074501da833e2b4fe374a0def2758fba23;p=platform%2Fupstream%2Fgstreamer.git

memory: more work on implementing buffer memory
---

diff --git a/gst/gstbuffer.c b/gst/gstbuffer.c
index 5d8bd4a..4f98ce5 100644
--- a/gst/gstbuffer.c
+++ b/gst/gstbuffer.c
@@ -196,7 +196,7 @@ gst_buffer_copy_into (GstBuffer * dest, GstBuffer * src,
 
 #if GST_VERSION_NANO == 1
   /* we enable this extra debugging in git versions only for now */
-  g_warn_if_fail (gst_buffer_is_metadata_writable (dest));
+  g_warn_if_fail (gst_buffer_is_writable (dest));
 #endif
 
   GST_CAT_LOG (GST_CAT_BUFFER, "copy %p to %p", src, dest);
@@ -398,8 +398,10 @@ gst_buffer_new_and_alloc (guint size)
 
   newbuf = gst_buffer_new ();
 
-  gst_buffer_take_memory (newbuf, gst_memory_new_alloc (size,
-          _gst_buffer_data_alignment));
+  if (size > 0) {
+    gst_buffer_take_memory (newbuf, gst_memory_new_alloc (size,
+            _gst_buffer_data_alignment));
+  }
 
   GST_CAT_LOG (GST_CAT_BUFFER, "new %p of size %d", newbuf, size);
 
@@ -429,24 +431,39 @@ gst_buffer_try_new_and_alloc (guint size)
   GstBuffer *newbuf;
   GstMemory *mem;
 
-  mem = gst_memory_new_alloc (size, _gst_buffer_data_alignment);
-  if (G_UNLIKELY (mem == NULL)) {
-    GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size);
-    return NULL;
+  if (size > 0) {
+    mem = gst_memory_new_alloc (size, _gst_buffer_data_alignment);
+    if (G_UNLIKELY (mem == NULL))
+      goto no_memory;
+  } else {
+    mem = NULL;
   }
 
   newbuf = gst_buffer_new ();
-  gst_buffer_take_memory (newbuf, mem);
+
+  if (mem != NULL)
+    gst_buffer_take_memory (newbuf, mem);
 
   GST_CAT_LOG (GST_CAT_BUFFER, "new %p of size %d", newbuf, size);
 
   return newbuf;
+
+  /* ERRORS */
+no_memory:
+  {
+    GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size);
+    return NULL;
+  }
 }
 
 guint
 gst_buffer_n_memory (GstBuffer * buffer)
 {
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
+
+  g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);
+
+  arr = (GPtrArray *) buffer->memory;
 
   return arr->len;
 }
@@ -454,8 +471,13 @@ gst_buffer_n_memory (GstBuffer * buffer)
 void
 gst_buffer_take_memory (GstBuffer * buffer, GstMemory * mem)
 {
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
 
+  g_return_if_fail (GST_IS_BUFFER (buffer));
+  g_return_if_fail (gst_buffer_is_writable (buffer));
+  g_return_if_fail (mem != NULL);
+
+  arr = (GPtrArray *) buffer->memory;
   g_ptr_array_add (arr, mem);
 }
 
@@ -463,7 +485,11 @@ GstMemory *
 gst_buffer_peek_memory (GstBuffer * buffer, guint idx)
 {
   GstMemory *mem;
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
+
+  g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL);
+  arr = (GPtrArray *) buffer->memory;
+  g_return_val_if_fail (idx < arr->len, NULL);
 
   mem = g_ptr_array_index (arr, idx);
 
@@ -473,7 +499,12 @@ gst_buffer_peek_memory (GstBuffer * buffer, guint idx)
 void
 gst_buffer_remove_memory (GstBuffer * buffer, guint idx)
 {
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
+
+  g_return_if_fail (GST_IS_BUFFER (buffer));
+  g_return_if_fail (gst_buffer_is_writable (buffer));
+  arr = (GPtrArray *) buffer->memory;
+  g_return_if_fail (idx < arr->len);
 
   g_ptr_array_remove_index (arr, idx);
 }
@@ -484,6 +515,8 @@ gst_buffer_get_size (GstBuffer * buffer)
   GPtrArray *arr = (GPtrArray *) buffer->memory;
   guint i, size, len;
 
+  g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);
+
   len = arr->len;
 
   size = 0;
@@ -498,29 +531,53 @@ gpointer
 gst_buffer_map (GstBuffer * buffer, gsize * size, gsize * maxsize,
     GstMapFlags flags)
 {
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
   guint len;
   gpointer data;
 
+  g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL);
+
+  arr = (GPtrArray *) buffer->memory;
   len = arr->len;
 
+  if (G_UNLIKELY ((flags & GST_MAP_WRITE) && !gst_buffer_is_writable (buffer)))
+    goto not_writable;
+
   if (G_LIKELY (len == 1)) {
     GstMemory *mem = g_ptr_array_index (arr, 0);
 
+    if (flags & GST_MAP_WRITE) {
+      if (G_UNLIKELY (!GST_MEMORY_IS_WRITABLE (mem))) {
+        /* try to get a writable copy */
+        g_return_val_if_fail (GST_MEMORY_IS_WRITABLE (mem), NULL);
+        return NULL;
+      }
+    }
+
     data = gst_memory_map (mem, size, maxsize, flags);
   } else {
     data = NULL;
   }
   return data;
+
+  /* ERROR */
+not_writable:
+  {
+    g_return_val_if_fail (gst_buffer_is_writable (buffer), NULL);
+    return NULL;
+  }
 }
 
 gboolean
 gst_buffer_unmap (GstBuffer * buffer, gpointer data, gsize size)
 {
-  GPtrArray *arr = (GPtrArray *) buffer->memory;
+  GPtrArray *arr;
   gboolean result;
   guint len;
 
+  g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
+
+  arr = (GPtrArray *) buffer->memory;
   len = arr->len;
 
   if (G_LIKELY (len == 1)) {
@@ -611,7 +668,7 @@ gst_buffer_set_caps (GstBuffer * buffer, GstCaps * caps)
 
 #if GST_VERSION_NANO == 1
   /* we enable this extra debugging in git versions only for now */
-  g_warn_if_fail (gst_buffer_is_metadata_writable (buffer));
+  g_warn_if_fail (gst_buffer_is_writable (buffer));
   /* FIXME: would be nice to also check if caps are fixed here, but expensive */
 #endif
 
@@ -619,55 +676,6 @@ gst_buffer_set_caps (GstBuffer * buffer, GstCaps * caps)
 }
 
 /**
- * gst_buffer_is_metadata_writable:
- * @buf: a #GstBuffer
- *
- * Similar to gst_buffer_is_writable, but this only ensures that the
- * refcount of the buffer is 1, indicating that the caller is the sole
- * owner and can change the buffer metadata, such as caps and timestamps.
- *
- * Returns: TRUE if the metadata is writable.
- */
-gboolean
-gst_buffer_is_metadata_writable (GstBuffer * buf)
-{
-  return (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1);
-}
-
-/**
- * gst_buffer_make_metadata_writable:
- * @buf: (transfer full): a #GstBuffer
- *
- * Similar to gst_buffer_make_writable, but does not ensure that the buffer
- * data array is writable. Instead, this just ensures that the returned buffer
- * is solely owned by the caller, by creating a subbuffer of the original
- * buffer if necessary.
- * 
- * After calling this function, @buf should not be referenced anymore. The
- * result of this function has guaranteed writable metadata.
- *
- * Returns: (transfer full): a new #GstBuffer with writable metadata, which
- *     may or may not be the same as @buf.
- */
-GstBuffer *
-gst_buffer_make_metadata_writable (GstBuffer * buf)
-{
-  GstBuffer *ret;
-
-  if (gst_buffer_is_metadata_writable (buf)) {
-    ret = buf;
-  } else {
-    /* create a fresh new buffer */
-    ret = gst_buffer_new ();
-
-    /* we simply copy everything from our parent */
-    gst_buffer_copy_into (ret, buf, GST_BUFFER_COPY_ALL, 0, 0);
-    gst_buffer_unref (buf);
-  }
-  return ret;
-}
-
-/**
  * gst_buffer_create_sub:
  * @parent: a #GstBuffer.
  * @offset: the offset into parent #GstBuffer at which the new sub-buffer 
diff --git a/gst/gstbuffer.h b/gst/gstbuffer.h
index 1e008be..d84d6d1 100644
--- a/gst/gstbuffer.h
+++ b/gst/gstbuffer.h
@@ -202,7 +202,6 @@ typedef struct _GstBufferPool GstBufferPool;
 
 /**
  * GstBufferFlag:
- * @GST_BUFFER_FLAG_READONLY: the buffer is read-only. This means the data of
  * the buffer should not be modified. The metadata might still be modified.
  * @GST_BUFFER_FLAG_PREROLL: the buffer is part of a preroll and should not be
  * displayed.
@@ -223,7 +222,6 @@ typedef struct _GstBufferPool GstBufferPool;
  * A set of buffer flags used to describe properties of a #GstBuffer.
  */
 typedef enum {
-  GST_BUFFER_FLAG_READONLY   = GST_MINI_OBJECT_FLAG_READONLY,
   GST_BUFFER_FLAG_PREROLL    = (GST_MINI_OBJECT_FLAG_LAST << 0),
   GST_BUFFER_FLAG_DISCONT    = (GST_MINI_OBJECT_FLAG_LAST << 1),
   GST_BUFFER_FLAG_IN_CAPS    = (GST_MINI_OBJECT_FLAG_LAST << 2),
@@ -456,11 +454,6 @@ void            gst_buffer_copy_into            (GstBuffer *dest, GstBuffer *src
  */
 #define         gst_buffer_make_writable(buf)   GST_BUFFER_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (buf)))
 
-/* Ensure that the metadata of the buffer is writable, even if the buffer data
- * isn't */
-gboolean        gst_buffer_is_metadata_writable (GstBuffer *buf);
-GstBuffer*      gst_buffer_make_metadata_writable (GstBuffer *buf);
-
 /**
  * gst_buffer_replace:
  * @obuf: (inout) (transfer full): pointer to a pointer to a #GstBuffer to be
diff --git a/gst/gstmemory.c b/gst/gstmemory.c
index e73f3e9..0192760 100644
--- a/gst/gstmemory.c
+++ b/gst/gstmemory.c
@@ -47,12 +47,12 @@ static const GstMemoryImpl *_default_mem_impl;
 static const GstMemoryImpl *_default_sub_impl;
 
 static void
-_default_mem_init (GstMemoryDefault * mem, GstMemory * parent,
-    gsize slice_size, gpointer data, GFreeFunc free_func,
-    gsize maxsize, gsize offset, gsize size)
+_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.impl = data ? _default_mem_impl : _default_sub_impl;
-  mem->mem.flags = 0;
+  mem->mem.flags = flags;
   mem->mem.refcount = 1;
   mem->mem.parent = parent ? gst_memory_ref (parent) : NULL;
   mem->slice_size = slice_size;
@@ -64,7 +64,7 @@ _default_mem_init (GstMemoryDefault * mem, GstMemory * parent,
 }
 
 static GstMemoryDefault *
-_default_mem_new (GstMemory * parent, gpointer data,
+_default_mem_new (GstMemoryFlags flags, GstMemory * parent, gpointer data,
     GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
 {
   GstMemoryDefault *mem;
@@ -73,7 +73,7 @@ _default_mem_new (GstMemory * parent, gpointer data,
   slice_size = sizeof (GstMemoryDefault);
 
   mem = g_slice_alloc (slice_size);
-  _default_mem_init (mem, parent, slice_size,
+  _default_mem_init (mem, flags, parent, slice_size,
       data, free_func, maxsize, offset, size);
 
   return mem;
@@ -98,7 +98,7 @@ _default_mem_new_block (gsize maxsize, gsize align, gsize offset, gsize size)
   if ((aoffset = ((guintptr) data & align)))
     aoffset = align - aoffset;
 
-  _default_mem_init (mem, NULL, slice_size, data, NULL, maxsize + align,
+  _default_mem_init (mem, 0, NULL, slice_size, data, NULL, maxsize + align,
       aoffset + offset, size);
 
   return mem;
@@ -213,7 +213,7 @@ _default_mem_sub (GstMemoryDefault * mem, gsize offset, gsize size)
   if ((parent = mem->mem.parent) == NULL)
     parent = (GstMemory *) mem;
 
-  sub = _default_mem_new (parent, mem->data, NULL, mem->maxsize,
+  sub = _default_mem_new (parent->flags, parent, mem->data, NULL, mem->maxsize,
       mem->offset + offset, size);
 
   return sub;
@@ -265,7 +265,7 @@ _fallback_sub (GstMemory * mem, gsize offset, gsize size)
   /* find the real parent */
   parent = mem->parent ? mem->parent : mem;
 
-  sub = _default_mem_new (parent, NULL, NULL, size, offset, size);
+  sub = _default_mem_new (0, parent, NULL, NULL, size, offset, size);
 
   return (GstMemory *) sub;
 }
@@ -458,7 +458,11 @@ gst_memory_is_span (GstMemory ** mem1, gsize len1, GstMemory ** mem2,
           return FALSE;
 
         if (!have_offset) {
-          *offset = offs;
+          if (offset)
+            *offset = offs;
+          if (parent)
+            *parent = m1->parent;
+
           have_offset = TRUE;
         }
       }
@@ -517,12 +521,12 @@ gst_memory_span (GstMemory ** mem1, gsize len1, gsize offset, GstMemory ** mem2,
 }
 
 GstMemory *
-gst_memory_new_wrapped (gpointer data, GFreeFunc free_func,
-    gsize maxsize, gsize offset, gsize size)
+gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data,
+    GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
 {
   GstMemoryDefault *mem;
 
-  mem = _default_mem_new (NULL, data, free_func, maxsize, offset, size);
+  mem = _default_mem_new (flags, NULL, data, free_func, maxsize, offset, size);
 
   return (GstMemory *) mem;
 }
@@ -532,7 +536,7 @@ gst_memory_new_alloc (gsize maxsize, gsize align)
 {
   GstMemoryDefault *mem;
 
-  mem = _default_mem_new_block (maxsize, align, 0, 0);
+  mem = _default_mem_new_block (maxsize, align, 0, maxsize);
 
   return (GstMemory *) mem;
 }
diff --git a/gst/gstmemory.h b/gst/gstmemory.h
index 3dacf3d..8861ff9 100644
--- a/gst/gstmemory.h
+++ b/gst/gstmemory.h
@@ -34,10 +34,14 @@ typedef struct _GstMemoryInfo GstMemoryInfo;
 typedef struct _GstMemoryImpl GstMemoryImpl;
 
 typedef enum {
-  GST_MEMORY_FLAG_READONLY = (1 << 0),
-  GST_MEMORY_FLAG_MUTABLE  = (1 << 1),
+  GST_MEMORY_FLAG_READONLY = (1 << 0)
 } GstMemoryFlags;
 
+
+#define GST_MEMORY_IS_WRITABLE(mem) (((mem)->refcount == 1) && \
+    (((mem)->parent == NULL) || ((mem)->parent->refcount == 1)) && \
+    (((mem)->flags & GST_MEMORY_FLAG_READONLY) == 0))
+
 /**
  * GstMemory:
  * @impl: pointer to the #GstMemoryImpl
@@ -104,7 +108,7 @@ struct _GstMemoryInfo {
 void _gst_memory_init (void);
 
 /* allocating memory blocks */
-GstMemory * gst_memory_new_wrapped (gpointer data, GFreeFunc free_func,
+GstMemory * gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data, GFreeFunc free_func,
                                     gsize maxsize, gsize offset, gsize size);
 GstMemory * gst_memory_new_alloc   (gsize maxsize, gsize align);
 GstMemory * gst_memory_new_copy    (gsize maxsize, gsize align, gpointer data,
diff --git a/gst/gstminiobject.c b/gst/gstminiobject.c
index 907edb9..92f6448 100644
--- a/gst/gstminiobject.c
+++ b/gst/gstminiobject.c
@@ -154,8 +154,7 @@ gst_mini_object_is_writable (const GstMiniObject * mini_object)
 {
   g_return_val_if_fail (mini_object != NULL, FALSE);
 
-  return (GST_MINI_OBJECT_REFCOUNT_VALUE (mini_object) == 1) &&
-      ((mini_object->flags & GST_MINI_OBJECT_FLAG_READONLY) == 0);
+  return (GST_MINI_OBJECT_REFCOUNT_VALUE (mini_object) == 1);
 }
 
 /**
diff --git a/gst/gstminiobject.h b/gst/gstminiobject.h
index a50a25c..fe0a1aa 100644
--- a/gst/gstminiobject.h
+++ b/gst/gstminiobject.h
@@ -106,14 +106,12 @@ typedef void (*GstMiniObjectFreeFunction) (GstMiniObject *obj);
 
 /**
  * GstMiniObjectFlags:
- * @GST_MINI_OBJECT_FLAG_READONLY: is the miniobject readonly or writable
  * @GST_MINI_OBJECT_FLAG_LAST: first flag that can be used by subclasses.
  *
  * Flags for the mini object
  */
 typedef enum
 {
-  GST_MINI_OBJECT_FLAG_READONLY = (1<<0),
   /* padding */
   GST_MINI_OBJECT_FLAG_LAST = (1<<4)
 } GstMiniObjectFlags;
diff --git a/libs/gst/base/gstadapter.c b/libs/gst/base/gstadapter.c
index 898cc1d..f8fd360 100644
--- a/libs/gst/base/gstadapter.c
+++ b/libs/gst/base/gstadapter.c
@@ -736,8 +736,8 @@ gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
   data = gst_adapter_take_internal (adapter, nbytes);
 
   buffer = gst_buffer_new ();
-  gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, g_free, nbytes,
-          0, nbytes));
+  gst_buffer_take_memory (buffer,
+      gst_memory_new_wrapped (0, data, g_free, nbytes, 0, nbytes));
 
 done:
   gst_adapter_flush_unchecked (adapter, nbytes);
diff --git a/libs/gst/base/gstbasesrc.c b/libs/gst/base/gstbasesrc.c
index 174ebe3..74597ae 100644
--- a/libs/gst/base/gstbasesrc.c
+++ b/libs/gst/base/gstbasesrc.c
@@ -2153,13 +2153,13 @@ again:
   /* no timestamp set and we are at offset 0, we can timestamp with 0 */
   if (offset == 0 && src->segment.time == 0
       && GST_BUFFER_TIMESTAMP (*buf) == -1) {
-    *buf = gst_buffer_make_metadata_writable (*buf);
+    *buf = gst_buffer_make_writable (*buf);
     GST_BUFFER_TIMESTAMP (*buf) = 0;
   }
 
   /* set pad caps on the buffer if the buffer had no caps */
   if (GST_BUFFER_CAPS (*buf) == NULL) {
-    *buf = gst_buffer_make_metadata_writable (*buf);
+    *buf = gst_buffer_make_writable (*buf);
     gst_buffer_set_caps (*buf, GST_PAD_CAPS (src->srcpad));
   }
 
@@ -2499,7 +2499,7 @@ gst_base_src_loop (GstPad * pad)
   }
 
   if (G_UNLIKELY (src->priv->discont)) {
-    buf = gst_buffer_make_metadata_writable (buf);
+    buf = gst_buffer_make_writable (buf);
     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
     src->priv->discont = FALSE;
   }
diff --git a/libs/gst/base/gstbasetransform.c b/libs/gst/base/gstbasetransform.c
index 8d7bafa..930ab56 100644
--- a/libs/gst/base/gstbasetransform.c
+++ b/libs/gst/base/gstbasetransform.c
@@ -1459,7 +1459,7 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
       if (othercaps && !gst_caps_is_empty (othercaps)) {
         GST_DEBUG_OBJECT (trans, "we found target caps %" GST_PTR_FORMAT,
             othercaps);
-        *out_buf = gst_buffer_make_metadata_writable (*out_buf);
+        *out_buf = gst_buffer_make_writable (*out_buf);
         gst_buffer_set_caps (*out_buf, othercaps);
         gst_caps_unref (othercaps);
         newcaps = GST_BUFFER_CAPS (*out_buf);
@@ -1487,7 +1487,7 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
             GST_DEBUG_PAD_NAME (trans->srcpad));
         bclass->fixate_caps (trans, GST_PAD_SINK, incaps, newcaps);
 
-        *out_buf = gst_buffer_make_metadata_writable (*out_buf);
+        *out_buf = gst_buffer_make_writable (*out_buf);
         gst_buffer_set_caps (*out_buf, newcaps);
         gst_caps_unref (newcaps);
         newcaps = GST_BUFFER_CAPS (*out_buf);
@@ -1596,12 +1596,12 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
 
   if (setcaps || copymeta) {
     GST_DEBUG_OBJECT (trans, "setcaps %d, copymeta %d", setcaps, copymeta);
-    if (!gst_buffer_is_metadata_writable (*out_buf)) {
+    if (!gst_buffer_is_writable (*out_buf)) {
       GST_DEBUG_OBJECT (trans, "buffer metadata %p not writable", *out_buf);
       if (in_buf == *out_buf)
         *out_buf = gst_buffer_create_sub (in_buf, 0, insize);
       else
-        *out_buf = gst_buffer_make_metadata_writable (*out_buf);
+        *out_buf = gst_buffer_make_writable (*out_buf);
     }
     /* when we get here, the metadata should be writable */
     if (setcaps)
@@ -2436,7 +2436,7 @@ gst_base_transform_chain (GstPad * pad, GstBuffer * buffer)
       /* apply DISCONT flag if the buffer is not yet marked as such */
       if (trans->priv->discont) {
         if (!GST_BUFFER_IS_DISCONT (outbuf)) {
-          outbuf = gst_buffer_make_metadata_writable (outbuf);
+          outbuf = gst_buffer_make_writable (outbuf);
           GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
         }
         trans->priv->discont = FALSE;
diff --git a/libs/gst/base/gstbytewriter.c b/libs/gst/base/gstbytewriter.c
index d59c22e..d6ef86f 100644
--- a/libs/gst/base/gstbytewriter.c
+++ b/libs/gst/base/gstbytewriter.c
@@ -259,8 +259,8 @@ gst_byte_writer_reset_and_get_buffer (GstByteWriter * writer)
   data = gst_byte_writer_reset_and_get_data (writer);
 
   buffer = gst_buffer_new ();
-  gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, g_free, size, 0,
-          size));
+  gst_buffer_take_memory (buffer,
+      gst_memory_new_wrapped (0, data, g_free, size, 0, size));
 
   return buffer;
 }
diff --git a/plugins/elements/gstcapsfilter.c b/plugins/elements/gstcapsfilter.c
index 6286ddc..97028ea 100644
--- a/plugins/elements/gstcapsfilter.c
+++ b/plugins/elements/gstcapsfilter.c
@@ -334,7 +334,7 @@ gst_capsfilter_prepare_buf (GstBaseTransform * trans, GstBuffer * input,
     if (GST_BUFFER_CAPS (input) != caps) {
       /* caps are different, make a metadata writable output buffer to set
        * caps */
-      if (gst_buffer_is_metadata_writable (input)) {
+      if (gst_buffer_is_writable (input)) {
         /* input is writable, just set caps and use this as the output */
         *buf = input;
         gst_buffer_set_caps (*buf, caps);
@@ -368,7 +368,7 @@ gst_capsfilter_prepare_buf (GstBaseTransform * trans, GstBuffer * input,
     if (gst_caps_is_fixed (out_caps) && !gst_caps_is_empty (out_caps)) {
       GST_DEBUG_OBJECT (trans, "Have fixed output caps %"
           GST_PTR_FORMAT " to apply to buffer with no caps", out_caps);
-      if (gst_buffer_is_metadata_writable (input)) {
+      if (gst_buffer_is_writable (input)) {
         gst_buffer_ref (input);
         *buf = input;
       } else {
diff --git a/plugins/elements/gstfakesrc.c b/plugins/elements/gstfakesrc.c
index 74dbc9b..bbc2039 100644
--- a/plugins/elements/gstfakesrc.c
+++ b/plugins/elements/gstfakesrc.c
@@ -691,8 +691,8 @@ gst_fake_src_alloc_buffer (GstFakeSrc * src, guint size)
     if (do_prepare)
       gst_fake_src_prepare_buffer (src, data, size);
 
-    gst_buffer_take_memory (buf, gst_memory_new_wrapped (data, g_free, size, 0,
-            size));
+    gst_buffer_take_memory (buf,
+        gst_memory_new_wrapped (0, data, g_free, size, 0, size));
   }
 
   return buf;
diff --git a/plugins/elements/gstidentity.c b/plugins/elements/gstidentity.c
index c8dbc10..5d72e55 100644
--- a/plugins/elements/gstidentity.c
+++ b/plugins/elements/gstidentity.c
@@ -394,13 +394,13 @@ gst_identity_prepare_output_buffer (GstBaseTransform * trans,
 
   /* only bother if we may have to alter metadata */
   if (identity->datarate > 0 || identity->single_segment) {
-    if (gst_buffer_is_metadata_writable (in_buf))
+    if (gst_buffer_is_writable (in_buf))
       *out_buf = gst_buffer_ref (in_buf);
     else {
       /* make even less writable */
       gst_buffer_ref (in_buf);
       /* extra ref is dropped going through the official process */
-      *out_buf = gst_buffer_make_metadata_writable (in_buf);
+      *out_buf = gst_buffer_make_writable (in_buf);
     }
   } else
     *out_buf = gst_buffer_ref (in_buf);
diff --git a/plugins/elements/gstinputselector.c b/plugins/elements/gstinputselector.c
index 7ef7be2..5f907d7 100644
--- a/plugins/elements/gstinputselector.c
+++ b/plugins/elements/gstinputselector.c
@@ -659,7 +659,7 @@ gst_selector_pad_chain (GstPad * pad, GstBuffer * buf)
     gst_pad_push_event (sel->srcpad, start_event);
 
   if (selpad->discont) {
-    buf = gst_buffer_make_metadata_writable (buf);
+    buf = gst_buffer_make_writable (buf);
 
     GST_DEBUG_OBJECT (pad, "Marking discont buffer %p", buf);
     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
diff --git a/plugins/elements/gstqueue.c b/plugins/elements/gstqueue.c
index 9bd3c3d..079f3dd 100644
--- a/plugins/elements/gstqueue.c
+++ b/plugins/elements/gstqueue.c
@@ -1008,7 +1008,7 @@ gst_queue_chain (GstPad * pad, GstBuffer * buffer)
   }
 
   if (queue->tail_needs_discont) {
-    GstBuffer *subbuffer = gst_buffer_make_metadata_writable (buffer);
+    GstBuffer *subbuffer = gst_buffer_make_writable (buffer);
 
     if (subbuffer) {
       buffer = subbuffer;
@@ -1109,7 +1109,7 @@ next:
     buffer = GST_BUFFER_CAST (data);
 
     if (queue->head_needs_discont) {
-      GstBuffer *subbuffer = gst_buffer_make_metadata_writable (buffer);
+      GstBuffer *subbuffer = gst_buffer_make_writable (buffer);
 
       if (subbuffer) {
         buffer = subbuffer;
diff --git a/plugins/elements/gsttypefindelement.c b/plugins/elements/gsttypefindelement.c
index 03e66fa..a671005 100644
--- a/plugins/elements/gsttypefindelement.c
+++ b/plugins/elements/gsttypefindelement.c
@@ -488,7 +488,7 @@ stop_typefinding (GstTypeFindElement * typefind)
     goto no_data;
 
   buffer = gst_adapter_take_buffer (typefind->adapter, avail);
-  buffer = gst_buffer_make_metadata_writable (buffer);
+  buffer = gst_buffer_make_writable (buffer);
 
   gst_buffer_set_caps (buffer, typefind->caps);
   GST_OBJECT_UNLOCK (typefind);
@@ -636,7 +636,7 @@ gst_type_find_element_setcaps (GstPad * pad, GstCaps * caps)
       goto no_data;
 
     buffer = gst_adapter_take_buffer (typefind->adapter, avail);
-    buffer = gst_buffer_make_metadata_writable (buffer);
+    buffer = gst_buffer_make_writable (buffer);
     gst_buffer_set_caps (buffer, typefind->caps);
     GST_OBJECT_UNLOCK (typefind);
 
@@ -752,7 +752,7 @@ gst_type_find_element_chain (GstPad * pad, GstBuffer * buffer)
       return GST_FLOW_ERROR;
     case MODE_NORMAL:
       /* don't take object lock as typefind->caps should not change anymore */
-      buffer = gst_buffer_make_metadata_writable (buffer);
+      buffer = gst_buffer_make_writable (buffer);
       gst_buffer_set_caps (buffer, typefind->caps);
       return gst_pad_push (typefind->src, buffer);
     case MODE_TYPEFIND:
diff --git a/plugins/elements/gstvalve.c b/plugins/elements/gstvalve.c
index ae905f4..d90f459 100644
--- a/plugins/elements/gstvalve.c
+++ b/plugins/elements/gstvalve.c
@@ -182,7 +182,7 @@ gst_valve_chain (GstPad * pad, GstBuffer * buffer)
     valve->discont = TRUE;
   } else {
     if (valve->discont) {
-      buffer = gst_buffer_make_metadata_writable (buffer);
+      buffer = gst_buffer_make_writable (buffer);
       GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
       valve->discont = FALSE;
     }
diff --git a/tests/check/gst/gstbuffer.c b/tests/check/gst/gstbuffer.c
index f46166c..64ffeed 100644
--- a/tests/check/gst/gstbuffer.c
+++ b/tests/check/gst/gstbuffer.c
@@ -86,7 +86,7 @@ GST_START_TEST (test_subbuffer)
 
   /* check sizes, buffer starts out empty */
   data = gst_buffer_map (buffer, &size, &maxsize, GST_MAP_WRITE);
-  fail_unless (size == 0, "buffer has wrong size");
+  fail_unless (size == 4, "buffer has wrong size");
   fail_unless (maxsize >= 4, "buffer has wrong size");
   memset (data, 0, 4);
   gst_buffer_unmap (buffer, data, 4);
@@ -105,7 +105,6 @@ GST_START_TEST (test_subbuffer)
   fail_unless (ssize == 2, "subbuffer has wrong size");
   fail_unless (memcmp (data + 1, sdata, 2) == 0,
       "subbuffer contains the wrong data");
-  ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
   fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
       "subbuffer has wrong timestamp");
@@ -123,7 +122,6 @@ GST_START_TEST (test_subbuffer)
   fail_unless (ssize == 0, "subbuffer has wrong size");
   fail_unless (memcmp (data + 1, sdata, 0) == 0,
       "subbuffer contains the wrong data");
-  ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
   gst_buffer_unmap (sub, sdata, ssize);
   gst_buffer_unref (sub);
@@ -293,11 +291,10 @@ create_read_only_buffer (void)
 
   /* assign some read-only data to the new buffer */
   gst_buffer_take_memory (buf,
-      gst_memory_new_wrapped ((gpointer) ro_memory, NULL,
+      gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY,
+          (gpointer) ro_memory, NULL,
           sizeof (ro_memory), 0, sizeof (ro_memory)));
 
-  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
-
   return buf;
 }
 
@@ -309,11 +306,7 @@ GST_START_TEST (test_make_writable)
 
   /* create read-only buffer and make it writable */
   buf = create_read_only_buffer ();
-  fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
-      "read-only buffer should have read-only flag set");
-  buf = gst_buffer_make_writable (buf);
-  fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
-      "writable buffer must not have read-only flag set");
+
   data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
   data[4] = 'a';
   gst_buffer_unmap (buf, data, size);
@@ -321,8 +314,6 @@ GST_START_TEST (test_make_writable)
 
   /* alloc'ed buffer with refcount 1 should be writable */
   buf = gst_buffer_new_and_alloc (32);
-  fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
-      "_new_and_alloc'ed buffer must not have read-only flag set");
   buf2 = gst_buffer_make_writable (buf);
   fail_unless (buf == buf2,
       "_make_writable() should have returned same buffer");
@@ -330,8 +321,6 @@ GST_START_TEST (test_make_writable)
 
   /* alloc'ed buffer with refcount >1 should be copied */
   buf = gst_buffer_new_and_alloc (32);
-  fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
-      "_new_and_alloc'ed buffer must not have read-only flag set");
   gst_buffer_ref (buf);
   buf2 = gst_buffer_make_writable (buf);
   fail_unless (buf != buf2, "_make_writable() should have returned a copy!");
@@ -349,18 +338,11 @@ GST_START_TEST (test_subbuffer_make_writable)
 
   /* create sub-buffer of read-only buffer and make it writable */
   buf = create_read_only_buffer ();
-  fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
-      "read-only buffer should have read-only flag set");
 
   sub_buf = gst_buffer_create_sub (buf, 0, 8);
-  fail_unless (GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
-      "sub-buffer of read-only buffer should have read-only flag set");
-
-  sub_buf = gst_buffer_make_writable (sub_buf);
-  fail_unless (!GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
-      "writable buffer must not have read-only flag set");
 
   data = gst_buffer_map (sub_buf, &size, NULL, GST_MAP_WRITE);
+  fail_if (data == NULL);
   data[4] = 'a';
   gst_buffer_unmap (sub_buf, data, size);
   gst_buffer_unref (sub_buf);
@@ -378,23 +360,18 @@ GST_START_TEST (test_metadata_writable)
   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
 
   /* Buffer with refcount 1 should have writable metadata */
-  fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
+  fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 
   /* Check that a buffer with refcount 2 does not have writable metadata */
   gst_buffer_ref (buffer);
   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
-  fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
+  fail_unless (gst_buffer_is_writable (buffer) == FALSE);
 
   /* Check that make_metadata_writable produces a new sub-buffer with 
    * writable metadata. */
-  sub1 = gst_buffer_make_metadata_writable (buffer);
+  sub1 = gst_buffer_make_writable (buffer);
   fail_if (sub1 == buffer);
-  fail_unless (gst_buffer_is_metadata_writable (sub1) == TRUE);
-
-  /* Check that the original metadata is still not writable 
-   * (subbuffer should be holding a reference, and so should we) */
-  ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
-  fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
+  fail_unless (gst_buffer_is_writable (sub1) == TRUE);
 
   /* Check that make_metadata_writable() maintains the buffer flags */
   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT));
@@ -410,7 +387,7 @@ GST_START_TEST (test_metadata_writable)
   /* Drop the subbuffer and check that the metadata is now writable again */
   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
   gst_buffer_unref (sub1);
-  fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
+  fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 
   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
   gst_buffer_unref (buffer);
@@ -430,11 +407,13 @@ GST_START_TEST (test_copy)
   copy = gst_buffer_copy (buffer);
   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
   ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
-  /* data must be copied and thus point to different memory */
+  /* buffers are copied and must point to different memory */
+  fail_if (buffer == copy);
+
   data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
   sdata = gst_buffer_map (copy, &ssize, NULL, GST_MAP_READ);
 
-  fail_if (data == sdata);
+  /* NOTE that data is refcounted */
   fail_unless (size == ssize);
 
   gst_buffer_unmap (copy, sdata, ssize);
@@ -447,7 +426,6 @@ GST_START_TEST (test_copy)
   buffer = gst_buffer_new_and_alloc (0);
   data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
   fail_unless (data == NULL);
-  fail_unless (size == 0);
   gst_buffer_unmap (buffer, data, size);
 
   /* copying a 0-sized buffer should not crash and also set
@@ -455,7 +433,6 @@ GST_START_TEST (test_copy)
   copy = gst_buffer_copy (buffer);
   data = gst_buffer_map (copy, &size, NULL, GST_MAP_READ);
   fail_unless (data == NULL);
-  fail_unless (size == 0);
   gst_buffer_unmap (copy, data, size);
 
   gst_buffer_unref (copy);
@@ -476,7 +453,6 @@ GST_START_TEST (test_try_new_and_alloc)
   fail_unless (GST_IS_BUFFER (buf));
   data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
   fail_unless (data == NULL);
-  fail_unless (size == 0);
   gst_buffer_unmap (buf, data, size);
   gst_buffer_unref (buf);
 
diff --git a/tests/check/gst/gstminiobject.c b/tests/check/gst/gstminiobject.c
index cb44e14..9330a4d 100644
--- a/tests/check/gst/gstminiobject.c
+++ b/tests/check/gst/gstminiobject.c
@@ -49,13 +49,6 @@ GST_START_TEST (test_is_writable)
   fail_unless (gst_mini_object_is_writable (mobj),
       "A buffer with one ref should be writable");
 
-  GST_MINI_OBJECT_FLAG_SET (mobj, GST_MINI_OBJECT_FLAG_READONLY);
-  fail_if (gst_mini_object_is_writable (mobj),
-      "A buffer with READONLY set should not be writable");
-  GST_MINI_OBJECT_FLAG_UNSET (mobj, GST_MINI_OBJECT_FLAG_READONLY);
-  fail_unless (gst_mini_object_is_writable (mobj),
-      "A buffer with one ref and READONLY not set should be writable");
-
   fail_if (gst_mini_object_ref (mobj) == NULL, "Could not ref the mobj");
 
   fail_if (gst_mini_object_is_writable (mobj),
diff --git a/tests/check/libs/bitreader.c b/tests/check/libs/bitreader.c
index 635b6f2..bdedbeb 100644
--- a/tests/check/libs/bitreader.c
+++ b/tests/check/libs/bitreader.c
@@ -49,7 +49,8 @@ GST_START_TEST (test_initialization)
   guint8 *bdata;
   gsize bsize;
 
-  gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, NULL, 4, 0, 4));
+  gst_buffer_take_memory (buffer,
+      gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY, data, NULL, 4, 0, 4));
 
   fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
   fail_unless_equals_int (x, 0x01);
diff --git a/tests/check/libs/bytereader.c b/tests/check/libs/bytereader.c
index d71f7f6..19af966 100644
--- a/tests/check/libs/bytereader.c
+++ b/tests/check/libs/bytereader.c
@@ -49,7 +49,8 @@ GST_START_TEST (test_initialization)
   guint8 *bdata;
   gsize bsize;
 
-  gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, NULL, 4, 0, 4));
+  gst_buffer_take_memory (buffer,
+      gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY, data, NULL, 4, 0, 4));
 
   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
   fail_unless_equals_int (x, 0x01);
diff --git a/tests/check/libs/typefindhelper.c b/tests/check/libs/typefindhelper.c
index d5b5b4f..349911a 100644
--- a/tests/check/libs/typefindhelper.c
+++ b/tests/check/libs/typefindhelper.c
@@ -56,8 +56,8 @@ GST_START_TEST (test_buffer_range)
   fail_unless (buf != NULL);
 
   gst_buffer_take_memory (buf,
-      gst_memory_new_wrapped ((gpointer) vorbisid, NULL, 30, 0, 30));
-  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
+      gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY,
+          (gpointer) vorbisid, NULL, 30, 0, 30));
 
   caps = gst_type_find_helper_for_buffer (NULL, buf, NULL);
   fail_unless (caps != NULL);