mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-06-05 06:58:56 +00:00
Code Issues 1 Projects Releases Wiki Activity

memory: more work on implementing buffer memory

Browse source
This commit is contained in:
Wim Taymans 2011-03-23 20:52:27 +01:00
parent 1af328e785
commit 38ffe30745
22 changed files with 143 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
gst/gstbuffer.c
View file

@ -196,7 +196,7 @@ gst_buffer_copy_into (GstBuffer * dest, GstBuffer * src,
#if GST_VERSION_NANO == 1 #if GST_VERSION_NANO == 1
/* we enable this extra debugging in git versions only for now */ /* 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 #endif
GST_CAT_LOG (GST_CAT_BUFFER, "copy %p to %p", src, dest); 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 (); newbuf = gst_buffer_new ();
gst_buffer_take_memory (newbuf, gst_memory_new_alloc (size, if (size > 0) {
_gst_buffer_data_alignment)); 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); 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; GstBuffer *newbuf;
GstMemory *mem; GstMemory *mem;
mem = gst_memory_new_alloc (size, _gst_buffer_data_alignment); if (size > 0) {
if (G_UNLIKELY (mem == NULL)) { mem = gst_memory_new_alloc (size, _gst_buffer_data_alignment);
GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size); if (G_UNLIKELY (mem == NULL))
return NULL; goto no_memory;
} else {
mem = NULL;
} }
newbuf = gst_buffer_new (); 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); GST_CAT_LOG (GST_CAT_BUFFER, "new %p of size %d", newbuf, size);
return newbuf; return newbuf;
/* ERRORS */
no_memory:
{
GST_CAT_WARNING (GST_CAT_BUFFER, "failed to allocate %d bytes", size);
return NULL;
}
} }
guint guint
gst_buffer_n_memory (GstBuffer * buffer) 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; return arr->len;
} }
@ -454,8 +471,13 @@ gst_buffer_n_memory (GstBuffer * buffer)
void void
gst_buffer_take_memory (GstBuffer * buffer, GstMemory * mem) 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); g_ptr_array_add (arr, mem);
} }
@ -463,7 +485,11 @@ GstMemory *
gst_buffer_peek_memory (GstBuffer * buffer, guint idx) gst_buffer_peek_memory (GstBuffer * buffer, guint idx)
{ {
GstMemory *mem; 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); mem = g_ptr_array_index (arr, idx);
@ -473,7 +499,12 @@ gst_buffer_peek_memory (GstBuffer * buffer, guint idx)
void void
gst_buffer_remove_memory (GstBuffer * buffer, guint idx) 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); g_ptr_array_remove_index (arr, idx);
} }
@ -484,6 +515,8 @@ gst_buffer_get_size (GstBuffer * buffer)
GPtrArray *arr = (GPtrArray *) buffer->memory; GPtrArray *arr = (GPtrArray *) buffer->memory;
guint i, size, len; guint i, size, len;
g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);
len = arr->len; len = arr->len;
size = 0; size = 0;
@ -498,29 +531,53 @@ gpointer
gst_buffer_map (GstBuffer * buffer, gsize * size, gsize * maxsize, gst_buffer_map (GstBuffer * buffer, gsize * size, gsize * maxsize,
GstMapFlags flags) GstMapFlags flags)
{ {
GPtrArray *arr = (GPtrArray *) buffer->memory; GPtrArray *arr;
guint len; guint len;
gpointer data; gpointer data;
g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL);
arr = (GPtrArray *) buffer->memory;
len = arr->len; len = arr->len;
if (G_UNLIKELY ((flags & GST_MAP_WRITE) && !gst_buffer_is_writable (buffer)))
goto not_writable;
if (G_LIKELY (len == 1)) { if (G_LIKELY (len == 1)) {
GstMemory *mem = g_ptr_array_index (arr, 0); 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); data = gst_memory_map (mem, size, maxsize, flags);
} else { } else {
data = NULL; data = NULL;
} }
return data; return data;
/* ERROR */
not_writable:
{
g_return_val_if_fail (gst_buffer_is_writable (buffer), NULL);
return NULL;
}
} }
gboolean gboolean
gst_buffer_unmap (GstBuffer * buffer, gpointer data, gsize size) gst_buffer_unmap (GstBuffer * buffer, gpointer data, gsize size)
{ {
GPtrArray *arr = (GPtrArray *) buffer->memory; GPtrArray *arr;
gboolean result; gboolean result;
guint len; guint len;
g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
arr = (GPtrArray *) buffer->memory;
len = arr->len; len = arr->len;
if (G_LIKELY (len == 1)) { if (G_LIKELY (len == 1)) {
@ -611,62 +668,13 @@ gst_buffer_set_caps (GstBuffer * buffer, GstCaps * caps)
#if GST_VERSION_NANO == 1 #if GST_VERSION_NANO == 1
/* we enable this extra debugging in git versions only for now */ /* 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 */ /* FIXME: would be nice to also check if caps are fixed here, but expensive */
#endif #endif
gst_caps_replace (&GST_BUFFER_CAPS (buffer), caps); gst_caps_replace (&GST_BUFFER_CAPS (buffer), 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: * gst_buffer_create_sub:
* @parent: a #GstBuffer. * @parent: a #GstBuffer.

7
gst/gstbuffer.h
View file

@ -202,7 +202,6 @@ typedef struct _GstBufferPool GstBufferPool;
/** /**
* GstBufferFlag: * 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. * 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 * @GST_BUFFER_FLAG_PREROLL: the buffer is part of a preroll and should not be
* displayed. * displayed.
@ -223,7 +222,6 @@ typedef struct _GstBufferPool GstBufferPool;
* A set of buffer flags used to describe properties of a #GstBuffer. * A set of buffer flags used to describe properties of a #GstBuffer.
*/ */
typedef enum { typedef enum {
GST_BUFFER_FLAG_READONLY = GST_MINI_OBJECT_FLAG_READONLY,
GST_BUFFER_FLAG_PREROLL = (GST_MINI_OBJECT_FLAG_LAST << 0), GST_BUFFER_FLAG_PREROLL = (GST_MINI_OBJECT_FLAG_LAST << 0),
GST_BUFFER_FLAG_DISCONT = (GST_MINI_OBJECT_FLAG_LAST << 1), GST_BUFFER_FLAG_DISCONT = (GST_MINI_OBJECT_FLAG_LAST << 1),
GST_BUFFER_FLAG_IN_CAPS = (GST_MINI_OBJECT_FLAG_LAST << 2), 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))) #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: * gst_buffer_replace:
* @obuf: (inout) (transfer full): pointer to a pointer to a #GstBuffer to be * @obuf: (inout) (transfer full): pointer to a pointer to a #GstBuffer to be

32
gst/gstmemory.c
View file

@ -47,12 +47,12 @@ static const GstMemoryImpl *_default_mem_impl;
static const GstMemoryImpl *_default_sub_impl; static const GstMemoryImpl *_default_sub_impl;
static void static void
_default_mem_init (GstMemoryDefault * mem, GstMemory * parent, _default_mem_init (GstMemoryDefault * mem, GstMemoryFlags flags,
gsize slice_size, gpointer data, GFreeFunc free_func, GstMemory * parent, gsize slice_size, gpointer data,
gsize maxsize, gsize offset, gsize size) GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
{ {
mem->mem.impl = data ? _default_mem_impl : _default_sub_impl; mem->mem.impl = data ? _default_mem_impl : _default_sub_impl;
mem->mem.flags = 0; mem->mem.flags = flags;
mem->mem.refcount = 1; mem->mem.refcount = 1;
mem->mem.parent = parent ? gst_memory_ref (parent) : NULL; mem->mem.parent = parent ? gst_memory_ref (parent) : NULL;
mem->slice_size = slice_size; mem->slice_size = slice_size;
@ -64,7 +64,7 @@ _default_mem_init (GstMemoryDefault * mem, GstMemory * parent,
} }
static GstMemoryDefault * 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) GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
{ {
GstMemoryDefault *mem; GstMemoryDefault *mem;
@ -73,7 +73,7 @@ _default_mem_new (GstMemory * parent, gpointer data,
slice_size = sizeof (GstMemoryDefault); slice_size = sizeof (GstMemoryDefault);
mem = g_slice_alloc (slice_size); 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); data, free_func, maxsize, offset, size);
return mem; return mem;
@ -98,7 +98,7 @@ _default_mem_new_block (gsize maxsize, gsize align, gsize offset, gsize size)
if ((aoffset = ((guintptr) data & align))) if ((aoffset = ((guintptr) data & align)))
aoffset = align - aoffset; 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); aoffset + offset, size);
return mem; return mem;
@ -213,7 +213,7 @@ _default_mem_sub (GstMemoryDefault * mem, gsize offset, gsize size)
if ((parent = mem->mem.parent) == NULL) if ((parent = mem->mem.parent) == NULL)
parent = (GstMemory *) mem; 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); mem->offset + offset, size);
return sub; return sub;
@ -265,7 +265,7 @@ _fallback_sub (GstMemory * mem, gsize offset, gsize size)
/* find the real parent */ /* find the real parent */
parent = mem->parent ? mem->parent : mem; 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 (GstMemory *) sub;
} }
@ -458,7 +458,11 @@ gst_memory_is_span (GstMemory ** mem1, gsize len1, GstMemory ** mem2,
return FALSE; return FALSE;
if (!have_offset) { if (!have_offset) {
*offset = offs; if (offset)
*offset = offs;
if (parent)
*parent = m1->parent;
have_offset = TRUE; have_offset = TRUE;
} }
} }
@ -517,12 +521,12 @@ gst_memory_span (GstMemory ** mem1, gsize len1, gsize offset, GstMemory ** mem2,
} }
GstMemory * GstMemory *
gst_memory_new_wrapped (gpointer data, GFreeFunc free_func, gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data,
gsize maxsize, gsize offset, gsize size) GFreeFunc free_func, gsize maxsize, gsize offset, gsize size)
{ {
GstMemoryDefault *mem; 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; return (GstMemory *) mem;
} }
@ -532,7 +536,7 @@ gst_memory_new_alloc (gsize maxsize, gsize align)
{ {
GstMemoryDefault *mem; GstMemoryDefault *mem;
mem = _default_mem_new_block (maxsize, align, 0, 0); mem = _default_mem_new_block (maxsize, align, 0, maxsize);
return (GstMemory *) mem; return (GstMemory *) mem;
} }

