GstBuffer

GstBuffer

Gst.Buffer.prototype.new

function Gst.Buffer.prototype.new(): {
    // javascript wrapper for 'gst_buffer_new'
}

Creates a newly allocated buffer without any data.

MT safe.

Gst.Buffer.prototype.new_allocate

function Gst.Buffer.prototype.new_allocate(allocator: Gst.Allocator, size: Number, params: Gst.AllocationParams): {
    // javascript wrapper for 'gst_buffer_new_allocate'
}

Tries to create a newly allocated buffer with data of the given size and extra parameters from allocator. If the requested amount of memory can't be allocated, null will be returned. The allocated buffer memory is not cleared.

When allocator is null, the default memory allocator will be used.

Note that when size == 0, the buffer will not have memory associated with it.

MT safe.

Gst.Buffer.prototype.new_wrapped

function Gst.Buffer.prototype.new_wrapped(data: [ Number ], size: Number): {
    // javascript wrapper for 'gst_buffer_new_wrapped'
}

Creates a new buffer that wraps the given data. The memory will be freed with g_free and will be marked writable.

MT safe.

Gst.Buffer.prototype.new_wrapped_bytes

function Gst.Buffer.prototype.new_wrapped_bytes(bytes: GLib.Bytes): {
    // javascript wrapper for 'gst_buffer_new_wrapped_bytes'
}

Creates a new Gst.Buffer that wraps the given bytes. The data inside bytes cannot be null and the resulting buffer will be marked as read only.

MT safe.

Since : 1.16

Gst.Buffer.prototype.new_wrapped_full

function Gst.Buffer.prototype.new_wrapped_full(flags: Gst.MemoryFlags, data: [ Number ], maxsize: Number, offset: Number, size: Number, user_data: Object, notify: GLib.DestroyNotify): {
    // javascript wrapper for 'gst_buffer_new_wrapped_full'
}

Allocate a new buffer that wraps the given memory. data must point to maxsize of memory, the wrapped buffer will have the region from offset and size visible.

When the buffer is destroyed, notify will be called with user_data.

The prefix/padding must be filled with 0 if flags contains Gst.MemoryFlags.ZERO_PREFIXED and Gst.MemoryFlags.ZERO_PADDED respectively.

Gst.Buffer.prototype.add_custom_meta

function Gst.Buffer.prototype.add_custom_meta(name: String): {
    // javascript wrapper for 'gst_buffer_add_custom_meta'
}

Creates and adds a Gst.CustomMeta for the desired name. name must have been successfully registered with Gst.prototype.meta_register_custom.

Since : 1.20

Gst.Buffer.prototype.add_meta

function Gst.Buffer.prototype.add_meta(info: Gst.MetaInfo, params: Object): {
    // javascript wrapper for 'gst_buffer_add_meta'
}

Add metadata for info to buffer using the parameters in params.

Gst.Buffer.prototype.add_parent_buffer_meta

function Gst.Buffer.prototype.add_parent_buffer_meta(ref: Gst.Buffer): {
    // javascript wrapper for 'gst_buffer_add_parent_buffer_meta'
}

Add a Gst.ParentBufferMeta to buffer that holds a reference on ref until the buffer is freed.

Since : 1.6

Gst.Buffer.prototype.add_protection_meta

function Gst.Buffer.prototype.add_protection_meta(info: Gst.Structure): {
    // javascript wrapper for 'gst_buffer_add_protection_meta'
}

Attaches protection metadata to a Gst.Buffer.

Since : 1.6

Gst.Buffer.prototype.add_reference_timestamp_meta

function Gst.Buffer.prototype.add_reference_timestamp_meta(reference: Gst.Caps, timestamp: Number, duration: Number): {
    // javascript wrapper for 'gst_buffer_add_reference_timestamp_meta'
}

Add a Gst.ReferenceTimestampMeta to buffer that holds a timestamp and optionally duration based on a specific timestamp reference. See the documentation of Gst.ReferenceTimestampMeta for details.

