Flags

Details

class Gst.AllocatorFlags(value)

Bases: GObject.GFlags

Flags for allocators.

LAST = 1048576

first flag that can be used for custom purposes

CUSTOM_ALLOC = 16

The allocator has a custom alloc function.

class Gst.BinFlags(value)

Bases: GObject.GFlags

Gst.BinFlags 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 ().

NO_RESYNC = 16384

don’t resync a state change when elements are added or linked in the bin (Since 1.0.5)

STREAMS_AWARE = 32768

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)

LAST = 524288

the last enum in the series of flags for bins. Derived classes can use this as first value in a list of flags.

class Gst.BufferCopyFlags(value)

Bases: GObject.GFlags

A set of flags that can be provided to the Gst.Buffer.copy_into() function to specify which items should be copied.

NONE = 0

copy nothing

FLAGS = 1

flag indicating that buffer flags should be copied

MERGE = 16

flag indicating that buffer memory should be merged

TIMESTAMPS = 2

flag indicating that buffer pts, dts, duration, offset and offset_end should be copied

DEEP = 32

flag indicating that memory should always be copied instead of reffed (Since 1.2)

META = 4

flag indicating that buffer meta should be copied

MEMORY = 8

flag indicating that buffer memory should be reffed and appended to already existing memory. Unless the memory is marked as NO_SHARE, no actual copy of the memory is made but it is simply reffed. Add Gst.BufferCopyFlags.DEEP to force a real copy.

class Gst.BufferFlags(value)

Bases: GObject.GFlags

A set of buffer flags used to describe properties of a Gst.Buffer.

HEADER = 1024

the buffer contains header information that is needed to decode the following data.

LAST = 1048576

additional media specific flags can be added starting from this flag.

RESYNC = 128

the buffer timestamps might have a discontinuity and this buffer is a good point to resynchronize.

LIVE = 16

the buffer is live data and should be discarded in the PAUSED state.

TAG_MEMORY = 16384

this flag is set when memory of the buffer is added/removed

GAP = 2048

the buffer has been created to fill a gap in the stream and contains media neutral data (elements can switch to optimized code path that ignores the buffer content).

CORRUPTED = 256

the buffer data is corrupted.

DECODE_ONLY = 32

the buffer contains data that should be dropped because it will be clipped against the segment boundaries or because it does not contain data that should be shown to the user.

SYNC_AFTER = 32768

Elements which write to disk or permanent storage should ensure the data is synced after writing the contents of this buffer. (Since 1.6)

DROPPABLE = 4096

the buffer can be dropped without breaking the stream, for example to reduce bandwidth.

MARKER = 512

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.

DISCONT = 64

the buffer marks a data discontinuity in the stream. This typically occurs after a seek or a dropped buffer from a live or network source.

NON_DROPPABLE = 65536

This buffer is important and should not be dropped. This can be used to mark important buffers, e.g. to flag RTP packets carrying keyframes or codec setup data for RTP Forward Error Correction purposes, or to prevent still video frames from being dropped by elements due to QoS. (Since 1.14)

DELTA_UNIT = 8192

this unit cannot be decoded independently.

class Gst.BufferPoolAcquireFlags(value)

Bases: GObject.GFlags

Additional flags to control the allocation of a buffer

NONE = 0

no flags

KEY_UNIT = 1

buffer is keyframe

DONTWAIT = 2

when the bufferpool is empty, acquire_buffer will by default block until a buffer is released into the pool again. Setting this flag makes acquire_buffer return Gst.FlowReturn.EOS instead of blocking.

DISCONT = 4

buffer is discont

LAST = 65536

last flag, subclasses can use private flags starting from this value.

class Gst.BusFlags(value)

Bases: GObject.GFlags

The standard flags that a bus may have.

FLUSHING = 16

The bus is currently dropping all messages

FLAG_LAST = 32

offset to define more flags

class Gst.CapsFlags(value)

Bases: GObject.GFlags

Extra flags for a caps.

ANY = 16

Caps has no specific content, but can contain anything.

class Gst.ClockFlags(value)

Bases: GObject.GFlags

The capabilities of this clock

