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

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

/// Audio channel positions.
///
/// These are the channels defined in SMPTE 2036-2-2008
/// Table 1 for 22.2 audio systems with the Surround and Wide channels from
/// DTS Coherent Acoustics (v.1.3.1) and 10.2 and 7.1 layouts. In the caps the
/// actual channel layout is expressed with a channel count and a channel mask,
/// which describes the existing channels. The positions in the bit mask correspond
/// to the enum values.
/// For negotiation it is allowed to have more bits set in the channel mask than
/// the number of channels to specify the allowed channel positions but this is
/// not allowed in negotiated caps. It is not allowed in any situation other
/// than the one mentioned below to have less bits set in the channel mask than
/// the number of channels.
///
/// `AudioChannelPosition::Mono` can only be used with a single mono channel that
/// has no direction information and would be mixed into all directional channels.
/// This is expressed in caps by having a single channel and no channel mask.
///
/// `AudioChannelPosition::None` can only be used if all channels have this position.
/// This is expressed in caps by having a channel mask with no bits set.
///
/// As another special case it is allowed to have two channels without a channel mask.
/// This implicitly means that this is a stereo stream with a front left and front right
/// channel.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioChannelPosition {
    /// used for position-less channels, e.g.
    ///  from a sound card that records 1024 channels; mutually exclusive with
    ///  any other channel position
    None,
    /// Mono without direction;
    ///  can only be used with 1 channel
    Mono,
    /// invalid position
    Invalid,
    /// Front left
    FrontLeft,
    /// Front right
    FrontRight,
    /// Front center
    FrontCenter,
    /// Low-frequency effects 1 (subwoofer)
    Lfe1,
    /// Rear left
    RearLeft,
    /// Rear right
    RearRight,
    /// Front left of center
    FrontLeftOfCenter,
    /// Front right of center
    FrontRightOfCenter,
    /// Rear center
    RearCenter,
    /// Low-frequency effects 2 (subwoofer)
    Lfe2,
    /// Side left
    SideLeft,
    /// Side right
    SideRight,
    /// Top front left
    TopFrontLeft,
    /// Top front right
    TopFrontRight,
    /// Top front center
    TopFrontCenter,
    /// Top center
    TopCenter,
    /// Top rear left
    TopRearLeft,
    /// Top rear right
    TopRearRight,
    /// Top side right
    TopSideLeft,
    /// Top rear right
    TopSideRight,
    /// Top rear center
    TopRearCenter,
    /// Bottom front center
    BottomFrontCenter,
    /// Bottom front left
    BottomFrontLeft,
    /// Bottom front right
    BottomFrontRight,
    /// Wide left (between front left and side left)
    WideLeft,
    /// Wide right (between front right and side right)
    WideRight,
    /// Surround left (between rear left and side left)
    SurroundLeft,
    /// Surround right (between rear right and side right)
    SurroundRight,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioChannelPosition {
    type GlibType = gst_audio_sys::GstAudioChannelPosition;

    fn to_glib(&self) -> gst_audio_sys::GstAudioChannelPosition {
        match *self {
            AudioChannelPosition::None => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_NONE,
            AudioChannelPosition::Mono => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_MONO,
            AudioChannelPosition::Invalid => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_INVALID,
            AudioChannelPosition::FrontLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
            AudioChannelPosition::FrontRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
            }
            AudioChannelPosition::FrontCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER
            }
            AudioChannelPosition::Lfe1 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE1,
            AudioChannelPosition::RearLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
            AudioChannelPosition::RearRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
            AudioChannelPosition::FrontLeftOfCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
            }
            AudioChannelPosition::FrontRightOfCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
            }
            AudioChannelPosition::RearCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_CENTER
            }
            AudioChannelPosition::Lfe2 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE2,
            AudioChannelPosition::SideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
            AudioChannelPosition::SideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT,
            AudioChannelPosition::TopFrontLeft => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT
            }
            AudioChannelPosition::TopFrontRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT
            }
            AudioChannelPosition::TopFrontCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER
            }
            AudioChannelPosition::TopCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_CENTER,
            AudioChannelPosition::TopRearLeft => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT
            }
            AudioChannelPosition::TopRearRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT
            }
            AudioChannelPosition::TopSideLeft => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT
            }
            AudioChannelPosition::TopSideRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT
            }
            AudioChannelPosition::TopRearCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER
            }
            AudioChannelPosition::BottomFrontCenter => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER
            }
            AudioChannelPosition::BottomFrontLeft => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT
            }
            AudioChannelPosition::BottomFrontRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT
            }
            AudioChannelPosition::WideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_LEFT,
            AudioChannelPosition::WideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_RIGHT,
            AudioChannelPosition::SurroundLeft => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_LEFT
            }
            AudioChannelPosition::SurroundRight => {
                gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_RIGHT
            }
            AudioChannelPosition::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioChannelPosition> for AudioChannelPosition {
    fn from_glib(value: gst_audio_sys::GstAudioChannelPosition) -> Self {
        skip_assert_initialized!();
        match value {
            -3 => AudioChannelPosition::None,
            -2 => AudioChannelPosition::Mono,
            -1 => AudioChannelPosition::Invalid,
            0 => AudioChannelPosition::FrontLeft,
            1 => AudioChannelPosition::FrontRight,
            2 => AudioChannelPosition::FrontCenter,
            3 => AudioChannelPosition::Lfe1,
            4 => AudioChannelPosition::RearLeft,
            5 => AudioChannelPosition::RearRight,
            6 => AudioChannelPosition::FrontLeftOfCenter,
            7 => AudioChannelPosition::FrontRightOfCenter,
            8 => AudioChannelPosition::RearCenter,
            9 => AudioChannelPosition::Lfe2,
            10 => AudioChannelPosition::SideLeft,
            11 => AudioChannelPosition::SideRight,
            12 => AudioChannelPosition::TopFrontLeft,
            13 => AudioChannelPosition::TopFrontRight,
            14 => AudioChannelPosition::TopFrontCenter,
            15 => AudioChannelPosition::TopCenter,
            16 => AudioChannelPosition::TopRearLeft,
            17 => AudioChannelPosition::TopRearRight,
            18 => AudioChannelPosition::TopSideLeft,
            19 => AudioChannelPosition::TopSideRight,
            20 => AudioChannelPosition::TopRearCenter,
            21 => AudioChannelPosition::BottomFrontCenter,
            22 => AudioChannelPosition::BottomFrontLeft,
            23 => AudioChannelPosition::BottomFrontRight,
            24 => AudioChannelPosition::WideLeft,
            25 => AudioChannelPosition::WideRight,
            26 => AudioChannelPosition::SurroundLeft,
            27 => AudioChannelPosition::SurroundRight,
            value => AudioChannelPosition::__Unknown(value),
        }
    }
}

