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