NEEDS_STARTUP_SYNC = 1024

clock needs to be synced before it can be used (Since 1.6)

CAN_DO_PERIODIC_ASYNC = 128

clock can do async periodic timeout callbacks

CAN_DO_SINGLE_SYNC = 16

clock can do a single sync timeout request

CAN_SET_RESOLUTION = 256

clock’s resolution can be changed

CAN_DO_SINGLE_ASYNC = 32

clock can do a single async timeout request

LAST = 4096

subclasses can add additional flags starting from this flag

CAN_SET_MASTER = 512

clock can be slaved to a master clock

CAN_DO_PERIODIC_SYNC = 64

clock can do sync periodic timeout requests

class Gst.DebugColorFlags(value)

Bases: GObject.GFlags

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

BG_BLACK = 0

Use black as background color.

FG_BLACK = 0

Use black as foreground color.

FG_RED = 1

Use red as foreground color.

BG_WHITE = 112

Use white as background color.

BG_RED = 16

Use red as background color.

FG_GREEN = 2

Use green as foreground color.

BOLD = 256

Make the output bold.

FG_YELLOW = 3

Use yellow as foreground color.

BG_GREEN = 32

Use green as background color.

FG_BLUE = 4

Use blue as foreground color.

BG_YELLOW = 48

Use yellow as background color.

FG_MAGENTA = 5

Use magenta as foreground color.

UNDERLINE = 512

Underline the output.

FG_CYAN = 6

Use cyan as foreground color.

BG_BLUE = 64

Use blue as background color.

FG_WHITE = 7

Use white as foreground color.

BG_MAGENTA = 80

Use magenta as background color.

BG_CYAN = 96

Use cyan as background color.

class Gst.DebugGraphDetails(value)

Bases: GObject.GFlags

Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE() and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS().

VERBOSE = -1

show all details regardless of how large or verbose they make the resulting output

MEDIA_TYPE = 1

show caps-name on edges

ALL = 15

show all the typical details that one might want

FULL_PARAMS = 16

show full element parameter values even if they are very long

CAPS_DETAILS = 2

show caps-details on edges

NON_DEFAULT_PARAMS = 4

show modified parameters on elements

STATES = 8

show element states

class Gst.ElementFlags(value)

Bases: GObject.GFlags

The standard flags that an element may have.

PROVIDE_CLOCK = 128

the element can provide a clock

LOCKED_STATE = 16

ignore state changes from parent

LAST = 16384

offset to define more flags

REQUIRE_CLOCK = 256

the element requires a clock

SINK = 32

the element is a sink

INDEXABLE = 512

the element can use an index

SOURCE = 64

the element is a source.

class Gst.EventTypeFlags(value)

Bases: GObject.GFlags

Gst.EventTypeFlags indicate the aspects of the different Gst.EventType values. You can get the type flags of a Gst.EventType with the Gst.EventType.get_flags() function.

UPSTREAM = 1

Set if the event can travel upstream.

STICKY_MULTI = 16

Multiple sticky events can be on a pad, each identified by the event name.

DOWNSTREAM = 2

Set if the event can travel downstream.

SERIALIZED = 4

Set if the event should be serialized with data flow.

STICKY = 8

Set if the event is sticky on the pads.

class Gst.LockFlags(value)

Bases: GObject.GFlags

Flags used when locking miniobjects

READ = 1

lock for read access

WRITE = 2

lock for write access

LAST = 256

first flag that can be used for custom purposes

EXCLUSIVE = 4

lock for exclusive access

class Gst.MapFlags(value)

Bases: GObject.GFlags

Flags used when mapping memory

READ = 1

map for read access

WRITE = 2

map for write access

FLAG_LAST = 65536

first flag that can be used for custom purposes

class Gst.MemoryFlags(value)

Bases: GObject.GFlags

Flags for wrapped memory.

LAST = 1048576

first flag that can be used for custom purposes

PHYSICALLY_CONTIGUOUS = 128

the memory is physically contiguous. (Since 1.2)

NO_SHARE = 16

memory must not be shared. Copies will have to be made when this memory needs to be shared between buffers.

READONLY = 2

