Package ch.bailu.gtk.gst

Klasse Memory

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.gst.Memory
Alle implementierten Schnittstellen:
PointerInterface
public class Memory extends Record
GstMemory is a lightweight refcounted object that wraps a region of memory.
They are typically used to manage the data of a #GstBuffer.

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 gst_allocator_alloc()
method call. When %NULL is used as the allocator, the default allocator will
be used.

New allocators can be registered with gst_allocator_register().
Allocators are identified by name and can be retrieved with
gst_allocator_find(). gst_allocator_set_default() can be used to change the
default allocator.

New memory can be created with gst_memory_new_wrapped() that wraps the memory
allocated elsewhere.

Refcounting of the memory block is performed with gst_memory_ref() and
gst_memory_unref().

The size of the memory can be retrieved and changed with
gst_memory_get_sizes() and gst_memory_resize() respectively.

Getting access to the data of the memory is performed with gst_memory_map().
The call will return a pointer to offset bytes into the region of memory.
After the memory access is completed, gst_memory_unmap() should be called.

Memory can be copied with gst_memory_copy(), which will return a writable
copy. gst_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 gst_memory_is_span() returns %TRUE.

https://gstreamer.freedesktop.org/documentation/gstreamer/gi-index.html

  • Felddetails

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • setFieldAllocator

      public void setFieldAllocator(Allocator allocator)
      pointer to the #GstAllocator

    • getFieldAllocator

      public Allocator getFieldAllocator()
      pointer to the #GstAllocator

    • setFieldParent

      public void setFieldParent(Memory parent)
      parent memory block

    • getFieldParent

      public Memory getFieldParent()
      parent memory block

    • setFieldMaxsize

      public void setFieldMaxsize(long maxsize)
      the maximum size allocated

    • getFieldMaxsize

      public long getFieldMaxsize()
      the maximum size allocated

    • setFieldAlign

      public void setFieldAlign(long align)
      the alignment of the memory

    • getFieldAlign

      public long getFieldAlign()
      the alignment of the memory

    • setFieldOffset

      public void setFieldOffset(long offset)
      the offset where valid data starts

    • getFieldOffset

      public long getFieldOffset()
      the offset where valid data starts

    • setFieldSize

      public void setFieldSize(long size)
      the size of valid data

    • getFieldSize

      public long getFieldSize()
      the size of valid data

    • newWrappedMemory

      public static Memory newWrappedMemory(int flags, @Nonnull Pointer data, long maxsize, long offset, long size, @Nullable Pointer user_data, Memory.OnDestroyNotify 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.
      Parameter:
      flags - #GstMemoryFlags
      data - data to wrap
      maxsize - allocated size of @data
      offset - offset in @data
      size - size of valid data
      user_data - user_data
      notify - called with @user_data when the memory is freed
      Gibt zurück:
      a new #GstMemory.

    • copy

      public Memory copy(long offset, long 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.
      Parameter:
      offset - offset to copy from
      size - size to copy, or -1 to copy to the end of the memory region
      Gibt zurück:
      a new copy of @mem if the copy succeeded, %NULL otherwise.

    • getSizes

      public long getSizes(@Nullable Int64 offset, @Nullable Int64 maxsize)
      Get the current @size, @offset and @maxsize of @mem.
      Parameter:
      offset - pointer to offset
      maxsize - pointer to maxsize
      Gibt zurück:
      the current size of @mem

    • init

      public void init(int flags, @Nonnull Allocator allocator, @Nonnull Memory parent, long maxsize, long align, long offset, long size)
      Initializes a newly allocated @mem with the given parameters. This function
      will call gst_mini_object_init() with the default memory parameters.
      Parameter:
      flags - #GstMemoryFlags
      allocator - the #GstAllocator
      parent - the parent of @mem
      maxsize - the total size of the memory
      align - the alignment of the memory
      offset - The offset in the memory
      size - the size of valid data in the memory

    • isSpan

      public boolean isSpan(@Nonnull Memory mem2, @Nonnull Int64 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.
      Parameter:
      mem2 - a #GstMemory
      offset - a pointer to a result offset
      Gibt zurück:
      %TRUE if the memory is contiguous and of a common parent.

    • isType

      public boolean isType(@Nonnull Str mem_type)
      Check if @mem if allocated with an allocator for @mem_type.
      Parameter:
      mem_type - a memory type
      Gibt zurück:
      %TRUE if @mem was allocated from an allocator for @mem_type.

    • isType

      public boolean isType(String mem_type)
      Check if @mem if allocated with an allocator for @mem_type.
      Parameter:
      mem_type - a memory type
      Gibt zurück:
      %TRUE if @mem was allocated from an allocator for @mem_type.

    • makeMapped

      public Memory makeMapped(@Nonnull MapInfo info, int 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.
      Parameter:
      info - pointer for info
      flags - mapping flags
      Gibt zurück:
      a #GstMemory object mapped with @flags or %NULL when a mapping is not possible.

    • map

      public boolean map(@Nonnull MapInfo info, int 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.
      Parameter:
      info - pointer for info
      flags - mapping flags
      Gibt zurück:
      %TRUE if the map operation was successful.

    • resize

      public void resize(long offset, long 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.
      Parameter:
      offset - a new offset
      size - a new size

    • share

      public Memory share(long offset, long 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.
      Parameter:
      offset - offset to share from
      size - size to share, or -1 to share to the end of the memory region
      Gibt zurück:
      a new #GstMemory.

    • unmap

      public void unmap(@Nonnull MapInfo info)
      Release the memory obtained with gst_memory_map()
      Parameter:
      info - a #GstMapInfo

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()