impl StaticType for AudioChannelPosition {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_channel_position_get_type()) }
    }
}

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioDitherMethod {
    None,
    Rpdf,
    Tpdf,
    TpdfHf,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioDitherMethod {
    type GlibType = gst_audio_sys::GstAudioDitherMethod;

    fn to_glib(&self) -> gst_audio_sys::GstAudioDitherMethod {
        match *self {
            AudioDitherMethod::None => gst_audio_sys::GST_AUDIO_DITHER_NONE,
            AudioDitherMethod::Rpdf => gst_audio_sys::GST_AUDIO_DITHER_RPDF,
            AudioDitherMethod::Tpdf => gst_audio_sys::GST_AUDIO_DITHER_TPDF,
            AudioDitherMethod::TpdfHf => gst_audio_sys::GST_AUDIO_DITHER_TPDF_HF,
            AudioDitherMethod::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioDitherMethod> for AudioDitherMethod {
    fn from_glib(value: gst_audio_sys::GstAudioDitherMethod) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioDitherMethod::None,
            1 => AudioDitherMethod::Rpdf,
            2 => AudioDitherMethod::Tpdf,
            3 => AudioDitherMethod::TpdfHf,
            value => AudioDitherMethod::__Unknown(value),
        }
    }
}

impl StaticType for AudioDitherMethod {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_dither_method_get_type()) }
    }
}

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

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

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

