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::{prelude::*, translate::*, GStr};
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        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        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        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        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        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        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        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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
922#[non_exhaustive]
923#[doc(alias = "GstWebRTCICEComponent")]
924pub enum WebRTCICEComponent {
925    /// RTP component
926    #[doc(alias = "GST_WEBRTC_ICE_COMPONENT_RTP")]
927    Rtp,
928    /// RTCP component
929    #[doc(alias = "GST_WEBRTC_ICE_COMPONENT_RTCP")]
930    Rtcp,
931    #[doc(hidden)]
932    __Unknown(i32),
933}
934
935#[doc(hidden)]
936impl IntoGlib for WebRTCICEComponent {
937    type GlibType = ffi::GstWebRTCICEComponent;
938
939    #[inline]
940    fn into_glib(self) -> ffi::GstWebRTCICEComponent {
941        match self {
942            Self::Rtp => ffi::GST_WEBRTC_ICE_COMPONENT_RTP,
943            Self::Rtcp => ffi::GST_WEBRTC_ICE_COMPONENT_RTCP,
944            Self::__Unknown(value) => value,
945        }
946    }
947}
948
949#[doc(hidden)]
950impl FromGlib<ffi::GstWebRTCICEComponent> for WebRTCICEComponent {
951    #[inline]
952    unsafe fn from_glib(value: ffi::GstWebRTCICEComponent) -> Self {
953        skip_assert_initialized!();
954
955        match value {
956            ffi::GST_WEBRTC_ICE_COMPONENT_RTP => Self::Rtp,
957            ffi::GST_WEBRTC_ICE_COMPONENT_RTCP => Self::Rtcp,
958            value => Self::__Unknown(value),
959        }
960    }
961}
962
963impl StaticType for WebRTCICEComponent {
964    #[inline]
965    #[doc(alias = "gst_webrtc_ice_component_get_type")]
966    fn static_type() -> glib::Type {
967        unsafe { from_glib(ffi::gst_webrtc_ice_component_get_type()) }
968    }
969}
970
971impl glib::HasParamSpec for WebRTCICEComponent {
972    type ParamSpec = glib::ParamSpecEnum;
973    type SetValue = Self;
974    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
975
976    fn param_spec_builder() -> Self::BuilderFn {
977        Self::ParamSpec::builder_with_default
978    }
979}
980
981impl glib::value::ValueType for WebRTCICEComponent {
982    type Type = Self;
983}
984
985unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEComponent {
986    type Checker = glib::value::GenericValueTypeChecker<Self>;
987
988    #[inline]
989    unsafe fn from_value(value: &'a glib::Value) -> Self {
990        skip_assert_initialized!();
991        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
992    }
993}
994
995impl ToValue for WebRTCICEComponent {
996    #[inline]
997    fn to_value(&self) -> glib::Value {
998        let mut value = glib::Value::for_value_type::<Self>();
999        unsafe {
1000            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1001        }
1002        value
1003    }
1004
1005    #[inline]
1006    fn value_type(&self) -> glib::Type {
1007        Self::static_type()
1008    }
1009}
1010
1011impl From<WebRTCICEComponent> for glib::Value {
1012    #[inline]
1013    fn from(v: WebRTCICEComponent) -> Self {
1014        skip_assert_initialized!();
1015        ToValue::to_value(&v)
1016    }
1017}
1018
1019/// See <http://w3c.github.io/webrtc-pc/`dom`-rtciceconnectionstate>
1020#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1021#[non_exhaustive]
1022#[doc(alias = "GstWebRTCICEConnectionState")]
1023pub enum WebRTCICEConnectionState {
1024    /// new
1025    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_NEW")]
1026    New,
1027    /// checking
1028    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING")]
1029    Checking,
1030    /// connected
1031    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED")]
1032    Connected,
1033    /// completed
1034    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED")]
1035    Completed,
1036    /// failed
1037    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_FAILED")]
1038    Failed,
1039    /// disconnected
1040    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED")]
1041    Disconnected,
1042    /// closed
1043    #[doc(alias = "GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED")]
1044    Closed,
1045    #[doc(hidden)]
1046    __Unknown(i32),
1047}
1048
1049#[doc(hidden)]
1050impl IntoGlib for WebRTCICEConnectionState {
1051    type GlibType = ffi::GstWebRTCICEConnectionState;
1052
1053    #[inline]
1054    fn into_glib(self) -> ffi::GstWebRTCICEConnectionState {
1055        match self {
1056            Self::New => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_NEW,
1057            Self::Checking => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING,
1058            Self::Connected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED,
1059            Self::Completed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED,
1060            Self::Failed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_FAILED,
1061            Self::Disconnected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED,
1062            Self::Closed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED,
1063            Self::__Unknown(value) => value,
1064        }
1065    }
1066}
1067
1068#[doc(hidden)]
1069impl FromGlib<ffi::GstWebRTCICEConnectionState> for WebRTCICEConnectionState {
1070    #[inline]
1071    unsafe fn from_glib(value: ffi::GstWebRTCICEConnectionState) -> Self {
1072        skip_assert_initialized!();
1073
1074        match value {
1075            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_NEW => Self::New,
1076            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING => Self::Checking,
1077            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED => Self::Connected,
1078            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED => Self::Completed,
1079            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_FAILED => Self::Failed,
1080            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED => Self::Disconnected,
1081            ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED => Self::Closed,
1082            value => Self::__Unknown(value),
1083        }
1084    }
1085}
1086
1087impl StaticType for WebRTCICEConnectionState {
1088    #[inline]
1089    #[doc(alias = "gst_webrtc_ice_connection_state_get_type")]
1090    fn static_type() -> glib::Type {
1091        unsafe { from_glib(ffi::gst_webrtc_ice_connection_state_get_type()) }
1092    }
1093}
1094
1095impl glib::HasParamSpec for WebRTCICEConnectionState {
1096    type ParamSpec = glib::ParamSpecEnum;
1097    type SetValue = Self;
1098    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1099
1100    fn param_spec_builder() -> Self::BuilderFn {
1101        Self::ParamSpec::builder_with_default
1102    }
1103}
1104
1105impl glib::value::ValueType for WebRTCICEConnectionState {
1106    type Type = Self;
1107}
1108
1109unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEConnectionState {
1110    type Checker = glib::value::GenericValueTypeChecker<Self>;
1111
1112    #[inline]
1113    unsafe fn from_value(value: &'a glib::Value) -> Self {
1114        skip_assert_initialized!();
1115        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1116    }
1117}
1118
1119impl ToValue for WebRTCICEConnectionState {
1120    #[inline]
1121    fn to_value(&self) -> glib::Value {
1122        let mut value = glib::Value::for_value_type::<Self>();
1123        unsafe {
1124            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1125        }
1126        value
1127    }
1128
1129    #[inline]
1130    fn value_type(&self) -> glib::Type {
1131        Self::static_type()
1132    }
1133}
1134
1135impl From<WebRTCICEConnectionState> for glib::Value {
1136    #[inline]
1137    fn from(v: WebRTCICEConnectionState) -> Self {
1138        skip_assert_initialized!();
1139        ToValue::to_value(&v)
1140    }
1141}
1142
1143/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcicegatheringstate>
1144#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1145#[non_exhaustive]
1146#[doc(alias = "GstWebRTCICEGatheringState")]
1147pub enum WebRTCICEGatheringState {
1148    /// new
1149    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_NEW")]
1150    New,
1151    /// gathering
1152    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_GATHERING")]
1153    Gathering,
1154    /// complete
1155    #[doc(alias = "GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE")]
1156    Complete,
1157    #[doc(hidden)]
1158    __Unknown(i32),
1159}
1160
1161#[doc(hidden)]
1162impl IntoGlib for WebRTCICEGatheringState {
1163    type GlibType = ffi::GstWebRTCICEGatheringState;
1164
1165    #[inline]
1166    fn into_glib(self) -> ffi::GstWebRTCICEGatheringState {
1167        match self {
1168            Self::New => ffi::GST_WEBRTC_ICE_GATHERING_STATE_NEW,
1169            Self::Gathering => ffi::GST_WEBRTC_ICE_GATHERING_STATE_GATHERING,
1170            Self::Complete => ffi::GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE,
1171            Self::__Unknown(value) => value,
1172        }
1173    }
1174}
1175
1176#[doc(hidden)]
1177impl FromGlib<ffi::GstWebRTCICEGatheringState> for WebRTCICEGatheringState {
1178    #[inline]
1179    unsafe fn from_glib(value: ffi::GstWebRTCICEGatheringState) -> Self {
1180        skip_assert_initialized!();
1181
1182        match value {
1183            ffi::GST_WEBRTC_ICE_GATHERING_STATE_NEW => Self::New,
1184            ffi::GST_WEBRTC_ICE_GATHERING_STATE_GATHERING => Self::Gathering,
1185            ffi::GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE => Self::Complete,
1186            value => Self::__Unknown(value),
1187        }
1188    }
1189}
1190
1191impl StaticType for WebRTCICEGatheringState {
1192    #[inline]
1193    #[doc(alias = "gst_webrtc_ice_gathering_state_get_type")]
1194    fn static_type() -> glib::Type {
1195        unsafe { from_glib(ffi::gst_webrtc_ice_gathering_state_get_type()) }
1196    }
1197}
1198
1199impl glib::HasParamSpec for WebRTCICEGatheringState {
1200    type ParamSpec = glib::ParamSpecEnum;
1201    type SetValue = Self;
1202    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1203
1204    fn param_spec_builder() -> Self::BuilderFn {
1205        Self::ParamSpec::builder_with_default
1206    }
1207}
1208
1209impl glib::value::ValueType for WebRTCICEGatheringState {
1210    type Type = Self;
1211}
1212
1213unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICEGatheringState {
1214    type Checker = glib::value::GenericValueTypeChecker<Self>;
1215
1216    #[inline]
1217    unsafe fn from_value(value: &'a glib::Value) -> Self {
1218        skip_assert_initialized!();
1219        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1220    }
1221}
1222
1223impl ToValue for WebRTCICEGatheringState {
1224    #[inline]
1225    fn to_value(&self) -> glib::Value {
1226        let mut value = glib::Value::for_value_type::<Self>();
1227        unsafe {
1228            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1229        }
1230        value
1231    }
1232
1233    #[inline]
1234    fn value_type(&self) -> glib::Type {
1235        Self::static_type()
1236    }
1237}
1238
1239impl From<WebRTCICEGatheringState> for glib::Value {
1240    #[inline]
1241    fn from(v: WebRTCICEGatheringState) -> Self {
1242        skip_assert_initialized!();
1243        ToValue::to_value(&v)
1244    }
1245}
1246
1247#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1248#[non_exhaustive]
1249#[doc(alias = "GstWebRTCICERole")]
1250pub enum WebRTCICERole {
1251    /// controlled
1252    #[doc(alias = "GST_WEBRTC_ICE_ROLE_CONTROLLED")]
1253    Controlled,
1254    /// controlling
1255    #[doc(alias = "GST_WEBRTC_ICE_ROLE_CONTROLLING")]
1256    Controlling,
1257    #[doc(hidden)]
1258    __Unknown(i32),
1259}
1260
1261#[doc(hidden)]
1262impl IntoGlib for WebRTCICERole {
1263    type GlibType = ffi::GstWebRTCICERole;
1264
1265    #[inline]
1266    fn into_glib(self) -> ffi::GstWebRTCICERole {
1267        match self {
1268            Self::Controlled => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLED,
1269            Self::Controlling => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLING,
1270            Self::__Unknown(value) => value,
1271        }
1272    }
1273}
1274
1275#[doc(hidden)]
1276impl FromGlib<ffi::GstWebRTCICERole> for WebRTCICERole {
1277    #[inline]
1278    unsafe fn from_glib(value: ffi::GstWebRTCICERole) -> Self {
1279        skip_assert_initialized!();
1280
1281        match value {
1282            ffi::GST_WEBRTC_ICE_ROLE_CONTROLLED => Self::Controlled,
1283            ffi::GST_WEBRTC_ICE_ROLE_CONTROLLING => Self::Controlling,
1284            value => Self::__Unknown(value),
1285        }
1286    }
1287}
1288
1289impl StaticType for WebRTCICERole {
1290    #[inline]
1291    #[doc(alias = "gst_webrtc_ice_role_get_type")]
1292    fn static_type() -> glib::Type {
1293        unsafe { from_glib(ffi::gst_webrtc_ice_role_get_type()) }
1294    }
1295}
1296
1297impl glib::HasParamSpec for WebRTCICERole {
1298    type ParamSpec = glib::ParamSpecEnum;
1299    type SetValue = Self;
1300    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1301
1302    fn param_spec_builder() -> Self::BuilderFn {
1303        Self::ParamSpec::builder_with_default
1304    }
1305}
1306
1307impl glib::value::ValueType for WebRTCICERole {
1308    type Type = Self;
1309}
1310
1311unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICERole {
1312    type Checker = glib::value::GenericValueTypeChecker<Self>;
1313
1314    #[inline]
1315    unsafe fn from_value(value: &'a glib::Value) -> Self {
1316        skip_assert_initialized!();
1317        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1318    }
1319}
1320
1321impl ToValue for WebRTCICERole {
1322    #[inline]
1323    fn to_value(&self) -> glib::Value {
1324        let mut value = glib::Value::for_value_type::<Self>();
1325        unsafe {
1326            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1327        }
1328        value
1329    }
1330
1331    #[inline]
1332    fn value_type(&self) -> glib::Type {
1333        Self::static_type()
1334    }
1335}
1336
1337impl From<WebRTCICERole> for glib::Value {
1338    #[inline]
1339    fn from(v: WebRTCICERole) -> Self {
1340        skip_assert_initialized!();
1341        ToValue::to_value(&v)
1342    }
1343}
1344
1345#[cfg(feature = "v1_28")]
1346#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1347#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1348#[non_exhaustive]
1349#[doc(alias = "GstWebRTCICETcpCandidateType")]
1350pub enum WebRTCICETcpCandidateType {
1351    /// An "active" TCP candidate is one for which the transport
1352    ///  will attempt to open an outbound connection but will not
1353    ///  receive incoming connection requests.
1354    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE")]
1355    Active,
1356    /// A "passive" TCP candidate is one for which the transport
1357    ///  will receive incoming connection attempts but not attempt
1358    ///  a connection.
1359    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE")]
1360    Passive,
1361    /// An "so" candidate is one for which the transport will attempt
1362    ///  to open a connection simultaneously with its peer.
1363    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO")]
1364    So,
1365    /// Value used for non-TCP candidate type.
1366    #[doc(alias = "GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE")]
1367    None,
1368    #[doc(hidden)]
1369    __Unknown(i32),
1370}
1371
1372#[cfg(feature = "v1_28")]
1373#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1374#[doc(hidden)]
1375impl IntoGlib for WebRTCICETcpCandidateType {
1376    type GlibType = ffi::GstWebRTCICETcpCandidateType;
1377
1378    #[inline]
1379    fn into_glib(self) -> ffi::GstWebRTCICETcpCandidateType {
1380        match self {
1381            Self::Active => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE,
1382            Self::Passive => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE,
1383            Self::So => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO,
1384            Self::None => ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE,
1385            Self::__Unknown(value) => value,
1386        }
1387    }
1388}
1389
1390#[cfg(feature = "v1_28")]
1391#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1392#[doc(hidden)]
1393impl FromGlib<ffi::GstWebRTCICETcpCandidateType> for WebRTCICETcpCandidateType {
1394    #[inline]
1395    unsafe fn from_glib(value: ffi::GstWebRTCICETcpCandidateType) -> Self {
1396        skip_assert_initialized!();
1397
1398        match value {
1399            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_ACTIVE => Self::Active,
1400            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_PASSIVE => Self::Passive,
1401            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_SO => Self::So,
1402            ffi::GST_WEBRTC_ICE_TCP_CANDIDATE_TYPE_NONE => Self::None,
1403            value => Self::__Unknown(value),
1404        }
1405    }
1406}
1407
1408#[cfg(feature = "v1_28")]
1409#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1410impl StaticType for WebRTCICETcpCandidateType {
1411    #[inline]
1412    #[doc(alias = "gst_webrtc_ice_tcp_candidate_type_get_type")]
1413    fn static_type() -> glib::Type {
1414        unsafe { from_glib(ffi::gst_webrtc_ice_tcp_candidate_type_get_type()) }
1415    }
1416}
1417
1418#[cfg(feature = "v1_28")]
1419#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1420impl glib::HasParamSpec for WebRTCICETcpCandidateType {
1421    type ParamSpec = glib::ParamSpecEnum;
1422    type SetValue = Self;
1423    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1424
1425    fn param_spec_builder() -> Self::BuilderFn {
1426        Self::ParamSpec::builder_with_default
1427    }
1428}
1429
1430#[cfg(feature = "v1_28")]
1431#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1432impl glib::value::ValueType for WebRTCICETcpCandidateType {
1433    type Type = Self;
1434}
1435
1436#[cfg(feature = "v1_28")]
1437#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1438unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICETcpCandidateType {
1439    type Checker = glib::value::GenericValueTypeChecker<Self>;
1440
1441    #[inline]
1442    unsafe fn from_value(value: &'a glib::Value) -> Self {
1443        skip_assert_initialized!();
1444        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1445    }
1446}
1447
1448#[cfg(feature = "v1_28")]
1449#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1450impl ToValue for WebRTCICETcpCandidateType {
1451    #[inline]
1452    fn to_value(&self) -> glib::Value {
1453        let mut value = glib::Value::for_value_type::<Self>();
1454        unsafe {
1455            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1456        }
1457        value
1458    }
1459
1460    #[inline]
1461    fn value_type(&self) -> glib::Type {
1462        Self::static_type()
1463    }
1464}
1465
1466#[cfg(feature = "v1_28")]
1467#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1468impl From<WebRTCICETcpCandidateType> for glib::Value {
1469    #[inline]
1470    fn from(v: WebRTCICETcpCandidateType) -> Self {
1471        skip_assert_initialized!();
1472        ToValue::to_value(&v)
1473    }
1474}
1475
1476/// See https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-24`section`-4.1.1
1477/// for more information.
1478#[cfg(feature = "v1_16")]
1479#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1480#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1481#[non_exhaustive]
1482#[doc(alias = "GstWebRTCICETransportPolicy")]
1483pub enum WebRTCICETransportPolicy {
1484    /// all
1485    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL")]
1486    All,
1487    /// relay
1488    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY")]
1489    Relay,
1490    #[doc(hidden)]
1491    __Unknown(i32),
1492}
1493
1494#[cfg(feature = "v1_16")]
1495#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1496#[doc(hidden)]
1497impl IntoGlib for WebRTCICETransportPolicy {
1498    type GlibType = ffi::GstWebRTCICETransportPolicy;
1499
1500    #[inline]
1501    fn into_glib(self) -> ffi::GstWebRTCICETransportPolicy {
1502        match self {
1503            Self::All => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL,
1504            Self::Relay => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY,
1505            Self::__Unknown(value) => value,
1506        }
1507    }
1508}
1509
1510#[cfg(feature = "v1_16")]
1511#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1512#[doc(hidden)]
1513impl FromGlib<ffi::GstWebRTCICETransportPolicy> for WebRTCICETransportPolicy {
1514    #[inline]
1515    unsafe fn from_glib(value: ffi::GstWebRTCICETransportPolicy) -> Self {
1516        skip_assert_initialized!();
1517
1518        match value {
1519            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL => Self::All,
1520            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY => Self::Relay,
1521            value => Self::__Unknown(value),
1522        }
1523    }
1524}
1525
1526#[cfg(feature = "v1_16")]
1527#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1528impl StaticType for WebRTCICETransportPolicy {
1529    #[inline]
1530    #[doc(alias = "gst_webrtc_ice_transport_policy_get_type")]
1531    fn static_type() -> glib::Type {
1532        unsafe { from_glib(ffi::gst_webrtc_ice_transport_policy_get_type()) }
1533    }
1534}
1535
1536#[cfg(feature = "v1_16")]
1537#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1538impl glib::HasParamSpec for WebRTCICETransportPolicy {
1539    type ParamSpec = glib::ParamSpecEnum;
1540    type SetValue = Self;
1541    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1542
1543    fn param_spec_builder() -> Self::BuilderFn {
1544        Self::ParamSpec::builder_with_default
1545    }
1546}
1547
1548#[cfg(feature = "v1_16")]
1549#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1550impl glib::value::ValueType for WebRTCICETransportPolicy {
1551    type Type = Self;
1552}
1553
1554#[cfg(feature = "v1_16")]
1555#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1556unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICETransportPolicy {
1557    type Checker = glib::value::GenericValueTypeChecker<Self>;
1558
1559    #[inline]
1560    unsafe fn from_value(value: &'a glib::Value) -> Self {
1561        skip_assert_initialized!();
1562        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1563    }
1564}
1565
1566#[cfg(feature = "v1_16")]
1567#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1568impl ToValue for WebRTCICETransportPolicy {
1569    #[inline]
1570    fn to_value(&self) -> glib::Value {
1571        let mut value = glib::Value::for_value_type::<Self>();
1572        unsafe {
1573            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1574        }
1575        value
1576    }
1577
1578    #[inline]
1579    fn value_type(&self) -> glib::Type {
1580        Self::static_type()
1581    }
1582}
1583
1584#[cfg(feature = "v1_16")]
1585#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1586impl From<WebRTCICETransportPolicy> for glib::Value {
1587    #[inline]
1588    fn from(v: WebRTCICETransportPolicy) -> Self {
1589        skip_assert_initialized!();
1590        ToValue::to_value(&v)
1591    }
1592}
1593
1594/// https://w3c.github.io/mediacapture-main/`dom`-mediastreamtrack-kind
1595#[cfg(feature = "v1_20")]
1596#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1597#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1598#[non_exhaustive]
1599#[doc(alias = "GstWebRTCKind")]
1600pub enum WebRTCKind {
1601    /// Kind has not yet been set
1602    #[doc(alias = "GST_WEBRTC_KIND_UNKNOWN")]
1603    Unknown,
1604    /// Kind is audio
1605    #[doc(alias = "GST_WEBRTC_KIND_AUDIO")]
1606    Audio,
1607    /// Kind is video
1608    #[doc(alias = "GST_WEBRTC_KIND_VIDEO")]
1609    Video,
1610    #[doc(hidden)]
1611    __Unknown(i32),
1612}
1613
1614#[cfg(feature = "v1_20")]
1615#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1616#[doc(hidden)]
1617impl IntoGlib for WebRTCKind {
1618    type GlibType = ffi::GstWebRTCKind;
1619
1620    #[inline]
1621    fn into_glib(self) -> ffi::GstWebRTCKind {
1622        match self {
1623            Self::Unknown => ffi::GST_WEBRTC_KIND_UNKNOWN,
1624            Self::Audio => ffi::GST_WEBRTC_KIND_AUDIO,
1625            Self::Video => ffi::GST_WEBRTC_KIND_VIDEO,
1626            Self::__Unknown(value) => value,
1627        }
1628    }
1629}
1630
1631#[cfg(feature = "v1_20")]
1632#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1633#[doc(hidden)]
1634impl FromGlib<ffi::GstWebRTCKind> for WebRTCKind {
1635    #[inline]
1636    unsafe fn from_glib(value: ffi::GstWebRTCKind) -> Self {
1637        skip_assert_initialized!();
1638
1639        match value {
1640            ffi::GST_WEBRTC_KIND_UNKNOWN => Self::Unknown,
1641            ffi::GST_WEBRTC_KIND_AUDIO => Self::Audio,
1642            ffi::GST_WEBRTC_KIND_VIDEO => Self::Video,
1643            value => Self::__Unknown(value),
1644        }
1645    }
1646}
1647
1648#[cfg(feature = "v1_20")]
1649#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1650impl StaticType for WebRTCKind {
1651    #[inline]
1652    #[doc(alias = "gst_webrtc_kind_get_type")]
1653    fn static_type() -> glib::Type {
1654        unsafe { from_glib(ffi::gst_webrtc_kind_get_type()) }
1655    }
1656}
1657
1658#[cfg(feature = "v1_20")]
1659#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1660impl glib::HasParamSpec for WebRTCKind {
1661    type ParamSpec = glib::ParamSpecEnum;
1662    type SetValue = Self;
1663    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1664
1665    fn param_spec_builder() -> Self::BuilderFn {
1666        Self::ParamSpec::builder_with_default
1667    }
1668}
1669
1670#[cfg(feature = "v1_20")]
1671#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1672impl glib::value::ValueType for WebRTCKind {
1673    type Type = Self;
1674}
1675
1676#[cfg(feature = "v1_20")]
1677#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1678unsafe impl<'a> glib::value::FromValue<'a> for WebRTCKind {
1679    type Checker = glib::value::GenericValueTypeChecker<Self>;
1680
1681    #[inline]
1682    unsafe fn from_value(value: &'a glib::Value) -> Self {
1683        skip_assert_initialized!();
1684        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1685    }
1686}
1687
1688#[cfg(feature = "v1_20")]
1689#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1690impl ToValue for WebRTCKind {
1691    #[inline]
1692    fn to_value(&self) -> glib::Value {
1693        let mut value = glib::Value::for_value_type::<Self>();
1694        unsafe {
1695            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1696        }
1697        value
1698    }
1699
1700    #[inline]
1701    fn value_type(&self) -> glib::Type {
1702        Self::static_type()
1703    }
1704}
1705
1706#[cfg(feature = "v1_20")]
1707#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1708impl From<WebRTCKind> for glib::Value {
1709    #[inline]
1710    fn from(v: WebRTCKind) -> Self {
1711        skip_assert_initialized!();
1712        ToValue::to_value(&v)
1713    }
1714}
1715
1716/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcpeerconnectionstate>
1717#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1718#[non_exhaustive]
1719#[doc(alias = "GstWebRTCPeerConnectionState")]
1720pub enum WebRTCPeerConnectionState {
1721    /// new
1722    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_NEW")]
1723    New,
1724    /// connecting
1725    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING")]
1726    Connecting,
1727    /// connected
1728    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED")]
1729    Connected,
1730    /// disconnected
1731    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED")]
1732    Disconnected,
1733    /// failed
1734    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_FAILED")]
1735    Failed,
1736    /// closed
1737    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED")]
1738    Closed,
1739    #[doc(hidden)]
1740    __Unknown(i32),
1741}
1742
1743#[doc(hidden)]
1744impl IntoGlib for WebRTCPeerConnectionState {
1745    type GlibType = ffi::GstWebRTCPeerConnectionState;
1746
1747    #[inline]
1748    fn into_glib(self) -> ffi::GstWebRTCPeerConnectionState {
1749        match self {
1750            Self::New => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW,
1751            Self::Connecting => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING,
1752            Self::Connected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED,
1753            Self::Disconnected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED,
1754            Self::Failed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED,
1755            Self::Closed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED,
1756            Self::__Unknown(value) => value,
1757        }
1758    }
1759}
1760
1761#[doc(hidden)]
1762impl FromGlib<ffi::GstWebRTCPeerConnectionState> for WebRTCPeerConnectionState {
1763    #[inline]
1764    unsafe fn from_glib(value: ffi::GstWebRTCPeerConnectionState) -> Self {
1765        skip_assert_initialized!();
1766
1767        match value {
1768            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW => Self::New,
1769            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING => Self::Connecting,
1770            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED => Self::Connected,
1771            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED => Self::Disconnected,
1772            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED => Self::Failed,
1773            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED => Self::Closed,
1774            value => Self::__Unknown(value),
1775        }
1776    }
1777}
1778
1779impl StaticType for WebRTCPeerConnectionState {
1780    #[inline]
1781    #[doc(alias = "gst_webrtc_peer_connection_state_get_type")]
1782    fn static_type() -> glib::Type {
1783        unsafe { from_glib(ffi::gst_webrtc_peer_connection_state_get_type()) }
1784    }
1785}
1786
1787impl glib::HasParamSpec for WebRTCPeerConnectionState {
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
1797impl glib::value::ValueType for WebRTCPeerConnectionState {
1798    type Type = Self;
1799}
1800
1801unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPeerConnectionState {
1802    type Checker = glib::value::GenericValueTypeChecker<Self>;
1803
1804    #[inline]
1805    unsafe fn from_value(value: &'a glib::Value) -> Self {
1806        skip_assert_initialized!();
1807        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1808    }
1809}
1810
1811impl ToValue for WebRTCPeerConnectionState {
1812    #[inline]
1813    fn to_value(&self) -> glib::Value {
1814        let mut value = glib::Value::for_value_type::<Self>();
1815        unsafe {
1816            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1817        }
1818        value
1819    }
1820
1821    #[inline]
1822    fn value_type(&self) -> glib::Type {
1823        Self::static_type()
1824    }
1825}
1826
1827impl From<WebRTCPeerConnectionState> for glib::Value {
1828    #[inline]
1829    fn from(v: WebRTCPeerConnectionState) -> Self {
1830        skip_assert_initialized!();
1831        ToValue::to_value(&v)
1832    }
1833}
1834
1835/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcprioritytype>
1836#[cfg(feature = "v1_16")]
1837#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1838#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1839#[non_exhaustive]
1840#[doc(alias = "GstWebRTCPriorityType")]
1841pub enum WebRTCPriorityType {
1842    /// very-low
1843    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_VERY_LOW")]
1844    VeryLow,
1845    /// low
1846    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_LOW")]
1847    Low,
1848    /// medium
1849    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_MEDIUM")]
1850    Medium,
1851    /// high
1852    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_HIGH")]
1853    High,
1854    #[doc(hidden)]
1855    __Unknown(i32),
1856}
1857
1858#[cfg(feature = "v1_16")]
1859#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1860#[doc(hidden)]
1861impl IntoGlib for WebRTCPriorityType {
1862    type GlibType = ffi::GstWebRTCPriorityType;
1863
1864    #[inline]
1865    fn into_glib(self) -> ffi::GstWebRTCPriorityType {
1866        match self {
1867            Self::VeryLow => ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW,
1868            Self::Low => ffi::GST_WEBRTC_PRIORITY_TYPE_LOW,
1869            Self::Medium => ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM,
1870            Self::High => ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH,
1871            Self::__Unknown(value) => value,
1872        }
1873    }
1874}
1875
1876#[cfg(feature = "v1_16")]
1877#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1878#[doc(hidden)]
1879impl FromGlib<ffi::GstWebRTCPriorityType> for WebRTCPriorityType {
1880    #[inline]
1881    unsafe fn from_glib(value: ffi::GstWebRTCPriorityType) -> Self {
1882        skip_assert_initialized!();
1883
1884        match value {
1885            ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW => Self::VeryLow,
1886            ffi::GST_WEBRTC_PRIORITY_TYPE_LOW => Self::Low,
1887            ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM => Self::Medium,
1888            ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH => Self::High,
1889            value => Self::__Unknown(value),
1890        }
1891    }
1892}
1893
1894#[cfg(feature = "v1_16")]
1895#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1896impl StaticType for WebRTCPriorityType {
1897    #[inline]
1898    #[doc(alias = "gst_webrtc_priority_type_get_type")]
1899    fn static_type() -> glib::Type {
1900        unsafe { from_glib(ffi::gst_webrtc_priority_type_get_type()) }
1901    }
1902}
1903
1904#[cfg(feature = "v1_16")]
1905#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1906impl glib::HasParamSpec for WebRTCPriorityType {
1907    type ParamSpec = glib::ParamSpecEnum;
1908    type SetValue = Self;
1909    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1910
1911    fn param_spec_builder() -> Self::BuilderFn {
1912        Self::ParamSpec::builder_with_default
1913    }
1914}
1915
1916#[cfg(feature = "v1_16")]
1917#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1918impl glib::value::ValueType for WebRTCPriorityType {
1919    type Type = Self;
1920}
1921
1922#[cfg(feature = "v1_16")]
1923#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1924unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPriorityType {
1925    type Checker = glib::value::GenericValueTypeChecker<Self>;
1926
1927    #[inline]
1928    unsafe fn from_value(value: &'a glib::Value) -> Self {
1929        skip_assert_initialized!();
1930        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1931    }
1932}
1933
1934#[cfg(feature = "v1_16")]
1935#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1936impl ToValue for WebRTCPriorityType {
1937    #[inline]
1938    fn to_value(&self) -> glib::Value {
1939        let mut value = glib::Value::for_value_type::<Self>();
1940        unsafe {
1941            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1942        }
1943        value
1944    }
1945
1946    #[inline]
1947    fn value_type(&self) -> glib::Type {
1948        Self::static_type()
1949    }
1950}
1951
1952#[cfg(feature = "v1_16")]
1953#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1954impl From<WebRTCPriorityType> for glib::Value {
1955    #[inline]
1956    fn from(v: WebRTCPriorityType) -> Self {
1957        skip_assert_initialized!();
1958        ToValue::to_value(&v)
1959    }
1960}
1961
1962#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1963#[non_exhaustive]
1964#[doc(alias = "GstWebRTCRTPTransceiverDirection")]
1965pub enum WebRTCRTPTransceiverDirection {
1966    /// none
1967    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE")]
1968    None,
1969    /// inactive
1970    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE")]
1971    Inactive,
1972    /// sendonly
1973    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY")]
1974    Sendonly,
1975    /// recvonly
1976    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY")]
1977    Recvonly,
1978    /// sendrecv
1979    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV")]
1980    Sendrecv,
1981    #[doc(hidden)]
1982    __Unknown(i32),
1983}
1984
1985#[doc(hidden)]
1986impl IntoGlib for WebRTCRTPTransceiverDirection {
1987    type GlibType = ffi::GstWebRTCRTPTransceiverDirection;
1988
1989    #[inline]
1990    fn into_glib(self) -> ffi::GstWebRTCRTPTransceiverDirection {
1991        match self {
1992            Self::None => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE,
1993            Self::Inactive => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE,
1994            Self::Sendonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY,
1995            Self::Recvonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY,
1996            Self::Sendrecv => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV,
1997            Self::__Unknown(value) => value,
1998        }
1999    }
2000}
2001
2002#[doc(hidden)]
2003impl FromGlib<ffi::GstWebRTCRTPTransceiverDirection> for WebRTCRTPTransceiverDirection {
2004    #[inline]
2005    unsafe fn from_glib(value: ffi::GstWebRTCRTPTransceiverDirection) -> Self {
2006        skip_assert_initialized!();
2007
2008        match value {
2009            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE => Self::None,
2010            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE => Self::Inactive,
2011            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY => Self::Sendonly,
2012            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY => Self::Recvonly,
2013            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV => Self::Sendrecv,
2014            value => Self::__Unknown(value),
2015        }
2016    }
2017}
2018
2019impl StaticType for WebRTCRTPTransceiverDirection {
2020    #[inline]
2021    #[doc(alias = "gst_webrtc_rtp_transceiver_direction_get_type")]
2022    fn static_type() -> glib::Type {
2023        unsafe { from_glib(ffi::gst_webrtc_rtp_transceiver_direction_get_type()) }
2024    }
2025}
2026
2027impl glib::HasParamSpec for WebRTCRTPTransceiverDirection {
2028    type ParamSpec = glib::ParamSpecEnum;
2029    type SetValue = Self;
2030    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2031
2032    fn param_spec_builder() -> Self::BuilderFn {
2033        Self::ParamSpec::builder_with_default
2034    }
2035}
2036
2037impl glib::value::ValueType for WebRTCRTPTransceiverDirection {
2038    type Type = Self;
2039}
2040
2041unsafe impl<'a> glib::value::FromValue<'a> for WebRTCRTPTransceiverDirection {
2042    type Checker = glib::value::GenericValueTypeChecker<Self>;
2043
2044    #[inline]
2045    unsafe fn from_value(value: &'a glib::Value) -> Self {
2046        skip_assert_initialized!();
2047        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2048    }
2049}
2050
2051impl ToValue for WebRTCRTPTransceiverDirection {
2052    #[inline]
2053    fn to_value(&self) -> glib::Value {
2054        let mut value = glib::Value::for_value_type::<Self>();
2055        unsafe {
2056            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2057        }
2058        value
2059    }
2060
2061    #[inline]
2062    fn value_type(&self) -> glib::Type {
2063        Self::static_type()
2064    }
2065}
2066
2067impl From<WebRTCRTPTransceiverDirection> for glib::Value {
2068    #[inline]
2069    fn from(v: WebRTCRTPTransceiverDirection) -> Self {
2070        skip_assert_initialized!();
2071        ToValue::to_value(&v)
2072    }
2073}
2074
2075/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcsctptransportstate>
2076#[cfg(feature = "v1_16")]
2077#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2078#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2079#[non_exhaustive]
2080#[doc(alias = "GstWebRTCSCTPTransportState")]
2081pub enum WebRTCSCTPTransportState {
2082    /// new
2083    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW")]
2084    New,
2085    /// connecting
2086    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING")]
2087    Connecting,
2088    /// connected
2089    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED")]
2090    Connected,
2091    /// closed
2092    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED")]
2093    Closed,
2094    #[doc(hidden)]
2095    __Unknown(i32),
2096}
2097
2098#[cfg(feature = "v1_16")]
2099#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2100#[doc(hidden)]
2101impl IntoGlib for WebRTCSCTPTransportState {
2102    type GlibType = ffi::GstWebRTCSCTPTransportState;
2103
2104    #[inline]
2105    fn into_glib(self) -> ffi::GstWebRTCSCTPTransportState {
2106        match self {
2107            Self::New => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW,
2108            Self::Connecting => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING,
2109            Self::Connected => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED,
2110            Self::Closed => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED,
2111            Self::__Unknown(value) => value,
2112        }
2113    }
2114}
2115
2116#[cfg(feature = "v1_16")]
2117#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2118#[doc(hidden)]
2119impl FromGlib<ffi::GstWebRTCSCTPTransportState> for WebRTCSCTPTransportState {
2120    #[inline]
2121    unsafe fn from_glib(value: ffi::GstWebRTCSCTPTransportState) -> Self {
2122        skip_assert_initialized!();
2123
2124        match value {
2125            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW => Self::New,
2126            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING => Self::Connecting,
2127            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED => Self::Connected,
2128            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED => Self::Closed,
2129            value => Self::__Unknown(value),
2130        }
2131    }
2132}
2133
2134#[cfg(feature = "v1_16")]
2135#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2136impl StaticType for WebRTCSCTPTransportState {
2137    #[inline]
2138    #[doc(alias = "gst_webrtc_sctp_transport_state_get_type")]
2139    fn static_type() -> glib::Type {
2140        unsafe { from_glib(ffi::gst_webrtc_sctp_transport_state_get_type()) }
2141    }
2142}
2143
2144#[cfg(feature = "v1_16")]
2145#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2146impl glib::HasParamSpec for WebRTCSCTPTransportState {
2147    type ParamSpec = glib::ParamSpecEnum;
2148    type SetValue = Self;
2149    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2150
2151    fn param_spec_builder() -> Self::BuilderFn {
2152        Self::ParamSpec::builder_with_default
2153    }
2154}
2155
2156#[cfg(feature = "v1_16")]
2157#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2158impl glib::value::ValueType for WebRTCSCTPTransportState {
2159    type Type = Self;
2160}
2161
2162#[cfg(feature = "v1_16")]
2163#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2164unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSCTPTransportState {
2165    type Checker = glib::value::GenericValueTypeChecker<Self>;
2166
2167    #[inline]
2168    unsafe fn from_value(value: &'a glib::Value) -> Self {
2169        skip_assert_initialized!();
2170        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2171    }
2172}
2173
2174#[cfg(feature = "v1_16")]
2175#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2176impl ToValue for WebRTCSCTPTransportState {
2177    #[inline]
2178    fn to_value(&self) -> glib::Value {
2179        let mut value = glib::Value::for_value_type::<Self>();
2180        unsafe {
2181            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2182        }
2183        value
2184    }
2185
2186    #[inline]
2187    fn value_type(&self) -> glib::Type {
2188        Self::static_type()
2189    }
2190}
2191
2192#[cfg(feature = "v1_16")]
2193#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2194impl From<WebRTCSCTPTransportState> for glib::Value {
2195    #[inline]
2196    fn from(v: WebRTCSCTPTransportState) -> Self {
2197        skip_assert_initialized!();
2198        ToValue::to_value(&v)
2199    }
2200}
2201
2202/// See <http://w3c.github.io/webrtc-pc/`rtcsdptype`>
2203#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2204#[non_exhaustive]
2205#[doc(alias = "GstWebRTCSDPType")]
2206pub enum WebRTCSDPType {
2207    /// offer
2208    #[doc(alias = "GST_WEBRTC_SDP_TYPE_OFFER")]
2209    Offer,
2210    /// pranswer
2211    #[doc(alias = "GST_WEBRTC_SDP_TYPE_PRANSWER")]
2212    Pranswer,
2213    /// answer
2214    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ANSWER")]
2215    Answer,
2216    /// rollback
2217    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ROLLBACK")]
2218    Rollback,
2219    #[doc(hidden)]
2220    __Unknown(i32),
2221}
2222
2223impl WebRTCSDPType {
2224    pub fn to_str<'a>(self) -> &'a GStr {
2225        unsafe {
2226            GStr::from_ptr(
2227                ffi::gst_webrtc_sdp_type_to_string(self.into_glib())
2228                    .as_ref()
2229                    .expect("gst_webrtc_sdp_type_to_string returned NULL"),
2230            )
2231        }
2232    }
2233}
2234
2235impl std::fmt::Display for WebRTCSDPType {
2236    #[inline]
2237    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2238        f.write_str(&self.to_str())
2239    }
2240}
2241
2242#[doc(hidden)]
2243impl IntoGlib for WebRTCSDPType {
2244    type GlibType = ffi::GstWebRTCSDPType;
2245
2246    #[inline]
2247    fn into_glib(self) -> ffi::GstWebRTCSDPType {
2248        match self {
2249            Self::Offer => ffi::GST_WEBRTC_SDP_TYPE_OFFER,
2250            Self::Pranswer => ffi::GST_WEBRTC_SDP_TYPE_PRANSWER,
2251            Self::Answer => ffi::GST_WEBRTC_SDP_TYPE_ANSWER,
2252            Self::Rollback => ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK,
2253            Self::__Unknown(value) => value,
2254        }
2255    }
2256}
2257
2258#[doc(hidden)]
2259impl FromGlib<ffi::GstWebRTCSDPType> for WebRTCSDPType {
2260    #[inline]
2261    unsafe fn from_glib(value: ffi::GstWebRTCSDPType) -> Self {
2262        skip_assert_initialized!();
2263
2264        match value {
2265            ffi::GST_WEBRTC_SDP_TYPE_OFFER => Self::Offer,
2266            ffi::GST_WEBRTC_SDP_TYPE_PRANSWER => Self::Pranswer,
2267            ffi::GST_WEBRTC_SDP_TYPE_ANSWER => Self::Answer,
2268            ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK => Self::Rollback,
2269            value => Self::__Unknown(value),
2270        }
2271    }
2272}
2273
2274impl StaticType for WebRTCSDPType {
2275    #[inline]
2276    #[doc(alias = "gst_webrtc_sdp_type_get_type")]
2277    fn static_type() -> glib::Type {
2278        unsafe { from_glib(ffi::gst_webrtc_sdp_type_get_type()) }
2279    }
2280}
2281
2282impl glib::HasParamSpec for WebRTCSDPType {
2283    type ParamSpec = glib::ParamSpecEnum;
2284    type SetValue = Self;
2285    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2286
2287    fn param_spec_builder() -> Self::BuilderFn {
2288        Self::ParamSpec::builder_with_default
2289    }
2290}
2291
2292impl glib::value::ValueType for WebRTCSDPType {
2293    type Type = Self;
2294}
2295
2296unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSDPType {
2297    type Checker = glib::value::GenericValueTypeChecker<Self>;
2298
2299    #[inline]
2300    unsafe fn from_value(value: &'a glib::Value) -> Self {
2301        skip_assert_initialized!();
2302        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2303    }
2304}
2305
2306impl ToValue for WebRTCSDPType {
2307    #[inline]
2308    fn to_value(&self) -> glib::Value {
2309        let mut value = glib::Value::for_value_type::<Self>();
2310        unsafe {
2311            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2312        }
2313        value
2314    }
2315
2316    #[inline]
2317    fn value_type(&self) -> glib::Type {
2318        Self::static_type()
2319    }
2320}
2321
2322impl From<WebRTCSDPType> for glib::Value {
2323    #[inline]
2324    fn from(v: WebRTCSDPType) -> Self {
2325        skip_assert_initialized!();
2326        ToValue::to_value(&v)
2327    }
2328}
2329
2330/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcsignalingstate>
2331#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2332#[non_exhaustive]
2333#[doc(alias = "GstWebRTCSignalingState")]
2334pub enum WebRTCSignalingState {
2335    /// stable
2336    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_STABLE")]
2337    Stable,
2338    /// closed
2339    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_CLOSED")]
2340    Closed,
2341    /// have-local-offer
2342    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER")]
2343    HaveLocalOffer,
2344    /// have-remote-offer
2345    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER")]
2346    HaveRemoteOffer,
2347    /// have-local-pranswer
2348    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER")]
2349    HaveLocalPranswer,
2350    /// have-remote-pranswer
2351    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER")]
2352    HaveRemotePranswer,
2353    #[doc(hidden)]
2354    __Unknown(i32),
2355}
2356
2357#[doc(hidden)]
2358impl IntoGlib for WebRTCSignalingState {
2359    type GlibType = ffi::GstWebRTCSignalingState;
2360
2361    #[inline]
2362    fn into_glib(self) -> ffi::GstWebRTCSignalingState {
2363        match self {
2364            Self::Stable => ffi::GST_WEBRTC_SIGNALING_STATE_STABLE,
2365            Self::Closed => ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED,
2366            Self::HaveLocalOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER,
2367            Self::HaveRemoteOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER,
2368            Self::HaveLocalPranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER,
2369            Self::HaveRemotePranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER,
2370            Self::__Unknown(value) => value,
2371        }
2372    }
2373}
2374
2375#[doc(hidden)]
2376impl FromGlib<ffi::GstWebRTCSignalingState> for WebRTCSignalingState {
2377    #[inline]
2378    unsafe fn from_glib(value: ffi::GstWebRTCSignalingState) -> Self {
2379        skip_assert_initialized!();
2380
2381        match value {
2382            ffi::GST_WEBRTC_SIGNALING_STATE_STABLE => Self::Stable,
2383            ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED => Self::Closed,
2384            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER => Self::HaveLocalOffer,
2385            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER => Self::HaveRemoteOffer,
2386            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER => Self::HaveLocalPranswer,
2387            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER => Self::HaveRemotePranswer,
2388            value => Self::__Unknown(value),
2389        }
2390    }
2391}
2392
2393impl StaticType for WebRTCSignalingState {
2394    #[inline]
2395    #[doc(alias = "gst_webrtc_signaling_state_get_type")]
2396    fn static_type() -> glib::Type {
2397        unsafe { from_glib(ffi::gst_webrtc_signaling_state_get_type()) }
2398    }
2399}
2400
2401impl glib::HasParamSpec for WebRTCSignalingState {
2402    type ParamSpec = glib::ParamSpecEnum;
2403    type SetValue = Self;
2404    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2405
2406    fn param_spec_builder() -> Self::BuilderFn {
2407        Self::ParamSpec::builder_with_default
2408    }
2409}
2410
2411impl glib::value::ValueType for WebRTCSignalingState {
2412    type Type = Self;
2413}
2414
2415unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSignalingState {
2416    type Checker = glib::value::GenericValueTypeChecker<Self>;
2417
2418    #[inline]
2419    unsafe fn from_value(value: &'a glib::Value) -> Self {
2420        skip_assert_initialized!();
2421        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2422    }
2423}
2424
2425impl ToValue for WebRTCSignalingState {
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
2441impl From<WebRTCSignalingState> for glib::Value {
2442    #[inline]
2443    fn from(v: WebRTCSignalingState) -> Self {
2444        skip_assert_initialized!();
2445        ToValue::to_value(&v)
2446    }
2447}
2448
2449/// See <https://w3c.github.io/webrtc-stats/`dom`-rtcstatstype>
2450#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2451#[non_exhaustive]
2452#[doc(alias = "GstWebRTCStatsType")]
2453pub enum WebRTCStatsType {
2454    /// codec
2455    #[doc(alias = "GST_WEBRTC_STATS_CODEC")]
2456    Codec,
2457    /// inbound-rtp
2458    #[doc(alias = "GST_WEBRTC_STATS_INBOUND_RTP")]
2459    InboundRtp,
2460    /// outbound-rtp
2461    #[doc(alias = "GST_WEBRTC_STATS_OUTBOUND_RTP")]
2462    OutboundRtp,
2463    /// remote-inbound-rtp
2464    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_INBOUND_RTP")]
2465    RemoteInboundRtp,
2466    /// remote-outbound-rtp
2467    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP")]
2468    RemoteOutboundRtp,
2469    /// csrc
2470    #[doc(alias = "GST_WEBRTC_STATS_CSRC")]
2471    Csrc,
2472    /// peer-connection
2473    #[doc(alias = "GST_WEBRTC_STATS_PEER_CONNECTION")]
2474    PeerConnection,
2475    /// data-channel
2476    #[doc(alias = "GST_WEBRTC_STATS_DATA_CHANNEL")]
2477    DataChannel,
2478    /// stream
2479    #[doc(alias = "GST_WEBRTC_STATS_STREAM")]
2480    Stream,
2481    /// transport
2482    #[doc(alias = "GST_WEBRTC_STATS_TRANSPORT")]
2483    Transport,
2484    /// candidate-pair
2485    #[doc(alias = "GST_WEBRTC_STATS_CANDIDATE_PAIR")]
2486    CandidatePair,
2487    /// local-candidate
2488    #[doc(alias = "GST_WEBRTC_STATS_LOCAL_CANDIDATE")]
2489    LocalCandidate,
2490    /// remote-candidate
2491    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_CANDIDATE")]
2492    RemoteCandidate,
2493    /// certificate
2494    #[doc(alias = "GST_WEBRTC_STATS_CERTIFICATE")]
2495    Certificate,
2496    #[doc(hidden)]
2497    __Unknown(i32),
2498}
2499
2500#[doc(hidden)]
2501impl IntoGlib for WebRTCStatsType {
2502    type GlibType = ffi::GstWebRTCStatsType;
2503
2504    fn into_glib(self) -> ffi::GstWebRTCStatsType {
2505        match self {
2506            Self::Codec => ffi::GST_WEBRTC_STATS_CODEC,
2507            Self::InboundRtp => ffi::GST_WEBRTC_STATS_INBOUND_RTP,
2508            Self::OutboundRtp => ffi::GST_WEBRTC_STATS_OUTBOUND_RTP,
2509            Self::RemoteInboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP,
2510            Self::RemoteOutboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP,
2511            Self::Csrc => ffi::GST_WEBRTC_STATS_CSRC,
2512            Self::PeerConnection => ffi::GST_WEBRTC_STATS_PEER_CONNECTION,
2513            Self::DataChannel => ffi::GST_WEBRTC_STATS_DATA_CHANNEL,
2514            Self::Stream => ffi::GST_WEBRTC_STATS_STREAM,
2515            Self::Transport => ffi::GST_WEBRTC_STATS_TRANSPORT,
2516            Self::CandidatePair => ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR,
2517            Self::LocalCandidate => ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE,
2518            Self::RemoteCandidate => ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE,
2519            Self::Certificate => ffi::GST_WEBRTC_STATS_CERTIFICATE,
2520            Self::__Unknown(value) => value,
2521        }
2522    }
2523}
2524
2525#[doc(hidden)]
2526impl FromGlib<ffi::GstWebRTCStatsType> for WebRTCStatsType {
2527    unsafe fn from_glib(value: ffi::GstWebRTCStatsType) -> Self {
2528        skip_assert_initialized!();
2529
2530        match value {
2531            ffi::GST_WEBRTC_STATS_CODEC => Self::Codec,
2532            ffi::GST_WEBRTC_STATS_INBOUND_RTP => Self::InboundRtp,
2533            ffi::GST_WEBRTC_STATS_OUTBOUND_RTP => Self::OutboundRtp,
2534            ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP => Self::RemoteInboundRtp,
2535            ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP => Self::RemoteOutboundRtp,
2536            ffi::GST_WEBRTC_STATS_CSRC => Self::Csrc,
2537            ffi::GST_WEBRTC_STATS_PEER_CONNECTION => Self::PeerConnection,
2538            ffi::GST_WEBRTC_STATS_DATA_CHANNEL => Self::DataChannel,
2539            ffi::GST_WEBRTC_STATS_STREAM => Self::Stream,
2540            ffi::GST_WEBRTC_STATS_TRANSPORT => Self::Transport,
2541            ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR => Self::CandidatePair,
2542            ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE => Self::LocalCandidate,
2543            ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE => Self::RemoteCandidate,
2544            ffi::GST_WEBRTC_STATS_CERTIFICATE => Self::Certificate,
2545            value => Self::__Unknown(value),
2546        }
2547    }
2548}
2549
2550impl StaticType for WebRTCStatsType {
2551    #[inline]
2552    #[doc(alias = "gst_webrtc_stats_type_get_type")]
2553    fn static_type() -> glib::Type {
2554        unsafe { from_glib(ffi::gst_webrtc_stats_type_get_type()) }
2555    }
2556}
2557
2558impl glib::HasParamSpec for WebRTCStatsType {
2559    type ParamSpec = glib::ParamSpecEnum;
2560    type SetValue = Self;
2561    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2562
2563    fn param_spec_builder() -> Self::BuilderFn {
2564        Self::ParamSpec::builder_with_default
2565    }
2566}
2567
2568impl glib::value::ValueType for WebRTCStatsType {
2569    type Type = Self;
2570}
2571
2572unsafe impl<'a> glib::value::FromValue<'a> for WebRTCStatsType {
2573    type Checker = glib::value::GenericValueTypeChecker<Self>;
2574
2575    #[inline]
2576    unsafe fn from_value(value: &'a glib::Value) -> Self {
2577        skip_assert_initialized!();
2578        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2579    }
2580}
2581
2582impl ToValue for WebRTCStatsType {
2583    #[inline]
2584    fn to_value(&self) -> glib::Value {
2585        let mut value = glib::Value::for_value_type::<Self>();
2586        unsafe {
2587            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2588        }
2589        value
2590    }
2591
2592    #[inline]
2593    fn value_type(&self) -> glib::Type {
2594        Self::static_type()
2595    }
2596}
2597
2598impl From<WebRTCStatsType> for glib::Value {
2599    #[inline]
2600    fn from(v: WebRTCStatsType) -> Self {
2601        skip_assert_initialized!();
2602        ToValue::to_value(&v)
2603    }
2604}
gstreamer_webrtc/auto/enums.rs

gstreamer_webrtc/auto/
enums.rs
