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, EventTypeFlags};
7use glib::{prelude::*, translate::*, GStr};
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "GstBufferingMode")]
12pub enum BufferingMode {
13 #[doc(alias = "GST_BUFFERING_STREAM")]
14 Stream,
15 #[doc(alias = "GST_BUFFERING_DOWNLOAD")]
16 Download,
17 #[doc(alias = "GST_BUFFERING_TIMESHIFT")]
18 Timeshift,
19 #[doc(alias = "GST_BUFFERING_LIVE")]
20 Live,
21 #[doc(hidden)]
22 __Unknown(i32),
23}
24
25#[doc(hidden)]
26impl IntoGlib for BufferingMode {
27 type GlibType = ffi::GstBufferingMode;
28
29 #[inline]
30 fn into_glib(self) -> ffi::GstBufferingMode {
31 match self {
32 Self::Stream => ffi::GST_BUFFERING_STREAM,
33 Self::Download => ffi::GST_BUFFERING_DOWNLOAD,
34 Self::Timeshift => ffi::GST_BUFFERING_TIMESHIFT,
35 Self::Live => ffi::GST_BUFFERING_LIVE,
36 Self::__Unknown(value: i32) => value,
37 }
38 }
39}
40
41#[doc(hidden)]
42impl FromGlib<ffi::GstBufferingMode> for BufferingMode {
43 #[inline]
44 unsafe fn from_glib(value: ffi::GstBufferingMode) -> Self {
45 skip_assert_initialized!();
46
47 match value {
48 ffi::GST_BUFFERING_STREAM => Self::Stream,
49 ffi::GST_BUFFERING_DOWNLOAD => Self::Download,
50 ffi::GST_BUFFERING_TIMESHIFT => Self::Timeshift,
51 ffi::GST_BUFFERING_LIVE => Self::Live,
52 value: i32 => Self::__Unknown(value),
53 }
54 }
55}
56
57impl StaticType for BufferingMode {
58 #[inline]
59 #[doc(alias = "gst_buffering_mode_get_type")]
60 fn static_type() -> glib::Type {
61 unsafe { from_glib(val:ffi::gst_buffering_mode_get_type()) }
62 }
63}
64
65impl glib::HasParamSpec for BufferingMode {
66 type ParamSpec = glib::ParamSpecEnum;
67 type SetValue = Self;
68 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
69
70 fn param_spec_builder() -> Self::BuilderFn {
71 Self::ParamSpec::builder_with_default
72 }
73}
74
75impl glib::value::ValueType for BufferingMode {
76 type Type = Self;
77}
78
79unsafe impl<'a> glib::value::FromValue<'a> for BufferingMode {
80 type Checker = glib::value::GenericValueTypeChecker<Self>;
81
82 #[inline]
83 unsafe fn from_value(value: &'a glib::Value) -> Self {
84 skip_assert_initialized!();
85 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
86 }
87}
88
89impl ToValue for BufferingMode {
90 #[inline]
91 fn to_value(&self) -> glib::Value {
92 let mut value: Value = glib::Value::for_value_type::<Self>();
93 unsafe {
94 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
95 }
96 value
97 }
98
99 #[inline]
100 fn value_type(&self) -> glib::Type {
101 Self::static_type()
102 }
103}
104
105impl From<BufferingMode> for glib::Value {
106 #[inline]
107 fn from(v: BufferingMode) -> Self {
108 skip_assert_initialized!();
109 ToValue::to_value(&v)
110 }
111}
112
113#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
114#[repr(i32)]
115#[doc(alias = "GstBusSyncReply")]
116pub enum BusSyncReply {
117 #[doc(alias = "GST_BUS_DROP")]
118 Drop = ffi::GST_BUS_DROP,
119 #[doc(alias = "GST_BUS_PASS")]
120 Pass = ffi::GST_BUS_PASS,
121 #[doc(alias = "GST_BUS_ASYNC")]
122 Async = ffi::GST_BUS_ASYNC,
123}
124
125#[doc(hidden)]
126impl IntoGlib for BusSyncReply {
127 type GlibType = ffi::GstBusSyncReply;
128
129 #[inline]
130 fn into_glib(self) -> ffi::GstBusSyncReply {
131 self as ffi::GstBusSyncReply
132 }
133}
134
135#[doc(hidden)]
136impl FromGlib<ffi::GstBusSyncReply> for BusSyncReply {
137 #[inline]
138 unsafe fn from_glib(value: ffi::GstBusSyncReply) -> Self {
139 skip_assert_initialized!();
140
141 debug_assert!([ffi::GST_BUS_DROP, ffi::GST_BUS_PASS, ffi::GST_BUS_ASYNC].contains(&value));
142 std::mem::transmute(src:value)
143 }
144}
145
146impl StaticType for BusSyncReply {
147 #[inline]
148 #[doc(alias = "gst_bus_sync_reply_get_type")]
149 fn static_type() -> glib::Type {
150 unsafe { from_glib(val:ffi::gst_bus_sync_reply_get_type()) }
151 }
152}
153
154impl glib::HasParamSpec for BusSyncReply {
155 type ParamSpec = glib::ParamSpecEnum;
156 type SetValue = Self;
157 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
158
159 fn param_spec_builder() -> Self::BuilderFn {
160 Self::ParamSpec::builder_with_default
161 }
162}
163
164impl glib::value::ValueType for BusSyncReply {
165 type Type = Self;
166}
167
168unsafe impl<'a> glib::value::FromValue<'a> for BusSyncReply {
169 type Checker = glib::value::GenericValueTypeChecker<Self>;
170
171 #[inline]
172 unsafe fn from_value(value: &'a glib::Value) -> Self {
173 skip_assert_initialized!();
174 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
175 }
176}
177
178impl ToValue for BusSyncReply {
179 #[inline]
180 fn to_value(&self) -> glib::Value {
181 let mut value: Value = glib::Value::for_value_type::<Self>();
182 unsafe {
183 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
184 }
185 value
186 }
187
188 #[inline]
189 fn value_type(&self) -> glib::Type {
190 Self::static_type()
191 }
192}
193
194impl From<BusSyncReply> for glib::Value {
195 #[inline]
196 fn from(v: BusSyncReply) -> Self {
197 skip_assert_initialized!();
198 ToValue::to_value(&v)
199 }
200}
201
202#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
203#[non_exhaustive]
204#[doc(alias = "GstCapsIntersectMode")]
205pub enum CapsIntersectMode {
206 #[doc(alias = "GST_CAPS_INTERSECT_ZIG_ZAG")]
207 ZigZag,
208 #[doc(alias = "GST_CAPS_INTERSECT_FIRST")]
209 First,
210 #[doc(hidden)]
211 __Unknown(i32),
212}
213
214#[doc(hidden)]
215impl IntoGlib for CapsIntersectMode {
216 type GlibType = ffi::GstCapsIntersectMode;
217
218 #[inline]
219 fn into_glib(self) -> ffi::GstCapsIntersectMode {
220 match self {
221 Self::ZigZag => ffi::GST_CAPS_INTERSECT_ZIG_ZAG,
222 Self::First => ffi::GST_CAPS_INTERSECT_FIRST,
223 Self::__Unknown(value: i32) => value,
224 }
225 }
226}
227
228#[doc(hidden)]
229impl FromGlib<ffi::GstCapsIntersectMode> for CapsIntersectMode {
230 #[inline]
231 unsafe fn from_glib(value: ffi::GstCapsIntersectMode) -> Self {
232 skip_assert_initialized!();
233
234 match value {
235 ffi::GST_CAPS_INTERSECT_ZIG_ZAG => Self::ZigZag,
236 ffi::GST_CAPS_INTERSECT_FIRST => Self::First,
237 value: i32 => Self::__Unknown(value),
238 }
239 }
240}
241
242impl StaticType for CapsIntersectMode {
243 #[inline]
244 #[doc(alias = "gst_caps_intersect_mode_get_type")]
245 fn static_type() -> glib::Type {
246 unsafe { from_glib(val:ffi::gst_caps_intersect_mode_get_type()) }
247 }
248}
249
250impl glib::HasParamSpec for CapsIntersectMode {
251 type ParamSpec = glib::ParamSpecEnum;
252 type SetValue = Self;
253 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
254
255 fn param_spec_builder() -> Self::BuilderFn {
256 Self::ParamSpec::builder_with_default
257 }
258}
259
260impl glib::value::ValueType for CapsIntersectMode {
261 type Type = Self;
262}
263
264unsafe impl<'a> glib::value::FromValue<'a> for CapsIntersectMode {
265 type Checker = glib::value::GenericValueTypeChecker<Self>;
266
267 #[inline]
268 unsafe fn from_value(value: &'a glib::Value) -> Self {
269 skip_assert_initialized!();
270 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
271 }
272}
273
274impl ToValue for CapsIntersectMode {
275 #[inline]
276 fn to_value(&self) -> glib::Value {
277 let mut value: Value = glib::Value::for_value_type::<Self>();
278 unsafe {
279 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
280 }
281 value
282 }
283
284 #[inline]
285 fn value_type(&self) -> glib::Type {
286 Self::static_type()
287 }
288}
289
290impl From<CapsIntersectMode> for glib::Value {
291 #[inline]
292 fn from(v: CapsIntersectMode) -> Self {
293 skip_assert_initialized!();
294 ToValue::to_value(&v)
295 }
296}
297
298#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
299#[non_exhaustive]
300#[doc(alias = "GstClockEntryType")]
301pub enum ClockEntryType {
302 #[doc(alias = "GST_CLOCK_ENTRY_SINGLE")]
303 Single,
304 #[doc(alias = "GST_CLOCK_ENTRY_PERIODIC")]
305 Periodic,
306 #[doc(hidden)]
307 __Unknown(i32),
308}
309
310#[doc(hidden)]
311impl IntoGlib for ClockEntryType {
312 type GlibType = ffi::GstClockEntryType;
313
314 #[inline]
315 fn into_glib(self) -> ffi::GstClockEntryType {
316 match self {
317 Self::Single => ffi::GST_CLOCK_ENTRY_SINGLE,
318 Self::Periodic => ffi::GST_CLOCK_ENTRY_PERIODIC,
319 Self::__Unknown(value: i32) => value,
320 }
321 }
322}
323
324#[doc(hidden)]
325impl FromGlib<ffi::GstClockEntryType> for ClockEntryType {
326 #[inline]
327 unsafe fn from_glib(value: ffi::GstClockEntryType) -> Self {
328 skip_assert_initialized!();
329
330 match value {
331 ffi::GST_CLOCK_ENTRY_SINGLE => Self::Single,
332 ffi::GST_CLOCK_ENTRY_PERIODIC => Self::Periodic,
333 value: i32 => Self::__Unknown(value),
334 }
335 }
336}
337
338impl StaticType for ClockEntryType {
339 #[inline]
340 #[doc(alias = "gst_clock_entry_type_get_type")]
341 fn static_type() -> glib::Type {
342 unsafe { from_glib(val:ffi::gst_clock_entry_type_get_type()) }
343 }
344}
345
346impl glib::HasParamSpec for ClockEntryType {
347 type ParamSpec = glib::ParamSpecEnum;
348 type SetValue = Self;
349 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
350
351 fn param_spec_builder() -> Self::BuilderFn {
352 Self::ParamSpec::builder_with_default
353 }
354}
355
356impl glib::value::ValueType for ClockEntryType {
357 type Type = Self;
358}
359
360unsafe impl<'a> glib::value::FromValue<'a> for ClockEntryType {
361 type Checker = glib::value::GenericValueTypeChecker<Self>;
362
363 #[inline]
364 unsafe fn from_value(value: &'a glib::Value) -> Self {
365 skip_assert_initialized!();
366 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
367 }
368}
369
370impl ToValue for ClockEntryType {
371 #[inline]
372 fn to_value(&self) -> glib::Value {
373 let mut value: Value = glib::Value::for_value_type::<Self>();
374 unsafe {
375 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
376 }
377 value
378 }
379
380 #[inline]
381 fn value_type(&self) -> glib::Type {
382 Self::static_type()
383 }
384}
385
386impl From<ClockEntryType> for glib::Value {
387 #[inline]
388 fn from(v: ClockEntryType) -> Self {
389 skip_assert_initialized!();
390 ToValue::to_value(&v)
391 }
392}
393
394#[must_use]
395#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
396#[repr(i32)]
397#[doc(alias = "GstClockReturn")]
398pub enum ClockReturn {
399 #[doc(alias = "GST_CLOCK_OK")]
400 Ok = ffi::GST_CLOCK_OK,
401 #[doc(alias = "GST_CLOCK_EARLY")]
402 Early = ffi::GST_CLOCK_EARLY,
403 #[doc(alias = "GST_CLOCK_UNSCHEDULED")]
404 Unscheduled = ffi::GST_CLOCK_UNSCHEDULED,
405 #[doc(alias = "GST_CLOCK_BUSY")]
406 Busy = ffi::GST_CLOCK_BUSY,
407 #[doc(alias = "GST_CLOCK_BADTIME")]
408 Badtime = ffi::GST_CLOCK_BADTIME,
409 #[doc(alias = "GST_CLOCK_ERROR")]
410 Error = ffi::GST_CLOCK_ERROR,
411 #[doc(alias = "GST_CLOCK_UNSUPPORTED")]
412 Unsupported = ffi::GST_CLOCK_UNSUPPORTED,
413 #[doc(alias = "GST_CLOCK_DONE")]
414 Done = ffi::GST_CLOCK_DONE,
415}
416
417#[doc(hidden)]
418impl IntoGlib for ClockReturn {
419 type GlibType = ffi::GstClockReturn;
420
421 #[inline]
422 fn into_glib(self) -> ffi::GstClockReturn {
423 self as ffi::GstClockReturn
424 }
425}
426
427#[doc(hidden)]
428impl FromGlib<ffi::GstClockReturn> for ClockReturn {
429 #[inline]
430 unsafe fn from_glib(value: ffi::GstClockReturn) -> Self {
431 skip_assert_initialized!();
432
433 debug_assert!([
434 ffi::GST_CLOCK_OK,
435 ffi::GST_CLOCK_EARLY,
436 ffi::GST_CLOCK_UNSCHEDULED,
437 ffi::GST_CLOCK_BUSY,
438 ffi::GST_CLOCK_BADTIME,
439 ffi::GST_CLOCK_ERROR,
440 ffi::GST_CLOCK_UNSUPPORTED,
441 ffi::GST_CLOCK_DONE
442 ]
443 .contains(&value));
444 std::mem::transmute(src:value)
445 }
446}
447
448impl StaticType for ClockReturn {
449 #[inline]
450 #[doc(alias = "gst_clock_return_get_type")]
451 fn static_type() -> glib::Type {
452 unsafe { from_glib(val:ffi::gst_clock_return_get_type()) }
453 }
454}
455
456impl glib::HasParamSpec for ClockReturn {
457 type ParamSpec = glib::ParamSpecEnum;
458 type SetValue = Self;
459 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
460
461 fn param_spec_builder() -> Self::BuilderFn {
462 Self::ParamSpec::builder_with_default
463 }
464}
465
466impl glib::value::ValueType for ClockReturn {
467 type Type = Self;
468}
469
470unsafe impl<'a> glib::value::FromValue<'a> for ClockReturn {
471 type Checker = glib::value::GenericValueTypeChecker<Self>;
472
473 #[inline]
474 unsafe fn from_value(value: &'a glib::Value) -> Self {
475 skip_assert_initialized!();
476 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
477 }
478}
479
480impl ToValue for ClockReturn {
481 #[inline]
482 fn to_value(&self) -> glib::Value {
483 let mut value: Value = glib::Value::for_value_type::<Self>();
484 unsafe {
485 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
486 }
487 value
488 }
489
490 #[inline]
491 fn value_type(&self) -> glib::Type {
492 Self::static_type()
493 }
494}
495
496impl From<ClockReturn> for glib::Value {
497 #[inline]
498 fn from(v: ClockReturn) -> Self {
499 skip_assert_initialized!();
500 ToValue::to_value(&v)
501 }
502}
503
504#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
505#[non_exhaustive]
506#[doc(alias = "GstClockType")]
507pub enum ClockType {
508 #[doc(alias = "GST_CLOCK_TYPE_REALTIME")]
509 Realtime,
510 #[doc(alias = "GST_CLOCK_TYPE_MONOTONIC")]
511 Monotonic,
512 #[doc(alias = "GST_CLOCK_TYPE_OTHER")]
513 Other,
514 #[cfg(feature = "v1_18")]
515 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
516 #[doc(alias = "GST_CLOCK_TYPE_TAI")]
517 Tai,
518 #[doc(hidden)]
519 __Unknown(i32),
520}
521
522#[doc(hidden)]
523impl IntoGlib for ClockType {
524 type GlibType = ffi::GstClockType;
525
526 #[inline]
527 fn into_glib(self) -> ffi::GstClockType {
528 match self {
529 Self::Realtime => ffi::GST_CLOCK_TYPE_REALTIME,
530 Self::Monotonic => ffi::GST_CLOCK_TYPE_MONOTONIC,
531 Self::Other => ffi::GST_CLOCK_TYPE_OTHER,
532 #[cfg(feature = "v1_18")]
533 Self::Tai => ffi::GST_CLOCK_TYPE_TAI,
534 Self::__Unknown(value: i32) => value,
535 }
536 }
537}
538
539#[doc(hidden)]
540impl FromGlib<ffi::GstClockType> for ClockType {
541 #[inline]
542 unsafe fn from_glib(value: ffi::GstClockType) -> Self {
543 skip_assert_initialized!();
544
545 match value {
546 ffi::GST_CLOCK_TYPE_REALTIME => Self::Realtime,
547 ffi::GST_CLOCK_TYPE_MONOTONIC => Self::Monotonic,
548 ffi::GST_CLOCK_TYPE_OTHER => Self::Other,
549 #[cfg(feature = "v1_18")]
550 ffi::GST_CLOCK_TYPE_TAI => Self::Tai,
551 value: i32 => Self::__Unknown(value),
552 }
553 }
554}
555
556impl StaticType for ClockType {
557 #[inline]
558 #[doc(alias = "gst_clock_type_get_type")]
559 fn static_type() -> glib::Type {
560 unsafe { from_glib(val:ffi::gst_clock_type_get_type()) }
561 }
562}
563
564impl glib::HasParamSpec for ClockType {
565 type ParamSpec = glib::ParamSpecEnum;
566 type SetValue = Self;
567 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
568
569 fn param_spec_builder() -> Self::BuilderFn {
570 Self::ParamSpec::builder_with_default
571 }
572}
573
574impl glib::value::ValueType for ClockType {
575 type Type = Self;
576}
577
578unsafe impl<'a> glib::value::FromValue<'a> for ClockType {
579 type Checker = glib::value::GenericValueTypeChecker<Self>;
580
581 #[inline]
582 unsafe fn from_value(value: &'a glib::Value) -> Self {
583 skip_assert_initialized!();
584 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
585 }
586}
587
588impl ToValue for ClockType {
589 #[inline]
590 fn to_value(&self) -> glib::Value {
591 let mut value: Value = glib::Value::for_value_type::<Self>();
592 unsafe {
593 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
594 }
595 value
596 }
597
598 #[inline]
599 fn value_type(&self) -> glib::Type {
600 Self::static_type()
601 }
602}
603
604impl From<ClockType> for glib::Value {
605 #[inline]
606 fn from(v: ClockType) -> Self {
607 skip_assert_initialized!();
608 ToValue::to_value(&v)
609 }
610}
611
612#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
613#[non_exhaustive]
614#[doc(alias = "GstCoreError")]
615pub enum CoreError {
616 #[doc(alias = "GST_CORE_ERROR_FAILED")]
617 Failed,
618 #[doc(alias = "GST_CORE_ERROR_TOO_LAZY")]
619 TooLazy,
620 #[doc(alias = "GST_CORE_ERROR_NOT_IMPLEMENTED")]
621 NotImplemented,
622 #[doc(alias = "GST_CORE_ERROR_STATE_CHANGE")]
623 StateChange,
624 #[doc(alias = "GST_CORE_ERROR_PAD")]
625 Pad,
626 #[doc(alias = "GST_CORE_ERROR_THREAD")]
627 Thread,
628 #[doc(alias = "GST_CORE_ERROR_NEGOTIATION")]
629 Negotiation,
630 #[doc(alias = "GST_CORE_ERROR_EVENT")]
631 Event,
632 #[doc(alias = "GST_CORE_ERROR_SEEK")]
633 Seek,
634 #[doc(alias = "GST_CORE_ERROR_CAPS")]
635 Caps,
636 #[doc(alias = "GST_CORE_ERROR_TAG")]
637 Tag,
638 #[doc(alias = "GST_CORE_ERROR_MISSING_PLUGIN")]
639 MissingPlugin,
640 #[doc(alias = "GST_CORE_ERROR_CLOCK")]
641 Clock,
642 #[doc(alias = "GST_CORE_ERROR_DISABLED")]
643 Disabled,
644 #[doc(hidden)]
645 __Unknown(i32),
646}
647
648#[doc(hidden)]
649impl IntoGlib for CoreError {
650 type GlibType = ffi::GstCoreError;
651
652 fn into_glib(self) -> ffi::GstCoreError {
653 match self {
654 Self::Failed => ffi::GST_CORE_ERROR_FAILED,
655 Self::TooLazy => ffi::GST_CORE_ERROR_TOO_LAZY,
656 Self::NotImplemented => ffi::GST_CORE_ERROR_NOT_IMPLEMENTED,
657 Self::StateChange => ffi::GST_CORE_ERROR_STATE_CHANGE,
658 Self::Pad => ffi::GST_CORE_ERROR_PAD,
659 Self::Thread => ffi::GST_CORE_ERROR_THREAD,
660 Self::Negotiation => ffi::GST_CORE_ERROR_NEGOTIATION,
661 Self::Event => ffi::GST_CORE_ERROR_EVENT,
662 Self::Seek => ffi::GST_CORE_ERROR_SEEK,
663 Self::Caps => ffi::GST_CORE_ERROR_CAPS,
664 Self::Tag => ffi::GST_CORE_ERROR_TAG,
665 Self::MissingPlugin => ffi::GST_CORE_ERROR_MISSING_PLUGIN,
666 Self::Clock => ffi::GST_CORE_ERROR_CLOCK,
667 Self::Disabled => ffi::GST_CORE_ERROR_DISABLED,
668 Self::__Unknown(value: i32) => value,
669 }
670 }
671}
672
673#[doc(hidden)]
674impl FromGlib<ffi::GstCoreError> for CoreError {
675 unsafe fn from_glib(value: ffi::GstCoreError) -> Self {
676 skip_assert_initialized!();
677
678 match value {
679 ffi::GST_CORE_ERROR_FAILED => Self::Failed,
680 ffi::GST_CORE_ERROR_TOO_LAZY => Self::TooLazy,
681 ffi::GST_CORE_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
682 ffi::GST_CORE_ERROR_STATE_CHANGE => Self::StateChange,
683 ffi::GST_CORE_ERROR_PAD => Self::Pad,
684 ffi::GST_CORE_ERROR_THREAD => Self::Thread,
685 ffi::GST_CORE_ERROR_NEGOTIATION => Self::Negotiation,
686 ffi::GST_CORE_ERROR_EVENT => Self::Event,
687 ffi::GST_CORE_ERROR_SEEK => Self::Seek,
688 ffi::GST_CORE_ERROR_CAPS => Self::Caps,
689 ffi::GST_CORE_ERROR_TAG => Self::Tag,
690 ffi::GST_CORE_ERROR_MISSING_PLUGIN => Self::MissingPlugin,
691 ffi::GST_CORE_ERROR_CLOCK => Self::Clock,
692 ffi::GST_CORE_ERROR_DISABLED => Self::Disabled,
693 value: i32 => Self::__Unknown(value),
694 }
695 }
696}
697
698impl glib::error::ErrorDomain for CoreError {
699 #[inline]
700 fn domain() -> glib::Quark {
701 skip_assert_initialized!();
702
703 unsafe { from_glib(val:ffi::gst_core_error_quark()) }
704 }
705
706 #[inline]
707 fn code(self) -> i32 {
708 self.into_glib()
709 }
710
711 #[inline]
712 #[allow(clippy::match_single_binding)]
713 fn from(code: i32) -> Option<Self> {
714 skip_assert_initialized!();
715 match unsafe { from_glib(val:code) } {
716 Self::__Unknown(_) => Some(Self::Failed),
717 value: CoreError => Some(value),
718 }
719 }
720}
721
722impl StaticType for CoreError {
723 #[inline]
724 #[doc(alias = "gst_core_error_get_type")]
725 fn static_type() -> glib::Type {
726 unsafe { from_glib(val:ffi::gst_core_error_get_type()) }
727 }
728}
729
730impl glib::HasParamSpec for CoreError {
731 type ParamSpec = glib::ParamSpecEnum;
732 type SetValue = Self;
733 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
734
735 fn param_spec_builder() -> Self::BuilderFn {
736 Self::ParamSpec::builder_with_default
737 }
738}
739
740impl glib::value::ValueType for CoreError {
741 type Type = Self;
742}
743
744unsafe impl<'a> glib::value::FromValue<'a> for CoreError {
745 type Checker = glib::value::GenericValueTypeChecker<Self>;
746
747 #[inline]
748 unsafe fn from_value(value: &'a glib::Value) -> Self {
749 skip_assert_initialized!();
750 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
751 }
752}
753
754impl ToValue for CoreError {
755 #[inline]
756 fn to_value(&self) -> glib::Value {
757 let mut value: Value = glib::Value::for_value_type::<Self>();
758 unsafe {
759 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
760 }
761 value
762 }
763
764 #[inline]
765 fn value_type(&self) -> glib::Type {
766 Self::static_type()
767 }
768}
769
770impl From<CoreError> for glib::Value {
771 #[inline]
772 fn from(v: CoreError) -> Self {
773 skip_assert_initialized!();
774 ToValue::to_value(&v)
775 }
776}
777
778#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
779#[non_exhaustive]
780#[doc(alias = "GstDebugLevel")]
781pub enum DebugLevel {
782 #[doc(alias = "GST_LEVEL_NONE")]
783 None,
784 #[doc(alias = "GST_LEVEL_ERROR")]
785 Error,
786 #[doc(alias = "GST_LEVEL_WARNING")]
787 Warning,
788 #[doc(alias = "GST_LEVEL_FIXME")]
789 Fixme,
790 #[doc(alias = "GST_LEVEL_INFO")]
791 Info,
792 #[doc(alias = "GST_LEVEL_DEBUG")]
793 Debug,
794 #[doc(alias = "GST_LEVEL_LOG")]
795 Log,
796 #[doc(alias = "GST_LEVEL_TRACE")]
797 Trace,
798 #[doc(alias = "GST_LEVEL_MEMDUMP")]
799 Memdump,
800 #[doc(hidden)]
801 __Unknown(i32),
802}
803
804impl DebugLevel {
805 pub fn name<'a>(self) -> &'a GStr {
806 unsafe {
807 GStr::from_ptr(
808 ffi::gst_debug_level_get_name(self.into_glib())
809 .as_ref()
810 .expect(msg:"gst_debug_level_get_name returned NULL"),
811 )
812 }
813 }
814}
815
816impl std::fmt::Display for DebugLevel {
817 #[inline]
818 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
819 f.write_str(&self.name())
820 }
821}
822
823#[doc(hidden)]
824impl IntoGlib for DebugLevel {
825 type GlibType = ffi::GstDebugLevel;
826
827 #[inline]
828 fn into_glib(self) -> ffi::GstDebugLevel {
829 match self {
830 Self::None => ffi::GST_LEVEL_NONE,
831 Self::Error => ffi::GST_LEVEL_ERROR,
832 Self::Warning => ffi::GST_LEVEL_WARNING,
833 Self::Fixme => ffi::GST_LEVEL_FIXME,
834 Self::Info => ffi::GST_LEVEL_INFO,
835 Self::Debug => ffi::GST_LEVEL_DEBUG,
836 Self::Log => ffi::GST_LEVEL_LOG,
837 Self::Trace => ffi::GST_LEVEL_TRACE,
838 Self::Memdump => ffi::GST_LEVEL_MEMDUMP,
839 Self::__Unknown(value: i32) => value,
840 }
841 }
842}
843
844#[doc(hidden)]
845impl FromGlib<ffi::GstDebugLevel> for DebugLevel {
846 #[inline]
847 unsafe fn from_glib(value: ffi::GstDebugLevel) -> Self {
848 skip_assert_initialized!();
849
850 match value {
851 ffi::GST_LEVEL_NONE => Self::None,
852 ffi::GST_LEVEL_ERROR => Self::Error,
853 ffi::GST_LEVEL_WARNING => Self::Warning,
854 ffi::GST_LEVEL_FIXME => Self::Fixme,
855 ffi::GST_LEVEL_INFO => Self::Info,
856 ffi::GST_LEVEL_DEBUG => Self::Debug,
857 ffi::GST_LEVEL_LOG => Self::Log,
858 ffi::GST_LEVEL_TRACE => Self::Trace,
859 ffi::GST_LEVEL_MEMDUMP => Self::Memdump,
860 value: i32 => Self::__Unknown(value),
861 }
862 }
863}
864
865impl StaticType for DebugLevel {
866 #[inline]
867 #[doc(alias = "gst_debug_level_get_type")]
868 fn static_type() -> glib::Type {
869 unsafe { from_glib(val:ffi::gst_debug_level_get_type()) }
870 }
871}
872
873impl glib::HasParamSpec for DebugLevel {
874 type ParamSpec = glib::ParamSpecEnum;
875 type SetValue = Self;
876 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
877
878 fn param_spec_builder() -> Self::BuilderFn {
879 Self::ParamSpec::builder_with_default
880 }
881}
882
883impl glib::value::ValueType for DebugLevel {
884 type Type = Self;
885}
886
887unsafe impl<'a> glib::value::FromValue<'a> for DebugLevel {
888 type Checker = glib::value::GenericValueTypeChecker<Self>;
889
890 #[inline]
891 unsafe fn from_value(value: &'a glib::Value) -> Self {
892 skip_assert_initialized!();
893 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
894 }
895}
896
897impl ToValue for DebugLevel {
898 #[inline]
899 fn to_value(&self) -> glib::Value {
900 let mut value: Value = glib::Value::for_value_type::<Self>();
901 unsafe {
902 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
903 }
904 value
905 }
906
907 #[inline]
908 fn value_type(&self) -> glib::Type {
909 Self::static_type()
910 }
911}
912
913impl From<DebugLevel> for glib::Value {
914 #[inline]
915 fn from(v: DebugLevel) -> Self {
916 skip_assert_initialized!();
917 ToValue::to_value(&v)
918 }
919}
920
921#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
922#[non_exhaustive]
923#[doc(alias = "GstEventType")]
924pub enum EventType {
925 #[doc(alias = "GST_EVENT_UNKNOWN")]
926 Unknown,
927 #[doc(alias = "GST_EVENT_FLUSH_START")]
928 FlushStart,
929 #[doc(alias = "GST_EVENT_FLUSH_STOP")]
930 FlushStop,
931 #[doc(alias = "GST_EVENT_STREAM_START")]
932 StreamStart,
933 #[doc(alias = "GST_EVENT_CAPS")]
934 Caps,
935 #[doc(alias = "GST_EVENT_SEGMENT")]
936 Segment,
937 #[doc(alias = "GST_EVENT_STREAM_COLLECTION")]
938 StreamCollection,
939 #[doc(alias = "GST_EVENT_TAG")]
940 Tag,
941 #[doc(alias = "GST_EVENT_BUFFERSIZE")]
942 Buffersize,
943 #[doc(alias = "GST_EVENT_SINK_MESSAGE")]
944 SinkMessage,
945 #[doc(alias = "GST_EVENT_STREAM_GROUP_DONE")]
946 StreamGroupDone,
947 #[doc(alias = "GST_EVENT_EOS")]
948 Eos,
949 #[doc(alias = "GST_EVENT_TOC")]
950 Toc,
951 #[doc(alias = "GST_EVENT_PROTECTION")]
952 Protection,
953 #[doc(alias = "GST_EVENT_SEGMENT_DONE")]
954 SegmentDone,
955 #[doc(alias = "GST_EVENT_GAP")]
956 Gap,
957 #[cfg(feature = "v1_18")]
958 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
959 #[doc(alias = "GST_EVENT_INSTANT_RATE_CHANGE")]
960 InstantRateChange,
961 #[doc(alias = "GST_EVENT_QOS")]
962 Qos,
963 #[doc(alias = "GST_EVENT_SEEK")]
964 Seek,
965 #[doc(alias = "GST_EVENT_NAVIGATION")]
966 Navigation,
967 #[doc(alias = "GST_EVENT_LATENCY")]
968 Latency,
969 #[doc(alias = "GST_EVENT_STEP")]
970 Step,
971 #[doc(alias = "GST_EVENT_RECONFIGURE")]
972 Reconfigure,
973 #[doc(alias = "GST_EVENT_TOC_SELECT")]
974 TocSelect,
975 #[doc(alias = "GST_EVENT_SELECT_STREAMS")]
976 SelectStreams,
977 #[cfg(feature = "v1_18")]
978 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
979 #[doc(alias = "GST_EVENT_INSTANT_RATE_SYNC_TIME")]
980 InstantRateSyncTime,
981 #[doc(alias = "GST_EVENT_CUSTOM_UPSTREAM")]
982 CustomUpstream,
983 #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM")]
984 CustomDownstream,
985 #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_OOB")]
986 CustomDownstreamOob,
987 #[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_STICKY")]
988 CustomDownstreamSticky,
989 #[doc(alias = "GST_EVENT_CUSTOM_BOTH")]
990 CustomBoth,
991 #[doc(alias = "GST_EVENT_CUSTOM_BOTH_OOB")]
992 CustomBothOob,
993 #[doc(hidden)]
994 __Unknown(i32),
995}
996
997impl EventType {
998 #[doc(alias = "gst_event_type_get_flags")]
999 #[doc(alias = "get_flags")]
1000 pub fn flags(self) -> EventTypeFlags {
1001 assert_initialized_main_thread!();
1002 unsafe { from_glib(val:ffi::gst_event_type_get_flags(self.into_glib())) }
1003 }
1004
1005 pub fn name<'a>(self) -> &'a GStr {
1006 unsafe {
1007 GStr::from_ptr(
1008 ffi::gst_event_type_get_name(self.into_glib())
1009 .as_ref()
1010 .expect(msg:"gst_event_type_get_name returned NULL"),
1011 )
1012 }
1013 }
1014
1015 #[doc(alias = "gst_event_type_to_quark")]
1016 pub fn to_quark(self) -> glib::Quark {
1017 assert_initialized_main_thread!();
1018 unsafe { from_glib(val:ffi::gst_event_type_to_quark(self.into_glib())) }
1019 }
1020}
1021
1022impl std::fmt::Display for EventType {
1023 #[inline]
1024 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1025 f.write_str(&self.name())
1026 }
1027}
1028
1029#[doc(hidden)]
1030impl IntoGlib for EventType {
1031 type GlibType = ffi::GstEventType;
1032
1033 fn into_glib(self) -> ffi::GstEventType {
1034 match self {
1035 Self::Unknown => ffi::GST_EVENT_UNKNOWN,
1036 Self::FlushStart => ffi::GST_EVENT_FLUSH_START,
1037 Self::FlushStop => ffi::GST_EVENT_FLUSH_STOP,
1038 Self::StreamStart => ffi::GST_EVENT_STREAM_START,
1039 Self::Caps => ffi::GST_EVENT_CAPS,
1040 Self::Segment => ffi::GST_EVENT_SEGMENT,
1041 Self::StreamCollection => ffi::GST_EVENT_STREAM_COLLECTION,
1042 Self::Tag => ffi::GST_EVENT_TAG,
1043 Self::Buffersize => ffi::GST_EVENT_BUFFERSIZE,
1044 Self::SinkMessage => ffi::GST_EVENT_SINK_MESSAGE,
1045 Self::StreamGroupDone => ffi::GST_EVENT_STREAM_GROUP_DONE,
1046 Self::Eos => ffi::GST_EVENT_EOS,
1047 Self::Toc => ffi::GST_EVENT_TOC,
1048 Self::Protection => ffi::GST_EVENT_PROTECTION,
1049 Self::SegmentDone => ffi::GST_EVENT_SEGMENT_DONE,
1050 Self::Gap => ffi::GST_EVENT_GAP,
1051 #[cfg(feature = "v1_18")]
1052 Self::InstantRateChange => ffi::GST_EVENT_INSTANT_RATE_CHANGE,
1053 Self::Qos => ffi::GST_EVENT_QOS,
1054 Self::Seek => ffi::GST_EVENT_SEEK,
1055 Self::Navigation => ffi::GST_EVENT_NAVIGATION,
1056 Self::Latency => ffi::GST_EVENT_LATENCY,
1057 Self::Step => ffi::GST_EVENT_STEP,
1058 Self::Reconfigure => ffi::GST_EVENT_RECONFIGURE,
1059 Self::TocSelect => ffi::GST_EVENT_TOC_SELECT,
1060 Self::SelectStreams => ffi::GST_EVENT_SELECT_STREAMS,
1061 #[cfg(feature = "v1_18")]
1062 Self::InstantRateSyncTime => ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME,
1063 Self::CustomUpstream => ffi::GST_EVENT_CUSTOM_UPSTREAM,
1064 Self::CustomDownstream => ffi::GST_EVENT_CUSTOM_DOWNSTREAM,
1065 Self::CustomDownstreamOob => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB,
1066 Self::CustomDownstreamSticky => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY,
1067 Self::CustomBoth => ffi::GST_EVENT_CUSTOM_BOTH,
1068 Self::CustomBothOob => ffi::GST_EVENT_CUSTOM_BOTH_OOB,
1069 Self::__Unknown(value) => value,
1070 }
1071 }
1072}
1073
1074#[doc(hidden)]
1075impl FromGlib<ffi::GstEventType> for EventType {
1076 unsafe fn from_glib(value: ffi::GstEventType) -> Self {
1077 skip_assert_initialized!();
1078
1079 match value {
1080 ffi::GST_EVENT_UNKNOWN => Self::Unknown,
1081 ffi::GST_EVENT_FLUSH_START => Self::FlushStart,
1082 ffi::GST_EVENT_FLUSH_STOP => Self::FlushStop,
1083 ffi::GST_EVENT_STREAM_START => Self::StreamStart,
1084 ffi::GST_EVENT_CAPS => Self::Caps,
1085 ffi::GST_EVENT_SEGMENT => Self::Segment,
1086 ffi::GST_EVENT_STREAM_COLLECTION => Self::StreamCollection,
1087 ffi::GST_EVENT_TAG => Self::Tag,
1088 ffi::GST_EVENT_BUFFERSIZE => Self::Buffersize,
1089 ffi::GST_EVENT_SINK_MESSAGE => Self::SinkMessage,
1090 ffi::GST_EVENT_STREAM_GROUP_DONE => Self::StreamGroupDone,
1091 ffi::GST_EVENT_EOS => Self::Eos,
1092 ffi::GST_EVENT_TOC => Self::Toc,
1093 ffi::GST_EVENT_PROTECTION => Self::Protection,
1094 ffi::GST_EVENT_SEGMENT_DONE => Self::SegmentDone,
1095 ffi::GST_EVENT_GAP => Self::Gap,
1096 #[cfg(feature = "v1_18")]
1097 ffi::GST_EVENT_INSTANT_RATE_CHANGE => Self::InstantRateChange,
1098 ffi::GST_EVENT_QOS => Self::Qos,
1099 ffi::GST_EVENT_SEEK => Self::Seek,
1100 ffi::GST_EVENT_NAVIGATION => Self::Navigation,
1101 ffi::GST_EVENT_LATENCY => Self::Latency,
1102 ffi::GST_EVENT_STEP => Self::Step,
1103 ffi::GST_EVENT_RECONFIGURE => Self::Reconfigure,
1104 ffi::GST_EVENT_TOC_SELECT => Self::TocSelect,
1105 ffi::GST_EVENT_SELECT_STREAMS => Self::SelectStreams,
1106 #[cfg(feature = "v1_18")]
1107 ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME => Self::InstantRateSyncTime,
1108 ffi::GST_EVENT_CUSTOM_UPSTREAM => Self::CustomUpstream,
1109 ffi::GST_EVENT_CUSTOM_DOWNSTREAM => Self::CustomDownstream,
1110 ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB => Self::CustomDownstreamOob,
1111 ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY => Self::CustomDownstreamSticky,
1112 ffi::GST_EVENT_CUSTOM_BOTH => Self::CustomBoth,
1113 ffi::GST_EVENT_CUSTOM_BOTH_OOB => Self::CustomBothOob,
1114 value => Self::__Unknown(value),
1115 }
1116 }
1117}
1118
1119impl StaticType for EventType {
1120 #[inline]
1121 #[doc(alias = "gst_event_type_get_type")]
1122 fn static_type() -> glib::Type {
1123 unsafe { from_glib(val:ffi::gst_event_type_get_type()) }
1124 }
1125}
1126
1127impl glib::HasParamSpec for EventType {
1128 type ParamSpec = glib::ParamSpecEnum;
1129 type SetValue = Self;
1130 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1131
1132 fn param_spec_builder() -> Self::BuilderFn {
1133 Self::ParamSpec::builder_with_default
1134 }
1135}
1136
1137impl glib::value::ValueType for EventType {
1138 type Type = Self;
1139}
1140
1141unsafe impl<'a> glib::value::FromValue<'a> for EventType {
1142 type Checker = glib::value::GenericValueTypeChecker<Self>;
1143
1144 #[inline]
1145 unsafe fn from_value(value: &'a glib::Value) -> Self {
1146 skip_assert_initialized!();
1147 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1148 }
1149}
1150
1151impl ToValue for EventType {
1152 #[inline]
1153 fn to_value(&self) -> glib::Value {
1154 let mut value: Value = glib::Value::for_value_type::<Self>();
1155 unsafe {
1156 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1157 }
1158 value
1159 }
1160
1161 #[inline]
1162 fn value_type(&self) -> glib::Type {
1163 Self::static_type()
1164 }
1165}
1166
1167impl From<EventType> for glib::Value {
1168 #[inline]
1169 fn from(v: EventType) -> Self {
1170 skip_assert_initialized!();
1171 ToValue::to_value(&v)
1172 }
1173}
1174
1175#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1176#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
1177#[non_exhaustive]
1178#[doc(alias = "GstFormat")]
1179pub enum Format {
1180 #[doc(alias = "GST_FORMAT_UNDEFINED")]
1181 Undefined,
1182 #[doc(alias = "GST_FORMAT_DEFAULT")]
1183 Default,
1184 #[doc(alias = "GST_FORMAT_BYTES")]
1185 Bytes,
1186 #[doc(alias = "GST_FORMAT_TIME")]
1187 Time,
1188 #[doc(alias = "GST_FORMAT_BUFFERS")]
1189 Buffers,
1190 #[doc(alias = "GST_FORMAT_PERCENT")]
1191 Percent,
1192 #[doc(hidden)]
1193 __Unknown(i32),
1194}
1195
1196impl Format {
1197 #[doc(alias = "gst_format_get_by_nick")]
1198 #[doc(alias = "get_by_nick")]
1199 pub fn by_nick(nick: &str) -> Format {
1200 assert_initialized_main_thread!();
1201 unsafe { from_glib(ffi::gst_format_get_by_nick(nick.to_glib_none().0)) }
1202 }
1203
1204 //#[doc(alias = "gst_format_get_details")]
1205 //#[doc(alias = "get_details")]
1206 //pub fn details(self) -> /*Ignored*/Option<FormatDefinition> {
1207 // unsafe { TODO: call ffi:gst_format_get_details() }
1208 //}
1209
1210 #[doc(alias = "gst_format_get_name")]
1211 #[doc(alias = "get_name")]
1212 pub fn name(self) -> Option<glib::GString> {
1213 assert_initialized_main_thread!();
1214 unsafe { from_glib_none(ffi::gst_format_get_name(self.into_glib())) }
1215 }
1216
1217 //#[doc(alias = "gst_format_iterate_definitions")]
1218 //pub fn iterate_definitions() -> /*Ignored*/Iterator {
1219 // unsafe { TODO: call ffi:gst_format_iterate_definitions() }
1220 //}
1221
1222 #[doc(alias = "gst_format_to_quark")]
1223 pub fn to_quark(self) -> glib::Quark {
1224 assert_initialized_main_thread!();
1225 unsafe { from_glib(ffi::gst_format_to_quark(self.into_glib())) }
1226 }
1227}
1228
1229#[doc(hidden)]
1230impl IntoGlib for Format {
1231 type GlibType = ffi::GstFormat;
1232
1233 #[inline]
1234 fn into_glib(self) -> ffi::GstFormat {
1235 match self {
1236 Self::Undefined => ffi::GST_FORMAT_UNDEFINED,
1237 Self::Default => ffi::GST_FORMAT_DEFAULT,
1238 Self::Bytes => ffi::GST_FORMAT_BYTES,
1239 Self::Time => ffi::GST_FORMAT_TIME,
1240 Self::Buffers => ffi::GST_FORMAT_BUFFERS,
1241 Self::Percent => ffi::GST_FORMAT_PERCENT,
1242 Self::__Unknown(value: i32) => value,
1243 }
1244 }
1245}
1246
1247#[doc(hidden)]
1248impl FromGlib<ffi::GstFormat> for Format {
1249 #[inline]
1250 unsafe fn from_glib(value: ffi::GstFormat) -> Self {
1251 skip_assert_initialized!();
1252
1253 match value {
1254 ffi::GST_FORMAT_UNDEFINED => Self::Undefined,
1255 ffi::GST_FORMAT_DEFAULT => Self::Default,
1256 ffi::GST_FORMAT_BYTES => Self::Bytes,
1257 ffi::GST_FORMAT_TIME => Self::Time,
1258 ffi::GST_FORMAT_BUFFERS => Self::Buffers,
1259 ffi::GST_FORMAT_PERCENT => Self::Percent,
1260 value: i32 => Self::__Unknown(value),
1261 }
1262 }
1263}
1264
1265impl StaticType for Format {
1266 #[inline]
1267 #[doc(alias = "gst_format_get_type")]
1268 fn static_type() -> glib::Type {
1269 unsafe { from_glib(val:ffi::gst_format_get_type()) }
1270 }
1271}
1272
1273impl glib::HasParamSpec for Format {
1274 type ParamSpec = glib::ParamSpecEnum;
1275 type SetValue = Self;
1276 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1277
1278 fn param_spec_builder() -> Self::BuilderFn {
1279 Self::ParamSpec::builder_with_default
1280 }
1281}
1282
1283impl glib::value::ValueType for Format {
1284 type Type = Self;
1285}
1286
1287unsafe impl<'a> glib::value::FromValue<'a> for Format {
1288 type Checker = glib::value::GenericValueTypeChecker<Self>;
1289
1290 #[inline]
1291 unsafe fn from_value(value: &'a glib::Value) -> Self {
1292 skip_assert_initialized!();
1293 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1294 }
1295}
1296
1297impl ToValue for Format {
1298 #[inline]
1299 fn to_value(&self) -> glib::Value {
1300 let mut value: Value = glib::Value::for_value_type::<Self>();
1301 unsafe {
1302 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1303 }
1304 value
1305 }
1306
1307 #[inline]
1308 fn value_type(&self) -> glib::Type {
1309 Self::static_type()
1310 }
1311}
1312
1313impl From<Format> for glib::Value {
1314 #[inline]
1315 fn from(v: Format) -> Self {
1316 skip_assert_initialized!();
1317 ToValue::to_value(&v)
1318 }
1319}
1320
1321#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1322#[non_exhaustive]
1323#[doc(alias = "GstLibraryError")]
1324pub enum LibraryError {
1325 #[doc(alias = "GST_LIBRARY_ERROR_FAILED")]
1326 Failed,
1327 #[doc(alias = "GST_LIBRARY_ERROR_TOO_LAZY")]
1328 TooLazy,
1329 #[doc(alias = "GST_LIBRARY_ERROR_INIT")]
1330 Init,
1331 #[doc(alias = "GST_LIBRARY_ERROR_SHUTDOWN")]
1332 Shutdown,
1333 #[doc(alias = "GST_LIBRARY_ERROR_SETTINGS")]
1334 Settings,
1335 #[doc(alias = "GST_LIBRARY_ERROR_ENCODE")]
1336 Encode,
1337 #[doc(hidden)]
1338 __Unknown(i32),
1339}
1340
1341#[doc(hidden)]
1342impl IntoGlib for LibraryError {
1343 type GlibType = ffi::GstLibraryError;
1344
1345 #[inline]
1346 fn into_glib(self) -> ffi::GstLibraryError {
1347 match self {
1348 Self::Failed => ffi::GST_LIBRARY_ERROR_FAILED,
1349 Self::TooLazy => ffi::GST_LIBRARY_ERROR_TOO_LAZY,
1350 Self::Init => ffi::GST_LIBRARY_ERROR_INIT,
1351 Self::Shutdown => ffi::GST_LIBRARY_ERROR_SHUTDOWN,
1352 Self::Settings => ffi::GST_LIBRARY_ERROR_SETTINGS,
1353 Self::Encode => ffi::GST_LIBRARY_ERROR_ENCODE,
1354 Self::__Unknown(value: i32) => value,
1355 }
1356 }
1357}
1358
1359#[doc(hidden)]
1360impl FromGlib<ffi::GstLibraryError> for LibraryError {
1361 #[inline]
1362 unsafe fn from_glib(value: ffi::GstLibraryError) -> Self {
1363 skip_assert_initialized!();
1364
1365 match value {
1366 ffi::GST_LIBRARY_ERROR_FAILED => Self::Failed,
1367 ffi::GST_LIBRARY_ERROR_TOO_LAZY => Self::TooLazy,
1368 ffi::GST_LIBRARY_ERROR_INIT => Self::Init,
1369 ffi::GST_LIBRARY_ERROR_SHUTDOWN => Self::Shutdown,
1370 ffi::GST_LIBRARY_ERROR_SETTINGS => Self::Settings,
1371 ffi::GST_LIBRARY_ERROR_ENCODE => Self::Encode,
1372 value: i32 => Self::__Unknown(value),
1373 }
1374 }
1375}
1376
1377impl glib::error::ErrorDomain for LibraryError {
1378 #[inline]
1379 fn domain() -> glib::Quark {
1380 skip_assert_initialized!();
1381
1382 unsafe { from_glib(val:ffi::gst_library_error_quark()) }
1383 }
1384
1385 #[inline]
1386 fn code(self) -> i32 {
1387 self.into_glib()
1388 }
1389
1390 #[inline]
1391 #[allow(clippy::match_single_binding)]
1392 fn from(code: i32) -> Option<Self> {
1393 skip_assert_initialized!();
1394 match unsafe { from_glib(val:code) } {
1395 Self::__Unknown(_) => Some(Self::Failed),
1396 value: LibraryError => Some(value),
1397 }
1398 }
1399}
1400
1401impl StaticType for LibraryError {
1402 #[inline]
1403 #[doc(alias = "gst_library_error_get_type")]
1404 fn static_type() -> glib::Type {
1405 unsafe { from_glib(val:ffi::gst_library_error_get_type()) }
1406 }
1407}
1408
1409impl glib::HasParamSpec for LibraryError {
1410 type ParamSpec = glib::ParamSpecEnum;
1411 type SetValue = Self;
1412 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1413
1414 fn param_spec_builder() -> Self::BuilderFn {
1415 Self::ParamSpec::builder_with_default
1416 }
1417}
1418
1419impl glib::value::ValueType for LibraryError {
1420 type Type = Self;
1421}
1422
1423unsafe impl<'a> glib::value::FromValue<'a> for LibraryError {
1424 type Checker = glib::value::GenericValueTypeChecker<Self>;
1425
1426 #[inline]
1427 unsafe fn from_value(value: &'a glib::Value) -> Self {
1428 skip_assert_initialized!();
1429 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1430 }
1431}
1432
1433impl ToValue for LibraryError {
1434 #[inline]
1435 fn to_value(&self) -> glib::Value {
1436 let mut value: Value = glib::Value::for_value_type::<Self>();
1437 unsafe {
1438 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1439 }
1440 value
1441 }
1442
1443 #[inline]
1444 fn value_type(&self) -> glib::Type {
1445 Self::static_type()
1446 }
1447}
1448
1449impl From<LibraryError> for glib::Value {
1450 #[inline]
1451 fn from(v: LibraryError) -> Self {
1452 skip_assert_initialized!();
1453 ToValue::to_value(&v)
1454 }
1455}
1456
1457#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1458#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
1459#[repr(i32)]
1460#[doc(alias = "GstPadDirection")]
1461pub enum PadDirection {
1462 #[doc(alias = "GST_PAD_UNKNOWN")]
1463 Unknown = ffi::GST_PAD_UNKNOWN,
1464 #[doc(alias = "GST_PAD_SRC")]
1465 Src = ffi::GST_PAD_SRC,
1466 #[doc(alias = "GST_PAD_SINK")]
1467 Sink = ffi::GST_PAD_SINK,
1468}
1469
1470#[doc(hidden)]
1471impl IntoGlib for PadDirection {
1472 type GlibType = ffi::GstPadDirection;
1473
1474 #[inline]
1475 fn into_glib(self) -> ffi::GstPadDirection {
1476 self as ffi::GstPadDirection
1477 }
1478}
1479
1480#[doc(hidden)]
1481impl FromGlib<ffi::GstPadDirection> for PadDirection {
1482 #[inline]
1483 unsafe fn from_glib(value: ffi::GstPadDirection) -> Self {
1484 skip_assert_initialized!();
1485
1486 debug_assert!([ffi::GST_PAD_UNKNOWN, ffi::GST_PAD_SRC, ffi::GST_PAD_SINK].contains(&value));
1487 std::mem::transmute(src:value)
1488 }
1489}
1490
1491impl StaticType for PadDirection {
1492 #[inline]
1493 #[doc(alias = "gst_pad_direction_get_type")]
1494 fn static_type() -> glib::Type {
1495 unsafe { from_glib(val:ffi::gst_pad_direction_get_type()) }
1496 }
1497}
1498
1499impl glib::HasParamSpec for PadDirection {
1500 type ParamSpec = glib::ParamSpecEnum;
1501 type SetValue = Self;
1502 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1503
1504 fn param_spec_builder() -> Self::BuilderFn {
1505 Self::ParamSpec::builder_with_default
1506 }
1507}
1508
1509impl glib::value::ValueType for PadDirection {
1510 type Type = Self;
1511}
1512
1513unsafe impl<'a> glib::value::FromValue<'a> for PadDirection {
1514 type Checker = glib::value::GenericValueTypeChecker<Self>;
1515
1516 #[inline]
1517 unsafe fn from_value(value: &'a glib::Value) -> Self {
1518 skip_assert_initialized!();
1519 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1520 }
1521}
1522
1523impl ToValue for PadDirection {
1524 #[inline]
1525 fn to_value(&self) -> glib::Value {
1526 let mut value: Value = glib::Value::for_value_type::<Self>();
1527 unsafe {
1528 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1529 }
1530 value
1531 }
1532
1533 #[inline]
1534 fn value_type(&self) -> glib::Type {
1535 Self::static_type()
1536 }
1537}
1538
1539impl From<PadDirection> for glib::Value {
1540 #[inline]
1541 fn from(v: PadDirection) -> Self {
1542 skip_assert_initialized!();
1543 ToValue::to_value(&v)
1544 }
1545}
1546
1547#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1548#[repr(i32)]
1549#[doc(alias = "GstPadMode")]
1550pub enum PadMode {
1551 #[doc(alias = "GST_PAD_MODE_NONE")]
1552 None = ffi::GST_PAD_MODE_NONE,
1553 #[doc(alias = "GST_PAD_MODE_PUSH")]
1554 Push = ffi::GST_PAD_MODE_PUSH,
1555 #[doc(alias = "GST_PAD_MODE_PULL")]
1556 Pull = ffi::GST_PAD_MODE_PULL,
1557}
1558
1559impl PadMode {
1560 pub fn name<'a>(self) -> &'a GStr {
1561 unsafe {
1562 GStr::from_ptr(
1563 ffi::gst_pad_mode_get_name(self.into_glib())
1564 .as_ref()
1565 .expect(msg:"gst_pad_mode_get_name returned NULL"),
1566 )
1567 }
1568 }
1569}
1570
1571impl std::fmt::Display for PadMode {
1572 #[inline]
1573 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1574 f.write_str(&self.name())
1575 }
1576}
1577
1578#[doc(hidden)]
1579impl IntoGlib for PadMode {
1580 type GlibType = ffi::GstPadMode;
1581
1582 #[inline]
1583 fn into_glib(self) -> ffi::GstPadMode {
1584 self as ffi::GstPadMode
1585 }
1586}
1587
1588#[doc(hidden)]
1589impl FromGlib<ffi::GstPadMode> for PadMode {
1590 #[inline]
1591 unsafe fn from_glib(value: ffi::GstPadMode) -> Self {
1592 skip_assert_initialized!();
1593
1594 debug_assert!([
1595 ffi::GST_PAD_MODE_NONE,
1596 ffi::GST_PAD_MODE_PUSH,
1597 ffi::GST_PAD_MODE_PULL
1598 ]
1599 .contains(&value));
1600 std::mem::transmute(src:value)
1601 }
1602}
1603
1604impl StaticType for PadMode {
1605 #[inline]
1606 #[doc(alias = "gst_pad_mode_get_type")]
1607 fn static_type() -> glib::Type {
1608 unsafe { from_glib(val:ffi::gst_pad_mode_get_type()) }
1609 }
1610}
1611
1612impl glib::HasParamSpec for PadMode {
1613 type ParamSpec = glib::ParamSpecEnum;
1614 type SetValue = Self;
1615 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1616
1617 fn param_spec_builder() -> Self::BuilderFn {
1618 Self::ParamSpec::builder_with_default
1619 }
1620}
1621
1622impl glib::value::ValueType for PadMode {
1623 type Type = Self;
1624}
1625
1626unsafe impl<'a> glib::value::FromValue<'a> for PadMode {
1627 type Checker = glib::value::GenericValueTypeChecker<Self>;
1628
1629 #[inline]
1630 unsafe fn from_value(value: &'a glib::Value) -> Self {
1631 skip_assert_initialized!();
1632 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1633 }
1634}
1635
1636impl ToValue for PadMode {
1637 #[inline]
1638 fn to_value(&self) -> glib::Value {
1639 let mut value: Value = glib::Value::for_value_type::<Self>();
1640 unsafe {
1641 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1642 }
1643 value
1644 }
1645
1646 #[inline]
1647 fn value_type(&self) -> glib::Type {
1648 Self::static_type()
1649 }
1650}
1651
1652impl From<PadMode> for glib::Value {
1653 #[inline]
1654 fn from(v: PadMode) -> Self {
1655 skip_assert_initialized!();
1656 ToValue::to_value(&v)
1657 }
1658}
1659
1660#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1661#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
1662#[repr(i32)]
1663#[doc(alias = "GstPadPresence")]
1664pub enum PadPresence {
1665 #[doc(alias = "GST_PAD_ALWAYS")]
1666 Always = ffi::GST_PAD_ALWAYS,
1667 #[doc(alias = "GST_PAD_SOMETIMES")]
1668 Sometimes = ffi::GST_PAD_SOMETIMES,
1669 #[doc(alias = "GST_PAD_REQUEST")]
1670 Request = ffi::GST_PAD_REQUEST,
1671}
1672
1673#[doc(hidden)]
1674impl IntoGlib for PadPresence {
1675 type GlibType = ffi::GstPadPresence;
1676
1677 #[inline]
1678 fn into_glib(self) -> ffi::GstPadPresence {
1679 self as ffi::GstPadPresence
1680 }
1681}
1682
1683#[doc(hidden)]
1684impl FromGlib<ffi::GstPadPresence> for PadPresence {
1685 #[inline]
1686 unsafe fn from_glib(value: ffi::GstPadPresence) -> Self {
1687 skip_assert_initialized!();
1688
1689 debug_assert!([
1690 ffi::GST_PAD_ALWAYS,
1691 ffi::GST_PAD_SOMETIMES,
1692 ffi::GST_PAD_REQUEST
1693 ]
1694 .contains(&value));
1695 std::mem::transmute(src:value)
1696 }
1697}
1698
1699impl StaticType for PadPresence {
1700 #[inline]
1701 #[doc(alias = "gst_pad_presence_get_type")]
1702 fn static_type() -> glib::Type {
1703 unsafe { from_glib(val:ffi::gst_pad_presence_get_type()) }
1704 }
1705}
1706
1707impl glib::HasParamSpec for PadPresence {
1708 type ParamSpec = glib::ParamSpecEnum;
1709 type SetValue = Self;
1710 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1711
1712 fn param_spec_builder() -> Self::BuilderFn {
1713 Self::ParamSpec::builder_with_default
1714 }
1715}
1716
1717impl glib::value::ValueType for PadPresence {
1718 type Type = Self;
1719}
1720
1721unsafe impl<'a> glib::value::FromValue<'a> for PadPresence {
1722 type Checker = glib::value::GenericValueTypeChecker<Self>;
1723
1724 #[inline]
1725 unsafe fn from_value(value: &'a glib::Value) -> Self {
1726 skip_assert_initialized!();
1727 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1728 }
1729}
1730
1731impl ToValue for PadPresence {
1732 #[inline]
1733 fn to_value(&self) -> glib::Value {
1734 let mut value: Value = glib::Value::for_value_type::<Self>();
1735 unsafe {
1736 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1737 }
1738 value
1739 }
1740
1741 #[inline]
1742 fn value_type(&self) -> glib::Type {
1743 Self::static_type()
1744 }
1745}
1746
1747impl From<PadPresence> for glib::Value {
1748 #[inline]
1749 fn from(v: PadPresence) -> Self {
1750 skip_assert_initialized!();
1751 ToValue::to_value(&v)
1752 }
1753}
1754
1755#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1756#[repr(i32)]
1757#[doc(alias = "GstPadProbeReturn")]
1758pub enum PadProbeReturn {
1759 #[doc(alias = "GST_PAD_PROBE_DROP")]
1760 Drop = ffi::GST_PAD_PROBE_DROP,
1761 #[doc(alias = "GST_PAD_PROBE_OK")]
1762 Ok = ffi::GST_PAD_PROBE_OK,
1763 #[doc(alias = "GST_PAD_PROBE_REMOVE")]
1764 Remove = ffi::GST_PAD_PROBE_REMOVE,
1765 #[doc(alias = "GST_PAD_PROBE_PASS")]
1766 Pass = ffi::GST_PAD_PROBE_PASS,
1767 #[doc(alias = "GST_PAD_PROBE_HANDLED")]
1768 Handled = ffi::GST_PAD_PROBE_HANDLED,
1769}
1770
1771#[doc(hidden)]
1772impl IntoGlib for PadProbeReturn {
1773 type GlibType = ffi::GstPadProbeReturn;
1774
1775 #[inline]
1776 fn into_glib(self) -> ffi::GstPadProbeReturn {
1777 self as ffi::GstPadProbeReturn
1778 }
1779}
1780
1781#[doc(hidden)]
1782impl FromGlib<ffi::GstPadProbeReturn> for PadProbeReturn {
1783 #[inline]
1784 unsafe fn from_glib(value: ffi::GstPadProbeReturn) -> Self {
1785 skip_assert_initialized!();
1786
1787 debug_assert!([
1788 ffi::GST_PAD_PROBE_DROP,
1789 ffi::GST_PAD_PROBE_OK,
1790 ffi::GST_PAD_PROBE_REMOVE,
1791 ffi::GST_PAD_PROBE_PASS,
1792 ffi::GST_PAD_PROBE_HANDLED
1793 ]
1794 .contains(&value));
1795 std::mem::transmute(src:value)
1796 }
1797}
1798
1799impl StaticType for PadProbeReturn {
1800 #[inline]
1801 #[doc(alias = "gst_pad_probe_return_get_type")]
1802 fn static_type() -> glib::Type {
1803 unsafe { from_glib(val:ffi::gst_pad_probe_return_get_type()) }
1804 }
1805}
1806
1807impl glib::HasParamSpec for PadProbeReturn {
1808 type ParamSpec = glib::ParamSpecEnum;
1809 type SetValue = Self;
1810 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1811
1812 fn param_spec_builder() -> Self::BuilderFn {
1813 Self::ParamSpec::builder_with_default
1814 }
1815}
1816
1817impl glib::value::ValueType for PadProbeReturn {
1818 type Type = Self;
1819}
1820
1821unsafe impl<'a> glib::value::FromValue<'a> for PadProbeReturn {
1822 type Checker = glib::value::GenericValueTypeChecker<Self>;
1823
1824 #[inline]
1825 unsafe fn from_value(value: &'a glib::Value) -> Self {
1826 skip_assert_initialized!();
1827 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1828 }
1829}
1830
1831impl ToValue for PadProbeReturn {
1832 #[inline]
1833 fn to_value(&self) -> glib::Value {
1834 let mut value: Value = glib::Value::for_value_type::<Self>();
1835 unsafe {
1836 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1837 }
1838 value
1839 }
1840
1841 #[inline]
1842 fn value_type(&self) -> glib::Type {
1843 Self::static_type()
1844 }
1845}
1846
1847impl From<PadProbeReturn> for glib::Value {
1848 #[inline]
1849 fn from(v: PadProbeReturn) -> Self {
1850 skip_assert_initialized!();
1851 ToValue::to_value(&v)
1852 }
1853}
1854
1855#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1856#[non_exhaustive]
1857#[doc(alias = "GstParseError")]
1858pub enum ParseError {
1859 #[doc(alias = "GST_PARSE_ERROR_SYNTAX")]
1860 Syntax,
1861 #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_ELEMENT")]
1862 NoSuchElement,
1863 #[doc(alias = "GST_PARSE_ERROR_NO_SUCH_PROPERTY")]
1864 NoSuchProperty,
1865 #[doc(alias = "GST_PARSE_ERROR_LINK")]
1866 Link,
1867 #[doc(alias = "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY")]
1868 CouldNotSetProperty,
1869 #[doc(alias = "GST_PARSE_ERROR_EMPTY_BIN")]
1870 EmptyBin,
1871 #[doc(alias = "GST_PARSE_ERROR_EMPTY")]
1872 Empty,
1873 #[doc(alias = "GST_PARSE_ERROR_DELAYED_LINK")]
1874 DelayedLink,
1875 #[doc(hidden)]
1876 __Unknown(i32),
1877}
1878
1879#[doc(hidden)]
1880impl IntoGlib for ParseError {
1881 type GlibType = ffi::GstParseError;
1882
1883 #[inline]
1884 fn into_glib(self) -> ffi::GstParseError {
1885 match self {
1886 Self::Syntax => ffi::GST_PARSE_ERROR_SYNTAX,
1887 Self::NoSuchElement => ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT,
1888 Self::NoSuchProperty => ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY,
1889 Self::Link => ffi::GST_PARSE_ERROR_LINK,
1890 Self::CouldNotSetProperty => ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
1891 Self::EmptyBin => ffi::GST_PARSE_ERROR_EMPTY_BIN,
1892 Self::Empty => ffi::GST_PARSE_ERROR_EMPTY,
1893 Self::DelayedLink => ffi::GST_PARSE_ERROR_DELAYED_LINK,
1894 Self::__Unknown(value: i32) => value,
1895 }
1896 }
1897}
1898
1899#[doc(hidden)]
1900impl FromGlib<ffi::GstParseError> for ParseError {
1901 #[inline]
1902 unsafe fn from_glib(value: ffi::GstParseError) -> Self {
1903 skip_assert_initialized!();
1904
1905 match value {
1906 ffi::GST_PARSE_ERROR_SYNTAX => Self::Syntax,
1907 ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT => Self::NoSuchElement,
1908 ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY => Self::NoSuchProperty,
1909 ffi::GST_PARSE_ERROR_LINK => Self::Link,
1910 ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY => Self::CouldNotSetProperty,
1911 ffi::GST_PARSE_ERROR_EMPTY_BIN => Self::EmptyBin,
1912 ffi::GST_PARSE_ERROR_EMPTY => Self::Empty,
1913 ffi::GST_PARSE_ERROR_DELAYED_LINK => Self::DelayedLink,
1914 value: i32 => Self::__Unknown(value),
1915 }
1916 }
1917}
1918
1919impl glib::error::ErrorDomain for ParseError {
1920 #[inline]
1921 fn domain() -> glib::Quark {
1922 skip_assert_initialized!();
1923
1924 unsafe { from_glib(val:ffi::gst_parse_error_quark()) }
1925 }
1926
1927 #[inline]
1928 fn code(self) -> i32 {
1929 self.into_glib()
1930 }
1931
1932 #[inline]
1933 #[allow(clippy::match_single_binding)]
1934 fn from(code: i32) -> Option<Self> {
1935 skip_assert_initialized!();
1936 match unsafe { from_glib(val:code) } {
1937 value: ParseError => Some(value),
1938 }
1939 }
1940}
1941
1942impl StaticType for ParseError {
1943 #[inline]
1944 #[doc(alias = "gst_parse_error_get_type")]
1945 fn static_type() -> glib::Type {
1946 unsafe { from_glib(val:ffi::gst_parse_error_get_type()) }
1947 }
1948}
1949
1950impl glib::HasParamSpec for ParseError {
1951 type ParamSpec = glib::ParamSpecEnum;
1952 type SetValue = Self;
1953 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1954
1955 fn param_spec_builder() -> Self::BuilderFn {
1956 Self::ParamSpec::builder_with_default
1957 }
1958}
1959
1960impl glib::value::ValueType for ParseError {
1961 type Type = Self;
1962}
1963
1964unsafe impl<'a> glib::value::FromValue<'a> for ParseError {
1965 type Checker = glib::value::GenericValueTypeChecker<Self>;
1966
1967 #[inline]
1968 unsafe fn from_value(value: &'a glib::Value) -> Self {
1969 skip_assert_initialized!();
1970 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1971 }
1972}
1973
1974impl ToValue for ParseError {
1975 #[inline]
1976 fn to_value(&self) -> glib::Value {
1977 let mut value: Value = glib::Value::for_value_type::<Self>();
1978 unsafe {
1979 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1980 }
1981 value
1982 }
1983
1984 #[inline]
1985 fn value_type(&self) -> glib::Type {
1986 Self::static_type()
1987 }
1988}
1989
1990impl From<ParseError> for glib::Value {
1991 #[inline]
1992 fn from(v: ParseError) -> Self {
1993 skip_assert_initialized!();
1994 ToValue::to_value(&v)
1995 }
1996}
1997
1998#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1999#[non_exhaustive]
2000#[doc(alias = "GstPluginError")]
2001pub enum PluginError {
2002 #[doc(alias = "GST_PLUGIN_ERROR_MODULE")]
2003 Module,
2004 #[doc(alias = "GST_PLUGIN_ERROR_DEPENDENCIES")]
2005 Dependencies,
2006 #[doc(alias = "GST_PLUGIN_ERROR_NAME_MISMATCH")]
2007 NameMismatch,
2008 #[doc(hidden)]
2009 __Unknown(i32),
2010}
2011
2012#[doc(hidden)]
2013impl IntoGlib for PluginError {
2014 type GlibType = ffi::GstPluginError;
2015
2016 #[inline]
2017 fn into_glib(self) -> ffi::GstPluginError {
2018 match self {
2019 Self::Module => ffi::GST_PLUGIN_ERROR_MODULE,
2020 Self::Dependencies => ffi::GST_PLUGIN_ERROR_DEPENDENCIES,
2021 Self::NameMismatch => ffi::GST_PLUGIN_ERROR_NAME_MISMATCH,
2022 Self::__Unknown(value: i32) => value,
2023 }
2024 }
2025}
2026
2027#[doc(hidden)]
2028impl FromGlib<ffi::GstPluginError> for PluginError {
2029 #[inline]
2030 unsafe fn from_glib(value: ffi::GstPluginError) -> Self {
2031 skip_assert_initialized!();
2032
2033 match value {
2034 ffi::GST_PLUGIN_ERROR_MODULE => Self::Module,
2035 ffi::GST_PLUGIN_ERROR_DEPENDENCIES => Self::Dependencies,
2036 ffi::GST_PLUGIN_ERROR_NAME_MISMATCH => Self::NameMismatch,
2037 value: i32 => Self::__Unknown(value),
2038 }
2039 }
2040}
2041
2042impl glib::error::ErrorDomain for PluginError {
2043 #[inline]
2044 fn domain() -> glib::Quark {
2045 skip_assert_initialized!();
2046
2047 unsafe { from_glib(val:ffi::gst_plugin_error_quark()) }
2048 }
2049
2050 #[inline]
2051 fn code(self) -> i32 {
2052 self.into_glib()
2053 }
2054
2055 #[inline]
2056 #[allow(clippy::match_single_binding)]
2057 fn from(code: i32) -> Option<Self> {
2058 skip_assert_initialized!();
2059 match unsafe { from_glib(val:code) } {
2060 value: PluginError => Some(value),
2061 }
2062 }
2063}
2064
2065impl StaticType for PluginError {
2066 #[inline]
2067 #[doc(alias = "gst_plugin_error_get_type")]
2068 fn static_type() -> glib::Type {
2069 unsafe { from_glib(val:ffi::gst_plugin_error_get_type()) }
2070 }
2071}
2072
2073impl glib::HasParamSpec for PluginError {
2074 type ParamSpec = glib::ParamSpecEnum;
2075 type SetValue = Self;
2076 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2077
2078 fn param_spec_builder() -> Self::BuilderFn {
2079 Self::ParamSpec::builder_with_default
2080 }
2081}
2082
2083impl glib::value::ValueType for PluginError {
2084 type Type = Self;
2085}
2086
2087unsafe impl<'a> glib::value::FromValue<'a> for PluginError {
2088 type Checker = glib::value::GenericValueTypeChecker<Self>;
2089
2090 #[inline]
2091 unsafe fn from_value(value: &'a glib::Value) -> Self {
2092 skip_assert_initialized!();
2093 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2094 }
2095}
2096
2097impl ToValue for PluginError {
2098 #[inline]
2099 fn to_value(&self) -> glib::Value {
2100 let mut value: Value = glib::Value::for_value_type::<Self>();
2101 unsafe {
2102 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2103 }
2104 value
2105 }
2106
2107 #[inline]
2108 fn value_type(&self) -> glib::Type {
2109 Self::static_type()
2110 }
2111}
2112
2113impl From<PluginError> for glib::Value {
2114 #[inline]
2115 fn from(v: PluginError) -> Self {
2116 skip_assert_initialized!();
2117 ToValue::to_value(&v)
2118 }
2119}
2120
2121#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2122#[non_exhaustive]
2123#[doc(alias = "GstProgressType")]
2124pub enum ProgressType {
2125 #[doc(alias = "GST_PROGRESS_TYPE_START")]
2126 Start,
2127 #[doc(alias = "GST_PROGRESS_TYPE_CONTINUE")]
2128 Continue,
2129 #[doc(alias = "GST_PROGRESS_TYPE_COMPLETE")]
2130 Complete,
2131 #[doc(alias = "GST_PROGRESS_TYPE_CANCELED")]
2132 Canceled,
2133 #[doc(alias = "GST_PROGRESS_TYPE_ERROR")]
2134 Error,
2135 #[doc(hidden)]
2136 __Unknown(i32),
2137}
2138
2139#[doc(hidden)]
2140impl IntoGlib for ProgressType {
2141 type GlibType = ffi::GstProgressType;
2142
2143 #[inline]
2144 fn into_glib(self) -> ffi::GstProgressType {
2145 match self {
2146 Self::Start => ffi::GST_PROGRESS_TYPE_START,
2147 Self::Continue => ffi::GST_PROGRESS_TYPE_CONTINUE,
2148 Self::Complete => ffi::GST_PROGRESS_TYPE_COMPLETE,
2149 Self::Canceled => ffi::GST_PROGRESS_TYPE_CANCELED,
2150 Self::Error => ffi::GST_PROGRESS_TYPE_ERROR,
2151 Self::__Unknown(value: i32) => value,
2152 }
2153 }
2154}
2155
2156#[doc(hidden)]
2157impl FromGlib<ffi::GstProgressType> for ProgressType {
2158 #[inline]
2159 unsafe fn from_glib(value: ffi::GstProgressType) -> Self {
2160 skip_assert_initialized!();
2161
2162 match value {
2163 ffi::GST_PROGRESS_TYPE_START => Self::Start,
2164 ffi::GST_PROGRESS_TYPE_CONTINUE => Self::Continue,
2165 ffi::GST_PROGRESS_TYPE_COMPLETE => Self::Complete,
2166 ffi::GST_PROGRESS_TYPE_CANCELED => Self::Canceled,
2167 ffi::GST_PROGRESS_TYPE_ERROR => Self::Error,
2168 value: i32 => Self::__Unknown(value),
2169 }
2170 }
2171}
2172
2173impl StaticType for ProgressType {
2174 #[inline]
2175 #[doc(alias = "gst_progress_type_get_type")]
2176 fn static_type() -> glib::Type {
2177 unsafe { from_glib(val:ffi::gst_progress_type_get_type()) }
2178 }
2179}
2180
2181impl glib::HasParamSpec for ProgressType {
2182 type ParamSpec = glib::ParamSpecEnum;
2183 type SetValue = Self;
2184 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2185
2186 fn param_spec_builder() -> Self::BuilderFn {
2187 Self::ParamSpec::builder_with_default
2188 }
2189}
2190
2191impl glib::value::ValueType for ProgressType {
2192 type Type = Self;
2193}
2194
2195unsafe impl<'a> glib::value::FromValue<'a> for ProgressType {
2196 type Checker = glib::value::GenericValueTypeChecker<Self>;
2197
2198 #[inline]
2199 unsafe fn from_value(value: &'a glib::Value) -> Self {
2200 skip_assert_initialized!();
2201 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2202 }
2203}
2204
2205impl ToValue for ProgressType {
2206 #[inline]
2207 fn to_value(&self) -> glib::Value {
2208 let mut value: Value = glib::Value::for_value_type::<Self>();
2209 unsafe {
2210 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2211 }
2212 value
2213 }
2214
2215 #[inline]
2216 fn value_type(&self) -> glib::Type {
2217 Self::static_type()
2218 }
2219}
2220
2221impl From<ProgressType> for glib::Value {
2222 #[inline]
2223 fn from(v: ProgressType) -> Self {
2224 skip_assert_initialized!();
2225 ToValue::to_value(&v)
2226 }
2227}
2228
2229#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2230#[non_exhaustive]
2231#[doc(alias = "GstPromiseResult")]
2232pub enum PromiseResult {
2233 #[doc(alias = "GST_PROMISE_RESULT_PENDING")]
2234 Pending,
2235 #[doc(alias = "GST_PROMISE_RESULT_INTERRUPTED")]
2236 Interrupted,
2237 #[doc(alias = "GST_PROMISE_RESULT_REPLIED")]
2238 Replied,
2239 #[doc(alias = "GST_PROMISE_RESULT_EXPIRED")]
2240 Expired,
2241 #[doc(hidden)]
2242 __Unknown(i32),
2243}
2244
2245#[doc(hidden)]
2246impl IntoGlib for PromiseResult {
2247 type GlibType = ffi::GstPromiseResult;
2248
2249 #[inline]
2250 fn into_glib(self) -> ffi::GstPromiseResult {
2251 match self {
2252 Self::Pending => ffi::GST_PROMISE_RESULT_PENDING,
2253 Self::Interrupted => ffi::GST_PROMISE_RESULT_INTERRUPTED,
2254 Self::Replied => ffi::GST_PROMISE_RESULT_REPLIED,
2255 Self::Expired => ffi::GST_PROMISE_RESULT_EXPIRED,
2256 Self::__Unknown(value: i32) => value,
2257 }
2258 }
2259}
2260
2261#[doc(hidden)]
2262impl FromGlib<ffi::GstPromiseResult> for PromiseResult {
2263 #[inline]
2264 unsafe fn from_glib(value: ffi::GstPromiseResult) -> Self {
2265 skip_assert_initialized!();
2266
2267 match value {
2268 ffi::GST_PROMISE_RESULT_PENDING => Self::Pending,
2269 ffi::GST_PROMISE_RESULT_INTERRUPTED => Self::Interrupted,
2270 ffi::GST_PROMISE_RESULT_REPLIED => Self::Replied,
2271 ffi::GST_PROMISE_RESULT_EXPIRED => Self::Expired,
2272 value: i32 => Self::__Unknown(value),
2273 }
2274 }
2275}
2276
2277impl StaticType for PromiseResult {
2278 #[inline]
2279 #[doc(alias = "gst_promise_result_get_type")]
2280 fn static_type() -> glib::Type {
2281 unsafe { from_glib(val:ffi::gst_promise_result_get_type()) }
2282 }
2283}
2284
2285impl glib::HasParamSpec for PromiseResult {
2286 type ParamSpec = glib::ParamSpecEnum;
2287 type SetValue = Self;
2288 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2289
2290 fn param_spec_builder() -> Self::BuilderFn {
2291 Self::ParamSpec::builder_with_default
2292 }
2293}
2294
2295impl glib::value::ValueType for PromiseResult {
2296 type Type = Self;
2297}
2298
2299unsafe impl<'a> glib::value::FromValue<'a> for PromiseResult {
2300 type Checker = glib::value::GenericValueTypeChecker<Self>;
2301
2302 #[inline]
2303 unsafe fn from_value(value: &'a glib::Value) -> Self {
2304 skip_assert_initialized!();
2305 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2306 }
2307}
2308
2309impl ToValue for PromiseResult {
2310 #[inline]
2311 fn to_value(&self) -> glib::Value {
2312 let mut value: Value = glib::Value::for_value_type::<Self>();
2313 unsafe {
2314 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2315 }
2316 value
2317 }
2318
2319 #[inline]
2320 fn value_type(&self) -> glib::Type {
2321 Self::static_type()
2322 }
2323}
2324
2325impl From<PromiseResult> for glib::Value {
2326 #[inline]
2327 fn from(v: PromiseResult) -> Self {
2328 skip_assert_initialized!();
2329 ToValue::to_value(&v)
2330 }
2331}
2332
2333#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2334#[non_exhaustive]
2335#[doc(alias = "GstQOSType")]
2336pub enum QOSType {
2337 #[doc(alias = "GST_QOS_TYPE_OVERFLOW")]
2338 Overflow,
2339 #[doc(alias = "GST_QOS_TYPE_UNDERFLOW")]
2340 Underflow,
2341 #[doc(alias = "GST_QOS_TYPE_THROTTLE")]
2342 Throttle,
2343 #[doc(hidden)]
2344 __Unknown(i32),
2345}
2346
2347#[doc(hidden)]
2348impl IntoGlib for QOSType {
2349 type GlibType = ffi::GstQOSType;
2350
2351 #[inline]
2352 fn into_glib(self) -> ffi::GstQOSType {
2353 match self {
2354 Self::Overflow => ffi::GST_QOS_TYPE_OVERFLOW,
2355 Self::Underflow => ffi::GST_QOS_TYPE_UNDERFLOW,
2356 Self::Throttle => ffi::GST_QOS_TYPE_THROTTLE,
2357 Self::__Unknown(value: i32) => value,
2358 }
2359 }
2360}
2361
2362#[doc(hidden)]
2363impl FromGlib<ffi::GstQOSType> for QOSType {
2364 #[inline]
2365 unsafe fn from_glib(value: ffi::GstQOSType) -> Self {
2366 skip_assert_initialized!();
2367
2368 match value {
2369 ffi::GST_QOS_TYPE_OVERFLOW => Self::Overflow,
2370 ffi::GST_QOS_TYPE_UNDERFLOW => Self::Underflow,
2371 ffi::GST_QOS_TYPE_THROTTLE => Self::Throttle,
2372 value: i32 => Self::__Unknown(value),
2373 }
2374 }
2375}
2376
2377impl StaticType for QOSType {
2378 #[inline]
2379 #[doc(alias = "gst_qos_type_get_type")]
2380 fn static_type() -> glib::Type {
2381 unsafe { from_glib(val:ffi::gst_qos_type_get_type()) }
2382 }
2383}
2384
2385impl glib::HasParamSpec for QOSType {
2386 type ParamSpec = glib::ParamSpecEnum;
2387 type SetValue = Self;
2388 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2389
2390 fn param_spec_builder() -> Self::BuilderFn {
2391 Self::ParamSpec::builder_with_default
2392 }
2393}
2394
2395impl glib::value::ValueType for QOSType {
2396 type Type = Self;
2397}
2398
2399unsafe impl<'a> glib::value::FromValue<'a> for QOSType {
2400 type Checker = glib::value::GenericValueTypeChecker<Self>;
2401
2402 #[inline]
2403 unsafe fn from_value(value: &'a glib::Value) -> Self {
2404 skip_assert_initialized!();
2405 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2406 }
2407}
2408
2409impl ToValue for QOSType {
2410 #[inline]
2411 fn to_value(&self) -> glib::Value {
2412 let mut value: Value = glib::Value::for_value_type::<Self>();
2413 unsafe {
2414 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2415 }
2416 value
2417 }
2418
2419 #[inline]
2420 fn value_type(&self) -> glib::Type {
2421 Self::static_type()
2422 }
2423}
2424
2425impl From<QOSType> for glib::Value {
2426 #[inline]
2427 fn from(v: QOSType) -> Self {
2428 skip_assert_initialized!();
2429 ToValue::to_value(&v)
2430 }
2431}
2432
2433#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2434#[non_exhaustive]
2435#[doc(alias = "GstResourceError")]
2436pub enum ResourceError {
2437 #[doc(alias = "GST_RESOURCE_ERROR_FAILED")]
2438 Failed,
2439 #[doc(alias = "GST_RESOURCE_ERROR_TOO_LAZY")]
2440 TooLazy,
2441 #[doc(alias = "GST_RESOURCE_ERROR_NOT_FOUND")]
2442 NotFound,
2443 #[doc(alias = "GST_RESOURCE_ERROR_BUSY")]
2444 Busy,
2445 #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ")]
2446 OpenRead,
2447 #[doc(alias = "GST_RESOURCE_ERROR_OPEN_WRITE")]
2448 OpenWrite,
2449 #[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ_WRITE")]
2450 OpenReadWrite,
2451 #[doc(alias = "GST_RESOURCE_ERROR_CLOSE")]
2452 Close,
2453 #[doc(alias = "GST_RESOURCE_ERROR_READ")]
2454 Read,
2455 #[doc(alias = "GST_RESOURCE_ERROR_WRITE")]
2456 Write,
2457 #[doc(alias = "GST_RESOURCE_ERROR_SEEK")]
2458 Seek,
2459 #[doc(alias = "GST_RESOURCE_ERROR_SYNC")]
2460 Sync,
2461 #[doc(alias = "GST_RESOURCE_ERROR_SETTINGS")]
2462 Settings,
2463 #[doc(alias = "GST_RESOURCE_ERROR_NO_SPACE_LEFT")]
2464 NoSpaceLeft,
2465 #[doc(alias = "GST_RESOURCE_ERROR_NOT_AUTHORIZED")]
2466 NotAuthorized,
2467 #[doc(hidden)]
2468 __Unknown(i32),
2469}
2470
2471#[doc(hidden)]
2472impl IntoGlib for ResourceError {
2473 type GlibType = ffi::GstResourceError;
2474
2475 fn into_glib(self) -> ffi::GstResourceError {
2476 match self {
2477 Self::Failed => ffi::GST_RESOURCE_ERROR_FAILED,
2478 Self::TooLazy => ffi::GST_RESOURCE_ERROR_TOO_LAZY,
2479 Self::NotFound => ffi::GST_RESOURCE_ERROR_NOT_FOUND,
2480 Self::Busy => ffi::GST_RESOURCE_ERROR_BUSY,
2481 Self::OpenRead => ffi::GST_RESOURCE_ERROR_OPEN_READ,
2482 Self::OpenWrite => ffi::GST_RESOURCE_ERROR_OPEN_WRITE,
2483 Self::OpenReadWrite => ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE,
2484 Self::Close => ffi::GST_RESOURCE_ERROR_CLOSE,
2485 Self::Read => ffi::GST_RESOURCE_ERROR_READ,
2486 Self::Write => ffi::GST_RESOURCE_ERROR_WRITE,
2487 Self::Seek => ffi::GST_RESOURCE_ERROR_SEEK,
2488 Self::Sync => ffi::GST_RESOURCE_ERROR_SYNC,
2489 Self::Settings => ffi::GST_RESOURCE_ERROR_SETTINGS,
2490 Self::NoSpaceLeft => ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT,
2491 Self::NotAuthorized => ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED,
2492 Self::__Unknown(value: i32) => value,
2493 }
2494 }
2495}
2496
2497#[doc(hidden)]
2498impl FromGlib<ffi::GstResourceError> for ResourceError {
2499 unsafe fn from_glib(value: ffi::GstResourceError) -> Self {
2500 skip_assert_initialized!();
2501
2502 match value {
2503 ffi::GST_RESOURCE_ERROR_FAILED => Self::Failed,
2504 ffi::GST_RESOURCE_ERROR_TOO_LAZY => Self::TooLazy,
2505 ffi::GST_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
2506 ffi::GST_RESOURCE_ERROR_BUSY => Self::Busy,
2507 ffi::GST_RESOURCE_ERROR_OPEN_READ => Self::OpenRead,
2508 ffi::GST_RESOURCE_ERROR_OPEN_WRITE => Self::OpenWrite,
2509 ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE => Self::OpenReadWrite,
2510 ffi::GST_RESOURCE_ERROR_CLOSE => Self::Close,
2511 ffi::GST_RESOURCE_ERROR_READ => Self::Read,
2512 ffi::GST_RESOURCE_ERROR_WRITE => Self::Write,
2513 ffi::GST_RESOURCE_ERROR_SEEK => Self::Seek,
2514 ffi::GST_RESOURCE_ERROR_SYNC => Self::Sync,
2515 ffi::GST_RESOURCE_ERROR_SETTINGS => Self::Settings,
2516 ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT => Self::NoSpaceLeft,
2517 ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
2518 value: i32 => Self::__Unknown(value),
2519 }
2520 }
2521}
2522
2523impl glib::error::ErrorDomain for ResourceError {
2524 #[inline]
2525 fn domain() -> glib::Quark {
2526 skip_assert_initialized!();
2527
2528 unsafe { from_glib(val:ffi::gst_resource_error_quark()) }
2529 }
2530
2531 #[inline]
2532 fn code(self) -> i32 {
2533 self.into_glib()
2534 }
2535
2536 #[inline]
2537 #[allow(clippy::match_single_binding)]
2538 fn from(code: i32) -> Option<Self> {
2539 skip_assert_initialized!();
2540 match unsafe { from_glib(val:code) } {
2541 Self::__Unknown(_) => Some(Self::Failed),
2542 value: ResourceError => Some(value),
2543 }
2544 }
2545}
2546
2547impl StaticType for ResourceError {
2548 #[inline]
2549 #[doc(alias = "gst_resource_error_get_type")]
2550 fn static_type() -> glib::Type {
2551 unsafe { from_glib(val:ffi::gst_resource_error_get_type()) }
2552 }
2553}
2554
2555impl glib::HasParamSpec for ResourceError {
2556 type ParamSpec = glib::ParamSpecEnum;
2557 type SetValue = Self;
2558 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2559
2560 fn param_spec_builder() -> Self::BuilderFn {
2561 Self::ParamSpec::builder_with_default
2562 }
2563}
2564
2565impl glib::value::ValueType for ResourceError {
2566 type Type = Self;
2567}
2568
2569unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
2570 type Checker = glib::value::GenericValueTypeChecker<Self>;
2571
2572 #[inline]
2573 unsafe fn from_value(value: &'a glib::Value) -> Self {
2574 skip_assert_initialized!();
2575 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2576 }
2577}
2578
2579impl ToValue for ResourceError {
2580 #[inline]
2581 fn to_value(&self) -> glib::Value {
2582 let mut value: Value = glib::Value::for_value_type::<Self>();
2583 unsafe {
2584 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2585 }
2586 value
2587 }
2588
2589 #[inline]
2590 fn value_type(&self) -> glib::Type {
2591 Self::static_type()
2592 }
2593}
2594
2595impl From<ResourceError> for glib::Value {
2596 #[inline]
2597 fn from(v: ResourceError) -> Self {
2598 skip_assert_initialized!();
2599 ToValue::to_value(&v)
2600 }
2601}
2602
2603#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2604#[repr(i32)]
2605#[doc(alias = "GstSeekType")]
2606pub enum SeekType {
2607 #[doc(alias = "GST_SEEK_TYPE_NONE")]
2608 None = ffi::GST_SEEK_TYPE_NONE,
2609 #[doc(alias = "GST_SEEK_TYPE_SET")]
2610 Set = ffi::GST_SEEK_TYPE_SET,
2611 #[doc(alias = "GST_SEEK_TYPE_END")]
2612 End = ffi::GST_SEEK_TYPE_END,
2613}
2614
2615#[doc(hidden)]
2616impl IntoGlib for SeekType {
2617 type GlibType = ffi::GstSeekType;
2618
2619 #[inline]
2620 fn into_glib(self) -> ffi::GstSeekType {
2621 self as ffi::GstSeekType
2622 }
2623}
2624
2625#[doc(hidden)]
2626impl FromGlib<ffi::GstSeekType> for SeekType {
2627 #[inline]
2628 unsafe fn from_glib(value: ffi::GstSeekType) -> Self {
2629 skip_assert_initialized!();
2630
2631 debug_assert!([
2632 ffi::GST_SEEK_TYPE_NONE,
2633 ffi::GST_SEEK_TYPE_SET,
2634 ffi::GST_SEEK_TYPE_END
2635 ]
2636 .contains(&value));
2637 std::mem::transmute(src:value)
2638 }
2639}
2640
2641impl StaticType for SeekType {
2642 #[inline]
2643 #[doc(alias = "gst_seek_type_get_type")]
2644 fn static_type() -> glib::Type {
2645 unsafe { from_glib(val:ffi::gst_seek_type_get_type()) }
2646 }
2647}
2648
2649impl glib::HasParamSpec for SeekType {
2650 type ParamSpec = glib::ParamSpecEnum;
2651 type SetValue = Self;
2652 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2653
2654 fn param_spec_builder() -> Self::BuilderFn {
2655 Self::ParamSpec::builder_with_default
2656 }
2657}
2658
2659impl glib::value::ValueType for SeekType {
2660 type Type = Self;
2661}
2662
2663unsafe impl<'a> glib::value::FromValue<'a> for SeekType {
2664 type Checker = glib::value::GenericValueTypeChecker<Self>;
2665
2666 #[inline]
2667 unsafe fn from_value(value: &'a glib::Value) -> Self {
2668 skip_assert_initialized!();
2669 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2670 }
2671}
2672
2673impl ToValue for SeekType {
2674 #[inline]
2675 fn to_value(&self) -> glib::Value {
2676 let mut value: Value = glib::Value::for_value_type::<Self>();
2677 unsafe {
2678 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2679 }
2680 value
2681 }
2682
2683 #[inline]
2684 fn value_type(&self) -> glib::Type {
2685 Self::static_type()
2686 }
2687}
2688
2689impl From<SeekType> for glib::Value {
2690 #[inline]
2691 fn from(v: SeekType) -> Self {
2692 skip_assert_initialized!();
2693 ToValue::to_value(&v)
2694 }
2695}
2696
2697#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2698#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
2699#[repr(i32)]
2700#[doc(alias = "GstState")]
2701pub enum State {
2702 #[doc(alias = "GST_STATE_VOID_PENDING")]
2703 VoidPending = ffi::GST_STATE_VOID_PENDING,
2704 #[doc(alias = "GST_STATE_NULL")]
2705 Null = ffi::GST_STATE_NULL,
2706 #[doc(alias = "GST_STATE_READY")]
2707 Ready = ffi::GST_STATE_READY,
2708 #[doc(alias = "GST_STATE_PAUSED")]
2709 Paused = ffi::GST_STATE_PAUSED,
2710 #[doc(alias = "GST_STATE_PLAYING")]
2711 Playing = ffi::GST_STATE_PLAYING,
2712}
2713
2714#[doc(hidden)]
2715impl IntoGlib for State {
2716 type GlibType = ffi::GstState;
2717
2718 #[inline]
2719 fn into_glib(self) -> ffi::GstState {
2720 self as ffi::GstState
2721 }
2722}
2723
2724#[doc(hidden)]
2725impl FromGlib<ffi::GstState> for State {
2726 #[inline]
2727 unsafe fn from_glib(value: ffi::GstState) -> Self {
2728 skip_assert_initialized!();
2729
2730 debug_assert!([
2731 ffi::GST_STATE_VOID_PENDING,
2732 ffi::GST_STATE_NULL,
2733 ffi::GST_STATE_READY,
2734 ffi::GST_STATE_PAUSED,
2735 ffi::GST_STATE_PLAYING
2736 ]
2737 .contains(&value));
2738 std::mem::transmute(src:value)
2739 }
2740}
2741
2742impl StaticType for State {
2743 #[inline]
2744 #[doc(alias = "gst_state_get_type")]
2745 fn static_type() -> glib::Type {
2746 unsafe { from_glib(val:ffi::gst_state_get_type()) }
2747 }
2748}
2749
2750impl glib::HasParamSpec for State {
2751 type ParamSpec = glib::ParamSpecEnum;
2752 type SetValue = Self;
2753 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2754
2755 fn param_spec_builder() -> Self::BuilderFn {
2756 Self::ParamSpec::builder_with_default
2757 }
2758}
2759
2760impl glib::value::ValueType for State {
2761 type Type = Self;
2762}
2763
2764unsafe impl<'a> glib::value::FromValue<'a> for State {
2765 type Checker = glib::value::GenericValueTypeChecker<Self>;
2766
2767 #[inline]
2768 unsafe fn from_value(value: &'a glib::Value) -> Self {
2769 skip_assert_initialized!();
2770 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2771 }
2772}
2773
2774impl ToValue for State {
2775 #[inline]
2776 fn to_value(&self) -> glib::Value {
2777 let mut value: Value = glib::Value::for_value_type::<Self>();
2778 unsafe {
2779 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2780 }
2781 value
2782 }
2783
2784 #[inline]
2785 fn value_type(&self) -> glib::Type {
2786 Self::static_type()
2787 }
2788}
2789
2790impl From<State> for glib::Value {
2791 #[inline]
2792 fn from(v: State) -> Self {
2793 skip_assert_initialized!();
2794 ToValue::to_value(&v)
2795 }
2796}
2797
2798#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2799#[repr(i32)]
2800#[doc(alias = "GstStateChange")]
2801pub enum StateChange {
2802 #[doc(alias = "GST_STATE_CHANGE_NULL_TO_READY")]
2803 NullToReady = ffi::GST_STATE_CHANGE_NULL_TO_READY,
2804 #[doc(alias = "GST_STATE_CHANGE_READY_TO_PAUSED")]
2805 ReadyToPaused = ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
2806 #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PLAYING")]
2807 PausedToPlaying = ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
2808 #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PAUSED")]
2809 PlayingToPaused = ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
2810 #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_READY")]
2811 PausedToReady = ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
2812 #[doc(alias = "GST_STATE_CHANGE_READY_TO_NULL")]
2813 ReadyToNull = ffi::GST_STATE_CHANGE_READY_TO_NULL,
2814 #[doc(alias = "GST_STATE_CHANGE_NULL_TO_NULL")]
2815 NullToNull = ffi::GST_STATE_CHANGE_NULL_TO_NULL,
2816 #[doc(alias = "GST_STATE_CHANGE_READY_TO_READY")]
2817 ReadyToReady = ffi::GST_STATE_CHANGE_READY_TO_READY,
2818 #[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PAUSED")]
2819 PausedToPaused = ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
2820 #[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PLAYING")]
2821 PlayingToPlaying = ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING,
2822}
2823
2824impl StateChange {
2825 pub fn name<'a>(self) -> &'a GStr {
2826 unsafe {
2827 GStr::from_ptr(
2828 ffi::gst_state_change_get_name(self.into_glib())
2829 .as_ref()
2830 .expect(msg:"gst_state_change_get_name returned NULL"),
2831 )
2832 }
2833 }
2834}
2835
2836impl std::fmt::Display for StateChange {
2837 #[inline]
2838 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2839 f.write_str(&self.name())
2840 }
2841}
2842
2843#[doc(hidden)]
2844impl IntoGlib for StateChange {
2845 type GlibType = ffi::GstStateChange;
2846
2847 #[inline]
2848 fn into_glib(self) -> ffi::GstStateChange {
2849 self as ffi::GstStateChange
2850 }
2851}
2852
2853#[doc(hidden)]
2854impl FromGlib<ffi::GstStateChange> for StateChange {
2855 #[inline]
2856 unsafe fn from_glib(value: ffi::GstStateChange) -> Self {
2857 skip_assert_initialized!();
2858
2859 debug_assert!([
2860 ffi::GST_STATE_CHANGE_NULL_TO_READY,
2861 ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
2862 ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
2863 ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
2864 ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
2865 ffi::GST_STATE_CHANGE_READY_TO_NULL,
2866 ffi::GST_STATE_CHANGE_NULL_TO_NULL,
2867 ffi::GST_STATE_CHANGE_READY_TO_READY,
2868 ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
2869 ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING
2870 ]
2871 .contains(&value));
2872 std::mem::transmute(src:value)
2873 }
2874}
2875
2876impl StaticType for StateChange {
2877 #[inline]
2878 #[doc(alias = "gst_state_change_get_type")]
2879 fn static_type() -> glib::Type {
2880 unsafe { from_glib(val:ffi::gst_state_change_get_type()) }
2881 }
2882}
2883
2884impl glib::HasParamSpec for StateChange {
2885 type ParamSpec = glib::ParamSpecEnum;
2886 type SetValue = Self;
2887 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2888
2889 fn param_spec_builder() -> Self::BuilderFn {
2890 Self::ParamSpec::builder_with_default
2891 }
2892}
2893
2894impl glib::value::ValueType for StateChange {
2895 type Type = Self;
2896}
2897
2898unsafe impl<'a> glib::value::FromValue<'a> for StateChange {
2899 type Checker = glib::value::GenericValueTypeChecker<Self>;
2900
2901 #[inline]
2902 unsafe fn from_value(value: &'a glib::Value) -> Self {
2903 skip_assert_initialized!();
2904 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2905 }
2906}
2907
2908impl ToValue for StateChange {
2909 #[inline]
2910 fn to_value(&self) -> glib::Value {
2911 let mut value: Value = glib::Value::for_value_type::<Self>();
2912 unsafe {
2913 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2914 }
2915 value
2916 }
2917
2918 #[inline]
2919 fn value_type(&self) -> glib::Type {
2920 Self::static_type()
2921 }
2922}
2923
2924impl From<StateChange> for glib::Value {
2925 #[inline]
2926 fn from(v: StateChange) -> Self {
2927 skip_assert_initialized!();
2928 ToValue::to_value(&v)
2929 }
2930}
2931
2932#[must_use]
2933#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2934#[repr(i32)]
2935#[doc(alias = "GstStateChangeReturn")]
2936pub enum StateChangeReturn {
2937 #[doc(alias = "GST_STATE_CHANGE_FAILURE")]
2938 Failure = ffi::GST_STATE_CHANGE_FAILURE,
2939 #[doc(alias = "GST_STATE_CHANGE_SUCCESS")]
2940 Success = ffi::GST_STATE_CHANGE_SUCCESS,
2941 #[doc(alias = "GST_STATE_CHANGE_ASYNC")]
2942 Async = ffi::GST_STATE_CHANGE_ASYNC,
2943 #[doc(alias = "GST_STATE_CHANGE_NO_PREROLL")]
2944 NoPreroll = ffi::GST_STATE_CHANGE_NO_PREROLL,
2945}
2946
2947#[doc(hidden)]
2948impl IntoGlib for StateChangeReturn {
2949 type GlibType = ffi::GstStateChangeReturn;
2950
2951 #[inline]
2952 fn into_glib(self) -> ffi::GstStateChangeReturn {
2953 self as ffi::GstStateChangeReturn
2954 }
2955}
2956
2957#[doc(hidden)]
2958impl FromGlib<ffi::GstStateChangeReturn> for StateChangeReturn {
2959 #[inline]
2960 unsafe fn from_glib(value: ffi::GstStateChangeReturn) -> Self {
2961 skip_assert_initialized!();
2962
2963 debug_assert!([
2964 ffi::GST_STATE_CHANGE_FAILURE,
2965 ffi::GST_STATE_CHANGE_SUCCESS,
2966 ffi::GST_STATE_CHANGE_ASYNC,
2967 ffi::GST_STATE_CHANGE_NO_PREROLL
2968 ]
2969 .contains(&value));
2970 std::mem::transmute(src:value)
2971 }
2972}
2973
2974impl StaticType for StateChangeReturn {
2975 #[inline]
2976 #[doc(alias = "gst_state_change_return_get_type")]
2977 fn static_type() -> glib::Type {
2978 unsafe { from_glib(val:ffi::gst_state_change_return_get_type()) }
2979 }
2980}
2981
2982impl glib::HasParamSpec for StateChangeReturn {
2983 type ParamSpec = glib::ParamSpecEnum;
2984 type SetValue = Self;
2985 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2986
2987 fn param_spec_builder() -> Self::BuilderFn {
2988 Self::ParamSpec::builder_with_default
2989 }
2990}
2991
2992impl glib::value::ValueType for StateChangeReturn {
2993 type Type = Self;
2994}
2995
2996unsafe impl<'a> glib::value::FromValue<'a> for StateChangeReturn {
2997 type Checker = glib::value::GenericValueTypeChecker<Self>;
2998
2999 #[inline]
3000 unsafe fn from_value(value: &'a glib::Value) -> Self {
3001 skip_assert_initialized!();
3002 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3003 }
3004}
3005
3006impl ToValue for StateChangeReturn {
3007 #[inline]
3008 fn to_value(&self) -> glib::Value {
3009 let mut value: Value = glib::Value::for_value_type::<Self>();
3010 unsafe {
3011 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3012 }
3013 value
3014 }
3015
3016 #[inline]
3017 fn value_type(&self) -> glib::Type {
3018 Self::static_type()
3019 }
3020}
3021
3022impl From<StateChangeReturn> for glib::Value {
3023 #[inline]
3024 fn from(v: StateChangeReturn) -> Self {
3025 skip_assert_initialized!();
3026 ToValue::to_value(&v)
3027 }
3028}
3029
3030#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3031#[non_exhaustive]
3032#[doc(alias = "GstStreamError")]
3033pub enum StreamError {
3034 #[doc(alias = "GST_STREAM_ERROR_FAILED")]
3035 Failed,
3036 #[doc(alias = "GST_STREAM_ERROR_TOO_LAZY")]
3037 TooLazy,
3038 #[doc(alias = "GST_STREAM_ERROR_NOT_IMPLEMENTED")]
3039 NotImplemented,
3040 #[doc(alias = "GST_STREAM_ERROR_TYPE_NOT_FOUND")]
3041 TypeNotFound,
3042 #[doc(alias = "GST_STREAM_ERROR_WRONG_TYPE")]
3043 WrongType,
3044 #[doc(alias = "GST_STREAM_ERROR_CODEC_NOT_FOUND")]
3045 CodecNotFound,
3046 #[doc(alias = "GST_STREAM_ERROR_DECODE")]
3047 Decode,
3048 #[doc(alias = "GST_STREAM_ERROR_ENCODE")]
3049 Encode,
3050 #[doc(alias = "GST_STREAM_ERROR_DEMUX")]
3051 Demux,
3052 #[doc(alias = "GST_STREAM_ERROR_MUX")]
3053 Mux,
3054 #[doc(alias = "GST_STREAM_ERROR_FORMAT")]
3055 Format,
3056 #[doc(alias = "GST_STREAM_ERROR_DECRYPT")]
3057 Decrypt,
3058 #[doc(alias = "GST_STREAM_ERROR_DECRYPT_NOKEY")]
3059 DecryptNokey,
3060 #[doc(hidden)]
3061 __Unknown(i32),
3062}
3063
3064#[doc(hidden)]
3065impl IntoGlib for StreamError {
3066 type GlibType = ffi::GstStreamError;
3067
3068 fn into_glib(self) -> ffi::GstStreamError {
3069 match self {
3070 Self::Failed => ffi::GST_STREAM_ERROR_FAILED,
3071 Self::TooLazy => ffi::GST_STREAM_ERROR_TOO_LAZY,
3072 Self::NotImplemented => ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED,
3073 Self::TypeNotFound => ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND,
3074 Self::WrongType => ffi::GST_STREAM_ERROR_WRONG_TYPE,
3075 Self::CodecNotFound => ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND,
3076 Self::Decode => ffi::GST_STREAM_ERROR_DECODE,
3077 Self::Encode => ffi::GST_STREAM_ERROR_ENCODE,
3078 Self::Demux => ffi::GST_STREAM_ERROR_DEMUX,
3079 Self::Mux => ffi::GST_STREAM_ERROR_MUX,
3080 Self::Format => ffi::GST_STREAM_ERROR_FORMAT,
3081 Self::Decrypt => ffi::GST_STREAM_ERROR_DECRYPT,
3082 Self::DecryptNokey => ffi::GST_STREAM_ERROR_DECRYPT_NOKEY,
3083 Self::__Unknown(value: i32) => value,
3084 }
3085 }
3086}
3087
3088#[doc(hidden)]
3089impl FromGlib<ffi::GstStreamError> for StreamError {
3090 unsafe fn from_glib(value: ffi::GstStreamError) -> Self {
3091 skip_assert_initialized!();
3092
3093 match value {
3094 ffi::GST_STREAM_ERROR_FAILED => Self::Failed,
3095 ffi::GST_STREAM_ERROR_TOO_LAZY => Self::TooLazy,
3096 ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
3097 ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND => Self::TypeNotFound,
3098 ffi::GST_STREAM_ERROR_WRONG_TYPE => Self::WrongType,
3099 ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND => Self::CodecNotFound,
3100 ffi::GST_STREAM_ERROR_DECODE => Self::Decode,
3101 ffi::GST_STREAM_ERROR_ENCODE => Self::Encode,
3102 ffi::GST_STREAM_ERROR_DEMUX => Self::Demux,
3103 ffi::GST_STREAM_ERROR_MUX => Self::Mux,
3104 ffi::GST_STREAM_ERROR_FORMAT => Self::Format,
3105 ffi::GST_STREAM_ERROR_DECRYPT => Self::Decrypt,
3106 ffi::GST_STREAM_ERROR_DECRYPT_NOKEY => Self::DecryptNokey,
3107 value: i32 => Self::__Unknown(value),
3108 }
3109 }
3110}
3111
3112impl glib::error::ErrorDomain for StreamError {
3113 #[inline]
3114 fn domain() -> glib::Quark {
3115 skip_assert_initialized!();
3116
3117 unsafe { from_glib(val:ffi::gst_stream_error_quark()) }
3118 }
3119
3120 #[inline]
3121 fn code(self) -> i32 {
3122 self.into_glib()
3123 }
3124
3125 #[inline]
3126 #[allow(clippy::match_single_binding)]
3127 fn from(code: i32) -> Option<Self> {
3128 skip_assert_initialized!();
3129 match unsafe { from_glib(val:code) } {
3130 Self::__Unknown(_) => Some(Self::Failed),
3131 value: StreamError => Some(value),
3132 }
3133 }
3134}
3135
3136impl StaticType for StreamError {
3137 #[inline]
3138 #[doc(alias = "gst_stream_error_get_type")]
3139 fn static_type() -> glib::Type {
3140 unsafe { from_glib(val:ffi::gst_stream_error_get_type()) }
3141 }
3142}
3143
3144impl glib::HasParamSpec for StreamError {
3145 type ParamSpec = glib::ParamSpecEnum;
3146 type SetValue = Self;
3147 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3148
3149 fn param_spec_builder() -> Self::BuilderFn {
3150 Self::ParamSpec::builder_with_default
3151 }
3152}
3153
3154impl glib::value::ValueType for StreamError {
3155 type Type = Self;
3156}
3157
3158unsafe impl<'a> glib::value::FromValue<'a> for StreamError {
3159 type Checker = glib::value::GenericValueTypeChecker<Self>;
3160
3161 #[inline]
3162 unsafe fn from_value(value: &'a glib::Value) -> Self {
3163 skip_assert_initialized!();
3164 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3165 }
3166}
3167
3168impl ToValue for StreamError {
3169 #[inline]
3170 fn to_value(&self) -> glib::Value {
3171 let mut value: Value = glib::Value::for_value_type::<Self>();
3172 unsafe {
3173 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3174 }
3175 value
3176 }
3177
3178 #[inline]
3179 fn value_type(&self) -> glib::Type {
3180 Self::static_type()
3181 }
3182}
3183
3184impl From<StreamError> for glib::Value {
3185 #[inline]
3186 fn from(v: StreamError) -> Self {
3187 skip_assert_initialized!();
3188 ToValue::to_value(&v)
3189 }
3190}
3191
3192#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3193#[non_exhaustive]
3194#[doc(alias = "GstStreamStatusType")]
3195pub enum StreamStatusType {
3196 #[doc(alias = "GST_STREAM_STATUS_TYPE_CREATE")]
3197 Create,
3198 #[doc(alias = "GST_STREAM_STATUS_TYPE_ENTER")]
3199 Enter,
3200 #[doc(alias = "GST_STREAM_STATUS_TYPE_LEAVE")]
3201 Leave,
3202 #[doc(alias = "GST_STREAM_STATUS_TYPE_DESTROY")]
3203 Destroy,
3204 #[doc(alias = "GST_STREAM_STATUS_TYPE_START")]
3205 Start,
3206 #[doc(alias = "GST_STREAM_STATUS_TYPE_PAUSE")]
3207 Pause,
3208 #[doc(alias = "GST_STREAM_STATUS_TYPE_STOP")]
3209 Stop,
3210 #[doc(hidden)]
3211 __Unknown(i32),
3212}
3213
3214#[doc(hidden)]
3215impl IntoGlib for StreamStatusType {
3216 type GlibType = ffi::GstStreamStatusType;
3217
3218 #[inline]
3219 fn into_glib(self) -> ffi::GstStreamStatusType {
3220 match self {
3221 Self::Create => ffi::GST_STREAM_STATUS_TYPE_CREATE,
3222 Self::Enter => ffi::GST_STREAM_STATUS_TYPE_ENTER,
3223 Self::Leave => ffi::GST_STREAM_STATUS_TYPE_LEAVE,
3224 Self::Destroy => ffi::GST_STREAM_STATUS_TYPE_DESTROY,
3225 Self::Start => ffi::GST_STREAM_STATUS_TYPE_START,
3226 Self::Pause => ffi::GST_STREAM_STATUS_TYPE_PAUSE,
3227 Self::Stop => ffi::GST_STREAM_STATUS_TYPE_STOP,
3228 Self::__Unknown(value: i32) => value,
3229 }
3230 }
3231}
3232
3233#[doc(hidden)]
3234impl FromGlib<ffi::GstStreamStatusType> for StreamStatusType {
3235 #[inline]
3236 unsafe fn from_glib(value: ffi::GstStreamStatusType) -> Self {
3237 skip_assert_initialized!();
3238
3239 match value {
3240 ffi::GST_STREAM_STATUS_TYPE_CREATE => Self::Create,
3241 ffi::GST_STREAM_STATUS_TYPE_ENTER => Self::Enter,
3242 ffi::GST_STREAM_STATUS_TYPE_LEAVE => Self::Leave,
3243 ffi::GST_STREAM_STATUS_TYPE_DESTROY => Self::Destroy,
3244 ffi::GST_STREAM_STATUS_TYPE_START => Self::Start,
3245 ffi::GST_STREAM_STATUS_TYPE_PAUSE => Self::Pause,
3246 ffi::GST_STREAM_STATUS_TYPE_STOP => Self::Stop,
3247 value: i32 => Self::__Unknown(value),
3248 }
3249 }
3250}
3251
3252impl StaticType for StreamStatusType {
3253 #[inline]
3254 #[doc(alias = "gst_stream_status_type_get_type")]
3255 fn static_type() -> glib::Type {
3256 unsafe { from_glib(val:ffi::gst_stream_status_type_get_type()) }
3257 }
3258}
3259
3260impl glib::HasParamSpec for StreamStatusType {
3261 type ParamSpec = glib::ParamSpecEnum;
3262 type SetValue = Self;
3263 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3264
3265 fn param_spec_builder() -> Self::BuilderFn {
3266 Self::ParamSpec::builder_with_default
3267 }
3268}
3269
3270impl glib::value::ValueType for StreamStatusType {
3271 type Type = Self;
3272}
3273
3274unsafe impl<'a> glib::value::FromValue<'a> for StreamStatusType {
3275 type Checker = glib::value::GenericValueTypeChecker<Self>;
3276
3277 #[inline]
3278 unsafe fn from_value(value: &'a glib::Value) -> Self {
3279 skip_assert_initialized!();
3280 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3281 }
3282}
3283
3284impl ToValue for StreamStatusType {
3285 #[inline]
3286 fn to_value(&self) -> glib::Value {
3287 let mut value: Value = glib::Value::for_value_type::<Self>();
3288 unsafe {
3289 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3290 }
3291 value
3292 }
3293
3294 #[inline]
3295 fn value_type(&self) -> glib::Type {
3296 Self::static_type()
3297 }
3298}
3299
3300impl From<StreamStatusType> for glib::Value {
3301 #[inline]
3302 fn from(v: StreamStatusType) -> Self {
3303 skip_assert_initialized!();
3304 ToValue::to_value(&v)
3305 }
3306}
3307
3308#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3309#[non_exhaustive]
3310#[doc(alias = "GstStructureChangeType")]
3311pub enum StructureChangeType {
3312 #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_LINK")]
3313 Link,
3314 #[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK")]
3315 Unlink,
3316 #[doc(hidden)]
3317 __Unknown(i32),
3318}
3319
3320#[doc(hidden)]
3321impl IntoGlib for StructureChangeType {
3322 type GlibType = ffi::GstStructureChangeType;
3323
3324 #[inline]
3325 fn into_glib(self) -> ffi::GstStructureChangeType {
3326 match self {
3327 Self::Link => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK,
3328 Self::Unlink => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK,
3329 Self::__Unknown(value: i32) => value,
3330 }
3331 }
3332}
3333
3334#[doc(hidden)]
3335impl FromGlib<ffi::GstStructureChangeType> for StructureChangeType {
3336 #[inline]
3337 unsafe fn from_glib(value: ffi::GstStructureChangeType) -> Self {
3338 skip_assert_initialized!();
3339
3340 match value {
3341 ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK => Self::Link,
3342 ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK => Self::Unlink,
3343 value: i32 => Self::__Unknown(value),
3344 }
3345 }
3346}
3347
3348impl StaticType for StructureChangeType {
3349 #[inline]
3350 #[doc(alias = "gst_structure_change_type_get_type")]
3351 fn static_type() -> glib::Type {
3352 unsafe { from_glib(val:ffi::gst_structure_change_type_get_type()) }
3353 }
3354}
3355
3356impl glib::HasParamSpec for StructureChangeType {
3357 type ParamSpec = glib::ParamSpecEnum;
3358 type SetValue = Self;
3359 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3360
3361 fn param_spec_builder() -> Self::BuilderFn {
3362 Self::ParamSpec::builder_with_default
3363 }
3364}
3365
3366impl glib::value::ValueType for StructureChangeType {
3367 type Type = Self;
3368}
3369
3370unsafe impl<'a> glib::value::FromValue<'a> for StructureChangeType {
3371 type Checker = glib::value::GenericValueTypeChecker<Self>;
3372
3373 #[inline]
3374 unsafe fn from_value(value: &'a glib::Value) -> Self {
3375 skip_assert_initialized!();
3376 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3377 }
3378}
3379
3380impl ToValue for StructureChangeType {
3381 #[inline]
3382 fn to_value(&self) -> glib::Value {
3383 let mut value: Value = glib::Value::for_value_type::<Self>();
3384 unsafe {
3385 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3386 }
3387 value
3388 }
3389
3390 #[inline]
3391 fn value_type(&self) -> glib::Type {
3392 Self::static_type()
3393 }
3394}
3395
3396impl From<StructureChangeType> for glib::Value {
3397 #[inline]
3398 fn from(v: StructureChangeType) -> Self {
3399 skip_assert_initialized!();
3400 ToValue::to_value(&v)
3401 }
3402}
3403
3404#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3405#[non_exhaustive]
3406#[doc(alias = "GstTagFlag")]
3407pub enum TagFlag {
3408 #[doc(alias = "GST_TAG_FLAG_UNDEFINED")]
3409 Undefined,
3410 #[doc(alias = "GST_TAG_FLAG_META")]
3411 Meta,
3412 #[doc(alias = "GST_TAG_FLAG_ENCODED")]
3413 Encoded,
3414 #[doc(alias = "GST_TAG_FLAG_DECODED")]
3415 Decoded,
3416 #[doc(hidden)]
3417 __Unknown(i32),
3418}
3419
3420#[doc(hidden)]
3421impl IntoGlib for TagFlag {
3422 type GlibType = ffi::GstTagFlag;
3423
3424 #[inline]
3425 fn into_glib(self) -> ffi::GstTagFlag {
3426 match self {
3427 Self::Undefined => ffi::GST_TAG_FLAG_UNDEFINED,
3428 Self::Meta => ffi::GST_TAG_FLAG_META,
3429 Self::Encoded => ffi::GST_TAG_FLAG_ENCODED,
3430 Self::Decoded => ffi::GST_TAG_FLAG_DECODED,
3431 Self::__Unknown(value: i32) => value,
3432 }
3433 }
3434}
3435
3436#[doc(hidden)]
3437impl FromGlib<ffi::GstTagFlag> for TagFlag {
3438 #[inline]
3439 unsafe fn from_glib(value: ffi::GstTagFlag) -> Self {
3440 skip_assert_initialized!();
3441
3442 match value {
3443 ffi::GST_TAG_FLAG_UNDEFINED => Self::Undefined,
3444 ffi::GST_TAG_FLAG_META => Self::Meta,
3445 ffi::GST_TAG_FLAG_ENCODED => Self::Encoded,
3446 ffi::GST_TAG_FLAG_DECODED => Self::Decoded,
3447 value: i32 => Self::__Unknown(value),
3448 }
3449 }
3450}
3451
3452impl StaticType for TagFlag {
3453 #[inline]
3454 #[doc(alias = "gst_tag_flag_get_type")]
3455 fn static_type() -> glib::Type {
3456 unsafe { from_glib(val:ffi::gst_tag_flag_get_type()) }
3457 }
3458}
3459
3460impl glib::HasParamSpec for TagFlag {
3461 type ParamSpec = glib::ParamSpecEnum;
3462 type SetValue = Self;
3463 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3464
3465 fn param_spec_builder() -> Self::BuilderFn {
3466 Self::ParamSpec::builder_with_default
3467 }
3468}
3469
3470impl glib::value::ValueType for TagFlag {
3471 type Type = Self;
3472}
3473
3474unsafe impl<'a> glib::value::FromValue<'a> for TagFlag {
3475 type Checker = glib::value::GenericValueTypeChecker<Self>;
3476
3477 #[inline]
3478 unsafe fn from_value(value: &'a glib::Value) -> Self {
3479 skip_assert_initialized!();
3480 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3481 }
3482}
3483
3484impl ToValue for TagFlag {
3485 #[inline]
3486 fn to_value(&self) -> glib::Value {
3487 let mut value: Value = glib::Value::for_value_type::<Self>();
3488 unsafe {
3489 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3490 }
3491 value
3492 }
3493
3494 #[inline]
3495 fn value_type(&self) -> glib::Type {
3496 Self::static_type()
3497 }
3498}
3499
3500impl From<TagFlag> for glib::Value {
3501 #[inline]
3502 fn from(v: TagFlag) -> Self {
3503 skip_assert_initialized!();
3504 ToValue::to_value(&v)
3505 }
3506}
3507
3508#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3509#[non_exhaustive]
3510#[doc(alias = "GstTagMergeMode")]
3511pub enum TagMergeMode {
3512 #[doc(alias = "GST_TAG_MERGE_UNDEFINED")]
3513 Undefined,
3514 #[doc(alias = "GST_TAG_MERGE_REPLACE_ALL")]
3515 ReplaceAll,
3516 #[doc(alias = "GST_TAG_MERGE_REPLACE")]
3517 Replace,
3518 #[doc(alias = "GST_TAG_MERGE_APPEND")]
3519 Append,
3520 #[doc(alias = "GST_TAG_MERGE_PREPEND")]
3521 Prepend,
3522 #[doc(alias = "GST_TAG_MERGE_KEEP")]
3523 Keep,
3524 #[doc(alias = "GST_TAG_MERGE_KEEP_ALL")]
3525 KeepAll,
3526 #[doc(hidden)]
3527 __Unknown(i32),
3528}
3529
3530#[doc(hidden)]
3531impl IntoGlib for TagMergeMode {
3532 type GlibType = ffi::GstTagMergeMode;
3533
3534 #[inline]
3535 fn into_glib(self) -> ffi::GstTagMergeMode {
3536 match self {
3537 Self::Undefined => ffi::GST_TAG_MERGE_UNDEFINED,
3538 Self::ReplaceAll => ffi::GST_TAG_MERGE_REPLACE_ALL,
3539 Self::Replace => ffi::GST_TAG_MERGE_REPLACE,
3540 Self::Append => ffi::GST_TAG_MERGE_APPEND,
3541 Self::Prepend => ffi::GST_TAG_MERGE_PREPEND,
3542 Self::Keep => ffi::GST_TAG_MERGE_KEEP,
3543 Self::KeepAll => ffi::GST_TAG_MERGE_KEEP_ALL,
3544 Self::__Unknown(value: i32) => value,
3545 }
3546 }
3547}
3548
3549#[doc(hidden)]
3550impl FromGlib<ffi::GstTagMergeMode> for TagMergeMode {
3551 #[inline]
3552 unsafe fn from_glib(value: ffi::GstTagMergeMode) -> Self {
3553 skip_assert_initialized!();
3554
3555 match value {
3556 ffi::GST_TAG_MERGE_UNDEFINED => Self::Undefined,
3557 ffi::GST_TAG_MERGE_REPLACE_ALL => Self::ReplaceAll,
3558 ffi::GST_TAG_MERGE_REPLACE => Self::Replace,
3559 ffi::GST_TAG_MERGE_APPEND => Self::Append,
3560 ffi::GST_TAG_MERGE_PREPEND => Self::Prepend,
3561 ffi::GST_TAG_MERGE_KEEP => Self::Keep,
3562 ffi::GST_TAG_MERGE_KEEP_ALL => Self::KeepAll,
3563 value: i32 => Self::__Unknown(value),
3564 }
3565 }
3566}
3567
3568impl StaticType for TagMergeMode {
3569 #[inline]
3570 #[doc(alias = "gst_tag_merge_mode_get_type")]
3571 fn static_type() -> glib::Type {
3572 unsafe { from_glib(val:ffi::gst_tag_merge_mode_get_type()) }
3573 }
3574}
3575
3576impl glib::HasParamSpec for TagMergeMode {
3577 type ParamSpec = glib::ParamSpecEnum;
3578 type SetValue = Self;
3579 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3580
3581 fn param_spec_builder() -> Self::BuilderFn {
3582 Self::ParamSpec::builder_with_default
3583 }
3584}
3585
3586impl glib::value::ValueType for TagMergeMode {
3587 type Type = Self;
3588}
3589
3590unsafe impl<'a> glib::value::FromValue<'a> for TagMergeMode {
3591 type Checker = glib::value::GenericValueTypeChecker<Self>;
3592
3593 #[inline]
3594 unsafe fn from_value(value: &'a glib::Value) -> Self {
3595 skip_assert_initialized!();
3596 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3597 }
3598}
3599
3600impl ToValue for TagMergeMode {
3601 #[inline]
3602 fn to_value(&self) -> glib::Value {
3603 let mut value: Value = glib::Value::for_value_type::<Self>();
3604 unsafe {
3605 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3606 }
3607 value
3608 }
3609
3610 #[inline]
3611 fn value_type(&self) -> glib::Type {
3612 Self::static_type()
3613 }
3614}
3615
3616impl From<TagMergeMode> for glib::Value {
3617 #[inline]
3618 fn from(v: TagMergeMode) -> Self {
3619 skip_assert_initialized!();
3620 ToValue::to_value(&v)
3621 }
3622}
3623
3624#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3625#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
3626#[non_exhaustive]
3627#[doc(alias = "GstTagScope")]
3628pub enum TagScope {
3629 #[doc(alias = "GST_TAG_SCOPE_STREAM")]
3630 Stream,
3631 #[doc(alias = "GST_TAG_SCOPE_GLOBAL")]
3632 Global,
3633 #[doc(hidden)]
3634 __Unknown(i32),
3635}
3636
3637#[doc(hidden)]
3638impl IntoGlib for TagScope {
3639 type GlibType = ffi::GstTagScope;
3640
3641 #[inline]
3642 fn into_glib(self) -> ffi::GstTagScope {
3643 match self {
3644 Self::Stream => ffi::GST_TAG_SCOPE_STREAM,
3645 Self::Global => ffi::GST_TAG_SCOPE_GLOBAL,
3646 Self::__Unknown(value: i32) => value,
3647 }
3648 }
3649}
3650
3651#[doc(hidden)]
3652impl FromGlib<ffi::GstTagScope> for TagScope {
3653 #[inline]
3654 unsafe fn from_glib(value: ffi::GstTagScope) -> Self {
3655 skip_assert_initialized!();
3656
3657 match value {
3658 ffi::GST_TAG_SCOPE_STREAM => Self::Stream,
3659 ffi::GST_TAG_SCOPE_GLOBAL => Self::Global,
3660 value: i32 => Self::__Unknown(value),
3661 }
3662 }
3663}
3664
3665impl StaticType for TagScope {
3666 #[inline]
3667 #[doc(alias = "gst_tag_scope_get_type")]
3668 fn static_type() -> glib::Type {
3669 unsafe { from_glib(val:ffi::gst_tag_scope_get_type()) }
3670 }
3671}
3672
3673impl glib::HasParamSpec for TagScope {
3674 type ParamSpec = glib::ParamSpecEnum;
3675 type SetValue = Self;
3676 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3677
3678 fn param_spec_builder() -> Self::BuilderFn {
3679 Self::ParamSpec::builder_with_default
3680 }
3681}
3682
3683impl glib::value::ValueType for TagScope {
3684 type Type = Self;
3685}
3686
3687unsafe impl<'a> glib::value::FromValue<'a> for TagScope {
3688 type Checker = glib::value::GenericValueTypeChecker<Self>;
3689
3690 #[inline]
3691 unsafe fn from_value(value: &'a glib::Value) -> Self {
3692 skip_assert_initialized!();
3693 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3694 }
3695}
3696
3697impl ToValue for TagScope {
3698 #[inline]
3699 fn to_value(&self) -> glib::Value {
3700 let mut value: Value = glib::Value::for_value_type::<Self>();
3701 unsafe {
3702 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3703 }
3704 value
3705 }
3706
3707 #[inline]
3708 fn value_type(&self) -> glib::Type {
3709 Self::static_type()
3710 }
3711}
3712
3713impl From<TagScope> for glib::Value {
3714 #[inline]
3715 fn from(v: TagScope) -> Self {
3716 skip_assert_initialized!();
3717 ToValue::to_value(&v)
3718 }
3719}
3720
3721#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3722#[non_exhaustive]
3723#[doc(alias = "GstTaskState")]
3724pub enum TaskState {
3725 #[doc(alias = "GST_TASK_STARTED")]
3726 Started,
3727 #[doc(alias = "GST_TASK_STOPPED")]
3728 Stopped,
3729 #[doc(alias = "GST_TASK_PAUSED")]
3730 Paused,
3731 #[doc(hidden)]
3732 __Unknown(i32),
3733}
3734
3735#[doc(hidden)]
3736impl IntoGlib for TaskState {
3737 type GlibType = ffi::GstTaskState;
3738
3739 #[inline]
3740 fn into_glib(self) -> ffi::GstTaskState {
3741 match self {
3742 Self::Started => ffi::GST_TASK_STARTED,
3743 Self::Stopped => ffi::GST_TASK_STOPPED,
3744 Self::Paused => ffi::GST_TASK_PAUSED,
3745 Self::__Unknown(value: i32) => value,
3746 }
3747 }
3748}
3749
3750#[doc(hidden)]
3751impl FromGlib<ffi::GstTaskState> for TaskState {
3752 #[inline]
3753 unsafe fn from_glib(value: ffi::GstTaskState) -> Self {
3754 skip_assert_initialized!();
3755
3756 match value {
3757 ffi::GST_TASK_STARTED => Self::Started,
3758 ffi::GST_TASK_STOPPED => Self::Stopped,
3759 ffi::GST_TASK_PAUSED => Self::Paused,
3760 value: i32 => Self::__Unknown(value),
3761 }
3762 }
3763}
3764
3765impl StaticType for TaskState {
3766 #[inline]
3767 #[doc(alias = "gst_task_state_get_type")]
3768 fn static_type() -> glib::Type {
3769 unsafe { from_glib(val:ffi::gst_task_state_get_type()) }
3770 }
3771}
3772
3773impl glib::HasParamSpec for TaskState {
3774 type ParamSpec = glib::ParamSpecEnum;
3775 type SetValue = Self;
3776 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3777
3778 fn param_spec_builder() -> Self::BuilderFn {
3779 Self::ParamSpec::builder_with_default
3780 }
3781}
3782
3783impl glib::value::ValueType for TaskState {
3784 type Type = Self;
3785}
3786
3787unsafe impl<'a> glib::value::FromValue<'a> for TaskState {
3788 type Checker = glib::value::GenericValueTypeChecker<Self>;
3789
3790 #[inline]
3791 unsafe fn from_value(value: &'a glib::Value) -> Self {
3792 skip_assert_initialized!();
3793 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3794 }
3795}
3796
3797impl ToValue for TaskState {
3798 #[inline]
3799 fn to_value(&self) -> glib::Value {
3800 let mut value: Value = glib::Value::for_value_type::<Self>();
3801 unsafe {
3802 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3803 }
3804 value
3805 }
3806
3807 #[inline]
3808 fn value_type(&self) -> glib::Type {
3809 Self::static_type()
3810 }
3811}
3812
3813impl From<TaskState> for glib::Value {
3814 #[inline]
3815 fn from(v: TaskState) -> Self {
3816 skip_assert_initialized!();
3817 ToValue::to_value(&v)
3818 }
3819}
3820
3821#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3822#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
3823#[non_exhaustive]
3824#[doc(alias = "GstTocEntryType")]
3825pub enum TocEntryType {
3826 #[doc(alias = "GST_TOC_ENTRY_TYPE_ANGLE")]
3827 Angle,
3828 #[doc(alias = "GST_TOC_ENTRY_TYPE_VERSION")]
3829 Version,
3830 #[doc(alias = "GST_TOC_ENTRY_TYPE_EDITION")]
3831 Edition,
3832 #[doc(alias = "GST_TOC_ENTRY_TYPE_INVALID")]
3833 Invalid,
3834 #[doc(alias = "GST_TOC_ENTRY_TYPE_TITLE")]
3835 Title,
3836 #[doc(alias = "GST_TOC_ENTRY_TYPE_TRACK")]
3837 Track,
3838 #[doc(alias = "GST_TOC_ENTRY_TYPE_CHAPTER")]
3839 Chapter,
3840 #[doc(hidden)]
3841 __Unknown(i32),
3842}
3843
3844impl TocEntryType {
3845 pub fn nick<'a>(self) -> &'a GStr {
3846 unsafe {
3847 GStr::from_ptr(
3848 ffi::gst_toc_entry_type_get_nick(self.into_glib())
3849 .as_ref()
3850 .expect(msg:"gst_toc_entry_type_get_nick returned NULL"),
3851 )
3852 }
3853 }
3854}
3855
3856#[doc(hidden)]
3857impl IntoGlib for TocEntryType {
3858 type GlibType = ffi::GstTocEntryType;
3859
3860 #[inline]
3861 fn into_glib(self) -> ffi::GstTocEntryType {
3862 match self {
3863 Self::Angle => ffi::GST_TOC_ENTRY_TYPE_ANGLE,
3864 Self::Version => ffi::GST_TOC_ENTRY_TYPE_VERSION,
3865 Self::Edition => ffi::GST_TOC_ENTRY_TYPE_EDITION,
3866 Self::Invalid => ffi::GST_TOC_ENTRY_TYPE_INVALID,
3867 Self::Title => ffi::GST_TOC_ENTRY_TYPE_TITLE,
3868 Self::Track => ffi::GST_TOC_ENTRY_TYPE_TRACK,
3869 Self::Chapter => ffi::GST_TOC_ENTRY_TYPE_CHAPTER,
3870 Self::__Unknown(value: i32) => value,
3871 }
3872 }
3873}
3874
3875#[doc(hidden)]
3876impl FromGlib<ffi::GstTocEntryType> for TocEntryType {
3877 #[inline]
3878 unsafe fn from_glib(value: ffi::GstTocEntryType) -> Self {
3879 skip_assert_initialized!();
3880
3881 match value {
3882 ffi::GST_TOC_ENTRY_TYPE_ANGLE => Self::Angle,
3883 ffi::GST_TOC_ENTRY_TYPE_VERSION => Self::Version,
3884 ffi::GST_TOC_ENTRY_TYPE_EDITION => Self::Edition,
3885 ffi::GST_TOC_ENTRY_TYPE_INVALID => Self::Invalid,
3886 ffi::GST_TOC_ENTRY_TYPE_TITLE => Self::Title,
3887 ffi::GST_TOC_ENTRY_TYPE_TRACK => Self::Track,
3888 ffi::GST_TOC_ENTRY_TYPE_CHAPTER => Self::Chapter,
3889 value: i32 => Self::__Unknown(value),
3890 }
3891 }
3892}
3893
3894impl StaticType for TocEntryType {
3895 #[inline]
3896 #[doc(alias = "gst_toc_entry_type_get_type")]
3897 fn static_type() -> glib::Type {
3898 unsafe { from_glib(val:ffi::gst_toc_entry_type_get_type()) }
3899 }
3900}
3901
3902impl glib::HasParamSpec for TocEntryType {
3903 type ParamSpec = glib::ParamSpecEnum;
3904 type SetValue = Self;
3905 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3906
3907 fn param_spec_builder() -> Self::BuilderFn {
3908 Self::ParamSpec::builder_with_default
3909 }
3910}
3911
3912impl glib::value::ValueType for TocEntryType {
3913 type Type = Self;
3914}
3915
3916unsafe impl<'a> glib::value::FromValue<'a> for TocEntryType {
3917 type Checker = glib::value::GenericValueTypeChecker<Self>;
3918
3919 #[inline]
3920 unsafe fn from_value(value: &'a glib::Value) -> Self {
3921 skip_assert_initialized!();
3922 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3923 }
3924}
3925
3926impl ToValue for TocEntryType {
3927 #[inline]
3928 fn to_value(&self) -> glib::Value {
3929 let mut value: Value = glib::Value::for_value_type::<Self>();
3930 unsafe {
3931 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3932 }
3933 value
3934 }
3935
3936 #[inline]
3937 fn value_type(&self) -> glib::Type {
3938 Self::static_type()
3939 }
3940}
3941
3942impl From<TocEntryType> for glib::Value {
3943 #[inline]
3944 fn from(v: TocEntryType) -> Self {
3945 skip_assert_initialized!();
3946 ToValue::to_value(&v)
3947 }
3948}
3949
3950#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3951#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
3952#[non_exhaustive]
3953#[doc(alias = "GstTocLoopType")]
3954pub enum TocLoopType {
3955 #[doc(alias = "GST_TOC_LOOP_NONE")]
3956 None,
3957 #[doc(alias = "GST_TOC_LOOP_FORWARD")]
3958 Forward,
3959 #[doc(alias = "GST_TOC_LOOP_REVERSE")]
3960 Reverse,
3961 #[doc(alias = "GST_TOC_LOOP_PING_PONG")]
3962 PingPong,
3963 #[doc(hidden)]
3964 __Unknown(i32),
3965}
3966
3967#[doc(hidden)]
3968impl IntoGlib for TocLoopType {
3969 type GlibType = ffi::GstTocLoopType;
3970
3971 #[inline]
3972 fn into_glib(self) -> ffi::GstTocLoopType {
3973 match self {
3974 Self::None => ffi::GST_TOC_LOOP_NONE,
3975 Self::Forward => ffi::GST_TOC_LOOP_FORWARD,
3976 Self::Reverse => ffi::GST_TOC_LOOP_REVERSE,
3977 Self::PingPong => ffi::GST_TOC_LOOP_PING_PONG,
3978 Self::__Unknown(value: i32) => value,
3979 }
3980 }
3981}
3982
3983#[doc(hidden)]
3984impl FromGlib<ffi::GstTocLoopType> for TocLoopType {
3985 #[inline]
3986 unsafe fn from_glib(value: ffi::GstTocLoopType) -> Self {
3987 skip_assert_initialized!();
3988
3989 match value {
3990 ffi::GST_TOC_LOOP_NONE => Self::None,
3991 ffi::GST_TOC_LOOP_FORWARD => Self::Forward,
3992 ffi::GST_TOC_LOOP_REVERSE => Self::Reverse,
3993 ffi::GST_TOC_LOOP_PING_PONG => Self::PingPong,
3994 value: i32 => Self::__Unknown(value),
3995 }
3996 }
3997}
3998
3999impl StaticType for TocLoopType {
4000 #[inline]
4001 #[doc(alias = "gst_toc_loop_type_get_type")]
4002 fn static_type() -> glib::Type {
4003 unsafe { from_glib(val:ffi::gst_toc_loop_type_get_type()) }
4004 }
4005}
4006
4007impl glib::HasParamSpec for TocLoopType {
4008 type ParamSpec = glib::ParamSpecEnum;
4009 type SetValue = Self;
4010 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4011
4012 fn param_spec_builder() -> Self::BuilderFn {
4013 Self::ParamSpec::builder_with_default
4014 }
4015}
4016
4017impl glib::value::ValueType for TocLoopType {
4018 type Type = Self;
4019}
4020
4021unsafe impl<'a> glib::value::FromValue<'a> for TocLoopType {
4022 type Checker = glib::value::GenericValueTypeChecker<Self>;
4023
4024 #[inline]
4025 unsafe fn from_value(value: &'a glib::Value) -> Self {
4026 skip_assert_initialized!();
4027 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4028 }
4029}
4030
4031impl ToValue for TocLoopType {
4032 #[inline]
4033 fn to_value(&self) -> glib::Value {
4034 let mut value: Value = glib::Value::for_value_type::<Self>();
4035 unsafe {
4036 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4037 }
4038 value
4039 }
4040
4041 #[inline]
4042 fn value_type(&self) -> glib::Type {
4043 Self::static_type()
4044 }
4045}
4046
4047impl From<TocLoopType> for glib::Value {
4048 #[inline]
4049 fn from(v: TocLoopType) -> Self {
4050 skip_assert_initialized!();
4051 ToValue::to_value(&v)
4052 }
4053}
4054
4055#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4056#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
4057#[non_exhaustive]
4058#[doc(alias = "GstTocScope")]
4059pub enum TocScope {
4060 #[doc(alias = "GST_TOC_SCOPE_GLOBAL")]
4061 Global,
4062 #[doc(alias = "GST_TOC_SCOPE_CURRENT")]
4063 Current,
4064 #[doc(hidden)]
4065 __Unknown(i32),
4066}
4067
4068#[doc(hidden)]
4069impl IntoGlib for TocScope {
4070 type GlibType = ffi::GstTocScope;
4071
4072 #[inline]
4073 fn into_glib(self) -> ffi::GstTocScope {
4074 match self {
4075 Self::Global => ffi::GST_TOC_SCOPE_GLOBAL,
4076 Self::Current => ffi::GST_TOC_SCOPE_CURRENT,
4077 Self::__Unknown(value: i32) => value,
4078 }
4079 }
4080}
4081
4082#[doc(hidden)]
4083impl FromGlib<ffi::GstTocScope> for TocScope {
4084 #[inline]
4085 unsafe fn from_glib(value: ffi::GstTocScope) -> Self {
4086 skip_assert_initialized!();
4087
4088 match value {
4089 ffi::GST_TOC_SCOPE_GLOBAL => Self::Global,
4090 ffi::GST_TOC_SCOPE_CURRENT => Self::Current,
4091 value: i32 => Self::__Unknown(value),
4092 }
4093 }
4094}
4095
4096impl StaticType for TocScope {
4097 #[inline]
4098 #[doc(alias = "gst_toc_scope_get_type")]
4099 fn static_type() -> glib::Type {
4100 unsafe { from_glib(val:ffi::gst_toc_scope_get_type()) }
4101 }
4102}
4103
4104impl glib::HasParamSpec for TocScope {
4105 type ParamSpec = glib::ParamSpecEnum;
4106 type SetValue = Self;
4107 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4108
4109 fn param_spec_builder() -> Self::BuilderFn {
4110 Self::ParamSpec::builder_with_default
4111 }
4112}
4113
4114impl glib::value::ValueType for TocScope {
4115 type Type = Self;
4116}
4117
4118unsafe impl<'a> glib::value::FromValue<'a> for TocScope {
4119 type Checker = glib::value::GenericValueTypeChecker<Self>;
4120
4121 #[inline]
4122 unsafe fn from_value(value: &'a glib::Value) -> Self {
4123 skip_assert_initialized!();
4124 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4125 }
4126}
4127
4128impl ToValue for TocScope {
4129 #[inline]
4130 fn to_value(&self) -> glib::Value {
4131 let mut value: Value = glib::Value::for_value_type::<Self>();
4132 unsafe {
4133 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4134 }
4135 value
4136 }
4137
4138 #[inline]
4139 fn value_type(&self) -> glib::Type {
4140 Self::static_type()
4141 }
4142}
4143
4144impl From<TocScope> for glib::Value {
4145 #[inline]
4146 fn from(v: TocScope) -> Self {
4147 skip_assert_initialized!();
4148 ToValue::to_value(&v)
4149 }
4150}
4151
4152#[derive(Debug, Clone, Copy)]
4153#[non_exhaustive]
4154#[doc(alias = "GstTypeFindProbability")]
4155pub enum TypeFindProbability {
4156 #[doc(alias = "GST_TYPE_FIND_NONE")]
4157 None,
4158 #[doc(alias = "GST_TYPE_FIND_MINIMUM")]
4159 Minimum,
4160 #[doc(alias = "GST_TYPE_FIND_POSSIBLE")]
4161 Possible,
4162 #[doc(alias = "GST_TYPE_FIND_LIKELY")]
4163 Likely,
4164 #[doc(alias = "GST_TYPE_FIND_NEARLY_CERTAIN")]
4165 NearlyCertain,
4166 #[doc(alias = "GST_TYPE_FIND_MAXIMUM")]
4167 Maximum,
4168 #[doc(hidden)]
4169 __Unknown(i32),
4170}
4171
4172#[doc(hidden)]
4173impl IntoGlib for TypeFindProbability {
4174 type GlibType = ffi::GstTypeFindProbability;
4175
4176 #[inline]
4177 fn into_glib(self) -> ffi::GstTypeFindProbability {
4178 match self {
4179 Self::None => ffi::GST_TYPE_FIND_NONE,
4180 Self::Minimum => ffi::GST_TYPE_FIND_MINIMUM,
4181 Self::Possible => ffi::GST_TYPE_FIND_POSSIBLE,
4182 Self::Likely => ffi::GST_TYPE_FIND_LIKELY,
4183 Self::NearlyCertain => ffi::GST_TYPE_FIND_NEARLY_CERTAIN,
4184 Self::Maximum => ffi::GST_TYPE_FIND_MAXIMUM,
4185 Self::__Unknown(value: i32) => value,
4186 }
4187 }
4188}
4189
4190#[doc(hidden)]
4191impl FromGlib<ffi::GstTypeFindProbability> for TypeFindProbability {
4192 #[inline]
4193 unsafe fn from_glib(value: ffi::GstTypeFindProbability) -> Self {
4194 skip_assert_initialized!();
4195
4196 match value {
4197 ffi::GST_TYPE_FIND_NONE => Self::None,
4198 ffi::GST_TYPE_FIND_MINIMUM => Self::Minimum,
4199 ffi::GST_TYPE_FIND_POSSIBLE => Self::Possible,
4200 ffi::GST_TYPE_FIND_LIKELY => Self::Likely,
4201 ffi::GST_TYPE_FIND_NEARLY_CERTAIN => Self::NearlyCertain,
4202 ffi::GST_TYPE_FIND_MAXIMUM => Self::Maximum,
4203 value: i32 => Self::__Unknown(value),
4204 }
4205 }
4206}
4207
4208impl StaticType for TypeFindProbability {
4209 #[inline]
4210 #[doc(alias = "gst_type_find_probability_get_type")]
4211 fn static_type() -> glib::Type {
4212 unsafe { from_glib(val:ffi::gst_type_find_probability_get_type()) }
4213 }
4214}
4215
4216impl glib::HasParamSpec for TypeFindProbability {
4217 type ParamSpec = glib::ParamSpecEnum;
4218 type SetValue = Self;
4219 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4220
4221 fn param_spec_builder() -> Self::BuilderFn {
4222 Self::ParamSpec::builder_with_default
4223 }
4224}
4225
4226impl glib::value::ValueType for TypeFindProbability {
4227 type Type = Self;
4228}
4229
4230unsafe impl<'a> glib::value::FromValue<'a> for TypeFindProbability {
4231 type Checker = glib::value::GenericValueTypeChecker<Self>;
4232
4233 #[inline]
4234 unsafe fn from_value(value: &'a glib::Value) -> Self {
4235 skip_assert_initialized!();
4236 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4237 }
4238}
4239
4240impl ToValue for TypeFindProbability {
4241 #[inline]
4242 fn to_value(&self) -> glib::Value {
4243 let mut value: Value = glib::Value::for_value_type::<Self>();
4244 unsafe {
4245 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4246 }
4247 value
4248 }
4249
4250 #[inline]
4251 fn value_type(&self) -> glib::Type {
4252 Self::static_type()
4253 }
4254}
4255
4256impl From<TypeFindProbability> for glib::Value {
4257 #[inline]
4258 fn from(v: TypeFindProbability) -> Self {
4259 skip_assert_initialized!();
4260 ToValue::to_value(&v)
4261 }
4262}
4263
4264#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4265#[non_exhaustive]
4266#[doc(alias = "GstURIError")]
4267pub enum URIError {
4268 #[doc(alias = "GST_URI_ERROR_UNSUPPORTED_PROTOCOL")]
4269 UnsupportedProtocol,
4270 #[doc(alias = "GST_URI_ERROR_BAD_URI")]
4271 BadUri,
4272 #[doc(alias = "GST_URI_ERROR_BAD_STATE")]
4273 BadState,
4274 #[doc(alias = "GST_URI_ERROR_BAD_REFERENCE")]
4275 BadReference,
4276 #[doc(hidden)]
4277 __Unknown(i32),
4278}
4279
4280#[doc(hidden)]
4281impl IntoGlib for URIError {
4282 type GlibType = ffi::GstURIError;
4283
4284 #[inline]
4285 fn into_glib(self) -> ffi::GstURIError {
4286 match self {
4287 Self::UnsupportedProtocol => ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
4288 Self::BadUri => ffi::GST_URI_ERROR_BAD_URI,
4289 Self::BadState => ffi::GST_URI_ERROR_BAD_STATE,
4290 Self::BadReference => ffi::GST_URI_ERROR_BAD_REFERENCE,
4291 Self::__Unknown(value: i32) => value,
4292 }
4293 }
4294}
4295
4296#[doc(hidden)]
4297impl FromGlib<ffi::GstURIError> for URIError {
4298 #[inline]
4299 unsafe fn from_glib(value: ffi::GstURIError) -> Self {
4300 skip_assert_initialized!();
4301
4302 match value {
4303 ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL => Self::UnsupportedProtocol,
4304 ffi::GST_URI_ERROR_BAD_URI => Self::BadUri,
4305 ffi::GST_URI_ERROR_BAD_STATE => Self::BadState,
4306 ffi::GST_URI_ERROR_BAD_REFERENCE => Self::BadReference,
4307 value: i32 => Self::__Unknown(value),
4308 }
4309 }
4310}
4311
4312impl glib::error::ErrorDomain for URIError {
4313 #[inline]
4314 fn domain() -> glib::Quark {
4315 skip_assert_initialized!();
4316
4317 unsafe { from_glib(val:ffi::gst_uri_error_quark()) }
4318 }
4319
4320 #[inline]
4321 fn code(self) -> i32 {
4322 self.into_glib()
4323 }
4324
4325 #[inline]
4326 #[allow(clippy::match_single_binding)]
4327 fn from(code: i32) -> Option<Self> {
4328 skip_assert_initialized!();
4329 match unsafe { from_glib(val:code) } {
4330 value: URIError => Some(value),
4331 }
4332 }
4333}
4334
4335impl StaticType for URIError {
4336 #[inline]
4337 #[doc(alias = "gst_uri_error_get_type")]
4338 fn static_type() -> glib::Type {
4339 unsafe { from_glib(val:ffi::gst_uri_error_get_type()) }
4340 }
4341}
4342
4343impl glib::HasParamSpec for URIError {
4344 type ParamSpec = glib::ParamSpecEnum;
4345 type SetValue = Self;
4346 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4347
4348 fn param_spec_builder() -> Self::BuilderFn {
4349 Self::ParamSpec::builder_with_default
4350 }
4351}
4352
4353impl glib::value::ValueType for URIError {
4354 type Type = Self;
4355}
4356
4357unsafe impl<'a> glib::value::FromValue<'a> for URIError {
4358 type Checker = glib::value::GenericValueTypeChecker<Self>;
4359
4360 #[inline]
4361 unsafe fn from_value(value: &'a glib::Value) -> Self {
4362 skip_assert_initialized!();
4363 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4364 }
4365}
4366
4367impl ToValue for URIError {
4368 #[inline]
4369 fn to_value(&self) -> glib::Value {
4370 let mut value: Value = glib::Value::for_value_type::<Self>();
4371 unsafe {
4372 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4373 }
4374 value
4375 }
4376
4377 #[inline]
4378 fn value_type(&self) -> glib::Type {
4379 Self::static_type()
4380 }
4381}
4382
4383impl From<URIError> for glib::Value {
4384 #[inline]
4385 fn from(v: URIError) -> Self {
4386 skip_assert_initialized!();
4387 ToValue::to_value(&v)
4388 }
4389}
4390
4391#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4392#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
4393#[repr(i32)]
4394#[doc(alias = "GstURIType")]
4395pub enum URIType {
4396 #[doc(alias = "GST_URI_UNKNOWN")]
4397 Unknown = ffi::GST_URI_UNKNOWN,
4398 #[doc(alias = "GST_URI_SINK")]
4399 Sink = ffi::GST_URI_SINK,
4400 #[doc(alias = "GST_URI_SRC")]
4401 Src = ffi::GST_URI_SRC,
4402}
4403
4404#[doc(hidden)]
4405impl IntoGlib for URIType {
4406 type GlibType = ffi::GstURIType;
4407
4408 #[inline]
4409 fn into_glib(self) -> ffi::GstURIType {
4410 self as ffi::GstURIType
4411 }
4412}
4413
4414#[doc(hidden)]
4415impl FromGlib<ffi::GstURIType> for URIType {
4416 #[inline]
4417 unsafe fn from_glib(value: ffi::GstURIType) -> Self {
4418 skip_assert_initialized!();
4419
4420 debug_assert!([ffi::GST_URI_UNKNOWN, ffi::GST_URI_SINK, ffi::GST_URI_SRC].contains(&value));
4421 std::mem::transmute(src:value)
4422 }
4423}
4424
4425impl StaticType for URIType {
4426 #[inline]
4427 #[doc(alias = "gst_uri_type_get_type")]
4428 fn static_type() -> glib::Type {
4429 unsafe { from_glib(val:ffi::gst_uri_type_get_type()) }
4430 }
4431}
4432
4433impl glib::HasParamSpec for URIType {
4434 type ParamSpec = glib::ParamSpecEnum;
4435 type SetValue = Self;
4436 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4437
4438 fn param_spec_builder() -> Self::BuilderFn {
4439 Self::ParamSpec::builder_with_default
4440 }
4441}
4442
4443impl glib::value::ValueType for URIType {
4444 type Type = Self;
4445}
4446
4447unsafe impl<'a> glib::value::FromValue<'a> for URIType {
4448 type Checker = glib::value::GenericValueTypeChecker<Self>;
4449
4450 #[inline]
4451 unsafe fn from_value(value: &'a glib::Value) -> Self {
4452 skip_assert_initialized!();
4453 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4454 }
4455}
4456
4457impl ToValue for URIType {
4458 #[inline]
4459 fn to_value(&self) -> glib::Value {
4460 let mut value: Value = glib::Value::for_value_type::<Self>();
4461 unsafe {
4462 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4463 }
4464 value
4465 }
4466
4467 #[inline]
4468 fn value_type(&self) -> glib::Type {
4469 Self::static_type()
4470 }
4471}
4472
4473impl From<URIType> for glib::Value {
4474 #[inline]
4475 fn from(v: URIType) -> Self {
4476 skip_assert_initialized!();
4477 ToValue::to_value(&v)
4478 }
4479}
4480