/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *

 * gstbuffer.c: Buffer operations

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstbuffer

 * @title: GstBuffer

 * @short_description: Data-passing buffer type

 * @see_also: #GstPad, #GstMiniObject, #GstMemory, #GstMeta, #GstBufferPool

 *

 * Buffers are the basic unit of data transfer in GStreamer. They contain the

 * timing and offset along with other arbitrary metadata that is associated

 * with the #GstMemory blocks that the buffer contains.

 *

 * Buffers are usually created with gst_buffer_new(). After a buffer has been

 * created one will typically allocate memory for it and add it to the buffer.

 * The following example creates a buffer that can hold a given video frame

 * with a given width, height and bits per plane.

 * |[

 *   GstBuffer *buffer;

 *   GstMemory *memory;

 *   gint size, width, height, bpp;

 *   ...

 *   size = width * height * bpp;

 *   buffer = gst_buffer_new ();

 *   memory = gst_allocator_alloc (NULL, size, NULL);

 *   gst_buffer_insert_memory (buffer, -1, memory);

 *   ...

 * ]|

 *

 * Alternatively, use gst_buffer_new_allocate() to create a buffer with

 * preallocated data of a given size.

 *

 * Buffers can contain a list of #GstMemory objects. You can retrieve how many

 * memory objects with gst_buffer_n_memory() and you can get a pointer

 * to memory with gst_buffer_peek_memory()

 *

 * A buffer will usually have timestamps, and a duration, but neither of these

 * are guaranteed (they may be set to #GST_CLOCK_TIME_NONE). Whenever a

 * meaningful value can be given for these, they should be set. The timestamps

 * and duration are measured in nanoseconds (they are #GstClockTime values).

 *

 * The buffer DTS refers to the timestamp when the buffer should be decoded and

 * is usually monotonically increasing. The buffer PTS refers to the timestamp when

 * the buffer content should be presented to the user and is not always

 * monotonically increasing.

 *

 * A buffer can also have one or both of a start and an end offset. These are

 * media-type specific. For video buffers, the start offset will generally be

 * the frame number. For audio buffers, it will be the number of samples

 * produced so far. For compressed data, it could be the byte offset in a

 * source or destination file. Likewise, the end offset will be the offset of

 * the end of the buffer. These can only be meaningfully interpreted if you

 * know the media type of the buffer (the preceding CAPS event). Either or both

 * can be set to #GST_BUFFER_OFFSET_NONE.

 *

 * gst_buffer_ref() is used to increase the refcount of a buffer. This must be

 * done when you want to keep a handle to the buffer after pushing it to the

 * next element. The buffer refcount determines the writability of the buffer, a

 * buffer is only writable when the refcount is exactly 1, i.e. when the caller

 * has the only reference to the buffer.

 *

 * To efficiently create a smaller buffer out of an existing one, you can

 * use gst_buffer_copy_region(). This method tries to share the memory objects

 * between the two buffers.

 *

 * If a plug-in wants to modify the buffer data or metadata in-place, it should

 * first obtain a buffer that is safe to modify by using

 * gst_buffer_make_writable().  This function is optimized so that a copy will

 * only be made when it is necessary.

 *

 * Several flags of the buffer can be set and unset with the

 * GST_BUFFER_FLAG_SET() and GST_BUFFER_FLAG_UNSET() macros. Use

 * GST_BUFFER_FLAG_IS_SET() to test if a certain #GstBufferFlags flag is set.

 *

 * Buffers can be efficiently merged into a larger buffer with

 * gst_buffer_append(). Copying of memory will only be done when absolutely

 * needed.

 *

 * Arbitrary extra metadata can be set on a buffer with gst_buffer_add_meta().

 * Metadata can be retrieved with gst_buffer_get_meta(). See also #GstMeta

 *

 * An element should either unref the buffer or push it out on a src pad

 * using gst_pad_push() (see #GstPad).

 *

 * Buffers are usually freed by unreffing them with gst_buffer_unref(). When

 * the refcount drops to 0, any memory and metadata pointed to by the buffer is

 * unreffed as well. Buffers allocated from a #GstBufferPool will be returned to

 * the pool when the refcount drops to 0.

 *

 * The #GstParentBufferMeta is a meta which can be attached to a #GstBuffer

 * to hold a reference to another buffer that is only released when the child

 * #GstBuffer is released.

 *

 * Typically, #GstParentBufferMeta is used when the child buffer is directly

 * using the #GstMemory of the parent buffer, and wants to prevent the parent

 * buffer from being returned to a buffer pool until the #GstMemory is available

 * for re-use. (Since 1.6)

 *

 */

#include "gst_private.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include "gstbuffer.h"

#include "gstbufferpool.h"

#include "gstinfo.h"

#include "gstutils.h"

#include "gstversion.h"

GType _gst_buffer_type = 0;

typedef struct _GstMetaItem GstMetaItem;

struct _GstMetaItem

{

  GstMetaItem *next;

  GstMeta meta;

};

#define ITEM_SIZE(info) ((info)->size + sizeof (GstMetaItem))

#define GST_BUFFER_MEM_MAX         16

#define GST_BUFFER_SLICE_SIZE(b)   (((GstBufferImpl *)(b))->slice_size)

#define GST_BUFFER_MEM_LEN(b)      (((GstBufferImpl *)(b))->len)

#define GST_BUFFER_MEM_ARRAY(b)    (((GstBufferImpl *)(b))->mem)

#define GST_BUFFER_MEM_PTR(b,i)    (((GstBufferImpl *)(b))->mem[i])

#define GST_BUFFER_BUFMEM(b)       (((GstBufferImpl *)(b))->bufmem)

#define GST_BUFFER_META(b)         (((GstBufferImpl *)(b))->item)

typedef struct

{

  GstBuffer buffer;

  gsize slice_size;

  /* the memory blocks */

  guint len;

  GstMemory *mem[GST_BUFFER_MEM_MAX];

  /* memory of the buffer when allocated from 1 chunk */

  GstMemory *bufmem;

  /* FIXME, make metadata allocation more efficient by using part of the

   * GstBufferImpl */

  GstMetaItem *item;

} GstBufferImpl;

static gboolean

_is_span (GstMemory ** mem, gsize len, gsize * poffset, GstMemory ** parent)

{

  GstMemory *mcur, *mprv;

  gboolean have_offset = FALSE;

  gsize i;

  mcur = mprv = NULL;

  for (i = 0; i < len; i++) {

    if (mcur)

      mprv = mcur;

    mcur = mem[i];

    if (mprv && mcur) {

      gsize poffs;

      /* check if memory is contiguous */

      if (!gst_memory_is_span (mprv, mcur, &poffs))

        return FALSE;

      if (!have_offset) {

        if (poffset)

          *poffset = poffs;

        if (parent)

          *parent = mprv->parent;

        have_offset = TRUE;

      }

    }

  }

  return have_offset;

}

static GstMemory *

_get_merged_memory (GstBuffer * buffer, guint idx, guint length)

{

  GstMemory **mem, *result = NULL;

  GST_CAT_LOG (GST_CAT_BUFFER, "buffer %p, idx %u, length %u", buffer, idx,

      length);

  mem = GST_BUFFER_MEM_ARRAY (buffer);

  if (G_UNLIKELY (length == 0)) {

    result = NULL;

  } else if (G_LIKELY (length == 1)) {

    result = gst_memory_ref (mem[idx]);

  } else {

    GstMemory *parent = NULL;

    gsize size, poffset = 0;

    size = gst_buffer_get_sizes_range (buffer, idx, length, NULL, NULL);

    if (G_UNLIKELY (_is_span (mem + idx, length, &poffset, &parent))) {

      if (!GST_MEMORY_IS_NO_SHARE (parent))

        result = gst_memory_share (parent, poffset, size);

      if (!result) {

        GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy for merge %p", parent);

        result = gst_memory_copy (parent, poffset, size);

      }

    } else {

      gsize i, tocopy, left;

      GstMapInfo sinfo, dinfo;

      guint8 *ptr;

      result = gst_allocator_alloc (NULL, size, NULL);

      if (result == NULL || !gst_memory_map (result, &dinfo, GST_MAP_WRITE)) {

        GST_CAT_ERROR (GST_CAT_BUFFER, "Failed to map memory writable");

        if (result)

          gst_memory_unref (result);

        return NULL;

      }

      ptr = dinfo.data;

      left = size;

      for (i = idx; i < (idx + length) && left > 0; i++) {

        if (!gst_memory_map (mem[i], &sinfo, GST_MAP_READ)) {

          GST_CAT_ERROR (GST_CAT_BUFFER,

              "buffer %p, idx %u, length %u failed to map readable", buffer,

              idx, length);

          gst_memory_unmap (result, &dinfo);

          gst_memory_unref (result);

          return NULL;

        }

        tocopy = MIN (sinfo.size, left);

        GST_CAT_DEBUG (GST_CAT_PERFORMANCE,

            "memcpy %" G_GSIZE_FORMAT " bytes for merge %p from memory %p",

            tocopy, result, mem[i]);

        memcpy (ptr, (guint8 *) sinfo.data, tocopy);

        left -= tocopy;

        ptr += tocopy;

        gst_memory_unmap (mem[i], &sinfo);

      }

      gst_memory_unmap (result, &dinfo);

    }

  }

  return result;

}

static void

_replace_memory (GstBuffer * buffer, guint len, guint idx, guint length,

    GstMemory * mem)

{

  gsize end, i;

  end = idx + length;

  GST_CAT_LOG (GST_CAT_BUFFER,

      "buffer %p replace %u-%" G_GSIZE_FORMAT " with memory %p", buffer, idx,

      end, mem);

  /* unref old memory */

  for (i = idx; i < end; i++) {

    GstMemory *old = GST_BUFFER_MEM_PTR (buffer, i);

    gst_memory_unlock (old, GST_LOCK_FLAG_EXCLUSIVE);

    gst_memory_unref (old);

  }

  if (mem != NULL) {

    /* replace with single memory */

    gst_memory_lock (mem, GST_LOCK_FLAG_EXCLUSIVE);

    GST_BUFFER_MEM_PTR (buffer, idx) = mem;

    idx++;

    length--;

  }

  if (end < len) {

    memmove (&GST_BUFFER_MEM_PTR (buffer, idx),

        &GST_BUFFER_MEM_PTR (buffer, end), (len - end) * sizeof (gpointer));

  }

  GST_BUFFER_MEM_LEN (buffer) = len - length;

  GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_TAG_MEMORY);

}

/**

 * gst_buffer_get_flags:

 * @buffer: a #GstBuffer

 *

 * Get the #GstBufferFlags flags set on this buffer.

 *

 * Returns: the flags set on this buffer.

 *

 * Since: 1.10

 */

GstBufferFlags

gst_buffer_get_flags (GstBuffer * buffer)

{

  return (GstBufferFlags) GST_BUFFER_FLAGS (buffer);

}

/**

 * gst_buffer_flag_is_set:

 * @buffer: a #GstBuffer

 * @flags: the #GstBufferFlags flag to check.

 *

 * Gives the status of a specific flag on a buffer.

 *

 * Returns: %TRUE if all flags in @flags are found on @buffer.

 *

 * Since: 1.10

 */

gboolean

gst_buffer_has_flags (GstBuffer * buffer, GstBufferFlags flags)

{

  return GST_BUFFER_FLAG_IS_SET (buffer, flags);

}

/**

 * gst_buffer_set_flags:

 * @buffer: a #GstBuffer

 * @flags: the #GstBufferFlags to set.

 *

 * Sets one or more buffer flags on a buffer.

 *

 * Returns: %TRUE if @flags were successfully set on buffer.

 *

 * Since: 1.10

 */

gboolean

gst_buffer_set_flags (GstBuffer * buffer, GstBufferFlags flags)

{

  GST_BUFFER_FLAG_SET (buffer, flags);

  return TRUE;

}

/**

 * gst_buffer_unset_flags:

 * @buffer: a #GstBuffer

 * @flags: the #GstBufferFlags to clear

 *

 * Clears one or more buffer flags.

 *

 * Returns: true if @flags is successfully cleared from buffer.

 *

 * Since: 1.10

 */

gboolean

gst_buffer_unset_flags (GstBuffer * buffer, GstBufferFlags flags)

{

  GST_BUFFER_FLAG_UNSET (buffer, flags);

  return TRUE;

}

/* transfer full for return and transfer none for @mem */

static inline GstMemory *

_memory_get_exclusive_reference (GstMemory * mem)

{

  GstMemory *ret = NULL;

  if (gst_memory_lock (mem, GST_LOCK_FLAG_EXCLUSIVE)) {

    ret = gst_memory_ref (mem);

  } else {

    /* we cannot take another exclusive lock as the memory is already

     * locked WRITE + EXCLUSIVE according to part-miniobject.txt */

    ret = gst_memory_copy (mem, 0, -1);

    if (ret) {

      if (!gst_memory_lock (ret, GST_LOCK_FLAG_EXCLUSIVE)) {

        gst_memory_unref (ret);

        ret = NULL;

      }

    }

  }

  if (!ret)

    GST_CAT_WARNING (GST_CAT_BUFFER, "Failed to acquire an exclusive lock for "

        "memory %p", mem);

  return ret;

}

static inline void

_memory_add (GstBuffer * buffer, gint idx, GstMemory * mem)

{

  guint i, len = GST_BUFFER_MEM_LEN (buffer);

  GST_CAT_LOG (GST_CAT_BUFFER, "buffer %p, idx %d, mem %p", buffer, idx, mem);

  if (G_UNLIKELY (len >= GST_BUFFER_MEM_MAX)) {

    /* too many buffer, span them. */

    /* FIXME, there is room for improvement here: We could only try to merge

     * 2 buffers to make some room. If we can't efficiently merge 2 buffers we

     * could try to only merge the two smallest buffers to avoid memcpy, etc. */

    GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "memory array overflow in buffer %p",

        buffer);

    _replace_memory (buffer, len, 0, len, _get_merged_memory (buffer, 0, len));

    /* we now have 1 single spanned buffer */

    len = 1;

  }

  if (idx == -1)

    idx = len;

  for (i = len; i > idx; i--) {

    /* move buffers to insert, FIXME, we need to insert first and then merge */

    GST_BUFFER_MEM_PTR (buffer, i) = GST_BUFFER_MEM_PTR (buffer, i - 1);

  }

  /* and insert the new buffer */

  GST_BUFFER_MEM_PTR (buffer, idx) = mem;

  GST_BUFFER_MEM_LEN (buffer) = len + 1;

  GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_TAG_MEMORY);

}