memory is readonly. It is not allowed to map the memory with Gst.MapFlags.WRITE.

NOT_MAPPABLE = 256

the memory can’t be mapped via Gst.Memory.map() without any preconditions. (Since 1.2)

ZERO_PREFIXED = 32

the memory prefix is filled with 0 bytes

ZERO_PADDED = 64

the memory padding is filled with 0 bytes

class Gst.MessageType(value)

Bases: GObject.GFlags

The different message types that are available.

ANY = -1

mask for all of the above messages.

REDIRECT = -2147483642

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)

STREAMS_SELECTED = -2147483643

Message indicating the active selection of Gst.Streams has changed (Since 1.10)

STREAM_COLLECTION = -2147483644

Message indicating a new Gst.StreamCollection is available (Since 1.10)

PROPERTY_NOTIFY = -2147483645

Message indicating a GObject.Object property has changed (Since 1.10)

DEVICE_REMOVED = -2147483646

Message indicating a Gst.Device was removed from a Gst.DeviceProvider (Since 1.4)

DEVICE_ADDED = -2147483647

Message indicating a Gst.Device was added to a Gst.DeviceProvider (Since 1.4)

EXTENDED = -2147483648

Message is an extended message type (see below). These extended message IDs can’t be used directly with mask-based API like Gst.Bus.poll() or Gst.Bus.timed_pop_filtered(), but you can still filter for Gst.MessageType.EXTENDED and then check the result for the specific type. (Since 1.4)

UNKNOWN = 0

an undefined message

EOS = 1

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.

CLOCK_LOST = 1024

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.

ASYNC_START = 1048576

Posted by elements when they start an ASYNC Gst.StateChange. This message is not forwarded to the application but is used internally.

HAVE_CONTEXT = 1073741824

Message indicating that an element created a context (Since 1.2)

STATE_DIRTY = 128

an element changed state in a streaming thread. This message is deprecated.

SEGMENT_DONE = 131072

pipeline completed playback of a segment. This message is forwarded to the application after all elements that posted Gst.MessageType.SEGMENT_START posted a Gst.MessageType.SEGMENT_DONE message.

RESET_TIME = 134217728

Message to request resetting the pipeline’s running time from the pipeline. This is an internal message which applications will likely never receive.

TAG = 16

a tag was found.

APPLICATION = 16384

message posted by the application, possibly via an application-specific element.

QOS = 16777216

A buffer was dropped or an element changed its processing strategy for Quality of Service reasons.

ERROR = 2

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.

NEW_CLOCK = 2048

a new clock was selected in the pipeline.

ASYNC_DONE = 2097152

Posted by elements when they complete an ASYNC Gst.StateChange. The application will only receive this message from the toplevel pipeline.

STEP_DONE = 256

a stepping operation finished.

DURATION_CHANGED = 262144

The duration of a pipeline changed. The application can get the new duration with a duration query.

STREAM_START = 268435456

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

BUFFERING = 32

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.

ELEMENT = 32768

element-specific message, see the specific element’s documentation

PROGRESS = 33554432

A progress message.

WARNING = 4

a warning occurred.

STRUCTURE_CHANGE = 4096

the structure of the pipeline changed. This message is used internally and never forwarded to the application.

REQUEST_STATE = 4194304

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.

CLOCK_PROVIDE = 512

an element notifies its capability of providing a clock. This message is used internally and never forwarded to the application.

LATENCY = 524288

Posted by elements when their latency changes. The application should recalculate and distribute a new latency.

NEED_CONTEXT = 536870912

Message indicating that an element wants a specific context (Since 1.2)

STATE_CHANGED = 64

a state change happened

SEGMENT_START = 65536

pipeline started playback of a segment. This message is used internally and never forwarded to the application.

TOC = 67108864

A new table of contents (TOC) was found or previously found TOC was updated.

INFO = 8

an info message occurred

STREAM_STATUS = 8192

status about a stream, emitted when it starts, stops, errors, etc..

STEP_START = 8388608

A stepping operation was started.

class Gst.MetaFlags(value)

Bases: GObject.GFlags

Extra metadata flags.

NONE = 0

no flags

READONLY = 1

metadata should not be modified

POOLED = 2

metadata is managed by a bufferpool

LOCKED = 4

metadata should not be removed

LAST = 65536

additional flags can be added starting from this flag.

class Gst.MiniObjectFlags(value)

Bases: GObject.GFlags

Flags for the mini object

LOCKABLE = 1

the object can be locked and unlocked with Gst.MiniObject.lock() and Gst.MiniObject.unlock().

LAST = 16

first flag that can be used by subclasses.

LOCK_READONLY = 2

the object is permanently locked in READONLY mode. Only read locks can be performed on the object.

MAY_BE_LEAKED = 4

the object is expected to stay alive even after Gst.deinit() has been called and so should be ignored by leak detection tools. (Since 1.10)

class Gst.ObjectFlags(value)

Bases: GObject.GFlags

The standard flags that an gstobject may have.

MAY_BE_LEAKED = 1

the object is expected to stay alive even after Gst.deinit() has been called and so should be ignored by leak detection tools. (Since 1.10)

LAST = 16

subclasses can add additional flags starting from this flag

class Gst.PadFlags(value)

Bases: GObject.GFlags

Pad state flags

PENDING_EVENTS = 1024

the pad has pending events

LAST = 1048576

offset to define more flags

BLOCKING = 128

is pad currently blocking on a buffer or event

BLOCKED = 16

is dataflow on a pad blocked

PROXY_SCHEDULING = 16384

the default query handler will forward scheduling queries to the internally linked pads instead of discarding them.

FIXED_CAPS = 2048

the pad is using fixed caps. This means that once the caps are set on the pad, the default caps query function will only return those caps.

NEED_PARENT = 256

ensure that there is a parent object before calling into the pad callbacks.

FLUSHING = 32

is pad flushing

ACCEPT_INTERSECT = 32768

the default accept-caps handler will check it the caps intersect the query-caps result instead of checking for a subset. This is interesting for parsers that can accept incompletely specified caps.

PROXY_CAPS = 4096

the default event and query handler will forward all events and queries to the internally linked pads instead of discarding them.

NEED_RECONFIGURE = 512

the pad should be reconfigured/renegotiated. The flag has to be unset manually after reconfiguration happened.

EOS = 64

is pad in EOS state

ACCEPT_TEMPLATE = 65536

the default accept-caps handler will use the template pad caps instead of query caps to compare with the accept caps. Use this in combination with Gst.PadFlags.ACCEPT_INTERSECT. (Since 1.6)

PROXY_ALLOCATION = 8192

the default query handler will forward allocation queries to the internally linked pads instead of discarding them.

class Gst.PadLinkCheck(value)

Bases: GObject.GFlags

The amount of checking to be done when linking pads. Gst.PadLinkCheck.CAPS and Gst.PadLinkCheck.TEMPLATE_CAPS are mutually exclusive. If both are specified, expensive but safe Gst.PadLinkCheck.CAPS 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 (Gst.PadLinkCheck.DEFAULT) or the regular methods for linking the pads.

NOTHING = 0

Don’t check hierarchy or caps compatibility.

HIERARCHY = 1

Check the pads have same parents/grandparents. Could be omitted if it is already known that the two elements that own the pads are in the same bin.

TEMPLATE_CAPS = 2

Check if the pads are compatible by using their template caps. This is much faster than Gst.PadLinkCheck.CAPS, but would be unsafe e.g. if one pad has %GST_CAPS_ANY.

CAPS = 4

Check if the pads are compatible by comparing the caps returned by Gst.Pad.query_caps().

DEFAULT = 5

The default checks done when linking pads (i.e. the ones used by Gst.Pad.link()).

NO_RECONFIGURE = 8

Disables pushing a reconfigure event when pads are linked.

class Gst.PadProbeType(value)

Bases: GObject.GFlags

The different probing types that can occur. When either one of Gst.PadProbeType.IDLE or Gst.PadProbeType.BLOCK is used, the probe will be a blocking probe.

INVALID = 0

invalid probe type

IDLE = 1

probe idle pads and block while the callback is called

QUERY_UPSTREAM = 1024

probe upstream queries

DATA_DOWNSTREAM = 112

