// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use glib::translate::*;
use glib::value::FromValue;
use glib::value::FromValueOptional;
use glib::value::SetValue;
use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys;
use gst_sys;

bitflags! {
    /// 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 ().
    pub struct BinFlags: u32 {
        /// don't resync a state change when elements are
        ///  added or linked in the bin (Since: 1.0.5)
        const NO_RESYNC = 16384;
        /// Indicates whether the bin can handle elements
        ///  that add/remove source pads at any point in time without
        ///  first posting a no-more-pads signal (Since: 1.10)
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        const STREAMS_AWARE = 32768;
    }
}

#[doc(hidden)]
impl ToGlib for BinFlags {
    type GlibType = gst_sys::GstBinFlags;

    fn to_glib(&self) -> gst_sys::GstBinFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstBinFlags> for BinFlags {
    fn from_glib(value: gst_sys::GstBinFlags) -> BinFlags {
        skip_assert_initialized!();
        BinFlags::from_bits_truncate(value)
    }
}

impl StaticType for BinFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_bin_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for BinFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for BinFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for BinFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// A set of flags that can be provided to the `Buffer::copy_into`
    /// function to specify which items should be copied.
    pub struct BufferCopyFlags: u32 {
        /// flag indicating that buffer flags should be copied
        const FLAGS = 1;
        /// flag indicating that buffer pts, dts,
        ///  duration, offset and offset_end should be copied
        const TIMESTAMPS = 2;
        /// flag indicating that buffer meta should be
        ///  copied
        const META = 4;
        /// 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 `BufferCopyFlags::Deep` to force a real copy.
        const MEMORY = 8;
        /// flag indicating that buffer memory should be
        ///  merged
        const MERGE = 16;
        /// flag indicating that memory should always be
        ///  copied instead of reffed (Since: 1.2)
        const DEEP = 32;
    }
}

#[doc(hidden)]
impl ToGlib for BufferCopyFlags {
    type GlibType = gst_sys::GstBufferCopyFlags;

    fn to_glib(&self) -> gst_sys::GstBufferCopyFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstBufferCopyFlags> for BufferCopyFlags {
    fn from_glib(value: gst_sys::GstBufferCopyFlags) -> BufferCopyFlags {
        skip_assert_initialized!();
        BufferCopyFlags::from_bits_truncate(value)
    }
}

impl StaticType for BufferCopyFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_buffer_copy_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for BufferCopyFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for BufferCopyFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for BufferCopyFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// A set of buffer flags used to describe properties of a `Buffer`.
    #[cfg_attr(feature = "ser_de", derive(Serialize, Deserialize))]
    pub struct BufferFlags: u32 {
        /// the buffer is live data and should be discarded in
        ///  the PAUSED state.
        const LIVE = 16;
        /// 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.
        const DECODE_ONLY = 32;
        /// 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.
        const DISCONT = 64;
        /// the buffer timestamps might have a discontinuity
        ///  and this buffer is a good point to resynchronize.
        const RESYNC = 128;
        /// the buffer data is corrupted.
        const CORRUPTED = 256;
        /// the buffer contains a media specific marker. for
        ///  video this is the end of a frame boundary, for audio
        ///  this is the start of a talkspurt.
        const MARKER = 512;
        /// the buffer contains header information that is
        ///  needed to decode the following data.
        const HEADER = 1024;
        /// 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).
        const GAP = 2048;
        /// the buffer can be dropped without breaking the
        ///  stream, for example to reduce bandwidth.
        const DROPPABLE = 4096;
        /// this unit cannot be decoded independently.
        const DELTA_UNIT = 8192;
        /// this flag is set when memory of the buffer
        ///  is added/removed
        const TAG_MEMORY = 16384;
        /// Elements which write to disk or permanent
        ///  storage should ensure the data is synced after
        ///  writing the contents of this buffer. (Since: 1.6)
        const SYNC_AFTER = 32768;
        /// This buffer is important and should not be dropped.
        ///  This can be used to mark important buffers, e.g. to flag
        ///  RTP packets carrying keyframes or codec setup data for RTP
        ///  Forward Error Correction purposes, or to prevent still video
        ///  frames from being dropped by elements due to QoS. (Since: 1.14)
        #[cfg(any(feature = "v1_14", feature = "dox"))]
        const NON_DROPPABLE = 65536;
    }
}

