GNOME.org

gstreamermm: gstreamermm Enums and Flags

Enumerations

enum  Gst::AutoplugSelectResult {

  Gst::AUTOPLUG_SELECT_TRY,

  Gst::AUTOPLUG_SELECT_EXPOSE,

  Gst::AUTOPLUG_SELECT_SKIP

}
 
enum  Gst::AudioConvertDithering {

  Gst::NONE,

  Gst::RPDF,

  Gst::TPDF,

  Gst::TPDF_HF

}
 
enum  Gst::AudioConvertNoiseShaping {

  Gst::SHAPING_NONE,

  Gst::SHAPING_ERROR_FEEDBACK,

  Gst::SHAPING_SIMPLE,

  Gst::SHAPING_MEDIUM,

  Gst::SHAPING_HIGH

}
 
enum  Gst::AudioTestSrcWave {

  Gst::AUDIO_TEST_SRC_WAVE_SINE,

  Gst::AUDIO_TEST_SRC_WAVE_SQUARE,

  Gst::AUDIO_TEST_SRC_WAVE_SAW,

  Gst::AUDIO_TEST_SRC_WAVE_TRIANGLE,

  Gst::AUDIO_TEST_SRC_WAVE_SILENCE,

  Gst::AUDIO_TEST_SRC_WAVE_WHITE_NOISE,

  Gst::AUDIO_TEST_SRC_WAVE_PINK_NOISE,

  Gst::AUDIO_TEST_SRC_WAVE_SINE_TAB,

  Gst::AUDIO_TEST_SRC_WAVE_TICKS,

  Gst::AUDIO_TEST_SRC_WAVE_GAUSSIAN_WHITE_NOISE,

  Gst::AUDIO_TEST_SRC_WAVE_RED_NOISE,

  Gst::AUDIO_TEST_SRC_WAVE_BLUE_NOISE,

  Gst::AUDIO_TEST_SRC_WAVE_VIOLET_NOISE

}
 
enum  Gst::CdParanoiaMode {

  Gst::PARANOIA_MODE_DISABLE = 1<<0,

  Gst::PARANOIA_MODE_FRAGMENT = 1<<1,

  Gst::PARANOIA_MODE_OVERLAP = 1<<2,

  Gst::PARANOIA_MODE_SCRATCH = 1<<3,

  Gst::PARANOIA_MODE_REPAIR = 1<<4,

  Gst::PARANOIA_MODE_FULL = 0xff

}
 
enum  Gst::FakeSinkStateError {

  Gst::SINK_STATE_ERROR_NONE,

  Gst::SINK_STATE_ERROR_NULL_READY,

  Gst::SINK_STATE_ERROR_READY_PAUSED,

  Gst::SINK_STATE_ERROR_PAUSED_PLAYING,

  Gst::SINK_STATE_ERROR_PLAYING_PAUSED,

  Gst::SINK_STATE_ERROR_PAUSED_READY,

  Gst::SINK_STATE_ERROR_READY_NULL

}
 
enum  Gst::FakeSrcDataType {

  Gst::SRC_DATA_ALLOCATE = 1,

  Gst::SRC_DATA_SUBBUFFER

}
 
enum  Gst::FakeSrcSizeType {

  Gst::SRC_SIZETYPE_EMPTY = 1,

  Gst::SRC_SIZETYPE_FIXED,

  Gst::SRC_SIZETYPE_RANDOM

}
 
enum  Gst::FakeSrcFillType {

  Gst::SRC_FILLTYPE_NOTHING = 1,

  Gst::SRC_FILLTYPE_ZERO,

  Gst::SRC_FILLTYPE_RANDOM,

  Gst::SRC_FILLTYPE_PATTERN,

  Gst::SRC_FILLTYPE_PATTERN_CONT

}
 
enum  Gst::FileSinkBufferMode {

  Gst::FILE_SINK_BUFFER_MODE_DEFAULT = -1,

  Gst::FILE_SINK_BUFFER_MODE_FULL,

  Gst::FILE_SINK_BUFFER_MODE_LINE,

  Gst::FILE_SINK_BUFFER_MODE_UNBUFFERED

}
 
enum  Gst::InputSelectorSyncMode {

  Gst::INPUT_SELECTOR_SYNC_MODE_ACTIVE_SEGMENT,

  Gst::INPUT_SELECTOR_SYNC_MODE_CLOCK

}
 
enum  Gst::OutputSelectorPadNegotiationMode {

  Gst::OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE,

  Gst::OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL,

  Gst::OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE

}
 
enum  Gst::PlayFlags {

  Gst::PLAY_FLAG_VIDEO = (1 << 0),

  Gst::PLAY_FLAG_AUDIO = (1 << 1),

  Gst::PLAY_FLAG_TEXT = (1 << 2),

  Gst::PLAY_FLAG_VIS = (1 << 3),

  Gst::PLAY_FLAG_SOFT_VOLUME = (1 << 4),

  Gst::PLAY_FLAG_NATIVE_AUDIO = (1 << 5),

  Gst::PLAY_FLAG_NATIVE_VIDEO = (1 << 6),

  Gst::PLAY_FLAG_DOWNLOAD = (1 << 7),

  Gst::PLAY_FLAG_BUFFERING = (1 << 8),

  Gst::PLAY_FLAG_DEINTERLACE = (1 << 9),

  Gst::PLAY_FLAG_SOFT_COLORBALANCE = (1 << 10)

}
 
enum  Gst::QueueLeaky {

  Gst::QUEUE_LEAK_NO_LEAK,

  Gst::QUEUE_LEAK_UPSTREAM,

  Gst::QUEUE_LEAK_DOWNSTREAM

}
 
enum  Gst::TeePullMode {

  Gst::TEE_PULL_MODE_NEVER,

  Gst::TEE_PULL_MODE_SINGLE

}
 
enum  Gst::TextRenderHAlign {

  Gst::TEXT_RENDER_HALIGN_LEFT,

  Gst::TEXT_RENDER_HALIGN_CENTER,

  Gst::TEXT_RENDER_HALIGN_RIGHT

}
 
enum  Gst::TextRenderVAlign {

  Gst::TEXT_RENDER_VALIGN_BASELINE,

  Gst::TEXT_RENDER_VALIGN_BOTTOM,

  Gst::TEXT_RENDER_VALIGN_TOP

}
 
enum  Gst::TextRenderLineAlign {

  Gst::TEXT_RENDER_LINE_ALIGN_LEFT = 0,

  Gst::TEXT_RENDER_LINE_ALIGN_CENTER = 1,

  Gst::TEXT_RENDER_LINE_ALIGN_RIGHT = 2

}
 
enum  Gst::TheoraEncMultipassMode {

  Gst::MODE_SINGLE_PASS,

  Gst::MODE_FIRST_PASS,

  Gst::MODE_SECOND_PASS

}
 
enum  Gst::VideoScaleMethod {

  Gst::VIDEO_SCALE_NEAREST,

  Gst::VIDEO_SCALE_BILINEAR,

  Gst::VIDEO_SCALE_4TAP,

  Gst::VIDEO_SCALE_LANCZOS

}
 
enum  Gst::VideoTestSrcPattern {

  Gst::VIDEO_TEST_SRC_SMPTE,

  Gst::VIDEO_TEST_SRC_SNOW,

  Gst::VIDEO_TEST_SRC_BLACK,

  Gst::VIDEO_TEST_SRC_WHITE,

  Gst::VIDEO_TEST_SRC_RED,

  Gst::VIDEO_TEST_SRC_GREEN,

  Gst::VIDEO_TEST_SRC_BLUE,

  Gst::VIDEO_TEST_SRC_CHECKERS1,

  Gst::VIDEO_TEST_SRC_CHECKERS2,

  Gst::VIDEO_TEST_SRC_CHECKERS4,

  Gst::VIDEO_TEST_SRC_CHECKERS8,

  Gst::VIDEO_TEST_SRC_CIRCULAR,

  Gst::VIDEO_TEST_SRC_BLINK,

  Gst::VIDEO_TEST_SRC_SMPTE75,

  Gst::VIDEO_TEST_SRC_ZONE_PLATE,

  Gst::VIDEO_TEST_SRC_GAMUT,

  Gst::VIDEO_TEST_SRC_CHROMA_ZONE_PLATE,

  Gst::VIDEO_TEST_SRC_SOLID,

  Gst::VIDEO_TEST_SRC_BALL,

  Gst::VIDEO_TEST_SRC_SMPTE100,

  Gst::VIDEO_TEST_SRC_BAR,

  Gst::VIDEO_TEST_SRC_PINWHEEL,

  Gst::VIDEO_TEST_SRC_SPOKES

}
 
enum  Gst::AudioBaseSinkSlaveMethod {

  Gst::AUDIO_BASE_SINK_SLAVE_RESAMPLE,

  Gst::AUDIO_BASE_SINK_SLAVE_SKEW,

  Gst::AUDIO_BASE_SINK_SLAVE_NONE

}
 Different possible clock slaving algorithms used when the internal audio clock is not selected as the pipeline master clock. More...

 
enum  Gst::AudioBaseSrcSlaveMethod {

  Gst::AUDIO_BASE_SRC_SLAVE_RESAMPLE,

  Gst::AUDIO_BASE_SRC_SLAVE_RETIMESTAMP,

  Gst::AUDIO_BASE_SRC_SLAVE_SKEW,

  Gst::AUDIO_BASE_SRC_SLAVE_NONE

}
 Different possible clock slaving algorithms when the internal audio clock was not selected as the pipeline clock. More...

 
enum  Gst::AudioFormat {

  Gst::AUDIO_FORMAT_UNKNOWN = 0,

  Gst::AUDIO_FORMAT_ENCODED = 1,

  Gst::AUDIO_FORMAT_S8 = 2,

  Gst::AUDIO_FORMAT_U8 = 3,

  Gst::AUDIO_FORMAT_S16LE = 4,

  Gst::AUDIO_FORMAT_S16BE = 5,

  Gst::AUDIO_FORMAT_U16LE = 6,

  Gst::AUDIO_FORMAT_U16BE = 7,

  Gst::AUDIO_FORMAT_S24_32LE = 8,

  Gst::AUDIO_FORMAT_S24_32BE = 9,

  Gst::AUDIO_FORMAT_U24_32LE = 10,

  Gst::AUDIO_FORMAT_U24_32BE = 11,

  Gst::AUDIO_FORMAT_S32LE = 12,

  Gst::AUDIO_FORMAT_S32BE = 13,

  Gst::AUDIO_FORMAT_U32LE = 14,

  Gst::AUDIO_FORMAT_U32BE = 15,

  Gst::AUDIO_FORMAT_S24LE = 16,

  Gst::AUDIO_FORMAT_S24BE = 17,

  Gst::AUDIO_FORMAT_U24LE = 18,

  Gst::AUDIO_FORMAT_U24BE = 19,

  Gst::AUDIO_FORMAT_S20LE = 20,

  Gst::AUDIO_FORMAT_S20BE = 21,

  Gst::AUDIO_FORMAT_U20LE = 22,

  Gst::AUDIO_FORMAT_U20BE = 23,

  Gst::AUDIO_FORMAT_S18LE = 24,

  Gst::AUDIO_FORMAT_S18BE = 25,

  Gst::AUDIO_FORMAT_U18LE = 26,

  Gst::AUDIO_FORMAT_U18BE = 27,

  Gst::AUDIO_FORMAT_F32LE = 28,

  Gst::AUDIO_FORMAT_F32BE = 29,

  Gst::AUDIO_FORMAT_F64LE = 30,

  Gst::AUDIO_FORMAT_F64BE = 31,

  Gst::AUDIO_FORMAT_S16 = _GST_AUDIO_FORMAT_NE(S16),

  Gst::AUDIO_FORMAT_U16 = _GST_AUDIO_FORMAT_NE(U16),

  Gst::AUDIO_FORMAT_S24_32 = _GST_AUDIO_FORMAT_NE(S24_32),

  Gst::AUDIO_FORMAT_U24_32 = _GST_AUDIO_FORMAT_NE(U24_32),

  Gst::AUDIO_FORMAT_S32 = _GST_AUDIO_FORMAT_NE(S32),

  Gst::AUDIO_FORMAT_U32 = _GST_AUDIO_FORMAT_NE(U32),

  Gst::AUDIO_FORMAT_S24 = _GST_AUDIO_FORMAT_NE(S24),

  Gst::AUDIO_FORMAT_U24 = _GST_AUDIO_FORMAT_NE(U24),

  Gst::AUDIO_FORMAT_S20 = _GST_AUDIO_FORMAT_NE(S20),

  Gst::AUDIO_FORMAT_U20 = _GST_AUDIO_FORMAT_NE(U20),

  Gst::AUDIO_FORMAT_S18 = _GST_AUDIO_FORMAT_NE(S18),

  Gst::AUDIO_FORMAT_U18 = _GST_AUDIO_FORMAT_NE(U18),

  Gst::AUDIO_FORMAT_F32 = _GST_AUDIO_FORMAT_NE(F32),

  Gst::AUDIO_FORMAT_F64 = _GST_AUDIO_FORMAT_NE(F64)

}
 Enum value describing the most common audio formats. More...

 
enum  Gst::AudioFormatFlags {

  Gst::AUDIO_FORMAT_FLAG_INTEGER = (1 << 0),

  Gst::AUDIO_FORMAT_FLAG_FLOAT = (1 << 1),

  Gst::AUDIO_FORMAT_FLAG_SIGNED = (1 << 2),

  Gst::AUDIO_FORMAT_FLAG_COMPLEX = (1 << 4),

  Gst::AUDIO_FORMAT_FLAG_UNPACK = (1 << 5)

}
 The different audio flags that a format info can have. More...

 
enum  Gst::AudioFlags {

  Gst::AUDIO_FLAG_NONE = 0x0,

  Gst::AUDIO_FLAG_UNPOSITIONED = (1 << 0)

}
 Extra audio flags. More...

 
enum  Gst::AudioLayout {

  Gst::AUDIO_LAYOUT_INTERLEAVED,

  Gst::AUDIO_LAYOUT_NON_INTERLEAVED

}
 Layout of the audio samples for the different channels. More...

 
enum  Gst::AudioChannelPosition {

  Gst::AUDIO_CHANNEL_POSITION_NONE = -3,

  Gst::AUDIO_CHANNEL_POSITION_MONO,

  Gst::AUDIO_CHANNEL_POSITION_INVALID,

  Gst::AUDIO_CHANNEL_POSITION_FRONT_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_FRONT_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_FRONT_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_LFE1,

  Gst::AUDIO_CHANNEL_POSITION_REAR_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_REAR_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_REAR_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_LFE2,

  Gst::AUDIO_CHANNEL_POSITION_SIDE_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_SIDE_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_TOP_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER,

  Gst::AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_WIDE_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_WIDE_RIGHT,

  Gst::AUDIO_CHANNEL_POSITION_SURROUND_LEFT,

  Gst::AUDIO_CHANNEL_POSITION_SURROUND_RIGHT

}
 Audio channel positions. More...

 
enum  Gst::AudioRingBufferState {

  Gst::AUDIO_RING_BUFFER_STATE_STOPPED,

  Gst::AUDIO_RING_BUFFER_STATE_PAUSED,

  Gst::AUDIO_RING_BUFFER_STATE_STARTED,

  Gst::AUDIO_RING_BUFFER_STATE_ERROR

}
 The state of the ringbuffer. More...

 
enum  Gst::AudioRingBufferFormatType {

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_RAW,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_GSM,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_AC3,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_DTS,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC,

  Gst::AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC

}
 The format of the samples in the ringbuffer. More...

 
enum  Gst::BinFlags {

  Gst::BIN_FLAG_NO_RESYNC = (GST_ELEMENT_FLAG_LAST << 0),

  Gst::BIN_FLAG_LAST = (GST_ELEMENT_FLAG_LAST << 5)

}
 GstBinFlags are a set of flags specific to bins. More...

 
enum  Gst::BufferFlags {

  Gst::BUFFER_FLAG_LIVE = (GST_MINI_OBJECT_FLAG_LAST << 0),

  Gst::BUFFER_FLAG_DECODE_ONLY = (GST_MINI_OBJECT_FLAG_LAST << 1),

  Gst::BUFFER_FLAG_DISCONT = (GST_MINI_OBJECT_FLAG_LAST << 2),

  Gst::BUFFER_FLAG_RESYNC = (GST_MINI_OBJECT_FLAG_LAST << 3),

  Gst::BUFFER_FLAG_CORRUPTED = (GST_MINI_OBJECT_FLAG_LAST << 4),

  Gst::BUFFER_FLAG_MARKER = (GST_MINI_OBJECT_FLAG_LAST << 5),

  Gst::BUFFER_FLAG_HEADER = (GST_MINI_OBJECT_FLAG_LAST << 6),

  Gst::BUFFER_FLAG_GAP = (GST_MINI_OBJECT_FLAG_LAST << 7),

  Gst::BUFFER_FLAG_DROPPABLE = (GST_MINI_OBJECT_FLAG_LAST << 8),

  Gst::BUFFER_FLAG_DELTA_UNIT = (GST_MINI_OBJECT_FLAG_LAST << 9),

  Gst::BUFFER_FLAG_LAST = (GST_MINI_OBJECT_FLAG_LAST << 16)

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

 
enum  Gst::BufferCopyFlags {

  Gst::BUFFER_COPY_NONE = 0x0,

  Gst::BUFFER_COPY_FLAGS = (1 << 0),

  Gst::BUFFER_COPY_TIMESTAMPS = (1 << 1),

  Gst::BUFFER_COPY_META = (1 << 2),

  Gst::BUFFER_COPY_MEMORY = (1 << 3),

  Gst::BUFFER_COPY_MERGE = (1 << 4),

  Gst::BUFFER_COPY_DEEP = (1 << 5)

}
 A set of flags that can be provided to the gst_buffer_copy_into() function to specify which items should be copied. More...

 
enum  Gst::BusFlags {

  Gst::BUS_FLUSHING = (GST_OBJECT_FLAG_LAST << 0),

