enum GstMemoryFlags

typedef enum {
  GST_MEMORY_FLAG_READONLY      = GST_MINI_OBJECT_FLAG_LOCK_READONLY,
  GST_MEMORY_FLAG_NO_SHARE      = (GST_MINI_OBJECT_FLAG_LAST << 0),
  GST_MEMORY_FLAG_ZERO_PREFIXED = (GST_MINI_OBJECT_FLAG_LAST << 1),
  GST_MEMORY_FLAG_ZERO_PADDED   = (GST_MINI_OBJECT_FLAG_LAST << 2),

  GST_MEMORY_FLAG_LAST          = (GST_MINI_OBJECT_FLAG_LAST << 16)
} GstMemoryFlags;

Flags for wrapped memory.

GST_MEMORY_FLAGS()

#define GST_MEMORY_FLAGS(mem)  GST_MINI_OBJECT_FLAGS (mem)

A flags word containing GstMemoryFlags flags set on mem

GST_MEMORY_FLAG_IS_SET()

#define GST_MEMORY_FLAG_IS_SET(mem,flag)   GST_MINI_OBJECT_FLAG_IS_SET (mem,flag)

Gives the status of a specific flag on a mem.

GST_MEMORY_FLAG_UNSET()

#define GST_MEMORY_FLAG_UNSET(mem,flag)   GST_MINI_OBJECT_FLAG_UNSET (mem, flag)

Clear a specific flag on a mem.

GST_MEMORY_IS_READONLY()

#define GST_MEMORY_IS_READONLY(mem)        GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_READONLY)

Check if mem is readonly.

GST_MEMORY_IS_NO_SHARE()

#define GST_MEMORY_IS_NO_SHARE(mem)        GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_NO_SHARE)

Check if mem cannot be shared between buffers

GST_MEMORY_IS_ZERO_PADDED()

#define GST_MEMORY_IS_ZERO_PADDED(mem)     GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_ZERO_PADDED)

Check if the padding in mem is 0 filled.

GST_MEMORY_IS_ZERO_PREFIXED()

#define GST_MEMORY_IS_ZERO_PREFIXED(mem)   GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_ZERO_PREFIXED)

Check if the prefix in mem is 0 filled.

struct GstMemory

struct GstMemory {
  GstMiniObject   mini_object;

  GstAllocator   *allocator;

  GstMemory      *parent;
  gsize           maxsize;
  gsize           align;
  gsize           offset;
  gsize           size;
};

Base structure for memory implementations. Custom memory will put this structure as the first member of their structure.

enum GstMapFlags

typedef enum {
  GST_MAP_READ      = GST_LOCK_FLAG_READ,
  GST_MAP_WRITE     = GST_LOCK_FLAG_WRITE,

  GST_MAP_FLAG_LAST = (1 << 16)
} GstMapFlags;

Flags used when mapping memory

GST_MAP_READWRITE

#define GST_MAP_READWRITE      (GST_MAP_READ | GST_MAP_WRITE)

GstMapFlags value alias for GST_MAP_READ | GST_MAP_WRITE

GstMapInfo

typedef struct {
  GstMemory *memory;
  GstMapFlags flags;
  guint8 *data;
  gsize size;
  gsize maxsize;
} GstMapInfo;

A structure containing the result of a map operation such as gst_memory_map(). It contains the data and size.

GST_MAP_INFO_INIT

#define GST_MAP_INFO_INIT { NULL, 0, NULL, 0, 0, }

Initializer for GstMapInfo

GstMemoryMapFunction ()

gpointer            (*GstMemoryMapFunction)             (GstMemory *mem,
                                                         gsize maxsize,
                                                         GstMapFlags flags);

Get the memory of mem that can be accessed according to the mode specified in flags. The function should return a pointer that contains at least maxsize bytes.

GstMemoryUnmapFunction ()

void                (*GstMemoryUnmapFunction)           (GstMemory *mem);

Return the pointer previously retrieved with gst_memory_map().

GstMemoryCopyFunction ()

GstMemory *         (*GstMemoryCopyFunction)            (GstMemory *mem,
                                                         gssize offset,
                                                         gssize size);

Copy 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 copied.