/// Enum value describing the most common audio formats.
#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioFormat {
    /// unknown or unset audio format
    Unknown,
    /// encoded audio format
    Encoded,
    /// 8 bits in 8 bits, signed
    S8,
    /// 8 bits in 8 bits, unsigned
    U8,
    /// 16 bits in 16 bits, signed, little endian
    S16le,
    /// 16 bits in 16 bits, signed, big endian
    S16be,
    /// 16 bits in 16 bits, unsigned, little endian
    U16le,
    /// 16 bits in 16 bits, unsigned, big endian
    U16be,
    /// 24 bits in 32 bits, signed, little endian
    S2432le,
    /// 24 bits in 32 bits, signed, big endian
    S2432be,
    /// 24 bits in 32 bits, unsigned, little endian
    U2432le,
    /// 24 bits in 32 bits, unsigned, big endian
    U2432be,
    /// 32 bits in 32 bits, signed, little endian
    S32le,
    /// 32 bits in 32 bits, signed, big endian
    S32be,
    /// 32 bits in 32 bits, unsigned, little endian
    U32le,
    /// 32 bits in 32 bits, unsigned, big endian
    U32be,
    /// 24 bits in 24 bits, signed, little endian
    S24le,
    /// 24 bits in 24 bits, signed, big endian
    S24be,
    /// 24 bits in 24 bits, unsigned, little endian
    U24le,
    /// 24 bits in 24 bits, unsigned, big endian
    U24be,
    /// 20 bits in 24 bits, signed, little endian
    S20le,
    /// 20 bits in 24 bits, signed, big endian
    S20be,
    /// 20 bits in 24 bits, unsigned, little endian
    U20le,
    /// 20 bits in 24 bits, unsigned, big endian
    U20be,
    /// 18 bits in 24 bits, signed, little endian
    S18le,
    /// 18 bits in 24 bits, signed, big endian
    S18be,
    /// 18 bits in 24 bits, unsigned, little endian
    U18le,
    /// 18 bits in 24 bits, unsigned, big endian
    U18be,
    /// 32-bit floating point samples, little endian
    F32le,
    /// 32-bit floating point samples, big endian
    F32be,
    /// 64-bit floating point samples, little endian
    F64le,
    /// 64-bit floating point samples, big endian
    F64be,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioFormat {
    type GlibType = gst_audio_sys::GstAudioFormat;

    fn to_glib(&self) -> gst_audio_sys::GstAudioFormat {
        match *self {
            AudioFormat::Unknown => gst_audio_sys::GST_AUDIO_FORMAT_UNKNOWN,
            AudioFormat::Encoded => gst_audio_sys::GST_AUDIO_FORMAT_ENCODED,
            AudioFormat::S8 => gst_audio_sys::GST_AUDIO_FORMAT_S8,
            AudioFormat::U8 => gst_audio_sys::GST_AUDIO_FORMAT_U8,
            AudioFormat::S16le => gst_audio_sys::GST_AUDIO_FORMAT_S16LE,
            AudioFormat::S16be => gst_audio_sys::GST_AUDIO_FORMAT_S16BE,
            AudioFormat::U16le => gst_audio_sys::GST_AUDIO_FORMAT_U16LE,
            AudioFormat::U16be => gst_audio_sys::GST_AUDIO_FORMAT_U16BE,
            AudioFormat::S2432le => gst_audio_sys::GST_AUDIO_FORMAT_S24_32LE,
            AudioFormat::S2432be => gst_audio_sys::GST_AUDIO_FORMAT_S24_32BE,
            AudioFormat::U2432le => gst_audio_sys::GST_AUDIO_FORMAT_U24_32LE,
            AudioFormat::U2432be => gst_audio_sys::GST_AUDIO_FORMAT_U24_32BE,
            AudioFormat::S32le => gst_audio_sys::GST_AUDIO_FORMAT_S32LE,
            AudioFormat::S32be => gst_audio_sys::GST_AUDIO_FORMAT_S32BE,
            AudioFormat::U32le => gst_audio_sys::GST_AUDIO_FORMAT_U32LE,
            AudioFormat::U32be => gst_audio_sys::GST_AUDIO_FORMAT_U32BE,
            AudioFormat::S24le => gst_audio_sys::GST_AUDIO_FORMAT_S24LE,
            AudioFormat::S24be => gst_audio_sys::GST_AUDIO_FORMAT_S24BE,
            AudioFormat::U24le => gst_audio_sys::GST_AUDIO_FORMAT_U24LE,
            AudioFormat::U24be => gst_audio_sys::GST_AUDIO_FORMAT_U24BE,
            AudioFormat::S20le => gst_audio_sys::GST_AUDIO_FORMAT_S20LE,
            AudioFormat::S20be => gst_audio_sys::GST_AUDIO_FORMAT_S20BE,
            AudioFormat::U20le => gst_audio_sys::GST_AUDIO_FORMAT_U20LE,
            AudioFormat::U20be => gst_audio_sys::GST_AUDIO_FORMAT_U20BE,
            AudioFormat::S18le => gst_audio_sys::GST_AUDIO_FORMAT_S18LE,
            AudioFormat::S18be => gst_audio_sys::GST_AUDIO_FORMAT_S18BE,
            AudioFormat::U18le => gst_audio_sys::GST_AUDIO_FORMAT_U18LE,
            AudioFormat::U18be => gst_audio_sys::GST_AUDIO_FORMAT_U18BE,
            AudioFormat::F32le => gst_audio_sys::GST_AUDIO_FORMAT_F32LE,
            AudioFormat::F32be => gst_audio_sys::GST_AUDIO_FORMAT_F32BE,
            AudioFormat::F64le => gst_audio_sys::GST_AUDIO_FORMAT_F64LE,
            AudioFormat::F64be => gst_audio_sys::GST_AUDIO_FORMAT_F64BE,
            AudioFormat::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioFormat> for AudioFormat {
    fn from_glib(value: gst_audio_sys::GstAudioFormat) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioFormat::Unknown,
            1 => AudioFormat::Encoded,
            2 => AudioFormat::S8,
            3 => AudioFormat::U8,
            4 => AudioFormat::S16le,
            5 => AudioFormat::S16be,
            6 => AudioFormat::U16le,
            7 => AudioFormat::U16be,
            8 => AudioFormat::S2432le,
            9 => AudioFormat::S2432be,
            10 => AudioFormat::U2432le,
            11 => AudioFormat::U2432be,
            12 => AudioFormat::S32le,
            13 => AudioFormat::S32be,
            14 => AudioFormat::U32le,
            15 => AudioFormat::U32be,
            16 => AudioFormat::S24le,
            17 => AudioFormat::S24be,
            18 => AudioFormat::U24le,
            19 => AudioFormat::U24be,
            20 => AudioFormat::S20le,
            21 => AudioFormat::S20be,
            22 => AudioFormat::U20le,
            23 => AudioFormat::U20be,
            24 => AudioFormat::S18le,
            25 => AudioFormat::S18be,
            26 => AudioFormat::U18le,
            27 => AudioFormat::U18be,
            28 => AudioFormat::F32le,
            29 => AudioFormat::F32be,
            30 => AudioFormat::F64le,
            31 => AudioFormat::F64be,
            value => AudioFormat::__Unknown(value),
        }
    }
}

impl StaticType for AudioFormat {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_format_get_type()) }
    }
}

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

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

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

