gst

package
v0.0.0-...-60d5db4 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 18, 2023 License: LGPL-2.1 Imports: 18 Imported by: 0

Documentation

Overview

Package gst contains bindings for the gstreamer C API. If you are trying to build simple pipelines quickly (and optiionally readers/writers) see the gstauto package.

Index

Constants

View Source
const (
	ParameterControllable   = C.GST_PARAM_CONTROLLABLE
	ParameterMutablePlaying = C.GST_PARAM_MUTABLE_PLAYING
	ParameterMutablePaused  = C.GST_PARAM_MUTABLE_PAUSED
	ParameterMutableReady   = C.GST_PARAM_MUTABLE_READY
)

Additional GStreamer ParamSpec flags

Variables

View Source
var BufferOffsetNone time.Duration = time.Duration(-1)

BufferOffsetNone is a var for no-offset return results.

View Source
var (
	CapsFeatureMemorySystemMemory string = C.GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY
)

Go casting of pre-baked caps features

View Source
var ClockTimeNone time.Duration = time.Duration(-1)

ClockTimeNone means infinite timeout or an empty value

View Source
var ExtendsBin glib.Extendable = &extendsBin{parent: ExtendsElement}

ExtendsBin implements an Extendable object based on a GstBin.

View Source
var ExtendsElement glib.Extendable = &extendElement{parent: glib.ExtendsObject}

ExtendsElement implements an Extendable object based on a GstElement.

View Source
var InterfaceChildProxy glib.Interface = &interfaceChildProxy{}

InterfaceChildProxy represents the GstChildProxy interface. Use this when querying bins for elements that implement GstChildProxy, or when signaling that a GoObjectSubclass provides this interface.

View Source
var InterfaceTOCSetter = glib.Type(C.GST_TYPE_TOC_SETTER)

InterfaceTOCSetter represents the GstTocSetter interface GType. Use this when querying bins for elements that implement a TOCSetter.

View Source
var InterfaceTagSetter glib.Interface = &interfaceTagSetter{}

InterfaceTagSetter represents the GstTagsetter interface GType. Use this when querying bins for elements that implement a TagSetter. Extending this interface is not yet implemented.

View Source
var InterfaceURIHandler glib.Interface = &interfaceURIHandler{}

InterfaceURIHandler represents the GstURIHandler interface GType. Use this when querying bins for elements that implement a URIHandler, or when signaling that a GoObjectSubclass provides this interface. Note that the way this interface is implemented, it can only be used once per plugin.

View Source
var TypeBitmask = glib.Type(C.gst_bitmask_get_type())

TypeBitmask is the GType for a bitmask value.

TypeCaps is the static Glib Type for a GstCaps.

View Source
var TypeCapsFeatures = glib.Type(C.gst_caps_features_get_type())

TypeCapsFeatures is the glib.Type for a CapsFeatures.

View Source
var TypeFlagset = glib.Type(C.gst_flagset_get_type())

TypeFlagset is the GType for a Flagset

View Source
var TypeFloat64Range = glib.Type(C.gst_double_range_get_type())

TypeFloat64Range is the GType for a range of 64-bit floating point numbers. This is the equivalent of a GstDoubleRange.

View Source
var TypeFraction = glib.Type(C.gst_fraction_get_type())

TypeFraction is the GType for a GstFraction

View Source
var TypeFractionRange = glib.Type(C.gst_fraction_range_get_type())

TypeFractionRange is the GType for a GstFractionRange

View Source
var TypeInt64Range = glib.Type(C.gst_int64_range_get_type())

TypeInt64Range is the GType for a range of 64-bit integers.

View Source
var TypeIntRange = glib.Type(C.gst_int_range_get_type())

TypeIntRange is the GType for a range of integers.

View Source
var TypeStructure = glib.Type(C.gst_structure_get_type())

TypeStructure is the glib.Type for a Structure.

View Source
var TypeValueArray = glib.Type(C.gst_value_array_get_type())

TypeValueArray is the GType for a GstValueArray

View Source
var TypeValueList = glib.Type(C.gst_value_list_get_type())

TypeValueList is the GType for a GstValueList

Functions

func APIHasTag

func APIHasTag(api glib.Type, tag string) bool

APIHasTag returns true if the given api has the given tag.

func Deinit

func Deinit()

Deinit is a wrapper for gst_deinit Clean up any resources created by GStreamer in gst_init(). It is normally not needed to call this function in a normal application as the resources will automatically be freed when the program terminates. This function is therefore mostly used by testsuites and other memory profiling tools.

func ElementLinkMany

func ElementLinkMany(elems ...*Element) error

ElementLinkMany is a go implementation of `gst_element_link_many` to compensate for no variadic functions in cgo.

func FilterProtectionSystemByDecryptors

func FilterProtectionSystemByDecryptors(decryptors []string) []string

FilterProtectionSystemByDecryptors tterates the supplied list of UUIDs and checks the GstRegistry for all the decryptors supporting one of the supplied UUIDs.

func GetAPITags

func GetAPITags(apiType glib.Type) []string

GetAPITags retrieves the tags for the given api type.

func GetMaxBufferMemory

func GetMaxBufferMemory() uint64

GetMaxBufferMemory returns the maximum amount of memory a buffer can hold.

func Init

func Init(args *[]string)

Init is a wrapper around gst_init() and must be called before any other gstreamer calls and is used to initialize everything necessary. In addition to setting up gstreamer for usage, a pointer to a slice of strings may be passed in to parse standard gst command line arguments. args will be modified to remove any flags that were handled. Alternatively, nil may be passed in to not perform any command line parsing.

The bindings will also set up their own internal DebugCategory for logging than can be invoked from applications or plugins as well. However, for plugins it is generally better to initialize your own DebugCategory.

func NextGroupID

func NextGroupID() uint

NextGroupID returns a new group id that can be used for an event.

func RegisterAPIType

func RegisterAPIType(name string, tags []string) glib.Type

RegisterAPIType registers and returns a GType for the given api name and associates it with tags.

func RegisterElement

func RegisterElement(plugin *Plugin, name string, rank Rank, elem glib.GoObjectSubclass, extends glib.Extendable, interfaces ...glib.Interface) bool

RegisterElement creates a new elementfactory capable of instantiating objects of the given GoElement and adds the factory to the plugin. A higher rank means more importance when autoplugging.

func RegisterPlugin

func RegisterPlugin(desc *PluginMetadata, initFunc PluginInitFunc) bool

RegisterPlugin will register a static plugin, i.e. a plugin which is private to an application or library and contained within the application or library (as opposed to being shipped as a separate module file).

func SelectProtectionSystem

func SelectProtectionSystem(decryptors []string) string

SelectProtectionSystem iterates the supplied list of UUIDs and checks the GstRegistry for an element that supports one of the supplied UUIDs. If more than one element matches, the system ID of the highest ranked element is selected.

func ValueDeserialize

func ValueDeserialize(data string, t glib.Type) (value *glib.Value, ok bool)

ValueDeserialize tries to deserialize a string into a glib.Value of the type specified. If the operation succeeds, TRUE is returned, FALSE otherwise.

func ValueFixate

func ValueFixate(src *glib.Value, dest *glib.Value) (ok bool)

ValueFixate fixates src into a new value dest. For ranges, the first element is taken. For lists and arrays, the first item is fixated and returned. If src is already fixed, this function returns FALSE.

func ValueFractionMultiply

func ValueFractionMultiply(factor1, factor2 *glib.Value) (product *glib.Value, ok bool)

ValueFractionMultiply multiplies the two GValue items containing a TypeFraction and returns the product. This function can return false if any error occurs, such as in memory allocation or an integer overflow.

func ValueFractionSubtract

func ValueFractionSubtract(minuend, subtrahend *glib.Value) (result *glib.Value, ok bool)

ValueFractionSubtract subtracts the subtrahend from the minuend containing a TypeFraction and returns the result. This function can return false if any error occurs, such as in memory allocation or an integer overflow.

func ValueIntersect

func ValueIntersect(value1, value2 *glib.Value) (*glib.Value, bool)

ValueIntersect calculates the intersection of two values. If the values have a non-empty intersection, the value representing the intersection isreturned. Otherwise this function returns false. This function can also return false for any allocation errors.

func ValueIsFixed

func ValueIsFixed(value *glib.Value) bool

ValueIsFixed tests if the given GValue, if available in a Structure (or any other container) contains a "fixed" (which means: one value) or an "unfixed" (which means: multiple possible values, such as data lists or data ranges) value.

func ValueIsSubset

func ValueIsSubset(value1, value2 *glib.Value) bool

ValueIsSubset checks that value1 is a subset of value2.

func ValueSerialize

func ValueSerialize(value *glib.Value) string

ValueSerialize attempts to serialize the given value into a string. An empty string is returned if no serializer exists.

func ValueSubtract

func ValueSubtract(minuend, subtrahend *glib.Value) (*glib.Value, bool)

ValueSubtract subtracts subtrahend from minuend and returns the resule. Note that this means subtraction as in sets, not as in mathematics. This function can return false if the subtraction is empty or any error occurs.

func ValueUnion

func ValueUnion(value1, value2 *glib.Value) (*glib.Value, bool)

ValueUnion creates a GValue corresponding to the union of value1 and value2.

func ValuesCanCompare

func ValuesCanCompare(val1, val2 *glib.Value) bool

ValuesCanCompare determines if val1 and val2 can be compared.

func ValuesCanIntersect

func ValuesCanIntersect(val1, val2 *glib.Value) bool

ValuesCanIntersect determines if intersecting two values will return a valid result. Two values will produce a valid intersection if they are the same type.

func ValuesCanSubtract

func ValuesCanSubtract(minuend, subtrahend *glib.Value) bool

ValuesCanSubtract checks if it's possible to subtract subtrahend from minuend.

func ValuesCanUnion

func ValuesCanUnion(val1, val2 *glib.Value) bool

ValuesCanUnion determines if val1 and val2 can be non-trivially unioned. Any two values can be trivially unioned by adding both of them to a GstValueList. However, certain types have the possibility to be unioned in a simpler way. For example, an integer range and an integer can be unioned if the integer is a subset of the integer range. If there is the possibility that two values can be unioned, this function returns TRUE.

Types

type AllocationParams

type AllocationParams struct {
	// contains filtered or unexported fields
}

AllocationParams wraps the GstAllocationParams.

func FromGstAllocationParamsUnsafe

func FromGstAllocationParamsUnsafe(alloc unsafe.Pointer) *AllocationParams

FromGstAllocationParamsUnsafe wraps the given unsafe.Pointer in an AllocationParams instance.

func NewAllocationParams

func NewAllocationParams() *AllocationParams

NewAllocationParams initializes a set of allocation params with the default values.

func (*AllocationParams) Copy

Copy copies these AllocationParams.

func (*AllocationParams) Free

func (a *AllocationParams) Free()

Free frees the underlying AllocationParams

func (*AllocationParams) GetAlignment

func (a *AllocationParams) GetAlignment() int64

GetAlignment returns the desired alignment of the memory.

func (*AllocationParams) GetFlags

func (a *AllocationParams) GetFlags() MemoryFlags

GetFlags returns the flags on these AllocationParams.

func (*AllocationParams) GetPadding

func (a *AllocationParams) GetPadding() int64

GetPadding returns the desired padding size.

func (*AllocationParams) GetPrefix

func (a *AllocationParams) GetPrefix() int64

GetPrefix returns the desired prefix size.

func (*AllocationParams) Init

func (a *AllocationParams) Init()

Init initializes these AllocationParams to their original values.

func (*AllocationParams) Instance

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

Instance returns the underlying GstAllocationParams.

func (*AllocationParams) SetAlignment

func (a *AllocationParams) SetAlignment(align int64)

SetAlignment sets the desired alignment of the memory.

func (*AllocationParams) SetFlags

func (a *AllocationParams) SetFlags(flags MemoryFlags)

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

func (*AllocationParams) SetPadding

func (a *AllocationParams) SetPadding(padding int64)

SetPadding sets the desired padding size.

func (*AllocationParams) SetPrefix

func (a *AllocationParams) SetPrefix(prefix int64)

SetPrefix sets the desired prefix size.

type Allocator

type Allocator struct{ *Object }

Allocator is a go representation of a GstAllocator

func DefaultAllocator

func DefaultAllocator() *Allocator

DefaultAllocator returns the default GstAllocator.

func FromGstAllocatorUnsafeFull

func FromGstAllocatorUnsafeFull(alloc unsafe.Pointer) *Allocator

FromGstAllocatorUnsafeFull wraps the given unsafe.Pointer in an Allocator instance.

func FromGstAllocatorUnsafeNone

func FromGstAllocatorUnsafeNone(alloc unsafe.Pointer) *Allocator

FromGstAllocatorUnsafeNone wraps the given unsafe.Pointer in an Allocator instance.

func (*Allocator) Alloc

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

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

Free memory that was originally allocated with this allocator.

func (*Allocator) Instance

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

Instance returns the underlying GstAllocator instance.

func (*Allocator) MemType

func (a *Allocator) MemType() string

MemType returns the memory type for this allocator.

type Bin

type Bin struct{ *Element }

Bin is a go wrapper arounds a GstBin.

func NewBin

func NewBin(name string) *Bin

NewBin returns a new Bin with the given name.

func NewBinFromString

func NewBinFromString(description string, ghostUnlinkedPads bool) (*Bin, error)

NewBinFromString constructs a bin from a string description. description - command line describing the bin ghostUnlinkedPads - whether to automatically create ghost pads for unlinked source or sink pads within the bin

func ToGstBin

func ToGstBin(obj interface{}) *Bin

ToGstBin wraps the given glib.Object, gst.Object, or gst.Element in a Bin instance. Only works for objects that implement their own Bin.

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

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

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

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

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

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

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

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

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

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

func (*Bin) GetElementsSorted

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

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

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

ParentAddElement chains up to the parent AddElement handler.

func (*Bin) ParentDeepElementAdded

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

ParentDeepElementAdded chains up to the parent DeepElementAdded handler.

func (*Bin) ParentDeepElementRemoved

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

ParentDeepElementRemoved chains up to the parent DeepElementRemoved handler.

func (*Bin) ParentDoLatency

func (b *Bin) ParentDoLatency() bool

ParentDoLatency chains up to the parent DoLatency handler.

func (*Bin) ParentElementAdded

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

ParentElementAdded chains up to the parent ElementAdded handler.

func (*Bin) ParentElementRemoved

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

ParentElementRemoved chains up to the parent ElementRemoved handler.

func (*Bin) ParentHandleMessage

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

ParentHandleMessage chains up to the parent HandleMessage handler.

func (*Bin) ParentRemoveElement

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

ParentRemoveElement chains up to the parent RemoveElement handler.

func (*Bin) RecalculateLatency

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

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

Remove removes an element from the Bin.

func (*Bin) RemoveMany

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

RemoveMany is a go implementation of `gst_bin_remove_many`.

func (*Bin) SetSuppressedFlags

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

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.

type BinImpl

type BinImpl interface {
	AddElement(self *Bin, element *Element) bool
	DeepElementAdded(self *Bin, subbin *Bin, child *Element)
	DeepElementRemoved(self *Bin, subbin *Bin, child *Element)
	DoLatency(self *Bin) bool
	ElementAdded(self *Bin, child *Element)
	ElementRemoved(self *Bin, child *Element)
	HandleMessage(self *Bin, msg *Message)
	RemoveElement(self *Bin, element *Element) bool
}

BinImpl is the reference interface for Go elements extending a Bin. You only need to implement the methods that interest you.

type Bitmask

type Bitmask uint64

Bitmask represents a bitmask value.

func ValueGetBitmask

func ValueGetBitmask(value *glib.Value) Bitmask

ValueGetBitmask gets the bitmask from the given value.

func (Bitmask) ToGValue

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

ToGValue implements a glib.ValueTransformer

type Buffer

type Buffer struct {
	// contains filtered or unexported fields
}

Buffer is a go representation of a GstBuffer.

func FromGstBufferUnsafeFull

func FromGstBufferUnsafeFull(buf unsafe.Pointer) *Buffer

FromGstBufferUnsafeFull wraps the given buffer without taking an additional reference.

func FromGstBufferUnsafeNone

func FromGstBufferUnsafeNone(buf unsafe.Pointer) *Buffer

FromGstBufferUnsafeNone wraps the given buffer, sinking any floating references, and places a finalizer on the wrapped Buffer.

func NewBufferAllocate

func NewBufferAllocate(alloc *Allocator, params *AllocationParams, size int64) *Buffer

NewBufferAllocate 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, nil will be returned. The allocated buffer memory is not cleared.

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

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

func NewBufferFromBytes

func NewBufferFromBytes(b []byte) *Buffer

NewBufferFromBytes returns a new buffer from the given byte slice.

func NewBufferFromReader

func NewBufferFromReader(rdr io.Reader) (*Buffer, error)

NewBufferFromReader returns a new buffer from the given io.Reader.

func NewBufferFull

func NewBufferFull(flags MemoryFlags, data []byte, maxSize, offset, size int64, notifyFunc func()) *Buffer

NewBufferFull allocates a new buffer that wraps the given data. The wrapped buffer will have the region from offset and size visible. The maxsize must be at least the size of the data provided.

When the buffer is destroyed, notifyFunc will be called if it is not nil.

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

 // Example

 buf := gst.NewBufferFull(0, []byte("hello-world"), 1024, 0, 1024, func() {
     fmt.Println("buffer was destroyed")
 })
 if buf != nil {
     buf.Unref()
 }

// > buffer was destroyed

func NewBufferWithSize

func NewBufferWithSize(size int64) *Buffer

NewBufferWithSize is a convenience wrapped for NewBufferrAllocate with the default allocator and parameters.

func NewEmptyBuffer

func NewEmptyBuffer() *Buffer

NewEmptyBuffer returns a new empty buffer.

func ToGstBuffer

func ToGstBuffer(buf unsafe.Pointer) *Buffer

ToGstBuffer converts the given pointer into a Buffer without affecting the ref count or placing finalizers.

func (*Buffer) AddMeta

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (b *Buffer) GetAllMemory() *Memory

GetAllMemory retrieves all the memory inside this buffer.

func (*Buffer) GetFlags

func (b *Buffer) GetFlags() BufferFlags

GetFlags returns the flags on this buffer.

func (*Buffer) GetMemory

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

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

func (*Buffer) GetMemoryRange

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

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

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

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

func (b *Buffer) GetSize() int64

GetSize retrieves the number of Memory blocks in the bffer.

func (*Buffer) GetSizes

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

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

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

HasFlags returns true if this Buffer has the given BufferFlags.

func (*Buffer) InsertMemory

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

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

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

func (b *Buffer) IsWritable() bool

IsWritable returns true if this buffer is writable.

func (*Buffer) IterateMeta

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

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

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

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

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

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

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

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

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

func (b *Buffer) Ref() *Buffer

Ref increases the ref count on the buffer by one.

func (*Buffer) RemoveAllMemory

func (b *Buffer) RemoveAllMemory()

RemoveAllMemory removes all memory blocks in the buffer.

func (*Buffer) RemoveMemoryAt

func (b *Buffer) RemoveMemoryAt(idx uint)

RemoveMemoryAt removes the memory block at the given index.

func (*Buffer) RemoveMemoryRange

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

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

RemoveMeta removes the given metadata from the buffer.

func (*Buffer) ReplaceAllMemory

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

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

func (*Buffer) ReplaceMemory

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

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

func (*Buffer) ReplaceMemoryRange

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

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

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

func (*Buffer) ResizeRange

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

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

SetDuration sets the duration on the buffer.

func (*Buffer) SetFlags

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

SetFlags sets one or more buffer flags on the buffer.

func (*Buffer) SetPresentationTimestamp

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

SetPresentationTimestamp sets the presentation timestamp on the buffer.

func (*Buffer) SetSize

func (b *Buffer) SetSize(size int64)

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

func (*Buffer) Unmap

func (b *Buffer) Unmap()

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

func (*Buffer) Unref

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

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

UnsetFlags removes one or more flags from the buffer.

type BufferCopyFlags

type BufferCopyFlags int

BufferCopyFlags casts GstBufferCopyFlags to a go type.

const (
	BufferCopyNone        BufferCopyFlags = C.GST_BUFFER_COPY_NONE       // (0) – copy nothing
	BufferCopyBufferFlags BufferCopyFlags = C.GST_BUFFER_COPY_FLAGS      // (1) – flag indicating that buffer flags should be copied
	BufferCopyTimestamps  BufferCopyFlags = C.GST_BUFFER_COPY_TIMESTAMPS // (2) – flag indicating that buffer pts, dts, duration, offset and offset_end should be copied
	BufferCopyMeta        BufferCopyFlags = C.GST_BUFFER_COPY_META       // (4) – flag indicating that buffer meta should be copied
	BufferCopyMemory      BufferCopyFlags = C.GST_BUFFER_COPY_MEMORY     // (8) – flag indicating that buffer memory should be reffed and appended to already existing memory. Unless the memory is marked as NO_SHARE, no actual copy of the memory is made but it is simply reffed. Add GST_BUFFER_COPY_DEEP to force a real copy.
	BufferCopyMerge       BufferCopyFlags = C.GST_BUFFER_COPY_MERGE      // (16) – flag indicating that buffer memory should be merged
	BufferCopyDeep        BufferCopyFlags = C.GST_BUFFER_COPY_DEEP       // (32) – flag indicating that memory should always be copied instead of reffed (Since: 1.2)
)

Type castings of BufferCopyFlags

type BufferFlags

type BufferFlags int

BufferFlags casts GstBufferFlags to a go type.

const (
	BufferFlagLive         BufferFlags = C.GST_BUFFER_FLAG_LIVE          // (16) – the buffer is live data and should be discarded in the PAUSED state.
	BufferFlagDecodeOnly   BufferFlags = C.GST_BUFFER_FLAG_DECODE_ONLY   // (32) – the buffer contains data that should be dropped because it will be clipped against the segment boundaries or because it does not contain data that should be shown to the user.
	BufferFlagDiscont      BufferFlags = C.GST_BUFFER_FLAG_DISCONT       // (64) – the buffer marks a data discontinuity in the stream. This typically occurs after a seek or a dropped buffer from a live or network source.
	BufferFlagResync       BufferFlags = C.GST_BUFFER_FLAG_RESYNC        // (128) – the buffer timestamps might have a discontinuity and this buffer is a good point to resynchronize.
	BufferFlagCorrupted    BufferFlags = C.GST_BUFFER_FLAG_CORRUPTED     // (256) – the buffer data is corrupted.
	BufferFlagMarker       BufferFlags = C.GST_BUFFER_FLAG_MARKER        // (512) – the buffer contains a media specific marker. for video this is the end of a frame boundary, for audio this is the start of a talkspurt.
	BufferFlagHeader       BufferFlags = C.GST_BUFFER_FLAG_HEADER        // (1024) – the buffer contains header information that is needed to decode the following data.
	BufferFlagGap          BufferFlags = C.GST_BUFFER_FLAG_GAP           // (2048) – the buffer has been created to fill a gap in the stream and contains media neutral data (elements can switch to optimized code path that ignores the buffer content).
	BufferFlagDroppable    BufferFlags = C.GST_BUFFER_FLAG_DROPPABLE     // (4096) – the buffer can be dropped without breaking the stream, for example to reduce bandwidth.
	BufferFlagDeltaUnit    BufferFlags = C.GST_BUFFER_FLAG_DELTA_UNIT    // (8192) – this unit cannot be decoded independently.
	BufferFlagSyncAfter    BufferFlags = C.GST_BUFFER_FLAG_SYNC_AFTER    // (32768) – Elements which write to disk or permanent storage should ensure the data is synced after writing the contents of this buffer. (Since: 1.6)
	BufferFlagNonDroppable BufferFlags = C.GST_BUFFER_FLAG_NON_DROPPABLE // (65536) – This buffer is important and should not be dropped. This can be used to mark important buffers, e.g. to flag RTP packets carrying keyframes or codec setup data for RTP Forward Error Correction purposes, or to prevent still video frames from being dropped by elements due to QoS. (Since: 1.14)
	BufferFlagLast         BufferFlags = C.GST_BUFFER_FLAG_LAST          // (1048576) – additional media specific flags can be added starting from this flag.
)

Type castings of BufferFlags

type BufferList

type BufferList struct {
	// contains filtered or unexported fields
}

BufferList is a go wrapper around a GstBufferList for grouping Buffers

func FromGstBufferListUnsafeFull

func FromGstBufferListUnsafeFull(buf unsafe.Pointer) *BufferList

FromGstBufferListUnsafeFull wraps the given buffer without taking an additional reference.

func FromGstBufferListUnsafeNone

func FromGstBufferListUnsafeNone(buf unsafe.Pointer) *BufferList

FromGstBufferListUnsafeNone is used for returns from transfer-none methods.

func NewBufferList

func NewBufferList(buffers []*Buffer) *BufferList

NewBufferList returns a new BufferList. The given slice can be nil and the returned buffer list will be empty.

func NewBufferListSized

func NewBufferListSized(size uint) *BufferList

NewBufferListSized creates a new BufferList with the given size.

func ToGstBufferList

func ToGstBufferList(buf unsafe.Pointer) *BufferList

ToGstBufferList converts the given pointer into a BufferList without affecting the ref count or placing finalizers.

func (*BufferList) CalculateSize

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

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

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

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

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

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

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

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

Instance returns the underlying GstBufferList.

func (*BufferList) IsWritable

func (b *BufferList) IsWritable() bool

IsWritable returns true if this BufferList is writable.

func (*BufferList) Length

func (b *BufferList) Length() uint

Length returns the number of buffers in the list.

func (*BufferList) MakeWritable

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

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

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

func (b *BufferList) Unref()

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

type BufferPool

type BufferPool struct{ *Object }

BufferPool is a go wrapper around a GstBufferPool.

For more information refer to the official documentation: https://gstreamer.freedesktop.org/documentation/gstreamer/gstbufferpool.html?gi-language=c

func FromGstBufferPoolUnsafeFull

func FromGstBufferPoolUnsafeFull(bufferPool unsafe.Pointer) *BufferPool

FromGstBufferPoolUnsafeFull wraps the given unsafe.Pointer in a BufferPool instance. It just places a runtime finalizer on the resulting object.

func FromGstBufferPoolUnsafeNone

func FromGstBufferPoolUnsafeNone(bufferPool unsafe.Pointer) *BufferPool

FromGstBufferPoolUnsafeNone wraps the given unsafe.Pointer in a BufferPool instance. It takes a ref and places a runtime finalizer on the resulting object.

func NewBufferPool

func NewBufferPool() *BufferPool

NewBufferPool returns a new BufferPool instance.

func (*BufferPool) AcquireBuffer

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

AcquireBuffer acquires a buffer from this pool.

func (*BufferPool) GetConfig

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

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

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

HasOption returns true if this BufferPool supports the given option.

func (*BufferPool) Instance

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

Instance returns the underlying GstBufferPool instance.

func (*BufferPool) IsActive

func (b *BufferPool) IsActive() bool

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

func (*BufferPool) IsFlushing

func (b *BufferPool) IsFlushing() bool

IsFlushing returns true if this BufferPool is currently flushing.

func (*BufferPool) ReleaseBuffer

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

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

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

func (b *BufferPool) SetFlushing(flushing bool)

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

type BufferPoolAcquireFlags

type BufferPoolAcquireFlags int

BufferPoolAcquireFlags casts GstBufferPoolAcquireFlags to a go type.

const (
	BufferPoolAcquireFlagNone     BufferPoolAcquireFlags = C.GST_BUFFER_POOL_ACQUIRE_FLAG_NONE     // (0) – no flags
	BufferPoolAcquireFlagKeyUnit  BufferPoolAcquireFlags = C.GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT // (1) – buffer is keyframe
	BufferPoolAcquireFlagDontWait BufferPoolAcquireFlags = C.GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT // (2) – when the bufferpool is empty, acquire_buffer will by default block until a buffer is released into the pool again. Setting this flag makes acquire_buffer return GST_FLOW_EOS instead of blocking.
	BufferPoolAcquireFlagDiscont  BufferPoolAcquireFlags = C.GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT  // (4) – buffer is discont
	BufferPoolAcquireFlagLast     BufferPoolAcquireFlags = C.GST_BUFFER_POOL_ACQUIRE_FLAG_LAST     // (65536) – last flag, subclasses can use private flags starting from this value.
)

Type castings of BufferPoolAcquireFlags

type BufferPoolAcquireParams

type BufferPoolAcquireParams struct {
	Format Format                 // format (GstFormat) – the format of start and stop
	Start  int64                  // start (gint64) – the start position
	Stop   int64                  // stop (gint64) – the stop position
	Flags  BufferPoolAcquireFlags // flags (GstBufferPoolAcquireFlags) – additional flags
}

BufferPoolAcquireParams represents parameters to an AcquireBuffer call.

type BufferPoolConfig

type BufferPoolConfig struct{ *Structure }

BufferPoolConfig wraps the Structure interface with extra methods for interacting with BufferPool configurations.

func (*BufferPoolConfig) AddOption

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

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

GetAllocator retrieves the allocator and params from config.

func (*BufferPoolConfig) GetOption

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

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

func (*BufferPoolConfig) GetParams

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

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

HasOption returns true if this config has the given option.

func (*BufferPoolConfig) NumOptions

func (b *BufferPoolConfig) NumOptions() uint

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

func (*BufferPoolConfig) SetAllocator

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

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

SetParams configures the config with the given parameters.

func (*BufferPoolConfig) Validate

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.

type BufferingMode

type BufferingMode int

BufferingMode is a representation of GstBufferingMode

const (
	BufferingStream    BufferingMode = C.GST_BUFFERING_STREAM    // (0) – a small amount of data is buffered
	BufferingDownload  BufferingMode = C.GST_BUFFERING_DOWNLOAD  // (1) – the stream is being downloaded
	BufferingTimeshift BufferingMode = C.GST_BUFFERING_TIMESHIFT //  (2) – the stream is being downloaded in a ringbuffer
	BufferingLive      BufferingMode = C.GST_BUFFERING_LIVE      // (3) – the stream is a live stream
)

Type casts of buffering modes

func (BufferingMode) String

func (b BufferingMode) String() string

String implements a stringer on a BufferingMode.

type BufferingStats

type BufferingStats struct {
	// The buffering mode
	BufferingMode BufferingMode
	// The average input rate
	AverageIn int
	// The average output rate
	AverageOut int
	// Amount of time until buffering is complete
	BufferingLeft time.Duration
}

BufferingStats represents the buffering stats as retrieved from a GST_MESSAGE_TYPE_BUFFERING.

type Bus

type Bus struct {
	*Object
}

Bus is a Go wrapper around a GstBus. It provides convenience methods for popping messages from the queue.

func FromGstBusUnsafeFull

func FromGstBusUnsafeFull(bus unsafe.Pointer) *Bus

FromGstBusUnsafeFull wraps the given unsafe.Pointer in a bus. It does not increase the ref count and places a runtime finalizer on the instance.

func FromGstBusUnsafeNone

func FromGstBusUnsafeNone(bus unsafe.Pointer) *Bus

FromGstBusUnsafeNone wraps the given unsafe.Pointer in a bus. It takes a ref on the bus and sets a runtime finalizer on it.

func NewBus

func NewBus() *Bus

NewBus returns a new Bus instance.

// Example of using the bus instance

package main

import (
    "fmt"

    "github.com/hiroyky/go-gst/gst"
)

func main() {
    gst.Init(nil)

    bus := gst.NewBus()
    defer bus.Unref()

    elem, err := gst.NewElement("fakesrc")
    if err != nil {
        panic(err)
    }
    defer elem.Unref()

    bus.Post(gst.NewAsyncStartMessage(elem))

    msg := bus.Pop()
    defer msg.Unref()

    fmt.Println(msg)
}

// > [fakesrc0] ASYNC-START - Async task started

func (*Bus) AddSignalWatch

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

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

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

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

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

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

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

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

func (b *Bus) Pop() *Message

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

func (*Bus) PopFiltered

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

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

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

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

func (*Bus) RemoveSignalWatch

func (b *Bus) RemoveSignalWatch()

RemoveSignalWatch removes a signal watch previously added with AddSignalWatch.

func (*Bus) RemoveWatch

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

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

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

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

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.

type BusSyncHandler

type BusSyncHandler func(msg *Message) BusSyncReply

BusSyncHandler will be invoked synchronously, when a new message has been injected into the bus. This function is mostly used internally. Only one sync handler can be attached to a given bus.

If the handler returns BusDrop, it should unref the message, else the message should not be unreffed by the sync handler.

type BusSyncReply

type BusSyncReply int

BusSyncReply casts GstBusSyncReply to a go type

const (
	BusDrop  BusSyncReply = C.GST_BUS_DROP  // (0) – drop the message
	BusPass  BusSyncReply = C.GST_BUS_PASS  // (1) – pass the message to the async queue
	BusAsync BusSyncReply = C.GST_BUS_ASYNC // (2) – pass message to async queue, continue if message is handled
)

Type castings of SyncReplies

type BusWatchFunc

type BusWatchFunc func(msg *Message) bool

BusWatchFunc is a go representation of a GstBusFunc. It takes a message as a single argument and returns a bool value for whether to continue processing messages or not. There is no need to unref the message unless addtional references are placed on it during processing.

type Caps

type Caps struct {
	// contains filtered or unexported fields
}

Caps is a go wrapper around GstCaps.

func FromGstCapsUnsafeFull

func FromGstCapsUnsafeFull(caps unsafe.Pointer) *Caps

FromGstCapsUnsafeFull wraps the pointer to the given C GstCaps with the go type. This is meant for internal usage and is exported for visibility to other packages. A finalizer is placed on the object to Unref after leaving scope.

func FromGstCapsUnsafeNone

func FromGstCapsUnsafeNone(caps unsafe.Pointer) *Caps

FromGstCapsUnsafeNone wraps the pointer to the given C GstCaps with the go type. This is meant for internal usage and is exported for visibility to other packages. A ref is taken on the caps and finalizer placed on the object.

func NewAnyCaps

func NewAnyCaps() *Caps

NewAnyCaps creates a new caps that indicate compatibility with any format.

caps := gst.NewAnyCaps()
fmt.Println(caps.IsAny())
// true

func NewCapsFromString

func NewCapsFromString(capsStr string) *Caps

NewCapsFromString creates a new Caps object from the given string.

caps := gst.NewCapsFromString("audio/x-raw, channels=2")
fmt.Println(caps.String())
// audio/x-raw, channels=(int)2

func NewEmptyCaps

func NewEmptyCaps() *Caps

NewEmptyCaps creates a new empty caps object. This is essentially the opposite of NewAnyCamps.

caps := gst.NewEmptyCaps()
fmt.Println(caps.IsEmpty())
// true

func NewEmptySimpleCaps

func NewEmptySimpleCaps(mediaFormat string) *Caps

NewEmptySimpleCaps returns a new empty caps object with the given media format.

caps := gst.NewEmptySimpleCaps("audio/x-raw")
fmt.Println(caps.String())
// audio/x-raw

func NewFullCaps

func NewFullCaps(structures ...*Structure) *Caps

NewFullCaps creates a new caps from the given structures.

func ToGstCaps

func ToGstCaps(caps unsafe.Pointer) *Caps

ToGstCaps converts the given pointer into a Caps without affecting the ref count or placing finalizers.

func ValueGetCaps

func ValueGetCaps(value *glib.Value) *Caps

ValueGetCaps gets the caps from the given value.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (*Caps) IsEqualFixed

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

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

func (*Caps) IsFixed

func (c *Caps) IsFixed() bool

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

func (*Caps) IsStrictlyEqual

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

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

func (*Caps) IsSubset

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

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

func (*Caps) IsSubsetStructure

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

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

func (*Caps) IsSubsetStructureFull

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

func (c *Caps) IsWritable() bool

IsWritable returns true if these caps are writable.

func (*Caps) MakeWritable

func (c *Caps) MakeWritable() *Caps

MakeWritable returns a writable copy of caps.

func (*Caps) MapInPlace

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

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

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

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

func (*Caps) MergeStructureFull

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

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

func (c *Caps) RemoveStructureAt(idx uint)

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

func (*Caps) SetFeaturesAt

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

SetFeaturesAt sets the CapsFeatures features for the structure at index.

func (*Caps) SetFeaturesSimple

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

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

func (*Caps) SetValue

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

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

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

func (c *Caps) String() string

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

func (*Caps) Subtract

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

Subtract subtracts the given caps from these.

func (*Caps) ToGValue

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

ToGValue returns a GValue containing the given caps.

func (*Caps) Truncate

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

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

Unsafe returns an unsafe.Pointer to the underlying GstCaps.

type CapsFeatures

type CapsFeatures struct {
	// contains filtered or unexported fields
}

CapsFeatures is a go representation of GstCapsFeatures.

func NewCapsFeaturesAny

func NewCapsFeaturesAny() *CapsFeatures

NewCapsFeaturesAny returns a new ANY CapsFeatures.

feats := gst.NewCapsFeaturesAny()
fmt.Println(feats.IsAny())
// true

func NewCapsFeaturesEmpty

func NewCapsFeaturesEmpty() *CapsFeatures

NewCapsFeaturesEmpty returns a new empty CapsFeatures.

feats := gst.NewCapsFeaturesEmpty()
fmt.Println(feats.GetSize())
// 0

func NewCapsFeaturesFromString

func NewCapsFeaturesFromString(features string) *CapsFeatures

NewCapsFeaturesFromString creates new CapsFeatures from the given string.

func ValueGetCapsFeatures

func ValueGetCapsFeatures(value *glib.Value) *CapsFeatures

ValueGetCapsFeatures gets the caps features from the given value.

func (*CapsFeatures) Add

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

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

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

func (*CapsFeatures) Copy

func (c *CapsFeatures) Copy() *CapsFeatures

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

func (*CapsFeatures) Free

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

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

GetNth returns the feature at index.

func (*CapsFeatures) GetSize

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

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

func (c *CapsFeatures) Remove(feature string)

Remove removes the given feature.

func (*CapsFeatures) SetParentRefCount

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

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

ToGValue implements a glib.ValueTransformer

type CapsIntersectMode

type CapsIntersectMode int

CapsIntersectMode represents the modes of caps intersection. See the official documentation for more details: https://gstreamer.freedesktop.org/documentation/gstreamer/gstcaps.html?gi-language=c#GstCapsIntersectMode

const (
	CapsIntersectZigZag CapsIntersectMode = C.GST_CAPS_INTERSECT_ZIG_ZAG
	CapsIntersectFirst  CapsIntersectMode = C.GST_CAPS_INTERSECT_FIRST
)

Type castings of intersect modes

type CapsMapFunc

type CapsMapFunc func(features *CapsFeatures, structure *Structure) bool

CapsMapFunc represents a function passed to the Caps MapInPlace, ForEach, and FilterAndMapInPlace methods.

type ChildProxy

type ChildProxy struct {
	// contains filtered or unexported fields
}

ChildProxy is an interface that abstracts handling of property sets for elements with children. They all have multiple GstPad or some kind of voice objects. Another use case are container elements like GstBin. The element implementing the interface acts as a parent for those child objects.

