gstreamermm 1.10.0

Enumerations | Functions
gstreamermm Enums and Flags

## Enumerations
enum | Gst::AutoplugSelectResult { Gst::AUTOPLUG_SELECT_TRY, Gst::AUTOPLUG_SELECT_EXPOSE, Gst::AUTOPLUG_SELECT_SKIP }
enum | Gst::MultiHandleSinkClientStatus { Gst::CLIENT_STATUS_OK, Gst::CLIENT_STATUS_CLOSED, Gst::CLIENT_STATUS_REMOVED, Gst::CLIENT_STATUS_SLOW, Gst::CLIENT_STATUS_ERROR, Gst::CLIENT_STATUS_DUPLICATE, Gst::CLIENT_STATUS_FLUSHING }
enum | Gst::MultiHandleSinkSyncMethod { Gst::SYNC_METHOD_LATEST, Gst::SYNC_METHOD_NEXT_KEYFRAME, Gst::SYNC_METHOD_LATEST_KEYFRAME, Gst::SYNC_METHOD_BURST, Gst::SYNC_METHOD_BURST_KEYFRAME, Gst::SYNC_METHOD_BURST_WITH_KEYFRAME }
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), Gst::PLAY_FLAG_FORCE_FILTERS = (1 << 11) }
enum | Gst::VideoFormat { Gst::VIDEO_FORMAT_UNKNOWN, Gst::VIDEO_FORMAT_ENCODED, Gst::VIDEO_FORMAT_I420, Gst::VIDEO_FORMAT_YV12, Gst::VIDEO_FORMAT_YUY2, Gst::VIDEO_FORMAT_UYVY, Gst::VIDEO_FORMAT_AYUV, Gst::VIDEO_FORMAT_RGBx, Gst::VIDEO_FORMAT_BGRx, Gst::VIDEO_FORMAT_xRGB, Gst::VIDEO_FORMAT_xBGR, Gst::VIDEO_FORMAT_RGBA, Gst::VIDEO_FORMAT_BGRA, Gst::VIDEO_FORMAT_ARGB, Gst::VIDEO_FORMAT_ABGR, Gst::VIDEO_FORMAT_RGB, Gst::VIDEO_FORMAT_BGR, Gst::VIDEO_FORMAT_Y41B, Gst::VIDEO_FORMAT_Y42B, Gst::VIDEO_FORMAT_YVYU, Gst::VIDEO_FORMAT_Y444, Gst::VIDEO_FORMAT_v210, Gst::VIDEO_FORMAT_v216, Gst::VIDEO_FORMAT_NV12, Gst::VIDEO_FORMAT_NV21, Gst::VIDEO_FORMAT_GRAY8, Gst::VIDEO_FORMAT_GRAY16_BE, Gst::VIDEO_FORMAT_GRAY16_LE, Gst::VIDEO_FORMAT_v308, Gst::VIDEO_FORMAT_RGB16, Gst::VIDEO_FORMAT_BGR16, Gst::VIDEO_FORMAT_RGB15, Gst::VIDEO_FORMAT_BGR15, Gst::VIDEO_FORMAT_UYVP, Gst::VIDEO_FORMAT_A420, Gst::VIDEO_FORMAT_RGB8P, Gst::VIDEO_FORMAT_YUV9, Gst::VIDEO_FORMAT_YVU9, Gst::VIDEO_FORMAT_IYU1, Gst::VIDEO_FORMAT_ARGB64, Gst::VIDEO_FORMAT_AYUV64, Gst::VIDEO_FORMAT_r210, Gst::VIDEO_FORMAT_I420_10BE, Gst::VIDEO_FORMAT_I420_10LE, Gst::VIDEO_FORMAT_I422_10BE, Gst::VIDEO_FORMAT_I422_10LE, Gst::VIDEO_FORMAT_Y444_10BE, Gst::VIDEO_FORMAT_Y444_10LE, Gst::VIDEO_FORMAT_GBR, Gst::VIDEO_FORMAT_GBR_10BE, Gst::VIDEO_FORMAT_GBR_10LE, Gst::VIDEO_FORMAT_NV16, Gst::VIDEO_FORMAT_NV24, Gst::VIDEO_FORMAT_NV12_64Z32, Gst::VIDEO_FORMAT_A420_10BE, Gst::VIDEO_FORMAT_A420_10LE, Gst::VIDEO_FORMAT_A422_10BE, Gst::VIDEO_FORMAT_A422_10LE, Gst::VIDEO_FORMAT_A444_10BE, Gst::VIDEO_FORMAT_A444_10LE, Gst::VIDEO_FORMAT_NV61 }
enum | Gst::AudioBaseSinkSlaveMethod { Gst::AUDIO_BASE_SINK_SLAVE_RESAMPLE, Gst::AUDIO_BASE_SINK_SLAVE_SKEW, Gst::AUDIO_BASE_SINK_SLAVE_NONE, Gst::AUDIO_BASE_SINK_SLAVE_CUSTOM }
enum | Gst::AudioBaseSinkDiscontReason { Gst::AUDIO_BASE_SINK_DISCONT_REASON_NO_DISCONT, Gst::AUDIO_BASE_SINK_DISCONT_REASON_NEW_CAPS, Gst::AUDIO_BASE_SINK_DISCONT_REASON_FLUSH, Gst::AUDIO_BASE_SINK_DISCONT_REASON_SYNC_LATENCY, Gst::AUDIO_BASE_SINK_DISCONT_REASON_ALIGNMENT, Gst::AUDIO_BASE_SINK_DISCONT_REASON_DEVICE_FAILURE }
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 }
enum | Gst::AudioCdSrcMode { Gst::AUDIO_CD_SRC_MODE_NORMAL, Gst::AUDIO_CD_SRC_MODE_CONTINUOUS }
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 | 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) }
enum | Gst::AudioPackFlags { Gst::AUDIO_PACK_FLAG_NONE = 0x0, Gst::AUDIO_PACK_FLAG_TRUNCATE_RANGE = (1 << 0) }
enum | Gst::AudioFlags { Gst::AUDIO_FLAG_NONE = 0x0, Gst::AUDIO_FLAG_UNPOSITIONED = (1 << 0) }
enum | Gst::AudioLayout { Gst::AUDIO_LAYOUT_INTERLEAVED, Gst::AUDIO_LAYOUT_NON_INTERLEAVED }
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 }
enum | Gst::AudioRingBufferState { Gst::AUDIO_RING_BUFFER_STATE_STOPPED, Gst::AUDIO_RING_BUFFER_STATE_PAUSED, Gst::AUDIO_RING_BUFFER_STATE_STARTED, Gst::AUDIO_RING_BUFFER_STATE_ERROR }
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 }
enum | Gst::BaseSrcFlags { Gst::BASE_SRC_FLAG_STARTING = (((GST_OBJECT_FLAG_LAST << 10)) << 0), Gst::BASE_SRC_FLAG_STARTED = (((GST_OBJECT_FLAG_LAST << 10)) << 1), Gst::BASE_SRC_FLAG_LAST = (((GST_OBJECT_FLAG_LAST << 10)) << 6) }
enum | Gst::BinFlags { Gst::BIN_FLAG_NO_RESYNC = (GST_ELEMENT_FLAG_LAST << 0), Gst::BIN_FLAG_LAST = (GST_ELEMENT_FLAG_LAST << 5) }
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_TAG_MEMORY = (GST_MINI_OBJECT_FLAG_LAST << 10), Gst::BUFFER_FLAG_SYNC_AFTER = (GST_MINI_OBJECT_FLAG_LAST << 11), Gst::BUFFER_FLAG_LAST = (GST_MINI_OBJECT_FLAG_LAST << 16) }
enum | Gst::BufferCopyFlags { Gst::BUFFER_COPY_NONE = 0x0, Gst::BUFFER_COPY_FLAGS = (1 << 0), Gst::BUFFER_COPY_TIMESTAMPS = (1 << 1), Gst::BUFFER_COPY_META = (1 << 2), Gst::BUFFER_COPY_MEMORY = (1 << 3), Gst::BUFFER_COPY_MERGE = (1 << 4), Gst::BUFFER_COPY_DEEP = (1 << 5) }
enum | Gst::BusFlags { Gst::BUS_FLUSHING = (GST_OBJECT_FLAG_LAST << 0), Gst::BUS_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 1) }
enum | Gst::BusSyncReply { Gst::BUS_DROP, Gst::BUS_PASS, Gst::BUS_ASYNC }
enum | Gst::CapsIntersectMode { Gst::CAPS_INTERSECT_ZIG_ZAG, Gst::CAPS_INTERSECT_FIRST }
enum | Gst::CapsFlags { Gst::CAPS_FLAG_ANY = (GST_MINI_OBJECT_FLAG_LAST << 0) }
enum | Gst::ClockEntryType { Gst::CLOCK_ENTRY_SINGLE, Gst::CLOCK_ENTRY_PERIODIC }
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 }
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_NEEDS_STARTUP_SYNC = (GST_OBJECT_FLAG_LAST << 6), Gst::CLOCK_FLAG_LAST = (GST_OBJECT_FLAG_LAST << 8) }
enum | Gst::ColorBalanceType { Gst::COLOR_BALANCE_HARDWARE, Gst::COLOR_BALANCE_SOFTWARE }
enum | Gst::DiscovererResult { Gst::DISCOVERER_OK, Gst::DISCOVERER_URI_INVALID, Gst::DISCOVERER_ERROR, Gst::DISCOVERER_TIMEOUT, Gst::DISCOVERER_BUSY, Gst::DISCOVERER_MISSING_PLUGINS }
enum | Gst::DiscovererSerializeFlags { Gst::DISCOVERER_SERIALIZE_BASIC = 0x0, Gst::DISCOVERER_SERIALIZE_CAPS = 1 << 0, Gst::DISCOVERER_SERIALIZE_TAGS = 1 << 1, Gst::DISCOVERER_SERIALIZE_MISC = 1 << 2, Gst::DISCOVERER_SERIALIZE_ALL = 0x7 }
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) }
enum | Gst::StateChange { Gst::STATE_CHANGE_NULL_TO_READY = 0xA, Gst::STATE_CHANGE_READY_TO_PAUSED = 0x13, Gst::STATE_CHANGE_PAUSED_TO_PLAYING = 0x1C, Gst::STATE_CHANGE_PLAYING_TO_PAUSED = 0x23, Gst::STATE_CHANGE_PAUSED_TO_READY = 0x1A, Gst::STATE_CHANGE_READY_TO_NULL = 0x11 }
enum | Gst::StateChangeReturn { Gst::STATE_CHANGE_FAILURE, Gst::STATE_CHANGE_SUCCESS, Gst::STATE_CHANGE_ASYNC, Gst::STATE_CHANGE_NO_PREROLL }
enum | Gst::State { Gst::STATE_VOID_PENDING, Gst::STATE_NULL, Gst::STATE_READY, Gst::STATE_PAUSED, Gst::STATE_PLAYING }
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_PROTECTION = GST_EVENT_MAKE_TYPE (130, 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)) }
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 }
enum | Gst::QOSType { Gst::QOS_TYPE_OVERFLOW, Gst::QOS_TYPE_UNDERFLOW, Gst::QOS_TYPE_THROTTLE }
enum | Gst::StreamFlags { Gst::STREAM_FLAG_NONE = 0x0, Gst::STREAM_FLAG_SPARSE = (1 << 0), Gst::STREAM_FLAG_SELECT = (1 << 1), Gst::STREAM_FLAG_UNSELECT = (1 << 2) }
enum | Format
enum | Gst::IteratorItem { Gst::ITERATOR_ITEM_SKIP, Gst::ITERATOR_ITEM_PASS, Gst::ITERATOR_ITEM_END }
enum | Gst::IteratorResult { Gst::ITERATOR_DONE, Gst::ITERATOR_OK, Gst::ITERATOR_RESYNC, Gst::ITERATOR_ERROR }
enum | Gst::MapFlags { Gst::MAP_READ = GST_LOCK_FLAG_READ, Gst::MAP_WRITE = GST_LOCK_FLAG_WRITE, Gst::MAP_FLAG_LAST = (1 << 16) }
enum | MessageType
enum | Gst::ProgressType { Gst::PROGRESS_TYPE_START, Gst::PROGRESS_TYPE_CONTINUE, Gst::PROGRESS_TYPE_COMPLETE, Gst::PROGRESS_TYPE_CANCELED, Gst::PROGRESS_TYPE_ERROR }
enum | Gst::StructureChangeType { Gst::STRUCTURE_CHANGE_TYPE_PAD_LINK, Gst::STRUCTURE_CHANGE_TYPE_PAD_UNLINK }
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 }
enum | Gst::MemoryFlags { Gst::MEMORY_FLAG_READONLY = GST_MINI_OBJECT_FLAG_LOCK_READONLY, Gst::MEMORY_FLAG_NO_SHARE = (GST_MINI_OBJECT_FLAG_LAST << 0), Gst::MEMORY_FLAG_ZERO_PREFIXED = (GST_MINI_OBJECT_FLAG_LAST << 1), Gst::MEMORY_FLAG_ZERO_PADDED = (GST_MINI_OBJECT_FLAG_LAST << 2), Gst::MEMORY_FLAG_PHYSICALLY_CONTIGUOUS = (GST_MINI_OBJECT_FLAG_LAST << 3), Gst::MEMORY_FLAG_NOT_MAPPABLE = (GST_MINI_OBJECT_FLAG_LAST << 4), Gst::MEMORY_FLAG_LAST = (GST_MINI_OBJECT_FLAG_LAST << 16) }
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) }
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) }
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 }
enum | Gst::NavigationEventType { Gst::NAVIGATION_EVENT_INVALID, Gst::NAVIGATION_EVENT_KEY_PRESS, Gst::NAVIGATION_EVENT_KEY_RELEASE, Gst::NAVIGATION_EVENT_MOUSE_BUTTON_PRESS, Gst::NAVIGATION_EVENT_MOUSE_BUTTON_RELEASE, Gst::NAVIGATION_EVENT_MOUSE_MOVE, Gst::NAVIGATION_EVENT_COMMAND }
enum | Gst::NavigationMessageType { Gst::NAVIGATION_MESSAGE_INVALID, Gst::NAVIGATION_MESSAGE_MOUSE_OVER, Gst::NAVIGATION_MESSAGE_COMMANDS_CHANGED, Gst::NAVIGATION_MESSAGE_ANGLES_CHANGED, Gst::NAVIGATION_MESSAGE_EVENT }
enum | Gst::NavigationQueryType { Gst::NAVIGATION_QUERY_INVALID, Gst::NAVIGATION_QUERY_COMMANDS, Gst::NAVIGATION_QUERY_ANGLES }
enum | Gst::ObjectFlags { Gst::OBJECT_FLAG_LAST = (1<<4) }
enum | Gst::PadMode { Gst::PAD_MODE_NONE, Gst::PAD_MODE_PUSH, Gst::PAD_MODE_PULL }
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 }
enum | Gst::PadDirection { Gst::PAD_UNKNOWN, Gst::PAD_SRC, Gst::PAD_SINK }
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_ACCEPT_INTERSECT = 0x8000, Gst::PAD_FLAG_ACCEPT_TEMPLATE = 0x10000, Gst::PAD_FLAG_LAST = 0x100000 }
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 }
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 }
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 }
enum | Gst::PadProbeReturn { Gst::PAD_PROBE_DROP, Gst::PAD_PROBE_OK, Gst::PAD_PROBE_REMOVE, Gst::PAD_PROBE_PASS, Gst::PAD_PROBE_HANDLED }
enum | Gst::PadTemplateFlags { Gst::PAD_TEMPLATE_FLAG_LAST = 0x100 }
enum | Gst::PadPresence { Gst::PAD_ALWAYS, Gst::PAD_SOMETIMES, Gst::PAD_REQUEST }
enum | Gst::Rank { Gst::RANK_NONE = 0, Gst::RANK_MARGINAL = 64, Gst::RANK_SECONDARY = 128, Gst::RANK_PRIMARY = 256 }
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), Gst::PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX = (1 << 3) }
enum | Gst::PluginFlags { Gst::PLUGIN_FLAG_CACHED = 0x10, Gst::PLUGIN_FLAG_BLACKLISTED = 0x20 }
enum | Gst::BufferingMode { Gst::BUFFERING_STREAM, Gst::BUFFERING_DOWNLOAD, Gst::BUFFERING_TIMESHIFT, Gst::BUFFERING_LIVE }
enum | Gst::QueryType { Gst::QUERY_UNKNOWN = GST_QUERY_MAKE_TYPE (0, 0), Gst::QUERY_POSITION = GST_QUERY_MAKE_TYPE (10, FLAG(BOTH)), Gst::QUERY_DURATION = GST_QUERY_MAKE_TYPE (20, FLAG(BOTH)), Gst::QUERY_LATENCY = GST_QUERY_MAKE_TYPE (30, FLAG(BOTH)), Gst::QUERY_JITTER = GST_QUERY_MAKE_TYPE (40, FLAG(BOTH)), Gst::QUERY_RATE = GST_QUERY_MAKE_TYPE (50, FLAG(BOTH)), Gst::QUERY_SEEKING = GST_QUERY_MAKE_TYPE (60, FLAG(BOTH)), Gst::QUERY_SEGMENT = GST_QUERY_MAKE_TYPE (70, FLAG(BOTH)), Gst::QUERY_CONVERT = GST_QUERY_MAKE_TYPE (80, FLAG(BOTH)), Gst::QUERY_FORMATS = GST_QUERY_MAKE_TYPE (90, FLAG(BOTH)), Gst::QUERY_BUFFERING = GST_QUERY_MAKE_TYPE (110, FLAG(BOTH)), Gst::QUERY_CUSTOM = GST_QUERY_MAKE_TYPE (120, FLAG(BOTH)), Gst::QUERY_URI = GST_QUERY_MAKE_TYPE (130, FLAG(BOTH)), Gst::QUERY_ALLOCATION = GST_QUERY_MAKE_TYPE (140, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), Gst::QUERY_SCHEDULING = GST_QUERY_MAKE_TYPE (150, FLAG(UPSTREAM)), Gst::QUERY_ACCEPT_CAPS = GST_QUERY_MAKE_TYPE (160, FLAG(BOTH)), Gst::QUERY_CAPS = GST_QUERY_MAKE_TYPE (170, FLAG(BOTH)), Gst::QUERY_DRAIN = GST_QUERY_MAKE_TYPE (180, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)), Gst::QUERY_CONTEXT = GST_QUERY_MAKE_TYPE (190, FLAG(BOTH)) }
enum | Gst::QueryTypeFlags { Gst::QUERY_TYPE_UPSTREAM = 1 << 0, Gst::QUERY_TYPE_DOWNSTREAM = 1 << 1, Gst::QUERY_TYPE_SERIALIZED = 1 << 2 }
enum | Gst::SchedulingFlags { Gst::SCHEDULING_FLAG_SEEKABLE = (1 << 0), Gst::SCHEDULING_FLAG_SEQUENTIAL = (1 << 1), Gst::SCHEDULING_FLAG_BANDWIDTH_LIMITED = (1 << 2) }
enum | Gst::SDP::Result { Gst::SDP::SDP_OK = 0, Gst::SDP::SDP_EINVAL = -1 }
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_TRICKMODE = (1 << 4), 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, Gst::SEEK_FLAG_TRICKMODE_KEY_UNITS = (1 << 7), Gst::SEEK_FLAG_TRICKMODE_NO_AUDIO = (1 << 8) }
enum | SeekType
enum | Gst::StreamVolumeFormat { Gst::STREAM_VOLUME_FORMAT_LINEAR, Gst::STREAM_VOLUME_FORMAT_CUBIC, Gst::STREAM_VOLUME_FORMAT_DB }
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 }
enum | Gst::TagFlag { Gst::TAG_FLAG_UNDEFINED, Gst::TAG_FLAG_META, Gst::TAG_FLAG_ENCODED, Gst::TAG_FLAG_DECODED, Gst::TAG_FLAG_COUNT }
enum | Gst::TaskState { Gst::TASK_STARTED, Gst::TASK_STOPPED, Gst::TASK_PAUSED }
enum | Gst::TocScope { Gst::TOC_SCOPE_GLOBAL = 1, Gst::TOC_SCOPE_CURRENT }
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 }
enum | Gst::TocLoopType { Gst::TOC_LOOP_NONE, Gst::TOC_LOOP_FORWARD, Gst::TOC_LOOP_REVERSE, Gst::TOC_LOOP_PING_PONG }
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 }
enum | Gst::URIType { Gst::URI_UNKNOWN, Gst::URI_SINK, Gst::URI_SRC }
enum | Gst::URIError { Gst::URI_ERROR_UNSUPPORTED_PROTOCOL, Gst::URI_ERROR_BAD_URI, Gst::URI_ERROR_BAD_STATE, Gst::URI_ERROR_BAD_REFERENCE }
enum | Gst::VideoChromaSite { Gst::VIDEO_CHROMA_SITE_UNKNOWN = 0x0, Gst::VIDEO_CHROMA_SITE_NONE = (1 << 0), Gst::VIDEO_CHROMA_SITE_H_COSITED = (1 << 1), Gst::VIDEO_CHROMA_SITE_V_COSITED = (1 << 2), Gst::VIDEO_CHROMA_SITE_ALT_LINE = (1 << 3), Gst::VIDEO_CHROMA_SITE_COSITED = 0x6, Gst::VIDEO_CHROMA_SITE_JPEG = 0x1, Gst::VIDEO_CHROMA_SITE_MPEG2 = 0x2, Gst::VIDEO_CHROMA_SITE_DV = 0xE }
enum | Gst::VideoChromaMethod { Gst::VIDEO_CHROMA_METHOD_NEAREST, Gst::VIDEO_CHROMA_METHOD_LINEAR }
enum | Gst::VideoChromaFlags { Gst::VIDEO_CHROMA_FLAG_NONE = 0x0, Gst::VIDEO_CHROMA_FLAG_INTERLACED = (1 << 0) }
enum | Gst::VideoFormatFlags { Gst::VIDEO_FORMAT_FLAG_YUV = (1 << 0), Gst::VIDEO_FORMAT_FLAG_RGB = (1 << 1), Gst::VIDEO_FORMAT_FLAG_GRAY = (1 << 2), Gst::VIDEO_FORMAT_FLAG_ALPHA = (1 << 3), Gst::VIDEO_FORMAT_FLAG_LE = (1 << 4), Gst::VIDEO_FORMAT_FLAG_PALETTE = (1 << 5), Gst::VIDEO_FORMAT_FLAG_COMPLEX = (1 << 6), Gst::VIDEO_FORMAT_FLAG_UNPACK = (1 << 7), Gst::VIDEO_FORMAT_FLAG_TILED = (1 << 8) }
enum | Gst::VideoPackFlags { Gst::VIDEO_PACK_FLAG_NONE = 0x0, Gst::VIDEO_PACK_FLAG_TRUNCATE_RANGE = (1 << 0), Gst::VIDEO_PACK_FLAG_INTERLACED = (1 << 1) }
enum | Gst::VideoFrameFlags { Gst::VIDEO_FRAME_FLAG_NONE = 0x0, Gst::VIDEO_FRAME_FLAG_INTERLACED = (1 << 0), Gst::VIDEO_FRAME_FLAG_TFF = (1 << 1), Gst::VIDEO_FRAME_FLAG_RFF = (1 << 2), Gst::VIDEO_FRAME_FLAG_ONEFIELD = (1 << 3), Gst::VIDEO_FRAME_FLAG_MULTIPLE_VIEW = (1 << 4), Gst::VIDEO_FRAME_FLAG_FIRST_IN_BUNDLE = (1 << 5) }
enum | Gst::VideoBufferFlags { Gst::VIDEO_BUFFER_FLAG_INTERLACED = (GST_BUFFER_FLAG_LAST << 0), Gst::VIDEO_BUFFER_FLAG_TFF = (GST_BUFFER_FLAG_LAST << 1), Gst::VIDEO_BUFFER_FLAG_RFF = (GST_BUFFER_FLAG_LAST << 2), Gst::VIDEO_BUFFER_FLAG_ONEFIELD = (GST_BUFFER_FLAG_LAST << 3), Gst::VIDEO_BUFFER_FLAG_MULTIPLE_VIEW = (GST_BUFFER_FLAG_LAST << 4), Gst::VIDEO_BUFFER_FLAG_FIRST_IN_BUNDLE = (GST_BUFFER_FLAG_LAST << 5), Gst::VIDEO_BUFFER_FLAG_LAST = (GST_BUFFER_FLAG_LAST << 8) }
enum | Gst::VideoFrameMapFlags { Gst::VIDEO_FRAME_MAP_FLAG_NO_REF = (GST_MAP_FLAG_LAST << 0), Gst::VIDEO_FRAME_MAP_FLAG_LAST = (GST_MAP_FLAG_LAST << 8) }
enum | Gst::VideoInterlaceMode { Gst::VIDEO_INTERLACE_MODE_PROGRESSIVE, Gst::VIDEO_INTERLACE_MODE_INTERLEAVED, Gst::VIDEO_INTERLACE_MODE_MIXED, Gst::VIDEO_INTERLACE_MODE_FIELDS }
enum | Gst::VideoMultiviewMode { Gst::VIDEO_MULTIVIEW_MODE_NONE = -1, Gst::VIDEO_MULTIVIEW_MODE_MONO = 0, Gst::VIDEO_MULTIVIEW_MODE_LEFT = 1, Gst::VIDEO_MULTIVIEW_MODE_RIGHT = 2, Gst::VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE = 3, Gst::VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX = 4, Gst::VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED = 5, Gst::VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED = 6, Gst::VIDEO_MULTIVIEW_MODE_TOP_BOTTOM = 7, Gst::VIDEO_MULTIVIEW_MODE_CHECKERBOARD = 8, Gst::VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME = 32, Gst::VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME = 33, Gst::VIDEO_MULTIVIEW_MODE_SEPARATED = 34 }
enum | Gst::VideoMultiviewFramePacking { Gst::VIDEO_MULTIVIEW_FRAME_PACKING_NONE = -1, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_MONO, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_LEFT, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_RIGHT, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE_QUINCUNX, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_COLUMN_INTERLEAVED, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_ROW_INTERLEAVED, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_TOP_BOTTOM, Gst::VIDEO_MULTIVIEW_FRAME_PACKING_CHECKERBOARD }
enum | Gst::VideoMultiviewFlags { Gst::VIDEO_MULTIVIEW_FLAGS_NONE = 0x0, Gst::VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST = (1 << 0), Gst::VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED = (1 << 1), Gst::VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED = (1 << 2), Gst::VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED = (1 << 3), Gst::VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED = (1 << 4), Gst::VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT = (1 << 14), Gst::VIDEO_MULTIVIEW_FLAGS_MIXED_MONO = (1 << 15) }
enum | Gst::VideoFlags { Gst::VIDEO_FLAG_NONE = 0x0, Gst::VIDEO_FLAG_VARIABLE_FPS = (1 << 0), Gst::VIDEO_FLAG_PREMULTIPLIED_ALPHA = (1 << 1) }

## 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)
AudioPackFlags | Gst::operator| (AudioPackFlags lhs, AudioPackFlags rhs)
AudioPackFlags | Gst::operator& (AudioPackFlags lhs, AudioPackFlags rhs)
AudioPackFlags | Gst::operator^ (AudioPackFlags lhs, AudioPackFlags rhs)
AudioPackFlags | Gst::operator~ (AudioPackFlags flags)
AudioPackFlags& | Gst::operator|= (AudioPackFlags& lhs, AudioPackFlags rhs)
AudioPackFlags& | Gst::operator&= (AudioPackFlags& lhs, AudioPackFlags rhs)
AudioPackFlags& | Gst::operator^= (AudioPackFlags& lhs, AudioPackFlags 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)
BaseSrcFlags | Gst::operator| (BaseSrcFlags lhs, BaseSrcFlags rhs)
BaseSrcFlags | Gst::operator& (BaseSrcFlags lhs, BaseSrcFlags rhs)
BaseSrcFlags | Gst::operator^ (BaseSrcFlags lhs, BaseSrcFlags rhs)
BaseSrcFlags | Gst::operator~ (BaseSrcFlags flags)
BaseSrcFlags& | Gst::operator|= (BaseSrcFlags& lhs, BaseSrcFlags rhs)
BaseSrcFlags& | Gst::operator&= (BaseSrcFlags& lhs, BaseSrcFlags rhs)
BaseSrcFlags& | Gst::operator^= (BaseSrcFlags& lhs, BaseSrcFlags rhs)
BinFlags | Gst::operator| (BinFlags lhs, BinFlags rhs)
BinFlags | Gst::operator& (BinFlags lhs, BinFlags rhs)
BinFlags | Gst::operator^ (BinFlags lhs, BinFlags rhs)
BinFlags | Gst::operator~ (BinFlags flags)
BinFlags& | Gst::operator|= (BinFlags& lhs, BinFlags rhs)
BinFlags& | Gst::operator&= (BinFlags& lhs, BinFlags rhs)
BinFlags& | Gst::operator^= (BinFlags& lhs, BinFlags rhs)
BufferFlags | Gst::operator| (BufferFlags lhs, BufferFlags rhs)
BufferFlags | Gst::operator& (BufferFlags lhs, BufferFlags rhs)
BufferFlags | Gst::operator^ (BufferFlags lhs, BufferFlags rhs)
BufferFlags | Gst::operator~ (BufferFlags flags)
BufferFlags& | Gst::operator|= (BufferFlags& lhs, BufferFlags rhs)
BufferFlags& | Gst::operator&= (BufferFlags& lhs, BufferFlags rhs)
BufferFlags& | Gst::operator^= (BufferFlags& lhs, BufferFlags rhs)
BufferCopyFlags | Gst::operator| (BufferCopyFlags lhs, BufferCopyFlags rhs)
BufferCopyFlags | Gst::operator& (BufferCopyFlags lhs, BufferCopyFlags rhs)
BufferCopyFlags | Gst::operator^ (BufferCopyFlags lhs, BufferCopyFlags rhs)
BufferCopyFlags | Gst::operator~ (BufferCopyFlags flags)
BufferCopyFlags& | Gst::operator|= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
BufferCopyFlags& | Gst::operator&= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
BufferCopyFlags& | Gst::operator^= (BufferCopyFlags& lhs, BufferCopyFlags rhs)
BusFlags | Gst::operator| (BusFlags lhs, BusFlags rhs)
BusFlags | Gst::operator& (BusFlags lhs, BusFlags rhs)
BusFlags | Gst::operator^ (BusFlags lhs, BusFlags rhs)
BusFlags | Gst::operator~ (BusFlags flags)
BusFlags& | Gst::operator|= (BusFlags& lhs, BusFlags rhs)
BusFlags& | Gst::operator&= (BusFlags& lhs, BusFlags rhs)
BusFlags& | Gst::operator^= (BusFlags& lhs, BusFlags rhs)
CapsFlags | Gst::operator| (CapsFlags lhs, CapsFlags rhs)
CapsFlags | Gst::operator& (CapsFlags lhs, CapsFlags rhs)
CapsFlags | Gst::operator^ (CapsFlags lhs, CapsFlags rhs)
CapsFlags | Gst::operator~ (CapsFlags flags)
CapsFlags& | Gst::operator|= (CapsFlags& lhs, CapsFlags rhs)
CapsFlags& | Gst::operator&= (CapsFlags& lhs, CapsFlags rhs)
CapsFlags& | Gst::operator^= (CapsFlags& lhs, CapsFlags 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)
DiscovererSerializeFlags | Gst::operator| (DiscovererSerializeFlags lhs, DiscovererSerializeFlags rhs)
DiscovererSerializeFlags | Gst::operator& (DiscovererSerializeFlags lhs, DiscovererSerializeFlags rhs)
DiscovererSerializeFlags | Gst::operator^ (DiscovererSerializeFlags lhs, DiscovererSerializeFlags rhs)
DiscovererSerializeFlags | Gst::operator~ (DiscovererSerializeFlags flags)
DiscovererSerializeFlags& | Gst::operator|= (DiscovererSerializeFlags& lhs, DiscovererSerializeFlags rhs)
DiscovererSerializeFlags& | Gst::operator&= (DiscovererSerializeFlags& lhs, DiscovererSerializeFlags rhs)
DiscovererSerializeFlags& | Gst::operator^= (DiscovererSerializeFlags& lhs, DiscovererSerializeFlags 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)
StateChange | Gst::operator| (StateChange lhs, StateChange rhs)
StateChange | Gst::operator& (StateChange lhs, StateChange rhs)
StateChange | Gst::operator^ (StateChange lhs, StateChange rhs)
StateChange | Gst::operator~ (StateChange flags)
StateChange& | Gst::operator|= (StateChange& lhs, StateChange rhs)
StateChange& | Gst::operator&= (StateChange& lhs, StateChange rhs)
StateChange& | Gst::operator^= (StateChange& lhs, StateChange 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)
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)
StreamFlags | Gst::operator| (StreamFlags lhs, StreamFlags rhs)
StreamFlags | Gst::operator& (StreamFlags lhs, StreamFlags rhs)
StreamFlags | Gst::operator^ (StreamFlags lhs, StreamFlags rhs)
StreamFlags | Gst::operator~ (StreamFlags flags)
StreamFlags& | Gst::operator|= (StreamFlags& lhs, StreamFlags rhs)
StreamFlags& | Gst::operator&= (StreamFlags& lhs, StreamFlags rhs)
StreamFlags& | Gst::operator^= (StreamFlags& lhs, StreamFlags 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)
PluginFlags | Gst::operator| (PluginFlags lhs, PluginFlags rhs)
PluginFlags | Gst::operator& (PluginFlags lhs, PluginFlags rhs)
PluginFlags | Gst::operator^ (PluginFlags lhs, PluginFlags rhs)
PluginFlags | Gst::operator~ (PluginFlags flags)
PluginFlags& | Gst::operator|= (PluginFlags& lhs, PluginFlags rhs)
PluginFlags& | Gst::operator&= (PluginFlags& lhs, PluginFlags rhs)
PluginFlags& | Gst::operator^= (PluginFlags& lhs, PluginFlags rhs)
QueryType | Gst::operator| (QueryType lhs, QueryType rhs)
QueryType | Gst::operator& (QueryType lhs, QueryType rhs)
QueryType | Gst::operator^ (QueryType lhs, QueryType rhs)
QueryType | Gst::operator~ (QueryType flags)
QueryType& | Gst::operator|= (QueryType& lhs, QueryType rhs)
QueryType& | Gst::operator&= (QueryType& lhs, QueryType rhs)
QueryType& | Gst::operator^= (QueryType& lhs, QueryType rhs)
QueryTypeFlags | Gst::operator| (QueryTypeFlags lhs, QueryTypeFlags rhs)
QueryTypeFlags | Gst::operator& (QueryTypeFlags lhs, QueryTypeFlags rhs)
QueryTypeFlags | Gst::operator^ (QueryTypeFlags lhs, QueryTypeFlags rhs)
QueryTypeFlags | Gst::operator~ (QueryTypeFlags flags)
QueryTypeFlags& | Gst::operator|= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
QueryTypeFlags& | Gst::operator&= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
QueryTypeFlags& | Gst::operator^= (QueryTypeFlags& lhs, QueryTypeFlags rhs)
SchedulingFlags | Gst::operator| (SchedulingFlags lhs, SchedulingFlags rhs)
SchedulingFlags | Gst::operator& (SchedulingFlags lhs, SchedulingFlags rhs)
SchedulingFlags | Gst::operator^ (SchedulingFlags lhs, SchedulingFlags rhs)
SchedulingFlags | Gst::operator~ (SchedulingFlags flags)
SchedulingFlags& | Gst::operator|= (SchedulingFlags& lhs, SchedulingFlags rhs)
SchedulingFlags& | Gst::operator&= (SchedulingFlags& lhs, SchedulingFlags rhs)
SchedulingFlags& | Gst::operator^= (SchedulingFlags& lhs, SchedulingFlags rhs)
SeekFlags | Gst::operator| (SeekFlags lhs, SeekFlags rhs)
SeekFlags | Gst::operator& (SeekFlags lhs, SeekFlags rhs)
SeekFlags | Gst::operator^ (SeekFlags lhs, SeekFlags rhs)
SeekFlags | Gst::operator~ (SeekFlags flags)
SeekFlags& | Gst::operator|= (SeekFlags& lhs, SeekFlags rhs)
SeekFlags& | Gst::operator&= (SeekFlags& lhs, SeekFlags rhs)
SeekFlags& | Gst::operator^= (SeekFlags& lhs, SeekFlags rhs)
VideoChromaSite | Gst::operator| (VideoChromaSite lhs, VideoChromaSite rhs)
VideoChromaSite | Gst::operator& (VideoChromaSite lhs, VideoChromaSite rhs)
VideoChromaSite | Gst::operator^ (VideoChromaSite lhs, VideoChromaSite rhs)
VideoChromaSite | Gst::operator~ (VideoChromaSite flags)
VideoChromaSite& | Gst::operator|= (VideoChromaSite& lhs, VideoChromaSite rhs)
VideoChromaSite& | Gst::operator&= (VideoChromaSite& lhs, VideoChromaSite rhs)
VideoChromaSite& | Gst::operator^= (VideoChromaSite& lhs, VideoChromaSite rhs)
VideoChromaFlags | Gst::operator| (VideoChromaFlags lhs, VideoChromaFlags rhs)
VideoChromaFlags | Gst::operator& (VideoChromaFlags lhs, VideoChromaFlags rhs)
VideoChromaFlags | Gst::operator^ (VideoChromaFlags lhs, VideoChromaFlags rhs)
VideoChromaFlags | Gst::operator~ (VideoChromaFlags flags)
VideoChromaFlags& | Gst::operator|= (VideoChromaFlags& lhs, VideoChromaFlags rhs)
VideoChromaFlags& | Gst::operator&= (VideoChromaFlags& lhs, VideoChromaFlags rhs)
VideoChromaFlags& | Gst::operator^= (VideoChromaFlags& lhs, VideoChromaFlags rhs)
VideoFormatFlags | Gst::operator| (VideoFormatFlags lhs, VideoFormatFlags rhs)
VideoFormatFlags | Gst::operator& (VideoFormatFlags lhs, VideoFormatFlags rhs)
VideoFormatFlags | Gst::operator^ (VideoFormatFlags lhs, VideoFormatFlags rhs)
VideoFormatFlags | Gst::operator~ (VideoFormatFlags flags)
VideoFormatFlags& | Gst::operator|= (VideoFormatFlags& lhs, VideoFormatFlags rhs)
VideoFormatFlags& | Gst::operator&= (VideoFormatFlags& lhs, VideoFormatFlags rhs)
VideoFormatFlags& | Gst::operator^= (VideoFormatFlags& lhs, VideoFormatFlags rhs)
VideoPackFlags | Gst::operator| (VideoPackFlags lhs, VideoPackFlags rhs)
VideoPackFlags | Gst::operator& (VideoPackFlags lhs, VideoPackFlags rhs)
VideoPackFlags | Gst::operator^ (VideoPackFlags lhs, VideoPackFlags rhs)
VideoPackFlags | Gst::operator~ (VideoPackFlags flags)
VideoPackFlags& | Gst::operator|= (VideoPackFlags& lhs, VideoPackFlags rhs)
VideoPackFlags& | Gst::operator&= (VideoPackFlags& lhs, VideoPackFlags rhs)
VideoPackFlags& | Gst::operator^= (VideoPackFlags& lhs, VideoPackFlags rhs)
VideoFrameFlags | Gst::operator| (VideoFrameFlags lhs, VideoFrameFlags rhs)
VideoFrameFlags | Gst::operator& (VideoFrameFlags lhs, VideoFrameFlags rhs)
VideoFrameFlags | Gst::operator^ (VideoFrameFlags lhs, VideoFrameFlags rhs)
VideoFrameFlags | Gst::operator~ (VideoFrameFlags flags)
VideoFrameFlags& | Gst::operator|= (VideoFrameFlags& lhs, VideoFrameFlags rhs)
VideoFrameFlags& | Gst::operator&= (VideoFrameFlags& lhs, VideoFrameFlags rhs)
VideoFrameFlags& | Gst::operator^= (VideoFrameFlags& lhs, VideoFrameFlags rhs)
VideoBufferFlags | Gst::operator| (VideoBufferFlags lhs, VideoBufferFlags rhs)
VideoBufferFlags | Gst::operator& (VideoBufferFlags lhs, VideoBufferFlags rhs)
VideoBufferFlags | Gst::operator^ (VideoBufferFlags lhs, VideoBufferFlags rhs)
VideoBufferFlags | Gst::operator~ (VideoBufferFlags flags)
VideoBufferFlags& | Gst::operator|= (VideoBufferFlags& lhs, VideoBufferFlags rhs)
VideoBufferFlags& | Gst::operator&= (VideoBufferFlags& lhs, VideoBufferFlags rhs)
VideoBufferFlags& | Gst::operator^= (VideoBufferFlags& lhs, VideoBufferFlags rhs)
VideoFrameMapFlags | Gst::operator| (VideoFrameMapFlags lhs, VideoFrameMapFlags rhs)
VideoFrameMapFlags | Gst::operator& (VideoFrameMapFlags lhs, VideoFrameMapFlags rhs)
VideoFrameMapFlags | Gst::operator^ (VideoFrameMapFlags lhs, VideoFrameMapFlags rhs)
VideoFrameMapFlags | Gst::operator~ (VideoFrameMapFlags flags)
VideoFrameMapFlags& | Gst::operator|= (VideoFrameMapFlags& lhs, VideoFrameMapFlags rhs)
VideoFrameMapFlags& | Gst::operator&= (VideoFrameMapFlags& lhs, VideoFrameMapFlags rhs)
VideoFrameMapFlags& | Gst::operator^= (VideoFrameMapFlags& lhs, VideoFrameMapFlags rhs)
VideoMultiviewFlags | Gst::operator| (VideoMultiviewFlags lhs, VideoMultiviewFlags rhs)
VideoMultiviewFlags | Gst::operator& (VideoMultiviewFlags lhs, VideoMultiviewFlags rhs)
VideoMultiviewFlags | Gst::operator^ (VideoMultiviewFlags lhs, VideoMultiviewFlags rhs)
VideoMultiviewFlags | Gst::operator~ (VideoMultiviewFlags flags)
VideoMultiviewFlags& | Gst::operator|= (VideoMultiviewFlags& lhs, VideoMultiviewFlags rhs)
VideoMultiviewFlags& | Gst::operator&= (VideoMultiviewFlags& lhs, VideoMultiviewFlags rhs)
VideoMultiviewFlags& | Gst::operator^= (VideoMultiviewFlags& lhs, VideoMultiviewFlags rhs)
VideoFlags | Gst::operator| (VideoFlags lhs, VideoFlags rhs)
VideoFlags | Gst::operator& (VideoFlags lhs, VideoFlags rhs)
VideoFlags | Gst::operator^ (VideoFlags lhs, VideoFlags rhs)
VideoFlags | Gst::operator~ (VideoFlags flags)
VideoFlags& | Gst::operator|= (VideoFlags& lhs, VideoFlags rhs)
VideoFlags& | Gst::operator&= (VideoFlags& lhs, VideoFlags rhs)
VideoFlags& | Gst::operator^= (VideoFlags& lhs, VideoFlags rhs)

