gst

func (*AllocationParams) Copy ¶ added in v0.0.9

func (a *AllocationParams) Copy() *AllocationParams

Copy copies these AllocationParams.

func (*AllocationParams) Free ¶ added in v0.0.9

func (a *AllocationParams) Free()

Free frees the underlying AllocationParams

func (*AllocationParams) GetAlignment ¶ added in v0.0.9

func (a *AllocationParams) GetAlignment() int64

GetAlignment returns the desired alignment of the memory.

func (*AllocationParams) GetFlags ¶ added in v0.0.9

func (a *AllocationParams) GetFlags() MemoryFlags

GetFlags returns the flags on these AllocationParams.

func (*AllocationParams) GetPadding ¶ added in v0.0.9

func (a *AllocationParams) GetPadding() int64

GetPadding returns the desired padding size.

func (*AllocationParams) GetPrefix ¶ added in v0.0.9

func (a *AllocationParams) GetPrefix() int64

GetPrefix returns the desired prefix size.

func (*AllocationParams) Init ¶ added in v0.0.9

func (a *AllocationParams) Init()

Init initializes these AllocationParams to their original values.

func (*AllocationParams) Instance ¶ added in v0.0.9

func (a *AllocationParams) Instance() *C.GstAllocationParams

Instance returns the underlying GstAllocationParams.

func (*AllocationParams) SetAlignment ¶ added in v0.0.9

func (a *AllocationParams) SetAlignment(align int64)

SetAlignment sets the desired alignment of the memory.

func (*AllocationParams) SetFlags ¶ added in v0.0.9

func (a *AllocationParams) SetFlags(flags MemoryFlags)

SetFlags changes the flags on these AllocationParams. this must be used

func (*AllocationParams) SetPadding ¶ added in v0.0.9

func (a *AllocationParams) SetPadding(padding int64)

SetPadding sets the desired padding size.

func (*AllocationParams) SetPrefix ¶ added in v0.0.9

func (a *AllocationParams) SetPrefix(prefix int64)

SetPrefix sets the desired prefix size.

func (*Allocator) Alloc ¶ added in v0.0.9

func (a *Allocator) Alloc(size int64, params *AllocationParams) *Memory

Alloc is used to allocate a new memory block with memory that is at least size big. The optional params can specify the prefix and padding for the memory. If nil is passed, no flags, no extra prefix/padding and a default alignment is used.

The prefix/padding will be filled with 0 if flags contains MemoryFlagZeroPrefixed and MemoryFlagZeroPadded respectively.

The alignment in params is given as a bitmask so that align + 1 equals the amount of bytes to align to. For example, to align to 8 bytes, use an alignment of 7.

func (*Allocator) Free ¶ added in v0.0.9

func (a *Allocator) Free(mem *Memory)

Free memory that was originally allocated with this allocator.

func (*Allocator) Instance ¶ added in v0.0.9

func (a *Allocator) Instance() *C.GstAllocator

Instance returns the underlying GstAllocator instance.

func (*Allocator) MemType ¶ added in v0.0.9

func (a *Allocator) MemType() string

MemType returns the memory type for this allocator.

func (*Bin) Add ¶

func (b *Bin) Add(elem *Element) error

Add adds an element to the bin.

func (*Bin) AddMany ¶

func (b *Bin) AddMany(elems ...*Element) error

AddMany is a go implementation of `gst_bin_add_many`.

func (*Bin) DebugBinToDotData ¶ added in v0.1.0

func (b *Bin) DebugBinToDotData(details DebugGraphDetails) string

DebugBinToDotData will obtain the whole network of gstreamer elements that form the pipeline into a dot file. This data can be processed with graphviz to get an image.

func (*Bin) DebugBinToDotFile ¶ added in v0.1.0

func (b *Bin) DebugBinToDotFile(details DebugGraphDetails, filename string)

DebugBinToDotFile is like DebugBinToDotData except it will write the dot data to the filename specified.

func (*Bin) DebugBinToDotFileWithTs ¶ added in v0.1.0

func (b *Bin) DebugBinToDotFileWithTs(details DebugGraphDetails, filename string)

DebugBinToDotFileWithTs is like DebugBinToDotFile except it will write the dot data to the filename specified, except it will append the current timestamp to the filename.

func (*Bin) FindUnlinkedPad ¶ added in v0.0.9

func (b *Bin) FindUnlinkedPad(direction PadDirection) *Pad

FindUnlinkedPad recursively looks for elements with an unlinked pad of the given direction within this bin and returns an unlinked pad if one is found, or NULL otherwise. If a pad is found, the caller owns a reference to it and should unref it when it is not needed any longer.

func (*Bin) GetAllByInterface ¶ added in v0.1.0

func (b *Bin) GetAllByInterface(iface glib.Interface) ([]*Element, error)

GetAllByInterface looks for all elements inside the bin that implements the given interface. You can safely cast all returned elements to the given interface. The function recurses inside child bins. The function will return a series of Elements that should be unreffed after use.

func (*Bin) GetByInterface ¶ added in v0.1.0

func (b *Bin) GetByInterface(iface glib.Interface) (*Element, error)

GetByInterface looks for an element inside the bin that implements the given interface. If such an element is found, it returns the element. You can cast this element to the given interface afterwards. If you want all elements that implement the interface, use GetAllByInterface. This function recurses into child bins.

func (*Bin) GetElementByName ¶

func (b *Bin) GetElementByName(name string) (*Element, error)

GetElementByName returns the element with the given name. Unref after usage.

func (*Bin) GetElementByNameRecursive ¶ added in v0.0.9

func (b *Bin) GetElementByNameRecursive(name string) (*Element, error)

GetElementByNameRecursive returns the element with the given name. If it is not found in this Bin, parent Bins are searched recursively. Unref after usage.

func (*Bin) GetElements ¶

func (b *Bin) GetElements() ([]*Element, error)

GetElements returns a list of the elements added to this pipeline.

func (*Bin) GetElementsRecursive ¶ added in v0.0.9

func (b *Bin) GetElementsRecursive() ([]*Element, error)

GetElementsRecursive returns a list of the elements added to this Bin. It recurses children Bins.

func (*Bin) GetElementsSorted ¶ added in v0.0.9

func (b *Bin) GetElementsSorted() ([]*Element, error)

GetElementsSorted returns a list of the elements in this bin in topologically sorted order. This means that the elements are returned from the most downstream elements (sinks) to the sources.

func (*Bin) GetSinkElements ¶

func (b *Bin) GetSinkElements() ([]*Element, error)

GetSinkElements returns a list of all the sink elements in this Bin. Unref elements after usage.

func (*Bin) GetSourceElements ¶

func (b *Bin) GetSourceElements() ([]*Element, error)

GetSourceElements returns a list of all the source elements in this Bin.

func (*Bin) GetSuppressedFlags ¶ added in v0.0.9

func (b *Bin) GetSuppressedFlags() ElementFlags

GetSuppressedFlags returns the suppressed flags of the bin.

func (*Bin) Instance ¶

func (b *Bin) Instance() *C.GstBin

Instance returns the underlying GstBin instance.

func (*Bin) ParentAddElement ¶ added in v0.2.4

func (b *Bin) ParentAddElement(element *Element) bool

ParentAddElement chains up to the parent AddElement handler.

func (*Bin) ParentDeepElementAdded ¶ added in v0.2.4

func (b *Bin) ParentDeepElementAdded(subbin *Bin, element *Element)

ParentDeepElementAdded chains up to the parent DeepElementAdded handler.

func (*Bin) ParentDeepElementRemoved ¶ added in v0.2.4

func (b *Bin) ParentDeepElementRemoved(subbin *Bin, element *Element)

