From c6a1bed1ad18c32c7433c3824975d735952540de Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Mon, 13 Feb 2012 16:33:00 +0100 Subject: [PATCH] memory: more work on refcount and writability Rename _is_writable() with _is_exclusive because the writability does not depend on the amount of references to the memory object anymore. Add accessor macros for the memory flags. Rename the GstBuffer _peek_memory() method to _get_memory() and return a reference to the memory now that we can do this without affecting writability of the memory object. Make it possible to also make this function merge the buffer memory. Add methods to replace memory in a buffer. Make some convience macros for the buffer memory functions. Fix unit tests. --- gst/gstbuffer.c | 208 +++++++++++++++++----------------- gst/gstbuffer.h | 11 +- gst/gstmemory.c | 43 ++++--- gst/gstmemory.h | 54 ++++++--- tests/check/gst/gstbuffer.c | 3 +- tests/check/gst/gstmemory.c | 9 +- win32/common/libgstreamer.def | 5 +- 7 files changed, 181 insertions(+), 152 deletions(-) diff --git a/gst/gstbuffer.c b/gst/gstbuffer.c index 3eb0f65960..d9304cdb2c 100644 --- a/gst/gstbuffer.c +++ b/gst/gstbuffer.c @@ -172,17 +172,46 @@ _span_memory (GstBuffer * buffer, gsize offset, gsize size, gboolean writable) return span; } +static GstMemory * +_get_merged_memory (GstBuffer * buffer) +{ + guint len; + GstMemory *mem; + + len = GST_BUFFER_MEM_LEN (buffer); + + if (G_UNLIKELY (len == 0)) { + /* no memory */ + mem = NULL; + } else if (G_LIKELY (len == 1)) { + /* we can take the first one */ + mem = GST_BUFFER_MEM_PTR (buffer, 0); + gst_memory_ref (mem); + } else { + /* we need to span memory */ + mem = _span_memory (buffer, 0, -1, FALSE); + } + return mem; +} + static void -_replace_memory (GstBuffer * buffer, GstMemory * mem) +_replace_all_memory (GstBuffer * buffer, GstMemory * mem) { gsize len, i; len = GST_BUFFER_MEM_LEN (buffer); - /* unref old buffers */ + + if (G_LIKELY (len == 1 && GST_BUFFER_MEM_PTR (buffer, 0) == mem)) { + gst_memory_unref (mem); + return; + } + + GST_LOG ("buffer %p replace with memory %p", buffer, mem); + + /* unref old memory */ for (i = 0; i < len; i++) gst_memory_unref (GST_BUFFER_MEM_PTR (buffer, i)); - - /* replace with single spanned buffer */ + /* replace with single memory */ GST_BUFFER_MEM_PTR (buffer, 0) = mem; GST_BUFFER_MEM_LEN (buffer) = 1; } @@ -199,7 +228,7 @@ _memory_add (GstBuffer * buffer, guint idx, GstMemory * mem) * 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, _span_memory (buffer, 0, -1, FALSE)); + _replace_all_memory (buffer, _span_memory (buffer, 0, -1, FALSE)); /* we now have 1 single spanned buffer */ len = 1; } @@ -321,7 +350,7 @@ gst_buffer_copy_into (GstBuffer * dest, GstBuffer * src, } } if (flags & GST_BUFFER_COPY_MERGE) { - _replace_memory (dest, _span_memory (dest, 0, size, FALSE)); + _replace_all_memory (dest, _span_memory (dest, 0, size, FALSE)); } } @@ -584,7 +613,7 @@ gst_buffer_new_wrapped_full (gpointer data, GFreeFunc free_func, gsize offset, GstBuffer *newbuf; newbuf = gst_buffer_new (); - gst_buffer_take_memory (newbuf, -1, + gst_buffer_append_memory (newbuf, gst_memory_new_wrapped (free_func ? 0 : GST_MEMORY_FLAG_READONLY, data, free_func, offset + size, offset, size)); @@ -647,67 +676,79 @@ gst_buffer_take_memory (GstBuffer * buffer, gint idx, GstMemory * mem) } static GstMemory * -_get_memory (GstBuffer * buffer, guint idx, gboolean write) +_get_mapped (GstBuffer * buffer, guint idx, GstMapInfo * info, + GstMapFlags flags) { - GstMemory *mem; + GstMemory *mem, *mapped; mem = GST_BUFFER_MEM_PTR (buffer, idx); - if (G_UNLIKELY (write && !gst_memory_is_writable (mem))) { - GstMemory *copy; - GST_CAT_LOG (GST_CAT_BUFFER, - "making writable copy of memory %p in buffer %p", mem, buffer); - /* replace with a writable copy */ - copy = gst_memory_copy (mem, 0, -1); - GST_BUFFER_MEM_PTR (buffer, idx) = copy; + mapped = gst_memory_make_mapped (mem, info, flags); + if (!mapped) + return NULL; + + if (mapped != mem) { + GST_BUFFER_MEM_PTR (buffer, idx) = mapped; gst_memory_unref (mem); - mem = copy; + mem = mapped; } return mem; } /** - * gst_buffer_peek_memory: + * gst_buffer_get_memory: * @buffer: a #GstBuffer. * @idx: an index - * @flags: #GstMapFlags * - * Get the memory block in @buffer at @idx for memory access in @flags. - * This function does not return a refcount to the memory block. The memory - * block stays valid for as long as the caller has a valid reference to @buffer - * and as long as no operations that modify the memory blocks are called, such - * as gst_buffer_remove_memory_range(), gst_buffer_take_memory() and gst_buffer_resize(). + * Get the memory block in @buffer at @idx. If @idx is -1, all memory is merged + * into one large #GstMemory object that is then returned. * - * @buffer should be writable when @flags contains #GST_MAP_WRITE. If the memory - * at @idx is not writable, a new writable copy will be installed in @buffer and - * returned. - * - * Returns: a #GstMemory at @idx. + * Returns: (transfer full): a #GstMemory at @idx. Use gst_memory_unref () after usage. */ GstMemory * -gst_buffer_peek_memory (GstBuffer * buffer, guint idx, GstMapFlags flags) +gst_buffer_get_memory (GstBuffer * buffer, gint idx) { GstMemory *mem; - gboolean write; - - write = (flags & GST_MAP_WRITE) != 0; g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL); - g_return_val_if_fail (idx < GST_BUFFER_MEM_LEN (buffer), NULL); - - /* check if we can write when asked for write access */ - if (G_UNLIKELY (write && !gst_buffer_is_writable (buffer))) - goto not_writable; - - mem = _get_memory (buffer, idx, write); + g_return_val_if_fail (idx == -1 || + (idx >= 0 && idx <= GST_BUFFER_MEM_LEN (buffer)), NULL); + if (idx == -1) { + mem = _get_merged_memory (buffer); + } else if ((mem = GST_BUFFER_MEM_PTR (buffer, idx))) { + gst_memory_ref (mem); + } return mem; +} - /* ERRORS */ -not_writable: - { - g_return_val_if_fail (gst_buffer_is_writable (buffer), NULL); - return NULL; +/** + * gst_buffer_replace_memory: + * @buffer: a #GstBuffer. + * @idx: an index + * @mem: (transfer full): a #GstMemory + * + * Replaces the memory block in @buffer at @idx with @mem. If @idx is -1, all + * memory will be removed and replaced with @mem. + * + * @buffer should be writable. + */ +void +gst_buffer_replace_memory (GstBuffer * buffer, gint idx, GstMemory * mem) +{ + g_return_if_fail (GST_IS_BUFFER (buffer)); + g_return_if_fail (gst_buffer_is_writable (buffer)); + g_return_if_fail (idx == -1 || + (idx >= 0 && idx < GST_BUFFER_MEM_LEN (buffer))); + + if (idx == -1) { + _replace_all_memory (buffer, mem); + } else { + GstMemory *old; + + if ((old = GST_BUFFER_MEM_PTR (buffer, idx))) + gst_memory_unref (old); + GST_BUFFER_MEM_PTR (buffer, idx) = mem; } } @@ -722,7 +763,7 @@ not_writable: * @length can be -1, in which case all memory starting from @idx is removed. */ void -gst_buffer_remove_memory_range (GstBuffer * buffer, guint idx, guint length) +gst_buffer_remove_memory_range (GstBuffer * buffer, guint idx, gint length) { guint len, i, end; @@ -730,10 +771,10 @@ gst_buffer_remove_memory_range (GstBuffer * buffer, guint idx, guint length) g_return_if_fail (gst_buffer_is_writable (buffer)); len = GST_BUFFER_MEM_LEN (buffer); - if (length == -1) { - g_return_if_fail (idx < len); + g_return_if_fail ((length == -1 && idx < len) || length + idx < len); + + if (length == -1) length = len - idx; - } end = idx + length; for (i = idx; i < end; i++) @@ -746,42 +787,6 @@ gst_buffer_remove_memory_range (GstBuffer * buffer, guint idx, guint length) GST_BUFFER_MEM_LEN (buffer) = len - length; } -/** - * gst_buffer_get_merged_memory: - * @buffer: a #GstBuffer. - * - * Return a #GstMemory object that contains all the memory in @buffer. If there - * was only one memory in @buffer, it will be returned directly, otherwise all - * memory objects will be merged into one object that will be returned. - * - * Returns: a #GstMemory with the merged memory in @buffer. This function can - * return %NULL if there is no memory in @buffer. Use gst_memory_unref() after - * usage. - */ -static GstMemory * -gst_buffer_get_merged_memory (GstBuffer * buffer) -{ - guint len; - GstMemory *mem; - - g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL); - - len = GST_BUFFER_MEM_LEN (buffer); - - if (G_UNLIKELY (len == 0)) { - /* no memory */ - mem = NULL; - } else if (G_LIKELY (len == 1)) { - /* we can take the first one */ - mem = GST_BUFFER_MEM_PTR (buffer, 0); - gst_memory_ref (mem); - } else { - /* we need to span memory */ - mem = _span_memory (buffer, 0, -1, FALSE); - } - return mem; -} - /** * gst_buffer_get_sizes: * @buffer: a #GstBuffer. @@ -904,8 +909,7 @@ gst_buffer_resize (GstBuffer * buffer, gssize offset, gssize size) left = MIN (bsize - offset, size); if (offset != 0 || left != bsize) { - /* we need to clip something */ - if (gst_memory_is_writable (mem)) { + if (gst_memory_is_exclusive (mem)) { gst_memory_resize (mem, offset, left); } else { GstMemory *tmp; @@ -963,7 +967,7 @@ gst_buffer_map (GstBuffer * buffer, GstMapInfo * info, GstMapFlags flags) if (G_UNLIKELY (write && !writable)) goto not_writable; - mem = gst_buffer_get_merged_memory (buffer); + mem = _get_merged_memory (buffer); if (G_UNLIKELY (mem == NULL)) goto no_memory; @@ -973,11 +977,13 @@ gst_buffer_map (GstBuffer * buffer, GstMapInfo * info, GstMapFlags flags) goto cannot_map; /* if the buffer is writable, replace the memory */ - if (writable) - _replace_memory (buffer, gst_memory_ref (mem)); - else if (GST_BUFFER_MEM_LEN (buffer) > 1) { - GST_CAT_DEBUG (GST_CAT_PERFORMANCE, - "temporary mapping for memory %p in buffer %p", mem, buffer); + if (writable) { + _replace_all_memory (buffer, gst_memory_ref (mem)); + } else { + if (GST_BUFFER_MEM_LEN (buffer) > 1) { + GST_CAT_DEBUG (GST_CAT_PERFORMANCE, + "temporary mapping for memory %p in buffer %p", mem, buffer); + } } return TRUE; @@ -1056,9 +1062,7 @@ gst_buffer_fill (GstBuffer * buffer, gsize offset, gconstpointer src, gsize tocopy; GstMemory *mem; - mem = _get_memory (buffer, i, TRUE); - - gst_memory_map (mem, &info, GST_MAP_WRITE); + mem = _get_mapped (buffer, i, &info, GST_MAP_WRITE); if (info.size > offset) { /* we have enough */ tocopy = MIN (info.size - offset, left); @@ -1104,9 +1108,7 @@ gst_buffer_extract (GstBuffer * buffer, gsize offset, gpointer dest, gsize size) gsize tocopy; GstMemory *mem; - mem = GST_BUFFER_MEM_PTR (buffer, i); - - gst_memory_map (mem, &info, GST_MAP_READ); + mem = _get_mapped (buffer, i, &info, GST_MAP_READ); if (info.size > offset) { /* we have enough */ tocopy = MIN (info.size - offset, left); @@ -1152,9 +1154,7 @@ gst_buffer_memcmp (GstBuffer * buffer, gsize offset, gconstpointer mem, gsize tocmp; GstMemory *mem; - mem = GST_BUFFER_MEM_PTR (buffer, i); - - gst_memory_map (mem, &info, GST_MAP_READ); + mem = _get_mapped (buffer, i, &info, GST_MAP_READ); if (info.size > offset) { /* we have enough */ tocmp = MIN (info.size - offset, size); @@ -1199,9 +1199,7 @@ gst_buffer_memset (GstBuffer * buffer, gsize offset, guint8 val, gsize size) gsize toset; GstMemory *mem; - mem = _get_memory (buffer, i, TRUE); - - gst_memory_map (mem, &info, GST_MAP_WRITE); + mem = _get_mapped (buffer, i, &info, GST_MAP_WRITE); if (info.size > offset) { /* we have enough */ toset = MIN (info.size - offset, left); diff --git a/gst/gstbuffer.h b/gst/gstbuffer.h index c8f48ec1c9..87ff09007e 100644 --- a/gst/gstbuffer.h +++ b/gst/gstbuffer.h @@ -265,9 +265,13 @@ GstBuffer * gst_buffer_new_wrapped (gpointer data, gsize size); /* memory blocks */ guint gst_buffer_n_memory (GstBuffer *buffer); void gst_buffer_take_memory (GstBuffer *buffer, gint idx, GstMemory *mem); -GstMemory * gst_buffer_peek_memory (GstBuffer *buffer, guint idx, GstMapFlags flags); -void gst_buffer_remove_memory_range (GstBuffer *buffer, guint idx, guint length); +void gst_buffer_replace_memory (GstBuffer *buffer, gint idx, GstMemory *mem); +GstMemory * gst_buffer_get_memory (GstBuffer *buffer, gint idx); +void gst_buffer_remove_memory_range (GstBuffer *buffer, guint idx, gint length); +#define gst_buffer_append_memory(b,m) gst_buffer_take_memory ((b), -1, (m)) +#define gst_buffer_replace_all_memory(b,m) gst_buffer_replace_memory ((b), -1, (m)) +#define gst_buffer_get_merged_memory(b) gst_buffer_get_memory ((b), -1) /** * gst_buffer_remove_memory: * @b: a #GstBuffer. @@ -275,7 +279,8 @@ void gst_buffer_remove_memory_range (GstBuffer *buffer, guint idx, guint * * Remove the memory block in @b at @i. */ -#define gst_buffer_remove_memory(b,i) gst_buffer_remove_memory_range ((b), (i), 1) +#define gst_buffer_remove_memory(b,i) gst_buffer_remove_memory_range ((b), (i), 1) +#define gst_buffer_remove_all_memory(b) gst_buffer_remove_memory_range ((b), 0, -1) gsize gst_buffer_fill (GstBuffer *buffer, gsize offset, gconstpointer src, gsize size); diff --git a/gst/gstmemory.c b/gst/gstmemory.c index 5a1ec4559b..e72d5510a1 100644 --- a/gst/gstmemory.c +++ b/gst/gstmemory.c @@ -135,7 +135,7 @@ _default_mem_init (GstMemoryDefault * mem, GstMemoryFlags flags, mem->mem.flags = flags; mem->mem.refcount = 1; mem->mem.parent = parent ? gst_memory_ref (parent) : NULL; - mem->mem.state = (flags & GST_MEMORY_FLAG_READONLY ? 0x5 : 0); + mem->mem.state = (flags & GST_MEMORY_FLAG_READONLY ? 0x1 : 0); mem->mem.maxsize = maxsize; mem->mem.offset = offset; mem->mem.size = size; @@ -431,6 +431,7 @@ gst_memory_unref (GstMemory * mem) mem->refcount - 1); if (g_atomic_int_dec_and_test (&mem->refcount)) { + g_return_if_fail (g_atomic_int_get (&mem->state) < 4); #ifndef GST_DISABLE_TRACE _gst_alloc_trace_free (_gst_memory_trace, mem); #endif @@ -438,6 +439,21 @@ gst_memory_unref (GstMemory * mem) } } +/** + * gst_memory_is_exclusive: + * @mem: a #GstMemory + * + * Check if the current ref to @mem is exclusive, this means that no other + * references exist other than @mem. + */ +gboolean +gst_memory_is_exclusive (GstMemory * mem) +{ + g_return_val_if_fail (mem != NULL, FALSE); + + return (g_atomic_int_get (&mem->refcount) == 1); +} + /** * gst_memory_get_sizes: * @mem: a #GstMemory @@ -474,7 +490,6 @@ void gst_memory_resize (GstMemory * mem, gssize offset, gsize size) { g_return_if_fail (mem != NULL); - g_return_if_fail (gst_memory_is_writable (mem)); g_return_if_fail (offset >= 0 || mem->offset >= -offset); g_return_if_fail (size + mem->offset + offset <= mem->maxsize); @@ -482,24 +497,6 @@ gst_memory_resize (GstMemory * mem, gssize offset, gsize size) mem->size = size; } -/** - * gst_memory_is_writable: - * @mem: a #GstMemory - * - * Check if @mem is writable. - * - * Returns: %TRUE is @mem is writable. - */ -gboolean -gst_memory_is_writable (GstMemory * mem) -{ - g_return_val_if_fail (mem != NULL, FALSE); - - return (mem->refcount == 1) && - ((mem->parent == NULL) || (mem->parent->refcount == 1)) && - ((mem->flags & GST_MEMORY_FLAG_READONLY) == 0); -} - static gboolean gst_memory_lock (GstMemory * mem, GstMapFlags flags) { @@ -610,8 +607,8 @@ cannot_map: * - the memory backed by @mem is not accessible with the given @flags. * - the memory was already mapped with a different mapping. * - * @info and its contents remains valid for as long as @mem is alive and until - * gst_memory_unmap() is called. + * @info and its contents remain valid for as long as @mem is valid and + * until gst_memory_unmap() is called. * * For each gst_memory_map() call, a corresponding gst_memory_unmap() call * should be done. @@ -722,6 +719,8 @@ gst_memory_share (GstMemory * mem, gssize offset, gssize size) GstMemory *shared; g_return_val_if_fail (mem != NULL, NULL); + g_return_val_if_fail (!GST_MEMORY_FLAG_IS_SET (mem, GST_MEMORY_FLAG_NO_SHARE), + NULL); shared = mem->allocator->info.mem_share (mem, offset, size); diff --git a/gst/gstmemory.h b/gst/gstmemory.h index aa9cb22075..354ea62a06 100644 --- a/gst/gstmemory.h +++ b/gst/gstmemory.h @@ -41,6 +41,8 @@ typedef struct _GstAllocator GstAllocator; GST_EXPORT gsize gst_memory_alignment; +#define GST_MEMORY_CAST(mem) ((GstMemory *)(mem)) + /** * GstMemoryFlags: * @GST_MEMORY_FLAG_READONLY: memory is readonly. It is not allowed to map the @@ -58,6 +60,30 @@ typedef enum { GST_MEMORY_FLAG_LAST = (1 << 16) } GstMemoryFlags; +/** + * GST_MEMORY_FLAGS: + * @mem: a #GstMemory. + * + * A flags word containing #GstMemoryFlags flags set on @mem + */ +#define GST_MEMORY_FLAGS(mem) (GST_MEMORY_CAST (mem)->flags) +/** + * GST_MEMORY_FLAG_IS_SET: + * @mem: a #GstMemory. + * @flag: the #GstMemoryFlags to check. + * + * Gives the status of a specific flag on a @mem. + */ +#define GST_MEMORY_FLAG_IS_SET(mem,flag) !!(GST_MEMORY_FLAGS (mem) & (flag)) + +/** + * GST_MEMORY_IS_READONLY: + * @mem: a #GstMemory. + * + * Check if @mem is readonly. + */ +#define GST_MEMORY_IS_READONLY(mem) GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_READONLY) + /** * GstMemory: * @allocator: pointer to the #GstAllocator @@ -278,30 +304,30 @@ void gst_allocator_set_default (GstAllocator * allocator); GstMemory * gst_allocator_alloc (GstAllocator * allocator, gsize maxsize, gsize align); -GstMemory * gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data, GFreeFunc free_func, - gsize maxsize, gsize offset, gsize size); +GstMemory * gst_memory_new_wrapped (GstMemoryFlags flags, gpointer data, GFreeFunc free_func, + gsize maxsize, gsize offset, gsize size); /* refcounting */ -GstMemory * gst_memory_ref (GstMemory *mem); -void gst_memory_unref (GstMemory *mem); +GstMemory * gst_memory_ref (GstMemory *mem); +void gst_memory_unref (GstMemory *mem); + +gboolean gst_memory_is_exclusive (GstMemory *mem); /* getting/setting memory properties */ -gsize gst_memory_get_sizes (GstMemory *mem, gsize *offset, gsize *maxsize); -void gst_memory_resize (GstMemory *mem, gssize offset, gsize size); +gsize gst_memory_get_sizes (GstMemory *mem, gsize *offset, gsize *maxsize); +void gst_memory_resize (GstMemory *mem, gssize offset, gsize size); /* retrieving data */ -gboolean gst_memory_is_writable (GstMemory *mem); - -GstMemory * gst_memory_make_mapped (GstMemory *mem, GstMapInfo *info, GstMapFlags flags); -gboolean gst_memory_map (GstMemory *mem, GstMapInfo *info, GstMapFlags flags); -void gst_memory_unmap (GstMemory *mem, GstMapInfo *info); +GstMemory * gst_memory_make_mapped (GstMemory *mem, GstMapInfo *info, GstMapFlags flags); +gboolean gst_memory_map (GstMemory *mem, GstMapInfo *info, GstMapFlags flags); +void gst_memory_unmap (GstMemory *mem, GstMapInfo *info); /* copy and subregions */ -GstMemory * gst_memory_copy (GstMemory *mem, gssize offset, gssize size); -GstMemory * gst_memory_share (GstMemory *mem, gssize offset, gssize size); +GstMemory * gst_memory_copy (GstMemory *mem, gssize offset, gssize size); +GstMemory * gst_memory_share (GstMemory *mem, gssize offset, gssize size); /* span memory */ -gboolean gst_memory_is_span (GstMemory *mem1, GstMemory *mem2, gsize *offset); +gboolean gst_memory_is_span (GstMemory *mem1, GstMemory *mem2, gsize *offset); G_END_DECLS diff --git a/tests/check/gst/gstbuffer.c b/tests/check/gst/gstbuffer.c index 7fcc06b032..b29af9cf64 100644 --- a/tests/check/gst/gstbuffer.c +++ b/tests/check/gst/gstbuffer.c @@ -450,8 +450,9 @@ GST_START_TEST (test_size) fail_unless (offset == 0); fail_unless (maxalloc >= 100); - mem = gst_buffer_peek_memory (buf, 0, GST_MAP_WRITE); + mem = gst_buffer_get_memory (buf, 0); gst_memory_resize (mem, 10, 70); + gst_memory_unref (mem); size = gst_buffer_get_sizes (buf, &offset, &maxsize); fail_unless (size == 70); diff --git a/tests/check/gst/gstmemory.c b/tests/check/gst/gstmemory.c index 1c6bf8a9c3..cef9e3f171 100644 --- a/tests/check/gst/gstmemory.c +++ b/tests/check/gst/gstmemory.c @@ -133,7 +133,7 @@ create_read_only_memory (void) /* assign some read-only data to the new memory */ mem = gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY, (gpointer) ro_memory, NULL, sizeof (ro_memory), 0, sizeof (ro_memory)); - fail_if (gst_memory_is_writable (mem)); + fail_unless (GST_MEMORY_IS_READONLY (mem)); return mem; } @@ -147,11 +147,10 @@ GST_START_TEST (test_writable) mem = create_read_only_memory (); fail_if (gst_memory_map (mem, &info, GST_MAP_WRITE)); - fail_if (gst_memory_is_writable (mem)); mem2 = gst_memory_copy (mem, 0, -1); - fail_if (gst_memory_is_writable (mem)); - fail_unless (gst_memory_is_writable (mem2)); + fail_unless (GST_MEMORY_IS_READONLY (mem)); + fail_if (GST_MEMORY_IS_READONLY (mem2)); fail_unless (gst_memory_map (mem2, &info, GST_MAP_WRITE)); info.data[4] = 'a'; @@ -180,7 +179,7 @@ GST_START_TEST (test_submemory_writable) mem = create_read_only_memory (); sub_mem = gst_memory_share (mem, 0, 8); - fail_if (gst_memory_is_writable (sub_mem)); + fail_unless (GST_MEMORY_IS_READONLY (sub_mem)); fail_if (gst_memory_map (mem, &info, GST_MAP_WRITE)); fail_if (gst_memory_map (sub_mem, &info, GST_MAP_WRITE)); diff --git a/win32/common/libgstreamer.def b/win32/common/libgstreamer.def index 3471eb6ab0..8a4a02ee30 100644 --- a/win32/common/libgstreamer.def +++ b/win32/common/libgstreamer.def @@ -90,6 +90,7 @@ EXPORTS gst_buffer_fill gst_buffer_flags_get_type gst_buffer_foreach_meta + gst_buffer_get_memory gst_buffer_get_meta gst_buffer_get_sizes gst_buffer_get_type @@ -113,7 +114,6 @@ EXPORTS gst_buffer_new_allocate gst_buffer_new_wrapped gst_buffer_new_wrapped_full - gst_buffer_peek_memory gst_buffer_pool_acquire_buffer gst_buffer_pool_config_add_option gst_buffer_pool_config_get @@ -133,6 +133,7 @@ EXPORTS gst_buffer_pool_set_config gst_buffer_remove_memory_range gst_buffer_remove_meta + gst_buffer_replace_memory gst_buffer_resize gst_buffer_span gst_buffer_take_memory @@ -507,8 +508,8 @@ EXPORTS gst_memory_flags_get_type gst_memory_get_sizes gst_memory_get_type + gst_memory_is_exclusive gst_memory_is_span - gst_memory_is_writable gst_memory_make_mapped gst_memory_map gst_memory_new_wrapped