  Gst::BUS_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 1)

}
 The standard flags that a bus may have. More...

 
enum  Gst::BusSyncReply {

  Gst::BUS_DROP,

  Gst::BUS_PASS,

  Gst::BUS_ASYNC

}
 The result values for a GstBusSyncHandler. More...

 
enum  Gst::CapsIntersectMode {

  Gst::CAPS_INTERSECT_ZIG_ZAG,

  Gst::CAPS_INTERSECT_FIRST

}
 Modes of caps intersection. More...

 
enum  Gst::ClockEntryType {

  Gst::CLOCK_ENTRY_SINGLE,

  Gst::CLOCK_ENTRY_PERIODIC

}
 The type of the clock entry. More...

 
enum  Gst::ClockReturn {

  Gst::CLOCK_OK,

  Gst::CLOCK_EARLY,

  Gst::CLOCK_UNSCHEDULED,

  Gst::CLOCK_BUSY,

  Gst::CLOCK_BADTIME,

  Gst::CLOCK_ERROR,

  Gst::CLOCK_UNSUPPORTED,

  Gst::CLOCK_DONE

}
 The return value of a clock operation. More...

 
enum  Gst::ClockFlags {

  Gst::CLOCK_FLAG_CAN_DO_SINGLE_SYNC = (GST_OBJECT_FLAG_LAST << 0),

  Gst::CLOCK_FLAG_CAN_DO_SINGLE_ASYNC = (GST_OBJECT_FLAG_LAST << 1),

  Gst::CLOCK_FLAG_CAN_DO_PERIODIC_SYNC = (GST_OBJECT_FLAG_LAST << 2),

  Gst::CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC = (GST_OBJECT_FLAG_LAST << 3),

  Gst::CLOCK_FLAG_CAN_SET_RESOLUTION = (GST_OBJECT_FLAG_LAST << 4),

  Gst::CLOCK_FLAG_CAN_SET_MASTER = (GST_OBJECT_FLAG_LAST << 5),

  Gst::CLOCK_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 8)

}
 The capabilities of this clock. More...

 
enum  Gst::ColorBalanceType {

  Gst::COLOR_BALANCE_HARDWARE,

  Gst::COLOR_BALANCE_SOFTWARE

}
 An enumeration indicating whether an element implements color balancing operations in software or in dedicated hardware. More...

 
enum  Gst::DiscovererResult {

  Gst::DISCOVERER_OK,

  Gst::DISCOVERER_URI_INVALID,

  Gst::DISCOVERER_ERROR,

  Gst::DISCOVERER_TIMEOUT,

  Gst::DISCOVERER_BUSY,

  Gst::DISCOVERER_MISSING_PLUGINS

}
 Result values for the discovery process. More...

 
enum  Gst::ElementFlags {

  Gst::ELEMENT_FLAG_LOCKED_STATE = (GST_OBJECT_FLAG_LAST << 0),

  Gst::ELEMENT_FLAG_SINK = (GST_OBJECT_FLAG_LAST << 1),

  Gst::ELEMENT_FLAG_SOURCE = (GST_OBJECT_FLAG_LAST << 2),

  Gst::ELEMENT_FLAG_PROVIDE_CLOCK = (GST_OBJECT_FLAG_LAST << 3),

  Gst::ELEMENT_FLAG_REQUIRE_CLOCK = (GST_OBJECT_FLAG_LAST << 4),

  Gst::ELEMENT_FLAG_INDEXABLE = (GST_OBJECT_FLAG_LAST << 5),

  Gst::ELEMENT_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 10)

}
 The standard flags that an element may have. More...

 
enum  Gst::StateChangeReturn {

  Gst::STATE_CHANGE_FAILURE,

  Gst::STATE_CHANGE_SUCCESS,

  Gst::STATE_CHANGE_ASYNC,

  Gst::STATE_CHANGE_NO_PREROLL

}
 The possible return values from a state change function such as Gst::Element::set_state(). More...

 
enum  Gst::State {

  Gst::STATE_VOID_PENDING,

  Gst::STATE_NULL,

  Gst::STATE_READY,

  Gst::STATE_PAUSED,

  Gst::STATE_PLAYING

}
 The possible states an element can be in. More...

 
enum  Gst::EventType {

  Gst::EVENT_UNKNOWN = GST_EVENT_MAKE_TYPE (0, 0),

  Gst::EVENT_FLUSH_START = GST_EVENT_MAKE_TYPE (10, FLAG(BOTH)),

  Gst::EVENT_FLUSH_STOP = GST_EVENT_MAKE_TYPE (20, FLAG(BOTH) | FLAG(SERIALIZED)),

  Gst::EVENT_STREAM_START = GST_EVENT_MAKE_TYPE (40, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY)),

  Gst::EVENT_CAPS = GST_EVENT_MAKE_TYPE (50, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY)),

  Gst::EVENT_SEGMENT = GST_EVENT_MAKE_TYPE (70, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY)),

  Gst::EVENT_TAG = GST_EVENT_MAKE_TYPE (80, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY) | FLAG(STICKY_MULTI)),

  Gst::EVENT_BUFFERSIZE = GST_EVENT_MAKE_TYPE (90, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY)),

  Gst::EVENT_SINK_MESSAGE = GST_EVENT_MAKE_TYPE (100, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY) | FLAG(STICKY_MULTI)),

  Gst::EVENT_EOS = GST_EVENT_MAKE_TYPE (110, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY)),

  Gst::EVENT_TOC = GST_EVENT_MAKE_TYPE (120, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY) | FLAG(STICKY_MULTI)),

  Gst::EVENT_SEGMENT_DONE = GST_EVENT_MAKE_TYPE (150, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),

  Gst::EVENT_GAP = GST_EVENT_MAKE_TYPE (160, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),

  Gst::EVENT_QOS = GST_EVENT_MAKE_TYPE (190, FLAG(UPSTREAM)),

  Gst::EVENT_SEEK = GST_EVENT_MAKE_TYPE (200, FLAG(UPSTREAM)),

  Gst::EVENT_NAVIGATION = GST_EVENT_MAKE_TYPE (210, FLAG(UPSTREAM)),

  Gst::EVENT_LATENCY = GST_EVENT_MAKE_TYPE (220, FLAG(UPSTREAM)),

  Gst::EVENT_STEP = GST_EVENT_MAKE_TYPE (230, FLAG(UPSTREAM)),

  Gst::EVENT_RECONFIGURE = GST_EVENT_MAKE_TYPE (240, FLAG(UPSTREAM)),

  Gst::EVENT_TOC_SELECT = GST_EVENT_MAKE_TYPE (250, FLAG(UPSTREAM)),

  Gst::EVENT_CUSTOM_UPSTREAM = GST_EVENT_MAKE_TYPE (270, FLAG(UPSTREAM)),

  Gst::EVENT_CUSTOM_DOWNSTREAM = GST_EVENT_MAKE_TYPE (280, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),

  Gst::EVENT_CUSTOM_DOWNSTREAM_OOB = GST_EVENT_MAKE_TYPE (290, FLAG(DOWNSTREAM)),

  Gst::EVENT_CUSTOM_DOWNSTREAM_STICKY = GST_EVENT_MAKE_TYPE (300, FLAG(DOWNSTREAM) | FLAG(SERIALIZED) | FLAG(STICKY) | FLAG(STICKY_MULTI)),

  Gst::EVENT_CUSTOM_BOTH = GST_EVENT_MAKE_TYPE (310, FLAG(BOTH) | FLAG(SERIALIZED)),

  Gst::EVENT_CUSTOM_BOTH_OOB = GST_EVENT_MAKE_TYPE (320, FLAG(BOTH))

}
 Gst::EventType lists the standard event types that can be sent in a pipeline. More...

 
enum  Gst::EventTypeFlags {

  Gst::EVENT_TYPE_UPSTREAM = 1 << 0,

  Gst::EVENT_TYPE_DOWNSTREAM = 1 << 1,

  Gst::EVENT_TYPE_SERIALIZED = 1 << 2,

  Gst::EVENT_TYPE_STICKY = 1 << 3,

  Gst::EVENT_TYPE_STICKY_MULTI = 1 << 4

}
 Gst::EventTypeFlags indicate the aspects of the different Gst::EventType values. More...

 
enum  Gst::QOSType {

  Gst::QOS_TYPE_OVERFLOW,

  Gst::QOS_TYPE_UNDERFLOW,

  Gst::QOS_TYPE_THROTTLE

}
 The different types of QoS events that can be given to the gst_event_new_qos() method. More...

 
enum  Gst::Format {

  Gst::FORMAT_UNDEFINED,

  Gst::FORMAT_DEFAULT,

  Gst::FORMAT_BYTES,

  Gst::FORMAT_TIME,

  Gst::FORMAT_BUFFERS,

  Gst::FORMAT_PERCENT

}
 Standard predefined formats. More...

 
enum  Gst::IteratorItem {

  Gst::ITERATOR_ITEM_SKIP,

  Gst::ITERATOR_ITEM_PASS,

  Gst::ITERATOR_ITEM_END

}
 The result of a Gst::IteratorItemFunction. More...

 
enum  Gst::IteratorResult {

  Gst::ITERATOR_DONE,

  Gst::ITERATOR_OK,

  Gst::ITERATOR_RESYNC,

  Gst::ITERATOR_ERROR

}
 The result of Gst::Iterator::next(). More...

 
enum  Gst::MapFlags {

  Gst::MAP_READ = GST_LOCK_FLAG_READ,

  Gst::MAP_WRITE = GST_LOCK_FLAG_WRITE,

  Gst::MAP_FLAG_LAST = (1 << 16)

}
 Flags used when mapping memory. More...

 
enum  Gio::DBus::MessageType
 The different message types that are available. More...

 
enum  Gst::StructureChangeType {

  Gst::STRUCTURE_CHANGE_TYPE_PAD_LINK,

  Gst::STRUCTURE_CHANGE_TYPE_PAD_UNLINK

}
 The type of a Gst::MESSAGE_STRUCTURE_CHANGE. More...

 
enum  Gst::StreamStatusType {

  Gst::STREAM_STATUS_TYPE_CREATE = 0,

  Gst::STREAM_STATUS_TYPE_ENTER = 1,

  Gst::STREAM_STATUS_TYPE_LEAVE = 2,

  Gst::STREAM_STATUS_TYPE_DESTROY = 3,

  Gst::STREAM_STATUS_TYPE_START = 8,

  Gst::STREAM_STATUS_TYPE_PAUSE = 9,

  Gst::STREAM_STATUS_TYPE_STOP = 10

}
 The type of a Gst::MESSAGE_STREAM_STATUS. More...

 
enum  Gst::MemoryFlags {

  Gst::MEMORY_FLAG_READONLY = GST_MINI_OBJECT_FLAG_LOCK_READONLY,

  Gst::MEMORY_FLAG_NO_SHARE = (GST_MINI_OBJECT_FLAG_LAST << 0),

  Gst::MEMORY_FLAG_ZERO_PREFIXED = (GST_MINI_OBJECT_FLAG_LAST << 1),

  Gst::MEMORY_FLAG_ZERO_PADDED = (GST_MINI_OBJECT_FLAG_LAST << 2),

  Gst::MEMORY_FLAG_PHYSICALLY_CONTIGUOUS = (GST_MINI_OBJECT_FLAG_LAST << 3),

  Gst::MEMORY_FLAG_NOT_MAPPABLE = (GST_MINI_OBJECT_FLAG_LAST << 4),

  Gst::MEMORY_FLAG_LAST = (GST_MINI_OBJECT_FLAG_LAST << 16)

}
 Flags for wrapped memory. More...

 
enum  Gst::MiniObjectFlags {

  Gst::MINI_OBJECT_FLAG_LOCKABLE = (1 << 0),

  Gst::MINI_OBJECT_FLAG_LOCK_READONLY = (1 << 1),

  Gst::MINI_OBJECT_FLAG_LAST = (1 << 4)

}
 Flags for the mini object. More...

 
enum  Gst::LockFlags {

  Gst::LOCK_FLAG_READ = (1 << 0),

  Gst::LOCK_FLAG_WRITE = (1 << 1),

  Gst::LOCK_FLAG_EXCLUSIVE = (1 << 2),

  Gst::LOCK_FLAG_LAST = (1 << 8)

}
 Flags used when locking miniobjects. More...

 
enum  Gst::NavigationCommand {

  Gst::NAVIGATION_COMMAND_INVALID = 0,

  Gst::NAVIGATION_COMMAND_MENU1 = 1,

  Gst::NAVIGATION_COMMAND_MENU2 = 2,

  Gst::NAVIGATION_COMMAND_MENU3 = 3,

  Gst::NAVIGATION_COMMAND_MENU4 = 4,

  Gst::NAVIGATION_COMMAND_MENU5 = 5,

  Gst::NAVIGATION_COMMAND_MENU6 = 6,

  Gst::NAVIGATION_COMMAND_MENU7 = 7,

  Gst::NAVIGATION_COMMAND_LEFT = 20,

  Gst::NAVIGATION_COMMAND_RIGHT = 21,

  Gst::NAVIGATION_COMMAND_UP = 22,

  Gst::NAVIGATION_COMMAND_DOWN = 23,

  Gst::NAVIGATION_COMMAND_ACTIVATE = 24,

  Gst::NAVIGATION_COMMAND_PREV_ANGLE = 30,

  Gst::NAVIGATION_COMMAND_NEXT_ANGLE = 31

}
 A set of commands that may be issued to an element providing the Gst::Navigation interface. More...

 
enum  Gst::ObjectFlags { Gst::OBJECT_FLAG_LAST = (1<<4) }
 The standard flags that an gstobject may have. More...

 
enum  Gst::PadMode {

  Gst::PAD_MODE_NONE,

  Gst::PAD_MODE_PUSH,

  Gst::PAD_MODE_PULL

}
 The status of a GstPad. More...

 
enum  Gst::FlowReturn {

  Gst::FLOW_CUSTOM_SUCCESS_2 = 102,

  Gst::FLOW_CUSTOM_SUCCESS_1 = 101,

  Gst::FLOW_CUSTOM_SUCCESS = 100,

  Gst::FLOW_OK = 0,

  Gst::FLOW_NOT_LINKED = -1,

  Gst::FLOW_FLUSHING = -2,

  Gst::FLOW_EOS = -3,

  Gst::FLOW_NOT_NEGOTIATED = -4,

  Gst::FLOW_ERROR = -5,

  Gst::FLOW_NOT_SUPPORTED = -6,

  Gst::FLOW_CUSTOM_ERROR = -100,

  Gst::FLOW_CUSTOM_ERROR_1 = -101,

  Gst::FLOW_CUSTOM_ERROR_2 = -102

}
 The result of passing data to a pad. More...

 
enum  Gst::PadDirection {

  Gst::PAD_UNKNOWN,

  Gst::PAD_SRC,

  Gst::PAD_SINK

}
 The direction of a pad. More...

 
enum  Gst::PadFlags {

  Gst::PAD_FLAG_BLOCKED = 0x10,

  Gst::PAD_FLAG_FLUSHING = 0x20,

  Gst::PAD_FLAG_EOS = 0x40,

  Gst::PAD_FLAG_BLOCKING = 0x80,

  Gst::PAD_FLAG_NEED_PARENT = 0x100,

  Gst::PAD_FLAG_NEED_RECONFIGURE = 0x200,

  Gst::PAD_FLAG_PENDING_EVENTS = 0x400,

  Gst::PAD_FLAG_FIXED_CAPS = 0x800,

  Gst::PAD_FLAG_PROXY_CAPS = 0x1000,

  Gst::PAD_FLAG_PROXY_ALLOCATION = 0x2000,

  Gst::PAD_FLAG_PROXY_SCHEDULING = 0x4000,

  Gst::PAD_FLAG_LAST = 0x100000

}
 Pad state flags. More...

 
enum  Gst::PadLinkReturn {

  Gst::PAD_LINK_OK = 0,

  Gst::PAD_LINK_WRONG_HIERARCHY = -1,

  Gst::PAD_LINK_WAS_LINKED = -2,

  Gst::PAD_LINK_WRONG_DIRECTION = -3,

  Gst::PAD_LINK_NOFORMAT = -4,

  Gst::PAD_LINK_NOSCHED = -5,

  Gst::PAD_LINK_REFUSED = -6

}
 Result values from gst_pad_link and friends. More...

 
enum  Gst::PadLinkCheck {

  Gst::PAD_LINK_CHECK_NOTHING = 0x0,

  Gst::PAD_LINK_CHECK_HIERARCHY = 1 << 0,

  Gst::PAD_LINK_CHECK_TEMPLATE_CAPS = 1 << 1,

  Gst::PAD_LINK_CHECK_CAPS = 1 << 2,

  Gst::PAD_LINK_CHECK_DEFAULT = 0x5

}
 The amount of checking to be done when linking pads. More...

 
enum  Gst::PadProbeType {

  Gst::PAD_PROBE_TYPE_INVALID = 0x0,

  Gst::PAD_PROBE_TYPE_IDLE = (1 << 0),

  Gst::PAD_PROBE_TYPE_BLOCK = (1 << 1),

  Gst::PAD_PROBE_TYPE_BUFFER = (1 << 4),

  Gst::PAD_PROBE_TYPE_BUFFER_LIST = (1 << 5),

  Gst::PAD_PROBE_TYPE_EVENT_DOWNSTREAM = (1 << 6),

  Gst::PAD_PROBE_TYPE_EVENT_UPSTREAM = (1 << 7),

  Gst::PAD_PROBE_TYPE_EVENT_FLUSH = (1 << 8),

  Gst::PAD_PROBE_TYPE_QUERY_DOWNSTREAM = (1 << 9),

  Gst::PAD_PROBE_TYPE_QUERY_UPSTREAM = (1 << 10),

  Gst::PAD_PROBE_TYPE_PUSH = (1 << 12),

  Gst::PAD_PROBE_TYPE_PULL = (1 << 13),