probe downstream data (buffers, buffer lists, and events)

BLOCK_DOWNSTREAM = 114

probe and block downstream data (buffers, buffer lists, and events)

SCHEDULING = 12288

probe push and pull

DATA_UPSTREAM = 128

probe upstream data (events)

EVENT_UPSTREAM = 128

probe upstream events

BLOCK_UPSTREAM = 130

probe and block upstream data (events)

QUERY_BOTH = 1536

probe upstream and downstream queries

BUFFER = 16

probe buffers

ALL_BOTH = 1776

probe upstream events and queries and downstream buffers, buffer lists, events and queries

EVENT_BOTH = 192

probe upstream and downstream events

BLOCK = 2

probe and block pads

DATA_BOTH = 240

probe upstream and downstream data (buffers, buffer lists, and events)

EVENT_FLUSH = 256

probe flush events. This probe has to be explicitly enabled and is not included in the @:obj:Gst.PadProbeType.EVENT_DOWNSTREAM or @:obj:Gst.PadProbeType.EVENT_UPSTREAM probe types.

BLOCKING = 3

probe and block at the next opportunity, at data flow or when idle

BUFFER_LIST = 32

probe buffer lists

PUSH = 4096

probe push

QUERY_DOWNSTREAM = 512

probe downstream queries

EVENT_DOWNSTREAM = 64

probe downstream events

PULL = 8192

probe pull

class Gst.PadTemplateFlags(value)

Bases: GObject.GFlags

Flags for the padtemplate

LAST = 256

first flag that can be used by subclasses.

class Gst.ParseFlags(value)

Bases: GObject.GFlags

Parsing options.

NONE = 0

Do not use any special parsing options.

FATAL_ERRORS = 1

Always return None when an error occurs (default behaviour is to return partially constructed bins or elements in some cases)

NO_SINGLE_ELEMENT_BINS = 2

If a bin only has a single element, just return the element.

PLACE_IN_BIN = 4

If more than one toplevel element is described by the pipeline description string, put them in a Gst.Bin instead of a Gst.Pipeline. (Since 1.10)

class Gst.PipelineFlags(value)

Bases: GObject.GFlags

Pipeline flags

FIXED_CLOCK = 524288

this pipeline works with a fixed clock

LAST = 8388608

offset to define more flags

class Gst.PluginDependencyFlags(value)

Bases: GObject.GFlags

Flags used in connection with Gst.Plugin.add_dependency().

NONE = 0

no special flags

RECURSE = 1

recurse into subdirectories

PATHS_ARE_RELATIVE_TO_EXE = 16

interpret non-absolute paths as relative to the main executable directory.

New in version 1.14.

PATHS_ARE_DEFAULT_ONLY = 2

use paths argument only if none of the environment variables is set

FILE_NAME_IS_SUFFIX = 4

interpret filename argument as filter suffix and check all matching files in the directory

FILE_NAME_IS_PREFIX = 8

interpret filename argument as filter prefix and check all matching files in the directory.

New in version 1.8.

class Gst.PluginFlags(value)

Bases: GObject.GFlags

The plugin loading state

CACHED = 16

Temporarily loaded plugins

BLACKLISTED = 32

The plugin won’t be scanned (again)

class Gst.QueryTypeFlags(value)

Bases: GObject.GFlags

Gst.QueryTypeFlags indicate the aspects of the different Gst.QueryType values. You can get the type flags of a Gst.QueryType with the Gst.QueryType.get_flags() function.

UPSTREAM = 1

Set if the query can travel upstream.

DOWNSTREAM = 2

Set if the query can travel downstream.

SERIALIZED = 4

Set if the query should be serialized with data flow.

class Gst.SchedulingFlags(value)

Bases: GObject.GFlags

The different scheduling flags.

SEEKABLE = 1

if seeking is possible

SEQUENTIAL = 2

if sequential access is recommended

BANDWIDTH_LIMITED = 4

if bandwidth is limited and buffering possible (since 1.2)

class Gst.SeekFlags(value)

Bases: GObject.GFlags

