gst

package

Go to main page

Versions in this module

v1

v1.3.6

Oct 2, 2024

Changes in this version

+ type GstObjectHolder interface

+ GstObject func() *C.GstObject

v1.3.5

Sep 13, 2024

Changes in this version

type Element

+ func (e *Element) PostMessage(message *Message) bool

+ func (e *Element) SetFlags(flags ElementFlags)

+ func (e *Element) UnsetFlags(flags ElementFlags)

type Pad

+ func (p *Pad) Has(flags PadFlags) bool

+ func (p *Pad) SetFlags(flags PadFlags)

+ func (p *Pad) UnsetFlags(flags PadFlags)

+ type Unsafer interface

+ Unsafe func() unsafe.Pointer

v1.3.4

Sep 13, 2024

Changes in this version

type Element

+ func (e *Element) ParentSendEvent(event *Event) bool

v1.3.3

Sep 12, 2024

v1.3.2

Sep 12, 2024

v1.3.1

Sep 12, 2024

v1.3.0

Sep 11, 2024

v1.2.3

Sep 6, 2024

v1.2.2

Sep 6, 2024

Changes in this version

+ const ParameterControllable

+ const ParameterMutablePaused

+ const ParameterMutablePlaying

+ const ParameterMutableReady

+ const PromiseResultExpired

+ const PromiseResultInterrupted

+ const PromiseResultPending

+ const PromiseResultReplied

+ var CapsFeatureMemorySystemMemory string = C.GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY

+ var ErrCannotAwaitPromise = errors.New("promises received from FFI cannot be awaited")

+ var ErrNilPromiseReply = errors.New("promise returned a nil reply")

+ var ErrPromiseNotReplied = errors.New("promise was not replied")

+ var ExtendsBin glib.Extendable = &extendsBin

+ var ExtendsElement glib.Extendable = &extendElement

+ var InterfaceChildProxy glib.Interface = &interfaceChildProxy

+ var InterfaceTOCSetter = glib.Type(C.GST_TYPE_TOC_SETTER)

+ var InterfaceTagSetter glib.Interface = &interfaceTagSetter

+ var InterfaceURIHandler glib.Interface = &interfaceURIHandler

+ var TypeBitmask = glib.Type(C.gst_bitmask_get_type())

+ var TypeCaps = glib.Type(C.gst_caps_get_type())

+ var TypeCapsFeatures = glib.Type(C.gst_caps_features_get_type())

+ var TypeFlagset = glib.Type(C.gst_flagset_get_type())

+ var TypeFloat64Range = glib.Type(C.gst_double_range_get_type())

+ var TypeFraction = glib.Type(C.gst_fraction_get_type())

+ var TypeFractionRange = glib.Type(C.gst_fraction_range_get_type())

+ var TypeInt64Range = glib.Type(C.gst_int64_range_get_type())

+ var TypeIntRange = glib.Type(C.gst_int_range_get_type())

+ var TypePromise = glib.Type(C.GST_TYPE_PROMISE)

+ var TypeStructure = glib.Type(C.gst_structure_get_type())

+ var TypeValueArray = glib.Type(C.gst_value_array_get_type())

+ var TypeValueList = glib.Type(C.gst_value_list_get_type())

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

+ func Deinit()

+ func ElementLinkMany(elems ...*Element) error

+ func ElementUnlinkMany(elems ...*Element)

+ func FilterProtectionSystemByDecryptors(decryptors []string) []string

+ func GetAPITags(apiType glib.Type) []string

+ func GetMaxBufferMemory() uint64

+ func Init(args *[]string)

+ func NextGroupID() uint

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

+ func RegisterElement(plugin *Plugin, name string, rank Rank, elem glib.GoObjectSubclass, ...) bool

+ func RegisterPlugin(desc *PluginMetadata, initFunc PluginInitFunc) bool

+ func SelectProtectionSystem(decryptors []string) string

+ func SetLogFunction(f LogFunction)

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

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

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

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

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

+ func ValueIsFixed(value *glib.Value) bool

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

+ func ValueSerialize(value *glib.Value) string

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

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

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

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

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

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

+ type AllocationParams struct

+ func FromGstAllocationParamsUnsafe(alloc unsafe.Pointer) *AllocationParams

+ func NewAllocationParams() *AllocationParams

+ func (a *AllocationParams) Copy() *AllocationParams

+ func (a *AllocationParams) Free()

+ func (a *AllocationParams) GetAlignment() int64

+ func (a *AllocationParams) GetFlags() MemoryFlags

+ func (a *AllocationParams) GetPadding() int64

+ func (a *AllocationParams) GetPrefix() int64

+ func (a *AllocationParams) Init()

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

+ func (a *AllocationParams) SetAlignment(align int64)

+ func (a *AllocationParams) SetFlags(flags MemoryFlags)

+ func (a *AllocationParams) SetPadding(padding int64)

+ func (a *AllocationParams) SetPrefix(prefix int64)

+ type Allocator struct

+ func DefaultAllocator() *Allocator

+ func FromGstAllocatorUnsafeFull(alloc unsafe.Pointer) *Allocator

+ func FromGstAllocatorUnsafeNone(alloc unsafe.Pointer) *Allocator

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

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

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

+ func (a *Allocator) MemType() string

+ type Bin struct

+ func NewBin(name string) *Bin

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

+ func ToGstBin(obj interface{}) *Bin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (b *Bin) GetSuppressedFlags() ElementFlags

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

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

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

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

+ func (b *Bin) ParentDoLatency() bool

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

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

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

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

+ func (b *Bin) RecalculateLatency() bool

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

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

+ func (b *Bin) SetSuppressedFlags(flags ElementFlags)

+ func (b *Bin) SyncChildrenStates() bool

+ type BinImpl interface

+ AddElement func(self *Bin, element *Element) bool

+ DeepElementAdded func(self *Bin, subbin *Bin, child *Element)

+ DeepElementRemoved func(self *Bin, subbin *Bin, child *Element)

+ DoLatency func(self *Bin) bool

+ ElementAdded func(self *Bin, child *Element)

+ ElementRemoved func(self *Bin, child *Element)

+ HandleMessage func(self *Bin, msg *Message)

+ RemoveElement func(self *Bin, element *Element) bool

+ type Bitmask uint64

+ func ValueGetBitmask(value *glib.Value) Bitmask

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

+ type Buffer struct

+ func FromGstBufferUnsafeFull(buf unsafe.Pointer) *Buffer

+ func FromGstBufferUnsafeNone(buf unsafe.Pointer) *Buffer

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

+ func NewBufferFromBytes(b []byte) *Buffer

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

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

+ func NewBufferWithSize(size int64) *Buffer

+ func NewEmptyBuffer() *Buffer

+ func ToGstBuffer(buf unsafe.Pointer) *Buffer

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

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

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

+ func (b *Buffer) AddReferenceTimestampMeta(ref *Caps, timestamp, duration ClockTime) *ReferenceTimestampMeta

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

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

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

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

+ func (b *Buffer) Copy() *Buffer

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

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

+ func (b *Buffer) DecodingTimestamp() ClockTime

+ func (b *Buffer) DeepCopy() *Buffer

+ func (b *Buffer) Duration() ClockTime

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

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

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

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

+ func (b *Buffer) GetAllMemory() *Memory

+ func (b *Buffer) GetFlags() BufferFlags

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

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

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

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

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

+ func (b *Buffer) GetSize() int64

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

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

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

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

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

+ func (b *Buffer) IsAllMemoryWritable() bool

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

+ func (b *Buffer) IsWritable() bool

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

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

+ func (b *Buffer) MakeWritable() *Buffer

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

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

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

+ func (b *Buffer) NumMemoryBlocks() uint

+ func (b *Buffer) Offset() int64

+ func (b *Buffer) OffsetEnd() int64

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

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

+ func (b *Buffer) PresentationTimestamp() ClockTime

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

+ func (b *Buffer) Ref() *Buffer

+ func (b *Buffer) RemoveAllMemory()

+ func (b *Buffer) RemoveMemoryAt(idx uint)

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

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

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

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

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

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

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

+ func (b *Buffer) SetDuration(dur ClockTime)

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

+ func (b *Buffer) SetPresentationTimestamp(dur ClockTime)

+ func (b *Buffer) SetSize(size int64)

+ func (b *Buffer) Unmap()

+ func (b *Buffer) Unref()

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

+ type BufferCopyFlags int

+ const BufferCopyBufferFlags

+ const BufferCopyDeep

+ const BufferCopyMemory

+ const BufferCopyMerge

+ const BufferCopyMeta

+ const BufferCopyNone

+ const BufferCopyTimestamps

+ type BufferFlags int

+ const BufferFlagCorrupted

+ const BufferFlagDecodeOnly

+ const BufferFlagDeltaUnit

+ const BufferFlagDiscont

+ const BufferFlagDroppable

+ const BufferFlagGap

+ const BufferFlagHeader

+ const BufferFlagLast

+ const BufferFlagLive

+ const BufferFlagMarker

+ const BufferFlagNonDroppable

+ const BufferFlagResync

+ const BufferFlagSyncAfter

+ type BufferList struct

+ func FromGstBufferListUnsafeFull(buf unsafe.Pointer) *BufferList

+ func FromGstBufferListUnsafeNone(buf unsafe.Pointer) *BufferList

+ func NewBufferList(buffers []*Buffer) *BufferList

+ func NewBufferListSized(size uint) *BufferList

+ func ToGstBufferList(buf unsafe.Pointer) *BufferList

+ func (b *BufferList) CalculateSize() int64

+ func (b *BufferList) Copy() *BufferList

+ func (b *BufferList) DeepCopy() *BufferList

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

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

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

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

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

+ func (b *BufferList) IsWritable() bool

+ func (b *BufferList) Length() uint

+ func (b *BufferList) MakeWritable() *BufferList

+ func (b *BufferList) Ref() *BufferList

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

+ func (b *BufferList) Unref()

+ type BufferPool struct

+ func FromGstBufferPoolUnsafeFull(bufferPool unsafe.Pointer) *BufferPool

+ func FromGstBufferPoolUnsafeNone(bufferPool unsafe.Pointer) *BufferPool

+ func NewBufferPool() *BufferPool

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

+ func (b *BufferPool) GetConfig() *BufferPoolConfig

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

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

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

+ func (b *BufferPool) IsActive() bool

+ func (b *BufferPool) IsFlushing() bool

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

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

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

+ func (b *BufferPool) SetFlushing(flushing bool)

+ type BufferPoolAcquireFlags int

+ const BufferPoolAcquireFlagDiscont

+ const BufferPoolAcquireFlagDontWait

+ const BufferPoolAcquireFlagKeyUnit

+ const BufferPoolAcquireFlagLast

+ const BufferPoolAcquireFlagNone

+ type BufferPoolAcquireParams struct

+ Flags BufferPoolAcquireFlags

+ Format Format

+ Start int64

+ Stop int64

+ type BufferPoolConfig struct

+ func (b *BufferPoolConfig) AddOption(opt string)

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

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

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

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

+ func (b *BufferPoolConfig) NumOptions() uint

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

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

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

+ type BufferingMode int

+ const BufferingDownload

+ const BufferingLive

+ const BufferingStream

+ const BufferingTimeshift

+ func (b BufferingMode) String() string

+ type BufferingStats struct

+ AverageIn int

+ AverageOut int

+ BufferingLeft time.Duration

+ BufferingMode BufferingMode

+ type Bus struct

+ func FromGstBusUnsafeFull(bus unsafe.Pointer) *Bus

+ func FromGstBusUnsafeNone(bus unsafe.Pointer) *Bus

+ func NewBus() *Bus

+ func (b *Bus) AddSignalWatch()

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

+ func (b *Bus) BlockPopMessage() *Message

+ func (b *Bus) DisableSyncMessageEmission()

+ func (b *Bus) EnableSyncMessageEmission()

+ func (b *Bus) GetPollFd() *PollFd

+ func (b *Bus) HavePending() bool

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

+ func (b *Bus) Peek() *Message

+ func (b *Bus) Poll(msgTypes MessageType, timeout ClockTime) *Message

+ func (b *Bus) Pop() *Message

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

+ func (b *Bus) PopMessage(timeout ClockTime) *Message

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

+ func (b *Bus) RemoveSignalWatch()

+ func (b *Bus) RemoveWatch() bool

+ func (b *Bus) SetFlushing(flushing bool)

+ func (b *Bus) SetSyncHandler(f BusSyncHandler)

+ func (b *Bus) TimedPop(dur ClockTime) *Message

+ func (b *Bus) TimedPopFiltered(dur ClockTime, msgTypes MessageType) *Message

+ type BusSyncHandler func(msg *Message) BusSyncReply

+ type BusSyncReply int

+ const BusAsync

+ const BusDrop

+ const BusPass

+ type BusWatchFunc func(msg *Message) bool

+ type Caps struct

+ func FromGstCapsUnsafeFull(caps unsafe.Pointer) *Caps

+ func FromGstCapsUnsafeNone(caps unsafe.Pointer) *Caps

+ func NewAnyCaps() *Caps

+ func NewCapsFromString(capsStr string) *Caps

+ func NewEmptyCaps() *Caps

+ func NewEmptySimpleCaps(mediaFormat string) *Caps

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

+ func ToGstCaps(caps unsafe.Pointer) *Caps

+ func ValueGetCaps(value *glib.Value) *Caps

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

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

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

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

+ func (c *Caps) Copy() *Caps

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

+ func (c *Caps) FilterAndMapInPlace(f CapsMapFunc)

+ func (c *Caps) Fixate() *Caps

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

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

+ func (c *Caps) GetSize() int

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

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

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

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

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

+ func (c *Caps) IsAny() bool

+ func (c *Caps) IsEmpty() bool

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

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

+ func (c *Caps) IsFixed() bool

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

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

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

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

+ func (c *Caps) IsWritable() bool

+ func (c *Caps) MakeWritable() *Caps

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

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

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

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

+ func (c *Caps) Normalize() *Caps

+ func (c *Caps) Ref() *Caps

+ func (c *Caps) RemoveStructureAt(idx uint)

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

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

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

+ func (c *Caps) Simplify() *Caps

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

+ func (c *Caps) String() string

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

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

+ func (c *Caps) Truncate() *Caps

+ func (c *Caps) Unref()

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

+ type CapsFeatures struct

+ func NewCapsFeaturesAny() *CapsFeatures

+ func NewCapsFeaturesEmpty() *CapsFeatures

+ func NewCapsFeaturesFromString(features string) *CapsFeatures

+ func ValueGetCapsFeatures(value *glib.Value) *CapsFeatures

+ func (c *CapsFeatures) Add(feature string)

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

+ func (c *CapsFeatures) Copy() *CapsFeatures

+ func (c *CapsFeatures) Free()

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

+ func (c *CapsFeatures) GetSize() uint

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

+ func (c *CapsFeatures) IsAny() bool

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

+ func (c *CapsFeatures) Remove(feature string)

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

+ func (c *CapsFeatures) String() string

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

+ type CapsIntersectMode int

+ const CapsIntersectFirst

+ const CapsIntersectZigZag

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

+ type ChildProxy struct

+ func ToChildProxy(elem *Element) *ChildProxy

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

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

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

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

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

+ func (c *ChildProxy) GetChildrenCount() uint

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

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

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

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

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

+ type ChildProxyImpl interface

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

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

+ GetChildByIndex func(self *ChildProxy, idx uint) *glib.Object

+ GetChildByName func(self *ChildProxy, name string) *glib.Object

+ GetChildrenCount func(self *ChildProxy) uint

+ type Clock struct

+ func FromGstClockUnsafeFull(clock unsafe.Pointer) *Clock

+ func FromGstClockUnsafeNone(clock unsafe.Pointer) *Clock

+ func (c *Clock) AddObservation(slaveTime, masterTime ClockTime) (bool, float64)

+ func (c *Clock) AddObservationUnapplied(slaveTime, masterTime ClockTime) (ok bool, rSquared float64, ...)

+ func (c *Clock) AdjustUnlocked(internal ClockTime) ClockTime

+ func (c *Clock) AdjustWithCalibration(internalTarget, cinternal, cexternal, cnum, cdenom ClockTime) ClockTime

+ func (c *Clock) GetCalibration() (internal, external, rateNum, rateDenom ClockTime)

+ func (c *Clock) GetInternalTime() ClockTime

+ func (c *Clock) GetMaster() *Clock

+ func (c *Clock) GetResolution() ClockTime

+ func (c *Clock) GetTime() ClockTime

+ func (c *Clock) GetTimeout() ClockTime

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

+ func (c *Clock) InternalString() string

+ func (c *Clock) IsSynced() bool

+ func (c *Clock) NewPeriodicID(startTime, interval ClockTime) *ClockID

+ func (c *Clock) NewSingleShotID(at ClockTime) *ClockID

+ func (c *Clock) PeriodicIDReinit(clockID *ClockID, startTime, interval ClockTime) bool

+ func (c *Clock) SetCalibration(internal, external, rateNum, rateDenom ClockTime)

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

+ func (c *Clock) SetResolution(resolution ClockTime) ClockTime

+ func (c *Clock) SetSynced(synced bool)

+ func (c *Clock) SetTimeout(timeout ClockTime)

+ func (c *Clock) SingleShotIDReinit(clockID *ClockID, at ClockTime) bool

+ func (c *Clock) String() string

+ func (c *Clock) UnadjustUnlocked(external ClockTime) ClockTime

+ func (c *Clock) UnadjustWithCalibration(externalTarget, cinternal, cexternal, cnum, cdenom ClockTime) ClockTime

+ func (c *Clock) WaitForSync(timeout ClockTime) bool

+ type ClockCallback func(clock *Clock, clockTime ClockTime) bool

+ type ClockEntryType int

+ const ClockEntryPeriodic

+ const ClockEntrySingle

+ type ClockFlags int

+ const ClockFlagCanDoPeriodicAsync

+ const ClockFlagCanDoPeriodicSync

+ const ClockFlagCanDoSingleAsync

+ const ClockFlagCanDoSingleSync

+ const ClockFlagCanSetMaster

+ const ClockFlagCanSetResolution

+ const ClockFlagLast

+ const ClockFlagNeedsStartupSync

+ type ClockID struct

+ func (c *ClockID) GetClock() *Clock

+ func (c *ClockID) GetTime() ClockTime

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

+ func (c *ClockID) Ref() *ClockID

+ func (c *ClockID) Unref()

+ func (c *ClockID) Unschedule()

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

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

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

+ type ClockReturn int

+ const ClockBadTime

+ const ClockBusy

+ const ClockDone

+ const ClockEarly

+ const ClockError

+ const ClockOK

+ const ClockUnscheduled

+ const ClockUnsupported

+ type ClockTime C.GstClockTime

+ const ClockTimeNone

+ func (ct ClockTime) AsDuration() *time.Duration

+ func (ct ClockTime) AsTimestamp() *time.Time

+ func (ct ClockTime) String() string

+ type ClockTimeDiff int64

+ func (ctd ClockTimeDiff) AsDuration() time.Duration

+ type Context struct

+ func FromGstContextUnsafeFull(ctx unsafe.Pointer) *Context

+ func FromGstContextUnsafeNone(ctx unsafe.Pointer) *Context

+ func NewContext(ctxType string, persistent bool) *Context

+ func (c *Context) GetStructure() *Structure

+ func (c *Context) GetType() string

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

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

+ func (c *Context) IsPersistent() bool

+ func (c *Context) IsWritable() bool

+ func (c *Context) MakeWritable() *Context

+ func (c *Context) Ref() *Context

+ func (c *Context) Unref()

+ func (c *Context) WritableStructure() *Structure

+ type ControlBinding struct

+ func (cb *ControlBinding) Instance() *C.GstControlBinding

+ type DebugCategory struct

+ var CAT *DebugCategory

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

+ func (d *DebugCategory) GetName() string

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

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

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

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

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

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

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

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

+ type DebugColorFlags int

+ const DebugColorBgBlack

+ const DebugColorBgBlue

+ const DebugColorBgCyan

+ const DebugColorBgGreen

+ const DebugColorBgMagenta

+ const DebugColorBgRed

+ const DebugColorBgWhite

+ const DebugColorBgYellow

+ const DebugColorBold

+ const DebugColorFgBlack

+ const DebugColorFgBlue

+ const DebugColorFgCyan

+ const DebugColorFgGreen

+ const DebugColorFgMagenta

+ const DebugColorFgRed

+ const DebugColorFgWhite

+ const DebugColorFgYellow

+ const DebugColorNone

+ const DebugColorUnderline

+ type DebugColorMode int

+ const DebugColorModeOff

+ const DebugColorModeOn

+ const DebugColorModeUnix

+ type DebugGraphDetails int

+ const DebugGraphShowAll

+ const DebugGraphShowCapsDetails

+ const DebugGraphShowMediaType

+ const DebugGraphShowNonDefaultParams

+ const DebugGraphShowPullParams

+ const DebugGraphShowStates

+ const DebugGraphShowVerbose

+ type DebugLevel int

+ const LevelDebug

+ const LevelError

+ const LevelFixMe

+ const LevelInfo

+ const LevelLog

+ const LevelMemDump

+ const LevelNone

+ const LevelTrace

+ const LevelWarning

+ type DebugMessage struct

+ func (d *DebugMessage) Get() string

+ func (d *DebugMessage) GetId() string

+ type Device struct

+ func FromGstDeviceUnsafeFull(device unsafe.Pointer) *Device

+ func FromGstDeviceUnsafeNone(device unsafe.Pointer) *Device

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

+ func (d *Device) GetCaps() *Caps

+ func (d *Device) GetDeviceClass() string

+ func (d *Device) GetDisplayName() string

+ func (d *Device) GetProperties() *Structure

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

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

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

+ type DeviceMonitor struct

+ func NewDeviceMonitor() *DeviceMonitor

+ func (d *DeviceMonitor) AddFilter(classes string, caps *Caps) uint

+ func (d *DeviceMonitor) GetBus() *Bus

+ func (d *DeviceMonitor) GetDevices() []*Device

+ func (d *DeviceMonitor) GetShowAllDevices() bool

+ func (d *DeviceMonitor) RemoveFilter(filterId uint) bool

+ func (d *DeviceMonitor) SetShowAllDevices(show bool)

+ func (d *DeviceMonitor) Start() bool

+ func (d *DeviceMonitor) Stop()

+ type DeviceProvider struct

+ func FindDeviceProviderByName(factoryName string) *DeviceProvider

+ func FromGstDeviceProviderUnsafeFull(deviceProvider unsafe.Pointer) *DeviceProvider

