diff options
Diffstat (limited to 'gst/gstmemory.h')
| -rw-r--r-- | gst/gstmemory.h | 322 |
1 files changed, 218 insertions, 104 deletions
diff --git a/gst/gstmemory.h b/gst/gstmemory.h index c1f8e67..c69ee59 100644 --- a/gst/gstmemory.h +++ b/gst/gstmemory.h @@ -29,11 +29,29 @@ G_BEGIN_DECLS +#define GST_TYPE_MEMORY (gst_memory_get_type()) +GType gst_memory_get_type(void); + +#define GST_TYPE_ALLOCATOR (gst_allocator_get_type()) +GType gst_allocator_get_type(void); + +#define GST_TYPE_ALLOCATION_PARAMS (gst_allocation_params_get_type()) +GType gst_allocation_params_get_type(void); + typedef struct _GstMemory GstMemory; typedef struct _GstMemoryInfo GstMemoryInfo; typedef struct _GstAllocator GstAllocator; +typedef struct _GstAllocationParams GstAllocationParams; + +/** + * gst_memory_alignment: + * + * The default memory alignment in bytes - 1 + * an alignment of 7 would be the same as what malloc() guarantees. + */ +GST_EXPORT gsize gst_memory_alignment; -extern gsize gst_memory_alignment; +#define GST_MEMORY_CAST(mem) ((GstMemory *)(mem)) /** * GstMemoryFlags: @@ -41,26 +59,67 @@ extern gsize gst_memory_alignment; * memory with #GST_MAP_WRITE. * @GST_MEMORY_FLAG_NO_SHARE: memory must not be shared. Copies will have to be * made when this memory needs to be shared between buffers. + * @GST_MEMORY_FLAG_ZERO_PREFIXED: the memory prefix is filled with 0 bytes + * @GST_MEMORY_FLAG_ZERO_PADDED: the memory padding is filled with 0 bytes * @GST_MEMORY_FLAG_LAST: first flag that can be used for custom purposes * * Flags for wrapped memory. */ typedef enum { - GST_MEMORY_FLAG_READONLY = (1 << 0), - GST_MEMORY_FLAG_NO_SHARE = (1 << 1), + GST_MEMORY_FLAG_READONLY = (1 << 0), + GST_MEMORY_FLAG_NO_SHARE = (1 << 1), + GST_MEMORY_FLAG_ZERO_PREFIXED = (1 << 2), + GST_MEMORY_FLAG_ZERO_PADDED = (1 << 3), - GST_MEMORY_FLAG_LAST = (1 << 24) + GST_MEMORY_FLAG_LAST = (1 << 16) } GstMemoryFlags; /** - * GST_MEMORY_IS_WRITABLE: - * @mem: a #GstMemory + * 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_FLAG_UNSET: + * @mem: a #GstMemory. + * @flag: the #GstMemoryFlags to clear. + * + * Clear a specific flag on a @mem. + */ +#define GST_MEMORY_FLAG_UNSET(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) +/** + * GST_MEMORY_IS_ZERO_PREFIXED: + * @mem: a #GstMemory. * - * Check if @mem is writable. + * Check if the prefix in @mem is 0 filled. */ -#define GST_MEMORY_IS_WRITABLE(mem) (((mem)->refcount == 1) && \ - (((mem)->parent == NULL) || ((mem)->parent->refcount == 1)) && \ - (((mem)->flags & GST_MEMORY_FLAG_READONLY) == 0)) +#define GST_MEMORY_IS_ZERO_PREFIXED(mem) GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_ZERO_PREFIXED) +/** + * GST_MEMORY_IS_ZERO_PADDED: + * @mem: a #GstMemory. + * + * Check if the padding in @mem is 0 filled. + */ +#define GST_MEMORY_IS_ZERO_PADDED(mem) GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_ZERO_PADDED) + /** * GstMemory: @@ -68,31 +127,74 @@ typedef enum { * @flags: memory flags * @refcount: refcount * @parent: parent memory block + * @state: private state + * @maxsize: the maximum size allocated + * @align: the alignment of the memory + * @offset: the offset where valid data starts + * @size: the size of valid data * * Base structure for memory implementations. Custom memory will put this structure * as the first member of their structure. */ struct _GstMemory { - const GstAllocator *allocator; + GstAllocator *allocator; GstMemoryFlags flags; gint refcount; GstMemory *parent; + volatile gint state; + gsize maxsize; + gsize align; + gsize offset; + gsize size; }; /** * GstMapFlags: * @GST_MAP_READ: map for read access * @GST_MAP_WRITE: map for write access + * @GST_MAP_FLAG_LAST: first flag that can be used for custom purposes * * Flags used when mapping memory */ typedef enum { - GST_MAP_READ = (1 << 0), - GST_MAP_WRITE = (1 << 1), + GST_MAP_READ = (1 << 0), + GST_MAP_WRITE = (1 << 1), + + GST_MAP_FLAG_LAST = (1 << 16) } GstMapFlags; /** + * GstMapInfo: + * @memory: a pointer to the mapped memory + * @flags: flags used when mapping the memory + * @data: a pointer to the mapped data + * @size: the valid size in @data + * @maxsize: the maximum bytes in @data + * @user_data: extra private user_data that the implementation of the memory + * can use to store extra info. + * + * A structure containing the result of a map operation such as + * gst_memory_map(). It contains the data and size. + */ +typedef struct { + GstMemory *memory; + GstMapFlags flags; + guint8 *data; + gsize size; + gsize maxsize; + /*< private >*/ + gpointer user_data[4]; +} GstMapInfo; + +/** + * GST_MAP_INFO_INIT: + * + * Initializer for #GstMapInfo + */ +#define GST_MAP_INFO_INIT { NULL, 0, NULL, 0, 0, } + +/** * GST_MAP_READWRITE: * * Map for readwrite access @@ -107,80 +209,70 @@ typedef enum { #define GST_ALLOCATOR_SYSMEM "SystemMemory" /** - * GstMemoryAllocFunction: - * @allocator: a #GstAllocator - * @maxsize: the maxsize - * @align: the alignment - * @user_data: user data - * - * Allocate a new #GstMemory from @allocator that can hold at least @maxsize bytes - * and is aligned to (@align + 1) bytes. - * - * @user_data is the data that was used when registering @allocator. + * GstAllocationParams: + * @flags: flags to control allocation + * @align: the desired alignment of the memory + * @prefix: the disired prefix + * @padding: the desired padding * - * Returns: a newly allocated #GstMemory. Free with gst_memory_unref() + * Parameters to control the allocation of memory */ -typedef GstMemory * (*GstMemoryAllocFunction) (const GstAllocator *allocator, - gsize maxsize, gsize align, - gpointer user_data); +struct _GstAllocationParams { + GstMemoryFlags flags; + gsize align; + gsize prefix; + gsize padding; + + /*< private >*/ + gpointer _gst_reserved[GST_PADDING]; +}; /** - * GstMemoryGetSizesFunction: - * @mem: a #GstMemory - * @offset: result pointer for offset - * @maxsize: result pointer for maxsize + * GstAllocatorAllocFunction: + * @allocator: a #GstAllocator + * @size: the size + * @params: allocator params + * @user_data: user data * - * Retrieve the size, offset and maxsize of @mem. + * Allocate a new #GstMemory from @allocator that can hold at least @size + * bytes (+ padding) and is aligned to (@align + 1) bytes. * - * Returns: the size of @mem, the offset and the maximum allocated size in @maxsize. - */ -typedef gsize (*GstMemoryGetSizesFunction) (GstMemory *mem, gsize *offset, gsize *maxsize); - -/** - * GstMemoryResizeFunction: - * @mem: a #GstMemory - * @offset: the offset adjustement - * @size: the new size + * The offset and size of the memory should be set and the prefix/padding must + * be filled with 0 if @params flags contains #GST_MEMORY_FLAG_ZERO_PREFIXED and + * #GST_MEMORY_FLAG_ZERO_PADDED respectively. * - * Adjust the size and offset of @mem. @offset bytes will be adjusted from the - * current first byte in @mem as retrieved with gst_memory_map() and the new - * size will be set to @size. + * @user_data is the data that was used when creating @allocator. * - * @size can be set to -1, which will only adjust the offset. + * Returns: a newly allocated #GstMemory. Free with gst_memory_unref() */ -typedef void (*GstMemoryResizeFunction) (GstMemory *mem, gssize offset, gsize size); +typedef GstMemory * (*GstAllocatorAllocFunction) (GstAllocator *allocator, + gsize size, GstAllocationParams *params, + gpointer user_data); /** * GstMemoryMapFunction: * @mem: a #GstMemory - * @size: pointer for the size - * @maxsize: pointer for the maxsize + * @maxsize: size to map * @flags: access mode for the memory * * Get the memory of @mem that can be accessed according to the mode specified - * in @flags. @size and @maxsize will respectively contain the current amount of - * valid bytes in the returned memory and the maximum allocated memory. - * @size and @maxsize can optionally be set to NULL. + * in @flags. The function should return a pointer that contains at least + * @maxsize bytes. * - * Returns: a pointer to memory. @size bytes are currently used from the - * returned pointer and @maxsize bytes can potentially be used. + * Returns: a pointer to memory of which at least @maxsize bytes can be + * accessed according to the access pattern in @flags. */ -typedef gpointer (*GstMemoryMapFunction) (GstMemory *mem, gsize *size, gsize *maxsize, - GstMapFlags flags); +typedef gpointer (*GstMemoryMapFunction) (GstMemory *mem, gsize maxsize, GstMapFlags flags); /** * GstMemoryUnmapFunction: * @mem: a #GstMemory - * @data: the data pointer - * @size: the new size * - * Return the pointer previously retrieved with gst_memory_map() and adjust the - * size of the memory with @size. @size can optionally be set to -1 to not - * modify the size. + * Return the pointer previously retrieved with gst_memory_map(). * * Returns: %TRUE on success. */ -typedef gboolean (*GstMemoryUnmapFunction) (GstMemory *mem, gpointer data, gsize size); +typedef void (*GstMemoryUnmapFunction) (GstMemory *mem); /** * GstMemoryFreeFunction: @@ -195,7 +287,7 @@ typedef void (*GstMemoryFreeFunction) (GstMemory *mem); * GstMemoryCopyFunction: * @mem: a #GstMemory * @offset: an offset - * @size: a size + * @size: a size or -1 * * Copy @size bytes from @mem starting at @offset and return them wrapped in a * new GstMemory object. @@ -204,13 +296,13 @@ typedef void (*GstMemoryFreeFunction) (GstMemory *mem); * Returns: a new #GstMemory object wrapping a copy of the requested region in * @mem. */ -typedef GstMemory * (*GstMemoryCopyFunction) (GstMemory *mem, gssize offset, gsize size); +typedef GstMemory * (*GstMemoryCopyFunction) (GstMemory *mem, gssize offset, gssize size); /** * GstMemoryShareFunction: * @mem: a #GstMemory * @offset: an offset - * @size: a size + * @size: a size or -1 * * Share @size bytes from @mem starting at @offset and return them wrapped in a * new GstMemory object. If @size is set to -1, all bytes starting at @offset are @@ -218,7 +310,7 @@ typedef GstMemory * (*GstMemoryCopyFunction) (GstMemory *mem, gssize offset * * Returns: a new #GstMemory object sharing the requested region in @mem. */ -typedef GstMemory * (*GstMemoryShareFunction) (GstMemory *mem, gssize offset, gsize size); +typedef GstMemory * (*GstMemoryShareFunction) (GstMemory *mem, gssize offset, gssize size); /** * GstMemoryIsSpanFunction: @@ -235,67 +327,89 @@ typedef gboolean (*GstMemoryIsSpanFunction) (GstMemory *mem1, GstMemory *m /** * GstMemoryInfo: - * @alloc: the implementation of the GstMemoryAllocFunction - * @get_sizes: the implementation of the GstMemoryGetSizesFunction - * @resize: the implementation of the GstMemoryResizeFunction - * @map: the implementation of the GstMemoryMapFunction - * @unmap: the implementation of the GstMemoryUnmapFunction - * @free: the implementation of the GstMemoryFreeFunction - * @copy: the implementation of the GstMemoryCopyFunction - * @share: the implementation of the GstMemoryShareFunction - * @is_span: the implementation of the GstMemoryIsSpanFunction - * @user_data: generic user data for the allocator + * @mem_type: the memory type this allocator provides + * @alloc: the implementation of the GstAllocatorAllocFunction + * @mem_map: the implementation of the GstMemoryMapFunction + * @mem_unmap: the implementation of the GstMemoryUnmapFunction + * @mem_free: the implementation of the GstMemoryFreeFunction + * @mem_copy: the implementation of the GstMemoryCopyFunction + * @mem_share: the implementation of the GstMemoryShareFunction + * @mem_is_span: the implementation of the GstMemoryIsSpanFunction * * The #GstMemoryInfo is used to register new memory allocators and contain * the implementations for various memory operations. */ struct _GstMemoryInfo { - GstMemoryAllocFunction alloc; - GstMemoryGetSizesFunction get_sizes; - GstMemoryResizeFunction resize; - GstMemoryMapFunction map; - GstMemoryUnmapFunction unmap; - GstMemoryFreeFunction free; - - GstMemoryCopyFunction copy; - GstMemoryShareFunction share; - GstMemoryIsSpanFunction is_span; - - gpointer user_data; + const gchar *mem_type; + + GstAllocatorAllocFunction alloc; + + GstMemoryMapFunction mem_map; + GstMemoryUnmapFunction mem_unmap; + GstMemoryFreeFunction mem_free; + + GstMemoryCopyFunction mem_copy; + GstMemoryShareFunction mem_share; + GstMemoryIsSpanFunction mem_is_span; + + /*< private >*/ + gpointer _gst_reserved[GST_PADDING]; }; +/** + * GstAllocator: + * + * An opaque type returned from gst_allocator_new() or gst_allocator_find() + * that can be used to allocator memory. + */ + /* allocators */ -const GstAllocator * gst_allocator_register (const gchar *name, const GstMemoryInfo *info); -const GstAllocator * gst_allocator_find (const gchar *name); +GstAllocator * gst_allocator_new (const GstMemoryInfo * info, + gpointer user_data, GDestroyNotify notify); +const gchar * gst_allocator_get_memory_type (GstAllocator * allocator); + +GstAllocator * gst_allocator_ref (GstAllocator * allocator); +void gst_allocator_unref (GstAllocator * allocator); -void gst_allocator_set_default (const GstAllocator * allocator); +void gst_allocator_register (const gchar *name, GstAllocator *allocator); +GstAllocator * gst_allocator_find (const gchar *name); + +void gst_allocator_set_default (GstAllocator * allocator); /* allocating memory blocks */ -GstMemory * gst_allocator_alloc (const GstAllocator * allocator, - gsize maxsize, gsize align); +void gst_allocation_params_init (GstAllocationParams *params); +GstAllocationParams * + gst_allocation_params_copy (const GstAllocationParams *params) G_GNUC_MALLOC; +void gst_allocation_params_free (GstAllocationParams *params); + +GstMemory * gst_allocator_alloc (GstAllocator * allocator, gsize size, + GstAllocationParams *params); -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, gsize maxsize, + gsize offset, gsize size, gpointer user_data, + GDestroyNotify notify); /* 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 */ -gpointer gst_memory_map (GstMemory *mem, gsize *size, gsize *maxsize, - GstMapFlags flags); -gboolean gst_memory_unmap (GstMemory *mem, gpointer data, gsize size); +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, gsize size); -GstMemory * gst_memory_share (GstMemory *mem, gssize offset, gsize 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 |