gstreamermm: gstreamermm Enums and Flags

gstreamermm 1.0.10

- Main Page
- 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::AUDIO_CONVERT_DITHER_NONE, Gst::AUDIO_CONVERT_DITHER_RPDF, Gst::AUDIO_CONVERT_DITHER_TPDF, Gst::AUDIO_CONVERT_DITHER_TPDF_HF }
enum | Gst::AudioConvertNoiseShaping { Gst::AUDIO_CONVERT_NOISE_SHAPING_NONE, Gst::AUDIO_CONVERT_NOISE_SHAPING_ERROR_FEEDBACK, Gst::AUDIO_CONVERT_NOISE_SHAPING_SIMPLE, Gst::AUDIO_CONVERT_NOISE_SHAPING_MEDIUM, Gst::AUDIO_CONVERT_NOISE_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::FAKE_SINK_STATE_ERROR_NONE, Gst::FAKE_SINK_STATE_ERROR_NULL_READY, Gst::FAKE_SINK_STATE_ERROR_READY_PAUSED, Gst::FAKE_SINK_STATE_ERROR_PAUSED_PLAYING, Gst::FAKE_SINK_STATE_ERROR_PLAYING_PAUSED, Gst::FAKE_SINK_STATE_ERROR_PAUSED_READY, Gst::FAKE_SINK_STATE_ERROR_READY_NULL }
enum | Gst::FakeSrcDataType { Gst::FAKE_SRC_DATA_ALLOCATE = 1, Gst::FAKE_SRC_DATA_SUBBUFFER }
enum | Gst::FakeSrcSizeType { Gst::FAKE_SRC_SIZETYPE_EMPTY = 1, Gst::FAKE_SRC_SIZETYPE_FIXED, Gst::FAKE_SRC_SIZETYPE_RANDOM }
enum | Gst::FakeSrcFillType { Gst::FAKE_SRC_FILLTYPE_NOTHING = 1, Gst::FAKE_SRC_FILLTYPE_ZERO, Gst::FAKE_SRC_FILLTYPE_RANDOM, Gst::FAKE_SRC_FILLTYPE_PATTERN, Gst::FAKE_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::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::THEORA_ENC_MULTIPASS_MODE_SINGLE_PASS, Gst::THEORA_ENC_MULTIPASS_MODE_FIRST_PASS, Gst::THEORA_ENC_MULTIPASS_MODE_SECOND_PASS }
enum | Gst::VideoConvertDitherMethod { Gst::NONE, Gst::VERTERR, Gst::HALFTONE }
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 }
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 }
| The state of the audioringbuffer. 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 audioringbuffer. 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) }
| 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 | Gst::MessageType { Gst::MESSAGE_UNKNOWN = 0x0, Gst::MESSAGE_EOS = (1 << 0), Gst::MESSAGE_ERROR = (1 << 1), Gst::MESSAGE_WARNING = (1 << 2), Gst::MESSAGE_INFO = (1 << 3), Gst::MESSAGE_TAG = (1 << 4), Gst::MESSAGE_BUFFERING = (1 << 5), Gst::MESSAGE_STATE_CHANGED = (1 << 6), Gst::MESSAGE_STATE_DIRTY = (1 << 7), Gst::MESSAGE_STEP_DONE = (1 << 8), Gst::MESSAGE_CLOCK_PROVIDE = (1 << 9), Gst::MESSAGE_CLOCK_LOST = (1 << 10), Gst::MESSAGE_NEW_CLOCK = (1 << 11), Gst::MESSAGE_STRUCTURE_CHANGE = (1 << 12), Gst::MESSAGE_STREAM_STATUS = (1 << 13), Gst::MESSAGE_APPLICATION = (1 << 14), Gst::MESSAGE_ELEMENT = (1 << 15), Gst::MESSAGE_SEGMENT_START = (1 << 16), Gst::MESSAGE_SEGMENT_DONE = (1 << 17), Gst::MESSAGE_DURATION_CHANGED = (1 << 18), Gst::MESSAGE_LATENCY = (1 << 19), Gst::MESSAGE_ASYNC_START = (1 << 20), Gst::MESSAGE_ASYNC_DONE = (1 << 21), Gst::MESSAGE_REQUEST_STATE = (1 << 22), Gst::MESSAGE_STEP_START = (1 << 23), Gst::MESSAGE_QOS = (1 << 24), Gst::MESSAGE_PROGRESS = (1 << 25), Gst::MESSAGE_TOC = (1 << 26), Gst::MESSAGE_RESET_TIME = (1 << 27), Gst::MESSAGE_STREAM_START = (1 << 28), Gst::MESSAGE_ANY = 0x0 }
| 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_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)) }
| Standard predefined Query types. 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 | Gst::SeekType { Gst::SEEK_TYPE_NONE, Gst::SEEK_TYPE_SET, Gst::SEEK_TYPE_END }
| 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)
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)
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 alive stream.
APP_STREAM_TYPE_SEEKABLE | The stream is seekable but seeking might notbe 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 clockdrifts 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 masterclock time.
AUDIO_BASE_SRC_SLAVE_SKEW | Adjust capture pointer when master clockdrifts 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 withany 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
AUDIO_CONVERT_DITHER_NONE |
AUDIO_CONVERT_DITHER_RPDF |
AUDIO_CONVERT_DITHER_TPDF |
AUDIO_CONVERT_DITHER_TPDF_HF |