  Gst::PAD_PROBE_TYPE_BLOCKING = 0x3,

  Gst::PAD_PROBE_TYPE_DATA_DOWNSTREAM = 0x70,

  Gst::PAD_PROBE_TYPE_DATA_UPSTREAM = 0x80,

  Gst::PAD_PROBE_TYPE_DATA_BOTH = 0xF0,

  Gst::PAD_PROBE_TYPE_BLOCK_DOWNSTREAM = 0x72,

  Gst::PAD_PROBE_TYPE_BLOCK_UPSTREAM = 0x82,

  Gst::PAD_PROBE_TYPE_EVENT_BOTH = 0xC0,

  Gst::PAD_PROBE_TYPE_QUERY_BOTH = 0x600,

  Gst::PAD_PROBE_TYPE_ALL_BOTH = 0x6F0,

  Gst::PAD_PROBE_TYPE_SCHEDULING = 0x3000

}
 The different probing types that can occur. More...

 
enum  Gst::PadProbeReturn {

  Gst::PAD_PROBE_DROP,

  Gst::PAD_PROBE_OK,

  Gst::PAD_PROBE_REMOVE,

  Gst::PAD_PROBE_PASS

}
 Different return values for the Gst::SlotPadProbe. More...

 
enum  Gst::PadTemplateFlags { Gst::PAD_TEMPLATE_FLAG_LAST = 0x100 }
 Flags for the padtemplate. More...

 
enum  Gst::PadPresence {

  Gst::PAD_ALWAYS,

  Gst::PAD_SOMETIMES,

  Gst::PAD_REQUEST

}
 Indicates when this pad will become available. More...

 
enum  Gst::Rank {

  Gst::RANK_NONE = 0,

  Gst::RANK_MARGINAL = 64,

  Gst::RANK_SECONDARY = 128,

  Gst::RANK_PRIMARY = 256

}
 Element priority ranks. More...

 
enum  Gst::PluginDependencyFlags {

  Gst::PLUGIN_DEPENDENCY_FLAG_NONE = 0x0,

  Gst::PLUGIN_DEPENDENCY_FLAG_RECURSE = (1 << 0),

  Gst::PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY = (1 << 1),

  Gst::PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX = (1 << 2)

}
 Flags used in connection with Gst::Plugin::add_dependency(). More...

 
enum  Gst::BufferingMode {

  Gst::BUFFERING_STREAM,

  Gst::BUFFERING_DOWNLOAD,

  Gst::BUFFERING_TIMESHIFT,

  Gst::BUFFERING_LIVE

}
 The different types of buffering methods. More...

 
enum  Gst::QueryType {

  Gst::QUERY_UNKNOWN = GST_QUERY_MAKE_TYPE (0, 0),

  Gst::QUERY_POSITION = GST_QUERY_MAKE_TYPE (10, FLAG(BOTH)),

  Gst::QUERY_DURATION = GST_QUERY_MAKE_TYPE (20, FLAG(BOTH)),

  Gst::QUERY_LATENCY = GST_QUERY_MAKE_TYPE (30, FLAG(BOTH)),

  Gst::QUERY_JITTER = GST_QUERY_MAKE_TYPE (40, FLAG(BOTH)),

  Gst::QUERY_RATE = GST_QUERY_MAKE_TYPE (50, FLAG(BOTH)),

  Gst::QUERY_SEEKING = GST_QUERY_MAKE_TYPE (60, FLAG(BOTH)),

  Gst::QUERY_SEGMENT = GST_QUERY_MAKE_TYPE (70, FLAG(BOTH)),

  Gst::QUERY_CONVERT = GST_QUERY_MAKE_TYPE (80, FLAG(BOTH)),

  Gst::QUERY_FORMATS = GST_QUERY_MAKE_TYPE (90, FLAG(BOTH)),

  Gst::QUERY_BUFFERING = GST_QUERY_MAKE_TYPE (110, FLAG(BOTH)),

  Gst::QUERY_CUSTOM = GST_QUERY_MAKE_TYPE (120, FLAG(BOTH)),

  Gst::QUERY_URI = GST_QUERY_MAKE_TYPE (130, FLAG(BOTH)),

  Gst::QUERY_ALLOCATION = GST_QUERY_MAKE_TYPE (140, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),

  Gst::QUERY_SCHEDULING = GST_QUERY_MAKE_TYPE (150, FLAG(UPSTREAM)),

  Gst::QUERY_ACCEPT_CAPS = GST_QUERY_MAKE_TYPE (160, FLAG(BOTH)),

  Gst::QUERY_CAPS = GST_QUERY_MAKE_TYPE (170, FLAG(BOTH)),

  Gst::QUERY_DRAIN = GST_QUERY_MAKE_TYPE (180, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),

  Gst::QUERY_CONTEXT = GST_QUERY_MAKE_TYPE (190, FLAG(BOTH))

}
 Standard predefined Query types. More...

 
enum  Gst::QueryTypeFlags {

  Gst::QUERY_TYPE_UPSTREAM = 1 << 0,

  Gst::QUERY_TYPE_DOWNSTREAM = 1 << 1,

  Gst::QUERY_TYPE_SERIALIZED = 1 << 2

}
 Gst::QueryTypeFlags indicate the aspects of the different Gst::QueryType values. More...

 
enum  Gst::SchedulingFlags {

  Gst::SCHEDULING_FLAG_SEEKABLE = (1 << 0),

  Gst::SCHEDULING_FLAG_SEQUENTIAL = (1 << 1),

  Gst::SCHEDULING_FLAG_BANDWIDTH_LIMITED = (1 << 2)

}
 The different scheduling flags. More...

 
enum  Gst::SeekFlags {

  Gst::SEEK_FLAG_NONE = 0x0,

  Gst::SEEK_FLAG_FLUSH = (1 << 0),

  Gst::SEEK_FLAG_ACCURATE = (1 << 1),

  Gst::SEEK_FLAG_KEY_UNIT = (1 << 2),

  Gst::SEEK_FLAG_SEGMENT = (1 << 3),

  Gst::SEEK_FLAG_SKIP = (1 << 4),

  Gst::SEEK_FLAG_SNAP_BEFORE = (1 << 5),

  Gst::SEEK_FLAG_SNAP_AFTER = (1 << 6),

  Gst::SEEK_FLAG_SNAP_NEAREST = 0x60

}
 Flags to be used with Gst::Element::seek() or gst_event_new_seek(). More...

 
enum  Glib::SeekType
 The different types of seek events. More...

 
enum  Gst::StreamVolumeFormat {

  Gst::STREAM_VOLUME_FORMAT_LINEAR,

  Gst::STREAM_VOLUME_FORMAT_CUBIC,

  Gst::STREAM_VOLUME_FORMAT_DB

}
 Different representations of a stream volume. More...

 
enum  Gst::TagMergeMode {

  Gst::TAG_MERGE_UNDEFINED,

  Gst::TAG_MERGE_REPLACE_ALL,

  Gst::TAG_MERGE_REPLACE,

  Gst::TAG_MERGE_APPEND,

  Gst::TAG_MERGE_PREPEND,

  Gst::TAG_MERGE_KEEP,

  Gst::TAG_MERGE_KEEP_ALL,

  Gst::TAG_MERGE_COUNT

}
 The different tag merging modes are basically replace, overwrite and append, but they can be seen from two directions. More...

 
enum  Gst::TagFlag {

  Gst::TAG_FLAG_UNDEFINED,

  Gst::TAG_FLAG_META,

  Gst::TAG_FLAG_ENCODED,

  Gst::TAG_FLAG_DECODED,

  Gst::TAG_FLAG_COUNT

}
 Extra tag flags used when registering tags. More...

 
enum  Gst::TaskState {

  Gst::TASK_STARTED,

  Gst::TASK_STOPPED,

  Gst::TASK_PAUSED

}
 The different states a task can be in. More...

 
enum  Gst::TocScope {

  Gst::TOC_SCOPE_GLOBAL = 1,

  Gst::TOC_SCOPE_CURRENT

}
 The scope of a TOC. More...

 
enum  Gst::TocEntryType {

  Gst::TOC_ENTRY_TYPE_ANGLE = -3,

  Gst::TOC_ENTRY_TYPE_VERSION,

  Gst::TOC_ENTRY_TYPE_EDITION,

  Gst::TOC_ENTRY_TYPE_INVALID,

  Gst::TOC_ENTRY_TYPE_TITLE,

  Gst::TOC_ENTRY_TYPE_TRACK,

  Gst::TOC_ENTRY_TYPE_CHAPTER

}
 The different types of TOC entries (see Gst::TocEntry). More...

 
enum  Gst::TypeFindProbability {

  Gst::TYPE_FIND_NONE = 0,

  Gst::TYPE_FIND_MINIMUM = 1,

  Gst::TYPE_FIND_POSSIBLE = 50,

  Gst::TYPE_FIND_LIKELY = 80,

  Gst::TYPE_FIND_NEARLY_CERTAIN = 99,

  Gst::TYPE_FIND_MAXIMUM = 100

}
 The probability of the typefind function. More...

 
enum  Gst::URIType {

  Gst::URI_UNKNOWN,

  Gst::URI_SINK,

  Gst::URI_SRC

}
 The different types of URI direction. More...

 
enum  Gst::AppStreamType {

  Gst::APP_STREAM_TYPE_STREAM,

  Gst::APP_STREAM_TYPE_SEEKABLE,

  Gst::APP_STREAM_TYPE_RANDOM_ACCESS

}
 The stream type. More...

 

Functions

AudioFormatFlags Gst::operator| (AudioFormatFlags lhs, AudioFormatFlags rhs)
 
AudioFormatFlags Gst::operator& (AudioFormatFlags lhs, AudioFormatFlags rhs)
 
AudioFormatFlags Gst::operator^ (AudioFormatFlags lhs, AudioFormatFlags rhs)
 
AudioFormatFlags Gst::operator~ (AudioFormatFlags flags)
 
AudioFormatFlags& Gst::operator|= (AudioFormatFlags& lhs, AudioFormatFlags rhs)
 
AudioFormatFlags& Gst::operator&= (AudioFormatFlags& lhs, AudioFormatFlags rhs)
 
AudioFormatFlags& Gst::operator^= (AudioFormatFlags& lhs, AudioFormatFlags rhs)
 
AudioFlags Gst::operator| (AudioFlags lhs, AudioFlags rhs)
 
AudioFlags Gst::operator& (AudioFlags lhs, AudioFlags rhs)
 
AudioFlags Gst::operator^ (AudioFlags lhs, AudioFlags rhs)
 
AudioFlags Gst::operator~ (AudioFlags flags)
 
AudioFlags& Gst::operator|= (AudioFlags& lhs, AudioFlags rhs)
 
AudioFlags& Gst::operator&= (AudioFlags& lhs, AudioFlags rhs)
 
AudioFlags& Gst::operator^= (AudioFlags& lhs, AudioFlags rhs)
 
BinFlags Gst::operator| (BinFlags lhs, BinFlags rhs)
 
BinFlags Gst::operator& (BinFlags lhs, BinFlags rhs)
 
BinFlags Gst::operator^ (BinFlags lhs, BinFlags rhs)
 
BinFlags Gst::operator~ (BinFlags flags)
 
BinFlags& Gst::operator|= (BinFlags& lhs, BinFlags rhs)
 
BinFlags& Gst::operator&= (BinFlags& lhs, BinFlags rhs)
 
BinFlags& Gst::operator^= (BinFlags& lhs, BinFlags rhs)
 
BufferFlags Gst::operator| (BufferFlags lhs, BufferFlags rhs)
 
BufferFlags Gst::operator& (BufferFlags lhs, BufferFlags rhs)
 
BufferFlags Gst::operator^ (BufferFlags lhs, BufferFlags rhs)
 
BufferFlags Gst::operator~ (BufferFlags flags)
 
BufferFlags& Gst::operator|= (BufferFlags& lhs, BufferFlags rhs)
 
BufferFlags& Gst::operator&= (BufferFlags& lhs, BufferFlags rhs)
 
BufferFlags& Gst::operator^= (BufferFlags& lhs, BufferFlags rhs)
 
BufferCopyFlags Gst::operator| (BufferCopyFlags lhs, BufferCopyFlags rhs)
 
BufferCopyFlags Gst::operator& (BufferCopyFlags lhs, BufferCopyFlags rhs)
 
BufferCopyFlags Gst::operator^ (BufferCopyFlags lhs, BufferCopyFlags rhs)
 
BufferCopyFlags Gst::operator~ (BufferCopyFlags flags)
 
BufferCopyFlags& Gst::operator|= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
 
BufferCopyFlags& Gst::operator&= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
 
BufferCopyFlags& Gst::operator^= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
 
BusFlags Gst::operator| (BusFlags lhs, BusFlags rhs)
 
BusFlags Gst::operator& (BusFlags lhs, BusFlags rhs)
 
BusFlags Gst::operator^ (BusFlags lhs, BusFlags rhs)
 
BusFlags Gst::operator~ (BusFlags flags)
 
BusFlags& Gst::operator|= (BusFlags& lhs, BusFlags rhs)
 
BusFlags& Gst::operator&= (BusFlags& lhs, BusFlags rhs)
 
BusFlags& Gst::operator^= (BusFlags& lhs, BusFlags rhs)
 
ClockFlags Gst::operator| (ClockFlags lhs, ClockFlags rhs)
 
ClockFlags Gst::operator& (ClockFlags lhs, ClockFlags rhs)
 
ClockFlags Gst::operator^ (ClockFlags lhs, ClockFlags rhs)
 
ClockFlags Gst::operator~ (ClockFlags flags)
 
ClockFlags& Gst::operator|= (ClockFlags& lhs, ClockFlags rhs)
 
ClockFlags& Gst::operator&= (ClockFlags& lhs, ClockFlags rhs)
 
ClockFlags& Gst::operator^= (ClockFlags& lhs, ClockFlags rhs)
 
ElementFlags Gst::operator| (ElementFlags lhs, ElementFlags rhs)
 
ElementFlags Gst::operator& (ElementFlags lhs, ElementFlags rhs)
 
ElementFlags Gst::operator^ (ElementFlags lhs, ElementFlags rhs)
 
ElementFlags Gst::operator~ (ElementFlags flags)
 
ElementFlags& Gst::operator|= (ElementFlags& lhs, ElementFlags rhs)
 
ElementFlags& Gst::operator&= (ElementFlags& lhs, ElementFlags rhs)
 
ElementFlags& Gst::operator^= (ElementFlags& lhs, ElementFlags rhs)
 
EventType Gst::operator| (EventType lhs, EventType rhs)
 
EventType Gst::operator& (EventType lhs, EventType rhs)
 
EventType Gst::operator^ (EventType lhs, EventType rhs)
 
EventType Gst::operator~ (EventType flags)
 
EventType& Gst::operator|= (EventType& lhs, EventType rhs)
 
EventType& Gst::operator&= (EventType& lhs, EventType rhs)
 
EventType& Gst::operator^= (EventType& lhs, EventType rhs)
 
EventTypeFlags Gst::operator| (EventTypeFlags lhs, EventTypeFlags rhs)
 
EventTypeFlags Gst::operator& (EventTypeFlags lhs, EventTypeFlags rhs)
 
EventTypeFlags Gst::operator^ (EventTypeFlags lhs, EventTypeFlags rhs)
 
EventTypeFlags Gst::operator~ (EventTypeFlags flags)
 
EventTypeFlags& Gst::operator|= (EventTypeFlags& lhs, EventTypeFlags rhs)
 
EventTypeFlags& Gst::operator&= (EventTypeFlags& lhs, EventTypeFlags rhs)
 
EventTypeFlags& Gst::operator^= (EventTypeFlags& lhs, EventTypeFlags rhs)
 
MapFlags Gst::operator| (MapFlags lhs, MapFlags rhs)
 
MapFlags Gst::operator& (MapFlags lhs, MapFlags rhs)
 
MapFlags Gst::operator^ (MapFlags lhs, MapFlags rhs)
 
MapFlags Gst::operator~ (MapFlags flags)
 
MapFlags& Gst::operator|= (MapFlags& lhs, MapFlags rhs)
 
MapFlags& Gst::operator&= (MapFlags& lhs, MapFlags rhs)
 
MapFlags& Gst::operator^= (MapFlags& lhs, MapFlags rhs)
 
MessageType Gst::operator| (MessageType lhs, MessageType rhs)
 
MessageType Gst::operator& (MessageType lhs, MessageType rhs)
 
MessageType Gst::operator^ (MessageType lhs, MessageType rhs)
 
MessageType Gst::operator~ (MessageType flags)
 
MessageType& Gst::operator|= (MessageType& lhs, MessageType rhs)
 
MessageType& Gst::operator&= (MessageType& lhs, MessageType rhs)
 
MessageType& Gst::operator^= (MessageType& lhs, MessageType rhs)
 
MemoryFlags Gst::operator| (MemoryFlags lhs, MemoryFlags rhs)
 
MemoryFlags Gst::operator& (MemoryFlags lhs, MemoryFlags rhs)
 
MemoryFlags Gst::operator^ (MemoryFlags lhs, MemoryFlags rhs)
 
MemoryFlags Gst::operator~ (MemoryFlags flags)
 
MemoryFlags& Gst::operator|= (MemoryFlags& lhs, MemoryFlags rhs)
 
MemoryFlags& Gst::operator&= (MemoryFlags& lhs, MemoryFlags rhs)
 
MemoryFlags& Gst::operator^= (MemoryFlags& lhs, MemoryFlags rhs)
 
MiniObjectFlags Gst::operator| (MiniObjectFlags lhs, MiniObjectFlags rhs)
 
MiniObjectFlags Gst::operator& (MiniObjectFlags lhs, MiniObjectFlags rhs)
 
MiniObjectFlags Gst::operator^ (MiniObjectFlags lhs, MiniObjectFlags rhs)
 
MiniObjectFlags Gst::operator~ (MiniObjectFlags flags)
 
MiniObjectFlags& Gst::operator|= (MiniObjectFlags& lhs, MiniObjectFlags rhs)
 
