docs: gst: more gobject introspection annotations
[platform/upstream/gstreamer.git] / gst / gstbuffer.c
index 923f060..871b34d 100644 (file)
  * Alternatively, use gst_buffer_new_and_alloc()
  * to create a buffer with preallocated data of a given size.
  *
+ * The data pointed to by the buffer can be retrieved with the GST_BUFFER_DATA()
+ * macro. The size of the data can be found with GST_BUFFER_SIZE(). For buffers
+ * of size 0, the data pointer is undefined (usually NULL) and should never be used.
+ *
  * If an element knows what pad you will push the buffer out on, it should use
  * gst_pad_alloc_buffer() instead to create a buffer.  This allows downstream
  * elements to provide special buffers to write in, like hardware buffers.
  * the refcount drops to 0, any data pointed to by GST_BUFFER_MALLOCDATA() will
  * also be freed.
  *
- * Last reviewed on November 23th, 2005 (0.9.5)
+ * Last reviewed on August 11th, 2006 (0.10.10)
  */
 #include "gst_private.h"
 
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
 #include "gstbuffer.h"
 #include "gstinfo.h"
 #include "gstutils.h"
 #include "gstminiobject.h"
+#include "gstversion.h"
 
-
-static void gst_buffer_init (GTypeInstance * instance, gpointer g_class);
-static void gst_buffer_class_init (gpointer g_class, gpointer class_data);
 static void gst_buffer_finalize (GstBuffer * buffer);
 static GstBuffer *_gst_buffer_copy (GstBuffer * buffer);
-static GType gst_subbuffer_get_type (void);
 
-void
-_gst_buffer_initialize (void)
+static GType _gst_buffer_type = 0;
+
+/* buffer alignment in bytes
+ * an alignment of 8 would be the same as malloc() guarantees
+ */
+#ifdef HAVE_POSIX_MEMALIGN
+#if defined(BUFFER_ALIGNMENT_MALLOC)
+static size_t _gst_buffer_data_alignment = 8;
+#elif defined(BUFFER_ALIGNMENT_PAGESIZE)
+static size_t _gst_buffer_data_alignment = 0;
+#elif defined(BUFFER_ALIGNMENT)
+static size_t _gst_buffer_data_alignment = BUFFER_ALIGNMENT;
+#else
+#error "No buffer alignment configured"
+#endif
+
+static inline gboolean
+aligned_malloc (gpointer * memptr, guint size)
 {
-  gpointer ptr;
+  gint res;
+
+  res = posix_memalign (memptr, _gst_buffer_data_alignment, size);
+  return (res == 0);
+}
 
-  gst_buffer_get_type ();
-  gst_subbuffer_get_type ();
+#endif /* HAVE_POSIX_MEMALIGN */
 
+void
+_gst_buffer_initialize (void)
+{
   /* the GstMiniObject types need to be class_ref'd once before it can be
    * done from multiple threads;
    * see http://bugzilla.gnome.org/show_bug.cgi?id=304551 */
-  ptr = g_type_class_ref (GST_TYPE_BUFFER);
-  g_type_class_unref (ptr);
+  g_type_class_ref (gst_buffer_get_type ());
+#ifdef HAVE_GETPAGESIZE
+#ifdef BUFFER_ALIGNMENT_PAGESIZE
+  _gst_buffer_data_alignment = getpagesize ();
+#endif
+#endif
 }
 
-GType
-gst_buffer_get_type (void)
-{
-  static GType _gst_buffer_type;
-
-  if (G_UNLIKELY (_gst_buffer_type == 0)) {
-    static const GTypeInfo buffer_info = {
-      sizeof (GstBufferClass),
-      NULL,
-      NULL,
-      gst_buffer_class_init,
-      NULL,
-      NULL,
-      sizeof (GstBuffer),
-      0,
-      gst_buffer_init,
-      NULL
-    };
-
-    _gst_buffer_type = g_type_register_static (GST_TYPE_MINI_OBJECT,
-        "GstBuffer", &buffer_info, 0);
-  }
-  return _gst_buffer_type;
+#define _do_init \
+{ \
+  _gst_buffer_type = g_define_type_id; \
 }
 
+G_DEFINE_TYPE_WITH_CODE (GstBuffer, gst_buffer, GST_TYPE_MINI_OBJECT, _do_init);
+
 static void
-gst_buffer_class_init (gpointer g_class, gpointer class_data)
+gst_buffer_class_init (GstBufferClass * klass)
 {
-  GstBufferClass *buffer_class = GST_BUFFER_CLASS (g_class);
-
-  buffer_class->mini_object_class.copy =
-      (GstMiniObjectCopyFunction) _gst_buffer_copy;
-  buffer_class->mini_object_class.finalize =
+  klass->mini_object_class.copy = (GstMiniObjectCopyFunction) _gst_buffer_copy;
+  klass->mini_object_class.finalize =
       (GstMiniObjectFinalizeFunction) gst_buffer_finalize;
-
 }
 
 static void
@@ -183,66 +195,126 @@ gst_buffer_finalize (GstBuffer * buffer)
   GST_CAT_LOG (GST_CAT_BUFFER, "finalize %p", buffer);
 
   /* free our data */
-  if (buffer->malloc_data) {
-    g_free (buffer->malloc_data);
-  }
+  if (G_LIKELY (buffer->malloc_data))
+    buffer->free_func (buffer->malloc_data);
 
   gst_caps_replace (&GST_BUFFER_CAPS (buffer), NULL);
+
+  if (buffer->parent)
+    gst_buffer_unref (buffer->parent);
+
+/*   ((GstMiniObjectClass *) */
+/*       gst_buffer_parent_class)->finalize (GST_MINI_OBJECT_CAST (buffer)); */
+}
+
+/**
+ * gst_buffer_copy_metadata:
+ * @dest: a destination #GstBuffer
+ * @src: a source #GstBuffer
+ * @flags: flags indicating what metadata fields should be copied.
+ *
+ * Copies the metadata from @src into @dest. The data, size and mallocdata
+ * fields are not copied.
+ *
+ * @flags indicate which fields will be copied. Use #GST_BUFFER_COPY_ALL to copy
+ * all the metadata fields.
+ *
+ * This function is typically called from a custom buffer copy function after
+ * creating @dest and setting the data, size, mallocdata.
+ *
+ * Since: 0.10.13
+ */
+void
+gst_buffer_copy_metadata (GstBuffer * dest, const GstBuffer * src,
+    GstBufferCopyFlags flags)
+{
+  g_return_if_fail (dest != NULL);
+  g_return_if_fail (src != NULL);
+
+  /* nothing to copy if the buffers are the same */
+  if (G_UNLIKELY (dest == src))
+    return;
+
+#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));
+#endif
+
+  GST_CAT_LOG (GST_CAT_BUFFER, "copy %p to %p", src, dest);
+
+  if (flags & GST_BUFFER_COPY_FLAGS) {
+    guint mask;
+
+    /* copy relevant flags */
+    mask = GST_BUFFER_FLAG_PREROLL | GST_BUFFER_FLAG_IN_CAPS |
+        GST_BUFFER_FLAG_DELTA_UNIT | GST_BUFFER_FLAG_DISCONT |
+        GST_BUFFER_FLAG_GAP | GST_BUFFER_FLAG_MEDIA1 |
+        GST_BUFFER_FLAG_MEDIA2 | GST_BUFFER_FLAG_MEDIA3;
+    GST_MINI_OBJECT_FLAGS (dest) |= GST_MINI_OBJECT_FLAGS (src) & mask;
+  }
+
+  if (flags & GST_BUFFER_COPY_TIMESTAMPS) {
+    GST_BUFFER_TIMESTAMP (dest) = GST_BUFFER_TIMESTAMP (src);
+    GST_BUFFER_DURATION (dest) = GST_BUFFER_DURATION (src);
+    GST_BUFFER_OFFSET (dest) = GST_BUFFER_OFFSET (src);
+    GST_BUFFER_OFFSET_END (dest) = GST_BUFFER_OFFSET_END (src);
+  }
+
+  if (flags & GST_BUFFER_COPY_CAPS) {
+    gst_caps_replace (&GST_BUFFER_CAPS (dest), GST_BUFFER_CAPS (src));
+  }
 }
 
 static GstBuffer *
 _gst_buffer_copy (GstBuffer * buffer)
 {
   GstBuffer *copy;
-  guint mask;
 
   g_return_val_if_fail (buffer != NULL, NULL);
 
   /* create a fresh new buffer */
   copy = gst_buffer_new ();
 
-  GST_CAT_LOG (GST_CAT_BUFFER, "copy %p to %p", buffer, copy);
-
-  /* copy relevant flags */
-  mask = GST_BUFFER_FLAG_PREROLL | GST_BUFFER_FLAG_IN_CAPS |
-      GST_BUFFER_FLAG_DELTA_UNIT | GST_BUFFER_FLAG_DISCONT |
-      GST_BUFFER_FLAG_GAP;
-  GST_MINI_OBJECT (copy)->flags |= GST_MINI_OBJECT (buffer)->flags & mask;
-
   /* we simply copy everything from our parent */
+#ifdef HAVE_POSIX_MEMALIGN
+  {
+    gpointer memptr = NULL;
+
+    if (G_LIKELY (buffer->size)) {
+      if (G_UNLIKELY (!aligned_malloc (&memptr, buffer->size))) {
+        /* terminate on error like g_memdup() would */
+        g_error ("%s: failed to allocate %u bytes", G_STRLOC, buffer->size);
+      } else {
+        memcpy (memptr, buffer->data, buffer->size);
+      }
+    }
+    copy->data = (guint8 *) memptr;
+    GST_BUFFER_FREE_FUNC (copy) = free;
+  }
+#else
   copy->data = g_memdup (buffer->data, buffer->size);
+#endif
+
   /* make sure it gets freed (even if the parent is subclassed, we return a
-     normal buffer */
+     normal buffer) */
   copy->malloc_data = copy->data;
-
   copy->size = buffer->size;
 
-  GST_BUFFER_TIMESTAMP (copy) = GST_BUFFER_TIMESTAMP (buffer);
-  GST_BUFFER_DURATION (copy) = GST_BUFFER_DURATION (buffer);
-  GST_BUFFER_OFFSET (copy) = GST_BUFFER_OFFSET (buffer);
-  GST_BUFFER_OFFSET_END (copy) = GST_BUFFER_OFFSET_END (buffer);
-
-  if (GST_BUFFER_CAPS (buffer))
-    GST_BUFFER_CAPS (copy) = gst_caps_ref (GST_BUFFER_CAPS (buffer));
-  else
-    GST_BUFFER_CAPS (copy) = NULL;
+  gst_buffer_copy_metadata (copy, buffer, GST_BUFFER_COPY_ALL);
 
   return copy;
 }
 
 static void
-gst_buffer_init (GTypeInstance * instance, gpointer g_class)
+gst_buffer_init (GstBuffer * buffer)
 {
-  GstBuffer *buffer;
-
-  buffer = (GstBuffer *) instance;
-
   GST_CAT_LOG (GST_CAT_BUFFER, "init %p", buffer);
 
   GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE;
   GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
   GST_BUFFER_OFFSET (buffer) = GST_BUFFER_OFFSET_NONE;
   GST_BUFFER_OFFSET_END (buffer) = GST_BUFFER_OFFSET_NONE;
+  GST_BUFFER_FREE_FUNC (buffer) = g_free;
 }
 
 /**
@@ -251,14 +323,15 @@ gst_buffer_init (GTypeInstance * instance, gpointer g_class)
  * Creates a newly allocated buffer without any data.
  *
  * MT safe.
- * Returns: the new #GstBuffer.
+ *
+ * Returns: (transfer full): the new #GstBuffer.
  */
 GstBuffer *
 gst_buffer_new (void)
 {
   GstBuffer *newbuf;
 
-  newbuf = (GstBuffer *) gst_mini_object_new (GST_TYPE_BUFFER);
+  newbuf = (GstBuffer *) gst_mini_object_new (_gst_buffer_type);
 
   GST_CAT_LOG (GST_CAT_BUFFER, "new %p", newbuf);
 
@@ -270,10 +343,18 @@ gst_buffer_new (void)
  * @size: the size of the new buffer's data.
  *
  * Creates a newly allocated buffer with data of the given size.
- * The buffer memory is not cleared.
+ * The buffer memory is not cleared. If the requested amount of
+ * memory can't be allocated, the program will abort. Use
+ * gst_buffer_try_new_and_alloc() if you want to handle this case
+ * gracefully or have gotten the size to allocate from an untrusted
+ * source such as a media stream.
+ * 
+ *
+ * Note that when @size == 0, the buffer data pointer will be NULL.
  *
  * MT safe.
- * Returns: the new #GstBuffer.
+ *
+ * Returns: (transfer full): the new #GstBuffer.
  */
 GstBuffer *
 gst_buffer_new_and_alloc (guint size)
@@ -282,7 +363,22 @@ gst_buffer_new_and_alloc (guint size)
 
   newbuf = gst_buffer_new ();
 
+#ifdef HAVE_POSIX_MEMALIGN
+  {
+    gpointer memptr = NULL;
+
+    if (G_LIKELY (size)) {
+      if (G_UNLIKELY (!aligned_malloc (&memptr, size))) {
+        /* terminate on error like g_memdup() would */
+        g_error ("%s: failed to allocate %u bytes", G_STRLOC, size);
+      }
+    }
+    newbuf->malloc_data = (guint8 *) memptr;
+    GST_BUFFER_FREE_FUNC (newbuf) = free;
+  }
+#else
   newbuf->malloc_data = g_malloc (size);
+#endif
   GST_BUFFER_DATA (newbuf) = newbuf->malloc_data;
   GST_BUFFER_SIZE (newbuf) = size;
 
@@ -292,17 +388,75 @@ gst_buffer_new_and_alloc (guint size)
 }
 
 /**
+ * gst_buffer_try_new_and_alloc:
+ * @size: the size of the new buffer's data.
+ *
+ * Tries to create a newly allocated buffer with data of the given size. If
+ * the requested amount of memory can't be allocated, NULL will be returned.
+ * The buffer memory is not cleared.
+ *
+ * Note that when @size == 0, the buffer data pointer will be NULL.
+ *
+ * MT safe.
+ *
+ * Returns: (transfer full): a new #GstBuffer, or NULL if the memory couldn't
+ *     be allocated.
+ *
+ * Since: 0.10.13
+ */
+GstBuffer *
+gst_buffer_try_new_and_alloc (guint size)
+{
+  GstBuffer *newbuf;
+  guint8 *malloc_data;
+#ifdef HAVE_POSIX_MEMALIGN
+  gpointer memptr = NULL;
+
+  if (G_LIKELY (size)) {
+    if (G_UNLIKELY (!aligned_malloc (&memptr, size))) {
+      GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size);
+      return NULL;
+    }
+  }
+  malloc_data = (guint8 *) memptr;
+#else
+  malloc_data = g_try_malloc (size);
+
+  if (G_UNLIKELY (malloc_data == NULL && size != 0)) {
+    GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size);
+    return NULL;
+  }
+#endif
+
+  /* FIXME: there's no g_type_try_create_instance() in GObject yet, so this
+   * will still abort if a new GstBuffer structure can't be allocated */
+  newbuf = gst_buffer_new ();
+
+  GST_BUFFER_MALLOCDATA (newbuf) = malloc_data;
+  GST_BUFFER_DATA (newbuf) = malloc_data;
+  GST_BUFFER_SIZE (newbuf) = size;
+#ifdef HAVE_POSIX_MEMALIGN
+  GST_BUFFER_FREE_FUNC (newbuf) = free;
+#endif
+
+  GST_CAT_LOG (GST_CAT_BUFFER, "new %p of size %d", newbuf, size);
+
+  return newbuf;
+}
+
+/**
  * gst_buffer_get_caps:
  * @buffer: a #GstBuffer.
  *
  * Gets the media type of the buffer. This can be NULL if there
  * is no media type attached to this buffer.
  *
- * Returns: a reference to the #GstCaps. unref after usage.
+ * Returns: (transfer full): a reference to the #GstCaps. unref after usage.
  * Returns NULL if there were no caps on this buffer.
  */