enum Gst::AudioConvertNoiseShaping

Enumerator
AUDIO_CONVERT_NOISE_SHAPING_NONE |
AUDIO_CONVERT_NOISE_SHAPING_ERROR_FEEDBACK |
AUDIO_CONVERT_NOISE_SHAPING_SIMPLE |
AUDIO_CONVERT_NOISE_SHAPING_MEDIUM |
AUDIO_CONVERT_NOISE_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 explicitlycontains 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 inGst::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 audioringbuffer.

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

Enumerator
AUDIO_RING_BUFFER_STATE_STOPPED | The audioringbuffer is stopped.
AUDIO_RING_BUFFER_STATE_PAUSED | The audioringbuffer is paused.
AUDIO_RING_BUFFER_STATE_STARTED | The audioringbuffer is started.

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::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 becopied.
BUFFER_COPY_MEMORY | flag indicating that buffer memory should be reffedand appended to already existing memory. Unless the memory is marked asSHARE, no actual copy of the memory is made but it is simply reffed.Add BUFFER_COPY_DEEP to force a real copy.
BUFFER_COPY_MERGE | flag indicating that buffer memory should bemerged.

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 inthe PAUSED state.
BUFFER_FLAG_DECODE_ONLY | the buffer contains data that should be droppedbecause it will be clipped against the segmentboundaries or because it does not contain datathat 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 bufferfrom a live or network source.
BUFFER_FLAG_RESYNC | the buffer timestamps might have a discontinuityand 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. forvideo this is typically the end of a frame boundary, for audiothis is usually the start of a talkspurt.
BUFFER_FLAG_HEADER | the buffer contains header information that isneeded to decode the following data.
BUFFER_FLAG_GAP | the buffer has been created to fill a gap in thestream and contains media neutral data (elements canswitch to optimized code path that ignores the buffercontent).
BUFFER_FLAG_DROPPABLE | the buffer can be dropped without breaking thestream, 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 fromthis 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 audioringbuffer.
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 dedicatedhardware.
COLOR_BALANCE_SOFTWARE | Color balance is implemented via softwareprocessing.

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 datafrom the pipeline and unblock all streaming threads.
EVENT_FLUSH_STOP | Stop a flush operation. This event resets therunning-time of the pipeline.
EVENT_STREAM_START | Event to mark the start of a new stream. Sent before anyother 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. Thesegment events contains information for clipping buffers andconverting buffer timestamps to running-time andstream-time.
EVENT_TAG | A new set of metadata tags has been found in the stream.
EVENT_BUFFERSIZE | Notification of buffering requirements. Currently notused yet.
EVENT_SINK_MESSAGE | An event that sinks turn into a message. Used tosend messages that should be emitted in sync withrendering.
EVENT_EOS | End-Of-Stream. No more data is to be expected to followwithout 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 elementsthat the downstream elements should adjust their processingrate.
EVENT_SEEK | A request for a new playback position and rate.
EVENT_NAVIGATION | Navigation events are usually used for communicatinguser requests, such as mouse or keyboard movements,to upstream elements.
EVENT_LATENCY | Notification of new latency adjustment. Sinks will usethe latency information to adjust their synchronisation.
EVENT_STEP | A request for stepping through the media. Sinks will usuallyexecute 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 TOCentry's UID.
EVENT_CUSTOM_UPSTREAM | Upstream custom event.
EVENT_CUSTOM_DOWNSTREAM | Downstream custom event that travels in thedata 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 dataflow.
EVENT_TYPE_STICKY | Set if the event is sticky on the pads.
EVENT_TYPE_STICKY_MULTI | Multiple sticky events can be on a pad, eachidentified by the event name.