MiniObjectFlags& Gst::operator&= (MiniObjectFlags& lhs, MiniObjectFlags rhs)
 
MiniObjectFlags& Gst::operator^= (MiniObjectFlags& lhs, MiniObjectFlags rhs)
 
LockFlags Gst::operator| (LockFlags lhs, LockFlags rhs)
 
LockFlags Gst::operator& (LockFlags lhs, LockFlags rhs)
 
LockFlags Gst::operator^ (LockFlags lhs, LockFlags rhs)
 
LockFlags Gst::operator~ (LockFlags flags)
 
LockFlags& Gst::operator|= (LockFlags& lhs, LockFlags rhs)
 
LockFlags& Gst::operator&= (LockFlags& lhs, LockFlags rhs)
 
LockFlags& Gst::operator^= (LockFlags& lhs, LockFlags rhs)
 
ObjectFlags Gst::operator| (ObjectFlags lhs, ObjectFlags rhs)
 
ObjectFlags Gst::operator& (ObjectFlags lhs, ObjectFlags rhs)
 
ObjectFlags Gst::operator^ (ObjectFlags lhs, ObjectFlags rhs)
 
ObjectFlags Gst::operator~ (ObjectFlags flags)
 
ObjectFlags& Gst::operator|= (ObjectFlags& lhs, ObjectFlags rhs)
 
ObjectFlags& Gst::operator&= (ObjectFlags& lhs, ObjectFlags rhs)
 
ObjectFlags& Gst::operator^= (ObjectFlags& lhs, ObjectFlags rhs)
 
PadFlags Gst::operator| (PadFlags lhs, PadFlags rhs)
 
PadFlags Gst::operator& (PadFlags lhs, PadFlags rhs)
 
PadFlags Gst::operator^ (PadFlags lhs, PadFlags rhs)
 
PadFlags Gst::operator~ (PadFlags flags)
 
PadFlags& Gst::operator|= (PadFlags& lhs, PadFlags rhs)
 
PadFlags& Gst::operator&= (PadFlags& lhs, PadFlags rhs)
 
PadFlags& Gst::operator^= (PadFlags& lhs, PadFlags rhs)
 
PadLinkCheck Gst::operator| (PadLinkCheck lhs, PadLinkCheck rhs)
 
PadLinkCheck Gst::operator& (PadLinkCheck lhs, PadLinkCheck rhs)
 
PadLinkCheck Gst::operator^ (PadLinkCheck lhs, PadLinkCheck rhs)
 
PadLinkCheck Gst::operator~ (PadLinkCheck flags)
 
PadLinkCheck& Gst::operator|= (PadLinkCheck& lhs, PadLinkCheck rhs)
 
PadLinkCheck& Gst::operator&= (PadLinkCheck& lhs, PadLinkCheck rhs)
 
PadLinkCheck& Gst::operator^= (PadLinkCheck& lhs, PadLinkCheck rhs)
 
PadProbeType Gst::operator| (PadProbeType lhs, PadProbeType rhs)
 
PadProbeType Gst::operator& (PadProbeType lhs, PadProbeType rhs)
 
PadProbeType Gst::operator^ (PadProbeType lhs, PadProbeType rhs)
 
PadProbeType Gst::operator~ (PadProbeType flags)
 
PadProbeType& Gst::operator|= (PadProbeType& lhs, PadProbeType rhs)
 
PadProbeType& Gst::operator&= (PadProbeType& lhs, PadProbeType rhs)
 
PadProbeType& Gst::operator^= (PadProbeType& lhs, PadProbeType rhs)
 
PadTemplateFlags Gst::operator| (PadTemplateFlags lhs, PadTemplateFlags rhs)
 
PadTemplateFlags Gst::operator& (PadTemplateFlags lhs, PadTemplateFlags rhs)
 
PadTemplateFlags Gst::operator^ (PadTemplateFlags lhs, PadTemplateFlags rhs)
 
PadTemplateFlags Gst::operator~ (PadTemplateFlags flags)
 
PadTemplateFlags& Gst::operator|= (PadTemplateFlags& lhs, PadTemplateFlags rhs)
 
PadTemplateFlags& Gst::operator&= (PadTemplateFlags& lhs, PadTemplateFlags rhs)
 
PadTemplateFlags& Gst::operator^= (PadTemplateFlags& lhs, PadTemplateFlags rhs)
 
PluginDependencyFlags Gst::operator| (PluginDependencyFlags lhs, PluginDependencyFlags rhs)
 
PluginDependencyFlags Gst::operator& (PluginDependencyFlags lhs, PluginDependencyFlags rhs)
 
PluginDependencyFlags Gst::operator^ (PluginDependencyFlags lhs, PluginDependencyFlags rhs)
 
PluginDependencyFlags Gst::operator~ (PluginDependencyFlags flags)
 
PluginDependencyFlags& Gst::operator|= (PluginDependencyFlags& lhs, PluginDependencyFlags rhs)
 
PluginDependencyFlags& Gst::operator&= (PluginDependencyFlags& lhs, PluginDependencyFlags rhs)
 
PluginDependencyFlags& Gst::operator^= (PluginDependencyFlags& lhs, PluginDependencyFlags rhs)
 
QueryType Gst::operator| (QueryType lhs, QueryType rhs)
 
QueryType Gst::operator& (QueryType lhs, QueryType rhs)
 
QueryType Gst::operator^ (QueryType lhs, QueryType rhs)
 
QueryType Gst::operator~ (QueryType flags)
 
QueryType& Gst::operator|= (QueryType& lhs, QueryType rhs)
 
QueryType& Gst::operator&= (QueryType& lhs, QueryType rhs)
 
QueryType& Gst::operator^= (QueryType& lhs, QueryType rhs)
 
QueryTypeFlags Gst::operator| (QueryTypeFlags lhs, QueryTypeFlags rhs)
 
QueryTypeFlags Gst::operator& (QueryTypeFlags lhs, QueryTypeFlags rhs)
 
QueryTypeFlags Gst::operator^ (QueryTypeFlags lhs, QueryTypeFlags rhs)
 
QueryTypeFlags Gst::operator~ (QueryTypeFlags flags)
 
QueryTypeFlags& Gst::operator|= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
 
QueryTypeFlags& Gst::operator&= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
 
QueryTypeFlags& Gst::operator^= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
 
SchedulingFlags Gst::operator| (SchedulingFlags lhs, SchedulingFlags rhs)
 
SchedulingFlags Gst::operator& (SchedulingFlags lhs, SchedulingFlags rhs)
 
SchedulingFlags Gst::operator^ (SchedulingFlags lhs, SchedulingFlags rhs)
 
SchedulingFlags Gst::operator~ (SchedulingFlags flags)
 
SchedulingFlags& Gst::operator|= (SchedulingFlags& lhs, SchedulingFlags rhs)
 
SchedulingFlags& Gst::operator&= (SchedulingFlags& lhs, SchedulingFlags rhs)
 
SchedulingFlags& Gst::operator^= (SchedulingFlags& lhs, SchedulingFlags rhs)
 
SeekFlags Gst::operator| (SeekFlags lhs, SeekFlags rhs)
 
SeekFlags Gst::operator& (SeekFlags lhs, SeekFlags rhs)
 
SeekFlags Gst::operator^ (SeekFlags lhs, SeekFlags rhs)
 
SeekFlags Gst::operator~ (SeekFlags flags)
 
SeekFlags& Gst::operator|= (SeekFlags& lhs, SeekFlags rhs)
 
SeekFlags& Gst::operator&= (SeekFlags& lhs, SeekFlags rhs)
 
SeekFlags& Gst::operator^= (SeekFlags& lhs, SeekFlags rhs)
 
PlayFlags Gst::operator| (PlayFlags lhs, PlayFlags rhs)
 
PlayFlags Gst::operator& (PlayFlags lhs, PlayFlags rhs)
 
PlayFlags Gst::operator^ (PlayFlags lhs, PlayFlags rhs)
 
PlayFlags Gst::operator~ (PlayFlags flags)
 
PlayFlags& Gst::operator|= (PlayFlags& lhs, PlayFlags rhs)
 
PlayFlags& Gst::operator&= (PlayFlags& lhs, PlayFlags rhs)
 
PlayFlags& Gst::operator^= (PlayFlags& lhs, PlayFlags rhs)
 
TextRenderLineAlign Gst::operator| (TextRenderLineAlign lhs, TextRenderLineAlign rhs)
 
TextRenderLineAlign Gst::operator& (TextRenderLineAlign lhs, TextRenderLineAlign rhs)
 
TextRenderLineAlign Gst::operator^ (TextRenderLineAlign lhs, TextRenderLineAlign rhs)
 
TextRenderLineAlign Gst::operator~ (TextRenderLineAlign flags)
 
TextRenderLineAlign& Gst::operator|= (TextRenderLineAlign& lhs, TextRenderLineAlign rhs)
 
TextRenderLineAlign& Gst::operator&= (TextRenderLineAlign& lhs, TextRenderLineAlign rhs)
 
TextRenderLineAlign& Gst::operator^= (TextRenderLineAlign& lhs, TextRenderLineAlign rhs)
 

Detailed Description

Enumeration Type Documentation

enum Gst::AppStreamType

The stream type.

Enumerator
APP_STREAM_TYPE_STREAM 

No seeking is supported in the stream, such as a live stream.

APP_STREAM_TYPE_SEEKABLE 

The stream is seekable but seeking might not be very fast, such as data from a webserver.

APP_STREAM_TYPE_RANDOM_ACCESS 

The stream is seekable and seeking is fast, such as in a local file.

enum Gst::AudioBaseSinkSlaveMethod

Different possible clock slaving algorithms used when the internal audio clock is not selected as the pipeline master clock.

Enumerator
AUDIO_BASE_SINK_SLAVE_RESAMPLE 

Resample to match the master clock.

AUDIO_BASE_SINK_SLAVE_SKEW 

Adjust playout pointer when master clock drifts too much.

AUDIO_BASE_SINK_SLAVE_NONE 

No adjustment is done.

enum Gst::AudioBaseSrcSlaveMethod

Different possible clock slaving algorithms when the internal audio clock was not selected as the pipeline clock.

Enumerator
AUDIO_BASE_SRC_SLAVE_RESAMPLE 

Resample to match the master clock.

AUDIO_BASE_SRC_SLAVE_RETIMESTAMP 

Retimestamp output buffers with master clock time.

AUDIO_BASE_SRC_SLAVE_SKEW 

Adjust capture pointer when master clock drifts too much.

AUDIO_BASE_SRC_SLAVE_NONE 

No adjustment is done.

enum Gst::AudioChannelPosition

Audio channel positions.

These are the channels defined in SMPTE 2036-2-2008 Table 1 for 22.2 audio systems with the Surround and Wide channels from DTS Coherent Acoustics (v.1.3.1) and 10.2 and 7.1 layouts. In the caps the actual channel layout is expressed with a channel count and a channel mask, which describes the existing channels. The positions in the bit mask correspond to the enum values. For negotiation it is allowed to have more bits set in the channel mask than the number of channels to specify the allowed channel positions but this is not allowed in negotiated caps. It is not allowed in any situation other than the one mentioned below to have less bits set in the channel mask than the number of channels.

GST_AUDIO_CHANNEL_POSITION_MONO can only be used with a single mono channel that has no direction information and would be mixed into all directional channels. This is expressed in caps by having a single channel and no channel mask.

GST_AUDIO_CHANNEL_POSITION_NONE can only be used if all channels have this position. This is expressed in caps by having a channel mask with no bits set.

As another special case it is allowed to have two channels without a channel mask. This implicitely means that this is a stereo stream with a front left and front right channel.

Enumerator
AUDIO_CHANNEL_POSITION_NONE 

Used for position-less channels, e.g.

from a sound card that records 1024 channels; mutually exclusive with any other channel position.

AUDIO_CHANNEL_POSITION_MONO 

Mono without direction; can only be used with 1 channel.

AUDIO_CHANNEL_POSITION_INVALID 

Invalid position.

AUDIO_CHANNEL_POSITION_FRONT_LEFT 

Front left.

AUDIO_CHANNEL_POSITION_FRONT_RIGHT 

Front right.

AUDIO_CHANNEL_POSITION_FRONT_CENTER 

Front center.

AUDIO_CHANNEL_POSITION_LFE1 

Low-frequency effects 1 (subwoofer).

AUDIO_CHANNEL_POSITION_REAR_LEFT 

Rear left.

AUDIO_CHANNEL_POSITION_REAR_RIGHT 

Rear right.

AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER 

Front left of center.

AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER 

Front right of center.

AUDIO_CHANNEL_POSITION_REAR_CENTER 

Rear center.

AUDIO_CHANNEL_POSITION_LFE2 

Low-frequency effects 2 (subwoofer).

AUDIO_CHANNEL_POSITION_SIDE_LEFT 

Side left.

AUDIO_CHANNEL_POSITION_SIDE_RIGHT 

Side right.

AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT 

Top front left.

AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT 

Top front right.

AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER 

Top front center.

AUDIO_CHANNEL_POSITION_TOP_CENTER 

Top center.

AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT 

Top rear left.

AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT 

Top rear right.

AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT 

Top side right.

AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT 

Top rear right.

AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER 

Top rear center.

AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER 

Bottom front center.

AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT 

Bottom front left.

AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT 

Bottom front right.

AUDIO_CHANNEL_POSITION_WIDE_LEFT 

Wide left (between front left and side left).

AUDIO_CHANNEL_POSITION_WIDE_RIGHT 

Wide right (between front right and side right).

AUDIO_CHANNEL_POSITION_SURROUND_LEFT 

Surround left (between rear left and side left).

AUDIO_CHANNEL_POSITION_SURROUND_RIGHT 

Surround right (between rear right and side right).

enum Gst::AudioConvertDithering
Enumerator
NONE 
RPDF 
TPDF 
TPDF_HF 
enum Gst::AudioConvertNoiseShaping
Enumerator
SHAPING_NONE 
SHAPING_ERROR_FEEDBACK 
SHAPING_SIMPLE 
SHAPING_MEDIUM 
SHAPING_HIGH 
enum Gst::AudioFlags

Extra audio flags.

Bitwise operators:
AudioFlags operator|(AudioFlags, AudioFlags)

AudioFlags operator&(AudioFlags, AudioFlags)

AudioFlags operator^(AudioFlags, AudioFlags)

AudioFlags operator~(AudioFlags)

AudioFlags& operator|=(AudioFlags&, AudioFlags)

AudioFlags& operator&=(AudioFlags&, AudioFlags)

AudioFlags& operator^=(AudioFlags&, AudioFlags)

Enumerator
AUDIO_FLAG_NONE 

No valid flag.

AUDIO_FLAG_UNPOSITIONED 

The position array explicitly contains unpositioned channels.

enum Gst::AudioFormat

Enum value describing the most common audio formats.

Enumerator
AUDIO_FORMAT_UNKNOWN 

Unknown or unset audio format.

AUDIO_FORMAT_ENCODED 

Encoded audio format.

AUDIO_FORMAT_S8 

8 bits in 8 bits, signed.

AUDIO_FORMAT_U8 

8 bits in 8 bits, unsigned.

AUDIO_FORMAT_S16LE 

16 bits in 16 bits, signed, little endian.

AUDIO_FORMAT_S16BE 

16 bits in 16 bits, signed, big endian.

AUDIO_FORMAT_U16LE 

16 bits in 16 bits, unsigned, little endian.

AUDIO_FORMAT_U16BE 

16 bits in 16 bits, unsigned, big endian.

AUDIO_FORMAT_S24_32LE 

24 bits in 32 bits, signed, little endian.

AUDIO_FORMAT_S24_32BE 

24 bits in 32 bits, signed, big endian.

AUDIO_FORMAT_U24_32LE 

24 bits in 32 bits, unsigned, little endian.

AUDIO_FORMAT_U24_32BE 

24 bits in 32 bits, unsigned, big endian.

AUDIO_FORMAT_S32LE 

32 bits in 32 bits, signed, little endian.

AUDIO_FORMAT_S32BE 

32 bits in 32 bits, signed, big endian.

AUDIO_FORMAT_U32LE 

32 bits in 32 bits, unsigned, little endian.

AUDIO_FORMAT_U32BE 

32 bits in 32 bits, unsigned, big endian.

AUDIO_FORMAT_S24LE 

24 bits in 24 bits, signed, little endian.

AUDIO_FORMAT_S24BE 

24 bits in 24 bits, signed, big endian.

AUDIO_FORMAT_U24LE 

24 bits in 24 bits, unsigned, little endian.

AUDIO_FORMAT_U24BE 

24 bits in 24 bits, unsigned, big endian.

AUDIO_FORMAT_S20LE 

20 bits in 24 bits, signed, little endian.

AUDIO_FORMAT_S20BE 

20 bits in 24 bits, signed, big endian.

AUDIO_FORMAT_U20LE 

20 bits in 24 bits, unsigned, little endian.

AUDIO_FORMAT_U20BE 

20 bits in 24 bits, unsigned, big endian.

AUDIO_FORMAT_S18LE 

18 bits in 24 bits, signed, little endian.

AUDIO_FORMAT_S18BE 

18 bits in 24 bits, signed, big endian.

AUDIO_FORMAT_U18LE 

18 bits in 24 bits, unsigned, little endian.

AUDIO_FORMAT_U18BE 

18 bits in 24 bits, unsigned, big endian.

AUDIO_FORMAT_F32LE 

32-bit floating point samples, little endian.

AUDIO_FORMAT_F32BE 

32-bit floating point samples, big endian.

AUDIO_FORMAT_F64LE 

64-bit floating point samples, little endian.

AUDIO_FORMAT_F64BE 

64-bit floating point samples, big endian.

AUDIO_FORMAT_S16 

16 bits in 16 bits, signed, native endianness.

AUDIO_FORMAT_U16 

16 bits in 16 bits, unsigned, native endianness.

AUDIO_FORMAT_S24_32 