/// Layout of the audio samples for the different channels.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioLayout {
    /// interleaved audio
    Interleaved,
    /// non-interleaved audio
    NonInterleaved,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioLayout {
    type GlibType = gst_audio_sys::GstAudioLayout;

    fn to_glib(&self) -> gst_audio_sys::GstAudioLayout {
        match *self {
            AudioLayout::Interleaved => gst_audio_sys::GST_AUDIO_LAYOUT_INTERLEAVED,
            AudioLayout::NonInterleaved => gst_audio_sys::GST_AUDIO_LAYOUT_NON_INTERLEAVED,
            AudioLayout::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioLayout> for AudioLayout {
    fn from_glib(value: gst_audio_sys::GstAudioLayout) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioLayout::Interleaved,
            1 => AudioLayout::NonInterleaved,
            value => AudioLayout::__Unknown(value),
        }
    }
}

impl StaticType for AudioLayout {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_layout_get_type()) }
    }
}

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioNoiseShapingMethod {
    None,
    ErrorFeedback,
    Simple,
    Medium,
    High,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioNoiseShapingMethod {
    type GlibType = gst_audio_sys::GstAudioNoiseShapingMethod;

    fn to_glib(&self) -> gst_audio_sys::GstAudioNoiseShapingMethod {
        match *self {
            AudioNoiseShapingMethod::None => gst_audio_sys::GST_AUDIO_NOISE_SHAPING_NONE,
            AudioNoiseShapingMethod::ErrorFeedback => {
                gst_audio_sys::GST_AUDIO_NOISE_SHAPING_ERROR_FEEDBACK
            }
            AudioNoiseShapingMethod::Simple => gst_audio_sys::GST_AUDIO_NOISE_SHAPING_SIMPLE,
            AudioNoiseShapingMethod::Medium => gst_audio_sys::GST_AUDIO_NOISE_SHAPING_MEDIUM,
            AudioNoiseShapingMethod::High => gst_audio_sys::GST_AUDIO_NOISE_SHAPING_HIGH,
            AudioNoiseShapingMethod::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioNoiseShapingMethod> for AudioNoiseShapingMethod {
    fn from_glib(value: gst_audio_sys::GstAudioNoiseShapingMethod) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioNoiseShapingMethod::None,
            1 => AudioNoiseShapingMethod::ErrorFeedback,
            2 => AudioNoiseShapingMethod::Simple,
            3 => AudioNoiseShapingMethod::Medium,
            4 => AudioNoiseShapingMethod::High,
            value => AudioNoiseShapingMethod::__Unknown(value),
        }
    }
}

impl StaticType for AudioNoiseShapingMethod {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_noise_shaping_method_get_type()) }
    }
}

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

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

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

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioResamplerMethod {
    Nearest,
    Linear,
    Cubic,
    BlackmanNuttall,
    Kaiser,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for AudioResamplerMethod {
    type GlibType = gst_audio_sys::GstAudioResamplerMethod;

    fn to_glib(&self) -> gst_audio_sys::GstAudioResamplerMethod {
        match *self {
            AudioResamplerMethod::Nearest => gst_audio_sys::GST_AUDIO_RESAMPLER_METHOD_NEAREST,
            AudioResamplerMethod::Linear => gst_audio_sys::GST_AUDIO_RESAMPLER_METHOD_LINEAR,
            AudioResamplerMethod::Cubic => gst_audio_sys::GST_AUDIO_RESAMPLER_METHOD_CUBIC,
            AudioResamplerMethod::BlackmanNuttall => {
                gst_audio_sys::GST_AUDIO_RESAMPLER_METHOD_BLACKMAN_NUTTALL
            }
            AudioResamplerMethod::Kaiser => gst_audio_sys::GST_AUDIO_RESAMPLER_METHOD_KAISER,
            AudioResamplerMethod::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v1_10", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioResamplerMethod> for AudioResamplerMethod {
    fn from_glib(value: gst_audio_sys::GstAudioResamplerMethod) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioResamplerMethod::Nearest,
            1 => AudioResamplerMethod::Linear,
            2 => AudioResamplerMethod::Cubic,
            3 => AudioResamplerMethod::BlackmanNuttall,
            4 => AudioResamplerMethod::Kaiser,
            value => AudioResamplerMethod::__Unknown(value),
        }
    }
}

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

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

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

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

/// The format of the samples in the ringbuffer.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum AudioRingBufferFormatType {
    /// samples in linear or float
    Raw,
    /// samples in mulaw
    MuLaw,
    /// samples in alaw
    ALaw,
    /// samples in ima adpcm
    ImaAdpcm,
    /// samples in mpeg audio (but not AAC) format
    Mpeg,
    /// samples in gsm format
    Gsm,
    /// samples in IEC958 frames (e.g. AC3)
    Iec958,
    /// samples in AC3 format
    Ac3,
    /// samples in EAC3 format
    Eac3,
    /// samples in DTS format
    Dts,
    /// samples in MPEG-2 AAC ADTS format
    Mpeg2Aac,
    /// samples in MPEG-4 AAC ADTS format
    Mpeg4Aac,
    /// samples in MPEG-2 AAC raw format (Since: 1.12)
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    Mpeg2AacRaw,
    /// samples in MPEG-4 AAC raw format (Since: 1.12)
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    Mpeg4AacRaw,
    /// samples in FLAC format (Since: 1.12)
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    Flac,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for AudioRingBufferFormatType {
    type GlibType = gst_audio_sys::GstAudioRingBufferFormatType;

    fn to_glib(&self) -> gst_audio_sys::GstAudioRingBufferFormatType {
        match *self {
            AudioRingBufferFormatType::Raw => gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW,
            AudioRingBufferFormatType::MuLaw => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW
            }
            AudioRingBufferFormatType::ALaw => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW
            }
            AudioRingBufferFormatType::ImaAdpcm => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM
            }
            AudioRingBufferFormatType::Mpeg => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG
            }
            AudioRingBufferFormatType::Gsm => gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_GSM,
            AudioRingBufferFormatType::Iec958 => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958
            }
            AudioRingBufferFormatType::Ac3 => gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3,
            AudioRingBufferFormatType::Eac3 => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3
            }
            AudioRingBufferFormatType::Dts => gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS,
            AudioRingBufferFormatType::Mpeg2Aac => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC
            }
            AudioRingBufferFormatType::Mpeg4Aac => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC
            }
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            AudioRingBufferFormatType::Mpeg2AacRaw => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW
            }
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            AudioRingBufferFormatType::Mpeg4AacRaw => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW
            }
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            AudioRingBufferFormatType::Flac => {
                gst_audio_sys::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC
            }
            AudioRingBufferFormatType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstAudioRingBufferFormatType> for AudioRingBufferFormatType {
    fn from_glib(value: gst_audio_sys::GstAudioRingBufferFormatType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => AudioRingBufferFormatType::Raw,
            1 => AudioRingBufferFormatType::MuLaw,
            2 => AudioRingBufferFormatType::ALaw,
            3 => AudioRingBufferFormatType::ImaAdpcm,
            4 => AudioRingBufferFormatType::Mpeg,
            5 => AudioRingBufferFormatType::Gsm,
            6 => AudioRingBufferFormatType::Iec958,
            7 => AudioRingBufferFormatType::Ac3,
            8 => AudioRingBufferFormatType::Eac3,
            9 => AudioRingBufferFormatType::Dts,
            10 => AudioRingBufferFormatType::Mpeg2Aac,
            11 => AudioRingBufferFormatType::Mpeg4Aac,
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            12 => AudioRingBufferFormatType::Mpeg2AacRaw,
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            13 => AudioRingBufferFormatType::Mpeg4AacRaw,
            #[cfg(any(feature = "v1_12", feature = "dox"))]
            14 => AudioRingBufferFormatType::Flac,
            value => AudioRingBufferFormatType::__Unknown(value),
        }
    }
}

