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

gstreamer_webrtc/auto/
enums.rs
