#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);
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);
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;
}
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);
}
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);
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);
}
GPtrArray *arr = (GPtrArray *) buffer->memory;
guint i, size, len;
+ g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);
+
len = arr->len;
size = 0;
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)) {
#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
}
/**
- * 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
/**
* 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.
* 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),
*/
#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
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;
}
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;
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;
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;
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;
/* 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;
}
return FALSE;
if (!have_offset) {
- *offset = offs;
+ if (offset)
+ *offset = offs;
+ if (parent)
+ *parent = m1->parent;
+
have_offset = TRUE;
}
}
}
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;
}
{
GstMemoryDefault *mem;
- mem = _default_mem_new_block (maxsize, align, 0, 0);
+ mem = _default_mem_new_block (maxsize, align, 0, maxsize);
return (GstMemory *) mem;
}
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
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,
{
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);
}
/**
/**
* 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;
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);
/* 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));
}
}
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;
}
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);
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);
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)
/* 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;
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;
}
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);
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 {
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;
/* 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);
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);
}
if (queue->tail_needs_discont) {
- GstBuffer *subbuffer = gst_buffer_make_metadata_writable (buffer);
+ GstBuffer *subbuffer = gst_buffer_make_writable (buffer);
if (subbuffer) {
buffer = subbuffer;
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;
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);
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);
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:
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;
}
/* 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);
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");
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);
/* 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;
}
/* 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);
/* 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");
/* 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!");
/* 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);
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));
/* 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);
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);
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
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);
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);
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),
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);
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);
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);
projects / platform / upstream / gstreamer.git / commitdiff