// 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_rtp_sys;

/// Different types of feedback messages.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTCPFBType {
    /// Invalid type
    FbTypeInvalid,
    /// Generic NACK
    RtpfbTypeNack,
    /// Temporary Maximum Media Stream Bit Rate Request
    RtpfbTypeTmmbr,
    /// Temporary Maximum Media Stream Bit Rate
    ///  Notification
    RtpfbTypeTmmbn,
    /// Request an SR packet for early
    ///  synchronization
    RtpfbTypeRtcpSrReq,
    RtpfbTypeTwcc,
    /// Slice Loss Indication
    PsfbTypeSli,
    /// Temporal-Spatial Trade-off Notification
    PsfbTypeTstn,
    /// Video Back Channel Message
    PsfbTypeVbcn,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for RTCPFBType {
    type GlibType = gst_rtp_sys::GstRTCPFBType;

    fn to_glib(&self) -> gst_rtp_sys::GstRTCPFBType {
        match *self {
            RTCPFBType::FbTypeInvalid => gst_rtp_sys::GST_RTCP_FB_TYPE_INVALID,
            RTCPFBType::RtpfbTypeNack => gst_rtp_sys::GST_RTCP_RTPFB_TYPE_NACK,
            RTCPFBType::RtpfbTypeTmmbr => gst_rtp_sys::GST_RTCP_RTPFB_TYPE_TMMBR,
            RTCPFBType::RtpfbTypeTmmbn => gst_rtp_sys::GST_RTCP_RTPFB_TYPE_TMMBN,
            RTCPFBType::RtpfbTypeRtcpSrReq => gst_rtp_sys::GST_RTCP_RTPFB_TYPE_RTCP_SR_REQ,
            RTCPFBType::RtpfbTypeTwcc => gst_rtp_sys::GST_RTCP_RTPFB_TYPE_TWCC,
            RTCPFBType::PsfbTypeSli => gst_rtp_sys::GST_RTCP_PSFB_TYPE_SLI,
            RTCPFBType::PsfbTypeTstn => gst_rtp_sys::GST_RTCP_PSFB_TYPE_TSTN,
            RTCPFBType::PsfbTypeVbcn => gst_rtp_sys::GST_RTCP_PSFB_TYPE_VBCN,
            RTCPFBType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTCPFBType> for RTCPFBType {
    fn from_glib(value: gst_rtp_sys::GstRTCPFBType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => RTCPFBType::FbTypeInvalid,
            1 => RTCPFBType::RtpfbTypeNack,
            3 => RTCPFBType::RtpfbTypeTmmbr,
            4 => RTCPFBType::RtpfbTypeTmmbn,
            5 => RTCPFBType::RtpfbTypeRtcpSrReq,
            15 => RTCPFBType::RtpfbTypeTwcc,
            2 => RTCPFBType::PsfbTypeSli,
            6 => RTCPFBType::PsfbTypeTstn,
            7 => RTCPFBType::PsfbTypeVbcn,
            value => RTCPFBType::__Unknown(value),
        }
    }
}

impl StaticType for RTCPFBType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtcpfb_type_get_type()) }
    }
}

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

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