GstMemoryShareFunction ()

GstMemory *         (*GstMemoryShareFunction)           (GstMemory *mem,
                                                         gssize offset,
                                                         gssize size);

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 shared. This function does not make a copy of the bytes in mem.

GstMemoryIsSpanFunction ()

gboolean            (*GstMemoryIsSpanFunction)          (GstMemory *mem1,
                                                         GstMemory *mem2,
                                                         gsize *offset);

Check if mem1 and mem2 occupy contiguous memory and return the offset of mem1 in the parent buffer in offset.

gst_memory_init ()

void                gst_memory_init                     (GstMemory *mem,
                                                         GstMemoryFlags flags,
                                                         GstAllocator *allocator,
                                                         GstMemory *parent,
                                                         gsize maxsize,
                                                         gsize align,
                                                         gsize offset,
                                                         gsize size);

Initializes a newly allocated mem with the given parameters. This function will call gst_mini_object_init() with the default memory parameters.

gst_memory_ref ()

GstMemory *         gst_memory_ref                      (GstMemory *memory);

Increase the refcount of this memory.

gst_memory_unref ()

void                gst_memory_unref                    (GstMemory *memory);

Decrease the refcount of an memory, freeing it if the refcount reaches 0.

gst_memory_get_sizes ()

gsize               gst_memory_get_sizes                (GstMemory *mem,
                                                         gsize *offset,
                                                         gsize *maxsize);

Get the current size, offset and maxsize of mem.

gst_memory_resize ()

void                gst_memory_resize                   (GstMemory *mem,
                                                         gssize offset,
                                                         gsize size);

Resize the memory region. mem should be writable and offset + size should be less than the maxsize of mem.

GST_MEMORY_FLAG_ZERO_PREFIXED and GST_MEMORY_FLAG_ZERO_PADDED will be cleared when offset or padding is increased respectively.

gst_memory_lock()

#define        gst_memory_lock(m,f)        gst_mini_object_lock (GST_MINI_OBJECT_CAST (m), (f))

gst_memory_unlock()

#define        gst_memory_unlock(m,f)      gst_mini_object_unlock (GST_MINI_OBJECT_CAST (m), (f))

gst_memory_is_writable()

#define        gst_memory_is_writable(m)   gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (m))

gst_memory_make_mapped ()

GstMemory *         gst_memory_make_mapped              (GstMemory *mem,
                                                         GstMapInfo *info,
                                                         GstMapFlags flags);

Create a GstMemory object that is mapped with flags. If mem is mappable with flags, this function returns the mapped mem directly. Otherwise a mapped copy of mem is returned.

This function takes ownership of old mem and returns a reference to a new GstMemory.

gst_memory_map ()

gboolean            gst_memory_map                      (GstMemory *mem,
                                                         GstMapInfo *info,
                                                         GstMapFlags flags);

Fill info with the pointer and sizes of the memory in mem that can be accessed according to flags.

This function can return FALSE for various reasons:

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.

gst_memory_unmap ()

void                gst_memory_unmap                    (GstMemory *mem,
                                                         GstMapInfo *info);

Release the memory obtained with gst_memory_map()

gst_memory_copy ()

GstMemory *         gst_memory_copy                     (GstMemory *mem,
                                                         gssize offset,
                                                         gssize size);

Return a copy of size bytes from mem starting from offset. This copy is guaranteed to be writable. size can be set to -1 to return a copy all bytes from offset.

gst_memory_share ()

GstMemory *         gst_memory_share                    (GstMemory *mem,
                                                         gssize offset,
                                                         gssize size);

Return a shared copy of size bytes from mem starting from offset. No memory copy is performed and the memory region is simply shared. The result is guaranteed to be not-writable. size can be set to -1 to return a share all bytes from offset.

gst_memory_is_span ()

gboolean            gst_memory_is_span                  (GstMemory *mem1,
                                                         GstMemory *mem2,
                                                         gsize *offset);

Check if mem1 and mem2 share the memory with a common parent memory object and that the memory is contiguous.

If this is the case, the memory of mem1 and mem2 can be merged efficiently by performing gst_memory_share() on the parent object from the returned offset.