ParentDeepElementRemoved chains up to the parent DeepElementRemoved handler.

func (*Bin) ParentDoLatency ¶ added in v0.2.4

func (b *Bin) ParentDoLatency() bool

ParentDoLatency chains up to the parent DoLatency handler.

func (*Bin) ParentElementAdded ¶ added in v0.2.4

func (b *Bin) ParentElementAdded(element *Element)

ParentElementAdded chains up to the parent ElementAdded handler.

func (*Bin) ParentElementRemoved ¶ added in v0.2.4

func (b *Bin) ParentElementRemoved(element *Element)

ParentElementRemoved chains up to the parent ElementRemoved handler.

func (*Bin) ParentHandleMessage ¶ added in v0.2.4

func (b *Bin) ParentHandleMessage(message *Message)

ParentHandleMessage chains up to the parent HandleMessage handler.

func (*Bin) ParentRemoveElement ¶ added in v0.2.4

func (b *Bin) ParentRemoveElement(element *Element) bool

ParentRemoveElement chains up to the parent RemoveElement handler.

func (*Bin) RecalculateLatency ¶ added in v0.0.9

func (b *Bin) RecalculateLatency() bool

RecalculateLatency queries bin for the current latency and reconfigures this latency to all the elements with a LATENCY event.

This method is typically called on the pipeline when a MessageLatency is posted on the bus.

This function simply emits the 'do-latency' signal so any custom latency calculations will be performed. It returns true if the latency could be queried and reconfigured.

func (*Bin) Remove ¶ added in v0.0.9

func (b *Bin) Remove(elem *Element) error

Remove removes an element from the Bin.

func (*Bin) RemoveMany ¶ added in v0.0.9

func (b *Bin) RemoveMany(elems ...*Element) error

RemoveMany is a go implementation of `gst_bin_remove_many`.

func (*Bin) SetSuppressedFlags ¶ added in v0.0.9

func (b *Bin) SetSuppressedFlags(flags ElementFlags)

SetSuppressedFlags suppresses the given flags on the bin. ElementFlags of a child element are propagated when it is added to the bin. When suppressed flags are set, those specified flags will not be propagated to the bin.

func (*Bin) SyncChildrenStates ¶ added in v0.0.9

func (b *Bin) SyncChildrenStates() bool

SyncChildrenStates synchronizes the state of every child with the state of this Bin. This function returns true if the operation was successful.

func (Bitmask) ToGValue ¶ added in v0.2.15

func (b Bitmask) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer

func (*Buffer) AddMeta ¶ added in v0.0.9

func (b *Buffer) AddMeta(info *MetaInfo, params interface{}) *Meta

AddMeta adds metadata for info to the buffer using the parameters in params. The given parameters are passed to the MetaInfo's init function, and as such will only work for MetaInfo objects created from the go runtime.

// Example

metaInfo := gst.RegisterMeta(glib.TypeFromName("MyObjectType"), "my-meta", 1024, &gst.MetaInfoCallbackFuncs{
    InitFunc: func(params interface{}, buffer *gst.Buffer) bool {
        paramStr := params.(string)
        fmt.Println("Buffer initialized with params:", paramStr)
        return true
    },
    FreeFunc: func(buffer *gst.Buffer) {
        fmt.Println("Buffer was destroyed")
    },
})

buf := gst.NewEmptyBuffer()
buf.AddMeta(metaInfo, "hello world")

buf.Unref()

// > Buffer initialized with params: hello world
// > Buffer was destroyed

func (*Buffer) AddParentMeta ¶ added in v0.0.9

func (b *Buffer) AddParentMeta(buf *Buffer) *ParentBufferMeta

AddParentMeta adds a ParentBufferMeta to this buffer that holds a parent reference on the given buffer until the it is freed.

func (*Buffer) AddProtectionMeta ¶ added in v0.0.9

func (b *Buffer) AddProtectionMeta(info *Structure) *ProtectionMeta

AddProtectionMeta attaches ProtectionMeta to this buffer. The structure contains cryptographic information relating to the sample contained in the buffer. This function takes ownership of the structure.

func (*Buffer) AddReferenceTimestampMeta ¶ added in v0.0.9

func (b *Buffer) AddReferenceTimestampMeta(ref *Caps, timestamp, duration time.Duration) *ReferenceTimestampMeta

AddReferenceTimestampMeta adds a ReferenceTimestampMeta to this buffer that holds a timestamp and optional duration (specify -1 to omit) based on a specific timestamp reference.

See the documentation of GstReferenceTimestampMeta for details. https://gstreamer.freedesktop.org/documentation/gstreamer/gstbuffer.html?gi-language=c#GstReferenceTimestampMeta

func (*Buffer) Append ¶ added in v0.0.9

func (b *Buffer) Append(buf *Buffer) *Buffer

Append will append all the memory from the given buffer to this one. The result buffer will contain a concatenation of the memory of the two buffers.

func (*Buffer) AppendMemory ¶ added in v0.0.9

func (b *Buffer) AppendMemory(mem *Memory)

AppendMemory append the memory block to this buffer. This function takes ownership of the memory and thus doesn't increase its refcount.

This function is identical to InsertMemory with an index of -1.

func (*Buffer) AppendRegion ¶ added in v0.0.9

func (b *Buffer) AppendRegion(buf *Buffer, offset, size int64) *Buffer

AppendRegion will append size bytes at offset from the given buffer to this one. The result buffer will contain a concatenation of the memory of this buffer and the requested region of the one provided.

func (*Buffer) Bytes ¶

func (b *Buffer) Bytes() []byte

Bytes returns a byte slice of the data inside this buffer.

func (*Buffer) Copy ¶ added in v0.0.9

func (b *Buffer) Copy() *Buffer

Copy creates a copy of this buffer. This will only copy the buffer's data to a newly allocated Memory if needed (if the type of memory requires it), otherwise the underlying data is just referenced. Check DeepCopy if you want to force the data to be copied to newly allocated Memory.

func (*Buffer) CopyInto ¶ added in v0.0.9

func (b *Buffer) CopyInto(dest *Buffer, flags BufferCopyFlags, offset, size int64) bool

CopyInto copies the information from this buffer into the given one. If the given buffer already contains memory and flags contains BufferCopyMemory, the memory from this one will be appended to that provided.

Flags indicate which fields will be copied. Offset and size dictate from where and how much memory is copied. If size is -1 then all data is copied. The function returns true if the copy was successful.

func (*Buffer) CopyRegion ¶ added in v0.0.9

func (b *Buffer) CopyRegion(flags BufferCopyFlags, offset, size int64) *Buffer

CopyRegion creates a sub-buffer from this one 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 ClockTimeNone and BufferOffsetNone.

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 ClockTimeNone and BufferOffsetNone.

func (*Buffer) DecodingTimestamp ¶

func (b *Buffer) DecodingTimestamp() time.Duration

DecodingTimestamp returns the decoding timestamp of the buffer, or a negative duration if not known or relevant. This value contains the timestamp when the media should be processed.

func (*Buffer) DeepCopy ¶ added in v0.0.9

func (b *Buffer) DeepCopy() *Buffer

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

func (*Buffer) Duration ¶

func (b *Buffer) Duration() time.Duration

Duration returns the length of the data inside this buffer, or a negative duration if not known or relevant.

func (*Buffer) Extract ¶ added in v0.0.9

func (b *Buffer) Extract(offset, size int64) []byte

Extract extracts size bytes starting from offset in this buffer. The data extracted may be lower than the actual size if the buffer did not contain enough data.

func (*Buffer) FillBytes ¶ added in v0.0.10

func (b *Buffer) FillBytes(offset int64, data []byte) int64

FillBytes adds the given byte slice to the buffer at the given offset. The return value reflects the amount of data added to the buffer.

func (*Buffer) FindMemory ¶ added in v0.0.9

func (b *Buffer) FindMemory(offset, size int64) (index, length uint, skip int64)

FindMemory looks for the memory blocks that span size bytes starting from offset in buffer. Size can be -1 to retrieve all the memory blocks.

Index 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 index to get to the byte for offset. All values will be 0 if the memory blocks could not be read.

func (*Buffer) ForEachMeta ¶ added in v0.0.9

func (b *Buffer) ForEachMeta(f func(meta *Meta) bool) bool

ForEachMeta calls the given function for each Meta in this buffer.

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

func (*Buffer) GetAllMemory ¶ added in v0.0.9

func (b *Buffer) GetAllMemory() *Memory

GetAllMemory retrieves all the memory inside this buffer.

func (*Buffer) GetFlags ¶ added in v0.0.9

func (b *Buffer) GetFlags() BufferFlags

GetFlags returns the flags on this buffer.

func (*Buffer) GetMemory ¶ added in v0.0.9

func (b *Buffer) GetMemory(idx uint) *Memory

GetMemory retrieves the memory block at the given index in the buffer.

func (*Buffer) GetMemoryRange ¶ added in v0.0.9

func (b *Buffer) GetMemoryRange(idx uint, length int) *Memory

GetMemoryRange retrieves length memory blocks in buffer starting at idx. The memory blocks will be merged into one large Memory. If length is -1, all memory starting from idx is merged.

func (*Buffer) GetMeta ¶ added in v0.0.9

func (b *Buffer) GetMeta(api glib.Type) *Meta

GetMeta retrieves the metadata for the given api on buffer. When there is no such metadata, nil 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 ForEachMeta instead and check the type.

func (*Buffer) GetNumMetas ¶ added in v0.0.9

func (b *Buffer) GetNumMetas(api glib.Type) uint

GetNumMetas returns the number of metas for the given api type on the buffer.

func (*Buffer) GetReferenceTimestampMeta ¶ added in v0.0.9

func (b *Buffer) GetReferenceTimestampMeta(caps *Caps) *ReferenceTimestampMeta

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

Buffers can contain multiple ReferenceTimestampMeta metadata items.

func (*Buffer) GetSize ¶ added in v0.0.9

func (b *Buffer) GetSize() int64

GetSize retrieves the number of Memory blocks in the bffer.

func (*Buffer) GetSizes ¶ added in v0.0.9

func (b *Buffer) GetSizes() (size, offset, maxsize int64)

GetSizes will retrieve the size of the buffer, the offset of the first memory block in the buffer, and the sum of the size of the buffer, the offset, and any padding. These values can be used to resize the buffer with Resize.

func (*Buffer) GetSizesRange ¶ added in v0.0.9

func (b *Buffer) GetSizesRange(idx uint, length int) (offset, maxsize int64)

GetSizesRange will get the total size of length memory blocks stating from idx in buffer.

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

func (*Buffer) HasFlags ¶ added in v0.0.9

func (b *Buffer) HasFlags(flags BufferFlags) bool

HasFlags returns true if this Buffer has the given BufferFlags.

func (*Buffer) InsertMemory ¶ added in v0.0.9

func (b *Buffer) InsertMemory(mem *Memory, idx int)

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

Only the value from GetMaxBufferMemory 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.

func (*Buffer) Instance ¶

func (b *Buffer) Instance() *C.GstBuffer

Instance returns the underlying GstBuffer instance.

func (*Buffer) IsAllMemoryWritable ¶ added in v0.0.9

func (b *Buffer) IsAllMemoryWritable() bool

IsAllMemoryWritable checks if all memory blocks in buffer are writable.

Note that this function does not check if buffer is writable, use IsWritable to check that if needed.

func (*Buffer) IsMemoryRangeWritable ¶ added in v0.0.9

func (b *Buffer) IsMemoryRangeWritable(idx uint, length int) bool

IsMemoryRangeWritable checks if length memory blocks in the 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 IsWritable to check that if needed.

func (*Buffer) IsWritable ¶ added in v0.0.9

func (b *Buffer) IsWritable() bool

IsWritable returns true if this buffer is writable.

func (*Buffer) IterateMeta ¶ added in v0.0.9

func (b *Buffer) IterateMeta(meta *Meta) *Meta

IterateMeta retrieves the next Meta after the given one. If state points to nil, the first Meta is returned.

func (*Buffer) IterateMetaFiltered ¶ added in v0.0.9

func (b *Buffer) IterateMetaFiltered(meta *Meta, apiType glib.Type) *Meta

IterateMetaFiltered is similar to IterateMeta except it will filter on the api type.

func (*Buffer) MakeWritable ¶ added in v0.0.9

func (b *Buffer) MakeWritable() *Buffer

MakeWritable returns a writable copy of this buffer. If the source buffer is already writable, this will simply return the same buffer.

Use this function to ensure that a buffer can be safely modified before making changes to it, including changing the metadata such as PTS/DTS.

If the reference count of the source buffer buf is exactly one, the caller is the sole owner and this function will return the buffer object unchanged.

If there is more than one reference on the object, a copy will be made using gst_buffer_copy. The passed-in buf will be unreffed in that case, and the caller will now own a reference to the new returned buffer object. Note that this just copies the buffer structure itself, the underlying memory is not copied if it can be shared amongst multiple buffers.

In short, this function unrefs the buf in the argument and refs the buffer that it returns. Don't access the argument after calling this function unless you have an additional reference to it.

func (*Buffer) Map ¶ added in v0.0.9

func (b *Buffer) Map(flags MapFlags) *MapInfo

Map will map the data inside this buffer. This function can return nil if the memory is not read or writable. It is safe to call this function multiple times on a single Buffer, however it will retain the flags used when mapping the first time. To change between read and write access first unmap and then remap the buffer with the appropriate flags, or map initially with both read/write access.

Unmap the Buffer after usage.

func (*Buffer) MapRange ¶ added in v0.0.9

func (b *Buffer) MapRange(idx uint, length int, flags MapFlags) *MapInfo

MapRange maps the info 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 MapWrite, buffer should be writable (as returned from IsWritable).

When the 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.

Unmap the Buffer after usage.

func (*Buffer) Memset ¶ added in v0.0.9

func (b *Buffer) Memset(offset int64, val uint8, size int64) int64

Memset fills buf with size bytes with val starting from offset. It returns the size written to the buffer.

func (*Buffer) NumMemoryBlocks ¶ added in v0.0.9

func (b *Buffer) NumMemoryBlocks() uint

NumMemoryBlocks returns the number of memory blocks this buffer has.

func (*Buffer) Offset ¶

func (b *Buffer) Offset() int64

Offset returns a media specific offset for the buffer data. For video frames, this is the frame number of this buffer. For audio samples, this is the offset of the first sample in this buffer. For file data or compressed data this is the byte offset of the first byte in this buffer.

func (*Buffer) OffsetEnd ¶

func (b *Buffer) OffsetEnd() int64

OffsetEnd returns the last offset contained in this buffer. It has the same format as Offset.

func (*Buffer) PeekMemory ¶ added in v0.0.9

func (b *Buffer) PeekMemory(idx uint) *Memory

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

func (*Buffer) PrependMemory ¶ added in v0.0.9

func (b *Buffer) PrependMemory(mem *Memory)

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

This function is identical to InsertMemory with an index of 0.

func (*Buffer) PresentationTimestamp ¶

func (b *Buffer) PresentationTimestamp() time.Duration