## Detailed Description

## Enumeration Type Documentation

## ◆ AudioBaseSinkDiscontReason

enum Gst::AudioBaseSinkDiscontReason

Different possible reasons for discontinuities. This enum is useful for the custom slave method.

Enumerator
AUDIO_BASE_SINK_DISCONT_REASON_NO_DISCONT | No discontinuity occurred.
AUDIO_BASE_SINK_DISCONT_REASON_NEW_CAPS | New caps are set, causing renegotiotion.
AUDIO_BASE_SINK_DISCONT_REASON_FLUSH | Samples have been flushed.
AUDIO_BASE_SINK_DISCONT_REASON_SYNC_LATENCY | Sink was synchronized to the estimated latency (occurs during initialization).
AUDIO_BASE_SINK_DISCONT_REASON_ALIGNMENT | Aligning buffers failed because the timestamps are too discontinuous.
AUDIO_BASE_SINK_DISCONT_REASON_DEVICE_FAILURE | Audio output device experienced and recovered from an error but introduced latency in the process (see also Gst::AudioBaseSink::report_device_failure()).

## ◆ AudioBaseSinkSlaveMethod

enum Gst::AudioBaseSinkSlaveMethod

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

Enumerator
AUDIO_BASE_SINK_SLAVE_RESAMPLE | Resample to match the master clock.
AUDIO_BASE_SINK_SLAVE_SKEW | Adjust playout pointer when master clock drifts too much.
AUDIO_BASE_SINK_SLAVE_NONE | No adjustment is done.
AUDIO_BASE_SINK_SLAVE_CUSTOM | Use custom clock slaving algorithm (Since: 1.6).