impl StaticType for AudioRingBufferFormatType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_audio_sys::gst_audio_ring_buffer_format_type_get_type()) }
    }
}

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

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

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

/// Different representations of a stream volume. `StreamVolume::convert_volume`
/// allows to convert between the different representations.
///
/// Formulas to convert from a linear to a cubic or dB volume are
/// cbrt(val) and 20 * log10 (val).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum StreamVolumeFormat {
    /// Linear scale factor, 1.0 = 100%
    Linear,
    /// Cubic volume scale
    Cubic,
    /// Logarithmic volume scale (dB, amplitude not power)
    Db,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for StreamVolumeFormat {
    type GlibType = gst_audio_sys::GstStreamVolumeFormat;

    fn to_glib(&self) -> gst_audio_sys::GstStreamVolumeFormat {
        match *self {
            StreamVolumeFormat::Linear => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_LINEAR,
            StreamVolumeFormat::Cubic => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_CUBIC,
            StreamVolumeFormat::Db => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_DB,
            StreamVolumeFormat::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_audio_sys::GstStreamVolumeFormat> for StreamVolumeFormat {
    fn from_glib(value: gst_audio_sys::GstStreamVolumeFormat) -> Self {
        skip_assert_initialized!();
        match value {
            0 => StreamVolumeFormat::Linear,
            1 => StreamVolumeFormat::Cubic,
            2 => StreamVolumeFormat::Db,
            value => StreamVolumeFormat::__Unknown(value),
        }
    }
}