mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-23 16:50:47 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/gstbufferlist.h

248 lines
8.2 KiB
C
Raw Normal View History

bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
/* GStreamer
* Copyright (C) 2009 Axis Communications <dev-gstreamer at axis dot com>
* @author Jonas Holmberg <jonas dot holmberg at axis dot com>
*
* gstbufferlist.h: Header for GstBufferList object
*
* 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
Fix FSF address https://bugzilla.gnome.org/show_bug.cgi?id=687520
2012-11-03 20:44:48 +00:00
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*/
#ifndef __GST_BUFFER_LIST_H__
#define __GST_BUFFER_LIST_H__
#include <gst/gstbuffer.h>
G_BEGIN_DECLS
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API GType _gst_buffer_list_type;
improve type registration
2010-11-02 12:31:25 +00:00
#define GST_TYPE_BUFFER_LIST (_gst_buffer_list_type)
fix macros
2009-12-07 19:32:12 +00:00
#define GST_IS_BUFFER_LIST(obj) (GST_IS_MINI_OBJECT_TYPE(obj, GST_TYPE_BUFFER_LIST))
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
#define GST_BUFFER_LIST_CAST(obj) ((GstBufferList *)obj)
fix macros
2009-12-07 19:32:12 +00:00
#define GST_BUFFER_LIST(obj) (GST_BUFFER_LIST_CAST(obj))
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
typedef struct _GstBufferList GstBufferList;
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
/**
* GstBufferListFunc:
introspection: add nullability annotations to out and inout params https://bugzilla.gnome.org/show_bug.cgi?id=730957
2014-06-11 23:06:19 +00:00
* @buffer: (out) (nullable): pointer the buffer
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
* @idx: the index of @buffer
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
* @user_data: user data passed to gst_buffer_list_foreach()
*
* A function that will be called from gst_buffer_list_foreach(). The @buffer
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
* field will point to a the reference of the buffer at @idx.
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
*
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
* When this function returns %TRUE, the next buffer will be
* returned. When %FALSE is returned, gst_buffer_list_foreach() will return.
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
*
docs: convert NULL, TRUE, and FALSE to %NULL, %TRUE, and %FALSE This should help improve documentation generated for languages other than C. https://bugzilla.gnome.org/show_bug.cgi?id=730961
2014-05-29 21:54:34 +00:00
* When @buffer is set to %NULL, the item will be removed from the bufferlist.
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
* When @buffer has been made writable, the new buffer reference can be assigned
* to @buffer. This function is responsible for unreffing the old buffer when
* removing or modifying.
*
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
* Returns: %FALSE when gst_buffer_list_foreach() should stop
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
*/
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
typedef gboolean (*GstBufferListFunc) (GstBuffer **buffer, guint idx,
gpointer user_data);
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
/* refcounting */
/**
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
* gst_buffer_list_ref: (skip)
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
* @list: a #GstBufferList
*
* Increases the refcount of the given buffer list by one.
*
docs: Fix typos in function/object descriptions Fixes https://bugzilla.gnome.org/show_bug.cgi?id=720029
2013-12-07 14:38:19 +00:00
* Note that the refcount affects the writability of @list and its data, see
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
* gst_buffer_list_make_writable(). It is important to note that keeping
* additional references to GstBufferList instances can potentially increase
* the number of memcpy operations in a pipeline.
*
docs: gst: more gobject introspection annotations Many of these are superfluous, added for clarity.
2010-12-07 18:35:04 +00:00
* Returns: (transfer full): @list
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*/
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
static inline GstBufferList* gst_buffer_list_ref(GstBufferList* list);
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
static inline GstBufferList *
gst_buffer_list_ref (GstBufferList * list)
{
return GST_BUFFER_LIST_CAST (gst_mini_object_ref (GST_MINI_OBJECT_CAST (
list)));
}
/**
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
* gst_buffer_list_unref: (skip)
docs: gst: more gobject introspection annotations Many of these are superfluous, added for clarity.
2010-12-07 18:35:04 +00:00
* @list: (transfer full): a #GstBufferList
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*
* Decreases the refcount of the buffer list. If the refcount reaches 0, the
* buffer list will be freed.
*/
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
static inline void gst_buffer_list_unref(GstBufferList* list);
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
static inline void
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
gst_buffer_list_unref(GstBufferList* list)
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
{
gst_mini_object_unref (GST_MINI_OBJECT_CAST (list));
}
bufferlist: add gst_clear_buffer_list() Basically, you can use this instead of using gst_buffer_list_unref (which needs to be preceded by a NULL-check). Also fixes #275
2018-11-04 17:52:50 +00:00
/**
* gst_clear_buffer_list: (skip)
* @list_ptr: a pointer to a #GstBufferList reference
*
* Clears a reference to a #GstBufferList.
*
* @list_ptr must not be %NULL.
*
* If the reference is %NULL then this function does nothing. Otherwise, the
* reference count of the list is decreased and the pointer is set to %NULL.
*
* Since: 1.16
*/
static inline void
gst_clear_buffer_list (GstBufferList ** list_ptr)
{
gst_clear_*: Cast to GstMiniObject** when needed
2018-11-05 13:03:51 +00:00
gst_clear_mini_object ((GstMiniObject **) list_ptr);
bufferlist: add gst_clear_buffer_list() Basically, you can use this instead of using gst_buffer_list_unref (which needs to be preceded by a NULL-check). Also fixes #275
2018-11-04 17:52:50 +00:00
}
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
/* copy */
/**
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
* gst_buffer_list_copy: (skip)
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
* @list: a #GstBufferList
*
* Create a shallow copy of the given buffer list. This will make a newly
* allocated copy of the source list with copies of buffer pointers. The
* refcount of buffers pointed to will be increased by one.
*
docs: gst: more gobject introspection annotations Many of these are superfluous, added for clarity.
2010-12-07 18:35:04 +00:00
* Returns: (transfer full): a new copy of @list.
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*/
doc: Fix hotdoc warnings * Making sure that `static inline` function are in the GIR (by first defining them, and make sure to mark as skiped) * Do not try to link to unexisting symbols * Also generate GIR information about gst_tracers
2018-08-19 22:41:41 +00:00
static inline GstBufferList* gst_buffer_list_copy(const GstBufferList* list);
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
static inline GstBufferList *
gst_buffer_list_copy (const GstBufferList * list)
{
Fix casts in a bunch of inline functions to maintain correct const-ness Make code including GStreamer headers compile with -Wcast-qual by maintaining const-ness when casting. Also fix function signature of gst_byte_writer_set_pos(): the byte writer should not be marked as const. https://bugzilla.gnome.org/show_bug.cgi?id=627910
2010-09-01 23:01:25 +00:00
return GST_BUFFER_LIST_CAST (gst_mini_object_copy (GST_MINI_OBJECT_CONST_CAST (list)));
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
}
bufferlist: add gst_buffer_list_replace/take() This makes its API consistent with the other GstMiniObject subclasses.
2018-11-04 18:13:39 +00:00
/**
* gst_buffer_list_replace:
* @old_list: (inout) (transfer full) (nullable): pointer to a pointer to a
* #GstBufferList to be replaced.
* @new_list: (transfer none) (allow-none): pointer to a #GstBufferList that
* will replace the buffer list pointed to by @old_list.
*
* Modifies a pointer to a #GstBufferList to point to a different
* #GstBufferList. The modification is done atomically (so this is useful for
* ensuring thread safety in some cases), and the reference counts are updated
* appropriately (the old buffer list is unreffed, the new is reffed).
*
* Either @new_list or the #GstBufferList pointed to by @old_list may be %NULL.
*
* Returns: %TRUE if @new_list was different from @old_list
*
* Since: 1.16
*/
static inline gboolean
gst_buffer_list_replace (GstBufferList **old_list, GstBufferList *new_list)
{
return gst_mini_object_replace ((GstMiniObject **) old_list,
(GstMiniObject *) new_list);
}
/**
* gst_buffer_list_take:
* @old_list: (inout) (transfer full): pointer to a pointer to a #GstBufferList
* to be replaced.
* @new_list: (transfer full) (allow-none): pointer to a #GstBufferList
* that will replace the bufferlist pointed to by @old_list.
*
* Modifies a pointer to a #GstBufferList to point to a different
* #GstBufferList. This function is similar to gst_buffer_list_replace() except
* that it takes ownership of @new_list.
*
* Returns: %TRUE if @new_list was different from @old_list
*
* Since: 1.16
*/
static inline gboolean
gst_buffer_list_take (GstBufferList **old_list, GstBufferList *new_list)
{
return gst_mini_object_take ((GstMiniObject **) old_list,
(GstMiniObject *) new_list);
}
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
/**
* gst_buffer_list_is_writable:
* @list: a #GstBufferList
*
* Tests if you can safely add buffers and groups into a buffer list.
*/
#define gst_buffer_list_is_writable(list) gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (list))
/**
* gst_buffer_list_make_writable:
docs: gst: more gobject introspection annotations Many of these are superfluous, added for clarity.
2010-12-07 18:35:04 +00:00
* @list: (transfer full): a #GstBufferList
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*
* Makes a writable buffer list from the given buffer list. If the source buffer
* list is already writable, this will simply return the same buffer list. A
* copy will otherwise be made using gst_buffer_list_copy().
docs: add some more Since: markers to buffer list docs
2010-01-31 17:30:54 +00:00
*
docs: gst: more gobject introspection annotations Many of these are superfluous, added for clarity.
2010-12-07 18:35:04 +00:00
* Returns: (transfer full): a writable list, which may or may not be the
* same as @list
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
*/
#define gst_buffer_list_make_writable(list) GST_BUFFER_LIST_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (list)))
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
init: add _get_type() functions Remove gst_mini_object_register() and add a GST_DEFINE_MINI_OBJECT macro to define a _get_type() function for the boxed miniobject. Remove a bunch of custom _get_type() functions and replace them with the miniobject macro. Rename some _init method to _priv_*_initialize() like the rest of them. Inspired by patch from Johan Dahlin and see bug #657603
2011-08-29 13:34:30 +00:00
GType gst_buffer_list_get_type (void);
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
/* allocation */
gst: mark symbols explicitly for export with GST_EXPORT One omission: gst_allocator_sysmem_get_type() was exported but never in any public header file.
2017-05-10 09:56:16 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
Merge remote-tracking branch 'origin/master' into 0.11 Conflicts: gst/gstbuffer.h gst/gstbufferlist.h gst/gstcaps.h gst/gstdatetime.h gst/gstelementfactory.h gst/gstevent.h gst/gstghostpad.h gst/gstindexfactory.h gst/gstiterator.h gst/gstmessage.h gst/gstminiobject.h gst/gstpipeline.h gst/gstquery.h gst/gstsegment.h gst/gststructure.h gst/gsttaglist.h gst/gsturi.h gst/gstvalue.h libs/gst/base/gstbitreader.h libs/gst/base/gstbytereader.h libs/gst/base/gstbytewriter.h Note: can't use G_GNUC_MALLOC with GstCaps return values in 0.11 because of the EMPTY+ANY singletons.
2011-11-26 19:44:23 +00:00
GstBufferList * gst_buffer_list_new (void) G_GNUC_MALLOC;
gst: mark symbols explicitly for export with GST_EXPORT One omission: gst_allocator_sysmem_get_type() was exported but never in any public header file.
2017-05-10 09:56:16 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
Merge remote-tracking branch 'origin/master' into 0.11 Conflicts: gst/gstbuffer.h gst/gstbufferlist.h gst/gstcaps.h gst/gstdatetime.h gst/gstelementfactory.h gst/gstevent.h gst/gstghostpad.h gst/gstindexfactory.h gst/gstiterator.h gst/gstmessage.h gst/gstminiobject.h gst/gstpipeline.h gst/gstquery.h gst/gstsegment.h gst/gststructure.h gst/gsttaglist.h gst/gsturi.h gst/gstvalue.h libs/gst/base/gstbitreader.h libs/gst/base/gstbytereader.h libs/gst/base/gstbytewriter.h Note: can't use G_GNUC_MALLOC with GstCaps return values in 0.11 because of the EMPTY+ANY singletons.
2011-11-26 19:44:23 +00:00
GstBufferList * gst_buffer_list_new_sized (guint size) G_GNUC_MALLOC;
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: clean up API gst_buffer_list_len() -> gst_buffer_list_length() gst_buffer_list_sized_new() -> gst_buffer_list_new_sized()
2011-10-29 06:24:12 +00:00
guint gst_buffer_list_length (GstBufferList *list);
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
GstBuffer * gst_buffer_list_get (GstBufferList *list, guint idx);
gst: mark symbols explicitly for export with GST_EXPORT One omission: gst_allocator_sysmem_get_type() was exported but never in any public header file.
2017-05-10 09:56:16 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: add gst_buffer_list_get_writable() Ensures buffer is writable. Useful if we want to change metadata on it such as timestamps. https://bugzilla.gnome.org/show_bug.cgi?id=750241
2017-08-30 12:50:33 +00:00
GstBuffer * gst_buffer_list_get_writable (GstBufferList *list, guint idx);
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: pass index as gint to _insert Make the idx argument of _insert() a gint because we allow -1 as a value. Improve annotation.
2012-07-23 14:27:34 +00:00
void gst_buffer_list_insert (GstBufferList *list, gint idx, GstBuffer *buffer);
gst: mark symbols explicitly for export with GST_EXPORT One omission: gst_allocator_sysmem_get_type() was exported but never in any public header file.
2017-05-10 09:56:16 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
void gst_buffer_list_remove (GstBufferList *list, guint idx, guint length);
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: improve foreach function Make the foreach function return FALSE when one of the function calls returned FALSE.
2012-07-17 10:52:59 +00:00
gboolean gst_buffer_list_foreach (GstBufferList *list,
bufferlist: Various cleanups Add new method to iterate a bufferlist without having to allocate an iterator. Add convenience method for getting an item from the list based on the group and index. Remove redundant _do_data callback and method. Update unit-tests and add some more for the new methods.
2009-06-19 13:29:14 +00:00
GstBufferListFunc func,
gpointer user_data);
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: add new api gst_buffer_list_copy_deep https://bugzilla.gnome.org/show_bug.cgi?id=751420
2015-06-24 05:18:47 +00:00
GstBufferList * gst_buffer_list_copy_deep (const GstBufferList * list);
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
gst: GST_EXPORT -> GST_API We need different export decorators for the different libs. For now no actual change though, just rename before the release, and add prelude headers to define the new decorator to GST_EXPORT.
2018-03-12 23:03:26 +00:00
GST_API
bufferlist: add gst_buffer_list_calculate_size() Returns size in bytes.
2017-08-31 11:54:55 +00:00
gsize gst_buffer_list_calculate_size (GstBufferList * list);
bufferlist: simplify bufferlists We now have multiple memory blocks as part of the buffers and we can therefore reduce the bufferlist to a simple array of buffers.
2011-03-31 15:51:02 +00:00
#define gst_buffer_list_add(l,b) gst_buffer_list_insert((l),-1,(b));
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
core: Add g_autoptr() support to all types https://bugzilla.gnome.org/show_bug.cgi?id=754464
2015-11-10 17:38:59 +00:00
#ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GstBufferList, gst_buffer_list_unref)
#endif
bufferlist: add bufferlist code Buffer lists are a means to manage disjoint buffers as one buffer. It's also possible to put many of those buffers into a list. The idea is that when support is added to various elements, we will be able to more efficiently slice and dice buffers, reduce the amount of memcpy and also reduce data passing overhead. The implementation is kept simple on purpose, reusing all of the memory management features we have for miniobjects and buffers. Access to the bufferlist object is done with an iterator, which allows for efficient iteration and modification of the list. See #572285
2009-05-12 09:51:37 +00:00
G_END_DECLS
#endif /* __GST_BUFFER_LIST_H__ */
Reference in a new issue Copy permalink