+ func FromGstDeviceProviderUnsafeNone(deviceProvider unsafe.Pointer) *DeviceProvider

+ func (d *DeviceProvider) GetBus() *Bus

+ func (d *DeviceProvider) GetDevices() []*Device

+ func (d *DeviceProvider) Instance() *C.GstDeviceProvider

+ func (d *DeviceProvider) Start() bool

+ func (d *DeviceProvider) Stop()

+ type DirectControlBinding struct

+ func NewDirectControlBinding(obj *Object, prop string, csource *InterpolationControlSource) *DirectControlBinding

+ type Domain string

+ const DomainCore

+ const DomainLibrary

+ const DomainResource

+ const DomainStream

+ type Element struct

+ func FromGstElementUnsafeFull(elem unsafe.Pointer) *Element

+ func FromGstElementUnsafeNone(elem unsafe.Pointer) *Element

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

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

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

+ func NewElementWithProperties(factory string, properties map[string]interface{}) (*Element, error)

+ func ToElement(obj interface{}) *Element

+ func (e *Element) AbortState()

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

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

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

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

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

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

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

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

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

+ func (e *Element) GetBaseTime() ClockTime

+ func (e *Element) GetBus() *Bus

+ func (e *Element) GetClock() *Clock

+ func (e *Element) GetCurrentState() State

+ func (e *Element) GetFactory() *ElementFactory

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

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

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

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

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

+ func (e *Element) GetStartTime() ClockTime

+ func (e *Element) GetState(state State, timeout ClockTime) (StateChangeReturn, State)

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

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

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

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

+ func (e *Element) IsURIHandler() bool

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

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

+ func (e *Element) MessageFull(msgType MessageType, domain Domain, code ErrorCode, ...)

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

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

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

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

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

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

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

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

+ func (e *Element) SeekDefault(position int64, flag SeekFlags) bool

+ func (e *Element) SeekSimple(position int64, format Format, flag SeekFlags) bool

+ func (e *Element) SeekTime(position time.Duration, flag SeekFlags) bool

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

+ func (e *Element) SetBaseTime(startTime ClockTime)

+ func (e *Element) SetStartTime(startTime ClockTime)

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

+ func (e *Element) SyncStateWithParent() bool

+ func (e *Element) TOCSetter() TOCSetter

+ func (e *Element) TagSetter() TagSetter

+ func (e *Element) ToGValue() (*glib.Value, error)

+ func (e *Element) URIHandler() URIHandler

+ func (e *Element) Unlink(elem *Element)

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

+ type ElementClass struct

+ func ToElementClass(klass *glib.ObjectClass) *ElementClass

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

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

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

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

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

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

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

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

+ type ElementFactory struct

+ func Find(name string) *ElementFactory

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

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

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

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

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

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

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

+ type ElementFlags int

+ const ElementFlagIndexable

+ const ElementFlagLast

+ const ElementFlagLockedState

+ const ElementFlagProvideClock

+ const ElementFlagRequireClock

+ const ElementFlagSink

+ const ElementFlagSource

+ type ElementImpl interface

+ ChangeState func(*Element, StateChange) StateChangeReturn

+ GetState func(self *Element, timeout time.Duration) (ret StateChangeReturn, current, pending State)

+ NoMorePads func(*Element)

+ PadAdded func(*Element, *Pad)

+ PadRemoved func(*Element, *Pad)

+ PostMessage func(*Element, *Message) bool

+ ProvideClock func(*Element) *Clock

+ Query func(*Element, *Query) bool

+ ReleasePad func(*Element, *Pad)

+ RequestNewPad func(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad

+ SendEvent func(*Element, *Event) bool

+ SetBus func(*Element, *Bus)

+ SetClock func(*Element, *Clock) bool

+ SetContext func(*Element, *Context)

+ SetState func(*Element, State) StateChangeReturn

+ StateChanged func(self *Element, old, new, pending State)

+ type ErrorCode int

+ const CoreErrorCaps

+ const CoreErrorClock

+ const CoreErrorDisabled

+ const CoreErrorEvent

+ const CoreErrorFailed

+ const CoreErrorMissingPlugin

+ const CoreErrorNegotiation

+ const CoreErrorNotImplemented

+ const CoreErrorPad

+ const CoreErrorSeek

+ const CoreErrorStateChange

+ const CoreErrorTag

+ const CoreErrorThread

+ const CoreErrorTooLazy

+ const LibraryErrorEncode

+ const LibraryErrorFailed

+ const LibraryErrorInit

+ const LibraryErrorSettings

+ const LibraryErrorShutdown

+ const LibraryErrorTooLazy

+ const ResourceErrorBusy

+ const ResourceErrorClose

+ const ResourceErrorFailed

+ const ResourceErrorNoSpaceLeft

+ const ResourceErrorNotAuthorized

+ const ResourceErrorNotFound

+ const ResourceErrorOpenRead

+ const ResourceErrorOpenReadWrite

+ const ResourceErrorOpenWrite

+ const ResourceErrorRead

+ const ResourceErrorSeek

+ const ResourceErrorSettings

+ const ResourceErrorSync

+ const ResourceErrorTooLazy

+ const ResourceErrorWrite

+ const StreamErrorCodecNotFound

+ const StreamErrorDecode

+ const StreamErrorDecrypt

+ const StreamErrorDecryptNoKey

+ const StreamErrorDemux

+ const StreamErrorEncode

+ const StreamErrorFailed

+ const StreamErrorFormat

+ const StreamErrorMux

+ const StreamErrorNotImplemented

+ const StreamErrorTooLazy

+ const StreamErrorTypeNotFound

+ const StreamErrorWrongType

+ type Event struct

+ func FromGstEventUnsafeFull(ev unsafe.Pointer) *Event

+ func FromGstEventUnsafeNone(ev unsafe.Pointer) *Event

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

+ func NewCapsEvent(caps *Caps) *Event

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

+ func NewEOSEvent() *Event

+ func NewFlushStartEvent() *Event

+ func NewFlushStopEvent(resetTime bool) *Event

+ func NewGapEvent(timestamp, duration ClockTime) *Event

+ func NewLatencyEvent(latency ClockTime) *Event

+ func NewNavigationEvent(structure *Structure) *Event

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

+ func NewQOSEvent(qType QOSType, proportion float64, diff ClockTimeDiff, timestamp ClockTime) *Event

+ func NewReconfigureEvent() *Event

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

+ func NewSegmentDoneEvent(format Format, position int64) *Event

+ func NewSegmentEvent(segment *Segment) *Event

+ func NewSelectStreamsEvent(streams []*Stream) *Event

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

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

+ func NewStreamCollectionEvent(collection *StreamCollection) *Event

+ func NewStreamGroupDoneEvent(groupID uint) *Event

+ func NewStreamStartEvent(streamID string) *Event

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

+ func NewTOCSelectEvent(uid string) *Event

+ func NewTagEvent(tagList *TagList) *Event

+ func ToGstEvent(ev unsafe.Pointer) *Event

+ func (e *Event) Copy() *Event

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

+ func (e *Event) GetRunningTimeOffset() int64

+ func (e *Event) GetSeqnum() uint32

+ func (e *Event) GetStructure() *Structure

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

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

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

+ func (e *Event) ParseCaps() *Caps

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

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

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

+ func (e *Event) ParseLatency() ClockTime

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

+ func (e *Event) ParseQOS() (qTtype QOSType, proportion float64, diff ClockTimeDiff, timestamp ClockTime)

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

+ func (e *Event) ParseSeekTrickModeInterval() (interval ClockTime)

+ func (e *Event) ParseSegment() *Segment

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

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

+ func (e *Event) ParseSinkMessage() *Message

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

+ func (e *Event) ParseStream() *Stream

+ func (e *Event) ParseStreamCollection() *StreamCollection

+ func (e *Event) ParseStreamFlags() StreamFlags

+ func (e *Event) ParseStreamGroupDone() uint

+ func (e *Event) ParseStreamStart() string

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

+ func (e *Event) ParseTOCSelect() string

+ func (e *Event) ParseTag() *TagList

+ func (e *Event) Ref() *Event

+ func (e *Event) Seqnum() uint32

+ func (e *Event) SetGroupID(id uint)

+ func (e *Event) SetRunningTimeOffset(offset int64)

+ func (e *Event) SetSeekTrickModeInterval(interval ClockTime)

+ func (e *Event) SetSeqnum(seqnum uint32)

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

+ func (e *Event) SetStreamFlags(flags StreamFlags)

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

+ func (e *Event) Type() EventType

+ func (e *Event) Unref()

+ func (e *Event) WritableStructure() *Structure

+ type EventType int

+ const EventTypeBufferSize

+ const EventTypeCaps

+ const EventTypeCustomBoth

+ const EventTypeCustomBothOOB

+ const EventTypeCustomDownstream

+ const EventTypeCustomDownstreamSticky

+ const EventTypeCustomOOB

+ const EventTypeCustomUpstream

+ const EventTypeEOS

+ const EventTypeFlushStart

+ const EventTypeFlushStop

+ const EventTypeGap

+ const EventTypeLatency

+ const EventTypeNavigation

+ const EventTypeProtection

+ const EventTypeQOS

+ const EventTypeReconfigure

+ const EventTypeSeek

+ const EventTypeSegment

+ const EventTypeSegmentDone

+ const EventTypeSelectStreams

+ const EventTypeSinkMessage

+ const EventTypeStep

+ const EventTypeStreamCollection

+ const EventTypeStreamGroupDone

+ const EventTypeStreamStart

+ const EventTypeTOC

+ const EventTypeTOCSelect

+ const EventTypeTag

+ const EventTypeUnknown

+ func (e EventType) String() string

+ type EventTypeFlags int

+ const EventTypeFlagDownstream

+ const EventTypeFlagSerialized

+ const EventTypeFlagSticky

+ const EventTypeFlagStickyMulti

+ const EventTypeFlagUpstream

+ type FlagsetValue struct

+ func Flagset(flags, mask uint) *FlagsetValue

+ func ValueGetFlagset(value *glib.Value) *FlagsetValue

+ func (f *FlagsetValue) Flags() uint

+ func (f *FlagsetValue) Mask() uint

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

+ type Float64RangeValue struct

+ func Float64Range(start, end float64) *Float64RangeValue

+ func ValueGetFloat64Range(value *glib.Value) *Float64RangeValue

+ func (f *Float64RangeValue) End() float64

+ func (f *Float64RangeValue) Start() float64

+ func (f *Float64RangeValue) String() string

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

+ type FlowReturn int

+ const FlowEOS

+ const FlowError

+ const FlowFlushing

+ const FlowNotLinked

+ const FlowNotNegotiated

+ const FlowNotSupported

+ const FlowOK

+ func (f FlowReturn) String() string

+ type Format int

+ const FormatBytes

+ const FormatDefault

+ const FormatTime

+ const FormatUndefined

+ func (f Format) String() string

+ type FractionRangeValue struct

+ func FractionRange(start, end *FractionValue) *FractionRangeValue

+ func ValueGetFractionRange(value *glib.Value) *FractionRangeValue

+ func (g *FractionRangeValue) End() *FractionValue

+ func (g *FractionRangeValue) Start() *FractionValue

+ func (g *FractionRangeValue) String() string

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

+ type FractionValue struct

+ func Fraction(numerator, denominator int) *FractionValue

+ func ValueGetFraction(value *glib.Value) *FractionValue

+ func (g *FractionValue) Denom() int

+ func (g *FractionValue) Num() int

+ func (g *FractionValue) String() string

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

+ type GError struct

+ func NewGError(code ErrorCode, err error) *GError

+ func (e *GError) Code() ErrorCode

+ func (e *GError) DebugString() string

+ func (e *GError) Error() string

+ func (e *GError) Message() string

+ func (e *GError) Structure() *Structure

+ type GapFlags int

+ const GapFlagMissingData

+ type GhostPad struct

+ func FromGstGhostPadUnsafeFull(pad unsafe.Pointer) *GhostPad

+ func FromGstGhostPadUnsafeNone(pad unsafe.Pointer) *GhostPad

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

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

+ func NewGhostPadNoTarget(name string, direction PadDirection) *GhostPad

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

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

+ func (g *GhostPad) GetTarget() *Pad

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

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

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

+ type Int64RangeValue struct

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

+ func ValueGetInt64Range(value *glib.Value) *Int64RangeValue

+ func (i *Int64RangeValue) End() int64

+ func (i *Int64RangeValue) Start() int64

+ func (i *Int64RangeValue) Step() int64

+ func (i *Int64RangeValue) String() string

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

+ type IntRangeValue struct

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

+ func ValueGetIntRange(value *glib.Value) *IntRangeValue

+ func (i *IntRangeValue) End() int

+ func (i *IntRangeValue) Start() int

+ func (i *IntRangeValue) Step() int

+ func (i *IntRangeValue) String() string

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

+ type InterpolationControlSource struct

+ func NewInterpolationControlSource() *InterpolationControlSource

+ func (cs *InterpolationControlSource) Instance() *C.GstControlSource

+ func (cs *InterpolationControlSource) SetInterpolationMode(mode InterpolationMode)

+ func (cs *InterpolationControlSource) SetTimedValue(time ClockTime, value float64) bool

+ func (cs *InterpolationControlSource) UnsetAll()

+ type InterpolationMode int

+ const InterpolationModeCubic

+ const InterpolationModeCubicMonotonic

+ const InterpolationModeLinear

+ const InterpolationModeNone

+ type License string

+ const LicenseBSD

+ const LicenseGPL

+ const LicenseGPLQPL

+ const LicenseLGPL

+ const LicenseMIT

+ const LicenseMPL

+ const LicenseProprietary

+ const LicenseQPL

+ const LicenseUnknown

+ type LogFunction = func(category *DebugCategory, level DebugLevel, file string, function string, ...)

+ type LoggedObject struct

+ func (l *LoggedObject) Get() unsafe.Pointer

+ type MapFlags int

+ const MapFlagLast

+ const MapRead

+ const MapWrite

+ type MapInfo struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (m *MapInfo) Flags() MapFlags

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

+ func (m *MapInfo) MaxSize() int64

+ func (m *MapInfo) Memory() *Memory

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

+ func (m *MapInfo) Size() int64

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

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

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

+ type Memory struct

+ func FromGstMemoryUnsafe(mem unsafe.Pointer) *Memory

+ func FromGstMemoryUnsafeFull(mem unsafe.Pointer) *Memory

+ func FromGstMemoryUnsafeNone(mem unsafe.Pointer) *Memory

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

+ func (m *Memory) Alignment() int64

+ func (m *Memory) Allocator() *Allocator

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

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

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

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

+ func (m *Memory) MaxSize() int64

+ func (m *Memory) Offset() int64

+ func (m *Memory) Parent() *Memory

+ func (m *Memory) Ref() *Memory

+ func (m *Memory) Size() int64

+ func (m *Memory) Unmap()

+ func (m *Memory) Unref()

+ type MemoryFlags int

+ const MemoryFlagLast

+ const MemoryFlagNoShare

+ const MemoryFlagNotMappable

+ const MemoryFlagPhysicallyContiguous

+ const MemoryFlagReadOnly

+ const MemoryFlagZeroPadded

+ const MemoryFlagZeroPrefixed

+ type Message struct

+ func FromGstMessageUnsafeFull(msg unsafe.Pointer) *Message

+ func FromGstMessageUnsafeNone(msg unsafe.Pointer) *Message

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

+ func NewAsyncDoneMessage(src interface{}, runningTime ClockTime) *Message

+ func NewAsyncStartMessage(src interface{}) *Message

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

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

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

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

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

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

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

+ func NewDurationChangedMessage(src interface{}) *Message

+ func NewEOSMessage(src interface{}) *Message

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

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

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

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

+ func NewLatencyMessage(src interface{}) *Message

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

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

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

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

+ func NewQoSMessage(src interface{}, live bool, ...) *Message

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

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

+ func NewResetTimeMessage(src interface{}, runningTime ClockTime) *Message

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

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

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

+ func NewStateDirtyMessage(src interface{}) *Message

+ func NewStepDoneMessage(src interface{}, format Format, amount uint64, rate float64, ...) *Message

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

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

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

+ func NewStreamStartMessage(src interface{}) *Message

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

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

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

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

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

+ func ToGstMessage(msg unsafe.Pointer) *Message

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

+ func (m *Message) Copy() *Message

+ func (m *Message) GetStructure() *Structure

+ func (m *Message) Instance() *C.GstMessage

+ func (m *Message) NumRedirectEntries() int64

+ func (m *Message) ParseAsyncDone() ClockTime

+ func (m *Message) ParseBuffering() int

+ func (m *Message) ParseBufferingStats() *BufferingStats

+ func (m *Message) ParseClockProvide() (clock *Clock, ready bool)

+ func (m *Message) ParseDeviceAdded() *Device

+ func (m *Message) ParseDeviceChanged() (newDevice, oldDevice *Device)

+ func (m *Message) ParseDeviceRemoved() *Device

+ func (m *Message) ParseError() *GError

+ func (m *Message) ParseHaveContext() *Context

+ func (m *Message) ParseInfo() *GError

+ func (m *Message) ParseNewClock() *Clock

+ func (m *Message) ParseProgress() (progressType ProgressType, code, text string)

+ func (m *Message) ParsePropertyNotify() (obj *Object, propertName string, propertyValue *glib.Value)

+ func (m *Message) ParseQoS() *QoSValues

+ func (m *Message) ParseRedirectEntryAt(idx int64) (location string, tags *TagList, structure *Structure)

+ func (m *Message) ParseRequestState() State

+ func (m *Message) ParseResetTime() ClockTime

+ func (m *Message) ParseSegmentDone() (Format, int64)

+ func (m *Message) ParseSegmentStart() (Format, int64)

+ func (m *Message) ParseStateChanged() (oldState, newState State)

+ func (m *Message) ParseStepDone() *StepDoneValues

+ func (m *Message) ParseStepStart() *StepStartValues

+ func (m *Message) ParseStreamCollection() *StreamCollection

+ func (m *Message) ParseStreamStatus() (StreamStatusType, *Element)

+ func (m *Message) ParseStreamsSelected() *StreamCollection

+ func (m *Message) ParseStructureChange() (chgType StructureChangeType, owner *Element, busy bool)

+ func (m *Message) ParseTOC() (toc *TOC, updated bool)

+ func (m *Message) ParseTags() *TagList

+ func (m *Message) ParseWarning() *GError

+ func (m *Message) Ref() *Message

+ func (m *Message) Source() string

+ func (m *Message) StreamsSelectedAdd(stream *Stream)

+ func (m *Message) StreamsSelectedGetStream(index uint) *Stream

+ func (m *Message) StreamsSelectedSize() uint

+ func (m *Message) String() string

+ func (m *Message) Type() MessageType

+ func (m *Message) TypeName() string

+ func (m *Message) Unref()

+ type MessageType int

+ const MessageAny

+ const MessageApplication

+ const MessageAsyncDone

+ const MessageAsyncStart

+ const MessageBuffering

+ const MessageClockLost

+ const MessageClockProvide

+ const MessageDeviceAdded

+ const MessageDeviceChanged

+ const MessageDeviceRemoved

+ const MessageDurationChanged

+ const MessageEOS

+ const MessageElement

+ const MessageError

+ const MessageExtended

+ const MessageHaveContext

+ const MessageInfo

+ const MessageLatency

+ const MessageNeedContext

+ const MessageNewClock

+ const MessageProgress

+ const MessagePropertyNotify

+ const MessageQoS

+ const MessageRedirect

+ const MessageRequestState

+ const MessageResetTime

+ const MessageSegmentDone

+ const MessageSegmentStart

+ const MessageStateChanged

+ const MessageStateDirty

+ const MessageStepDone

+ const MessageStepStart

+ const MessageStreamCollection

+ const MessageStreamStart

+ const MessageStreamStatus

+ const MessageStreamsSelected

+ const MessageStructureChange

+ const MessageTOC

+ const MessageTag

+ const MessageUnknown

+ const MessageWarning

+ func (m MessageType) String() string

+ type Meta struct

+ func FromGstMetaUnsafe(ptr unsafe.Pointer) *Meta

+ func (m *Meta) Flags() MetaFlags

+ func (m *Meta) Info() *MetaInfo

+ func (m *Meta) Instance() *C.GstMeta

+ func (m *Meta) SetFlags(flags MetaFlags)

+ func (m *Meta) SetInfo(info *MetaInfo)

+ type MetaFlags int

+ const MetaFlagLast

+ const MetaFlagLocked

+ const MetaFlagNone

+ const MetaFlagPooled

+ const MetaFlagReadOnly

+ type MetaFreeFunc func(buffer *Buffer)

+ type MetaInfo struct

+ func FromGstMetaInfoUnsafe(ptr unsafe.Pointer) *MetaInfo

+ func GetAPIInfo(name string) *MetaInfo

+ func GetProtectionMetaInfo() *MetaInfo

+ func RegisterMeta(api glib.Type, name string, size int64, cbFuncs *MetaInfoCallbackFuncs) *MetaInfo

+ func (m *MetaInfo) API() glib.Type

+ func (m *MetaInfo) Instance() *C.GstMetaInfo

+ func (m *MetaInfo) SetAPI(t glib.Type)

+ func (m *MetaInfo) SetSize(size int64)

+ func (m *MetaInfo) SetType(t glib.Type)

+ func (m *MetaInfo) Size() int64

+ func (m *MetaInfo) Type() glib.Type

+ type MetaInfoCallbackFuncs struct

+ FreeFunc MetaFreeFunc

+ InitFunc MetaInitFunc

+ TransformFunc MetaTransformFunc

+ type MetaInitFunc func(params interface{}, buffer *Buffer) bool

+ type MetaTransformCopy struct

+ Offset int64

+ Region bool

+ Size int64

+ type MetaTransformFunc func(transBuf, buf *Buffer, mType string, data *MetaTransformCopy) bool

+ type MiniObject struct

+ func NewMiniObject(flags MiniObjectFlags, gtype glib.Type) *MiniObject

+ func (m *MiniObject) AddParent(parent *MiniObject)

+ func (m *MiniObject) Copy() *MiniObject

+ func (m *MiniObject) GetData(name string) unsafe.Pointer

+ func (m *MiniObject) Instance() *C.GstMiniObject

+ func (m *MiniObject) Parent() *MiniObject

+ func (m *MiniObject) Ref()

+ func (m *MiniObject) SetData(name string, ptr unsafe.Pointer)

+ func (m *MiniObject) Type() glib.Type

+ func (m *MiniObject) Unref()

+ type MiniObjectFlags int

+ const MiniObjectFlagLast

+ const MiniObjectFlagLockReadOnly

+ const MiniObjectFlagLockable

+ const MiniObjectFlagMayBeLeaked

+ type Object struct

+ func FromGstObjectUnsafeFull(ptr unsafe.Pointer) *Object

+ func FromGstObjectUnsafeNone(ptr unsafe.Pointer) *Object

+ func (o *Object) AddControlBinding(binding *ControlBinding)

+ func (o *Object) BaseObject() *Object

+ func (o *Object) Clear()

+ func (o *Object) GObject() *glib.Object

+ func (o *Object) GetName() string

+ func (o *Object) GetValue(property string, timestamp ClockTime) *glib.Value

+ func (o *Object) GstObject() *C.GstObject

+ func (o *Object) Instance() *C.GstObject

+ func (o *Object) Log(cat *DebugCategory, level DebugLevel, message string)

+ func (o *Object) Ref() *Object

+ func (o *Object) SetArg(name, value string)

+ func (o *Object) Unref()

+ type Pad struct

+ func FromGstPadUnsafeFull(pad unsafe.Pointer) *Pad

+ func FromGstPadUnsafeNone(pad unsafe.Pointer) *Pad

+ func NewPad(name string, direction PadDirection) *Pad

+ func NewPadFromTemplate(tmpl *PadTemplate, name string) *Pad

+ func (p *Pad) ActivateMode(mode PadMode, active bool)

+ func (p *Pad) AddProbe(mask PadProbeType, f PadProbeCallback) uint64

+ func (p *Pad) CanLink(sink *Pad) bool

+ func (p *Pad) Chain(buffer *Buffer) FlowReturn

+ func (p *Pad) ChainList(bufferList *BufferList) FlowReturn

+ func (p *Pad) CheckReconfigure() bool

+ func (p *Pad) CreateStreamID(parent *Element, streamID string) string

+ func (p *Pad) CurrentCaps() *Caps

+ func (p *Pad) Direction() PadDirection

+ func (p *Pad) EventDefault(parent *Object, event *Event) bool

+ func (p *Pad) Forward(f PadForwardFunc) bool

+ func (p *Pad) GetAllowedCaps() *Caps

+ func (p *Pad) GetCurrentCaps() *Caps

+ func (p *Pad) GetDirection() PadDirection

+ func (p *Pad) GetElementPrivate() interface{}

+ func (p *Pad) GetInternalLinks() ([]*Pad, error)

+ func (p *Pad) GetInternalLinksDefault(parent *Object) ([]*Pad, error)

+ func (p *Pad) GetLastFlowReturn() FlowReturn

+ func (p *Pad) GetOffset() int64

+ func (p *Pad) GetPadTemplate() *PadTemplate

+ func (p *Pad) GetPadTemplateCaps() *Caps

+ func (p *Pad) GetParentElement() *Element

+ func (p *Pad) GetPeer() *Pad

+ func (p *Pad) GetRange(offset uint64, size uint, buffer *Buffer) (FlowReturn, *Buffer)

+ func (p *Pad) GetStickyEvent(eventType EventType, idx uint) *Event

+ func (p *Pad) GetStream() *Stream

+ func (p *Pad) GetStreamID() string

+ func (p *Pad) GetTaskState() TaskState

+ func (p *Pad) HasCurrentCaps() bool

+ func (p *Pad) Instance() *C.GstPad

+ func (p *Pad) IsActive() bool

+ func (p *Pad) IsBlocked() bool

+ func (p *Pad) IsBlocking() bool

+ func (p *Pad) IsLinked() bool

+ func (p *Pad) Link(sink *Pad) PadLinkReturn

+ func (p *Pad) LinkFull(sink *Pad, flags PadLinkCheck) PadLinkReturn

+ func (p *Pad) LinkMaybeGhosting(sink *Pad) bool

+ func (p *Pad) LinkMaybeGhostingFull(sink *Pad, flags PadLinkCheck) bool

+ func (p *Pad) MarkReconfigure()

+ func (p *Pad) NeedsReconfigure() bool

+ func (p *Pad) PauseTask() bool

+ func (p *Pad) PeerQuery(query *Query) bool

+ func (p *Pad) PeerQueryAcceptCaps(caps *Caps) bool

+ func (p *Pad) PeerQueryCaps(filter *Caps) *Caps

+ func (p *Pad) PeerQueryConvert(srcFormat, destFormat Format, srcVal int64) (bool, int64)

+ func (p *Pad) PeerQueryDuration(format Format) (bool, int64)

+ func (p *Pad) PeerQueryPosition(format Format) (bool, int64)

+ func (p *Pad) ProxyQueryAcceptCaps(query *Query) bool

+ func (p *Pad) ProxyQueryCaps(query *Query) bool

+ func (p *Pad) PullRange(offset uint64, size uint, buffer *Buffer) (FlowReturn, *Buffer)

+ func (p *Pad) Push(buf *Buffer) FlowReturn

+ func (p *Pad) PushEvent(ev *Event) bool

+ func (p *Pad) PushList(bufList *BufferList) FlowReturn

+ func (p *Pad) Query(query *Query) bool

+ func (p *Pad) QueryAcceptCaps(caps *Caps) bool

+ func (p *Pad) QueryCaps(filter *Caps) *Caps

+ func (p *Pad) QueryConvert(srcFormat, destFormat Format, srcVal int64) (bool, int64)

+ func (p *Pad) QueryDefault(parent *Object, query *Query) bool

+ func (p *Pad) QueryDuration(format Format) (bool, int64)

+ func (p *Pad) QueryPosition(format Format) (bool, int64)

+ func (p *Pad) RemoveProbe(id uint64)

+ func (p *Pad) SendEvent(ev *Event) bool

+ func (p *Pad) SetActivateFunction(f PadActivateFunc)

+ func (p *Pad) SetActivateModeFunction(f PadActivateModeFunc)

+ func (p *Pad) SetActive(active bool) bool

+ func (p *Pad) SetChainFunction(f PadChainFunc)

+ func (p *Pad) SetChainListFunction(f PadChainListFunc)

+ func (p *Pad) SetElementPrivate(data interface{})

+ func (p *Pad) SetEventFullFunction(f PadEventFullFunc)

+ func (p *Pad) SetEventFunction(f PadEventFunc)

+ func (p *Pad) SetGetRangeFunction(f PadGetRangeFunc)

+ func (p *Pad) SetIterIntLinkFunction(f PadIterIntLinkFunc)

+ func (p *Pad) SetLinkFunction(f PadLinkFunc)

+ func (p *Pad) SetOffset(offset int64)

+ func (p *Pad) SetQueryFunction(f PadQueryFunc)

+ func (p *Pad) SetUnlinkFunction(f PadUnlinkFunc)

+ func (p *Pad) StickyEventsForEach(f StickyEventsForEachFunc)

+ func (p *Pad) StoreStickyEvent(ev *Event) FlowReturn

+ func (p *Pad) Template() *PadTemplate

+ func (p *Pad) ToGValue() (*glib.Value, error)

+ func (p *Pad) Unlink(pad *Pad) bool

+ func (p *Pad) UseFixedCaps()

+ type PadActivateFunc func(self *Pad, parent *Object) bool

+ type PadActivateModeFunc func(self *Pad, parent *Object, mode PadMode, active bool) bool

+ type PadChainFunc func(self *Pad, parent *Object, buffer *Buffer) FlowReturn

+ type PadChainListFunc func(self *Pad, parent *Object, list *BufferList) FlowReturn

+ type PadDirection int

+ const PadDirectionSink

+ const PadDirectionSource

+ const PadDirectionUnknown

+ func (p PadDirection) String() string

+ type PadEventFullFunc func(self *Pad, parent *Object, event *Event) FlowReturn

+ type PadEventFunc func(self *Pad, parent *Object, event *Event) bool

+ type PadFlags int

+ const PadFlagAcceptIntersect

+ const PadFlagAcceptTemplate

+ const PadFlagBlocked

+ const PadFlagBlocking

+ const PadFlagEOS

+ const PadFlagFixedCaps

+ const PadFlagFlushing

+ const PadFlagLast

+ const PadFlagParent

+ const PadFlagPendingEvents

+ const PadFlagProxyAllocation

+ const PadFlagProxyCaps

+ const PadFlagProxyScheduling

+ const PadFlagReconfigure

+ type PadForwardFunc func(pad *Pad) bool

+ type PadFuncMap map[unsafe.Pointer]interface

+ func (p PadFuncMap) FuncForPad(pad unsafe.Pointer) interface{}

+ func (p PadFuncMap) RemoveFuncForPad(pad unsafe.Pointer)

+ type PadGetRangeFunc func(self *Pad, parent *Object, offset uint64, length uint) (FlowReturn, *Buffer)

+ type PadIterIntLinkFunc func(self *Pad, parent *Object) []*Pad

+ type PadLinkCheck int

+ const PadLinkCheckCaps

+ const PadLinkCheckDefault

+ const PadLinkCheckHierarchy

+ const PadLinkCheckNoReconfigure

+ const PadLinkCheckNothing

+ const PadLinkCheckTemplateCaps

+ type PadLinkFunc func(self *Pad, parent *Object, peer *Pad) PadLinkReturn

+ type PadLinkReturn int

+ const PadLinkNoFormat

+ const PadLinkNoSched

+ const PadLinkOK

+ const PadLinkRefused

+ const PadLinkWasLinked

+ const PadLinkWrongDirection

+ const PadLinkWrongHierarchy

+ func (p PadLinkReturn) String() string

+ type PadMode int

+ const PadModeNone

+ const PadModePull

+ const PadModePush

+ func (p PadMode) String() string

+ type PadPresence int

+ const PadPresenceAlways

+ const PadPresenceRequest

+ const PadPresenceSometimes

+ func (p PadPresence) String() string

+ type PadProbeCallback func(*Pad, *PadProbeInfo) PadProbeReturn

+ type PadProbeInfo struct

+ func (p *PadProbeInfo) GetBuffer() *Buffer

+ func (p *PadProbeInfo) GetBufferList() *BufferList

+ func (p *PadProbeInfo) GetEvent() *Event

+ func (p *PadProbeInfo) GetQuery() *Query

+ func (p *PadProbeInfo) ID() uint32

+ func (p *PadProbeInfo) Offset() uint64

+ func (p *PadProbeInfo) Size() uint64

+ func (p *PadProbeInfo) Type() PadProbeType

+ type PadProbeReturn int

+ const PadProbeDrop

+ const PadProbeOK

+ const PadProbePass

+ const PadProbeRemove

+ const PadProbeUnhandled

+ type PadProbeType int

+ const PadProbeTypeAllBoth

+ const PadProbeTypeBlock

+ const PadProbeTypeBlockDownstream

+ const PadProbeTypeBlockUpstream

+ const PadProbeTypeBlocking

+ const PadProbeTypeBuffer

+ const PadProbeTypeBufferList

+ const PadProbeTypeDataBoth

+ const PadProbeTypeDataDownstream

+ const PadProbeTypeDataUpstream

+ const PadProbeTypeEventBoth

+ const PadProbeTypeEventDownstream

+ const PadProbeTypeEventFlush

+ const PadProbeTypeEventUpstream

+ const PadProbeTypeIdle

+ const PadProbeTypeInvalid

+ const PadProbeTypePull

+ const PadProbeTypePush

+ const PadProbeTypeQueryBoth

+ const PadProbeTypeQueryDownstream

+ const PadProbeTypeQueryUpstream

+ const PadProbeTypeScheduling

+ type PadQueryFunc func(self *Pad, parent *Object, query *Query) bool

+ type PadTemplate struct

+ func FromGstPadTemplateUnsafeFull(tmpl unsafe.Pointer) *PadTemplate

+ func FromGstPadTemplateUnsafeNone(tmpl unsafe.Pointer) *PadTemplate

+ func NewPadTemplate(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps) *PadTemplate

+ func NewPadTemplateWithGType(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps, ...) *PadTemplate

+ func (p *PadTemplate) Caps() *Caps

+ func (p *PadTemplate) Direction() PadDirection

+ func (p *PadTemplate) Instance() *C.GstPadTemplate

+ func (p *PadTemplate) Name() string

+ func (p *PadTemplate) PadCreated(pad *Pad)

+ func (p *PadTemplate) Presence() PadPresence

+ type PadUnlinkFunc func(self *Pad, parent *Object)

+ type ParentBufferMeta struct

+ Buffer *Buffer

+ Parent *Meta

+ type Pipeline struct

+ func FromGstPipelineUnsafeFull(pipeline unsafe.Pointer) *Pipeline

+ func FromGstPipelineUnsafeNone(pipeline unsafe.Pointer) *Pipeline

+ func NewPipeline(name string) (*Pipeline, error)

+ func NewPipelineFromString(launchv string) (*Pipeline, error)

+ func (p *Pipeline) ForceClock(clock *Clock)

+ func (p *Pipeline) GetPipelineBus() *Bus

+ func (p *Pipeline) GetPipelineClock() *Clock

+ func (p *Pipeline) Instance() *C.GstPipeline

+ func (p *Pipeline) SetAutoFlushBus(b bool)

+ func (p *Pipeline) Start() error

+ type Plugin struct

+ func FromGstPluginUnsafeFull(plugin unsafe.Pointer) *Plugin

+ func FromGstPluginUnsafeNone(plugin unsafe.Pointer) *Plugin

+ func LoadPluginByName(name string) *Plugin

+ func LoadPluginFile(fpath string) (*Plugin, error)

+ func (p *Plugin) Description() string

+ func (p *Plugin) Filename() string

+ func (p *Plugin) Instance() *C.GstPlugin

+ func (p *Plugin) License() License

+ func (p *Plugin) Origin() string

+ func (p *Plugin) Package() string

+ func (p *Plugin) Source() string

+ func (p *Plugin) Version() string

+ type PluginFeature struct

+ func (p *PluginFeature) GetPlugin() *Plugin

+ func (p *PluginFeature) GetPluginName() string

+ func (p *PluginFeature) GetPluginRank() int

+ func (p *PluginFeature) Instance() *C.GstPluginFeature

+ func (p *PluginFeature) SetPluginRank(rank Rank)

+ type PluginInitFunc func(*Plugin) bool

+ type PluginMetadata struct

+ Description string

+ Init PluginInitFunc

+ License License

+ MajorVersion Version

+ MinorVersion Version

+ Name string

+ Origin string

+ Package string

+ ReleaseDate string

+ Source string

+ Version string

+ func (p *PluginMetadata) Export() unsafe.Pointer

+ type PollFd struct

+ Events uint

+ Fd int

+ REvents uint

+ type ProgressType int

+ const ProgressTypeCanceled

+ const ProgressTypeComplete

+ const ProgressTypeContinue

+ const ProgressTypeError

+ const ProgressTypeStart

+ func (p ProgressType) String() string

+ type Promise struct

+ func NewPromise() *Promise

+ func (p *Promise) Await(ctx context.Context) (*Structure, error)

+ func (p *Promise) Expire()

+ func (p *Promise) GetReply() *Structure

+ func (p *Promise) Instance() *C.GstPromise

+ func (p *Promise) Interrupt()

+ func (p *Promise) Ref()

+ func (p *Promise) Reply(answer *Structure)

+ func (p *Promise) ToGValue() (*glib.Value, error)

+ func (p *Promise) Unref()

+ type PromiseResult int

+ func (pr PromiseResult) String() string

+ type ProtectionMeta struct

+ Info *Structure

+ Meta *Meta

+ type ProxyPad struct

+ func (p *ProxyPad) ChainDefault(parent *Object, buffer *Buffer) FlowReturn

+ func (p *ProxyPad) ChainListDefault(parent *Object, bufferList *BufferList) FlowReturn

+ func (p *ProxyPad) GetInternal() *ProxyPad

+ func (p *ProxyPad) GetInternalLinksDefault(parent *Object) ([]*Pad, error)

+ func (p *ProxyPad) GetRangeDefault(parent *Object, offset uint64, size uint) (FlowReturn, *Buffer)

+ func (p *ProxyPad) Instance() *C.GstProxyPad

+ type QOSType int

+ const QOSTypeOverflow

+ const QOSTypeThrottle

+ const QOSTypeUnderflow

+ type QoSValues struct

+ Duration time.Duration

+ Live bool

+ RunningTime time.Duration

+ StreamTime time.Duration

+ Timestamp time.Duration

+ type Query struct

+ func FromGstQueryUnsafeFull(query unsafe.Pointer) *Query

+ func FromGstQueryUnsafeNone(query unsafe.Pointer) *Query

+ func NewAcceptCapsQuery(caps *Caps) *Query

+ func NewAllocationQuery(caps *Caps, needPool bool) *Query

+ func NewBitrateQuery() *Query

+ func NewBufferingQuery(format Format) *Query

+ func NewCapsQuery(caps *Caps) *Query

+ func NewContextQuery(ctxType string) *Query

+ func NewConvertQuery(srcFormat, destFormat Format, value int64) *Query

+ func NewCustomQuery(queryType QueryType, structure *Structure) *Query

+ func NewDrainQuery() *Query

+ func NewDurationQuery(format Format) *Query

+ func NewFormatsQuery() *Query

+ func NewLatencyQuery() *Query

+ func NewPositionQuery(format Format) *Query

+ func NewSchedulingQuery() *Query

+ func NewSeekingQuery(format Format) *Query

+ func NewSegmentQuery(format Format) *Query

+ func NewURIQuery() *Query

+ func ToGstQuery(query unsafe.Pointer) *Query

+ func (q *Query) AddAllocationMeta(api glib.Type, structure *Structure)

+ func (q *Query) AddAllocationParam(allocator *Allocator, params *AllocationParams)

+ func (q *Query) AddAllocationPool(pool *BufferPool, size, minBuffers, maxBuffers uint)

+ func (q *Query) AddBufferingRange(start, stop int64) (ok bool)

+ func (q *Query) AddSchedulingMode(mode PadMode)

+ func (q *Query) Copy() *Query

+ func (q *Query) FindAllocationMeta(api glib.Type) (ok bool, index uint)

+ func (q *Query) GetNumAllocationMetas() uint

+ func (q *Query) GetNumAllocationParams() uint

+ func (q *Query) GetNumAllocationPools() uint

+ func (q *Query) GetNumBufferingRanges() uint

+ func (q *Query) GetNumSchedulingModes() uint

+ func (q *Query) GetStructure() *Structure

+ func (q *Query) HasSchedulingMode(mode PadMode) bool

+ func (q *Query) HasSchedulingModeWithFlags(mode PadMode, flags SchedulingFlags) bool

+ func (q *Query) Instance() *C.GstQuery

+ func (q *Query) ParseAcceptCaps() *Caps

+ func (q *Query) ParseAcceptCapsResult() bool

+ func (q *Query) ParseAllocation() (caps *Caps, needPool bool)

+ func (q *Query) ParseAllocationMetaAt(idx uint) (api glib.Type, st *Structure)

+ func (q *Query) ParseAllocationParamAt(idx uint) (*Allocator, *AllocationParams)

+ func (q *Query) ParseAllocationPoolAt(idx uint) (pool *BufferPool, size, minBuffers, maxBuffers uint)

+ func (q *Query) ParseBitrate() uint

+ func (q *Query) ParseBufferingPercent() (busy bool, percent int)

+ func (q *Query) ParseBufferingRange() (format Format, start, stop, estimatedTotal int64)

+ func (q *Query) ParseBufferingRangeAt(idx uint) (start, stop int64)

+ func (q *Query) ParseBufferingStats() (mode BufferingMode, avgIn, avgOut int, bufLeft int64)

+ func (q *Query) ParseCaps() *Caps

+ func (q *Query) ParseCapsResult() *Caps

+ func (q *Query) ParseContext() *Context

+ func (q *Query) ParseContextType() (ok bool, ctxType string)

+ func (q *Query) ParseConvert() (srcformat, destFormat Format, srcValue, destValue int64)

+ func (q *Query) ParseDuration() (format Format, duration int64)

+ func (q *Query) ParseFormatAt(idx uint) Format

+ func (q *Query) ParseLatency() (live bool, minLatency, maxLatency ClockTime)

+ func (q *Query) ParseNumFormats() uint

+ func (q *Query) ParsePosition() (format Format, cur int64)

+ func (q *Query) ParseScheduling() (flags SchedulingFlags, minSize, maxSize, align int)

+ func (q *Query) ParseSchedulingModeAt(idx uint) PadMode

+ func (q *Query) ParseSeeking() (format Format, seekable bool, start, end int64)

+ func (q *Query) ParseSegment() (rate float64, format Format, start, stop int64)

+ func (q *Query) ParseURI() string

+ func (q *Query) ParseURIRedirection() string

+ func (q *Query) ParseURIRedirectionPermanent() bool

+ func (q *Query) Ref() *Query

+ func (q *Query) RemoveAllocationMetaAt(idx uint)

+ func (q *Query) RemoveAllocationParamAt(idx uint)

+ func (q *Query) RemoveAllocationPoolAt(idx uint)

+ func (q *Query) SetAcceptCapsResult(result bool)

+ func (q *Query) SetAllocationParamAt(idx uint, allocator *Allocator, params *AllocationParams)

+ func (q *Query) SetAllocationPoolAt(idx uint, pool *BufferPool, size, minBuffers, maxBuffers uint)

+ func (q *Query) SetBitrate(nominal uint)

+ func (q *Query) SetBufferingPercent(busy bool, percent int)

+ func (q *Query) SetBufferingRange(format Format, start, stop, estimatedTotal int64)

+ func (q *Query) SetBufferingStats(mode BufferingMode, avgIn, avgOut int, bufferingLeft int64)

+ func (q *Query) SetCapsResult(caps *Caps)

+ func (q *Query) SetContext(ctx *Context)

+ func (q *Query) SetConvert(srcFormat, destFormat Format, srcValue, destValue int64)

+ func (q *Query) SetDuration(format Format, duration int64)

+ func (q *Query) SetFormats(formats ...Format)

+ func (q *Query) SetLatency(live bool, minLatency, maxLatency ClockTime)

+ func (q *Query) SetPosition(format Format, cur int64)

+ func (q *Query) SetScheduling(flags SchedulingFlags, minSize, maxSize, align int)

+ func (q *Query) SetSeeking(format Format, seekable bool, segmentStart, segmentEnd int64)

+ func (q *Query) SetSegment(rate float64, format Format, startValue, stopValue int64)

+ func (q *Query) SetURI(uri string)

+ func (q *Query) SetURIRedirection(uri string)

+ func (q *Query) SetURIRedirectionPermanent(permanent bool)

+ func (q *Query) Type() QueryType

+ func (q *Query) Unref()

+ func (q *Query) WritableStructure() *Structure

+ type QueryType int

+ const QueryAcceptCaps

+ const QueryAllocation

+ const QueryBitrate

+ const QueryBuffering

+ const QueryCaps

+ const QueryContext

+ const QueryConvert

+ const QueryCustom

+ const QueryDrain

+ const QueryDuration

+ const QueryFormats

+ const QueryJitter

+ const QueryLatency

+ const QueryPosition

+ const QueryRate

+ const QueryScheduling

+ const QuerySeeking

+ const QuerySegment

+ const QueryURI

+ const QueryUnknown

+ func (q QueryType) String() string

+ type QueryTypeFlags int

+ const QueryTypeDownstream

+ const QueryTypeSerialized

+ const QueryTypeUpstream

+ type Rank uint

+ const RankMarginal

+ const RankNone

+ const RankPrimary

+ const RankSecondary

+ type ReferenceTimestampMeta struct

+ Duration ClockTime

+ Parent *Meta

+ Reference *Caps

+ Timestamp ClockTime

+ type Registry struct

+ func FromGstRegistryUnsafeFull(registry unsafe.Pointer) *Registry

+ func FromGstRegistryUnsafeNone(registry unsafe.Pointer) *Registry

+ func GetRegistry() *Registry

+ func (r *Registry) FindPlugin(name string) (*Plugin, error)

+ func (r *Registry) Instance() *C.GstRegistry

+ func (r *Registry) LookupFeature(name string) (*PluginFeature, error)

+ type Sample struct

+ func FromGstSampleUnsafeFull(sample unsafe.Pointer) *Sample

+ func FromGstSampleUnsafeNone(sample unsafe.Pointer) *Sample

+ func (s *Sample) Copy() *Sample

+ func (s *Sample) GetBuffer() *Buffer

+ func (s *Sample) GetBufferList() *BufferList

+ func (s *Sample) GetCaps() *Caps

+ func (s *Sample) GetInfo() *Structure

+ func (s *Sample) GetSegment() *Segment

+ func (s *Sample) Instance() *C.GstSample

+ func (s *Sample) Ref() *Sample

+ func (s *Sample) SetBuffer(buf *Buffer)

+ func (s *Sample) SetBufferList(buf *BufferList)

+ func (s *Sample) SetCaps(caps *Caps)

+ func (s *Sample) SetInfo(st *Structure) bool

+ func (s *Sample) SetSegment(segment *Segment)

+ func (s *Sample) Unref()

+ type SchedulingFlags int

+ const SchedulingFlagBandwidthLimited

+ const SchedulingFlagSeekable

+ const SchedulingFlagSequential

+ type SeekFlags int

+ const SeekFlagAccurate

+ const SeekFlagFlush

+ const SeekFlagKeyUnit

+ const SeekFlagNone

+ const SeekFlagSegment

+ const SeekFlagSkip

+ const SeekFlagSnapAfter

+ const SeekFlagSnapBefore

+ const SeekFlagSnapNearest

+ type SeekType int

+ const SeekTypeEnd

+ const SeekTypeNone

+ const SeekTypeSet

+ type Segment struct

+ func FromGstSegmentUnsafe(segment unsafe.Pointer) *Segment

+ func NewFormattedSegment(f Format) *Segment

+ func NewSegment() *Segment

+ func ToGstSegment(segment unsafe.Pointer) *Segment

+ func (s *Segment) Clip(format Format, start, stop uint64) (ok bool, clipStart, clipStop uint64)

+ func (s *Segment) Copy() *Segment

+ func (s *Segment) CopyInto(segment *Segment)

+ func (s *Segment) DoSeek(rate float64, format Format, flags SeekFlags, startType SeekType, start uint64, ...) (ok, update bool)

+ func (s *Segment) Free()

+ func (s *Segment) GetAppliedRate() float64

+ func (s *Segment) GetBase() uint64

+ func (s *Segment) GetDuration() uint64

+ func (s *Segment) GetFlags() SegmentFlags

+ func (s *Segment) GetFormat() Format

+ func (s *Segment) GetOffset() uint64

+ func (s *Segment) GetPosition() uint64

+ func (s *Segment) GetRate() float64

+ func (s *Segment) GetStart() uint64

+ func (s *Segment) GetStop() uint64

+ func (s *Segment) GetTime() uint64

+ func (s *Segment) Init(format Format)

+ func (s *Segment) Instance() *C.GstSegment

+ func (s *Segment) IsEqual(segment *Segment) bool

+ func (s *Segment) OffsetRunningTime(format Format, offset int64) bool

+ func (s *Segment) PositionFromRunningTime(format Format, runningTime uint64) uint64

+ func (s *Segment) PositionFromRunningTimeFull(format Format, runningTime uint64) int64

+ func (s *Segment) PositionFromStreamTime(format Format, streamTime uint64) uint64

+ func (s *Segment) PositionFromStreamTimeFull(format Format, streamTime uint64) int64

+ func (s *Segment) SetAppliedRate(rate float64)

+ func (s *Segment) SetFlags(flags SegmentFlags)

+ func (s *Segment) SetFormat(f Format)

+ func (s *Segment) SetRate(rate float64)

+ func (s *Segment) SetRunningTime(format Format, runningTime uint64) bool

+ func (s *Segment) ToRunningTime(format Format, position uint64) uint64

+ func (s *Segment) ToRunningTimeFull(format Format, position uint64) int64

+ func (s *Segment) ToStreamTime(format Format, position uint64) uint64

+ func (s *Segment) ToStreamTimeFull(format Format, position uint64) int64

+ type SegmentFlags int

+ const SegmentFlagKeyUnits

+ const SegmentFlagNone

+ const SegmentFlagReset

+ const SegmentFlagSegment

+ const SegmentFlagSkip

+ const SegmentFlagTrickMode

+ const SegmentFlagTrickModeNoAudio

+ type StackTraceFlags int

+ const StackTraceShowFull

+ const StackTraceShowNone

+ type State int

+ const StateNull

+ const StatePaused

+ const StatePlaying

+ const StateReady

+ const VoidPending

+ func (s State) String() string

+ type StateChange int

+ const StateChangeNullToNull

+ const StateChangeNullToReady

+ const StateChangePausedToPaused

+ const StateChangePausedToPlaying

+ const StateChangePausedToReady

+ const StateChangePlayingToPaused

+ const StateChangePlayingToPlaying

+ const StateChangeReadyToNull

+ const StateChangeReadyToPaused

+ const StateChangeReadyToReady

+ func (s StateChange) String() string

+ type StateChangeReturn int

+ const StateChangeAsync

+ const StateChangeFailure

+ const StateChangeNoPreroll

+ const StateChangeSuccess

+ func (s StateChangeReturn) String() string

+ type StepDoneValues struct

+ Amount uint64

+ Duration time.Duration

+ EOS bool

+ Flush bool

+ Format Format

+ Intermediate bool

+ Rate float64

+ type StepStartValues struct

+ Active bool

+ Amount uint64

+ Flush bool

+ Format Format

+ Intermediate bool

+ Rate float64

+ type StickyEventsForEachFunc func(pad *Pad, event *Event) bool

+ type Stream struct

+ func FromGstStreamUnsafeFull(stream unsafe.Pointer) *Stream

+ func FromGstStreamUnsafeNone(stream unsafe.Pointer) *Stream

+ func NewStream(id string, caps *Caps, sType StreamType, flags StreamFlags) *Stream

+ func (s *Stream) Caps() *Caps

+ func (s *Stream) Instance() *C.GstStream

+ func (s *Stream) SetCaps(caps *Caps)

+ func (s *Stream) SetStreamFlags(flags StreamFlags)

+ func (s *Stream) SetStreamType(sType StreamType)

+ func (s *Stream) SetTags(tags *TagList)

+ func (s *Stream) StreamFlags() StreamFlags

+ func (s *Stream) StreamID() string

+ func (s *Stream) StreamType() StreamType

+ func (s *Stream) Tags() *TagList

+ type StreamCollection struct

+ func FromGstStreamCollectionUnsafeFull(stream unsafe.Pointer) *StreamCollection

+ func FromGstStreamCollectionUnsafeNone(stream unsafe.Pointer) *StreamCollection

+ func NewStreamCollection(upstreamID string) *StreamCollection

+ func (s *StreamCollection) AddStream(stream *Stream) error

+ func (s *StreamCollection) GetSize() uint

+ func (s *StreamCollection) GetStreamAt(idx uint) *Stream

+ func (s *StreamCollection) GetUpstreamID() string

+ func (s *StreamCollection) Instance() *C.GstStreamCollection

+ type StreamFlags int

+ const StreamFlagNone

+ const StreamFlagSelect

+ const StreamFlagSparse

+ const StreamFlagUnselect

+ type StreamStatusType int

+ const StreamStatusCreate

+ const StreamStatusDestroy

+ const StreamStatusEnter

+ const StreamStatusLeave

+ const StreamStatusPause

+ const StreamStatusStart

+ const StreamStatusStop

+ func (s StreamStatusType) String() string

+ type StreamType int

+ const StreamTypeAudio

+ const StreamTypeContainer

+ const StreamTypeText

+ const StreamTypeUnknown

+ const StreamTypeVideo

+ func (s StreamType) String() string

+ type Structure struct

+ func FromGstStructureUnsafe(st unsafe.Pointer) *Structure

+ func MarshalStructure(data interface{}) *Structure

+ func NewStructure(name string) *Structure

+ func NewStructureFromString(stStr string) *Structure

+ func ValueGetStructure(gval *glib.Value) *Structure

+ func (s *Structure) Free()

+ func (s *Structure) GetValue(key string) (interface{}, error)

+ func (s *Structure) Instance() *C.GstStructure

+ func (s *Structure) Name() string

+ func (s *Structure) RemoveValue(key string)

+ func (s *Structure) SetValue(key string, value interface{}) error

+ func (s *Structure) Size() int

+ func (s *Structure) String() string

+ func (s *Structure) ToGValue() (*glib.Value, error)

+ func (s *Structure) UnmarshalInto(data interface{}) error

+ func (s *Structure) Values() map[string]interface{}

+ type StructureChangeType int

+ const StructureChangePadLink

+ const StructureChangePadUnlink

+ func (s StructureChangeType) String() string

+ type SystemClock struct

+ func ObtainSystemClock() *SystemClock

+ type TOC struct

+ func FromGstTOCUnsafeFull(toc unsafe.Pointer) *TOC

+ func FromGstTOCUnsafeNone(toc unsafe.Pointer) *TOC

+ func NewTOC(scope TOCScope) *TOC

+ func (t *TOC) AppendEntry(entry *TOCEntry)

+ func (t *TOC) Copy() *TOC

+ func (t *TOC) Dump()

+ func (t *TOC) FindEntry(uid string) *TOCEntry

+ func (t *TOC) GetEntries() []*TOCEntry

+ func (t *TOC) GetScope() TOCScope

+ func (t *TOC) GetTags() *TagList

+ func (t *TOC) Instance() *C.GstToc

+ func (t *TOC) MakeWritable() *TOC

+ func (t *TOC) MergeTags(tagList *TagList, mergeMode TagMergeMode)

+ func (t *TOC) Ref() *TOC

+ func (t *TOC) SetTags(tagList *TagList)

+ func (t *TOC) Unref()

+ type TOCEntry struct

+ func FromGstTocEntryUnsafeFull(entry unsafe.Pointer) *TOCEntry

+ func FromGstTocEntryUnsafeNone(entry unsafe.Pointer) *TOCEntry

+ func NewTOCEntry(entryType TOCEntryType, uid string) *TOCEntry

+ func (t *TOCEntry) AppendSubEntry(subEntry *TOCEntry)

+ func (t *TOCEntry) Copy() *TOCEntry

+ func (t *TOCEntry) GetEntryType() TOCEntryType

+ func (t *TOCEntry) GetEntryTypeString() string

+ func (t *TOCEntry) GetLoop() (bool, TOCLoopType, int)

+ func (t *TOCEntry) GetParent() *TOCEntry

+ func (t *TOCEntry) GetStartStopTimes() (ok bool, startTime, stopTime int64)

+ func (t *TOCEntry) GetSubEntries() []*TOCEntry

+ func (t *TOCEntry) GetTOC() *TOC

+ func (t *TOCEntry) GetTags() *TagList

+ func (t *TOCEntry) GetUID() string

+ func (t *TOCEntry) Instance() *C.GstTocEntry

+ func (t *TOCEntry) IsAlternative() bool

+ func (t *TOCEntry) IsSequence() bool

+ func (t *TOCEntry) MakeWritable() *TOCEntry

+ func (t *TOCEntry) MergeTags(tagList *TagList, mergeMode TagMergeMode)

+ func (t *TOCEntry) Ref() *TOCEntry

+ func (t *TOCEntry) SetLoop(loopType TOCLoopType, repeatCount int)

+ func (t *TOCEntry) SetStartStopTimes(startTime, stopTime int64)

+ func (t *TOCEntry) SetTags(tagList *TagList)

+ func (t *TOCEntry) Unref()

+ type TOCEntryType int

+ const TOCEntryTypeAngle

+ const TOCEntryTypeChapter

+ const TOCEntryTypeEdition

+ const TOCEntryTypeInvalid

+ const TOCEntryTypeTitle

+ const TOCEntryTypeTrack

+ const TOCEntryTypeVersion

+ type TOCLoopType int

+ const TOCLoopForward

+ const TOCLoopNone

+ const TOCLoopPingPong

+ const TOCLoopReverse

+ type TOCScope int

+ const TOCScopeCurrent

+ const TOCScopeGlobal

+ func (t TOCScope) String() string

+ type TOCSetter interface

+ GetTOC func() *TOC

+ Reset func()

+ SetTOC func(*TOC)

+ type Tag string

+ const TagAlbum

+ const TagAlbumArtist

+ const TagAlbumArtistSortName

+ const TagAlbumGain

+ const TagAlbumPeak

+ const TagAlbumSortName

+ const TagAlbumVolumeCount

+ const TagAlbumVolumeNumber

+ const TagApplicationData

+ const TagApplicationName

+ const TagArtist

+ const TagArtistSortName

+ const TagAttachment

+ const TagAudioCodec

+ const TagBeatsPerMinute

+ const TagBitrate

+ const TagCodec

+ const TagComment

+ const TagComposer

+ const TagComposerSortName

+ const TagConductor

+ const TagContact

+ const TagContainerFormat

+ const TagCopyright

+ const TagCopyrightURI

+ const TagDate

+ const TagDateTime

+ const TagDescription

+ const TagDeviceManufacturer

+ const TagDeviceModel

+ const TagDuration

+ const TagEncodedBy

+ const TagEncoder

+ const TagEncoderVersion

+ const TagExtendedComment

+ const TagGenre

+ const TagGeoLocationCaptureDirection

+ const TagGeoLocationCity

+ const TagGeoLocationCountry

+ const TagGeoLocationElevation

+ const TagGeoLocationHoriozontalError

+ const TagGeoLocationLatitude

+ const TagGeoLocationLongitude

+ const TagGeoLocationMovementDirection

+ const TagGeoLocationMovementSpeed

+ const TagGeoLocationName

+ const TagGeoLocationSubLocation

+ const TagGrouping

+ const TagHomepage

+ const TagISRC

+ const TagImage

+ const TagImageOrientation

+ const TagInterpretedBy

+ const TagKeywords

+ const TagLanguageCode

+ const TagLanguageName

+ const TagLicense

+ const TagLicenseURI

+ const TagLocation

+ const TagLyrics

+ const TagMIDIBaseNote

+ const TagMaximumBitrate

+ const TagMinimumBitrate

+ const TagNominalBitrate

+ const TagOrganization

+ const TagPerformer

+ const TagPreviewImage

+ const TagPrivateData

+ const TagPublisher

+ const TagReferenceLevel

+ const TagSerial

+ const TagShowEpisodeNumber

+ const TagShowName

+ const TagShowSeasonNumber

+ const TagShowSortName

+ const TagSubtitleCodec

+ const TagTitle

+ const TagTitleSortName

+ const TagTrackCount

+ const TagTrackGain

+ const TagTrackNumber

+ const TagTrackPeak

+ const TagUserRating

+ const TagVersion

+ const TagVideoCodec

+ type TagFlag int

+ const TagFlagCount

+ const TagFlagDecoded

+ const TagFlagEncoded

+ const TagFlagMeta

+ const TagFlagUndefined

+ type TagList struct

+ func FromGstTagListUnsafeFull(tags unsafe.Pointer) *TagList

+ func FromGstTagListUnsafeNone(tags unsafe.Pointer) *TagList

+ func NewEmptyTagList() *TagList

+ func NewTagListFromString(tags string) *TagList

+ func (t *TagList) AddValue(mergeMode TagMergeMode, tag Tag, value interface{})

+ func (t *TagList) AddValues(mergeMode TagMergeMode, tag Tag, vals ...interface{})

+ func (t *TagList) Copy() *TagList

+ func (t *TagList) ForEach(f TagListForEachFunc)

+ func (t *TagList) GetBool(tag Tag) (value, ok bool)

+ func (t *TagList) GetBoolIndex(tag Tag, idx uint) (value, ok bool)

+ func (t *TagList) GetDate(tag Tag) (value time.Time, ok bool)

+ func (t *TagList) GetDateIndex(tag Tag, idx uint) (value time.Time, ok bool)

+ func (t *TagList) GetDateTime(tag Tag) (value time.Time, ok bool)

+ func (t *TagList) GetDateTimeIndex(tag Tag, idx uint) (value time.Time, ok bool)

+ func (t *TagList) GetFloat32(tag Tag) (value float32, ok bool)

+ func (t *TagList) GetFloat32Index(tag Tag, idx uint) (value float32, ok bool)

+ func (t *TagList) GetFloat64(tag Tag) (value float64, ok bool)

+ func (t *TagList) GetFloat64Index(tag Tag, idx uint) (value float64, ok bool)

+ func (t *TagList) GetInt32(tag Tag) (value int32, ok bool)

+ func (t *TagList) GetInt32Index(tag Tag, idx uint) (value int32, ok bool)

+ func (t *TagList) GetInt64(tag Tag) (value int64, ok bool)

+ func (t *TagList) GetInt64Index(tag Tag, idx uint) (value int64, ok bool)

+ func (t *TagList) GetPointer(tag Tag) (value unsafe.Pointer, ok bool)

+ func (t *TagList) GetPointerIndex(tag Tag, idx uint) (value unsafe.Pointer, ok bool)

+ func (t *TagList) GetSample(tag Tag) (value *Sample, ok bool)

+ func (t *TagList) GetSampleIndex(tag Tag, idx uint) (value *Sample, ok bool)

+ func (t *TagList) GetScope() TagScope

+ func (t *TagList) GetString(tag Tag) (value string, ok bool)

+ func (t *TagList) GetStringIndex(tag Tag, idx uint) (value string, ok bool)

+ func (t *TagList) GetTagSize(tagKey string) int

+ func (t *TagList) GetUint32(tag Tag) (value uint32, ok bool)

+ func (t *TagList) GetUint32Index(tag Tag, idx uint) (value uint32, ok bool)

+ func (t *TagList) GetUint64(tag Tag) (value uint64, ok bool)

+ func (t *TagList) GetUint64Index(tag Tag, idx uint) (value uint64, ok bool)

+ func (t *TagList) GetValueIndex(tag Tag, idx uint) interface{}

+ func (t *TagList) Insert(tagList *TagList, mergeMode TagMergeMode)

+ func (t *TagList) Instance() *C.GstTagList

+ func (t *TagList) IsEmpty() bool

+ func (t *TagList) IsEqual(tagList *TagList) bool

+ func (t *TagList) IsWritable() bool

+ func (t *TagList) MakeWritable() *TagList

+ func (t *TagList) Merge(tagList *TagList, mergeMode TagMergeMode) *TagList

+ func (t *TagList) NumTags() int

+ func (t *TagList) PeekStringIndex(tag Tag, idx uint) (value string, ok bool)

+ func (t *TagList) Ref() *TagList

+ func (t *TagList) RemoveTag(tag Tag)

+ func (t *TagList) SetScope(scope TagScope)

+ func (t *TagList) String() string

+ func (t *TagList) TagNameAt(idx int) string

+ func (t *TagList) Unref()

+ type TagListForEachFunc func(tagList *TagList, tag Tag)

+ type TagMergeMode int

+ const TagMergeAppend

+ const TagMergeCount

+ const TagMergeKeep

+ const TagMergeKeepAll

+ const TagMergePrepend

+ const TagMergeReplace

+ const TagMergeReplaceAll

+ const TagMergeUndefined

+ type TagScope int

+ const TagScopeGlobal

+ const TagScopeStream

+ type TagSetter interface

+ AddTagValue func(mergeMode TagMergeMode, tagKey Tag, tagValue interface{})

+ GetTagList func() *TagList

+ GetTagMergeMode func() TagMergeMode

+ MergeTags func(*TagList, TagMergeMode)

+ ResetTags func()

+ SetTagMergeMode func(TagMergeMode)

+ type TaskState int

+ const TaskPaused

+ const TaskStarted

+ const TaskStopped

+ type TypeFindProbability int

+ const TypeFindLikely

+ const TypeFindMaximum

+ const TypeFindMinimum

+ const TypeFindNearlyCertain

+ const TypeFindNone

+ const TypeFindPossible

+ type URIHandler interface

+ GetProtocols func() []string

+ GetURI func() string

+ GetURIType func() URIType

+ SetURI func(string) (bool, error)

+ type URIType int

+ const URISink

+ const URISource

+ const URIUnknown

+ func (u URIType) String() string

+ type ValueArrayValue glib.Value

+ func ValueArray(ss []interface{}) *ValueArrayValue

+ func (v *ValueArrayValue) Size() uint

+ func (v *ValueArrayValue) ToGValue() (*glib.Value, error)

+ func (v *ValueArrayValue) ValueAt(idx uint) interface{}

+ type ValueCmp int

+ const ValueEqual

+ const ValueGreaterThan

+ const ValueLessThan

+ const ValueUnordered

+ func ValueCompare(value1, value2 *glib.Value) ValueCmp

+ type ValueListValue glib.Value

+ func ValueList(ss []interface{}) *ValueListValue

+ func (v *ValueListValue) Concat(value *ValueListValue) *ValueListValue

+ func (v *ValueListValue) Merge(value *ValueListValue) *ValueListValue

+ func (v *ValueListValue) Size() uint

+ func (v *ValueListValue) ToGValue() (*glib.Value, error)

+ func (v *ValueListValue) ValueAt(idx uint) interface{}

+ type Version int

+ const VersionMajor

+ const VersionMicro

+ const VersionMinor

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL