gstreamer/auto/

enums.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use crate::{EventTypeFlags, ffi};
use glib::{GStr, prelude::*, translate::*};

/// The different types of buffering methods.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstBufferingMode")]
pub enum BufferingMode {
    /// a small amount of data is buffered
    #[doc(alias = "GST_BUFFERING_STREAM")]
    Stream,
    /// the stream is being downloaded
    #[doc(alias = "GST_BUFFERING_DOWNLOAD")]
    Download,
    /// the stream is being downloaded in a ringbuffer
    #[doc(alias = "GST_BUFFERING_TIMESHIFT")]
    Timeshift,
    /// the stream is a live stream
    #[doc(alias = "GST_BUFFERING_LIVE")]
    Live,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for BufferingMode {
    type GlibType = ffi::GstBufferingMode;

    #[inline]
    fn into_glib(self) -> ffi::GstBufferingMode {
        match self {
            Self::Stream => ffi::GST_BUFFERING_STREAM,
            Self::Download => ffi::GST_BUFFERING_DOWNLOAD,
            Self::Timeshift => ffi::GST_BUFFERING_TIMESHIFT,
            Self::Live => ffi::GST_BUFFERING_LIVE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBufferingMode> for BufferingMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GstBufferingMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_BUFFERING_STREAM => Self::Stream,
            ffi::GST_BUFFERING_DOWNLOAD => Self::Download,
            ffi::GST_BUFFERING_TIMESHIFT => Self::Timeshift,
            ffi::GST_BUFFERING_LIVE => Self::Live,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for BufferingMode {
    #[inline]
    #[doc(alias = "gst_buffering_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_buffering_mode_get_type()) }
    }
}

impl glib::HasParamSpec for BufferingMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BufferingMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BufferingMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BufferingMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BufferingMode> for glib::Value {
    #[inline]
    fn from(v: BufferingMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The result values for a GstBusSyncHandler.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstBusSyncReply")]
pub enum BusSyncReply {
    /// drop the message
    #[doc(alias = "GST_BUS_DROP")]
    Drop = ffi::GST_BUS_DROP,
    /// pass the message to the async queue
    #[doc(alias = "GST_BUS_PASS")]
    Pass = ffi::GST_BUS_PASS,
    /// pass message to async queue, continue if message is handled
    #[doc(alias = "GST_BUS_ASYNC")]
    Async = ffi::GST_BUS_ASYNC,
}

#[doc(hidden)]
impl IntoGlib for BusSyncReply {
    type GlibType = ffi::GstBusSyncReply;

    #[inline]
    fn into_glib(self) -> ffi::GstBusSyncReply {
        self as ffi::GstBusSyncReply
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstBusSyncReply> for BusSyncReply {
    #[inline]
    unsafe fn from_glib(value: ffi::GstBusSyncReply) -> Self {
        skip_assert_initialized!();

        debug_assert!([ffi::GST_BUS_DROP, ffi::GST_BUS_PASS, ffi::GST_BUS_ASYNC].contains(&value));
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for BusSyncReply {
    #[inline]
    #[doc(alias = "gst_bus_sync_reply_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_bus_sync_reply_get_type()) }
    }
}

impl glib::HasParamSpec for BusSyncReply {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BusSyncReply {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BusSyncReply {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BusSyncReply {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BusSyncReply> for glib::Value {
    #[inline]
    fn from(v: BusSyncReply) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Modes of caps intersection
///
/// [`ZigZag`][Self::ZigZag] tries to preserve overall order of both caps
/// by iterating on the caps' structures as the following matrix shows:
///
/// ```text
///          caps1
///       +-------------
///       | 1  2  4  7
/// caps2 | 3  5  8 10
///       | 6  9 11 12
/// ```
///
/// 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.
///
/// [`First`][Self::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.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstCapsIntersectMode")]
pub enum CapsIntersectMode {
    /// Zig-zags over both caps.
    #[doc(alias = "GST_CAPS_INTERSECT_ZIG_ZAG")]
    ZigZag,
    /// Keeps the first caps order.
    #[doc(alias = "GST_CAPS_INTERSECT_FIRST")]
    First,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CapsIntersectMode {
    type GlibType = ffi::GstCapsIntersectMode;

    #[inline]
    fn into_glib(self) -> ffi::GstCapsIntersectMode {
        match self {
            Self::ZigZag => ffi::GST_CAPS_INTERSECT_ZIG_ZAG,
            Self::First => ffi::GST_CAPS_INTERSECT_FIRST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstCapsIntersectMode> for CapsIntersectMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GstCapsIntersectMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_CAPS_INTERSECT_ZIG_ZAG => Self::ZigZag,
            ffi::GST_CAPS_INTERSECT_FIRST => Self::First,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for CapsIntersectMode {
    #[inline]
    #[doc(alias = "gst_caps_intersect_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_caps_intersect_mode_get_type()) }
    }
}

impl glib::HasParamSpec for CapsIntersectMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for CapsIntersectMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for CapsIntersectMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for CapsIntersectMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<CapsIntersectMode> for glib::Value {
    #[inline]
    fn from(v: CapsIntersectMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of the clock entry
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstClockEntryType")]
pub enum ClockEntryType {
    /// a single shot timeout
    #[doc(alias = "GST_CLOCK_ENTRY_SINGLE")]
    Single,
    /// a periodic timeout request
    #[doc(alias = "GST_CLOCK_ENTRY_PERIODIC")]
    Periodic,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ClockEntryType {
    type GlibType = ffi::GstClockEntryType;

    #[inline]
    fn into_glib(self) -> ffi::GstClockEntryType {
        match self {
            Self::Single => ffi::GST_CLOCK_ENTRY_SINGLE,
            Self::Periodic => ffi::GST_CLOCK_ENTRY_PERIODIC,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockEntryType> for ClockEntryType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstClockEntryType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_CLOCK_ENTRY_SINGLE => Self::Single,
            ffi::GST_CLOCK_ENTRY_PERIODIC => Self::Periodic,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ClockEntryType {
    #[inline]
    #[doc(alias = "gst_clock_entry_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_clock_entry_type_get_type()) }
    }
}

impl glib::HasParamSpec for ClockEntryType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ClockEntryType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ClockEntryType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ClockEntryType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ClockEntryType> for glib::Value {
    #[inline]
    fn from(v: ClockEntryType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The return value of a clock operation.
#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstClockReturn")]
pub enum ClockReturn {
    /// The operation succeeded.
    #[doc(alias = "GST_CLOCK_OK")]
    Ok = ffi::GST_CLOCK_OK,
    /// The operation was scheduled too late.
    #[doc(alias = "GST_CLOCK_EARLY")]
    Early = ffi::GST_CLOCK_EARLY,
    /// The clockID was unscheduled
    #[doc(alias = "GST_CLOCK_UNSCHEDULED")]
    Unscheduled = ffi::GST_CLOCK_UNSCHEDULED,
    /// The ClockID is busy
    #[doc(alias = "GST_CLOCK_BUSY")]
    Busy = ffi::GST_CLOCK_BUSY,
    /// A bad time was provided to a function.
    #[doc(alias = "GST_CLOCK_BADTIME")]
    Badtime = ffi::GST_CLOCK_BADTIME,
    /// An error occurred
    #[doc(alias = "GST_CLOCK_ERROR")]
    Error = ffi::GST_CLOCK_ERROR,
    /// Operation is not supported
    #[doc(alias = "GST_CLOCK_UNSUPPORTED")]
    Unsupported = ffi::GST_CLOCK_UNSUPPORTED,
    /// The ClockID is done waiting
    #[doc(alias = "GST_CLOCK_DONE")]
    Done = ffi::GST_CLOCK_DONE,
}

#[doc(hidden)]
impl IntoGlib for ClockReturn {
    type GlibType = ffi::GstClockReturn;

    #[inline]
    fn into_glib(self) -> ffi::GstClockReturn {
        self as ffi::GstClockReturn
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockReturn> for ClockReturn {
    #[inline]
    unsafe fn from_glib(value: ffi::GstClockReturn) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_CLOCK_OK,
                ffi::GST_CLOCK_EARLY,
                ffi::GST_CLOCK_UNSCHEDULED,
                ffi::GST_CLOCK_BUSY,
                ffi::GST_CLOCK_BADTIME,
                ffi::GST_CLOCK_ERROR,
                ffi::GST_CLOCK_UNSUPPORTED,
                ffi::GST_CLOCK_DONE
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for ClockReturn {
    #[inline]
    #[doc(alias = "gst_clock_return_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_clock_return_get_type()) }
    }
}

impl glib::HasParamSpec for ClockReturn {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ClockReturn {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ClockReturn {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ClockReturn {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ClockReturn> for glib::Value {
    #[inline]
    fn from(v: ClockReturn) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different kind of clocks.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstClockType")]
pub enum ClockType {
    /// time since Epoch
    #[doc(alias = "GST_CLOCK_TYPE_REALTIME")]
    Realtime,
    /// monotonic time since some unspecified starting
    ///  point
    #[doc(alias = "GST_CLOCK_TYPE_MONOTONIC")]
    Monotonic,
    /// some other time source is used (Since: 1.0.5)
    #[doc(alias = "GST_CLOCK_TYPE_OTHER")]
    Other,
    /// time since Epoch, but using International Atomic Time
    ///  as reference (Since: 1.18)
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_CLOCK_TYPE_TAI")]
    Tai,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ClockType {
    type GlibType = ffi::GstClockType;

    #[inline]
    fn into_glib(self) -> ffi::GstClockType {
        match self {
            Self::Realtime => ffi::GST_CLOCK_TYPE_REALTIME,
            Self::Monotonic => ffi::GST_CLOCK_TYPE_MONOTONIC,
            Self::Other => ffi::GST_CLOCK_TYPE_OTHER,
            #[cfg(feature = "v1_18")]
            Self::Tai => ffi::GST_CLOCK_TYPE_TAI,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstClockType> for ClockType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstClockType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_CLOCK_TYPE_REALTIME => Self::Realtime,
            ffi::GST_CLOCK_TYPE_MONOTONIC => Self::Monotonic,
            ffi::GST_CLOCK_TYPE_OTHER => Self::Other,
            #[cfg(feature = "v1_18")]
            ffi::GST_CLOCK_TYPE_TAI => Self::Tai,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ClockType {
    #[inline]
    #[doc(alias = "gst_clock_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_clock_type_get_type()) }
    }
}

impl glib::HasParamSpec for ClockType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ClockType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ClockType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ClockType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ClockType> for glib::Value {
    #[inline]
    fn from(v: ClockType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Core errors are errors inside the core GStreamer library.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstCoreError")]
pub enum CoreError {
    /// a general error which doesn't fit in any other
    /// category. Make sure you add a custom message to the error call.
    #[doc(alias = "GST_CORE_ERROR_FAILED")]
    Failed,
    /// do not use this except as a placeholder for
    /// deciding where to go while developing code.
    #[doc(alias = "GST_CORE_ERROR_TOO_LAZY")]
    TooLazy,
    /// use this when you do not want to implement
    /// this functionality yet.
    #[doc(alias = "GST_CORE_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    /// used for state change errors.
    #[doc(alias = "GST_CORE_ERROR_STATE_CHANGE")]
    StateChange,
    /// used for pad-related errors.
    #[doc(alias = "GST_CORE_ERROR_PAD")]
    Pad,
    /// used for thread-related errors.
    #[doc(alias = "GST_CORE_ERROR_THREAD")]
    Thread,
    /// used for negotiation-related errors.
    #[doc(alias = "GST_CORE_ERROR_NEGOTIATION")]
    Negotiation,
    /// used for event-related errors.
    #[doc(alias = "GST_CORE_ERROR_EVENT")]
    Event,
    /// used for seek-related errors.
    #[doc(alias = "GST_CORE_ERROR_SEEK")]
    Seek,
    /// used for caps-related errors.
    #[doc(alias = "GST_CORE_ERROR_CAPS")]
    Caps,
    /// used for negotiation-related errors.
    #[doc(alias = "GST_CORE_ERROR_TAG")]
    Tag,
    /// used if a plugin is missing.
    #[doc(alias = "GST_CORE_ERROR_MISSING_PLUGIN")]
    MissingPlugin,
    /// used for clock related errors.
    #[doc(alias = "GST_CORE_ERROR_CLOCK")]
    Clock,
    /// used if functionality has been disabled at
    ///  compile time.
    #[doc(alias = "GST_CORE_ERROR_DISABLED")]
    Disabled,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CoreError {
    type GlibType = ffi::GstCoreError;

    fn into_glib(self) -> ffi::GstCoreError {
        match self {
            Self::Failed => ffi::GST_CORE_ERROR_FAILED,
            Self::TooLazy => ffi::GST_CORE_ERROR_TOO_LAZY,
            Self::NotImplemented => ffi::GST_CORE_ERROR_NOT_IMPLEMENTED,
            Self::StateChange => ffi::GST_CORE_ERROR_STATE_CHANGE,
            Self::Pad => ffi::GST_CORE_ERROR_PAD,
            Self::Thread => ffi::GST_CORE_ERROR_THREAD,
            Self::Negotiation => ffi::GST_CORE_ERROR_NEGOTIATION,
            Self::Event => ffi::GST_CORE_ERROR_EVENT,
            Self::Seek => ffi::GST_CORE_ERROR_SEEK,
            Self::Caps => ffi::GST_CORE_ERROR_CAPS,
            Self::Tag => ffi::GST_CORE_ERROR_TAG,
            Self::MissingPlugin => ffi::GST_CORE_ERROR_MISSING_PLUGIN,
            Self::Clock => ffi::GST_CORE_ERROR_CLOCK,
            Self::Disabled => ffi::GST_CORE_ERROR_DISABLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstCoreError> for CoreError {
    unsafe fn from_glib(value: ffi::GstCoreError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_CORE_ERROR_FAILED => Self::Failed,
            ffi::GST_CORE_ERROR_TOO_LAZY => Self::TooLazy,
            ffi::GST_CORE_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
            ffi::GST_CORE_ERROR_STATE_CHANGE => Self::StateChange,
            ffi::GST_CORE_ERROR_PAD => Self::Pad,
            ffi::GST_CORE_ERROR_THREAD => Self::Thread,
            ffi::GST_CORE_ERROR_NEGOTIATION => Self::Negotiation,
            ffi::GST_CORE_ERROR_EVENT => Self::Event,
            ffi::GST_CORE_ERROR_SEEK => Self::Seek,
            ffi::GST_CORE_ERROR_CAPS => Self::Caps,
            ffi::GST_CORE_ERROR_TAG => Self::Tag,
            ffi::GST_CORE_ERROR_MISSING_PLUGIN => Self::MissingPlugin,
            ffi::GST_CORE_ERROR_CLOCK => Self::Clock,
            ffi::GST_CORE_ERROR_DISABLED => Self::Disabled,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for CoreError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_core_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for CoreError {
    #[inline]
    #[doc(alias = "gst_core_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_core_error_get_type()) }
    }
}

impl glib::HasParamSpec for CoreError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for CoreError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for CoreError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for CoreError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<CoreError> for glib::Value {
    #[inline]
    fn from(v: CoreError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The level defines the importance of a debugging message. The more important a
/// message is, the greater the probability that the debugging system outputs it.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstDebugLevel")]
pub enum DebugLevel {
    /// No debugging level specified or desired. Used to deactivate
    ///  debugging output.
    #[doc(alias = "GST_LEVEL_NONE")]
    None,
    /// Error messages are to be used only when an error occurred
    ///  that stops the application from keeping working correctly.
    ///  An examples is gst_element_error, which outputs a message with this priority.
    ///  It does not mean that the application is terminating as with g_error.
    #[doc(alias = "GST_LEVEL_ERROR")]
    Error,
    /// Warning messages are to inform about abnormal behaviour
    ///  that could lead to problems or weird behaviour later on. An example of this
    ///  would be clocking issues ("your computer is pretty slow") or broken input
    ///  data ("Can't synchronize to stream.")
    #[doc(alias = "GST_LEVEL_WARNING")]
    Warning,
    /// Fixme messages are messages that indicate that something
    ///  in the executed code path is not fully implemented or handled yet. Note
    ///  that this does not replace proper error handling in any way, the purpose
    ///  of this message is to make it easier to spot incomplete/unfinished pieces
    ///  of code when reading the debug log.
    #[doc(alias = "GST_LEVEL_FIXME")]
    Fixme,
    /// Informational messages should be used to keep the developer
    ///  updated about what is happening.
    ///  Examples where this should be used are when a typefind function has
    ///  successfully determined the type of the stream or when an mp3 plugin detects
    ///  the format to be used. ("This file has mono sound.")
    #[doc(alias = "GST_LEVEL_INFO")]
    Info,
    /// Debugging messages should be used when something common
    ///  happens that is not the expected default behavior, or something that's
    ///  useful to know but doesn't happen all the time (ie. per loop iteration or
    ///  buffer processed or event handled).
    ///  An example would be notifications about state changes or receiving/sending
    ///  of events.
    #[doc(alias = "GST_LEVEL_DEBUG")]
    Debug,
    /// Log messages are messages that are very common but might be
    ///  useful to know. As a rule of thumb a pipeline that is running as expected
    ///  should never output anything else but LOG messages whilst processing data.
    ///  Use this log level to log recurring information in chain functions and
    ///  loop functions, for example.
    #[doc(alias = "GST_LEVEL_LOG")]
    Log,
    /// Tracing-related messages.
    ///  Examples for this are referencing/dereferencing of objects.
    #[doc(alias = "GST_LEVEL_TRACE")]
    Trace,
    /// memory dump messages are used to log (small) chunks of
    ///  data as memory dumps in the log. They will be displayed as hexdump with
    ///  ASCII characters.
    #[doc(alias = "GST_LEVEL_MEMDUMP")]
    Memdump,
    #[doc(hidden)]
    __Unknown(i32),
}

impl DebugLevel {
    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_debug_level_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_debug_level_get_name returned NULL"),
            )
        }
    }
}

impl std::fmt::Display for DebugLevel {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for DebugLevel {
    type GlibType = ffi::GstDebugLevel;

    #[inline]
    fn into_glib(self) -> ffi::GstDebugLevel {
        match self {
            Self::None => ffi::GST_LEVEL_NONE,
            Self::Error => ffi::GST_LEVEL_ERROR,
            Self::Warning => ffi::GST_LEVEL_WARNING,
            Self::Fixme => ffi::GST_LEVEL_FIXME,
            Self::Info => ffi::GST_LEVEL_INFO,
            Self::Debug => ffi::GST_LEVEL_DEBUG,
            Self::Log => ffi::GST_LEVEL_LOG,
            Self::Trace => ffi::GST_LEVEL_TRACE,
            Self::Memdump => ffi::GST_LEVEL_MEMDUMP,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstDebugLevel> for DebugLevel {
    #[inline]
    unsafe fn from_glib(value: ffi::GstDebugLevel) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_LEVEL_NONE => Self::None,
            ffi::GST_LEVEL_ERROR => Self::Error,
            ffi::GST_LEVEL_WARNING => Self::Warning,
            ffi::GST_LEVEL_FIXME => Self::Fixme,
            ffi::GST_LEVEL_INFO => Self::Info,
            ffi::GST_LEVEL_DEBUG => Self::Debug,
            ffi::GST_LEVEL_LOG => Self::Log,
            ffi::GST_LEVEL_TRACE => Self::Trace,
            ffi::GST_LEVEL_MEMDUMP => Self::Memdump,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DebugLevel {
    #[inline]
    #[doc(alias = "gst_debug_level_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_debug_level_get_type()) }
    }
}

impl glib::HasParamSpec for DebugLevel {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DebugLevel {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DebugLevel {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DebugLevel {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DebugLevel> for glib::Value {
    #[inline]
    fn from(v: DebugLevel) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// [`EventType`][crate::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
/// [`Structure`][crate::Structure].
/// Specific custom events are distinguished by the name of the structure.
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstEventType")]
pub enum EventType {
    /// unknown event.
    #[doc(alias = "GST_EVENT_UNKNOWN")]
    Unknown,
    /// Start a flush operation. This event clears all data
    ///  from the pipeline and unblock all streaming threads.
    #[doc(alias = "GST_EVENT_FLUSH_START")]
    FlushStart,
    /// Stop a flush operation. This event resets the
    ///  running-time of the pipeline.
    #[doc(alias = "GST_EVENT_FLUSH_STOP")]
    FlushStop,
    /// 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.
    #[doc(alias = "GST_EVENT_STREAM_START")]
    StreamStart,
    /// [`Caps`][crate::Caps] event. Notify the pad of a new media type.
    #[doc(alias = "GST_EVENT_CAPS")]
    Caps,
    /// 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.
    #[doc(alias = "GST_EVENT_SEGMENT")]
    Segment,
    /// A new [`StreamCollection`][crate::StreamCollection] is available (Since: 1.10)
    #[doc(alias = "GST_EVENT_STREAM_COLLECTION")]
    StreamCollection,
    /// A new set of metadata tags has been found in the stream.
    #[doc(alias = "GST_EVENT_TAG")]
    Tag,
    /// Notification of buffering requirements. Currently not
    ///  used yet.
    #[doc(alias = "GST_EVENT_BUFFERSIZE")]
    Buffersize,
    /// An event that sinks turn into a message. Used to
    ///  send messages that should be emitted in sync with
    ///  rendering.
    #[doc(alias = "GST_EVENT_SINK_MESSAGE")]
    SinkMessage,
    /// Indicates that there is no more data for
    ///  the stream group ID in the message. Sent before EOS
    ///  in some instances and should be handled mostly the same. (Since: 1.10)
    #[doc(alias = "GST_EVENT_STREAM_GROUP_DONE")]
    StreamGroupDone,
    /// End-Of-Stream. No more data is to be expected to follow
    ///  without either a STREAM_START event, or a FLUSH_STOP and a SEGMENT
    ///  event.
    #[doc(alias = "GST_EVENT_EOS")]
    Eos,
    /// An event which indicates that a new table of contents (TOC)
    ///  was found or updated.
    #[doc(alias = "GST_EVENT_TOC")]
    Toc,
    /// An event which indicates that new or updated
    ///  encryption information has been found in the stream.
    #[doc(alias = "GST_EVENT_PROTECTION")]
    Protection,
    /// Marks the end of a segment playback.
    #[doc(alias = "GST_EVENT_SEGMENT_DONE")]
    SegmentDone,
    /// Marks a gap in the datastream.
    #[doc(alias = "GST_EVENT_GAP")]
    Gap,
    /// Notify downstream that a playback rate override
    ///  should be applied as soon as possible. (Since: 1.18)
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_EVENT_INSTANT_RATE_CHANGE")]
    InstantRateChange,
    /// A quality message. Used to indicate to upstream elements
    ///  that the downstream elements should adjust their processing
    ///  rate.
    #[doc(alias = "GST_EVENT_QOS")]
    Qos,
    /// A request for a new playback position and rate.
    #[doc(alias = "GST_EVENT_SEEK")]
    Seek,
    /// Navigation events are usually used for communicating
    ///  user requests, such as mouse or keyboard movements,
    ///  to upstream elements.
    #[doc(alias = "GST_EVENT_NAVIGATION")]
    Navigation,
    /// Notification of new latency adjustment. Sinks will use
    ///  the latency information to adjust their synchronisation.
    #[doc(alias = "GST_EVENT_LATENCY")]
    Latency,
    /// A request for stepping through the media. Sinks will usually
    ///  execute the step operation.
    #[doc(alias = "GST_EVENT_STEP")]
    Step,
    /// A request for upstream renegotiating caps and reconfiguring.
    #[doc(alias = "GST_EVENT_RECONFIGURE")]
    Reconfigure,
    /// A request for a new playback position based on TOC
    ///  entry's UID.
    #[doc(alias = "GST_EVENT_TOC_SELECT")]
    TocSelect,
    /// A request to select one or more streams (Since: 1.10)
    #[doc(alias = "GST_EVENT_SELECT_STREAMS")]
    SelectStreams,
    /// Sent by the pipeline to notify elements that handle the
    ///  instant-rate-change event about the running-time when
    ///  the rate multiplier should be applied (or was applied). (Since: 1.18)
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "GST_EVENT_INSTANT_RATE_SYNC_TIME")]
    InstantRateSyncTime,
    /// Upstream custom event
    #[doc(alias = "GST_EVENT_CUSTOM_UPSTREAM")]
    CustomUpstream,
    /// Downstream custom event that travels in the
    ///  data flow.
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM")]
    CustomDownstream,
    /// Custom out-of-band downstream event.
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_OOB")]
    CustomDownstreamOob,
    /// Custom sticky downstream event.
    #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_STICKY")]
    CustomDownstreamSticky,
    /// Custom upstream or downstream event.
    ///  In-band when travelling downstream.
    #[doc(alias = "GST_EVENT_CUSTOM_BOTH")]
    CustomBoth,
    /// Custom upstream or downstream out-of-band event.
    #[doc(alias = "GST_EVENT_CUSTOM_BOTH_OOB")]
    CustomBothOob,
    #[doc(hidden)]
    __Unknown(i32),
}

impl EventType {
    #[doc(alias = "gst_event_type_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(self) -> EventTypeFlags {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_event_type_get_flags(self.into_glib())) }
    }

    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_event_type_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_event_type_get_name returned NULL"),
            )
        }
    }

    #[doc(alias = "gst_event_type_to_quark")]
    pub fn to_quark(self) -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_event_type_to_quark(self.into_glib())) }
    }
}

impl std::fmt::Display for EventType {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for EventType {
    type GlibType = ffi::GstEventType;

    fn into_glib(self) -> ffi::GstEventType {
        match self {
            Self::Unknown => ffi::GST_EVENT_UNKNOWN,
            Self::FlushStart => ffi::GST_EVENT_FLUSH_START,
            Self::FlushStop => ffi::GST_EVENT_FLUSH_STOP,
            Self::StreamStart => ffi::GST_EVENT_STREAM_START,
            Self::Caps => ffi::GST_EVENT_CAPS,
            Self::Segment => ffi::GST_EVENT_SEGMENT,
            Self::StreamCollection => ffi::GST_EVENT_STREAM_COLLECTION,
            Self::Tag => ffi::GST_EVENT_TAG,
            Self::Buffersize => ffi::GST_EVENT_BUFFERSIZE,
            Self::SinkMessage => ffi::GST_EVENT_SINK_MESSAGE,
            Self::StreamGroupDone => ffi::GST_EVENT_STREAM_GROUP_DONE,
            Self::Eos => ffi::GST_EVENT_EOS,
            Self::Toc => ffi::GST_EVENT_TOC,
            Self::Protection => ffi::GST_EVENT_PROTECTION,
            Self::SegmentDone => ffi::GST_EVENT_SEGMENT_DONE,
            Self::Gap => ffi::GST_EVENT_GAP,
            #[cfg(feature = "v1_18")]
            Self::InstantRateChange => ffi::GST_EVENT_INSTANT_RATE_CHANGE,
            Self::Qos => ffi::GST_EVENT_QOS,
            Self::Seek => ffi::GST_EVENT_SEEK,
            Self::Navigation => ffi::GST_EVENT_NAVIGATION,
            Self::Latency => ffi::GST_EVENT_LATENCY,
            Self::Step => ffi::GST_EVENT_STEP,
            Self::Reconfigure => ffi::GST_EVENT_RECONFIGURE,
            Self::TocSelect => ffi::GST_EVENT_TOC_SELECT,
            Self::SelectStreams => ffi::GST_EVENT_SELECT_STREAMS,
            #[cfg(feature = "v1_18")]
            Self::InstantRateSyncTime => ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME,
            Self::CustomUpstream => ffi::GST_EVENT_CUSTOM_UPSTREAM,
            Self::CustomDownstream => ffi::GST_EVENT_CUSTOM_DOWNSTREAM,
            Self::CustomDownstreamOob => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB,
            Self::CustomDownstreamSticky => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY,
            Self::CustomBoth => ffi::GST_EVENT_CUSTOM_BOTH,
            Self::CustomBothOob => ffi::GST_EVENT_CUSTOM_BOTH_OOB,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstEventType> for EventType {
    unsafe fn from_glib(value: ffi::GstEventType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_EVENT_UNKNOWN => Self::Unknown,
            ffi::GST_EVENT_FLUSH_START => Self::FlushStart,
            ffi::GST_EVENT_FLUSH_STOP => Self::FlushStop,
            ffi::GST_EVENT_STREAM_START => Self::StreamStart,
            ffi::GST_EVENT_CAPS => Self::Caps,
            ffi::GST_EVENT_SEGMENT => Self::Segment,
            ffi::GST_EVENT_STREAM_COLLECTION => Self::StreamCollection,
            ffi::GST_EVENT_TAG => Self::Tag,
            ffi::GST_EVENT_BUFFERSIZE => Self::Buffersize,
            ffi::GST_EVENT_SINK_MESSAGE => Self::SinkMessage,
            ffi::GST_EVENT_STREAM_GROUP_DONE => Self::StreamGroupDone,
            ffi::GST_EVENT_EOS => Self::Eos,
            ffi::GST_EVENT_TOC => Self::Toc,
            ffi::GST_EVENT_PROTECTION => Self::Protection,
            ffi::GST_EVENT_SEGMENT_DONE => Self::SegmentDone,
            ffi::GST_EVENT_GAP => Self::Gap,
            #[cfg(feature = "v1_18")]
            ffi::GST_EVENT_INSTANT_RATE_CHANGE => Self::InstantRateChange,
            ffi::GST_EVENT_QOS => Self::Qos,
            ffi::GST_EVENT_SEEK => Self::Seek,
            ffi::GST_EVENT_NAVIGATION => Self::Navigation,
            ffi::GST_EVENT_LATENCY => Self::Latency,
            ffi::GST_EVENT_STEP => Self::Step,
            ffi::GST_EVENT_RECONFIGURE => Self::Reconfigure,
            ffi::GST_EVENT_TOC_SELECT => Self::TocSelect,
            ffi::GST_EVENT_SELECT_STREAMS => Self::SelectStreams,
            #[cfg(feature = "v1_18")]
            ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME => Self::InstantRateSyncTime,
            ffi::GST_EVENT_CUSTOM_UPSTREAM => Self::CustomUpstream,
            ffi::GST_EVENT_CUSTOM_DOWNSTREAM => Self::CustomDownstream,
            ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB => Self::CustomDownstreamOob,
            ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY => Self::CustomDownstreamSticky,
            ffi::GST_EVENT_CUSTOM_BOTH => Self::CustomBoth,
            ffi::GST_EVENT_CUSTOM_BOTH_OOB => Self::CustomBothOob,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventType {
    #[inline]
    #[doc(alias = "gst_event_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_event_type_get_type()) }
    }
}

impl glib::HasParamSpec for EventType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for EventType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for EventType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for EventType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventType> for glib::Value {
    #[inline]
    fn from(v: EventType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Standard predefined formats
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstFormat")]
pub enum Format {
    /// undefined format
    #[doc(alias = "GST_FORMAT_UNDEFINED")]
    Undefined,
    /// the default format of the pad/element. This can be
    ///  samples for raw audio, frames/fields for raw video (some, but not all,
    ///  elements support this; use [`Time`][Self::Time] if you don't have a good
    ///  reason to query for samples/frames)
    #[doc(alias = "GST_FORMAT_DEFAULT")]
    Default,
    /// bytes
    #[doc(alias = "GST_FORMAT_BYTES")]
    Bytes,
    /// time in nanoseconds
    #[doc(alias = "GST_FORMAT_TIME")]
    Time,
    /// buffers (few, if any, elements implement this as of
    ///  May 2009)
    #[doc(alias = "GST_FORMAT_BUFFERS")]
    Buffers,
    /// percentage of stream (few, if any, elements implement
    ///  this as of May 2009)
    #[doc(alias = "GST_FORMAT_PERCENT")]
    Percent,
    #[doc(hidden)]
    __Unknown(i32),
}

impl Format {
    #[doc(alias = "gst_format_get_by_nick")]
    #[doc(alias = "get_by_nick")]
    pub fn by_nick(nick: &str) -> Format {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_format_get_by_nick(nick.to_glib_none().0)) }
    }

    //#[doc(alias = "gst_format_get_details")]
    //#[doc(alias = "get_details")]
    //pub fn details(self) -> /*Ignored*/Option<FormatDefinition> {
    //    unsafe { TODO: call ffi:gst_format_get_details() }
    //}

    #[doc(alias = "gst_format_get_name")]
    #[doc(alias = "get_name")]
    pub fn name(self) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gst_format_get_name(self.into_glib())) }
    }

    //#[doc(alias = "gst_format_iterate_definitions")]
    //pub fn iterate_definitions() -> /*Ignored*/Iterator {
    //    unsafe { TODO: call ffi:gst_format_iterate_definitions() }
    //}

    #[doc(alias = "gst_format_to_quark")]
    pub fn to_quark(self) -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_format_to_quark(self.into_glib())) }
    }
}

#[doc(hidden)]
impl IntoGlib for Format {
    type GlibType = ffi::GstFormat;

    #[inline]
    fn into_glib(self) -> ffi::GstFormat {
        match self {
            Self::Undefined => ffi::GST_FORMAT_UNDEFINED,
            Self::Default => ffi::GST_FORMAT_DEFAULT,
            Self::Bytes => ffi::GST_FORMAT_BYTES,
            Self::Time => ffi::GST_FORMAT_TIME,
            Self::Buffers => ffi::GST_FORMAT_BUFFERS,
            Self::Percent => ffi::GST_FORMAT_PERCENT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstFormat> for Format {
    #[inline]
    unsafe fn from_glib(value: ffi::GstFormat) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_FORMAT_UNDEFINED => Self::Undefined,
            ffi::GST_FORMAT_DEFAULT => Self::Default,
            ffi::GST_FORMAT_BYTES => Self::Bytes,
            ffi::GST_FORMAT_TIME => Self::Time,
            ffi::GST_FORMAT_BUFFERS => Self::Buffers,
            ffi::GST_FORMAT_PERCENT => Self::Percent,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Format {
    #[inline]
    #[doc(alias = "gst_format_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_format_get_type()) }
    }
}

impl glib::HasParamSpec for Format {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Format {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Format {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Format {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Format> for glib::Value {
    #[inline]
    fn from(v: Format) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Library errors are for errors from the library being used by elements
/// (initializing, finalizing, settings, ...)
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstLibraryError")]
pub enum LibraryError {
    /// a general error which doesn't fit in any other
    /// category. Make sure you add a custom message to the error call.
    #[doc(alias = "GST_LIBRARY_ERROR_FAILED")]
    Failed,
    /// do not use this except as a placeholder for
    /// deciding where to go while developing code.
    #[doc(alias = "GST_LIBRARY_ERROR_TOO_LAZY")]
    TooLazy,
    /// used when the library could not be opened.
    #[doc(alias = "GST_LIBRARY_ERROR_INIT")]
    Init,
    /// used when the library could not be closed.
    #[doc(alias = "GST_LIBRARY_ERROR_SHUTDOWN")]
    Shutdown,
    /// used when the library doesn't accept settings.
    #[doc(alias = "GST_LIBRARY_ERROR_SETTINGS")]
    Settings,
    /// used when the library generated an encoding error.
    #[doc(alias = "GST_LIBRARY_ERROR_ENCODE")]
    Encode,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for LibraryError {
    type GlibType = ffi::GstLibraryError;

    #[inline]
    fn into_glib(self) -> ffi::GstLibraryError {
        match self {
            Self::Failed => ffi::GST_LIBRARY_ERROR_FAILED,
            Self::TooLazy => ffi::GST_LIBRARY_ERROR_TOO_LAZY,
            Self::Init => ffi::GST_LIBRARY_ERROR_INIT,
            Self::Shutdown => ffi::GST_LIBRARY_ERROR_SHUTDOWN,
            Self::Settings => ffi::GST_LIBRARY_ERROR_SETTINGS,
            Self::Encode => ffi::GST_LIBRARY_ERROR_ENCODE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstLibraryError> for LibraryError {
    #[inline]
    unsafe fn from_glib(value: ffi::GstLibraryError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_LIBRARY_ERROR_FAILED => Self::Failed,
            ffi::GST_LIBRARY_ERROR_TOO_LAZY => Self::TooLazy,
            ffi::GST_LIBRARY_ERROR_INIT => Self::Init,
            ffi::GST_LIBRARY_ERROR_SHUTDOWN => Self::Shutdown,
            ffi::GST_LIBRARY_ERROR_SETTINGS => Self::Settings,
            ffi::GST_LIBRARY_ERROR_ENCODE => Self::Encode,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for LibraryError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_library_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for LibraryError {
    #[inline]
    #[doc(alias = "gst_library_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_library_error_get_type()) }
    }
}

impl glib::HasParamSpec for LibraryError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for LibraryError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for LibraryError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for LibraryError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<LibraryError> for glib::Value {
    #[inline]
    fn from(v: LibraryError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The direction of a pad.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstPadDirection")]
pub enum PadDirection {
    /// direction is unknown.
    #[doc(alias = "GST_PAD_UNKNOWN")]
    Unknown = ffi::GST_PAD_UNKNOWN,
    /// the pad is a source pad.
    #[doc(alias = "GST_PAD_SRC")]
    Src = ffi::GST_PAD_SRC,
    /// the pad is a sink pad.
    #[doc(alias = "GST_PAD_SINK")]
    Sink = ffi::GST_PAD_SINK,
}

#[doc(hidden)]
impl IntoGlib for PadDirection {
    type GlibType = ffi::GstPadDirection;

    #[inline]
    fn into_glib(self) -> ffi::GstPadDirection {
        self as ffi::GstPadDirection
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadDirection> for PadDirection {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPadDirection) -> Self {
        skip_assert_initialized!();

        debug_assert!([ffi::GST_PAD_UNKNOWN, ffi::GST_PAD_SRC, ffi::GST_PAD_SINK].contains(&value));
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for PadDirection {
    #[inline]
    #[doc(alias = "gst_pad_direction_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_pad_direction_get_type()) }
    }
}

impl glib::HasParamSpec for PadDirection {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PadDirection {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PadDirection {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PadDirection {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PadDirection> for glib::Value {
    #[inline]
    fn from(v: PadDirection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// 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.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstPadMode")]
pub enum PadMode {
    /// Pad will not handle dataflow
    #[doc(alias = "GST_PAD_MODE_NONE")]
    None = ffi::GST_PAD_MODE_NONE,
    /// Pad handles dataflow in downstream push mode
    #[doc(alias = "GST_PAD_MODE_PUSH")]
    Push = ffi::GST_PAD_MODE_PUSH,
    /// Pad handles dataflow in upstream pull mode
    #[doc(alias = "GST_PAD_MODE_PULL")]
    Pull = ffi::GST_PAD_MODE_PULL,
}

impl PadMode {
    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_pad_mode_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_pad_mode_get_name returned NULL"),
            )
        }
    }
}

impl std::fmt::Display for PadMode {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for PadMode {
    type GlibType = ffi::GstPadMode;

    #[inline]
    fn into_glib(self) -> ffi::GstPadMode {
        self as ffi::GstPadMode
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadMode> for PadMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPadMode) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_PAD_MODE_NONE,
                ffi::GST_PAD_MODE_PUSH,
                ffi::GST_PAD_MODE_PULL
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for PadMode {
    #[inline]
    #[doc(alias = "gst_pad_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_pad_mode_get_type()) }
    }
}

impl glib::HasParamSpec for PadMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PadMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PadMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PadMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PadMode> for glib::Value {
    #[inline]
    fn from(v: PadMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Indicates when this pad will become available.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstPadPresence")]
pub enum PadPresence {
    /// the pad is always available
    #[doc(alias = "GST_PAD_ALWAYS")]
    Always = ffi::GST_PAD_ALWAYS,
    /// the pad will become available depending on the media stream
    #[doc(alias = "GST_PAD_SOMETIMES")]
    Sometimes = ffi::GST_PAD_SOMETIMES,
    /// the pad is only available on request with
    ///  [`ElementExt::request_pad()`][crate::prelude::ElementExt::request_pad()].
    #[doc(alias = "GST_PAD_REQUEST")]
    Request = ffi::GST_PAD_REQUEST,
}

#[doc(hidden)]
impl IntoGlib for PadPresence {
    type GlibType = ffi::GstPadPresence;

    #[inline]
    fn into_glib(self) -> ffi::GstPadPresence {
        self as ffi::GstPadPresence
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadPresence> for PadPresence {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPadPresence) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_PAD_ALWAYS,
                ffi::GST_PAD_SOMETIMES,
                ffi::GST_PAD_REQUEST
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for PadPresence {
    #[inline]
    #[doc(alias = "gst_pad_presence_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_pad_presence_get_type()) }
    }
}

impl glib::HasParamSpec for PadPresence {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PadPresence {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PadPresence {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PadPresence {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PadPresence> for glib::Value {
    #[inline]
    fn from(v: PadPresence) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Different return values for the `GstPadProbeCallback`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstPadProbeReturn")]
pub enum PadProbeReturn {
    /// 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 other probes
    ///  are called for this item and [`FlowReturn::Ok`][crate::FlowReturn::Ok] or [`true`] is returned to the
    ///  caller.
    #[doc(alias = "GST_PAD_PROBE_DROP")]
    Drop = ffi::GST_PAD_PROBE_DROP,
    /// 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).
    #[doc(alias = "GST_PAD_PROBE_OK")]
    Ok = ffi::GST_PAD_PROBE_OK,
    /// remove this probe, passing the data. For blocking probes
    ///  this will cause data flow to unblock, unless there are also other
    ///  blocking probes installed.
    #[doc(alias = "GST_PAD_PROBE_REMOVE")]
    Remove = ffi::GST_PAD_PROBE_REMOVE,
    /// pass the data item in the block probe and block on the
    ///  next item. Note, that if there are multiple pad probes installed and
    ///  any probe returns PASS, the data will be passed.
    #[doc(alias = "GST_PAD_PROBE_PASS")]
    Pass = ffi::GST_PAD_PROBE_PASS,
    /// Data has been handled in the probe and will not be
    ///  forwarded further. For events and buffers this is the same behaviour as
    ///  [`Drop`][Self::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 [`FlowReturn`][crate::FlowReturn] value by using the
    ///  `GST_PAD_PROBE_INFO_FLOW_RETURN`() accessor.
    ///  Note that the resulting query must contain valid entries.
    ///  Since: 1.6
    #[doc(alias = "GST_PAD_PROBE_HANDLED")]
    Handled = ffi::GST_PAD_PROBE_HANDLED,
}

#[doc(hidden)]
impl IntoGlib for PadProbeReturn {
    type GlibType = ffi::GstPadProbeReturn;

    #[inline]
    fn into_glib(self) -> ffi::GstPadProbeReturn {
        self as ffi::GstPadProbeReturn
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeReturn> for PadProbeReturn {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPadProbeReturn) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_PAD_PROBE_DROP,
                ffi::GST_PAD_PROBE_OK,
                ffi::GST_PAD_PROBE_REMOVE,
                ffi::GST_PAD_PROBE_PASS,
                ffi::GST_PAD_PROBE_HANDLED
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for PadProbeReturn {
    #[inline]
    #[doc(alias = "gst_pad_probe_return_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_pad_probe_return_get_type()) }
    }
}

impl glib::HasParamSpec for PadProbeReturn {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PadProbeReturn {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PadProbeReturn {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PadProbeReturn {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PadProbeReturn> for glib::Value {
    #[inline]
    fn from(v: PadProbeReturn) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different parsing errors that can occur.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstParseError")]
pub enum ParseError {
    /// A syntax error occurred.
    #[doc(alias = "GST_PARSE_ERROR_SYNTAX")]
    Syntax,
    /// The description contained an unknown element
    #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_ELEMENT")]
    NoSuchElement,
    /// An element did not have a specified property
    #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_PROPERTY")]
    NoSuchProperty,
    /// There was an error linking two pads.
    #[doc(alias = "GST_PARSE_ERROR_LINK")]
    Link,
    /// There was an error setting a property
    #[doc(alias = "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY")]
    CouldNotSetProperty,
    /// An empty bin was specified.
    #[doc(alias = "GST_PARSE_ERROR_EMPTY_BIN")]
    EmptyBin,
    /// An empty description was specified
    #[doc(alias = "GST_PARSE_ERROR_EMPTY")]
    Empty,
    /// A delayed link did not get resolved.
    #[doc(alias = "GST_PARSE_ERROR_DELAYED_LINK")]
    DelayedLink,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ParseError {
    type GlibType = ffi::GstParseError;

    #[inline]
    fn into_glib(self) -> ffi::GstParseError {
        match self {
            Self::Syntax => ffi::GST_PARSE_ERROR_SYNTAX,
            Self::NoSuchElement => ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT,
            Self::NoSuchProperty => ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY,
            Self::Link => ffi::GST_PARSE_ERROR_LINK,
            Self::CouldNotSetProperty => ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
            Self::EmptyBin => ffi::GST_PARSE_ERROR_EMPTY_BIN,
            Self::Empty => ffi::GST_PARSE_ERROR_EMPTY,
            Self::DelayedLink => ffi::GST_PARSE_ERROR_DELAYED_LINK,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstParseError> for ParseError {
    #[inline]
    unsafe fn from_glib(value: ffi::GstParseError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_PARSE_ERROR_SYNTAX => Self::Syntax,
            ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT => Self::NoSuchElement,
            ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY => Self::NoSuchProperty,
            ffi::GST_PARSE_ERROR_LINK => Self::Link,
            ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY => Self::CouldNotSetProperty,
            ffi::GST_PARSE_ERROR_EMPTY_BIN => Self::EmptyBin,
            ffi::GST_PARSE_ERROR_EMPTY => Self::Empty,
            ffi::GST_PARSE_ERROR_DELAYED_LINK => Self::DelayedLink,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for ParseError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_parse_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for ParseError {
    #[inline]
    #[doc(alias = "gst_parse_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_parse_error_get_type()) }
    }
}

impl glib::HasParamSpec for ParseError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ParseError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ParseError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ParseError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ParseError> for glib::Value {
    #[inline]
    fn from(v: ParseError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The plugin loading errors
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPluginError")]
pub enum PluginError {
    /// The plugin could not be loaded
    #[doc(alias = "GST_PLUGIN_ERROR_MODULE")]
    Module,
    /// The plugin has unresolved dependencies
    #[doc(alias = "GST_PLUGIN_ERROR_DEPENDENCIES")]
    Dependencies,
    /// The plugin has already be loaded from a different file
    #[doc(alias = "GST_PLUGIN_ERROR_NAME_MISMATCH")]
    NameMismatch,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PluginError {
    type GlibType = ffi::GstPluginError;

    #[inline]
    fn into_glib(self) -> ffi::GstPluginError {
        match self {
            Self::Module => ffi::GST_PLUGIN_ERROR_MODULE,
            Self::Dependencies => ffi::GST_PLUGIN_ERROR_DEPENDENCIES,
            Self::NameMismatch => ffi::GST_PLUGIN_ERROR_NAME_MISMATCH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPluginError> for PluginError {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPluginError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_PLUGIN_ERROR_MODULE => Self::Module,
            ffi::GST_PLUGIN_ERROR_DEPENDENCIES => Self::Dependencies,
            ffi::GST_PLUGIN_ERROR_NAME_MISMATCH => Self::NameMismatch,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for PluginError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_plugin_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for PluginError {
    #[inline]
    #[doc(alias = "gst_plugin_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_plugin_error_get_type()) }
    }
}

impl glib::HasParamSpec for PluginError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PluginError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PluginError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PluginError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PluginError> for glib::Value {
    #[inline]
    fn from(v: PluginError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of a `GST_MESSAGE_PROGRESS`. The progress messages inform the
/// application of the status of asynchronous tasks.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstProgressType")]
pub enum ProgressType {
    /// A new task started.
    #[doc(alias = "GST_PROGRESS_TYPE_START")]
    Start,
    /// A task completed and a new one continues.
    #[doc(alias = "GST_PROGRESS_TYPE_CONTINUE")]
    Continue,
    /// A task completed.
    #[doc(alias = "GST_PROGRESS_TYPE_COMPLETE")]
    Complete,
    /// A task was canceled.
    #[doc(alias = "GST_PROGRESS_TYPE_CANCELED")]
    Canceled,
    /// A task caused an error. An error message is also
    ///  posted on the bus.
    #[doc(alias = "GST_PROGRESS_TYPE_ERROR")]
    Error,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ProgressType {
    type GlibType = ffi::GstProgressType;

    #[inline]
    fn into_glib(self) -> ffi::GstProgressType {
        match self {
            Self::Start => ffi::GST_PROGRESS_TYPE_START,
            Self::Continue => ffi::GST_PROGRESS_TYPE_CONTINUE,
            Self::Complete => ffi::GST_PROGRESS_TYPE_COMPLETE,
            Self::Canceled => ffi::GST_PROGRESS_TYPE_CANCELED,
            Self::Error => ffi::GST_PROGRESS_TYPE_ERROR,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstProgressType> for ProgressType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstProgressType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_PROGRESS_TYPE_START => Self::Start,
            ffi::GST_PROGRESS_TYPE_CONTINUE => Self::Continue,
            ffi::GST_PROGRESS_TYPE_COMPLETE => Self::Complete,
            ffi::GST_PROGRESS_TYPE_CANCELED => Self::Canceled,
            ffi::GST_PROGRESS_TYPE_ERROR => Self::Error,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ProgressType {
    #[inline]
    #[doc(alias = "gst_progress_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_progress_type_get_type()) }
    }
}

impl glib::HasParamSpec for ProgressType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ProgressType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ProgressType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ProgressType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ProgressType> for glib::Value {
    #[inline]
    fn from(v: ProgressType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The result of a [`Promise`][crate::Promise]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstPromiseResult")]
pub enum PromiseResult {
    /// Initial state. Waiting for transition to any
    ///     other state.
    #[doc(alias = "GST_PROMISE_RESULT_PENDING")]
    Pending,
    /// Interrupted by the consumer as it doesn't
    ///     want the value anymore.
    #[doc(alias = "GST_PROMISE_RESULT_INTERRUPTED")]
    Interrupted,
    /// A producer marked a reply
    #[doc(alias = "GST_PROMISE_RESULT_REPLIED")]
    Replied,
    /// The promise expired (the carrying object
    ///     lost all refs) and the promise will never be fulfilled.
    #[doc(alias = "GST_PROMISE_RESULT_EXPIRED")]
    Expired,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PromiseResult {
    type GlibType = ffi::GstPromiseResult;

    #[inline]
    fn into_glib(self) -> ffi::GstPromiseResult {
        match self {
            Self::Pending => ffi::GST_PROMISE_RESULT_PENDING,
            Self::Interrupted => ffi::GST_PROMISE_RESULT_INTERRUPTED,
            Self::Replied => ffi::GST_PROMISE_RESULT_REPLIED,
            Self::Expired => ffi::GST_PROMISE_RESULT_EXPIRED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstPromiseResult> for PromiseResult {
    #[inline]
    unsafe fn from_glib(value: ffi::GstPromiseResult) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_PROMISE_RESULT_PENDING => Self::Pending,
            ffi::GST_PROMISE_RESULT_INTERRUPTED => Self::Interrupted,
            ffi::GST_PROMISE_RESULT_REPLIED => Self::Replied,
            ffi::GST_PROMISE_RESULT_EXPIRED => Self::Expired,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PromiseResult {
    #[inline]
    #[doc(alias = "gst_promise_result_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_promise_result_get_type()) }
    }
}

impl glib::HasParamSpec for PromiseResult {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PromiseResult {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PromiseResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PromiseResult {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PromiseResult> for glib::Value {
    #[inline]
    fn from(v: PromiseResult) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different types of QoS events that can be given to the
/// `gst_event_new_qos()` method.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstQOSType")]
pub enum QOSType {
    /// 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.
    #[doc(alias = "GST_QOS_TYPE_OVERFLOW")]
    Overflow,
    /// The QoS event type that is produced when upstream
    ///  elements are producing data too slowly and need to speed up their
    ///  production rate.
    #[doc(alias = "GST_QOS_TYPE_UNDERFLOW")]
    Underflow,
    /// The QoS event type that is produced when the
    ///  application enabled throttling to limit the data rate.
    #[doc(alias = "GST_QOS_TYPE_THROTTLE")]
    Throttle,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for QOSType {
    type GlibType = ffi::GstQOSType;

    #[inline]
    fn into_glib(self) -> ffi::GstQOSType {
        match self {
            Self::Overflow => ffi::GST_QOS_TYPE_OVERFLOW,
            Self::Underflow => ffi::GST_QOS_TYPE_UNDERFLOW,
            Self::Throttle => ffi::GST_QOS_TYPE_THROTTLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstQOSType> for QOSType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstQOSType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_QOS_TYPE_OVERFLOW => Self::Overflow,
            ffi::GST_QOS_TYPE_UNDERFLOW => Self::Underflow,
            ffi::GST_QOS_TYPE_THROTTLE => Self::Throttle,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for QOSType {
    #[inline]
    #[doc(alias = "gst_qos_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_qos_type_get_type()) }
    }
}

impl glib::HasParamSpec for QOSType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for QOSType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for QOSType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for QOSType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<QOSType> for glib::Value {
    #[inline]
    fn from(v: QOSType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Standard predefined Query types
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstQueryType")]
pub enum QueryType {
    /// unknown query type
    #[doc(alias = "GST_QUERY_UNKNOWN")]
    Unknown,
    /// current position in stream
    #[doc(alias = "GST_QUERY_POSITION")]
    Position,
    /// total duration of the stream
    #[doc(alias = "GST_QUERY_DURATION")]
    Duration,
    /// latency of stream
    #[doc(alias = "GST_QUERY_LATENCY")]
    Latency,
    /// current jitter of stream
    #[doc(alias = "GST_QUERY_JITTER")]
    Jitter,
    /// current rate of the stream
    #[doc(alias = "GST_QUERY_RATE")]
    Rate,
    /// seeking capabilities
    #[doc(alias = "GST_QUERY_SEEKING")]
    Seeking,
    /// segment start/stop positions
    #[doc(alias = "GST_QUERY_SEGMENT")]
    Segment,
    /// convert values between formats
    #[doc(alias = "GST_QUERY_CONVERT")]
    Convert,
    /// query supported formats for convert
    #[doc(alias = "GST_QUERY_FORMATS")]
    Formats,
    /// query available media for efficient seeking.
    #[doc(alias = "GST_QUERY_BUFFERING")]
    Buffering,
    /// a custom application or element defined query.
    #[doc(alias = "GST_QUERY_CUSTOM")]
    Custom,
    /// query the URI of the source or sink.
    #[doc(alias = "GST_QUERY_URI")]
    Uri,
    /// the buffer allocation properties
    #[doc(alias = "GST_QUERY_ALLOCATION")]
    Allocation,
    /// the scheduling properties
    #[doc(alias = "GST_QUERY_SCHEDULING")]
    Scheduling,
    /// the accept caps query
    #[doc(alias = "GST_QUERY_ACCEPT_CAPS")]
    AcceptCaps,
    /// the caps query
    #[doc(alias = "GST_QUERY_CAPS")]
    Caps,
    /// wait till all serialized data is consumed downstream
    #[doc(alias = "GST_QUERY_DRAIN")]
    Drain,
    /// query the pipeline-local context from
    ///  downstream or upstream (since 1.2)
    #[doc(alias = "GST_QUERY_CONTEXT")]
    Context,
    /// the bitrate query (since 1.16)
    #[doc(alias = "GST_QUERY_BITRATE")]
    Bitrate,
    /// Query stream selection capability.
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "GST_QUERY_SELECTABLE")]
    Selectable,
    #[doc(hidden)]
    __Unknown(i32),
}

impl QueryType {
    //#[doc(alias = "gst_query_type_get_flags")]
    //#[doc(alias = "get_flags")]
    //pub fn flags(self) -> /*Ignored*/QueryTypeFlags {
    //    unsafe { TODO: call ffi:gst_query_type_get_flags() }
    //}

    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_query_type_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_query_type_get_name returned NULL"),
            )
        }
    }

    #[doc(alias = "gst_query_type_to_quark")]
    pub fn to_quark(self) -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gst_query_type_to_quark(self.into_glib())) }
    }
}

impl std::fmt::Display for QueryType {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for QueryType {
    type GlibType = ffi::GstQueryType;

    fn into_glib(self) -> ffi::GstQueryType {
        match self {
            Self::Unknown => ffi::GST_QUERY_UNKNOWN,
            Self::Position => ffi::GST_QUERY_POSITION,
            Self::Duration => ffi::GST_QUERY_DURATION,
            Self::Latency => ffi::GST_QUERY_LATENCY,
            Self::Jitter => ffi::GST_QUERY_JITTER,
            Self::Rate => ffi::GST_QUERY_RATE,
            Self::Seeking => ffi::GST_QUERY_SEEKING,
            Self::Segment => ffi::GST_QUERY_SEGMENT,
            Self::Convert => ffi::GST_QUERY_CONVERT,
            Self::Formats => ffi::GST_QUERY_FORMATS,
            Self::Buffering => ffi::GST_QUERY_BUFFERING,
            Self::Custom => ffi::GST_QUERY_CUSTOM,
            Self::Uri => ffi::GST_QUERY_URI,
            Self::Allocation => ffi::GST_QUERY_ALLOCATION,
            Self::Scheduling => ffi::GST_QUERY_SCHEDULING,
            Self::AcceptCaps => ffi::GST_QUERY_ACCEPT_CAPS,
            Self::Caps => ffi::GST_QUERY_CAPS,
            Self::Drain => ffi::GST_QUERY_DRAIN,
            Self::Context => ffi::GST_QUERY_CONTEXT,
            Self::Bitrate => ffi::GST_QUERY_BITRATE,
            #[cfg(feature = "v1_22")]
            Self::Selectable => ffi::GST_QUERY_SELECTABLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstQueryType> for QueryType {
    unsafe fn from_glib(value: ffi::GstQueryType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_QUERY_UNKNOWN => Self::Unknown,
            ffi::GST_QUERY_POSITION => Self::Position,
            ffi::GST_QUERY_DURATION => Self::Duration,
            ffi::GST_QUERY_LATENCY => Self::Latency,
            ffi::GST_QUERY_JITTER => Self::Jitter,
            ffi::GST_QUERY_RATE => Self::Rate,
            ffi::GST_QUERY_SEEKING => Self::Seeking,
            ffi::GST_QUERY_SEGMENT => Self::Segment,
            ffi::GST_QUERY_CONVERT => Self::Convert,
            ffi::GST_QUERY_FORMATS => Self::Formats,
            ffi::GST_QUERY_BUFFERING => Self::Buffering,
            ffi::GST_QUERY_CUSTOM => Self::Custom,
            ffi::GST_QUERY_URI => Self::Uri,
            ffi::GST_QUERY_ALLOCATION => Self::Allocation,
            ffi::GST_QUERY_SCHEDULING => Self::Scheduling,
            ffi::GST_QUERY_ACCEPT_CAPS => Self::AcceptCaps,
            ffi::GST_QUERY_CAPS => Self::Caps,
            ffi::GST_QUERY_DRAIN => Self::Drain,
            ffi::GST_QUERY_CONTEXT => Self::Context,
            ffi::GST_QUERY_BITRATE => Self::Bitrate,
            #[cfg(feature = "v1_22")]
            ffi::GST_QUERY_SELECTABLE => Self::Selectable,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for QueryType {
    #[inline]
    #[doc(alias = "gst_query_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_query_type_get_type()) }
    }
}

impl glib::HasParamSpec for QueryType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for QueryType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for QueryType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for QueryType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<QueryType> for glib::Value {
    #[inline]
    fn from(v: QueryType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Resource errors are for any resource used by an element:
/// memory, files, network connections, process space, ...
/// They're typically used by source and sink elements.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstResourceError")]
pub enum ResourceError {
    /// a general error which doesn't fit in any other
    /// category. Make sure you add a custom message to the error call.
    #[doc(alias = "GST_RESOURCE_ERROR_FAILED")]
    Failed,
    /// do not use this except as a placeholder for
    /// deciding where to go while developing code.
    #[doc(alias = "GST_RESOURCE_ERROR_TOO_LAZY")]
    TooLazy,
    /// used when the resource could not be found.
    #[doc(alias = "GST_RESOURCE_ERROR_NOT_FOUND")]
    NotFound,
    /// used when resource is busy.
    #[doc(alias = "GST_RESOURCE_ERROR_BUSY")]
    Busy,
    /// used when resource fails to open for reading.
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ")]
    OpenRead,
    /// used when resource fails to open for writing.
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_WRITE")]
    OpenWrite,
    /// used when resource cannot be opened for
    /// both reading and writing, or either (but unspecified which).
    #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ_WRITE")]
    OpenReadWrite,
    /// used when the resource can't be closed.
    #[doc(alias = "GST_RESOURCE_ERROR_CLOSE")]
    Close,
    /// used when the resource can't be read from.
    #[doc(alias = "GST_RESOURCE_ERROR_READ")]
    Read,
    /// used when the resource can't be written to.
    #[doc(alias = "GST_RESOURCE_ERROR_WRITE")]
    Write,
    /// used when a seek on the resource fails.
    #[doc(alias = "GST_RESOURCE_ERROR_SEEK")]
    Seek,
    /// used when a synchronize on the resource fails.
    #[doc(alias = "GST_RESOURCE_ERROR_SYNC")]
    Sync,
    /// used when settings can't be manipulated on.
    #[doc(alias = "GST_RESOURCE_ERROR_SETTINGS")]
    Settings,
    /// used when the resource has no space left.
    #[doc(alias = "GST_RESOURCE_ERROR_NO_SPACE_LEFT")]
    NoSpaceLeft,
    /// used when the resource can't be opened
    ///  due to missing authorization.
    ///  (Since: 1.2.4)
    #[doc(alias = "GST_RESOURCE_ERROR_NOT_AUTHORIZED")]
    NotAuthorized,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ResourceError {
    type GlibType = ffi::GstResourceError;

    fn into_glib(self) -> ffi::GstResourceError {
        match self {
            Self::Failed => ffi::GST_RESOURCE_ERROR_FAILED,
            Self::TooLazy => ffi::GST_RESOURCE_ERROR_TOO_LAZY,
            Self::NotFound => ffi::GST_RESOURCE_ERROR_NOT_FOUND,
            Self::Busy => ffi::GST_RESOURCE_ERROR_BUSY,
            Self::OpenRead => ffi::GST_RESOURCE_ERROR_OPEN_READ,
            Self::OpenWrite => ffi::GST_RESOURCE_ERROR_OPEN_WRITE,
            Self::OpenReadWrite => ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE,
            Self::Close => ffi::GST_RESOURCE_ERROR_CLOSE,
            Self::Read => ffi::GST_RESOURCE_ERROR_READ,
            Self::Write => ffi::GST_RESOURCE_ERROR_WRITE,
            Self::Seek => ffi::GST_RESOURCE_ERROR_SEEK,
            Self::Sync => ffi::GST_RESOURCE_ERROR_SYNC,
            Self::Settings => ffi::GST_RESOURCE_ERROR_SETTINGS,
            Self::NoSpaceLeft => ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT,
            Self::NotAuthorized => ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstResourceError> for ResourceError {
    unsafe fn from_glib(value: ffi::GstResourceError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_RESOURCE_ERROR_FAILED => Self::Failed,
            ffi::GST_RESOURCE_ERROR_TOO_LAZY => Self::TooLazy,
            ffi::GST_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
            ffi::GST_RESOURCE_ERROR_BUSY => Self::Busy,
            ffi::GST_RESOURCE_ERROR_OPEN_READ => Self::OpenRead,
            ffi::GST_RESOURCE_ERROR_OPEN_WRITE => Self::OpenWrite,
            ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE => Self::OpenReadWrite,
            ffi::GST_RESOURCE_ERROR_CLOSE => Self::Close,
            ffi::GST_RESOURCE_ERROR_READ => Self::Read,
            ffi::GST_RESOURCE_ERROR_WRITE => Self::Write,
            ffi::GST_RESOURCE_ERROR_SEEK => Self::Seek,
            ffi::GST_RESOURCE_ERROR_SYNC => Self::Sync,
            ffi::GST_RESOURCE_ERROR_SETTINGS => Self::Settings,
            ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT => Self::NoSpaceLeft,
            ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for ResourceError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_resource_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for ResourceError {
    #[inline]
    #[doc(alias = "gst_resource_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_resource_error_get_type()) }
    }
}

impl glib::HasParamSpec for ResourceError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ResourceError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ResourceError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ResourceError> for glib::Value {
    #[inline]
    fn from(v: ResourceError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different types of seek events. When constructing a seek event with
/// `gst_event_new_seek()` or when doing gst_segment_do_seek ().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstSeekType")]
pub enum SeekType {
    /// no change in position is required
    #[doc(alias = "GST_SEEK_TYPE_NONE")]
    None = ffi::GST_SEEK_TYPE_NONE,
    /// absolute position is requested
    #[doc(alias = "GST_SEEK_TYPE_SET")]
    Set = ffi::GST_SEEK_TYPE_SET,
    /// relative position to duration is requested
    #[doc(alias = "GST_SEEK_TYPE_END")]
    End = ffi::GST_SEEK_TYPE_END,
}

#[doc(hidden)]
impl IntoGlib for SeekType {
    type GlibType = ffi::GstSeekType;

    #[inline]
    fn into_glib(self) -> ffi::GstSeekType {
        self as ffi::GstSeekType
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstSeekType> for SeekType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstSeekType) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_SEEK_TYPE_NONE,
                ffi::GST_SEEK_TYPE_SET,
                ffi::GST_SEEK_TYPE_END
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for SeekType {
    #[inline]
    #[doc(alias = "gst_seek_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_seek_type_get_type()) }
    }
}

impl glib::HasParamSpec for SeekType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SeekType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SeekType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SeekType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SeekType> for glib::Value {
    #[inline]
    fn from(v: SeekType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible states an element can be in. States can be changed using
/// [`ElementExt::set_state()`][crate::prelude::ElementExt::set_state()] and checked using [`ElementExt::state()`][crate::prelude::ElementExt::state()].
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstState")]
pub enum State {
    /// no pending state.
    #[doc(alias = "GST_STATE_VOID_PENDING")]
    VoidPending = ffi::GST_STATE_VOID_PENDING,
    /// the NULL state or initial state of an element.
    #[doc(alias = "GST_STATE_NULL")]
    Null = ffi::GST_STATE_NULL,
    /// the element is ready to go to PAUSED.
    #[doc(alias = "GST_STATE_READY")]
    Ready = ffi::GST_STATE_READY,
    /// the element is PAUSED, it is ready to accept and
    ///  process data. Sink elements however only accept one
    ///  buffer and then block.
    #[doc(alias = "GST_STATE_PAUSED")]
    Paused = ffi::GST_STATE_PAUSED,
    /// the element is PLAYING, the [`Clock`][crate::Clock] is running and
    ///  the data is flowing.
    #[doc(alias = "GST_STATE_PLAYING")]
    Playing = ffi::GST_STATE_PLAYING,
}

#[doc(hidden)]
impl IntoGlib for State {
    type GlibType = ffi::GstState;

    #[inline]
    fn into_glib(self) -> ffi::GstState {
        self as ffi::GstState
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstState> for State {
    #[inline]
    unsafe fn from_glib(value: ffi::GstState) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_STATE_VOID_PENDING,
                ffi::GST_STATE_NULL,
                ffi::GST_STATE_READY,
                ffi::GST_STATE_PAUSED,
                ffi::GST_STATE_PLAYING
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for State {
    #[inline]
    #[doc(alias = "gst_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_state_get_type()) }
    }
}

impl glib::HasParamSpec for State {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for State {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for State {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for State {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<State> for glib::Value {
    #[inline]
    fn from(v: State) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// These are the different state changes an element goes through.
/// [`State::Null`][crate::State::Null] &rArr; [`State::Playing`][crate::State::Playing] is called an upwards state change
/// and [`State::Playing`][crate::State::Playing] &rArr; [`State::Null`][crate::State::Null] a downwards state change.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstStateChange")]
pub enum StateChange {
    /// state change from NULL 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).
    #[doc(alias = "GST_STATE_CHANGE_NULL_TO_READY")]
    NullToReady = ffi::GST_STATE_CHANGE_NULL_TO_READY,
    /// 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 [`StateChangeReturn::Async`][crate::StateChangeReturn::Async] and complete
    ///  the state change when they have enough information. It is a requirement
    ///  for sinks to return [`StateChangeReturn::Async`][crate::StateChangeReturn::Async] and complete the state change
    ///  when they receive the first buffer or [`EventType::Eos`][crate::EventType::Eos] (preroll).
    ///  Sinks also block the dataflow when in PAUSED.
    ///  * A pipeline resets the running_time to 0.
    ///  * Live sources return [`StateChangeReturn::NoPreroll`][crate::StateChangeReturn::NoPreroll] and don't generate data.
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_PAUSED")]
    ReadyToPaused = ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
    /// state change from PAUSED to PLAYING.
    ///  * Most elements ignore this state change.
    ///  * The pipeline selects a [`Clock`][crate::Clock] and distributes this to all the children
    ///  before setting them to PLAYING. This means that it is only allowed to
    ///  synchronize on the [`Clock`][crate::Clock] in the PLAYING state.
    ///  * The pipeline uses the [`Clock`][crate::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 [`StateChangeReturn::Success`][crate::StateChangeReturn::Success].
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PLAYING")]
    PausedToPlaying = ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
    /// state change from PLAYING to PAUSED.
    ///  * Most elements ignore this state change.
    ///  * The pipeline calculates the running_time based on the last selected
    ///  [`Clock`][crate::Clock] and the base_time. It stores this information to continue
    ///  playback when going back to the PLAYING state.
    ///  * Sinks unblock any [`Clock`][crate::Clock] wait calls.
    ///  * When a sink does not have a pending buffer to play, it returns
    ///  [`StateChangeReturn::Async`][crate::StateChangeReturn::Async] from this state change and completes the state
    ///  change when it receives a new buffer or an [`EventType::Eos`][crate::EventType::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
    ///  [`Bin`][crate::Bin] containers.
    ///  * Live sources stop generating data and return [`StateChangeReturn::NoPreroll`][crate::StateChangeReturn::NoPreroll].
    #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PAUSED")]
    PlayingToPaused = ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
    /// 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 [`FlowReturn::Flushing`][crate::FlowReturn::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
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_READY")]
    PausedToReady = ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
    /// state change from READY to NULL.
    ///  * Elements close devices
    ///  * Elements reset any internal state.
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_NULL")]
    ReadyToNull = ffi::GST_STATE_CHANGE_READY_TO_NULL,
    /// state change from NULL to NULL. (Since: 1.14)
    #[doc(alias = "GST_STATE_CHANGE_NULL_TO_NULL")]
    NullToNull = ffi::GST_STATE_CHANGE_NULL_TO_NULL,
    /// state change from READY to READY,
    /// This might happen when going to PAUSED asynchronously failed, in that case
    /// elements should make sure they are in a proper, coherent READY state. (Since: 1.14)
    #[doc(alias = "GST_STATE_CHANGE_READY_TO_READY")]
    ReadyToReady = ffi::GST_STATE_CHANGE_READY_TO_READY,
    /// state change from PAUSED to PAUSED.
    /// This might happen when elements were in PLAYING state and 'lost state',
    /// they should make sure to go back to real 'PAUSED' state (prerolling for example). (Since: 1.14)
    #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PAUSED")]
    PausedToPaused = ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
    /// state change from PLAYING to PLAYING. (Since: 1.14)
    #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PLAYING")]
    PlayingToPlaying = ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING,
}

impl StateChange {
    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_state_change_get_name(self.into_glib())
                    .as_ref()
                    .expect("gst_state_change_get_name returned NULL"),
            )
        }
    }
}

impl std::fmt::Display for StateChange {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for StateChange {
    type GlibType = ffi::GstStateChange;

    #[inline]
    fn into_glib(self) -> ffi::GstStateChange {
        self as ffi::GstStateChange
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStateChange> for StateChange {
    #[inline]
    unsafe fn from_glib(value: ffi::GstStateChange) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_STATE_CHANGE_NULL_TO_READY,
                ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
                ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
                ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
                ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
                ffi::GST_STATE_CHANGE_READY_TO_NULL,
                ffi::GST_STATE_CHANGE_NULL_TO_NULL,
                ffi::GST_STATE_CHANGE_READY_TO_READY,
                ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
                ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for StateChange {
    #[inline]
    #[doc(alias = "gst_state_change_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_state_change_get_type()) }
    }
}

impl glib::HasParamSpec for StateChange {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StateChange {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StateChange {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StateChange {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StateChange> for glib::Value {
    #[inline]
    fn from(v: StateChange) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible return values from a state change function such as
/// [`ElementExt::set_state()`][crate::prelude::ElementExt::set_state()]. Only [`Failure`][Self::Failure] is a real failure.
#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstStateChangeReturn")]
pub enum StateChangeReturn {
    /// the state change failed
    #[doc(alias = "GST_STATE_CHANGE_FAILURE")]
    Failure = ffi::GST_STATE_CHANGE_FAILURE,
    /// the state change succeeded
    #[doc(alias = "GST_STATE_CHANGE_SUCCESS")]
    Success = ffi::GST_STATE_CHANGE_SUCCESS,
    /// the state change will happen asynchronously
    #[doc(alias = "GST_STATE_CHANGE_ASYNC")]
    Async = ffi::GST_STATE_CHANGE_ASYNC,
    /// the state change succeeded but the element
    ///  cannot produce data in [`State::Paused`][crate::State::Paused].
    ///  This typically happens with live sources.
    #[doc(alias = "GST_STATE_CHANGE_NO_PREROLL")]
    NoPreroll = ffi::GST_STATE_CHANGE_NO_PREROLL,
}

#[doc(hidden)]
impl IntoGlib for StateChangeReturn {
    type GlibType = ffi::GstStateChangeReturn;

    #[inline]
    fn into_glib(self) -> ffi::GstStateChangeReturn {
        self as ffi::GstStateChangeReturn
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStateChangeReturn> for StateChangeReturn {
    #[inline]
    unsafe fn from_glib(value: ffi::GstStateChangeReturn) -> Self {
        skip_assert_initialized!();

        debug_assert!(
            [
                ffi::GST_STATE_CHANGE_FAILURE,
                ffi::GST_STATE_CHANGE_SUCCESS,
                ffi::GST_STATE_CHANGE_ASYNC,
                ffi::GST_STATE_CHANGE_NO_PREROLL
            ]
            .contains(&value)
        );
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for StateChangeReturn {
    #[inline]
    #[doc(alias = "gst_state_change_return_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_state_change_return_get_type()) }
    }
}

impl glib::HasParamSpec for StateChangeReturn {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StateChangeReturn {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StateChangeReturn {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StateChangeReturn {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StateChangeReturn> for glib::Value {
    #[inline]
    fn from(v: StateChangeReturn) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Stream errors are for anything related to the stream being processed:
/// format errors, media type errors, ...
/// They're typically used by decoders, demuxers, converters, ...
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStreamError")]
pub enum StreamError {
    /// a general error which doesn't fit in any other
    /// category. Make sure you add a custom message to the error call.
    #[doc(alias = "GST_STREAM_ERROR_FAILED")]
    Failed,
    /// do not use this except as a placeholder for
    /// deciding where to go while developing code.
    #[doc(alias = "GST_STREAM_ERROR_TOO_LAZY")]
    TooLazy,
    /// use this when you do not want to implement
    /// this functionality yet.
    #[doc(alias = "GST_STREAM_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    /// used when the element doesn't know the
    /// stream's type.
    #[doc(alias = "GST_STREAM_ERROR_TYPE_NOT_FOUND")]
    TypeNotFound,
    /// used when the element doesn't handle this type
    /// of stream.
    #[doc(alias = "GST_STREAM_ERROR_WRONG_TYPE")]
    WrongType,
    /// used when there's no codec to handle the
    /// stream's type.
    #[doc(alias = "GST_STREAM_ERROR_CODEC_NOT_FOUND")]
    CodecNotFound,
    /// used when decoding fails.
    #[doc(alias = "GST_STREAM_ERROR_DECODE")]
    Decode,
    /// used when encoding fails.
    #[doc(alias = "GST_STREAM_ERROR_ENCODE")]
    Encode,
    /// used when demuxing fails.
    #[doc(alias = "GST_STREAM_ERROR_DEMUX")]
    Demux,
    /// used when muxing fails.
    #[doc(alias = "GST_STREAM_ERROR_MUX")]
    Mux,
    /// used when the stream is of the wrong format
    /// (for example, wrong caps).
    #[doc(alias = "GST_STREAM_ERROR_FORMAT")]
    Format,
    /// used when the stream is encrypted and can't be
    /// decrypted because this is not supported by the element.
    #[doc(alias = "GST_STREAM_ERROR_DECRYPT")]
    Decrypt,
    /// used when the stream is encrypted and
    /// can't be decrypted because no suitable key is available.
    #[doc(alias = "GST_STREAM_ERROR_DECRYPT_NOKEY")]
    DecryptNokey,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for StreamError {
    type GlibType = ffi::GstStreamError;

    fn into_glib(self) -> ffi::GstStreamError {
        match self {
            Self::Failed => ffi::GST_STREAM_ERROR_FAILED,
            Self::TooLazy => ffi::GST_STREAM_ERROR_TOO_LAZY,
            Self::NotImplemented => ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED,
            Self::TypeNotFound => ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND,
            Self::WrongType => ffi::GST_STREAM_ERROR_WRONG_TYPE,
            Self::CodecNotFound => ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND,
            Self::Decode => ffi::GST_STREAM_ERROR_DECODE,
            Self::Encode => ffi::GST_STREAM_ERROR_ENCODE,
            Self::Demux => ffi::GST_STREAM_ERROR_DEMUX,
            Self::Mux => ffi::GST_STREAM_ERROR_MUX,
            Self::Format => ffi::GST_STREAM_ERROR_FORMAT,
            Self::Decrypt => ffi::GST_STREAM_ERROR_DECRYPT,
            Self::DecryptNokey => ffi::GST_STREAM_ERROR_DECRYPT_NOKEY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStreamError> for StreamError {
    unsafe fn from_glib(value: ffi::GstStreamError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_STREAM_ERROR_FAILED => Self::Failed,
            ffi::GST_STREAM_ERROR_TOO_LAZY => Self::TooLazy,
            ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
            ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND => Self::TypeNotFound,
            ffi::GST_STREAM_ERROR_WRONG_TYPE => Self::WrongType,
            ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND => Self::CodecNotFound,
            ffi::GST_STREAM_ERROR_DECODE => Self::Decode,
            ffi::GST_STREAM_ERROR_ENCODE => Self::Encode,
            ffi::GST_STREAM_ERROR_DEMUX => Self::Demux,
            ffi::GST_STREAM_ERROR_MUX => Self::Mux,
            ffi::GST_STREAM_ERROR_FORMAT => Self::Format,
            ffi::GST_STREAM_ERROR_DECRYPT => Self::Decrypt,
            ffi::GST_STREAM_ERROR_DECRYPT_NOKEY => Self::DecryptNokey,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for StreamError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_stream_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for StreamError {
    #[inline]
    #[doc(alias = "gst_stream_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_stream_error_get_type()) }
    }
}

impl glib::HasParamSpec for StreamError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StreamError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StreamError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StreamError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StreamError> for glib::Value {
    #[inline]
    fn from(v: StreamError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of a `GST_MESSAGE_STREAM_STATUS`. The stream status messages inform the
/// application of new streaming threads and their status.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStreamStatusType")]
pub enum StreamStatusType {
    /// A new thread need to be created.
    #[doc(alias = "GST_STREAM_STATUS_TYPE_CREATE")]
    Create,
    /// a thread entered its loop function
    #[doc(alias = "GST_STREAM_STATUS_TYPE_ENTER")]
    Enter,
    /// a thread left its loop function
    #[doc(alias = "GST_STREAM_STATUS_TYPE_LEAVE")]
    Leave,
    /// a thread is destroyed
    #[doc(alias = "GST_STREAM_STATUS_TYPE_DESTROY")]
    Destroy,
    /// a thread is started
    #[doc(alias = "GST_STREAM_STATUS_TYPE_START")]
    Start,
    /// a thread is paused
    #[doc(alias = "GST_STREAM_STATUS_TYPE_PAUSE")]
    Pause,
    /// a thread is stopped
    #[doc(alias = "GST_STREAM_STATUS_TYPE_STOP")]
    Stop,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for StreamStatusType {
    type GlibType = ffi::GstStreamStatusType;

    #[inline]
    fn into_glib(self) -> ffi::GstStreamStatusType {
        match self {
            Self::Create => ffi::GST_STREAM_STATUS_TYPE_CREATE,
            Self::Enter => ffi::GST_STREAM_STATUS_TYPE_ENTER,
            Self::Leave => ffi::GST_STREAM_STATUS_TYPE_LEAVE,
            Self::Destroy => ffi::GST_STREAM_STATUS_TYPE_DESTROY,
            Self::Start => ffi::GST_STREAM_STATUS_TYPE_START,
            Self::Pause => ffi::GST_STREAM_STATUS_TYPE_PAUSE,
            Self::Stop => ffi::GST_STREAM_STATUS_TYPE_STOP,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStreamStatusType> for StreamStatusType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstStreamStatusType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_STREAM_STATUS_TYPE_CREATE => Self::Create,
            ffi::GST_STREAM_STATUS_TYPE_ENTER => Self::Enter,
            ffi::GST_STREAM_STATUS_TYPE_LEAVE => Self::Leave,
            ffi::GST_STREAM_STATUS_TYPE_DESTROY => Self::Destroy,
            ffi::GST_STREAM_STATUS_TYPE_START => Self::Start,
            ffi::GST_STREAM_STATUS_TYPE_PAUSE => Self::Pause,
            ffi::GST_STREAM_STATUS_TYPE_STOP => Self::Stop,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for StreamStatusType {
    #[inline]
    #[doc(alias = "gst_stream_status_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_stream_status_type_get_type()) }
    }
}

impl glib::HasParamSpec for StreamStatusType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StreamStatusType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StreamStatusType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StreamStatusType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StreamStatusType> for glib::Value {
    #[inline]
    fn from(v: StreamStatusType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of a `GST_MESSAGE_STRUCTURE_CHANGE`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstStructureChangeType")]
pub enum StructureChangeType {
    /// Pad linking is starting or done.
    #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_LINK")]
    Link,
    /// Pad unlinking is starting or done.
    #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK")]
    Unlink,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for StructureChangeType {
    type GlibType = ffi::GstStructureChangeType;

    #[inline]
    fn into_glib(self) -> ffi::GstStructureChangeType {
        match self {
            Self::Link => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK,
            Self::Unlink => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstStructureChangeType> for StructureChangeType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstStructureChangeType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK => Self::Link,
            ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK => Self::Unlink,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for StructureChangeType {
    #[inline]
    #[doc(alias = "gst_structure_change_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_structure_change_type_get_type()) }
    }
}

impl glib::HasParamSpec for StructureChangeType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StructureChangeType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StructureChangeType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StructureChangeType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StructureChangeType> for glib::Value {
    #[inline]
    fn from(v: StructureChangeType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Extra tag flags used when registering tags.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagFlag")]
pub enum TagFlag {
    /// undefined flag
    #[doc(alias = "GST_TAG_FLAG_UNDEFINED")]
    Undefined,
    /// tag is meta data
    #[doc(alias = "GST_TAG_FLAG_META")]
    Meta,
    /// tag is encoded
    #[doc(alias = "GST_TAG_FLAG_ENCODED")]
    Encoded,
    /// tag is decoded
    #[doc(alias = "GST_TAG_FLAG_DECODED")]
    Decoded,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TagFlag {
    type GlibType = ffi::GstTagFlag;

    #[inline]
    fn into_glib(self) -> ffi::GstTagFlag {
        match self {
            Self::Undefined => ffi::GST_TAG_FLAG_UNDEFINED,
            Self::Meta => ffi::GST_TAG_FLAG_META,
            Self::Encoded => ffi::GST_TAG_FLAG_ENCODED,
            Self::Decoded => ffi::GST_TAG_FLAG_DECODED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagFlag> for TagFlag {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTagFlag) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TAG_FLAG_UNDEFINED => Self::Undefined,
            ffi::GST_TAG_FLAG_META => Self::Meta,
            ffi::GST_TAG_FLAG_ENCODED => Self::Encoded,
            ffi::GST_TAG_FLAG_DECODED => Self::Decoded,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TagFlag {
    #[inline]
    #[doc(alias = "gst_tag_flag_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_tag_flag_get_type()) }
    }
}

impl glib::HasParamSpec for TagFlag {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TagFlag {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TagFlag {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TagFlag {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TagFlag> for glib::Value {
    #[inline]
    fn from(v: TagFlag) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// 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 [`TagSetterExt::merge_tags()`][crate::prelude::TagSetterExt::merge_tags()] / `gst_tag_setter_add_tags()` or a
/// [`EventType::Tag`][crate::EventType::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 | A + B | A + !B | !A + B | !A + !B |
/// | ----------- | ----- | ------ | ------ | ------- |
/// | REPLACE_ALL | B | ø | B | ø |
/// | REPLACE | B | A | B | ø |
/// | APPEND | A, B | A | B | ø |
/// | PREPEND | B, A | A | B | ø |
/// | KEEP | A | A | B | ø |
/// | KEEP_ALL | A | A | ø | ø |
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagMergeMode")]
pub enum TagMergeMode {
    /// undefined merge mode
    #[doc(alias = "GST_TAG_MERGE_UNDEFINED")]
    Undefined,
    /// replace all tags (clear list and append)
    #[doc(alias = "GST_TAG_MERGE_REPLACE_ALL")]
    ReplaceAll,
    /// replace tags
    #[doc(alias = "GST_TAG_MERGE_REPLACE")]
    Replace,
    /// append tags
    #[doc(alias = "GST_TAG_MERGE_APPEND")]
    Append,
    /// prepend tags
    #[doc(alias = "GST_TAG_MERGE_PREPEND")]
    Prepend,
    /// keep existing tags
    #[doc(alias = "GST_TAG_MERGE_KEEP")]
    Keep,
    /// keep all existing tags
    #[doc(alias = "GST_TAG_MERGE_KEEP_ALL")]
    KeepAll,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TagMergeMode {
    type GlibType = ffi::GstTagMergeMode;

    #[inline]
    fn into_glib(self) -> ffi::GstTagMergeMode {
        match self {
            Self::Undefined => ffi::GST_TAG_MERGE_UNDEFINED,
            Self::ReplaceAll => ffi::GST_TAG_MERGE_REPLACE_ALL,
            Self::Replace => ffi::GST_TAG_MERGE_REPLACE,
            Self::Append => ffi::GST_TAG_MERGE_APPEND,
            Self::Prepend => ffi::GST_TAG_MERGE_PREPEND,
            Self::Keep => ffi::GST_TAG_MERGE_KEEP,
            Self::KeepAll => ffi::GST_TAG_MERGE_KEEP_ALL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagMergeMode> for TagMergeMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTagMergeMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TAG_MERGE_UNDEFINED => Self::Undefined,
            ffi::GST_TAG_MERGE_REPLACE_ALL => Self::ReplaceAll,
            ffi::GST_TAG_MERGE_REPLACE => Self::Replace,
            ffi::GST_TAG_MERGE_APPEND => Self::Append,
            ffi::GST_TAG_MERGE_PREPEND => Self::Prepend,
            ffi::GST_TAG_MERGE_KEEP => Self::Keep,
            ffi::GST_TAG_MERGE_KEEP_ALL => Self::KeepAll,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TagMergeMode {
    #[inline]
    #[doc(alias = "gst_tag_merge_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_tag_merge_mode_get_type()) }
    }
}

impl glib::HasParamSpec for TagMergeMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TagMergeMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TagMergeMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TagMergeMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TagMergeMode> for glib::Value {
    #[inline]
    fn from(v: TagMergeMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// GstTagScope specifies if a taglist applies to the complete
/// medium or only to one single stream.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTagScope")]
pub enum TagScope {
    /// tags specific to this single stream
    #[doc(alias = "GST_TAG_SCOPE_STREAM")]
    Stream,
    /// global tags for the complete medium
    #[doc(alias = "GST_TAG_SCOPE_GLOBAL")]
    Global,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TagScope {
    type GlibType = ffi::GstTagScope;

    #[inline]
    fn into_glib(self) -> ffi::GstTagScope {
        match self {
            Self::Stream => ffi::GST_TAG_SCOPE_STREAM,
            Self::Global => ffi::GST_TAG_SCOPE_GLOBAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTagScope> for TagScope {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTagScope) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TAG_SCOPE_STREAM => Self::Stream,
            ffi::GST_TAG_SCOPE_GLOBAL => Self::Global,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TagScope {
    #[inline]
    #[doc(alias = "gst_tag_scope_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_tag_scope_get_type()) }
    }
}

impl glib::HasParamSpec for TagScope {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TagScope {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TagScope {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TagScope {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TagScope> for glib::Value {
    #[inline]
    fn from(v: TagScope) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different states a task can be in
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTaskState")]
pub enum TaskState {
    /// the task is started and running
    #[doc(alias = "GST_TASK_STARTED")]
    Started,
    /// the task is stopped
    #[doc(alias = "GST_TASK_STOPPED")]
    Stopped,
    /// the task is paused
    #[doc(alias = "GST_TASK_PAUSED")]
    Paused,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TaskState {
    type GlibType = ffi::GstTaskState;

    #[inline]
    fn into_glib(self) -> ffi::GstTaskState {
        match self {
            Self::Started => ffi::GST_TASK_STARTED,
            Self::Stopped => ffi::GST_TASK_STOPPED,
            Self::Paused => ffi::GST_TASK_PAUSED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTaskState> for TaskState {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTaskState) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TASK_STARTED => Self::Started,
            ffi::GST_TASK_STOPPED => Self::Stopped,
            ffi::GST_TASK_PAUSED => Self::Paused,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TaskState {
    #[inline]
    #[doc(alias = "gst_task_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_task_state_get_type()) }
    }
}

impl glib::HasParamSpec for TaskState {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TaskState {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TaskState {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TaskState {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TaskState> for glib::Value {
    #[inline]
    fn from(v: TaskState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different types of TOC entries (see [`TocEntry`][crate::TocEntry]).
///
/// There are two types of TOC entries: alternatives or parts in a sequence.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocEntryType")]
pub enum TocEntryType {
    /// entry is an angle (i.e. an alternative)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_ANGLE")]
    Angle,
    /// entry is a version (i.e. alternative)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_VERSION")]
    Version,
    /// entry is an edition (i.e. alternative)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_EDITION")]
    Edition,
    /// invalid entry type value
    #[doc(alias = "GST_TOC_ENTRY_TYPE_INVALID")]
    Invalid,
    /// entry is a title (i.e. a part of a sequence)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_TITLE")]
    Title,
    /// entry is a track (i.e. a part of a sequence)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_TRACK")]
    Track,
    /// entry is a chapter (i.e. a part of a sequence)
    #[doc(alias = "GST_TOC_ENTRY_TYPE_CHAPTER")]
    Chapter,
    #[doc(hidden)]
    __Unknown(i32),
}

impl TocEntryType {
    pub fn nick<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::gst_toc_entry_type_get_nick(self.into_glib())
                    .as_ref()
                    .expect("gst_toc_entry_type_get_nick returned NULL"),
            )
        }
    }
}

#[doc(hidden)]
impl IntoGlib for TocEntryType {
    type GlibType = ffi::GstTocEntryType;

    #[inline]
    fn into_glib(self) -> ffi::GstTocEntryType {
        match self {
            Self::Angle => ffi::GST_TOC_ENTRY_TYPE_ANGLE,
            Self::Version => ffi::GST_TOC_ENTRY_TYPE_VERSION,
            Self::Edition => ffi::GST_TOC_ENTRY_TYPE_EDITION,
            Self::Invalid => ffi::GST_TOC_ENTRY_TYPE_INVALID,
            Self::Title => ffi::GST_TOC_ENTRY_TYPE_TITLE,
            Self::Track => ffi::GST_TOC_ENTRY_TYPE_TRACK,
            Self::Chapter => ffi::GST_TOC_ENTRY_TYPE_CHAPTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocEntryType> for TocEntryType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTocEntryType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TOC_ENTRY_TYPE_ANGLE => Self::Angle,
            ffi::GST_TOC_ENTRY_TYPE_VERSION => Self::Version,
            ffi::GST_TOC_ENTRY_TYPE_EDITION => Self::Edition,
            ffi::GST_TOC_ENTRY_TYPE_INVALID => Self::Invalid,
            ffi::GST_TOC_ENTRY_TYPE_TITLE => Self::Title,
            ffi::GST_TOC_ENTRY_TYPE_TRACK => Self::Track,
            ffi::GST_TOC_ENTRY_TYPE_CHAPTER => Self::Chapter,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TocEntryType {
    #[inline]
    #[doc(alias = "gst_toc_entry_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_toc_entry_type_get_type()) }
    }
}

impl glib::HasParamSpec for TocEntryType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TocEntryType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TocEntryType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TocEntryType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TocEntryType> for glib::Value {
    #[inline]
    fn from(v: TocEntryType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// How a [`TocEntry`][crate::TocEntry] should be repeated. By default, entries are played a
/// single time.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocLoopType")]
pub enum TocLoopType {
    /// single forward playback
    #[doc(alias = "GST_TOC_LOOP_NONE")]
    None,
    /// repeat forward
    #[doc(alias = "GST_TOC_LOOP_FORWARD")]
    Forward,
    /// repeat backward
    #[doc(alias = "GST_TOC_LOOP_REVERSE")]
    Reverse,
    /// repeat forward and backward
    #[doc(alias = "GST_TOC_LOOP_PING_PONG")]
    PingPong,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TocLoopType {
    type GlibType = ffi::GstTocLoopType;

    #[inline]
    fn into_glib(self) -> ffi::GstTocLoopType {
        match self {
            Self::None => ffi::GST_TOC_LOOP_NONE,
            Self::Forward => ffi::GST_TOC_LOOP_FORWARD,
            Self::Reverse => ffi::GST_TOC_LOOP_REVERSE,
            Self::PingPong => ffi::GST_TOC_LOOP_PING_PONG,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocLoopType> for TocLoopType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTocLoopType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TOC_LOOP_NONE => Self::None,
            ffi::GST_TOC_LOOP_FORWARD => Self::Forward,
            ffi::GST_TOC_LOOP_REVERSE => Self::Reverse,
            ffi::GST_TOC_LOOP_PING_PONG => Self::PingPong,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TocLoopType {
    #[inline]
    #[doc(alias = "gst_toc_loop_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_toc_loop_type_get_type()) }
    }
}

impl glib::HasParamSpec for TocLoopType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TocLoopType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TocLoopType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TocLoopType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TocLoopType> for glib::Value {
    #[inline]
    fn from(v: TocLoopType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The scope of a TOC.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTocScope")]
pub enum TocScope {
    /// global TOC representing all selectable options
    ///  (this is what applications are usually interested in)
    #[doc(alias = "GST_TOC_SCOPE_GLOBAL")]
    Global,
    /// 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)
    #[doc(alias = "GST_TOC_SCOPE_CURRENT")]
    Current,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TocScope {
    type GlibType = ffi::GstTocScope;

    #[inline]
    fn into_glib(self) -> ffi::GstTocScope {
        match self {
            Self::Global => ffi::GST_TOC_SCOPE_GLOBAL,
            Self::Current => ffi::GST_TOC_SCOPE_CURRENT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTocScope> for TocScope {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTocScope) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TOC_SCOPE_GLOBAL => Self::Global,
            ffi::GST_TOC_SCOPE_CURRENT => Self::Current,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TocScope {
    #[inline]
    #[doc(alias = "gst_toc_scope_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_toc_scope_get_type()) }
    }
}

impl glib::HasParamSpec for TocScope {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TocScope {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TocScope {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TocScope {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TocScope> for glib::Value {
    #[inline]
    fn from(v: TocScope) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The probability of the typefind function. Higher values have more certainty
/// in doing a reliable typefind.
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstTypeFindProbability")]
pub enum TypeFindProbability {
    /// type undetected.
    #[doc(alias = "GST_TYPE_FIND_NONE")]
    None,
    /// unlikely typefind.
    #[doc(alias = "GST_TYPE_FIND_MINIMUM")]
    Minimum,
    /// possible type detected.
    #[doc(alias = "GST_TYPE_FIND_POSSIBLE")]
    Possible,
    /// likely a type was detected.
    #[doc(alias = "GST_TYPE_FIND_LIKELY")]
    Likely,
    /// nearly certain that a type was detected.
    #[doc(alias = "GST_TYPE_FIND_NEARLY_CERTAIN")]
    NearlyCertain,
    /// very certain a type was detected.
    #[doc(alias = "GST_TYPE_FIND_MAXIMUM")]
    Maximum,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TypeFindProbability {
    type GlibType = ffi::GstTypeFindProbability;

    #[inline]
    fn into_glib(self) -> ffi::GstTypeFindProbability {
        match self {
            Self::None => ffi::GST_TYPE_FIND_NONE,
            Self::Minimum => ffi::GST_TYPE_FIND_MINIMUM,
            Self::Possible => ffi::GST_TYPE_FIND_POSSIBLE,
            Self::Likely => ffi::GST_TYPE_FIND_LIKELY,
            Self::NearlyCertain => ffi::GST_TYPE_FIND_NEARLY_CERTAIN,
            Self::Maximum => ffi::GST_TYPE_FIND_MAXIMUM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstTypeFindProbability> for TypeFindProbability {
    #[inline]
    unsafe fn from_glib(value: ffi::GstTypeFindProbability) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_TYPE_FIND_NONE => Self::None,
            ffi::GST_TYPE_FIND_MINIMUM => Self::Minimum,
            ffi::GST_TYPE_FIND_POSSIBLE => Self::Possible,
            ffi::GST_TYPE_FIND_LIKELY => Self::Likely,
            ffi::GST_TYPE_FIND_NEARLY_CERTAIN => Self::NearlyCertain,
            ffi::GST_TYPE_FIND_MAXIMUM => Self::Maximum,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TypeFindProbability {
    #[inline]
    #[doc(alias = "gst_type_find_probability_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_type_find_probability_get_type()) }
    }
}

impl glib::HasParamSpec for TypeFindProbability {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TypeFindProbability {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TypeFindProbability {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TypeFindProbability {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TypeFindProbability> for glib::Value {
    #[inline]
    fn from(v: TypeFindProbability) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Different URI-related errors that can occur.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GstURIError")]
pub enum URIError {
    /// The protocol is not supported
    #[doc(alias = "GST_URI_ERROR_UNSUPPORTED_PROTOCOL")]
    UnsupportedProtocol,
    /// There was a problem with the URI
    #[doc(alias = "GST_URI_ERROR_BAD_URI")]
    BadUri,
    /// Could not set or change the URI because the
    ///  URI handler was in a state where that is not possible or not permitted
    #[doc(alias = "GST_URI_ERROR_BAD_STATE")]
    BadState,
    /// There was a problem with the entity that
    ///  the URI references
    #[doc(alias = "GST_URI_ERROR_BAD_REFERENCE")]
    BadReference,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for URIError {
    type GlibType = ffi::GstURIError;

    #[inline]
    fn into_glib(self) -> ffi::GstURIError {
        match self {
            Self::UnsupportedProtocol => ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
            Self::BadUri => ffi::GST_URI_ERROR_BAD_URI,
            Self::BadState => ffi::GST_URI_ERROR_BAD_STATE,
            Self::BadReference => ffi::GST_URI_ERROR_BAD_REFERENCE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstURIError> for URIError {
    #[inline]
    unsafe fn from_glib(value: ffi::GstURIError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL => Self::UnsupportedProtocol,
            ffi::GST_URI_ERROR_BAD_URI => Self::BadUri,
            ffi::GST_URI_ERROR_BAD_STATE => Self::BadState,
            ffi::GST_URI_ERROR_BAD_REFERENCE => Self::BadReference,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for URIError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gst_uri_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for URIError {
    #[inline]
    #[doc(alias = "gst_uri_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_uri_error_get_type()) }
    }
}

impl glib::HasParamSpec for URIError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for URIError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for URIError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for URIError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<URIError> for glib::Value {
    #[inline]
    fn from(v: URIError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different types of URI direction.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
#[repr(i32)]
#[doc(alias = "GstURIType")]
pub enum URIType {
    /// The URI direction is unknown
    #[doc(alias = "GST_URI_UNKNOWN")]
    Unknown = ffi::GST_URI_UNKNOWN,
    /// The URI is a consumer.
    #[doc(alias = "GST_URI_SINK")]
    Sink = ffi::GST_URI_SINK,
    /// The URI is a producer.
    #[doc(alias = "GST_URI_SRC")]
    Src = ffi::GST_URI_SRC,
}

#[doc(hidden)]
impl IntoGlib for URIType {
    type GlibType = ffi::GstURIType;

    #[inline]
    fn into_glib(self) -> ffi::GstURIType {
        self as ffi::GstURIType
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstURIType> for URIType {
    #[inline]
    unsafe fn from_glib(value: ffi::GstURIType) -> Self {
        skip_assert_initialized!();

        debug_assert!([ffi::GST_URI_UNKNOWN, ffi::GST_URI_SINK, ffi::GST_URI_SRC].contains(&value));
        unsafe { std::mem::transmute(value) }
    }
}

impl StaticType for URIType {
    #[inline]
    #[doc(alias = "gst_uri_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gst_uri_type_get_type()) }
    }
}

impl glib::HasParamSpec for URIType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for URIType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for URIType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for URIType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<URIType> for glib::Value {
    #[inline]
    fn from(v: URIType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}