Property names are written as "child-name::property-name". The whole naming scheme is recursive. Thus "child1::child2::property" is valid too, if "child1" and "child2" implement the GstChildProxy interface.

func ToChildProxy

func ToChildProxy(elem *Element) *ChildProxy

ToChildProxy returns a ChildProxy for the given element. If the element does not implement a ChildProxy it returns nil.

func (*ChildProxy) ChildAdded

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

ChildAdded emits the "child-added" signal.

func (*ChildProxy) ChildRemoved

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

ChildRemoved emits the "child-removed" signal.

func (*ChildProxy) Get

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

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

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

func (c *ChildProxy) GetChildrenCount() uint

GetChildrenCount returns the number of child objects the parent contains.

func (*ChildProxy) GetProperty

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

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

Instance returns the underlying GstChildProxy instance.

func (*ChildProxy) Lookup

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

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

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

SetProperty sets a single property using the ChildProxy mechanism.

type ChildProxyImpl

type ChildProxyImpl interface {
	ChildAdded(self *ChildProxy, child *glib.Object, name string)
	ChildRemoved(self *ChildProxy, child *glib.Object, name string)
	GetChildByIndex(self *ChildProxy, idx uint) *glib.Object
	GetChildByName(self *ChildProxy, name string) *glib.Object
	GetChildrenCount(self *ChildProxy) uint
}

ChildProxyImpl is the reference implementation for a ChildProxy implemented by a Go object.

type Clock

type Clock struct{ *Object }

Clock is a go wrapper around a GstClock.

func FromGstClockUnsafeFull

func FromGstClockUnsafeFull(clock unsafe.Pointer) *Clock

FromGstClockUnsafeFull takes a pointer to a GstClock and wraps it in a Clock instance. A finalizer is set on the returned object.

func FromGstClockUnsafeNone

func FromGstClockUnsafeNone(clock unsafe.Pointer) *Clock

FromGstClockUnsafeNone takes a pointer to a GstClock and wraps it in a Clock instance. A ref is taken on the clock and a finalizer applied.

func (*Clock) AddObservation

func (c *Clock) AddObservation(slaveTime, masterTime time.Duration) (bool, float64)

AddObservation adds the time master of the master clock and the time slave of the slave clock to the list of observations. If enough observations are available, a linear regression algorithm is run on the observations and clock is recalibrated.

If this functions returns TRUE, the float will contain the correlation coefficient of the interpolation. A value of 1.0 means a perfect regression was performed. This value can be used to control the sampling frequency of the master and slave clocks.

func (*Clock) AddObservationUnapplied

func (c *Clock) AddObservationUnapplied(slaveTime, masterTime time.Duration) (ok bool, rSquared float64, internalTime, externalTime, rateNum, rateDenom time.Duration)

AddObservationUnapplied adds a clock observation to the internal slaving algorithm the same as AddObservation, and returns the result of the master clock estimation, without updating the internal calibration.

The caller can then take the results and call SetCalibration with the values, or some modified version of them.

func (*Clock) AdjustUnlocked

func (c *Clock) AdjustUnlocked(internal time.Duration) time.Duration

AdjustUnlocked converts the given internal clock time to the external time, adjusting for the rate and reference time set with SetCalibration and making sure that the returned time is increasing. This function should be called with the clock's OBJECT_LOCK held and is mainly used by clock subclasses.

This function is the reverse of UnadjustUnlocked.

func (*Clock) AdjustWithCalibration

func (c *Clock) AdjustWithCalibration(internalTarget, cinternal, cexternal, cnum, cdenom time.Duration) time.Duration

AdjustWithCalibration converts the given internal_target clock time to the external time, using the passed calibration parameters. This function performs the same calculation as AdjustUnlocked when called using the current calibration parameters, but doesn't ensure a monotonically increasing result as AdjustUnlocked does.

See: https://gstreamer.freedesktop.org/documentation/gstreamer/gstclock.html#gst_clock_adjust_with_calibration

func (*Clock) GetCalibration

func (c *Clock) GetCalibration() (internal, external, rateNum, rateDenom time.Duration)

GetCalibration gets the internal rate and reference time of clock. See gst_clock_set_calibration for more information.

func (*Clock) GetInternalTime

func (c *Clock) GetInternalTime() time.Duration

GetInternalTime gets the current internal time of the given clock in nanoseconds or ClockTimeNone if invalid. The time is returned unadjusted for the offset and the rate.

func (*Clock) GetMaster

func (c *Clock) GetMaster() *Clock

GetMaster returns the master clock that this clock is slaved to or nil when the clock is not slaved to any master clock.

func (*Clock) GetResolution

func (c *Clock) GetResolution() time.Duration

GetResolution gets the accuracy of the clock. The accuracy of the clock is the granularity of the values returned by GetTime.

func (*Clock) GetTime

func (c *Clock) GetTime() time.Duration

GetTime gets the current time of the given clock in nanoseconds or -1 if invalid. The time is always monotonically increasing and adjusted according to the current offset and rate.

func (*Clock) GetTimeout

func (c *Clock) GetTimeout() time.Duration

GetTimeout gets the amount of time that master and slave clocks are sampled.

func (*Clock) Instance

func (c *Clock) Instance() *C.GstClock

Instance returns the underlying GstClock instance.

func (*Clock) InternalString

func (c *Clock) InternalString() string

InternalString returns the string representation of this clock's internal value.

func (*Clock) IsSynced

func (c *Clock) IsSynced() bool

IsSynced returns true if the clock is synced.

func (*Clock) NewPeriodicID

func (c *Clock) NewPeriodicID(startTime, interval time.Duration) *ClockID

NewPeriodicID gets an ID from clock to trigger a periodic notification. The periodic notifications will start at time start_time and will then be fired with the given interval. ID should be unreffed after usage.

func (*Clock) NewSingleShotID

func (c *Clock) NewSingleShotID(at time.Duration) *ClockID

NewSingleShotID gets a ClockID from the clock to trigger a single shot notification at the requested time. The single shot id should be unreffed after usage.

func (*Clock) PeriodicIDReinit

func (c *Clock) PeriodicIDReinit(clockID *ClockID, startTime, interval time.Duration) bool

PeriodicIDReinit reinitializes the provided periodic id to the provided start time and interval. Does not / modify the reference count.

func (*Clock) SetCalibration

func (c *Clock) SetCalibration(internal, external, rateNum, rateDenom time.Duration)

SetCalibration adjusts the rate and time of clock. See: https://gstreamer.freedesktop.org/documentation/gstreamer/gstclock.html#gst_clock_set_calibration.

func (*Clock) SetMaster

func (c *Clock) SetMaster(master *Clock) bool

SetMaster sets master as the master clock for clock. clock will be automatically calibrated so that GetTime reports the same time as the master clock.

A clock provider that slaves its clock to a master can get the current calibration values with GetCalibration.

Master can be nil in which case clock will not be slaved anymore. It will however keep reporting its time adjusted with the last configured rate and time offsets.

func (*Clock) SetResolution

func (c *Clock) SetResolution(resolution time.Duration) time.Duration

SetResolution sets the accuracy of the clock. Some clocks have the possibility to operate with different accuracy at the expense of more resource usage. There is normally no need to change the default resolution of a clock. The resolution of a clock can only be changed if the clock has the ClockFlagCanSetResolution flag set.

func (*Clock) SetSynced

func (c *Clock) SetSynced(synced bool)

SetSynced sets clock to synced and emits the GstClock::synced signal, and wakes up any thread waiting in WaitForSync.

This function must only be called if ClockFlagNeedsStartupSync is set on the clock, and is intended to be called by subclasses only.

func (*Clock) SetTimeout

func (c *Clock) SetTimeout(timeout time.Duration)

SetTimeout sets the amount of time, in nanoseconds, to sample master and slave clocks

func (*Clock) SingleShotIDReinit

func (c *Clock) SingleShotIDReinit(clockID *ClockID, at time.Duration) bool

SingleShotIDReinit reinitializes the provided single shot id to the provided time. Does not modify the reference count.

func (*Clock) String

func (c *Clock) String() string

String returns the string representation of this clock value.

func (*Clock) UnadjustUnlocked

func (c *Clock) UnadjustUnlocked(external time.Duration) time.Duration

UnadjustUnlocked converts the given external clock time to the internal time of clock, using the rate and reference time set with SetCalibration. This function should be called with the clock's OBJECT_LOCK held and is mainly used by clock subclasses.

This function is the reverse of AdjustUnlocked.

func (*Clock) UnadjustWithCalibration

func (c *Clock) UnadjustWithCalibration(externalTarget, cinternal, cexternal, cnum, cdenom time.Duration) time.Duration

UnadjustWithCalibration converts the given external_target clock time to the internal time, using the passed calibration parameters. This function performs the same calculation as UnadjustUnlocked when called using the current calibration parameters.

func (*Clock) WaitForSync

func (c *Clock) WaitForSync(timeout time.Duration) bool

WaitForSync waits until clock is synced for reporting the current time. If timeout is ClockTimeNone it will wait forever, otherwise it will time out after timeout nanoseconds.

For asynchronous waiting, the GstClock::synced signal can be used.

This returns immediately with TRUE if ClockFlagNeedsStartupSync is not set on the clock, or if the clock is already synced.

type ClockCallback

type ClockCallback func(clock *Clock, clockTime time.Duration) bool

ClockCallback is the prototype of a clock callback function.

type ClockEntryType

type ClockEntryType int

ClockEntryType wraps GstClockEntryType

const (
	ClockEntrySingle   ClockEntryType = C.GST_CLOCK_ENTRY_SINGLE   // (0) – a single shot timeout
	ClockEntryPeriodic ClockEntryType = C.GST_CLOCK_ENTRY_PERIODIC // (1) – a periodic timeout request
)

Type castings of ClockEntryTypes

type ClockFlags

type ClockFlags int

ClockFlags wraps GstClockFlags

const (
	ClockFlagCanDoSingleSync    ClockFlags = C.GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC    // (16) – clock can do a single sync timeout request
	ClockFlagCanDoSingleAsync   ClockFlags = C.GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC   // (32) – clock can do a single async timeout request
	ClockFlagCanDoPeriodicSync  ClockFlags = C.GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC  // (64) – clock can do sync periodic timeout requests
	ClockFlagCanDoPeriodicAsync ClockFlags = C.GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC // (128) – clock can do async periodic timeout callbacks
	ClockFlagCanSetResolution   ClockFlags = C.GST_CLOCK_FLAG_CAN_SET_RESOLUTION    // (256) – clock's resolution can be changed
	ClockFlagCanSetMaster       ClockFlags = C.GST_CLOCK_FLAG_CAN_SET_MASTER        // (512) – clock can be slaved to a master clock
	ClockFlagNeedsStartupSync   ClockFlags = C.GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC    // (1024) – clock needs to be synced before it can be used (Since: 1.6)
	ClockFlagLast               ClockFlags = C.GST_CLOCK_FLAG_LAST                  // (4096) – subclasses can add additional flags starting from this flag
)

Type castings of ClockFlags

type ClockID

type ClockID struct {
	// contains filtered or unexported fields
}

ClockID is a go wrapper around a GstClockID.

func (*ClockID) GetClock

func (c *ClockID) GetClock() *Clock

GetClock returns the clock for this ClockID.

func (*ClockID) GetTime

func (c *ClockID) GetTime() time.Duration

GetTime returns the time for this ClockID

func (*ClockID) Instance

func (c *ClockID) Instance() C.GstClockID

Instance returns the underlying pointer.

func (*ClockID) Ref

func (c *ClockID) Ref() *ClockID

Ref increaes the ref count on ClockID.

func (*ClockID) Unref

func (c *ClockID) Unref()

Unref unrefs a ClockID.

func (*ClockID) Unschedule

func (c *ClockID) Unschedule()

Unschedule cancels an outstanding request with id. This can either be an outstanding async notification or a pending sync notification. After this call, id cannot be used anymore to receive sync or async notifications, you need to create a new GstClockID.

func (*ClockID) UsesClock

func (c *ClockID) UsesClock(clock *Clock) bool

UsesClock returns whether id uses clock as the underlying clock. clock can be nil, in which case the return value indicates whether the underlying clock has been freed. If this is the case, the id is no longer usable and should be freed.

func (*ClockID) Wait

func (c *ClockID) Wait() (ret ClockReturn, jitter ClockTimeDiff)

Wait performs a blocking wait on id. id should have been created with NewSingleShotID or NewPeriodicID and should not have been unscheduled with a call to Unschedule.

If the jitter argument is not 0 and this function returns ClockOK or ClockEarly, it will contain the difference against the clock and the time of id when this method was called. Positive values indicate how late id was relative to the clock (in which case this function will return ClockEarly). Negative values indicate how much time was spent waiting on the clock before this function returned.

func (*ClockID) WaitAsync

func (c *ClockID) WaitAsync(f ClockCallback) ClockReturn

WaitAsync registers a callback on the given ClockID id with the given function and user_data. When passing a ClockID with an invalid time to this function, the callback will be called immediately with a time set to ClockTimeNone. The callback will be called when the time of id has been reached.

The callback func can be invoked from any thread, either provided by the core or from a streaming thread. The application should be prepared for this.

// Example

pipeline, _ := gst.NewPipelineFromString("fakesrc ! fakesink")
defer pipeline.Unref()

clock := pipeline.GetPipelineClock()

id := clock.NewSingleShotID(gst.ClockTime(1000000000)) // 1 second

id.WaitAsync(func(clock *gst.Clock, clockTime time.Duration) bool {
    fmt.Println("Single shot triggered at", clockTime.Nanoseconds())
    pipeline.SetState(gst.StateNull)
    return true
})

pipeline.SetState(gst.StatePlaying)
gst.Wait(pipeline)

// Single shot triggered at 1000000000

type ClockReturn

type ClockReturn int

ClockReturn wraps a GstClockReturn

const (
	ClockOK          ClockReturn = C.GST_CLOCK_OK          // (0) – The operation succeeded.
	ClockEarly       ClockReturn = C.GST_CLOCK_EARLY       // (1) – The operation was scheduled too late.
	ClockUnscheduled ClockReturn = C.GST_CLOCK_UNSCHEDULED // (2) – The clockID was unscheduled
	ClockBusy        ClockReturn = C.GST_CLOCK_BUSY        // (3) – The ClockID is busy
	ClockBadTime     ClockReturn = C.GST_CLOCK_BADTIME     // (4) – A bad time was provided to a function.
	ClockError       ClockReturn = C.GST_CLOCK_ERROR       // (5) – An error occurred
	ClockUnsupported ClockReturn = C.GST_CLOCK_UNSUPPORTED // (6) – Operation is not supported
	ClockDone        ClockReturn = C.GST_CLOCK_DONE        // (7) – The ClockID is done waiting
)

Type castings of clock returns

type ClockTimeDiff

type ClockTimeDiff int64

ClockTimeDiff is a datatype to hold a time difference, measured in nanoseconds.

type Context

type Context struct {
	// contains filtered or unexported fields
}

Context wraps a GstContext object.

func FromGstContextUnsafeFull

func FromGstContextUnsafeFull(ctx unsafe.Pointer) *Context

FromGstContextUnsafeFull wraps the given context and places a runtime finalizer on it.

func FromGstContextUnsafeNone

func FromGstContextUnsafeNone(ctx unsafe.Pointer) *Context

FromGstContextUnsafeNone refs and wraps the given context and places a runtime finalizer on it.

func NewContext

func NewContext(ctxType string, persistent bool) *Context

NewContext creates a new context.

// Example

ctx := gst.NewContext("test-context", false)
fmt.Println(ctx.IsPersistent())

ctx = gst.NewContext("test-context", true)
fmt.Println(ctx.IsPersistent())

// false
// true

func (*Context) GetStructure

func (c *Context) GetStructure() *Structure

GetStructure returns the structure of the context. You should not modify or unref it.

func (*Context) GetType

func (c *Context) GetType() string

GetType returns the type of the context.

// Example

ctx := gst.NewContext("test-context", false)
fmt.Println(ctx.GetType())

// test-context

func (*Context) HasContextType

func (c *Context) HasContextType(ctxType string) bool

HasContextType checks if the context has the given type.

// Example

ctx := gst.NewContext("test-context", false)
fmt.Println(ctx.HasContextType("test-context"))
fmt.Println(ctx.HasContextType("another-context"))

// true
// false

func (*Context) Instance

func (c *Context) Instance() *C.GstContext

Instance returns the underlying GstContext instance.

func (*Context) IsPersistent

func (c *Context) IsPersistent() bool

IsPersistent checks if the context is persistent.

func (*Context) IsWritable

func (c *Context) IsWritable() bool

IsWritable returns true if the context is writable.

func (*Context) MakeWritable

func (c *Context) MakeWritable() *Context

MakeWritable returns a writable version of the context.

func (*Context) Ref

func (c *Context) Ref() *Context

Ref increases the ref count on the Context.

func (*Context) Unref

func (c *Context) Unref()

Unref decreases the ref count on the Context.

func (*Context) WritableStructure

func (c *Context) WritableStructure() *Structure

WritableStructure returns a writable version of the structure. You should still not unref it.

type DebugCategory

type DebugCategory struct {
	// contains filtered or unexported fields
}

DebugCategory is a struct that describes a category of log messages.

var CAT *DebugCategory

CAT is the global DebugCategory used for logging from the bindings. It is okay to use it from applications, but plugins should use their own.

func NewDebugCategory

func NewDebugCategory(name string, color DebugColorFlags, description string) *DebugCategory

NewDebugCategory initializes a new DebugCategory with the given properties and set to the default threshold.

func (*DebugCategory) Log

func (d *DebugCategory) Log(level DebugLevel, message string, obj ...*Object)

Log logs the given message using the currently registered debugging handlers. You can optionally provide a single object to log the message for. GStreamer will automatically add a newline to the end of the message.

func (*DebugCategory) LogDebug

func (d *DebugCategory) LogDebug(message string, obj ...*Object)

LogDebug is a convenience wrapper for logging a DEBUG level message.

func (*DebugCategory) LogError

func (d *DebugCategory) LogError(message string, obj ...*Object)

LogError is a convenience wrapper for logging an ERROR level message.

func (*DebugCategory) LogInfo

func (d *DebugCategory) LogInfo(message string, obj ...*Object)

LogInfo is a convenience wrapper for logging an INFO level message.

func (*DebugCategory) LogLog

func (d *DebugCategory) LogLog(message string, obj ...*Object)

LogLog is a convenience wrapper for logging a LOG level message.

func (*DebugCategory) LogMemDump

func (d *DebugCategory) LogMemDump(message string, obj ...*Object)

LogMemDump is a convenience wrapper for logging a MEMDUMP level message.

func (*DebugCategory) LogTrace

func (d *DebugCategory) LogTrace(message string, obj ...*Object)

LogTrace is a convenience wrapper for logging a TRACE level message.

func (*DebugCategory) LogWarning

func (d *DebugCategory) LogWarning(message string, obj ...*Object)

LogWarning is a convenience wrapper for logging a WARNING level message.

type DebugColorFlags

type DebugColorFlags int

DebugColorFlags are terminal style flags you can use when creating your debugging categories to make them stand out in debugging output.

const (
	DebugColorNone      DebugColorFlags = 0                      // (0) - No color
	DebugColorFgBlack   DebugColorFlags = C.GST_DEBUG_FG_BLACK   // (0) – Use black as foreground color.
	DebugColorFgRed     DebugColorFlags = C.GST_DEBUG_FG_RED     // (1) – Use red as foreground color.
	DebugColorFgGreen   DebugColorFlags = C.GST_DEBUG_FG_GREEN   // (2) – Use green as foreground color.
	DebugColorFgYellow  DebugColorFlags = C.GST_DEBUG_FG_YELLOW  // (3) – Use yellow as foreground color.
	DebugColorFgBlue    DebugColorFlags = C.GST_DEBUG_FG_BLUE    // (4) – Use blue as foreground color.
	DebugColorFgMagenta DebugColorFlags = C.GST_DEBUG_FG_MAGENTA // (5) – Use magenta as foreground color.
	DebugColorFgCyan    DebugColorFlags = C.GST_DEBUG_FG_CYAN    // (6) – Use cyan as foreground color.
	DebugColorFgWhite   DebugColorFlags = C.GST_DEBUG_FG_WHITE   // (7) – Use white as foreground color.
	DebugColorBgBlack   DebugColorFlags = C.GST_DEBUG_BG_BLACK   // (0) – Use black as background color.
	DebugColorBgRed     DebugColorFlags = C.GST_DEBUG_BG_RED     // (16) – Use red as background color.
	DebugColorBgGreen   DebugColorFlags = C.GST_DEBUG_BG_GREEN   // (32) – Use green as background color.
	DebugColorBgYellow  DebugColorFlags = C.GST_DEBUG_BG_YELLOW  // (48) – Use yellow as background color.
	DebugColorBgBlue    DebugColorFlags = C.GST_DEBUG_BG_BLUE    // (64) – Use blue as background color.
	DebugColorBgMagenta DebugColorFlags = C.GST_DEBUG_BG_MAGENTA // (80) – Use magenta as background color.
	DebugColorBgCyan    DebugColorFlags = C.GST_DEBUG_BG_CYAN    // (96) – Use cyan as background color.
	DebugColorBgWhite   DebugColorFlags = C.GST_DEBUG_BG_WHITE   // (112) – Use white as background color.
	DebugColorBold      DebugColorFlags = C.GST_DEBUG_BOLD       // (256) – Make the output bold.
	DebugColorUnderline DebugColorFlags = C.GST_DEBUG_UNDERLINE  // (512) – Underline the output.
)

Type castings of DebugColorFlags

type DebugColorMode

type DebugColorMode int

DebugColorMode represents how to display colors.

const (
	DebugColorModeOff  DebugColorMode = C.GST_DEBUG_COLOR_MODE_OFF  // (0) – Do not use colors in logs.
	DebugColorModeOn   DebugColorMode = C.GST_DEBUG_COLOR_MODE_ON   // (1) – Paint logs in a platform-specific way.
	DebugColorModeUnix DebugColorMode = C.GST_DEBUG_COLOR_MODE_UNIX // (2) – Paint logs with UNIX terminal color codes no matter what platform GStreamer is running on.
)

Type castings of DebugColorModes

type DebugGraphDetails

type DebugGraphDetails int

DebugGraphDetails casts GstDebugGraphDetails

const (
	DebugGraphShowMediaType        DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE         // (1) – show caps-name on edges
	DebugGraphShowCapsDetails      DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS       // (2) – show caps-details on edges
	DebugGraphShowNonDefaultParams DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS // (4) – show modified parameters on elements
	DebugGraphShowStates           DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_STATES             // (8) – show element states
	DebugGraphShowPullParams       DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_FULL_PARAMS        // (16) – show full element parameter values even if they are very long
	DebugGraphShowAll              DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_ALL                // (15) – show all the typical details that one might want
	DebugGraphShowVerbose          DebugGraphDetails = C.GST_DEBUG_GRAPH_SHOW_VERBOSE            // (4294967295) – show all details regardless of how large or verbose they make the resulting output
)

Type castings

type DebugLevel

type DebugLevel int

DebugLevel defines the importance of a debugging message. The more important a message is, the greater the probability that the debugging system outputs it.

const (
	LevelNone    DebugLevel = C.GST_LEVEL_NONE    // (0) – No debugging level specified or desired. Used to deactivate debugging output.
	LevelError   DebugLevel = C.GST_LEVEL_ERROR   // (1) – Error messages are to be used only when an error occurred that stops the application from keeping working correctly. An examples is gst_element_error, which outputs a message with this priority. It does not mean that the application is terminating as with g_error.
	LevelWarning DebugLevel = C.GST_LEVEL_WARNING // (2) – Warning messages are to inform about abnormal behaviour that could lead to problems or weird behaviour later on. An example of this would be clocking issues ("your computer is pretty slow") or broken input data ("Can't synchronize to stream.")
	LevelFixMe   DebugLevel = C.GST_LEVEL_FIXME   // (3) – Fixme messages are messages that indicate that something in the executed code path is not fully implemented or handled yet. Note that this does not replace proper error handling in any way, the purpose of this message is to make it easier to spot incomplete/unfinished pieces of code when reading the debug log.
	LevelInfo    DebugLevel = C.GST_LEVEL_INFO    // (4) – Informational messages should be used to keep the developer updated about what is happening. Examples where this should be used are when a typefind function has successfully determined the type of the stream or when an mp3 plugin detects the format to be used. ("This file has mono sound.")
	LevelDebug   DebugLevel = C.GST_LEVEL_DEBUG   // (5) – Debugging messages should be used when something common happens that is not the expected default behavior, or something that's useful to know but doesn't happen all the time (ie. per loop iteration or buffer processed or event handled). An example would be notifications about state changes or receiving/sending of events.
	LevelLog     DebugLevel = C.GST_LEVEL_LOG     // (6) – Log messages are messages that are very common but might be useful to know. As a rule of thumb a pipeline that is running as expected should never output anything else but LOG messages whilst processing data. Use this log level to log recurring information in chain functions and loop functions, for example.
	LevelTrace   DebugLevel = C.GST_LEVEL_TRACE   // (7) – Tracing-related messages. Examples for this are referencing/dereferencing of objects.
	LevelMemDump DebugLevel = C.GST_LEVEL_MEMDUMP // (9) – memory dump messages are used to log (small) chunks of data as memory dumps in the log. They will be displayed as hexdump with ASCII characters.
)

Type castings of DebugLevels

type Device

type Device struct{ *Object }

Device is a Go representation of a GstDevice.

func FromGstDeviceUnsafeFull

func FromGstDeviceUnsafeFull(device unsafe.Pointer) *Device

FromGstDeviceUnsafeFull wraps the given device with a finalizer.

func FromGstDeviceUnsafeNone

func FromGstDeviceUnsafeNone(device unsafe.Pointer) *Device

FromGstDeviceUnsafeNone wraps the given device with a ref and finalizer.

func (*Device) CreateElement

func (d *Device) CreateElement(name string) *Element

CreateElement creates a new element with all the required parameters set to use this device. If name is empty, one is automatically generated.

func (*Device) GetCaps

func (d *Device) GetCaps() *Caps

GetCaps returns the caps that this device supports. Unref after usage.

func (*Device) GetDeviceClass

func (d *Device) GetDeviceClass() string

GetDeviceClass gets the "class" of a device. This is a "/" separated list of classes that represent this device. They are a subset of the classes of the GstDeviceProvider that produced this device.

func (*Device) GetDisplayName

func (d *Device) GetDisplayName() string

GetDisplayName gets the user-friendly name of the device.

func (*Device) GetProperties

func (d *Device) GetProperties() *Structure

GetProperties gets the extra properties of the device.

func (*Device) HasClasses

func (d *Device) HasClasses(classes []string) bool

HasClasses checks if device matches all of the given classes.

func (*Device) Instance

func (d *Device) Instance() *C.GstDevice

Instance returns the underlying GstDevice object.

func (*Device) ReconfigureElement

func (d *Device) ReconfigureElement(elem *Element) error

ReconfigureElement tries to reconfigure an existing element to use the device. If this function fails, then one must destroy the element and create a new one using Device.CreateElement().

Note: This should only be implemented for elements that can change their device while in the PLAYING state.

type Domain

type Domain string

Domain represents the different types of error domains.

const (
	DomainCore     Domain = "CORE"
	DomainLibrary  Domain = "LIBRARY"
	DomainResource Domain = "RESOURCE"
	DomainStream   Domain = "STREAM"
)

ErrorDomain castings

type Element

type Element struct{ *Object }

Element is a Go wrapper around a GstElement.

func FromGstElementUnsafeFull

func FromGstElementUnsafeFull(elem unsafe.Pointer) *Element

FromGstElementUnsafeFull wraps the given element with a finalizer.

func FromGstElementUnsafeNone

func FromGstElementUnsafeNone(elem unsafe.Pointer) *Element

FromGstElementUnsafeNone wraps the given element with a ref and a finalizer.

func NewElement

func NewElement(factory string) (*Element, error)

NewElement creates a new element using the factory of the given name.

func NewElementMany

func NewElementMany(elemNames ...string) ([]*Element, error)

NewElementMany is a convenience wrapper around building many GstElements in a single function call. It returns an error if the creation of any element fails. A slice in the order the names were given is returned.

func NewElementWithName

func NewElementWithName(factory string, name string) (*Element, error)

NewElementWithName creates a new element and sets it's name to the given value.

func ToElement

func ToElement(obj interface{}) *Element

ToElement returns an Element object for the given Object. It will work on either gst.Object or glib.Object interfaces.

func (*Element) AbortState

func (e *Element) AbortState()

AbortState aborts the state change of the element. This function is used by elements that do asynchronous state changes and find out something is wrong.

func (*Element) AddPad

func (e *Element) AddPad(pad *Pad) bool

AddPad adds a pad (link point) to element. pad's parent will be set to element

Pads are automatically activated when added in the PAUSED or PLAYING state.

The pad and the element should be unlocked when calling this function.

This function will emit the pad-added signal on the element.

func (*Element) BlockSetState

func (e *Element) BlockSetState(state State) error

BlockSetState is like SetState except it will block until the transition is complete.

func (*Element) CallAsync

func (e *Element) CallAsync(f func())

CallAsync calls f from another thread. This is to be used for cases when a state change has to be performed from a streaming thread, directly via SetState or indirectly e.g. via SEEK events.

Calling those functions directly from the streaming thread will cause deadlocks in many situations, as they might involve waiting for the streaming thread to shut down from this very streaming thread.

func (*Element) ChangeState

func (e *Element) ChangeState(transition StateChange) StateChangeReturn

ChangeState performs the given transition on this element.

func (*Element) Connect

func (e *Element) Connect(signal string, f interface{}) (glib.SignalHandle, error)

Connect connects to the given signal on this element, and applies f as the callback. The callback must match the signature of the expected callback from the documentation. However, instead of specifying C types for arguments specify the go-gst equivalent (e.g. *gst.Element for almost all GstElement derivitives).

This and the Emit() method may get moved down the hierarchy to the Object level at some point, since

func (*Element) ContinueState

func (e *Element) ContinueState(ret StateChangeReturn) StateChangeReturn

ContinueState commits the state change of the element and proceed to the next pending state if any. This function is used by elements that do asynchronous state changes. The core will normally call this method automatically when an element returned GST_STATE_CHANGE_SUCCESS from the state change function.

If after calling this method the element still has not reached the pending state, the next state change is performed.

This method is used internally and should normally not be called by plugins or applications.

This function must be called with STATE_LOCK held.

func (*Element) Emit

func (e *Element) Emit(signal string, args ...interface{}) (interface{}, error)

Emit is a wrapper around g_signal_emitv() and emits the signal specified by the string s to an Object. Arguments to callback functions connected to this signal must be specified in args. Emit() returns an interface{} which must be type asserted as the Go equivalent type to the return value for native C callback.

Note that this code is unsafe in that the types of values in args are not checked against whether they are suitable for the callback.

func (*Element) Error

func (e *Element) Error(msg string, err error)

Error is a convenience wrapper around ErrorMessage to simply post the provided go error on the bus. The domain is assumed to be DomainLibrary and the code is assumed to be LibraryErrorFailed.

func (*Element) ErrorMessage

func (e *Element) ErrorMessage(domain Domain, code ErrorCode, text, debug string)

ErrorMessage is a convenience wrapper for posting an error message from inside an element. Only to be used from plugins.

func (*Element) GetBus

func (e *Element) GetBus() *Bus

GetBus returns the GstBus for retrieving messages from this element. This function returns nil unless the element is a Pipeline.

func (*Element) GetClock

func (e *Element) GetClock() *Clock

GetClock returns the Clock for this element. This is the clock as was last set with gst_element_set_clock. Elements in a pipeline will only have their clock set when the pipeline is in the PLAYING state.

func (*Element) GetFactory

func (e *Element) GetFactory() *ElementFactory

GetFactory returns the factory that created this element. No refcounting is needed.

func (*Element) GetPadTemplates

func (e *Element) GetPadTemplates() []*PadTemplate

GetPadTemplates retrieves a list of the pad templates associated with this element. The list must not be modified by the calling code.

func (*Element) GetPads

func (e *Element) GetPads() ([]*Pad, error)

GetPads retrieves a list of pads associated with the element.

func (*Element) GetRequestPad

func (e *Element) GetRequestPad(name string) *Pad

GetRequestPad gets a request pad from the element based on the name of the pad template. Unlike static pads, request pads are not created automatically but are only created on demand For example, audiomixer has sink template, 'sink_%u', which is used for creating multiple sink pads on demand so that it performs mixing of audio streams by linking multiple upstream elements on it's sink pads created on demand. This returns the request pad created on demand. Otherwise, it returns null if failed to create.

func (*Element) GetSinkPads

func (e *Element) GetSinkPads() ([]*Pad, error)

GetSinkPads retrieves a list of sink pads associated with the element.

func (*Element) GetSrcPads

func (e *Element) GetSrcPads() ([]*Pad, error)

GetSrcPads retrieves a list of src pads associated with the element.

func (*Element) GetState

func (e *Element) GetState() State

GetState returns the current state of this element.

func (*Element) GetStaticPad

func (e *Element) GetStaticPad(name string) *Pad

GetStaticPad retrieves a pad from element by name. This version only retrieves already-existing (i.e. 'static') pads.

func (*Element) Has

func (e *Element) Has(flags ElementFlags) bool

Has returns true if this element has the given flags.

func (*Element) InfoMessage

func (e *Element) InfoMessage(domain Domain, text string)

InfoMessage is a convenience wrapper for posting an info message from inside an element. Only to be used from plugins.

func (*Element) Instance

func (e *Element) Instance() *C.GstElement

Instance returns the underlying GstElement instance.

func (*Element) IsURIHandler

func (e *Element) IsURIHandler() bool

IsURIHandler returns true if this element can handle URIs.

func (e *Element) Link(elem *Element) error

Link wraps gst_element_link and links this element to the given one.

func (*Element) LinkFiltered

func (e *Element) LinkFiltered(elem *Element, filter *Caps) error

LinkFiltered wraps gst_element_link_filtered and link this element to the given one using the provided sink caps.

func (*Element) MessageFull

func (e *Element) MessageFull(msgType MessageType, domain Domain, code ErrorCode, text, debug, file, function string, line int)

MessageFull will post an error, warning, or info message on the bus from inside an element. Only to be used from plugins.

func (*Element) ParentChangeState

func (e *Element) ParentChangeState(transition StateChange) StateChangeReturn

ParentChangeState can be used when extending an element to chain up to the parents ChangeState handler.

func (*Element) ParentPostMessage

func (e *Element) ParentPostMessage(msg *Message) bool

ParentPostMessage can be used when extending an element. During a PostMessage, use this method to have the message posted on the bus after processing.

func (*Element) Query

func (e *Element) Query(q *Query) bool

Query performs a query on the given element.

For elements that don't implement a query handler, this function forwards the query to a random srcpad or to the peer of a random linked sinkpad of this element.

Please note that some queries might need a running pipeline to work.

func (*Element) QueryConvert

func (e *Element) QueryConvert(srcFormat Format, srcValue int64, destFormat Format) (bool, int64)

QueryConvert queries an element to convert src_val in src_format to dest_format.

func (*Element) QueryDuration

func (e *Element) QueryDuration(format Format) (bool, int64)

QueryDuration queries an element (usually top-level pipeline or playbin element) for the total stream duration in nanoseconds. This query will only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application will receive an ASYNC_DONE message on the pipeline bus when that is the case.

If the duration changes for some reason, you will get a DURATION_CHANGED message on the pipeline bus, in which case you should re-query the duration using this function.

func (*Element) QueryPosition

func (e *Element) QueryPosition(format Format) (bool, int64)

QueryPosition queries an element (usually top-level pipeline or playbin element) for the stream position in nanoseconds. This will be a value between 0 and the stream duration (if the stream duration is known). This query will usually only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application will receive an ASYNC_DONE message on the pipeline bus when that is the case.

func (*Element) ReleaseRequestPad

func (e *Element) ReleaseRequestPad(pad *Pad)

ReleaseRequestPad releases request pad

func (*Element) RemovePad

func (e *Element) RemovePad(pad *Pad) bool

RemovePad removes pad from element. pad will be destroyed if it has not been referenced elsewhere using gst_object_unparent.

This function is used by plugin developers and should not be used by applications. Pads that were dynamically requested from elements with gst_element_request_pad should be released with the gst_element_release_request_pad function instead.

Pads are not automatically deactivated so elements should perform the needed steps to deactivate the pad in case this pad is removed in the PAUSED or PLAYING state. See gst_pad_set_active for more information about deactivating pads.

The pad and the element should be unlocked when calling this function.

This function will emit the pad-removed signal on the element.

func (*Element) SendEvent

func (e *Element) SendEvent(ev *Event) bool

SendEvent sends an event to an element. If the element doesn't implement an event handler, the event will be pushed on a random linked sink pad for downstream events or a random linked source pad for upstream events.

This function takes ownership of the provided event so you should gst_event_ref it if you want to reuse the event after this call.

func (*Element) SetState

func (e *Element) SetState(state State) error

SetState sets the target state for this element.

func (*Element) SyncStateWithParent

func (e *Element) SyncStateWithParent() bool

SyncStateWithParent tries to change the state of the element to the same as its parent. If this function returns FALSE, the state of element is undefined.

func (*Element) TOCSetter

func (e *Element) TOCSetter() TOCSetter

TOCSetter returns a TOCSetter interface if implemented by this element. Otherwise it returns nil. Currently this only supports elements built through this package, however, inner application elements could still use the interface as a reference implementation.

func (*Element) TagSetter

func (e *Element) TagSetter() TagSetter

TagSetter returns a TagSetter interface if implemented by this element. Otherwise it returns nil. This currently only supports elements built through this package's bindings, however, inner application elements can still implement the interface themselves if they want.

func (*Element) URIHandler

func (e *Element) URIHandler() URIHandler

URIHandler returns a URIHandler interface if implemented by this element. Otherwise it returns nil. Currently this only supports elements built through this package, however, inner application elements could still use the interface as a reference implementation.

func (*Element) WarningMessage

func (e *Element) WarningMessage(domain Domain, text string)

WarningMessage is a convenience wrapper for posting a warning message from inside an element. Only to be used from plugins.

type ElementClass

type ElementClass struct{ *glib.ObjectClass }

ElementClass represents the subclass of an element provided by a plugin.

func ToElementClass

func ToElementClass(klass *glib.ObjectClass) *ElementClass

ToElementClass wraps the given ObjectClass in an ElementClass instance.

func (*ElementClass) AddMetadata

func (e *ElementClass) AddMetadata(key, value string)

AddMetadata sets key with the given value in the metadata of the class.

func (*ElementClass) AddPadTemplate

func (e *ElementClass) AddPadTemplate(templ *PadTemplate)

AddPadTemplate adds a padtemplate to an element class. This is mainly used in the ClassInit functions of ObjectSubclasses. If a pad template with the same name as an already existing one is added the old one is replaced by the new one.

templ's reference count will be incremented, and any floating reference will be removed

func (*ElementClass) AddStaticPadTemplate

func (e *ElementClass) AddStaticPadTemplate(templ *PadTemplate)

AddStaticPadTemplate adds a pad template to an element class based on the pad template templ. The template is first converted to a static pad template.