24 bits in 32 bits, signed, native endianness.

AUDIO_FORMAT_U24_32 

24 bits in 32 bits, unsigned, native endianness.

AUDIO_FORMAT_S32 

32 bits in 32 bits, signed, native endianness.

AUDIO_FORMAT_U32 

32 bits in 32 bits, unsigned, native endianness.

AUDIO_FORMAT_S24 

24 bits in 24 bits, signed, native endianness.

AUDIO_FORMAT_U24 

24 bits in 24 bits, unsigned, native endianness.

AUDIO_FORMAT_S20 

20 bits in 24 bits, signed, native endianness.

AUDIO_FORMAT_U20 

20 bits in 24 bits, unsigned, native endianness.

AUDIO_FORMAT_S18 

18 bits in 24 bits, signed, native endianness.

AUDIO_FORMAT_U18 

18 bits in 24 bits, unsigned, native endianness.

AUDIO_FORMAT_F32 

32-bit floating point samples, native endianness.

AUDIO_FORMAT_F64 

64-bit floating point samples, native endianness.

enum Gst::AudioFormatFlags

The different audio flags that a format info can have.

Bitwise operators:
AudioFormatFlags operator|(AudioFormatFlags, AudioFormatFlags)

AudioFormatFlags operator&(AudioFormatFlags, AudioFormatFlags)

AudioFormatFlags operator^(AudioFormatFlags, AudioFormatFlags)

AudioFormatFlags operator~(AudioFormatFlags)

AudioFormatFlags& operator|=(AudioFormatFlags&, AudioFormatFlags)

AudioFormatFlags& operator&=(AudioFormatFlags&, AudioFormatFlags)

AudioFormatFlags& operator^=(AudioFormatFlags&, AudioFormatFlags)

Enumerator
AUDIO_FORMAT_FLAG_INTEGER 

Integer samples.

AUDIO_FORMAT_FLAG_FLOAT 

Float samples.

AUDIO_FORMAT_FLAG_SIGNED 

Signed samples.

AUDIO_FORMAT_FLAG_COMPLEX 

Complex layout.

AUDIO_FORMAT_FLAG_UNPACK 

The format can be used in Gst::AudioFormatUnpack and Gst::AudioFormatPack functions.

enum Gst::AudioLayout

Layout of the audio samples for the different channels.

Enumerator
AUDIO_LAYOUT_INTERLEAVED 

Interleaved audio.

AUDIO_LAYOUT_NON_INTERLEAVED 

Non-interleaved audio.

enum Gst::AudioRingBufferFormatType

The format of the samples in the ringbuffer.

Enumerator
AUDIO_RING_BUFFER_FORMAT_TYPE_RAW 

Samples in linear or float.

AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW 

Samples in mulaw.

AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW 

Samples in alaw.

AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM 

Samples in ima adpcm.

AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG 

Samples in mpeg audio (but not AAC) format.

AUDIO_RING_BUFFER_FORMAT_TYPE_GSM 

Samples in gsm format.

AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958 

Samples in IEC958 frames (e.g.

AC3).

AUDIO_RING_BUFFER_FORMAT_TYPE_AC3 

Samples in AC3 format.

AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3 

Samples in EAC3 format.

AUDIO_RING_BUFFER_FORMAT_TYPE_DTS 

Samples in DTS format.

AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC 

Samples in MPEG-2 AAC format.

AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC 

Samples in MPEG-4 AAC format.

enum Gst::AudioRingBufferState

The state of the ringbuffer.

Enumerator
AUDIO_RING_BUFFER_STATE_STOPPED 

The ringbuffer is stopped.

AUDIO_RING_BUFFER_STATE_PAUSED 

The ringbuffer is paused.

AUDIO_RING_BUFFER_STATE_STARTED 

The ringbuffer is started.

AUDIO_RING_BUFFER_STATE_ERROR 

The ringbuffer has encountered an error after it has been started, e.g.

because the device was disconnected (Since 1.2).

enum Gst::AudioTestSrcWave
Enumerator
AUDIO_TEST_SRC_WAVE_SINE 
AUDIO_TEST_SRC_WAVE_SQUARE 
AUDIO_TEST_SRC_WAVE_SAW 
AUDIO_TEST_SRC_WAVE_TRIANGLE 
AUDIO_TEST_SRC_WAVE_SILENCE 
AUDIO_TEST_SRC_WAVE_WHITE_NOISE 
AUDIO_TEST_SRC_WAVE_PINK_NOISE 
AUDIO_TEST_SRC_WAVE_SINE_TAB 
AUDIO_TEST_SRC_WAVE_TICKS 
AUDIO_TEST_SRC_WAVE_GAUSSIAN_WHITE_NOISE 
AUDIO_TEST_SRC_WAVE_RED_NOISE 
AUDIO_TEST_SRC_WAVE_BLUE_NOISE 
AUDIO_TEST_SRC_WAVE_VIOLET_NOISE 
enum Gst::AutoplugSelectResult
Enumerator
AUTOPLUG_SELECT_TRY 
AUTOPLUG_SELECT_EXPOSE 
AUTOPLUG_SELECT_SKIP 
enum Gst::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 ().

Bitwise operators:
BinFlags operator|(BinFlags, BinFlags)

BinFlags operator&(BinFlags, BinFlags)

BinFlags operator^(BinFlags, BinFlags)

BinFlags operator~(BinFlags)

BinFlags& operator|=(BinFlags&, BinFlags)

BinFlags& operator&=(BinFlags&, BinFlags)

BinFlags& operator^=(BinFlags&, BinFlags)

Enumerator
BIN_FLAG_NO_RESYNC 

Don't resync a state change when elements are added or linked in the bin.

BIN_FLAG_LAST 

The last enum in the series of flags for bins.

Derived classes can use this as first value in a list of flags.

enum Gst::BufferCopyFlags

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

Bitwise operators:
BufferCopyFlags operator|(BufferCopyFlags, BufferCopyFlags)

BufferCopyFlags operator&(BufferCopyFlags, BufferCopyFlags)

BufferCopyFlags operator^(BufferCopyFlags, BufferCopyFlags)

BufferCopyFlags operator~(BufferCopyFlags)

BufferCopyFlags& operator|=(BufferCopyFlags&, BufferCopyFlags)

BufferCopyFlags& operator&=(BufferCopyFlags&, BufferCopyFlags)

BufferCopyFlags& operator^=(BufferCopyFlags&, BufferCopyFlags)

Enumerator
BUFFER_COPY_NONE 

Copy nothing.

BUFFER_COPY_FLAGS 

Flag indicating that buffer flags should be copied.

BUFFER_COPY_TIMESTAMPS 

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

BUFFER_COPY_META 

Flag indicating that buffer meta should be copied.

BUFFER_COPY_MEMORY 

Flag indicating that buffer memory should be reffed and appended to already existing memory.

Unless the memory is marked as NO_SHARE, no actual copy of the memory is made but it is simply reffed. Add GST_BUFFER_COPY_DEEP to force a real copy.

BUFFER_COPY_MERGE 

Flag indicating that buffer memory should be merged.

BUFFER_COPY_DEEP 

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

enum Gst::BufferFlags

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

Bitwise operators:
BufferFlags operator|(BufferFlags, BufferFlags)

BufferFlags operator&(BufferFlags, BufferFlags)

BufferFlags operator^(BufferFlags, BufferFlags)

BufferFlags operator~(BufferFlags)

BufferFlags& operator|=(BufferFlags&, BufferFlags)

BufferFlags& operator&=(BufferFlags&, BufferFlags)

BufferFlags& operator^=(BufferFlags&, BufferFlags)

Enumerator
BUFFER_FLAG_LIVE 

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

BUFFER_FLAG_DECODE_ONLY 

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.

BUFFER_FLAG_DISCONT 

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.

BUFFER_FLAG_RESYNC 

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

BUFFER_FLAG_CORRUPTED 

The buffer data is corrupted.

BUFFER_FLAG_MARKER 

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.

BUFFER_FLAG_HEADER 

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

BUFFER_FLAG_GAP 

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

BUFFER_FLAG_DROPPABLE 

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

BUFFER_FLAG_DELTA_UNIT 

This unit cannot be decoded independently.

BUFFER_FLAG_LAST 

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

enum Gst::BufferingMode

The different types of buffering methods.

Enumerator
BUFFERING_STREAM 

A small amount of data is buffered.

BUFFERING_DOWNLOAD 

The stream is being downloaded.

BUFFERING_TIMESHIFT 

The stream is being downloaded in a ringbuffer.

BUFFERING_LIVE 

The stream is a live stream.

enum Gst::BusFlags

The standard flags that a bus may have.

Bitwise operators:
BusFlags operator|(BusFlags, BusFlags)

BusFlags operator&(BusFlags, BusFlags)

BusFlags operator^(BusFlags, BusFlags)

BusFlags operator~(BusFlags)

BusFlags& operator|=(BusFlags&, BusFlags)

BusFlags& operator&=(BusFlags&, BusFlags)

BusFlags& operator^=(BusFlags&, BusFlags)

Enumerator
BUS_FLUSHING 

The bus is currently dropping all messages.

BUS_FLAG_LAST 

Offset to define more flags.

enum Gst::BusSyncReply

The result values for a GstBusSyncHandler.

Enumerator
BUS_DROP 

The result values for a Gst::Bus::SlotMessageSync.

BUS_PASS 

Pass the message to the async queue.

BUS_ASYNC 

Pass message to async queue, continue if message is handled.

enum Gst::CapsIntersectMode

Modes of caps intersection.

GST_CAPS_INTERSECT_ZIG_ZAG tries to preserve overall order of both caps by iterating on the caps' structures as the following matrix shows:

[C example ellipted] Used when there is no explicit precedence of one caps over the other. e.g. tee's sink pad getcaps function, it will probe its src pad peers' for their caps and intersect them with this mode.

GST_CAPS_INTERSECT_FIRST is useful when an element wants to preserve another element's caps priority order when intersecting with its own caps. Example: If caps1 is [A, B, C] and caps2 is [E, B, D, A], the result would be [A, B], maintaining the first caps priority on the intersection.

Enumerator
CAPS_INTERSECT_ZIG_ZAG 

Zig-zags over both caps.

CAPS_INTERSECT_FIRST 

Keeps the first caps order.

enum Gst::CdParanoiaMode
Enumerator
PARANOIA_MODE_DISABLE 
PARANOIA_MODE_FRAGMENT 
PARANOIA_MODE_OVERLAP 
PARANOIA_MODE_SCRATCH 
PARANOIA_MODE_REPAIR 
PARANOIA_MODE_FULL 
enum Gst::ClockEntryType

The type of the clock entry.

Enumerator
CLOCK_ENTRY_SINGLE 

A single shot timeout.

CLOCK_ENTRY_PERIODIC 

A periodic timeout request.

enum Gst::ClockFlags

The capabilities of this clock.

Bitwise operators:
ClockFlags operator|(ClockFlags, ClockFlags)

ClockFlags operator&(ClockFlags, ClockFlags)

ClockFlags operator^(ClockFlags, ClockFlags)

ClockFlags operator~(ClockFlags)

ClockFlags& operator|=(ClockFlags&, ClockFlags)

ClockFlags& operator&=(ClockFlags&, ClockFlags)

ClockFlags& operator^=(ClockFlags&, ClockFlags)

Enumerator
CLOCK_FLAG_CAN_DO_SINGLE_SYNC 

Clock can do a single sync timeout request.

CLOCK_FLAG_CAN_DO_SINGLE_ASYNC 

Clock can do a single async timeout request.

CLOCK_FLAG_CAN_DO_PERIODIC_SYNC 

Clock can do sync periodic timeout requests.

CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC 

Clock can do async periodic timeout callbacks.

CLOCK_FLAG_CAN_SET_RESOLUTION 

Clock's resolution can be changed.

CLOCK_FLAG_CAN_SET_MASTER 

Clock can be slaved to a master clock.

CLOCK_FLAG_LAST 

Subclasses can add additional flags starting from this flag.

enum Gst::ClockReturn

The return value of a clock operation.

Enumerator
CLOCK_OK 

The operation succeeded.

CLOCK_EARLY 

The operation was scheduled too late.

CLOCK_UNSCHEDULED 

The clockID was unscheduled.

CLOCK_BUSY 

The ClockID is busy.

CLOCK_BADTIME 

A bad time was provided to a function.

CLOCK_ERROR 

An error occurred.

CLOCK_UNSUPPORTED 

Operation is not supported.

CLOCK_DONE 

The ClockID is done waiting.

enum Gst::ColorBalanceType

An enumeration indicating whether an element implements color balancing operations in software or in dedicated hardware.

In general, dedicated hardware implementations (such as those provided by xvimagesink) are preferred.

Enumerator
COLOR_BALANCE_HARDWARE 

Color balance is implemented with dedicated hardware.

COLOR_BALANCE_SOFTWARE 

Color balance is implemented via software processing.

enum Gst::DiscovererResult

Result values for the discovery process.

Enumerator
DISCOVERER_OK 

The discovery was successful.

DISCOVERER_URI_INVALID 

The URI is invalid.

DISCOVERER_ERROR 

An error happened and the GError is set.

DISCOVERER_TIMEOUT 

The discovery timed-out.

DISCOVERER_BUSY 

The discoverer was already discovering a file.

DISCOVERER_MISSING_PLUGINS 

Some plugins are missing for full discovery.

enum Gst::ElementFlags

The standard flags that an element may have.

Bitwise operators:
ElementFlags operator|(ElementFlags, ElementFlags)

ElementFlags operator&(ElementFlags, ElementFlags)

ElementFlags operator^(ElementFlags, ElementFlags)

ElementFlags operator~(ElementFlags)

ElementFlags& operator|=(ElementFlags&, ElementFlags)

ElementFlags& operator&=(ElementFlags&, ElementFlags)

ElementFlags& operator^=(ElementFlags&, ElementFlags)

Enumerator
ELEMENT_FLAG_LOCKED_STATE 

Ignore state changes from parent.

ELEMENT_FLAG_SINK 

The element is a sink.

ELEMENT_FLAG_SOURCE 

The element is a source.

ELEMENT_FLAG_PROVIDE_CLOCK 

The element can provide a clock.

ELEMENT_FLAG_REQUIRE_CLOCK 

The element requires a clock.

ELEMENT_FLAG_INDEXABLE 

The element can use an index.

ELEMENT_FLAG_LAST 

Offset to define more flags.

enum Gst::EventType

Gst::EventType lists the standard event types that can be sent in a pipeline.

The custom event types can be used for private messages between elements that can't be expressed using normal GStreamer buffer passing semantics. Custom events carry an arbitrary Gst::Structure. Specific custom events are distinguished by the name of the structure.

Bitwise operators:
EventType operator|(EventType, EventType)

EventType operator&(EventType, EventType)

EventType operator^(EventType, EventType)

EventType operator~(EventType)

EventType& operator|=(EventType&, EventType)

EventType& operator&=(EventType&, EventType)

EventType& operator^=(EventType&, EventType)

Enumerator
EVENT_UNKNOWN 

Unknown event.

EVENT_FLUSH_START 

Start a flush operation.

This event clears all data from the pipeline and unblock all streaming threads.

EVENT_FLUSH_STOP 

Stop a flush operation.

This event resets the running-time of the pipeline.

EVENT_STREAM_START 

Event to mark the start of a new stream.

Sent before any other serialized event and only sent at the start of a new stream, not after flushing seeks.

EVENT_CAPS 

Gst::Caps event.

Notify the pad of a new media type.

EVENT_SEGMENT 

A new media segment follows in the dataflow.

The segment events contains information for clipping buffers and converting buffer timestamps to running-time and stream-time.

EVENT_TAG 

A new set of metadata tags has been found in the stream.

EVENT_BUFFERSIZE 

Notification of buffering requirements.

Currently not used yet.

EVENT_SINK_MESSAGE 

An event that sinks turn into a message.

Used to send messages that should be emitted in sync with rendering.

EVENT_EOS 

End-Of-Stream.

No more data is to be expected to follow without a SEGMENT event.

EVENT_TOC 

An event which indicates that a new table of contents (TOC) was found or updated.

EVENT_SEGMENT_DONE 

Marks the end of a segment playback.

EVENT_GAP 

Marks a gap in the datastream.

EVENT_QOS 

A quality message.

Used to indicate to upstream elements that the downstream elements should adjust their processing rate.

EVENT_SEEK 

A request for a new playback position and rate.

EVENT_NAVIGATION 

Navigation events are usually used for communicating user requests, such as mouse or keyboard movements, to upstream elements.

EVENT_LATENCY 

Notification of new latency adjustment.

Sinks will use the latency information to adjust their synchronisation.

EVENT_STEP 

A request for stepping through the media.

Sinks will usually execute the step operation.

EVENT_RECONFIGURE 

A request for upstream renegotiating caps and reconfiguring.

EVENT_TOC_SELECT 

A request for a new playback position based on TOC entry's UID.

EVENT_CUSTOM_UPSTREAM 

Upstream custom event.

EVENT_CUSTOM_DOWNSTREAM 

Downstream custom event that travels in the data flow.

EVENT_CUSTOM_DOWNSTREAM_OOB 

Custom out-of-band downstream event.

EVENT_CUSTOM_DOWNSTREAM_STICKY 

Custom sticky downstream event.

EVENT_CUSTOM_BOTH 

Custom upstream or downstream event.

In-band when travelling downstream.

EVENT_CUSTOM_BOTH_OOB 

Custom upstream or downstream out-of-band event.

enum Gst::EventTypeFlags

Gst::EventTypeFlags indicate the aspects of the different Gst::EventType values.

You can get the type flags of a Gst::EventType with the gst_event_type_get_flags() function.

Bitwise operators:
EventTypeFlags operator|(EventTypeFlags, EventTypeFlags)

EventTypeFlags operator&(EventTypeFlags, EventTypeFlags)

EventTypeFlags operator^(EventTypeFlags, EventTypeFlags)

EventTypeFlags operator~(EventTypeFlags)

