Memory

GstMemory is a lightweight refcounted object that wraps a region of memory. They are typically used to manage the data of a gstreamer.Buffer

A GstMemory object has an allocated region of memory of maxsize. The maximum size does not change during the lifetime of the memory object. The memory also has an offset and size property that specifies the valid range of memory in the allocated region.

Memory is usually created by allocators with a Allocator.alloc method call. When NULL is used as the allocator, the default allocator will be used.

New allocators can be registered with Allocator.register. Allocators are identified by name and can be retrieved with Allocator.find. Allocator.setDefault can be used to change the default allocator.

New memory can be created with Memory.newWrapped that wraps the memory allocated elsewhere.

Refcounting of the memory block is performed with Memory.ref and Memory.unref.

The size of the memory can be retrieved and changed with Memory.getSizes and Memory.resize respectively.

Getting access to the data of the memory is performed with Memory.map. The call will return a pointer to offset bytes into the region of memory. After the memory access is completed, Memory.unmap should be called.

Memory can be copied with Memory.copy, which will return a writable copy. Memory.share will create a new memory block that shares the memory with an existing memory block at a custom offset and with a custom size.

Memory can be efficiently merged when Memory.isSpan returns TRUE.

class Memory {

protected

GstMemory* gstMemory;

protected

bool ownedRef;

GstMemory* getMemoryStruct(bool transferOwnership);

void* getStruct();

this(GstMemory* gstMemory, bool ownedRef);

static GType getType();

this(GstMemoryFlags flags, ubyte[] data, size_t maxsize, size_t offset, void* userData, GDestroyNotify notify);

Memory copy(ptrdiff_t offset, ptrdiff_t size);

size_t getSizes(size_t offset, size_t maxsize);

void init(GstMemoryFlags flags, Allocator allocator, Memory parent, size_t maxsize, size_t align_, size_t offset, size_t size);

bool isSpan(Memory mem2, size_t offset);

bool isType(string memType);

Memory makeMapped(GstMapInfo info, GstMapFlags flags);

bool map(GstMapInfo info, GstMapFlags flags);

void resize(ptrdiff_t offset, size_t size);

Memory share(ptrdiff_t offset, ptrdiff_t size);

void unmap(GstMapInfo* info);

}

Constructors

this this(GstMemory* gstMemory, bool ownedRef): Sets our main struct and passes it to the parent class.
this this(GstMemoryFlags flags, ubyte[] data, size_t maxsize, size_t offset, void* userData, GDestroyNotify notify): Allocate a new memory block that wraps the given data.

Members

Functions

copy Memory copy(ptrdiff_t offset, ptrdiff_t 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.
getMemoryStruct GstMemory* getMemoryStruct(bool transferOwnership): Get the main Gtk struct
getSizes size_t getSizes(size_t offset, size_t maxsize): Get the current size, offset and maxsize of mem.
getStruct void* getStruct(): the main Gtk struct as a void*
init void init(GstMemoryFlags flags, Allocator allocator, Memory parent, size_t maxsize, size_t align_, size_t offset, size_t size): Initializes a newly allocated mem with the given parameters. This function will call MiniObject.init with the default memory parameters.
isSpan bool isSpan(Memory mem2, size_t offset): Check if mem1 and mem2 share the memory with a common parent memory object and that the memory is contiguous.
isType bool isType(string memType): Check if mem if allocated with an allocator for mem_type.
makeMapped Memory makeMapped(GstMapInfo info, GstMapFlags flags): Create a gstreamer.Memory 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.
map bool map(GstMapInfo info, GstMapFlags flags): Fill info with the pointer and sizes of the memory in mem that can be accessed according to flags.
resize void resize(ptrdiff_t offset, size_t size): Resize the memory region. mem should be writable and offset + size should be less than the maxsize of mem.
share Memory share(ptrdiff_t offset, ptrdiff_t 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.
unmap void unmap(GstMapInfo* info): Release the memory obtained with Memory.map

Static functions

getType GType getType()

Variables

gstMemory GstMemory* gstMemory;: the main Gtk struct

gstreamer Memory classes

Memory