1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// 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::ffi;
use glib::{bitflags::bitflags, prelude::*, translate::*};

bitflags! {
    /// Flags used to control allocation of addresses
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    #[doc(alias = "GstRTSPAddressFlags")]
    pub struct RTSPAddressFlags: u32 {
        /// an IPv4 address
        #[doc(alias = "GST_RTSP_ADDRESS_FLAG_IPV4")]
        const IPV4 = ffi::GST_RTSP_ADDRESS_FLAG_IPV4 as _;
        /// and IPv6 address
        #[doc(alias = "GST_RTSP_ADDRESS_FLAG_IPV6")]
        const IPV6 = ffi::GST_RTSP_ADDRESS_FLAG_IPV6 as _;
        /// address with an even port
        #[doc(alias = "GST_RTSP_ADDRESS_FLAG_EVEN_PORT")]
        const EVEN_PORT = ffi::GST_RTSP_ADDRESS_FLAG_EVEN_PORT as _;
        /// a multicast address
        #[doc(alias = "GST_RTSP_ADDRESS_FLAG_MULTICAST")]
        const MULTICAST = ffi::GST_RTSP_ADDRESS_FLAG_MULTICAST as _;
        /// a unicast address
        #[doc(alias = "GST_RTSP_ADDRESS_FLAG_UNICAST")]
        const UNICAST = ffi::GST_RTSP_ADDRESS_FLAG_UNICAST as _;
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GstRTSPAddressFlags {
        self.bits()
    }
}

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

bitflags! {
    /// The supported modes of the media.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    #[doc(alias = "GstRTSPTransportMode")]
    pub struct RTSPTransportMode: u32 {
        /// Transport supports PLAY mode
        #[doc(alias = "GST_RTSP_TRANSPORT_MODE_PLAY")]
        const PLAY = ffi::GST_RTSP_TRANSPORT_MODE_PLAY as _;
        /// Transport supports RECORD mode
        #[doc(alias = "GST_RTSP_TRANSPORT_MODE_RECORD")]
        const RECORD = ffi::GST_RTSP_TRANSPORT_MODE_RECORD as _;
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GstRTSPTransportMode {
        self.bits()
    }
}

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

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

impl glib::HasParamSpec for RTSPTransportMode {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

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

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

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

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

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

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

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