enum Gst::FakeSinkStateError

Enumerator
FAKE_SINK_STATE_ERROR_NONE |
FAKE_SINK_STATE_ERROR_NULL_READY |
FAKE_SINK_STATE_ERROR_READY_PAUSED |
FAKE_SINK_STATE_ERROR_PAUSED_PLAYING |
FAKE_SINK_STATE_ERROR_PLAYING_PAUSED |
FAKE_SINK_STATE_ERROR_PAUSED_READY |
FAKE_SINK_STATE_ERROR_READY_NULL |

enum Gst::FakeSrcDataType

Enumerator
FAKE_SRC_DATA_ALLOCATE |
FAKE_SRC_DATA_SUBBUFFER |

enum Gst::FakeSrcFillType

Enumerator
FAKE_SRC_FILLTYPE_NOTHING |
FAKE_SRC_FILLTYPE_ZERO |
FAKE_SRC_FILLTYPE_RANDOM |
FAKE_SRC_FILLTYPE_PATTERN |
FAKE_SRC_FILLTYPE_PATTERN_CONT |

enum Gst::FakeSrcSizeType

Enumerator
FAKE_SRC_SIZETYPE_EMPTY |
FAKE_SRC_SIZETYPE_FIXED |
FAKE_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 yourcustom success code to this to avoid compilerwarnings).
FLOW_CUSTOM_SUCCESS | Elements can use values starting fromthis (and higher) to define custom successcodes.
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 generatingthis error should post an error message with moredetails.
FLOW_NOT_SUPPORTED | This operation is not supported.
FLOW_CUSTOM_ERROR | Elements can use values starting fromthis (and lower) to define custom error codes.
FLOW_CUSTOM_ERROR_1 | Pre-defined custom error code (define yourcustom error code to this to avoid compilerwarnings).
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 besamples for raw audio, frames/fields for raw video (some, but not all,elements support this; use FORMAT_TIME if you don't have a goodreason to query for samples/frames).
FORMAT_BYTES | bytes.
FORMAT_TIME | time in nanoseconds.
FORMAT_BUFFERS | buffers (few, if any, elements implement this as ofMay 2009).
FORMAT_PERCENT | percentage of stream (few, if any, elements implementthis as of May 2009).

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 thememory with Map::WRITE.
MEMORY_FLAG_NO_SHARE | memory must not be shared. Copies will have to bemade 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_LAST | first flag that can be used for custom purposes.

enum Gst::MessageType

The different message types that are available.

Bitwise operators:
  `MessageType operator|(MessageType, MessageType)`
  `MessageType operator&(MessageType, MessageType)`
  `MessageType operator^(MessageType, MessageType)`
  `MessageType operator~(MessageType)`
  `MessageType& operator|=(MessageType&, MessageType)`
  `MessageType& operator&=(MessageType&, MessageType)`
  `MessageType& operator^=(MessageType&, MessageType)`

Enumerator
MESSAGE_UNKNOWN | an undefined message.
MESSAGE_EOS | end-of-stream reached in a pipeline. The application willonly receive this message in the PLAYING state and every time it sets apipeline to PLAYING that is in the EOS state. The application can perform aflushing seek in the pipeline, which will undo the EOS state again.
MESSAGE_ERROR | an error occured. When the application receives an errormessage it should stop playback of the pipeline and not assume that moredata will be played.
MESSAGE_WARNING | a warning occured.
MESSAGE_INFO | an info message occured.
MESSAGE_TAG | a tag was found.
MESSAGE_BUFFERING | the pipeline is buffering. When the applicationreceives a buffering message in the PLAYING state for a non-live pipeline itmust PAUSE the pipeline until the buffering completes, when the percentagefield in the message is 100%. For live pipelines, no action must beperformed and the buffering percentage can be used to inform the user aboutthe progress.
MESSAGE_STATE_CHANGED | a state change happened.
MESSAGE_STATE_DIRTY | an element changed state in a streaming thread.This message is deprecated.
MESSAGE_STEP_DONE | a stepping operation finished.
MESSAGE_CLOCK_PROVIDE | an element notifies its capability of providinga clock. This message is used internally andnever forwarded to the application.
MESSAGE_CLOCK_LOST | The current clock as selected by the pipeline becameunusable. The pipeline will select a new clock onthe next PLAYING state change. The applicationshould set the pipeline to PAUSED and back toPLAYING when this message is received.
MESSAGE_NEW_CLOCK | a new clock was selected in the pipeline.
MESSAGE_STRUCTURE_CHANGE | the structure of the pipeline changed. Thismessage is used internally and never forwarded to the application.
MESSAGE_STREAM_STATUS | status about a stream, emitted when it starts,stops, errors, etc.
MESSAGE_APPLICATION | message posted by the application, possiblyvia an application-specific element.
MESSAGE_ELEMENT | element-specific message, see the specific element'sdocumentation.
MESSAGE_SEGMENT_START | pipeline started playback of a segment. Thismessage is used internally and never forwarded to the application.
MESSAGE_SEGMENT_DONE | pipeline completed playback of a segment. Thismessage is forwarded to the application after all elements that posted MESSAGE_SEGMENT_START posted a MESSAGE_SEGMENT_DONE message.
MESSAGE_DURATION_CHANGED | The duration of a pipeline changed. Theapplication can get the new duration with a duration query.
MESSAGE_LATENCY | Posted by elements when their latency changes. Theapplication should recalculate and distribute a new latency.
MESSAGE_ASYNC_START | Posted by elements when they start an ASYNCGst::StateChange. This message is not forwarded to the application but is usedinternally.
MESSAGE_ASYNC_DONE | Posted by elements when they complete an ASYNCGst::StateChange. The application will only receive this message from the toplevelpipeline.
MESSAGE_REQUEST_STATE | Posted by elements when they want the pipeline tochange state. This message is a suggestion to the application which candecide to perform the state change on (part of) the pipeline.
MESSAGE_STEP_START | A stepping operation was started.
MESSAGE_QOS | A buffer was dropped or an element changed its processingstrategy for Quality of Service reasons.
MESSAGE_PROGRESS | A progress message.
MESSAGE_TOC | A new table of contents (TOC) was found or previously found TOCwas updated.
MESSAGE_RESET_TIME | Message to request resetting the pipeline'srunning time from the pipeline. This is an internal message whichapplications will likely never receive.
MESSAGE_STREAM_START | Message indicating start of a new stream. Usefule.g. when using playbin in gapless playback mode, to get notified whenthe next title actually starts playing (which will be some time afterthe URI for the next title has been set).
MESSAGE_ANY | mask for all of the above messages.

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 withgst_mini_object_lock() and gst_mini_object_unlock().
MINI_OBJECT_FLAG_LOCK_READONLY | the object is permanently locked inREADONLY 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 amenu, if such a button exists.
NAVIGATION_COMMAND_DOWN | Select the button below the current one in amenu, if such a button exists.
NAVIGATION_COMMAND_ACTIVATE | Activate (click) the currently selectedbutton in a menu, if such a button exists.
NAVIGATION_COMMAND_PREV_ANGLE | Switch to the previous angle in amultiangle feature.
NAVIGATION_COMMAND_NEXT_ANGLE | Switch to the next angle in a multianglefeature.

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::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 callinginto the pad callbacks.
PAD_FLAG_NEED_RECONFIGURE | the pad should be reconfigured/renegotiated.The flag has to be unset manually afterreconfiguration happened.
PAD_FLAG_PENDING_EVENTS | the pad has pending events.
PAD_FLAG_FIXED_CAPS | the pad is using fixed caps this means that once thecaps are set on the pad, the caps query function onlyreturns those caps.
PAD_FLAG_PROXY_CAPS | the default event and query handler will forwardall events and queries to the internally linked padsinstead of discarding them.
PAD_FLAG_PROXY_ALLOCATION | the default query handler will forwardallocation queries to the internally linked padsinstead of discarding them.
PAD_FLAG_PROXY_SCHEDULING | the default query handler will forwardscheduling queries to the internally linked padsinstead 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 thepads are in the same bin.
PAD_LINK_CHECK_TEMPLATE_CAPS | Check if the pads are compatible by usingtheir template caps. This is much faster than PAD_LINK_CHECK_CAPS, butwould be unsafe e.g. if one pad has Caps::ANY.
PAD_LINK_CHECK_CAPS | Check if the pads are compatible by comparing thecaps returned by Gst::Pad::query_caps().
PAD_LINK_CHECK_DEFAULT | The default checks done when linkingpads (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 withgst_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 thatthe data item is not sent downstream. For pull mode, it means that thedata item is not passed upstream. In both cases, this result codereturns 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 onthe 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 beexplicitly enabled and is not included in the@ PAD_PROBE_TYPE_EVENT_DOWNSTREAM or@ 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 pathsargument only if none of the environment variables is set.
PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX | interpretfilename argument as filter suffix and check all matching files inthe 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 downstreamelements are producing data too quickly and the element can't keep upprocessing the data. Upstream should reduce their processing rate. Thistype is also used when buffers arrive early or in time.
QOS_TYPE_UNDERFLOW | The QoS event type that is produced when downstreamelements are producing data too slowly and need to speed up their processingrate.
QOS_TYPE_THROTTLE | The QoS event type that is produced when theapplication 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.

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::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 mightbe considerably slower for some formats.
SEEK_FLAG_KEY_UNIT | seek to the nearest keyframe. This might befaster but less accurate.
SEEK_FLAG_SEGMENT | perform a segment seek.
SEEK_FLAG_SKIP | when doing fast foward or fast reverse playback, allowelements to skip frames instead of generating allframes.
SEEK_FLAG_SNAP_BEFORE | go to a location before the requested position,if UNIT this means the keyframe at or before therequested position the one at or before the seek target.
SEEK_FLAG_SNAP_AFTER | go to a location after the requested position,if UNIT this means the keyframe at of after therequested position.
SEEK_FLAG_SNAP_NEAREST | go to a position near the requested position,if UNIT this means the keyframe closest to therequested position, if both keyframes are at an equaldistance, behaves like BEFORE.

enum Gst::SeekType

The different types of seek events.

When constructing a seek event with gst_event_new_seek() or when doing Gst::Segment::do_seek().

Enumerator
SEEK_TYPE_NONE | no change in position is required.
SEEK_TYPE_SET | absolute position is requested.
SEEK_TYPE_END | relative position to duration is requested.

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 andprocess data. Sink elements however only accept onebuffer and then block.
STATE_PLAYING | the element is PLAYING, the Gst::Clock is running andthe 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 elementcannot produce data in 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
THEORA_ENC_MULTIPASS_MODE_SINGLE_PASS |
THEORA_ENC_MULTIPASS_MODE_FIRST_PASS |
THEORA_ENC_MULTIPASS_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 willusually be a subset of the global TOC, e.g. just the chapters ofthe current title, or the chapters selected for playback from thecurrent 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::VideoConvertDitherMethod

Enumerator
NONE |
VERTERR |
HALFTONE |

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 |

## Function Documentation

AudioFlags Gst::operator& | ( | AudioFlags | lhs,
|  | AudioFlags | rhs
| ) |  |
| inline

PlayFlags Gst::operator& | ( | PlayFlags | lhs,
|  | PlayFlags | rhs
| ) |  |
| inline

MiniObjectFlags Gst::operator& | ( | MiniObjectFlags | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags Gst::operator& | ( | PadTemplateFlags | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags Gst::operator& | ( | ObjectFlags | lhs,
|  | ObjectFlags | 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

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

MessageType Gst::operator& | ( | MessageType | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags Gst::operator& | ( | BufferCopyFlags | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType Gst::operator& | ( | QueryType | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags Gst::operator& | ( | ClockFlags | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags Gst::operator& | ( | EventTypeFlags | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags Gst::operator& | ( | AudioFormatFlags | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags Gst::operator& | ( | PadFlags | lhs,
|  | PadFlags | 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

MiniObjectFlags& Gst::operator&= | ( | MiniObjectFlags & | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags& Gst::operator&= | ( | PadTemplateFlags & | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags& Gst::operator&= | ( | ObjectFlags & | lhs,
|  | ObjectFlags | 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

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

MessageType& Gst::operator&= | ( | MessageType & | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags& Gst::operator&= | ( | BufferCopyFlags & | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType& Gst::operator&= | ( | QueryType & | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags& Gst::operator&= | ( | ClockFlags & | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags& Gst::operator&= | ( | EventTypeFlags & | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags& Gst::operator&= | ( | AudioFormatFlags & | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags& Gst::operator&= | ( | PadFlags & | lhs,
|  | PadFlags | 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

MiniObjectFlags Gst::operator^ | ( | MiniObjectFlags | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags Gst::operator^ | ( | PadTemplateFlags | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags Gst::operator^ | ( | ObjectFlags | lhs,
|  | ObjectFlags | 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

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

MessageType Gst::operator^ | ( | MessageType | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags Gst::operator^ | ( | BufferCopyFlags | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType Gst::operator^ | ( | QueryType | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags Gst::operator^ | ( | ClockFlags | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags Gst::operator^ | ( | EventTypeFlags | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags Gst::operator^ | ( | AudioFormatFlags | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags Gst::operator^ | ( | PadFlags | lhs,
|  | PadFlags | 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

MiniObjectFlags& Gst::operator^= | ( | MiniObjectFlags & | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags& Gst::operator^= | ( | PadTemplateFlags & | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags& Gst::operator^= | ( | ObjectFlags & | lhs,
|  | ObjectFlags | 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

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

MessageType& Gst::operator^= | ( | MessageType & | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags& Gst::operator^= | ( | BufferCopyFlags & | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType& Gst::operator^= | ( | QueryType & | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags& Gst::operator^= | ( | ClockFlags & | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags& Gst::operator^= | ( | EventTypeFlags & | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags& Gst::operator^= | ( | AudioFormatFlags & | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags& Gst::operator^= | ( | PadFlags & | lhs,
|  | PadFlags | 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

MiniObjectFlags Gst::operator| | ( | MiniObjectFlags | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags Gst::operator| | ( | PadTemplateFlags | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags Gst::operator| | ( | ObjectFlags | lhs,
|  | ObjectFlags | 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

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

MessageType Gst::operator| | ( | MessageType | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags Gst::operator| | ( | BufferCopyFlags | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType Gst::operator| | ( | QueryType | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags Gst::operator| | ( | ClockFlags | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags Gst::operator| | ( | EventTypeFlags | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags Gst::operator| | ( | AudioFormatFlags | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags Gst::operator| | ( | PadFlags | lhs,
|  | PadFlags | 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

MiniObjectFlags& Gst::operator|= | ( | MiniObjectFlags & | lhs,
|  | MiniObjectFlags | rhs
| ) |  |
| inline

PadTemplateFlags& Gst::operator|= | ( | PadTemplateFlags & | lhs,
|  | PadTemplateFlags | rhs
| ) |  |
| inline

ObjectFlags& Gst::operator|= | ( | ObjectFlags & | lhs,
|  | ObjectFlags | 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

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

MessageType& Gst::operator|= | ( | MessageType & | lhs,
|  | MessageType | rhs
| ) |  |
| inline

BufferCopyFlags& Gst::operator|= | ( | BufferCopyFlags & | lhs,
|  | BufferCopyFlags | rhs
| ) |  |
| inline

QueryType& Gst::operator|= | ( | QueryType & | lhs,
|  | QueryType | rhs
| ) |  |
| inline

ClockFlags& Gst::operator|= | ( | ClockFlags & | lhs,
|  | ClockFlags | rhs
| ) |  |
| inline

EventTypeFlags& Gst::operator|= | ( | EventTypeFlags & | lhs,
|  | EventTypeFlags | rhs
| ) |  |
| inline

AudioFormatFlags& Gst::operator|= | ( | AudioFormatFlags & | lhs,
|  | AudioFormatFlags | rhs
| ) |  |
| inline

PadFlags& Gst::operator|= | ( | PadFlags & | lhs,
|  | PadFlags | 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

MiniObjectFlags Gst::operator~ | ( | MiniObjectFlags | flags | ) |
| inline

PadTemplateFlags Gst::operator~ | ( | PadTemplateFlags | flags | ) |
| inline

ObjectFlags Gst::operator~ | ( | ObjectFlags | flags | ) |
| inline

MapFlags Gst::operator~ | ( | MapFlags | flags | ) |
| inline

BusFlags Gst::operator~ | ( | BusFlags | flags | ) |
| inline

PluginDependencyFlags Gst::operator~ | ( | PluginDependencyFlags | 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

MessageType Gst::operator~ | ( | MessageType | flags | ) |
| inline

BufferCopyFlags Gst::operator~ | ( | BufferCopyFlags | flags | ) |
| inline

QueryType Gst::operator~ | ( | QueryType | flags | ) |
| inline

ClockFlags Gst::operator~ | ( | ClockFlags | flags | ) |
| inline

EventTypeFlags Gst::operator~ | ( | EventTypeFlags | flags | ) |
| inline

AudioFormatFlags Gst::operator~ | ( | AudioFormatFlags | flags | ) |
| inline

PadFlags Gst::operator~ | ( | PadFlags | flags | ) |
| inline

PadLinkCheck Gst::operator~ | ( | PadLinkCheck | flags | ) |
| inline

PadProbeType Gst::operator~ | ( | PadProbeType | flags | ) |
| inline