Since : 1.14

Gst.Buffer.prototype.append

function Gst.Buffer.prototype.append(buf2: Gst.Buffer): {
    // javascript wrapper for 'gst_buffer_append'
}

Append all the memory from buf2 to buf1. The result buffer will contain a concatenation of the memory of buf1 and buf2.

Gst.Buffer.prototype.append_memory

function Gst.Buffer.prototype.append_memory(mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_append_memory'
}

Append the memory block mem to buffer. This function takes ownership of mem and thus doesn't increase its refcount.

This function is identical to Gst.Buffer.prototype.insert_memory with an index of -1. See Gst.Buffer.prototype.insert_memory for more details.

Gst.Buffer.prototype.append_region

function Gst.Buffer.prototype.append_region(buf2: Gst.Buffer, offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_append_region'
}

Append size bytes at offset from buf2 to buf1. The result buffer will contain a concatenation of the memory of buf1 and the requested region of buf2.

Gst.Buffer.prototype.copy_deep

function Gst.Buffer.prototype.copy_deep(): {
    // javascript wrapper for 'gst_buffer_copy_deep'
}

Create a copy of the given buffer. This will make a newly allocated copy of the data the source buffer contains.

Since : 1.6

Gst.Buffer.prototype.copy_into

function Gst.Buffer.prototype.copy_into(src: Gst.Buffer, flags: Gst.BufferCopyFlags, offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_copy_into'
}

Copies the information from src into dest.

If dest already contains memory and flags contains GST_BUFFER_COPY_MEMORY, the memory from src will be appended to dest.

flags indicate which fields will be copied.

Gst.Buffer.prototype.copy_region

function Gst.Buffer.prototype.copy_region(flags: Gst.BufferCopyFlags, offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_copy_region'
}

Creates a sub-buffer from parent at offset and size. This sub-buffer uses the actual memory space of the parent buffer. This function will copy the offset and timestamp fields when the offset is 0. If not, they will be set to Gst.CLOCK_TIME_NONE and Gst.BUFFER_OFFSET_NONE. If offset equals 0 and size equals the total size of buffer, the duration and offset end fields are also copied. If not they will be set to Gst.CLOCK_TIME_NONE and Gst.BUFFER_OFFSET_NONE.

MT safe.

Gst.Buffer.prototype.extract

function Gst.Buffer.prototype.extract(offset: Number): {
    // javascript wrapper for 'gst_buffer_extract'
}

Copy size bytes starting from offset in buffer to dest.

Gst.Buffer.prototype.extract_dup

function Gst.Buffer.prototype.extract_dup(offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_extract_dup'
}

Extracts a copy of at most size bytes the data at offset into newly-allocated memory. dest must be freed using GLib.prototype.free when done.

Since : 1.0.10

Gst.Buffer.prototype.fill

function Gst.Buffer.prototype.fill(offset: Number, src: [ Number ], size: Number): {
    // javascript wrapper for 'gst_buffer_fill'
}

Copy size bytes from src to buffer at offset.

Gst.Buffer.prototype.find_memory

function Gst.Buffer.prototype.find_memory(offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_find_memory'
}

Find the memory blocks that span size bytes starting from offset in buffer.

When this function returns true, idx will contain the index of the first memory block where the byte for offset can be found and length contains the number of memory blocks containing the size remaining bytes. skip contains the number of bytes to skip in the memory block at idx to get to the byte for offset.

size can be -1 to get all the memory blocks after idx.

Gst.Buffer.prototype.foreach_meta

function Gst.Buffer.prototype.foreach_meta(func: Gst.BufferForeachMetaFunc, user_data: Object): {
    // javascript wrapper for 'gst_buffer_foreach_meta'
}

Call func with user_data for each meta in buffer.

func can modify the passed meta pointer or its contents. The return value of func define if this function returns or if the remaining metadata items in the buffer should be skipped.

Gst.Buffer.prototype.get_all_memory

