GstBufferPool Create buffers from a pool A bufferpool is used to create buffers in an efficient way. An element can, for example, maintain a bufferpool with a fixed number of buffers. This will reduce the g_malloc and g_free overhead. A bufferpool can also be used to implement direct access. A bufferpool can be sent from one element to another so that the latter can directly write into the memory of the element that maintains the bufferpool. This can greatly reduce the number of memcpy operations. A bufferpool is created with gst_buffer_pool_new(). You'll have to provide a free and copy function to handle the refcounting of the bufferpool as well as functions to create, free and copy buffers created from this pool. All buffer functions will receive the user_data you provide in the constructor. When no free and copy function is provided for the pool, a default implementation will be used. To create a buffer from the bufferpool use gst_buffer_new_from_pool(). When the buffer is unreffed and has reached a refcount of 0, the bufferpools free function is called with the pool, the buffer and the user_data as arguments. A bufferpool can store private data in the buffer it creates with the GST_BUFFER_POOL_PRIVATE() macro. To check it a buffer was made by a specific bufferpool, use the GST_BUFFER_BUFFERPOOL() macro to get its bufferpool. All plugins should unref the bufferpool if it is no longer required. When the bufferpool reaches a refcount of 0, the free function will be called. If your plugin is going to need a lot of equally sized memory areas you can use gst_buffer_pool_get_default() to request a pool that will create buffers of that size. These bufferpools will be shared with all plugins needing the same size of buffers so it's quite efficient since it reduces the number of memory allocations. A bufferpool can be requested from a pad with the gst_pad_get_bufferpool() function. This function is typically used when a plugin wants to write into a memory area provided by another plugin. Use gst_buffer_pool_unref() is you no longer require the bufferpool. #GstBuffer, #GstPad Cast a pointer to a GstBufferPool @pool: The pointer to cast The name used for memory tracing. Check if the given pointer is a bufferpool @buf: The pointer to check The bufferpool structure @data: @active: @buffer_new: @buffer_copy: @buffer_free: @user_data: The function will be called when a buffer must be allocated from the pool. @pool: The pool allocating the buffer @offset: An offset for the requested buffer, this can be a TIMESTAMP for example so that the bufferpool owner can implement double buffering or return a suitable position in a DMA buffer. @size: The size of the allocated buffer @user_data: user data as set on the bufferpool @Returns: A new buffer with the given parameters. The function that will be called when a buffer from the given pool is copied. @pool: The pool that owns the buffer @buffer: The buffer to copy @user_data: any user data associated with the pool @Returns: A new buffer that is a copy of the original The function that will be called when a buffer is to be freed into the pool. @pool: The pool that owns the buffer @buffer: The buffer to free @user_data: Any user data associated with the pool @free: @copy: @buffer_new: @buffer_copy: @buffer_free: @user_data: @Returns: @pool: @Returns: @pool: @active: Increase the refcount of the given pool @pool: The pool to refcount Increase the refcount of the given pool by c @pool: The pool to refcount @c: The value to add to the refcount Decrease the refcount of the given pool. If the refcount reaches 0, the free function of the pool will be called. @pool: The pool to unref. Copy the pool @pool: The pool to copy. Copy the pool if the refcount > 1 @pool: A copy of the pool or the pool itself if the refcount is 1 Free the given pool. This is dangerous, use gst_buffer_pool_unref() instead. @pool: The pool to free @pool: @user_data: @pool: @Returns: @buffer_size: @pool_size: @Returns: @pool: