gstreamermm: gstreamermm Enums and Flags

gstreamermm 1.4.3

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes

Enumerations | Functions
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. Gst::BUS_DROP - Drop the message. Gst::BUS_PASS - Pass the message to the async queue. Gst::BUS_ASYNC - Pass message to async queue, continue if message is handled. Drop the message.
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