Flags to be used with Gst.Element.seek() or Gst.Event.new_seek(). 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 Gst.MessageType.SEGMENT_DONE 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 Gst.SeekFlags.TRICKMODE 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 Gst.SeekFlags.TRICKMODE_KEY_UNITS flag can be used to request that decoders skip all frames except key units, and Gst.SeekFlags.TRICKMODE_NO_AUDIO flags can be used to request that audio decoders do no decoding at all, and simple output silence.

The Gst.SeekFlags.SNAP_BEFORE flag can be used to snap to the previous relevant location, and the Gst.SeekFlags.SNAP_AFTER flag can be used to select the next relevant location. If Gst.SeekFlags.KEY_UNIT 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.

NONE = 0

no flag

FLUSH = 1

flush pipeline

TRICKMODE_KEY_UNITS = 128

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)

SKIP = 16

Deprecated backward compatibility flag, replaced by Gst.SeekFlags.TRICKMODE

TRICKMODE = 16

when doing fast forward or fast reverse playback, allow elements to skip frames instead of generating all frames. (Since 1.6)

ACCURATE = 2

accurate position is requested, this might be considerably slower for some formats.

TRICKMODE_NO_AUDIO = 256

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)

SNAP_BEFORE = 32

go to a location before the requested position, if Gst.SeekFlags.KEY_UNIT this means the keyframe at or before the requested position the one at or before the seek target.

KEY_UNIT = 4

seek to the nearest keyframe. This might be faster but less accurate.

SNAP_AFTER = 64

go to a location after the requested position, if Gst.SeekFlags.KEY_UNIT this means the keyframe at of after the requested position.

SEGMENT = 8

perform a segment seek.

SNAP_NEAREST = 96

go to a position near the requested position, if Gst.SeekFlags.KEY_UNIT this means the keyframe closest to the requested position, if both keyframes are at an equal distance, behaves like Gst.SeekFlags.SNAP_BEFORE.

class Gst.SegmentFlags(value)

Bases: GObject.GFlags

Flags for the Gst.Segment structure. Currently mapped to the corresponding values of the seek flags.

NONE = 0

no flags

RESET = 1

reset the pipeline running_time to the segment running_time

TRICKMODE_KEY_UNITS = 128

Decode only keyframes, where possible (Since 1.6)

SKIP = 16

Deprecated backward compatibility flag, replaced by Gst.SegmentFlags.TRICKMODE

TRICKMODE = 16

perform skip playback (Since 1.6)

TRICKMODE_NO_AUDIO = 256

Do not decode any audio, where possible (Since 1.6)

SEGMENT = 8

send SEGMENT_DONE instead of EOS

class Gst.StackTraceFlags(value)

Bases: GObject.GFlags

New in version 1.12.

FULL = 1

Try to retrieve as much information as possible when getting the stack trace

class Gst.StreamFlags(value)

Bases: GObject.GFlags

New in version 1.2.

NONE = 0

This stream has no special attributes

SPARSE = 1

This stream is a sparse stream (e.g. a subtitle stream), data may flow only in irregular intervals with large gaps in between.

SELECT = 2

This stream should be selected by default. This flag may be used by demuxers to signal that a stream should be selected by default in a playback scenario.

UNSELECT = 4

This stream should not be selected by default. This flag may be used by demuxers to signal that a stream should not be selected by default in a playback scenario, but only if explicitly selected by the user (e.g. an audio track for the hard of hearing or a director’s commentary track).

class Gst.StreamType(value)

Bases: GObject.GFlags

Gst.StreamType describes a high level classification set for flows of data in Gst.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.

New in version 1.10.

UNKNOWN = 1

The stream is of unknown (unclassified) type.

TEXT = 16

The stream contains subtitle / subpicture data.

AUDIO = 2

The stream is of audio data

VIDEO = 4

The stream carries video data

CONTAINER = 8

The stream is a muxed container type

class Gst.TracerValueFlags(value)

Bases: GObject.GFlags

Flag that describe the value. These flags help applications processing the logs to understand the values.

NONE = 0

no flags

OPTIONAL = 1

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 gst_tracer_record_log().

AGGREGATED = 2

the value is a combined figure, since the start of tracing. Examples are averages or timestamps.