GST_DEFINE_MINI_OBJECT_TYPE (GstBuffer, gst_buffer);

void

_priv_gst_buffer_initialize (void)

{

  _gst_buffer_type = gst_buffer_get_type ();

}

/**

 * gst_buffer_get_max_memory:

 *

 * Get the maximum amount of memory blocks that a buffer can hold. This is a

 * compile time constant that can be queried with the function.

 *

 * When more memory blocks are added, existing memory blocks will be merged

 * together to make room for the new block.

 *

 * Returns: the maximum amount of memory blocks that a buffer can hold.

 *

 * Since: 1.2

 */

guint

gst_buffer_get_max_memory (void)

{

  return GST_BUFFER_MEM_MAX;

}

/**

 * gst_buffer_copy_into:

 * @dest: a destination #GstBuffer

 * @src: a source #GstBuffer

 * @flags: flags indicating what metadata fields should be copied.

 * @offset: offset to copy from

 * @size: total size to copy. If -1, all data is copied.

 *

 * Copies the information from @src into @dest.

 *

 * If @dest already contains memory and @flags contains GST_BUFFER_COPY_MEMORY,

 * the memory from @src will be appended to @dest.

 *

 * @flags indicate which fields will be copied.

 *

 * Returns: %TRUE if the copying succeeded, %FALSE otherwise.

 */

gboolean

gst_buffer_copy_into (GstBuffer * dest, GstBuffer * src,

    GstBufferCopyFlags flags, gsize offset, gsize size)

{

  GstMetaItem *walk;

  gsize bufsize;

  gboolean region = FALSE;

  g_return_val_if_fail (dest != NULL, FALSE);

  g_return_val_if_fail (src != NULL, FALSE);

  /* nothing to copy if the buffers are the same */

  if (G_UNLIKELY (dest == src))

    return TRUE;

  g_return_val_if_fail (gst_buffer_is_writable (dest), FALSE);

  bufsize = gst_buffer_get_size (src);

  g_return_val_if_fail (bufsize >= offset, FALSE);

  if (offset > 0)

    region = TRUE;

  if (size == -1)

    size = bufsize - offset;

  if (size < bufsize)

    region = TRUE;

  g_return_val_if_fail (bufsize >= offset + size, FALSE);

  GST_CAT_LOG (GST_CAT_BUFFER, "copy %p to %p, offset %" G_GSIZE_FORMAT

      "-%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT, src, dest, offset, size,

      bufsize);

  if (flags & GST_BUFFER_COPY_FLAGS) {

    /* copy flags */

    guint flags_mask = ~GST_BUFFER_FLAG_TAG_MEMORY;

    GST_MINI_OBJECT_FLAGS (dest) =

        (GST_MINI_OBJECT_FLAGS (src) & flags_mask) |

        (GST_MINI_OBJECT_FLAGS (dest) & ~flags_mask);

  }

  if (flags & GST_BUFFER_COPY_TIMESTAMPS) {

    if (offset == 0) {

      GST_BUFFER_PTS (dest) = GST_BUFFER_PTS (src);

      GST_BUFFER_DTS (dest) = GST_BUFFER_DTS (src);

      GST_BUFFER_OFFSET (dest) = GST_BUFFER_OFFSET (src);

      if (size == bufsize) {

        GST_BUFFER_DURATION (dest) = GST_BUFFER_DURATION (src);

        GST_BUFFER_OFFSET_END (dest) = GST_BUFFER_OFFSET_END (src);

      }

    } else {

      GST_BUFFER_PTS (dest) = GST_CLOCK_TIME_NONE;

      GST_BUFFER_DTS (dest) = GST_CLOCK_TIME_NONE;

      GST_BUFFER_DURATION (dest) = GST_CLOCK_TIME_NONE;

      GST_BUFFER_OFFSET (dest) = GST_BUFFER_OFFSET_NONE;

      GST_BUFFER_OFFSET_END (dest) = GST_BUFFER_OFFSET_NONE;

    }

  }

  if (flags & GST_BUFFER_COPY_MEMORY) {

    gsize skip, left, len, dest_len, i, bsize;

    gboolean deep;

    deep = flags & GST_BUFFER_COPY_DEEP;

    len = GST_BUFFER_MEM_LEN (src);

    dest_len = GST_BUFFER_MEM_LEN (dest);

    left = size;

    skip = offset;

    /* copy and make regions of the memory */

    for (i = 0; i < len && left > 0; i++) {

      GstMemory *mem = GST_BUFFER_MEM_PTR (src, i);

      bsize = gst_memory_get_sizes (mem, NULL, NULL);

      if (bsize <= skip) {

        /* don't copy buffer */

        skip -= bsize;

      } else {

        GstMemory *newmem = NULL;

        gsize tocopy;

        tocopy = MIN (bsize - skip, left);

        if (tocopy < bsize && !deep && !GST_MEMORY_IS_NO_SHARE (mem)) {

          /* we need to clip something */

          newmem = gst_memory_share (mem, skip, tocopy);

          if (newmem) {

            gst_memory_lock (newmem, GST_LOCK_FLAG_EXCLUSIVE);

            skip = 0;

          }

        }

        if (deep || GST_MEMORY_IS_NO_SHARE (mem) || (!newmem && tocopy < bsize)) {

          /* deep copy or we're not allowed to share this memory

           * between buffers, always copy then */

          newmem = gst_memory_copy (mem, skip, tocopy);

          if (newmem) {

            gst_memory_lock (newmem, GST_LOCK_FLAG_EXCLUSIVE);

            skip = 0;

          }

        } else if (!newmem) {

          newmem = _memory_get_exclusive_reference (mem);

        }

        if (!newmem) {

          gst_buffer_remove_memory_range (dest, dest_len, -1);

          return FALSE;

        }

        _memory_add (dest, -1, newmem);

        left -= tocopy;

      }

    }

    if (flags & GST_BUFFER_COPY_MERGE) {

      GstMemory *mem;

      len = GST_BUFFER_MEM_LEN (dest);

      mem = _get_merged_memory (dest, 0, len);

      if (!mem) {

        gst_buffer_remove_memory_range (dest, dest_len, -1);

        return FALSE;

      }

      _replace_memory (dest, len, 0, len, mem);

    }

  }

  if (flags & GST_BUFFER_COPY_META) {

    /* NOTE: GstGLSyncMeta copying relies on the meta

     *       being copied now, after the buffer data,

     *       so this has to happen last */

    for (walk = GST_BUFFER_META (src); walk; walk = walk->next) {

      GstMeta *meta = &walk->meta;

      const GstMetaInfo *info = meta->info;

      /* Don't copy memory metas if we only copied part of the buffer, didn't

       * copy memories or merged memories. In all these cases the memory

       * structure has changed and the memory meta becomes meaningless.

       */

      if ((region || !(flags & GST_BUFFER_COPY_MEMORY)

              || (flags & GST_BUFFER_COPY_MERGE))

          && gst_meta_api_type_has_tag (info->api, _gst_meta_tag_memory)) {

        GST_CAT_DEBUG (GST_CAT_BUFFER,

            "don't copy memory meta %p of API type %s", meta,

            g_type_name (info->api));

      } else if (info->transform_func) {

        GstMetaTransformCopy copy_data;

        copy_data.region = region;

        copy_data.offset = offset;

        copy_data.size = size;

        if (!info->transform_func (dest, meta, src,

                _gst_meta_transform_copy, &copy_data)) {

          GST_CAT_ERROR (GST_CAT_BUFFER,

              "failed to copy meta %p of API type %s", meta,

              g_type_name (info->api));

        }

      }

    }

  }

  return TRUE;

}