function Gst.Buffer.prototype.get_all_memory(): {
    // javascript wrapper for 'gst_buffer_get_all_memory'
}

Get all the memory block in buffer. The memory blocks will be merged into one large Gst.Memory.

Gst.Buffer.prototype.get_custom_meta

function Gst.Buffer.prototype.get_custom_meta(name: String): {
    // javascript wrapper for 'gst_buffer_get_custom_meta'
}

Find the first Gst.CustomMeta on buffer for the desired name.

Since : 1.20

Gst.Buffer.prototype.get_flags

function Gst.Buffer.prototype.get_flags(): {
    // javascript wrapper for 'gst_buffer_get_flags'
}

Get the Gst.BufferFlags flags set on this buffer.

Since : 1.10

Gst.Buffer.prototype.get_memory

function Gst.Buffer.prototype.get_memory(idx: Number): {
    // javascript wrapper for 'gst_buffer_get_memory'
}

Get the memory block at index idx in buffer.

Gst.Buffer.prototype.get_memory_range

function Gst.Buffer.prototype.get_memory_range(idx: Number, length: Number): {
    // javascript wrapper for 'gst_buffer_get_memory_range'
}

Get length memory blocks in buffer starting at idx. The memory blocks will be merged into one large Gst.Memory.

If length is -1, all memory starting from idx is merged.

Gst.Buffer.prototype.get_meta

function Gst.Buffer.prototype.get_meta(api: GObject.Type): {
    // javascript wrapper for 'gst_buffer_get_meta'
}

Get the metadata for api on buffer. When there is no such metadata, null is returned. If multiple metadata with the given api are attached to this buffer only the first one is returned. To handle multiple metadata with a given API use gst_buffer_iterate_meta (not introspectable) or Gst.Buffer.prototype.foreach_meta instead and check the meta->info.api member for the API type.

Gst.Buffer.prototype.get_n_meta

function Gst.Buffer.prototype.get_n_meta(api_type: GObject.Type): {
    // javascript wrapper for 'gst_buffer_get_n_meta'
}

Since : 1.14

Gst.Buffer.prototype.get_reference_timestamp_meta

function Gst.Buffer.prototype.get_reference_timestamp_meta(reference: Gst.Caps): {
    // javascript wrapper for 'gst_buffer_get_reference_timestamp_meta'
}

Find the first Gst.ReferenceTimestampMeta on buffer that conforms to reference. Conformance is tested by checking if the meta's reference is a subset of reference.

Buffers can contain multiple Gst.ReferenceTimestampMeta metadata items.

Since : 1.14

Gst.Buffer.prototype.get_size

function Gst.Buffer.prototype.get_size(): {
    // javascript wrapper for 'gst_buffer_get_size'
}

Get the total size of the memory blocks in buffer.

Gst.Buffer.prototype.get_sizes

function Gst.Buffer.prototype.get_sizes(): {
    // javascript wrapper for 'gst_buffer_get_sizes'
}

Get the total size of the memory blocks in b.

When not null, offset will contain the offset of the data in the first memory block in buffer and maxsize will contain the sum of the size and offset and the amount of extra padding on the last memory block. offset and maxsize can be used to resize the buffer memory blocks with Gst.Buffer.prototype.resize.

Gst.Buffer.prototype.get_sizes_range

function Gst.Buffer.prototype.get_sizes_range(idx: Number, length: Number): {
    // javascript wrapper for 'gst_buffer_get_sizes_range'
}

Get the total size of length memory blocks stating from idx in buffer.

When not null, offset will contain the offset of the data in the memory block in buffer at idx and maxsize will contain the sum of the size and offset and the amount of extra padding on the memory block at idx + length -1. offset and maxsize can be used to resize the buffer memory blocks with Gst.Buffer.prototype.resize_range.

Gst.Buffer.prototype.has_flags

function Gst.Buffer.prototype.has_flags(flags: Gst.BufferFlags): {
    // javascript wrapper for 'gst_buffer_has_flags'
}