impl SetValue for RTCPFBType {
    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 types of SDES content.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTCPSDESType {
    /// Invalid SDES entry
    Invalid,
    /// End of SDES list
    End,
    /// Canonical name
    Cname,
    /// User name
    Name,
    /// User's electronic mail address
    Email,
    /// User's phone number
    Phone,
    /// Geographic user location
    Loc,
    /// Name of application or tool
    Tool,
    /// Notice about the source
    Note,
    /// Private extensions
    Priv,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for RTCPSDESType {
    type GlibType = gst_rtp_sys::GstRTCPSDESType;

    fn to_glib(&self) -> gst_rtp_sys::GstRTCPSDESType {
        match *self {
            RTCPSDESType::Invalid => gst_rtp_sys::GST_RTCP_SDES_INVALID,
            RTCPSDESType::End => gst_rtp_sys::GST_RTCP_SDES_END,
            RTCPSDESType::Cname => gst_rtp_sys::GST_RTCP_SDES_CNAME,
            RTCPSDESType::Name => gst_rtp_sys::GST_RTCP_SDES_NAME,
            RTCPSDESType::Email => gst_rtp_sys::GST_RTCP_SDES_EMAIL,
            RTCPSDESType::Phone => gst_rtp_sys::GST_RTCP_SDES_PHONE,
            RTCPSDESType::Loc => gst_rtp_sys::GST_RTCP_SDES_LOC,
            RTCPSDESType::Tool => gst_rtp_sys::GST_RTCP_SDES_TOOL,
            RTCPSDESType::Note => gst_rtp_sys::GST_RTCP_SDES_NOTE,
            RTCPSDESType::Priv => gst_rtp_sys::GST_RTCP_SDES_PRIV,
            RTCPSDESType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTCPSDESType> for RTCPSDESType {
    fn from_glib(value: gst_rtp_sys::GstRTCPSDESType) -> Self {
        skip_assert_initialized!();
        match value {
            -1 => RTCPSDESType::Invalid,
            0 => RTCPSDESType::End,
            1 => RTCPSDESType::Cname,
            2 => RTCPSDESType::Name,
            3 => RTCPSDESType::Email,
            4 => RTCPSDESType::Phone,
            5 => RTCPSDESType::Loc,
            6 => RTCPSDESType::Tool,
            7 => RTCPSDESType::Note,
            8 => RTCPSDESType::Priv,
            value => RTCPSDESType::__Unknown(value),
        }
    }
}

impl StaticType for RTCPSDESType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtcpsdes_type_get_type()) }
    }
}

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

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

impl SetValue for RTCPSDESType {
    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 RTCP packet types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTCPType {
    /// Invalid type
    Invalid,
    /// Sender report
    Sr,
    /// Receiver report
    Rr,
    /// Source description
    Sdes,
    /// Goodbye
    Bye,
    /// Application defined
    App,
    /// Transport layer feedback.
    Rtpfb,
    /// Payload-specific feedback.
    Psfb,
    /// Extended report.
    Xr,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for RTCPType {
    type GlibType = gst_rtp_sys::GstRTCPType;

    fn to_glib(&self) -> gst_rtp_sys::GstRTCPType {
        match *self {
            RTCPType::Invalid => gst_rtp_sys::GST_RTCP_TYPE_INVALID,
            RTCPType::Sr => gst_rtp_sys::GST_RTCP_TYPE_SR,
            RTCPType::Rr => gst_rtp_sys::GST_RTCP_TYPE_RR,
            RTCPType::Sdes => gst_rtp_sys::GST_RTCP_TYPE_SDES,
            RTCPType::Bye => gst_rtp_sys::GST_RTCP_TYPE_BYE,
            RTCPType::App => gst_rtp_sys::GST_RTCP_TYPE_APP,
            RTCPType::Rtpfb => gst_rtp_sys::GST_RTCP_TYPE_RTPFB,
            RTCPType::Psfb => gst_rtp_sys::GST_RTCP_TYPE_PSFB,
            RTCPType::Xr => gst_rtp_sys::GST_RTCP_TYPE_XR,
            RTCPType::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTCPType> for RTCPType {
    fn from_glib(value: gst_rtp_sys::GstRTCPType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => RTCPType::Invalid,
            200 => RTCPType::Sr,
            201 => RTCPType::Rr,
            202 => RTCPType::Sdes,
            203 => RTCPType::Bye,
            204 => RTCPType::App,
            205 => RTCPType::Rtpfb,
            206 => RTCPType::Psfb,
            207 => RTCPType::Xr,
            value => RTCPType::__Unknown(value),
        }
    }
}

impl StaticType for RTCPType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtcp_type_get_type()) }
    }
}

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

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

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

/// Types of RTCP Extended Reports, those are defined in RFC 3611 and other RFCs
/// according to the [IANA registry](https://www.iana.org/assignments/rtcp-xr-block-types/rtcp-xr-block-types.xhtml).
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTCPXRType {
    /// Invalid XR Report Block
    Invalid,
    /// Loss RLE Report Block
    Lrle,
    /// Duplicate RLE Report Block
    Drle,
    /// Packet Receipt Times Report Block
    Prt,
    /// Receiver Reference Time Report Block
    Rrt,
    /// Delay since the last Receiver Report
    Dlrr,
    /// Statistics Summary Report Block
    Ssumm,
    /// VoIP Metrics Report Block
    ///
    /// Feature: `v1_16`
    ///
    VoipMetrics,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(any(feature = "v1_16", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for RTCPXRType {
    type GlibType = gst_rtp_sys::GstRTCPXRType;

    fn to_glib(&self) -> gst_rtp_sys::GstRTCPXRType {
        match *self {
            RTCPXRType::Invalid => gst_rtp_sys::GST_RTCP_XR_TYPE_INVALID,
            RTCPXRType::Lrle => gst_rtp_sys::GST_RTCP_XR_TYPE_LRLE,
            RTCPXRType::Drle => gst_rtp_sys::GST_RTCP_XR_TYPE_DRLE,
            RTCPXRType::Prt => gst_rtp_sys::GST_RTCP_XR_TYPE_PRT,
            RTCPXRType::Rrt => gst_rtp_sys::GST_RTCP_XR_TYPE_RRT,
            RTCPXRType::Dlrr => gst_rtp_sys::GST_RTCP_XR_TYPE_DLRR,
            RTCPXRType::Ssumm => gst_rtp_sys::GST_RTCP_XR_TYPE_SSUMM,
            RTCPXRType::VoipMetrics => gst_rtp_sys::GST_RTCP_XR_TYPE_VOIP_METRICS,
            RTCPXRType::__Unknown(value) => value,
        }
    }
}

#[cfg(any(feature = "v1_16", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTCPXRType> for RTCPXRType {
    fn from_glib(value: gst_rtp_sys::GstRTCPXRType) -> Self {
        skip_assert_initialized!();
        match value {
            -1 => RTCPXRType::Invalid,
            1 => RTCPXRType::Lrle,
            2 => RTCPXRType::Drle,
            3 => RTCPXRType::Prt,
            4 => RTCPXRType::Rrt,
            5 => RTCPXRType::Dlrr,
            6 => RTCPXRType::Ssumm,
            7 => RTCPXRType::VoipMetrics,
            value => RTCPXRType::__Unknown(value),
        }
    }
}

#[cfg(any(feature = "v1_16", feature = "dox"))]
impl StaticType for RTCPXRType {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtcpxr_type_get_type()) }
    }
}

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

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

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