static GstBuffer *

gst_buffer_copy_with_flags (const GstBuffer * buffer, GstBufferCopyFlags flags)

{

  GstBuffer *copy;

  g_return_val_if_fail (buffer != NULL, NULL);

  /* create a fresh new buffer */

  copy = gst_buffer_new ();

  /* copy what the 'flags' want from our parent */

  /* FIXME why we can't pass const to gst_buffer_copy_into() ? */

  if (!gst_buffer_copy_into (copy, (GstBuffer *) buffer, flags, 0, -1))

    gst_buffer_replace (&copy, NULL);

  if (copy)

    GST_BUFFER_FLAG_UNSET (copy, GST_BUFFER_FLAG_TAG_MEMORY);

  return copy;

}

static GstBuffer *

_gst_buffer_copy (const GstBuffer * buffer)

{

  return gst_buffer_copy_with_flags (buffer, GST_BUFFER_COPY_ALL);

}

/**

 * gst_buffer_copy_deep:

 * @buf: a #GstBuffer.

 *

 * Create a copy of the given buffer. This will make a newly allocated

 * copy of the data the source buffer contains.

 *

 * Returns: (transfer full): a new copy of @buf.

 *

 * Since: 1.6

 */

GstBuffer *

gst_buffer_copy_deep (const GstBuffer * buffer)

{

  return gst_buffer_copy_with_flags (buffer,

      GST_BUFFER_COPY_ALL | GST_BUFFER_COPY_DEEP);

}

/* the default dispose function revives the buffer and returns it to the

 * pool when there is a pool */

static gboolean

_gst_buffer_dispose (GstBuffer * buffer)

{

  GstBufferPool *pool;

  /* no pool, do free */

  if ((pool = buffer->pool) == NULL)

    return TRUE;

  /* keep the buffer alive */

  gst_buffer_ref (buffer);

  /* return the buffer to the pool */

  GST_CAT_LOG (GST_CAT_BUFFER, "release %p to pool %p", buffer, pool);

  gst_buffer_pool_release_buffer (pool, buffer);

  return FALSE;

}

static void

_gst_buffer_free (GstBuffer * buffer)

{

  GstMetaItem *walk, *next;

  guint i, len;

  gsize msize;

  g_return_if_fail (buffer != NULL);

  GST_CAT_LOG (GST_CAT_BUFFER, "finalize %p", buffer);

  /* free metadata */

  for (walk = GST_BUFFER_META (buffer); walk; walk = next) {

    GstMeta *meta = &walk->meta;

    const GstMetaInfo *info = meta->info;

    /* call free_func if any */

    if (info->free_func)

      info->free_func (meta, buffer);

    next = walk->next;

    /* and free the slice */

    g_slice_free1 (ITEM_SIZE (info), walk);

  }

  /* get the size, when unreffing the memory, we could also unref the buffer

   * itself */

  msize = GST_BUFFER_SLICE_SIZE (buffer);

  /* free our memory */

  len = GST_BUFFER_MEM_LEN (buffer);

  for (i = 0; i < len; i++) {

    gst_memory_unlock (GST_BUFFER_MEM_PTR (buffer, i), GST_LOCK_FLAG_EXCLUSIVE);

    gst_memory_unref (GST_BUFFER_MEM_PTR (buffer, i));

  }

  /* we set msize to 0 when the buffer is part of the memory block */

  if (msize) {

#ifdef USE_POISONING

    memset (buffer, 0xff, msize);

#endif

    g_slice_free1 (msize, buffer);

  } else {

    gst_memory_unref (GST_BUFFER_BUFMEM (buffer));

  }

}