Gives the status of a specific flag on a buffer.

Since : 1.10

Gst.Buffer.prototype.insert_memory

function Gst.Buffer.prototype.insert_memory(idx: Number, mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_insert_memory'
}

Insert the memory block mem to buffer at idx. This function takes ownership of mem and thus doesn't increase its refcount.

Only Gst.prototype.buffer_get_max_memory can be added to a buffer. If more memory is added, existing memory blocks will automatically be merged to make room for the new memory.

Gst.Buffer.prototype.is_all_memory_writable

function Gst.Buffer.prototype.is_all_memory_writable(): {
    // javascript wrapper for 'gst_buffer_is_all_memory_writable'
}

Check if all memory blocks in buffer are writable.

Note that this function does not check if buffer is writable, use gst_buffer_is_writable (not introspectable) to check that if needed.

Since : 1.4

Gst.Buffer.prototype.is_memory_range_writable

function Gst.Buffer.prototype.is_memory_range_writable(idx: Number, length: Number): {
    // javascript wrapper for 'gst_buffer_is_memory_range_writable'
}

Check if length memory blocks in buffer starting from idx are writable.

length can be -1 to check all the memory blocks after idx.

Note that this function does not check if buffer is writable, use gst_buffer_is_writable (not introspectable) to check that if needed.

Since : 1.4

Gst.Buffer.prototype.map

function Gst.Buffer.prototype.map(flags: Gst.MapFlags): {
    // javascript wrapper for 'gst_buffer_map'
}

This function fills info with the Gst.MapInfo of all merged memory blocks in buffer.

flags describe the desired access of the memory. When flags is Gst.MapFlags.WRITE, buffer should be writable (as returned from gst_buffer_is_writable (not introspectable)).

When buffer is writable but the memory isn't, a writable copy will automatically be created and returned. The readonly copy of the buffer memory will then also be replaced with this writable copy.

The memory in info should be unmapped with Gst.Buffer.prototype.unmap after usage.

Gst.Buffer.prototype.map_range

function Gst.Buffer.prototype.map_range(idx: Number, length: Number, flags: Gst.MapFlags): {
    // javascript wrapper for 'gst_buffer_map_range'
}

This function fills info with the Gst.MapInfo of length merged memory blocks starting at idx in buffer. When length is -1, all memory blocks starting from idx are merged and mapped.

flags describe the desired access of the memory. When flags is Gst.MapFlags.WRITE, buffer should be writable (as returned from gst_buffer_is_writable (not introspectable)).

When buffer is writable but the memory isn't, a writable copy will automatically be created and returned. The readonly copy of the buffer memory will then also be replaced with this writable copy.

The memory in info should be unmapped with Gst.Buffer.prototype.unmap after usage.

Gst.Buffer.prototype.memcmp

function Gst.Buffer.prototype.memcmp(offset: Number, mem: [ Number ], size: Number): {
    // javascript wrapper for 'gst_buffer_memcmp'
}

Compare size bytes starting from offset in buffer with the memory in mem.

Gst.Buffer.prototype.memset

function Gst.Buffer.prototype.memset(offset: Number, val: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_memset'
}

Fill buf with size bytes with val starting from offset.

Gst.Buffer.prototype.n_memory

function Gst.Buffer.prototype.n_memory(): {
    // javascript wrapper for 'gst_buffer_n_memory'
}

Get the amount of memory blocks that this buffer has. This amount is never larger than what Gst.prototype.buffer_get_max_memory returns.

Gst.Buffer.prototype.peek_memory

function Gst.Buffer.prototype.peek_memory(idx: Number): {
    // javascript wrapper for 'gst_buffer_peek_memory'
}

Get the memory block at idx in buffer. The memory block stays valid until the memory block in buffer is removed, replaced or merged, typically with any call that modifies the memory in buffer.

Gst.Buffer.prototype.prepend_memory