EventTypeFlags& operator|=(EventTypeFlags&, EventTypeFlags)

EventTypeFlags& operator&=(EventTypeFlags&, EventTypeFlags)

EventTypeFlags& operator^=(EventTypeFlags&, EventTypeFlags)

Enumerator
EVENT_TYPE_UPSTREAM 

Set if the event can travel upstream.

EVENT_TYPE_DOWNSTREAM 

Set if the event can travel downstream.

EVENT_TYPE_SERIALIZED 

Set if the event should be serialized with data flow.

EVENT_TYPE_STICKY 

Set if the event is sticky on the pads.

EVENT_TYPE_STICKY_MULTI 

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

enum Gst::FakeSinkStateError
Enumerator
SINK_STATE_ERROR_NONE 
SINK_STATE_ERROR_NULL_READY 
SINK_STATE_ERROR_READY_PAUSED 
SINK_STATE_ERROR_PAUSED_PLAYING 
SINK_STATE_ERROR_PLAYING_PAUSED 
SINK_STATE_ERROR_PAUSED_READY 
SINK_STATE_ERROR_READY_NULL 
enum Gst::FakeSrcDataType
Enumerator
SRC_DATA_ALLOCATE 
SRC_DATA_SUBBUFFER 
enum Gst::FakeSrcFillType
Enumerator
SRC_FILLTYPE_NOTHING 
SRC_FILLTYPE_ZERO 
SRC_FILLTYPE_RANDOM 
SRC_FILLTYPE_PATTERN 
SRC_FILLTYPE_PATTERN_CONT 
enum Gst::FakeSrcSizeType
Enumerator
SRC_SIZETYPE_EMPTY 
SRC_SIZETYPE_FIXED 
SRC_SIZETYPE_RANDOM 
enum Gst::FileSinkBufferMode
Enumerator
FILE_SINK_BUFFER_MODE_DEFAULT 
FILE_SINK_BUFFER_MODE_FULL 
FILE_SINK_BUFFER_MODE_LINE 
FILE_SINK_BUFFER_MODE_UNBUFFERED 
enum Gst::FlowReturn

The result of passing data to a pad.

Note that the custom return values should not be exposed outside of the element scope.

Enumerator
FLOW_CUSTOM_SUCCESS_2 

Pre-defined custom success code.

FLOW_CUSTOM_SUCCESS_1 

Pre-defined custom success code (define your custom success code to this to avoid compiler warnings).

FLOW_CUSTOM_SUCCESS 

Elements can use values starting from this (and higher) to define custom success codes.

FLOW_OK 

Data passing was ok.

FLOW_NOT_LINKED 

Pad is not linked.

FLOW_FLUSHING 

Pad is flushing.

FLOW_EOS 

Pad is EOS.

FLOW_NOT_NEGOTIATED 

Pad is not negotiated.

FLOW_ERROR 

Some (fatal) error occured.

Element generating this error should post an error message with more details.

FLOW_NOT_SUPPORTED 

This operation is not supported.

FLOW_CUSTOM_ERROR 

Elements can use values starting from this (and lower) to define custom error codes.

FLOW_CUSTOM_ERROR_1 

Pre-defined custom error code (define your custom error code to this to avoid compiler warnings).

FLOW_CUSTOM_ERROR_2 

Pre-defined custom error code.

enum Gst::Format

Standard predefined formats.

Enumerator
FORMAT_UNDEFINED 

Undefined format.

FORMAT_DEFAULT 

The default format of the pad/element.

This can be samples for raw audio, frames/fields for raw video (some, but not all, elements support this; use GST_FORMAT_TIME if you don't have a good reason to query for samples/frames).

FORMAT_BYTES 

Bytes.

FORMAT_TIME 

Time in nanoseconds.

FORMAT_BUFFERS 

Buffers (few, if any, elements implement this as of May 2009).

FORMAT_PERCENT 

Percentage of stream (few, if any, elements implement this as of May 2009).

enum Gst::InputSelectorSyncMode
Enumerator
INPUT_SELECTOR_SYNC_MODE_ACTIVE_SEGMENT 
INPUT_SELECTOR_SYNC_MODE_CLOCK 
enum Gst::IteratorItem

The result of a Gst::IteratorItemFunction.

Enumerator
ITERATOR_ITEM_SKIP 

Skip this item.

ITERATOR_ITEM_PASS 

Return item.

ITERATOR_ITEM_END 

Stop after this item.

enum Gst::IteratorResult

The result of Gst::Iterator::next().

Enumerator
ITERATOR_DONE 

No more items in the iterator.

ITERATOR_OK 

An item was retrieved.

ITERATOR_RESYNC 

Datastructure changed while iterating.

ITERATOR_ERROR 

An error happened.

enum Gst::LockFlags

Flags used when locking miniobjects.

Bitwise operators:
LockFlags operator|(LockFlags, LockFlags)

LockFlags operator&(LockFlags, LockFlags)

LockFlags operator^(LockFlags, LockFlags)

LockFlags operator~(LockFlags)

LockFlags& operator|=(LockFlags&, LockFlags)

LockFlags& operator&=(LockFlags&, LockFlags)

LockFlags& operator^=(LockFlags&, LockFlags)

Enumerator
LOCK_FLAG_READ 

Lock for read access.

LOCK_FLAG_WRITE 

Lock for write access.

LOCK_FLAG_EXCLUSIVE 

Lock for exclusive access.

LOCK_FLAG_LAST 

First flag that can be used for custom purposes.

enum Gst::MapFlags

Flags used when mapping memory.

Bitwise operators:
MapFlags operator|(MapFlags, MapFlags)

MapFlags operator&(MapFlags, MapFlags)

MapFlags operator^(MapFlags, MapFlags)

MapFlags operator~(MapFlags)

MapFlags& operator|=(MapFlags&, MapFlags)

MapFlags& operator&=(MapFlags&, MapFlags)

MapFlags& operator^=(MapFlags&, MapFlags)

Enumerator
MAP_READ 

Map for read access.

MAP_WRITE 

Map for write access.

MAP_FLAG_LAST 

First flag that can be used for custom purposes.

enum Gst::MemoryFlags

Flags for wrapped memory.

Bitwise operators:
MemoryFlags operator|(MemoryFlags, MemoryFlags)

MemoryFlags operator&(MemoryFlags, MemoryFlags)

MemoryFlags operator^(MemoryFlags, MemoryFlags)

MemoryFlags operator~(MemoryFlags)

MemoryFlags& operator|=(MemoryFlags&, MemoryFlags)

MemoryFlags& operator&=(MemoryFlags&, MemoryFlags)

MemoryFlags& operator^=(MemoryFlags&, MemoryFlags)

Enumerator
MEMORY_FLAG_READONLY 

Memory is readonly.

It is not allowed to map the memory with Gst::MAP_WRITE.

MEMORY_FLAG_NO_SHARE 

Memory must not be shared.

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

MEMORY_FLAG_ZERO_PREFIXED 

The memory prefix is filled with 0 bytes.

MEMORY_FLAG_ZERO_PADDED 

The memory padding is filled with 0 bytes.

MEMORY_FLAG_PHYSICALLY_CONTIGUOUS 

The memory is physically contiguous.

Since 1.2.

MEMORY_FLAG_NOT_MAPPABLE 

The memory can't be mapped via gst_memory_map() without any preconditions.

Since 1.2.

MEMORY_FLAG_LAST 

First flag that can be used for custom purposes.

enum Gst::MiniObjectFlags

Flags for the mini object.

Bitwise operators:
MiniObjectFlags operator|(MiniObjectFlags, MiniObjectFlags)

MiniObjectFlags operator&(MiniObjectFlags, MiniObjectFlags)

MiniObjectFlags operator^(MiniObjectFlags, MiniObjectFlags)

MiniObjectFlags operator~(MiniObjectFlags)

MiniObjectFlags& operator|=(MiniObjectFlags&, MiniObjectFlags)

MiniObjectFlags& operator&=(MiniObjectFlags&, MiniObjectFlags)

MiniObjectFlags& operator^=(MiniObjectFlags&, MiniObjectFlags)

Enumerator
MINI_OBJECT_FLAG_LOCKABLE 

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

MINI_OBJECT_FLAG_LOCK_READONLY 

The object is permanently locked in READONLY mode.

Only read locks can be performed on the object.

MINI_OBJECT_FLAG_LAST 

First flag that can be used by subclasses.

enum Gst::NavigationCommand

A set of commands that may be issued to an element providing the Gst::Navigation interface.

The available commands can be queried via the gst_navigation_query_new_commands() query.

For convenience in handling DVD navigation, the MENU commands are aliased as: GST_NAVIGATION_COMMAND_DVD_MENU = GST_NAVIGATION_COMMAND_MENU1 GST_NAVIGATION_COMMAND_DVD_TITLE_MENU = GST_NAVIGATION_COMMAND_MENU2 GST_NAVIGATION_COMMAND_DVD_ROOT_MENU = GST_NAVIGATION_COMMAND_MENU3 GST_NAVIGATION_COMMAND_DVD_SUBPICTURE_MENU = GST_NAVIGATION_COMMAND_MENU4 GST_NAVIGATION_COMMAND_DVD_AUDIO_MENU = GST_NAVIGATION_COMMAND_MENU5 GST_NAVIGATION_COMMAND_DVD_ANGLE_MENU = GST_NAVIGATION_COMMAND_MENU6 GST_NAVIGATION_COMMAND_DVD_CHAPTER_MENU = GST_NAVIGATION_COMMAND_MENU7

Enumerator
NAVIGATION_COMMAND_INVALID 

An invalid command entry.

NAVIGATION_COMMAND_MENU1 

Execute navigation menu command 1.

For DVD, this enters the DVD root menu, or exits back to the title from the menu.

NAVIGATION_COMMAND_MENU2 

Execute navigation menu command 2.

For DVD, this jumps to the DVD title menu.

NAVIGATION_COMMAND_MENU3 

Execute navigation menu command 3.

For DVD, this jumps into the DVD root menu.

NAVIGATION_COMMAND_MENU4 

Execute navigation menu command 4.

For DVD, this jumps to the Subpicture menu.

NAVIGATION_COMMAND_MENU5 

Execute navigation menu command 5.

For DVD, the jumps to the audio menu.

NAVIGATION_COMMAND_MENU6 

Execute navigation menu command 6.

For DVD, this jumps to the angles menu.

NAVIGATION_COMMAND_MENU7 

Execute navigation menu command 7.

For DVD, this jumps to the chapter menu.

NAVIGATION_COMMAND_LEFT 

Select the next button to the left in a menu, if such a button exists.

NAVIGATION_COMMAND_RIGHT 

Select the next button to the right in a menu, if such a button exists.

NAVIGATION_COMMAND_UP 

Select the button above the current one in a menu, if such a button exists.

NAVIGATION_COMMAND_DOWN 

Select the button below the current one in a menu, if such a button exists.

NAVIGATION_COMMAND_ACTIVATE 

Activate (click) the currently selected button in a menu, if such a button exists.

NAVIGATION_COMMAND_PREV_ANGLE 

Switch to the previous angle in a multiangle feature.

NAVIGATION_COMMAND_NEXT_ANGLE 

Switch to the next angle in a multiangle feature.

enum Gst::ObjectFlags

The standard flags that an gstobject may have.

Bitwise operators:
ObjectFlags operator|(ObjectFlags, ObjectFlags)

ObjectFlags operator&(ObjectFlags, ObjectFlags)

ObjectFlags operator^(ObjectFlags, ObjectFlags)

ObjectFlags operator~(ObjectFlags)

ObjectFlags& operator|=(ObjectFlags&, ObjectFlags)

ObjectFlags& operator&=(ObjectFlags&, ObjectFlags)

ObjectFlags& operator^=(ObjectFlags&, ObjectFlags)

Enumerator
OBJECT_FLAG_LAST 

Subclasses can add additional flags starting from this flag.

enum Gst::OutputSelectorPadNegotiationMode
Enumerator
OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_NONE 
OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ALL 
OUTPUT_SELECTOR_PAD_NEGOTIATION_MODE_ACTIVE 
enum Gst::PadDirection

The direction of a pad.

Enumerator
PAD_UNKNOWN 

Direction is unknown.

PAD_SRC 

The pad is a source pad.

PAD_SINK 

The pad is a sink pad.

enum Gst::PadFlags

Pad state flags.

Bitwise operators:
PadFlags operator|(PadFlags, PadFlags)

PadFlags operator&(PadFlags, PadFlags)

PadFlags operator^(PadFlags, PadFlags)

PadFlags operator~(PadFlags)

PadFlags& operator|=(PadFlags&, PadFlags)

PadFlags& operator&=(PadFlags&, PadFlags)

PadFlags& operator^=(PadFlags&, PadFlags)

Enumerator
PAD_FLAG_BLOCKED 

Is dataflow on a pad blocked.

PAD_FLAG_FLUSHING 

Is pad flushing.

PAD_FLAG_EOS 

Is pad in EOS state.

PAD_FLAG_BLOCKING 

Is pad currently blocking on a buffer or event.

PAD_FLAG_NEED_PARENT 

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

PAD_FLAG_NEED_RECONFIGURE 

The pad should be reconfigured/renegotiated.

The flag has to be unset manually after reconfiguration happened.

PAD_FLAG_PENDING_EVENTS 

The pad has pending events.

PAD_FLAG_FIXED_CAPS 

The pad is using fixed caps this means that once the caps are set on the pad, the caps query function only returns those caps.

PAD_FLAG_PROXY_CAPS 

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

PAD_FLAG_PROXY_ALLOCATION 

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

PAD_FLAG_PROXY_SCHEDULING 

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

PAD_FLAG_LAST 

Offset to define more flags.

enum Gst::PadLinkCheck

The amount of checking to be done when linking pads.

GST_PAD_LINK_CHECK_CAPS and GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are specified, expensive but safe GST_PAD_LINK_CHECK_CAPS are performed.

<warning> 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::PAD_LINK_CHECK_DEFAULT) or the regular methods for linking the pads. </warning>

Bitwise operators:
PadLinkCheck operator|(PadLinkCheck, PadLinkCheck)

PadLinkCheck operator&(PadLinkCheck, PadLinkCheck)

PadLinkCheck operator^(PadLinkCheck, PadLinkCheck)

PadLinkCheck operator~(PadLinkCheck)

PadLinkCheck& operator|=(PadLinkCheck&, PadLinkCheck)

PadLinkCheck& operator&=(PadLinkCheck&, PadLinkCheck)

PadLinkCheck& operator^=(PadLinkCheck&, PadLinkCheck)

Enumerator
PAD_LINK_CHECK_NOTHING 

Don't check hierarchy or caps compatibility.

PAD_LINK_CHECK_HIERARCHY 

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.

PAD_LINK_CHECK_TEMPLATE_CAPS 

Check if the pads are compatible by using their template caps.

This is much faster than GST_PAD_LINK_CHECK_CAPS, but would be unsafe e.g. if one pad has Gst::CAPS_ANY.

PAD_LINK_CHECK_CAPS 

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

PAD_LINK_CHECK_DEFAULT 

The default checks done when linking pads (i.e.

the ones used by Gst::Pad::link()).

enum Gst::PadLinkReturn

Result values from gst_pad_link and friends.

Enumerator
PAD_LINK_OK 

Link succeeded.

PAD_LINK_WRONG_HIERARCHY 

Pads have no common grandparent.

PAD_LINK_WAS_LINKED 

Pad was already linked.

PAD_LINK_WRONG_DIRECTION 

Pads have wrong direction.

PAD_LINK_NOFORMAT 

Pads do not have common format.

PAD_LINK_NOSCHED 

Pads cannot cooperate in scheduling.

PAD_LINK_REFUSED 

Refused for some reason.

enum Gst::PadMode

The status of a GstPad.

After activating a pad, which usually happens when the parent element goes from READY to PAUSED, the GstPadMode defines if the pad operates in push or pull mode.

Enumerator
PAD_MODE_NONE 

Pad will not handle dataflow.

PAD_MODE_PUSH 

Pad handles dataflow in downstream push mode.

PAD_MODE_PULL 

Pad handles dataflow in upstream pull mode.

enum Gst::PadPresence

Indicates when this pad will become available.

Enumerator
PAD_ALWAYS 

The pad is always available.

PAD_SOMETIMES 

The pad will become available depending on the media stream.

PAD_REQUEST 

The pad is only available on request with Gst::Element::get_request_pad().

enum Gst::PadProbeReturn

Different return values for the Gst::SlotPadProbe.

Enumerator
PAD_PROBE_DROP 

Drop data in data probes.

For push mode this means that the data item is not sent downstream. For pull mode, it means that the data item is not passed upstream. In both cases, this result code returns Gst::FLOW_OK or true to the caller.

PAD_PROBE_OK 

Normal probe return value.

PAD_PROBE_REMOVE 

Remove probe.

PAD_PROBE_PASS 

Pass the data item in the block probe and block on the next item.

enum Gst::PadProbeType

The different probing types that can occur.

When either one of GST_PAD_PROBE_TYPE_IDLE or GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a blocking probe.

Bitwise operators:
PadProbeType operator|(PadProbeType, PadProbeType)

PadProbeType operator&(PadProbeType, PadProbeType)

PadProbeType operator^(PadProbeType, PadProbeType)

PadProbeType operator~(PadProbeType)

PadProbeType& operator|=(PadProbeType&, PadProbeType)

PadProbeType& operator&=(PadProbeType&, PadProbeType)

PadProbeType& operator^=(PadProbeType&, PadProbeType)

Enumerator
PAD_PROBE_TYPE_INVALID 

Invalid probe type.

PAD_PROBE_TYPE_IDLE 

Probe idle pads and block.

PAD_PROBE_TYPE_BLOCK 

Probe and block pads.

PAD_PROBE_TYPE_BUFFER 

Probe buffers.

PAD_PROBE_TYPE_BUFFER_LIST 

Probe buffer lists.

PAD_PROBE_TYPE_EVENT_DOWNSTREAM 

Probe downstream events.