This is mainly used in the ClassInit functions of element implementations. If a pad template with the same name already exists, the old one is replaced by the new one.

func (*ElementClass) GetAllPadTemplates

func (e *ElementClass) GetAllPadTemplates() []*PadTemplate

GetAllPadTemplates retrieves a slice of all the pad templates associated with this class. The list must not be modified.

func (*ElementClass) GetMetadata

func (e *ElementClass) GetMetadata(key string) string

GetMetadata retrieves the metadata associated with key in the class.

func (*ElementClass) GetPadTemplate

func (e *ElementClass) GetPadTemplate(name string) *PadTemplate

GetPadTemplate retrieves the padtemplate with the given name. No unrefing is necessary. If no pad template exists with the given name, nil is returned.

func (*ElementClass) Instance

func (e *ElementClass) Instance() *C.GstElementClass

Instance returns the underlying GstElementClass instance.

func (*ElementClass) SetMetadata

func (e *ElementClass) SetMetadata(longname, classification, description, author string)

SetMetadata sets the detailed information for this class.

`longname` - The english long name of the element. E.g "File Sink"

`classification` - A string describing the type of element, as an unordered list separated with slashes ('/'). E.g: "Sink/File"

`description` - Sentence describing the purpose of the element. E.g: "Write stream to a file"

`author` - Name and contact details of the author(s). Use \n to separate multiple author metadata. E.g: "Joe Bloggs <joe.blogs at foo.com>"

type ElementFactory

type ElementFactory struct{ *PluginFeature }

ElementFactory wraps the GstElementFactory

func Find

func Find(name string) *ElementFactory

Find returns the factory for the given plugin, or nil if it doesn't exist. Unref after usage.

func (*ElementFactory) CanSinkAllCaps

func (e *ElementFactory) CanSinkAllCaps(caps *Caps) bool

CanSinkAllCaps checks if the factory can sink all possible capabilities.

func (*ElementFactory) CanSinkAnyCaps

func (e *ElementFactory) CanSinkAnyCaps(caps *Caps) bool

CanSinkAnyCaps checks if the factory can sink any possible capability.

func (*ElementFactory) CanSourceAllCaps

func (e *ElementFactory) CanSourceAllCaps(caps *Caps) bool

CanSourceAllCaps checks if the factory can src all possible capabilities.

func (*ElementFactory) CanSourceAnyCaps

func (e *ElementFactory) CanSourceAnyCaps(caps *Caps) bool

CanSourceAnyCaps checks if the factory can src any possible capability.

func (*ElementFactory) GetMetadata

func (e *ElementFactory) GetMetadata(key string) string

GetMetadata gets the metadata on this factory with key.

func (*ElementFactory) GetMetadataKeys

func (e *ElementFactory) GetMetadataKeys() []string

GetMetadataKeys gets the available keys for the metadata on this factory.

func (*ElementFactory) Instance

func (e *ElementFactory) Instance() *C.GstElementFactory

Instance returns the C GstFactory instance

type ElementFlags

type ElementFlags int

ElementFlags casts C GstElementFlags to a go type

const (
	ElementFlagLockedState  ElementFlags = C.GST_ELEMENT_FLAG_LOCKED_STATE  // (16) – ignore state changes from parent
	ElementFlagSink         ElementFlags = C.GST_ELEMENT_FLAG_SINK          // (32) – the element is a sink
	ElementFlagSource       ElementFlags = C.GST_ELEMENT_FLAG_SOURCE        // (64) – the element is a source.
	ElementFlagProvideClock ElementFlags = C.GST_ELEMENT_FLAG_PROVIDE_CLOCK // (128) – the element can provide a clock
	ElementFlagRequireClock ElementFlags = C.GST_ELEMENT_FLAG_REQUIRE_CLOCK // (256) – the element requires a clock
	ElementFlagIndexable    ElementFlags = C.GST_ELEMENT_FLAG_INDEXABLE     // (512) – the element can use an index
	ElementFlagLast         ElementFlags = C.GST_ELEMENT_FLAG_LAST          // (16384) – offset to define more flags
)

Type casting of element flags

type ElementImpl