PresentationTimestamp returns the presentation timestamp of the buffer, or a negative duration if not known or relevant. This value contains the timestamp when the media should be presented to the user.

func (*Buffer) Reader ¶

func (b *Buffer) Reader() io.Reader

Reader returns an io.Reader for this buffer.

func (*Buffer) Ref ¶ added in v0.0.9

func (b *Buffer) Ref() *Buffer

Ref increases the ref count on the buffer by one.

func (*Buffer) RemoveAllMemory ¶ added in v0.0.9

func (b *Buffer) RemoveAllMemory()

RemoveAllMemory removes all memory blocks in the buffer.

func (*Buffer) RemoveMemoryAt ¶ added in v0.0.9

func (b *Buffer) RemoveMemoryAt(idx uint)

RemoveMemoryAt removes the memory block at the given index.

func (*Buffer) RemoveMemoryRange ¶ added in v0.0.9

func (b *Buffer) RemoveMemoryRange(idx uint, length int)

RemoveMemoryRange removes length memory blocks in buffer starting from idx.

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

func (*Buffer) RemoveMeta ¶ added in v0.0.9

func (b *Buffer) RemoveMeta(meta *Meta) bool

RemoveMeta removes the given metadata from the buffer.

func (*Buffer) ReplaceAllMemory ¶ added in v0.0.9

func (b *Buffer) ReplaceAllMemory(mem *Memory)

ReplaceAllMemory replaces all the memory in this buffer with that provided.

func (*Buffer) ReplaceMemory ¶ added in v0.0.9

func (b *Buffer) ReplaceMemory(mem *Memory, idx uint)

ReplaceMemory replaces the memory at the given index with the given memory.

func (*Buffer) ReplaceMemoryRange ¶ added in v0.0.9

func (b *Buffer) ReplaceMemoryRange(idx uint, length int, mem *Memory)

ReplaceMemoryRange replaces length memory blocks in the buffer starting at idx with the given memory.

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

The buffer should be writable.

func (*Buffer) Resize ¶ added in v0.0.9

func (b *Buffer) Resize(offset, size int64)

Resize sets the offset and total size of the memory blocks in this buffer.

func (*Buffer) ResizeRange ¶ added in v0.0.9

func (b *Buffer) ResizeRange(idx uint, length int, offset, size int64) bool

ResizeRange sets the total size of the length memory blocks starting at idx in this buffer.

func (*Buffer) SetDuration ¶ added in v0.0.10

func (b *Buffer) SetDuration(dur time.Duration)

SetDuration sets the duration on the buffer.

func (*Buffer) SetFlags ¶ added in v0.0.9

func (b *Buffer) SetFlags(flags BufferFlags) bool

SetFlags sets one or more buffer flags on the buffer.

func (*Buffer) SetPresentationTimestamp ¶ added in v0.0.10

func (b *Buffer) SetPresentationTimestamp(dur time.Duration)

SetPresentationTimestamp sets the presentation timestamp on the buffer.

func (*Buffer) SetSize ¶ added in v0.0.9

func (b *Buffer) SetSize(size int64)

SetSize sets the total size of the memory blocks in buffer.

func (*Buffer) Unmap ¶ added in v0.1.5

func (b *Buffer) Unmap()

Unmap will unmap the data inside this memory. Use this after calling Map on the buffer.

func (*Buffer) Unref ¶ added in v0.0.9

func (b *Buffer) Unref()

Unref decreaes the ref count on the buffer by one. When the refcount reaches zero, the memory is freed.

func (*Buffer) UnsetFlags ¶ added in v0.0.9

func (b *Buffer) UnsetFlags(flags BufferFlags) bool

UnsetFlags removes one or more flags from the buffer.

func (*BufferList) CalculateSize ¶ added in v0.0.9

func (b *BufferList) CalculateSize() int64

CalculateSize calculates the size of the data contained in this buffer list by adding the size of all buffers.

func (*BufferList) Copy ¶ added in v0.0.9

func (b *BufferList) Copy() *BufferList

Copy creates a shallow copy of the given buffer list. This will make a newly allocated copy of the source list with copies of buffer pointers. The refcount of buffers pointed to will be increased by one.

func (*BufferList) DeepCopy ¶ added in v0.0.9

func (b *BufferList) DeepCopy() *BufferList

DeepCopy creates a copy of the given buffer list. This will make a newly allocated copy of each buffer that the source buffer list contains.

func (*BufferList) ForEach ¶ added in v0.0.9

func (b *BufferList) ForEach(f func(buf *Buffer, idx uint) bool)

ForEach calls the given function for each buffer in list.

The function can modify the passed buffer pointer or its contents. The return value defines if this function returns or if the remaining buffers in the list should be skipped.

func (*BufferList) GetBufferAt ¶ added in v0.0.9

func (b *BufferList) GetBufferAt(idx uint) *Buffer

GetBufferAt gets the buffer at idx.

You must make sure that idx does not exceed the number of buffers available.

func (*BufferList) GetWritableBufferAt ¶ added in v0.0.9

func (b *BufferList) GetWritableBufferAt(idx uint) *Buffer

GetWritableBufferAt gets the buffer at idx, ensuring it is a writable buffer.

You must make sure that idx does not exceed the number of buffers available.

func (*BufferList) Insert ¶ added in v0.0.9

func (b *BufferList) Insert(idx int, buf *Buffer)

Insert inserts a buffer at idx in the list. Other buffers are moved to make room for this new buffer.

A -1 value for idx will append the buffer at the end.

func (*BufferList) Instance ¶ added in v0.0.9

func (b *BufferList) Instance() *C.GstBufferList

Instance returns the underlying GstBufferList.

func (*BufferList) IsWritable ¶ added in v0.0.9

func (b *BufferList) IsWritable() bool

IsWritable returns true if this BufferList is writable.

func (*BufferList) Length ¶ added in v0.0.9

func (b *BufferList) Length() uint

Length returns the number of buffers in the list.

func (*BufferList) MakeWritable ¶ added in v0.0.9

func (b *BufferList) MakeWritable() *BufferList

MakeWritable makes a writable buffer list from this one. If the source buffer list is already writable, this will simply return the same buffer list. A copy will otherwise be made using Copy.

func (*BufferList) Ref ¶ added in v0.0.9

func (b *BufferList) Ref() *BufferList

Ref increases the refcount of the given buffer list by one.

Note that the refcount affects the writability of list and its data, see MakeWritable. It is important to note that keeping additional references to GstBufferList instances can potentially increase the number of memcpy operations in a pipeline.

func (*BufferList) Remove ¶ added in v0.0.9

func (b *BufferList) Remove(idx, length uint)

Remove removes length buffers from the list starting at index. All following buffers are moved to close the gap.

func (*BufferList) Unref ¶ added in v0.0.9

func (b *BufferList) Unref()

Unref decreases the refcount of the buffer list. If the refcount reaches 0, the buffer list will be freed.

func (*BufferPool) AcquireBuffer ¶ added in v0.0.9

func (b *BufferPool) AcquireBuffer(params *BufferPoolAcquireParams) (*Buffer, FlowReturn)

AcquireBuffer acquires a buffer from this pool.

func (*BufferPool) GetConfig ¶ added in v0.0.9

func (b *BufferPool) GetConfig() *BufferPoolConfig

GetConfig retrieves a copy of the current configuration of the pool. This configuration can either be modified and used for the SetConfig call or it must be freed after usage with Free.

func (*BufferPool) GetOptions ¶ added in v0.0.9

func (b *BufferPool) GetOptions() []string

GetOptions retrieves a list of supported bufferpool options for the pool. An option would typically be enabled with AddOption.

func (*BufferPool) HasOption ¶ added in v0.0.9

func (b *BufferPool) HasOption(opt string) bool

HasOption returns true if this BufferPool supports the given option.

func (*BufferPool) Instance ¶ added in v0.0.9

func (b *BufferPool) Instance() *C.GstBufferPool

Instance returns the underlying GstBufferPool instance.

func (*BufferPool) IsActive ¶ added in v0.0.9

func (b *BufferPool) IsActive() bool

IsActive returns true if this BufferPool is active. A pool can be activated with SetActive.

func (*BufferPool) IsFlushing ¶ added in v0.0.9

func (b *BufferPool) IsFlushing() bool

IsFlushing returns true if this BufferPool is currently flushing.

func (*BufferPool) ReleaseBuffer ¶ added in v0.0.9

func (b *BufferPool) ReleaseBuffer(buf *Buffer)

ReleaseBuffer releases the given buffer from the pool. The buffer should have previously been allocated from pool with AcquireBiffer.

This function is usually called automatically when the last ref on buffer disappears.

func (*BufferPool) SetActive ¶ added in v0.0.9

func (b *BufferPool) SetActive(active bool) (ok bool)

SetActive can be used to control the active state of pool. When the pool is inactive, new calls to AcquireBuffer will return with FlowFlushing.

Activating the bufferpool will preallocate all resources in the pool based on the configuration of the pool.

Deactivating will free the resources again when there are no outstanding buffers. When there are outstanding buffers, they will be freed as soon as they are all returned to the pool.

func (*BufferPool) SetConfig ¶ added in v0.0.9

func (b *BufferPool) SetConfig(cfg *BufferPoolConfig) bool

SetConfig sets the configuration of the pool. If the pool is already configured, and the configurations haven't changed, this function will return TRUE. If the pool is active, this method will return FALSE and active configurations will remain. Buffers allocated form this pool must be returned or else this function will do nothing and return FALSE.

config is a GstStructure that contains the configuration parameters for the pool. A default and mandatory set of parameters can be configured with gst_buffer_pool_config_set_params, gst_buffer_pool_config_set_allocator and gst_buffer_pool_config_add_option.

If the parameters in config can not be set exactly, this function returns FALSE and will try to update as much state as possible. The new state can then be retrieved and refined with GetConfig.

This function takes ownership of the given structure.

func (*BufferPool) SetFlushing ¶ added in v0.0.9

func (b *BufferPool) SetFlushing(flushing bool)

SetFlushing enables or disable the flushing state of a pool without freeing or allocating buffers.

func (*BufferPoolConfig) AddOption ¶ added in v0.0.9

func (b *BufferPoolConfig) AddOption(opt string)

AddOption enables the option in config. This will instruct the bufferpool to enable the specified option on the buffers that it allocates.

The supported options by pool can be retrieved with GetOptions.

func (*BufferPoolConfig) GetAllocator ¶ added in v0.0.9

func (b *BufferPoolConfig) GetAllocator() (*Allocator, *AllocationParams)

GetAllocator retrieves the allocator and params from config.

func (*BufferPoolConfig) GetOption ¶ added in v0.0.9

func (b *BufferPoolConfig) GetOption(index uint) string

GetOption retrieves the option at index of the options API array.

func (*BufferPoolConfig) GetParams ¶ added in v0.0.9

func (b *BufferPoolConfig) GetParams() (caps *Caps, size, minBuffers, maxBuffers uint)

GetParams retrieves the values from this config. All params return 0 or nil if they could not be fetched.

func (*BufferPoolConfig) HasOption ¶ added in v0.0.9

func (b *BufferPoolConfig) HasOption(opt string) bool

HasOption returns true if this config has the given option.

func (*BufferPoolConfig) NumOptions ¶ added in v0.0.9

func (b *BufferPoolConfig) NumOptions() uint

NumOptions retrieves the number of values currently stored in the options array of the config structure.

func (*BufferPoolConfig) SetAllocator ¶ added in v0.0.9

func (b *BufferPoolConfig) SetAllocator(allocator *Allocator, params *AllocationParams)

SetAllocator sets the allocator and params on config.

One of allocator and params can be nil, but not both. When allocator is nil, the default allocator of the pool will use the values in param to perform its allocation. When param is nil, the pool will use the provided allocator with its default AllocationParams.

A call to SetConfig on the BufferPool can update the allocator and params with the values that it is able to do. Some pools are, for example, not able to operate with different allocators or cannot allocate with the values specified in params. Use GetConfig on the pool to get the currently used values.

func (*BufferPoolConfig) SetParams ¶ added in v0.0.9

func (b *BufferPoolConfig) SetParams(caps *Caps, size, minBuffers, maxBuffers uint)

SetParams configures the config with the given parameters.

func (*BufferPoolConfig) Validate ¶ added in v0.0.9

func (b *BufferPoolConfig) Validate(caps *Caps, size, minBuffers, maxBuffers uint) bool

Validate that changes made to config are still valid in the context of the expected parameters. This function is a helper that can be used to validate changes made by a pool to a config when SetConfig returns FALSE. This expects that caps haven't changed and that min_buffers aren't lower then what we initially expected. This does not check if options or allocator parameters are still valid, and won't check if size have changed, since changing the size is valid to adapt padding.

func (BufferingMode) String ¶ added in v0.0.8

func (b BufferingMode) String() string

String implements a stringer on a BufferingMode.

func (*Bus) AddSignalWatch ¶ added in v0.0.9

func (b *Bus) AddSignalWatch()

AddSignalWatch adds a bus signal watch to the default main context with the default priority (%G_PRIORITY_DEFAULT). It is also possible to use a non-default main context set up using g_main_context_push_thread_default (before one had to create a bus watch source and attach it to the desired main context 'manually').

After calling this statement, the bus will emit the "message" signal for each message posted on the bus.

This function may be called multiple times. To clean up, the caller is responsible for calling RemoveSignalWatch as many times as this function is called.

func (*Bus) AddWatch ¶ added in v0.0.8

func (b *Bus) AddWatch(busFunc BusWatchFunc) bool

AddWatch adds a watch to the default MainContext for messages emitted on this bus. This function is used to receive asynchronous messages in the main loop. There can only be a single bus watch per bus, you must remove it before you can set a new one. It is safe to unref the Bus after setting this watch, since the watch itself will take it's own reference to the Bus.

The watch can be removed either by returning false from the function or by using RemoveWatch(). A MainLoop must be running for bus watches to work.

The return value reflects whether the watch was successfully added. False is returned if there is already a function registered.

func (*Bus) BlockPopMessage ¶

func (b *Bus) BlockPopMessage() *Message

BlockPopMessage blocks until a message is available on the bus and then returns it. This function can return nil if the bus is closed. The message should be unreffed after usage.

It is much safer and easier to use the AddWatch or other polling functions. Only use this method if you are unable to also run a MainLoop, or for convenience sake.

func (*Bus) DisableSyncMessageEmission ¶ added in v0.0.9

func (b *Bus) DisableSyncMessageEmission()

DisableSyncMessageEmission instructs GStreamer to stop emitting the "sync-message" signal for this bus. See EnableSyncMessageEmission for more information.

In the event that multiple pieces of code have called EnableSyncMessageEmission, the sync-message emissions will only be stopped after all calls to EnableSyncMessageEmission were "cancelled" by calling this function. In this way the semantics are exactly the same as Ref that which calls enable should also call disable.

func (*Bus) EnableSyncMessageEmission ¶ added in v0.0.9

func (b *Bus) EnableSyncMessageEmission()

EnableSyncMessageEmission instructs GStreamer to emit the "sync-message" signal after running the bus's sync handler. This function is here so that code can ensure that they can synchronously receive messages without having to affect what the bin's sync handler is.