10
gst/gstmemory.h
View file

@ -34,10 +34,14 @@ typedef struct _GstMemoryInfo GstMemoryInfo;
typedef struct _GstMemoryImpl GstMemoryImpl; typedef struct _GstMemoryImpl GstMemoryImpl;
typedef enum { typedef enum {
GST_MEMORY_FLAG_READONLY = (1 << 0), GST_MEMORY_FLAG_READONLY = (1 << 0)
GST_MEMORY_FLAG_MUTABLE = (1 << 1),
} GstMemoryFlags; } 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: * GstMemory:
* @impl: pointer to the #GstMemoryImpl * @impl: pointer to the #GstMemoryImpl
@ -104,7 +108,7 @@ struct _GstMemoryInfo {
void _gst_memory_init (void); void _gst_memory_init (void);
/* allocating memory blocks */ /* 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); gsize maxsize, gsize offset, gsize size);
GstMemory * gst_memory_new_alloc (gsize maxsize, gsize align); GstMemory * gst_memory_new_alloc (gsize maxsize, gsize align);
GstMemory * gst_memory_new_copy (gsize maxsize, gsize align, gpointer data, GstMemory * gst_memory_new_copy (gsize maxsize, gsize align, gpointer data,

3
gst/gstminiobject.c
View file

@ -154,8 +154,7 @@ gst_mini_object_is_writable (const GstMiniObject * mini_object)
{ {
g_return_val_if_fail (mini_object != NULL, FALSE); g_return_val_if_fail (mini_object != NULL, FALSE);
return (GST_MINI_OBJECT_REFCOUNT_VALUE (mini_object) == 1) && return (GST_MINI_OBJECT_REFCOUNT_VALUE (mini_object) == 1);
((mini_object->flags & GST_MINI_OBJECT_FLAG_READONLY) == 0);
} }
/** /**

2
gst/gstminiobject.h
View file

@ -106,14 +106,12 @@ typedef void (*GstMiniObjectFreeFunction) (GstMiniObject *obj);
/** /**
* GstMiniObjectFlags: * 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. * @GST_MINI_OBJECT_FLAG_LAST: first flag that can be used by subclasses.
* *
* Flags for the mini object * Flags for the mini object
*/ */
typedef enum typedef enum
{ {
GST_MINI_OBJECT_FLAG_READONLY = (1<<0),
/* padding */ /* padding */
GST_MINI_OBJECT_FLAG_LAST = (1<<4) GST_MINI_OBJECT_FLAG_LAST = (1<<4)
} GstMiniObjectFlags; } GstMiniObjectFlags;

4
libs/gst/base/gstadapter.c
View file

@ -736,8 +736,8 @@ gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
data = gst_adapter_take_internal (adapter, nbytes); data = gst_adapter_take_internal (adapter, nbytes);
buffer = gst_buffer_new (); buffer = gst_buffer_new ();
gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, g_free, nbytes, gst_buffer_take_memory (buffer,
0, nbytes)); gst_memory_new_wrapped (0, data, g_free, nbytes, 0, nbytes));
done: done:
gst_adapter_flush_unchecked (adapter, nbytes); gst_adapter_flush_unchecked (adapter, nbytes);

6
libs/gst/base/gstbasesrc.c
View file

@ -2153,13 +2153,13 @@ again:
/* no timestamp set and we are at offset 0, we can timestamp with 0 */ /* no timestamp set and we are at offset 0, we can timestamp with 0 */
if (offset == 0 && src->segment.time == 0 if (offset == 0 && src->segment.time == 0
&& GST_BUFFER_TIMESTAMP (*buf) == -1) { && GST_BUFFER_TIMESTAMP (*buf) == -1) {
*buf = gst_buffer_make_metadata_writable (*buf); *buf = gst_buffer_make_writable (*buf);
GST_BUFFER_TIMESTAMP (*buf) = 0; GST_BUFFER_TIMESTAMP (*buf) = 0;
} }
/* set pad caps on the buffer if the buffer had no caps */ /* set pad caps on the buffer if the buffer had no caps */
if (GST_BUFFER_CAPS (*buf) == NULL) { 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)); 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)) { 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); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
src->priv->discont = FALSE; src->priv->discont = FALSE;
} }

10
libs/gst/base/gstbasetransform.c
View file

@ -1459,7 +1459,7 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
if (othercaps && !gst_caps_is_empty (othercaps)) { if (othercaps && !gst_caps_is_empty (othercaps)) {
GST_DEBUG_OBJECT (trans, "we found target caps %" GST_PTR_FORMAT, GST_DEBUG_OBJECT (trans, "we found target caps %" GST_PTR_FORMAT,
othercaps); 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_buffer_set_caps (*out_buf, othercaps);
gst_caps_unref (othercaps); gst_caps_unref (othercaps);
newcaps = GST_BUFFER_CAPS (*out_buf); newcaps = GST_BUFFER_CAPS (*out_buf);
@ -1487,7 +1487,7 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
GST_DEBUG_PAD_NAME (trans->srcpad)); GST_DEBUG_PAD_NAME (trans->srcpad));
bclass->fixate_caps (trans, GST_PAD_SINK, incaps, newcaps); 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_buffer_set_caps (*out_buf, newcaps);
gst_caps_unref (newcaps); gst_caps_unref (newcaps);
newcaps = GST_BUFFER_CAPS (*out_buf); newcaps = GST_BUFFER_CAPS (*out_buf);
@ -1596,12 +1596,12 @@ gst_base_transform_prepare_output_buffer (GstBaseTransform * trans,
if (setcaps || copymeta) { if (setcaps || copymeta) {
GST_DEBUG_OBJECT (trans, "setcaps %d, copymeta %d", 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); GST_DEBUG_OBJECT (trans, "buffer metadata %p not writable", *out_buf);
if (in_buf == *out_buf) if (in_buf == *out_buf)
*out_buf = gst_buffer_create_sub (in_buf, 0, insize); *out_buf = gst_buffer_create_sub (in_buf, 0, insize);
else 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 */ /* when we get here, the metadata should be writable */
if (setcaps) 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 */ /* apply DISCONT flag if the buffer is not yet marked as such */
if (trans->priv->discont) { if (trans->priv->discont) {
if (!GST_BUFFER_IS_DISCONT (outbuf)) { 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); GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
} }
trans->priv->discont = FALSE; trans->priv->discont = FALSE;

4
libs/gst/base/gstbytewriter.c
View file

@ -259,8 +259,8 @@ gst_byte_writer_reset_and_get_buffer (GstByteWriter * writer)
data = gst_byte_writer_reset_and_get_data (writer); data = gst_byte_writer_reset_and_get_data (writer);
buffer = gst_buffer_new (); buffer = gst_buffer_new ();
gst_buffer_take_memory (buffer, gst_memory_new_wrapped (data, g_free, size, 0, gst_buffer_take_memory (buffer,
size)); gst_memory_new_wrapped (0, data, g_free, size, 0, size));
return buffer; return buffer;
} }

4
plugins/elements/gstcapsfilter.c
View file

@ -334,7 +334,7 @@ gst_capsfilter_prepare_buf (GstBaseTransform * trans, GstBuffer * input,
if (GST_BUFFER_CAPS (input) != caps) { if (GST_BUFFER_CAPS (input) != caps) {
/* caps are different, make a metadata writable output buffer to set /* caps are different, make a metadata writable output buffer to set
* caps */ * 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 */ /* input is writable, just set caps and use this as the output */
*buf = input; *buf = input;
gst_buffer_set_caps (*buf, caps); 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)) { if (gst_caps_is_fixed (out_caps) && !gst_caps_is_empty (out_caps)) {
GST_DEBUG_OBJECT (trans, "Have fixed output caps %" GST_DEBUG_OBJECT (trans, "Have fixed output caps %"
GST_PTR_FORMAT " to apply to buffer with no caps", out_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); gst_buffer_ref (input);
*buf = input; *buf = input;
} else { } else {

4
plugins/elements/gstfakesrc.c
View file

@ -691,8 +691,8 @@ gst_fake_src_alloc_buffer (GstFakeSrc * src, guint size)
if (do_prepare) if (do_prepare)
gst_fake_src_prepare_buffer (src, data, size); gst_fake_src_prepare_buffer (src, data, size);
gst_buffer_take_memory (buf, gst_memory_new_wrapped (data, g_free, size, 0, gst_buffer_take_memory (buf,
size)); gst_memory_new_wrapped (0, data, g_free, size, 0, size));
} }
return buf; return buf;

4
plugins/elements/gstidentity.c
View file

@ -394,13 +394,13 @@ gst_identity_prepare_output_buffer (GstBaseTransform * trans,
/* only bother if we may have to alter metadata */ /* only bother if we may have to alter metadata */
if (identity->datarate > 0 || identity->single_segment) { 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); *out_buf = gst_buffer_ref (in_buf);
else { else {
/* make even less writable */ /* make even less writable */
gst_buffer_ref (in_buf); gst_buffer_ref (in_buf);
/* extra ref is dropped going through the official process */ /* 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 } else
*out_buf = gst_buffer_ref (in_buf); *out_buf = gst_buffer_ref (in_buf);

2
plugins/elements/gstinputselector.c
View file

@ -659,7 +659,7 @@ gst_selector_pad_chain (GstPad * pad, GstBuffer * buf)
gst_pad_push_event (sel->srcpad, start_event); gst_pad_push_event (sel->srcpad, start_event);
if (selpad->discont) { 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_DEBUG_OBJECT (pad, "Marking discont buffer %p", buf);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);

4
plugins/elements/gstqueue.c
View file

@ -1008,7 +1008,7 @@ gst_queue_chain (GstPad * pad, GstBuffer * buffer)
} }
if (queue->tail_needs_discont) { if (queue->tail_needs_discont) {
GstBuffer *subbuffer = gst_buffer_make_metadata_writable (buffer); GstBuffer *subbuffer = gst_buffer_make_writable (buffer);
if (subbuffer) { if (subbuffer) {
buffer = subbuffer; buffer = subbuffer;
@ -1109,7 +1109,7 @@ next:
buffer = GST_BUFFER_CAST (data); buffer = GST_BUFFER_CAST (data);
if (queue->head_needs_discont) { if (queue->head_needs_discont) {
GstBuffer *subbuffer = gst_buffer_make_metadata_writable (buffer); GstBuffer *subbuffer = gst_buffer_make_writable (buffer);
if (subbuffer) { if (subbuffer) {
buffer = subbuffer; buffer = subbuffer;

6
plugins/elements/gsttypefindelement.c
View file

@ -488,7 +488,7 @@ stop_typefinding (GstTypeFindElement * typefind)
goto no_data; goto no_data;
buffer = gst_adapter_take_buffer (typefind->adapter, avail); 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_buffer_set_caps (buffer, typefind->caps);
GST_OBJECT_UNLOCK (typefind); GST_OBJECT_UNLOCK (typefind);
@ -636,7 +636,7 @@ gst_type_find_element_setcaps (GstPad * pad, GstCaps * caps)
goto no_data; goto no_data;
buffer = gst_adapter_take_buffer (typefind->adapter, avail); 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_buffer_set_caps (buffer, typefind->caps);
GST_OBJECT_UNLOCK (typefind); GST_OBJECT_UNLOCK (typefind);
@ -752,7 +752,7 @@ gst_type_find_element_chain (GstPad * pad, GstBuffer * buffer)
return GST_FLOW_ERROR; return GST_FLOW_ERROR;
case MODE_NORMAL: case MODE_NORMAL:
/* don't take object lock as typefind->caps should not change anymore */ /* 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); gst_buffer_set_caps (buffer, typefind->caps);
return gst_pad_push (typefind->src, buffer); return gst_pad_push (typefind->src, buffer);
case MODE_TYPEFIND: case MODE_TYPEFIND:

2
plugins/elements/gstvalve.c
View file

@ -182,7 +182,7 @@ gst_valve_chain (GstPad * pad, GstBuffer * buffer)
valve->discont = TRUE; valve->discont = TRUE;
} else { } else {
if (valve->discont) { 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); GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
valve->discont = FALSE; valve->discont = FALSE;
} }

52
tests/check/gst/gstbuffer.c
View file

@ -86,7 +86,7 @@ GST_START_TEST (test_subbuffer)
/* check sizes, buffer starts out empty */ /* check sizes, buffer starts out empty */
data = gst_buffer_map (buffer, &size, &maxsize, GST_MAP_WRITE); 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"); fail_unless (maxsize >= 4, "buffer has wrong size");
memset (data, 0, 4); memset (data, 0, 4);
gst_buffer_unmap (buffer, data, 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 (ssize == 2, "subbuffer has wrong size");
fail_unless (memcmp (data + 1, sdata, 2) == 0, fail_unless (memcmp (data + 1, sdata, 2) == 0,
"subbuffer contains the wrong data"); "subbuffer contains the wrong data");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1); ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1, fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
"subbuffer has wrong timestamp"); "subbuffer has wrong timestamp");
@ -123,7 +122,6 @@ GST_START_TEST (test_subbuffer)
fail_unless (ssize == 0, "subbuffer has wrong size"); fail_unless (ssize == 0, "subbuffer has wrong size");
fail_unless (memcmp (data + 1, sdata, 0) == 0, fail_unless (memcmp (data + 1, sdata, 0) == 0,
"subbuffer contains the wrong data"); "subbuffer contains the wrong data");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1); ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
gst_buffer_unmap (sub, sdata, ssize); gst_buffer_unmap (sub, sdata, ssize);
gst_buffer_unref (sub); gst_buffer_unref (sub);
@ -293,11 +291,10 @@ create_read_only_buffer (void)
/* assign some read-only data to the new buffer */ /* assign some read-only data to the new buffer */
gst_buffer_take_memory (buf, 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))); sizeof (ro_memory), 0, sizeof (ro_memory)));
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
return buf; return buf;
} }
@ -309,11 +306,7 @@ GST_START_TEST (test_make_writable)
/* create read-only buffer and make it writable */ /* create read-only buffer and make it writable */
buf = create_read_only_buffer (); 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 = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
data[4] = 'a'; data[4] = 'a';
gst_buffer_unmap (buf, data, size); 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 */ /* alloc'ed buffer with refcount 1 should be writable */
buf = gst_buffer_new_and_alloc (32); 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); buf2 = gst_buffer_make_writable (buf);
fail_unless (buf == buf2, fail_unless (buf == buf2,
"_make_writable() should have returned same buffer"); "_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 */ /* alloc'ed buffer with refcount >1 should be copied */
buf = gst_buffer_new_and_alloc (32); 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); gst_buffer_ref (buf);
buf2 = gst_buffer_make_writable (buf); buf2 = gst_buffer_make_writable (buf);
fail_unless (buf != buf2, "_make_writable() should have returned a copy!"); 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 */ /* create sub-buffer of read-only buffer and make it writable */
buf = create_read_only_buffer (); 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); 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); data = gst_buffer_map (sub_buf, &size, NULL, GST_MAP_WRITE);
fail_if (data == NULL);
data[4] = 'a'; data[4] = 'a';
gst_buffer_unmap (sub_buf, data, size); gst_buffer_unmap (sub_buf, data, size);
gst_buffer_unref (sub_buf); 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); GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
/* Buffer with refcount 1 should have writable metadata */ /* 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 */ /* Check that a buffer with refcount 2 does not have writable metadata */
gst_buffer_ref (buffer); gst_buffer_ref (buffer);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2); 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 /* Check that make_metadata_writable produces a new sub-buffer with
* writable metadata. */ * writable metadata. */
sub1 = gst_buffer_make_metadata_writable (buffer); sub1 = gst_buffer_make_writable (buffer);
fail_if (sub1 == buffer); fail_if (sub1 == buffer);
fail_unless (gst_buffer_is_metadata_writable (sub1) == TRUE); fail_unless (gst_buffer_is_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);
/* Check that make_metadata_writable() maintains the buffer flags */ /* Check that make_metadata_writable() maintains the buffer flags */
fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT)); 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 */ /* Drop the subbuffer and check that the metadata is now writable again */
ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1); ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
gst_buffer_unref (sub1); 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); ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
gst_buffer_unref (buffer); gst_buffer_unref (buffer);
@ -430,11 +407,13 @@ GST_START_TEST (test_copy)
copy = gst_buffer_copy (buffer); copy = gst_buffer_copy (buffer);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1); ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
ASSERT_BUFFER_REFCOUNT (copy, "copy", 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); data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
sdata = gst_buffer_map (copy, &ssize, 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); fail_unless (size == ssize);
gst_buffer_unmap (copy, sdata, ssize); gst_buffer_unmap (copy, sdata, ssize);
@ -447,7 +426,6 @@ GST_START_TEST (test_copy)
buffer = gst_buffer_new_and_alloc (0); buffer = gst_buffer_new_and_alloc (0);
data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ); data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL); fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (buffer, data, size); gst_buffer_unmap (buffer, data, size);
/* copying a 0-sized buffer should not crash and also set /* 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); copy = gst_buffer_copy (buffer);
data = gst_buffer_map (copy, &size, NULL, GST_MAP_READ); data = gst_buffer_map (copy, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL); fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (copy, data, size); gst_buffer_unmap (copy, data, size);
gst_buffer_unref (copy); gst_buffer_unref (copy);
@ -476,7 +453,6 @@ GST_START_TEST (test_try_new_and_alloc)
fail_unless (GST_IS_BUFFER (buf)); fail_unless (GST_IS_BUFFER (buf));
data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ); data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL); fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (buf, data, size); gst_buffer_unmap (buf, data, size);
gst_buffer_unref (buf); gst_buffer_unref (buf);

7
tests/check/gst/gstminiobject.c
View file

@ -49,13 +49,6 @@ GST_START_TEST (test_is_writable)
fail_unless (gst_mini_object_is_writable (mobj), fail_unless (gst_mini_object_is_writable (mobj),
"A buffer with one ref should be writable"); "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_ref (mobj) == NULL, "Could not ref the mobj");
fail_if (gst_mini_object_is_writable (mobj), fail_if (gst_mini_object_is_writable (mobj),

3
tests/check/libs/bitreader.c
View file

@ -49,7 +49,8 @@ GST_START_TEST (test_initialization)
guint8 *bdata; guint8 *bdata;
gsize bsize; 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 (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
fail_unless_equals_int (x, 0x01); fail_unless_equals_int (x, 0x01);

3
tests/check/libs/bytereader.c
View file

@ -49,7 +49,8 @@ GST_START_TEST (test_initialization)
guint8 *bdata; guint8 *bdata;
gsize bsize; 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 (gst_byte_reader_get_uint8 (&reader, &x));
fail_unless_equals_int (x, 0x01); fail_unless_equals_int (x, 0x01);

4
tests/check/libs/typefindhelper.c
View file

@ -56,8 +56,8 @@ GST_START_TEST (test_buffer_range)
fail_unless (buf != NULL); fail_unless (buf != NULL);
gst_buffer_take_memory (buf, gst_buffer_take_memory (buf,
gst_memory_new_wrapped ((gpointer) vorbisid, NULL, 30, 0, 30)); gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY,
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY); (gpointer) vorbisid, NULL, 30, 0, 30));
caps = gst_type_find_helper_for_buffer (NULL, buf, NULL); caps = gst_type_find_helper_for_buffer (NULL, buf, NULL);
fail_unless (caps != NULL); fail_unless (caps != NULL);