type ElementImpl interface {
	// ChangeState is called by SetState to perform an incremental state change.
	ChangeState(*Element, StateChange) StateChangeReturn
	// GetState should return the states of the element
	GetState(self *Element, timeout time.Duration) (ret StateChangeReturn, current, pending State)
	// NoMorePads is called when there are no more pads on the element.
	NoMorePads(*Element)
	// PadAdded is called to add a pad to the element.
	PadAdded(*Element, *Pad)
	// PadRemoved is called to remove a pad from the element.
	PadRemoved(*Element, *Pad)
	// PostMessage is called when a message is posted to the element. Call Element.ParentPostMessage
	// to have it posted on the bus after processing.
	PostMessage(*Element, *Message) bool
	// ProvideClock is called to retrieve the clock provided by the element.
	ProvideClock(*Element) *Clock
	// Query is called to perform a query on the element.
	Query(*Element, *Query) bool
	// ReleasePad is called when a request pad is to be released.
	ReleasePad(*Element, *Pad)
	// RequestNewPad is called when a new pad is requested from the element.
	RequestNewPad(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad
	// SendEvent is called to send an event to the element.
	SendEvent(*Element, *Event) bool
	// SetBus is called to set the Bus on the element.
	SetBus(*Element, *Bus)
	// SetClock is called to set the clock on the element.
	SetClock(*Element, *Clock) bool
	// SetContext is called to set the Context on the element.
	SetContext(*Element, *Context)
	// SetState is called to set a new state on the element.
	SetState(*Element, State) StateChangeReturn
	// StateChanged is called immediately after a new state was set.
	StateChanged(self *Element, old, new, pending State)
}

ElementImpl is an interface containing go equivalents of the virtual methods that can be overridden by a plugin extending an Element.

type ErrorCode

type ErrorCode int

ErrorCode represents GstGError codes.

const (
	CoreErrorFailed         ErrorCode = C.GST_CORE_ERROR_FAILED          // (1) – a general error which doesn't fit in any other category. Make sure you add a custom message to the error call.
	CoreErrorTooLazy        ErrorCode = C.GST_CORE_ERROR_TOO_LAZY        // (2) – do not use this except as a placeholder for deciding where to go while developing code.
	CoreErrorNotImplemented ErrorCode = C.GST_CORE_ERROR_NOT_IMPLEMENTED // (3) – use this when you do not want to implement this functionality yet.
	CoreErrorStateChange    ErrorCode = C.GST_CORE_ERROR_STATE_CHANGE    // (4) – used for state change errors.
	CoreErrorPad            ErrorCode = C.GST_CORE_ERROR_PAD             // (5) – used for pad-related errors.
	CoreErrorThread         ErrorCode = C.GST_CORE_ERROR_THREAD          // (6) – used for thread-related errors.
	CoreErrorNegotiation    ErrorCode = C.GST_CORE_ERROR_NEGOTIATION     // (7) – used for negotiation-related errors.
	CoreErrorEvent          ErrorCode = C.GST_CORE_ERROR_EVENT           // (8) – used for event-related errors.
	CoreErrorSeek           ErrorCode = C.GST_CORE_ERROR_SEEK            // (9) – used for seek-related errors.
	CoreErrorCaps           ErrorCode = C.GST_CORE_ERROR_CAPS            // (10) – used for caps-related errors.
	CoreErrorTag            ErrorCode = C.GST_CORE_ERROR_TAG             // (11) – used for negotiation-related errors.
	CoreErrorMissingPlugin  ErrorCode = C.GST_CORE_ERROR_MISSING_PLUGIN  // (12) – used if a plugin is missing.
	CoreErrorClock          ErrorCode = C.GST_CORE_ERROR_CLOCK           // (13) – used for clock related errors.
	CoreErrorDisabled       ErrorCode = C.GST_CORE_ERROR_DISABLED        // (14) – used if functionality has been disabled at compile time.
)

Type castings of CoreErrors

const (
	LibraryErrorFailed   ErrorCode = C.GST_LIBRARY_ERROR_FAILED   // (1) – a general error which doesn't fit in any other category. Make sure you add a custom message to the error call.
	LibraryErrorTooLazy  ErrorCode = C.GST_LIBRARY_ERROR_TOO_LAZY // (2) – do not use this except as a placeholder for deciding where to go while developing code.
	LibraryErrorInit     ErrorCode = C.GST_LIBRARY_ERROR_INIT     // (3) – used when the library could not be opened.
	LibraryErrorShutdown ErrorCode = C.GST_LIBRARY_ERROR_SHUTDOWN // (4) – used when the library could not be closed.
	LibraryErrorSettings ErrorCode = C.GST_LIBRARY_ERROR_SETTINGS // (5) – used when the library doesn't accept settings.
	LibraryErrorEncode   ErrorCode = C.GST_LIBRARY_ERROR_ENCODE   // (6) – used when the library generated an encoding error.
)

Type castings for LibraryErrors

const (
	ResourceErrorFailed        ErrorCode = C.GST_RESOURCE_ERROR_FAILED          // (1) – a general error which doesn't fit in any other category. Make sure you add a custom message to the error call.
	ResourceErrorTooLazy       ErrorCode = C.GST_RESOURCE_ERROR_TOO_LAZY        // (2) – do not use this except as a placeholder for deciding where to go while developing code.
	ResourceErrorNotFound      ErrorCode = C.GST_RESOURCE_ERROR_NOT_FOUND       // (3) – used when the resource could not be found.
	ResourceErrorBusy          ErrorCode = C.GST_RESOURCE_ERROR_BUSY            // (4) – used when resource is busy.
	ResourceErrorOpenRead      ErrorCode = C.GST_RESOURCE_ERROR_OPEN_READ       // (5) – used when resource fails to open for reading.
	ResourceErrorOpenWrite     ErrorCode = C.GST_RESOURCE_ERROR_OPEN_WRITE      // (6) – used when resource fails to open for writing.
	ResourceErrorOpenReadWrite ErrorCode = C.GST_RESOURCE_ERROR_OPEN_READ_WRITE // (7) – used when resource cannot be opened for both reading and writing, or either (but unspecified which).
	ResourceErrorClose         ErrorCode = C.GST_RESOURCE_ERROR_CLOSE           // (8) – used when the resource can't be closed.
	ResourceErrorRead          ErrorCode = C.GST_RESOURCE_ERROR_READ            // (9) – used when the resource can't be read from.
	ResourceErrorWrite         ErrorCode = C.GST_RESOURCE_ERROR_WRITE           // (10) – used when the resource can't be written to.
	ResourceErrorSeek          ErrorCode = C.GST_RESOURCE_ERROR_SEEK            // (11) – used when a seek on the resource fails.
	ResourceErrorSync          ErrorCode = C.GST_RESOURCE_ERROR_SYNC            // (12) – used when a synchronize on the resource fails.
	ResourceErrorSettings      ErrorCode = C.GST_RESOURCE_ERROR_SETTINGS        // (13) – used when settings can't be manipulated on.
	ResourceErrorNoSpaceLeft   ErrorCode = C.GST_RESOURCE_ERROR_NO_SPACE_LEFT   // (14) – used when the resource has no space left.
	ResourceErrorNotAuthorized ErrorCode = C.GST_RESOURCE_ERROR_NOT_AUTHORIZED  // (15) – used when the resource can't be opened due to missing authorization. (Since: 1.2.4)
)

Type castings for ResourceErrors

const (
	StreamErrorFailed         ErrorCode = C.GST_STREAM_ERROR_FAILED          // (1) – a general error which doesn't fit in any other category. Make sure you add a custom message to the error call.
	StreamErrorTooLazy        ErrorCode = C.GST_STREAM_ERROR_TOO_LAZY        // (2) – do not use this except as a placeholder for deciding where to go while developing code.
	StreamErrorNotImplemented ErrorCode = C.GST_STREAM_ERROR_NOT_IMPLEMENTED // (3) – use this when you do not want to implement this functionality yet.
	StreamErrorTypeNotFound   ErrorCode = C.GST_STREAM_ERROR_TYPE_NOT_FOUND  // (4) – used when the element doesn't know the stream's type.
	StreamErrorWrongType      ErrorCode = C.GST_STREAM_ERROR_WRONG_TYPE      // (5) – used when the element doesn't handle this type of stream.
	StreamErrorCodecNotFound  ErrorCode = C.GST_STREAM_ERROR_CODEC_NOT_FOUND // (6) – used when there's no codec to handle the stream's type.
	StreamErrorDecode         ErrorCode = C.GST_STREAM_ERROR_DECODE          // (7) – used when decoding fails.
	StreamErrorEncode         ErrorCode = C.GST_STREAM_ERROR_ENCODE          // (8) – used when encoding fails.
	StreamErrorDemux          ErrorCode = C.GST_STREAM_ERROR_DEMUX           // (9) – used when demuxing fails.
	StreamErrorMux            ErrorCode = C.GST_STREAM_ERROR_MUX             // (10) – used when muxing fails.
	StreamErrorFormat         ErrorCode = C.GST_STREAM_ERROR_FORMAT          // (11) – used when the stream is of the wrong format (for example, wrong caps).
	StreamErrorDecrypt        ErrorCode = C.GST_STREAM_ERROR_DECRYPT         // (12) – used when the stream is encrypted and can't be decrypted because this is not supported by the element.
	StreamErrorDecryptNoKey   ErrorCode = C.GST_STREAM_ERROR_DECRYPT_NOKEY   // (13) – used when the stream is encrypted and can't be decrypted because no suitable key is available.
)

Type castings for StreamErrors

type Event

type Event struct {
	// contains filtered or unexported fields
}

Event is a go wrapper around a GstEvent.

func FromGstEventUnsafeFull

func FromGstEventUnsafeFull(ev unsafe.Pointer) *Event

FromGstEventUnsafeFull wraps the pointer to the given C GstEvent without taking a ref. A finalizer is applied.

func FromGstEventUnsafeNone

func FromGstEventUnsafeNone(ev unsafe.Pointer) *Event

FromGstEventUnsafeNone wraps the pointer to the given C GstEvent with the go type. A ref is taken and finalizer applied.

func NewBufferSizeEvent

func NewBufferSizeEvent(format Format, minSize, maxSize int64, async bool) *Event

NewBufferSizeEvent creates a new buffersize event. The event is sent downstream and notifies elements that they should provide a buffer of the specified dimensions.

When the async flag is set, a thread boundary is preferred.

func NewCapsEvent

func NewCapsEvent(caps *Caps) *Event

NewCapsEvent creates a new CAPS event for caps. The caps event can only travel downstream synchronized with the buffer flow and contains the format of the buffers that will follow after the event.

func NewCustomEvent

func NewCustomEvent(eventType EventType, structure *Structure) *Event

NewCustomEvent creates a new custom-typed event. This can be used for anything not handled by other event-specific functions to pass an event to another element.

func NewEOSEvent

func NewEOSEvent() *Event

NewEOSEvent creates a new EOS event. The eos event can only travel downstream synchronized with the buffer flow. Elements that receive the EOS event on a pad can return FlowEOS as a FlowReturn when data after the EOS event arrives.

The EOS event will travel down to the sink elements in the pipeline which will then post the MessageEOS on the bus after they have finished playing any buffered data.

When all sinks have posted an EOS message, an EOS message is forwarded to the application.

The EOS event itself will not cause any state transitions of the pipeline.

func NewFlushStartEvent

func NewFlushStartEvent() *Event

NewFlushStartEvent allocates a new flush start event. The flush start event can be sent upstream and downstream and travels out-of-bounds with the dataflow.

It marks pads as being flushing and will make them return FlowFlushing when used for data flow with gst_pad_push, gst_pad_chain, gst_pad_get_range and gst_pad_pull_range. Any event (except a EventFlushSStop) received on a flushing pad will return FALSE immediately.

Elements should unlock any blocking functions and exit their streaming functions as fast as possible when this event is received.

This event is typically generated after a seek to flush out all queued data in the pipeline so that the new media is played as soon as possible.

func NewFlushStopEvent

func NewFlushStopEvent(resetTime bool) *Event

NewFlushStopEvent allocates a new flush stop event. The flush stop event can be sent upstream and downstream and travels serialized with the dataflow. It is typically sent after sending a FLUSH_START event to make the pads accept data again.

Elements can process this event synchronized with the dataflow since the preceding FLUSH_START event stopped the dataflow.

This event is typically generated to complete a seek and to resume dataflow.

func NewGapEvent

func NewGapEvent(timestamp, duration time.Duration) *Event

NewGapEvent creates a new GAP event. A gap event can be thought of as conceptually equivalent to a buffer to signal that there is no data for a certain amount of time. This is useful to signal a gap to downstream elements which may wait for data, such as muxers or mixers or overlays, especially for sparse streams such as subtitle streams.

func NewLatencyEvent

func NewLatencyEvent(latency time.Duration) *Event

NewLatencyEvent creates a new latency event. The event is sent upstream from the sinks and notifies elements that they should add an additional latency to the running time before synchronising against the clock.

The latency is mostly used in live sinks and is always expressed in the time format.

func NewNavigationEvent

func NewNavigationEvent(structure *Structure) *Event

NewNavigationEvent creates a new navigation event from the given description. The event will take ownership of the structure.

func NewProtectionEvent

func NewProtectionEvent(systemID string, buffer *Buffer, origin string) *Event

NewProtectionEvent creates a new event containing information specific to a particular protection system (uniquely identified by system_id), by which that protection system can acquire key(s) to decrypt a protected stream.

In order for a decryption element to decrypt media protected using a specific system, it first needs all the protection system specific information necessary to acquire the decryption key(s) for that stream. The functions defined here enable this information to be passed in events from elements that extract it (e.g., ISOBMFF demuxers, MPEG DASH demuxers) to protection decrypter elements that use it.

Events containing protection system specific information are created using NewProtectionEvent, and they can be parsed by downstream elements using ParseProtection.

In Common Encryption, protection system specific information may be located within ISOBMFF files, both in movie (moov) boxes and movie fragment (moof) boxes; it may also be contained in ContentProtection elements within MPEG DASH MPDs. The events created by gst_event_new_protection contain data identifying from which of these locations the encapsulated protection system specific information originated. This origin information is required as some protection systems use different encodings depending upon where the information originates.

The events returned by NewProtectionEvent are implemented in such a way as to ensure that the most recently-pushed protection info event of a particular origin and system_id will be stuck to the output pad of the sending element.

func NewQOSEvent

func NewQOSEvent(qType QOSType, proportion float64, diff ClockTimeDiff, timestamp time.Duration) *Event

NewQOSEvent allocates a new qos event with the given values. The QOS event is generated in an element that wants an upstream element to either reduce or increase its rate because of high/low CPU load or other resource usage such as network performance or throttling. Typically sinks generate these events for each buffer they receive.

Type indicates the reason for the QoS event. GST_QOS_TYPE_OVERFLOW is used when a buffer arrived in time or when the sink cannot keep up with the upstream datarate. GST_QOS_TYPE_UNDERFLOW is when the sink is not receiving buffers fast enough and thus has to drop late buffers. GST_QOS_TYPE_THROTTLE is used when the datarate is artificially limited by the application, for example to reduce power consumption.

Proportion indicates the real-time performance of the streaming in the element that generated the QoS event (usually the sink). The value is generally computed based on more long term statistics about the streams timestamps compared to the clock. A value < 1.0 indicates that the upstream element is producing data faster than real-time. A value > 1.0 indicates that the upstream element is not producing data fast enough. 1.0 is the ideal proportion value. The proportion value can safely be used to lower or increase the quality of the element.

Diff is the difference against the clock in running time of the last buffer that caused the element to generate the QOS event. A negative value means that the buffer with timestamp arrived in time. A positive value indicates how late the buffer with timestamp was. When throttling is enabled, diff will be set to the requested throttling interval.

Timestamp is the timestamp of the last buffer that cause the element to generate the QOS event. It is expressed in running time and thus an ever increasing value.

The upstream element can use the diff and timestamp values to decide whether to process more buffers. For positive diff, all buffers with timestamp <= timestamp + diff will certainly arrive late in the sink as well. A (negative) diff value so that timestamp + diff would yield a result smaller than 0 is not allowed.

The application can use general event probes to intercept the QoS event and implement custom application specific QoS handling.

func NewReconfigureEvent

func NewReconfigureEvent() *Event

NewReconfigureEvent creates a new reconfigure event. The purpose of the reconfigure event is to travel upstream and make elements renegotiate their caps or reconfigure their buffer pools. This is useful when changing properties on elements or changing the topology of the pipeline.

func NewSeekEvent

func NewSeekEvent(rate float64, format Format, flags SeekFlags, startType SeekType, start int64, stopType SeekType, stop int64) *Event

NewSeekEvent allocates a new seek event with the given parameters.

The seek event configures playback of the pipeline between start to stop at the speed given in rate, also called a playback segment. The start and stop values are expressed in format.

A rate of 1.0 means normal playback rate, 2.0 means double speed. Negatives values means backwards playback. A value of 0.0 for the rate is not allowed and should be accomplished instead by PAUSING the pipeline.

A pipeline has a default playback segment configured with a start position of 0, a stop position of -1 and a rate of 1.0. The currently configured playback segment can be queried with GST_QUERY_SEGMENT.

start_type and stop_type specify how to adjust the currently configured start and stop fields in playback segment. Adjustments can be made relative or absolute to the last configured values. A type of GST_SEEK_TYPE_NONE means that the position should not be updated.

When the rate is positive and start has been updated, playback will start from the newly configured start position.

For negative rates, playback will start from the newly configured stop position (if any). If the stop position is updated, it must be different from -1 (#GST_CLOCK_TIME_NONE) for negative rates.

It is not possible to seek relative to the current playback position, to do this, PAUSE the pipeline, query the current playback position with GST_QUERY_POSITION and update the playback segment current position with a GST_SEEK_TYPE_SET to the desired position.

func NewSegmentDoneEvent

func NewSegmentDoneEvent(format Format, position int64) *Event

NewSegmentDoneEvent creates a new segment-done event. This event is sent by elements that finish playback of a segment as a result of a segment seek.

func NewSegmentEvent

func NewSegmentEvent(segment *Segment) *Event

NewSegmentEvent creates a new SEGMENT event for segment. The segment event can only travel downstream synchronized with the buffer flow and contains timing information and playback properties for the buffers that will follow.

The segment event marks the range of buffers to be processed. All data not within the segment range is not to be processed. This can be used intelligently by plugins to apply more efficient methods of skipping unneeded data. The valid range is expressed with the start and stop values.

The time value of the segment is used in conjunction with the start value to convert the buffer timestamps into the stream time. This is usually done in sinks to report the current stream_time. time represents the stream_time of a buffer carrying a timestamp of start. time cannot be -1.

start cannot be -1, stop can be -1. If there is a valid stop given, it must be greater or equal the start, including when the indicated playback rate is < 0.

The applied_rate value provides information about any rate adjustment that has already been made to the timestamps and content on the buffers of the stream. (@rate * applied_rate) should always equal the rate that has been requested for playback. For example, if an element has an input segment with intended playback rate of 2.0 and applied_rate of 1.0, it can adjust incoming timestamps and buffer content by half and output a segment event with rate of 1.0 and applied_rate of 2.0

After a segment event, the buffer stream time is calculated with:

time + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate)

func NewSelectStreamsEvent

func NewSelectStreamsEvent(streams []*Stream) *Event

NewSelectStreamsEvent allocates a new select-streams event.

The select-streams event requests the specified streams to be activated.

The list of streams corresponds to the "Stream ID" of each stream to be activated. Those ID can be obtained via the GstStream objects present in EventStreamStart, EventStreamCollection or MessageStreamCollection.

Note: The list of streams can not be empty.

func NewSinkMessageEvent

func NewSinkMessageEvent(name string, msg *Message) *Event

NewSinkMessageEvent creates a new sink-message event. The purpose of the sink-message event is to instruct a sink to post the message contained in the event synchronized with the stream.

name is used to store multiple sticky events on one pad.

func NewStepEvent

func NewStepEvent(format Format, amount uint64, rate float64, flush, intermediate bool) *Event

NewStepEvent createss a new step event. The purpose of the step event is to instruct a sink to skip amount (expressed in format) of media. It can be used to implement stepping through the video frame by frame or for doing fast trick modes.

A rate of <= 0.0 is not allowed. Pause the pipeline, for the effect of rate = 0.0 or first reverse the direction of playback using a seek event to get the same effect as rate < 0.0.

The flush flag will clear any pending data in the pipeline before starting the step operation.

The intermediate flag instructs the pipeline that this step operation is part of a larger step operation.

func NewStreamCollectionEvent

func NewStreamCollectionEvent(collection *StreamCollection) *Event

NewStreamCollectionEvent creates a new STREAM_COLLECTION event. The stream collection event can only travel downstream synchronized with the buffer flow.

Source elements, demuxers and other elements that manage collections of streams and post GstStreamCollection messages on the bus also send this event downstream on each pad involved in the collection, so that activation of a new collection can be tracked through the downstream data flow.

func NewStreamGroupDoneEvent

func NewStreamGroupDoneEvent(groupID uint) *Event

NewStreamGroupDoneEvent creates a new Stream Group Done event. The stream-group-done event can only travel downstream synchronized with the buffer flow. Elements that receive the event on a pad should handle it mostly like EOS, and emit any data or pending buffers that would depend on more data arriving and unblock, since there won't be any more data.

This event is followed by EOS at some point in the future, and is generally used when switching pads - to unblock downstream so that new pads can be exposed before sending EOS on the existing pads.

func NewStreamStartEvent

func NewStreamStartEvent(streamID string) *Event

NewStreamStartEvent creates a new STREAM_START event. The stream start event can only travel downstream synchronized with the buffer flow. It is expected to be the first event that is sent for a new stream.

Source elements, demuxers and other elements that create new streams are supposed to send this event as the first event of a new stream. It should not be sent after a flushing seek or in similar situations and is used to mark the beginning of a new logical stream. Elements combining multiple streams must ensure that this event is only forwarded downstream once and not for every single input stream.

The stream_id should be a unique string that consists of the upstream stream-id, / as separator and a unique stream-id for this specific stream. A new stream-id should only be created for a stream if the upstream stream is split into (potentially) multiple new streams, e.g. in a demuxer, but not for every single element in the pipeline. Pad CreateStreamID can be used to create a stream-id. There are no particular semantics for the stream-id, though it should be deterministic (to support stream matching) and it might be used to order streams (besides any information conveyed by stream flags).

func NewTOCEvent

func NewTOCEvent(toc *TOC, updated bool) *Event

NewTOCEvent generates a TOC event from the given toc. The purpose of the TOC event is to inform elements that some kind of the TOC was found.

func NewTOCSelectEvent

func NewTOCSelectEvent(uid string) *Event

NewTOCSelectEvent generates a TOC select event with the given uid. The purpose of the TOC select event is to start playback based on the TOC's entry with the given uid.

func NewTagEvent

func NewTagEvent(tagList *TagList) *Event

NewTagEvent generates a metadata tag event from the given taglist.

The scope of the taglist specifies if the taglist applies to the complete medium or only to this specific stream. As the tag event is a sticky event, elements should merge tags received from upstream with a given scope with their own tags with the same scope and create a new tag event from it.

func ToGstEvent

func ToGstEvent(ev unsafe.Pointer) *Event

ToGstEvent converts the given pointer into an Event without affecting the ref count or placing finalizers.

func (*Event) Copy

func (e *Event) Copy() *Event

Copy copies the event using the event specific copy function.

func (*Event) CopySegment

func (e *Event) CopySegment(segment *Segment)

CopySegment parses a segment event and copies the Segment into the location given by segment.

func (*Event) GetRunningTimeOffset

func (e *Event) GetRunningTimeOffset() int64

GetRunningTimeOffset retrieves the accumulated running time offset of the event.

Events passing through GstPad that have a running time offset set via gst_pad_set_offset will get their offset adjusted according to the pad's offset.

If the event contains any information that related to the running time, this information will need to be updated before usage with this offset.

func (*Event) GetSeqnum

func (e *Event) GetSeqnum() uint32

GetSeqnum retrieves the sequence number of a event.

Events have ever-incrementing sequence numbers, which may also be set explicitly via SetSeqnum. Sequence numbers are typically used to indicate that a event corresponds to some other set of events or messages, for example an EOS event corresponding to a SEEK event. It is considered good practice to make this correspondence when possible, though it is not required.

Note that events and messages share the same sequence number incrementor; two events or messages will never have the same sequence number unless that correspondence was made explicitly.

func (*Event) GetStructure

func (e *Event) GetStructure() *Structure

GetStructure accesses the structure of the event.

func (*Event) HasName

func (e *Event) HasName(name string) bool

HasName checks if event has the given name. This function is usually used to check the name of a custom event.

func (*Event) Instance

func (e *Event) Instance() *C.GstEvent

Instance returns the underlying GstEvent instance.

func (*Event) ParseBufferSize

func (e *Event) ParseBufferSize() (format Format, minSize, maxSize int64, async bool)

ParseBufferSize gets the format, minsize, maxsize and async-flag in the buffersize event.

func (*Event) ParseCaps

func (e *Event) ParseCaps() *Caps

ParseCaps gets the caps from event. The caps remains valid as long as event remains valid.

func (*Event) ParseFlushStop

func (e *Event) ParseFlushStop() (resetTime bool)

ParseFlushStop parses the FLUSH_STOP event and retrieve the reset_time member. Value reflects whether time should be reset.

func (*Event) ParseGap

func (e *Event) ParseGap() (timestamp, duration time.Duration)

ParseGap extracts timestamp and duration from a new GAP event.

func (*Event) ParseGroupID

func (e *Event) ParseGroupID() (ok bool, gid uint)

ParseGroupID returns a group ID if set on the event.

func (*Event) ParseLatency

func (e *Event) ParseLatency() time.Duration

ParseLatency gets the latency in the latency event.

func (*Event) ParseProtection

func (e *Event) ParseProtection() (systemID string, data *Buffer, origin string)

ParseProtection parses an event containing protection system specific information and stores the results in system_id, data and origin. The data stored in system_id, origin and data are valid until event is released.

func (*Event) ParseQOS

func (e *Event) ParseQOS() (qTtype QOSType, proportion float64, diff ClockTimeDiff, timestamp time.Duration)

ParseQOS gets the type, proportion, diff and timestamp in the qos event. See NewQOSEvent for more information about the different QoS values.

timestamp will be adjusted for any pad offsets of pads it was passing through.

func (*Event) ParseSeek

func (e *Event) ParseSeek() (rate float64, format Format, flags SeekFlags, startType SeekType, start int64, stopType SeekType, stop int64)

ParseSeek parses a seek event.

func (*Event) ParseSeekTrickModeInterval

func (e *Event) ParseSeekTrickModeInterval() (interval time.Duration)

ParseSeekTrickModeInterval retrieves the trickmode interval that may have been set on a seek event with SetSeekTrickModeInterval.

func (*Event) ParseSegment

func (e *Event) ParseSegment() *Segment

ParseSegment parses a segment event and stores the result in the given segment location. segment remains valid only until the event is freed. Don't modify the segment and make a copy if you want to modify it or store it for later use.

func (*Event) ParseSegmentDone

func (e *Event) ParseSegmentDone() (Format, int64)

ParseSegmentDone extracts the position and format from the segment done message.

func (*Event) ParseSelectStreams

func (e *Event) ParseSelectStreams() []*Stream

ParseSelectStreams parses the SELECT_STREAMS event and retrieve the contained streams.

func (*Event) ParseSinkMessage

func (e *Event) ParseSinkMessage() *Message

ParseSinkMessage parses the sink-message event. Unref msg after usage.

func (*Event) ParseStep

func (e *Event) ParseStep() (format Format, amount uint64, rate float64, flush, intermediate bool)

ParseStep parses a step message

func (*Event) ParseStream

func (e *Event) ParseStream() *Stream

ParseStream parses a stream-start event and extract the GstStream from it.

func (*Event) ParseStreamCollection

func (e *Event) ParseStreamCollection() *StreamCollection

ParseStreamCollection parses a stream collection from the event.

func (*Event) ParseStreamFlags

func (e *Event) ParseStreamFlags() StreamFlags

ParseStreamFlags parses the stream flags from an event.

func (*Event) ParseStreamGroupDone

func (e *Event) ParseStreamGroupDone() uint

ParseStreamGroupDone parses a stream-group-done event and store the result in the given group_id location.

func (*Event) ParseStreamStart

func (e *Event) ParseStreamStart() string

ParseStreamStart parses a stream-id event and store the result in the given stream_id location.

func (*Event) ParseTOC

func (e *Event) ParseTOC() (toc *TOC, updated bool)

ParseTOC parses a TOC event and store the results in the given toc and updated locations.

func (*Event) ParseTOCSelect

func (e *Event) ParseTOCSelect() string

ParseTOCSelect parses a TOC select event and store the results in the given uid location.

func (*Event) ParseTag

func (e *Event) ParseTag() *TagList

ParseTag parses a tag event and stores the results in the given taglist location. Do not modify or free the returned tag list.

func (*Event) Ref

func (e *Event) Ref() *Event

Ref increases the ref count on the event by one.

func (*Event) Seqnum

func (e *Event) Seqnum() uint32

Seqnum returns the sequence number of the event.

func (*Event) SetGroupID

func (e *Event) SetGroupID(id uint)

SetGroupID sets the group id for the stream. All streams that have the same group id are supposed to be played together, i.e. all streams inside a container file should have the same group id but different stream ids. The group id should change each time the stream is started, resulting in different group ids each time a file is played for example.

Use NextGroupID to get a new group id.

func (*Event) SetRunningTimeOffset

func (e *Event) SetRunningTimeOffset(offset int64)

SetRunningTimeOffset sets the running time offset of a event. See GetRunningTimeOffset for more information.

func (*Event) SetSeekTrickModeInterval

func (e *Event) SetSeekTrickModeInterval(interval time.Duration)

SetSeekTrickModeInterval sets a trickmode interval on a (writable) seek event. Elements that support TRICKMODE_KEY_UNITS seeks SHOULD use this as the minimal interval between each frame they may output.

func (*Event) SetSeqnum

func (e *Event) SetSeqnum(seqnum uint32)

SetSeqnum sets the sequence number of a event.

This function might be called by the creator of a event to indicate that the event relates to other events or messages. See GetSeqnum for more information.

func (*Event) SetStream

func (e *Event) SetStream(stream *Stream)

SetStream sets the stream on the stream-start event

func (*Event) SetStreamFlags

func (e *Event) SetStreamFlags(flags StreamFlags)

SetStreamFlags sets the stream flags on the event.

func (*Event) Timestamp

func (e *Event) Timestamp() time.Duration

Timestamp returns the timestamp of the event.

func (*Event) Type

func (e *Event) Type() EventType

Type returns the type of the event

func (*Event) Unref

func (e *Event) Unref()

Unref decreases the refcount of an event, freeing it if the refcount reaches 0.

func (*Event) WritableStructure

func (e *Event) WritableStructure() *Structure

WritableStructure returns a writable version of the structure.

type EventType

type EventType int

EventType is a go cast for a GstEventType

const (
	EventTypeUnknown          EventType = C.GST_EVENT_UNKNOWN           //(0) – unknown event.
	EventTypeFlushStart       EventType = C.GST_EVENT_FLUSH_START       // (2563) – Start a flush operation. This event clears all data from the pipeline and unblock all streaming threads.
	EventTypeFlushStop        EventType = C.GST_EVENT_FLUSH_STOP        // (5127) – Stop a flush operation. This event resets the running-time of the pipeline.
	EventTypeStreamStart      EventType = C.GST_EVENT_STREAM_START      // (10254) – Event to mark the start of a new stream. Sent before any other serialized event and only sent at the start of a new stream, not after flushing seeks.
	EventTypeCaps             EventType = C.GST_EVENT_CAPS              // (12814) – GstCaps event. Notify the pad of a new media type.
	EventTypeSegment          EventType = C.GST_EVENT_SEGMENT           // (17934) – A new media segment follows in the dataflow. The segment events contains information for clipping buffers and converting buffer timestamps to running-time and stream-time.
	EventTypeStreamCollection EventType = C.GST_EVENT_STREAM_COLLECTION // (19230) – A new GstStreamCollection is available (Since: 1.10)
	EventTypeTag              EventType = C.GST_EVENT_TAG               // (20510) – A new set of metadata tags has been found in the stream.
	EventTypeBufferSize       EventType = C.GST_EVENT_BUFFERSIZE        // (23054) – Notification of buffering requirements. Currently not used yet.
	EventTypeSinkMessage      EventType = C.GST_EVENT_SINK_MESSAGE      // (25630) – An event that sinks turn into a message. Used to send messages that should be emitted in sync with rendering.
	EventTypeStreamGroupDone  EventType = C.GST_EVENT_STREAM_GROUP_DONE // (26894) – Indicates that there is no more data for the stream group ID in the message. Sent before EOS in some instances and should be handled mostly the same. (Since: 1.10)
	EventTypeEOS              EventType = C.GST_EVENT_EOS               // (28174) – End-Of-Stream. No more data is to be expected to follow without either a STREAM_START event, or a FLUSH_STOP and a SEGMENT event.
	EventTypeTOC              EventType = C.GST_EVENT_TOC               // (30750) – An event which indicates that a new table of contents (TOC) was found or updated.
	EventTypeProtection       EventType = C.GST_EVENT_PROTECTION        // (33310) – An event which indicates that new or updated encryption information has been found in the stream.
	EventTypeSegmentDone      EventType = C.GST_EVENT_SEGMENT_DONE      // (38406) – Marks the end of a segment playback.
	EventTypeGap              EventType = C.GST_EVENT_GAP               // (40966) – Marks a gap in the datastream.
	// EventTypeInstantRateChange      EventType = C.GST_EVENT_INSTANT_RATE_CHANGE      // (46090) – Notify downstream that a playback rate override should be applied as soon as possible. (Since: 1.18)
	EventTypeQOS           EventType = C.GST_EVENT_QOS            // (48641) – A quality message. Used to indicate to upstream elements that the downstream elements should adjust their processing rate.
	EventTypeSeek          EventType = C.GST_EVENT_SEEK           // (51201) – A request for a new playback position and rate.
	EventTypeNavigation    EventType = C.GST_EVENT_NAVIGATION     // (53761) – Navigation events are usually used for communicating user requests, such as mouse or keyboard movements, to upstream elements.
	EventTypeLatency       EventType = C.GST_EVENT_LATENCY        // (56321) – Notification of new latency adjustment. Sinks will use the latency information to adjust their synchronisation.
	EventTypeStep          EventType = C.GST_EVENT_STEP           // (58881) – A request for stepping through the media. Sinks will usually execute the step operation.
	EventTypeReconfigure   EventType = C.GST_EVENT_RECONFIGURE    // (61441) – A request for upstream renegotiating caps and reconfiguring.
	EventTypeTOCSelect     EventType = C.GST_EVENT_TOC_SELECT     // (64001) – A request for a new playback position based on TOC entry's UID.
	EventTypeSelectStreams EventType = C.GST_EVENT_SELECT_STREAMS // (66561) – A request to select one or more streams (Since: 1.10)
	// EventTypeInstantRateSyncTime    EventType = C.GST_EVENT_INSTANT_RATE_SYNC_TIME   // (66817) – Sent by the pipeline to notify elements that handle the instant-rate-change event about the running-time when the rate multiplier should be applied (or was applied). (Since: 1.18)
	EventTypeCustomUpstream         EventType = C.GST_EVENT_CUSTOM_UPSTREAM          // (69121) – Upstream custom event
	EventTypeCustomDownstream       EventType = C.GST_EVENT_CUSTOM_DOWNSTREAM        // (71686) – Downstream custom event that travels in the data flow.
	EventTypeCustomOOB              EventType = C.GST_EVENT_CUSTOM_DOWNSTREAM_OOB    // (74242) – Custom out-of-band downstream event.
	EventTypeCustomDownstreamSticky EventType = C.GST_EVENT_CUSTOM_DOWNSTREAM_STICKY // (76830) – Custom sticky downstream event.
	EventTypeCustomBoth             EventType = C.GST_EVENT_CUSTOM_BOTH              // (79367) – Custom upstream or downstream event. In-band when travelling downstream.
	EventTypeCustomBothOOB          EventType = C.GST_EVENT_CUSTOM_BOTH_OOB          // (81923) – Custom upstream or downstream out-of-band event.
)

Type casts for EventTypes

func (EventType) String

func (e EventType) String() string

String implements a stringer on event types

type EventTypeFlags

type EventTypeFlags int

EventTypeFlags casts GstEventTypeFlags

const (
	EventTypeFlagUpstream    EventTypeFlags = C.GST_EVENT_TYPE_UPSTREAM     // (1) – Set if the event can travel upstream.
	EventTypeFlagDownstream  EventTypeFlags = C.GST_EVENT_TYPE_DOWNSTREAM   // (2) – Set if the event can travel downstream.
	EventTypeFlagSerialized  EventTypeFlags = C.GST_EVENT_TYPE_SERIALIZED   // (4) – Set if the event should be serialized with data flow.
	EventTypeFlagSticky      EventTypeFlags = C.GST_EVENT_TYPE_STICKY       // (8) – Set if the event is sticky on the pads.
	EventTypeFlagStickyMulti EventTypeFlags = C.GST_EVENT_TYPE_STICKY_MULTI // (16) – Multiple sticky events can be on a pad, each identified by the event name.
)

Type castings

type FlagsetValue

type FlagsetValue struct {
	// contains filtered or unexported fields
}

FlagsetValue is the go wrapper around a GstFlagSet value.

func Flagset

func Flagset(flags, mask uint) *FlagsetValue

Flagset returns a new FlagsetValue. The flags value indicates the values of flags, the mask represents which bits in the flag value have been set, and which are "don't care".

func ValueGetFlagset

func ValueGetFlagset(value *glib.Value) *FlagsetValue

ValueGetFlagset returns the flagset inside his value.

func (*FlagsetValue) Flags

func (f *FlagsetValue) Flags() uint

Flags returns the flags for this flagset.

func (*FlagsetValue) Mask

func (f *FlagsetValue) Mask() uint

Mask returns the mask for this flagset.

func (*FlagsetValue) ToGValue

func (f *FlagsetValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type Float64RangeValue

type Float64RangeValue struct {
	// contains filtered or unexported fields
}

Float64RangeValue is the go wrapper around a GstDoubleRange value.

func Float64Range

func Float64Range(start, end float64) *Float64RangeValue

Float64Range returns a new Float64RangeValue. This is the equivalent of a double range value.

func ValueGetFloat64Range

func ValueGetFloat64Range(value *glib.Value) *Float64RangeValue

ValueGetFloat64Range returns the range from inside this value.

func (*Float64RangeValue) End

func (f *Float64RangeValue) End() float64

End returns the end for this range.

func (*Float64RangeValue) Start

func (f *Float64RangeValue) Start() float64

Start returns the start for this range.

func (*Float64RangeValue) String

func (f *Float64RangeValue) String() string

String returns a string representation of the range.

func (*Float64RangeValue) ToGValue

func (f *Float64RangeValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type FlowReturn

type FlowReturn int

FlowReturn is go type casting for GstFlowReturn.

const (
	FlowOK            FlowReturn = C.GST_FLOW_OK             // Data passing was ok
	FlowNotLinked     FlowReturn = C.GST_FLOW_NOT_LINKED     // Pad is not linked
	FlowFlushing      FlowReturn = C.GST_FLOW_FLUSHING       // Pad is flushing
	FlowEOS           FlowReturn = C.GST_FLOW_EOS            // Pad is EOS
	FlowNotNegotiated FlowReturn = C.GST_FLOW_NOT_NEGOTIATED // Pad is not negotiated
	FlowError         FlowReturn = C.GST_FLOW_ERROR          // Some (fatal) error occurred
	FlowNotSupported  FlowReturn = C.GST_FLOW_NOT_SUPPORTED  // The operation is not supported.
)

Type casting of the GstFlowReturn types. Custom ones are omitted for now.

func (FlowReturn) String

func (f FlowReturn) String() string

String impelements a stringer on FlowReturn

type Format

type Format int

Format is a representation of GstFormat.

const (
	FormatUndefined Format = C.GST_FORMAT_UNDEFINED // (0) – undefined format
	FormatDefault   Format = C.GST_FORMAT_DEFAULT   // (1) – the default format of the pad/element. This can be samples for raw audio, or frames/fields for raw video.
	FormatBytes     Format = C.GST_FORMAT_BYTES     // (2) - bytes
	FormatTime      Format = C.GST_FORMAT_TIME      // (3) – time in nanoseconds
)

Type casts of formats

func (Format) String

func (f Format) String() string

String implements a stringer on GstFormat types

type FractionRangeValue

type FractionRangeValue struct {
	// contains filtered or unexported fields
}

FractionRangeValue represents a GstFractionRange.

func FractionRange

func FractionRange(start, end *FractionValue) *FractionRangeValue

FractionRange returns a new GstFractionRange.

func ValueGetFractionRange

func ValueGetFractionRange(value *glib.Value) *FractionRangeValue

ValueGetFractionRange returns the range inside the given value.

func (*FractionRangeValue) End

End returns the end of the range.

func (*FractionRangeValue) Start

func (g *FractionRangeValue) Start() *FractionValue

Start returns the start of the range.

func (*FractionRangeValue) String

func (g *FractionRangeValue) String() string

String returns a string representation of the range.

func (*FractionRangeValue) ToGValue

func (g *FractionRangeValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type FractionValue

type FractionValue struct {
	// contains filtered or unexported fields
}

FractionValue is a helper structure for building fractions for functions that require them.

func Fraction

func Fraction(numerator, denominator int) *FractionValue

Fraction returns a new GFraction with the given numerator and denominator.

func ValueGetFraction

func ValueGetFraction(value *glib.Value) *FractionValue

ValueGetFraction returns the fraction inside the given value.

func (*FractionValue) Denom

func (g *FractionValue) Denom() int

Denom returns the fraction's denominator.

func (*FractionValue) Num

func (g *FractionValue) Num() int

Num returns the fraction's numerator.

func (*FractionValue) String

func (g *FractionValue) String() string

String returns a string representation of the fraction.

func (*FractionValue) ToGValue

func (g *FractionValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type GError

type GError struct {
	// contains filtered or unexported fields
}

GError is a Go wrapper for a C GError in the context of GStreamer. It implements the error interface and provides additional functions for retrieving debug strings and details.

func NewGError

func NewGError(code ErrorCode, err error) *GError

NewGError wraps the given error inside a GError (to be used with message constructors).

func (*GError) Code

func (e *GError) Code() ErrorCode

Code returns the error code of the error message.

func (*GError) DebugString

func (e *GError) DebugString() string

DebugString returns any debug info alongside the error.

func (*GError) Error

func (e *GError) Error() string

Error implements the error interface and returns the error message.

func (*GError) Message

func (e *GError) Message() string

Message is an alias to `Error()`. It's for clarity when this object is parsed from a `GST_MESSAGE_INFO` or `GST_MESSAGE_WARNING`.

func (*GError) Structure

func (e *GError) Structure() *Structure

Structure returns the structure of the error message which may contain additional metadata.

type GapFlags

type GapFlags int

GapFlags casts GstGapFlags

const (
	GapFlagMissingData GapFlags = 1
)

Type castings

type GhostPad

type GhostPad struct{ *ProxyPad }

GhostPad is a go representation of a GstGhostPad.

func FromGstGhostPadUnsafeFull

func FromGstGhostPadUnsafeFull(pad unsafe.Pointer) *GhostPad

FromGstGhostPadUnsafeFull wraps the given GstGhostPad.

func FromGstGhostPadUnsafeNone

func FromGstGhostPadUnsafeNone(pad unsafe.Pointer) *GhostPad

FromGstGhostPadUnsafeNone wraps the given GstGhostPad.

func NewGhostPad

func NewGhostPad(name string, target *Pad) *GhostPad

NewGhostPad create a new ghostpad with target as the target. The direction will be taken from the target pad. The target must be unlinked. If name is empty, one will be selected.

Will ref the target.

func NewGhostPadFromTemplate

func NewGhostPadFromTemplate(name string, target *Pad, tmpl *PadTemplate) *GhostPad

NewGhostPadFromTemplate creates a new ghostpad with target as the target. The direction will be taken from the target pad. The template used on the ghostpad will be template. If name is empty one will be selected.

Will ref the target.

func NewGhostPadNoTarget

func NewGhostPadNoTarget(name string, direction PadDirection) *GhostPad

NewGhostPadNoTarget creates a new ghostpad without a target with the given direction. A target can be set on the ghostpad later with the SetTarget function. If name is empty, one will be selected.

The created ghostpad will not have a padtemplate.

func NewGhostPadNoTargetFromTemplate

func NewGhostPadNoTargetFromTemplate(name string, tmpl *PadTemplate) *GhostPad

NewGhostPadNoTargetFromTemplate creates a new ghostpad based on templ, without setting a target. The direction will be taken from the templ.

func (*GhostPad) ActivateModeDefault

func (g *GhostPad) ActivateModeDefault(parent *Object, mode PadMode, active bool) bool

ActivateModeDefault invokes the default activate mode function of a ghost pad.

func (*GhostPad) GetTarget

func (g *GhostPad) GetTarget() *Pad

GetTarget gets the target pad of gpad.

func (*GhostPad) Instance

func (g *GhostPad) Instance() *C.GstGhostPad

Instance returns the underlying ghost pad instance.

func (*GhostPad) InternalActivateModeDefault

func (g *GhostPad) InternalActivateModeDefault(parent *Object, mode PadMode, active bool) bool

InternalActivateModeDefault invokes the default activate mode function of a proxy pad that is owned by a ghost pad.

func (*GhostPad) SetTarget

func (g *GhostPad) SetTarget(target *Pad) bool

SetTarget sets the new target of the ghostpad gpad. Any existing target is unlinked and links to the new target are established. if newtarget is nil the target will be cleared.

type Int64RangeValue

type Int64RangeValue struct {
	// contains filtered or unexported fields
}

Int64RangeValue represents a GstInt64Range.

func Int64Range

func Int64Range(start, end, step int64) *Int64RangeValue

Int64Range returns a new Int64RangeValue.

func ValueGetInt64Range

func ValueGetInt64Range(value *glib.Value) *Int64RangeValue

ValueGetInt64Range gets the int64 range from the given value.

func (*Int64RangeValue) End

func (i *Int64RangeValue) End() int64

End returns the end of the range

func (*Int64RangeValue) Start

func (i *Int64RangeValue) Start() int64

Start returns the start of the range

func (*Int64RangeValue) Step

func (i *Int64RangeValue) Step() int64

Step returns the step of the range

func (*Int64RangeValue) String

func (i *Int64RangeValue) String() string

String implements a Stringer.

func (*Int64RangeValue) ToGValue

func (i *Int64RangeValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type IntRangeValue

type IntRangeValue struct {
	// contains filtered or unexported fields
}

IntRangeValue represents a GstIntRange.

func IntRange

func IntRange(start, end, step int) *IntRangeValue

IntRange returns a new IntRangeValue.

func ValueGetIntRange

func ValueGetIntRange(value *glib.Value) *IntRangeValue

ValueGetIntRange gets the int range from the given value.

func (*IntRangeValue) End

func (i *IntRangeValue) End() int

End returns the end of the range

func (*IntRangeValue) Start

func (i *IntRangeValue) Start() int

Start returns the start of the range

func (*IntRangeValue) Step

func (i *IntRangeValue) Step() int

Step returns the step of the range

func (*IntRangeValue) String

func (i *IntRangeValue) String() string

String implements a Stringer.

func (*IntRangeValue) ToGValue

func (i *IntRangeValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

type License

type License string

License represents a type of license used on a plugin.

const (
	LicenseLGPL        License = "LGPL"
	LicenseGPL         License = "GPL"
	LicenseQPL         License = "QPL"
	LicenseGPLQPL      License = "GPL/QPL"
	LicenseMPL         License = "MPL"
	LicenseBSD         License = "BSD"
	LicenseMIT         License = "MIT/X11"
	LicenseProprietary License = "Proprietary"
	LicenseUnknown     License = "unknown"
)

Types of licenses

type MapFlags

type MapFlags int

MapFlags is a go casting of GstMapFlags

const (
	MapRead     MapFlags = C.GST_MAP_READ      //  (1) – map for read access
	MapWrite    MapFlags = C.GST_MAP_WRITE     // (2) - map for write access
	MapFlagLast MapFlags = C.GST_MAP_FLAG_LAST // (65536) – first flag that can be used for custom purposes
)

Type casting of the map flag types

type MapInfo

type MapInfo struct {
	// contains filtered or unexported fields
}

MapInfo is a go representation of a GstMapInfo.

func (*MapInfo) AsFloat32BESlice

func (m *MapInfo) AsFloat32BESlice() []float32

AsFloat32BESlice returns the contents of this map as a slice of 32-bit big-endian floats.

func (*MapInfo) AsFloat32LESlice

func (m *MapInfo) AsFloat32LESlice() []float32

AsFloat32LESlice returns the contents of this map as a slice of 32-bit little-endian floats.

func (*MapInfo) AsFloat64BESlice

func (m *MapInfo) AsFloat64BESlice() []float64

AsFloat64BESlice returns the contents of this map as a slice of 64-bit big-endian floats.

func (*MapInfo) AsFloat64LESlice

func (m *MapInfo) AsFloat64LESlice() []float64

AsFloat64LESlice returns the contents of this map as a slice of 64-bit little-endian floats.

func (*MapInfo) AsInt16BESlice

func (m *MapInfo) AsInt16BESlice() []int16

AsInt16BESlice returns the contents of this map as a slice of signed 16-bit big-endian integers.

func (*MapInfo) AsInt16LESlice

func (m *MapInfo) AsInt16LESlice() []int16

AsInt16LESlice returns the contents of this map as a slice of signed 16-bit little-endian integers.

func (*MapInfo) AsInt32BESlice

func (m *MapInfo) AsInt32BESlice() []int32

AsInt32BESlice returns the contents of this map as a slice of signed 32-bit big-endian integers.

func (*MapInfo) AsInt32LESlice

func (m *MapInfo) AsInt32LESlice() []int32

AsInt32LESlice returns the contents of this map as a slice of signed 32-bit little-endian integers.

func (*MapInfo) AsInt64BESlice

func (m *MapInfo) AsInt64BESlice() []int64

AsInt64BESlice returns the contents of this map as a slice of signed 64-bit big-endian integers.

func (*MapInfo) AsInt64LESlice

func (m *MapInfo) AsInt64LESlice() []int64

AsInt64LESlice returns the contents of this map as a slice of signed 64-bit little-endian integers.

func (*MapInfo) AsInt8Slice

func (m *MapInfo) AsInt8Slice() []int8

AsInt8Slice returns the contents of this map as a slice of signed 8-bit integers.

func (*MapInfo) AsUint16BESlice

func (m *MapInfo) AsUint16BESlice() []uint16

AsUint16BESlice returns the contents of this map as a slice of unsigned 16-bit big-endian integers.

func (*MapInfo) AsUint16LESlice

func (m *MapInfo) AsUint16LESlice() []uint16

AsUint16LESlice returns the contents of this map as a slice of unsigned 16-bit little-endian integers.

func (*MapInfo) AsUint32BESlice

func (m *MapInfo) AsUint32BESlice() []uint32

AsUint32BESlice returns the contents of this map as a slice of unsigned 32-bit big-endian integers.

func (*MapInfo) AsUint32LESlice

func (m *MapInfo) AsUint32LESlice() []uint32

AsUint32LESlice returns the contents of this map as a slice of unsigned 32-bit little-endian integers.

func (*MapInfo) AsUint64BESlice

func (m *MapInfo) AsUint64BESlice() []uint64

AsUint64BESlice returns the contents of this map as a slice of unsigned 64-bit big-endian integers.

func (*MapInfo) AsUint64LESlice

func (m *MapInfo) AsUint64LESlice() []uint64

AsUint64LESlice returns the contents of this map as a slice of unsigned 64-bit little-endian integers.

func (*MapInfo) AsUint8Slice

func (m *MapInfo) AsUint8Slice() []uint8

AsUint8Slice returns the contents of this map as a slice of unsigned 8-bit integers.

func (*MapInfo) Bytes

func (m *MapInfo) Bytes() []byte

Bytes returns a byte slice of the data inside this map info.

func (*MapInfo) Data

func (m *MapInfo) Data() unsafe.Pointer

Data returns a pointer to the raw data inside this map.

func (*MapInfo) Flags

func (m *MapInfo) Flags() MapFlags

Flags returns the flags set on this map.

func (*MapInfo) Instance

func (m *MapInfo) Instance() *C.GstMapInfo

Instance returns the underlying GstMapInfo instance.

func (*MapInfo) MaxSize

func (m *MapInfo) MaxSize() int64

MaxSize returns the maximum size of this map.

func (*MapInfo) Memory

func (m *MapInfo) Memory() *Memory

Memory returns the underlying memory object.

func (*MapInfo) Reader

func (m *MapInfo) Reader() io.Reader

Reader returns a Reader for the contents of this map's memory.

func (*MapInfo) Size

func (m *MapInfo) Size() int64

Size returrns the size of this map.

func (*MapInfo) WriteAt

func (m *MapInfo) WriteAt(offset int, data []byte)

WriteAt writes the given data sequence directly to the map's memory at the given offset.

func (*MapInfo) WriteData

func (m *MapInfo) WriteData(data []byte)

WriteData writes the given sequence directly to the map's memory.

func (*MapInfo) Writer

func (m *MapInfo) Writer() io.Writer

Writer returns a writer that will copy the contents passed to Write directly to the map's memory sequentially. An error will be returned if an attempt is made to write more data than the map can hold.

type Memory

type Memory struct {
	// contains filtered or unexported fields
}

Memory is a go representation of GstMemory. This object is implemented in a read-only fashion currently primarily for reference, and as such you should not really use it. You can create new memory blocks, but there are no methods implemented yet for modifying ones already in existence.

Use the Buffer and its Map methods to interact with memory in both a read and writable way.

func FromGstMemoryUnsafe

func FromGstMemoryUnsafe(mem unsafe.Pointer) *Memory

FromGstMemoryUnsafe wraps the given C GstMemory in the go type. It is meant for internal usage and exported for visibility to other packages.

func FromGstMemoryUnsafeFull

func FromGstMemoryUnsafeFull(mem unsafe.Pointer) *Memory

FromGstMemoryUnsafeFull wraps the given memory without taking an additional reference.

func FromGstMemoryUnsafeNone

func FromGstMemoryUnsafeNone(mem unsafe.Pointer) *Memory

FromGstMemoryUnsafeNone is an alias to FromGstMemoryUnsafe.

func NewMemoryWrapped

func NewMemoryWrapped(flags MemoryFlags, data []byte, maxSize, offset int64) *Memory

NewMemoryWrapped allocates a new memory block that wraps the given data.

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

func (*Memory) Alignment

func (m *Memory) Alignment() int64

Alignment returns the alignment of the memory.

func (*Memory) Allocator

func (m *Memory) Allocator() *Allocator

Allocator returns the allocator for this memory.

func (*Memory) Bytes

func (m *Memory) Bytes() []byte

Bytes will return a byte slice of the data inside this memory if it is readable.

func (*Memory) Copy

func (m *Memory) Copy(offset, size int64) *Memory

Copy returns 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.

func (*Memory) Instance

func (m *Memory) Instance() *C.GstMemory

Instance returns the underlying GstMemory instance.

func (*Memory) Map

func (m *Memory) Map(flags MapFlags) *MapInfo

Map the data inside the memory. This function can return nil if the memory is not read or writable. It is safe to call this function multiple times on the same Memory, 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 memory with the appropriate flags, or map initially with both read/write access.

Unmap the Memory after usage.

func (*Memory) MaxSize

func (m *Memory) MaxSize() int64

MaxSize returns the maximum size allocated for this memory block.

func (*Memory) Offset

func (m *Memory) Offset() int64

Offset returns the offset where valid data starts.

func (*Memory) Parent

func (m *Memory) Parent() *Memory

Parent returns this memory block's parent.

func (*Memory) Ref

func (m *Memory) Ref() *Memory

Ref increases the ref count on this memory block by one.

func (*Memory) Size

func (m *Memory) Size() int64

Size returns the size of valid data.

func (*Memory) Unmap

func (m *Memory) Unmap()

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

func (*Memory) Unref

func (m *Memory) Unref()

Unref decreases the ref count on this memory block by one. When the refcount reaches zero the memory is freed.

type MemoryFlags

type MemoryFlags int

MemoryFlags represent flags for wrapped memory

const (
	MemoryFlagReadOnly             MemoryFlags = C.GST_MEMORY_FLAG_READONLY              // (2) – memory is readonly. It is not allowed to map the memory with GST_MAP_WRITE.
	MemoryFlagNoShare              MemoryFlags = C.GST_MEMORY_FLAG_NO_SHARE              // (16) – memory must not be shared. Copies will have to be made when this memory needs to be shared between buffers. (DEPRECATED: do not use in new code, instead you should create a custom GstAllocator for memory pooling instead of relying on the GstBuffer they were originally attached to.)
	MemoryFlagZeroPrefixed         MemoryFlags = C.GST_MEMORY_FLAG_ZERO_PREFIXED         // (32) – the memory prefix is filled with 0 bytes
	MemoryFlagZeroPadded           MemoryFlags = C.GST_MEMORY_FLAG_ZERO_PADDED           // (64) – the memory padding is filled with 0 bytes
	MemoryFlagPhysicallyContiguous MemoryFlags = C.GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS // (128) – the memory is physically contiguous. (Since: 1.2)
	MemoryFlagNotMappable          MemoryFlags = C.GST_MEMORY_FLAG_NOT_MAPPABLE          // (256) – the memory can't be mapped via gst_memory_map without any preconditions. (Since: 1.2)
	MemoryFlagLast                 MemoryFlags = 1048576                                 // first flag that can be used for custom purposes
)

Type castins of MemoryFlags

type Message

type Message struct {
	// contains filtered or unexported fields
}

Message is a Go wrapper around a GstMessage. It provides convenience methods for unref-ing and parsing the underlying messages.

func FromGstMessageUnsafeFull

func FromGstMessageUnsafeFull(msg unsafe.Pointer) *Message

FromGstMessageUnsafeFull wraps the given unsafe.Pointer in a message. No ref is taken and a finalizer is placed on the resulting object.

func FromGstMessageUnsafeNone

func FromGstMessageUnsafeNone(msg unsafe.Pointer) *Message

FromGstMessageUnsafeNone wraps the given unsafe.Pointer in a message. A ref is taken on the message and a runtime finalizer placed on the object.

func NewApplicationMessage

func NewApplicationMessage(src interface{}, structure *Structure) *Message

NewApplicationMessage creates a new application-typed message. GStreamer will never create these messages; they are a gift from them to you. Enjoy.

The source of all message constructors must be a valid Object or descendant, specifically one created from the go runtime. If not the message returned will be nil.

func NewAsyncDoneMessage

func NewAsyncDoneMessage(src interface{}, runningTime time.Duration) *Message

NewAsyncDoneMessage builds a message that is posted when elements completed an ASYNC state change. RunningTime contains the time of the desired running time when this elements goes to PLAYING. A value less than 0 for runningTime means that the element has no clock interaction and thus doesn't care about the running time of the pipeline.

func NewAsyncStartMessage

func NewAsyncStartMessage(src interface{}) *Message

NewAsyncStartMessage returns a message that is posted by elements when they start an ASYNC state change.

func NewBufferingMessage

func NewBufferingMessage(src interface{}, percent int) *Message

NewBufferingMessage returns a message that can be posted by an element that needs to buffer data before it can continue processing. percent should be a value between 0 and 100. A value of 100 means that the buffering completed.

When percent is < 100 the application should PAUSE a PLAYING pipeline. When percent is 100, the application can set the pipeline (back) to PLAYING. The application must be prepared to receive BUFFERING messages in the PREROLLING state and may only set the pipeline to PLAYING after receiving a message with percent set to 100, which can happen after the pipeline completed prerolling.

func NewClockLostMessage

func NewClockLostMessage(src interface{}, clock *Clock) *Message

NewClockLostMessage creates a clock lost message. This message is posted whenever the clock is not valid anymore.

If this message is posted by the pipeline, the pipeline will select a new clock again when it goes to PLAYING. It might therefore be needed to set the pipeline to PAUSED and PLAYING again.

func NewClockProvideMessage

func NewClockProvideMessage(src interface{}, clock *Clock, ready bool) *Message

NewClockProvideMessage creates a clock provide message. This message is posted whenever an element is ready to provide a clock or lost its ability to provide a clock (maybe because it paused or became EOS).

This message is mainly used internally to manage the clock selection.

func NewCustomMessage

func NewCustomMessage(src interface{}, msgType MessageType, structure *Structure) *Message

NewCustomMessage creates a new custom-typed message. This can be used for anything not handled by other message-specific functions to pass a message to the app. The structure field can be nil.

func NewDeviceAddedMessage

func NewDeviceAddedMessage(src interface{}, device *Device) *Message

NewDeviceAddedMessage creates a new device-added message. The device-added message is produced by a DeviceProvider or a DeviceMonitor. They announce the appearance of monitored devices.

func NewDeviceChangedMessage

func NewDeviceChangedMessage(src interface{}, device, changedDevice *Device) *Message

NewDeviceChangedMessage creates a new device-changed message. The device-changed message is produced by a DeviceProvider or a DeviceMonitor. They announce that a device properties has changed and device represent the new modified version of changed_device.

func NewDeviceRemovedMessage

func NewDeviceRemovedMessage(src interface{}, device *Device) *Message

NewDeviceRemovedMessage creates a new device-removed message. The device-removed message is produced by a DeviceProvider or a DeviceMonitor. They announce the disappearance of monitored devices.

func NewDurationChangedMessage

func NewDurationChangedMessage(src interface{}) *Message

NewDurationChangedMessage creates a new duration changed message. This message is posted by elements that know the duration of a stream when the duration changes. This message is received by bins and is used to calculate the total duration of a pipeline.

func NewEOSMessage

func NewEOSMessage(src interface{}) *Message

NewEOSMessage creates a new eos message. This message is generated and posted in the sink elements of a Bin. The bin will only forward the EOS message to the application if all sinks have posted an EOS message.

func NewElementMessage

func NewElementMessage(src interface{}, structure *Structure) *Message

NewElementMessage creates a new element-specific message. This is meant as a generic way of allowing one-way communication from an element to an application, for example "the firewire cable was unplugged". The format of the message should be documented in the element's documentation. The structure field can be nil.

func NewErrorMessage

func NewErrorMessage(src interface{}, err error, debugStr string, structure *Structure) *Message

NewErrorMessage creates a new error message. The message will copy error and debug. This message is posted by element when a fatal event occurred. The pipeline will probably (partially) stop. The application receiving this message should stop the pipeline. Structure can be nil to not add a structure to the message.

func NewHaveContextMessage

func NewHaveContextMessage(src interface{}, ctx *Context) *Message

NewHaveContextMessage creates a message that is posted when an element has a new local Context.

func NewInfoMessage

func NewInfoMessage(src interface{}, msg string, debugStr string, structure *Structure) *Message

NewInfoMessage creates a new info message. Structure can be nil.

func NewLatencyMessage

func NewLatencyMessage(src interface{}) *Message

NewLatencyMessage creates a message that can be posted by elements when their latency requirements have changed.

func NewNeedContextMessage

func NewNeedContextMessage(src interface{}, ctxType string) *Message

NewNeedContextMessage creates a message that is posted when an element needs a specific Context.

func NewNewClockMessage

func NewNewClockMessage(src interface{}, clock *Clock) *Message

NewNewClockMessage creates a new clock message. This message is posted whenever the pipeline selects a new clock for the pipeline.

func NewProgressMessage

func NewProgressMessage(src interface{}, progressType ProgressType, code, text string) *Message

NewProgressMessage creates messages that are posted by elements when they use an asynchronous task to perform actions triggered by a state change.

Code contains a well defined string describing the action. Text should contain a user visible string detailing the current action.

func NewPropertyNotifyMessage

func NewPropertyNotifyMessage(src interface{}, propName string, val interface{}) *Message

NewPropertyNotifyMessage creates a new message notifying an object's properties have changed. If the source OR the value cannot be coereced to C types, the function will return nil.

func NewQoSMessage

func NewQoSMessage(src interface{}, live bool, runningTime, streamTime, timestamp, duration time.Duration) *Message

NewQoSMessage creates a message that is posted on the bus whenever an element decides to drop a buffer because of QoS reasons or whenever it changes its processing strategy because of QoS reasons (quality adjustments such as processing at lower accuracy).

This message can be posted by an element that performs synchronisation against the clock (live) or it could be dropped by an element that performs QoS because of QOS events received from a downstream element (!live).

running_time, stream_time, timestamp, duration should be set to the respective running-time, stream-time, timestamp and duration of the (dropped) buffer that generated the QoS event. Values can be left to less than zero when unknown.

func NewRedirectMessage

func NewRedirectMessage(src interface{}, location string, tagList *TagList, entryStructure *Structure) *Message

NewRedirectMessage creates a new redirect message and adds a new entry to it. Redirect messages are posted when an element detects that the actual data has to be retrieved from a different location. This is useful if such a redirection cannot be handled inside a source element, for example when HTTP 302/303 redirects return a non-HTTP URL.

The redirect message can hold multiple entries. The first one is added when the redirect message is created, with the given location, tag_list, entry_struct arguments. Use AddRedirectEntry to add more entries.

Each entry has a location, a tag list, and a structure. All of these are optional. The tag list and structure are useful for additional metadata, such as bitrate statistics for the given location.

By default, message recipients should treat entries in the order they are stored. The recipient should therefore try entry #0 first, and if this entry is not acceptable or working, try entry #1 etc. Senders must make sure that they add entries in this order. However, recipients are free to ignore the order and pick an entry that is "best" for them. One example would be a recipient that scans the entries for the one with the highest bitrate tag.

The specified location string is copied. However, ownership over the tag list and structure are transferred to the message.

func NewRequestStateMessage

func NewRequestStateMessage(src interface{}, state State) *Message

NewRequestStateMessage creates a message that can be posted by elements when they want to have their state changed. A typical use case would be an audio server that wants to pause the pipeline because a higher priority stream is being played.

func NewResetTimeMessage

func NewResetTimeMessage(src interface{}, runningTime time.Duration) *Message

NewResetTimeMessage creates a message that is posted when the pipeline running-time should be reset to running_time, like after a flushing seek.

func NewSegmentDoneMessage

func NewSegmentDoneMessage(src interface{}, format Format, position int64) *Message

NewSegmentDoneMessage creates a new segment done message. This message is posted by elements that finish playback of a segment as a result of a segment seek. This message is received by the application after all elements that posted a segment_start have posted the segment_done.

func NewSegmentStartMessage

func NewSegmentStartMessage(src interface{}, format Format, position int64) *Message

NewSegmentStartMessage creates a new segment message. This message is posted by elements that start playback of a segment as a result of a segment seek. This message is not received by the application but is used for maintenance reasons in container elements.

func NewStateChangedMessage

func NewStateChangedMessage(src interface{}, oldState, newState, pendingState State) *Message

NewStateChangedMessage creates a state change message. This message is posted whenever an element changed its state.

func NewStateDirtyMessage

func NewStateDirtyMessage(src interface{}) *Message

NewStateDirtyMessage creates a state dirty message. This message is posted whenever an element changed its state asynchronously and is used internally to update the states of container objects.

func NewStepDoneMessage

func NewStepDoneMessage(src interface{}, format Format, amount uint64, rate float64, flush, intermediate bool, duration time.Duration, eos bool) *Message

NewStepDoneMessage creates a message that is posted by elements when they complete a part, when intermediate set to TRUE, or a complete step operation.

Duration will contain the amount of time of the stepped amount of media in format format.

func NewStepStartMessage

func NewStepStartMessage(src interface{}, active bool, format Format, amount uint64, rate float64, flush, intermediate bool) *Message

NewStepStartMessage creates a message that is posted by elements when they accept or activate a new step event for amount in format.

Active is set to FALSE when the element accepted the new step event and has queued it for execution in the streaming threads.

Active is set to TRUE when the element has activated the step operation and is now ready to start executing the step in the streaming thread. After this message is emitted, the application can queue a new step operation in the element.

func NewStreamCollectionMessage

func NewStreamCollectionMessage(src interface{}, collection *StreamCollection) *Message

NewStreamCollectionMessage creates a new stream-collection message. The message is used to announce new StreamCollections.

func NewStreamSelectedMessage

func NewStreamSelectedMessage(src interface{}, collection *StreamCollection) *Message

NewStreamSelectedMessage creates a new steams-selected message. The message is used to announce that an array of streams has been selected. This is generally in response to a GST_EVENT_SELECT_STREAMS event, or when an element (such as decodebin3) makes an initial selection of streams.

The message also contains the StreamCollection to which the various streams belong to.

Users of this constructor can add the selected streams with StreamsSelectedAdd.

func NewStreamStartMessage

func NewStreamStartMessage(src interface{}) *Message

NewStreamStartMessage creates a new stream_start message. This message is generated and posted in the sink elements of a Bin. The bin will only forward the StreamStart message to the application if all sinks have posted a StreamStart message.

func NewStreamStatusMessage

func NewStreamStatusMessage(src interface{}, stType StreamStatusType, owner *Element) *Message

NewStreamStatusMessage creates a new stream status message. This message is posted when a streaming thread is created/destroyed or when the state changed.

func NewStructureChangeMessage

func NewStructureChangeMessage(src interface{}, chgType StructureChangeType, owner *Element, busy bool) *Message

NewStructureChangeMessage creates a new structure change message. This message is posted when the structure of a pipeline is in the process of being changed, for example when pads are linked or unlinked.

Src should be the sinkpad that unlinked or linked.

func NewTOCMessage

func NewTOCMessage(src interface{}, toc *TOC, updated bool) *Message

NewTOCMessage creates a new TOC message. The message is posted by elements that discovered or updated a TOC.

func NewTagMessage

func NewTagMessage(src interface{}, tagList *TagList) *Message

NewTagMessage creates a new tag message. The message will take ownership of the tag list. The message is posted by elements that discovered a new taglist.

func NewWarningMessage

func NewWarningMessage(src interface{}, msg string, debugStr string, structure *Structure) *Message

NewWarningMessage creates a new warning message. Structure can be nil.

func ToGstMessage

func ToGstMessage(msg unsafe.Pointer) *Message

ToGstMessage converts the given pointer into a Message without affecting the ref count or placing finalizers.

func (*Message) AddRedirectEntry

func (m *Message) AddRedirectEntry(location string, tagList *TagList, entryStructure *Structure)

AddRedirectEntry creates and appends a new entry to the message.

func (*Message) Copy

func (m *Message) Copy() *Message

Copy will copy this object into a new Message that can be Unrefed separately.

func (*Message) GetStructure

func (m *Message) GetStructure() *Structure

GetStructure returns the GstStructure of this message, using the type of the message to determine the method to use. The returned structure must not be freed.

func (*Message) Instance

func (m *Message) Instance() *C.GstMessage

Instance returns the underlying GstMessage object.

func (*Message) NumRedirectEntries

func (m *Message) NumRedirectEntries() int64

NumRedirectEntries returns the number of redirect entries in a MessageRedirect.

func (*Message) ParseAsyncDone

func (m *Message) ParseAsyncDone() time.Duration

ParseAsyncDone extracts the running time from the async task done message.

func (*Message) ParseBuffering

func (m *Message) ParseBuffering() int

ParseBuffering extracts the buffering percent from the GstMessage.

func (*Message) ParseBufferingStats

func (m *Message) ParseBufferingStats() *BufferingStats

ParseBufferingStats extracts the buffering stats values from message.

func (*Message) ParseClockProvide

func (m *Message) ParseClockProvide() (clock *Clock, ready bool)

ParseClockProvide extracts the clock and ready flag from the GstMessage. The clock object returned remains valid until the message is freed.

func (*Message) ParseDeviceAdded

func (m *Message) ParseDeviceAdded() *Device

ParseDeviceAdded parses a device-added message. The device-added message is produced by GstDeviceProvider or a GstDeviceMonitor. It announces the appearance of monitored devices.

func (*Message) ParseDeviceChanged

func (m *Message) ParseDeviceChanged() (newDevice, oldDevice *Device)

ParseDeviceChanged Parses a device-changed message. The device-changed message is produced by GstDeviceProvider or a GstDeviceMonitor. It announces that a device's properties have changed. The first device returned is the updated Device, and the second changedDevice represents the old state of the device.

func (*Message) ParseDeviceRemoved

func (m *Message) ParseDeviceRemoved() *Device

ParseDeviceRemoved parses a device-removed message. The device-removed message is produced by GstDeviceProvider or a GstDeviceMonitor. It announces the disappearance of monitored devices.

func (*Message) ParseError

func (m *Message) ParseError() *GError

ParseError will return a GError from the contents of this message. This will only work if the GstMessageType is `GST_MESSAGE_ERROR`.

func (*Message) ParseHaveContext

func (m *Message) ParseHaveContext() *Context

ParseHaveContext parses the context from a HaveContext message.

func (*Message) ParseInfo

func (m *Message) ParseInfo() *GError

ParseInfo is identical to ParseError. The returned types are the same. However, this is intended for use with GstMessageType `GST_MESSAGE_INFO`.

func (*Message) ParseNewClock

func (m *Message) ParseNewClock() *Clock

ParseNewClock parses the new Clock in the message. The clock object returned remains valid until the message is freed.

func (*Message) ParseProgress

func (m *Message) ParseProgress() (progressType ProgressType, code, text string)

ParseProgress parses the progress type, code and text.

func (*Message) ParsePropertyNotify

func (m *Message) ParsePropertyNotify() (obj *Object, propertName string, propertyValue *glib.Value)

ParsePropertyNotify parses a property-notify message. These will be posted on the bus only when set up with Element.AddPropertyNotifyWatch (TODO) or Element.AddPropertyDeepNotifyWatch (TODO).

func (*Message) ParseQoS

func (m *Message) ParseQoS() *QoSValues

ParseQoS extracts the timestamps and live status from the QoS message. The values reflect those of the dropped buffer. Values of ClockTimeNone or -1 mean unknown values.

func (*Message) ParseRedirectEntryAt

func (m *Message) ParseRedirectEntryAt(idx int64) (location string, tags *TagList, structure *Structure)

ParseRedirectEntryAt parses the redirect entry at the given index. Total indices can be retrieved with NumRedirectEntries().

func (*Message) ParseRequestState

func (m *Message) ParseRequestState() State

ParseRequestState parses the requests state from the message.

func (*Message) ParseResetTime

func (m *Message) ParseResetTime() time.Duration

ParseResetTime extracts the running-time from the ResetTime message.

func (*Message) ParseSegmentDone

func (m *Message) ParseSegmentDone() (Format, int64)

ParseSegmentDone extracts the position and format of the SegmentDone message.

func (*Message) ParseSegmentStart

func (m *Message) ParseSegmentStart() (Format, int64)

ParseSegmentStart extracts the position and format of the SegmentStart message.

func (*Message) ParseStateChanged

func (m *Message) ParseStateChanged() (oldState, newState State)

ParseStateChanged will return the old and new states as Go strings. This will only work if the GstMessageType is `GST_MESSAGE_STATE_CHANGED`.

func (*Message) ParseStepDone

func (m *Message) ParseStepDone() *StepDoneValues

ParseStepDone extracts the values for the StepDone message.

func (*Message) ParseStepStart

func (m *Message) ParseStepStart() *StepStartValues

ParseStepStart extracts the values for the StepStart message.

func (*Message) ParseStreamCollection

func (m *Message) ParseStreamCollection() *StreamCollection

ParseStreamCollection parses a stream-collection message.

func (*Message) ParseStreamStatus

func (m *Message) ParseStreamStatus() (StreamStatusType, *Element)

ParseStreamStatus parses the stream status type of the message as well as the element that produced it. The element returned should NOT be unrefed.

func (*Message) ParseStreamsSelected

func (m *Message) ParseStreamsSelected() *StreamCollection

ParseStreamsSelected parses a streams-selected message.

func (*Message) ParseStructureChange

func (m *Message) ParseStructureChange() (chgType StructureChangeType, owner *Element, busy bool)

ParseStructureChange extracts the change type and completion status from the GstMessage. If the returned bool is true, the change is still in progress.

func (*Message) ParseTOC

func (m *Message) ParseTOC() (toc *TOC, updated bool)

ParseTOC extracts the TOC from the GstMessage. The TOC returned in the output argument is a copy; the caller must free it with Unref when done.

func (*Message) ParseTags

func (m *Message) ParseTags() *TagList

ParseTags extracts the tag list from the GstMessage. Tags are copied and should be unrefed after usage.

func (*Message) ParseWarning

func (m *Message) ParseWarning() *GError

ParseWarning is identical to ParseError. The returned types are the same. However, this is intended for use with GstMessageType `GST_MESSAGE_WARNING`.

func (*Message) Ref

func (m *Message) Ref() *Message

Ref will increase the ref count on this message. This increases the total amount of times Unref needs to be called before the object is freed from memory. It returns the underlying message object for convenience.

func (*Message) Source

func (m *Message) Source() string

Source returns the source of the message.

func (*Message) StreamsSelectedAdd

func (m *Message) StreamsSelectedAdd(stream *Stream)

StreamsSelectedAdd adds the stream to the message

func (*Message) StreamsSelectedGetStream

func (m *Message) StreamsSelectedGetStream(index uint) *Stream

StreamsSelectedGetStream retrieves the Stream with index index from the message.

func (*Message) StreamsSelectedSize

func (m *Message) StreamsSelectedSize() uint

StreamsSelectedSize returns the number of streams contained in the message.

func (*Message) String

func (m *Message) String() string

String implements a stringer on the message. It iterates over the type of the message and applies the correct parser, then dumps a string of the basic contents of the message. This function can be expensive and should only be used for debugging purposes or in routines where latency is not a concern.

This stringer really just helps in keeping track of making sure all message types are accounted for in some way. It's the devil, writing it was the devil, and I hope you enjoy being able to `fmt.Println(msg)`.

func (*Message) Type

func (m *Message) Type() MessageType

Type returns the MessageType of the message.

func (*Message) TypeName

func (m *Message) TypeName() string

TypeName returns a Go string of the GstMessageType name.

func (*Message) Unref

func (m *Message) Unref()

Unref will call `gst_message_unref` on the underlying GstMessage, freeing it from memory.

type MessageType

type MessageType int

MessageType is an alias to the C equivalent of GstMessageType. See the official documentation for definitions of the messages: https://gstreamer.freedesktop.org/documentation/gstreamer/gstmessage.html?gi-language=c#GstMessageType

const (
	MessageUnknown          MessageType = C.GST_MESSAGE_UNKNOWN
	MessageEOS              MessageType = C.GST_MESSAGE_EOS
	MessageError            MessageType = C.GST_MESSAGE_ERROR
	MessageWarning          MessageType = C.GST_MESSAGE_WARNING
	MessageInfo             MessageType = C.GST_MESSAGE_INFO
	MessageTag              MessageType = C.GST_MESSAGE_TAG
	MessageBuffering        MessageType = C.GST_MESSAGE_BUFFERING
	MessageStateChanged     MessageType = C.GST_MESSAGE_STATE_CHANGED
	MessageStateDirty       MessageType = C.GST_MESSAGE_STATE_DIRTY
	MessageStepDone         MessageType = C.GST_MESSAGE_STEP_DONE
	MessageClockProvide     MessageType = C.GST_MESSAGE_CLOCK_PROVIDE
	MessageClockLost        MessageType = C.GST_MESSAGE_CLOCK_LOST
	MessageNewClock         MessageType = C.GST_MESSAGE_NEW_CLOCK
	MessageStructureChange  MessageType = C.GST_MESSAGE_STRUCTURE_CHANGE
	MessageStreamStatus     MessageType = C.GST_MESSAGE_STREAM_STATUS
	MessageApplication      MessageType = C.GST_MESSAGE_APPLICATION
	MessageElement          MessageType = C.GST_MESSAGE_ELEMENT
	MessageSegmentStart     MessageType = C.GST_MESSAGE_SEGMENT_START
	MessageSegmentDone      MessageType = C.GST_MESSAGE_SEGMENT_DONE
	MessageDurationChanged  MessageType = C.GST_MESSAGE_DURATION_CHANGED
	MessageLatency          MessageType = C.GST_MESSAGE_LATENCY
	MessageAsyncStart       MessageType = C.GST_MESSAGE_ASYNC_START
	MessageAsyncDone        MessageType = C.GST_MESSAGE_ASYNC_DONE
	MessageRequestState     MessageType = C.GST_MESSAGE_REQUEST_STATE
	MessageStepStart        MessageType = C.GST_MESSAGE_STEP_START
	MessageQoS              MessageType = C.GST_MESSAGE_QOS
	MessageProgress         MessageType = C.GST_MESSAGE_PROGRESS
	MessageTOC              MessageType = C.GST_MESSAGE_TOC
	MessageResetTime        MessageType = C.GST_MESSAGE_RESET_TIME
	MessageStreamStart      MessageType = C.GST_MESSAGE_STREAM_START
	MessageNeedContext      MessageType = C.GST_MESSAGE_NEED_CONTEXT
	MessageHaveContext      MessageType = C.GST_MESSAGE_HAVE_CONTEXT
	MessageExtended         MessageType = C.GST_MESSAGE_EXTENDED
	MessageDeviceAdded      MessageType = C.GST_MESSAGE_DEVICE_ADDED
	MessageDeviceRemoved    MessageType = C.GST_MESSAGE_DEVICE_REMOVED
	MessagePropertyNotify   MessageType = C.GST_MESSAGE_PROPERTY_NOTIFY
	MessageStreamCollection MessageType = C.GST_MESSAGE_STREAM_COLLECTION
	MessageStreamsSelected  MessageType = C.GST_MESSAGE_STREAMS_SELECTED
	MessageRedirect         MessageType = C.GST_MESSAGE_REDIRECT
	MessageDeviceChanged    MessageType = C.GST_MESSAGE_DEVICE_CHANGED
	MessageAny              MessageType = C.GST_MESSAGE_ANY
)

Type casting of GstMessageTypes See the official documentation for definitions of the messages: https://gstreamer.freedesktop.org/documentation/gstreamer/gstmessage.html?gi-language=c#GstMessageType

func (MessageType) String

func (m MessageType) String() string

String implements a stringer on MessageTypes

type Meta

type Meta struct {
	// contains filtered or unexported fields
}

Meta is a go representation of GstMeta.

func FromGstMetaUnsafe

func FromGstMetaUnsafe(ptr unsafe.Pointer) *Meta

FromGstMetaUnsafe wraps the pointer to the given C GstMeta with the go type. This is meant for internal usage and is exported for visibility to other packages.

func (*Meta) Flags

func (m *Meta) Flags() MetaFlags

Flags returns the flags on this Meta instance.

func (*Meta) Info

func (m *Meta) Info() *MetaInfo

Info returns the extra info with this metadata.

func (*Meta) Instance

func (m *Meta) Instance() *C.GstMeta

Instance returns the underlying GstMeta instance.

func (*Meta) SetFlags

func (m *Meta) SetFlags(flags MetaFlags)

SetFlags sets the flags on this Meta instance.

func (*Meta) SetInfo

func (m *Meta) SetInfo(info *MetaInfo)

SetInfo sets the info on this metadata.

type MetaFlags

type MetaFlags int

MetaFlags casts C GstMetaFlags to a go type.

const (
	MetaFlagNone     MetaFlags = C.GST_META_FLAG_NONE     // (0) – no flags
	MetaFlagReadOnly MetaFlags = C.GST_META_FLAG_READONLY // (1) – metadata should not be modified
	MetaFlagPooled   MetaFlags = C.GST_META_FLAG_POOLED   // (2) – metadata is managed by a bufferpool
	MetaFlagLocked   MetaFlags = C.GST_META_FLAG_LOCKED   // (4) – metadata should not be removed
	MetaFlagLast     MetaFlags = C.GST_META_FLAG_LAST     // (65536) – additional flags can be added starting from this flag.
)

Type casts of GstMetaFlags

type MetaFreeFunc

type MetaFreeFunc func(buffer *Buffer)

MetaFreeFunc is a function called when meta is freed in buffer.

type MetaInfo

type MetaInfo struct {
	// contains filtered or unexported fields
}

MetaInfo is a go representation of GstMetaInfo

func FromGstMetaInfoUnsafe

func FromGstMetaInfoUnsafe(ptr unsafe.Pointer) *MetaInfo

FromGstMetaInfoUnsafe wraps the given unsafe pointer in a MetaInfo instance.

func GetAPIInfo

func GetAPIInfo(name string) *MetaInfo

GetAPIInfo gets the MetaInfo for the given api type.

func GetProtectionMetaInfo

func GetProtectionMetaInfo() *MetaInfo

GetProtectionMetaInfo retrieves global ProtectionMetaInfo.

func RegisterMeta

func RegisterMeta(api glib.Type, name string, size int64, cbFuncs *MetaInfoCallbackFuncs) *MetaInfo

RegisterMeta registers and returns a new MetaInfo instance denoting the given type, name, and size.

func (*MetaInfo) API

func (m *MetaInfo) API() glib.Type

API returns the tag identifying the metadata structure and api.

func (*MetaInfo) Instance

func (m *MetaInfo) Instance() *C.GstMetaInfo

Instance returns the underlying GstMetaInfo instance.

func (*MetaInfo) SetAPI

func (m *MetaInfo) SetAPI(t glib.Type)

SetAPI sets the API tag identifying the metadata structure and api.

func (*MetaInfo) SetSize

func (m *MetaInfo) SetSize(size int64)

SetSize sets the size on the metadata.

func (*MetaInfo) SetType

func (m *MetaInfo) SetType(t glib.Type)

SetType sets the type identifying the implementor of the api.

func (*MetaInfo) Size

func (m *MetaInfo) Size() int64

Size returns the size of the metadata.

func (*MetaInfo) Type

func (m *MetaInfo) Type() glib.Type

Type returns the type identifying the implementor of the api.

type MetaInfoCallbackFuncs

type MetaInfoCallbackFuncs struct {
	InitFunc      MetaInitFunc
	FreeFunc      MetaFreeFunc
	TransformFunc MetaTransformFunc
}

MetaInfoCallbackFuncs represents callback functions to includ when registering a new meta type.

type MetaInitFunc

type MetaInitFunc func(params interface{}, buffer *Buffer) bool

MetaInitFunc is a function called when meta is initialized in buffer.

type MetaTransformCopy

type MetaTransformCopy struct {
	// true if only region is copied
	Region bool
	// the offset to copy, 0 if region is FALSE, otherwise > 0
	Offset int64
	// the size to copy, -1 or the buffer size when region is FALSE
	Size int64
}

MetaTransformCopy is extra data passed to a MetaTransformFunc

type MetaTransformFunc

type MetaTransformFunc func(transBuf, buf *Buffer, mType string, data *MetaTransformCopy) bool

MetaTransformFunc is a function called for each meta in buf as a result of performing a transformation on transbuf. Additional type specific transform data is passed to the function as data.

type MiniObject

type MiniObject struct {
	// contains filtered or unexported fields
}

MiniObject is an opaque struct meant to form the base of gstreamer classes extending the GstMiniObject. This object is a WIP and is intended primarily for forming the base of extending classes.

func NewMiniObject

func NewMiniObject(flags MiniObjectFlags, gtype glib.Type) *MiniObject

NewMiniObject initializes a new mini object with the desired flags, types, and callbacks. If you don't need any callbacks you can specify nil. TODO: This is more for reference and is not fully implemented.

func (*MiniObject) AddParent

func (m *MiniObject) AddParent(parent *MiniObject)

AddParent adds the given object as a parent of this object. See https://gstreamer.freedesktop.org/documentation/gstreamer/gstminiobject.html?gi-language=c#gst_mini_object_add_parent.

func (*MiniObject) Copy

func (m *MiniObject) Copy() *MiniObject

Copy creates a copy of this object.

func (*MiniObject) GetData

func (m *MiniObject) GetData(name string) unsafe.Pointer

GetData returns the userdata pointer associated with this object at the given key, or nil if none exists.

func (*MiniObject) Instance

func (m *MiniObject) Instance() *C.GstMiniObject

Instance returns the native GstMiniObject instance.

func (*MiniObject) Parent

func (m *MiniObject) Parent() *MiniObject

Parent returns the parent of this MiniObject

func (*MiniObject) Ref

func (m *MiniObject) Ref()

Ref increases the ref count on this object by one.

func (*MiniObject) SetData

func (m *MiniObject) SetData(name string, ptr unsafe.Pointer)

SetData sets a userdata pointer associated with this object at the given key, Use nil to delete an existing key.

func (*MiniObject) Type

func (m *MiniObject) Type() glib.Type

Type returns the type of this mini object.

func (*MiniObject) Unref

func (m *MiniObject) Unref()

Unref decresaes the ref count on this object by one.

type MiniObjectFlags

type MiniObjectFlags int

MiniObjectFlags casts GstMiniObjectFlags to a go type.

const (
	MiniObjectFlagLockable     MiniObjectFlags = C.GST_MINI_OBJECT_FLAG_LOCKABLE      // (1) – the object can be locked and unlocked with gst_mini_object_lock and gst_mini_object_unlock.
	MiniObjectFlagLockReadOnly MiniObjectFlags = C.GST_MINI_OBJECT_FLAG_LOCK_READONLY // (2) – the object is permanently locked in READONLY mode. Only read locks can be performed on the object.
	MiniObjectFlagMayBeLeaked  MiniObjectFlags = C.GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED // (4) – the object is expected to stay alive even after gst_deinit has been called and so should be ignored by leak detection tools. (Since: 1.10)
	MiniObjectFlagLast         MiniObjectFlags = C.GST_MINI_OBJECT_FLAG_LAST          // (16) – first flag that can be used by subclasses.
)

Type casting of mini-object flags

type Object

type Object struct{ *glib.InitiallyUnowned }

Object is a go representation of a GstObject.

func FromGstObjectUnsafeFull

func FromGstObjectUnsafeFull(ptr unsafe.Pointer) *Object

FromGstObjectUnsafeFull returns an Object wrapping the given pointer. It meant for internal usage and exported for visibility to other packages.

func FromGstObjectUnsafeNone

func FromGstObjectUnsafeNone(ptr unsafe.Pointer) *Object

FromGstObjectUnsafeNone returns an Object wrapping the given pointer. It meant for internal usage and exported for visibility to other packages.

func (*Object) BaseObject

func (o *Object) BaseObject() *Object

BaseObject is a convenience method for retrieving this object from embedded structs.

func (*Object) Clear

func (o *Object) Clear()

Clear will will clear all references to this object. If the reference is already null the the function does nothing. Otherwise the reference count is decreased and the pointer set to null.

func (*Object) GObject

func (o *Object) GObject() *glib.Object

GObject returns the underlying GObject instance.

func (*Object) GetName

func (o *Object) GetName() string

GetName returns the name of this object.

func (*Object) GetValue

func (o *Object) GetValue(property string, timestamp time.Duration) *glib.Value

GetValue retrieves the value for the given controlled property at the given timestamp.

func (*Object) GstObject

func (o *Object) GstObject() *C.GstObject

GstObject is an alias to Instance on the underlying GstObject of any extending struct.

func (*Object) Instance

func (o *Object) Instance() *C.GstObject

Instance returns the native C GstObject.

func (*Object) Log

func (o *Object) Log(cat *DebugCategory, level DebugLevel, message string)

Log logs a message to the given category from this object using the currently registered debugging handlers.

func (*Object) Ref

func (o *Object) Ref() *Object

Ref increments the reference count on object. This function does not take the lock on object because it relies on atomic refcounting. For convenience the same object is returned.

func (*Object) SetArg

func (o *Object) SetArg(name, value string)

SetArg sets the argument name to value on this object. Note that function silently returns if object has no property named name or when value cannot be converted to the type for this property.

func (*Object) Unref

func (o *Object) Unref()

Unref decrements the reference count on object. If reference count hits zero, destroy object. This function does not take the lock on object as it relies on atomic refcounting.

type Pad

type Pad struct{ *Object }

Pad is a go representation of a GstPad

func FromGstPadUnsafeFull

func FromGstPadUnsafeFull(pad unsafe.Pointer) *Pad

FromGstPadUnsafeFull wraps the given pad in a reference and finalizer.

func FromGstPadUnsafeNone

func FromGstPadUnsafeNone(pad unsafe.Pointer) *Pad

FromGstPadUnsafeNone wraps the given pad in a finalizer.

func NewPad

func NewPad(name string, direction PadDirection) *Pad

NewPad returns a new pad with the given direction. If name is empty, one will be generated for you.

func NewPadFromTemplate

func NewPadFromTemplate(tmpl *PadTemplate, name string) *Pad

NewPadFromTemplate creates a new pad with the given name from the given template. If name is empty, one will be generated for you.

func (*Pad) ActivateMode

func (p *Pad) ActivateMode(mode PadMode, active bool)

ActivateMode activates or deactivates the given pad in mode via dispatching to the pad's activatemodefunc. For use from within pad activation functions only.

If you don't know what this is, you probably don't want to call it.

func (*Pad) AddProbe

func (p *Pad) AddProbe(mask PadProbeType, f PadProbeCallback) uint64

AddProbe adds a callback to be notified of different states of pads. The provided callback is called for every state that matches mask.

Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called immediately if the pad is already idle while calling gst_pad_add_probe. In each of the groups, probes are called in the order in which they were added.

A probe ID is returned that can be used to remove the probe.

func (p *Pad) CanLink(sink *Pad) bool

CanLink checks if this pad is compatible with the given sink pad.

func (*Pad) Chain

func (p *Pad) Chain(buffer *Buffer) FlowReturn

Chain a buffer to pad.

The function returns FlowFlushing if the pad was flushing.

If the buffer type is not acceptable for pad (as negotiated with a preceding EventCaps event), this function returns FlowNotNegotiated.

The function proceeds calling the chain function installed on pad (see SetChainFunction) and the return value of that function is returned to the caller. FlowNotSupported is returned if pad has no chain function.

In all cases, success or failure, the caller loses its reference to buffer after calling this function.

func (*Pad) ChainList

func (p *Pad) ChainList(bufferList *BufferList) FlowReturn

ChainList chains a bufferlist to pad.

The function returns FlowFlushing if the pad was flushing.

If pad was not negotiated properly with a CAPS event, this function returns FlowNotNegotiated.

The function proceeds calling the chainlist function installed on pad (see SetChainListFunction) and the return value of that function is returned to the caller. FlowNotSupported is returned if pad has no chainlist function.

In all cases, success or failure, the caller loses its reference to list after calling this function.

func (*Pad) CheckReconfigure

func (p *Pad) CheckReconfigure() bool

CheckReconfigure checks and clear the PadFlagNeedReconfigure flag on pad and return TRUE if the flag was set.

func (*Pad) CreateStreamID

func (p *Pad) CreateStreamID(parent *Element, streamID string) string

CreateStreamID creates a stream-id for the source GstPad pad by combining the upstream information with the optional stream_id of the stream of pad. Pad must have a parent GstElement and which must have zero or one sinkpad. stream_id can only be NULL if the parent element of pad has only a single source pad.

This function generates an unique stream-id by getting the upstream stream-start event stream ID and appending stream_id to it. If the element has no sinkpad it will generate an upstream stream-id by doing an URI query on the element and in the worst case just uses a random number. Source elements that don't implement the URI handler interface should ideally generate a unique, deterministic stream-id manually instead.

Since stream IDs are sorted alphabetically, any numbers in the stream ID should be printed with a fixed number of characters, preceded by 0's, such as by using the format %03u instead of %u.

func (*Pad) CurrentCaps

func (p *Pad) CurrentCaps() *Caps

CurrentCaps returns the caps for this Pad or nil.

func (*Pad) Direction

func (p *Pad) Direction() PadDirection

Direction returns the direction of this pad.

func (*Pad) EventDefault

func (p *Pad) EventDefault(parent *Object, event *Event) bool

EventDefault invokes the default event handler for the given pad.

The EOS event will pause the task associated with pad before it is forwarded to all internally linked pads,

The event is sent to all pads internally linked to pad. This function takes ownership of event.

func (*Pad) Forward

func (p *Pad) Forward(f PadForwardFunc) bool

Forward calls the given function for all internally linked pads of pad. This function deals with dynamically changing internal pads and will make sure that the forward function is only called once for each pad.

When forward returns TRUE, no further pads will be processed.

func (*Pad) GetAllowedCaps

func (p *Pad) GetAllowedCaps() *Caps

GetAllowedCaps getss the capabilities of the allowed media types that can flow through pad and its peer.

The allowed capabilities is calculated as the intersection of the results of calling QueryCaps on pad and its peer. The caller owns a reference on the resulting caps.

func (*Pad) GetCurrentCaps

func (p *Pad) GetCurrentCaps() *Caps

GetCurrentCaps gets the capabilities currently configured on pad with the last EventCaps event.

func (*Pad) GetDirection

func (p *Pad) GetDirection() PadDirection

GetDirection gets the direction of the pad. The direction of the pad is decided at construction time so this function does not take the LOCK.

func (*Pad) GetElementPrivate

func (p *Pad) GetElementPrivate() interface{}

GetElementPrivate gets the private data of a pad. No locking is performed in this function.

func (p *Pad) GetInternalLinks() ([]*Pad, error)

GetInternalLinks gets the pads to which the given pad is linked to inside of the parent element.

Unref each pad after use.

func (*Pad) GetInternalLinksDefault

func (p *Pad) GetInternalLinksDefault(parent *Object) ([]*Pad, error)

GetInternalLinksDefault gets the list of pads to which the given pad is linked to inside of the parent element. This is the default handler, and thus returns all of the pads inside the parent element with opposite direction.

func (*Pad) GetLastFlowReturn

func (p *Pad) GetLastFlowReturn() FlowReturn

GetLastFlowReturn gets the FlowReturn return from the last data passed by this pad.

func (*Pad) GetOffset

func (p *Pad) GetOffset() int64

GetOffset gets the offset applied to the running time of pad. pad has to be a source pad.

func (*Pad) GetPadTemplate

func (p *Pad) GetPadTemplate() *PadTemplate

GetPadTemplate gets the template for this pad.

func (*Pad) GetPadTemplateCaps

func (p *Pad) GetPadTemplateCaps() *Caps

GetPadTemplateCaps gets the capabilities for pad's template.

func (*Pad) GetParentElement

func (p *Pad) GetParentElement() *Element

GetParentElement gets the parent of pad, cast to a Element. If a pad has no parent or its parent is not an element, return nil.

func (*Pad) GetPeer

func (p *Pad) GetPeer() *Pad

GetPeer gets the peer of pad. This function refs the peer pad so you need to unref it after use.

func (*Pad) GetRange

func (p *Pad) GetRange(offset uint64, size uint, buffer *Buffer) (FlowReturn, *Buffer)

GetRange calls the getrange function of pad, see PadGetRangeFunc for a description of a getrange function. If pad has no getrange function installed (see SetGetRangeFunction) this function returns FlowNotSupported.

If buffer points to a variable holding nil, a valid new GstBuffer will be placed in buffer when this function returns FlowOK. The new buffer must be freed with Unref after usage.

When buffer points to a variable that points to a valid Buffer, the buffer will be filled with the result data when this function returns FlowOK. If the provided buffer is larger than size, only size bytes will be filled in the result buffer and its size will be updated accordingly.

Note that less than size bytes can be returned in buffer when, for example, an EOS condition is near or when buffer is not large enough to hold size bytes. The caller should check the result buffer size to get the result size.

When this function returns any other result value than FlowOK, buffer will be unchanged.

This is a lowlevel function. Usually PullRange is used.

func (*Pad) GetStickyEvent

func (p *Pad) GetStickyEvent(eventType EventType, idx uint) *Event

GetStickyEvent returns a new reference of the sticky event of type event_type from the event.

func (*Pad) GetStream

func (p *Pad) GetStream() *Stream

GetStream returns the current Stream for the pad, or nil if none has been set yet, i.e. the pad has not received a stream-start event yet.

This is a convenience wrapper around GetStickyEvent and Event ParseStream.

func (*Pad) GetStreamID

func (p *Pad) GetStreamID() string

GetStreamID returns the current stream-id for the pad, or an empty string if none has been set yet, i.e. the pad has not received a stream-start event yet.

This is a convenience wrapper around gst_pad_get_sticky_event and gst_event_parse_stream_start.

The returned stream-id string should be treated as an opaque string, its contents should not be interpreted.

func (*Pad) GetTaskState

func (p *Pad) GetTaskState() TaskState

GetTaskState gets the pad task state. If no task is currently set, TaskStopped is returned.

func (*Pad) HasCurrentCaps

func (p *Pad) HasCurrentCaps() bool

HasCurrentCaps checks if pad has caps set on it with a GST_EVENT_CAPS event.

func (*Pad) Instance

func (p *Pad) Instance() *C.GstPad

Instance returns the underlying C GstPad.

func (*Pad) IsActive

func (p *Pad) IsActive() bool

IsActive queries if a pad is active

func (*Pad) IsBlocked

func (p *Pad) IsBlocked() bool

IsBlocked checks if the pad is blocked or not. This function returns the last requested state of the pad. It is not certain that the pad is actually blocking at this point (see IsBlocking).

func (*Pad) IsBlocking

func (p *Pad) IsBlocking() bool

IsBlocking checks if the pad is blocking or not. This is a guaranteed state of whether the pad is actually blocking on a GstBuffer or a GstEvent.

func (*Pad) IsLinked

func (p *Pad) IsLinked() bool

IsLinked checks if a pad is linked to another pad or not.

func (p *Pad) Link(sink *Pad) PadLinkReturn

Link links a sink pad to this source pad.

func (*Pad) LinkFull

func (p *Pad) LinkFull(sink *Pad, flags PadLinkCheck) PadLinkReturn

LinkFull links this source pad and the sink pad.

This variant of Link provides a more granular control on the checks being done when linking. While providing some considerable speedups the caller of this method must be aware that wrong usage of those flags can cause severe issues. Refer to the documentation of GstPadLinkCheck for more information.

func (*Pad) LinkMaybeGhosting

func (p *Pad) LinkMaybeGhosting(sink *Pad) bool

LinkMaybeGhosting links this src to sink, creating any GstGhostPad's in between as necessary.

This is a convenience function to save having to create and add intermediate GstGhostPad's as required for linking across GstBin boundaries.

If src or sink pads don't have parent elements or do not share a common ancestor, the link will fail.

func (*Pad) LinkMaybeGhostingFull

func (p *Pad) LinkMaybeGhostingFull(sink *Pad, flags PadLinkCheck) bool

LinkMaybeGhostingFull links this src to sink, creating any GstGhostPad's in between as necessary.

This is a convenience function to save having to create and add intermediate GstGhostPad's as required for linking across GstBin boundaries.

If src or sink pads don't have parent elements or do not share a common ancestor, the link will fail.

Calling LinkMaybeGhostingFull with flags == PadLinkCheckDefault is the recommended way of linking pads with safety checks applied.

func (*Pad) MarkReconfigure

func (p *Pad) MarkReconfigure()

MarkReconfigure marks this pad for needing reconfiguration. The next call to CheckReconfigure will return TRUE after this call.

func (*Pad) NeedsReconfigure

func (p *Pad) NeedsReconfigure() bool

NeedsReconfigure checks the GST_PAD_FLAG_NEED_RECONFIGURE flag on pad and return TRUE if the flag was set.

func (*Pad) PauseTask

func (p *Pad) PauseTask() bool

PauseTask pauses the task of pad. This function will also wait until the function executed by the task is finished if this function is not called from the task function.

func (*Pad) PeerQuery

func (p *Pad) PeerQuery(query *Query) bool

PeerQuery performs PadQuery on the peer of pad.

The caller is responsible for both the allocation and deallocation of the query structure.

func (*Pad) PeerQueryAcceptCaps

func (p *Pad) PeerQueryAcceptCaps(caps *Caps) bool

PeerQueryAcceptCaps checks if the peer of pad accepts caps. If pad has no peer, this function returns TRUE.

func (*Pad) PeerQueryCaps

func (p *Pad) PeerQueryCaps(filter *Caps) *Caps

PeerQueryCaps gets the capabilities of the peer connected to this pad. Similar to QueryCaps.

When called on srcpads filter contains the caps that upstream could produce in the order preferred by upstream. When called on sinkpads filter contains the caps accepted by downstream in the preferred order. filter might be nil but if it is not nil the returned caps will be a subset of filter.

func (*Pad) PeerQueryConvert

func (p *Pad) PeerQueryConvert(srcFormat, destFormat Format, srcVal int64) (bool, int64)

PeerQueryConvert queries the peer pad of a given sink pad to convert src_val in src_format to dest_format.

func (*Pad) PeerQueryDuration

func (p *Pad) PeerQueryDuration(format Format) (bool, int64)

PeerQueryDuration queries the peer pad of a given sink pad for the total stream duration.

func (*Pad) PeerQueryPosition

func (p *Pad) PeerQueryPosition(format Format) (bool, int64)

PeerQueryPosition queries the peer of a given sink pad for the stream position.

func (*Pad) ProxyQueryAcceptCaps

func (p *Pad) ProxyQueryAcceptCaps(query *Query) bool

ProxyQueryAcceptCaps checks if all internally linked pads of pad accepts the caps in query and returns the intersection of the results.

This function is useful as a default accept caps query function for an element that can handle any stream format, but requires caps that are acceptable for all opposite pads.

func (*Pad) ProxyQueryCaps

func (p *Pad) ProxyQueryCaps(query *Query) bool

ProxyQueryCaps calls QueryCaps for all internally linked pads of pad and returns the intersection of the results.

This function is useful as a default caps query function for an element that can handle any stream format, but requires all its pads to have the same caps. Two such elements are tee and adder.

func (*Pad) PullRange

func (p *Pad) PullRange(offset uint64, size uint, buffer *Buffer) (FlowReturn, *Buffer)

PullRange pulls a buffer from the peer pad or fills up a provided buffer.

This function will first trigger the pad block signal if it was installed.

When pad is not linked GST_FLOW_NOT_LINKED is returned else this function returns the result of GetRange on the peer pad. See GetRange for a list of return values and for the semantics of the arguments of this function.

If buffer points to a variable holding nil, a valid new GstBuffer will be placed in buffer when this function returns GST_FLOW_OK. The new buffer must be freed with Unref after usage. When this function returns any other result value, buffer will still point to NULL.

When buffer points to a variable that points to a valid GstBuffer, the buffer will be filled with the result data when this function returns GST_FLOW_OK. When this function returns any other result value, buffer will be unchanged. If the provided buffer is larger than size, only size bytes will be filled in the result buffer and its size will be updated accordingly.

Note that less than size bytes can be returned in buffer when, for example, an EOS condition is near or when buffer is not large enough to hold size bytes. The caller should check the result buffer size to get the result size.

func (*Pad) Push

func (p *Pad) Push(buf *Buffer) FlowReturn

Push pushes a buffer to the peer of pad.

This function will call installed block probes before triggering any installed data probes.

The function proceeds calling Chain on the peer pad and returns the value from that function. If pad has no peer, GST_FLOW_NOT_LINKED will be returned.

In all cases, success or failure, the caller loses its reference to buffer after calling this function.

func (*Pad) PushEvent

func (p *Pad) PushEvent(ev *Event) bool

PushEvent sends the event to the peer of the given pad. This function is mainly used by elements to send events to their peer elements.

This function takes ownership of the provided event so you should Ref it if you want to reuse the event after this call.

func (*Pad) PushList

func (p *Pad) PushList(bufList *BufferList) FlowReturn

PushList pushes a buffer list to the peer of pad.

This function will call installed block probes before triggering any installed data probes.

The function proceeds calling the chain function on the peer pad and returns the value from that function. If pad has no peer, GST_FLOW_NOT_LINKED will be returned. If the peer pad does not have any installed chainlist function every group buffer of the list will be merged into a normal GstBuffer and chained via Chain.

In all cases, success or failure, the caller loses its reference to list after calling this function.

func (*Pad) Query

func (p *Pad) Query(query *Query) bool

Query dispatches a query to a pad. The query should have been allocated by the caller via one of the type-specific allocation functions. The element that the pad belongs to is responsible for filling the query with an appropriate response, which should then be parsed with a type-specific query parsing function.

Again, the caller is responsible for both the allocation and deallocation of the query structure.

Please also note that some queries might need a running pipeline to work.

func (*Pad) QueryAcceptCaps

func (p *Pad) QueryAcceptCaps(caps *Caps) bool

QueryAcceptCaps checks if the given pad accepts the caps.

func (*Pad) QueryCaps

func (p *Pad) QueryCaps(filter *Caps) *Caps

QueryCaps gets the capabilities this pad can produce or consume. Note that this method doesn't necessarily return the caps set by sending a NewCapsEvent - use GetCurrentCaps for that instead. QueryCaps returns all possible caps a pad can operate with, using the pad's CAPS query function, If the query fails, this function will return filter, if not NULL, otherwise ANY.

When called on sinkpads filter contains the caps that upstream could produce in the order preferred by upstream. When called on srcpads filter contains the caps accepted by downstream in the preferred order. filter might be NULL but if it is not NULL the returned caps will be a subset of filter.

Note that this function does not return writable GstCaps, use gst_caps_make_writable before modifying the caps.

func (*Pad) QueryConvert

func (p *Pad) QueryConvert(srcFormat, destFormat Format, srcVal int64) (bool, int64)

QueryConvert queries a pad to convert src_val in src_format to dest_format.

func (*Pad) QueryDefault

func (p *Pad) QueryDefault(parent *Object, query *Query) bool

QueryDefault invokes the default query handler for the given pad. The query is sent to all pads internally linked to pad. Note that if there are many possible sink pads that are internally linked to pad, only one will be sent the query. Multi-sinkpad elements should implement custom query handlers.

func (*Pad) QueryDuration

func (p *Pad) QueryDuration(format Format) (bool, int64)

QueryDuration queries a pad for the total stream duration.

func (*Pad) QueryPosition

func (p *Pad) QueryPosition(format Format) (bool, int64)

QueryPosition queries a pad for the stream position.

func (*Pad) RemoveProbe

func (p *Pad) RemoveProbe(id uint64)

RemoveProbe removes the probe with id from pad.

func (*Pad) SendEvent

func (p *Pad) SendEvent(ev *Event) bool

SendEvent sends the event to the pad. This function can be used by applications to send events in the pipeline.

If pad is a source pad, event should be an upstream event. If pad is a sink pad, event should be a downstream event. For example, you would not send a GST_EVENT_EOS on a src pad; EOS events only propagate downstream. Furthermore, some downstream events have to be serialized with data flow, like EOS, while some can travel out-of-band, like GST_EVENT_FLUSH_START. If the event needs to be serialized with data flow, this function will take the pad's stream lock while calling its event function.

To find out whether an event type is upstream, downstream, or downstream and serialized, see GstEventTypeFlags, gst_event_type_get_flags, GST_EVENT_IS_UPSTREAM, GST_EVENT_IS_DOWNSTREAM, and GST_EVENT_IS_SERIALIZED. Note that in practice that an application or plugin doesn't need to bother itself with this information; the core handles all necessary locks and checks.

This function takes ownership of the provided event so you should gst_event_ref it if you want to reuse the event after this call.

func (*Pad) SetActivateFunction

func (p *Pad) SetActivateFunction(f PadActivateFunc)

SetActivateFunction sets the given active function on the pad. The activate function will dispatch to ActivateMode to perform the actual activation. Only makes sense to set on sink pads.

func (*Pad) SetActivateModeFunction

func (p *Pad) SetActivateModeFunction(f PadActivateModeFunc)

SetActivateModeFunction sets the given activate_mode function for the pad. An activate_mode function prepares the element for data passing.

func (*Pad) SetActive

func (p *Pad) SetActive(active bool) bool

SetActive activates or deactivates the given pad. Normally called from within core state change functions.

If active, makes sure the pad is active. If it is already active, either in push or pull mode, just return. Otherwise dispatches to the pad's activate function to perform the actual activation.

If not active, calls ActivateMode with the pad's current mode and a FALSE argument.

func (*Pad) SetChainFunction

func (p *Pad) SetChainFunction(f PadChainFunc)

SetChainFunction sets the given chain function for the pad. The chain function is called to process an input buffer.

func (*Pad) SetChainListFunction

func (p *Pad) SetChainListFunction(f PadChainListFunc)

SetChainListFunction sets the given chain function for the pad. The chain function is called to process an input buffer list.

func (*Pad) SetElementPrivate

func (p *Pad) SetElementPrivate(data interface{})

SetElementPrivate sets the given private data pointer on the pad. This function can only be used by the element that owns the pad. No locking is performed in this function.

func (*Pad) SetEventFullFunction

func (p *Pad) SetEventFullFunction(f PadEventFullFunc)

SetEventFullFunction sets the given event handler for the pad.

func (*Pad) SetEventFunction

func (p *Pad) SetEventFunction(f PadEventFunc)

SetEventFunction sets the given event handler for the pad.

func (*Pad) SetGetRangeFunction

func (p *Pad) SetGetRangeFunction(f PadGetRangeFunc)

SetGetRangeFunction sets the given getrange function for the pad. The getrange function is called to produce a new Buffer to start the processing pipeline. see PadGetRangeFunc for a description of the getrange function.

func (*Pad) SetIterIntLinkFunction

func (p *Pad) SetIterIntLinkFunction(f PadIterIntLinkFunc)

SetIterIntLinkFunction sets the given internal link iterator function for the pad.

func (*Pad) SetLinkFunction

func (p *Pad) SetLinkFunction(f PadLinkFunc)

SetLinkFunction sets the given link function for the pad. It will be called when the pad is linked with another pad.

The return value PadLinkOK should be used when the connection can be made.

The return value PadLinkRefused should be used when the connection cannot be made for some reason.

If link is installed on a source pad, it should call the Link of the peer sink pad, if present.

func (*Pad) SetOffset

func (p *Pad) SetOffset(offset int64)

SetOffset sets the offset that will be applied to the running time of pad.

func (*Pad) SetQueryFunction

func (p *Pad) SetQueryFunction(f PadQueryFunc)

SetQueryFunction sets the query handler for the pad.

func (*Pad) SetUnlinkFunction

func (p *Pad) SetUnlinkFunction(f PadUnlinkFunc)

SetUnlinkFunction sets the given unlink function for the pad. It will be called when the pad is unlinked.

Note that the pad's lock is already held when the unlink function is called, so most pad functions cannot be called from within the callback.

func (*Pad) StickyEventsForEach

func (p *Pad) StickyEventsForEach(f StickyEventsForEachFunc)

StickyEventsForEach iterates all sticky events on pad and calls foreach_func for every event. If foreach_func returns FALSE the iteration is immediately stopped.

func (*Pad) StoreStickyEvent

func (p *Pad) StoreStickyEvent(ev *Event) FlowReturn

StoreStickyEvent stores the sticky event on pad

func (*Pad) Template

func (p *Pad) Template() *PadTemplate

Template returns the template for this pad or nil.

func (p *Pad) Unlink(pad *Pad) bool

Unlink unlinks this source pad from the sink pad. Will emit the unlinked signal on both pads.

func (*Pad) UseFixedCaps

func (p *Pad) UseFixedCaps()

UseFixedCaps is a helper function you can use that sets the FIXED_CAPS flag This way the default CAPS query will always return the negotiated caps or in case the pad is not negotiated, the padtemplate caps.

The negotiated caps are the caps of the last CAPS event that passed on the pad. Use this function on a pad that, once it negotiated to a CAPS, cannot be renegotiated to something else.

type PadActivateFunc

type PadActivateFunc func(self *Pad, parent *Object) bool

PadActivateFunc is called when the pad is activated during the element READY to PAUSED state change. By default this function will call the activate function that puts the pad in push mode but elements can override this function to activate the pad in pull mode if they wish.

type PadActivateModeFunc

type PadActivateModeFunc func(self *Pad, parent *Object, mode PadMode, active bool) bool

PadActivateModeFunc is the prototype of the push and pull activate functions.

type PadChainFunc

type PadChainFunc func(self *Pad, parent *Object, buffer *Buffer) FlowReturn

PadChainFunc is a function that will be called on sinkpads when chaining buffers. The function typically processes the data contained in the buffer and either consumes the data or passes it on to the internally linked pad(s).

The GStreamer API will produce a refcount to buffer, and the bindings will automatically call Unref after the function returns. If you'd like to hold on to the buffer longer, add an additional ref yourself or create a copy.

When a chain function detects an error in the data stream, it must post an error on the bus and return an appropriate FlowReturn value.

type PadChainListFunc

type PadChainListFunc func(self *Pad, parent *Object, list *BufferList) FlowReturn

PadChainListFunc is a function that will be called on sinkpads when chaining buffer lists. The function typically processes the data contained in the buffer list and either consumes the data or passes it on to the internally linked pad(s).

The GStreamer API will produce a refcount to list, and the bindings will automatically call Unref after the function returns. If you'd like to hold on to the list longer, add an additional ref yourself or create a copy.

When a chainlist function detects an error in the data stream, it must post an error on the bus and return an appropriate FlowReturn value.

type PadDirection

type PadDirection int

PadDirection is a cast of GstPadDirection to a go type.

const (
	PadDirectionUnknown PadDirection = C.GST_PAD_UNKNOWN // (0) - the direction is unknown
	PadDirectionSource  PadDirection = C.GST_PAD_SRC     // (1) - the pad is a source pad
	PadDirectionSink    PadDirection = C.GST_PAD_SINK    // (2) - the pad is a sink pad
)

Type casting of pad directions

func (PadDirection) String

func (p PadDirection) String() string

String implements a Stringer on PadDirection.

type PadEventFullFunc

type PadEventFullFunc func(self *Pad, parent *Object, event *Event) FlowReturn

PadEventFullFunc is the function signature to handle an event for the pad. This variant is for specific elements that will take into account the last downstream flow return (from a pad push), in which case they can return it.

type PadEventFunc

type PadEventFunc func(self *Pad, parent *Object, event *Event) bool

PadEventFunc is the function signature to handle an event for the pad

type PadFlags

type PadFlags int

PadFlags is a go cast of GstPadFlags

const (
	PadFlagBlocked         PadFlags = C.GST_PAD_FLAG_BLOCKED          // (16) – is dataflow on a pad blocked
	PadFlagFlushing        PadFlags = C.GST_PAD_FLAG_FLUSHING         // (32) – is pad flushing
	PadFlagEOS             PadFlags = C.GST_PAD_FLAG_EOS              // (64) – is pad in EOS state
	PadFlagBlocking        PadFlags = C.GST_PAD_FLAG_BLOCKING         // (128) – is pad currently blocking on a buffer or event
	PadFlagParent          PadFlags = C.GST_PAD_FLAG_NEED_PARENT      // (256) – ensure that there is a parent object before calling into the pad callbacks.
	PadFlagReconfigure     PadFlags = C.GST_PAD_FLAG_NEED_RECONFIGURE // (512) – the pad should be reconfigured/renegotiated. The flag has to be unset manually after reconfiguration happened.
	PadFlagPendingEvents   PadFlags = C.GST_PAD_FLAG_PENDING_EVENTS   // (1024) – the pad has pending events
	PadFlagFixedCaps       PadFlags = C.GST_PAD_FLAG_FIXED_CAPS       // (2048) – the pad is using fixed caps. This means that once the caps are set on the pad, the default caps query function will only return those caps.
	PadFlagProxyCaps       PadFlags = C.GST_PAD_FLAG_PROXY_CAPS       // (4096) – the default event and query handler will forward all events and queries to the internally linked pads instead of discarding them.
	PadFlagProxyAllocation PadFlags = C.GST_PAD_FLAG_PROXY_ALLOCATION // (8192) – the default query handler will forward allocation queries to the internally linked pads instead of discarding them.
	PadFlagProxyScheduling PadFlags = C.GST_PAD_FLAG_PROXY_SCHEDULING // (16384) – the default query handler will forward scheduling queries to the internally linked pads instead of discarding them.
	PadFlagAcceptIntersect PadFlags = C.GST_PAD_FLAG_ACCEPT_INTERSECT // (32768) – the default accept-caps handler will check it the caps intersect the query-caps result instead of checking for a subset. This is interesting for parsers that can accept incompletely specified caps.
	PadFlagAcceptTemplate  PadFlags = C.GST_PAD_FLAG_ACCEPT_TEMPLATE  // (65536) – the default accept-caps handler will use the template pad caps instead of query caps to compare with the accept caps. Use this in combination with GST_PAD_FLAG_ACCEPT_INTERSECT. (Since: 1.6)
	PadFlagLast            PadFlags = C.GST_PAD_FLAG_LAST             // (1048576) – offset to define more flags
)

Type casts of PadFlags

type PadForwardFunc

type PadForwardFunc func(pad *Pad) bool

PadForwardFunc is called for all internally linked pads, see Pad Forward(). If the function returns true, the procedure is stopped.

type PadFuncMap

type PadFuncMap map[unsafe.Pointer]interface{}

PadFuncMap is an type of map for registering callbacks to a pad instance. It compensates for the lack of userdata in pad callbacks by providing a FuncForPad method that will return the function matching the Pad at the given address.

func (PadFuncMap) FuncForPad

func (p PadFuncMap) FuncForPad(pad unsafe.Pointer) interface{}

FuncForPad will return the function in this map for the given pad.

func (PadFuncMap) RemoveFuncForPad

func (p PadFuncMap) RemoveFuncForPad(pad unsafe.Pointer)

RemoveFuncForPad will remove the function for the given pad from this map.

type PadGetRangeFunc

type PadGetRangeFunc func(self *Pad, parent *Object, offset uint64, length uint) (FlowReturn, *Buffer)

PadGetRangeFunc will be called on source pads when a peer element request a buffer at the specified offset and length. If this function returns FlowOK it must also return a valid buffer.

This function is installed on a source pad with SetGetRangeFunction and can only be called on source pads after they are successfully activated with ActivateMode with the PadModePull.

offset and length are always given in byte units. offset must normally be a value between 0 and the length in bytes of the data available on pad. The length (duration in bytes) can be retrieved with a GST_QUERY_DURATION or with a GST_QUERY_SEEKING.

Any offset larger or equal than the length will make the function return FlowEOS, which corresponds to EOS. In this case buffer does not contain a valid buffer.

The buffer size of buffer will only be smaller than length when offset is near the end of the stream. In all other cases, the size of buffer must be exactly the requested size.

It is allowed to call this function with a 0 length and valid offset, in which case buffer will contain a 0-sized buffer and the function returns FlowOK.

When this function is called with a -1 offset, the sequentially next buffer of length length in the stream is returned.

When this function is called with a -1 length, a buffer with a default optimal length is returned in buffer. The length might depend on the value of offset.

type PadIterIntLinkFunc

type PadIterIntLinkFunc func(self *Pad, parent *Object) []*Pad

PadIterIntLinkFunc is the signature of the internal pad link iterator function. It should return a slice of pads that are linked to the given pad on the inside of the parent element. Currently the function only supports returning a single pad until GstIterator is implemented fully in the bindings.

type PadLinkCheck

type PadLinkCheck int

PadLinkCheck is a go cast of GstPadLinkCheck

const (
	PadLinkCheckNothing       PadLinkCheck = C.GST_PAD_LINK_CHECK_NOTHING        // (0) – Don't check hierarchy or caps compatibility.
	PadLinkCheckHierarchy     PadLinkCheck = C.GST_PAD_LINK_CHECK_HIERARCHY      // (1) – Check the pads have same parents/grandparents. Could be omitted if it is already known that the two elements that own the pads are in the same bin.
	PadLinkCheckTemplateCaps  PadLinkCheck = C.GST_PAD_LINK_CHECK_TEMPLATE_CAPS  // (2) – Check if the pads are compatible by using their template caps. This is much faster than GST_PAD_LINK_CHECK_CAPS, but would be unsafe e.g. if one pad has GST_CAPS_ANY.
	PadLinkCheckCaps          PadLinkCheck = C.GST_PAD_LINK_CHECK_CAPS           // (4) – Check if the pads are compatible by comparing the caps returned by gst_pad_query_caps.
	PadLinkCheckNoReconfigure PadLinkCheck = C.GST_PAD_LINK_CHECK_NO_RECONFIGURE // (8) – Disables pushing a reconfigure event when pads are linked.
	PadLinkCheckDefault       PadLinkCheck = C.GST_PAD_LINK_CHECK_DEFAULT        // (5) – The default checks done when linking pads (i.e. the ones used by gst_pad_link).
)

Type casts of PadLinkChecks

type PadLinkFunc

type PadLinkFunc func(self *Pad, parent *Object, peer *Pad) PadLinkReturn

PadLinkFunc is the function signature to handle a new link on a pad.

type PadLinkReturn

type PadLinkReturn int

PadLinkReturn os a representation of GstPadLinkReturn.

Type casts for PadLinkReturns.

func (PadLinkReturn) String

func (p PadLinkReturn) String() string

String implemeents a stringer on PadLinkReturn

type PadMode

type PadMode int

PadMode is a cast of GstPadMode.

const (
	PadModeNone PadMode = C.GST_PAD_MODE_NONE // (0) – Pad will not handle dataflow
	PadModePush PadMode = C.GST_PAD_MODE_PUSH // (1) – Pad handles dataflow in downstream push mode
	PadModePull PadMode = C.GST_PAD_MODE_PULL // (2) – Pad handles dataflow in upstream pull mode
)

Type casts of PadModes

func (PadMode) String

func (p PadMode) String() string

String implements a stringer on PadMode

type PadPresence

type PadPresence int

PadPresence is a cast of GstPadPresence to a go type.

const (
	PadPresenceAlways    PadPresence = C.GST_PAD_ALWAYS    // (0) - the pad is always available
	PadPresenceSometimes PadPresence = C.GST_PAD_SOMETIMES // (1) - the pad will become available depending on the media stream
	PadPresenceRequest   PadPresence = C.GST_PAD_REQUEST   // (2) - the pad is only available on request with gst_element_request_pad.
)

Type casting of pad presences

func (PadPresence) String

func (p PadPresence) String() string

String implements a stringer on PadPresence.

type PadProbeCallback

type PadProbeCallback func(*Pad, *PadProbeInfo) PadProbeReturn

PadProbeCallback is a callback used by Pad AddProbe. It gets called to notify about the current blocking type.

type PadProbeInfo

type PadProbeInfo struct {
	// contains filtered or unexported fields
}

PadProbeInfo represents the info passed to a PadProbeCallback.

func (*PadProbeInfo) GetBuffer

func (p *PadProbeInfo) GetBuffer() *Buffer

GetBuffer returns the buffer, if any, inside this probe info.

func (*PadProbeInfo) GetBufferList

func (p *PadProbeInfo) GetBufferList() *BufferList

GetBufferList returns the buffer list, if any, inside this probe info.

func (*PadProbeInfo) GetEvent

func (p *PadProbeInfo) GetEvent() *Event

GetEvent returns the event, if any, inside this probe info.

func (*PadProbeInfo) GetQuery

func (p *PadProbeInfo) GetQuery() *Query

GetQuery returns the query, if any, inside this probe info.

func (*PadProbeInfo) ID

func (p *PadProbeInfo) ID() uint32

ID returns the id of the probe.

func (*PadProbeInfo) Offset

func (p *PadProbeInfo) Offset() uint64

Offset returns the offset of pull probe, this field is valid when type contains PadProbeTypePull.

func (*PadProbeInfo) Size

func (p *PadProbeInfo) Size() uint64

Size returns the size of pull probe, this field is valid when type contains PadProbeTypePull.

func (*PadProbeInfo) Type

func (p *PadProbeInfo) Type() PadProbeType

Type returns the type of the probe. The type indicates the type of data that can be expected with the probe.

type PadProbeReturn

type PadProbeReturn int

PadProbeReturn casts GstPadProbeReturn

const (
	PadProbeDrop      PadProbeReturn = C.GST_PAD_PROBE_DROP    // (0) – drop data in data probes. For push mode this means that the data item is not sent downstream. For pull mode, it means that the data item is not passed upstream. In both cases, no other probes are called for this item and GST_FLOW_OK or TRUE is returned to the caller.
	PadProbeOK        PadProbeReturn = C.GST_PAD_PROBE_OK      // (1) – normal probe return value. This leaves the probe in place, and defers decisions about dropping or passing data to other probes, if any. If there are no other probes, the default behaviour for the probe type applies ('block' for blocking probes, and 'pass' for non-blocking probes).
	PadProbeRemove    PadProbeReturn = C.GST_PAD_PROBE_REMOVE  // (2) – remove this probe.
	PadProbePass      PadProbeReturn = C.GST_PAD_PROBE_PASS    // (3) – pass the data item in the block probe and block on the next item.
	PadProbeUnhandled PadProbeReturn = C.GST_PAD_PROBE_HANDLED // (4) – Data has been handled in the probe and will not be forwarded further. For events and buffers this is the same behaviour as GST_PAD_PROBE_DROP (except that in this case you need to unref the buffer or event yourself). For queries it will also return TRUE to the caller. The probe can also modify the GstFlowReturn value by using the GST_PAD_PROBE_INFO_FLOW_RETURN() accessor. Note that the resulting query must contain valid entries. Since: 1.6
)

Type castings of ProbeReturns

type PadProbeType

type PadProbeType int

PadProbeType casts GstPadProbeType

const (
	PadProbeTypeInvalid         PadProbeType = C.GST_PAD_PROBE_TYPE_INVALID          // (0) – invalid probe type
	PadProbeTypeIdle            PadProbeType = C.GST_PAD_PROBE_TYPE_IDLE             // (1) – probe idle pads and block while the callback is called
	PadProbeTypeBlock           PadProbeType = C.GST_PAD_PROBE_TYPE_BLOCK            // (2) – probe and block pads
	PadProbeTypeBuffer          PadProbeType = C.GST_PAD_PROBE_TYPE_BUFFER           // (16) – probe buffers
	PadProbeTypeBufferList      PadProbeType = C.GST_PAD_PROBE_TYPE_BUFFER_LIST      // (32) – probe buffer lists
	PadProbeTypeEventDownstream PadProbeType = C.GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM // (64) – probe downstream events
	PadProbeTypeEventUpstream   PadProbeType = C.GST_PAD_PROBE_TYPE_EVENT_UPSTREAM   // (128) – probe upstream events
	PadProbeTypeEventFlush      PadProbeType = C.GST_PAD_PROBE_TYPE_EVENT_FLUSH      // (256) – probe flush events. This probe has to be explicitly enabled and is not included in the @GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM or @GST_PAD_PROBE_TYPE_EVENT_UPSTREAM probe types.
	PadProbeTypeQueryDownstream PadProbeType = C.GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM // (512) – probe downstream queries
	PadProbeTypeQueryUpstream   PadProbeType = C.GST_PAD_PROBE_TYPE_QUERY_UPSTREAM   // (1024) – probe upstream queries
	PadProbeTypePush            PadProbeType = C.GST_PAD_PROBE_TYPE_PUSH             // (4096) – probe push
	PadProbeTypePull            PadProbeType = C.GST_PAD_PROBE_TYPE_PULL             // (8192) – probe pull
	PadProbeTypeBlocking        PadProbeType = C.GST_PAD_PROBE_TYPE_BLOCKING         // (3) – probe and block at the next opportunity, at data flow or when idle
	PadProbeTypeDataDownstream  PadProbeType = C.GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM  // (112) – probe downstream data (buffers, buffer lists, and events)
	PadProbeTypeDataUpstream    PadProbeType = C.GST_PAD_PROBE_TYPE_DATA_UPSTREAM    // (128) – probe upstream data (events)
	PadProbeTypeDataBoth        PadProbeType = C.GST_PAD_PROBE_TYPE_DATA_BOTH        // (240) – probe upstream and downstream data (buffers, buffer lists, and events)
	PadProbeTypeBlockDownstream PadProbeType = C.GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM // (114) – probe and block downstream data (buffers, buffer lists, and events)
	PadProbeTypeBlockUpstream   PadProbeType = C.GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM   // (130) – probe and block upstream data (events)
	PadProbeTypeEventBoth       PadProbeType = C.GST_PAD_PROBE_TYPE_EVENT_BOTH       // (192) – probe upstream and downstream events
	PadProbeTypeQueryBoth       PadProbeType = C.GST_PAD_PROBE_TYPE_QUERY_BOTH       // (1536) – probe upstream and downstream queries
	PadProbeTypeAllBoth         PadProbeType = C.GST_PAD_PROBE_TYPE_ALL_BOTH         // (1776) – probe upstream events and queries and downstream buffers, buffer lists, events and queries
	PadProbeTypeScheduling      PadProbeType = C.GST_PAD_PROBE_TYPE_SCHEDULING       // (12288) – probe push and pull
)

Type castings of PadProbeTypes

type PadQueryFunc

type PadQueryFunc func(self *Pad, parent *Object, query *Query) bool

PadQueryFunc is a function for performing queries on a pad. It should return true if it could handle the query.

type PadTemplate

type PadTemplate struct{ *Object }

PadTemplate is a go representation of a GstPadTemplate

func FromGstPadTemplateUnsafeFull

func FromGstPadTemplateUnsafeFull(tmpl unsafe.Pointer) *PadTemplate

FromGstPadTemplateUnsafeFull wraps the given GstPadTemplate in a finalizer.

func FromGstPadTemplateUnsafeNone

func FromGstPadTemplateUnsafeNone(tmpl unsafe.Pointer) *PadTemplate

FromGstPadTemplateUnsafeNone wraps the given GstPadTemplate in a ref and a finalizer.

func NewPadTemplate

func NewPadTemplate(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps) *PadTemplate

NewPadTemplate creates a new pad template with a name according to the given template and with the given arguments.

func NewPadTemplateWithGType

func NewPadTemplateWithGType(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps, gType glib.Type) *PadTemplate

NewPadTemplateWithGType creates a new pad template with a name according to the given template and with the given arguments.

func (*PadTemplate) Caps

func (p *PadTemplate) Caps() *Caps

Caps returns the caps of the pad template.

func (*PadTemplate) Direction

func (p *PadTemplate) Direction() PadDirection

Direction returns the direction of the pad template.

func (*PadTemplate) Instance

func (p *PadTemplate) Instance() *C.GstPadTemplate

Instance returns the underlying C GstPadTemplate.

func (*PadTemplate) Name

func (p *PadTemplate) Name() string

Name returns the name of the pad template.

func (*PadTemplate) PadCreated

func (p *PadTemplate) PadCreated(pad *Pad)

PadCreated emits the pad-created signal for this template when created by this pad.

func (*PadTemplate) Presence

func (p *PadTemplate) Presence() PadPresence

Presence returns the presence of the pad template.

type PadUnlinkFunc

type PadUnlinkFunc func(self *Pad, parent *Object)

PadUnlinkFunc is the function signature to handle a unlinking the pad from its peer.

The pad's lock is already held when the unlink function is called, so most pad functions cannot be called from within the callback.

type ParentBufferMeta

type ParentBufferMeta struct {
	Parent *Meta
	Buffer *Buffer
}

ParentBufferMeta is a go representation of a GstParentBufferMeta

type Pipeline

type Pipeline struct {
	*Bin
	// contains filtered or unexported fields
}

Pipeline is a go implementation of a GstPipeline.

func FromGstPipelineUnsafeFull

func FromGstPipelineUnsafeFull(pipeline unsafe.Pointer) *Pipeline

FromGstPipelineUnsafeFull wraps the given pipeline pointer.

func FromGstPipelineUnsafeNone

func FromGstPipelineUnsafeNone(pipeline unsafe.Pointer) *Pipeline

FromGstPipelineUnsafeNone wraps the given pipeline pointer.

func NewPipeline

func NewPipeline(name string) (*Pipeline, error)

NewPipeline allocates and returns a new empty pipeline. If name is empty, one is generated by gstreamer.

func NewPipelineFromString

func NewPipelineFromString(launchv string) (*Pipeline, error)

NewPipelineFromString creates a new gstreamer pipeline from the given launch string.

func (*Pipeline) GetPipelineBus

func (p *Pipeline) GetPipelineBus() *Bus

GetPipelineBus returns the message bus for this pipeline.

func (*Pipeline) GetPipelineClock

func (p *Pipeline) GetPipelineClock() *Clock

GetPipelineClock returns the global clock for this pipeline.

func (*Pipeline) Instance

func (p *Pipeline) Instance() *C.GstPipeline

Instance returns the native GstPipeline instance.

func (*Pipeline) SetAutoFlushBus

func (p *Pipeline) SetAutoFlushBus(b bool)

SetAutoFlushBus can be used to disable automatically flushing the message bus when a pipeline goes to StateNull.

Usually, when a pipeline goes from READY to NULL state, it automatically flushes all pending messages on the bus, which is done for refcounting purposes, to break circular references.

This means that applications that update state using (async) bus messages (e.g. do certain things when a pipeline goes from PAUSED to READY) might not get to see messages when the pipeline is shut down, because they might be flushed before they can be dispatched in the main thread. This behaviour can be disabled using this function.

It is important that all messages on the bus are handled when the automatic flushing is disabled else memory leaks will be introduced.

func (*Pipeline) Start

func (p *Pipeline) Start() error

Start is the equivalent to calling SetState(StatePlaying) on the underlying GstElement.

type Plugin

type Plugin struct{ *Object }

Plugin is a go representation of a GstPlugin.

func FromGstPluginUnsafeFull

func FromGstPluginUnsafeFull(plugin unsafe.Pointer) *Plugin

FromGstPluginUnsafeFull wraps the given pointer in a Plugin.

func FromGstPluginUnsafeNone

func FromGstPluginUnsafeNone(plugin unsafe.Pointer) *Plugin

FromGstPluginUnsafeNone wraps the given pointer in a Plugin.

func LoadPluginByName

func LoadPluginByName(name string) *Plugin

LoadPluginByName loads the named plugin and places a ref count on it. The function returns nil if the plugin could not be loaded.

func LoadPluginFile

func LoadPluginFile(fpath string) (*Plugin, error)

LoadPluginFile loads the given plugin and refs it. If an error is returned Plugin will be nil.

func (*Plugin) Description

func (p *Plugin) Description() string

Description returns the description for this plugin.

func (*Plugin) Filename

func (p *Plugin) Filename() string

Filename returns the filename for this plugin.

func (*Plugin) Instance

func (p *Plugin) Instance() *C.GstPlugin

Instance returns the underlying GstPlugin instance.

func (*Plugin) License

func (p *Plugin) License() License

License returns the license for this plugin.

func (*Plugin) Origin

func (p *Plugin) Origin() string

Origin returns the origin URL for this plugin.

func (*Plugin) Package

func (p *Plugin) Package() string

Package returns the binary package for this plugin.

func (*Plugin) Source

func (p *Plugin) Source() string

Source returns the source module for this plugin.

func (*Plugin) Version

func (p *Plugin) Version() string

Version returns the version for this plugin.

type PluginFeature

type PluginFeature struct{ *Object }

PluginFeature wraps the C GstPluginFeature.

func (*PluginFeature) GetPlugin

func (p *PluginFeature) GetPlugin() *Plugin

GetPlugin returns the plugin that provides this feature or nil. Unref after usage.

func (*PluginFeature) GetPluginName

func (p *PluginFeature) GetPluginName() string

GetPluginName returns the name of the plugin that provides this feature.

func (*PluginFeature) Instance

func (p *PluginFeature) Instance() *C.GstPluginFeature

Instance returns the underlying GstPluginFeature instance

type PluginInitFunc

type PluginInitFunc func(*Plugin) bool

PluginInitFunc is a function called by the plugin loader at startup. This function should register all the features of the plugin. The function should return true if the plugin is initialized successfully.

type PluginMetadata

type PluginMetadata struct {
	// The major version number of the GStreamer core that the plugin was compiled for, you can just use VersionMajor here
	MajorVersion Version
	// The minor version number of the GStreamer core that the plugin was compiled for, you can just use VersionMinor here
	MinorVersion Version
	// A unique name of the plugin (ideally prefixed with an application- or library-specific namespace prefix in order to
	// avoid name conflicts in case a similar plugin with the same name ever gets added to GStreamer)
	Name string
	// A description of the plugin
	Description string
	// The function to call when initiliazing the plugin
	Init PluginInitFunc
	// The version of the plugin
	Version string
	// The license for the plugin, must match one of the license constants in this package
	License License
	// The source module the plugin belongs to
	Source string
	// The shipped package the plugin belongs to
	Package string
	// The URL to the provider of the plugin
	Origin string
	// The date of release in ISO 8601 format.
	// See https://gstreamer.freedesktop.org/documentation/gstreamer/gstplugin.html?gi-language=c#GstPluginDesc for more details.
	ReleaseDate string
}

PluginMetadata represents the information to include when registering a new plugin with gstreamer.

func (*PluginMetadata) Export

func (p *PluginMetadata) Export() unsafe.Pointer

Export will export the PluginMetadata to an unsafe pointer to a GstPluginDesc.

type PollFd

type PollFd struct {
	Fd              int
	Events, REvents uint
}

PollFd represents the possible values returned from a GetPollFd. On Windows, there will not be a Fd.

type ProgressType

type ProgressType int

ProgressType is a go representation of a GstProgressType

const (
	ProgressTypeStart     ProgressType = C.GST_PROGRESS_TYPE_START    // (0) – A new task started.
	ProgressTypeContinue  ProgressType = C.GST_PROGRESS_TYPE_CONTINUE // (1) – A task completed and a new one continues.
	ProgressTypeComplete  ProgressType = C.GST_PROGRESS_TYPE_COMPLETE // (2) – A task completed.
	ProgressTypeCancelled ProgressType = C.GST_PROGRESS_TYPE_CANCELED // (3) – A task was canceled.
	ProgressTypeError     ProgressType = C.GST_PROGRESS_TYPE_ERROR    // (4) – A task caused an error. An error message is also posted on the bus.
)

Type castings of ProgressTypes

func (ProgressType) String

func (p ProgressType) String() string

String implements a stringer on ProgressTypes

type ProtectionMeta

type ProtectionMeta struct {
	Meta *Meta
	Info *Structure
}

ProtectionMeta is a go wrapper around C GstProtectionMeta.

type ProxyPad

type ProxyPad struct{ *Pad }

ProxyPad is a go representation of a GstProxyPad.

func (*ProxyPad) ChainDefault

func (p *ProxyPad) ChainDefault(parent *Object, buffer *Buffer) FlowReturn

ChainDefault invokes the default chain function of the proxy pad.

func (*ProxyPad) ChainListDefault

func (p *ProxyPad) ChainListDefault(parent *Object, bufferList *BufferList) FlowReturn

ChainListDefault invokes the default chain list function of the proxy pad.

func (*ProxyPad) GetInternal

func (p *ProxyPad) GetInternal() *ProxyPad

GetInternal gets the internal pad of pad. Unref target pad after usage.

The internal pad of a GhostPad is the internally used pad of opposite direction, which is used to link to the target.

func (*ProxyPad) GetInternalLinksDefault

func (p *ProxyPad) GetInternalLinksDefault(parent *Object) ([]*Pad, error)

GetInternalLinksDefault invokes the default iterate internal links function of the proxy pad.

func (*ProxyPad) GetRangeDefault

func (p *ProxyPad) GetRangeDefault(parent *Object, offset uint64, size uint) (FlowReturn, *Buffer)

GetRangeDefault invokes the default getrange function of the proxy pad.

func (*ProxyPad) Instance

func (p *ProxyPad) Instance() *C.GstProxyPad

Instance returns the underlying GstProxyPad instance.

type QOSType

type QOSType int

QOSType casts GstQOSType

const (
	QOSTypeOverflow  QOSType = C.GST_QOS_TYPE_OVERFLOW  // (0) – The QoS event type that is produced when upstream elements are producing data too quickly and the element can't keep up processing the data. Upstream should reduce their production rate. This type is also used when buffers arrive early or in time.
	QOSTypeUnderflow QOSType = C.GST_QOS_TYPE_UNDERFLOW // (1) – The QoS event type that is produced when upstream elements are producing data too slowly and need to speed up their production rate.
	QOSTypeThrottle  QOSType = C.GST_QOS_TYPE_THROTTLE  // (2) – The QoS event type that is produced when the application enabled throttling to limit the data rate.
)

Type castings

type QoSValues

type QoSValues struct {
	// If the message was generated by a live element
	Live bool
	// The running time of the buffer that generated the message
	RunningTime time.Duration
	// The stream time of the buffer that generated the message
	StreamTime time.Duration
	//  The timestamps of the buffer that generated the message
	Timestamp time.Duration
	//  The duration of the buffer that generated the message
	Duration time.Duration
}

QoSValues represents the values inside a QoS message.

type Query

type Query struct {
	// contains filtered or unexported fields
}

Query is a go wrapper around a GstQuery.

func FromGstQueryUnsafeFull

func FromGstQueryUnsafeFull(query unsafe.Pointer) *Query

FromGstQueryUnsafeFull wraps the pointer to the given C GstQuery with the go type. This is meant for internal usage and is exported for visibility to other packages.

func FromGstQueryUnsafeNone

func FromGstQueryUnsafeNone(query unsafe.Pointer) *Query

FromGstQueryUnsafeNone wraps the pointer to the given C GstQuery with the go type. This is meant for internal usage and is exported for visibility to other packages.

func NewAcceptCapsQuery

func NewAcceptCapsQuery(caps *Caps) *Query

NewAcceptCapsQuery constructs a new query object for querying if caps are accepted.

func NewAllocationQuery

func NewAllocationQuery(caps *Caps, needPool bool) *Query

NewAllocationQuery constructs a new query object for querying the allocation properties.

func NewBitrateQuery

func NewBitrateQuery() *Query

NewBitrateQuery constructs a new query object for querying the bitrate.

func NewBufferingQuery

func NewBufferingQuery(format Format) *Query

NewBufferingQuery constructs a new query object for querying the buffering status of a stream.

func NewCapsQuery

func NewCapsQuery(caps *Caps) *Query

NewCapsQuery constructs a new query object for querying the caps.

The CAPS query should return the allowable caps for a pad in the context of the element's state, its link to other elements, and the devices or files it has opened. These caps must be a subset of the pad template caps. In the NULL state with no links, the CAPS query should ideally return the same caps as the pad template. In rare circumstances, an object property can affect the caps returned by the CAPS query, but this is discouraged.

For most filters, the caps returned by CAPS query is directly affected by the allowed caps on other pads. For demuxers and decoders, the caps returned by the srcpad's getcaps function is directly related to the stream data. Again, the CAPS query should return the most specific caps it reasonably can, since this helps with autoplugging.

The filter is used to restrict the result caps, only the caps matching filter should be returned from the CAPS query. Specifying a filter might greatly reduce the amount of processing an element needs to do.

func NewContextQuery

func NewContextQuery(ctxType string) *Query

NewContextQuery constructs a new query object for querying the pipeline-local context.

func NewConvertQuery

func NewConvertQuery(srcFormat, destFormat Format, value int64) *Query

NewConvertQuery constructs a new convert query object. A convert query is used to ask for a conversion between one format and another.

func NewCustomQuery

func NewCustomQuery(queryType QueryType, structure *Structure) *Query

NewCustomQuery constructs a new custom query object.

func NewDrainQuery

func NewDrainQuery() *Query

NewDrainQuery constructs a new query object for querying the drain state.

func NewDurationQuery

func NewDurationQuery(format Format) *Query

NewDurationQuery constructs a new stream duration query object to query in the given format. A duration query will give the total length of the stream.

func NewFormatsQuery

func NewFormatsQuery() *Query

NewFormatsQuery constructs a new query object for querying formats of the stream.

func NewLatencyQuery

func NewLatencyQuery() *Query

NewLatencyQuery constructs a new latency query object. A latency query is usually performed by sinks to compensate for additional latency introduced by elements in the pipeline.

func NewPositionQuery

func NewPositionQuery(format Format) *Query

NewPositionQuery constructs a new query stream position query object. A position query is used to query the current position of playback in the streams, in some format.

func NewSchedulingQuery

func NewSchedulingQuery() *Query

NewSchedulingQuery constructs a new query object for querying the scheduling properties.

func NewSeekingQuery

func NewSeekingQuery(format Format) *Query

NewSeekingQuery constructs a new query object for querying seeking properties of the stream.

func NewSegmentQuery

func NewSegmentQuery(format Format) *Query

NewSegmentQuery constructs a new segment query object. A segment query is used to discover information about the currently configured segment for playback.

func NewURIQuery

func NewURIQuery() *Query

NewURIQuery constructs a new query URI query object. An URI query is used to query the current URI that is used by the source or sink.

func ToGstQuery

func ToGstQuery(query unsafe.Pointer) *Query

ToGstQuery converts the given pointer into a Message without affecting the ref count or placing finalizers.

func (*Query) AddAllocationMeta

func (q *Query) AddAllocationMeta(api glib.Type, structure *Structure)

AddAllocationMeta adds api with params as one of the supported metadata API to query.

func (*Query) AddAllocationParam

func (q *Query) AddAllocationParam(allocator *Allocator, params *AllocationParams)

AddAllocationParam adds allocator and its params as a supported memory allocator.

func (*Query) AddAllocationPool

func (q *Query) AddAllocationPool(pool *BufferPool, size, minBuffers, maxBuffers uint)

AddAllocationPool sets the pool parameters in query.

func (*Query) AddBufferingRange

func (q *Query) AddBufferingRange(start, stop int64) (ok bool)

AddBufferingRange sets the buffering-ranges array field in query. The current last start position of the array should be inferior to start.

func (*Query) AddSchedulingMode

func (q *Query) AddSchedulingMode(mode PadMode)

AddSchedulingMode adds mode as one of the supported scheduling modes to query.

func (*Query) Copy

func (q *Query) Copy() *Query

Copy copies the given query using the copy function of the parent GstStructure.

func (*Query) FindAllocationMeta

func (q *Query) FindAllocationMeta(api glib.Type) (ok bool, index uint)

FindAllocationMeta checks if query has metadata api set. When this function returns TRUE, index will contain the index where the requested API and the parameters can be found.

func (*Query) GetNumAllocationMetas

func (q *Query) GetNumAllocationMetas() uint

GetNumAllocationMetas retrieves the number of values currently stored in the meta API array of the query's structure.

func (*Query) GetNumAllocationParams

func (q *Query) GetNumAllocationParams() uint

GetNumAllocationParams retrieves the number of values currently stored in the allocator params array of the query's structure.

If no memory allocator is specified, the downstream element can handle the default memory allocator. The first memory allocator in the query should be generic and allow mapping to system memory, all following allocators should be ordered by preference with the preferred one first.

func (*Query) GetNumAllocationPools

func (q *Query) GetNumAllocationPools() uint

GetNumAllocationPools retrieves the number of values currently stored in the pool array of the query's structure.

func (*Query) GetNumBufferingRanges

func (q *Query) GetNumBufferingRanges() uint

GetNumBufferingRanges retrieves the number of values currently stored in the buffered-ranges array of the query's structure.

func (*Query) GetNumSchedulingModes

func (q *Query) GetNumSchedulingModes() uint

GetNumSchedulingModes retrieves the number of values currently stored in the scheduling mode array of the query's structure.

func (*Query) GetStructure

func (q *Query) GetStructure() *Structure

GetStructure retrieves the structure of a query.

func (*Query) HasSchedulingMode

func (q *Query) HasSchedulingMode(mode PadMode) bool

HasSchedulingMode checks if query has scheduling mode set.

func (*Query) HasSchedulingModeWithFlags

func (q *Query) HasSchedulingModeWithFlags(mode PadMode, flags SchedulingFlags) bool

HasSchedulingModeWithFlags checks if query has scheduling mode set and flags is set in query scheduling flags.

func (*Query) Instance

func (q *Query) Instance() *C.GstQuery

Instance returns the underlying GstQuery instance.

func (*Query) ParseAcceptCaps

func (q *Query) ParseAcceptCaps() *Caps

ParseAcceptCaps gets the caps from query. The caps remains valid as long as query remains valid.

func (*Query) ParseAcceptCapsResult

func (q *Query) ParseAcceptCapsResult() bool

ParseAcceptCapsResult parses the result from the caps query.

func (*Query) ParseAllocation

func (q *Query) ParseAllocation() (caps *Caps, needPool bool)

ParseAllocation parses an allocation query.

func (*Query) ParseAllocationMetaAt

func (q *Query) ParseAllocationMetaAt(idx uint) (api glib.Type, st *Structure)

ParseAllocationMetaAt parses an available query and get the metadata API at index of the metadata API array.

func (*Query) ParseAllocationParamAt

func (q *Query) ParseAllocationParamAt(idx uint) (*Allocator, *AllocationParams)

ParseAllocationParamAt parses an available query and get the allocator and its params at index of the allocator array.

func (*Query) ParseAllocationPoolAt

func (q *Query) ParseAllocationPoolAt(idx uint) (pool *BufferPool, size, minBuffers, maxBuffers uint)

ParseAllocationPoolAt gets the pool parameters in query.

func (*Query) ParseBitrate

func (q *Query) ParseBitrate() uint

ParseBitrate gets the results of a bitrate query. See also SetBitrate.

func (*Query) ParseBufferingPercent

func (q *Query) ParseBufferingPercent() (busy bool, percent int)

ParseBufferingPercent gets the percentage of buffered data. This is a value between 0 and 100. The busy indicator is TRUE when the buffering is in progress.

func (*Query) ParseBufferingRange

func (q *Query) ParseBufferingRange() (format Format, start, stop, estimatedTotal int64)

ParseBufferingRange parses a buffering range query.

func (*Query) ParseBufferingRangeAt

func (q *Query) ParseBufferingRangeAt(idx uint) (start, stop int64)

ParseBufferingRangeAt parses an available query and get the start and stop values stored at the index of the buffered ranges array.

func (*Query) ParseBufferingStats

func (q *Query) ParseBufferingStats() (mode BufferingMode, avgIn, avgOut int, bufLeft int64)

ParseBufferingStats extracts the buffering stats values from query.

func (*Query) ParseCaps

func (q *Query) ParseCaps() *Caps

ParseCaps gets the filter from the caps query. The caps remains valid as long as query remains valid.

func (*Query) ParseCapsResult

func (q *Query) ParseCapsResult() *Caps

ParseCapsResult gets the caps result from query. The caps remains valid as long as query remains valid.

func (*Query) ParseContext

func (q *Query) ParseContext() *Context

ParseContext gets the context from the context query. The context remains valid as long as query remains valid.

func (*Query) ParseContextType

func (q *Query) ParseContextType() (ok bool, ctxType string)

ParseContextType parses a context type from an existing GST_QUERY_CONTEXT query.

func (*Query) ParseConvert

func (q *Query) ParseConvert() (srcformat, destFormat Format, srcValue, destValue int64)

ParseConvert parses a convert query answer.

func (*Query) ParseDuration

func (q *Query) ParseDuration() (format Format, duration int64)

ParseDuration parses a duration query answer.

func (*Query) ParseFormatAt

func (q *Query) ParseFormatAt(idx uint) Format

ParseFormatAt parses the format query and retrieve the nth format from it into format. If the list contains less elements than nth, format will be set to GST_FORMAT_UNDEFINED.

func (*Query) ParseLatency

func (q *Query) ParseLatency() (live bool, minLatency, maxLatency time.Duration)

ParseLatency parses a latency query answer.

func (*Query) ParseNumFormats

func (q *Query) ParseNumFormats() uint

ParseNumFormats parses the number of formats in the formats query.

func (*Query) ParsePosition

func (q *Query) ParsePosition() (format Format, cur int64)

ParsePosition parses a position query, writing the format into format, and the position into cur, if the respective parameters are non-%NULL.

func (*Query) ParseScheduling

func (q *Query) ParseScheduling() (flags SchedulingFlags, minSize, maxSize, align int)

ParseScheduling sets the scheduling properties.

func (*Query) ParseSchedulingModeAt

func (q *Query) ParseSchedulingModeAt(idx uint) PadMode

ParseSchedulingModeAt parses an available query and get the scheduling mode at index of the scheduling modes array.

func (*Query) ParseSeeking

func (q *Query) ParseSeeking() (format Format, seekable bool, start, end int64)

ParseSeeking parses a seeking query.

func (*Query) ParseSegment

func (q *Query) ParseSegment() (rate float64, format Format, start, stop int64)

ParseSegment parses a segment query answer.

func (*Query) ParseURI

func (q *Query) ParseURI() string

ParseURI parses a URI query.

func (*Query) ParseURIRedirection

func (q *Query) ParseURIRedirection() string

ParseURIRedirection parses a URI query.

func (*Query) ParseURIRedirectionPermanent

func (q *Query) ParseURIRedirectionPermanent() bool

ParseURIRedirectionPermanent parses an URI query, and set permanent to TRUE if there is a redirection and it should be considered permanent. If a redirection is permanent, applications should update their internal storage of the URI, otherwise they should make all future requests to the original URI.

func (*Query) Ref

func (q *Query) Ref() *Query

Ref increases the query ref count by one.

func (*Query) RemoveAllocationMetaAt

func (q *Query) RemoveAllocationMetaAt(idx uint)

RemoveAllocationMetaAt removes the metadata API at index of the metadata API array.

func (*Query) RemoveAllocationParamAt

func (q *Query) RemoveAllocationParamAt(idx uint)

RemoveAllocationParamAt removes the allocation param at index of the allocation param array.

func (*Query) RemoveAllocationPoolAt

func (q *Query) RemoveAllocationPoolAt(idx uint)

RemoveAllocationPoolAt removes the allocation pool at index of the allocation pool array.

func (*Query) SetAcceptCapsResult

func (q *Query) SetAcceptCapsResult(result bool)

SetAcceptCapsResult sets result as the result for the query.

func (*Query) SetAllocationParamAt

func (q *Query) SetAllocationParamAt(idx uint, allocator *Allocator, params *AllocationParams)

SetAllocationParamAt sets allocation params in query.

func (*Query) SetAllocationPoolAt

func (q *Query) SetAllocationPoolAt(idx uint, pool *BufferPool, size, minBuffers, maxBuffers uint)

SetAllocationPoolAt sets the pool parameters in query.

func (*Query) SetBitrate

func (q *Query) SetBitrate(nominal uint)

SetBitrate sets the results of a bitrate query. The nominal bitrate is the average bitrate expected over the length of the stream as advertised in file headers (or similar).

func (*Query) SetBufferingPercent

func (q *Query) SetBufferingPercent(busy bool, percent int)

SetBufferingPercent sets the percentage of buffered data. This is a value between 0 and 100. The busy indicator is TRUE when the buffering is in progress.

func (*Query) SetBufferingRange

func (q *Query) SetBufferingRange(format Format, start, stop, estimatedTotal int64)

SetBufferingRange sets the available query result fields in query.

func (*Query) SetBufferingStats

func (q *Query) SetBufferingStats(mode BufferingMode, avgIn, avgOut int, bufferingLeft int64)

SetBufferingStats configures the buffering stats values in query.

func (*Query) SetCapsResult

func (q *Query) SetCapsResult(caps *Caps)

SetCapsResult sets the caps result in query.

func (*Query) SetContext

func (q *Query) SetContext(ctx *Context)

SetContext answers a context query by setting the requested context.

func (*Query) SetConvert

func (q *Query) SetConvert(srcFormat, destFormat Format, srcValue, destValue int64)

SetConvert answers a convert query by setting the requested values.

func (*Query) SetDuration

func (q *Query) SetDuration(format Format, duration int64)

SetDuration answers a duration query by setting the requested value in the given format.

func (*Query) SetFormats

func (q *Query) SetFormats(formats ...Format)

SetFormats sets the formats query result fields in query. The number of formats passed must be equal to n_formats.

func (*Query) SetLatency

func (q *Query) SetLatency(live bool, minLatency, maxLatency time.Duration)

SetLatency answers a latency query by setting the requested values in the given format.

func (*Query) SetPosition

func (q *Query) SetPosition(format Format, cur int64)

SetPosition answers a position query by setting the requested value in the given format.

func (*Query) SetScheduling

func (q *Query) SetScheduling(flags SchedulingFlags, minSize, maxSize, align int)

SetScheduling sets the scheduling properties.

func (*Query) SetSeeking

func (q *Query) SetSeeking(format Format, seekable bool, segmentStart, segmentEnd int64)

SetSeeking sets the seeking query result fields in query.

func (*Query) SetSegment

func (q *Query) SetSegment(rate float64, format Format, startValue, stopValue int64)

SetSegment answers a segment query by setting the requested values. The normal playback segment of a pipeline is 0 to duration at the default rate of 1.0. If a seek was performed on the pipeline to play a different segment, this query will return the range specified in the last seek.

start_value and stop_value will respectively contain the configured playback range start and stop values expressed in format. The values are always between 0 and the duration of the media and start_value <= stop_value. rate will contain the playback rate. For negative rates, playback will actually happen from stop_value to start_value.

func (*Query) SetURI

func (q *Query) SetURI(uri string)

SetURI answers a URI query by setting the requested URI.

func (*Query) SetURIRedirection

func (q *Query) SetURIRedirection(uri string)

SetURIRedirection answers a URI query by setting the requested URI redirection.

func (*Query) SetURIRedirectionPermanent

func (q *Query) SetURIRedirectionPermanent(permanent bool)

SetURIRedirectionPermanent answers a URI query by setting the requested URI redirection to permanent or not.

func (*Query) Type

func (q *Query) Type() QueryType

Type returns the type of the Query.

func (*Query) Unref

func (q *Query) Unref()

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

func (*Query) WritableStructure

func (q *Query) WritableStructure() *Structure

WritableStructure gets the structure of a query. This method should be called with a writable query so that the returned structure is guaranteed to be writable.

type QueryType

type QueryType int

QueryType casts GstQueryType

const (
	QueryUnknown    QueryType = C.GST_QUERY_UNKNOWN     // (0) – unknown query type
	QueryPosition   QueryType = C.GST_QUERY_POSITION    // (2563) – current position in stream
	QueryDuration   QueryType = C.GST_QUERY_DURATION    // (5123) – total duration of the stream
	QueryLatency    QueryType = C.GST_QUERY_LATENCY     // (7683) – latency of stream
	QueryJitter     QueryType = C.GST_QUERY_JITTER      // (10243) – current jitter of stream
	QueryRate       QueryType = C.GST_QUERY_RATE        // (12803) – current rate of the stream
	QuerySeeking    QueryType = C.GST_QUERY_SEEKING     // (15363) – seeking capabilities
	QuerySegment    QueryType = C.GST_QUERY_SEGMENT     // (17923) – segment start/stop positions
	QueryConvert    QueryType = C.GST_QUERY_CONVERT     // (20483) – convert values between formats
	QueryFormats    QueryType = C.GST_QUERY_FORMATS     // (23043) – query supported formats for convert
	QueryBuffering  QueryType = C.GST_QUERY_BUFFERING   // (28163) – query available media for efficient seeking.
	QueryCustom     QueryType = C.GST_QUERY_CUSTOM      // (30723) – a custom application or element defined que	QueryType = C.ry.
	QueryURI        QueryType = C.GST_QUERY_URI         // (33283) – query the URI of the source or sink.
	QueryAllocation QueryType = C.GST_QUERY_ALLOCATION  // (35846) – the buffer allocation properties
	QueryScheduling QueryType = C.GST_QUERY_SCHEDULING  // (38401) – the scheduling properties
	QueryAcceptCaps QueryType = C.GST_QUERY_ACCEPT_CAPS // (40963) – the accept caps query
	QueryCaps       QueryType = C.GST_QUERY_CAPS        // (43523) – the caps query
	QueryDrain      QueryType = C.GST_QUERY_DRAIN       // (46086) – wait till all serialized data is consumed downstream
	QueryContext    QueryType = C.GST_QUERY_CONTEXT     // (48643) – query the pipeline-local context from downstream or upstream (since 1.2)
	QueryBitrate    QueryType = C.GST_QUERY_BITRATE     // (51202) – the bitrate query (since 1.16)
)

Type casts

func (QueryType) String

func (q QueryType) String() string

type QueryTypeFlags

type QueryTypeFlags int

QueryTypeFlags casts GstQueryTypeFlags

const (
	QueryTypeUpstream   QueryTypeFlags = C.GST_QUERY_TYPE_UPSTREAM   // (1) – Set if the query can travel upstream.
	QueryTypeDownstream QueryTypeFlags = C.GST_QUERY_TYPE_DOWNSTREAM // (2) – Set if the query can travel downstream.
	QueryTypeSerialized QueryTypeFlags = C.GST_QUERY_TYPE_SERIALIZED // (4) – Set if the query should be serialized with data flow.
)

Type casts

type Rank

type Rank uint

Rank represents a level of importance when autoplugging elements.

const (
	RankNone Rank = 0
)

For now just a single RankNone is provided

type ReferenceTimestampMeta

type ReferenceTimestampMeta struct {
	Parent              *Meta
	Reference           *Caps
	Timestamp, Duration time.Duration
}

ReferenceTimestampMeta is a go representation of a GstReferenceTimestampMeta.

type Registry

type Registry struct{ *Object }

Registry is a go representation of a GstRegistry.

func FromGstRegistryUnsafeFull

func FromGstRegistryUnsafeFull(registry unsafe.Pointer) *Registry

FromGstRegistryUnsafeFull wraps the given GstRegistry pointer.

func FromGstRegistryUnsafeNone

func FromGstRegistryUnsafeNone(registry unsafe.Pointer) *Registry

FromGstRegistryUnsafeNone wraps the given GstRegistry pointer.

func GetRegistry

func GetRegistry() *Registry

GetRegistry returns the default global GstRegistry.

func (*Registry) FindPlugin

func (r *Registry) FindPlugin(name string) (*Plugin, error)

FindPlugin retrieves the plugin by the given name. Unref after usage.

func (*Registry) Instance

func (r *Registry) Instance() *C.GstRegistry

Instance returns the underlying GstRegistry instance.

func (*Registry) LookupFeature

func (r *Registry) LookupFeature(name string) (*PluginFeature, error)

LookupFeature looks up the given plugin feature by name. Unref after usage.

type Sample

type Sample struct {
	// contains filtered or unexported fields
}

Sample is a go wrapper around a GstSample object.

func FromGstSampleUnsafeFull

func FromGstSampleUnsafeFull(sample unsafe.Pointer) *Sample

FromGstSampleUnsafeFull wraps the pointer to the given C GstSample with the go type. This is meant for internal usage and is exported for visibility to other packages.

func FromGstSampleUnsafeNone

func FromGstSampleUnsafeNone(sample unsafe.Pointer) *Sample

FromGstSampleUnsafeNone wraps the pointer to the given C GstSample with the go type. This is meant for internal usage and is exported for visibility to other packages.

func (*Sample) Copy

func (s *Sample) Copy() *Sample

Copy creates a copy of the given sample. This will also make a newly allocated copy of the data the source sample contains.

func (*Sample) GetBuffer

func (s *Sample) GetBuffer() *Buffer

GetBuffer returns the buffer inside this sample.

func (*Sample) GetBufferList

func (s *Sample) GetBufferList() *BufferList

GetBufferList gets the buffer list associated with this sample.

func (*Sample) GetCaps

func (s *Sample) GetCaps() *Caps

GetCaps returns the caps associated with this sample. Take a ref if you need to hold on to them longer then the life of the sample.

func (*Sample) GetInfo

func (s *Sample) GetInfo() *Structure

GetInfo gets extra information about this sample. The structure remains valid as long as sample is valid.

func (*Sample) GetSegment

func (s *Sample) GetSegment() *Segment

GetSegment gets the segment associated with the sample. The segmenr remains valid as long as sample is valid.

func (*Sample) Instance

func (s *Sample) Instance() *C.GstSample

Instance returns the underlying *GstSample instance.

func (*Sample) Ref

func (s *Sample) Ref() *Sample

Ref increases the ref count on the sample.

func (*Sample) SetBuffer

func (s *Sample) SetBuffer(buf *Buffer)

SetBuffer sets the buffer inside this sample. The sample must be writable.

func (*Sample) SetBufferList

func (s *Sample) SetBufferList(buf *BufferList)

SetBufferList sets the buffer list for this sample. The sample must be writable.

func (*Sample) SetCaps

func (s *Sample) SetCaps(caps *Caps)

SetCaps sets the caps on this sample. The sample must be writable.

func (*Sample) SetInfo

func (s *Sample) SetInfo(st *Structure) bool

SetInfo sets the info on this sample. The sample must be writable.

func (*Sample) SetSegment

func (s *Sample) SetSegment(segment *Segment)

SetSegment sets the segment on this sample. The sample must be writable.

func (*Sample) Unref

func (s *Sample) Unref()

Unref calls gst_sample_unref on the sample.

type SchedulingFlags

type SchedulingFlags int

SchedulingFlags casts GstSchedulingFlags

const (
	SchedulingFlagSeekable         SchedulingFlags = C.GST_SCHEDULING_FLAG_SEEKABLE          // (1) – if seeking is possible
	SchedulingFlagSequential       SchedulingFlags = C.GST_SCHEDULING_FLAG_SEQUENTIAL        // (2) – if sequential access is recommended
	SchedulingFlagBandwidthLimited SchedulingFlags = C.GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED // (4) – if bandwidth is limited and buffering possible (since 1.2)
)

Type casts

type SeekFlags

type SeekFlags int

SeekFlags is a representation of GstSeekFlags.

const (
	SeekFlagNone        SeekFlags = C.GST_SEEK_FLAG_NONE
	SeekFlagFlush       SeekFlags = C.GST_SEEK_FLAG_FLUSH
	SeekFlagAccurate    SeekFlags = C.GST_SEEK_FLAG_ACCURATE
	SeekFlagKeyUnit     SeekFlags = C.GST_SEEK_FLAG_KEY_UNIT
	SeekFlagSegment     SeekFlags = C.GST_SEEK_FLAG_SEGMENT
	SeekFlagSkip        SeekFlags = C.GST_SEEK_FLAG_SKIP
	SeekFlagSnapBefore  SeekFlags = C.GST_SEEK_FLAG_SNAP_BEFORE
	SeekFlagSnapAfter   SeekFlags = C.GST_SEEK_FLAG_SNAP_AFTER
	SeekFlagSnapNearest SeekFlags = C.GST_SEEK_FLAG_SNAP_NEAREST
)

Type casts of SeekFlags

type SeekType

type SeekType int

SeekType is a representation of GstSeekType.

const (
	SeekTypeNone SeekType = C.GST_SEEK_TYPE_NONE
	SeekTypeSet  SeekType = C.GST_SEEK_TYPE_SET
	SeekTypeEnd  SeekType = C.GST_SEEK_TYPE_END
)

Type casts of seek types

type Segment

type Segment struct {
	// contains filtered or unexported fields
}

Segment is a go wrapper around a GstSegment. See: https://gstreamer.freedesktop.org/documentation/gstreamer/gstsegment.html?gi-language=c#GstSegment

func FromGstSegmentUnsafe

func FromGstSegmentUnsafe(segment unsafe.Pointer) *Segment

FromGstSegmentUnsafe wraps the GstSegment pointer.

func NewFormattedSegment

func NewFormattedSegment(f Format) *Segment

NewFormattedSegment returns a new Segment with the given format.

func NewSegment

func NewSegment() *Segment

NewSegment allocates and initializes a new Segment. Free when you are finished.

func ToGstSegment

func ToGstSegment(segment unsafe.Pointer) *Segment

ToGstSegment converts the given pointer into a Segment without affecting the ref count or placing finalizers.

func (*Segment) Clip

func (s *Segment) Clip(format Format, start, stop uint64) (ok bool, clipStart, clipStop uint64)

Clip clips the given start and stop values to the segment boundaries given in segment. start and stop are compared and clipped to segment start and stop values.

If the function returns FALSE, start and stop are known to fall outside of segment and clip_start and clip_stop are not updated.

When the function returns TRUE, clip_start and clip_stop will be updated. If clip_start or clip_stop are different from start or stop respectively, the region fell partially in the segment.

Note that when stop is -1, clip_stop will be set to the end of the segment. Depending on the use case, this may or may not be what you want.

func (*Segment) Copy

func (s *Segment) Copy() *Segment

Copy creates a copy of this segment.

func (*Segment) CopyInto

func (s *Segment) CopyInto(segment *Segment)

CopyInto copies the contents of this segment into the given one.

func (*Segment) DoSeek

func (s *Segment) DoSeek(rate float64, format Format, flags SeekFlags, startType SeekType, start uint64, stopType SeekType, stop uint64) (ok, update bool)

DoSeek updates the segment structure with the field values of a seek event (see NewSeekEvent).

After calling this method, the segment field position and time will contain the requested new position in the segment. The new requested position in the segment depends on rate and start_type and stop_type.

For positive rate, the new position in the segment is the new segment start field when it was updated with a start_type different from SeekTypeNone. If no update was performed on segment start position (#SeekTypeNone), start is ignored and segment position is unmodified.

For negative rate, the new position in the segment is the new segment stop field when it was updated with a stop_type different from SeekTypeNone. If no stop was previously configured in the segment, the duration of the segment will be used to update the stop position. If no update was performed on segment stop position (#SeekTypeNone), stop is ignored and segment position is unmodified.

The applied rate of the segment will be set to 1.0 by default. If the caller can apply a rate change, it should update segment rate and applied_rate after calling this function.

update will be set to TRUE if a seek should be performed to the segment position field. This field can be FALSE if, for example, only the rate has been changed but not the playback position.

func (*Segment) Free

func (s *Segment) Free()

Free frees the allocated segment.

func (*Segment) GetAppliedRate

func (s *Segment) GetAppliedRate() float64

GetAppliedRate returns the applied rate for this segment.

func (*Segment) GetBase

func (s *Segment) GetBase() uint64

GetBase returns the base for this segment.

func (*Segment) GetDuration

func (s *Segment) GetDuration() uint64

GetDuration gets the duration of this segment.

func (*Segment) GetFlags

func (s *Segment) GetFlags() SegmentFlags

GetFlags returns the flags on this segment.

func (*Segment) GetFormat

func (s *Segment) GetFormat() Format

GetFormat returns the format for this segment.

func (*Segment) GetOffset

func (s *Segment) GetOffset() uint64

GetOffset returns the offset for this segment.

func (*Segment) GetPosition

func (s *Segment) GetPosition() uint64

GetPosition returns the position of this segment.

func (*Segment) GetRate

func (s *Segment) GetRate() float64

GetRate returns the rate for this segment.

func (*Segment) GetStart

func (s *Segment) GetStart() uint64

GetStart returns the start of this segment.

func (*Segment) GetStop

func (s *Segment) GetStop() uint64

GetStop returns the stop of this segment.

func (*Segment) GetTime

func (s *Segment) GetTime() uint64

GetTime returns the time of this segment.

func (*Segment) Init

func (s *Segment) Init(format Format)

Init reinitializes a segment to its default values.

func (*Segment) Instance

func (s *Segment) Instance() *C.GstSegment

Instance returns the underlying GstSegment instance.

func (*Segment) IsEqual

func (s *Segment) IsEqual(segment *Segment) bool

IsEqual checks for two segments being equal. Equality here is defined as perfect equality, including floating point values.

func (*Segment) OffsetRunningTime

func (s *Segment) OffsetRunningTime(format Format, offset int64) bool

OffsetRunningTime adjusts the values in segment so that offset is applied to all future running-time calculations.

func (*Segment) PositionFromRunningTime

func (s *Segment) PositionFromRunningTime(format Format, runningTime uint64) uint64

PositionFromRunningTime converts running_time into a position in the segment so that ToRunningTime with that position returns running_time. The position in the segment for runningTime is returned.

func (*Segment) PositionFromRunningTimeFull

func (s *Segment) PositionFromRunningTimeFull(format Format, runningTime uint64) int64

PositionFromRunningTimeFull translates running_time to the segment position using the currently configured segment. Compared to PositionFromRunningTime this function can return negative segment position.

This function is typically used by elements that need to synchronize buffers against the clock or each other.

running_time can be any value and the result of this function for values outside of the segment is extrapolated.

func (*Segment) PositionFromStreamTime

func (s *Segment) PositionFromStreamTime(format Format, streamTime uint64) uint64

PositionFromStreamTime converts stream_time into a position in the segment so that ToStreamTime with that position returns stream_time.

func (*Segment) PositionFromStreamTimeFull

func (s *Segment) PositionFromStreamTimeFull(format Format, streamTime uint64) int64

PositionFromStreamTimeFull translates stream_time to the segment position using the currently configured segment. Compared to PositionFromStreamTime this function can return negative segment position.

This function is typically used by elements that need to synchronize buffers against the clock or each other.

stream_time can be any value and the result of this function for values outside of the segment is extrapolated.

func (*Segment) SetAppliedRate

func (s *Segment) SetAppliedRate(rate float64)

SetAppliedRate sets the applied rate for this segment

func (*Segment) SetFlags

func (s *Segment) SetFlags(flags SegmentFlags)

SetFlags sets the flags on this segment.

func (*Segment) SetFormat

func (s *Segment) SetFormat(f Format)

SetFormat sets the format on this segment.

func (*Segment) SetRate

func (s *Segment) SetRate(rate float64)

SetRate sets the rate for this segment.

func (*Segment) SetRunningTime

func (s *Segment) SetRunningTime(format Format, runningTime uint64) bool

SetRunningTime adjusts the start/stop and base values of segment such that the next valid buffer will be one with running_time.

func (*Segment) ToRunningTime

func (s *Segment) ToRunningTime(format Format, position uint64) uint64

ToRunningTime translates position to the total running time using the currently configured segment. Position is a value between segment start and stop time.

This function is typically used by elements that need to synchronize to the global clock in a pipeline. The running time is a constantly increasing value starting from 0. When segment Init is called, this value will reset to 0.

This function returns -1 if the position is outside of segment start and stop.

func (*Segment) ToRunningTimeFull

func (s *Segment) ToRunningTimeFull(format Format, position uint64) int64

ToRunningTimeFull translates position to the total running time using the currently configured segment. Compared to ToRunningTime this function can return negative running-time.

This function is typically used by elements that need to synchronize buffers against the clock or each other.

position can be any value and the result of this function for values outside of the segment is extrapolated.

func (*Segment) ToStreamTime

func (s *Segment) ToStreamTime(format Format, position uint64) uint64

ToStreamTime translates position to stream time using the currently configured segment. The position value must be between segment start and stop value.

This function is typically used by elements that need to operate on the stream time of the buffers it receives, such as effect plugins. In those use cases, position is typically the buffer timestamp or clock time that one wants to convert to the stream time. The stream time is always between 0 and the total duration of the media stream.

func (*Segment) ToStreamTimeFull

func (s *Segment) ToStreamTimeFull(format Format, position uint64) int64

ToStreamTimeFull translates position to the total stream time using the currently configured segment. Compared to ToStreamTime this function can return negative stream-time.

This function is typically used by elements that need to synchronize buffers against the clock or each other.

position can be any value and the result of this function for values outside of the segment is extrapolated.

type SegmentFlags

type SegmentFlags int

SegmentFlags casts GstSegmentFlags

const (
	SegmentFlagNone      SegmentFlags = C.GST_SEGMENT_FLAG_NONE                // (0) – no flags
	SegmentFlagReset     SegmentFlags = C.GST_SEGMENT_FLAG_RESET               // (1) – reset the pipeline running_time to the segment running_time
	SegmentFlagTrickMode SegmentFlags = C.GST_SEGMENT_FLAG_TRICKMODE           // (16) – perform skip playback (Since: 1.6)
	SegmentFlagSkip      SegmentFlags = C.GST_SEGMENT_FLAG_SKIP                // (16) – Deprecated backward compatibility flag, replaced by GST_SEGMENT_FLAG_TRICKMODE
	SegmentFlagSegment   SegmentFlags = C.GST_SEGMENT_FLAG_SEGMENT             // (8) – send SEGMENT_DONE instead of EOS
	SegmentFlagKeyUnits  SegmentFlags = C.GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS // (128) – Decode only keyframes, where possible (Since: 1.6)
	// SegmentFlagTrickModeForwardPredicted SegmentFlags = C.GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED // (512) – Decode only keyframes or forward predicted frames, where possible (Since: 1.18)
	SegmentFlagTrickModeNoAudio SegmentFlags = C.GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO // (256) – Do not decode any audio, where possible (Since: 1.6)
)

Type castings

type StackTraceFlags

type StackTraceFlags int

StackTraceFlags are flags for configuring stack traces

const (
	StackTraceShowNone StackTraceFlags = 0                           // (0) – Try to retrieve the minimum information available, which may be none on some platforms (Since: 1.18)
	StackTraceShowFull StackTraceFlags = C.GST_STACK_TRACE_SHOW_FULL // (1) – Try to retrieve as much information as possible, including source information when getting the stack trace
)

Type castings of StackTraceFlags

type State

type State int

State is a type cast of the C GstState

const (
	VoidPending  State = C.GST_STATE_VOID_PENDING // (0) – no pending state.
	StateNull    State = C.GST_STATE_NULL         // (1) – the NULL state or initial state of an element.
	StateReady   State = C.GST_STATE_READY        // (2) – the element is ready to go to PAUSED.
	StatePaused  State = C.GST_STATE_PAUSED       // (3) – the element is PAUSED, it is ready to accept and process data. Sink elements however only accept one buffer and then block.
	StatePlaying State = C.GST_STATE_PLAYING      // (4) – the element is PLAYING, the GstClock is running and the data is flowing.
)

Type casting for GstStates

func (State) String

func (s State) String() string

String returns the string representation of this state.

type StateChange

type StateChange int

StateChange is the different state changes an element goes through. StateNull ⇒ StatePlaying is called an upwards state change and StatePlaying ⇒ StateNull a downwards state change.

See https://gstreamer.freedesktop.org/documentation/gstreamer/gstelement.html?gi-language=c#GstStateChange for more information on the responsibiltiies of elements during each transition.

const (
	StateChangeNullToReady      StateChange = C.GST_STATE_CHANGE_NULL_TO_READY
	StateChangeReadyToPaused    StateChange = C.GST_STATE_CHANGE_READY_TO_PAUSED
	StateChangePausedToPlaying  StateChange = C.GST_STATE_CHANGE_PAUSED_TO_PLAYING
	StateChangePlayingToPaused  StateChange = C.GST_STATE_CHANGE_PLAYING_TO_PAUSED
	StateChangePausedToReady    StateChange = C.GST_STATE_CHANGE_PAUSED_TO_READY
	StateChangeReadyToNull      StateChange = C.GST_STATE_CHANGE_READY_TO_NULL
	StateChangeNullToNull       StateChange = C.GST_STATE_CHANGE_NULL_TO_NULL
	StateChangeReadyToReady     StateChange = C.GST_STATE_CHANGE_READY_TO_READY
	StateChangePausedToPaused   StateChange = C.GST_STATE_CHANGE_PAUSED_TO_PAUSED
	StateChangePlayingToPlaying StateChange = C.GST_STATE_CHANGE_PLAYING_TO_PLAYING
)

StateChange castings

func (StateChange) String

func (s StateChange) String() string

String returns the string representation of a StateChange

type StateChangeReturn

type StateChangeReturn int

StateChangeReturn is a representation of GstStateChangeReturn.

Type casts of state change returns

func (StateChangeReturn) String

func (s StateChangeReturn) String() string

type StepDoneValues

type StepDoneValues struct {
	Format       Format
	Amount       uint64
	Rate         float64
	Flush        bool
	Intermediate bool
	Duration     time.Duration
	EOS          bool
}

StepDoneValues represents the values inside a StepDone message.

type StepStartValues

type StepStartValues struct {
	Active       bool
	Format       Format
	Amount       uint64
	Rate         float64
	Flush        bool
	Intermediate bool
}

StepStartValues represents the values inside a StepStart message.

type StickyEventsForEachFunc

type StickyEventsForEachFunc func(pad *Pad, event *Event) bool

StickyEventsForEachFunc is a callback used by StickyEventsForEach. When this function returns TRUE, the next event will be returned. When FALSE is returned, gst_pad_sticky_events_foreach will return.

When event is set to NULL, the item will be removed from the list of sticky events. event can be replaced by assigning a new reference to it. This function is responsible for unreffing the old event when removing or modifying.

type Stream

type Stream struct{ *Object }

Stream is a Go representation of a GstStream.

func FromGstStreamUnsafeFull

func FromGstStreamUnsafeFull(stream unsafe.Pointer) *Stream

FromGstStreamUnsafeFull captures a pointer with just a finalizer.

func FromGstStreamUnsafeNone

func FromGstStreamUnsafeNone(stream unsafe.Pointer) *Stream

FromGstStreamUnsafeNone captures a pointer with a ref and finalizer.

func NewStream

func NewStream(id string, caps *Caps, sType StreamType, flags StreamFlags) *Stream

NewStream returns a new Stream with the given ID, caps, type, and flags.

func (*Stream) Caps

func (s *Stream) Caps() *Caps

Caps returns the caps for this stream.

func (*Stream) Instance

func (s *Stream) Instance() *C.GstStream

Instance returns the underlying GstStream.

func (*Stream) SetCaps

func (s *Stream) SetCaps(caps *Caps)

SetCaps sets the caps for this stream.

func (*Stream) SetStreamFlags

func (s *Stream) SetStreamFlags(flags StreamFlags)

SetStreamFlags sets the flags for this stream.

func (*Stream) SetStreamType

func (s *Stream) SetStreamType(sType StreamType)

SetStreamType sets the type of this stream.

func (*Stream) SetTags

func (s *Stream) SetTags(tags *TagList)

SetTags sets the tags for this stream.

func (*Stream) StreamFlags

func (s *Stream) StreamFlags() StreamFlags

StreamFlags returns the flags for this stream.

func (*Stream) StreamID

func (s *Stream) StreamID() string

StreamID returns the id of this stream.

func (*Stream) StreamType

func (s *Stream) StreamType() StreamType

StreamType returns the type of this stream.

func (*Stream) Tags

func (s *Stream) Tags() *TagList

Tags returns the tag list for this stream.

type StreamCollection

type StreamCollection struct{ *Object }

StreamCollection is a Go representation of a GstStreamCollection.

func FromGstStreamCollectionUnsafeFull

func FromGstStreamCollectionUnsafeFull(stream unsafe.Pointer) *StreamCollection

FromGstStreamCollectionUnsafeFull captures a pointer with just a finalizer.

func FromGstStreamCollectionUnsafeNone

func FromGstStreamCollectionUnsafeNone(stream unsafe.Pointer) *StreamCollection

FromGstStreamCollectionUnsafeNone captures a pointer with a ref and finalizer.

func NewStreamCollection

func NewStreamCollection(upstreamID string) *StreamCollection

NewStreamCollection returns a new StreamCollection with an upstream parent of the given stream ID.

func (*StreamCollection) AddStream

func (s *StreamCollection) AddStream(stream *Stream) error

AddStream adds the given stream to this collection.

func (*StreamCollection) GetSize

func (s *StreamCollection) GetSize() uint

GetSize returns the size of this stream collection.

func (*StreamCollection) GetStreamAt

func (s *StreamCollection) GetStreamAt(idx uint) *Stream

GetStreamAt returns the stream at the given index in this collection.

func (*StreamCollection) GetUpstreamID

func (s *StreamCollection) GetUpstreamID() string

GetUpstreamID retrieves the upstream ID for this collection.

func (*StreamCollection) Instance

func (s *StreamCollection) Instance() *C.GstStreamCollection

Instance returns the underlying GstStreamCollection.

type StreamFlags

type StreamFlags int

StreamFlags represent configuration options for a new stream.

const (
	StreamFlagNone     StreamFlags = C.GST_STREAM_FLAG_NONE     // (0) – This stream has no special attributes
	StreamFlagSparse   StreamFlags = C.GST_STREAM_FLAG_SPARSE   // (1) – This stream is a sparse stream (e.g. a subtitle stream), data may flow only in irregular intervals with large gaps in between.
	StreamFlagSelect   StreamFlags = C.GST_STREAM_FLAG_SELECT   // (2) – This stream should be selected by default. This flag may be used by demuxers to signal that a stream should be selected by default in a playback scenario.
	StreamFlagUnselect StreamFlags = C.GST_STREAM_FLAG_UNSELECT // (4) – This stream should not be selected by default. This flag may be used by demuxers to signal that a stream should not be selected by default in a playback scenario, but only if explicitly selected by the user (e.g. an audio track for the hard of hearing or a director's commentary track).
)

Type castings of StreamFlags

type StreamStatusType

type StreamStatusType int

StreamStatusType represents a type of change in a stream's status

const (
	StreamStatusCreate  StreamStatusType = C.GST_STREAM_STATUS_TYPE_CREATE  // (0) – A new thread need to be created.
	StreamStatusEnter   StreamStatusType = C.GST_STREAM_STATUS_TYPE_ENTER   // (1) – a thread entered its loop function
	StreamStatusLeave   StreamStatusType = C.GST_STREAM_STATUS_TYPE_LEAVE   // (2) – a thread left its loop function
	StreamStatusDestroy StreamStatusType = C.GST_STREAM_STATUS_TYPE_DESTROY // (3) – a thread is destroyed
	StreamStatusStart   StreamStatusType = C.GST_STREAM_STATUS_TYPE_START   // (8) – a thread is started
	StreamStatusPause   StreamStatusType = C.GST_STREAM_STATUS_TYPE_PAUSE   // (9) – a thread is paused
	StreamStatusStop    StreamStatusType = C.GST_STREAM_STATUS_TYPE_STOP    // (10) – a thread is stopped
)

Type castings of the stream status types

func (StreamStatusType) String

func (s StreamStatusType) String() string

type StreamType

type StreamType int

StreamType is a go representation of a GstStreamType

const (
	StreamTypeUnknown   StreamType = C.GST_STREAM_TYPE_UNKNOWN   // (1) – The stream is of unknown (unclassified) type.
	StreamTypeAudio     StreamType = C.GST_STREAM_TYPE_AUDIO     // (2) – The stream is of audio data
	StreamTypeVideo     StreamType = C.GST_STREAM_TYPE_VIDEO     // (4) – The stream carries video data
	StreamTypeContainer StreamType = C.GST_STREAM_TYPE_CONTAINER // (8) – The stream is a muxed container type
	StreamTypeText      StreamType = C.GST_STREAM_TYPE_TEXT      // (16) – The stream contains subtitle / subpicture data.
)

Type castings of stream types

func (StreamType) String

func (s StreamType) String() string

String implements a stringer on StreamTypes.

type Structure

type Structure struct {
	// contains filtered or unexported fields
}

Structure is a go implementation of a C GstStructure.

func FromGstStructureUnsafe

func FromGstStructureUnsafe(st unsafe.Pointer) *Structure

FromGstStructureUnsafe wraps the given unsafe.Pointer in a Structure. This is meant for internal usage and is exported for visibility to other packages.

func MarshalStructure

func MarshalStructure(data interface{}) *Structure

MarshalStructure will convert the given go struct into a GstStructure. Currently nested structs are not supported.

func NewStructure

func NewStructure(name string) *Structure

NewStructure returns a new empty structure with the given name.

func NewStructureFromString

func NewStructureFromString(stStr string) *Structure

NewStructureFromString builds a new GstStructure from the given string.

func ValueGetStructure

func ValueGetStructure(gval *glib.Value) *Structure

ValueGetStructure extracts the GstStructure from a glib.Value, or nil if one does not exist.

func (*Structure) Free

func (s *Structure) Free()

Free frees the memory for the underlying GstStructure.

func (*Structure) GetValue

func (s *Structure) GetValue(key string) (interface{}, error)

GetValue retrieves the value at key.

func (*Structure) Instance

func (s *Structure) Instance() *C.GstStructure

Instance returns the native GstStructure instance.

func (*Structure) Name

func (s *Structure) Name() string

Name returns the name of this structure.

func (*Structure) RemoveValue

func (s *Structure) RemoveValue(key string)

RemoveValue removes the value at the given key. If the key does not exist, the structure is unchanged.

func (*Structure) SetValue

func (s *Structure) SetValue(key string, value interface{}) error

SetValue sets the data at key to the given value.

func (*Structure) Size

func (s *Structure) Size() int

Size returns the number of fields inside this structure.

func (*Structure) String

func (s *Structure) String() string

String implement a stringer on a GstStructure.

func (*Structure) ToGValue

func (s *Structure) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer

func (*Structure) UnmarshalInto

func (s *Structure) UnmarshalInto(data interface{}) error

UnmarshalInto will unmarshal this structure into the given pointer. The object reflected by the pointer must be non-nil.

func (*Structure) Values

func (s *Structure) Values() map[string]interface{}

Values returns a map of all the values inside this structure. If values cannot be converted to an equivalent go type, they are serialized to a string.

type StructureChangeType

type StructureChangeType int

StructureChangeType is a go representation of a GstStructureChangeType

const (
	StructureChangePadLink   StructureChangeType = C.GST_STRUCTURE_CHANGE_TYPE_PAD_LINK   // (0) – Pad linking is starting or done.
	StructureChangePadUnlink StructureChangeType = C.GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK // (1) – Pad unlinking is starting or done.
)

Type castings of StructureChangeTypes

func (StructureChangeType) String

func (s StructureChangeType) String() string

String implements a stringer on StructureChangeTypes.

type SystemClock

type SystemClock struct{ *Clock }

SystemClock wraps GstSystemClock

func ObtainSystemClock

func ObtainSystemClock() *SystemClock

ObtainSystemClock returns the default SystemClock. The refcount of the clock will be increased so you need to unref the clock after usage.

type TOC

type TOC struct {
	// contains filtered or unexported fields
}

TOC is a go representation of a GstToc.

func FromGstTOCUnsafeFull

func FromGstTOCUnsafeFull(toc unsafe.Pointer) *TOC

FromGstTOCUnsafeFull wraps the pointer to the given C GstToc with the go type. This is meant for internal usage and is exported for visibility to other packages.

func FromGstTOCUnsafeNone

func FromGstTOCUnsafeNone(toc unsafe.Pointer) *TOC

FromGstTOCUnsafeNone wraps the pointer to the given C GstToc with the go type. This is meant for internal usage and is exported for visibility to other packages.

func NewTOC

func NewTOC(scope TOCScope) *TOC

NewTOC returns a new TOC with the given scope.

func (*TOC) AppendEntry

func (t *TOC) AppendEntry(entry *TOCEntry)

AppendEntry appends the given TOCEntry to this TOC.

func (*TOC) Copy

func (t *TOC) Copy() *TOC

Copy creates a copy of the TOC.

func (*TOC) Dump

func (t *TOC) Dump()

Dump dumps the TOC.

func (*TOC) FindEntry

func (t *TOC) FindEntry(uid string) *TOCEntry

FindEntry finds the entry with the given uid.

func (*TOC) GetEntries

func (t *TOC) GetEntries() []*TOCEntry

GetEntries returns a list of all TOCEntries.

func (*TOC) GetScope

func (t *TOC) GetScope() TOCScope

GetScope returns the scope of this TOC.

func (*TOC) GetTags

func (t *TOC) GetTags() *TagList

GetTags returns the TagList for this TOC.

func (*TOC) Instance

func (t *TOC) Instance() *C.GstToc

Instance returns the underlying GstToc instance.

func (*TOC) MakeWritable

func (t *TOC) MakeWritable() *TOC

MakeWritable returns a writable copy of the TOC if it isn't already,

func (*TOC) MergeTags

func (t *TOC) MergeTags(tagList *TagList, mergeMode TagMergeMode)

MergeTags merges the given tags into this TOC's TagList.

func (*TOC) Ref

func (t *TOC) Ref() *TOC

Ref increases the ref count on the TOC by one.

func (*TOC) SetTags

func (t *TOC) SetTags(tagList *TagList)

SetTags sets tags for the entire TOC.

func (*TOC) Unref

func (t *TOC) Unref()

Unref decreases the ref count on the TOC by one.

type TOCEntry

type TOCEntry struct {
	// contains filtered or unexported fields
}

TOCEntry is a go representation of a GstTocEntry,

func FromGstTocEntryUnsafeFull

func FromGstTocEntryUnsafeFull(entry unsafe.Pointer) *TOCEntry

FromGstTocEntryUnsafeFull wraps the given TOCEntry.

func FromGstTocEntryUnsafeNone

func FromGstTocEntryUnsafeNone(entry unsafe.Pointer) *TOCEntry

FromGstTocEntryUnsafeNone wraps the given TOCEntry.

func NewTOCEntry

func NewTOCEntry(entryType TOCEntryType, uid string) *TOCEntry

NewTOCEntry creates a new TOCEntry with the given UID and type.

func (*TOCEntry) AppendSubEntry

func (t *TOCEntry) AppendSubEntry(subEntry *TOCEntry)

AppendSubEntry appends the given entry as a subentry to this one.

func (*TOCEntry) Copy

func (t *TOCEntry) Copy() *TOCEntry

Copy creates a copy of the TOCEntry

func (*TOCEntry) GetEntryType

func (t *TOCEntry) GetEntryType() TOCEntryType

GetEntryType returns the type of this TOCEntry

func (*TOCEntry) GetEntryTypeString

func (t *TOCEntry) GetEntryTypeString() string

GetEntryTypeString returns a string representation of the entry type.

func (*TOCEntry) GetLoop

func (t *TOCEntry) GetLoop() (bool, TOCLoopType, int)

GetLoop gets the loop type and repeat count for the TOC entry.

func (*TOCEntry) GetParent

func (t *TOCEntry) GetParent() *TOCEntry

GetParent gets the parent of this TOCEntry.

func (*TOCEntry) GetStartStopTimes

func (t *TOCEntry) GetStartStopTimes() (ok bool, startTime, stopTime int64)

GetStartStopTimes gets the start and stop times for the TOCEntry if available.

func (*TOCEntry) GetSubEntries

func (t *TOCEntry) GetSubEntries() []*TOCEntry

GetSubEntries gets all the subentries for this TOCEntry.

func (*TOCEntry) GetTOC

func (t *TOCEntry) GetTOC() *TOC

GetTOC returns the parent TOC of this entry.

func (*TOCEntry) GetTags

func (t *TOCEntry) GetTags() *TagList

GetTags gets the tags for this entry.

func (*TOCEntry) GetUID

func (t *TOCEntry) GetUID() string

GetUID returns the uid of this entry.

func (*TOCEntry) Instance

func (t *TOCEntry) Instance() *C.GstTocEntry

Instance returns the underlying GstTocEntry instance.

func (*TOCEntry) IsAlternative

func (t *TOCEntry) IsAlternative() bool

IsAlternative returns true if this is an alternative entry.

func (*TOCEntry) IsSequence

func (t *TOCEntry) IsSequence() bool

IsSequence returns true if this is a sequence entry.

func (*TOCEntry) MakeWritable

func (t *TOCEntry) MakeWritable() *TOCEntry

MakeWritable returns a writable copy of the TOCEntry if it is not already so.

func (*TOCEntry) MergeTags

func (t *TOCEntry) MergeTags(tagList *TagList, mergeMode TagMergeMode)

MergeTags merges the given tags with the given mode.

func (*TOCEntry) Ref

func (t *TOCEntry) Ref() *TOCEntry

Ref increases the ref count on the TOCEntry by one.

func (*TOCEntry) SetLoop

func (t *TOCEntry) SetLoop(loopType TOCLoopType, repeatCount int)

SetLoop sets the loop type and repeat counts for the entry.

func (*TOCEntry) SetStartStopTimes

func (t *TOCEntry) SetStartStopTimes(startTime, stopTime int64)

SetStartStopTimes sets the start and stop times for the TOC entry.

func (*TOCEntry) SetTags

func (t *TOCEntry) SetTags(tagList *TagList)

SetTags sets the tags on the TOC entry.

func (*TOCEntry) Unref

func (t *TOCEntry) Unref()

Unref decreases the ref count on the TOCEntry by one.

type TOCEntryType

type TOCEntryType int

TOCEntryType represents a GstTocEntryType.

const (
	TOCEntryTypeAngle   TOCEntryType = C.GST_TOC_ENTRY_TYPE_ANGLE   // (-3) – entry is an angle (i.e. an alternative)
	TOCEntryTypeVersion TOCEntryType = C.GST_TOC_ENTRY_TYPE_VERSION // (-2) – entry is a version (i.e. alternative)
	TOCEntryTypeEdition TOCEntryType = C.GST_TOC_ENTRY_TYPE_EDITION // (-1) – entry is an edition (i.e. alternative)
	TOCEntryTypeInvalid TOCEntryType = C.GST_TOC_ENTRY_TYPE_INVALID // (0) – invalid entry type value
	TOCEntryTypeTitle   TOCEntryType = C.GST_TOC_ENTRY_TYPE_TITLE   // (1) – entry is a title (i.e. a part of a sequence)
	TOCEntryTypeTrack   TOCEntryType = C.GST_TOC_ENTRY_TYPE_TRACK   // (2) – entry is a track (i.e. a part of a sequence)
	TOCEntryTypeChapter TOCEntryType = C.GST_TOC_ENTRY_TYPE_CHAPTER // (3) – entry is a chapter (i.e. a part of a sequence)
)

Type castings of TOCEntryTypes

type TOCLoopType

type TOCLoopType int

TOCLoopType represents a GstTocLoopType

const (
	TOCLoopNone     TOCLoopType = C.GST_TOC_LOOP_NONE      // (0) – single forward playback
	TOCLoopForward  TOCLoopType = C.GST_TOC_LOOP_FORWARD   // (1) – repeat forward
	TOCLoopReverse  TOCLoopType = C.GST_TOC_LOOP_REVERSE   // (2) – repeat backward
	TOCLoopPingPong TOCLoopType = C.GST_TOC_LOOP_PING_PONG // (3) – repeat forward and backward
)

Type castings of TOCLoopTypes

type TOCScope

type TOCScope int

TOCScope represents the scope of a TOC.

const (
	// (1) – global TOC representing all selectable options (this is what applications are usually interested in)
	TOCScopeGlobal TOCScope = C.GST_TOC_SCOPE_GLOBAL
	// (2) – TOC for the currently active/selected stream (this is a TOC representing the current stream from start
	// to EOS, and is what a TOC writer / muxer is usually interested in; it will usually be a subset of the global
	// TOC, e.g. just the chapters of the current title, or the chapters selected for playback from the current title)
	TOCScopeCurrent TOCScope = C.GST_TOC_SCOPE_CURRENT
)

Type castings of TOCScopes.

func (TOCScope) String

func (t TOCScope) String() string

String implements a stringer on a TOCScope

type TOCSetter

type TOCSetter interface {
	// Return current TOC the setter uses. The TOC should not be modified without making it writable first.
	GetTOC() *TOC
	// Set the given TOC on the setter. Previously set TOC will be unreffed before setting a new one.
	SetTOC(*TOC)
	// Reset the internal TOC. Elements should call this from within the state-change handler.
	Reset()
}

TOCSetter is an interface that elements can implement to provide TOC writing capabilities.

type Tag

type Tag string

Tag wraps the builtin gstreamer tags

const (
	TagAlbum                        Tag = C.GST_TAG_ALBUM
	TagAlbumArtist                  Tag = C.GST_TAG_ALBUM_ARTIST
	TagAlbumArtistSortName          Tag = C.GST_TAG_ALBUM_ARTIST_SORTNAME
	TagAlbumGain                    Tag = C.GST_TAG_ALBUM_GAIN
	TagAlbumPeak                    Tag = C.GST_TAG_ALBUM_PEAK
	TagAlbumSortName                Tag = C.GST_TAG_ALBUM_SORTNAME
	TagAlbumVolumeCount             Tag = C.GST_TAG_ALBUM_VOLUME_COUNT
	TagAlbumVolumeNumber            Tag = C.GST_TAG_ALBUM_VOLUME_NUMBER
	TagApplicationData              Tag = C.GST_TAG_APPLICATION_DATA
	TagApplicationName              Tag = C.GST_TAG_APPLICATION_NAME
	TagArtist                       Tag = C.GST_TAG_ARTIST
	TagArtistSortName               Tag = C.GST_TAG_ARTIST_SORTNAME
	TagAttachment                   Tag = C.GST_TAG_ATTACHMENT
	TagAudioCodec                   Tag = C.GST_TAG_AUDIO_CODEC
	TagBeatsPerMinute               Tag = C.GST_TAG_BEATS_PER_MINUTE
	TagBitrate                      Tag = C.GST_TAG_BITRATE
	TagCodec                        Tag = C.GST_TAG_CODEC
	TagComment                      Tag = C.GST_TAG_COMMENT
	TagComposer                     Tag = C.GST_TAG_COMPOSER
	TagComposerSortName             Tag = C.GST_TAG_COMPOSER_SORTNAME
	TagConductor                    Tag = C.GST_TAG_CONDUCTOR
	TagContact                      Tag = C.GST_TAG_CONTACT
	TagContainerFormat              Tag = C.GST_TAG_CONTAINER_FORMAT
	TagCopyright                    Tag = C.GST_TAG_COPYRIGHT
	TagCopyrightURI                 Tag = C.GST_TAG_COPYRIGHT_URI
	TagDate                         Tag = C.GST_TAG_DATE
	TagDateTime                     Tag = C.GST_TAG_DATE_TIME
	TagDescription                  Tag = C.GST_TAG_DESCRIPTION
	TagDeviceManufacturer           Tag = C.GST_TAG_DEVICE_MANUFACTURER
	TagDeviceModel                  Tag = C.GST_TAG_DEVICE_MODEL
	TagDuration                     Tag = C.GST_TAG_DURATION
	TagEncodedBy                    Tag = C.GST_TAG_ENCODED_BY
	TagEncoder                      Tag = C.GST_TAG_ENCODER
	TagEncoderVersion               Tag = C.GST_TAG_ENCODER_VERSION
	TagExtendedComment              Tag = C.GST_TAG_EXTENDED_COMMENT
	TagGenre                        Tag = C.GST_TAG_GENRE
	TagGeoLocationCaptureDirection  Tag = C.GST_TAG_GEO_LOCATION_CAPTURE_DIRECTION
	TagGeoLocationCity              Tag = C.GST_TAG_GEO_LOCATION_CITY
	TagGeoLocationCountry           Tag = C.GST_TAG_GEO_LOCATION_COUNTRY
	TagGeoLocationElevation         Tag = C.GST_TAG_GEO_LOCATION_ELEVATION
	TagGeoLocationHoriozontalError  Tag = C.GST_TAG_GEO_LOCATION_HORIZONTAL_ERROR
	TagGeoLocationLatitude          Tag = C.GST_TAG_GEO_LOCATION_LATITUDE
	TagGeoLocationLongitude         Tag = C.GST_TAG_GEO_LOCATION_LONGITUDE
	TagGeoLocationMovementDirection Tag = C.GST_TAG_GEO_LOCATION_MOVEMENT_DIRECTION
	TagGeoLocationMovementSpeed     Tag = C.GST_TAG_GEO_LOCATION_MOVEMENT_SPEED
	TagGeoLocationName              Tag = C.GST_TAG_GEO_LOCATION_NAME
	TagGeoLocationSubLocation       Tag = C.GST_TAG_GEO_LOCATION_SUBLOCATION
	TagGrouping                     Tag = C.GST_TAG_GROUPING
	TagHomepage                     Tag = C.GST_TAG_HOMEPAGE
	TagImage                        Tag = C.GST_TAG_IMAGE
	TagImageOrientation             Tag = C.GST_TAG_IMAGE_ORIENTATION
	TagInterpretedBy                Tag = C.GST_TAG_INTERPRETED_BY
	TagISRC                         Tag = C.GST_TAG_ISRC
	TagKeywords                     Tag = C.GST_TAG_KEYWORDS
	TagLanguageCode                 Tag = C.GST_TAG_LANGUAGE_CODE
	TagLanguageName                 Tag = C.GST_TAG_LANGUAGE_NAME
	TagLicense                      Tag = C.GST_TAG_LICENSE
	TagLicenseURI                   Tag = C.GST_TAG_LICENSE_URI
	TagLocation                     Tag = C.GST_TAG_LOCATION
	TagLyrics                       Tag = C.GST_TAG_LYRICS
	TagMaximumBitrate               Tag = C.GST_TAG_MAXIMUM_BITRATE
	TagMIDIBaseNote                 Tag = C.GST_TAG_MIDI_BASE_NOTE
	TagMinimumBitrate               Tag = C.GST_TAG_MINIMUM_BITRATE
	TagNominalBitrate               Tag = C.GST_TAG_NOMINAL_BITRATE
	TagOrganization                 Tag = C.GST_TAG_ORGANIZATION
	TagPerformer                    Tag = C.GST_TAG_PERFORMER
	TagPreviewImage                 Tag = C.GST_TAG_PREVIEW_IMAGE
	TagPrivateData                  Tag = C.GST_TAG_PRIVATE_DATA
	TagPublisher                    Tag = C.GST_TAG_PUBLISHER
	TagReferenceLevel               Tag = C.GST_TAG_REFERENCE_LEVEL
	TagSerial                       Tag = C.GST_TAG_SERIAL
	TagShowEpisodeNumber            Tag = C.GST_TAG_SHOW_EPISODE_NUMBER
	TagShowName                     Tag = C.GST_TAG_SHOW_NAME
	TagShowSeasonNumber             Tag = C.GST_TAG_SHOW_SEASON_NUMBER
	TagShowSortName                 Tag = C.GST_TAG_SHOW_SORTNAME
	TagSubtitleCodec                Tag = C.GST_TAG_SUBTITLE_CODEC
	TagTitle                        Tag = C.GST_TAG_TITLE
	TagTitleSortName                Tag = C.GST_TAG_TITLE_SORTNAME
	TagTrackCount                   Tag = C.GST_TAG_TRACK_COUNT
	TagTrackGain                    Tag = C.GST_TAG_TRACK_GAIN
	TagTrackNumber                  Tag = C.GST_TAG_TRACK_NUMBER
	TagTrackPeak                    Tag = C.GST_TAG_TRACK_PEAK
	TagUserRating                   Tag = C.GST_TAG_USER_RATING
	TagVersion                      Tag = C.GST_TAG_VERSION
	TagVideoCodec                   Tag = C.GST_TAG_VIDEO_CODEC
)

Type castings of Tags For more information see: https://gstreamer.freedesktop.org/documentation/gstreamer/gsttaglist.html?gi-language=c#constants

type TagFlag

type TagFlag int

TagFlag represents a GstTagFlag

const (
	TagFlagUndefined TagFlag = C.GST_TAG_FLAG_UNDEFINED // (0) – undefined flag
	TagFlagMeta      TagFlag = C.GST_TAG_FLAG_META      // (1) – tag is meta data
	TagFlagEncoded   TagFlag = C.GST_TAG_FLAG_ENCODED   // (2) – tag is encoded
	TagFlagDecoded   TagFlag = C.GST_TAG_FLAG_DECODED   // (3) – tag is decoded
	TagFlagCount     TagFlag = C.GST_TAG_FLAG_COUNT     // (4) – number of tag flags
)

Type castins of TagFlags

type TagList

type TagList struct {
	// contains filtered or unexported fields
}

TagList is a go wrapper around a GstTagList. For now, until the rest of the methods are implemnented, this struct is primarily used for retrieving serialized copies of the tags.

func FromGstTagListUnsafeFull

func FromGstTagListUnsafeFull(tags unsafe.Pointer) *TagList

FromGstTagListUnsafeFull wraps the pointer to the given C GstTagList with the go type. This is meant for internal usage and is exported for visibility to other packages.

func FromGstTagListUnsafeNone

func FromGstTagListUnsafeNone(tags unsafe.Pointer) *TagList

FromGstTagListUnsafeNone wraps the pointer to the given C GstTagList with the go type. This is meant for internal usage and is exported for visibility to other packages.

func NewEmptyTagList

func NewEmptyTagList() *TagList

NewEmptyTagList returns a new empty tag list.

tagList := gst.NewEmptyTagList()
fmt.Println(tagList.IsEmpty())
// true

func NewTagListFromString

func NewTagListFromString(tags string) *TagList

NewTagListFromString creates a new tag list from the given string. This is the same format produced by the stringer interface on the TagList.

func (*TagList) AddValue

func (t *TagList) AddValue(mergeMode TagMergeMode, tag Tag, value interface{})

AddValue adds a value to a given tag using the given merge mode. If the value provided cannot be coerced to a GValue, nothing will happen.

tagList := gst.NewEmptyTagList()
tagList.AddValue(gst.TagMergeAppend, gst.TagAlbum, "MyNewAlbum")
myAlbum, _ := tagList.GetString(gst.TagAlbum)
fmt.Println(myAlbum)
// MyNewAlbum

func (*TagList) AddValues

func (t *TagList) AddValues(mergeMode TagMergeMode, tag Tag, vals ...interface{})

AddValues can be used to add multiple values to a tag with the given merge mode. Values that cannot be coerced to C types will be ignored.

func (*TagList) Copy

func (t *TagList) Copy() *TagList

Copy creates a new TagList as a copy of the old taglist. The new taglist will have a refcount of 1, owned by the caller, and will be writable as a result.

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 taglist, call Unref on it.

func (*TagList) ForEach

func (t *TagList) ForEach(f TagListForEachFunc)

ForEach calls the given function for each tag inside the tag list. Note that if there is no tag, the function won't be called at all.

tagList := gst.NewEmptyTagList()

tagList.AddValue(gst.TagMergeAppend, gst.TagAlbumArtist, "tinyzimmer")
tagList.AddValue(gst.TagMergeAppend, gst.TagAlbum, "GstreamerInGo")

tagList.ForEach(func(_ *gst.TagList, tag gst.Tag) {
    val, _ := tagList.GetString(tag)
    fmt.Println(tag, ":", val)
})

// album-artist : tinyzimmer
// album : GstreamerInGo

func (*TagList) GetBool

func (t *TagList) GetBool(tag Tag) (value, ok bool)

GetBool returns the boolean value at the given tag key. If multiple values are associated with the tag they are merged.

func (*TagList) GetBoolIndex

func (t *TagList) GetBoolIndex(tag Tag, idx uint) (value, ok bool)

GetBoolIndex retrieves the bool at the given index in the tag key.

func (*TagList) GetDate

func (t *TagList) GetDate(tag Tag) (value time.Time, ok bool)

GetDate returns the date stored at the given tag key. If there are multiple values, the first one is returned.

func (*TagList) GetDateIndex

func (t *TagList) GetDateIndex(tag Tag, idx uint) (value time.Time, ok bool)

GetDateIndex returns the date stored at the given index in tag key.

func (*TagList) GetDateTime

func (t *TagList) GetDateTime(tag Tag) (value time.Time, ok bool)

GetDateTime returns the date and time stored at the given tag key. If there are multiple values, the first one is returned.

func (*TagList) GetDateTimeIndex

func (t *TagList) GetDateTimeIndex(tag Tag, idx uint) (value time.Time, ok bool)

GetDateTimeIndex returns the date and time stored at the given tag key at the given index.

func (*TagList) GetFloat32

func (t *TagList) GetFloat32(tag Tag) (value float32, ok bool)

GetFloat32 returns the float at the given tag key, merging multiple values into one if multiple values are associated with the tag.

func (*TagList) GetFloat32Index

func (t *TagList) GetFloat32Index(tag Tag, idx uint) (value float32, ok bool)

GetFloat32Index returns the float at the index of the given tag key.

func (*TagList) GetFloat64

func (t *TagList) GetFloat64(tag Tag) (value float64, ok bool)

GetFloat64 returns the float at the given tag key, merging multiple values into one if multiple values are associated with the tag. This is the equivalent of a C double stored in the tag.

func (*TagList) GetFloat64Index

func (t *TagList) GetFloat64Index(tag Tag, idx uint) (value float64, ok bool)

GetFloat64Index returns the float at the index of the given tag key.

func (*TagList) GetInt32

func (t *TagList) GetInt32(tag Tag) (value int32, ok bool)

GetInt32 returns the integer at the given tag key, merging multiple values into one if multiple values are associated with the tag.

func (*TagList) GetInt32Index

func (t *TagList) GetInt32Index(tag Tag, idx uint) (value int32, ok bool)

GetInt32Index returns the integer at the index of the given tag key.

func (*TagList) GetInt64

func (t *TagList) GetInt64(tag Tag) (value int64, ok bool)

GetInt64 returns the integer at the given tag key, merging multiple values into one if multiple values are associated with the tag.

func (*TagList) GetInt64Index

func (t *TagList) GetInt64Index(tag Tag, idx uint) (value int64, ok bool)

GetInt64Index returns the integer at the index of the given tag key.

func (*TagList) GetPointer

func (t *TagList) GetPointer(tag Tag) (value unsafe.Pointer, ok bool)

GetPointer returns the C pointer stored at the given tag key, merging values if there are multiple.

func (*TagList) GetPointerIndex

func (t *TagList) GetPointerIndex(tag Tag, idx uint) (value unsafe.Pointer, ok bool)

GetPointerIndex returns the C pointer stored at the given tag key index.

func (*TagList) GetSample

func (t *TagList) GetSample(tag Tag) (value *Sample, ok bool)

GetSample copies the first sample for the given tag in the taglist. Free the sample with Unref when it is no longer needed.

func (*TagList) GetSampleIndex

func (t *TagList) GetSampleIndex(tag Tag, idx uint) (value *Sample, ok bool)

GetSampleIndex copies the sample for the given index in tag in the taglist. Free the sample with Unref when it is no longer needed.

func (*TagList) GetScope

func (t *TagList) GetScope() TagScope

GetScope returns the scope for this TagList.

func (*TagList) GetString

func (t *TagList) GetString(tag Tag) (value string, ok bool)

GetString returns the string for the given tag, possibly merging multiple values into one.

func (*TagList) GetStringIndex

func (t *TagList) GetStringIndex(tag Tag, idx uint) (value string, ok bool)

GetStringIndex returns the string for the given index in tag.

func (*TagList) GetTagSize

func (t *TagList) GetTagSize(tagKey string) int

GetTagSize returns the number of tag values at the given tag key.

func (*TagList) GetUint32

func (t *TagList) GetUint32(tag Tag) (value uint32, ok bool)

GetUint32 returns the unsigned integer at the given tag key, merging multiple values into one if multiple values are associated with the tag.

func (*TagList) GetUint32Index

func (t *TagList) GetUint32Index(tag Tag, idx uint) (value uint32, ok bool)

GetUint32Index returns the unsigned integer at the index of the given tag key.

func (*TagList) GetUint64

func (t *TagList) GetUint64(tag Tag) (value uint64, ok bool)

GetUint64 returns the unsigned integer at the given tag key, merging multiple values into one if multiple values are associated with the tag.

func (*TagList) GetUint64Index

func (t *TagList) GetUint64Index(tag Tag, idx uint) (value uint64, ok bool)

GetUint64Index returns the unsigned integer at the index of the given tag key.

func (*TagList) GetValueIndex

func (t *TagList) GetValueIndex(tag Tag, idx uint) interface{}

GetValueIndex retrieves the GValue at the given index in tag, or nil if none exists. Note that this function can also return nil if the stored value cannot be cleanly coerced to a go type. It is safer to use the other functions provided when you know the expected return type.

func (*TagList) Insert

func (t *TagList) Insert(tagList *TagList, mergeMode TagMergeMode)

Insert inserts the tags from the provided list using the given merge mode.

func (*TagList) Instance

func (t *TagList) Instance() *C.GstTagList

Instance returns the underlying GstTagList instance.

func (*TagList) IsEmpty

func (t *TagList) IsEmpty() bool

IsEmpty returns true if this tag list is empty.

func (*TagList) IsEqual

func (t *TagList) IsEqual(tagList *TagList) bool

IsEqual checks if the two tag lists are equal.

func (*TagList) IsWritable

func (t *TagList) IsWritable() bool

IsWritable returns true if this TagList is writable.

func (*TagList) MakeWritable

func (t *TagList) MakeWritable() *TagList

MakeWritable will return a writable copy of the tag list if it is not already so.

func (*TagList) Merge

func (t *TagList) Merge(tagList *TagList, mergeMode TagMergeMode) *TagList

Merge merges the two tag lists with the given mode.

func (*TagList) NumTags

func (t *TagList) NumTags() int

NumTags returns the number of key/value pairs in ths TagList

func (*TagList) PeekStringIndex

func (t *TagList) PeekStringIndex(tag Tag, idx uint) (value string, ok bool)

PeekStringIndex peeks at the value that is at the given index for the given tag in the given list.

func (*TagList) Ref

func (t *TagList) Ref() *TagList

Ref increases the ref count on this TagList by one.

func (*TagList) RemoveTag

func (t *TagList) RemoveTag(tag Tag)

RemoveTag removes the values for the given tag in this list.

func (*TagList) SetScope

func (t *TagList) SetScope(scope TagScope)

SetScope sets the scope of this TagList. By default, the scope of a tag list is stream scope.

func (*TagList) String

func (t *TagList) String() string

String implements a stringer on the TagList and serializes it to a string.

func (*TagList) TagNameAt

func (t *TagList) TagNameAt(idx int) string

TagNameAt returns the tag name at the given index.

func (*TagList) Unref

func (t *TagList) Unref()

Unref decreses the ref count on this TagList by one. When the ref count reaches zero, the object is destroyed.

type TagListForEachFunc

type TagListForEachFunc func(tagList *TagList, tag Tag)

TagListForEachFunc is a function that will be called in ForEach. The function may not modify the tag list.

type TagMergeMode

type TagMergeMode int

TagMergeMode represents a GstTagMergeMode. See: https://gstreamer.freedesktop.org/documentation/gstreamer/gsttaglist.html#GstTagMergeMode

const (
	TagMergeUndefined  TagMergeMode = C.GST_TAG_MERGE_UNDEFINED   // (0) – undefined merge mode
	TagMergeReplaceAll TagMergeMode = C.GST_TAG_MERGE_REPLACE_ALL // (1) – replace all tags (clear list and append)
	TagMergeReplace    TagMergeMode = C.GST_TAG_MERGE_REPLACE     // (2) – replace tags
	TagMergeAppend     TagMergeMode = C.GST_TAG_MERGE_APPEND      // (3) – append tags
	TagMergePrepend    TagMergeMode = C.GST_TAG_MERGE_PREPEND     // (4) – prepend tags
	TagMergeKeep       TagMergeMode = C.GST_TAG_MERGE_KEEP        // (5) – keep existing tags
	TagMergeKeepAll    TagMergeMode = C.GST_TAG_MERGE_KEEP_ALL    // (6) – keep all existing tags
	TagMergeCount      TagMergeMode = C.GST_TAG_MERGE_COUNT       // (7) – the number of merge modes
)

Type castings of TagMergeModes

type TagScope

type TagScope int

TagScope represents a GstTagScope

const (
	TagScopeStream TagScope = C.GST_TAG_SCOPE_STREAM // (0) – tags specific to this single stream
	TagScopeGlobal TagScope = C.GST_TAG_SCOPE_GLOBAL // (1) – global tags for the complete medium
)

Type castings of tag scopes

type TagSetter

type TagSetter interface {
	// Returns the current list of tags the setter uses. The list should not be modified or freed.
	GetTagList() *TagList
	// Adds the given tag/value pair using the given merge mode. If the tag value cannot be coerced
	// to a GValue when dealing with C elements, nothing will happen.
	AddTagValue(mergeMode TagMergeMode, tagKey Tag, tagValue interface{})
	// Merges a tag list with the given merge mode
	MergeTags(*TagList, TagMergeMode)
	// Resets the internal tag list. Elements should call this from within the state-change handler.
	ResetTags()
	// Queries the mode by which tags inside the setter are overwritten by tags from events
	GetTagMergeMode() TagMergeMode
	// Sets the given merge mode that is used for adding tags from events to tags specified by this interface.
	// The default is TagMergeKeep, which keeps the tags set with this interface and discards tags from events.
	SetTagMergeMode(TagMergeMode)
}

TagSetter is an interface that elements can implement to provide Tag writing capabilities.

type TaskState

type TaskState int

TaskState casts GstTaskState

const (
	TaskStarted TaskState = C.GST_TASK_STARTED // (0) – the task is started and running
	TaskStopped TaskState = C.GST_TASK_STOPPED // (1) – the task is stopped
	TaskPaused  TaskState = C.GST_TASK_PAUSED  // (2) – the task is paused
)

Type castings

type TypeFindProbability

type TypeFindProbability int

TypeFindProbability represents a probability for type find functions. Higher values reflect higher certainty.

const (
	TypeFindNone          TypeFindProbability = C.GST_TYPE_FIND_NONE           // (0) – type undetected.
	TypeFindMinimum       TypeFindProbability = C.GST_TYPE_FIND_MINIMUM        // (1) – unlikely typefind.
	TypeFindPossible      TypeFindProbability = C.GST_TYPE_FIND_POSSIBLE       // (50) – possible type detected.
	TypeFindLikely        TypeFindProbability = C.GST_TYPE_FIND_LIKELY         // (80) – likely a type was detected.
	TypeFindNearlyCertain TypeFindProbability = C.GST_TYPE_FIND_NEARLY_CERTAIN // (99) – nearly certain that a type was detected.
	TypeFindMaximum       TypeFindProbability = C.GST_TYPE_FIND_MAXIMUM        // (100) – very certain a type was detected.
)

Type castings

type URIHandler

type URIHandler interface {
	// GetURI gets the currently handled URI.
	GetURI() string
	// GetURIType returns the type of URI this element can handle.
	GetURIType() URIType
	// GetProtocols returns the protocols this element can handle.
	GetProtocols() []string
	// SetURI tries to set the URI of the given handler.
	SetURI(string) (bool, error)
}

URIHandler represents an interface that elements can implement to provide URI handling capabilities.

type URIType

type URIType int

URIType casts C GstURIType to a go type

const (
	URIUnknown URIType = C.GST_URI_UNKNOWN // (0) – The URI direction is unknown
	URISink    URIType = C.GST_URI_SINK    // (1) – The URI is a consumer.
	URISource  URIType = C.GST_URI_SRC     // (2) - The URI is a producer.
)

Type cast URI types

func (URIType) String

func (u URIType) String() string

type ValueArrayValue

type ValueArrayValue glib.Value

ValueArrayValue represets a GstValueArray.

func ValueArray

func ValueArray(ss []interface{}) *ValueArrayValue

ValueArray converts the given slice of Go types into a ValueArrayValue. This function can return nil on any conversion or memory allocation errors.

func (*ValueArrayValue) Size

func (v *ValueArrayValue) Size() uint

Size returns the size of the array.

func (*ValueArrayValue) ToGValue

func (v *ValueArrayValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

func (*ValueArrayValue) ValueAt

func (v *ValueArrayValue) ValueAt(idx uint) interface{}

ValueAt returns the value at the index in the array, or nil on any error.

type ValueCmp

type ValueCmp int

ValueCmp represents the result of comparing two values.

const (
	ValueEqual       ValueCmp = C.GST_VALUE_EQUAL        // Indicates that the first value provided to a comparison function (ValueCompare) is equal to the second one.
	ValueGreaterThan ValueCmp = C.GST_VALUE_GREATER_THAN // Indicates that the first value provided to a comparison function (ValueCompare) is greater than the second one.
	ValueLessThan    ValueCmp = C.GST_VALUE_LESS_THAN    // Indicates that the first value provided to a comparison function (ValueCompare) is lesser than the second one.
	ValueUnordered   ValueCmp = C.GST_VALUE_UNORDERED    // Indicates that the comparison function (ValueCompare) can not determine a order for the two provided values.

)

ValueCmp castings

func ValueCompare

func ValueCompare(value1, value2 *glib.Value) ValueCmp

ValueCompare compares value1 and value2. If value1 and value2 cannot be compared, the function returns ValueUnordered. Otherwise, if value1 is greater than value2, ValueGreaterThan is returned. If value1 is less than value2, ValueLessThan is returned. If the values are equal, ValueEqual is returned.

type ValueListValue

type ValueListValue glib.Value

ValueListValue represets a GstValueList.

func ValueList

func ValueList(ss []interface{}) *ValueListValue

ValueList converts the given slice of Go types into a ValueListValue. This function can return nil on any conversion or memory allocation errors.

func (*ValueListValue) Concat

func (v *ValueListValue) Concat(value *ValueListValue) *ValueListValue

Concat concatenates copies of this list and value into a new list. Values that are not of type TypeValueList are treated as if they were lists of length 1. dest will be initialized to the type TypeValueList.

func (*ValueListValue) Merge

func (v *ValueListValue) Merge(value *ValueListValue) *ValueListValue

Merge merges copies of value into this list. Values that are not of type TypeValueList are treated as if they were lists of length 1.

The result will be put into a new value and will either be a list that will not contain any duplicates, or a non-list type (if the lists were equal).

func (*ValueListValue) Size

func (v *ValueListValue) Size() uint

Size returns the size of the list.

func (*ValueListValue) ToGValue

func (v *ValueListValue) ToGValue() (*glib.Value, error)

ToGValue implements a glib.ValueTransformer.

func (*ValueListValue) ValueAt

func (v *ValueListValue) ValueAt(idx uint) interface{}

ValueAt returns the value at the index in the lise, or nil on any error.

type Version

type Version int

Version represents information about the current GST version.

const (
	// VersionMajor is the major version number of the GStreamer core.
	VersionMajor Version = C.GST_VERSION_MAJOR
	// VersionMinor is the minor version number of the GStreamer core.
	VersionMinor Version = C.GST_VERSION_MINOR
)

Directories

Path Synopsis
Package app contains bindings for the gstreamer-app C API.
Package app contains bindings for the gstreamer-app C API.
Package audio contains bindings for the gstaudio C API.
Package audio contains bindings for the gstaudio C API.
Package base contains bindings for extendable GStreamer base objects.
Package base contains bindings for extendable GStreamer base objects.
Package pbutils contains bindings for libgstpbutils.
Package pbutils contains bindings for libgstpbutils.
Package rtp contains bindings for the GStreamer RTP library.
Package rtp contains bindings for the GStreamer RTP library.
Package video contains bindings for the gstvideo C API.
Package video contains bindings for the gstvideo C API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL