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