gstreamer_webrtc/auto/
enums.rs

Help
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/// See https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-24`section`-4.1.1
1225/// for more information.
1226#[cfg(feature = "v1_16")]
1227#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1228#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1229#[non_exhaustive]
1230#[doc(alias = "GstWebRTCICETransportPolicy")]
1231pub enum WebRTCICETransportPolicy {
1232    /// all
1233    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL")]
1234    All,
1235    /// relay
1236    #[doc(alias = "GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY")]
1237    Relay,
1238    #[doc(hidden)]
1239    __Unknown(i32),
1240}
1241
1242#[cfg(feature = "v1_16")]
1243#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1244#[doc(hidden)]
1245impl IntoGlib for WebRTCICETransportPolicy {
1246    type GlibType = ffi::GstWebRTCICETransportPolicy;
1247
1248    #[inline]
1249    fn into_glib(self) -> ffi::GstWebRTCICETransportPolicy {
1250        match self {
1251            Self::All => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL,
1252            Self::Relay => ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY,
1253            Self::__Unknown(value) => value,
1254        }
1255    }
1256}
1257
1258#[cfg(feature = "v1_16")]
1259#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1260#[doc(hidden)]
1261impl FromGlib<ffi::GstWebRTCICETransportPolicy> for WebRTCICETransportPolicy {
1262    #[inline]
1263    unsafe fn from_glib(value: ffi::GstWebRTCICETransportPolicy) -> Self {
1264        skip_assert_initialized!();
1265
1266        match value {
1267            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_ALL => Self::All,
1268            ffi::GST_WEBRTC_ICE_TRANSPORT_POLICY_RELAY => Self::Relay,
1269            value => Self::__Unknown(value),
1270        }
1271    }
1272}
1273
1274#[cfg(feature = "v1_16")]
1275#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1276impl StaticType for WebRTCICETransportPolicy {
1277    #[inline]
1278    #[doc(alias = "gst_webrtc_ice_transport_policy_get_type")]
1279    fn static_type() -> glib::Type {
1280        unsafe { from_glib(ffi::gst_webrtc_ice_transport_policy_get_type()) }
1281    }
1282}
1283
1284#[cfg(feature = "v1_16")]
1285#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1286impl glib::HasParamSpec for WebRTCICETransportPolicy {
1287    type ParamSpec = glib::ParamSpecEnum;
1288    type SetValue = Self;
1289    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1290
1291    fn param_spec_builder() -> Self::BuilderFn {
1292        Self::ParamSpec::builder_with_default
1293    }
1294}
1295
1296#[cfg(feature = "v1_16")]
1297#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1298impl glib::value::ValueType for WebRTCICETransportPolicy {
1299    type Type = Self;
1300}
1301
1302#[cfg(feature = "v1_16")]
1303#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1304unsafe impl<'a> glib::value::FromValue<'a> for WebRTCICETransportPolicy {
1305    type Checker = glib::value::GenericValueTypeChecker<Self>;
1306
1307    #[inline]
1308    unsafe fn from_value(value: &'a glib::Value) -> Self {
1309        skip_assert_initialized!();
1310        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1311    }
1312}
1313
1314#[cfg(feature = "v1_16")]
1315#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1316impl ToValue for WebRTCICETransportPolicy {
1317    #[inline]
1318    fn to_value(&self) -> glib::Value {
1319        let mut value = glib::Value::for_value_type::<Self>();
1320        unsafe {
1321            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1322        }
1323        value
1324    }
1325
1326    #[inline]
1327    fn value_type(&self) -> glib::Type {
1328        Self::static_type()
1329    }
1330}
1331
1332#[cfg(feature = "v1_16")]
1333#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1334impl From<WebRTCICETransportPolicy> for glib::Value {
1335    #[inline]
1336    fn from(v: WebRTCICETransportPolicy) -> Self {
1337        skip_assert_initialized!();
1338        ToValue::to_value(&v)
1339    }
1340}
1341
1342/// https://w3c.github.io/mediacapture-main/`dom`-mediastreamtrack-kind
1343#[cfg(feature = "v1_20")]
1344#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1345#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1346#[non_exhaustive]
1347#[doc(alias = "GstWebRTCKind")]
1348pub enum WebRTCKind {
1349    /// Kind has not yet been set
1350    #[doc(alias = "GST_WEBRTC_KIND_UNKNOWN")]
1351    Unknown,
1352    /// Kind is audio
1353    #[doc(alias = "GST_WEBRTC_KIND_AUDIO")]
1354    Audio,
1355    /// Kind is video
1356    #[doc(alias = "GST_WEBRTC_KIND_VIDEO")]
1357    Video,
1358    #[doc(hidden)]
1359    __Unknown(i32),
1360}
1361
1362#[cfg(feature = "v1_20")]
1363#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1364#[doc(hidden)]
1365impl IntoGlib for WebRTCKind {
1366    type GlibType = ffi::GstWebRTCKind;
1367
1368    #[inline]
1369    fn into_glib(self) -> ffi::GstWebRTCKind {
1370        match self {
1371            Self::Unknown => ffi::GST_WEBRTC_KIND_UNKNOWN,
1372            Self::Audio => ffi::GST_WEBRTC_KIND_AUDIO,
1373            Self::Video => ffi::GST_WEBRTC_KIND_VIDEO,
1374            Self::__Unknown(value) => value,
1375        }
1376    }
1377}
1378
1379#[cfg(feature = "v1_20")]
1380#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1381#[doc(hidden)]
1382impl FromGlib<ffi::GstWebRTCKind> for WebRTCKind {
1383    #[inline]
1384    unsafe fn from_glib(value: ffi::GstWebRTCKind) -> Self {
1385        skip_assert_initialized!();
1386
1387        match value {
1388            ffi::GST_WEBRTC_KIND_UNKNOWN => Self::Unknown,
1389            ffi::GST_WEBRTC_KIND_AUDIO => Self::Audio,
1390            ffi::GST_WEBRTC_KIND_VIDEO => Self::Video,
1391            value => Self::__Unknown(value),
1392        }
1393    }
1394}
1395
1396#[cfg(feature = "v1_20")]
1397#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1398impl StaticType for WebRTCKind {
1399    #[inline]
1400    #[doc(alias = "gst_webrtc_kind_get_type")]
1401    fn static_type() -> glib::Type {
1402        unsafe { from_glib(ffi::gst_webrtc_kind_get_type()) }
1403    }
1404}
1405
1406#[cfg(feature = "v1_20")]
1407#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1408impl glib::HasParamSpec for WebRTCKind {
1409    type ParamSpec = glib::ParamSpecEnum;
1410    type SetValue = Self;
1411    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1412
1413    fn param_spec_builder() -> Self::BuilderFn {
1414        Self::ParamSpec::builder_with_default
1415    }
1416}
1417
1418#[cfg(feature = "v1_20")]
1419#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1420impl glib::value::ValueType for WebRTCKind {
1421    type Type = Self;
1422}
1423
1424#[cfg(feature = "v1_20")]
1425#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1426unsafe impl<'a> glib::value::FromValue<'a> for WebRTCKind {
1427    type Checker = glib::value::GenericValueTypeChecker<Self>;
1428
1429    #[inline]
1430    unsafe fn from_value(value: &'a glib::Value) -> Self {
1431        skip_assert_initialized!();
1432        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1433    }
1434}
1435
1436#[cfg(feature = "v1_20")]
1437#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1438impl ToValue for WebRTCKind {
1439    #[inline]
1440    fn to_value(&self) -> glib::Value {
1441        let mut value = glib::Value::for_value_type::<Self>();
1442        unsafe {
1443            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1444        }
1445        value
1446    }
1447
1448    #[inline]
1449    fn value_type(&self) -> glib::Type {
1450        Self::static_type()
1451    }
1452}
1453
1454#[cfg(feature = "v1_20")]
1455#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1456impl From<WebRTCKind> for glib::Value {
1457    #[inline]
1458    fn from(v: WebRTCKind) -> Self {
1459        skip_assert_initialized!();
1460        ToValue::to_value(&v)
1461    }
1462}
1463
1464/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcpeerconnectionstate>
1465#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1466#[non_exhaustive]
1467#[doc(alias = "GstWebRTCPeerConnectionState")]
1468pub enum WebRTCPeerConnectionState {
1469    /// new
1470    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_NEW")]
1471    New,
1472    /// connecting
1473    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING")]
1474    Connecting,
1475    /// connected
1476    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED")]
1477    Connected,
1478    /// disconnected
1479    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED")]
1480    Disconnected,
1481    /// failed
1482    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_FAILED")]
1483    Failed,
1484    /// closed
1485    #[doc(alias = "GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED")]
1486    Closed,
1487    #[doc(hidden)]
1488    __Unknown(i32),
1489}
1490
1491#[doc(hidden)]
1492impl IntoGlib for WebRTCPeerConnectionState {
1493    type GlibType = ffi::GstWebRTCPeerConnectionState;
1494
1495    #[inline]
1496    fn into_glib(self) -> ffi::GstWebRTCPeerConnectionState {
1497        match self {
1498            Self::New => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW,
1499            Self::Connecting => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING,
1500            Self::Connected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED,
1501            Self::Disconnected => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED,
1502            Self::Failed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED,
1503            Self::Closed => ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED,
1504            Self::__Unknown(value) => value,
1505        }
1506    }
1507}
1508
1509#[doc(hidden)]
1510impl FromGlib<ffi::GstWebRTCPeerConnectionState> for WebRTCPeerConnectionState {
1511    #[inline]
1512    unsafe fn from_glib(value: ffi::GstWebRTCPeerConnectionState) -> Self {
1513        skip_assert_initialized!();
1514
1515        match value {
1516            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_NEW => Self::New,
1517            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING => Self::Connecting,
1518            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED => Self::Connected,
1519            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED => Self::Disconnected,
1520            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_FAILED => Self::Failed,
1521            ffi::GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED => Self::Closed,
1522            value => Self::__Unknown(value),
1523        }
1524    }
1525}
1526
1527impl StaticType for WebRTCPeerConnectionState {
1528    #[inline]
1529    #[doc(alias = "gst_webrtc_peer_connection_state_get_type")]
1530    fn static_type() -> glib::Type {
1531        unsafe { from_glib(ffi::gst_webrtc_peer_connection_state_get_type()) }
1532    }
1533}
1534
1535impl glib::HasParamSpec for WebRTCPeerConnectionState {
1536    type ParamSpec = glib::ParamSpecEnum;
1537    type SetValue = Self;
1538    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1539
1540    fn param_spec_builder() -> Self::BuilderFn {
1541        Self::ParamSpec::builder_with_default
1542    }
1543}
1544
1545impl glib::value::ValueType for WebRTCPeerConnectionState {
1546    type Type = Self;
1547}
1548
1549unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPeerConnectionState {
1550    type Checker = glib::value::GenericValueTypeChecker<Self>;
1551
1552    #[inline]
1553    unsafe fn from_value(value: &'a glib::Value) -> Self {
1554        skip_assert_initialized!();
1555        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1556    }
1557}
1558
1559impl ToValue for WebRTCPeerConnectionState {
1560    #[inline]
1561    fn to_value(&self) -> glib::Value {
1562        let mut value = glib::Value::for_value_type::<Self>();
1563        unsafe {
1564            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1565        }
1566        value
1567    }
1568
1569    #[inline]
1570    fn value_type(&self) -> glib::Type {
1571        Self::static_type()
1572    }
1573}
1574
1575impl From<WebRTCPeerConnectionState> for glib::Value {
1576    #[inline]
1577    fn from(v: WebRTCPeerConnectionState) -> Self {
1578        skip_assert_initialized!();
1579        ToValue::to_value(&v)
1580    }
1581}
1582
1583/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcprioritytype>
1584#[cfg(feature = "v1_16")]
1585#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1586#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1587#[non_exhaustive]
1588#[doc(alias = "GstWebRTCPriorityType")]
1589pub enum WebRTCPriorityType {
1590    /// very-low
1591    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_VERY_LOW")]
1592    VeryLow,
1593    /// low
1594    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_LOW")]
1595    Low,
1596    /// medium
1597    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_MEDIUM")]
1598    Medium,
1599    /// high
1600    #[doc(alias = "GST_WEBRTC_PRIORITY_TYPE_HIGH")]
1601    High,
1602    #[doc(hidden)]
1603    __Unknown(i32),
1604}
1605
1606#[cfg(feature = "v1_16")]
1607#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1608#[doc(hidden)]
1609impl IntoGlib for WebRTCPriorityType {
1610    type GlibType = ffi::GstWebRTCPriorityType;
1611
1612    #[inline]
1613    fn into_glib(self) -> ffi::GstWebRTCPriorityType {
1614        match self {
1615            Self::VeryLow => ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW,
1616            Self::Low => ffi::GST_WEBRTC_PRIORITY_TYPE_LOW,
1617            Self::Medium => ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM,
1618            Self::High => ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH,
1619            Self::__Unknown(value) => value,
1620        }
1621    }
1622}
1623
1624#[cfg(feature = "v1_16")]
1625#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1626#[doc(hidden)]
1627impl FromGlib<ffi::GstWebRTCPriorityType> for WebRTCPriorityType {
1628    #[inline]
1629    unsafe fn from_glib(value: ffi::GstWebRTCPriorityType) -> Self {
1630        skip_assert_initialized!();
1631
1632        match value {
1633            ffi::GST_WEBRTC_PRIORITY_TYPE_VERY_LOW => Self::VeryLow,
1634            ffi::GST_WEBRTC_PRIORITY_TYPE_LOW => Self::Low,
1635            ffi::GST_WEBRTC_PRIORITY_TYPE_MEDIUM => Self::Medium,
1636            ffi::GST_WEBRTC_PRIORITY_TYPE_HIGH => Self::High,
1637            value => Self::__Unknown(value),
1638        }
1639    }
1640}
1641
1642#[cfg(feature = "v1_16")]
1643#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1644impl StaticType for WebRTCPriorityType {
1645    #[inline]
1646    #[doc(alias = "gst_webrtc_priority_type_get_type")]
1647    fn static_type() -> glib::Type {
1648        unsafe { from_glib(ffi::gst_webrtc_priority_type_get_type()) }
1649    }
1650}
1651
1652#[cfg(feature = "v1_16")]
1653#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1654impl glib::HasParamSpec for WebRTCPriorityType {
1655    type ParamSpec = glib::ParamSpecEnum;
1656    type SetValue = Self;
1657    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1658
1659    fn param_spec_builder() -> Self::BuilderFn {
1660        Self::ParamSpec::builder_with_default
1661    }
1662}
1663
1664#[cfg(feature = "v1_16")]
1665#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1666impl glib::value::ValueType for WebRTCPriorityType {
1667    type Type = Self;
1668}
1669
1670#[cfg(feature = "v1_16")]
1671#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1672unsafe impl<'a> glib::value::FromValue<'a> for WebRTCPriorityType {
1673    type Checker = glib::value::GenericValueTypeChecker<Self>;
1674
1675    #[inline]
1676    unsafe fn from_value(value: &'a glib::Value) -> Self {
1677        skip_assert_initialized!();
1678        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1679    }
1680}
1681
1682#[cfg(feature = "v1_16")]
1683#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1684impl ToValue for WebRTCPriorityType {
1685    #[inline]
1686    fn to_value(&self) -> glib::Value {
1687        let mut value = glib::Value::for_value_type::<Self>();
1688        unsafe {
1689            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1690        }
1691        value
1692    }
1693
1694    #[inline]
1695    fn value_type(&self) -> glib::Type {
1696        Self::static_type()
1697    }
1698}
1699
1700#[cfg(feature = "v1_16")]
1701#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1702impl From<WebRTCPriorityType> for glib::Value {
1703    #[inline]
1704    fn from(v: WebRTCPriorityType) -> Self {
1705        skip_assert_initialized!();
1706        ToValue::to_value(&v)
1707    }
1708}
1709
1710#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1711#[non_exhaustive]
1712#[doc(alias = "GstWebRTCRTPTransceiverDirection")]
1713pub enum WebRTCRTPTransceiverDirection {
1714    /// none
1715    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE")]
1716    None,
1717    /// inactive
1718    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE")]
1719    Inactive,
1720    /// sendonly
1721    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY")]
1722    Sendonly,
1723    /// recvonly
1724    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY")]
1725    Recvonly,
1726    /// sendrecv
1727    #[doc(alias = "GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV")]
1728    Sendrecv,
1729    #[doc(hidden)]
1730    __Unknown(i32),
1731}
1732
1733#[doc(hidden)]
1734impl IntoGlib for WebRTCRTPTransceiverDirection {
1735    type GlibType = ffi::GstWebRTCRTPTransceiverDirection;
1736
1737    #[inline]
1738    fn into_glib(self) -> ffi::GstWebRTCRTPTransceiverDirection {
1739        match self {
1740            Self::None => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE,
1741            Self::Inactive => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE,
1742            Self::Sendonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY,
1743            Self::Recvonly => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY,
1744            Self::Sendrecv => ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV,
1745            Self::__Unknown(value) => value,
1746        }
1747    }
1748}
1749
1750#[doc(hidden)]
1751impl FromGlib<ffi::GstWebRTCRTPTransceiverDirection> for WebRTCRTPTransceiverDirection {
1752    #[inline]
1753    unsafe fn from_glib(value: ffi::GstWebRTCRTPTransceiverDirection) -> Self {
1754        skip_assert_initialized!();
1755
1756        match value {
1757            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE => Self::None,
1758            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE => Self::Inactive,
1759            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY => Self::Sendonly,
1760            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY => Self::Recvonly,
1761            ffi::GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV => Self::Sendrecv,
1762            value => Self::__Unknown(value),
1763        }
1764    }
1765}
1766
1767impl StaticType for WebRTCRTPTransceiverDirection {
1768    #[inline]
1769    #[doc(alias = "gst_webrtc_rtp_transceiver_direction_get_type")]
1770    fn static_type() -> glib::Type {
1771        unsafe { from_glib(ffi::gst_webrtc_rtp_transceiver_direction_get_type()) }
1772    }
1773}
1774
1775impl glib::HasParamSpec for WebRTCRTPTransceiverDirection {
1776    type ParamSpec = glib::ParamSpecEnum;
1777    type SetValue = Self;
1778    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1779
1780    fn param_spec_builder() -> Self::BuilderFn {
1781        Self::ParamSpec::builder_with_default
1782    }
1783}
1784
1785impl glib::value::ValueType for WebRTCRTPTransceiverDirection {
1786    type Type = Self;
1787}
1788
1789unsafe impl<'a> glib::value::FromValue<'a> for WebRTCRTPTransceiverDirection {
1790    type Checker = glib::value::GenericValueTypeChecker<Self>;
1791
1792    #[inline]
1793    unsafe fn from_value(value: &'a glib::Value) -> Self {
1794        skip_assert_initialized!();
1795        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1796    }
1797}
1798
1799impl ToValue for WebRTCRTPTransceiverDirection {
1800    #[inline]
1801    fn to_value(&self) -> glib::Value {
1802        let mut value = glib::Value::for_value_type::<Self>();
1803        unsafe {
1804            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1805        }
1806        value
1807    }
1808
1809    #[inline]
1810    fn value_type(&self) -> glib::Type {
1811        Self::static_type()
1812    }
1813}
1814
1815impl From<WebRTCRTPTransceiverDirection> for glib::Value {
1816    #[inline]
1817    fn from(v: WebRTCRTPTransceiverDirection) -> Self {
1818        skip_assert_initialized!();
1819        ToValue::to_value(&v)
1820    }
1821}
1822
1823/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcsctptransportstate>
1824#[cfg(feature = "v1_16")]
1825#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1826#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1827#[non_exhaustive]
1828#[doc(alias = "GstWebRTCSCTPTransportState")]
1829pub enum WebRTCSCTPTransportState {
1830    /// new
1831    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW")]
1832    New,
1833    /// connecting
1834    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING")]
1835    Connecting,
1836    /// connected
1837    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED")]
1838    Connected,
1839    /// closed
1840    #[doc(alias = "GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED")]
1841    Closed,
1842    #[doc(hidden)]
1843    __Unknown(i32),
1844}
1845
1846#[cfg(feature = "v1_16")]
1847#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1848#[doc(hidden)]
1849impl IntoGlib for WebRTCSCTPTransportState {
1850    type GlibType = ffi::GstWebRTCSCTPTransportState;
1851
1852    #[inline]
1853    fn into_glib(self) -> ffi::GstWebRTCSCTPTransportState {
1854        match self {
1855            Self::New => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW,
1856            Self::Connecting => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING,
1857            Self::Connected => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED,
1858            Self::Closed => ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED,
1859            Self::__Unknown(value) => value,
1860        }
1861    }
1862}
1863
1864#[cfg(feature = "v1_16")]
1865#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1866#[doc(hidden)]
1867impl FromGlib<ffi::GstWebRTCSCTPTransportState> for WebRTCSCTPTransportState {
1868    #[inline]
1869    unsafe fn from_glib(value: ffi::GstWebRTCSCTPTransportState) -> Self {
1870        skip_assert_initialized!();
1871
1872        match value {
1873            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_NEW => Self::New,
1874            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTING => Self::Connecting,
1875            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CONNECTED => Self::Connected,
1876            ffi::GST_WEBRTC_SCTP_TRANSPORT_STATE_CLOSED => Self::Closed,
1877            value => Self::__Unknown(value),
1878        }
1879    }
1880}
1881
1882#[cfg(feature = "v1_16")]
1883#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1884impl StaticType for WebRTCSCTPTransportState {
1885    #[inline]
1886    #[doc(alias = "gst_webrtc_sctp_transport_state_get_type")]
1887    fn static_type() -> glib::Type {
1888        unsafe { from_glib(ffi::gst_webrtc_sctp_transport_state_get_type()) }
1889    }
1890}
1891
1892#[cfg(feature = "v1_16")]
1893#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1894impl glib::HasParamSpec for WebRTCSCTPTransportState {
1895    type ParamSpec = glib::ParamSpecEnum;
1896    type SetValue = Self;
1897    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1898
1899    fn param_spec_builder() -> Self::BuilderFn {
1900        Self::ParamSpec::builder_with_default
1901    }
1902}
1903
1904#[cfg(feature = "v1_16")]
1905#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1906impl glib::value::ValueType for WebRTCSCTPTransportState {
1907    type Type = Self;
1908}
1909
1910#[cfg(feature = "v1_16")]
1911#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1912unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSCTPTransportState {
1913    type Checker = glib::value::GenericValueTypeChecker<Self>;
1914
1915    #[inline]
1916    unsafe fn from_value(value: &'a glib::Value) -> Self {
1917        skip_assert_initialized!();
1918        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1919    }
1920}
1921
1922#[cfg(feature = "v1_16")]
1923#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1924impl ToValue for WebRTCSCTPTransportState {
1925    #[inline]
1926    fn to_value(&self) -> glib::Value {
1927        let mut value = glib::Value::for_value_type::<Self>();
1928        unsafe {
1929            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1930        }
1931        value
1932    }
1933
1934    #[inline]
1935    fn value_type(&self) -> glib::Type {
1936        Self::static_type()
1937    }
1938}
1939
1940#[cfg(feature = "v1_16")]
1941#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1942impl From<WebRTCSCTPTransportState> for glib::Value {
1943    #[inline]
1944    fn from(v: WebRTCSCTPTransportState) -> Self {
1945        skip_assert_initialized!();
1946        ToValue::to_value(&v)
1947    }
1948}
1949
1950/// See <http://w3c.github.io/webrtc-pc/`rtcsdptype`>
1951#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1952#[non_exhaustive]
1953#[doc(alias = "GstWebRTCSDPType")]
1954pub enum WebRTCSDPType {
1955    /// offer
1956    #[doc(alias = "GST_WEBRTC_SDP_TYPE_OFFER")]
1957    Offer,
1958    /// pranswer
1959    #[doc(alias = "GST_WEBRTC_SDP_TYPE_PRANSWER")]
1960    Pranswer,
1961    /// answer
1962    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ANSWER")]
1963    Answer,
1964    /// rollback
1965    #[doc(alias = "GST_WEBRTC_SDP_TYPE_ROLLBACK")]
1966    Rollback,
1967    #[doc(hidden)]
1968    __Unknown(i32),
1969}
1970
1971impl WebRTCSDPType {
1972    pub fn to_str<'a>(self) -> &'a GStr {
1973        unsafe {
1974            GStr::from_ptr(
1975                ffi::gst_webrtc_sdp_type_to_string(self.into_glib())
1976                    .as_ref()
1977                    .expect("gst_webrtc_sdp_type_to_string returned NULL"),
1978            )
1979        }
1980    }
1981}
1982
1983impl std::fmt::Display for WebRTCSDPType {
1984    #[inline]
1985    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1986        f.write_str(&self.to_str())
1987    }
1988}
1989
1990#[doc(hidden)]
1991impl IntoGlib for WebRTCSDPType {
1992    type GlibType = ffi::GstWebRTCSDPType;
1993
1994    #[inline]
1995    fn into_glib(self) -> ffi::GstWebRTCSDPType {
1996        match self {
1997            Self::Offer => ffi::GST_WEBRTC_SDP_TYPE_OFFER,
1998            Self::Pranswer => ffi::GST_WEBRTC_SDP_TYPE_PRANSWER,
1999            Self::Answer => ffi::GST_WEBRTC_SDP_TYPE_ANSWER,
2000            Self::Rollback => ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK,
2001            Self::__Unknown(value) => value,
2002        }
2003    }
2004}
2005
2006#[doc(hidden)]
2007impl FromGlib<ffi::GstWebRTCSDPType> for WebRTCSDPType {
2008    #[inline]
2009    unsafe fn from_glib(value: ffi::GstWebRTCSDPType) -> Self {
2010        skip_assert_initialized!();
2011
2012        match value {
2013            ffi::GST_WEBRTC_SDP_TYPE_OFFER => Self::Offer,
2014            ffi::GST_WEBRTC_SDP_TYPE_PRANSWER => Self::Pranswer,
2015            ffi::GST_WEBRTC_SDP_TYPE_ANSWER => Self::Answer,
2016            ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK => Self::Rollback,
2017            value => Self::__Unknown(value),
2018        }
2019    }
2020}
2021
2022impl StaticType for WebRTCSDPType {
2023    #[inline]
2024    #[doc(alias = "gst_webrtc_sdp_type_get_type")]
2025    fn static_type() -> glib::Type {
2026        unsafe { from_glib(ffi::gst_webrtc_sdp_type_get_type()) }
2027    }
2028}
2029
2030impl glib::HasParamSpec for WebRTCSDPType {
2031    type ParamSpec = glib::ParamSpecEnum;
2032    type SetValue = Self;
2033    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2034
2035    fn param_spec_builder() -> Self::BuilderFn {
2036        Self::ParamSpec::builder_with_default
2037    }
2038}
2039
2040impl glib::value::ValueType for WebRTCSDPType {
2041    type Type = Self;
2042}
2043
2044unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSDPType {
2045    type Checker = glib::value::GenericValueTypeChecker<Self>;
2046
2047    #[inline]
2048    unsafe fn from_value(value: &'a glib::Value) -> Self {
2049        skip_assert_initialized!();
2050        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2051    }
2052}
2053
2054impl ToValue for WebRTCSDPType {
2055    #[inline]
2056    fn to_value(&self) -> glib::Value {
2057        let mut value = glib::Value::for_value_type::<Self>();
2058        unsafe {
2059            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2060        }
2061        value
2062    }
2063
2064    #[inline]
2065    fn value_type(&self) -> glib::Type {
2066        Self::static_type()
2067    }
2068}
2069
2070impl From<WebRTCSDPType> for glib::Value {
2071    #[inline]
2072    fn from(v: WebRTCSDPType) -> Self {
2073        skip_assert_initialized!();
2074        ToValue::to_value(&v)
2075    }
2076}
2077
2078/// See <http://w3c.github.io/webrtc-pc/`dom`-rtcsignalingstate>
2079#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2080#[non_exhaustive]
2081#[doc(alias = "GstWebRTCSignalingState")]
2082pub enum WebRTCSignalingState {
2083    /// stable
2084    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_STABLE")]
2085    Stable,
2086    /// closed
2087    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_CLOSED")]
2088    Closed,
2089    /// have-local-offer
2090    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER")]
2091    HaveLocalOffer,
2092    /// have-remote-offer
2093    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER")]
2094    HaveRemoteOffer,
2095    /// have-local-pranswer
2096    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER")]
2097    HaveLocalPranswer,
2098    /// have-remote-pranswer
2099    #[doc(alias = "GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER")]
2100    HaveRemotePranswer,
2101    #[doc(hidden)]
2102    __Unknown(i32),
2103}
2104
2105#[doc(hidden)]
2106impl IntoGlib for WebRTCSignalingState {
2107    type GlibType = ffi::GstWebRTCSignalingState;
2108
2109    #[inline]
2110    fn into_glib(self) -> ffi::GstWebRTCSignalingState {
2111        match self {
2112            Self::Stable => ffi::GST_WEBRTC_SIGNALING_STATE_STABLE,
2113            Self::Closed => ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED,
2114            Self::HaveLocalOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER,
2115            Self::HaveRemoteOffer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER,
2116            Self::HaveLocalPranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER,
2117            Self::HaveRemotePranswer => ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER,
2118            Self::__Unknown(value) => value,
2119        }
2120    }
2121}
2122
2123#[doc(hidden)]
2124impl FromGlib<ffi::GstWebRTCSignalingState> for WebRTCSignalingState {
2125    #[inline]
2126    unsafe fn from_glib(value: ffi::GstWebRTCSignalingState) -> Self {
2127        skip_assert_initialized!();
2128
2129        match value {
2130            ffi::GST_WEBRTC_SIGNALING_STATE_STABLE => Self::Stable,
2131            ffi::GST_WEBRTC_SIGNALING_STATE_CLOSED => Self::Closed,
2132            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER => Self::HaveLocalOffer,
2133            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER => Self::HaveRemoteOffer,
2134            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER => Self::HaveLocalPranswer,
2135            ffi::GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER => Self::HaveRemotePranswer,
2136            value => Self::__Unknown(value),
2137        }
2138    }
2139}
2140
2141impl StaticType for WebRTCSignalingState {
2142    #[inline]
2143    #[doc(alias = "gst_webrtc_signaling_state_get_type")]
2144    fn static_type() -> glib::Type {
2145        unsafe { from_glib(ffi::gst_webrtc_signaling_state_get_type()) }
2146    }
2147}
2148
2149impl glib::HasParamSpec for WebRTCSignalingState {
2150    type ParamSpec = glib::ParamSpecEnum;
2151    type SetValue = Self;
2152    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2153
2154    fn param_spec_builder() -> Self::BuilderFn {
2155        Self::ParamSpec::builder_with_default
2156    }
2157}
2158
2159impl glib::value::ValueType for WebRTCSignalingState {
2160    type Type = Self;
2161}
2162
2163unsafe impl<'a> glib::value::FromValue<'a> for WebRTCSignalingState {
2164    type Checker = glib::value::GenericValueTypeChecker<Self>;
2165
2166    #[inline]
2167    unsafe fn from_value(value: &'a glib::Value) -> Self {
2168        skip_assert_initialized!();
2169        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2170    }
2171}
2172
2173impl ToValue for WebRTCSignalingState {
2174    #[inline]
2175    fn to_value(&self) -> glib::Value {
2176        let mut value = glib::Value::for_value_type::<Self>();
2177        unsafe {
2178            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2179        }
2180        value
2181    }
2182
2183    #[inline]
2184    fn value_type(&self) -> glib::Type {
2185        Self::static_type()
2186    }
2187}
2188
2189impl From<WebRTCSignalingState> for glib::Value {
2190    #[inline]
2191    fn from(v: WebRTCSignalingState) -> Self {
2192        skip_assert_initialized!();
2193        ToValue::to_value(&v)
2194    }
2195}
2196
2197/// See <https://w3c.github.io/webrtc-stats/`dom`-rtcstatstype>
2198#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2199#[non_exhaustive]
2200#[doc(alias = "GstWebRTCStatsType")]
2201pub enum WebRTCStatsType {
2202    /// codec
2203    #[doc(alias = "GST_WEBRTC_STATS_CODEC")]
2204    Codec,
2205    /// inbound-rtp
2206    #[doc(alias = "GST_WEBRTC_STATS_INBOUND_RTP")]
2207    InboundRtp,
2208    /// outbound-rtp
2209    #[doc(alias = "GST_WEBRTC_STATS_OUTBOUND_RTP")]
2210    OutboundRtp,
2211    /// remote-inbound-rtp
2212    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_INBOUND_RTP")]
2213    RemoteInboundRtp,
2214    /// remote-outbound-rtp
2215    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP")]
2216    RemoteOutboundRtp,
2217    /// csrc
2218    #[doc(alias = "GST_WEBRTC_STATS_CSRC")]
2219    Csrc,
2220    /// peer-connection
2221    #[doc(alias = "GST_WEBRTC_STATS_PEER_CONNECTION")]
2222    PeerConnection,
2223    /// data-channel
2224    #[doc(alias = "GST_WEBRTC_STATS_DATA_CHANNEL")]
2225    DataChannel,
2226    /// stream
2227    #[doc(alias = "GST_WEBRTC_STATS_STREAM")]
2228    Stream,
2229    /// transport
2230    #[doc(alias = "GST_WEBRTC_STATS_TRANSPORT")]
2231    Transport,
2232    /// candidate-pair
2233    #[doc(alias = "GST_WEBRTC_STATS_CANDIDATE_PAIR")]
2234    CandidatePair,
2235    /// local-candidate
2236    #[doc(alias = "GST_WEBRTC_STATS_LOCAL_CANDIDATE")]
2237    LocalCandidate,
2238    /// remote-candidate
2239    #[doc(alias = "GST_WEBRTC_STATS_REMOTE_CANDIDATE")]
2240    RemoteCandidate,
2241    /// certificate
2242    #[doc(alias = "GST_WEBRTC_STATS_CERTIFICATE")]
2243    Certificate,
2244    #[doc(hidden)]
2245    __Unknown(i32),
2246}
2247
2248#[doc(hidden)]
2249impl IntoGlib for WebRTCStatsType {
2250    type GlibType = ffi::GstWebRTCStatsType;
2251
2252    fn into_glib(self) -> ffi::GstWebRTCStatsType {
2253        match self {
2254            Self::Codec => ffi::GST_WEBRTC_STATS_CODEC,
2255            Self::InboundRtp => ffi::GST_WEBRTC_STATS_INBOUND_RTP,
2256            Self::OutboundRtp => ffi::GST_WEBRTC_STATS_OUTBOUND_RTP,
2257            Self::RemoteInboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP,
2258            Self::RemoteOutboundRtp => ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP,
2259            Self::Csrc => ffi::GST_WEBRTC_STATS_CSRC,
2260            Self::PeerConnection => ffi::GST_WEBRTC_STATS_PEER_CONNECTION,
2261            Self::DataChannel => ffi::GST_WEBRTC_STATS_DATA_CHANNEL,
2262            Self::Stream => ffi::GST_WEBRTC_STATS_STREAM,
2263            Self::Transport => ffi::GST_WEBRTC_STATS_TRANSPORT,
2264            Self::CandidatePair => ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR,
2265            Self::LocalCandidate => ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE,
2266            Self::RemoteCandidate => ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE,
2267            Self::Certificate => ffi::GST_WEBRTC_STATS_CERTIFICATE,
2268            Self::__Unknown(value) => value,
2269        }
2270    }
2271}
2272
2273#[doc(hidden)]
2274impl FromGlib<ffi::GstWebRTCStatsType> for WebRTCStatsType {
2275    unsafe fn from_glib(value: ffi::GstWebRTCStatsType) -> Self {
2276        skip_assert_initialized!();
2277
2278        match value {
2279            ffi::GST_WEBRTC_STATS_CODEC => Self::Codec,
2280            ffi::GST_WEBRTC_STATS_INBOUND_RTP => Self::InboundRtp,
2281            ffi::GST_WEBRTC_STATS_OUTBOUND_RTP => Self::OutboundRtp,
2282            ffi::GST_WEBRTC_STATS_REMOTE_INBOUND_RTP => Self::RemoteInboundRtp,
2283            ffi::GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP => Self::RemoteOutboundRtp,
2284            ffi::GST_WEBRTC_STATS_CSRC => Self::Csrc,
2285            ffi::GST_WEBRTC_STATS_PEER_CONNECTION => Self::PeerConnection,
2286            ffi::GST_WEBRTC_STATS_DATA_CHANNEL => Self::DataChannel,
2287            ffi::GST_WEBRTC_STATS_STREAM => Self::Stream,
2288            ffi::GST_WEBRTC_STATS_TRANSPORT => Self::Transport,
2289            ffi::GST_WEBRTC_STATS_CANDIDATE_PAIR => Self::CandidatePair,
2290            ffi::GST_WEBRTC_STATS_LOCAL_CANDIDATE => Self::LocalCandidate,
2291            ffi::GST_WEBRTC_STATS_REMOTE_CANDIDATE => Self::RemoteCandidate,
2292            ffi::GST_WEBRTC_STATS_CERTIFICATE => Self::Certificate,
2293            value => Self::__Unknown(value),
2294        }
2295    }
2296}
2297
2298impl StaticType for WebRTCStatsType {
2299    #[inline]
2300    #[doc(alias = "gst_webrtc_stats_type_get_type")]
2301    fn static_type() -> glib::Type {
2302        unsafe { from_glib(ffi::gst_webrtc_stats_type_get_type()) }
2303    }
2304}
2305
2306impl glib::HasParamSpec for WebRTCStatsType {
2307    type ParamSpec = glib::ParamSpecEnum;
2308    type SetValue = Self;
2309    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2310
2311    fn param_spec_builder() -> Self::BuilderFn {
2312        Self::ParamSpec::builder_with_default
2313    }
2314}
2315
2316impl glib::value::ValueType for WebRTCStatsType {
2317    type Type = Self;
2318}
2319
2320unsafe impl<'a> glib::value::FromValue<'a> for WebRTCStatsType {
2321    type Checker = glib::value::GenericValueTypeChecker<Self>;
2322
2323    #[inline]
2324    unsafe fn from_value(value: &'a glib::Value) -> Self {
2325        skip_assert_initialized!();
2326        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2327    }
2328}
2329
2330impl ToValue for WebRTCStatsType {
2331    #[inline]
2332    fn to_value(&self) -> glib::Value {
2333        let mut value = glib::Value::for_value_type::<Self>();
2334        unsafe {
2335            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2336        }
2337        value
2338    }
2339
2340    #[inline]
2341    fn value_type(&self) -> glib::Type {
2342        Self::static_type()
2343    }
2344}
2345
2346impl From<WebRTCStatsType> for glib::Value {
2347    #[inline]
2348    fn from(v: WebRTCStatsType) -> Self {
2349        skip_assert_initialized!();
2350        ToValue::to_value(&v)
2351    }
2352}
gstreamer_webrtc/auto/enums.rs

gstreamer_webrtc/auto/
enums.rs