## ◆ AudioBaseSrcSlaveMethod

enum Gst::AudioBaseSrcSlaveMethod

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

Enumerator
AUDIO_BASE_SRC_SLAVE_RESAMPLE | Resample to match the master clock.
AUDIO_BASE_SRC_SLAVE_RETIMESTAMP | Retimestamp output buffers with master clock time.
AUDIO_BASE_SRC_SLAVE_SKEW | Adjust capture pointer when master clock drifts too much.
AUDIO_BASE_SRC_SLAVE_NONE | No adjustment is done.

## ◆ AudioCdSrcMode

enum Gst::AudioCdSrcMode

Mode in which the CD audio source operates. Influences timestamping, EOS handling and seeking.

Enumerator
AUDIO_CD_SRC_MODE_NORMAL | Each single track is a stream.
AUDIO_CD_SRC_MODE_CONTINUOUS | The entire disc is a single stream.

## ◆ AudioChannelPosition

enum Gst::AudioChannelPosition

Audio channel positions.

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

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

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

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

Enumerator
AUDIO_CHANNEL_POSITION_NONE | Used for position-less channels, e.g. from a sound card that records 1024 channels; mutually exclusive with any other channel position.
AUDIO_CHANNEL_POSITION_MONO | Mono without direction; can only be used with 1 channel.
AUDIO_CHANNEL_POSITION_INVALID | Invalid position.
AUDIO_CHANNEL_POSITION_FRONT_LEFT | Front left.
AUDIO_CHANNEL_POSITION_FRONT_RIGHT | Front right.
AUDIO_CHANNEL_POSITION_FRONT_CENTER | Front center.
AUDIO_CHANNEL_POSITION_LFE1 | Low-frequency effects 1 (subwoofer).
AUDIO_CHANNEL_POSITION_REAR_LEFT | Rear left.
AUDIO_CHANNEL_POSITION_REAR_RIGHT | Rear right.
AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER | Front left of center.
AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER | Front right of center.
AUDIO_CHANNEL_POSITION_REAR_CENTER | Rear center.
AUDIO_CHANNEL_POSITION_LFE2 | Low-frequency effects 2 (subwoofer).
AUDIO_CHANNEL_POSITION_SIDE_LEFT | Side left.
AUDIO_CHANNEL_POSITION_SIDE_RIGHT | Side right.
AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT | Top front left.
AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT | Top front right.
AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER | Top front center.
AUDIO_CHANNEL_POSITION_TOP_CENTER | Top center.
AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT | Top rear left.
AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT | Top rear right.
AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT | Top side right.
AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT | Top rear right.
AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER | Top rear center.
AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER | Bottom front center.
AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT | Bottom front left.
AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT | Bottom front right.
AUDIO_CHANNEL_POSITION_WIDE_LEFT | Wide left (between front left and side left).
AUDIO_CHANNEL_POSITION_WIDE_RIGHT | Wide right (between front right and side right).
AUDIO_CHANNEL_POSITION_SURROUND_LEFT | Surround left (between rear left and side left).
AUDIO_CHANNEL_POSITION_SURROUND_RIGHT | Surround right (between rear right and side right).

## ◆ AudioFlags

enum Gst::AudioFlags

Extra audio flags

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

Enumerator
AUDIO_FLAG_NONE | No valid flag.
AUDIO_FLAG_UNPOSITIONED | The position array explicitly contains unpositioned channels.

## ◆ AudioFormat

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.

## ◆ AudioFormatFlags

enum Gst::AudioFormatFlags

The different audio flags that a format info can have.

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

Enumerator
AUDIO_FORMAT_FLAG_INTEGER | Integer samples.
AUDIO_FORMAT_FLAG_FLOAT | Float samples.
AUDIO_FORMAT_FLAG_SIGNED | Signed samples.
AUDIO_FORMAT_FLAG_COMPLEX | Complex layout.
AUDIO_FORMAT_FLAG_UNPACK | The format can be used in Gst::AudioFormatUnpack and Gst::AudioFormatPack functions.

## ◆ AudioLayout

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.

## ◆ AudioPackFlags

enum Gst::AudioPackFlags

The different flags that can be used when packing and unpacking.

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

Enumerator
AUDIO_PACK_FLAG_NONE | No flag.
AUDIO_PACK_FLAG_TRUNCATE_RANGE | When the source has a smaller depth than the target format, set the least significant bits of the target to 0. This is likely sightly faster but less accurate. When this flag is not specified, the most significant bits of the source are duplicated in the least significant bits of the destination.

## ◆ AudioRingBufferFormatType

enum Gst::AudioRingBufferFormatType

The format of the samples in the ringbuffer.

Enumerator
AUDIO_RING_BUFFER_FORMAT_TYPE_RAW | Samples in linear or float.
AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW | Samples in mulaw.
AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW | Samples in alaw.
AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM | Samples in ima adpcm.
AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG | Samples in mpeg audio (but not AAC) format.
AUDIO_RING_BUFFER_FORMAT_TYPE_GSM | Samples in gsm format.
AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958 | Samples in IEC958 frames (e.g. AC3).
AUDIO_RING_BUFFER_FORMAT_TYPE_AC3 | Samples in AC3 format.
AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3 | Samples in EAC3 format.
AUDIO_RING_BUFFER_FORMAT_TYPE_DTS | Samples in DTS format.
AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC | Samples in MPEG-2 AAC format.
AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC | Samples in MPEG-4 AAC format.

## ◆ AudioRingBufferState

enum Gst::AudioRingBufferState

The state of the ringbuffer.

Enumerator
AUDIO_RING_BUFFER_STATE_STOPPED | The ringbuffer is stopped.
AUDIO_RING_BUFFER_STATE_PAUSED | The ringbuffer is paused.
AUDIO_RING_BUFFER_STATE_STARTED | The ringbuffer is started.
AUDIO_RING_BUFFER_STATE_ERROR | The ringbuffer has encountered an error after it has been started, e.g. because the device was disconnected (Since 1.2).

## ◆ AutoplugSelectResult

enum Gst::AutoplugSelectResult

Enumerator
AUTOPLUG_SELECT_TRY |
AUTOPLUG_SELECT_EXPOSE |
AUTOPLUG_SELECT_SKIP |

## ◆ BaseSrcFlags

enum Gst::BaseSrcFlags

The Gst::Element flags that a basesrc element may have.

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

Enumerator
BASE_SRC_FLAG_STARTING | Has source is starting.
BASE_SRC_FLAG_STARTED | Has source been started.
BASE_SRC_FLAG_LAST | Offset to define more flags.

## ◆ BinFlags

enum Gst::BinFlags

GstBinFlags are a set of flags specific to bins. Most are set/used internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro, and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET ().

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

Enumerator
BIN_FLAG_NO_RESYNC | Don't resync a state change when elements are added or linked in the bin (Since 1.0.5).
BIN_FLAG_LAST | The last enum in the series of flags for bins. Derived classes can use this as first value in a list of flags.

## ◆ BufferCopyFlags

enum Gst::BufferCopyFlags

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

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

Enumerator
BUFFER_COPY_NONE | Copy nothing.
BUFFER_COPY_FLAGS | Flag indicating that buffer flags should be copied.
BUFFER_COPY_TIMESTAMPS | Flag indicating that buffer pts, dts, duration, offset and offset_end should be copied.
BUFFER_COPY_META | Flag indicating that buffer meta should be copied.
BUFFER_COPY_MEMORY | Flag indicating that buffer memory should be reffed and appended to already existing memory. Unless the memory is marked as NO_SHARE, no actual copy of the memory is made but it is simply reffed. Add GST_BUFFER_COPY_DEEP to force a real copy.
BUFFER_COPY_MERGE | Flag indicating that buffer memory should be merged.
BUFFER_COPY_DEEP | Flag indicating that memory should always be copied instead of reffed (Since 1.2).

## ◆ BufferFlags

enum Gst::BufferFlags

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

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

Enumerator
BUFFER_FLAG_LIVE | The buffer is live data and should be discarded in the PAUSED state.
BUFFER_FLAG_DECODE_ONLY | The buffer contains data that should be dropped because it will be clipped against the segment boundaries or because it does not contain data that should be shown to the user.
BUFFER_FLAG_DISCONT | The buffer marks a data discontinuity in the stream. This typically occurs after a seek or a dropped buffer from a live or network source.
BUFFER_FLAG_RESYNC | The buffer timestamps might have a discontinuity and this buffer is a good point to resynchronize.
BUFFER_FLAG_CORRUPTED | The buffer data is corrupted.
BUFFER_FLAG_MARKER | The buffer contains a media specific marker. for video this is typically the end of a frame boundary, for audio this is usually the start of a talkspurt.
BUFFER_FLAG_HEADER | The buffer contains header information that is needed to decode the following data.
BUFFER_FLAG_GAP | The buffer has been created to fill a gap in the stream and contains media neutral data (elements can switch to optimized code path that ignores the buffer content).
BUFFER_FLAG_DROPPABLE | The buffer can be dropped without breaking the stream, for example to reduce bandwidth.
BUFFER_FLAG_DELTA_UNIT | This unit cannot be decoded independently.
BUFFER_FLAG_TAG_MEMORY | This flag is set when memory of the buffer is added/removed.
BUFFER_FLAG_SYNC_AFTER | Elements which write to disk or permanent storage should ensure the data is synced after writing the contents of this buffer. (Since 1.6).
BUFFER_FLAG_LAST | Additional media specific flags can be added starting from this flag.

## ◆ BufferingMode

enum Gst::BufferingMode

The different types of buffering methods.

Enumerator
BUFFERING_STREAM | A small amount of data is buffered.
BUFFERING_DOWNLOAD | The stream is being downloaded.
BUFFERING_TIMESHIFT | The stream is being downloaded in a ringbuffer.
BUFFERING_LIVE | The stream is a live stream.

## ◆ BusFlags

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.

## ◆ BusSyncReply

enum Gst::BusSyncReply

The result values for a GstBusSyncHandler.

Enumerator
BUS_DROP | Drop the message.
BUS_PASS | Pass the message to the async queue.
BUS_ASYNC | Pass message to async queue, continue if message is handled.

## ◆ CapsFlags

enum Gst::CapsFlags

Extra flags for a caps.

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

Enumerator
CAPS_FLAG_ANY | Caps has no specific content, but can contain anything.

## ◆ CapsIntersectMode

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.

## ◆ ClockEntryType

enum Gst::ClockEntryType

The type of the clock entry

Enumerator
CLOCK_ENTRY_SINGLE | A single shot timeout.
CLOCK_ENTRY_PERIODIC | A periodic timeout request.

## ◆ ClockFlags

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_NEEDS_STARTUP_SYNC | Clock needs to be synced before it can be used (Since 1.6).
CLOCK_FLAG_LAST | Subclasses can add additional flags starting from this flag.

## ◆ ClockReturn

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.

## ◆ ColorBalanceType

enum Gst::ColorBalanceType

An enumeration indicating whether an element implements color balancing operations in software or in dedicated hardware. In general, dedicated hardware implementations (such as those provided by xvimagesink) are preferred.

Enumerator
COLOR_BALANCE_HARDWARE | Color balance is implemented with dedicated hardware.
COLOR_BALANCE_SOFTWARE | Color balance is implemented via software processing.

## ◆ DiscovererResult

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.

## ◆ DiscovererSerializeFlags

enum Gst::DiscovererSerializeFlags

You can use these flags to control what is serialized by Gst::Discoverer::info_to_variant()

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

Enumerator
DISCOVERER_SERIALIZE_BASIC | Serialize only basic information, excluding caps, tags and miscellaneous information.
DISCOVERER_SERIALIZE_CAPS | Serialize the caps for each stream.
DISCOVERER_SERIALIZE_TAGS | Serialize the tags for each stream.
DISCOVERER_SERIALIZE_MISC | Serialize miscellaneous information for each stream.
DISCOVERER_SERIALIZE_ALL | Serialize all the available info, including caps, tags and miscellaneous information.

## ◆ ElementFlags

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.

## ◆ EventType

enum Gst::EventType

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

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

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

Enumerator
EVENT_UNKNOWN | Unknown event.
EVENT_FLUSH_START | Start a flush operation. This event clears all data from the pipeline and unblock all streaming threads.
EVENT_FLUSH_STOP | Stop a flush operation. This event resets the running-time of the pipeline.
EVENT_STREAM_START | Event to mark the start of a new stream. Sent before any other serialized event and only sent at the start of a new stream, not after flushing seeks.
EVENT_CAPS | Gst::Caps event. Notify the pad of a new media type.
EVENT_SEGMENT | A new media segment follows in the dataflow. The segment events contains information for clipping buffers and converting buffer timestamps to running-time and stream-time.
EVENT_TAG | A new set of metadata tags has been found in the stream.
EVENT_BUFFERSIZE | Notification of buffering requirements. Currently not used yet.
EVENT_SINK_MESSAGE | An event that sinks turn into a message. Used to send messages that should be emitted in sync with rendering.
EVENT_EOS | End-Of-Stream. No more data is to be expected to follow without a SEGMENT event.
EVENT_TOC | An event which indicates that a new table of contents (TOC) was found or updated.
EVENT_PROTECTION | An event which indicates that new or updated encryption information has been found in the stream.
EVENT_SEGMENT_DONE | Marks the end of a segment playback.
EVENT_GAP | Marks a gap in the datastream.
EVENT_QOS | A quality message. Used to indicate to upstream elements that the downstream elements should adjust their processing rate.
EVENT_SEEK | A request for a new playback position and rate.
EVENT_NAVIGATION | Navigation events are usually used for communicating user requests, such as mouse or keyboard movements, to upstream elements.
EVENT_LATENCY | Notification of new latency adjustment. Sinks will use the latency information to adjust their synchronisation.
EVENT_STEP | A request for stepping through the media. Sinks will usually execute the step operation.
EVENT_RECONFIGURE | A request for upstream renegotiating caps and reconfiguring.
EVENT_TOC_SELECT | A request for a new playback position based on TOC entry's UID.
EVENT_CUSTOM_UPSTREAM | Upstream custom event.
EVENT_CUSTOM_DOWNSTREAM | Downstream custom event that travels in the data flow.
EVENT_CUSTOM_DOWNSTREAM_OOB | Custom out-of-band downstream event.
EVENT_CUSTOM_DOWNSTREAM_STICKY | Custom sticky downstream event.
EVENT_CUSTOM_BOTH | Custom upstream or downstream event. In-band when travelling downstream.
EVENT_CUSTOM_BOTH_OOB | Custom upstream or downstream out-of-band event.

## ◆ EventTypeFlags

enum Gst::EventTypeFlags

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

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

Enumerator
EVENT_TYPE_UPSTREAM | Set if the event can travel upstream.
EVENT_TYPE_DOWNSTREAM | Set if the event can travel downstream.
EVENT_TYPE_SERIALIZED | Set if the event should be serialized with data flow.
EVENT_TYPE_STICKY | Set if the event is sticky on the pads.
EVENT_TYPE_STICKY_MULTI | Multiple sticky events can be on a pad, each identified by the event name.

## ◆ FlowReturn

enum Gst::FlowReturn

The result of passing data to a pad.

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

Enumerator
FLOW_CUSTOM_SUCCESS_2 | Pre-defined custom success code.
FLOW_CUSTOM_SUCCESS_1 | Pre-defined custom success code (define your custom success code to this to avoid compiler warnings).
FLOW_CUSTOM_SUCCESS | Elements can use values starting from this (and higher) to define custom success codes.
FLOW_OK | Data passing was ok.
FLOW_NOT_LINKED | Pad is not linked.
FLOW_FLUSHING | Pad is flushing.
FLOW_EOS | Pad is EOS.
FLOW_NOT_NEGOTIATED | Pad is not negotiated.
FLOW_ERROR | Some (fatal) error occurred. Element generating this error should post an error message with more details.
FLOW_NOT_SUPPORTED | This operation is not supported.
FLOW_CUSTOM_ERROR | Elements can use values starting from this (and lower) to define custom error codes.
FLOW_CUSTOM_ERROR_1 | Pre-defined custom error code (define your custom error code to this to avoid compiler warnings).
FLOW_CUSTOM_ERROR_2 | Pre-defined custom error code.

## ◆ IteratorItem

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.

## ◆ IteratorResult

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.

## ◆ LockFlags

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.

## ◆ MapFlags

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.

## ◆ MemoryFlags

enum Gst::MemoryFlags

Flags for wrapped memory.

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

Enumerator
MEMORY_FLAG_READONLY | Memory is readonly. It is not allowed to map the memory with Gst::MAP_WRITE.
MEMORY_FLAG_NO_SHARE | Memory must not be shared. Copies will have to be made when this memory needs to be shared between buffers.
MEMORY_FLAG_ZERO_PREFIXED | The memory prefix is filled with 0 bytes.
MEMORY_FLAG_ZERO_PADDED | The memory padding is filled with 0 bytes.
MEMORY_FLAG_PHYSICALLY_CONTIGUOUS | The memory is physically contiguous. (Since 1.2).
MEMORY_FLAG_NOT_MAPPABLE | The memory can't be mapped via Gst::Memory::map() without any preconditions. (Since 1.2).
MEMORY_FLAG_LAST | First flag that can be used for custom purposes.

## ◆ MiniObjectFlags

enum Gst::MiniObjectFlags

Flags for the mini object

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

Enumerator
MINI_OBJECT_FLAG_LOCKABLE | The object can be locked and unlocked with Gst::MiniObject::lock() and Gst::MiniObject::unlock().
MINI_OBJECT_FLAG_LOCK_READONLY | The object is permanently locked in READONLY mode. Only read locks can be performed on the object.
MINI_OBJECT_FLAG_LAST | First flag that can be used by subclasses.

## ◆ MultiHandleSinkClientStatus

enum Gst::MultiHandleSinkClientStatus

Enumerator
CLIENT_STATUS_OK |
CLIENT_STATUS_CLOSED |
CLIENT_STATUS_REMOVED |
CLIENT_STATUS_SLOW |
CLIENT_STATUS_ERROR |
CLIENT_STATUS_DUPLICATE |
CLIENT_STATUS_FLUSHING |

## ◆ MultiHandleSinkSyncMethod

enum Gst::MultiHandleSinkSyncMethod

Enumerator
SYNC_METHOD_LATEST |
SYNC_METHOD_NEXT_KEYFRAME |
SYNC_METHOD_LATEST_KEYFRAME |
SYNC_METHOD_BURST |
SYNC_METHOD_BURST_KEYFRAME |
SYNC_METHOD_BURST_WITH_KEYFRAME |

## ◆ NavigationCommand

enum Gst::NavigationCommand

A set of commands that may be issued to an element providing the Gst::Navigation interface. The available commands can be queried via the gst_navigation_query_new_commands() query.

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

Enumerator
NAVIGATION_COMMAND_INVALID | An invalid command entry.
NAVIGATION_COMMAND_MENU1 | Execute navigation menu command 1. For DVD, this enters the DVD root menu, or exits back to the title from the menu.
NAVIGATION_COMMAND_MENU2 | Execute navigation menu command 2. For DVD, this jumps to the DVD title menu.
NAVIGATION_COMMAND_MENU3 | Execute navigation menu command 3. For DVD, this jumps into the DVD root menu.
NAVIGATION_COMMAND_MENU4 | Execute navigation menu command 4. For DVD, this jumps to the Subpicture menu.
NAVIGATION_COMMAND_MENU5 | Execute navigation menu command 5. For DVD, the jumps to the audio menu.
NAVIGATION_COMMAND_MENU6 | Execute navigation menu command 6. For DVD, this jumps to the angles menu.
NAVIGATION_COMMAND_MENU7 | Execute navigation menu command 7. For DVD, this jumps to the chapter menu.
NAVIGATION_COMMAND_LEFT | Select the next button to the left in a menu, if such a button exists.
NAVIGATION_COMMAND_RIGHT | Select the next button to the right in a menu, if such a button exists.
NAVIGATION_COMMAND_UP | Select the button above the current one in a menu, if such a button exists.
NAVIGATION_COMMAND_DOWN | Select the button below the current one in a menu, if such a button exists.
NAVIGATION_COMMAND_ACTIVATE | Activate (click) the currently selected button in a menu, if such a button exists.
NAVIGATION_COMMAND_PREV_ANGLE | Switch to the previous angle in a multiangle feature.
NAVIGATION_COMMAND_NEXT_ANGLE | Switch to the next angle in a multiangle feature.

## ◆ NavigationEventType

enum Gst::NavigationEventType

Enum values for the various events that an element implementing the GstNavigation interface might send up the pipeline.

Enumerator
NAVIGATION_EVENT_INVALID | Returned from gst_navigation_event_get_type() when the passed event is not a navigation event.
NAVIGATION_EVENT_KEY_PRESS | A key press event. Use gst_navigation_event_parse_key_event() to extract the details from the event.
NAVIGATION_EVENT_KEY_RELEASE | A key release event. Use gst_navigation_event_parse_key_event() to extract the details from the event.
NAVIGATION_EVENT_MOUSE_BUTTON_PRESS | A mouse button press event. Use gst_navigation_event_parse_mouse_button_event() to extract the details from the event.
NAVIGATION_EVENT_MOUSE_BUTTON_RELEASE | A mouse button release event. Use gst_navigation_event_parse_mouse_button_event() to extract the details from the event.
NAVIGATION_EVENT_MOUSE_MOVE | A mouse movement event. Use gst_navigation_event_parse_mouse_move_event() to extract the details from the event.
NAVIGATION_EVENT_COMMAND | A navigation command event. Use gst_navigation_event_parse_command() to extract the details from the event.

## ◆ NavigationMessageType

enum Gst::NavigationMessageType

A set of notifications that may be received on the bus when navigation related status changes.

Enumerator
NAVIGATION_MESSAGE_INVALID | Returned from gst_navigation_message_get_type() when the passed message is not a navigation message.
NAVIGATION_MESSAGE_MOUSE_OVER | Sent when the mouse moves over or leaves a clickable region of the output, such as a DVD menu button.
NAVIGATION_MESSAGE_COMMANDS_CHANGED | Sent when the set of available commands changes and should re-queried by interested applications.
NAVIGATION_MESSAGE_ANGLES_CHANGED | Sent when display angles in a multi-angle feature (such as a multiangle DVD) change - either angles have appeared or disappeared.
NAVIGATION_MESSAGE_EVENT | Sent when a navigation event was not handled by any element in the pipeline (Since 1.6).

## ◆ NavigationQueryType

enum Gst::NavigationQueryType

Tyoes of navigation interface queries.

Enumerator
NAVIGATION_QUERY_INVALID | Invalid query.
NAVIGATION_QUERY_COMMANDS | Command query.
NAVIGATION_QUERY_ANGLES | Viewing angle query.

## ◆ ObjectFlags

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.

## ◆ PadDirection

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.

## ◆ PadFlags

enum Gst::PadFlags

Pad state flags

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

Enumerator
PAD_FLAG_BLOCKED | Is dataflow on a pad blocked.
PAD_FLAG_FLUSHING | Is pad flushing.
PAD_FLAG_EOS | Is pad in EOS state.
PAD_FLAG_BLOCKING | Is pad currently blocking on a buffer or event.
PAD_FLAG_NEED_PARENT | Ensure that there is a parent object before calling into the pad callbacks.
PAD_FLAG_NEED_RECONFIGURE | The pad should be reconfigured/renegotiated. The flag has to be unset manually after reconfiguration happened.
PAD_FLAG_PENDING_EVENTS | The pad has pending events.
PAD_FLAG_FIXED_CAPS | The pad is using fixed caps. This means that once the caps are set on the pad, the default caps query function will only return those caps.
PAD_FLAG_PROXY_CAPS | The default event and query handler will forward all events and queries to the internally linked pads instead of discarding them.
PAD_FLAG_PROXY_ALLOCATION | The default query handler will forward allocation queries to the internally linked pads instead of discarding them.
PAD_FLAG_PROXY_SCHEDULING | The default query handler will forward scheduling queries to the internally linked pads instead of discarding them.
PAD_FLAG_ACCEPT_INTERSECT | The default accept-caps handler will check it the caps intersect the query-caps result instead of checking for a subset. This is interesting for parsers that can accept incompletely specified caps.
PAD_FLAG_ACCEPT_TEMPLATE | The default accept-caps handler will use the template pad caps instead of query caps to compare with the accept caps. Use this in combination with Gst::PAD_FLAG_ACCEPT_INTERSECT. (Since 1.6).
PAD_FLAG_LAST | Offset to define more flags.

## ◆ PadLinkCheck

enum Gst::PadLinkCheck

The amount of checking to be done when linking pads. GST_PAD_LINK_CHECK_CAPS and GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are specified, expensive but safe GST_PAD_LINK_CHECK_CAPS are performed.

<warning> Only disable some of the checks if you are 100% certain you know the link will not fail because of hierarchy/caps compatibility failures. If uncertain, use the default checks (Gst::PAD_LINK_CHECK_DEFAULT) or the regular methods for linking the pads. </warning>

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

Enumerator
PAD_LINK_CHECK_NOTHING | Don't check hierarchy or caps compatibility.
PAD_LINK_CHECK_HIERARCHY | Check the pads have same parents/grandparents. Could be omitted if it is already known that the two elements that own the pads are in the same bin.
PAD_LINK_CHECK_TEMPLATE_CAPS | Check if the pads are compatible by using their template caps. This is much faster than GST_PAD_LINK_CHECK_CAPS, but would be unsafe e.g. if one pad has Gst::CAPS_ANY.
PAD_LINK_CHECK_CAPS | Check if the pads are compatible by comparing the caps returned by Gst::Pad::query_caps().
PAD_LINK_CHECK_DEFAULT | The default checks done when linking pads (i.e. the ones used by Gst::Pad::link()).

## ◆ PadLinkReturn

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.

## ◆ PadMode

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.

## ◆ PadPresence

enum Gst::PadPresence

Indicates when this pad will become available.

Enumerator
PAD_ALWAYS | The pad is always available.
PAD_SOMETIMES | The pad will become available depending on the media stream.
PAD_REQUEST | The pad is only available on request with Gst::Element::request_pad().

## ◆ PadProbeReturn

enum Gst::PadProbeReturn

Different return values for the Gst::SlotPadProbe.

Enumerator
PAD_PROBE_DROP | Drop data in data probes. For push mode this means that the data item is not sent downstream. For pull mode, it means that the data item is not passed upstream. In both cases, no more probes are called and Gst::FLOW_OK or `true` is returned to the caller.
PAD_PROBE_OK | Normal probe return value. This leaves the probe in place, and defers decisions about dropping or passing data to other probes, if any. If there are no other probes, the default behaviour for the probe type applies (block for blocking probes, and pass for non-blocking probes).
PAD_PROBE_REMOVE | Remove this probe.
PAD_PROBE_PASS | Pass the data item in the block probe and block on the next item.
PAD_PROBE_HANDLED | Data has been handled in the probe and will not be forwarded further. For events and buffers this is the same behaviour as GST_PAD_PROBE_DROP (except that in this case you need to unref the buffer or event yourself). For queries it will also return `true` to the caller. The probe can also modify the Gst::FlowReturn value by using the Gst::PAD_PROBE_INFO_FLOW_RETURN() accessor. Note that the resulting query must contain valid entries. Since gstreamermm 1.6:

## ◆ PadProbeType

enum Gst::PadProbeType

The different probing types that can occur. When either one of GST_PAD_PROBE_TYPE_IDLE or GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a blocking probe.

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

Enumerator
PAD_PROBE_TYPE_INVALID | Invalid probe type.
PAD_PROBE_TYPE_IDLE | Probe idle pads and block.
PAD_PROBE_TYPE_BLOCK | Probe and block pads.
PAD_PROBE_TYPE_BUFFER | Probe buffers.
PAD_PROBE_TYPE_BUFFER_LIST | Probe buffer lists.
PAD_PROBE_TYPE_EVENT_DOWNSTREAM | Probe downstream events.
PAD_PROBE_TYPE_EVENT_UPSTREAM | Probe upstream events.
PAD_PROBE_TYPE_EVENT_FLUSH | Probe flush events. This probe has to be explicitly enabled and is not included in the @ GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM or @ GST_PAD_PROBE_TYPE_EVENT_UPSTREAM probe types.
PAD_PROBE_TYPE_QUERY_DOWNSTREAM | Probe downstream queries.
PAD_PROBE_TYPE_QUERY_UPSTREAM | Probe upstream queries.
PAD_PROBE_TYPE_PUSH | Probe push.
PAD_PROBE_TYPE_PULL | Probe pull.
PAD_PROBE_TYPE_BLOCKING | Probe and block at the next opportunity, at data flow or when idle.
PAD_PROBE_TYPE_DATA_DOWNSTREAM | Probe downstream data (buffers, buffer lists, and events).
PAD_PROBE_TYPE_DATA_UPSTREAM | Probe upstream data (events).
PAD_PROBE_TYPE_DATA_BOTH | Probe upstream and downstream data (buffers, buffer lists, and events).
PAD_PROBE_TYPE_BLOCK_DOWNSTREAM | Probe and block downstream data (buffers, buffer lists, and events).
PAD_PROBE_TYPE_BLOCK_UPSTREAM | Probe and block upstream data (events).
PAD_PROBE_TYPE_EVENT_BOTH | Probe upstream and downstream events.
PAD_PROBE_TYPE_QUERY_BOTH | Probe upstream and downstream queries.
PAD_PROBE_TYPE_ALL_BOTH | Probe upstream events and queries and downstream buffers, buffer lists, events and queries.
PAD_PROBE_TYPE_SCHEDULING | Probe push and pull.

## ◆ PadTemplateFlags

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.

## ◆ PlayFlags

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 |
PLAY_FLAG_FORCE_FILTERS |

## ◆ PluginDependencyFlags

enum Gst::PluginDependencyFlags

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

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

Enumerator
PLUGIN_DEPENDENCY_FLAG_NONE | No special flags.
PLUGIN_DEPENDENCY_FLAG_RECURSE | Recurse into subdirectories.
PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY | Use paths argument only if none of the environment variables is set.
PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX | Interpret filename argument as filter suffix and check all matching files in the directory.
PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX | Interpret filename argument as filter prefix and check all matching files in the directory. Since gstreamermm 1.8:

## ◆ PluginFlags

enum Gst::PluginFlags

The plugin loading state

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

Enumerator
PLUGIN_FLAG_CACHED | Temporarily loaded plugins.
PLUGIN_FLAG_BLACKLISTED | The plugin won't be scanned (again).

## ◆ ProgressType

enum Gst::ProgressType

The type of a Gst::MESSAGE_PROGRESS. The progress messages inform the application of the status of asynchronous tasks.

Enumerator
PROGRESS_TYPE_START | A new task started.
PROGRESS_TYPE_CONTINUE | A task completed and a new one continues.
PROGRESS_TYPE_COMPLETE | A task completed.
PROGRESS_TYPE_CANCELED | A task was canceled.
PROGRESS_TYPE_ERROR | A task caused an error. An error message is also posted on the bus.

## ◆ QOSType

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 upstream elements are producing data too quickly and the element can't keep up processing the data. Upstream should reduce their production rate. This type is also used when buffers arrive early or in time.
QOS_TYPE_UNDERFLOW | The QoS event type that is produced when upstream elements are producing data too slowly and need to speed up their production rate.
QOS_TYPE_THROTTLE | The QoS event type that is produced when the application enabled throttling to limit the data rate.

## ◆ QueryType

enum Gst::QueryType

Standard predefined Query types

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

Enumerator
QUERY_UNKNOWN | Unknown query type.
QUERY_POSITION | Current position in stream.
QUERY_DURATION | Total duration of the stream.
QUERY_LATENCY | Latency of stream.
QUERY_JITTER | Current jitter of stream.
QUERY_RATE | Current rate of the stream.
QUERY_SEEKING | Seeking capabilities.
QUERY_SEGMENT | Segment start/stop positions.
QUERY_CONVERT | Convert values between formats.
QUERY_FORMATS | Query supported formats for convert.
QUERY_BUFFERING | Query available media for efficient seeking.
QUERY_CUSTOM | A custom application or element defined query.
QUERY_URI | Query the URI of the source or sink.
QUERY_ALLOCATION | The buffer allocation properties.
QUERY_SCHEDULING | The scheduling properties.
QUERY_ACCEPT_CAPS | The accept caps query.
QUERY_CAPS | The caps query.
QUERY_DRAIN | Wait till all serialized data is consumed downstream.
QUERY_CONTEXT | Query the pipeline-local context from downstream or upstream (since 1.2).

## ◆ QueryTypeFlags

enum Gst::QueryTypeFlags

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

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

Enumerator
QUERY_TYPE_UPSTREAM | Set if the query can travel upstream.
QUERY_TYPE_DOWNSTREAM | Set if the query can travel downstream.
QUERY_TYPE_SERIALIZED | Set if the query should be serialized with data flow.

## ◆ Rank

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.

## ◆ Result

enum Gst::SDP::Result

Return values for the SDP functions.

Enumerator
SDP_OK | A successful return value.
SDP_EINVAL | A function was given invalid parameters.

## ◆ SchedulingFlags

enum Gst::SchedulingFlags

The different scheduling flags.

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

Enumerator
SCHEDULING_FLAG_SEEKABLE | If seeking is possible.
SCHEDULING_FLAG_SEQUENTIAL | If sequential access is recommended.
SCHEDULING_FLAG_BANDWIDTH_LIMITED | If bandwidth is limited and buffering possible (since 1.2).

## ◆ SeekFlags

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 emitted 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_TRICKMODE flag can be used to instruct decoders and demuxers to adjust the playback rate by skipping frames. This can improve performance and decrease CPU usage because not all frames need to be decoded.

Beyond that, the Gst::SEEK_FLAG_TRICKMODE_KEY_UNITS flag can be used to request that decoders skip all frames except key units, and Gst::SEEK_FLAG_TRICKMODE_NO_AUDIO flags can be used to request that audio decoders do no decoding at all, and simple output silence.

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 Gst::SEEK_FLAG_KEY_UNIT is specified, the relevant location is a keyframe. If both flags are specified, the nearest of these locations will be selected. If none are specified, the implementation is free to select whichever it wants.

The before and after here are in running time, so when playing backwards, the next location refers to the one that will played in next, and not the one that is located after in the actual source stream.

Also see part-seeking.txt in the GStreamer design documentation for more details on the meaning of these flags and the behaviour expected of elements that handle them.

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

Enumerator
SEEK_FLAG_NONE | No flag.
SEEK_FLAG_FLUSH | Flush pipeline.
SEEK_FLAG_ACCURATE | Accurate position is requested, this might be considerably slower for some formats.
SEEK_FLAG_KEY_UNIT | Seek to the nearest keyframe. This might be faster but less accurate.
SEEK_FLAG_SEGMENT | Perform a segment seek.
SEEK_FLAG_TRICKMODE | When doing fast forward or fast reverse playback, allow elements to skip frames instead of generating all frames. (Since 1.6).
SEEK_FLAG_SKIP | Deprecated backward compatibility flag, replaced by Gst::SEEK_FLAG_TRICKMODE.
SEEK_FLAG_SNAP_BEFORE | Go to a location before the requested position, if Gst::SEEK_FLAG_KEY_UNIT this means the keyframe at or before the requested position the one at or before the seek target.
SEEK_FLAG_SNAP_AFTER | Go to a location after the requested position, if Gst::SEEK_FLAG_KEY_UNIT this means the keyframe at of after the requested position.
SEEK_FLAG_SNAP_NEAREST | Go to a position near the requested position, if Gst::SEEK_FLAG_KEY_UNIT this means the keyframe closest to the requested position, if both keyframes are at an equal distance, behaves like Gst::SEEK_FLAG_SNAP_BEFORE.
SEEK_FLAG_TRICKMODE_KEY_UNITS | When doing fast forward or fast reverse playback, request that elements only decode keyframes and skip all other content, for formats that have keyframes. (Since 1.6).
SEEK_FLAG_TRICKMODE_NO_AUDIO | When doing fast forward or fast reverse playback, request that audio decoder elements skip decoding and output only gap events or silence. (Since 1.6).

## ◆ State

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 `nullptr` state or initial state of an element.
STATE_READY | The element is ready to go to PAUSED.
STATE_PAUSED | The element is PAUSED, it is ready to accept and process data. Sink elements however only accept one buffer and then block.
STATE_PLAYING | The element is PLAYING, the Gst::Clock is running and the data is flowing.

## ◆ StateChange

enum Gst::StateChange

These are the different state changes an element goes through. Gst::STATE_NULL ⇒ Gst::STATE_PLAYING is called an upwards state change and Gst::STATE_PLAYING ⇒ Gst::STATE_NULL a downwards state change.

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

Enumerator
STATE_CHANGE_NULL_TO_READY | State change from `nullptr` to READY. The element must check if the resources it needs are available. Device sinks and -sources typically try to probe the device to constrain their caps. The element opens the device (in case feature need to be probed).
STATE_CHANGE_READY_TO_PAUSED | State change from READY to PAUSED. The element pads are activated in order to receive data in PAUSED. Streaming threads are started. Some elements might need to return Gst::STATE_CHANGE_ASYNC and complete the state change when they have enough information. It is a requirement for sinks to return Gst::STATE_CHANGE_ASYNC and complete the state change when they receive the first buffer or Gst::EVENT_EOS (preroll). Sinks also block the dataflow when in PAUSED. A pipeline resets the running_time to 0. Live sources return Gst::STATE_CHANGE_NO_PREROLL and don't generate data.
STATE_CHANGE_PAUSED_TO_PLAYING | State change from PAUSED to PLAYING. Most elements ignore this state change. The pipeline selects a Gst::Clock and distributes this to all the children before setting them to PLAYING. This means that it is only allowed to synchronize on the Gst::Clock in the PLAYING state. The pipeline uses the Gst::Clock and the running_time to calculate the base_time. The base_time is distributed to all children when performing the state change. Sink elements stop blocking on the preroll buffer or event and start rendering the data. Sinks can post Gst::MESSAGE_EOS in the PLAYING state. It is not allowed to post Gst::MESSAGE_EOS when not in the PLAYING state. While streaming in PAUSED or PLAYING elements can create and remove sometimes pads. Live sources start generating data and return Gst::STATE_CHANGE_SUCCESS.
STATE_CHANGE_PLAYING_TO_PAUSED | State change from PLAYING to PAUSED. Most elements ignore this state change. The pipeline calculates the running_time based on the last selected Gst::Clock and the base_time. It stores this information to continue playback when going back to the PLAYING state. Sinks unblock any Gst::Clock wait calls. When a sink does not have a pending buffer to play, it returns Gst::STATE_CHANGE_ASYNC from this state change and completes the state change when it receives a new buffer or an Gst::EVENT_EOS. Any queued Gst::MESSAGE_EOS items are removed since they will be reposted when going back to the PLAYING state. The EOS messages are queued in Gst::Bin containers. Live sources stop generating data and return Gst::STATE_CHANGE_NO_PREROLL.
STATE_CHANGE_PAUSED_TO_READY | State change from PAUSED to READY. Sinks unblock any waits in the preroll. Elements unblock any waits on devices Chain or get_range functions return Gst::FLOW_FLUSHING. The element pads are deactivated so that streaming becomes impossible and all streaming threads are stopped. The sink forgets all negotiated formats Elements remove all sometimes pads
STATE_CHANGE_READY_TO_NULL | State change from READY to `nullptr`. Elements close devices Elements reset any internal state.

## ◆ StateChangeReturn

enum Gst::StateChangeReturn

The possible return values from a state change function such as Gst::Element::set_state(). Only GST_STATE_CHANGE_FAILURE is a real failure.

Enumerator
STATE_CHANGE_FAILURE | The state change failed.
STATE_CHANGE_SUCCESS | The state change succeeded.
STATE_CHANGE_ASYNC | The state change will happen asynchronously.
STATE_CHANGE_NO_PREROLL | The state change succeeded but the element cannot produce data in Gst::STATE_PAUSED. This typically happens with live sources.

## ◆ StreamFlags

enum Gst::StreamFlags

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

Enumerator
STREAM_FLAG_NONE | This stream has no special attributes.
STREAM_FLAG_SPARSE | This stream is a sparse stream (e.g. a subtitle stream), data may flow only in irregular intervals with large gaps in between.
STREAM_FLAG_SELECT | This stream should be selected by default. This flag may be used by demuxers to signal that a stream should be selected by default in a playback scenario.
STREAM_FLAG_UNSELECT | This stream should not be selected by default. This flag may be used by demuxers to signal that a stream should not be selected by default in a playback scenario, but only if explicitly selected by the user (e.g. an audio track for the hard of hearing or a director's commentary track).

## ◆ StreamStatusType

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.

## ◆ StreamVolumeFormat

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

## ◆ StructureChangeType

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.

## ◆ TagFlag

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.

## ◆ TagMergeMode

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.

## ◆ TaskState

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.

## ◆ TocEntryType

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

## ◆ TocLoopType

enum Gst::TocLoopType

How a Gst::TocEntry should be repeated. By default, entries are played a single time.

Enumerator
TOC_LOOP_NONE | Single forward playback.
TOC_LOOP_FORWARD | Repeat forward.
TOC_LOOP_REVERSE | Repeat backward.
TOC_LOOP_PING_PONG | Repeat forward and backward.

## ◆ TocScope

enum Gst::TocScope

The scope of a TOC.

Enumerator
TOC_SCOPE_GLOBAL | Global TOC representing all selectable options (this is what applications are usually interested in).
TOC_SCOPE_CURRENT | TOC for the currently active/selected stream (this is a TOC representing the current stream from start to EOS, and is what a TOC writer / muxer is usually interested in; it will usually be a subset of the global TOC, e.g. just the chapters of the current title, or the chapters selected for playback from the current title).

## ◆ TypeFindProbability

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.

## ◆ URIError

enum Gst::URIError

Different URI-related errors that can occur.

Enumerator
URI_ERROR_UNSUPPORTED_PROTOCOL | The protocol is not supported.
URI_ERROR_BAD_URI | There was a problem with the URI.
URI_ERROR_BAD_STATE | Could not set or change the URI because the URI handler was in a state where that is not possible or not permitted.
URI_ERROR_BAD_REFERENCE | There was a problem with the entity that the URI references.

## ◆ URIType

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.

## ◆ VideoBufferFlags

enum Gst::VideoBufferFlags

Additional video buffer flags. These flags can potentially be used on any buffers carrying video data - even encoded data.

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

Enumerator
VIDEO_BUFFER_FLAG_INTERLACED | If the Gst::Buffer is interlaced. In mixed interlace-mode, this flags specifies if the frame is interlaced or progressive.
VIDEO_BUFFER_FLAG_TFF | If the Gst::Buffer is interlaced, then the first field in the video frame is the top field. If unset, the bottom field is first.
VIDEO_BUFFER_FLAG_RFF | If the Gst::Buffer is interlaced, then the first field (as defined by the Gst::VIDEO_BUFFER_TFF flag setting) is repeated.
VIDEO_BUFFER_FLAG_ONEFIELD | If the Gst::Buffer is interlaced, then only the first field (as defined by the Gst::VIDEO_BUFFER_TFF flag setting) is to be displayed.
VIDEO_BUFFER_FLAG_MULTIPLE_VIEW | The Gst::Buffer contains one or more specific views, such as left or right eye view. This flags is set on any buffer that contains non-mono content - even for streams that contain only a single viewpoint. In mixed mono / non-mono streams, the absense of the flag marks mono buffers.
VIDEO_BUFFER_FLAG_FIRST_IN_BUNDLE | When conveying stereo/multiview content with frame-by-frame methods, this flag marks the first buffer in a bundle of frames that belong together.
VIDEO_BUFFER_FLAG_LAST | Offset to define more flags.

## ◆ VideoChromaFlags

enum Gst::VideoChromaFlags

Extra flags that influence the result from gst_video_chroma_resample_new().

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

Enumerator
VIDEO_CHROMA_FLAG_NONE | No flags.
VIDEO_CHROMA_FLAG_INTERLACED | The input is interlaced.

## ◆ VideoChromaMethod

enum Gst::VideoChromaMethod

Different subsampling and upsampling methods

Enumerator
VIDEO_CHROMA_METHOD_NEAREST | Duplicates the chroma samples when upsampling and drops when subsampling.
VIDEO_CHROMA_METHOD_LINEAR | Uses linear interpolation to reconstruct missing chroma and averaging to subsample.

## ◆ VideoChromaSite

enum Gst::VideoChromaSite

Various Chroma sitings.

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

Enumerator
VIDEO_CHROMA_SITE_UNKNOWN | Unknown cositing.
VIDEO_CHROMA_SITE_NONE | No cositing.
VIDEO_CHROMA_SITE_H_COSITED | Chroma is horizontally cosited.
VIDEO_CHROMA_SITE_V_COSITED | Chroma is vertically cosited.
VIDEO_CHROMA_SITE_ALT_LINE | Choma samples are sited on alternate lines.
VIDEO_CHROMA_SITE_COSITED | Chroma samples cosited with luma samples.
VIDEO_CHROMA_SITE_JPEG | Jpeg style cositing, also for mpeg1 and mjpeg.
VIDEO_CHROMA_SITE_MPEG2 | Mpeg2 style cositing.
VIDEO_CHROMA_SITE_DV | DV style cositing.

## ◆ VideoFlags

enum Gst::VideoFlags

Extra video flags

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

Enumerator
VIDEO_FLAG_NONE | No flags.
VIDEO_FLAG_VARIABLE_FPS | A variable fps is selected, fps_n and fps_d denote the maximum fps of the video.
VIDEO_FLAG_PREMULTIPLIED_ALPHA | Each color has been scaled by the alpha value.

## ◆ VideoFormat

enum Gst::VideoFormat

Enumerator
VIDEO_FORMAT_UNKNOWN |
VIDEO_FORMAT_ENCODED |
VIDEO_FORMAT_I420 |
VIDEO_FORMAT_YV12 |
VIDEO_FORMAT_YUY2 |
VIDEO_FORMAT_UYVY |
VIDEO_FORMAT_AYUV |
VIDEO_FORMAT_RGBx |
VIDEO_FORMAT_BGRx |
VIDEO_FORMAT_xRGB |
VIDEO_FORMAT_xBGR |
VIDEO_FORMAT_RGBA |
VIDEO_FORMAT_BGRA |
VIDEO_FORMAT_ARGB |
VIDEO_FORMAT_ABGR |
VIDEO_FORMAT_RGB |
VIDEO_FORMAT_BGR |
VIDEO_FORMAT_Y41B |
VIDEO_FORMAT_Y42B |
VIDEO_FORMAT_YVYU |
VIDEO_FORMAT_Y444 |
VIDEO_FORMAT_v210 |
VIDEO_FORMAT_v216 |
VIDEO_FORMAT_NV12 |
VIDEO_FORMAT_NV21 |
VIDEO_FORMAT_GRAY8 |
VIDEO_FORMAT_GRAY16_BE |
VIDEO_FORMAT_GRAY16_LE |
VIDEO_FORMAT_v308 |
VIDEO_FORMAT_RGB16 |
VIDEO_FORMAT_BGR16 |
VIDEO_FORMAT_RGB15 |
VIDEO_FORMAT_BGR15 |
VIDEO_FORMAT_UYVP |
VIDEO_FORMAT_A420 |
VIDEO_FORMAT_RGB8P |
VIDEO_FORMAT_YUV9 |
VIDEO_FORMAT_YVU9 |
VIDEO_FORMAT_IYU1 |
VIDEO_FORMAT_ARGB64 |
VIDEO_FORMAT_AYUV64 |
VIDEO_FORMAT_r210 |
VIDEO_FORMAT_I420_10BE |
VIDEO_FORMAT_I420_10LE |
VIDEO_FORMAT_I422_10BE |
VIDEO_FORMAT_I422_10LE |
VIDEO_FORMAT_Y444_10BE |
VIDEO_FORMAT_Y444_10LE |
VIDEO_FORMAT_GBR |
VIDEO_FORMAT_GBR_10BE |
VIDEO_FORMAT_GBR_10LE |
VIDEO_FORMAT_NV16 |
VIDEO_FORMAT_NV24 |
VIDEO_FORMAT_NV12_64Z32 |
VIDEO_FORMAT_A420_10BE |
VIDEO_FORMAT_A420_10LE |
VIDEO_FORMAT_A422_10BE |
VIDEO_FORMAT_A422_10LE |
VIDEO_FORMAT_A444_10BE |
VIDEO_FORMAT_A444_10LE |
VIDEO_FORMAT_NV61 |

## ◆ VideoFormatFlags

enum Gst::VideoFormatFlags

The different video flags that a format info can have.

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

Enumerator
VIDEO_FORMAT_FLAG_YUV | The video format is YUV, components are numbered 0=Y, 1=U, 2=V.
VIDEO_FORMAT_FLAG_RGB | The video format is RGB, components are numbered 0=R, 1=G, 2=B.
VIDEO_FORMAT_FLAG_GRAY | The video is gray, there is one gray component with index 0.
VIDEO_FORMAT_FLAG_ALPHA | The video format has an alpha components with the number 3.
VIDEO_FORMAT_FLAG_LE | The video format has data stored in little endianness.
VIDEO_FORMAT_FLAG_PALETTE | The video format has a palette. The palette is stored in the second plane and indexes are stored in the first plane.
VIDEO_FORMAT_FLAG_COMPLEX | The video format has a complex layout that can't be described with the usual information in the Gst::VideoFormatInfo.
VIDEO_FORMAT_FLAG_UNPACK | This format can be used in a Gst::VideoFormatUnpack and Gst::VideoFormatPack function.
VIDEO_FORMAT_FLAG_TILED | The format is tiled, there is tiling information in the last plane.

## ◆ VideoFrameFlags

enum Gst::VideoFrameFlags

Extra video frame flags

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

Enumerator
VIDEO_FRAME_FLAG_NONE | No flags.
VIDEO_FRAME_FLAG_INTERLACED | The video frame is interlaced. In mixed interlace-mode, this flag specifies if the frame is interlaced or progressive.
VIDEO_FRAME_FLAG_TFF | The video frame has the top field first.
VIDEO_FRAME_FLAG_RFF | The video frame has the repeat flag.
VIDEO_FRAME_FLAG_ONEFIELD | The video frame has one field.
VIDEO_FRAME_FLAG_MULTIPLE_VIEW | The video contains one or more non-mono views.
VIDEO_FRAME_FLAG_FIRST_IN_BUNDLE | The video frame is the first in a set of corresponding views provided as sequential frames.

## ◆ VideoFrameMapFlags

enum Gst::VideoFrameMapFlags

Additional mapping flags for Gst::VideoFrame::map().

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

Enumerator
VIDEO_FRAME_MAP_FLAG_NO_REF | Don't take another reference of the buffer and store it in the GstVideoFrame. This makes sure that the buffer stays writable while the frame is mapped, but requires that the buffer reference stays valid until the frame is unmapped again.
VIDEO_FRAME_MAP_FLAG_LAST | Offset to define more flags.

## ◆ VideoInterlaceMode

enum Gst::VideoInterlaceMode

The possible values of the Gst::VideoInterlaceMode describing the interlace mode of the stream.

Enumerator
VIDEO_INTERLACE_MODE_PROGRESSIVE | All frames are progressive.
VIDEO_INTERLACE_MODE_INTERLEAVED | 2 fields are interleaved in one video frame. Extra buffer flags describe the field order.
VIDEO_INTERLACE_MODE_MIXED | Frames contains both interlaced and progressive video, the buffer flags describe the frame and fields.
VIDEO_INTERLACE_MODE_FIELDS | 2 fields are stored in one buffer, use the frame ID to get access to the required field. For multiview (the 'views' property > 1) the fields of view N can be found at frame ID (N * 2) and (N * 2) + 1. Each field has only half the amount of lines as noted in the height property. This mode requires multiple GstVideoMeta metadata to describe the fields.

## ◆ VideoMultiviewFlags

enum Gst::VideoMultiviewFlags

GstVideoMultiviewFlags are used to indicate extra properties of a stereo/multiview stream beyond the frame layout and buffer mapping that is conveyed in the Gst::MultiviewMode.

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

Enumerator
VIDEO_MULTIVIEW_FLAGS_NONE | No flags.
VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST | For stereo streams, the normal arrangement of left and right views is reversed.
VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED | The left view is vertically mirrored.
VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED | The left view is horizontally mirrored.
VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED | The right view is vertically mirrored.
VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED | The right view is horizontally mirrored.
VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT | For frame-packed multiview modes, indicates that the individual views have been encoded with half the true width or height and should be scaled back up for display. This flag is used for overriding input layout interpretation by adjusting pixel-aspect-ratio. For side-by-side, column interleaved or checkerboard packings, the pixel width will be doubled. For row interleaved and top-bottom encodings, pixel height will be doubled.
VIDEO_MULTIVIEW_FLAGS_MIXED_MONO | The video stream contains both mono and multiview portions, signalled on each buffer by the absence or presence of the GST_VIDEO_BUFFER_FLAG_MULTIPLE_VIEW buffer flag.

## ◆ VideoMultiviewFramePacking

enum Gst::VideoMultiviewFramePacking

Gst::VideoMultiviewFramePacking represents the subset of Gst::VideoMultiviewMode values that can be applied to any video frame without needing extra metadata. It can be used by elements that provide a property to override the multiview interpretation of a video stream when the video doesn't contain any markers.

This enum is used (for example) on playbin, to re-interpret a played video stream as a stereoscopic video. The individual enum values are equivalent to and have the same value as the matching Gst::VideoMultiviewMode.

Enumerator
VIDEO_MULTIVIEW_FRAME_PACKING_NONE | A special value indicating no frame packing info.
VIDEO_MULTIVIEW_FRAME_PACKING_MONO | All frames are monoscopic.
VIDEO_MULTIVIEW_FRAME_PACKING_LEFT | All frames represent a left-eye view.
VIDEO_MULTIVIEW_FRAME_PACKING_RIGHT | All frames represent a right-eye view.
VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE | Left and right eye views are provided in the left and right half of the frame respectively.
VIDEO_MULTIVIEW_FRAME_PACKING_SIDE_BY_SIDE_QUINCUNX | Left and right eye views are provided in the left and right half of the frame, but have been sampled using quincunx method, with half-pixel offset between the 2 views.
VIDEO_MULTIVIEW_FRAME_PACKING_COLUMN_INTERLEAVED | Alternating vertical columns of pixels represent the left and right eye view respectively.
VIDEO_MULTIVIEW_FRAME_PACKING_ROW_INTERLEAVED | Alternating horizontal rows of pixels represent the left and right eye view respectively.
VIDEO_MULTIVIEW_FRAME_PACKING_TOP_BOTTOM | The top half of the frame contains the left eye, and the bottom half the right eye.
VIDEO_MULTIVIEW_FRAME_PACKING_CHECKERBOARD | Pixels are arranged with alternating pixels representing left and right eye views in a checkerboard fashion.

## ◆ VideoMultiviewMode

enum Gst::VideoMultiviewMode

All possible stereoscopic 3D and multiview representations. In conjunction with Gst::VideoMultiviewFlags, describes how multiview content is being transported in the stream.

Enumerator
VIDEO_MULTIVIEW_MODE_NONE | A special value indicating no multiview information. Used in GstVideoInfo and other places to indicate that no specific multiview handling has been requested or provided. This value is never carried on caps.
VIDEO_MULTIVIEW_MODE_MONO | All frames are monoscopic.
VIDEO_MULTIVIEW_MODE_LEFT | All frames represent a left-eye view.
VIDEO_MULTIVIEW_MODE_RIGHT | All frames represent a right-eye view.
VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE | Left and right eye views are provided in the left and right half of the frame respectively.
VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX | Left and right eye views are provided in the left and right half of the frame, but have been sampled using quincunx method, with half-pixel offset between the 2 views.
VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED | Alternating vertical columns of pixels represent the left and right eye view respectively.
VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED | Alternating horizontal rows of pixels represent the left and right eye view respectively.
VIDEO_MULTIVIEW_MODE_TOP_BOTTOM | The top half of the frame contains the left eye, and the bottom half the right eye.
VIDEO_MULTIVIEW_MODE_CHECKERBOARD | Pixels are arranged with alternating pixels representing left and right eye views in a checkerboard fashion.
VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME | Left and right eye views are provided in separate frames alternately.
VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME | Multiple independent views are provided in separate frames in sequence. This method only applies to raw video buffers at the moment. Specific view identification is via the Gst::VideoMultiviewMeta and Gst::VideoMeta(s) on raw video buffers.
VIDEO_MULTIVIEW_MODE_SEPARATED | Multiple views are provided as separate Gst::Memory framebuffers attached to each Gst::Buffer, described by the Gst::VideoMultiviewMeta and Gst::VideoMeta(s).

## ◆ VideoPackFlags

enum Gst::VideoPackFlags

The different flags that can be used when packing and unpacking.

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

Enumerator
VIDEO_PACK_FLAG_NONE | No flag.
VIDEO_PACK_FLAG_TRUNCATE_RANGE | When the source has a smaller depth than the target format, set the least significant bits of the target to 0. This is likely sightly faster but less accurate. When this flag is not specified, the most significant bits of the source are duplicated in the least significant bits of the destination.
VIDEO_PACK_FLAG_INTERLACED | The source is interlaced. The unpacked format will be interlaced as well with each line containing information from alternating fields. (Since 1.2).

## Function Documentation

## ◆ operator&() [1/42]

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

## ◆ operator&() [2/42]

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

## ◆ operator&() [3/42]

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

## ◆ operator&() [4/42]

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

## ◆ operator&() [5/42]

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

## ◆ operator&() [6/42]

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

## ◆ operator&() [7/42]

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

## ◆ operator&() [8/42]

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

## ◆ operator&() [9/42]

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

## ◆ operator&() [10/42]

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

## ◆ operator&() [11/42]

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

## ◆ operator&() [12/42]

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

## ◆ operator&() [13/42]

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

## ◆ operator&() [14/42]

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

## ◆ operator&() [15/42]

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

## ◆ operator&() [16/42]

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

## ◆ operator&() [17/42]

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

## ◆ operator&() [18/42]

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

## ◆ operator&() [19/42]

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

## ◆ operator&() [20/42]

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

## ◆ operator&() [21/42]

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

## ◆ operator&() [22/42]

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

## ◆ operator&() [23/42]

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

## ◆ operator&() [24/42]

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

## ◆ operator&() [25/42]

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

## ◆ operator&() [26/42]

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

## ◆ operator&() [27/42]

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

## ◆ operator&() [28/42]

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

## ◆ operator&() [29/42]

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

## ◆ operator&() [30/42]

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

## ◆ operator&() [31/42]

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

## ◆ operator&() [32/42]

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

## ◆ operator&() [33/42]

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

## ◆ operator&() [34/42]

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

## ◆ operator&() [35/42]

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

## ◆ operator&() [36/42]

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

## ◆ operator&() [37/42]

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

## ◆ operator&() [38/42]

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

## ◆ operator&() [39/42]

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

## ◆ operator&() [40/42]

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

## ◆ operator&() [41/42]

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

## ◆ operator&() [42/42]

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

## ◆ operator&=() [1/42]

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

## ◆ operator&=() [2/42]

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

## ◆ operator&=() [3/42]

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

## ◆ operator&=() [4/42]

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

## ◆ operator&=() [5/42]

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

## ◆ operator&=() [6/42]

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

## ◆ operator&=() [7/42]

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

## ◆ operator&=() [8/42]

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

## ◆ operator&=() [9/42]

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

## ◆ operator&=() [10/42]

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

## ◆ operator&=() [11/42]

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

## ◆ operator&=() [12/42]

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

## ◆ operator&=() [13/42]

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

## ◆ operator&=() [14/42]

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

## ◆ operator&=() [15/42]

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

## ◆ operator&=() [16/42]

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

## ◆ operator&=() [17/42]

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

## ◆ operator&=() [18/42]

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

## ◆ operator&=() [19/42]

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

## ◆ operator&=() [20/42]

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

## ◆ operator&=() [21/42]

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

## ◆ operator&=() [22/42]

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

## ◆ operator&=() [23/42]

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

## ◆ operator&=() [24/42]

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

## ◆ operator&=() [25/42]

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

## ◆ operator&=() [26/42]

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

## ◆ operator&=() [27/42]

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

## ◆ operator&=() [28/42]

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

## ◆ operator&=() [29/42]

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

## ◆ operator&=() [30/42]

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

## ◆ operator&=() [31/42]

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

## ◆ operator&=() [32/42]

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

## ◆ operator&=() [33/42]

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

## ◆ operator&=() [34/42]

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

## ◆ operator&=() [35/42]

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

## ◆ operator&=() [36/42]

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

## ◆ operator&=() [37/42]

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

## ◆ operator&=() [38/42]

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

## ◆ operator&=() [39/42]

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

## ◆ operator&=() [40/42]

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

## ◆ operator&=() [41/42]

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

## ◆ operator&=() [42/42]

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

## ◆ operator^() [1/42]

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

## ◆ operator^() [2/42]

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

## ◆ operator^() [3/42]

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

## ◆ operator^() [4/42]

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

## ◆ operator^() [5/42]

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

## ◆ operator^() [6/42]

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

## ◆ operator^() [7/42]

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

## ◆ operator^() [8/42]

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

## ◆ operator^() [9/42]

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

## ◆ operator^() [10/42]

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

## ◆ operator^() [11/42]

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

## ◆ operator^() [12/42]

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

## ◆ operator^() [13/42]

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

## ◆ operator^() [14/42]

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

## ◆ operator^() [15/42]

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

## ◆ operator^() [16/42]

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

## ◆ operator^() [17/42]

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

## ◆ operator^() [18/42]

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

## ◆ operator^() [19/42]

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

## ◆ operator^() [20/42]

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

## ◆ operator^() [21/42]

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

## ◆ operator^() [22/42]

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

## ◆ operator^() [23/42]

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

## ◆ operator^() [24/42]

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

## ◆ operator^() [25/42]

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

## ◆ operator^() [26/42]

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

## ◆ operator^() [27/42]

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

## ◆ operator^() [28/42]

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

## ◆ operator^() [29/42]

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

## ◆ operator^() [30/42]

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

## ◆ operator^() [31/42]

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

## ◆ operator^() [32/42]

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

## ◆ operator^() [33/42]

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

## ◆ operator^() [34/42]

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

## ◆ operator^() [35/42]

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

## ◆ operator^() [36/42]

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

## ◆ operator^() [37/42]

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

## ◆ operator^() [38/42]

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

## ◆ operator^() [39/42]

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

## ◆ operator^() [40/42]

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

## ◆ operator^() [41/42]

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

## ◆ operator^() [42/42]

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

## ◆ operator^=() [1/42]

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

## ◆ operator^=() [2/42]

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

## ◆ operator^=() [3/42]

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

## ◆ operator^=() [4/42]

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

## ◆ operator^=() [5/42]

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

## ◆ operator^=() [6/42]

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

## ◆ operator^=() [7/42]

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

## ◆ operator^=() [8/42]

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

## ◆ operator^=() [9/42]

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

## ◆ operator^=() [10/42]

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

## ◆ operator^=() [11/42]

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

## ◆ operator^=() [12/42]

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

## ◆ operator^=() [13/42]

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

## ◆ operator^=() [14/42]

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

## ◆ operator^=() [15/42]

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

## ◆ operator^=() [16/42]

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

## ◆ operator^=() [17/42]

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

## ◆ operator^=() [18/42]

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

## ◆ operator^=() [19/42]

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

## ◆ operator^=() [20/42]

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

## ◆ operator^=() [21/42]

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

## ◆ operator^=() [22/42]

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

## ◆ operator^=() [23/42]

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

## ◆ operator^=() [24/42]

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

## ◆ operator^=() [25/42]

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

## ◆ operator^=() [26/42]

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

## ◆ operator^=() [27/42]

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

## ◆ operator^=() [28/42]

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

## ◆ operator^=() [29/42]

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

## ◆ operator^=() [30/42]

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

## ◆ operator^=() [31/42]

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

## ◆ operator^=() [32/42]

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

## ◆ operator^=() [33/42]

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

## ◆ operator^=() [34/42]

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

## ◆ operator^=() [35/42]

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

## ◆ operator^=() [36/42]

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

## ◆ operator^=() [37/42]

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

## ◆ operator^=() [38/42]

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

## ◆ operator^=() [39/42]

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

## ◆ operator^=() [40/42]

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

## ◆ operator^=() [41/42]

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

## ◆ operator^=() [42/42]

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

## ◆ operator|() [1/42]

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

## ◆ operator|() [2/42]

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

## ◆ operator|() [3/42]

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

## ◆ operator|() [4/42]

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

## ◆ operator|() [5/42]

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

## ◆ operator|() [6/42]

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

## ◆ operator|() [7/42]

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

## ◆ operator|() [8/42]

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

## ◆ operator|() [9/42]

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

## ◆ operator|() [10/42]

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

## ◆ operator|() [11/42]

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

## ◆ operator|() [12/42]

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

## ◆ operator|() [13/42]

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

## ◆ operator|() [14/42]

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

## ◆ operator|() [15/42]

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

## ◆ operator|() [16/42]

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

## ◆ operator|() [17/42]

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

## ◆ operator|() [18/42]

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

## ◆ operator|() [19/42]

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

## ◆ operator|() [20/42]

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

## ◆ operator|() [21/42]

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

## ◆ operator|() [22/42]

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

## ◆ operator|() [23/42]

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

## ◆ operator|() [24/42]

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

## ◆ operator|() [25/42]

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

## ◆ operator|() [26/42]

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

## ◆ operator|() [27/42]

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

## ◆ operator|() [28/42]

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

## ◆ operator|() [29/42]

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

## ◆ operator|() [30/42]

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

## ◆ operator|() [31/42]

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

## ◆ operator|() [32/42]

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

## ◆ operator|() [33/42]

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

## ◆ operator|() [34/42]

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

## ◆ operator|() [35/42]

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

## ◆ operator|() [36/42]

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

## ◆ operator|() [37/42]

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

## ◆ operator|() [38/42]

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

## ◆ operator|() [39/42]

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

## ◆ operator|() [40/42]

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

## ◆ operator|() [41/42]

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

## ◆ operator|() [42/42]

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

## ◆ operator|=() [1/42]

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

## ◆ operator|=() [2/42]

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

## ◆ operator|=() [3/42]

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

## ◆ operator|=() [4/42]

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

## ◆ operator|=() [5/42]

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

## ◆ operator|=() [6/42]

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

## ◆ operator|=() [7/42]

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

## ◆ operator|=() [8/42]

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

## ◆ operator|=() [9/42]

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

## ◆ operator|=() [10/42]

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

## ◆ operator|=() [11/42]

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

## ◆ operator|=() [12/42]

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

## ◆ operator|=() [13/42]

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

## ◆ operator|=() [14/42]

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

## ◆ operator|=() [15/42]

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

## ◆ operator|=() [16/42]

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

## ◆ operator|=() [17/42]

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

## ◆ operator|=() [18/42]

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

## ◆ operator|=() [19/42]

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

## ◆ operator|=() [20/42]

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

## ◆ operator|=() [21/42]

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

## ◆ operator|=() [22/42]

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

## ◆ operator|=() [23/42]

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

## ◆ operator|=() [24/42]

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

## ◆ operator|=() [25/42]

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

## ◆ operator|=() [26/42]

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

## ◆ operator|=() [27/42]

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

## ◆ operator|=() [28/42]

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

## ◆ operator|=() [29/42]

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

## ◆ operator|=() [30/42]

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

## ◆ operator|=() [31/42]

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

## ◆ operator|=() [32/42]

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

## ◆ operator|=() [33/42]

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

## ◆ operator|=() [34/42]

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

## ◆ operator|=() [35/42]

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

## ◆ operator|=() [36/42]

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

## ◆ operator|=() [37/42]

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

## ◆ operator|=() [38/42]

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

## ◆ operator|=() [39/42]

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

## ◆ operator|=() [40/42]

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

## ◆ operator|=() [41/42]

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

## ◆ operator|=() [42/42]

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

## ◆ operator~() [1/42]

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

## ◆ operator~() [2/42]

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

## ◆ operator~() [3/42]

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

## ◆ operator~() [4/42]

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

## ◆ operator~() [5/42]

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

## ◆ operator~() [6/42]

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

## ◆ operator~() [7/42]

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

## ◆ operator~() [8/42]

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

## ◆ operator~() [9/42]

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

## ◆ operator~() [10/42]

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

## ◆ operator~() [11/42]

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

## ◆ operator~() [12/42]

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

## ◆ operator~() [13/42]

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

## ◆ operator~() [14/42]

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

## ◆ operator~() [15/42]

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

## ◆ operator~() [16/42]

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

## ◆ operator~() [17/42]

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

## ◆ operator~() [18/42]

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

## ◆ operator~() [19/42]

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

## ◆ operator~() [20/42]

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

## ◆ operator~() [21/42]

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

## ◆ operator~() [22/42]

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

## ◆ operator~() [23/42]

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

## ◆ operator~() [24/42]

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

## ◆ operator~() [25/42]

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

## ◆ operator~() [26/42]

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

## ◆ operator~() [27/42]

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

## ◆ operator~() [28/42]

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

## ◆ operator~() [29/42]

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

## ◆ operator~() [30/42]

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

## ◆ operator~() [31/42]

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

## ◆ operator~() [32/42]

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

## ◆ operator~() [33/42]

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

## ◆ operator~() [34/42]

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

## ◆ operator~() [35/42]

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

## ◆ operator~() [36/42]

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

## ◆ operator~() [37/42]

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

## ◆ operator~() [38/42]

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

## ◆ operator~() [39/42]

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

## ◆ operator~() [40/42]

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

## ◆ operator~() [41/42]

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

## ◆ operator~() [42/42]

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