| Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
|---|---|
| License | LGPL-2.1 |
| Maintainer | Iñaki García Etxebarria |
| Safe Haskell | None |
| Language | Haskell2010 |
GI.Gst.Flags
Contents
- Flags
- AllocatorFlags
- BinFlags
- BufferCopyFlags
- BufferFlags
- BufferPoolAcquireFlags
- BusFlags
- CapsFlags
- ClockFlags
- DebugColorFlags
- DebugGraphDetails
- ElementFlags
- EventTypeFlags
- LockFlags
- MapFlags
- MemoryFlags
- MessageType
- MetaFlags
- MiniObjectFlags
- ObjectFlags
- PadFlags
- PadLinkCheck
- PadProbeType
- PadTemplateFlags
- ParseFlags
- PipelineFlags
- PluginDependencyFlags
- PluginFlags
- QueryTypeFlags
- SchedulingFlags
- SeekFlags
- SegmentFlags
- StackTraceFlags
- StreamFlags
- StreamType
- TracerValueFlags
Description
Synopsis
- data AllocatorFlags
- data BinFlags
- data BufferCopyFlags
- data BufferFlags
- = BufferFlagsLive
- | BufferFlagsDecodeOnly
- | BufferFlagsDiscont
- | BufferFlagsResync
- | BufferFlagsCorrupted
- | BufferFlagsMarker
- | BufferFlagsHeader
- | BufferFlagsGap
- | BufferFlagsDroppable
- | BufferFlagsDeltaUnit
- | BufferFlagsTagMemory
- | BufferFlagsSyncAfter
- | BufferFlagsNonDroppable
- | BufferFlagsLast
- | AnotherBufferFlags Int
- data BufferPoolAcquireFlags
- data BusFlags
- data CapsFlags
- data ClockFlags
- data DebugColorFlags
- = DebugColorFlagsFgBlack
- | DebugColorFlagsFgRed
- | DebugColorFlagsFgGreen
- | DebugColorFlagsFgYellow
- | DebugColorFlagsFgBlue
- | DebugColorFlagsFgMagenta
- | DebugColorFlagsFgCyan
- | DebugColorFlagsFgWhite
- | DebugColorFlagsBgBlack
- | DebugColorFlagsBgRed
- | DebugColorFlagsBgGreen
- | DebugColorFlagsBgYellow
- | DebugColorFlagsBgBlue
- | DebugColorFlagsBgMagenta
- | DebugColorFlagsBgCyan
- | DebugColorFlagsBgWhite
- | DebugColorFlagsBold
- | DebugColorFlagsUnderline
- | AnotherDebugColorFlags Int
- data DebugGraphDetails
- data ElementFlags
- data EventTypeFlags
- data LockFlags
- data MapFlags
- data MemoryFlags
- data MessageType
- = MessageTypeUnknown
- | MessageTypeEos
- | MessageTypeError
- | MessageTypeWarning
- | MessageTypeInfo
- | MessageTypeTag
- | MessageTypeBuffering
- | MessageTypeStateChanged
- | MessageTypeStateDirty
- | MessageTypeStepDone
- | MessageTypeClockProvide
- | MessageTypeClockLost
- | MessageTypeNewClock
- | MessageTypeStructureChange
- | MessageTypeStreamStatus
- | MessageTypeApplication
- | MessageTypeElement
- | MessageTypeSegmentStart
- | MessageTypeSegmentDone
- | MessageTypeDurationChanged
- | MessageTypeLatency
- | MessageTypeAsyncStart
- | MessageTypeAsyncDone
- | MessageTypeRequestState
- | MessageTypeStepStart
- | MessageTypeQos
- | MessageTypeProgress
- | MessageTypeToc
- | MessageTypeResetTime
- | MessageTypeStreamStart
- | MessageTypeNeedContext
- | MessageTypeHaveContext
- | MessageTypeExtended
- | MessageTypeDeviceAdded
- | MessageTypeDeviceRemoved
- | MessageTypePropertyNotify
- | MessageTypeStreamCollection
- | MessageTypeStreamsSelected
- | MessageTypeRedirect
- | MessageTypeDeviceChanged
- | MessageTypeAny
- | AnotherMessageType Int
- data MetaFlags
- data MiniObjectFlags
- data ObjectFlags
- data PadFlags
- = PadFlagsBlocked
- | PadFlagsFlushing
- | PadFlagsEos
- | PadFlagsBlocking
- | PadFlagsNeedParent
- | PadFlagsNeedReconfigure
- | PadFlagsPendingEvents
- | PadFlagsFixedCaps
- | PadFlagsProxyCaps
- | PadFlagsProxyAllocation
- | PadFlagsProxyScheduling
- | PadFlagsAcceptIntersect
- | PadFlagsAcceptTemplate
- | PadFlagsLast
- | AnotherPadFlags Int
- data PadLinkCheck
- data PadProbeType
- = PadProbeTypeInvalid
- | PadProbeTypeIdle
- | PadProbeTypeBlock
- | PadProbeTypeBuffer
- | PadProbeTypeBufferList
- | PadProbeTypeEventDownstream
- | PadProbeTypeEventUpstream
- | PadProbeTypeEventFlush
- | PadProbeTypeQueryDownstream
- | PadProbeTypeQueryUpstream
- | PadProbeTypePush
- | PadProbeTypePull
- | PadProbeTypeBlocking
- | PadProbeTypeDataDownstream
- | PadProbeTypeDataUpstream
- | PadProbeTypeDataBoth
- | PadProbeTypeBlockDownstream
- | PadProbeTypeBlockUpstream
- | PadProbeTypeEventBoth
- | PadProbeTypeQueryBoth
- | PadProbeTypeAllBoth
- | PadProbeTypeScheduling
- | AnotherPadProbeType Int
- data PadTemplateFlags
- data ParseFlags
- data PipelineFlags
- data PluginDependencyFlags
- data PluginFlags
- data QueryTypeFlags
- data SchedulingFlags
- data SeekFlags
- data SegmentFlags
- data StackTraceFlags
- data StreamFlags
- data StreamType
- data TracerValueFlags
Flags
AllocatorFlags
data AllocatorFlags Source #
Flags for allocators.
Constructors
| AllocatorFlagsCustomAlloc | The allocator has a custom alloc function. |
| AllocatorFlagsLast | first flag that can be used for custom purposes |
| AnotherAllocatorFlags Int | Catch-all for unknown values |
Instances
BinFlags
GstBinFlags are a set of flags specific to bins. Most are set/used internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro, and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET ().
Constructors
| BinFlagsNoResync | don't resync a state change when elements are added or linked in the bin (Since 1.0.5) |
| BinFlagsStreamsAware | Indicates whether the bin can handle elements that add/remove source pads at any point in time without first posting a no-more-pads signal (Since 1.10) |
| BinFlagsLast | the last enum in the series of flags for bins. Derived classes can use this as first value in a list of flags. |
| AnotherBinFlags Int | Catch-all for unknown values |
Instances
| Enum BinFlags Source # | |
| Eq BinFlags Source # | |
| Ord BinFlags Source # | |
Defined in GI.Gst.Flags | |
| Show BinFlags Source # | |
| IsGFlag BinFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags BinFlags Source # | |
Defined in GI.Gst.Flags | |
BufferCopyFlags
data BufferCopyFlags Source #
A set of flags that can be provided to the bufferCopyInto
function to specify which items should be copied.
Constructors
| BufferCopyFlagsNone | copy nothing |
| BufferCopyFlagsFlags | flag indicating that buffer flags should be copied |
| BufferCopyFlagsTimestamps | flag indicating that buffer pts, dts, duration, offset and offset_end should be copied |
| BufferCopyFlagsMeta | flag indicating that buffer meta should be copied |
| BufferCopyFlagsMemory | flag indicating that buffer memory should be reffed
and appended to already existing memory. Unless the memory is marked as
NO_SHARE, no actual copy of the memory is made but it is simply reffed.
Add |
| BufferCopyFlagsMerge | flag indicating that buffer memory should be merged |
| BufferCopyFlagsDeep | flag indicating that memory should always be copied instead of reffed (Since 1.2) |
| AnotherBufferCopyFlags Int | Catch-all for unknown values |
Instances
BufferFlags
data BufferFlags Source #
A set of buffer flags used to describe properties of a Buffer.
Constructors
| BufferFlagsLive | the buffer is live data and should be discarded in the PAUSED state. |
| BufferFlagsDecodeOnly | the buffer contains data that should be dropped because it will be clipped against the segment boundaries or because it does not contain data that should be shown to the user. |
| BufferFlagsDiscont | the buffer marks a data discontinuity in the stream. This typically occurs after a seek or a dropped buffer from a live or network source. |
| BufferFlagsResync | the buffer timestamps might have a discontinuity and this buffer is a good point to resynchronize. |
| BufferFlagsCorrupted | the buffer data is corrupted. |
| BufferFlagsMarker | the buffer contains a media specific marker. for video this is typically the end of a frame boundary, for audio this is usually the start of a talkspurt. |
| BufferFlagsHeader | the buffer contains header information that is needed to decode the following data. |
| BufferFlagsGap | the buffer has been created to fill a gap in the stream and contains media neutral data (elements can switch to optimized code path that ignores the buffer content). |
| BufferFlagsDroppable | the buffer can be dropped without breaking the stream, for example to reduce bandwidth. |
| BufferFlagsDeltaUnit | this unit cannot be decoded independently. |
| BufferFlagsTagMemory | this flag is set when memory of the buffer is added/removed |
| BufferFlagsSyncAfter | Elements which write to disk or permanent storage should ensure the data is synced after writing the contents of this buffer. (Since 1.6) |
| BufferFlagsNonDroppable | This buffer is important and should not be dropped. This can be used to mark important buffers, e.g. to flag RTP packets carrying keyframes or codec setup data for RTP Forward Error Correction purposes, or to prevent still video frames from being dropped by elements due to QoS. (Since 1.14) |
| BufferFlagsLast | additional media specific flags can be added starting from this flag. |
| AnotherBufferFlags Int | Catch-all for unknown values |
Instances
BufferPoolAcquireFlags
data BufferPoolAcquireFlags Source #
Additional flags to control the allocation of a buffer
Constructors
| BufferPoolAcquireFlagsNone | no flags |
| BufferPoolAcquireFlagsKeyUnit | buffer is keyframe |
| BufferPoolAcquireFlagsDontwait | when the bufferpool is empty, acquire_buffer
will by default block until a buffer is released into the pool again. Setting
this flag makes acquire_buffer return |
| BufferPoolAcquireFlagsDiscont | buffer is discont |
| BufferPoolAcquireFlagsLast | last flag, subclasses can use private flags starting from this value. |
| AnotherBufferPoolAcquireFlags Int | Catch-all for unknown values |
Instances
BusFlags
The standard flags that a bus may have.
Constructors
| BusFlagsFlushing | The bus is currently dropping all messages |
| BusFlagsFlagLast | offset to define more flags |
| AnotherBusFlags Int | Catch-all for unknown values |
Instances
| Enum BusFlags Source # | |
| Eq BusFlags Source # | |
| Ord BusFlags Source # | |
Defined in GI.Gst.Flags | |
| Show BusFlags Source # | |
| IsGFlag BusFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags BusFlags Source # | |
Defined in GI.Gst.Flags | |
CapsFlags
Extra flags for a caps.
Constructors
| CapsFlagsAny | Caps has no specific content, but can contain anything. |
| AnotherCapsFlags Int | Catch-all for unknown values |
Instances
| Enum CapsFlags Source # | |
Defined in GI.Gst.Flags Methods succ :: CapsFlags -> CapsFlags # pred :: CapsFlags -> CapsFlags # fromEnum :: CapsFlags -> Int # enumFrom :: CapsFlags -> [CapsFlags] # enumFromThen :: CapsFlags -> CapsFlags -> [CapsFlags] # enumFromTo :: CapsFlags -> CapsFlags -> [CapsFlags] # enumFromThenTo :: CapsFlags -> CapsFlags -> CapsFlags -> [CapsFlags] # | |
| Eq CapsFlags Source # | |
| Ord CapsFlags Source # | |
| Show CapsFlags Source # | |
| IsGFlag CapsFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags CapsFlags Source # | |
Defined in GI.Gst.Flags | |
ClockFlags
data ClockFlags Source #
The capabilities of this clock
Constructors
| ClockFlagsCanDoSingleSync | clock can do a single sync timeout request |
| ClockFlagsCanDoSingleAsync | clock can do a single async timeout request |
| ClockFlagsCanDoPeriodicSync | clock can do sync periodic timeout requests |
| ClockFlagsCanDoPeriodicAsync | clock can do async periodic timeout callbacks |
| ClockFlagsCanSetResolution | clock's resolution can be changed |
| ClockFlagsCanSetMaster | clock can be slaved to a master clock |
| ClockFlagsNeedsStartupSync | clock needs to be synced before it can be used (Since 1.6) |
| ClockFlagsLast | subclasses can add additional flags starting from this flag |
| AnotherClockFlags Int | Catch-all for unknown values |
Instances
DebugColorFlags
data DebugColorFlags Source #
These are some terminal style flags you can use when creating your debugging categories to make them stand out in debugging output.
Constructors
| DebugColorFlagsFgBlack | Use black as foreground color. |
| DebugColorFlagsFgRed | Use red as foreground color. |
| DebugColorFlagsFgGreen | Use green as foreground color. |
| DebugColorFlagsFgYellow | Use yellow as foreground color. |
| DebugColorFlagsFgBlue | Use blue as foreground color. |
| DebugColorFlagsFgMagenta | Use magenta as foreground color. |
| DebugColorFlagsFgCyan | Use cyan as foreground color. |
| DebugColorFlagsFgWhite | Use white as foreground color. |
| DebugColorFlagsBgBlack | Use black as background color. |
| DebugColorFlagsBgRed | Use red as background color. |
| DebugColorFlagsBgGreen | Use green as background color. |
| DebugColorFlagsBgYellow | Use yellow as background color. |
| DebugColorFlagsBgBlue | Use blue as background color. |
| DebugColorFlagsBgMagenta | Use magenta as background color. |
| DebugColorFlagsBgCyan | Use cyan as background color. |
| DebugColorFlagsBgWhite | Use white as background color. |
| DebugColorFlagsBold | Make the output bold. |
| DebugColorFlagsUnderline | Underline the output. |
| AnotherDebugColorFlags Int | Catch-all for unknown values |
Instances
DebugGraphDetails
data DebugGraphDetails Source #
Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE()
and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS().
Constructors
| DebugGraphDetailsMediaType | show caps-name on edges |
| DebugGraphDetailsCapsDetails | show caps-details on edges |
| DebugGraphDetailsNonDefaultParams | show modified parameters on elements |
| DebugGraphDetailsStates | show element states |
| DebugGraphDetailsFullParams | show full element parameter values even if they are very long |
| DebugGraphDetailsAll | show all the typical details that one might want |
| DebugGraphDetailsVerbose | show all details regardless of how large or verbose they make the resulting output |
| AnotherDebugGraphDetails Int | Catch-all for unknown values |
Instances
ElementFlags
data ElementFlags Source #
The standard flags that an element may have.
Constructors
| ElementFlagsLockedState | ignore state changes from parent |
| ElementFlagsSink | the element is a sink |
| ElementFlagsSource | the element is a source. |
| ElementFlagsProvideClock | the element can provide a clock |
| ElementFlagsRequireClock | the element requires a clock |
| ElementFlagsIndexable | the element can use an index |
| ElementFlagsLast | offset to define more flags |
| AnotherElementFlags Int | Catch-all for unknown values |
Instances
EventTypeFlags
data EventTypeFlags Source #
EventTypeFlags indicate the aspects of the different EventType
values. You can get the type flags of a EventType with the
eventTypeGetFlags function.
Constructors
| EventTypeFlagsUpstream | Set if the event can travel upstream. |
| EventTypeFlagsDownstream | Set if the event can travel downstream. |
| EventTypeFlagsSerialized | Set if the event should be serialized with data flow. |
| EventTypeFlagsSticky | Set if the event is sticky on the pads. |
| EventTypeFlagsStickyMulti | Multiple sticky events can be on a pad, each identified by the event name. |
| AnotherEventTypeFlags Int | Catch-all for unknown values |
Instances
LockFlags
Flags used when locking miniobjects
Constructors
| LockFlagsRead | lock for read access |
| LockFlagsWrite | lock for write access |
| LockFlagsExclusive | lock for exclusive access |
| LockFlagsLast | first flag that can be used for custom purposes |
| AnotherLockFlags Int | Catch-all for unknown values |
Instances
| Enum LockFlags Source # | |
Defined in GI.Gst.Flags Methods succ :: LockFlags -> LockFlags # pred :: LockFlags -> LockFlags # fromEnum :: LockFlags -> Int # enumFrom :: LockFlags -> [LockFlags] # enumFromThen :: LockFlags -> LockFlags -> [LockFlags] # enumFromTo :: LockFlags -> LockFlags -> [LockFlags] # enumFromThenTo :: LockFlags -> LockFlags -> LockFlags -> [LockFlags] # | |
| Eq LockFlags Source # | |
| Ord LockFlags Source # | |
| Show LockFlags Source # | |
| IsGFlag LockFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags LockFlags Source # | |
Defined in GI.Gst.Flags | |
MapFlags
Flags used when mapping memory
Constructors
| MapFlagsRead | map for read access |
| MapFlagsWrite | map for write access |
| MapFlagsFlagLast | first flag that can be used for custom purposes |
| AnotherMapFlags Int | Catch-all for unknown values |
Instances
| Enum MapFlags Source # | |
| Eq MapFlags Source # | |
| Ord MapFlags Source # | |
Defined in GI.Gst.Flags | |
| Show MapFlags Source # | |
| IsGFlag MapFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags MapFlags Source # | |
Defined in GI.Gst.Flags | |
MemoryFlags
data MemoryFlags Source #
Flags for wrapped memory.
Constructors
| MemoryFlagsReadonly | memory is readonly. It is not allowed to map the
memory with |
| MemoryFlagsNoShare | memory must not be shared. Copies will have to be made when this memory needs to be shared between buffers. |
| MemoryFlagsZeroPrefixed | the memory prefix is filled with 0 bytes |
| MemoryFlagsZeroPadded | the memory padding is filled with 0 bytes |
| MemoryFlagsPhysicallyContiguous | the memory is physically contiguous. (Since 1.2) |
| MemoryFlagsNotMappable | the memory can't be mapped via |
| MemoryFlagsLast | first flag that can be used for custom purposes |
| AnotherMemoryFlags Int | Catch-all for unknown values |
Instances
MessageType
data MessageType Source #
The different message types that are available.
Constructors
| MessageTypeUnknown | an undefined message |
| MessageTypeEos | end-of-stream reached in a pipeline. The application will only receive this message in the PLAYING state and every time it sets a pipeline to PLAYING that is in the EOS state. The application can perform a flushing seek in the pipeline, which will undo the EOS state again. |
| MessageTypeError | an error occurred. When the application receives an error message it should stop playback of the pipeline and not assume that more data will be played. |
| MessageTypeWarning | a warning occurred. |
| MessageTypeInfo | an info message occurred |
| MessageTypeTag | a tag was found. |
| MessageTypeBuffering | the pipeline is buffering. When the application receives a buffering message in the PLAYING state for a non-live pipeline it must PAUSE the pipeline until the buffering completes, when the percentage field in the message is 100%. For live pipelines, no action must be performed and the buffering percentage can be used to inform the user about the progress. |
| MessageTypeStateChanged | a state change happened |
| MessageTypeStateDirty | an element changed state in a streaming thread. This message is deprecated. |
| MessageTypeStepDone | a stepping operation finished. |
| MessageTypeClockProvide | an element notifies its capability of providing a clock. This message is used internally and never forwarded to the application. |
| MessageTypeClockLost | The current clock as selected by the pipeline became unusable. The pipeline will select a new clock on the next PLAYING state change. The application should set the pipeline to PAUSED and back to PLAYING when this message is received. |
| MessageTypeNewClock | a new clock was selected in the pipeline. |
| MessageTypeStructureChange | the structure of the pipeline changed. This message is used internally and never forwarded to the application. |
| MessageTypeStreamStatus | status about a stream, emitted when it starts, stops, errors, etc.. |
| MessageTypeApplication | message posted by the application, possibly via an application-specific element. |
| MessageTypeElement | element-specific message, see the specific element's documentation |
| MessageTypeSegmentStart | pipeline started playback of a segment. This message is used internally and never forwarded to the application. |
| MessageTypeSegmentDone | pipeline completed playback of a segment. This
message is forwarded to the application after all elements that posted
|
| MessageTypeDurationChanged | The duration of a pipeline changed. The application can get the new duration with a duration query. |
| MessageTypeLatency | Posted by elements when their latency changes. The application should recalculate and distribute a new latency. |
| MessageTypeAsyncStart | Posted by elements when they start an ASYNC
|
| MessageTypeAsyncDone | Posted by elements when they complete an ASYNC
|
| MessageTypeRequestState | Posted by elements when they want the pipeline to change state. This message is a suggestion to the application which can decide to perform the state change on (part of) the pipeline. |
| MessageTypeStepStart | A stepping operation was started. |
| MessageTypeQos | A buffer was dropped or an element changed its processing strategy for Quality of Service reasons. |
| MessageTypeProgress | A progress message. |
| MessageTypeToc | A new table of contents (TOC) was found or previously found TOC was updated. |
| MessageTypeResetTime | Message to request resetting the pipeline's running time from the pipeline. This is an internal message which applications will likely never receive. |
| MessageTypeStreamStart | Message indicating start of a new stream. Useful e.g. when using playbin in gapless playback mode, to get notified when the next title actually starts playing (which will be some time after the URI for the next title has been set). |
| MessageTypeNeedContext | Message indicating that an element wants a specific context (Since 1.2) |
| MessageTypeHaveContext | Message indicating that an element created a context (Since 1.2) |
| MessageTypeExtended | Message is an extended message type (see below).
These extended message IDs can't be used directly with mask-based API
like |
| MessageTypeDeviceAdded | Message indicating a |
| MessageTypeDeviceRemoved | Message indicating a |
| MessageTypePropertyNotify | Message indicating a |
| MessageTypeStreamCollection | Message indicating a new |
| MessageTypeStreamsSelected | Message indicating the active selection of
|
| MessageTypeRedirect | Message indicating to request the application to try to play the given URL(s). Useful if for example a HTTP 302/303 response is received with a non-HTTP URL inside. (Since 1.10) |
| MessageTypeDeviceChanged | Message indicating a |
| MessageTypeAny | mask for all of the above messages. |
| AnotherMessageType Int | Catch-all for unknown values |
Instances
MetaFlags
Extra metadata flags.
Constructors
| MetaFlagsNone | no flags |
| MetaFlagsReadonly | metadata should not be modified |
| MetaFlagsPooled | metadata is managed by a bufferpool |
| MetaFlagsLocked | metadata should not be removed |
| MetaFlagsLast | additional flags can be added starting from this flag. |
| AnotherMetaFlags Int | Catch-all for unknown values |
Instances
| Enum MetaFlags Source # | |
Defined in GI.Gst.Flags Methods succ :: MetaFlags -> MetaFlags # pred :: MetaFlags -> MetaFlags # fromEnum :: MetaFlags -> Int # enumFrom :: MetaFlags -> [MetaFlags] # enumFromThen :: MetaFlags -> MetaFlags -> [MetaFlags] # enumFromTo :: MetaFlags -> MetaFlags -> [MetaFlags] # enumFromThenTo :: MetaFlags -> MetaFlags -> MetaFlags -> [MetaFlags] # | |
| Eq MetaFlags Source # | |
| Ord MetaFlags Source # | |
| Show MetaFlags Source # | |
| IsGFlag MetaFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags MetaFlags Source # | |
Defined in GI.Gst.Flags | |
MiniObjectFlags
data MiniObjectFlags Source #
Flags for the mini object
Constructors
| MiniObjectFlagsLockable | the object can be locked and unlocked with
|
| MiniObjectFlagsLockReadonly | the object is permanently locked in READONLY mode. Only read locks can be performed on the object. |
| MiniObjectFlagsMayBeLeaked | the object is expected to stay alive
even after |
| MiniObjectFlagsLast | first flag that can be used by subclasses. |
| AnotherMiniObjectFlags Int | Catch-all for unknown values |
Instances
ObjectFlags
data ObjectFlags Source #
The standard flags that an gstobject may have.
Constructors
| ObjectFlagsMayBeLeaked | the object is expected to stay alive even
after |
| ObjectFlagsLast | subclasses can add additional flags starting from this flag |
| AnotherObjectFlags Int | Catch-all for unknown values |
Instances
PadFlags
Pad state flags
Constructors
| PadFlagsBlocked | is dataflow on a pad blocked |
| PadFlagsFlushing | is pad flushing |
| PadFlagsEos | is pad in EOS state |
| PadFlagsBlocking | is pad currently blocking on a buffer or event |
| PadFlagsNeedParent | ensure that there is a parent object before calling into the pad callbacks. |
| PadFlagsNeedReconfigure | the pad should be reconfigured/renegotiated. The flag has to be unset manually after reconfiguration happened. |
| PadFlagsPendingEvents | the pad has pending events |
| PadFlagsFixedCaps | the pad is using fixed caps. This means that once the caps are set on the pad, the default caps query function will only return those caps. |
| PadFlagsProxyCaps | the default event and query handler will forward all events and queries to the internally linked pads instead of discarding them. |
| PadFlagsProxyAllocation | the default query handler will forward allocation queries to the internally linked pads instead of discarding them. |
| PadFlagsProxyScheduling | the default query handler will forward scheduling queries to the internally linked pads instead of discarding them. |
| PadFlagsAcceptIntersect | the default accept-caps handler will check it the caps intersect the query-caps result instead of checking for a subset. This is interesting for parsers that can accept incompletely specified caps. |
| PadFlagsAcceptTemplate | the default accept-caps handler will use
the template pad caps instead of query caps to
compare with the accept caps. Use this in combination
with |
| PadFlagsLast | offset to define more flags |
| AnotherPadFlags Int | Catch-all for unknown values |
Instances
| Enum PadFlags Source # | |
| Eq PadFlags Source # | |
| Ord PadFlags Source # | |
Defined in GI.Gst.Flags | |
| Show PadFlags Source # | |
| IsGFlag PadFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags PadFlags Source # | |
Defined in GI.Gst.Flags | |
PadLinkCheck
data PadLinkCheck Source #
The amount of checking to be done when linking pads. gSTPADLINKCHECKCAPS
and gSTPADLINKCHECKTEMPLATECAPS are mutually exclusive. If both are
specified, expensive but safe gSTPADLINKCHECKCAPS are performed.
Only disable some of the checks if you are 100% certain you know the link
will not fail because of hierarchy\/caps compatibility failures. If uncertain,
use the default checks ('GI.Gst.Flags.PadLinkCheckDefault') or the regular methods
for linking the pads.Constructors
| PadLinkCheckNothing | Don't check hierarchy or caps compatibility. |
| PadLinkCheckHierarchy | Check the pads have same parents/grandparents. Could be omitted if it is already known that the two elements that own the pads are in the same bin. |
| PadLinkCheckTemplateCaps | Check if the pads are compatible by using
their template caps. This is much faster than |
| PadLinkCheckCaps | Check if the pads are compatible by comparing the
caps returned by |
| PadLinkCheckNoReconfigure | Disables pushing a reconfigure event when pads are linked. |
| PadLinkCheckDefault | The default checks done when linking
pads (i.e. the ones used by |
| AnotherPadLinkCheck Int | Catch-all for unknown values |
Instances
PadProbeType
data PadProbeType Source #
The different probing types that can occur. When either one of
gSTPADPROBETYPEIDLE or gSTPADPROBETYPEBLOCK is used, the probe will be a
blocking probe.
Constructors
| PadProbeTypeInvalid | invalid probe type |
| PadProbeTypeIdle | probe idle pads and block while the callback is called |
| PadProbeTypeBlock | probe and block pads |
| PadProbeTypeBuffer | probe buffers |
| PadProbeTypeBufferList | probe buffer lists |
| PadProbeTypeEventDownstream | probe downstream events |
| PadProbeTypeEventUpstream | probe upstream events |
| PadProbeTypeEventFlush | probe flush events. This probe has to be
explicitly enabled and is not included in the
@ |
| PadProbeTypeQueryDownstream | probe downstream queries |
| PadProbeTypeQueryUpstream | probe upstream queries |
| PadProbeTypePush | probe push |
| PadProbeTypePull | probe pull |
| PadProbeTypeBlocking | probe and block at the next opportunity, at data flow or when idle |
| PadProbeTypeDataDownstream | probe downstream data (buffers, buffer lists, and events) |
| PadProbeTypeDataUpstream | probe upstream data (events) |
| PadProbeTypeDataBoth | probe upstream and downstream data (buffers, buffer lists, and events) |
| PadProbeTypeBlockDownstream | probe and block downstream data (buffers, buffer lists, and events) |
| PadProbeTypeBlockUpstream | probe and block upstream data (events) |
| PadProbeTypeEventBoth | probe upstream and downstream events |
| PadProbeTypeQueryBoth | probe upstream and downstream queries |
| PadProbeTypeAllBoth | probe upstream events and queries and downstream buffers, buffer lists, events and queries |
| PadProbeTypeScheduling | probe push and pull |
| AnotherPadProbeType Int | Catch-all for unknown values |
Instances
PadTemplateFlags
data PadTemplateFlags Source #
Flags for the padtemplate
Constructors
| PadTemplateFlagsLast | first flag that can be used by subclasses. |
| AnotherPadTemplateFlags Int | Catch-all for unknown values |
Instances
ParseFlags
data ParseFlags Source #
Parsing options.
Constructors
| ParseFlagsNone | Do not use any special parsing options. |
| ParseFlagsFatalErrors | Always return |
| ParseFlagsNoSingleElementBins | If a bin only has a single element, just return the element. |
| ParseFlagsPlaceInBin | If more than one toplevel element is described
by the pipeline description string, put them in a |
| AnotherParseFlags Int | Catch-all for unknown values |
Instances
PipelineFlags
data PipelineFlags Source #
Pipeline flags
Constructors
| PipelineFlagsFixedClock | this pipeline works with a fixed clock |
| PipelineFlagsLast | offset to define more flags |
| AnotherPipelineFlags Int | Catch-all for unknown values |
Instances
PluginDependencyFlags
data PluginDependencyFlags Source #
Flags used in connection with pluginAddDependency.
Constructors
| PluginDependencyFlagsNone | no special flags |
| PluginDependencyFlagsRecurse | recurse into subdirectories |
| PluginDependencyFlagsPathsAreDefaultOnly | use paths argument only if none of the environment variables is set |
| PluginDependencyFlagsFileNameIsSuffix | interpret filename argument as filter suffix and check all matching files in the directory |
| PluginDependencyFlagsFileNameIsPrefix | interpret filename argument as filter prefix and check all matching files in the directory. Since 1.8. |
| PluginDependencyFlagsPathsAreRelativeToExe | interpret non-absolute paths as relative to the main executable directory. Since 1.14. |
| AnotherPluginDependencyFlags Int | Catch-all for unknown values |
Instances
PluginFlags
data PluginFlags Source #
The plugin loading state
Constructors
| PluginFlagsCached | Temporarily loaded plugins |
| PluginFlagsBlacklisted | The plugin won't be scanned (again) |
| AnotherPluginFlags Int | Catch-all for unknown values |
Instances
QueryTypeFlags
data QueryTypeFlags Source #
QueryTypeFlags indicate the aspects of the different QueryType
values. You can get the type flags of a QueryType with the
queryTypeGetFlags function.
Constructors
| QueryTypeFlagsUpstream | Set if the query can travel upstream. |
| QueryTypeFlagsDownstream | Set if the query can travel downstream. |
| QueryTypeFlagsSerialized | Set if the query should be serialized with data flow. |
| AnotherQueryTypeFlags Int | Catch-all for unknown values |
Instances
SchedulingFlags
data SchedulingFlags Source #
The different scheduling flags.
Constructors
| SchedulingFlagsSeekable | if seeking is possible |
| SchedulingFlagsSequential | if sequential access is recommended |
| SchedulingFlagsBandwidthLimited | if bandwidth is limited and buffering possible (since 1.2) |
| AnotherSchedulingFlags Int | Catch-all for unknown values |
Instances
SeekFlags
Flags to be used with elementSeek or eventNewSeek. All flags
can be used together.
A non flushing seek might take some time to perform as the currently playing data in the pipeline will not be cleared.
An accurate seek might be slower for formats that don't have any indexes or timestamp markers in the stream. Specifying this flag might require a complete scan of the file in those cases.
When performing a segment seek: after the playback of the segment completes,
no EOS will be emitted by the element that performed the seek, but a
MessageTypeSegmentDone message will be posted on the bus by the element.
When this message is posted, it is possible to send a new seek event to
continue playback. With this seek method it is possible to perform seamless
looping or simple linear editing.
When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode
playback, the SeekFlagsTrickmode flag can be used to instruct decoders
and demuxers to adjust the playback rate by skipping frames. This can improve
performance and decrease CPU usage because not all frames need to be decoded.
Beyond that, the SeekFlagsTrickmodeKeyUnits flag can be used to
request that decoders skip all frames except key units, and
SeekFlagsTrickmodeNoAudio flags can be used to request that audio
decoders do no decoding at all, and simple output silence.
The SeekFlagsSnapBefore flag can be used to snap to the previous
relevant location, and the SeekFlagsSnapAfter flag can be used to
select the next relevant location. If SeekFlagsKeyUnit is specified,
the relevant location is a keyframe. If both flags are specified, the nearest
of these locations will be selected. If none are specified, the implementation is
free to select whichever it wants.
The before and after here are in running time, so when playing backwards, the next location refers to the one that will played in next, and not the one that is located after in the actual source stream.
Also see part-seeking.txt in the GStreamer design documentation for more details on the meaning of these flags and the behaviour expected of elements that handle them.
Constructors
| SeekFlagsNone | no flag |
| SeekFlagsFlush | flush pipeline |
| SeekFlagsAccurate | accurate position is requested, this might be considerably slower for some formats. |
| SeekFlagsKeyUnit | seek to the nearest keyframe. This might be faster but less accurate. |
| SeekFlagsSegment | perform a segment seek. |
| SeekFlagsTrickmode | when doing fast forward or fast reverse playback, allow elements to skip frames instead of generating all frames. (Since 1.6) |
| SeekFlagsSkip | Deprecated backward compatibility flag, replaced
by |
| SeekFlagsSnapBefore | go to a location before the requested position,
if |
| SeekFlagsSnapAfter | go to a location after the requested position,
if |
| SeekFlagsSnapNearest | go to a position near the requested position,
if |
| SeekFlagsTrickmodeKeyUnits | when doing fast forward or fast reverse playback, request that elements only decode keyframes and skip all other content, for formats that have keyframes. (Since 1.6) |
| SeekFlagsTrickmodeNoAudio | when doing fast forward or fast reverse playback, request that audio decoder elements skip decoding and output only gap events or silence. (Since 1.6) |
| AnotherSeekFlags Int | Catch-all for unknown values |
Instances
| Enum SeekFlags Source # | |
Defined in GI.Gst.Flags Methods succ :: SeekFlags -> SeekFlags # pred :: SeekFlags -> SeekFlags # fromEnum :: SeekFlags -> Int # enumFrom :: SeekFlags -> [SeekFlags] # enumFromThen :: SeekFlags -> SeekFlags -> [SeekFlags] # enumFromTo :: SeekFlags -> SeekFlags -> [SeekFlags] # enumFromThenTo :: SeekFlags -> SeekFlags -> SeekFlags -> [SeekFlags] # | |
| Eq SeekFlags Source # | |
| Ord SeekFlags Source # | |
| Show SeekFlags Source # | |
| IsGFlag SeekFlags Source # | |
Defined in GI.Gst.Flags | |
| BoxedFlags SeekFlags Source # | |
Defined in GI.Gst.Flags | |
SegmentFlags
data SegmentFlags Source #
Flags for the GstSegment structure. Currently mapped to the corresponding values of the seek flags.
Constructors
| SegmentFlagsNone | no flags |
| SegmentFlagsReset | reset the pipeline running_time to the segment running_time |
| SegmentFlagsTrickmode | perform skip playback (Since 1.6) |
| SegmentFlagsSkip | Deprecated backward compatibility flag, replaced
by |
| SegmentFlagsSegment | send SEGMENT_DONE instead of EOS |
| SegmentFlagsTrickmodeKeyUnits | Decode only keyframes, where possible (Since 1.6) |
| SegmentFlagsTrickmodeNoAudio | Do not decode any audio, where possible (Since 1.6) |
| AnotherSegmentFlags Int | Catch-all for unknown values |
Instances
StackTraceFlags
data StackTraceFlags Source #
No description available in the introspection data.
Since: 1.12
Constructors
| StackTraceFlagsFull | Try to retrieve as much information as possible when getting the stack trace |
| AnotherStackTraceFlags Int | Catch-all for unknown values |
Instances
StreamFlags
data StreamFlags Source #
No description available in the introspection data.
Since: 1.2
Constructors
| StreamFlagsNone | This stream has no special attributes |
| StreamFlagsSparse | This stream is a sparse stream (e.g. a subtitle stream), data may flow only in irregular intervals with large gaps in between. |
| StreamFlagsSelect | This stream should be selected by default. This flag may be used by demuxers to signal that a stream should be selected by default in a playback scenario. |
| StreamFlagsUnselect | This stream should not be selected by default. This flag may be used by demuxers to signal that a stream should not be selected by default in a playback scenario, but only if explicitly selected by the user (e.g. an audio track for the hard of hearing or a director's commentary track). |
| AnotherStreamFlags Int | Catch-all for unknown values |
Instances
StreamType
data StreamType Source #
StreamType describes a high level classification set for
flows of data in Stream objects.
Note that this is a flag, and therefore users should not assume it will be a single value. Do not use the equality operator for checking whether a stream is of a certain type.
Since: 1.10
Constructors
| StreamTypeUnknown | The stream is of unknown (unclassified) type. |
| StreamTypeAudio | The stream is of audio data |
| StreamTypeVideo | The stream carries video data |
| StreamTypeContainer | The stream is a muxed container type |
| StreamTypeText | The stream contains subtitle / subpicture data. |
| AnotherStreamType Int | Catch-all for unknown values |
Instances
TracerValueFlags
data TracerValueFlags Source #
Flag that describe the value. These flags help applications processing the logs to understand the values.
Constructors
| TracerValueFlagsNone | no flags |
| TracerValueFlagsOptional | the value is optional. When using this flag
one need to have an additional boolean arg before this value in the
var-args list passed to |
| TracerValueFlagsAggregated | the value is a combined figure, since the start of tracing. Examples are averages or timestamps. |
| AnotherTracerValueFlags Int | Catch-all for unknown values |