GstMemory

GstMapInfo

GstMemory

gst_memory_new_wrapped

GstMemory *
gst_memory_new_wrapped (GstMemoryFlags flags,
                        gpointer data,
                        gsize maxsize,
                        gsize offset,
                        gsize size,
                        gpointer user_data,
                        GDestroyNotify notify)

Allocate a new memory block that wraps the given data.

The prefix/padding must be filled with 0 if flags contains GST_MEMORY_FLAG_ZERO_PREFIXED and GST_MEMORY_FLAG_ZERO_PADDED respectively.

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 from offset to the end of the memory region.

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_init

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_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.

gst_memory_is_type

gboolean
gst_memory_is_type (GstMemory * mem,
                    const gchar * mem_type)

Check if mem if allocated with an allocator for mem_type.

Since : 1.2

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:

• 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 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_ref

GstMemory *
gst_memory_ref (GstMemory * memory)

Increase the refcount of this memory.

gst_memory_resize

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_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 non-writable. size can be set to -1 to return a shared copy from offset to the end of the memory region.

gst_memory_unmap

gst_memory_unmap (GstMemory * mem,
                  GstMapInfo * info)

Release the memory obtained with gst_memory_map

gst_memory_unref

gst_memory_unref (GstMemory * memory)

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

GST_MEMORY_CAST

#define GST_MEMORY_CAST(mem)   ((GstMemory *)(mem))

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_NOT_MAPPABLE

#define GST_MEMORY_IS_NOT_MAPPABLE(mem)     GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_NOT_MAPPABLE)

Check if mem can't be mapped via gst_memory_map without any preconditions

Since : 1.2

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_PHYSICALLY_CONTIGUOUS

#define GST_MEMORY_IS_PHYSICALLY_CONTIGUOUS(mem)     GST_MEMORY_FLAG_IS_SET(mem,GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS)

Check if mem is physically contiguous.

Since : 1.2

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_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.

gst_memory_is_writable

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

gst_memory_lock

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

gst_memory_make_writable

#define gst_memory_make_writable(m) GST_MEMORY_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (m)))

Returns a writable copy of m. If the source memory is already writable, this will simply return the same memory.

gst_memory_unlock

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

GstMapFlags

Flags used when mapping memory

GstMemoryFlags

Flags for wrapped memory.

GST_MAP_INFO_INIT

#define GST_MAP_INFO_INIT { NULL, (GstMapFlags) 0, NULL, 0, 0, { NULL, NULL, NULL, NULL}, {NULL, NULL, NULL, NULL}}

Initializer for GstMapInfo

GST_MAP_READWRITE

#define GST_MAP_READWRITE      ((GstMapFlags) (GST_MAP_READ | GST_MAP_WRITE))

GstMapFlags value alias for GST_MAP_READ | GST_MAP_WRITE

GstMemoryMapInfo

typedef GstMapInfo GstMemoryMapInfo

Alias for GstMapInfo to be used with g_auto:

void my_func(GstMemory *mem)
{
  g_auto(GstMemoryMapInfo) map = GST_MAP_INFO_INIT;
  if (!gst_memory_map(mem, &map, GST_MAP_READWRITE))
    return;
  ...
  // No need to call gst_memory_unmap()
}

GstMapInfo cannot be used with g_auto because it is ambiguous whether it needs to be unmapped using gst_buffer_unmap or gst_memory_unmap.

See also GstBufferMapInfo.

Since : 1.22

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.

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.

GstMemoryMapFullFunction

gpointer
(*GstMemoryMapFullFunction) (GstMemory * mem,
                             GstMapInfo * info,
                             gsize maxsize)

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

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.

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.

GstMemoryUnmapFullFunction

(*GstMemoryUnmapFullFunction) (GstMemory * mem,
                               GstMapInfo * info)

Release the pointer previously retrieved with gst_memory_map with info.

GstMemoryUnmapFunction

(*GstMemoryUnmapFunction) (GstMemory * mem)

Release the pointer previously retrieved with gst_memory_map.