/// Standard predefined fixed payload types.
///
/// The official list is at:
/// http://www.iana.org/assignments/rtp-parameters
///
/// Audio:
/// reserved: 19
/// unassigned: 20-23,
///
/// Video:
/// unassigned: 24, 27, 29, 30, 35-71, 77-95
/// Reserved for RTCP conflict avoidance: 72-76
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTPPayload {
    /// ITU-T G.711. mu-law audio (RFC 3551)
    Pcmu,
    _1016,
    /// RFC 3551 says reserved
    G721,
    /// GSM audio
    Gsm,
    /// ITU G.723.1 audio
    G723,
    /// IMA ADPCM wave type (RFC 3551)
    Dvi48000,
    /// IMA ADPCM wave type (RFC 3551)
    Dvi416000,
    /// experimental linear predictive encoding
    Lpc,
    /// ITU-T G.711 A-law audio (RFC 3551)
    Pcma,
    /// ITU-T G.722 (RFC 3551)
    G722,
    /// stereo PCM
    L16Stereo,
    /// mono PCM
    L16Mono,
    /// EIA & TIA standard IS-733
    Qcelp,
    /// Comfort Noise (RFC 3389)
    Cn,
    /// Audio MPEG 1-3.
    Mpa,
    /// ITU-T G.728 Speech coder (RFC 3551)
    G728,
    /// IMA ADPCM wave type (RFC 3551)
    Dvi411025,
    /// IMA ADPCM wave type (RFC 3551)
    Dvi422050,
    /// ITU-T G.729 Speech coder (RFC 3551)
    G729,
    /// See RFC 2029
    Cellb,
    /// ISO Standards 10918-1 and 10918-2 (RFC 2435)
    Jpeg,
    /// nv encoding by Ron Frederick
    Nv,
    /// ITU-T Recommendation H.261 (RFC 2032)
    H261,
    /// Video MPEG 1 & 2 (RFC 2250)
    Mpv,
    /// MPEG-2 transport stream (RFC 2250)
    Mp2t,
    /// Video H263 (RFC 2190)
    H263,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for RTPPayload {
    type GlibType = gst_rtp_sys::GstRTPPayload;

    fn to_glib(&self) -> gst_rtp_sys::GstRTPPayload {
        match *self {
            RTPPayload::Pcmu => gst_rtp_sys::GST_RTP_PAYLOAD_PCMU,
            RTPPayload::_1016 => gst_rtp_sys::GST_RTP_PAYLOAD_1016,
            RTPPayload::G721 => gst_rtp_sys::GST_RTP_PAYLOAD_G721,
            RTPPayload::Gsm => gst_rtp_sys::GST_RTP_PAYLOAD_GSM,
            RTPPayload::G723 => gst_rtp_sys::GST_RTP_PAYLOAD_G723,
            RTPPayload::Dvi48000 => gst_rtp_sys::GST_RTP_PAYLOAD_DVI4_8000,
            RTPPayload::Dvi416000 => gst_rtp_sys::GST_RTP_PAYLOAD_DVI4_16000,
            RTPPayload::Lpc => gst_rtp_sys::GST_RTP_PAYLOAD_LPC,
            RTPPayload::Pcma => gst_rtp_sys::GST_RTP_PAYLOAD_PCMA,
            RTPPayload::G722 => gst_rtp_sys::GST_RTP_PAYLOAD_G722,
            RTPPayload::L16Stereo => gst_rtp_sys::GST_RTP_PAYLOAD_L16_STEREO,
            RTPPayload::L16Mono => gst_rtp_sys::GST_RTP_PAYLOAD_L16_MONO,
            RTPPayload::Qcelp => gst_rtp_sys::GST_RTP_PAYLOAD_QCELP,
            RTPPayload::Cn => gst_rtp_sys::GST_RTP_PAYLOAD_CN,
            RTPPayload::Mpa => gst_rtp_sys::GST_RTP_PAYLOAD_MPA,
            RTPPayload::G728 => gst_rtp_sys::GST_RTP_PAYLOAD_G728,
            RTPPayload::Dvi411025 => gst_rtp_sys::GST_RTP_PAYLOAD_DVI4_11025,
            RTPPayload::Dvi422050 => gst_rtp_sys::GST_RTP_PAYLOAD_DVI4_22050,
            RTPPayload::G729 => gst_rtp_sys::GST_RTP_PAYLOAD_G729,
            RTPPayload::Cellb => gst_rtp_sys::GST_RTP_PAYLOAD_CELLB,
            RTPPayload::Jpeg => gst_rtp_sys::GST_RTP_PAYLOAD_JPEG,
            RTPPayload::Nv => gst_rtp_sys::GST_RTP_PAYLOAD_NV,
            RTPPayload::H261 => gst_rtp_sys::GST_RTP_PAYLOAD_H261,
            RTPPayload::Mpv => gst_rtp_sys::GST_RTP_PAYLOAD_MPV,
            RTPPayload::Mp2t => gst_rtp_sys::GST_RTP_PAYLOAD_MP2T,
            RTPPayload::H263 => gst_rtp_sys::GST_RTP_PAYLOAD_H263,
            RTPPayload::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTPPayload> for RTPPayload {
    fn from_glib(value: gst_rtp_sys::GstRTPPayload) -> Self {
        skip_assert_initialized!();
        match value {
            0 => RTPPayload::Pcmu,
            1 => RTPPayload::_1016,
            2 => RTPPayload::G721,
            3 => RTPPayload::Gsm,
            4 => RTPPayload::G723,
            5 => RTPPayload::Dvi48000,
            6 => RTPPayload::Dvi416000,
            7 => RTPPayload::Lpc,
            8 => RTPPayload::Pcma,
            9 => RTPPayload::G722,
            10 => RTPPayload::L16Stereo,
            11 => RTPPayload::L16Mono,
            12 => RTPPayload::Qcelp,
            13 => RTPPayload::Cn,
            14 => RTPPayload::Mpa,
            15 => RTPPayload::G728,
            16 => RTPPayload::Dvi411025,
            17 => RTPPayload::Dvi422050,
            18 => RTPPayload::G729,
            25 => RTPPayload::Cellb,
            26 => RTPPayload::Jpeg,
            28 => RTPPayload::Nv,
            31 => RTPPayload::H261,
            32 => RTPPayload::Mpv,
            33 => RTPPayload::Mp2t,
            34 => RTPPayload::H263,
            value => RTPPayload::__Unknown(value),
        }
    }
}

impl StaticType for RTPPayload {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtp_payload_get_type()) }
    }
}

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

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

impl SetValue for RTPPayload {
    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 transfer profile to use.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum RTPProfile {
    /// invalid profile
    Unknown,
    /// the Audio/Visual profile (RFC 3551)
    Avp,
    /// the secure Audio/Visual profile (RFC 3711)
    Savp,
    /// the Audio/Visual profile with feedback (RFC 4585)
    Avpf,
    /// the secure Audio/Visual profile with feedback (RFC 5124)
    Savpf,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for RTPProfile {
    type GlibType = gst_rtp_sys::GstRTPProfile;

    fn to_glib(&self) -> gst_rtp_sys::GstRTPProfile {
        match *self {
            RTPProfile::Unknown => gst_rtp_sys::GST_RTP_PROFILE_UNKNOWN,
            RTPProfile::Avp => gst_rtp_sys::GST_RTP_PROFILE_AVP,
            RTPProfile::Savp => gst_rtp_sys::GST_RTP_PROFILE_SAVP,
            RTPProfile::Avpf => gst_rtp_sys::GST_RTP_PROFILE_AVPF,
            RTPProfile::Savpf => gst_rtp_sys::GST_RTP_PROFILE_SAVPF,
            RTPProfile::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gst_rtp_sys::GstRTPProfile> for RTPProfile {
    fn from_glib(value: gst_rtp_sys::GstRTPProfile) -> Self {
        skip_assert_initialized!();
        match value {
            0 => RTPProfile::Unknown,
            1 => RTPProfile::Avp,
            2 => RTPProfile::Savp,
            3 => RTPProfile::Avpf,
            4 => RTPProfile::Savpf,
            value => RTPProfile::__Unknown(value),
        }
    }
}

impl StaticType for RTPProfile {
    fn static_type() -> Type {
        unsafe { from_glib(gst_rtp_sys::gst_rtp_profile_get_type()) }
    }
}

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

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

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