function Gst.Buffer.prototype.prepend_memory(mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_prepend_memory'
}

Prepend the memory block mem to buffer. This function takes ownership of mem and thus doesn't increase its refcount.

This function is identical to Gst.Buffer.prototype.insert_memory with an index of 0. See Gst.Buffer.prototype.insert_memory for more details.

Gst.Buffer.prototype.remove_all_memory

function Gst.Buffer.prototype.remove_all_memory(): {
    // javascript wrapper for 'gst_buffer_remove_all_memory'
}

Remove all the memory blocks in buffer.

Gst.Buffer.prototype.remove_memory

function Gst.Buffer.prototype.remove_memory(idx: Number): {
    // javascript wrapper for 'gst_buffer_remove_memory'
}

Remove the memory block in b at index i.

Gst.Buffer.prototype.remove_memory_range

function Gst.Buffer.prototype.remove_memory_range(idx: Number, length: Number): {
    // javascript wrapper for 'gst_buffer_remove_memory_range'
}

Remove length memory blocks in buffer starting from idx.

length can be -1, in which case all memory starting from idx is removed.

Gst.Buffer.prototype.remove_meta

function Gst.Buffer.prototype.remove_meta(meta: Gst.Meta): {
    // javascript wrapper for 'gst_buffer_remove_meta'
}

Remove the metadata for meta on buffer.

Gst.Buffer.prototype.replace_all_memory

function Gst.Buffer.prototype.replace_all_memory(mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_replace_all_memory'
}

Replaces all memory in buffer with mem.

Gst.Buffer.prototype.replace_memory

function Gst.Buffer.prototype.replace_memory(idx: Number, mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_replace_memory'
}

Replaces the memory block at index idx in buffer with mem.

Gst.Buffer.prototype.replace_memory_range

function Gst.Buffer.prototype.replace_memory_range(idx: Number, length: Number, mem: Gst.Memory): {
    // javascript wrapper for 'gst_buffer_replace_memory_range'
}

Replaces length memory blocks in buffer starting at idx with mem.

If length is -1, all memory starting from idx will be removed and replaced with mem.

buffer should be writable.

Gst.Buffer.prototype.resize

function Gst.Buffer.prototype.resize(offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_resize'
}

Set the offset and total size of the memory blocks in buffer.

Gst.Buffer.prototype.resize_range

function Gst.Buffer.prototype.resize_range(idx: Number, length: Number, offset: Number, size: Number): {
    // javascript wrapper for 'gst_buffer_resize_range'
}

Set the total size of the length memory blocks starting at idx in buffer

Gst.Buffer.prototype.set_flags

function Gst.Buffer.prototype.set_flags(flags: Gst.BufferFlags): {
    // javascript wrapper for 'gst_buffer_set_flags'
}

Sets one or more buffer flags on a buffer.

Since : 1.10

Gst.Buffer.prototype.set_size

function Gst.Buffer.prototype.set_size(size: Number): {
    // javascript wrapper for 'gst_buffer_set_size'
}

Set the total size of the memory blocks in buffer.

Gst.Buffer.prototype.unmap

function Gst.Buffer.prototype.unmap(info: Gst.MapInfo): {
    // javascript wrapper for 'gst_buffer_unmap'
}

Release the memory previously mapped with Gst.Buffer.prototype.map.

Gst.Buffer.prototype.unset_flags

function Gst.Buffer.prototype.unset_flags(flags: Gst.BufferFlags): {
    // javascript wrapper for 'gst_buffer_unset_flags'
}

Clears one or more buffer flags.

Since : 1.10

Gst.prototype.buffer_get_max_memory

function Gst.prototype.buffer_get_max_memory(): {
    // javascript wrapper for 'gst_buffer_get_max_memory'
}

Get the maximum amount of memory blocks that a buffer can hold. This is a compile time constant that can be queried with the function.

When more memory blocks are added, existing memory blocks will be merged together to make room for the new block.

Since : 1.2