#[doc(hidden)]
impl ToGlib for BufferFlags {
    type GlibType = gst_sys::GstBufferFlags;

    fn to_glib(&self) -> gst_sys::GstBufferFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstBufferFlags> for BufferFlags {
    fn from_glib(value: gst_sys::GstBufferFlags) -> BufferFlags {
        skip_assert_initialized!();
        BufferFlags::from_bits_truncate(value)
    }
}

impl StaticType for BufferFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_buffer_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for BufferFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for BufferFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for BufferFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Additional flags to control the allocation of a buffer
    pub struct BufferPoolAcquireFlags: u32 {
        /// buffer is keyframe
        const KEY_UNIT = 1;
        /// when the bufferpool is empty, acquire_buffer
        /// will by default block until a buffer is released into the pool again. Setting
        /// this flag makes acquire_buffer return `FlowReturn::Eos` instead of blocking.
        const DONTWAIT = 2;
        /// buffer is discont
        const DISCONT = 4;
    }
}

#[doc(hidden)]
impl ToGlib for BufferPoolAcquireFlags {
    type GlibType = gst_sys::GstBufferPoolAcquireFlags;

    fn to_glib(&self) -> gst_sys::GstBufferPoolAcquireFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstBufferPoolAcquireFlags> for BufferPoolAcquireFlags {
    fn from_glib(value: gst_sys::GstBufferPoolAcquireFlags) -> BufferPoolAcquireFlags {
        skip_assert_initialized!();
        BufferPoolAcquireFlags::from_bits_truncate(value)
    }
}

impl StaticType for BufferPoolAcquireFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_buffer_pool_acquire_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for BufferPoolAcquireFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for BufferPoolAcquireFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for BufferPoolAcquireFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The capabilities of this clock
    pub struct ClockFlags: u32 {
        /// clock can do a single sync timeout request
        const CAN_DO_SINGLE_SYNC = 16;
        /// clock can do a single async timeout request
        const CAN_DO_SINGLE_ASYNC = 32;
        /// clock can do sync periodic timeout requests
        const CAN_DO_PERIODIC_SYNC = 64;
        /// clock can do async periodic timeout callbacks
        const CAN_DO_PERIODIC_ASYNC = 128;
        /// clock's resolution can be changed
        const CAN_SET_RESOLUTION = 256;
        /// clock can be slaved to a master clock
        const CAN_SET_MASTER = 512;
        /// clock needs to be synced before it can be used
        ///  (Since: 1.6)
        const NEEDS_STARTUP_SYNC = 1024;
    }
}

#[doc(hidden)]
impl ToGlib for ClockFlags {
    type GlibType = gst_sys::GstClockFlags;

    fn to_glib(&self) -> gst_sys::GstClockFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstClockFlags> for ClockFlags {
    fn from_glib(value: gst_sys::GstClockFlags) -> ClockFlags {
        skip_assert_initialized!();
        ClockFlags::from_bits_truncate(value)
    }
}

impl StaticType for ClockFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_clock_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ClockFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ClockFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for ClockFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// These are some terminal style flags you can use when creating your
    /// debugging categories to make them stand out in debugging output.
    pub struct DebugColorFlags: u32 {
        /// Use black as foreground color.
        const FG_BLACK = 0;
        /// Use red as foreground color.
        const FG_RED = 1;
        /// Use green as foreground color.
        const FG_GREEN = 2;
        /// Use yellow as foreground color.
        const FG_YELLOW = 3;
        /// Use blue as foreground color.
        const FG_BLUE = 4;
        /// Use magenta as foreground color.
        const FG_MAGENTA = 5;
        /// Use cyan as foreground color.
        const FG_CYAN = 6;
        /// Use white as foreground color.
        const FG_WHITE = 7;
        /// Use black as background color.
        const BG_BLACK = 0;
        /// Use red as background color.
        const BG_RED = 16;
        /// Use green as background color.
        const BG_GREEN = 32;
        /// Use yellow as background color.
        const BG_YELLOW = 48;
        /// Use blue as background color.
        const BG_BLUE = 64;
        /// Use magenta as background color.
        const BG_MAGENTA = 80;
        /// Use cyan as background color.
        const BG_CYAN = 96;
        /// Use white as background color.
        const BG_WHITE = 112;
        /// Make the output bold.
        const BOLD = 256;
        /// Underline the output.
        const UNDERLINE = 512;
    }
}

#[doc(hidden)]
impl ToGlib for DebugColorFlags {
    type GlibType = gst_sys::GstDebugColorFlags;

    fn to_glib(&self) -> gst_sys::GstDebugColorFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstDebugColorFlags> for DebugColorFlags {
    fn from_glib(value: gst_sys::GstDebugColorFlags) -> DebugColorFlags {
        skip_assert_initialized!();
        DebugColorFlags::from_bits_truncate(value)
    }
}

impl StaticType for DebugColorFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_debug_color_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for DebugColorFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for DebugColorFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for DebugColorFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE()
    /// and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS().
    pub struct DebugGraphDetails: u32 {
        /// show caps-name on edges
        const MEDIA_TYPE = 1;
        /// show caps-details on edges
        const CAPS_DETAILS = 2;
        /// show modified parameters on
        ///  elements
        const NON_DEFAULT_PARAMS = 4;
        /// show element states
        const STATES = 8;
        /// show full element parameter values even
        ///  if they are very long
        const FULL_PARAMS = 16;
        /// show all the typical details that one might want
        const ALL = 15;
        /// show all details regardless of how large or
        ///  verbose they make the resulting output
        const VERBOSE = 4294967295;
    }
}

#[doc(hidden)]
impl ToGlib for DebugGraphDetails {
    type GlibType = gst_sys::GstDebugGraphDetails;

