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

gstreamer_webrtc/auto/
enums.rs