PAD_PROBE_TYPE_EVENT_UPSTREAM 

Probe upstream events.

PAD_PROBE_TYPE_EVENT_FLUSH 

Probe flush events.

This probe has to be explicitly enabled and is not included in the @ GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM or @ GST_PAD_PROBE_TYPE_EVENT_UPSTREAM probe types.

PAD_PROBE_TYPE_QUERY_DOWNSTREAM 

Probe downstream queries.

PAD_PROBE_TYPE_QUERY_UPSTREAM 

Probe upstream queries.

PAD_PROBE_TYPE_PUSH 

Probe push.

PAD_PROBE_TYPE_PULL 

Probe pull.

PAD_PROBE_TYPE_BLOCKING 

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

PAD_PROBE_TYPE_DATA_DOWNSTREAM 

Probe downstream data (buffers, buffer lists, and events).

PAD_PROBE_TYPE_DATA_UPSTREAM 

Probe upstream data (events).

PAD_PROBE_TYPE_DATA_BOTH 

Probe upstream and downstream data (buffers, buffer lists, and events).

PAD_PROBE_TYPE_BLOCK_DOWNSTREAM 

Probe and block downstream data (buffers, buffer lists, and events).

PAD_PROBE_TYPE_BLOCK_UPSTREAM 

Probe and block upstream data (events).

PAD_PROBE_TYPE_EVENT_BOTH 

Probe upstream and downstream events.

PAD_PROBE_TYPE_QUERY_BOTH 

Probe upstream and downstream queries.

PAD_PROBE_TYPE_ALL_BOTH 

Probe upstream events and queries and downstream buffers, buffer lists, events and queries.

PAD_PROBE_TYPE_SCHEDULING 

Probe push and pull.

enum Gst::PadTemplateFlags

Flags for the padtemplate.

Bitwise operators:
PadTemplateFlags operator|(PadTemplateFlags, PadTemplateFlags)

PadTemplateFlags operator&(PadTemplateFlags, PadTemplateFlags)

PadTemplateFlags operator^(PadTemplateFlags, PadTemplateFlags)

PadTemplateFlags operator~(PadTemplateFlags)

PadTemplateFlags& operator|=(PadTemplateFlags&, PadTemplateFlags)

PadTemplateFlags& operator&=(PadTemplateFlags&, PadTemplateFlags)

PadTemplateFlags& operator^=(PadTemplateFlags&, PadTemplateFlags)

Enumerator
PAD_TEMPLATE_FLAG_LAST 

First flag that can be used by subclasses.

enum Gst::PlayFlags
Bitwise operators:
PlayFlags operator|(PlayFlags, PlayFlags)

PlayFlags operator&(PlayFlags, PlayFlags)

PlayFlags operator^(PlayFlags, PlayFlags)

PlayFlags operator~(PlayFlags)

PlayFlags& operator|=(PlayFlags&, PlayFlags)

PlayFlags& operator&=(PlayFlags&, PlayFlags)

PlayFlags& operator^=(PlayFlags&, PlayFlags)

Enumerator
PLAY_FLAG_VIDEO 
PLAY_FLAG_AUDIO 
PLAY_FLAG_TEXT 
PLAY_FLAG_VIS 
PLAY_FLAG_SOFT_VOLUME 
PLAY_FLAG_NATIVE_AUDIO 
PLAY_FLAG_NATIVE_VIDEO 
PLAY_FLAG_DOWNLOAD 
PLAY_FLAG_BUFFERING 
PLAY_FLAG_DEINTERLACE 
PLAY_FLAG_SOFT_COLORBALANCE 
enum Gst::PluginDependencyFlags

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

Bitwise operators:
PluginDependencyFlags operator|(PluginDependencyFlags, PluginDependencyFlags)

PluginDependencyFlags operator&(PluginDependencyFlags, PluginDependencyFlags)

PluginDependencyFlags operator^(PluginDependencyFlags, PluginDependencyFlags)

PluginDependencyFlags operator~(PluginDependencyFlags)

PluginDependencyFlags& operator|=(PluginDependencyFlags&, PluginDependencyFlags)

PluginDependencyFlags& operator&=(PluginDependencyFlags&, PluginDependencyFlags)

PluginDependencyFlags& operator^=(PluginDependencyFlags&, PluginDependencyFlags)

Enumerator
PLUGIN_DEPENDENCY_FLAG_NONE 

No special flags.

PLUGIN_DEPENDENCY_FLAG_RECURSE 

Recurse into subdirectories.

PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY 

Use paths argument only if none of the environment variables is set.

PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX 

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

enum Gst::QOSType

The different types of QoS events that can be given to the gst_event_new_qos() method.

Enumerator
QOS_TYPE_OVERFLOW 

The QoS event type that is produced when downstream elements are producing data too quickly and the element can't keep up processing the data.

Upstream should reduce their processing rate. This type is also used when buffers arrive early or in time.

QOS_TYPE_UNDERFLOW 

The QoS event type that is produced when downstream elements are producing data too slowly and need to speed up their processing rate.

QOS_TYPE_THROTTLE 

The QoS event type that is produced when the application enabled throttling to limit the datarate.

enum Gst::QueryType

Standard predefined Query types.

Bitwise operators:
QueryType operator|(QueryType, QueryType)

QueryType operator&(QueryType, QueryType)

QueryType operator^(QueryType, QueryType)

QueryType operator~(QueryType)

QueryType& operator|=(QueryType&, QueryType)

QueryType& operator&=(QueryType&, QueryType)

QueryType& operator^=(QueryType&, QueryType)

Enumerator
QUERY_UNKNOWN 

Unknown query type.

QUERY_POSITION 

Current position in stream.

QUERY_DURATION 

Total duration of the stream.

QUERY_LATENCY 

Latency of stream.

QUERY_JITTER 

Current jitter of stream.

QUERY_RATE 

Current rate of the stream.

QUERY_SEEKING 

Seeking capabilities.

QUERY_SEGMENT 

Segment start/stop positions.

QUERY_CONVERT 

Convert values between formats.

QUERY_FORMATS 

Query supported formats for convert.

QUERY_BUFFERING 

Query available media for efficient seeking.

QUERY_CUSTOM 

A custom application or element defined query.

QUERY_URI 

Query the URI of the source or sink.

QUERY_ALLOCATION 

The buffer allocation properties.

QUERY_SCHEDULING 

The scheduling properties.

QUERY_ACCEPT_CAPS 

The accept caps query.

QUERY_CAPS 

The caps query.

QUERY_DRAIN 

Wait till all serialized data is consumed downstream.

QUERY_CONTEXT 

Query the pipeline-local context from downstream or upstream (since 1.2).

enum Gst::QueryTypeFlags

Gst::QueryTypeFlags indicate the aspects of the different Gst::QueryType values.

You can get the type flags of a Gst::QueryType with the Gst::Query::type_get_flags() function.

Bitwise operators:
QueryTypeFlags operator|(QueryTypeFlags, QueryTypeFlags)

QueryTypeFlags operator&(QueryTypeFlags, QueryTypeFlags)

QueryTypeFlags operator^(QueryTypeFlags, QueryTypeFlags)

QueryTypeFlags operator~(QueryTypeFlags)

QueryTypeFlags& operator|=(QueryTypeFlags&, QueryTypeFlags)

QueryTypeFlags& operator&=(QueryTypeFlags&, QueryTypeFlags)

QueryTypeFlags& operator^=(QueryTypeFlags&, QueryTypeFlags)

Enumerator
QUERY_TYPE_UPSTREAM 

Set if the query can travel upstream.

QUERY_TYPE_DOWNSTREAM 

Set if the query can travel downstream.

QUERY_TYPE_SERIALIZED 

Set if the query should be serialized with data flow.

enum Gst::QueueLeaky
Enumerator
QUEUE_LEAK_NO_LEAK 
QUEUE_LEAK_UPSTREAM 
QUEUE_LEAK_DOWNSTREAM 
enum Gst::Rank

Element priority ranks.

Defines the order in which the autoplugger (or similar rank-picking mechanisms, such as e.g. Gst::Element::make_from_uri()) will choose this element over an alternative one with the same function.

These constants serve as a rough guidance for defining the rank of a Gst::PluginFeature. Any value is valid, including values bigger than GST_RANK_PRIMARY.

Enumerator
RANK_NONE 

Will be chosen last or not at all.

RANK_MARGINAL 

Unlikely to be chosen.

RANK_SECONDARY 

Likely to be chosen.

RANK_PRIMARY 

Will be chosen first.

enum Gst::SchedulingFlags

The different scheduling flags.

Bitwise operators:
SchedulingFlags operator|(SchedulingFlags, SchedulingFlags)

SchedulingFlags operator&(SchedulingFlags, SchedulingFlags)

SchedulingFlags operator^(SchedulingFlags, SchedulingFlags)

SchedulingFlags operator~(SchedulingFlags)

SchedulingFlags& operator|=(SchedulingFlags&, SchedulingFlags)

SchedulingFlags& operator&=(SchedulingFlags&, SchedulingFlags)

SchedulingFlags& operator^=(SchedulingFlags&, SchedulingFlags)

Enumerator
SCHEDULING_FLAG_SEEKABLE 

If seeking is possible.

SCHEDULING_FLAG_SEQUENTIAL 

If sequential access is recommended.

SCHEDULING_FLAG_BANDWIDTH_LIMITED 

If bandwidth is limited and buffering possible (since 1.2).

enum Gst::SeekFlags

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 emmited by the element that performed the seek, but a Gst::MESSAGE_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_SEEK_FLAG_SKIP 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.

The GST_SEEK_FLAG_SNAP_BEFORE flag can be used to snap to the previous relevant location, and the GST_SEEK_FLAG_SNAP_AFTER flag can be used to select the next relevant location. If 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.

Bitwise operators:
SeekFlags operator|(SeekFlags, SeekFlags)

SeekFlags operator&(SeekFlags, SeekFlags)

SeekFlags operator^(SeekFlags, SeekFlags)

SeekFlags operator~(SeekFlags)

SeekFlags& operator|=(SeekFlags&, SeekFlags)

SeekFlags& operator&=(SeekFlags&, SeekFlags)

SeekFlags& operator^=(SeekFlags&, SeekFlags)

Enumerator
SEEK_FLAG_NONE 

No flag.

SEEK_FLAG_FLUSH 

Flush pipeline.

SEEK_FLAG_ACCURATE 

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

SEEK_FLAG_KEY_UNIT 

Seek to the nearest keyframe.

This might be faster but less accurate.

SEEK_FLAG_SEGMENT 

Perform a segment seek.

SEEK_FLAG_SKIP 

When doing fast foward or fast reverse playback, allow elements to skip frames instead of generating all frames.

SEEK_FLAG_SNAP_BEFORE 

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

SEEK_FLAG_SNAP_AFTER 

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

SEEK_FLAG_SNAP_NEAREST 

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

enum Gst::State

The possible states an element can be in.

States can be changed using Gst::Element::set_state() and checked using Gst::Element::get_state().

Enumerator
STATE_VOID_PENDING 

No pending state.

STATE_NULL 

The 0 state or initial state of an element.

STATE_READY 

The element is ready to go to PAUSED.

STATE_PAUSED 

The element is PAUSED, it is ready to accept and process data.

Sink elements however only accept one buffer and then block.

STATE_PLAYING 

The element is PLAYING, the Gst::Clock is running and the data is flowing.

enum Gst::StateChangeReturn

The possible return values from a state change function such as Gst::Element::set_state().

Only GST_STATE_CHANGE_FAILURE is a real failure.

Enumerator
STATE_CHANGE_FAILURE 

The state change failed.

STATE_CHANGE_SUCCESS 

The state change succeeded.

STATE_CHANGE_ASYNC 

The state change will happen asynchronously.

STATE_CHANGE_NO_PREROLL 

The state change succeeded but the element cannot produce data in Gst::STATE_PAUSED.

This typically happens with live sources.

enum Gst::StreamStatusType

The type of a Gst::MESSAGE_STREAM_STATUS.

The stream status messages inform the application of new streaming threads and their status.

Enumerator
STREAM_STATUS_TYPE_CREATE 

A new thread need to be created.

STREAM_STATUS_TYPE_ENTER 

A thread entered its loop function.

STREAM_STATUS_TYPE_LEAVE 

A thread left its loop function.

STREAM_STATUS_TYPE_DESTROY 

A thread is destroyed.

STREAM_STATUS_TYPE_START 

A thread is started.

STREAM_STATUS_TYPE_PAUSE 

A thread is paused.

STREAM_STATUS_TYPE_STOP 

A thread is stopped.

enum Gst::StreamVolumeFormat

Different representations of a stream volume.

gst_stream_volume_convert_volume() allows to convert between the different representations.

Formulas to convert from a linear to a cubic or dB volume are cbrt(val) and 20 * log10 (val).

Enumerator
STREAM_VOLUME_FORMAT_LINEAR 

Linear scale factor, 1.0 = 100%.

STREAM_VOLUME_FORMAT_CUBIC 

Cubic volume scale.

STREAM_VOLUME_FORMAT_DB 

Logarithmic volume scale (dB, amplitude not power).

enum Gst::StructureChangeType

The type of a Gst::MESSAGE_STRUCTURE_CHANGE.

Enumerator
STRUCTURE_CHANGE_TYPE_PAD_LINK 

Pad linking is starting or done.

STRUCTURE_CHANGE_TYPE_PAD_UNLINK 

Pad unlinking is starting or done.

enum Gst::TagFlag

Extra tag flags used when registering tags.

Enumerator
TAG_FLAG_UNDEFINED 

Undefined flag.

TAG_FLAG_META 

Tag is meta data.

TAG_FLAG_ENCODED 

Tag is encoded.

TAG_FLAG_DECODED 

Tag is decoded.

TAG_FLAG_COUNT 

Number of tag flags.

enum Gst::TagMergeMode

The different tag merging modes are basically replace, overwrite and append, but they can be seen from two directions.

Given two taglists: (A) the tags already in the element and (B) the ones that are supplied to the element ( e.g. via gst_tag_setter_merge_tags() / gst_tag_setter_add_tags() or a Gst::EVENT_TAG), how are these tags merged? In the table below this is shown for the cases that a tag exists in the list (A) or does not exists (!A) and combinations thereof.

merge mode</title> <tgroup cols="5" align="left"> <thead> <row> <entry>merge mode</entry> <entry>A + B</entry> <entry>A + !B</entry> <entry>!A + B</entry> <entry>!A + !B</entry> </row> </thead> <tbody> <row> <entry>REPLACE_ALL</entry> <entry>B</entry> <entry>-</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>REPLACE</entry> <entry>B</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>APPEND</entry> <entry>A, B</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>PREPEND</entry> <entry>B, A</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>KEEP</entry> <entry>A</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>KEEP_ALL</entry> <entry>A</entry> <entry>A</entry> <entry>-</entry> <entry>-</entry> </row> </tbody> </tgroup>

Enumerator
TAG_MERGE_UNDEFINED 

Undefined merge mode.

TAG_MERGE_REPLACE_ALL 

Replace all tags (clear list and append).

TAG_MERGE_REPLACE 

Replace tags.

TAG_MERGE_APPEND 

Append tags.

TAG_MERGE_PREPEND 

Prepend tags.

TAG_MERGE_KEEP 

Keep existing tags.

TAG_MERGE_KEEP_ALL 

Keep all existing tags.

TAG_MERGE_COUNT 

The number of merge modes.

enum Gst::TaskState

The different states a task can be in.

Enumerator
TASK_STARTED 

The task is started and running.

TASK_STOPPED 

The task is stopped.

TASK_PAUSED 

The task is paused.

enum Gst::TeePullMode
Enumerator
TEE_PULL_MODE_NEVER 
TEE_PULL_MODE_SINGLE 
enum Gst::TextRenderHAlign
Enumerator
TEXT_RENDER_HALIGN_LEFT 
TEXT_RENDER_HALIGN_CENTER 
TEXT_RENDER_HALIGN_RIGHT 
enum Gst::TextRenderLineAlign
Bitwise operators:
TextRenderLineAlign operator|(TextRenderLineAlign, TextRenderLineAlign)

TextRenderLineAlign operator&(TextRenderLineAlign, TextRenderLineAlign)

TextRenderLineAlign operator^(TextRenderLineAlign, TextRenderLineAlign)

TextRenderLineAlign operator~(TextRenderLineAlign)

TextRenderLineAlign& operator|=(TextRenderLineAlign&, TextRenderLineAlign)

TextRenderLineAlign& operator&=(TextRenderLineAlign&, TextRenderLineAlign)

TextRenderLineAlign& operator^=(TextRenderLineAlign&, TextRenderLineAlign)

Enumerator
TEXT_RENDER_LINE_ALIGN_LEFT 
TEXT_RENDER_LINE_ALIGN_CENTER 
TEXT_RENDER_LINE_ALIGN_RIGHT 
enum Gst::TextRenderVAlign
Enumerator
TEXT_RENDER_VALIGN_BASELINE 
TEXT_RENDER_VALIGN_BOTTOM 
TEXT_RENDER_VALIGN_TOP 
enum Gst::TheoraEncMultipassMode
Enumerator
MODE_SINGLE_PASS 
MODE_FIRST_PASS 
MODE_SECOND_PASS 
enum Gst::TocEntryType

The different types of TOC entries (see Gst::TocEntry).

There are two types of TOC entries: alternatives or parts in a sequence.

Enumerator
TOC_ENTRY_TYPE_ANGLE 

Entry is an angle (i.e. an alternative).

TOC_ENTRY_TYPE_VERSION 

Entry is a version (i.e.

alternative).

TOC_ENTRY_TYPE_EDITION 

Entry is an edition (i.e.

alternative).

TOC_ENTRY_TYPE_INVALID 

Invalid entry type value.

TOC_ENTRY_TYPE_TITLE 

Entry is a title (i.e.

a part of a sequence).

TOC_ENTRY_TYPE_TRACK 

Entry is a track (i.e.

a part of a sequence).

TOC_ENTRY_TYPE_CHAPTER 

