Skip to main content

gstreamer_webrtc/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6use crate::ffi;
7use glib::{GStr, prelude::*, translate::*};
8
9#[cfg(feature = "v1_16")]
10#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
11#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12#[non_exhaustive]
13#[doc(alias = "GstWebRTCBundlePolicy")]
14pub enum WebRTCBundlePolicy {
15    #[doc(alias = "GST_WEBRTC_BUNDLE_POLICY_NONE")]
16    None,
17    #[doc(alias = "GST_WEBRTC_BUNDLE_POLICY_BALANCED")]
18    Balanced,
19    #[doc(alias = "GST_WEBRTC_BUNDLE_POLICY_MAX_COMPAT")]
20    MaxCompat,
21    #[doc(alias = "GST_WEBRTC_BUNDLE_POLICY_MAX_BUNDLE")]
22    MaxBundle,
23    #[doc(hidden)]
24    __Unknown(i32),
25}
26
27#[cfg(feature = "v1_16")]
28#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
29#[doc(hidden)]
30impl IntoGlib for WebRTCBundlePolicy {
31    type GlibType = ffi::GstWebRTCBundlePolicy;
32
33    #[inline]
34    fn into_glib(self) -> ffi::GstWebRTCBundlePolicy {
35        match self {
36            Self::None => ffi::GST_WEBRTC_BUNDLE_POLICY_NONE,
37            Self::Balanced => ffi::GST_WEBRTC_BUNDLE_POLICY_BALANCED,
38            Self::MaxCompat => ffi::GST_WEBRTC_BUNDLE_POLICY_MAX_COMPAT,
39            Self::MaxBundle => ffi::GST_WEBRTC_BUNDLE_POLICY_MAX_BUNDLE,
40            Self::__Unknown(value) => value,
41        }
42    }
43}
44
45#[cfg(feature = "v1_16")]
46#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
47#[doc(hidden)]
48impl FromGlib<ffi::GstWebRTCBundlePolicy> for WebRTCBundlePolicy {
49    #[inline]
50    unsafe fn from_glib(value: ffi::GstWebRTCBundlePolicy) -> Self {
51        skip_assert_initialized!();
52
53        match value {
54            ffi::GST_WEBRTC_BUNDLE_POLICY_NONE => Self::None,
55            ffi::GST_WEBRTC_BUNDLE_POLICY_BALANCED => Self::Balanced,
56            ffi::GST_WEBRTC_BUNDLE_POLICY_MAX_COMPAT => Self::MaxCompat,
57            ffi::GST_WEBRTC_BUNDLE_POLICY_MAX_BUNDLE => Self::MaxBundle,
58            value => Self::__Unknown(value),
59        }
60    }
61}
62
63#[cfg(feature = "v1_16")]
64#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
65impl StaticType for WebRTCBundlePolicy {
66    #[inline]
67    #[doc(alias = "gst_webrtc_bundle_policy_get_type")]
68    fn static_type() -> glib::Type {
69        unsafe { from_glib(ffi::gst_webrtc_bundle_policy_get_type()) }
70    }
71}
72
73#[cfg(feature = "v1_16")]
74#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
75impl glib::HasParamSpec for WebRTCBundlePolicy {
76    type ParamSpec = glib::ParamSpecEnum;
77    type SetValue = Self;
78    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
79
80    fn param_spec_builder() -> Self::BuilderFn {
81        Self::ParamSpec::builder_with_default
82    }
83}
84
85#[cfg(feature = "v1_16")]
86#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
87impl glib::value::ValueType for WebRTCBundlePolicy {
88    type Type = Self;
89}
90
91#[cfg(feature = "v1_16")]
92#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
93unsafe impl<'a> glib::value::FromValue<'a> for WebRTCBundlePolicy {
94    type Checker = glib::value::GenericValueTypeChecker<Self>;
95
96    #[inline]
97    unsafe fn from_value(value: &'a glib::Value) -> Self {
98        skip_assert_initialized!();
99        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
100    }
101}
102
103#[cfg(feature = "v1_16")]
104#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
105impl ToValue for WebRTCBundlePolicy {
106    #[inline]
107    fn to_value(&self) -> glib::Value {
108        let mut value = glib::Value::for_value_type::<Self>();
109        unsafe {
110            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
111        }
112        value
113    }
114
115    #[inline]
116    fn value_type(&self) -> glib::Type {
117        Self::static_type()
118    }
119}
120
121#[cfg(feature = "v1_16")]
122#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
123impl From<WebRTCBundlePolicy> for glib::Value {
124    #[inline]
125    fn from(v: WebRTCBundlePolicy) -> Self {
126        skip_assert_initialized!();
127        ToValue::to_value(&v)
128    }
129}
130
131#[cfg(feature = "v1_28")]
132#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
133#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
134#[non_exhaustive]
135#[doc(alias = "GstWebRTCDTLSRole")]
136pub enum WebRTCDTLSRole {
137    #[doc(alias = "GST_WEBRTC_DTLS_ROLE_CLIENT")]
138    Client,
139    #[doc(alias = "GST_WEBRTC_DTLS_ROLE_SERVER")]
140    Server,
141    #[doc(alias = "GST_WEBRTC_DTLS_ROLE_UNKNOWN")]
142    Unknown,
143    #[doc(hidden)]
144    __Unknown(i32),
145}
146
147#[cfg(feature = "v1_28")]
148#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
149#[doc(hidden)]
150impl IntoGlib for WebRTCDTLSRole {
151    type GlibType = ffi::GstWebRTCDTLSRole;
152
153    #[inline]
154    fn into_glib(self) -> ffi::GstWebRTCDTLSRole {
155        match self {
156            Self::Client => ffi::GST_WEBRTC_DTLS_ROLE_CLIENT,
157            Self::Server => ffi::GST_WEBRTC_DTLS_ROLE_SERVER,
158            Self::Unknown => ffi::GST_WEBRTC_DTLS_ROLE_UNKNOWN,
159            Self::__Unknown(value) => value,
160        }
161    }
162}
163
164#[cfg(feature = "v1_28")]
165#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
166#[doc(hidden)]
167impl FromGlib<ffi::GstWebRTCDTLSRole> for WebRTCDTLSRole {
168    #[inline]
169    unsafe fn from_glib(value: ffi::GstWebRTCDTLSRole) -> Self {
170        skip_assert_initialized!();
171
172        match value {
173            ffi::GST_WEBRTC_DTLS_ROLE_CLIENT => Self::Client,
174            ffi::GST_WEBRTC_DTLS_ROLE_SERVER => Self::Server,
175            ffi::GST_WEBRTC_DTLS_ROLE_UNKNOWN => Self::Unknown,
176            value => Self::__Unknown(value),
177        }
178    }
179}
180
181#[cfg(feature = "v1_28")]
182#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
183impl StaticType for WebRTCDTLSRole {
184    #[inline]
185    #[doc(alias = "gst_webrtc_dtls_role_get_type")]
186    fn static_type() -> glib::Type {
187        unsafe { from_glib(ffi::gst_webrtc_dtls_role_get_type()) }
188    }
189}
190
191#[cfg(feature = "v1_28")]
192#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
193impl glib::HasParamSpec for WebRTCDTLSRole {
194    type ParamSpec = glib::ParamSpecEnum;
195    type SetValue = Self;
196    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
197
198    fn param_spec_builder() -> Self::BuilderFn {
199        Self::ParamSpec::builder_with_default
200    }
201}
202
203#[cfg(feature = "v1_28")]
204#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
205impl glib::value::ValueType for WebRTCDTLSRole {
206    type Type = Self;
207}
208
209#[cfg(feature = "v1_28")]
210#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
211unsafe impl<'a> glib::value::FromValue<'a> for WebRTCDTLSRole {
212    type Checker = glib::value::GenericValueTypeChecker<Self>;
213
214    #[inline]
215    unsafe fn from_value(value: &'a glib::Value) -> Self {
216        skip_assert_initialized!();
217        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
218    }
219}
220
221#[cfg(feature = "v1_28")]
222#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
223impl ToValue for WebRTCDTLSRole {
224    #[inline]
225    fn to_value(&self) -> glib::Value {
226        let mut value = glib::Value::for_value_type::<Self>();
227        unsafe {
228            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
229        }
230        value
231    }
232
233    #[inline]
234    fn value_type(&self) -> glib::Type {
235        Self::static_type()
236    }
237}
238
239#[cfg(feature = "v1_28")]
240#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
241impl From<WebRTCDTLSRole> for glib::Value {
242    #[inline]
243    fn from(v: WebRTCDTLSRole) -> Self {
244        skip_assert_initialized!();
245        ToValue::to_value(&v)
246    }
247}
248
249#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
250#[non_exhaustive]
251#[doc(alias = "GstWebRTCDTLSSetup")]
252pub enum WebRTCDTLSSetup {
253    #[doc(alias = "GST_WEBRTC_DTLS_SETUP_NONE")]
254    None,
255    #[doc(alias = "GST_WEBRTC_DTLS_SETUP_ACTPASS")]
256    Actpass,
257    #[doc(alias = "GST_WEBRTC_DTLS_SETUP_ACTIVE")]
258    Active,
259    #[doc(alias = "GST_WEBRTC_DTLS_SETUP_PASSIVE")]
260    Passive,
261    #[doc(hidden)]
262    __Unknown(i32),
263}
264
265#[doc(hidden)]
266impl IntoGlib for WebRTCDTLSSetup {
267    type GlibType = ffi::GstWebRTCDTLSSetup;
268
269    #[inline]
270    fn into_glib(self) -> ffi::GstWebRTCDTLSSetup {
271        match self {
272            Self::None => ffi::GST_WEBRTC_DTLS_SETUP_NONE,
273            Self::Actpass => ffi::GST_WEBRTC_DTLS_SETUP_ACTPASS,
274            Self::Active => ffi::GST_WEBRTC_DTLS_SETUP_ACTIVE,
275            Self::Passive => ffi::GST_WEBRTC_DTLS_SETUP_PASSIVE,
276            Self::__Unknown(value) => value,
277        }
278    }
279}
280
281#[doc(hidden)]
282impl FromGlib<ffi::GstWebRTCDTLSSetup> for WebRTCDTLSSetup {
283    #[inline]
284    unsafe fn from_glib(value: ffi::GstWebRTCDTLSSetup) -> Self {
285        skip_assert_initialized!();
286
287        match value {
288            ffi::GST_WEBRTC_DTLS_SETUP_NONE => Self::None,
289            ffi::GST_WEBRTC_DTLS_SETUP_ACTPASS => Self::Actpass,
290            ffi::GST_WEBRTC_DTLS_SETUP_ACTIVE => Self::Active,
291            ffi::GST_WEBRTC_DTLS_SETUP_PASSIVE => Self::Passive,
292            value => Self::__Unknown(value),
293        }
294    }
295}
296
297impl StaticType for WebRTCDTLSSetup {
298    #[inline]
299    #[doc(alias = "gst_webrtc_dtls_setup_get_type")]
300    fn static_type() -> glib::Type {
301        unsafe { from_glib(ffi::gst_webrtc_dtls_setup_get_type()) }
302    }
303}
304
305impl glib::HasParamSpec for WebRTCDTLSSetup {
306    type ParamSpec = glib::ParamSpecEnum;
307    type SetValue = Self;
308    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
309
310    fn param_spec_builder() -> Self::BuilderFn {
311        Self::ParamSpec::builder_with_default
312    }
313}
314
315impl glib::value::ValueType for WebRTCDTLSSetup {
316    type Type = Self;
317}
318
319unsafe impl<'a> glib::value::FromValue<'a> for WebRTCDTLSSetup {
320    type Checker = glib::value::GenericValueTypeChecker<Self>;
321
322    #[inline]
323    unsafe fn from_value(value: &'a glib::Value) -> Self {
324        skip_assert_initialized!();
325        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
326    }
327}
328
329impl ToValue for WebRTCDTLSSetup {
330    #[inline]
331    fn to_value(&self) -> glib::Value {
332        let mut value = glib::Value::for_value_type::<Self>();
333        unsafe {
334            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
335        }
336        value
337    }
338
339    #[inline]
340    fn value_type(&self) -> glib::Type {
341        Self::static_type()
342    }
343}
344
345impl From<WebRTCDTLSSetup> for glib::Value {
346    #[inline]
347    fn from(v: WebRTCDTLSSetup) -> Self {
348        skip_assert_initialized!();
349        ToValue::to_value(&v)
350    }
351}
352
353#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
354#[non_exhaustive]
355#[doc(alias = "GstWebRTCDTLSTransportState")]
356pub enum WebRTCDTLSTransportState {
357    #[doc(alias = "GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW")]
358    New,
359    #[doc(alias = "GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED")]
360    Closed,
361    #[doc(alias = "GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED")]
362    Failed,
363    #[doc(alias = "GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING")]
364    Connecting,
365    #[doc(alias = "GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED")]
366    Connected,
367    #[doc(hidden)]
368    __Unknown(i32),
369}
370
371#[doc(hidden)]
372impl IntoGlib for WebRTCDTLSTransportState {
373    type GlibType = ffi::GstWebRTCDTLSTransportState;
374
375    #[inline]
376    fn into_glib(self) -> ffi::GstWebRTCDTLSTransportState {
377        match self {
378            Self::New => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW,
379            Self::Closed => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED,
380            Self::Failed => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED,
381            Self::Connecting => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING,
382            Self::Connected => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED,
383            Self::__Unknown(value) => value,
384        }
385    }
386}
387
388#[doc(hidden)]
389impl FromGlib<ffi::GstWebRTCDTLSTransportState> for WebRTCDTLSTransportState {
390    #[inline]
391    unsafe fn from_glib(value: ffi::GstWebRTCDTLSTransportState) -> Self {
392        skip_assert_initialized!();
393
394        match value {
395            ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW => Self::New,
396            ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED => Self::Closed,
397            ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED => Self::Failed,
398            ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING => Self::Connecting,
399            ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED => Self::Connected,
400            value => Self::__Unknown(value),
401        }
402    }
403}
404
405impl StaticType for WebRTCDTLSTransportState {
406    #[inline]
407    #[doc(alias = "gst_webrtc_dtls_transport_state_get_type")]
408    fn static_type() -> glib::Type {
409        unsafe { from_glib(ffi::gst_webrtc_dtls_transport_state_get_type()) }
410    }
411}
412
413impl glib::HasParamSpec for WebRTCDTLSTransportState {
414    type ParamSpec = glib::ParamSpecEnum;
415    type SetValue = Self;
416    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
417
418    fn param_spec_builder() -> Self::BuilderFn {
419        Self::ParamSpec::builder_with_default
420    }
421}
422
423impl glib::value::ValueType for WebRTCDTLSTransportState {
424    type Type = Self;
425}
426
427unsafe impl<'a> glib::value::FromValue<'a> for WebRTCDTLSTransportState {
428    type Checker = glib::value::GenericValueTypeChecker<Self>;
429
430    #[inline]
431    unsafe fn from_value(value: &'a glib::Value) -> Self {
432        skip_assert_initialized!();
433        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
434    }
435}
436
437impl ToValue for WebRTCDTLSTransportState {
438    #[inline]
439    fn to_value(&self) -> glib::Value {
440        let mut value = glib::Value::for_value_type::<Self>();
441        unsafe {
442            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
443        }
444        value
445    }
446
447    #[inline]
448    fn value_type(&self) -> glib::Type {
449        Self::static_type()
450    }
451}
452
453impl From<WebRTCDTLSTransportState> for glib::Value {
454    #[inline]
455    fn from(v: WebRTCDTLSTransportState) -> Self {
456        skip_assert_initialized!();
457        ToValue::to_value(&v)
458    }
459}
460
461#[cfg(feature = "v1_16")]
462#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
463#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
464#[non_exhaustive]
465#[doc(alias = "GstWebRTCDataChannelState")]
466pub enum WebRTCDataChannelState {
467    #[doc(alias = "GST_WEBRTC_DATA_CHANNEL_STATE_CONNECTING")]
468    Connecting,
469    #[doc(alias = "GST_WEBRTC_DATA_CHANNEL_STATE_OPEN")]
470    Open,
471    #[doc(alias = "GST_WEBRTC_DATA_CHANNEL_STATE_CLOSING")]
472    Closing,
473    #[doc(alias = "GST_WEBRTC_DATA_CHANNEL_STATE_CLOSED")]
474    Closed,
475    #[doc(hidden)]
476    __Unknown(i32),
477}
478
479#[cfg(feature = "v1_16")]
480#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
481#[doc(hidden)]
482impl IntoGlib for WebRTCDataChannelState {
483    type GlibType = ffi::GstWebRTCDataChannelState;
484
485    #[inline]
486    fn into_glib(self) -> ffi::GstWebRTCDataChannelState {
487        match self {
488            Self::Connecting => ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CONNECTING,
489            Self::Open => ffi::GST_WEBRTC_DATA_CHANNEL_STATE_OPEN,
490            Self::Closing => ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CLOSING,
491            Self::Closed => ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CLOSED,
492            Self::__Unknown(value) => value,
493        }
494    }
495}
496
497#[cfg(feature = "v1_16")]
498#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
499#[doc(hidden)]
500impl FromGlib<ffi::GstWebRTCDataChannelState> for WebRTCDataChannelState {
501    #[inline]
502    unsafe fn from_glib(value: ffi::GstWebRTCDataChannelState) -> Self {
503        skip_assert_initialized!();
504
505        match value {
506            ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CONNECTING => Self::Connecting,
507            ffi::GST_WEBRTC_DATA_CHANNEL_STATE_OPEN => Self::Open,
508            ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CLOSING => Self::Closing,
509            ffi::GST_WEBRTC_DATA_CHANNEL_STATE_CLOSED => Self::Closed,
510            value => Self::__Unknown(value),
511        }
512    }
513}
514
515#[cfg(feature = "v1_16")]
516#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
517impl StaticType for WebRTCDataChannelState {
518    #[inline]
519    #[doc(alias = "gst_webrtc_data_channel_state_get_type")]
520    fn static_type() -> glib::Type {
521        unsafe { from_glib(ffi::gst_webrtc_data_channel_state_get_type()) }
522    }
523}
524
525#[cfg(feature = "v1_16")]
526#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
527impl glib::HasParamSpec for WebRTCDataChannelState {
528    type ParamSpec = glib::ParamSpecEnum;
529    type SetValue = Self;
530    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
531
532    fn param_spec_builder() -> Self::BuilderFn {
533        Self::ParamSpec::builder_with_default
534    }
535}
536
537#[cfg(feature = "v1_16")]
538#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
539impl glib::value::ValueType for WebRTCDataChannelState {
540    type Type = Self;
541}
542
543#[cfg(feature = "v1_16")]
544#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
545unsafe impl<'a> glib::value::FromValue<'a> for WebRTCDataChannelState {
546    type Checker = glib::value::GenericValueTypeChecker<Self>;
547
548    #[inline]
549    unsafe fn from_value(value: &'a glib::Value) -> Self {
550        skip_assert_initialized!();
551        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
552    }
553}
554
555#[cfg(feature = "v1_16")]
556#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
557impl ToValue for WebRTCDataChannelState {
558    #[inline]
559    fn to_value(&self) -> glib::Value {
560        let mut value = glib::Value::for_value_type::<Self>();
561        unsafe {
562            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
563        }
564        value
565    }
566
567    #[inline]
568    fn value_type(&self) -> glib::Type {
569        Self::static_type()
570    }
571}
572
573#[cfg(feature = "v1_16")]
574#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
575impl From<WebRTCDataChannelState> for glib::Value {
576    #[inline]
577    fn from(v: WebRTCDataChannelState) -> Self {
578        skip_assert_initialized!();
579        ToValue::to_value(&v)
580    }
581}
582
583#[cfg(feature = "v1_20")]
584#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
585#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
586#[non_exhaustive]
587#[doc(alias = "GstWebRTCError")]
588pub enum WebRTCError {
589    #[doc(alias = "GST_WEBRTC_ERROR_DATA_CHANNEL_FAILURE")]
590    DataChannelFailure,
591    #[doc(alias = "GST_WEBRTC_ERROR_DTLS_FAILURE")]
592    DtlsFailure,
593    #[doc(alias = "GST_WEBRTC_ERROR_FINGERPRINT_FAILURE")]
594    FingerprintFailure,
595    #[doc(alias = "GST_WEBRTC_ERROR_SCTP_FAILURE")]
596    SctpFailure,
597    #[doc(alias = "GST_WEBRTC_ERROR_SDP_SYNTAX_ERROR")]
598    SdpSyntaxError,
599    #[doc(alias = "GST_WEBRTC_ERROR_HARDWARE_ENCODER_NOT_AVAILABLE")]
600    HardwareEncoderNotAvailable,
601    #[doc(alias = "GST_WEBRTC_ERROR_ENCODER_ERROR")]
602    EncoderError,
603    #[doc(alias = "GST_WEBRTC_ERROR_INVALID_STATE")]
604    InvalidState,
605    #[doc(alias = "GST_WEBRTC_ERROR_INTERNAL_FAILURE")]
606    InternalFailure,
607    #[cfg(feature = "v1_22")]
608    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
609    #[doc(alias = "GST_WEBRTC_ERROR_INVALID_MODIFICATION")]
610    InvalidModification,
611    #[cfg(feature = "v1_22")]
612    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
613    #[doc(alias = "GST_WEBRTC_ERROR_TYPE_ERROR")]
614    TypeError,
615    #[doc(hidden)]
616    __Unknown(i32),
617}
618
619#[cfg(feature = "v1_20")]
620#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
621#[doc(hidden)]
622impl IntoGlib for WebRTCError {
623    type GlibType = ffi::GstWebRTCError;
624
625    #[inline]
626    fn into_glib(self) -> ffi::GstWebRTCError {
627        match self {
628            Self::DataChannelFailure => ffi::GST_WEBRTC_ERROR_DATA_CHANNEL_FAILURE,
629            Self::DtlsFailure => ffi::GST_WEBRTC_ERROR_DTLS_FAILURE,
630            Self::FingerprintFailure => ffi::GST_WEBRTC_ERROR_FINGERPRINT_FAILURE,
631            Self::SctpFailure => ffi::GST_WEBRTC_ERROR_SCTP_FAILURE,
632            Self::SdpSyntaxError => ffi::GST_WEBRTC_ERROR_SDP_SYNTAX_ERROR,
633            Self::HardwareEncoderNotAvailable => {
634                ffi::GST_WEBRTC_ERROR_HARDWARE_ENCODER_NOT_AVAILABLE
635            }
636            Self::EncoderError => ffi::GST_WEBRTC_ERROR_ENCODER_ERROR,
637            Self::InvalidState => ffi::GST_WEBRTC_ERROR_INVALID_STATE,
638            Self::InternalFailure => ffi::GST_WEBRTC_ERROR_INTERNAL_FAILURE,
639            #[cfg(feature = "v1_22")]
640            Self::InvalidModification => ffi::GST_WEBRTC_ERROR_INVALID_MODIFICATION,
641            #[cfg(feature = "v1_22")]
642            Self::TypeError => ffi::GST_WEBRTC_ERROR_TYPE_ERROR,
643            Self::__Unknown(value) => value,
644        }
645    }
646}
647
648#[cfg(feature = "v1_20")]
649#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
650#[doc(hidden)]
651impl FromGlib<ffi::GstWebRTCError> for WebRTCError {
652    #[inline]
653    unsafe fn from_glib(value: ffi::GstWebRTCError) -> Self {
654        skip_assert_initialized!();
655
656        match value {
657            ffi::GST_WEBRTC_ERROR_DATA_CHANNEL_FAILURE => Self::DataChannelFailure,
658            ffi::GST_WEBRTC_ERROR_DTLS_FAILURE => Self::DtlsFailure,
659            ffi::GST_WEBRTC_ERROR_FINGERPRINT_FAILURE => Self::FingerprintFailure,
660            ffi::GST_WEBRTC_ERROR_SCTP_FAILURE => Self::SctpFailure,
661            ffi::GST_WEBRTC_ERROR_SDP_SYNTAX_ERROR => Self::SdpSyntaxError,
662            ffi::GST_WEBRTC_ERROR_HARDWARE_ENCODER_NOT_AVAILABLE => {
663                Self::HardwareEncoderNotAvailable
664            }
665            ffi::GST_WEBRTC_ERROR_ENCODER_ERROR => Self::EncoderError,
666            ffi::GST_WEBRTC_ERROR_INVALID_STATE => Self::InvalidState,
667            ffi::GST_WEBRTC_ERROR_INTERNAL_FAILURE => Self::InternalFailure,
668            #[cfg(feature = "v1_22")]
669            ffi::GST_WEBRTC_ERROR_INVALID_MODIFICATION => Self::InvalidModification,
670            #[cfg(feature = "v1_22")]
671            ffi::GST_WEBRTC_ERROR_TYPE_ERROR => Self::TypeError,
672            value => Self::__Unknown(value),
673        }
674    }
675}
676
677#[cfg(feature = "v1_20")]
678#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
679impl glib::error::ErrorDomain for WebRTCError {
680    #[inline]
681    fn domain() -> glib::Quark {
682        skip_assert_initialized!();
683
684        unsafe { from_glib(ffi::gst_webrtc_error_quark()) }
685    }
686
687    #[inline]
688    fn code(self) -> i32 {
689        self.into_glib()
690    }
691
692    #[inline]
693    #[allow(clippy::match_single_binding)]
694    fn from(code: i32) -> Option<Self> {
695        skip_assert_initialized!();
696        match unsafe { from_glib(code) } {
697            value => Some(value),
698        }
699    }
700}
701
702#[cfg(feature = "v1_20")]
703#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
704impl StaticType for WebRTCError {
705    #[inline]
706    #[doc(alias = "gst_webrtc_error_get_type")]
707    fn static_type() -> glib::Type {
708        unsafe { from_glib(ffi::gst_webrtc_error_get_type()) }
709    }
710}
711
712#[cfg(feature = "v1_20")]
713#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
714impl glib::HasParamSpec for WebRTCError {
715    type ParamSpec = glib::ParamSpecEnum;
716    type SetValue = Self;
717    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
718
719    fn param_spec_builder() -> Self::BuilderFn {
720        Self::ParamSpec::builder_with_default
721    }
722}
723
724#[cfg(feature = "v1_20")]
725#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
726impl glib::value::ValueType for WebRTCError {
727    type Type = Self;
728}
729
730#[cfg(feature = "v1_20")]
731#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
732unsafe impl<'a> glib::value::FromValue<'a> for WebRTCError {
733    type Checker = glib::value::GenericValueTypeChecker<Self>;
734
735    #[inline]
736    unsafe fn from_value(value: &'a glib::Value) -> Self {
737        skip_assert_initialized!();
738        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
739    }
740}
741
742#[cfg(feature = "v1_20")]
743#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
744impl ToValue for WebRTCError {
745    #[inline]
746    fn to_value(&self) -> glib::Value {
747        let mut value = glib::Value::for_value_type::<Self>();
748        unsafe {
749            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
750        }
751        value
752    }
753
754    #[inline]
755    fn value_type(&self) -> glib::Type {
756        Self::static_type()
757    }
758}
759
760#[cfg(feature = "v1_20")]
761#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
762impl From<WebRTCError> for glib::Value {
763    #[inline]
764    fn from(v: WebRTCError) -> Self {
765        skip_assert_initialized!();
766        ToValue::to_value(&v)
767    }
768}
769
770#[cfg(feature = "v1_14_1")]
771#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
772#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
773#[non_exhaustive]
774#[doc(alias = "GstWebRTCFECType")]
775pub enum WebRTCFECType {
776    #[doc(alias = "GST_WEBRTC_FEC_TYPE_NONE")]
777    None,
778    #[doc(alias = "GST_WEBRTC_FEC_TYPE_ULP_RED")]
779    UlpRed,
780    #[doc(hidden)]
781    __Unknown(i32),
782}
783
784#[cfg(feature = "v1_14_1")]
785#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
786#[doc(hidden)]
787impl IntoGlib for WebRTCFECType {
788    type GlibType = ffi::GstWebRTCFECType;
789
790    #[inline]
791    fn into_glib(self) -> ffi::GstWebRTCFECType {
792        match self {
793            Self::None => ffi::GST_WEBRTC_FEC_TYPE_NONE,
794            Self::UlpRed => ffi::GST_WEBRTC_FEC_TYPE_ULP_RED,
795            Self::__Unknown(value) => value,
796        }
797    }
798}
799
800#[cfg(feature = "v1_14_1")]
801#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
802#[doc(hidden)]
803impl FromGlib<ffi::GstWebRTCFECType> for WebRTCFECType {
804    #[inline]
805    unsafe fn from_glib(value: ffi::GstWebRTCFECType) -> Self {
806        skip_assert_initialized!();
807
808        match value {
809            ffi::GST_WEBRTC_FEC_TYPE_NONE => Self::None,
810            ffi::GST_WEBRTC_FEC_TYPE_ULP_RED => Self::UlpRed,
811            value => Self::__Unknown(value),
812        }
813    }
814}
815
816#[cfg(feature = "v1_14_1")]
817#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
818impl StaticType for WebRTCFECType {
819    #[inline]
820    #[doc(alias = "gst_webrtc_fec_type_get_type")]
821    fn static_type() -> glib::Type {
822        unsafe { from_glib(ffi::gst_webrtc_fec_type_get_type()) }
823    }
824}
825
826#[cfg(feature = "v1_14_1")]
827#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
828impl glib::HasParamSpec for WebRTCFECType {
829    type ParamSpec = glib::ParamSpecEnum;
830    type SetValue = Self;
831    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
832
833    fn param_spec_builder() -> Self::BuilderFn {
834        Self::ParamSpec::builder_with_default
835    }
836}
837
838#[cfg(feature = "v1_14_1")]
839#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
840impl glib::value::ValueType for WebRTCFECType {
841    type Type = Self;
842}
843
844#[cfg(feature = "v1_14_1")]
845#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
846unsafe impl<'a> glib::value::FromValue<'a> for WebRTCFECType {
847    type Checker = glib::value::GenericValueTypeChecker<Self>;
848
849    #[inline]
850    unsafe fn from_value(value: &'a glib::Value) -> Self {
851        skip_assert_initialized!();
852        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
853    }
854}
855
856#[cfg(feature = "v1_14_1")]
857#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
858impl ToValue for WebRTCFECType {
859    #[inline]
860    fn to_value(&self) -> glib::Value {
861        let mut value = glib::Value::for_value_type::<Self>();
862        unsafe {
863            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
864        }
865        value
866    }
867
868    #[inline]
869    fn value_type(&self) -> glib::Type {
870        Self::static_type()
871    }
872}
873
874#[cfg(feature = "v1_14_1")]
875#[cfg_attr(docsrs, doc(cfg(feature = "v1_14_1")))]
876impl From<WebRTCFECType> for glib::Value {
877    #[inline]
878    fn from(v: WebRTCFECType) -> Self {
879        skip_assert_initialized!();
880        ToValue::to_value(&v)
881    }
882}
883
884#[cfg(feature = "v1_28")]
885#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
886#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
887#[non_exhaustive]
888#[doc(alias = "GstWebRTCICECandidateProtocolType")]
889pub enum WebRTCICECandidateProtocolType {
890    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_TCP")]
891    Tcp,
892    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_UDP")]
893    Udp,
894    #[doc(hidden)]
895    __Unknown(i32),
896}
897
898#[cfg(feature = "v1_28")]
899#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
900#[doc(hidden)]
901impl IntoGlib for WebRTCICECandidateProtocolType {
902    type GlibType = ffi::GstWebRTCICECandidateProtocolType;
903
904    #[inline]
905    fn into_glib(self) -> ffi::GstWebRTCICECandidateProtocolType {
906        match self {
907            Self::Tcp => ffi::GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_TCP,
908            Self::Udp => ffi::GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_UDP,
909            Self::__Unknown(value) => value,
910        }
911    }
912}
913
914#[cfg(feature = "v1_28")]
915#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
916#[doc(hidden)]
917impl FromGlib<ffi::GstWebRTCICECandidateProtocolType> for WebRTCICECandidateProtocolType {
918    #[inline]
919    unsafe fn from_glib(value: ffi::GstWebRTCICECandidateProtocolType) -> Self {
920        skip_assert_initialized!();
921
922        match value {
923            ffi::GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_TCP => Self::Tcp,
924            ffi::GST_WEBRTC_ICE_CANDIDATE_PROTOCOL_TYPE_UDP => Self::Udp,
925            value => Self::__Unknown(value),
926        }
927    }
928}
929
930#[cfg(feature = "v1_28")]
931#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
932impl StaticType for WebRTCICECandidateProtocolType {
933    #[inline]
934    #[doc(alias = "gst_webrtc_ice_candidate_protocol_type_get_type")]
935    fn static_type() -> glib::Type {
936        unsafe { from_glib(ffi::gst_webrtc_ice_candidate_protocol_type_get_type()) }
937    }
938}
939
940#[cfg(feature = "v1_28")]
941#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
942impl glib::HasParamSpec for WebRTCICECandidateProtocolType {
943    type ParamSpec = glib::ParamSpecEnum;
944    type SetValue = Self;
945    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
946
947    fn param_spec_builder() -> Self::BuilderFn {
948        Self::ParamSpec::builder_with_default
949    }
950}
951
952#[cfg(feature = "v1_28")]
953#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
954impl glib::value::ValueType for WebRTCICECandidateProtocolType {
955    type Type = Self;
956}
957
958#[cfg(feature = "v1_28")]
959#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
960unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICECandidateProtocolType {
961    type Checker = glib::value::GenericValueTypeChecker<Self>;
962
963    #[inline]
964    unsafe fn from_value(value: &'a glib::Value) -> Self {
965        skip_assert_initialized!();
966        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
967    }
968}
969
970#[cfg(feature = "v1_28")]
971#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
972impl ToValue for WebRTCICECandidateProtocolType {
973    #[inline]
974    fn to_value(&self) -> glib::Value {
975        let mut value = glib::Value::for_value_type::<Self>();
976        unsafe {
977            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
978        }
979        value
980    }
981
982    #[inline]
983    fn value_type(&self) -> glib::Type {
984        Self::static_type()
985    }
986}
987
988#[cfg(feature = "v1_28")]
989#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
990impl From<WebRTCICECandidateProtocolType> for glib::Value {
991    #[inline]
992    fn from(v: WebRTCICECandidateProtocolType) -> Self {
993        skip_assert_initialized!();
994        ToValue::to_value(&v)
995    }
996}
997
998#[cfg(feature = "v1_28")]
999#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1000#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1001#[non_exhaustive]
1002#[doc(alias = "GstWebRTCICECandidateType")]
1003pub enum WebRTCICECandidateType {
1004    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_TYPE_HOST")]
1005    Host,
1006    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_TYPE_SERVER_REFLEXIVE")]
1007    ServerReflexive,
1008    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_TYPE_PEER_REFLEXIVE")]
1009    PeerReflexive,
1010    #[doc(alias = "GST_WEBRTC_ICE_CANDIDATE_TYPE_RELAYED")]
1011    Relayed,
1012    #[doc(hidden)]
1013    __Unknown(i32),
1014}
1015
1016#[cfg(feature = "v1_28")]
1017#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1018#[doc(hidden)]
1019impl IntoGlib for WebRTCICECandidateType {
1020    type GlibType = ffi::GstWebRTCICECandidateType;
1021
1022    #[inline]
1023    fn into_glib(self) -> ffi::GstWebRTCICECandidateType {
1024        match self {
1025            Self::Host => ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_HOST,
1026            Self::ServerReflexive => ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_SERVER_REFLEXIVE,
1027            Self::PeerReflexive => ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_PEER_REFLEXIVE,
1028            Self::Relayed => ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_RELAYED,
1029            Self::__Unknown(value) => value,
1030        }
1031    }
1032}
1033
1034#[cfg(feature = "v1_28")]
1035#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1036#[doc(hidden)]
1037impl FromGlib<ffi::GstWebRTCICECandidateType> for WebRTCICECandidateType {
1038    #[inline]
1039    unsafe fn from_glib(value: ffi::GstWebRTCICECandidateType) -> Self {
1040        skip_assert_initialized!();
1041
1042        match value {
1043            ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_HOST => Self::Host,
1044            ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_SERVER_REFLEXIVE => Self::ServerReflexive,
1045            ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_PEER_REFLEXIVE => Self::PeerReflexive,
1046            ffi::GST_WEBRTC_ICE_CANDIDATE_TYPE_RELAYED => Self::Relayed,
1047            value => Self::__Unknown(value),
1048        }
1049    }
1050}
1051
1052#[cfg(feature = "v1_28")]
1053#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1054impl StaticType for WebRTCICECandidateType {
1055    #[inline]
1056    #[doc(alias = "gst_webrtc_ice_candidate_type_get_type")]
1057    fn static_type() -> glib::Type {
1058        unsafe { from_glib(ffi::gst_webrtc_ice_candidate_type_get_type()) }
1059    }
1060}
1061
1062#[cfg(feature = "v1_28")]
1063#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1064impl glib::HasParamSpec for WebRTCICECandidateType {
1065    type ParamSpec = glib::ParamSpecEnum;
1066    type SetValue = Self;
1067    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1068
1069    fn param_spec_builder() -> Self::BuilderFn {
1070        Self::ParamSpec::builder_with_default
1071    }
1072}
1073
1074#[cfg(feature = "v1_28")]
1075#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1076impl glib::value::ValueType for WebRTCICECandidateType {
1077    type Type = Self;
1078}
1079
1080#[cfg(feature = "v1_28")]
1081#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1082unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICECandidateType {
1083    type Checker = glib::value::GenericValueTypeChecker<Self>;
1084
1085    #[inline]
1086    unsafe fn from_value(value: &'a glib::Value) -> Self {
1087        skip_assert_initialized!();
1088        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1089    }
1090}
1091
1092#[cfg(feature = "v1_28")]
1093#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1094impl ToValue for WebRTCICECandidateType {
1095    #[inline]
1096    fn to_value(&self) -> glib::Value {
1097        let mut value = glib::Value::for_value_type::<Self>();
1098        unsafe {
1099            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1100        }
1101        value
1102    }
1103
1104    #[inline]
1105    fn value_type(&self) -> glib::Type {
1106        Self::static_type()
1107    }
1108}
1109
1110#[cfg(feature = "v1_28")]
1111#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1112impl From<WebRTCICECandidateType> for glib::Value {
1113    #[inline]
1114    fn from(v: WebRTCICECandidateType) -> Self {
1115        skip_assert_initialized!();
1116        ToValue::to_value(&v)
1117    }
1118}
1119
1120#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1121#[non_exhaustive]
1122#[doc(alias = "GstWebRTCICEComponent")]
1123pub enum WebRTCICEComponent {
1124    #[doc(alias = "GST_WEBRTC_ICE_COMPONENT_RTP")]
1125    Rtp,
1126    #[doc(alias = "GST_WEBRTC_ICE_COMPONENT_RTCP")]
1127    Rtcp,
1128    #[doc(hidden)]
1129    __Unknown(i32),
1130}
1131
1132#[doc(hidden)]
1133impl IntoGlib for WebRTCICEComponent {
1134    type GlibType = ffi::GstWebRTCICEComponent;
1135
1136    #[inline]
1137    fn into_glib(self) -> ffi::GstWebRTCICEComponent {
1138        match self {
1139            Self::Rtp => ffi::GST_WEBRTC_ICE_COMPONENT_RTP,
1140            Self::Rtcp => ffi::GST_WEBRTC_ICE_COMPONENT_RTCP,
1141            Self::__Unknown(value) => value,
1142        }
1143    }
1144}
1145
1146#[doc(hidden)]
1147impl FromGlib<ffi::GstWebRTCICEComponent> for WebRTCICEComponent {
1148    #[inline]
1149    unsafe fn from_glib(value: ffi::GstWebRTCICEComponent) -> Self {
1150        skip_assert_initialized!();
1151
1152        match value {
1153            ffi::GST_WEBRTC_ICE_COMPONENT_RTP => Self::Rtp,
1154            ffi::GST_WEBRTC_ICE_COMPONENT_RTCP => Self::Rtcp,
1155            value => Self::__Unknown(value),
1156        }
1157    }
1158}
1159
1160impl StaticType for WebRTCICEComponent {
1161    #[inline]
1162    #[doc(alias = "gst_webrtc_ice_component_get_type")]
1163    fn static_type() -> glib::Type {
1164        unsafe { from_glib(ffi::gst_webrtc_ice_component_get_type()) }
1165    }
1166}
1167
1168impl glib::HasParamSpec for WebRTCICEComponent {
1169    type ParamSpec = glib::ParamSpecEnum;
1170    type SetValue = Self;
1171    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1172
1173    fn param_spec_builder() -> Self::BuilderFn {
1174        Self::ParamSpec::builder_with_default
1175    }
1176}
1177
1178impl glib::value::ValueType for WebRTCICEComponent {
1179    type Type = Self;
1180}
1181
1182unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEComponent {
1183    type Checker = glib::value::GenericValueTypeChecker<Self>;
1184
1185    #[inline]
1186    unsafe fn from_value(value: &'a glib::Value) -> Self {
1187        skip_assert_initialized!();
1188        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1189    }
1190}
1191
1192impl ToValue for WebRTCICEComponent {
1193    #[inline]
1194    fn to_value(&self) -> glib::Value {
1195        let mut value = glib::Value::for_value_type::<Self>();
1196        unsafe {
1197            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1198        }
1199        value
1200    }
1201
1202    #[inline]
1203    fn value_type(&self) -> glib::Type {
1204        Self::static_type()
1205    }
1206}
1207
1208impl From<WebRTCICEComponent> for glib::Value {
1209    #[inline]
1210    fn from(v: WebRTCICEComponent) -> Self {
1211        skip_assert_initialized!();
1212        ToValue::to_value(&v)
1213    }
1214}
1215
1216#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1217#[non_exhaustive]
1218#[doc(alias = "GstWebRTCICEConnectionState")]
1219pub enum WebRTCICEConnectionState {
1220    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_NEW")]
1221    New,
1222    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING")]
1223    Checking,
1224    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED")]
1225    Connected,
1226    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED")]
1227    Completed,
1228    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_FAILED")]
1229    Failed,
1230    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED")]
1231    Disconnected,
1232    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED")]
1233    Closed,
1234    #[doc(hidden)]
1235    __Unknown(i32),
1236}
1237
1238#[doc(hidden)]
1239impl IntoGlib for WebRTCICEConnectionState {
1240    type GlibType = ffi::GstWebRTCICEConnectionState;
1241
1242    #[inline]
1243    fn into_glib(self) -> ffi::GstWebRTCICEConnectionState {
1244        match self {
1245            Self::New => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_NEW,
1246            Self::Checking => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING,
1247            Self::Connected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED,
1248            Self::Completed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED,
1249            Self::Failed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_FAILED,
1250            Self::Disconnected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED,
1251            Self::Closed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED,
1252            Self::__Unknown(value) => value,
1253        }
1254    }
1255}
1256
1257#[doc(hidden)]
1258impl FromGlib<ffi::GstWebRTCICEConnectionState> for WebRTCICEConnectionState {
1259    #[inline]
1260    unsafe fn from_glib(value: ffi::GstWebRTCICEConnectionState) -> Self {
1261        skip_assert_initialized!();
1262
1263        match value {
1264            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_NEW => Self::New,
1265            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING => Self::Checking,
1266            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED => Self::Connected,
1267            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED => Self::Completed,
1268            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_FAILED => Self::Failed,
1269            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED => Self::Disconnected,
1270            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED => Self::Closed,
1271            value => Self::__Unknown(value),
1272        }
1273    }
1274}
1275
1276impl StaticType for WebRTCICEConnectionState {
1277    #[inline]
1278    #[doc(alias = "gst_webrtc_ice_connection_state_get_type")]
1279    fn static_type() -> glib::Type {
1280        unsafe { from_glib(ffi::gst_webrtc_ice_connection_state_get_type()) }
1281    }
1282}
1283
1284impl glib::HasParamSpec for WebRTCICEConnectionState {
1285    type ParamSpec = glib::ParamSpecEnum;
1286    type SetValue = Self;
1287    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1288
1289    fn param_spec_builder() -> Self::BuilderFn {
1290        Self::ParamSpec::builder_with_default
1291    }
1292}
1293
1294impl glib::value::ValueType for WebRTCICEConnectionState {
1295    type Type = Self;
1296}
1297
1298unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEConnectionState {
1299    type Checker = glib::value::GenericValueTypeChecker<Self>;
1300
1301    #[inline]
1302    unsafe fn from_value(value: &'a glib::Value) -> Self {
1303        skip_assert_initialized!();
1304        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1305    }
1306}
1307
1308impl ToValue for WebRTCICEConnectionState {
1309    #[inline]
1310    fn to_value(&self) -> glib::Value {
1311        let mut value = glib::Value::for_value_type::<Self>();
1312        unsafe {
1313            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1314        }
1315        value
1316    }
1317
1318    #[inline]
1319    fn value_type(&self) -> glib::Type {
1320        Self::static_type()
1321    }
1322}
1323
1324impl From<WebRTCICEConnectionState> for glib::Value {
1325    #[inline]
1326    fn from(v: WebRTCICEConnectionState) -> Self {
1327        skip_assert_initialized!();
1328        ToValue::to_value(&v)
1329    }
1330}
1331
1332#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1333#[non_exhaustive]
1334#[doc(alias = "GstWebRTCICEGatheringState")]
1335pub enum WebRTCICEGatheringState {
1336    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_NEW")]
1337    New,
1338    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_GATHERING")]
1339    Gathering,
1340    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE")]
1341    Complete,
1342    #[doc(hidden)]
1343    __Unknown(i32),
1344}
1345
1346#[doc(hidden)]
1347impl IntoGlib for WebRTCICEGatheringState {
1348    type GlibType = ffi::GstWebRTCICEGatheringState;
1349
1350    #[inline]
1351    fn into_glib(self) -> ffi::GstWebRTCICEGatheringState {
1352        match self {
1353            Self::New => ffi::GST_WEBRTC_ICE_GATHERING_STATE_NEW,
1354            Self::Gathering => ffi::GST_WEBRTC_ICE_GATHERING_STATE_GATHERING,
1355            Self::Complete => ffi::GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE,
1356            Self::__Unknown(value) => value,
1357        }
1358    }
1359}
1360
1361#[doc(hidden)]
1362impl FromGlib<ffi::GstWebRTCICEGatheringState> for WebRTCICEGatheringState {
1363    #[inline]
1364    unsafe fn from_glib(value: ffi::GstWebRTCICEGatheringState) -> Self {
1365        skip_assert_initialized!();
1366
1367        match value {
1368            ffi::GST_WEBRTC_ICE_GATHERING_STATE_NEW => Self::New,
1369            ffi::GST_WEBRTC_ICE_GATHERING_STATE_GATHERING => Self::Gathering,
1370            ffi::GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE => Self::Complete,
1371            value => Self::__Unknown(value),
1372        }
1373    }
1374}
1375
1376impl StaticType for WebRTCICEGatheringState {
1377    #[inline]
1378    #[doc(alias = "gst_webrtc_ice_gathering_state_get_type")]
1379    fn static_type() -> glib::Type {
1380        unsafe { from_glib(ffi::gst_webrtc_ice_gathering_state_get_type()) }
1381    }
1382}
1383
1384impl glib::HasParamSpec for WebRTCICEGatheringState {
1385    type ParamSpec = glib::ParamSpecEnum;
1386    type SetValue = Self;
1387    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1388
1389    fn param_spec_builder() -> Self::BuilderFn {
1390        Self::ParamSpec::builder_with_default
1391    }
1392}
1393
1394impl glib::value::ValueType for WebRTCICEGatheringState {
1395    type Type = Self;
1396}
1397
1398unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEGatheringState {
1399    type Checker = glib::value::GenericValueTypeChecker<Self>;
1400
1401    #[inline]
1402    unsafe fn from_value(value: &'a glib::Value) -> Self {
1403        skip_assert_initialized!();
1404        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1405    }
1406}
1407
1408impl ToValue for WebRTCICEGatheringState {
1409    #[inline]
1410    fn to_value(&self) -> glib::Value {
1411        let mut value = glib::Value::for_value_type::<Self>();
1412        unsafe {
1413            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1414        }
1415        value
1416    }
1417
1418    #[inline]
1419    fn value_type(&self) -> glib::Type {
1420        Self::static_type()
1421    }
1422}
1423
1424impl From<WebRTCICEGatheringState> for glib::Value {
1425    #[inline]
1426    fn from(v: WebRTCICEGatheringState) -> Self {
1427        skip_assert_initialized!();
1428        ToValue::to_value(&v)
1429    }
1430}
1431
1432#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1433#[non_exhaustive]
1434#[doc(alias = "GstWebRTCICERole")]
1435pub enum WebRTCICERole {
1436    #[doc(alias = "GST_WEBRTC_ICE_ROLE_CONTROLLED")]
1437    Controlled,
1438    #[doc(alias = "GST_WEBRTC_ICE_ROLE_CONTROLLING")]
1439    Controlling,
1440    #[doc(hidden)]
1441    __Unknown(i32),
1442}
1443
1444#[doc(hidden)]
1445impl IntoGlib for WebRTCICERole {
1446    type GlibType = ffi::GstWebRTCICERole;
1447
1448    #[inline]
1449    fn into_glib(self) -> ffi::GstWebRTCICERole {
1450        match self {
1451            Self::Controlled => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLED,
1452            Self::Controlling => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLING,
1453            Self::__Unknown(value) => value,
1454        }
1455    }
1456}
1457
1458#[doc(hidden)]
1459impl FromGlib<ffi::GstWebRTCICERole> for WebRTCICERole {
1460    #[inline]
1461    unsafe fn from_glib(value: ffi::GstWebRTCICERole) -> Self {
1462        skip_assert_initialized!();
1463
1464        match value {
1465            ffi::GST_WEBRTC_ICE_ROLE_CONTROLLED => Self::Controlled,
1466            ffi::GST_WEBRTC_ICE_ROLE_CONTROLLING => Self::Controlling,
1467            value => Self::__Unknown(value),
1468        }
1469    }
1470}
1471
1472impl StaticType for WebRTCICERole {
1473    #[inline]
1474    #[doc(alias = "gst_webrtc_ice_role_get_type")]
1475    fn static_type() -> glib::Type {
1476        unsafe { from_glib(ffi::gst_webrtc_ice_role_get_type()) }
1477    }
1478}
1479
1480impl glib::HasParamSpec for WebRTCICERole {
1481    type ParamSpec = glib::ParamSpecEnum;
1482    type SetValue = Self;
1483    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1484
1485    fn param_spec_builder() -> Self::BuilderFn {
1486        Self::ParamSpec::builder_with_default
1487    }
1488}
1489
1490impl glib::value::ValueType for WebRTCICERole {
1491    type Type = Self;
1492}
1493
1494unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICERole {
1495    type Checker = glib::value::GenericValueTypeChecker<Self>;
1496
1497    #[inline]
1498    unsafe fn from_value(value: &'a glib::Value) -> Self {
1499        skip_assert_initialized!();
1500        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1501    }
1502}
1503
1504impl ToValue for WebRTCICERole {
1505    #[inline]
1506    fn to_value(&self) -> glib::Value {
1507        let mut value = glib::Value::for_value_type::<Self>();
1508        unsafe {
1509            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1510        }
1511        value
1512    }
1513
1514    #[inline]
1515    fn value_type(&self) -> glib::Type {
1516        Self::static_type()
1517    }
1518}
1519
1520impl From<WebRTCICERole> for glib::Value {
1521    #[inline]
1522    fn from(v: WebRTCICERole) -> Self {
1523        skip_assert_initialized!();
1524        ToValue::to_value(&v)
1525    }
1526}
1527
1528#[cfg(feature = "v1_28")]
1529#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1530#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1531#[non_exhaustive]
1532#[doc(alias = "GstWebRTCICETcpCandidateType")]
1533pub enum WebRTCICETcpCandidateType {
1534    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE")]
1535    Active,
1536    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE")]
1537    Passive,
1538    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO")]
1539    So,
1540    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE")]
1541    None,
1542    #[doc(hidden)]
1543    __Unknown(i32),
1544}
1545
1546#[cfg(feature = "v1_28")]
1547#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1548#[doc(hidden)]
1549impl IntoGlib for WebRTCICETcpCandidateType {
1550    type GlibType = ffi::GstWebRTCICETcpCandidateType;
1551
1552    #[inline]
1553    fn into_glib(self) -> ffi::GstWebRTCICETcpCandidateType {
1554        match self {
1555            Self::Active => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE,
1556            Self::Passive => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE,
1557            Self::So => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO,
1558            Self::None => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE,
1559            Self::__Unknown(value) => value,
1560        }
1561    }
1562}
1563
1564#[cfg(feature = "v1_28")]
1565#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1566#[doc(hidden)]
1567impl FromGlib<ffi::GstWebRTCICETcpCandidateType> for WebRTCICETcpCandidateType {
1568    #[inline]
1569    unsafe fn from_glib(value: ffi::GstWebRTCICETcpCandidateType) -> Self {
1570        skip_assert_initialized!();
1571
1572        match value {
1573            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE => Self::Active,
1574            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE => Self::Passive,
1575            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO => Self::So,
1576            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE => Self::None,
1577            value => Self::__Unknown(value),
1578        }
1579    }
1580}
1581
1582#[cfg(feature = "v1_28")]
1583#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1584impl StaticType for WebRTCICETcpCandidateType {
1585    #[inline]
1586    #[doc(alias = "gst_webrtc_ice_tcp_candidate_type_get_type")]
1587    fn static_type() -> glib::Type {
1588        unsafe { from_glib(ffi::gst_webrtc_ice_tcp_candidate_type_get_type()) }
1589    }
1590}
1591
1592#[cfg(feature = "v1_28")]
1593#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1594impl glib::HasParamSpec for WebRTCICETcpCandidateType {
1595    type ParamSpec = glib::ParamSpecEnum;
1596    type SetValue = Self;
1597    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1598
1599    fn param_spec_builder() -> Self::BuilderFn {
1600        Self::ParamSpec::builder_with_default
1601    }
1602}
1603
1604#[cfg(feature = "v1_28")]
1605#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1606impl glib::value::ValueType for WebRTCICETcpCandidateType {
1607    type Type = Self;
1608}
1609
1610#[cfg(feature = "v1_28")]
1611#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1612unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICETcpCandidateType {
1613    type Checker = glib::value::GenericValueTypeChecker<Self>;
1614
1615    #[inline]
1616    unsafe fn from_value(value: &'a glib::Value) -> Self {
1617        skip_assert_initialized!();
1618        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1619    }
1620}
1621
1622#[cfg(feature = "v1_28")]
1623#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1624impl ToValue for WebRTCICETcpCandidateType {
1625    #[inline]
1626    fn to_value(&self) -> glib::Value {
1627        let mut value = glib::Value::for_value_type::<Self>();
1628        unsafe {
1629            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1630        }
1631        value
1632    }
1633
1634    #[inline]
1635    fn value_type(&self) -> glib::Type {
1636        Self::static_type()
1637    }
1638}
1639
1640#[cfg(feature = "v1_28")]
1641#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1642impl From<WebRTCICETcpCandidateType> for glib::Value {
1643    #[inline]
1644    fn from(v: WebRTCICETcpCandidateType) -> Self {
1645        skip_assert_initialized!();
1646        ToValue::to_value(&v)
1647    }
1648}
1649
1650#[cfg(feature = "v1_16")]
1651#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1652#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1653#[non_exhaustive]
1654#[doc(alias = "GstWebRTCICETransportPolicy")]
1655pub enum WebRTCICETransportPolicy {
1656    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL")]
1657    All,
1658    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY")]
1659    Relay,
1660    #[doc(hidden)]
1661    __Unknown(i32),
1662}
1663
1664#[cfg(feature = "v1_16")]
1665#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1666#[doc(hidden)]
1667impl IntoGlib for WebRTCICETransportPolicy {
1668    type GlibType = ffi::GstWebRTCICETransportPolicy;
1669
1670    #[inline]
1671    fn into_glib(self) -> ffi::GstWebRTCICETransportPolicy {
1672        match self {
1673            Self::All => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL,
1674            Self::Relay => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY,
1675            Self::__Unknown(value) => value,
1676        }
1677    }
1678}
1679
1680#[cfg(feature = "v1_16")]
1681#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1682#[doc(hidden)]
1683impl FromGlib<ffi::GstWebRTCICETransportPolicy> for WebRTCICETransportPolicy {
1684    #[inline]
1685    unsafe fn from_glib(value: ffi::GstWebRTCICETransportPolicy) -> Self {
1686        skip_assert_initialized!();
1687
1688        match value {
1689            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL => Self::All,
1690            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY => Self::Relay,
1691            value => Self::__Unknown(value),
1692        }
1693    }
1694}
1695
1696#[cfg(feature = "v1_16")]
1697#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1698impl StaticType for WebRTCICETransportPolicy {
1699    #[inline]
1700    #[doc(alias = "gst_webrtc_ice_transport_policy_get_type")]
1701    fn static_type() -> glib::Type {
1702        unsafe { from_glib(ffi::gst_webrtc_ice_transport_policy_get_type()) }
1703    }
1704}
1705
1706#[cfg(feature = "v1_16")]
1707#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1708impl glib::HasParamSpec for WebRTCICETransportPolicy {
1709    type ParamSpec = glib::ParamSpecEnum;
1710    type SetValue = Self;
1711    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1712
1713    fn param_spec_builder() -> Self::BuilderFn {
1714        Self::ParamSpec::builder_with_default
1715    }
1716}
1717
1718#[cfg(feature = "v1_16")]
1719#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1720impl glib::value::ValueType for WebRTCICETransportPolicy {
1721    type Type = Self;
1722}
1723
1724#[cfg(feature = "v1_16")]
1725#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1726unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICETransportPolicy {
1727    type Checker = glib::value::GenericValueTypeChecker<Self>;
1728
1729    #[inline]
1730    unsafe fn from_value(value: &'a glib::Value) -> Self {
1731        skip_assert_initialized!();
1732        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1733    }
1734}
1735
1736#[cfg(feature = "v1_16")]
1737#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1738impl ToValue for WebRTCICETransportPolicy {
1739    #[inline]
1740    fn to_value(&self) -> glib::Value {
1741        let mut value = glib::Value::for_value_type::<Self>();
1742        unsafe {
1743            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1744        }
1745        value
1746    }
1747
1748    #[inline]
1749    fn value_type(&self) -> glib::Type {
1750        Self::static_type()
1751    }
1752}
1753
1754#[cfg(feature = "v1_16")]
1755#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1756impl From<WebRTCICETransportPolicy> for glib::Value {
1757    #[inline]
1758    fn from(v: WebRTCICETransportPolicy) -> Self {
1759        skip_assert_initialized!();
1760        ToValue::to_value(&v)
1761    }
1762}
1763
1764#[cfg(feature = "v1_20")]
1765#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1766#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1767#[non_exhaustive]
1768#[doc(alias = "GstWebRTCKind")]
1769pub enum WebRTCKind {
1770    #[doc(alias = "GST_WEBRTC_KIND_UNKNOWN")]
1771    Unknown,
1772    #[doc(alias = "GST_WEBRTC_KIND_AUDIO")]
1773    Audio,
1774    #[doc(alias = "GST_WEBRTC_KIND_VIDEO")]
1775    Video,
1776    #[doc(hidden)]
1777    __Unknown(i32),
1778}
1779
1780#[cfg(feature = "v1_20")]
1781#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1782#[doc(hidden)]
1783impl IntoGlib for WebRTCKind {
1784    type GlibType = ffi::GstWebRTCKind;
1785
1786    #[inline]
1787    fn into_glib(self) -> ffi::GstWebRTCKind {
1788        match self {
1789            Self::Unknown => ffi::GST_WEBRTC_KIND_UNKNOWN,
1790            Self::Audio => ffi::GST_WEBRTC_KIND_AUDIO,
1791            Self::Video => ffi::GST_WEBRTC_KIND_VIDEO,
1792            Self::__Unknown(value) => value,
1793        }
1794    }
1795}
1796
1797#[cfg(feature = "v1_20")]
1798#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1799#[doc(hidden)]
1800impl FromGlib<ffi::GstWebRTCKind> for WebRTCKind {
1801    #[inline]
1802    unsafe fn from_glib(value: ffi::GstWebRTCKind) -> Self {
1803        skip_assert_initialized!();
1804
1805        match value {
1806            ffi::GST_WEBRTC_KIND_UNKNOWN => Self::Unknown,
1807            ffi::GST_WEBRTC_KIND_AUDIO => Self::Audio,
1808            ffi::GST_WEBRTC_KIND_VIDEO => Self::Video,
1809            value => Self::__Unknown(value),
1810        }
1811    }
1812}
1813
1814#[cfg(feature = "v1_20")]
1815#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1816impl StaticType for WebRTCKind {
1817    #[inline]
1818    #[doc(alias = "gst_webrtc_kind_get_type")]
1819    fn static_type() -> glib::Type {
1820        unsafe { from_glib(ffi::gst_webrtc_kind_get_type()) }
1821    }
1822}
1823
1824#[cfg(feature = "v1_20")]
1825#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1826impl glib::HasParamSpec for WebRTCKind {
1827    type ParamSpec = glib::ParamSpecEnum;
1828    type SetValue = Self;
1829    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1830
1831    fn param_spec_builder() -> Self::BuilderFn {
1832        Self::ParamSpec::builder_with_default
1833    }
1834}
1835
1836#[cfg(feature = "v1_20")]
1837#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1838impl glib::value::ValueType for WebRTCKind {
1839    type Type = Self;
1840}
1841
1842#[cfg(feature = "v1_20")]
1843#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1844unsafe impl<'a> glib::value::FromValue<'a> for WebRTCKind {
1845    type Checker = glib::value::GenericValueTypeChecker<Self>;
1846
1847    #[inline]
1848    unsafe fn from_value(value: &'a glib::Value) -> Self {
1849        skip_assert_initialized!();
1850        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1851    }
1852}
1853
1854#[cfg(feature = "v1_20")]
1855#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1856impl ToValue for WebRTCKind {
1857    #[inline]
1858    fn to_value(&self) -> glib::Value {
1859        let mut value = glib::Value::for_value_type::<Self>();
1860        unsafe {
1861            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1862        }
1863        value
1864    }
1865
1866    #[inline]
1867    fn value_type(&self) -> glib::Type {
1868        Self::static_type()
1869    }
1870}
1871
1872#[cfg(feature = "v1_20")]
1873#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1874impl From<WebRTCKind> for glib::Value {
1875    #[inline]
1876    fn from(v: WebRTCKind) -> Self {
1877        skip_assert_initialized!();
1878        ToValue::to_value(&v)
1879    }
1880}
1881
1882#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1883#[non_exhaustive]
1884#[doc(alias = "GstWebRTCPeerConnectionState")]
1885pub enum WebRTCPeerConnectionState {
1886    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_NEW")]
1887    New,
1888    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING")]
1889    Connecting,
1890    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED")]
1891    Connected,
1892    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED")]
1893    Disconnected,
1894    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_FAILED")]
1895    Failed,
1896    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED")]
1897    Closed,
1898    #[doc(hidden)]
1899    __Unknown(i32),
1900}
1901
1902#[doc(hidden)]
1903impl IntoGlib for WebRTCPeerConnectionState {
1904    type GlibType = ffi::GstWebRTCPeerConnectionState;
1905
1906    #[inline]
1907    fn into_glib(self) -> ffi::GstWebRTCPeerConnectionState {
1908        match self {
1909            Self::New => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW,
1910            Self::Connecting => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING,
1911            Self::Connected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED,
1912            Self::Disconnected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED,
1913            Self::Failed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED,
1914            Self::Closed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED,
1915            Self::__Unknown(value) => value,
1916        }
1917    }
1918}
1919
1920#[doc(hidden)]
1921impl FromGlib<ffi::GstWebRTCPeerConnectionState> for WebRTCPeerConnectionState {
1922    #[inline]
1923    unsafe fn from_glib(value: ffi::GstWebRTCPeerConnectionState) -> Self {
1924        skip_assert_initialized!();
1925
1926        match value {
1927            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW => Self::New,
1928            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING => Self::Connecting,
1929            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED => Self::Connected,
1930            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED => Self::Disconnected,
1931            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED => Self::Failed,
1932            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED => Self::Closed,
1933            value => Self::__Unknown(value),
1934        }
1935    }
1936}
1937
1938impl StaticType for WebRTCPeerConnectionState {
1939    #[inline]
1940    #[doc(alias = "gst_webrtc_peer_connection_state_get_type")]
1941    fn static_type() -> glib::Type {
1942        unsafe { from_glib(ffi::gst_webrtc_peer_connection_state_get_type()) }
1943    }
1944}
1945
1946impl glib::HasParamSpec for WebRTCPeerConnectionState {
1947    type ParamSpec = glib::ParamSpecEnum;
1948    type SetValue = Self;
1949    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1950
1951    fn param_spec_builder() -> Self::BuilderFn {
1952        Self::ParamSpec::builder_with_default
1953    }
1954}
1955
1956impl glib::value::ValueType for WebRTCPeerConnectionState {
1957    type Type = Self;
1958}
1959
1960unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPeerConnectionState {
1961    type Checker = glib::value::GenericValueTypeChecker<Self>;
1962
1963    #[inline]
1964    unsafe fn from_value(value: &'a glib::Value) -> Self {
1965        skip_assert_initialized!();
1966        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1967    }
1968}
1969
1970impl ToValue for WebRTCPeerConnectionState {
1971    #[inline]
1972    fn to_value(&self) -> glib::Value {
1973        let mut value = glib::Value::for_value_type::<Self>();
1974        unsafe {
1975            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1976        }
1977        value
1978    }
1979
1980    #[inline]
1981    fn value_type(&self) -> glib::Type {
1982        Self::static_type()
1983    }
1984}
1985
1986impl From<WebRTCPeerConnectionState> for glib::Value {
1987    #[inline]
1988    fn from(v: WebRTCPeerConnectionState) -> Self {
1989        skip_assert_initialized!();
1990        ToValue::to_value(&v)
1991    }
1992}
1993
1994#[cfg(feature = "v1_16")]
1995#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1996#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1997#[non_exhaustive]
1998#[doc(alias = "GstWebRTCPriorityType")]
1999pub enum WebRTCPriorityType {
2000    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_VERY_LOW")]
2001    VeryLow,
2002    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_LOW")]
2003    Low,
2004    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_MEDIUM")]
2005    Medium,
2006    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_HIGH")]
2007    High,
2008    #[doc(hidden)]
2009    __Unknown(i32),
2010}
2011
2012#[cfg(feature = "v1_16")]
2013#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2014#[doc(hidden)]
2015impl IntoGlib for WebRTCPriorityType {
2016    type GlibType = ffi::GstWebRTCPriorityType;
2017
2018    #[inline]
2019    fn into_glib(self) -> ffi::GstWebRTCPriorityType {
2020        match self {
2021            Self::VeryLow => ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW,
2022            Self::Low => ffi::GST_WEBRTC_PRIORITY_TYPE_LOW,
2023            Self::Medium => ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM,
2024            Self::High => ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH,
2025            Self::__Unknown(value) => value,
2026        }
2027    }
2028}
2029
2030#[cfg(feature = "v1_16")]
2031#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2032#[doc(hidden)]
2033impl FromGlib<ffi::GstWebRTCPriorityType> for WebRTCPriorityType {
2034    #[inline]
2035    unsafe fn from_glib(value: ffi::GstWebRTCPriorityType) -> Self {
2036        skip_assert_initialized!();
2037
2038        match value {
2039            ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW => Self::VeryLow,
2040            ffi::GST_WEBRTC_PRIORITY_TYPE_LOW => Self::Low,
2041            ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM => Self::Medium,
2042            ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH => Self::High,
2043            value => Self::__Unknown(value),
2044        }
2045    }
2046}
2047
2048#[cfg(feature = "v1_16")]
2049#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2050impl StaticType for WebRTCPriorityType {
2051    #[inline]
2052    #[doc(alias = "gst_webrtc_priority_type_get_type")]
2053    fn static_type() -> glib::Type {
2054        unsafe { from_glib(ffi::gst_webrtc_priority_type_get_type()) }
2055    }
2056}
2057
2058#[cfg(feature = "v1_16")]
2059#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2060impl glib::HasParamSpec for WebRTCPriorityType {
2061    type ParamSpec = glib::ParamSpecEnum;
2062    type SetValue = Self;
2063    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2064
2065    fn param_spec_builder() -> Self::BuilderFn {
2066        Self::ParamSpec::builder_with_default
2067    }
2068}
2069
2070#[cfg(feature = "v1_16")]
2071#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2072impl glib::value::ValueType for WebRTCPriorityType {
2073    type Type = Self;
2074}
2075
2076#[cfg(feature = "v1_16")]
2077#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2078unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPriorityType {
2079    type Checker = glib::value::GenericValueTypeChecker<Self>;
2080
2081    #[inline]
2082    unsafe fn from_value(value: &'a glib::Value) -> Self {
2083        skip_assert_initialized!();
2084        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2085    }
2086}
2087
2088#[cfg(feature = "v1_16")]
2089#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2090impl ToValue for WebRTCPriorityType {
2091    #[inline]
2092    fn to_value(&self) -> glib::Value {
2093        let mut value = glib::Value::for_value_type::<Self>();
2094        unsafe {
2095            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2096        }
2097        value
2098    }
2099
2100    #[inline]
2101    fn value_type(&self) -> glib::Type {
2102        Self::static_type()
2103    }
2104}
2105
2106#[cfg(feature = "v1_16")]
2107#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2108impl From<WebRTCPriorityType> for glib::Value {
2109    #[inline]
2110    fn from(v: WebRTCPriorityType) -> Self {
2111        skip_assert_initialized!();
2112        ToValue::to_value(&v)
2113    }
2114}
2115
2116#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2117#[non_exhaustive]
2118#[doc(alias = "GstWebRTCRTPTransceiverDirection")]
2119pub enum WebRTCRTPTransceiverDirection {
2120    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE")]
2121    None,
2122    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE")]
2123    Inactive,
2124    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY")]
2125    Sendonly,
2126    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY")]
2127    Recvonly,
2128    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV")]
2129    Sendrecv,
2130    #[doc(hidden)]
2131    __Unknown(i32),
2132}
2133
2134#[doc(hidden)]
2135impl IntoGlib for WebRTCRTPTransceiverDirection {
2136    type GlibType = ffi::GstWebRTCRTPTransceiverDirection;
2137
2138    #[inline]
2139    fn into_glib(self) -> ffi::GstWebRTCRTPTransceiverDirection {
2140        match self {
2141            Self::None => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE,
2142            Self::Inactive => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE,
2143            Self::Sendonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY,
2144            Self::Recvonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY,
2145            Self::Sendrecv => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV,
2146            Self::__Unknown(value) => value,
2147        }
2148    }
2149}
2150
2151#[doc(hidden)]
2152impl FromGlib<ffi::GstWebRTCRTPTransceiverDirection> for WebRTCRTPTransceiverDirection {
2153    #[inline]
2154    unsafe fn from_glib(value: ffi::GstWebRTCRTPTransceiverDirection) -> Self {
2155        skip_assert_initialized!();
2156
2157        match value {
2158            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE => Self::None,
2159            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE => Self::Inactive,
2160            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY => Self::Sendonly,
2161            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY => Self::Recvonly,
2162            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV => Self::Sendrecv,
2163            value => Self::__Unknown(value),
2164        }
2165    }
2166}
2167
2168impl StaticType for WebRTCRTPTransceiverDirection {
2169    #[inline]
2170    #[doc(alias = "gst_webrtc_rtp_transceiver_direction_get_type")]
2171    fn static_type() -> glib::Type {
2172        unsafe { from_glib(ffi::gst_webrtc_rtp_transceiver_direction_get_type()) }
2173    }
2174}
2175
2176impl glib::HasParamSpec for WebRTCRTPTransceiverDirection {
2177    type ParamSpec = glib::ParamSpecEnum;
2178    type SetValue = Self;
2179    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2180
2181    fn param_spec_builder() -> Self::BuilderFn {
2182        Self::ParamSpec::builder_with_default
2183    }
2184}
2185
2186impl glib::value::ValueType for WebRTCRTPTransceiverDirection {
2187    type Type = Self;
2188}
2189
2190unsafe impl<'a> glib::value::FromValue<'a> for WebRTCRTPTransceiverDirection {
2191    type Checker = glib::value::GenericValueTypeChecker<Self>;
2192
2193    #[inline]
2194    unsafe fn from_value(value: &'a glib::Value) -> Self {
2195        skip_assert_initialized!();
2196        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2197    }
2198}
2199
2200impl ToValue for WebRTCRTPTransceiverDirection {
2201    #[inline]
2202    fn to_value(&self) -> glib::Value {
2203        let mut value = glib::Value::for_value_type::<Self>();
2204        unsafe {
2205            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2206        }
2207        value
2208    }
2209
2210    #[inline]
2211    fn value_type(&self) -> glib::Type {
2212        Self::static_type()
2213    }
2214}
2215
2216impl From<WebRTCRTPTransceiverDirection> for glib::Value {
2217    #[inline]
2218    fn from(v: WebRTCRTPTransceiverDirection) -> Self {
2219        skip_assert_initialized!();
2220        ToValue::to_value(&v)
2221    }
2222}
2223
2224#[cfg(feature = "v1_16")]
2225#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2226#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2227#[non_exhaustive]
2228#[doc(alias = "GstWebRTCSCTPTransportState")]
2229pub enum WebRTCSCTPTransportState {
2230    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW")]
2231    New,
2232    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING")]
2233    Connecting,
2234    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED")]
2235    Connected,
2236    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED")]
2237    Closed,
2238    #[doc(hidden)]
2239    __Unknown(i32),
2240}
2241
2242#[cfg(feature = "v1_16")]
2243#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2244#[doc(hidden)]
2245impl IntoGlib for WebRTCSCTPTransportState {
2246    type GlibType = ffi::GstWebRTCSCTPTransportState;
2247
2248    #[inline]
2249    fn into_glib(self) -> ffi::GstWebRTCSCTPTransportState {
2250        match self {
2251            Self::New => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW,
2252            Self::Connecting => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING,
2253            Self::Connected => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED,
2254            Self::Closed => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED,
2255            Self::__Unknown(value) => value,
2256        }
2257    }
2258}
2259
2260#[cfg(feature = "v1_16")]
2261#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2262#[doc(hidden)]
2263impl FromGlib<ffi::GstWebRTCSCTPTransportState> for WebRTCSCTPTransportState {
2264    #[inline]
2265    unsafe fn from_glib(value: ffi::GstWebRTCSCTPTransportState) -> Self {
2266        skip_assert_initialized!();
2267
2268        match value {
2269            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW => Self::New,
2270            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING => Self::Connecting,
2271            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED => Self::Connected,
2272            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED => Self::Closed,
2273            value => Self::__Unknown(value),
2274        }
2275    }
2276}
2277
2278#[cfg(feature = "v1_16")]
2279#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2280impl StaticType for WebRTCSCTPTransportState {
2281    #[inline]
2282    #[doc(alias = "gst_webrtc_sctp_transport_state_get_type")]
2283    fn static_type() -> glib::Type {
2284        unsafe { from_glib(ffi::gst_webrtc_sctp_transport_state_get_type()) }
2285    }
2286}
2287
2288#[cfg(feature = "v1_16")]
2289#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2290impl glib::HasParamSpec for WebRTCSCTPTransportState {
2291    type ParamSpec = glib::ParamSpecEnum;
2292    type SetValue = Self;
2293    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2294
2295    fn param_spec_builder() -> Self::BuilderFn {
2296        Self::ParamSpec::builder_with_default
2297    }
2298}
2299
2300#[cfg(feature = "v1_16")]
2301#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2302impl glib::value::ValueType for WebRTCSCTPTransportState {
2303    type Type = Self;
2304}
2305
2306#[cfg(feature = "v1_16")]
2307#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2308unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSCTPTransportState {
2309    type Checker = glib::value::GenericValueTypeChecker<Self>;
2310
2311    #[inline]
2312    unsafe fn from_value(value: &'a glib::Value) -> Self {
2313        skip_assert_initialized!();
2314        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2315    }
2316}
2317
2318#[cfg(feature = "v1_16")]
2319#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2320impl ToValue for WebRTCSCTPTransportState {
2321    #[inline]
2322    fn to_value(&self) -> glib::Value {
2323        let mut value = glib::Value::for_value_type::<Self>();
2324        unsafe {
2325            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2326        }
2327        value
2328    }
2329
2330    #[inline]
2331    fn value_type(&self) -> glib::Type {
2332        Self::static_type()
2333    }
2334}
2335
2336#[cfg(feature = "v1_16")]
2337#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2338impl From<WebRTCSCTPTransportState> for glib::Value {
2339    #[inline]
2340    fn from(v: WebRTCSCTPTransportState) -> Self {
2341        skip_assert_initialized!();
2342        ToValue::to_value(&v)
2343    }
2344}
2345
2346#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2347#[non_exhaustive]
2348#[doc(alias = "GstWebRTCSDPType")]
2349pub enum WebRTCSDPType {
2350    #[doc(alias = "GST_WEBRTC_SDP_TYPE_OFFER")]
2351    Offer,
2352    #[doc(alias = "GST_WEBRTC_SDP_TYPE_PRANSWER")]
2353    Pranswer,
2354    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ANSWER")]
2355    Answer,
2356    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ROLLBACK")]
2357    Rollback,
2358    #[doc(hidden)]
2359    __Unknown(i32),
2360}
2361
2362impl WebRTCSDPType {
2363    pub fn to_str<'a>(self) -> &'a GStr {
2364        unsafe {
2365            GStr::from_ptr(
2366                ffi::gst_webrtc_sdp_type_to_string(self.into_glib())
2367                    .as_ref()
2368                    .expect("gst_webrtc_sdp_type_to_string returned NULL"),
2369            )
2370        }
2371    }
2372}
2373
2374impl std::fmt::Display for WebRTCSDPType {
2375    #[inline]
2376    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2377        f.write_str(&self.to_str())
2378    }
2379}
2380
2381#[doc(hidden)]
2382impl IntoGlib for WebRTCSDPType {
2383    type GlibType = ffi::GstWebRTCSDPType;
2384
2385    #[inline]
2386    fn into_glib(self) -> ffi::GstWebRTCSDPType {
2387        match self {
2388            Self::Offer => ffi::GST_WEBRTC_SDP_TYPE_OFFER,
2389            Self::Pranswer => ffi::GST_WEBRTC_SDP_TYPE_PRANSWER,
2390            Self::Answer => ffi::GST_WEBRTC_SDP_TYPE_ANSWER,
2391            Self::Rollback => ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK,
2392            Self::__Unknown(value) => value,
2393        }
2394    }
2395}
2396
2397#[doc(hidden)]
2398impl FromGlib<ffi::GstWebRTCSDPType> for WebRTCSDPType {
2399    #[inline]
2400    unsafe fn from_glib(value: ffi::GstWebRTCSDPType) -> Self {
2401        skip_assert_initialized!();
2402
2403        match value {
2404            ffi::GST_WEBRTC_SDP_TYPE_OFFER => Self::Offer,
2405            ffi::GST_WEBRTC_SDP_TYPE_PRANSWER => Self::Pranswer,
2406            ffi::GST_WEBRTC_SDP_TYPE_ANSWER => Self::Answer,
2407            ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK => Self::Rollback,
2408            value => Self::__Unknown(value),
2409        }
2410    }
2411}
2412
2413impl StaticType for WebRTCSDPType {
2414    #[inline]
2415    #[doc(alias = "gst_webrtc_sdp_type_get_type")]
2416    fn static_type() -> glib::Type {
2417        unsafe { from_glib(ffi::gst_webrtc_sdp_type_get_type()) }
2418    }
2419}
2420
2421impl glib::HasParamSpec for WebRTCSDPType {
2422    type ParamSpec = glib::ParamSpecEnum;
2423    type SetValue = Self;
2424    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2425
2426    fn param_spec_builder() -> Self::BuilderFn {
2427        Self::ParamSpec::builder_with_default
2428    }
2429}
2430
2431impl glib::value::ValueType for WebRTCSDPType {
2432    type Type = Self;
2433}
2434
2435unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSDPType {
2436    type Checker = glib::value::GenericValueTypeChecker<Self>;
2437
2438    #[inline]
2439    unsafe fn from_value(value: &'a glib::Value) -> Self {
2440        skip_assert_initialized!();
2441        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2442    }
2443}
2444
2445impl ToValue for WebRTCSDPType {
2446    #[inline]
2447    fn to_value(&self) -> glib::Value {
2448        let mut value = glib::Value::for_value_type::<Self>();
2449        unsafe {
2450            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2451        }
2452        value
2453    }
2454
2455    #[inline]
2456    fn value_type(&self) -> glib::Type {
2457        Self::static_type()
2458    }
2459}
2460
2461impl From<WebRTCSDPType> for glib::Value {
2462    #[inline]
2463    fn from(v: WebRTCSDPType) -> Self {
2464        skip_assert_initialized!();
2465        ToValue::to_value(&v)
2466    }
2467}
2468
2469#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2470#[non_exhaustive]
2471#[doc(alias = "GstWebRTCSignalingState")]
2472pub enum WebRTCSignalingState {
2473    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_STABLE")]
2474    Stable,
2475    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_CLOSED")]
2476    Closed,
2477    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER")]
2478    HaveLocalOffer,
2479    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER")]
2480    HaveRemoteOffer,
2481    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER")]
2482    HaveLocalPranswer,
2483    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER")]
2484    HaveRemotePranswer,
2485    #[doc(hidden)]
2486    __Unknown(i32),
2487}
2488
2489#[doc(hidden)]
2490impl IntoGlib for WebRTCSignalingState {
2491    type GlibType = ffi::GstWebRTCSignalingState;
2492
2493    #[inline]
2494    fn into_glib(self) -> ffi::GstWebRTCSignalingState {
2495        match self {
2496            Self::Stable => ffi::GST_WEBRTC_SIGNALING_STATE_STABLE,
2497            Self::Closed => ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED,
2498            Self::HaveLocalOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER,
2499            Self::HaveRemoteOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER,
2500            Self::HaveLocalPranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER,
2501            Self::HaveRemotePranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER,
2502            Self::__Unknown(value) => value,
2503        }
2504    }
2505}
2506
2507#[doc(hidden)]
2508impl FromGlib<ffi::GstWebRTCSignalingState> for WebRTCSignalingState {
2509    #[inline]
2510    unsafe fn from_glib(value: ffi::GstWebRTCSignalingState) -> Self {
2511        skip_assert_initialized!();
2512
2513        match value {
2514            ffi::GST_WEBRTC_SIGNALING_STATE_STABLE => Self::Stable,
2515            ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED => Self::Closed,
2516            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER => Self::HaveLocalOffer,
2517            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER => Self::HaveRemoteOffer,
2518            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER => Self::HaveLocalPranswer,
2519            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER => Self::HaveRemotePranswer,
2520            value => Self::__Unknown(value),
2521        }
2522    }
2523}
2524
2525impl StaticType for WebRTCSignalingState {
2526    #[inline]
2527    #[doc(alias = "gst_webrtc_signaling_state_get_type")]
2528    fn static_type() -> glib::Type {
2529        unsafe { from_glib(ffi::gst_webrtc_signaling_state_get_type()) }
2530    }
2531}
2532
2533impl glib::HasParamSpec for WebRTCSignalingState {
2534    type ParamSpec = glib::ParamSpecEnum;
2535    type SetValue = Self;
2536    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2537
2538    fn param_spec_builder() -> Self::BuilderFn {
2539        Self::ParamSpec::builder_with_default
2540    }
2541}
2542
2543impl glib::value::ValueType for WebRTCSignalingState {
2544    type Type = Self;
2545}
2546
2547unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSignalingState {
2548    type Checker = glib::value::GenericValueTypeChecker<Self>;
2549
2550    #[inline]
2551    unsafe fn from_value(value: &'a glib::Value) -> Self {
2552        skip_assert_initialized!();
2553        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2554    }
2555}
2556
2557impl ToValue for WebRTCSignalingState {
2558    #[inline]
2559    fn to_value(&self) -> glib::Value {
2560        let mut value = glib::Value::for_value_type::<Self>();
2561        unsafe {
2562            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2563        }
2564        value
2565    }
2566
2567    #[inline]
2568    fn value_type(&self) -> glib::Type {
2569        Self::static_type()
2570    }
2571}
2572
2573impl From<WebRTCSignalingState> for glib::Value {
2574    #[inline]
2575    fn from(v: WebRTCSignalingState) -> Self {
2576        skip_assert_initialized!();
2577        ToValue::to_value(&v)
2578    }
2579}
2580
2581#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2582#[non_exhaustive]
2583#[doc(alias = "GstWebRTCStatsType")]
2584pub enum WebRTCStatsType {
2585    #[doc(alias = "GST_WEBRTC_STATS_CODEC")]
2586    Codec,
2587    #[doc(alias = "GST_WEBRTC_STATS_INBOUND_RTP")]
2588    InboundRtp,
2589    #[doc(alias = "GST_WEBRTC_STATS_OUTBOUND_RTP")]
2590    OutboundRtp,
2591    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_INBOUND_RTP")]
2592    RemoteInboundRtp,
2593    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP")]
2594    RemoteOutboundRtp,
2595    #[doc(alias = "GST_WEBRTC_STATS_CSRC")]
2596    Csrc,
2597    #[doc(alias = "GST_WEBRTC_STATS_PEER_CONNECTION")]
2598    PeerConnection,
2599    #[doc(alias = "GST_WEBRTC_STATS_DATA_CHANNEL")]
2600    DataChannel,
2601    #[doc(alias = "GST_WEBRTC_STATS_STREAM")]
2602    Stream,
2603    #[doc(alias = "GST_WEBRTC_STATS_TRANSPORT")]
2604    Transport,
2605    #[doc(alias = "GST_WEBRTC_STATS_CANDIDATE_PAIR")]
2606    CandidatePair,
2607    #[doc(alias = "GST_WEBRTC_STATS_LOCAL_CANDIDATE")]
2608    LocalCandidate,
2609    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_CANDIDATE")]
2610    RemoteCandidate,
2611    #[doc(alias = "GST_WEBRTC_STATS_CERTIFICATE")]
2612    Certificate,
2613    #[doc(hidden)]
2614    __Unknown(i32),
2615}
2616
2617#[doc(hidden)]
2618impl IntoGlib for WebRTCStatsType {
2619    type GlibType = ffi::GstWebRTCStatsType;
2620
2621    fn into_glib(self) -> ffi::GstWebRTCStatsType {
2622        match self {
2623            Self::Codec => ffi::GST_WEBRTC_STATS_CODEC,
2624            Self::InboundRtp => ffi::GST_WEBRTC_STATS_INBOUND_RTP,
2625            Self::OutboundRtp => ffi::GST_WEBRTC_STATS_OUTBOUND_RTP,
2626            Self::RemoteInboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP,
2627            Self::RemoteOutboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP,
2628            Self::Csrc => ffi::GST_WEBRTC_STATS_CSRC,
2629            Self::PeerConnection => ffi::GST_WEBRTC_STATS_PEER_CONNECTION,
2630            Self::DataChannel => ffi::GST_WEBRTC_STATS_DATA_CHANNEL,
2631            Self::Stream => ffi::GST_WEBRTC_STATS_STREAM,
2632            Self::Transport => ffi::GST_WEBRTC_STATS_TRANSPORT,
2633            Self::CandidatePair => ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR,
2634            Self::LocalCandidate => ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE,
2635            Self::RemoteCandidate => ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE,
2636            Self::Certificate => ffi::GST_WEBRTC_STATS_CERTIFICATE,
2637            Self::__Unknown(value) => value,
2638        }
2639    }
2640}
2641
2642#[doc(hidden)]
2643impl FromGlib<ffi::GstWebRTCStatsType> for WebRTCStatsType {
2644    unsafe fn from_glib(value: ffi::GstWebRTCStatsType) -> Self {
2645        skip_assert_initialized!();
2646
2647        match value {
2648            ffi::GST_WEBRTC_STATS_CODEC => Self::Codec,
2649            ffi::GST_WEBRTC_STATS_INBOUND_RTP => Self::InboundRtp,
2650            ffi::GST_WEBRTC_STATS_OUTBOUND_RTP => Self::OutboundRtp,
2651            ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP => Self::RemoteInboundRtp,
2652            ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP => Self::RemoteOutboundRtp,
2653            ffi::GST_WEBRTC_STATS_CSRC => Self::Csrc,
2654            ffi::GST_WEBRTC_STATS_PEER_CONNECTION => Self::PeerConnection,
2655            ffi::GST_WEBRTC_STATS_DATA_CHANNEL => Self::DataChannel,
2656            ffi::GST_WEBRTC_STATS_STREAM => Self::Stream,
2657            ffi::GST_WEBRTC_STATS_TRANSPORT => Self::Transport,
2658            ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR => Self::CandidatePair,
2659            ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE => Self::LocalCandidate,
2660            ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE => Self::RemoteCandidate,
2661            ffi::GST_WEBRTC_STATS_CERTIFICATE => Self::Certificate,
2662            value => Self::__Unknown(value),
2663        }
2664    }
2665}
2666
2667impl StaticType for WebRTCStatsType {
2668    #[inline]
2669    #[doc(alias = "gst_webrtc_stats_type_get_type")]
2670    fn static_type() -> glib::Type {
2671        unsafe { from_glib(ffi::gst_webrtc_stats_type_get_type()) }
2672    }
2673}
2674
2675impl glib::HasParamSpec for WebRTCStatsType {
2676    type ParamSpec = glib::ParamSpecEnum;
2677    type SetValue = Self;
2678    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2679
2680    fn param_spec_builder() -> Self::BuilderFn {
2681        Self::ParamSpec::builder_with_default
2682    }
2683}
2684
2685impl glib::value::ValueType for WebRTCStatsType {
2686    type Type = Self;
2687}
2688
2689unsafe impl<'a> glib::value::FromValue<'a> for WebRTCStatsType {
2690    type Checker = glib::value::GenericValueTypeChecker<Self>;
2691
2692    #[inline]
2693    unsafe fn from_value(value: &'a glib::Value) -> Self {
2694        skip_assert_initialized!();
2695        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2696    }
2697}
2698
2699impl ToValue for WebRTCStatsType {
2700    #[inline]
2701    fn to_value(&self) -> glib::Value {
2702        let mut value = glib::Value::for_value_type::<Self>();
2703        unsafe {
2704            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2705        }
2706        value
2707    }
2708
2709    #[inline]
2710    fn value_type(&self) -> glib::Type {
2711        Self::static_type()
2712    }
2713}
2714
2715impl From<WebRTCStatsType> for glib::Value {
2716    #[inline]
2717    fn from(v: WebRTCStatsType) -> Self {
2718        skip_assert_initialized!();
2719        ToValue::to_value(&v)
2720    }
2721}