    fn to_glib(&self) -> gst_sys::GstDebugGraphDetails {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstDebugGraphDetails> for DebugGraphDetails {
    fn from_glib(value: gst_sys::GstDebugGraphDetails) -> DebugGraphDetails {
        skip_assert_initialized!();
        DebugGraphDetails::from_bits_truncate(value)
    }
}

impl StaticType for DebugGraphDetails {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_debug_graph_details_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for DebugGraphDetails {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for DebugGraphDetails {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for DebugGraphDetails {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The standard flags that an element may have.
    pub struct ElementFlags: u32 {
        /// ignore state changes from parent
        const LOCKED_STATE = 16;
        /// the element is a sink
        const SINK = 32;
        /// the element is a source.
        const SOURCE = 64;
        /// the element can provide a clock
        const PROVIDE_CLOCK = 128;
        /// the element requires a clock
        const REQUIRE_CLOCK = 256;
        /// the element can use an index
        const INDEXABLE = 512;
    }
}

#[doc(hidden)]
impl ToGlib for ElementFlags {
    type GlibType = gst_sys::GstElementFlags;

    fn to_glib(&self) -> gst_sys::GstElementFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstElementFlags> for ElementFlags {
    fn from_glib(value: gst_sys::GstElementFlags) -> ElementFlags {
        skip_assert_initialized!();
        ElementFlags::from_bits_truncate(value)
    }
}

impl StaticType for ElementFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_element_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ElementFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ElementFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for ElementFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Flags for wrapped memory.
    pub struct MemoryFlags: u32 {
        /// memory is readonly. It is not allowed to map the
        /// memory with `MapFlags::Write`.
        const READONLY = 2;
        /// memory must not be shared. Copies will have to be
        /// made when this memory needs to be shared between buffers.
        const NO_SHARE = 16;
        /// the memory prefix is filled with 0 bytes
        const ZERO_PREFIXED = 32;
        /// the memory padding is filled with 0 bytes
        const ZERO_PADDED = 64;
        /// the memory is physically contiguous. (Since: 1.2)
        const PHYSICALLY_CONTIGUOUS = 128;
        /// the memory can't be mapped via `Memory::map` without any preconditions. (Since: 1.2)
        const NOT_MAPPABLE = 256;
    }
}

#[doc(hidden)]
impl ToGlib for MemoryFlags {
    type GlibType = gst_sys::GstMemoryFlags;

    fn to_glib(&self) -> gst_sys::GstMemoryFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstMemoryFlags> for MemoryFlags {
    fn from_glib(value: gst_sys::GstMemoryFlags) -> MemoryFlags {
        skip_assert_initialized!();
        MemoryFlags::from_bits_truncate(value)
    }
}

impl StaticType for MemoryFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_memory_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for MemoryFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for MemoryFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for MemoryFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The standard flags that an gstobject may have.
    pub struct ObjectFlags: u32 {
        /// the object is expected to stay alive even
        /// after `gst_deinit` has been called and so should be ignored by leak
        /// detection tools. (Since: 1.10)
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        const MAY_BE_LEAKED = 1;
    }
}

#[doc(hidden)]
impl ToGlib for ObjectFlags {
    type GlibType = gst_sys::GstObjectFlags;

    fn to_glib(&self) -> gst_sys::GstObjectFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstObjectFlags> for ObjectFlags {
    fn from_glib(value: gst_sys::GstObjectFlags) -> ObjectFlags {
        skip_assert_initialized!();
        ObjectFlags::from_bits_truncate(value)
    }
}

impl StaticType for ObjectFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_object_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ObjectFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ObjectFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for ObjectFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Pad state flags
    pub struct PadFlags: u32 {
        /// is dataflow on a pad blocked
        const BLOCKED = 16;
        /// is pad flushing
        const FLUSHING = 32;
        /// is pad in EOS state
        const EOS = 64;
        /// is pad currently blocking on a buffer or event
        const BLOCKING = 128;
        /// ensure that there is a parent object before calling
        ///  into the pad callbacks.
        const NEED_PARENT = 256;
        /// the pad should be reconfigured/renegotiated.
        ///  The flag has to be unset manually after
        ///  reconfiguration happened.
        const NEED_RECONFIGURE = 512;
        /// the pad has pending events
        const PENDING_EVENTS = 1024;
        /// 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.
        const FIXED_CAPS = 2048;
        /// the default event and query handler will forward
        ///  all events and queries to the internally linked pads
        ///  instead of discarding them.
        const PROXY_CAPS = 4096;
        /// the default query handler will forward
        ///  allocation queries to the internally linked pads
        ///  instead of discarding them.
        const PROXY_ALLOCATION = 8192;
        /// the default query handler will forward
        ///  scheduling queries to the internally linked pads
        ///  instead of discarding them.
        const PROXY_SCHEDULING = 16384;
        /// 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.
        const ACCEPT_INTERSECT = 32768;
        /// 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 `PadFlags::AcceptIntersect`. (Since: 1.6)
        const ACCEPT_TEMPLATE = 65536;
    }
}

#[doc(hidden)]
impl ToGlib for PadFlags {
    type GlibType = gst_sys::GstPadFlags;

    fn to_glib(&self) -> gst_sys::GstPadFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPadFlags> for PadFlags {
    fn from_glib(value: gst_sys::GstPadFlags) -> PadFlags {
        skip_assert_initialized!();
        PadFlags::from_bits_truncate(value)
    }
}

impl StaticType for PadFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_pad_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PadFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PadFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PadFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The amount of checking to be done when linking pads. `PadLinkCheck::Caps`
    /// and `PadLinkCheck::TemplateCaps` are mutually exclusive. If both are
    /// specified, expensive but safe `PadLinkCheck::Caps` are performed.
    ///
    /// > Only disable some of the checks if you are 100% certain you know the link
    /// > will not fail because of hierarchy/caps compatibility failures. If uncertain,
    /// > use the default checks (`PadLinkCheck::Default`) or the regular methods
    /// > for linking the pads.
    pub struct PadLinkCheck: u32 {
        /// 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.
        const HIERARCHY = 1;
        /// Check if the pads are compatible by using
        ///  their template caps. This is much faster than `PadLinkCheck::Caps`, but
        ///  would be unsafe e.g. if one pad has `GST_CAPS_ANY`.
        const TEMPLATE_CAPS = 2;
        /// Check if the pads are compatible by comparing the
        ///  caps returned by `PadExt::query_caps`.
        const CAPS = 4;
        /// Disables pushing a reconfigure event when pads are
        ///  linked.
        const NO_RECONFIGURE = 8;
        /// The default checks done when linking
        ///  pads (i.e. the ones used by `Pad::link`).
        const DEFAULT = 5;
    }
}

#[doc(hidden)]
impl ToGlib for PadLinkCheck {
    type GlibType = gst_sys::GstPadLinkCheck;

    fn to_glib(&self) -> gst_sys::GstPadLinkCheck {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPadLinkCheck> for PadLinkCheck {
    fn from_glib(value: gst_sys::GstPadLinkCheck) -> PadLinkCheck {
        skip_assert_initialized!();
        PadLinkCheck::from_bits_truncate(value)
    }
}

impl StaticType for PadLinkCheck {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_pad_link_check_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PadLinkCheck {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PadLinkCheck {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PadLinkCheck {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The different probing types that can occur. When either one of
    /// `PadProbeType::Idle` or `PadProbeType::Block` is used, the probe will be a
    /// blocking probe.
    pub struct PadProbeType: u32 {
        /// probe idle pads and block while the callback is called
        const IDLE = 1;
        /// probe and block pads
        const BLOCK = 2;
        /// probe buffers
        const BUFFER = 16;
        /// probe buffer lists
        const BUFFER_LIST = 32;
        /// probe downstream events
        const EVENT_DOWNSTREAM = 64;
        /// probe upstream events
        const EVENT_UPSTREAM = 128;
        /// probe flush events. This probe has to be
        ///  explicitly enabled and is not included in the
        ///  @`PadProbeType::EventDownstream` or
        ///  @`PadProbeType::EventUpstream` probe types.
        const EVENT_FLUSH = 256;
        /// probe downstream queries
        const QUERY_DOWNSTREAM = 512;
        /// probe upstream queries
        const QUERY_UPSTREAM = 1024;
        /// probe push
        const PUSH = 4096;
        /// probe pull
        const PULL = 8192;
        /// probe and block at the next opportunity, at data flow or when idle
        const BLOCKING = 3;
        /// probe downstream data (buffers, buffer lists, and events)
        const DATA_DOWNSTREAM = 112;
        /// probe upstream data (events)
        const DATA_UPSTREAM = 128;
        /// probe upstream and downstream data (buffers, buffer lists, and events)
        const DATA_BOTH = 240;
        /// probe and block downstream data (buffers, buffer lists, and events)
        const BLOCK_DOWNSTREAM = 114;
        /// probe and block upstream data (events)
        const BLOCK_UPSTREAM = 130;
        /// probe upstream and downstream events
        const EVENT_BOTH = 192;
        /// probe upstream and downstream queries
        const QUERY_BOTH = 1536;
        /// probe upstream events and queries and downstream buffers, buffer lists, events and queries
        const ALL_BOTH = 1776;
        /// probe push and pull
        const SCHEDULING = 12288;
    }
}

#[doc(hidden)]
impl ToGlib for PadProbeType {
    type GlibType = gst_sys::GstPadProbeType;

    fn to_glib(&self) -> gst_sys::GstPadProbeType {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPadProbeType> for PadProbeType {
    fn from_glib(value: gst_sys::GstPadProbeType) -> PadProbeType {
        skip_assert_initialized!();
        PadProbeType::from_bits_truncate(value)
    }
}

impl StaticType for PadProbeType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_pad_probe_type_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PadProbeType {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PadProbeType {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PadProbeType {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Parsing options.
    pub struct ParseFlags: u32 {
        /// Always return `None` when an error occurs
        ///  (default behaviour is to return partially constructed bins or elements
        ///  in some cases)
        const FATAL_ERRORS = 1;
        /// If a bin only has a single element,
        ///  just return the element.
        const NO_SINGLE_ELEMENT_BINS = 2;
        /// If more than one toplevel element is described
        ///  by the pipeline description string, put them in a `Bin` instead of a
        ///  `Pipeline`. (Since: 1.10)
        #[cfg(any(feature = "v1_10", feature = "dox"))]
        const PLACE_IN_BIN = 4;
    }
}

#[doc(hidden)]
impl ToGlib for ParseFlags {
    type GlibType = gst_sys::GstParseFlags;

    fn to_glib(&self) -> gst_sys::GstParseFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstParseFlags> for ParseFlags {
    fn from_glib(value: gst_sys::GstParseFlags) -> ParseFlags {
        skip_assert_initialized!();
        ParseFlags::from_bits_truncate(value)
    }
}

impl StaticType for ParseFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_parse_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for ParseFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for ParseFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for ParseFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Pipeline flags
    pub struct PipelineFlags: u32 {
        /// this pipeline works with a fixed clock
        const FIXED_CLOCK = 524288;
    }
}

#[doc(hidden)]
impl ToGlib for PipelineFlags {
    type GlibType = gst_sys::GstPipelineFlags;

    fn to_glib(&self) -> gst_sys::GstPipelineFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPipelineFlags> for PipelineFlags {
    fn from_glib(value: gst_sys::GstPipelineFlags) -> PipelineFlags {
        skip_assert_initialized!();
        PipelineFlags::from_bits_truncate(value)
    }
}

impl StaticType for PipelineFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_pipeline_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PipelineFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PipelineFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PipelineFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
bitflags! {
    pub struct PluginAPIFlags: u32 {
        /// Ignore enum members when generating
        ///  the plugins cache. This is useful if the members of the enum are generated
        ///  dynamically, in order not to expose incorrect documentation to the end user.
        ///
        /// Feature: `v1_18`
        ///
        const MEMBERS = 1;
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for PluginAPIFlags {
    type GlibType = gst_sys::GstPluginAPIFlags;

    fn to_glib(&self) -> gst_sys::GstPluginAPIFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<gst_sys::GstPluginAPIFlags> for PluginAPIFlags {
    fn from_glib(value: gst_sys::GstPluginAPIFlags) -> PluginAPIFlags {
        skip_assert_initialized!();
        PluginAPIFlags::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
impl StaticType for PluginAPIFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_plugin_api_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
impl<'a> FromValueOptional<'a> for PluginAPIFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
impl<'a> FromValue<'a> for PluginAPIFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_18", feature = "dox"))]
impl SetValue for PluginAPIFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Flags used in connection with `Plugin::add_dependency`.
    pub struct PluginDependencyFlags: u32 {
        /// recurse into subdirectories
        const RECURSE = 1;
        /// use paths
        ///  argument only if none of the environment variables is set
        const PATHS_ARE_DEFAULT_ONLY = 2;
        /// interpret
        ///  filename argument as filter suffix and check all matching files in
        ///  the directory
        const FILE_NAME_IS_SUFFIX = 4;
        /// interpret
        ///  filename argument as filter prefix and check all matching files in
        ///  the directory. Since: 1.8.
        const FILE_NAME_IS_PREFIX = 8;
        /// interpret
        ///  non-absolute paths as relative to the main executable directory. Since
        ///  1.14.
        const PATHS_ARE_RELATIVE_TO_EXE = 16;
    }
}

#[doc(hidden)]
impl ToGlib for PluginDependencyFlags {
    type GlibType = gst_sys::GstPluginDependencyFlags;

    fn to_glib(&self) -> gst_sys::GstPluginDependencyFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPluginDependencyFlags> for PluginDependencyFlags {
    fn from_glib(value: gst_sys::GstPluginDependencyFlags) -> PluginDependencyFlags {
        skip_assert_initialized!();
        PluginDependencyFlags::from_bits_truncate(value)
    }
}

impl StaticType for PluginDependencyFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_plugin_dependency_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PluginDependencyFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PluginDependencyFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PluginDependencyFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The plugin loading state
    pub struct PluginFlags: u32 {
        /// Temporarily loaded plugins
        const CACHED = 16;
        /// The plugin won't be scanned (again)
        const BLACKLISTED = 32;
    }
}

#[doc(hidden)]
impl ToGlib for PluginFlags {
    type GlibType = gst_sys::GstPluginFlags;

    fn to_glib(&self) -> gst_sys::GstPluginFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstPluginFlags> for PluginFlags {
    fn from_glib(value: gst_sys::GstPluginFlags) -> PluginFlags {
        skip_assert_initialized!();
        PluginFlags::from_bits_truncate(value)
    }
}

impl StaticType for PluginFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_plugin_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PluginFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PluginFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PluginFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// The different scheduling flags.
    pub struct SchedulingFlags: u32 {
        /// if seeking is possible
        const SEEKABLE = 1;
        /// if sequential access is recommended
        const SEQUENTIAL = 2;
        /// if bandwidth is limited and buffering possible (since 1.2)
        const BANDWIDTH_LIMITED = 4;
    }
}

#[doc(hidden)]
impl ToGlib for SchedulingFlags {
    type GlibType = gst_sys::GstSchedulingFlags;

    fn to_glib(&self) -> gst_sys::GstSchedulingFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstSchedulingFlags> for SchedulingFlags {
    fn from_glib(value: gst_sys::GstSchedulingFlags) -> SchedulingFlags {
        skip_assert_initialized!();
        SchedulingFlags::from_bits_truncate(value)
    }
}

impl StaticType for SchedulingFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_scheduling_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for SchedulingFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for SchedulingFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for SchedulingFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Flags to be used with `Element::seek` or `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
    /// `MessageType::SegmentDone` 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 only changing the playback rate and not the direction, the
    /// `SeekFlags::InstantRateChange` flag can be used for a non-flushing seek
    /// to signal that the rate change should be applied immediately. This requires
    /// special support in the seek handlers (e.g. demuxers) and any elements
    /// synchronizing to the clock, and in general can't work in all cases (for example
    /// UDP streaming where the delivery rate is controlled by a remote server). The
    /// instant-rate-change mode supports changing the trickmode-related GST_SEEK_ flags,
    /// but can't be used in conjunction with other seek flags that affect the new
    /// playback position - as the playback position will not be changing.
    ///
    /// When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode
    /// playback, the `SeekFlags::Trickmode` flag can be used to instruct decoders
    /// and demuxers to adjust the playback rate by skipping frames. This can improve
    /// performance and decrease CPU usage because not all frames need to be decoded.
    ///
    /// Beyond that, the `SeekFlags::TrickmodeKeyUnits` flag can be used to
    /// request that decoders skip all frames except key units, and
    /// `SeekFlags::TrickmodeNoAudio` flags can be used to request that audio
    /// decoders do no decoding at all, and simple output silence.
    ///
    /// The `SeekFlags::SnapBefore` flag can be used to snap to the previous
    /// relevant location, and the `SeekFlags::SnapAfter` flag can be used to
    /// select the next relevant location. If `SeekFlags::KeyUnit` 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.
    pub struct SeekFlags: u32 {
        /// flush pipeline
        const FLUSH = 1;
        /// accurate position is requested, this might
        ///  be considerably slower for some formats.
        const ACCURATE = 2;
        /// seek to the nearest keyframe. This might be
        ///  faster but less accurate.
        const KEY_UNIT = 4;
        /// perform a segment seek.
        const SEGMENT = 8;
        /// when doing fast forward or fast reverse playback, allow
        ///  elements to skip frames instead of generating all
        ///  frames. (Since: 1.6)
        const TRICKMODE = 16;
        /// Deprecated backward compatibility flag, replaced
        ///  by `SeekFlags::Trickmode`
        const SKIP = 16;
        /// go to a location before the requested position,
        ///  if `SeekFlags::KeyUnit` this means the keyframe at or before
        ///  the requested position the one at or before the seek target.
        const SNAP_BEFORE = 32;
        /// go to a location after the requested position,
        ///  if `SeekFlags::KeyUnit` this means the keyframe at of after the
        ///  requested position.
        const SNAP_AFTER = 64;
        /// go to a position near the requested position,
        ///  if `SeekFlags::KeyUnit` this means the keyframe closest
        ///  to the requested position, if both keyframes are at an equal
        ///  distance, behaves like `SeekFlags::SnapBefore`.
        const SNAP_NEAREST = 96;
        /// 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)
        const TRICKMODE_KEY_UNITS = 128;
        /// 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)
        const TRICKMODE_NO_AUDIO = 256;
        /// When doing fast forward or fast reverse
        ///  playback, request that elements only decode keyframes and
        ///  forward predicted frames and skip all other content (for example
        ///  B-Frames), for formats that have keyframes and forward predicted
        ///  frames. (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        const TRICKMODE_FORWARD_PREDICTED = 512;
        /// Signals that a rate change should be
        ///  applied immediately. Only valid if start/stop position
        ///  are GST_CLOCK_TIME_NONE, the playback direction does not change
        ///  and the seek is not flushing. (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        const INSTANT_RATE_CHANGE = 1024;
    }
}

#[doc(hidden)]
impl ToGlib for SeekFlags {
    type GlibType = gst_sys::GstSeekFlags;

    fn to_glib(&self) -> gst_sys::GstSeekFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstSeekFlags> for SeekFlags {
    fn from_glib(value: gst_sys::GstSeekFlags) -> SeekFlags {
        skip_assert_initialized!();
        SeekFlags::from_bits_truncate(value)
    }
}

impl StaticType for SeekFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_seek_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for SeekFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for SeekFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for SeekFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Flags for the GstSegment structure. Currently mapped to the corresponding
    /// values of the seek flags.
    #[cfg_attr(feature = "ser_de", derive(Serialize, Deserialize))]
    pub struct SegmentFlags: u32 {
        /// reset the pipeline running_time to the segment
        ///  running_time
        const RESET = 1;
        /// perform skip playback (Since: 1.6)
        const TRICKMODE = 16;
        /// Deprecated backward compatibility flag, replaced
        ///  by `SegmentFlags::Trickmode`
        const SKIP = 16;
        /// send SEGMENT_DONE instead of EOS
        const SEGMENT = 8;
        /// Decode only keyframes, where
        ///  possible (Since: 1.6)
        const TRICKMODE_KEY_UNITS = 128;
        /// Decode only keyframes or forward
        ///  predicted frames, where possible (Since: 1.18)
        #[cfg(any(feature = "v1_18", feature = "dox"))]
        const TRICKMODE_FORWARD_PREDICTED = 512;
        /// Do not decode any audio, where
        ///  possible (Since: 1.6)
        const TRICKMODE_NO_AUDIO = 256;
    }
}

#[doc(hidden)]
impl ToGlib for SegmentFlags {
    type GlibType = gst_sys::GstSegmentFlags;

    fn to_glib(&self) -> gst_sys::GstSegmentFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstSegmentFlags> for SegmentFlags {
    fn from_glib(value: gst_sys::GstSegmentFlags) -> SegmentFlags {
        skip_assert_initialized!();
        SegmentFlags::from_bits_truncate(value)
    }
}

impl StaticType for SegmentFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_segment_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for SegmentFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for SegmentFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for SegmentFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
bitflags! {
    pub struct StackTraceFlags: u32 {
        /// Try to retrieve as much information as possible,
        ///  including source information when getting the
        ///  stack trace
        ///
        /// Feature: `v1_12`
        ///
        const FULL = 1;
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for StackTraceFlags {
    type GlibType = gst_sys::GstStackTraceFlags;

    fn to_glib(&self) -> gst_sys::GstStackTraceFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<gst_sys::GstStackTraceFlags> for StackTraceFlags {
    fn from_glib(value: gst_sys::GstStackTraceFlags) -> StackTraceFlags {
        skip_assert_initialized!();
        StackTraceFlags::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
impl StaticType for StackTraceFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_stack_trace_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
impl<'a> FromValueOptional<'a> for StackTraceFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
impl<'a> FromValue<'a> for StackTraceFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_12", feature = "dox"))]
impl SetValue for StackTraceFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    pub struct StreamFlags: u32 {
        /// This stream is a sparse stream (e.g. a subtitle
        ///  stream), data may flow only in irregular intervals with large gaps in
        ///  between.
        const SPARSE = 1;
        /// 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.
        const SELECT = 2;
        /// 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).
        const UNSELECT = 4;
    }
}

#[doc(hidden)]
impl ToGlib for StreamFlags {
    type GlibType = gst_sys::GstStreamFlags;

    fn to_glib(&self) -> gst_sys::GstStreamFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<gst_sys::GstStreamFlags> for StreamFlags {
    fn from_glib(value: gst_sys::GstStreamFlags) -> StreamFlags {
        skip_assert_initialized!();
        StreamFlags::from_bits_truncate(value)
    }
}

impl StaticType for StreamFlags {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_stream_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for StreamFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for StreamFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for StreamFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
bitflags! {
    /// `StreamType` describes a high level classification set for
    /// flows of data in `Stream` objects.
    ///
    /// Note that this is a flag, and therefore users should not assume it
    /// will be a single value. Do not use the equality operator for checking
    /// whether a stream is of a certain type.
    pub struct StreamType: u32 {
        /// The stream is of unknown (unclassified) type.
        const UNKNOWN = 1;
        /// The stream is of audio data
        const AUDIO = 2;
        /// The stream carries video data
        const VIDEO = 4;
        /// The stream is a muxed container type
        const CONTAINER = 8;
        /// The stream contains subtitle / subpicture data.
        ///
        /// Feature: `v1_10`
        ///
        const TEXT = 16;
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for StreamType {
    type GlibType = gst_sys::GstStreamType;

    fn to_glib(&self) -> gst_sys::GstStreamType {
        self.bits()
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<gst_sys::GstStreamType> for StreamType {
    fn from_glib(value: gst_sys::GstStreamType) -> StreamType {
        skip_assert_initialized!();
        StreamType::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
impl StaticType for StreamType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_sys::gst_stream_type_get_type()) }
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
impl<'a> FromValueOptional<'a> for StreamType {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
impl<'a> FromValue<'a> for StreamType {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
impl SetValue for StreamType {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}