Entry is a chapter (i.e.

a part of a sequence).

enum Gst::TocScope

The scope of a TOC.

Enumerator
TOC_SCOPE_GLOBAL 

Global TOC representing all selectable options (this is what applications are usually interested in).

TOC_SCOPE_CURRENT 

TOC for the currently active/selected stream (this is a TOC representing the current stream from start to EOS, and is what a TOC writer / muxer is usually interested in; it will usually be a subset of the global TOC, e.g.

just the chapters of the current title, or the chapters selected for playback from the current title).

enum Gst::TypeFindProbability

The probability of the typefind function.

Higher values have more certainty in doing a reliable typefind.

Enumerator
TYPE_FIND_NONE 

Type undetected.

TYPE_FIND_MINIMUM 

Unlikely typefind.

TYPE_FIND_POSSIBLE 

Possible type detected.

TYPE_FIND_LIKELY 

Likely a type was detected.

TYPE_FIND_NEARLY_CERTAIN 

Nearly certain that a type was detected.

TYPE_FIND_MAXIMUM 

Very certain a type was detected.

enum Gst::URIType

The different types of URI direction.

Enumerator
URI_UNKNOWN 

The URI direction is unknown.

URI_SINK 

The URI is a consumer.

URI_SRC 

The URI is a producer.

enum Gst::VideoScaleMethod
Enumerator
VIDEO_SCALE_NEAREST 
VIDEO_SCALE_BILINEAR 
VIDEO_SCALE_4TAP 
VIDEO_SCALE_LANCZOS 
enum Gst::VideoTestSrcPattern
Enumerator
VIDEO_TEST_SRC_SMPTE 
VIDEO_TEST_SRC_SNOW 
VIDEO_TEST_SRC_BLACK 
VIDEO_TEST_SRC_WHITE 
VIDEO_TEST_SRC_RED 
VIDEO_TEST_SRC_GREEN 
VIDEO_TEST_SRC_BLUE 
VIDEO_TEST_SRC_CHECKERS1 
VIDEO_TEST_SRC_CHECKERS2 
VIDEO_TEST_SRC_CHECKERS4 
VIDEO_TEST_SRC_CHECKERS8 
VIDEO_TEST_SRC_CIRCULAR 
VIDEO_TEST_SRC_BLINK 
VIDEO_TEST_SRC_SMPTE75 
VIDEO_TEST_SRC_ZONE_PLATE 
VIDEO_TEST_SRC_GAMUT 
VIDEO_TEST_SRC_CHROMA_ZONE_PLATE 
VIDEO_TEST_SRC_SOLID 
VIDEO_TEST_SRC_BALL 
VIDEO_TEST_SRC_SMPTE100 
VIDEO_TEST_SRC_BAR 
VIDEO_TEST_SRC_PINWHEEL 
VIDEO_TEST_SRC_SPOKES 

Function Documentation

AudioFlags Gst::operator& ( AudioFlags  lhs,
AudioFlags  rhs 
)
inline
PlayFlags Gst::operator& ( PlayFlags  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags Gst::operator& ( PadTemplateFlags  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags Gst::operator& ( ObjectFlags  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags Gst::operator& ( MiniObjectFlags  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags Gst::operator& ( MapFlags  lhs,
MapFlags  rhs 
)
inline
BusFlags Gst::operator& ( BusFlags  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags Gst::operator& ( PluginDependencyFlags  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags Gst::operator& ( BinFlags  lhs,
BinFlags  rhs 
)
inline
MemoryFlags Gst::operator& ( MemoryFlags  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags Gst::operator& ( BufferFlags  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign Gst::operator& ( TextRenderLineAlign  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags Gst::operator& ( ElementFlags  lhs,
ElementFlags  rhs 
)
inline
SeekFlags Gst::operator& ( SeekFlags  lhs,
SeekFlags  rhs 
)
inline
LockFlags Gst::operator& ( LockFlags  lhs,
LockFlags  rhs 
)
inline
EventType Gst::operator& ( EventType  lhs,
EventType  rhs 
)
inline
BufferCopyFlags Gst::operator& ( BufferCopyFlags  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType Gst::operator& ( QueryType  lhs,
QueryType  rhs 
)
inline
MessageType Gst::operator& ( MessageType  lhs,
MessageType  rhs 
)
inline
ClockFlags Gst::operator& ( ClockFlags  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags Gst::operator& ( EventTypeFlags  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags Gst::operator& ( QueryTypeFlags  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags Gst::operator& ( AudioFormatFlags  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags Gst::operator& ( PadFlags  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags Gst::operator& ( SchedulingFlags  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck Gst::operator& ( PadLinkCheck  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType Gst::operator& ( PadProbeType  lhs,
PadProbeType  rhs 
)
inline
AudioFlags& Gst::operator&= ( AudioFlags &  lhs,
AudioFlags  rhs 
)
inline
PlayFlags& Gst::operator&= ( PlayFlags &  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags& Gst::operator&= ( PadTemplateFlags &  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags& Gst::operator&= ( ObjectFlags &  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags& Gst::operator&= ( MiniObjectFlags &  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags& Gst::operator&= ( MapFlags &  lhs,
MapFlags  rhs 
)
inline
BusFlags& Gst::operator&= ( BusFlags &  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags& Gst::operator&= ( PluginDependencyFlags &  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags& Gst::operator&= ( BinFlags &  lhs,
BinFlags  rhs 
)
inline
MemoryFlags& Gst::operator&= ( MemoryFlags &  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags& Gst::operator&= ( BufferFlags &  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign& Gst::operator&= ( TextRenderLineAlign &  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags& Gst::operator&= ( ElementFlags &  lhs,
ElementFlags  rhs 
)
inline
SeekFlags& Gst::operator&= ( SeekFlags &  lhs,
SeekFlags  rhs 
)
inline
LockFlags& Gst::operator&= ( LockFlags &  lhs,
LockFlags  rhs 
)
inline
EventType& Gst::operator&= ( EventType &  lhs,
EventType  rhs 
)
inline
BufferCopyFlags& Gst::operator&= ( BufferCopyFlags &  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType& Gst::operator&= ( QueryType &  lhs,
QueryType  rhs 
)
inline
MessageType& Gst::operator&= ( MessageType &  lhs,
MessageType  rhs 
)
inline
ClockFlags& Gst::operator&= ( ClockFlags &  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags& Gst::operator&= ( EventTypeFlags &  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags& Gst::operator&= ( QueryTypeFlags &  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags& Gst::operator&= ( AudioFormatFlags &  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags& Gst::operator&= ( PadFlags &  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags& Gst::operator&= ( SchedulingFlags &  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck& Gst::operator&= ( PadLinkCheck &  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType& Gst::operator&= ( PadProbeType &  lhs,
PadProbeType  rhs 
)
inline
AudioFlags Gst::operator^ ( AudioFlags  lhs,
AudioFlags  rhs 
)
inline
PlayFlags Gst::operator^ ( PlayFlags  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags Gst::operator^ ( PadTemplateFlags  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags Gst::operator^ ( ObjectFlags  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags Gst::operator^ ( MiniObjectFlags  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags Gst::operator^ ( MapFlags  lhs,
MapFlags  rhs 
)
inline
BusFlags Gst::operator^ ( BusFlags  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags Gst::operator^ ( PluginDependencyFlags  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags Gst::operator^ ( BinFlags  lhs,
BinFlags  rhs 
)
inline
MemoryFlags Gst::operator^ ( MemoryFlags  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags Gst::operator^ ( BufferFlags  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign Gst::operator^ ( TextRenderLineAlign  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags Gst::operator^ ( ElementFlags  lhs,
ElementFlags  rhs 
)
inline
SeekFlags Gst::operator^ ( SeekFlags  lhs,
SeekFlags  rhs 
)
inline
LockFlags Gst::operator^ ( LockFlags  lhs,
LockFlags  rhs 
)
inline
EventType Gst::operator^ ( EventType  lhs,
EventType  rhs 
)
inline
BufferCopyFlags Gst::operator^ ( BufferCopyFlags  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType Gst::operator^ ( QueryType  lhs,
QueryType  rhs 
)
inline
MessageType Gst::operator^ ( MessageType  lhs,
MessageType  rhs 
)
inline
ClockFlags Gst::operator^ ( ClockFlags  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags Gst::operator^ ( EventTypeFlags  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags Gst::operator^ ( QueryTypeFlags  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags Gst::operator^ ( AudioFormatFlags  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags Gst::operator^ ( PadFlags  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags Gst::operator^ ( SchedulingFlags  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck Gst::operator^ ( PadLinkCheck  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType Gst::operator^ ( PadProbeType  lhs,
PadProbeType  rhs 
)
inline
AudioFlags& Gst::operator^= ( AudioFlags &  lhs,
AudioFlags  rhs 
)
inline
PlayFlags& Gst::operator^= ( PlayFlags &  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags& Gst::operator^= ( PadTemplateFlags &  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags& Gst::operator^= ( ObjectFlags &  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags& Gst::operator^= ( MiniObjectFlags &  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags& Gst::operator^= ( MapFlags &  lhs,
MapFlags  rhs 
)
inline
BusFlags& Gst::operator^= ( BusFlags &  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags& Gst::operator^= ( PluginDependencyFlags &  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags& Gst::operator^= ( BinFlags &  lhs,
BinFlags  rhs 
)
inline
MemoryFlags& Gst::operator^= ( MemoryFlags &  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags& Gst::operator^= ( BufferFlags &  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign& Gst::operator^= ( TextRenderLineAlign &  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags& Gst::operator^= ( ElementFlags &  lhs,
ElementFlags  rhs 
)
inline
SeekFlags& Gst::operator^= ( SeekFlags &  lhs,
SeekFlags  rhs 
)
inline
LockFlags& Gst::operator^= ( LockFlags &  lhs,
LockFlags  rhs 
)
inline
EventType& Gst::operator^= ( EventType &  lhs,
EventType  rhs 
)
inline
BufferCopyFlags& Gst::operator^= ( BufferCopyFlags &  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType& Gst::operator^= ( QueryType &  lhs,
QueryType  rhs 
)
inline
MessageType& Gst::operator^= ( MessageType &  lhs,
MessageType  rhs 
)
inline
ClockFlags& Gst::operator^= ( ClockFlags &  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags& Gst::operator^= ( EventTypeFlags &  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags& Gst::operator^= ( QueryTypeFlags &  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags& Gst::operator^= ( AudioFormatFlags &  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags& Gst::operator^= ( PadFlags &  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags& Gst::operator^= ( SchedulingFlags &  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck& Gst::operator^= ( PadLinkCheck &  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType& Gst::operator^= ( PadProbeType &  lhs,
PadProbeType  rhs 
)
inline
AudioFlags Gst::operator| ( AudioFlags  lhs,
AudioFlags  rhs 
)
inline
PlayFlags Gst::operator| ( PlayFlags  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags Gst::operator| ( PadTemplateFlags  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags Gst::operator| ( ObjectFlags  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags Gst::operator| ( MiniObjectFlags  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags Gst::operator| ( MapFlags  lhs,
MapFlags  rhs 
)
inline
BusFlags Gst::operator| ( BusFlags  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags Gst::operator| ( PluginDependencyFlags  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags Gst::operator| ( BinFlags  lhs,
BinFlags  rhs 
)
inline
MemoryFlags Gst::operator| ( MemoryFlags  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags Gst::operator| ( BufferFlags  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign Gst::operator| ( TextRenderLineAlign  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags Gst::operator| ( ElementFlags  lhs,
ElementFlags  rhs 
)
inline
SeekFlags Gst::operator| ( SeekFlags  lhs,
SeekFlags  rhs 
)
inline
LockFlags Gst::operator| ( LockFlags  lhs,
LockFlags  rhs 
)
inline
EventType Gst::operator| ( EventType  lhs,
EventType  rhs 
)
inline
BufferCopyFlags Gst::operator| ( BufferCopyFlags  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType Gst::operator| ( QueryType  lhs,
QueryType  rhs 
)
inline
MessageType Gst::operator| ( MessageType  lhs,
MessageType  rhs 
)
inline
ClockFlags Gst::operator| ( ClockFlags  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags Gst::operator| ( EventTypeFlags  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags Gst::operator| ( QueryTypeFlags  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags Gst::operator| ( AudioFormatFlags  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags Gst::operator| ( PadFlags  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags Gst::operator| ( SchedulingFlags  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck Gst::operator| ( PadLinkCheck  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType Gst::operator| ( PadProbeType  lhs,
PadProbeType  rhs 
)
inline
AudioFlags& Gst::operator|= ( AudioFlags &  lhs,
AudioFlags  rhs 
)
inline
PlayFlags& Gst::operator|= ( PlayFlags &  lhs,
PlayFlags  rhs 
)
inline
PadTemplateFlags& Gst::operator|= ( PadTemplateFlags &  lhs,
PadTemplateFlags  rhs 
)
inline
ObjectFlags& Gst::operator|= ( ObjectFlags &  lhs,
ObjectFlags  rhs 
)
inline
MiniObjectFlags& Gst::operator|= ( MiniObjectFlags &  lhs,
MiniObjectFlags  rhs 
)
inline
MapFlags& Gst::operator|= ( MapFlags &  lhs,
MapFlags  rhs 
)
inline
BusFlags& Gst::operator|= ( BusFlags &  lhs,
BusFlags  rhs 
)
inline
PluginDependencyFlags& Gst::operator|= ( PluginDependencyFlags &  lhs,
PluginDependencyFlags  rhs 
)
inline
BinFlags& Gst::operator|= ( BinFlags &  lhs,
BinFlags  rhs 
)
inline
MemoryFlags& Gst::operator|= ( MemoryFlags &  lhs,
MemoryFlags  rhs 
)
inline
BufferFlags& Gst::operator|= ( BufferFlags &  lhs,
BufferFlags  rhs 
)
inline
TextRenderLineAlign& Gst::operator|= ( TextRenderLineAlign &  lhs,
TextRenderLineAlign  rhs 
)
inline
ElementFlags& Gst::operator|= ( ElementFlags &  lhs,
ElementFlags  rhs 
)
inline
SeekFlags& Gst::operator|= ( SeekFlags &  lhs,
SeekFlags  rhs 
)
inline
LockFlags& Gst::operator|= ( LockFlags &  lhs,
LockFlags  rhs 
)
inline
EventType& Gst::operator|= ( EventType &  lhs,
EventType  rhs 
)
inline
BufferCopyFlags& Gst::operator|= ( BufferCopyFlags &  lhs,
BufferCopyFlags  rhs 
)
inline
QueryType& Gst::operator|= ( QueryType &  lhs,
QueryType  rhs 
)
inline
MessageType& Gst::operator|= ( MessageType &  lhs,
MessageType  rhs 
)
inline
ClockFlags& Gst::operator|= ( ClockFlags &  lhs,
ClockFlags  rhs 
)
inline
EventTypeFlags& Gst::operator|= ( EventTypeFlags &  lhs,
EventTypeFlags  rhs 
)
inline
QueryTypeFlags& Gst::operator|= ( QueryTypeFlags &  lhs,
QueryTypeFlags  rhs 
)
inline
AudioFormatFlags& Gst::operator|= ( AudioFormatFlags &  lhs,
AudioFormatFlags  rhs 
)
inline
PadFlags& Gst::operator|= ( PadFlags &  lhs,
PadFlags  rhs 
)
inline
SchedulingFlags& Gst::operator|= ( SchedulingFlags &  lhs,
SchedulingFlags  rhs 
)
inline
PadLinkCheck& Gst::operator|= ( PadLinkCheck &  lhs,
PadLinkCheck  rhs 
)
inline
PadProbeType& Gst::operator|= ( PadProbeType &  lhs,
PadProbeType  rhs 
)
inline
AudioFlags Gst::operator~ ( AudioFlags  flags)
inline
PlayFlags Gst::operator~ ( PlayFlags  flags)
inline
PadTemplateFlags Gst::operator~ ( PadTemplateFlags  flags)
inline
ObjectFlags Gst::operator~ ( ObjectFlags  flags)
inline
MiniObjectFlags Gst::operator~ ( MiniObjectFlags  flags)
inline
MapFlags Gst::operator~ ( MapFlags  flags)
inline
BusFlags Gst::operator~ ( BusFlags  flags)
inline
PluginDependencyFlags Gst::operator~ ( PluginDependencyFlags  flags)
inline
BinFlags Gst::operator~ ( BinFlags  flags)
inline
MemoryFlags Gst::operator~ ( MemoryFlags  flags)
inline
BufferFlags Gst::operator~ ( BufferFlags  flags)
inline
TextRenderLineAlign Gst::operator~ ( TextRenderLineAlign  flags)
inline
ElementFlags Gst::operator~ ( ElementFlags  flags)
inline
SeekFlags Gst::operator~ ( SeekFlags  flags)
inline
LockFlags Gst::operator~ ( LockFlags  flags)
inline
EventType Gst::operator~ ( EventType  flags)
inline
BufferCopyFlags Gst::operator~ ( BufferCopyFlags  flags)
inline
QueryType Gst::operator~ ( QueryType  flags)
inline
MessageType Gst::operator~ ( MessageType  flags)
inline
ClockFlags Gst::operator~ ( ClockFlags  flags)
inline
EventTypeFlags Gst::operator~ ( EventTypeFlags  flags)
inline
QueryTypeFlags Gst::operator~ ( QueryTypeFlags  flags)
inline
AudioFormatFlags Gst::operator~ ( AudioFormatFlags  flags)
inline
PadFlags Gst::operator~ ( PadFlags  flags)
inline
SchedulingFlags Gst::operator~ ( SchedulingFlags  flags)
inline
PadLinkCheck Gst::operator~ ( PadLinkCheck  flags)
inline
PadProbeType Gst::operator~ ( PadProbeType  flags)
inline