-/* FIXME can we make this threadsafe without a lock on the buffer?
- * We can use compare and swap and atomic reads. */
+/* this is not made atomic because if the buffer were reffed from multiple
+ * threads, it would have a refcount > 2 and thus be immutable.
+ */
 GstCaps *
 gst_buffer_get_caps (GstBuffer * buffer)
 {
@@ -321,20 +475,26 @@ gst_buffer_get_caps (GstBuffer * buffer)
 /**
  * gst_buffer_set_caps:
  * @buffer: a #GstBuffer.
- * @caps: a #GstCaps.
+ * @caps: (transfer none): a #GstCaps.
  *
  * Sets the media type on the buffer. The refcount of the caps will
  * be increased and any previous caps on the buffer will be
  * unreffed.
  */
-/* FIXME can we make this threadsafe without a lock on the buffer?
- * We can use compare and swap and atomic reads. Another idea is to
- * not attach the caps to the buffer but use an event to signal a caps
- * change. */
+/* this is not made atomic because if the buffer were reffed from multiple
+ * threads, it would have a refcount > 2 and thus be immutable.
+ */
 void
 gst_buffer_set_caps (GstBuffer * buffer, GstCaps * caps)
 {
   g_return_if_fail (buffer != NULL);
+  g_return_if_fail (caps == NULL || GST_CAPS_IS_SIMPLE (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));
+  /* FIXME: would be nice to also check if caps are fixed here, but expensive */
+#endif
 
   gst_caps_replace (&GST_BUFFER_CAPS (buffer), caps);
 }
@@ -352,21 +512,23 @@ gst_buffer_set_caps (GstBuffer * buffer, GstCaps * caps)
 gboolean
 gst_buffer_is_metadata_writable (GstBuffer * buf)
 {
-  return (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT (buf)) == 1);
+  return (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1);
 }
 
 /**
  * gst_buffer_make_metadata_writable:
- * @buf: a #GstBuffer
+ * @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.
+ * After calling this function, @buf should not be referenced anymore. The
+ * result of this function has guaranteed writable metadata.
  *
- * Returns: A new #GstBuffer with 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)
@@ -377,153 +539,105 @@ gst_buffer_make_metadata_writable (GstBuffer * buf)
     ret = buf;
   } else {
     ret = gst_buffer_create_sub (buf, 0, GST_BUFFER_SIZE (buf));
-    GST_BUFFER_FLAGS (ret) = GST_BUFFER_FLAGS (buf);
-    GST_BUFFER_FLAG_UNSET (ret, GST_BUFFER_FLAG_IN_CAPS);
+
     gst_buffer_unref (buf);
   }
 
   return ret;
 }
 
-typedef struct _GstSubBuffer GstSubBuffer;
-typedef struct _GstSubBufferClass GstSubBufferClass;
-
-#define GST_TYPE_SUBBUFFER                         (gst_subbuffer_get_type())
-
-#define GST_IS_SUBBUFFER(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_SUBBUFFER))
-#define GST_SUBBUFFER(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_SUBBUFFER, GstSubBuffer))
-
-struct _GstSubBuffer
-{
-  GstBuffer buffer;
-
-  GstBuffer *parent;
-};
-
-struct _GstSubBufferClass
-{
-  GstBufferClass buffer_class;
-};
-
-static GstBufferClass *sub_parent_class;
-
-static void gst_subbuffer_init (GTypeInstance * instance, gpointer g_class);
-static void gst_subbuffer_class_init (gpointer g_class, gpointer class_data);
-static void gst_subbuffer_finalize (GstSubBuffer * buffer);
-
-static GType
-gst_subbuffer_get_type (void)
-{
-  static GType _gst_subbuffer_type = 0;
-
-  if (G_UNLIKELY (_gst_subbuffer_type == 0)) {
-    static const GTypeInfo subbuffer_info = {
-      sizeof (GstSubBufferClass),
-      NULL,
-      NULL,
-      gst_subbuffer_class_init,
-      NULL,
-      NULL,
-      sizeof (GstSubBuffer),
-      0,
-      gst_subbuffer_init,
-      NULL
-    };
-
-    _gst_subbuffer_type = g_type_register_static (GST_TYPE_BUFFER,
-        "GstSubBuffer", &subbuffer_info, 0);
-  }
-  return _gst_subbuffer_type;
-}
-
-static void
-gst_subbuffer_class_init (gpointer g_class, gpointer class_data)
-{
-  GstBufferClass *buffer_class = GST_BUFFER_CLASS (g_class);
-
-  sub_parent_class = g_type_class_peek_parent (g_class);
-
-  buffer_class->mini_object_class.finalize =
-      (GstMiniObjectFinalizeFunction) gst_subbuffer_finalize;
-}
-
-static void
-gst_subbuffer_finalize (GstSubBuffer * buffer)
-{
-  gst_buffer_unref (buffer->parent);
-
-  GST_MINI_OBJECT_CLASS (sub_parent_class)->finalize (GST_MINI_OBJECT (buffer));
-}
-
-static void
-gst_subbuffer_init (GTypeInstance * instance, gpointer g_class)
-{
-  GST_BUFFER_FLAG_SET (GST_BUFFER_CAST (instance), GST_BUFFER_FLAG_READONLY);
-}
+#define GST_IS_SUBBUFFER(obj)   (GST_BUFFER_CAST(obj)->parent != NULL)
 
 /**
  * gst_buffer_create_sub:
  * @parent: a #GstBuffer.
  * @offset: the offset into parent #GstBuffer at which the new sub-buffer 
  *          begins.
- * @size: the size of the new #GstBuffer sub-buffer, in bytes (with size > 0).
+ * @size: the size of the new #GstBuffer sub-buffer, in bytes.
  *
  * Creates a sub-buffer from @parent at @offset and @size.
  * This sub-buffer uses the actual memory space of the parent buffer.
  * This function will copy the offset and timestamp fields when the
- * offset is 0, else they are set to #GST_CLOCK_TIME_NONE/#GST_BUFFER_OFFSET_NONE.
- * The duration field of the new buffer is set to #GST_CLOCK_TIME_NONE.
+ * offset is 0. If not, they will be set to #GST_CLOCK_TIME_NONE and 
+ * #GST_BUFFER_OFFSET_NONE.
+ * If @offset equals 0 and @size equals the total size of @buffer, the
+ * duration and offset end fields are also copied. If not they will be set
+ * to #GST_CLOCK_TIME_NONE and #GST_BUFFER_OFFSET_NONE.
  *
  * MT safe.
- * Returns: the new #GstBuffer.
- * Returns NULL if the arguments were invalid.
+ *
+ * Returns: (transfer full): the new #GstBuffer or NULL if the arguments were
+ *     invalid.
  */
 GstBuffer *
 gst_buffer_create_sub (GstBuffer * buffer, guint offset, guint size)
 {
-  GstSubBuffer *subbuffer;
+  GstBuffer *subbuffer;
   GstBuffer *parent;
+  gboolean complete;
 
   g_return_val_if_fail (buffer != NULL, NULL);
-  g_return_val_if_fail (buffer->mini_object.refcount > 0, NULL);
-  g_return_val_if_fail (size > 0, NULL);
+  g_return_val_if_fail (buffer->mini_object.refcount, NULL);
   g_return_val_if_fail (buffer->size >= offset + size, NULL);
 
   /* find real parent */
   if (GST_IS_SUBBUFFER (buffer)) {
-    parent = GST_SUBBUFFER (buffer)->parent;
+    parent = buffer->parent;
   } else {
     parent = buffer;
   }
   gst_buffer_ref (parent);
 
   /* create the new buffer */
-  subbuffer = (GstSubBuffer *) gst_mini_object_new (GST_TYPE_SUBBUFFER);
+  subbuffer = gst_buffer_new ();
   subbuffer->parent = parent;
+  GST_BUFFER_FLAG_SET (subbuffer, GST_BUFFER_FLAG_READONLY);
 
   GST_CAT_LOG (GST_CAT_BUFFER, "new subbuffer %p (parent %p)", subbuffer,
       parent);
 
   /* set the right values in the child */
-  GST_BUFFER_DATA (GST_BUFFER_CAST (subbuffer)) = buffer->data + offset;
-  GST_BUFFER_SIZE (GST_BUFFER_CAST (subbuffer)) = size;
+  GST_BUFFER_DATA (subbuffer) = buffer->data + offset;
+  GST_BUFFER_SIZE (subbuffer) = size;
+
+  if ((offset == 0) && (size == GST_BUFFER_SIZE (buffer))) {
+    /* copy all the flags except IN_CAPS */
+    GST_BUFFER_FLAG_SET (subbuffer, GST_BUFFER_FLAGS (buffer));
+    GST_BUFFER_FLAG_UNSET (subbuffer, GST_BUFFER_FLAG_IN_CAPS);
+  } else {
+    /* copy only PREROLL & GAP flags */
+    GST_BUFFER_FLAG_SET (subbuffer, (GST_BUFFER_FLAGS (buffer) &
+            (GST_BUFFER_FLAG_PREROLL | GST_BUFFER_FLAG_GAP)));
+  }
 
   /* we can copy the timestamp and offset if the new buffer starts at
    * offset 0 */
   if (offset == 0) {
     GST_BUFFER_TIMESTAMP (subbuffer) = GST_BUFFER_TIMESTAMP (buffer);
     GST_BUFFER_OFFSET (subbuffer) = GST_BUFFER_OFFSET (buffer);
+    complete = (buffer->size == size);
   } else {
     GST_BUFFER_TIMESTAMP (subbuffer) = GST_CLOCK_TIME_NONE;
     GST_BUFFER_OFFSET (subbuffer) = GST_BUFFER_OFFSET_NONE;
+    complete = FALSE;
   }
 
-  GST_BUFFER_DURATION (subbuffer) = GST_CLOCK_TIME_NONE;
-  GST_BUFFER_OFFSET_END (subbuffer) = GST_BUFFER_OFFSET_NONE;
+  if (complete) {
+    GstCaps *caps;
 
-  GST_BUFFER_CAPS (subbuffer) = NULL;
-
-  return GST_BUFFER_CAST (subbuffer);
+    /* if we copied the complete buffer we can copy the duration,
+     * offset_end and caps as well */
+    GST_BUFFER_DURATION (subbuffer) = GST_BUFFER_DURATION (buffer);
+    GST_BUFFER_OFFSET_END (subbuffer) = GST_BUFFER_OFFSET_END (buffer);
+    if ((caps = GST_BUFFER_CAPS (buffer)))
+      gst_caps_ref (caps);
+    GST_BUFFER_CAPS (subbuffer) = caps;
+  } else {
+    GST_BUFFER_DURATION (subbuffer) = GST_CLOCK_TIME_NONE;
+    GST_BUFFER_OFFSET_END (subbuffer) = GST_BUFFER_OFFSET_NONE;
+    GST_BUFFER_CAPS (subbuffer) = NULL;
+  }
+  return subbuffer;
 }
 
 /**
@@ -543,14 +657,13 @@ gboolean
 gst_buffer_is_span_fast (GstBuffer * buf1, GstBuffer * buf2)
 {
   g_return_val_if_fail (buf1 != NULL && buf2 != NULL, FALSE);
-  g_return_val_if_fail (buf1->mini_object.refcount > 0, FALSE);
-  g_return_val_if_fail (buf2->mini_object.refcount > 0, FALSE);
+  g_return_val_if_fail (buf1->mini_object.refcount, FALSE);
+  g_return_val_if_fail (buf2->mini_object.refcount, FALSE);
 
   /* it's only fast if we have subbuffers of the same parent */
   return (GST_IS_SUBBUFFER (buf1) &&
-      GST_IS_SUBBUFFER (buf2) &&
-      (GST_SUBBUFFER (buf1)->parent == GST_SUBBUFFER (buf2)->parent) &&
-      ((buf1->data + buf1->size) == buf2->data));
+      GST_IS_SUBBUFFER (buf2) && (buf1->parent == buf2->parent)
+      && ((buf1->data + buf1->size) == buf2->data));
 }
 
 /**
@@ -572,8 +685,9 @@ gst_buffer_is_span_fast (GstBuffer * buf1, GstBuffer * buf2)
  * gst_buffer_is_span_fast() to determine if a memcpy will be needed.
  *
  * MT safe.
- * Returns: the new #GstBuffer that spans the two source buffers.
- * Returns NULL if the arguments are invalid.
+ *
+ * Returns: (transfer full): the new #GstBuffer that spans the two source
+ *     buffers, or NULL if the arguments are invalid.
  */
 GstBuffer *
 gst_buffer_span (GstBuffer * buf1, guint32 offset, GstBuffer * buf2,
@@ -582,14 +696,14 @@ gst_buffer_span (GstBuffer * buf1, guint32 offset, GstBuffer * buf2,
   GstBuffer *newbuf;
 
   g_return_val_if_fail (buf1 != NULL && buf2 != NULL, NULL);
-  g_return_val_if_fail (buf1->mini_object.refcount > 0, NULL);
-  g_return_val_if_fail (buf2->mini_object.refcount > 0, NULL);
-  g_return_val_if_fail (len > 0, NULL);
+  g_return_val_if_fail (buf1->mini_object.refcount, NULL);
+  g_return_val_if_fail (buf2->mini_object.refcount, NULL);
+  g_return_val_if_fail (len, NULL);
   g_return_val_if_fail (len <= buf1->size + buf2->size - offset, NULL);
 
   /* if the two buffers have the same parent and are adjacent */
   if (gst_buffer_is_span_fast (buf1, buf2)) {
-    GstBuffer *parent = GST_SUBBUFFER (buf1)->parent;
+    GstBuffer *parent = buf1->parent;
 
     /* we simply create a subbuffer of the common parent */
     newbuf = gst_buffer_create_sub (parent,