static void

gst_buffer_init (GstBufferImpl * buffer, gsize size)

{

  gst_mini_object_init (GST_MINI_OBJECT_CAST (buffer), 0, _gst_buffer_type,

      (GstMiniObjectCopyFunction) _gst_buffer_copy,

      (GstMiniObjectDisposeFunction) _gst_buffer_dispose,

      (GstMiniObjectFreeFunction) _gst_buffer_free);

  GST_BUFFER_SLICE_SIZE (buffer) = size;

  GST_BUFFER (buffer)->pool = NULL;

  GST_BUFFER_PTS (buffer) = GST_CLOCK_TIME_NONE;

  GST_BUFFER_DTS (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_MEM_LEN (buffer) = 0;

  GST_BUFFER_META (buffer) = NULL;

}

/**

 * gst_buffer_new:

 *

 * Creates a newly allocated buffer without any data.

 *

 * MT safe.

 *

 * Returns: (transfer full): the new #GstBuffer.

 */

GstBuffer *

gst_buffer_new (void)

{

  GstBufferImpl *newbuf;

  newbuf = g_slice_new (GstBufferImpl);

  GST_CAT_LOG (GST_CAT_BUFFER, "new %p", newbuf);

  gst_buffer_init (newbuf, sizeof (GstBufferImpl));

  return GST_BUFFER_CAST (newbuf);

}

/**

 * gst_buffer_new_allocate:

 * @allocator: (transfer none) (allow-none): the #GstAllocator to use, or %NULL to use the

 *     default allocator

 * @size: the size in bytes of the new buffer's data.

 * @params: (transfer none) (allow-none): optional parameters

 *

 * Tries to create a newly allocated buffer with data of the given size and

 * extra parameters from @allocator. If the requested amount of memory can't be

 * allocated, %NULL will be returned. The allocated buffer memory is not cleared.

 *

 * When @allocator is %NULL, the default memory allocator will be used.

 *

 * Note that when @size == 0, the buffer will not have memory associated with it.

 *

 * MT safe.

 *

 * Returns: (transfer full) (nullable): a new #GstBuffer, or %NULL if

 *     the memory couldn't be allocated.

 */

GstBuffer *

gst_buffer_new_allocate (GstAllocator * allocator, gsize size,

    GstAllocationParams * params)

{

  GstBuffer *newbuf;

  GstMemory *mem;

#if 0

  guint8 *data;

  gsize asize;

#endif

#if 1

  if (size > 0) {

    mem = gst_allocator_alloc (allocator, size, params);

    if (G_UNLIKELY (mem == NULL))

      goto no_memory;

  } else {

    mem = NULL;

  }

  newbuf = gst_buffer_new ();

  if (mem != NULL) {

    gst_memory_lock (mem, GST_LOCK_FLAG_EXCLUSIVE);

    _memory_add (newbuf, -1, mem);

  }

  GST_CAT_LOG (GST_CAT_BUFFER,

      "new buffer %p of size %" G_GSIZE_FORMAT " from allocator %p", newbuf,

      size, allocator);

#endif

#if 0

  asize = sizeof (GstBufferImpl) + size;

  data = g_slice_alloc (asize);

  if (G_UNLIKELY (data == NULL))

    goto no_memory;

  newbuf = GST_BUFFER_CAST (data);

  gst_buffer_init ((GstBufferImpl *) data, asize);

  if (size > 0) {

    mem = gst_memory_new_wrapped (0, data + sizeof (GstBufferImpl), NULL,

        size, 0, size);

    _memory_add (newbuf, -1, mem, TRUE);

  }

#endif

#if 0

  /* allocate memory and buffer, it might be interesting to do this but there

   * are many complications. We need to keep the memory mapped to access the

   * buffer fields and the memory for the buffer might be just very slow. We

   * also need to do some more magic to get the alignment right. */

  asize = sizeof (GstBufferImpl) + size;

  mem = gst_allocator_alloc (allocator, asize, align);