This function may be called multiple times. To clean up, the caller is responsible for calling DisableSyncMessageEmission as many times as this function is called.

While this function looks similar to AddSignalWatch, it is not exactly the same -- this function enables *synchronous* emission of signals when messages arrive; AddSignalWatch adds an idle callback to pop messages off the bus asynchronously. The sync-message signal comes from the thread of whatever object posted the message; the "message" signal is marshalled to the main thread via the main loop.

func (*Bus) GetPollFd ¶ added in v0.0.9

func (b *Bus) GetPollFd() *PollFd

GetPollFd gets the file descriptor from the bus which can be used to get notified about messages being available with functions like g_poll, and allows integration into other event loops based on file descriptors. Whenever a message is available, the POLLIN / G_IO_IN event is set.

Warning: NEVER read or write anything to the returned fd but only use it for getting notifications via g_poll or similar and then use the normal GstBus API, e.g. PopMessage.

func (*Bus) HavePending ¶ added in v0.0.9

func (b *Bus) HavePending() bool

HavePending checks if there are pending messages on the bus that should be handled.

func (*Bus) Instance ¶

func (b *Bus) Instance() *C.GstBus

Instance returns the underlying GstBus instance.

func (*Bus) Peek ¶ added in v0.0.9

func (b *Bus) Peek() *Message

Peek peeks the message on the top of the bus' queue. The message will remain on the bus' message queue. A reference is returned, and needs to be unreffed by the caller.

func (*Bus) Poll ¶ added in v0.0.9

func (b *Bus) Poll(msgTypes MessageType, timeout time.Duration) *Message

Poll the bus for messages. Will block while waiting for messages to come. You can specify a maximum time to poll with the timeout parameter. If timeout is negative, this function will block indefinitely.

All messages not in events will be popped off the bus and will be ignored. It is not possible to use message enums beyond MessageExtended in the events mask.

Because poll is implemented using the "message" signal enabled by AddSignalWatch, calling Poll will cause the "message" signal to be emitted for every message that poll sees. Thus a "message" signal handler will see the same messages that this function sees -- neither will steal messages from the other.

This function will run a main loop from the default main context when polling.

You should never use this function, since it is pure evil. This is especially true for GUI applications based on Gtk+ or Qt, but also for any other non-trivial application that uses the GLib main loop. As this function runs a GLib main loop, any callback attached to the default GLib main context may be invoked. This could be timeouts, GUI events, I/O events etc.; even if Poll is called with a 0 timeout. Any of these callbacks

may do things you do not expect, e.g. destroy the main application window or some other resource; change other

application state; display a dialog and run another main loop until the user clicks it away. In short, using this function may add a lot of complexity to your code through unexpected re-entrancy and unexpected changes to your application's state.

For 0 timeouts use gst_bus_pop_filtered instead of this function; for other short timeouts use TimedPopFiltered; everything else is better handled by setting up an asynchronous bus watch and doing things from there.

func (*Bus) Pop ¶ added in v0.0.9

func (b *Bus) Pop() *Message

Pop pops a message from the bus, or returns nil if none are available.

func (*Bus) PopFiltered ¶ added in v0.0.9

func (b *Bus) PopFiltered(msgTypes MessageType) *Message

PopFiltered gets a message matching type from the bus. Will discard all messages on the bus that do not match type and that have been posted before the first message that does match type. If there is no message matching type on the bus, all messages will be discarded. It is not possible to use message enums beyond MessageExtended in the events mask.

func (*Bus) PopMessage ¶ added in v0.0.2

func (b *Bus) PopMessage(timeout int) *Message

PopMessage attempts to pop a message from the bus. It returns nil if none are available. The message should be unreffed after usage.

It is much safer and easier to use the AddWatch or other polling functions. Only use this method if you are unable to also run a MainLoop, or for convenience sake.

func (*Bus) Post ¶ added in v0.0.9

func (b *Bus) Post(msg *Message) bool

Post a new message on the bus. The bus takes ownership of the message.

func (*Bus) RemoveSignalWatch ¶ added in v0.0.9

func (b *Bus) RemoveSignalWatch()

RemoveSignalWatch removes a signal watch previously added with AddSignalWatch.

func (*Bus) RemoveWatch ¶ added in v0.0.8

func (b *Bus) RemoveWatch() bool

RemoveWatch will remove any watches installed on the bus. This can also be accomplished by returning false from a previously installed function.

The function returns false if there was no watch on the bus.

func (*Bus) SetFlushing ¶ added in v0.0.9

func (b *Bus) SetFlushing(flushing bool)

SetFlushing sets whether to flush out and unref any messages queued in the bus. Releases references to the message origin objects. Will flush future messages until SetFlushing sets flushing to FALSE.

func (*Bus) SetSyncHandler ¶ added in v0.0.9

func (b *Bus) SetSyncHandler(f BusSyncHandler)

SetSyncHandler sets the synchronous handler on the bus. The function will be called every time a new message is posted on the bus. Note that the function will be called in the same thread context as the posting object. This function is usually only called by the creator of the bus. Applications should handle messages asynchronously using the watch and poll functions.

Currently, destroyNotify funcs are not supported.

func (*Bus) TimedPop ¶ added in v0.0.9

func (b *Bus) TimedPop(dur time.Duration) *Message

TimedPop gets a message from the bus, waiting up to the specified timeout. Unref returned messages after usage.

If timeout is 0, this function behaves like Pop. If timeout is < 0, this function will block forever until a message was posted on the bus.

func (*Bus) TimedPopFiltered ¶ added in v0.0.9

func (b *Bus) TimedPopFiltered(dur time.Duration, msgTypes MessageType) *Message

TimedPopFiltered gets a message from the bus whose type matches the message type mask types, waiting up to the specified timeout (and discarding any messages that do not match the mask provided).

If timeout is 0, this function behaves like PopFiltered. If timeout is < 0, this function will block forever until a matching message was posted on the bus.

func (*Caps) Append ¶

func (c *Caps) Append(caps *Caps)

Append appends the given caps element to these caps. These caps take ownership over the given object. If either caps are ANY, the resulting caps will be ANY.

func (*Caps) AppendStructure ¶

func (c *Caps) AppendStructure(st *Structure)

AppendStructure appends the given structure to this caps instance.

func (*Caps) AppendStructureFull ¶ added in v0.0.9

func (c *Caps) AppendStructureFull(st *Structure, features *CapsFeatures)

AppendStructureFull appends structure with features to caps. The structure is not copied; caps becomes the owner of structure.

func (*Caps) CanIntersect ¶ added in v0.0.9

func (c *Caps) CanIntersect(caps *Caps) bool

CanIntersect tries intersecting these caps with those given and reports whether the result would not be empty.

func (*Caps) Copy ¶ added in v0.0.9

func (c *Caps) Copy() *Caps

Copy creates a new Caps as a copy of these. The new caps will have a refcount of 1, owned by the caller. The structures are copied as well.

Note that this function is the semantic equivalent of a Ref followed by a MakeWritable. If you only want to hold on to a reference to the data, you should use Ref.

When you are finished with the caps, call Unref on it.

func (*Caps) CopyNth ¶ added in v0.0.9

func (c *Caps) CopyNth(n uint) *Caps

CopyNth creates a new GstCaps and appends a copy of the nth structure contained in caps.

func (*Caps) FilterAndMapInPlace ¶ added in v0.0.9

func (c *Caps) FilterAndMapInPlace(f CapsMapFunc)

FilterAndMapInPlace calls the provided function once for each structure and caps feature in the Caps. In contrast to ForEach, the function may modify the structure and features. In contrast to MapInPlace, the structure and features are removed from the caps if FALSE is returned from the function. The caps must be mutable.

caps := gst.NewCapsFromString("audio/x-raw")

caps.FilterAndMapInPlace(func(features *gst.CapsFeatures, structure *gst.Structure) bool {
    if features.Contains(gst.CapsFeatureMemorySystemMemory) {
        fmt.Println("Removing system memory feature")
        return false
    }
    return true
})

fmt.Println(caps.IsEmpty())

// Removing system memory feature
// true

func (*Caps) Fixate ¶ added in v0.0.9

func (c *Caps) Fixate() *Caps

Fixate modifies the given caps into a representation with only fixed values. First the caps will be truncated and then the first structure will be fixated with Structure's Fixate.

This function takes ownership of caps and will call gst_caps_make_writable on it so you must not use caps afterwards unless you keep an additional reference to it with Ref.

Note that it is not guaranteed that the returned caps have exactly one structure. If caps are empty caps then then returned caps will be the empty too and contain no structure at all.

Calling this function with any caps is not allowed.

func (*Caps) ForEach ¶ added in v0.0.9

func (c *Caps) ForEach(f CapsMapFunc) bool

ForEach calls the provided function once for each structure and caps feature in the GstCaps. The function must not modify the fields. There is an unresolved bug in this function currently and it is better to use MapInPlace instead.

caps := gst.NewCapsFromString("audio/x-raw")

caps.ForEach(func(features *gst.CapsFeatures, structure *gst.Structure) bool {
    fmt.Println(structure)
    return true
})

// audio/x-raw;

func (*Caps) GetFeaturesAt ¶

func (c *Caps) GetFeaturesAt(idx int) *CapsFeatures

GetFeaturesAt returns the feature at the given index, or nil if none exists.

func (*Caps) GetSize ¶ added in v0.0.9

func (c *Caps) GetSize() int

GetSize returns the number of structures inside this caps instance.

func (*Caps) GetStructureAt ¶

func (c *Caps) GetStructureAt(idx int) *Structure

GetStructureAt returns the structure at the given index, or nil if none exists.

func (*Caps) Instance ¶

func (c *Caps) Instance() *C.GstCaps

Instance returns the native GstCaps instance

func (*Caps) Intersect ¶ added in v0.0.9

func (c *Caps) Intersect(caps *Caps) *Caps

Intersect creates a new Caps that contains all the formats that are common to both these caps and those given. Defaults to CapsIntersectZigZag mode.

func (*Caps) IntersectFull ¶ added in v0.0.9

func (c *Caps) IntersectFull(caps *Caps, mode CapsIntersectMode) *Caps

IntersectFull creates a new Caps that contains all the formats that are common to both these caps those given. The order is defined by the CapsIntersectMode used.

func (*Caps) IsAlwaysCompatible ¶ added in v0.0.9

func (c *Caps) IsAlwaysCompatible(caps *Caps) bool

IsAlwaysCompatible returns if this structure is always compatible with another if every media format that is in the first is also contained in the second. That is, these caps are a subset of those given.

func (*Caps) IsAny ¶

func (c *Caps) IsAny() bool

IsAny returns true if these caps match any media format.

func (*Caps) IsEmpty ¶

func (c *Caps) IsEmpty() bool

IsEmpty returns true if these caps are empty.

func (*Caps) IsEqual ¶ added in v0.0.9

func (c *Caps) IsEqual(caps *Caps) bool

IsEqual returns true if the caps given represent the same set as these.

func (*Caps) IsEqualFixed ¶ added in v0.0.9

func (c *Caps) IsEqualFixed(caps *Caps) bool

IsEqualFixed tests if the Caps are equal. This function only works on fixed Caps.

func (*Caps) IsFixed ¶ added in v0.0.9

func (c *Caps) IsFixed() bool

IsFixed returns true if these caps are fixed, that is, they describe exactly one format.

func (*Caps) IsStrictlyEqual ¶ added in v0.0.9

func (c *Caps) IsStrictlyEqual(caps *Caps) bool

IsStrictlyEqual checks if the given caps are exactly the same set of caps.

func (*Caps) IsSubset ¶ added in v0.0.9

func (c *Caps) IsSubset(caps *Caps) bool

IsSubset checks if all caps represented by these are also represented by those given.

func (*Caps) IsSubsetStructure ¶ added in v0.0.9

func (c *Caps) IsSubsetStructure(structure *Structure) bool

IsSubsetStructure checks if the given structure is a subset of these caps.

func (*Caps) IsSubsetStructureFull ¶ added in v0.0.9

func (c *Caps) IsSubsetStructureFull(structure *Structure, features *CapsFeatures) bool

IsSubsetStructureFull checks if the given structure is a subset of these caps with features.

func (*Caps) IsWritable ¶ added in v0.0.9

func (c *Caps) IsWritable() bool

IsWritable returns true if these caps are writable.

func (*Caps) MakeWritable ¶ added in v0.0.9

func (c *Caps) MakeWritable() *Caps

MakeWritable returns a writable copy of caps.

func (*Caps) MapInPlace ¶ added in v0.0.9

func (c *Caps) MapInPlace(f CapsMapFunc) bool

MapInPlace calls the provided function once for each structure and caps feature in the Caps. In contrast to ForEach, the function may modify, but not delete, the structures and features. The caps must be mutable.

func (*Caps) Merge ¶ added in v0.0.9

func (c *Caps) Merge(caps *Caps) *Caps

Merge appends the structures contained in the given caps if they are not yet expressed by these. The structures in the given caps are not copied -- they are transferred to a writable copy of these ones, and then those given are freed. If either caps are ANY, the resulting caps will be ANY.

func (*Caps) MergeStructure ¶ added in v0.0.9

func (c *Caps) MergeStructure(structure *Structure) *Caps

MergeStructure appends structure to caps if its not already expressed by caps.

func (*Caps) MergeStructureFull ¶ added in v0.0.9

func (c *Caps) MergeStructureFull(structure *Structure, features *CapsFeatures) *Caps

MergeStructureFull appends structure with features to the caps if its not already expressed.

func (*Caps) Normalize ¶ added in v0.0.9

func (c *Caps) Normalize() *Caps

Normalize returns a Caps that represents the same set of formats as caps, but contains no lists. Each list is expanded into separate GstStructures.

This function takes ownership of caps and will call MakeWritable on it so you must not use caps afterwards unless you keep an additional reference to it with Ref.

func (*Caps) Ref ¶

func (c *Caps) Ref() *Caps

Ref increases the ref count on these caps by one.

From this point on, until the caller calls Unref or MakeWritable, it is guaranteed that the caps object will not change. This means its structures won't change, etc. To use a Caps object, you must always have a refcount on it -- either the one made implicitly by e.g. NewSimpleCaps, or via taking one explicitly with this function. Note that when a function provided by these bindings returns caps, or they are converted through the FromGstCapsUnsafe methods, a ref is automatically taken if necessary and a runtime Finalizer is used to remove it.

func (*Caps) RemoveStructureAt ¶ added in v0.0.9

func (c *Caps) RemoveStructureAt(idx uint)

RemoveStructureAt removes the structure with the given index from the list of structures.

func (*Caps) SetFeaturesAt ¶ added in v0.0.9

func (c *Caps) SetFeaturesAt(idx uint, features *CapsFeatures)

SetFeaturesAt sets the CapsFeatures features for the structure at index.

func (*Caps) SetFeaturesSimple ¶ added in v0.0.9

func (c *Caps) SetFeaturesSimple(features *CapsFeatures)

SetFeaturesSimple sets the CapsFeatures for all the structures of these caps.

func (*Caps) SetValue ¶ added in v0.0.9

func (c *Caps) SetValue(field string, val interface{})

SetValue sets the given field on all structures of caps to the given value. This is a convenience function for calling SetValue on all structures of caps. If the value cannot be coerced to a C type, then nothing will happen.

func (*Caps) Simplify ¶ added in v0.0.9

func (c *Caps) Simplify() *Caps

Simplify converts the given caps into a representation that represents the same set of formats, but in a simpler form. Component structures that are identical are merged. Component structures that have values that can be merged are also merged.

This function takes ownership of caps and will call MakeWritable on it if necessary, so you must not use caps afterwards unless you keep an additional reference to it with Ref.

This method does not preserve the original order of caps.

func (*Caps) StealStructureAt ¶ added in v0.0.9

func (c *Caps) StealStructureAt(idx uint) *Structure

StealStructureAt retrieves the structure with the given index from the list of structures contained in caps. The caller becomes the owner of the returned structure.

func (*Caps) String ¶ added in v0.0.9

func (c *Caps) String() string

String implements a stringer on a caps instance. This same string can be used for NewCapsFromString.

func (*Caps) Subtract ¶ added in v0.0.9

func (c *Caps) Subtract(caps *Caps) *Caps

Subtract subtracts the given caps from these.

func (*Caps) ToGValue ¶ added in v0.1.16

func (c *Caps) ToGValue() (*glib.Value, error)

ToGValue returns a GValue containing the given caps.

func (*Caps) Truncate ¶ added in v0.0.9

func (c *Caps) Truncate() *Caps

Truncate discards all but the first structure from caps. Useful when fixating.

This function takes ownership of caps and will call gst_caps_make_writable on it if necessary, so you must not use caps afterwards unless you keep an additional reference to it with Ref.

Note that it is not guaranteed that the returned caps have exactly one structure. If caps is any or empty caps then then returned caps will be the same and contain no structure at all.

func (*Caps) Unref ¶

func (c *Caps) Unref()

Unref decreases the ref count on these caps by one.

func (*Caps) Unsafe ¶ added in v0.2.5

func (c *Caps) Unsafe() unsafe.Pointer

Unsafe returns an unsafe.Pointer to the underlying GstCaps.

func (*CapsFeatures) Add ¶ added in v0.0.9

func (c *CapsFeatures) Add(feature string)

Add adds the given feature to these.

feats := gst.NewCapsFeaturesEmpty()

fmt.Println(feats.GetSize())

feats.Add(gst.CapsFeatureMemorySystemMemory)

fmt.Println(feats.GetSize())
fmt.Println(feats.Contains(gst.CapsFeatureMemorySystemMemory))
fmt.Println(feats.GetNth(0))

// 0
// 1
// true
// memory:SystemMemory

func (*CapsFeatures) Contains ¶ added in v0.0.9

func (c *CapsFeatures) Contains(feature string) bool

Contains returns true if the given feature is included in these.

func (*CapsFeatures) Copy ¶ added in v0.0.9

func (c *CapsFeatures) Copy() *CapsFeatures

Copy duplicates these features and all of it's values.

func (*CapsFeatures) Free ¶ added in v0.0.9

func (c *CapsFeatures) Free()

Free frees the memory containing these features. Only call this if you do not intend to pass these features to other methods.

func (*CapsFeatures) GetNth ¶ added in v0.0.9

func (c *CapsFeatures) GetNth(idx uint) string

GetNth returns the feature at index.

func (*CapsFeatures) GetSize ¶ added in v0.0.9

func (c *CapsFeatures) GetSize() uint

GetSize returns the number of features.

func (*CapsFeatures) Instance ¶

func (c *CapsFeatures) Instance() *C.GstCapsFeatures

Instance returns the native underlying GstCapsFeatures instance.

func (*CapsFeatures) IsAny ¶

func (c *CapsFeatures) IsAny() bool

IsAny returns true if these features match any.

func (*CapsFeatures) IsEqual ¶ added in v0.0.9

func (c *CapsFeatures) IsEqual(feats *CapsFeatures) bool

IsEqual returns true if the given CapsFeatures are equal to the provided ones. If the provided structure is nil, this function immediately returns false.

func (*CapsFeatures) Remove ¶ added in v0.0.9

func (c *CapsFeatures) Remove(feature string)

Remove removes the given feature.

func (*CapsFeatures) SetParentRefCount ¶ added in v0.0.9

func (c *CapsFeatures) SetParentRefCount(refCount int) bool

SetParentRefCount sets the parent_refcount field of CapsFeatures. This field is used to determine whether a caps features is mutable or not. This function should only be called by code implementing parent objects of CapsFeatures, as described in the MT Refcounting section of the design documents.

func (*CapsFeatures) String ¶

func (c *CapsFeatures) String() string

String implements a stringer on caps features.

feats := gst.NewCapsFeaturesAny()
fmt.Println(feats.String())
// ANY

func (*CapsFeatures) ToGValue ¶ added in v0.2.15

func (c *CapsFeatures) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer

func (*ChildProxy) ChildAdded ¶ added in v0.2.4

func (c *ChildProxy) ChildAdded(child *glib.Object, name string)

ChildAdded emits the "child-added" signal.

func (*ChildProxy) ChildRemoved ¶ added in v0.2.4

func (c *ChildProxy) ChildRemoved(child *glib.Object, name string)

ChildRemoved emits the "child-removed" signal.

func (*ChildProxy) Get ¶ added in v0.2.4

func (c *ChildProxy) Get(names ...string) []*glib.Value

Get gets properties of the parent object and its children. This is a direct alias to looping over GetProperty and returning the results in the order of the arguments. If any of the results returns nil from an allocation error, nil is returned for the entire slice.

func (*ChildProxy) GetChildByIndex ¶ added in v0.2.4

func (c *ChildProxy) GetChildByIndex(idx uint) *glib.Object

GetChildByIndex fetches a child by its number. This function can return nil if the object is not found. Unref after usage.

func (*ChildProxy) GetChildByName ¶ added in v0.2.4

func (c *ChildProxy) GetChildByName(name string) *glib.Object

GetChildByName fetches a child by name. The virtual method's default implementation uses Object together with Object.GetName. If the interface is to be used with GObjects, this method needs to be overridden.

This function can return nil if the object is not found. Unref after usage.

func (*ChildProxy) GetChildrenCount ¶ added in v0.2.4

func (c *ChildProxy) GetChildrenCount() uint

GetChildrenCount returns the number of child objects the parent contains.

func (*ChildProxy) GetProperty ¶ added in v0.2.4

func (c *ChildProxy) GetProperty(name string) *glib.Value

GetProperty gets a single property using the ChildProxy mechanism. The bindings take care of freeing the value when it leaves the user's scope. This function can return nil if a failure happens trying to allocate GValues.

func (*ChildProxy) Instance ¶ added in v0.2.4

func (c *ChildProxy) Instance() *C.GstChildProxy

Instance returns the underlying GstChildProxy instance.

func (*ChildProxy) Lookup ¶ added in v0.2.4

func (c *ChildProxy) Lookup(name string) (ok bool, target *glib.Object, param *glib.ParamSpec)

Lookup looks up which object and and parameter would be affected by the given name. If ok is false, the targets could not be found and this function returned nil. Unref target after usage.

func (*ChildProxy) Set ¶ added in v0.2.4

func (c *ChildProxy) Set(values map[string]*glib.Value)

Set takes a map of names to values and applies them using the ChildProxy mechanism.

func (*ChildProxy) SetProperty ¶ added in v0.2.4

func (c *ChildProxy) SetProperty(name string, value *glib.Value)

SetProperty sets a single property using the ChildProxy mechanism.