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 glib::{bitflags::bitflags, prelude::*, translate::*, GStr};
7use std::fmt;
8
9bitflags! {
10 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
11 #[doc(alias = "GstBinFlags")]
12 pub struct BinFlags: u32 {
13 #[doc(alias = "GST_BIN_FLAG_NO_RESYNC")]
14 const NO_RESYNC = ffi::GST_BIN_FLAG_NO_RESYNC as _;
15 #[doc(alias = "GST_BIN_FLAG_STREAMS_AWARE")]
16 const STREAMS_AWARE = ffi::GST_BIN_FLAG_STREAMS_AWARE as _;
17 }
18}
19
20#[doc(hidden)]
21impl IntoGlib for BinFlags {
22 type GlibType = ffi::GstBinFlags;
23
24 #[inline]
25 fn into_glib(self) -> ffi::GstBinFlags {
26 self.bits()
27 }
28}
29
30#[doc(hidden)]
31impl FromGlib<ffi::GstBinFlags> for BinFlags {
32 #[inline]
33 unsafe fn from_glib(value: ffi::GstBinFlags) -> Self {
34 skip_assert_initialized!();
35 Self::from_bits_truncate(bits:value)
36 }
37}
38
39impl StaticType for BinFlags {
40 #[inline]
41 #[doc(alias = "gst_bin_flags_get_type")]
42 fn static_type() -> glib::Type {
43 unsafe { from_glib(val:ffi::gst_bin_flags_get_type()) }
44 }
45}
46
47impl glib::HasParamSpec for BinFlags {
48 type ParamSpec = glib::ParamSpecFlags;
49 type SetValue = Self;
50 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
51
52 fn param_spec_builder() -> Self::BuilderFn {
53 Self::ParamSpec::builder
54 }
55}
56
57impl glib::value::ValueType for BinFlags {
58 type Type = Self;
59}
60
61unsafe impl<'a> glib::value::FromValue<'a> for BinFlags {
62 type Checker = glib::value::GenericValueTypeChecker<Self>;
63
64 #[inline]
65 unsafe fn from_value(value: &'a glib::Value) -> Self {
66 skip_assert_initialized!();
67 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
68 }
69}
70
71impl ToValue for BinFlags {
72 #[inline]
73 fn to_value(&self) -> glib::Value {
74 let mut value: Value = glib::Value::for_value_type::<Self>();
75 unsafe {
76 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
77 }
78 value
79 }
80
81 #[inline]
82 fn value_type(&self) -> glib::Type {
83 Self::static_type()
84 }
85}
86
87impl From<BinFlags> for glib::Value {
88 #[inline]
89 fn from(v: BinFlags) -> Self {
90 skip_assert_initialized!();
91 ToValue::to_value(&v)
92 }
93}
94
95bitflags! {
96 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
97 #[doc(alias = "GstBufferCopyFlags")]
98 pub struct BufferCopyFlags: u32 {
99 #[doc(alias = "GST_BUFFER_COPY_FLAGS")]
100 const FLAGS = ffi::GST_BUFFER_COPY_FLAGS as _;
101 #[doc(alias = "GST_BUFFER_COPY_TIMESTAMPS")]
102 const TIMESTAMPS = ffi::GST_BUFFER_COPY_TIMESTAMPS as _;
103 #[doc(alias = "GST_BUFFER_COPY_META")]
104 const META = ffi::GST_BUFFER_COPY_META as _;
105 #[doc(alias = "GST_BUFFER_COPY_MEMORY")]
106 const MEMORY = ffi::GST_BUFFER_COPY_MEMORY as _;
107 #[doc(alias = "GST_BUFFER_COPY_MERGE")]
108 const MERGE = ffi::GST_BUFFER_COPY_MERGE as _;
109 #[doc(alias = "GST_BUFFER_COPY_DEEP")]
110 const DEEP = ffi::GST_BUFFER_COPY_DEEP as _;
111 }
112}
113
114#[doc(hidden)]
115impl IntoGlib for BufferCopyFlags {
116 type GlibType = ffi::GstBufferCopyFlags;
117
118 #[inline]
119 fn into_glib(self) -> ffi::GstBufferCopyFlags {
120 self.bits()
121 }
122}
123
124#[doc(hidden)]
125impl FromGlib<ffi::GstBufferCopyFlags> for BufferCopyFlags {
126 #[inline]
127 unsafe fn from_glib(value: ffi::GstBufferCopyFlags) -> Self {
128 skip_assert_initialized!();
129 Self::from_bits_truncate(bits:value)
130 }
131}
132
133impl StaticType for BufferCopyFlags {
134 #[inline]
135 #[doc(alias = "gst_buffer_copy_flags_get_type")]
136 fn static_type() -> glib::Type {
137 unsafe { from_glib(val:ffi::gst_buffer_copy_flags_get_type()) }
138 }
139}
140
141impl glib::HasParamSpec for BufferCopyFlags {
142 type ParamSpec = glib::ParamSpecFlags;
143 type SetValue = Self;
144 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
145
146 fn param_spec_builder() -> Self::BuilderFn {
147 Self::ParamSpec::builder
148 }
149}
150
151impl glib::value::ValueType for BufferCopyFlags {
152 type Type = Self;
153}
154
155unsafe impl<'a> glib::value::FromValue<'a> for BufferCopyFlags {
156 type Checker = glib::value::GenericValueTypeChecker<Self>;
157
158 #[inline]
159 unsafe fn from_value(value: &'a glib::Value) -> Self {
160 skip_assert_initialized!();
161 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
162 }
163}
164
165impl ToValue for BufferCopyFlags {
166 #[inline]
167 fn to_value(&self) -> glib::Value {
168 let mut value: Value = glib::Value::for_value_type::<Self>();
169 unsafe {
170 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
171 }
172 value
173 }
174
175 #[inline]
176 fn value_type(&self) -> glib::Type {
177 Self::static_type()
178 }
179}
180
181impl From<BufferCopyFlags> for glib::Value {
182 #[inline]
183 fn from(v: BufferCopyFlags) -> Self {
184 skip_assert_initialized!();
185 ToValue::to_value(&v)
186 }
187}
188
189bitflags! {
190 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
191 #[doc(alias = "GstBufferFlags")]
192 pub struct BufferFlags: u32 {
193 #[doc(alias = "GST_BUFFER_FLAG_LIVE")]
194 const LIVE = ffi::GST_BUFFER_FLAG_LIVE as _;
195 #[doc(alias = "GST_BUFFER_FLAG_DECODE_ONLY")]
196 const DECODE_ONLY = ffi::GST_BUFFER_FLAG_DECODE_ONLY as _;
197 #[doc(alias = "GST_BUFFER_FLAG_DISCONT")]
198 const DISCONT = ffi::GST_BUFFER_FLAG_DISCONT as _;
199 #[doc(alias = "GST_BUFFER_FLAG_RESYNC")]
200 const RESYNC = ffi::GST_BUFFER_FLAG_RESYNC as _;
201 #[doc(alias = "GST_BUFFER_FLAG_CORRUPTED")]
202 const CORRUPTED = ffi::GST_BUFFER_FLAG_CORRUPTED as _;
203 #[doc(alias = "GST_BUFFER_FLAG_MARKER")]
204 const MARKER = ffi::GST_BUFFER_FLAG_MARKER as _;
205 #[doc(alias = "GST_BUFFER_FLAG_HEADER")]
206 const HEADER = ffi::GST_BUFFER_FLAG_HEADER as _;
207 #[doc(alias = "GST_BUFFER_FLAG_GAP")]
208 const GAP = ffi::GST_BUFFER_FLAG_GAP as _;
209 #[doc(alias = "GST_BUFFER_FLAG_DROPPABLE")]
210 const DROPPABLE = ffi::GST_BUFFER_FLAG_DROPPABLE as _;
211 #[doc(alias = "GST_BUFFER_FLAG_DELTA_UNIT")]
212 const DELTA_UNIT = ffi::GST_BUFFER_FLAG_DELTA_UNIT as _;
213 #[doc(alias = "GST_BUFFER_FLAG_TAG_MEMORY")]
214 const TAG_MEMORY = ffi::GST_BUFFER_FLAG_TAG_MEMORY as _;
215 #[doc(alias = "GST_BUFFER_FLAG_SYNC_AFTER")]
216 const SYNC_AFTER = ffi::GST_BUFFER_FLAG_SYNC_AFTER as _;
217 #[doc(alias = "GST_BUFFER_FLAG_NON_DROPPABLE")]
218 const NON_DROPPABLE = ffi::GST_BUFFER_FLAG_NON_DROPPABLE as _;
219 }
220}
221
222#[doc(hidden)]
223impl IntoGlib for BufferFlags {
224 type GlibType = ffi::GstBufferFlags;
225
226 #[inline]
227 fn into_glib(self) -> ffi::GstBufferFlags {
228 self.bits()
229 }
230}
231
232#[doc(hidden)]
233impl FromGlib<ffi::GstBufferFlags> for BufferFlags {
234 #[inline]
235 unsafe fn from_glib(value: ffi::GstBufferFlags) -> Self {
236 skip_assert_initialized!();
237 Self::from_bits_truncate(bits:value)
238 }
239}
240
241impl StaticType for BufferFlags {
242 #[inline]
243 #[doc(alias = "gst_buffer_flags_get_type")]
244 fn static_type() -> glib::Type {
245 unsafe { from_glib(val:ffi::gst_buffer_flags_get_type()) }
246 }
247}
248
249impl glib::HasParamSpec for BufferFlags {
250 type ParamSpec = glib::ParamSpecFlags;
251 type SetValue = Self;
252 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
253
254 fn param_spec_builder() -> Self::BuilderFn {
255 Self::ParamSpec::builder
256 }
257}
258
259impl glib::value::ValueType for BufferFlags {
260 type Type = Self;
261}
262
263unsafe impl<'a> glib::value::FromValue<'a> for BufferFlags {
264 type Checker = glib::value::GenericValueTypeChecker<Self>;
265
266 #[inline]
267 unsafe fn from_value(value: &'a glib::Value) -> Self {
268 skip_assert_initialized!();
269 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
270 }
271}
272
273impl ToValue for BufferFlags {
274 #[inline]
275 fn to_value(&self) -> glib::Value {
276 let mut value: Value = glib::Value::for_value_type::<Self>();
277 unsafe {
278 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
279 }
280 value
281 }
282
283 #[inline]
284 fn value_type(&self) -> glib::Type {
285 Self::static_type()
286 }
287}
288
289impl From<BufferFlags> for glib::Value {
290 #[inline]
291 fn from(v: BufferFlags) -> Self {
292 skip_assert_initialized!();
293 ToValue::to_value(&v)
294 }
295}
296
297bitflags! {
298 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
299 #[doc(alias = "GstBufferPoolAcquireFlags")]
300 pub struct BufferPoolAcquireFlags: u32 {
301 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT")]
302 const KEY_UNIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT as _;
303 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT")]
304 const DONTWAIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT as _;
305 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT")]
306 const DISCONT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT as _;
307 }
308}
309
310#[doc(hidden)]
311impl IntoGlib for BufferPoolAcquireFlags {
312 type GlibType = ffi::GstBufferPoolAcquireFlags;
313
314 #[inline]
315 fn into_glib(self) -> ffi::GstBufferPoolAcquireFlags {
316 self.bits()
317 }
318}
319
320#[doc(hidden)]
321impl FromGlib<ffi::GstBufferPoolAcquireFlags> for BufferPoolAcquireFlags {
322 #[inline]
323 unsafe fn from_glib(value: ffi::GstBufferPoolAcquireFlags) -> Self {
324 skip_assert_initialized!();
325 Self::from_bits_truncate(bits:value)
326 }
327}
328
329impl StaticType for BufferPoolAcquireFlags {
330 #[inline]
331 #[doc(alias = "gst_buffer_pool_acquire_flags_get_type")]
332 fn static_type() -> glib::Type {
333 unsafe { from_glib(val:ffi::gst_buffer_pool_acquire_flags_get_type()) }
334 }
335}
336
337impl glib::HasParamSpec for BufferPoolAcquireFlags {
338 type ParamSpec = glib::ParamSpecFlags;
339 type SetValue = Self;
340 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
341
342 fn param_spec_builder() -> Self::BuilderFn {
343 Self::ParamSpec::builder
344 }
345}
346
347impl glib::value::ValueType for BufferPoolAcquireFlags {
348 type Type = Self;
349}
350
351unsafe impl<'a> glib::value::FromValue<'a> for BufferPoolAcquireFlags {
352 type Checker = glib::value::GenericValueTypeChecker<Self>;
353
354 #[inline]
355 unsafe fn from_value(value: &'a glib::Value) -> Self {
356 skip_assert_initialized!();
357 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
358 }
359}
360
361impl ToValue for BufferPoolAcquireFlags {
362 #[inline]
363 fn to_value(&self) -> glib::Value {
364 let mut value: Value = glib::Value::for_value_type::<Self>();
365 unsafe {
366 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
367 }
368 value
369 }
370
371 #[inline]
372 fn value_type(&self) -> glib::Type {
373 Self::static_type()
374 }
375}
376
377impl From<BufferPoolAcquireFlags> for glib::Value {
378 #[inline]
379 fn from(v: BufferPoolAcquireFlags) -> Self {
380 skip_assert_initialized!();
381 ToValue::to_value(&v)
382 }
383}
384
385bitflags! {
386 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
387 #[doc(alias = "GstClockFlags")]
388 pub struct ClockFlags: u32 {
389 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC")]
390 const CAN_DO_SINGLE_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC as _;
391 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC")]
392 const CAN_DO_SINGLE_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC as _;
393 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC")]
394 const CAN_DO_PERIODIC_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC as _;
395 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC")]
396 const CAN_DO_PERIODIC_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC as _;
397 #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_RESOLUTION")]
398 const CAN_SET_RESOLUTION = ffi::GST_CLOCK_FLAG_CAN_SET_RESOLUTION as _;
399 #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_MASTER")]
400 const CAN_SET_MASTER = ffi::GST_CLOCK_FLAG_CAN_SET_MASTER as _;
401 #[doc(alias = "GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC")]
402 const NEEDS_STARTUP_SYNC = ffi::GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC as _;
403 }
404}
405
406#[doc(hidden)]
407impl IntoGlib for ClockFlags {
408 type GlibType = ffi::GstClockFlags;
409
410 #[inline]
411 fn into_glib(self) -> ffi::GstClockFlags {
412 self.bits()
413 }
414}
415
416#[doc(hidden)]
417impl FromGlib<ffi::GstClockFlags> for ClockFlags {
418 #[inline]
419 unsafe fn from_glib(value: ffi::GstClockFlags) -> Self {
420 skip_assert_initialized!();
421 Self::from_bits_truncate(bits:value)
422 }
423}
424
425impl StaticType for ClockFlags {
426 #[inline]
427 #[doc(alias = "gst_clock_flags_get_type")]
428 fn static_type() -> glib::Type {
429 unsafe { from_glib(val:ffi::gst_clock_flags_get_type()) }
430 }
431}
432
433impl glib::HasParamSpec for ClockFlags {
434 type ParamSpec = glib::ParamSpecFlags;
435 type SetValue = Self;
436 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
437
438 fn param_spec_builder() -> Self::BuilderFn {
439 Self::ParamSpec::builder
440 }
441}
442
443impl glib::value::ValueType for ClockFlags {
444 type Type = Self;
445}
446
447unsafe impl<'a> glib::value::FromValue<'a> for ClockFlags {
448 type Checker = glib::value::GenericValueTypeChecker<Self>;
449
450 #[inline]
451 unsafe fn from_value(value: &'a glib::Value) -> Self {
452 skip_assert_initialized!();
453 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
454 }
455}
456
457impl ToValue for ClockFlags {
458 #[inline]
459 fn to_value(&self) -> glib::Value {
460 let mut value: Value = glib::Value::for_value_type::<Self>();
461 unsafe {
462 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
463 }
464 value
465 }
466
467 #[inline]
468 fn value_type(&self) -> glib::Type {
469 Self::static_type()
470 }
471}
472
473impl From<ClockFlags> for glib::Value {
474 #[inline]
475 fn from(v: ClockFlags) -> Self {
476 skip_assert_initialized!();
477 ToValue::to_value(&v)
478 }
479}
480
481bitflags! {
482 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
483 #[doc(alias = "GstDebugColorFlags")]
484 pub struct DebugColorFlags: u32 {
485 #[doc(alias = "GST_DEBUG_FG_BLACK")]
486 const FG_BLACK = ffi::GST_DEBUG_FG_BLACK as _;
487 #[doc(alias = "GST_DEBUG_FG_RED")]
488 const FG_RED = ffi::GST_DEBUG_FG_RED as _;
489 #[doc(alias = "GST_DEBUG_FG_GREEN")]
490 const FG_GREEN = ffi::GST_DEBUG_FG_GREEN as _;
491 #[doc(alias = "GST_DEBUG_FG_YELLOW")]
492 const FG_YELLOW = ffi::GST_DEBUG_FG_YELLOW as _;
493 #[doc(alias = "GST_DEBUG_FG_BLUE")]
494 const FG_BLUE = ffi::GST_DEBUG_FG_BLUE as _;
495 #[doc(alias = "GST_DEBUG_FG_MAGENTA")]
496 const FG_MAGENTA = ffi::GST_DEBUG_FG_MAGENTA as _;
497 #[doc(alias = "GST_DEBUG_FG_CYAN")]
498 const FG_CYAN = ffi::GST_DEBUG_FG_CYAN as _;
499 #[doc(alias = "GST_DEBUG_FG_WHITE")]
500 const FG_WHITE = ffi::GST_DEBUG_FG_WHITE as _;
501 #[doc(alias = "GST_DEBUG_BG_BLACK")]
502 const BG_BLACK = ffi::GST_DEBUG_BG_BLACK as _;
503 #[doc(alias = "GST_DEBUG_BG_RED")]
504 const BG_RED = ffi::GST_DEBUG_BG_RED as _;
505 #[doc(alias = "GST_DEBUG_BG_GREEN")]
506 const BG_GREEN = ffi::GST_DEBUG_BG_GREEN as _;
507 #[doc(alias = "GST_DEBUG_BG_YELLOW")]
508 const BG_YELLOW = ffi::GST_DEBUG_BG_YELLOW as _;
509 #[doc(alias = "GST_DEBUG_BG_BLUE")]
510 const BG_BLUE = ffi::GST_DEBUG_BG_BLUE as _;
511 #[doc(alias = "GST_DEBUG_BG_MAGENTA")]
512 const BG_MAGENTA = ffi::GST_DEBUG_BG_MAGENTA as _;
513 #[doc(alias = "GST_DEBUG_BG_CYAN")]
514 const BG_CYAN = ffi::GST_DEBUG_BG_CYAN as _;
515 #[doc(alias = "GST_DEBUG_BG_WHITE")]
516 const BG_WHITE = ffi::GST_DEBUG_BG_WHITE as _;
517 #[doc(alias = "GST_DEBUG_BOLD")]
518 const BOLD = ffi::GST_DEBUG_BOLD as _;
519 #[doc(alias = "GST_DEBUG_UNDERLINE")]
520 const UNDERLINE = ffi::GST_DEBUG_UNDERLINE as _;
521 }
522}
523
524#[doc(hidden)]
525impl IntoGlib for DebugColorFlags {
526 type GlibType = ffi::GstDebugColorFlags;
527
528 #[inline]
529 fn into_glib(self) -> ffi::GstDebugColorFlags {
530 self.bits()
531 }
532}
533
534#[doc(hidden)]
535impl FromGlib<ffi::GstDebugColorFlags> for DebugColorFlags {
536 #[inline]
537 unsafe fn from_glib(value: ffi::GstDebugColorFlags) -> Self {
538 skip_assert_initialized!();
539 Self::from_bits_truncate(bits:value)
540 }
541}
542
543impl StaticType for DebugColorFlags {
544 #[inline]
545 #[doc(alias = "gst_debug_color_flags_get_type")]
546 fn static_type() -> glib::Type {
547 unsafe { from_glib(val:ffi::gst_debug_color_flags_get_type()) }
548 }
549}
550
551impl glib::HasParamSpec for DebugColorFlags {
552 type ParamSpec = glib::ParamSpecFlags;
553 type SetValue = Self;
554 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
555
556 fn param_spec_builder() -> Self::BuilderFn {
557 Self::ParamSpec::builder
558 }
559}
560
561impl glib::value::ValueType for DebugColorFlags {
562 type Type = Self;
563}
564
565unsafe impl<'a> glib::value::FromValue<'a> for DebugColorFlags {
566 type Checker = glib::value::GenericValueTypeChecker<Self>;
567
568 #[inline]
569 unsafe fn from_value(value: &'a glib::Value) -> Self {
570 skip_assert_initialized!();
571 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
572 }
573}
574
575impl ToValue for DebugColorFlags {
576 #[inline]
577 fn to_value(&self) -> glib::Value {
578 let mut value: Value = glib::Value::for_value_type::<Self>();
579 unsafe {
580 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
581 }
582 value
583 }
584
585 #[inline]
586 fn value_type(&self) -> glib::Type {
587 Self::static_type()
588 }
589}
590
591impl From<DebugColorFlags> for glib::Value {
592 #[inline]
593 fn from(v: DebugColorFlags) -> Self {
594 skip_assert_initialized!();
595 ToValue::to_value(&v)
596 }
597}
598
599bitflags! {
600 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
601 #[doc(alias = "GstDebugGraphDetails")]
602 pub struct DebugGraphDetails: u32 {
603 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE")]
604 const MEDIA_TYPE = ffi::GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE as _;
605 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS")]
606 const CAPS_DETAILS = ffi::GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS as _;
607 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS")]
608 const NON_DEFAULT_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS as _;
609 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_STATES")]
610 const STATES = ffi::GST_DEBUG_GRAPH_SHOW_STATES as _;
611 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_FULL_PARAMS")]
612 const FULL_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_FULL_PARAMS as _;
613 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_ALL")]
614 const ALL = ffi::GST_DEBUG_GRAPH_SHOW_ALL as _;
615 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_VERBOSE")]
616 const VERBOSE = ffi::GST_DEBUG_GRAPH_SHOW_VERBOSE as _;
617 }
618}
619
620#[doc(hidden)]
621impl IntoGlib for DebugGraphDetails {
622 type GlibType = ffi::GstDebugGraphDetails;
623
624 #[inline]
625 fn into_glib(self) -> ffi::GstDebugGraphDetails {
626 self.bits()
627 }
628}
629
630#[doc(hidden)]
631impl FromGlib<ffi::GstDebugGraphDetails> for DebugGraphDetails {
632 #[inline]
633 unsafe fn from_glib(value: ffi::GstDebugGraphDetails) -> Self {
634 skip_assert_initialized!();
635 Self::from_bits_truncate(bits:value)
636 }
637}
638
639impl StaticType for DebugGraphDetails {
640 #[inline]
641 #[doc(alias = "gst_debug_graph_details_get_type")]
642 fn static_type() -> glib::Type {
643 unsafe { from_glib(val:ffi::gst_debug_graph_details_get_type()) }
644 }
645}
646
647impl glib::HasParamSpec for DebugGraphDetails {
648 type ParamSpec = glib::ParamSpecFlags;
649 type SetValue = Self;
650 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
651
652 fn param_spec_builder() -> Self::BuilderFn {
653 Self::ParamSpec::builder
654 }
655}
656
657impl glib::value::ValueType for DebugGraphDetails {
658 type Type = Self;
659}
660
661unsafe impl<'a> glib::value::FromValue<'a> for DebugGraphDetails {
662 type Checker = glib::value::GenericValueTypeChecker<Self>;
663
664 #[inline]
665 unsafe fn from_value(value: &'a glib::Value) -> Self {
666 skip_assert_initialized!();
667 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
668 }
669}
670
671impl ToValue for DebugGraphDetails {
672 #[inline]
673 fn to_value(&self) -> glib::Value {
674 let mut value: Value = glib::Value::for_value_type::<Self>();
675 unsafe {
676 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
677 }
678 value
679 }
680
681 #[inline]
682 fn value_type(&self) -> glib::Type {
683 Self::static_type()
684 }
685}
686
687impl From<DebugGraphDetails> for glib::Value {
688 #[inline]
689 fn from(v: DebugGraphDetails) -> Self {
690 skip_assert_initialized!();
691 ToValue::to_value(&v)
692 }
693}
694
695bitflags! {
696 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
697 #[doc(alias = "GstElementFlags")]
698 pub struct ElementFlags: u32 {
699 #[doc(alias = "GST_ELEMENT_FLAG_LOCKED_STATE")]
700 const LOCKED_STATE = ffi::GST_ELEMENT_FLAG_LOCKED_STATE as _;
701 #[doc(alias = "GST_ELEMENT_FLAG_SINK")]
702 const SINK = ffi::GST_ELEMENT_FLAG_SINK as _;
703 #[doc(alias = "GST_ELEMENT_FLAG_SOURCE")]
704 const SOURCE = ffi::GST_ELEMENT_FLAG_SOURCE as _;
705 #[doc(alias = "GST_ELEMENT_FLAG_PROVIDE_CLOCK")]
706 const PROVIDE_CLOCK = ffi::GST_ELEMENT_FLAG_PROVIDE_CLOCK as _;
707 #[doc(alias = "GST_ELEMENT_FLAG_REQUIRE_CLOCK")]
708 const REQUIRE_CLOCK = ffi::GST_ELEMENT_FLAG_REQUIRE_CLOCK as _;
709 #[doc(alias = "GST_ELEMENT_FLAG_INDEXABLE")]
710 const INDEXABLE = ffi::GST_ELEMENT_FLAG_INDEXABLE as _;
711 }
712}
713
714#[doc(hidden)]
715impl IntoGlib for ElementFlags {
716 type GlibType = ffi::GstElementFlags;
717
718 #[inline]
719 fn into_glib(self) -> ffi::GstElementFlags {
720 self.bits()
721 }
722}
723
724#[doc(hidden)]
725impl FromGlib<ffi::GstElementFlags> for ElementFlags {
726 #[inline]
727 unsafe fn from_glib(value: ffi::GstElementFlags) -> Self {
728 skip_assert_initialized!();
729 Self::from_bits_truncate(bits:value)
730 }
731}
732
733impl StaticType for ElementFlags {
734 #[inline]
735 #[doc(alias = "gst_element_flags_get_type")]
736 fn static_type() -> glib::Type {
737 unsafe { from_glib(val:ffi::gst_element_flags_get_type()) }
738 }
739}
740
741impl glib::HasParamSpec for ElementFlags {
742 type ParamSpec = glib::ParamSpecFlags;
743 type SetValue = Self;
744 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
745
746 fn param_spec_builder() -> Self::BuilderFn {
747 Self::ParamSpec::builder
748 }
749}
750
751impl glib::value::ValueType for ElementFlags {
752 type Type = Self;
753}
754
755unsafe impl<'a> glib::value::FromValue<'a> for ElementFlags {
756 type Checker = glib::value::GenericValueTypeChecker<Self>;
757
758 #[inline]
759 unsafe fn from_value(value: &'a glib::Value) -> Self {
760 skip_assert_initialized!();
761 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
762 }
763}
764
765impl ToValue for ElementFlags {
766 #[inline]
767 fn to_value(&self) -> glib::Value {
768 let mut value: Value = glib::Value::for_value_type::<Self>();
769 unsafe {
770 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
771 }
772 value
773 }
774
775 #[inline]
776 fn value_type(&self) -> glib::Type {
777 Self::static_type()
778 }
779}
780
781impl From<ElementFlags> for glib::Value {
782 #[inline]
783 fn from(v: ElementFlags) -> Self {
784 skip_assert_initialized!();
785 ToValue::to_value(&v)
786 }
787}
788
789bitflags! {
790 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
791 #[doc(alias = "GstEventTypeFlags")]
792 pub struct EventTypeFlags: u32 {
793 #[doc(alias = "GST_EVENT_TYPE_UPSTREAM")]
794 const UPSTREAM = ffi::GST_EVENT_TYPE_UPSTREAM as _;
795 #[doc(alias = "GST_EVENT_TYPE_DOWNSTREAM")]
796 const DOWNSTREAM = ffi::GST_EVENT_TYPE_DOWNSTREAM as _;
797 #[doc(alias = "GST_EVENT_TYPE_SERIALIZED")]
798 const SERIALIZED = ffi::GST_EVENT_TYPE_SERIALIZED as _;
799 #[doc(alias = "GST_EVENT_TYPE_STICKY")]
800 const STICKY = ffi::GST_EVENT_TYPE_STICKY as _;
801 #[doc(alias = "GST_EVENT_TYPE_STICKY_MULTI")]
802 const STICKY_MULTI = ffi::GST_EVENT_TYPE_STICKY_MULTI as _;
803 }
804}
805
806#[doc(hidden)]
807impl IntoGlib for EventTypeFlags {
808 type GlibType = ffi::GstEventTypeFlags;
809
810 #[inline]
811 fn into_glib(self) -> ffi::GstEventTypeFlags {
812 self.bits()
813 }
814}
815
816#[doc(hidden)]
817impl FromGlib<ffi::GstEventTypeFlags> for EventTypeFlags {
818 #[inline]
819 unsafe fn from_glib(value: ffi::GstEventTypeFlags) -> Self {
820 skip_assert_initialized!();
821 Self::from_bits_truncate(bits:value)
822 }
823}
824
825impl StaticType for EventTypeFlags {
826 #[inline]
827 #[doc(alias = "gst_event_type_flags_get_type")]
828 fn static_type() -> glib::Type {
829 unsafe { from_glib(val:ffi::gst_event_type_flags_get_type()) }
830 }
831}
832
833impl glib::HasParamSpec for EventTypeFlags {
834 type ParamSpec = glib::ParamSpecFlags;
835 type SetValue = Self;
836 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
837
838 fn param_spec_builder() -> Self::BuilderFn {
839 Self::ParamSpec::builder
840 }
841}
842
843impl glib::value::ValueType for EventTypeFlags {
844 type Type = Self;
845}
846
847unsafe impl<'a> glib::value::FromValue<'a> for EventTypeFlags {
848 type Checker = glib::value::GenericValueTypeChecker<Self>;
849
850 #[inline]
851 unsafe fn from_value(value: &'a glib::Value) -> Self {
852 skip_assert_initialized!();
853 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
854 }
855}
856
857impl ToValue for EventTypeFlags {
858 #[inline]
859 fn to_value(&self) -> glib::Value {
860 let mut value: Value = glib::Value::for_value_type::<Self>();
861 unsafe {
862 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
863 }
864 value
865 }
866
867 #[inline]
868 fn value_type(&self) -> glib::Type {
869 Self::static_type()
870 }
871}
872
873impl From<EventTypeFlags> for glib::Value {
874 #[inline]
875 fn from(v: EventTypeFlags) -> Self {
876 skip_assert_initialized!();
877 ToValue::to_value(&v)
878 }
879}
880
881#[cfg(feature = "v1_20")]
882bitflags! {
883 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
884 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
885 #[doc(alias = "GstGapFlags")]
886 pub struct GapFlags: u32 {
887 #[doc(alias = "GST_GAP_FLAG_MISSING_DATA")]
888 const DATA = ffi::GST_GAP_FLAG_MISSING_DATA as _;
889 }
890}
891
892#[cfg(feature = "v1_20")]
893#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
894#[doc(hidden)]
895impl IntoGlib for GapFlags {
896 type GlibType = ffi::GstGapFlags;
897
898 #[inline]
899 fn into_glib(self) -> ffi::GstGapFlags {
900 self.bits()
901 }
902}
903
904#[cfg(feature = "v1_20")]
905#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
906#[doc(hidden)]
907impl FromGlib<ffi::GstGapFlags> for GapFlags {
908 #[inline]
909 unsafe fn from_glib(value: ffi::GstGapFlags) -> Self {
910 skip_assert_initialized!();
911 Self::from_bits_truncate(value)
912 }
913}
914
915#[cfg(feature = "v1_20")]
916#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
917impl StaticType for GapFlags {
918 #[inline]
919 #[doc(alias = "gst_gap_flags_get_type")]
920 fn static_type() -> glib::Type {
921 unsafe { from_glib(ffi::gst_gap_flags_get_type()) }
922 }
923}
924
925#[cfg(feature = "v1_20")]
926#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
927impl glib::HasParamSpec for GapFlags {
928 type ParamSpec = glib::ParamSpecFlags;
929 type SetValue = Self;
930 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
931
932 fn param_spec_builder() -> Self::BuilderFn {
933 Self::ParamSpec::builder
934 }
935}
936
937#[cfg(feature = "v1_20")]
938#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
939impl glib::value::ValueType for GapFlags {
940 type Type = Self;
941}
942
943#[cfg(feature = "v1_20")]
944#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
945unsafe impl<'a> glib::value::FromValue<'a> for GapFlags {
946 type Checker = glib::value::GenericValueTypeChecker<Self>;
947
948 #[inline]
949 unsafe fn from_value(value: &'a glib::Value) -> Self {
950 skip_assert_initialized!();
951 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
952 }
953}
954
955#[cfg(feature = "v1_20")]
956#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
957impl ToValue for GapFlags {
958 #[inline]
959 fn to_value(&self) -> glib::Value {
960 let mut value = glib::Value::for_value_type::<Self>();
961 unsafe {
962 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
963 }
964 value
965 }
966
967 #[inline]
968 fn value_type(&self) -> glib::Type {
969 Self::static_type()
970 }
971}
972
973#[cfg(feature = "v1_20")]
974#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
975impl From<GapFlags> for glib::Value {
976 #[inline]
977 fn from(v: GapFlags) -> Self {
978 skip_assert_initialized!();
979 ToValue::to_value(&v)
980 }
981}
982
983bitflags! {
984 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
985 #[doc(alias = "GstMemoryFlags")]
986 pub struct MemoryFlags: u32 {
987 #[doc(alias = "GST_MEMORY_FLAG_READONLY")]
988 const READONLY = ffi::GST_MEMORY_FLAG_READONLY as _;
989 #[doc(alias = "GST_MEMORY_FLAG_NO_SHARE")]
990 const NO_SHARE = ffi::GST_MEMORY_FLAG_NO_SHARE as _;
991 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PREFIXED")]
992 const ZERO_PREFIXED = ffi::GST_MEMORY_FLAG_ZERO_PREFIXED as _;
993 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PADDED")]
994 const ZERO_PADDED = ffi::GST_MEMORY_FLAG_ZERO_PADDED as _;
995 #[doc(alias = "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS")]
996 const PHYSICALLY_CONTIGUOUS = ffi::GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS as _;
997 #[doc(alias = "GST_MEMORY_FLAG_NOT_MAPPABLE")]
998 const NOT_MAPPABLE = ffi::GST_MEMORY_FLAG_NOT_MAPPABLE as _;
999 }
1000}
1001
1002#[doc(hidden)]
1003impl IntoGlib for MemoryFlags {
1004 type GlibType = ffi::GstMemoryFlags;
1005
1006 #[inline]
1007 fn into_glib(self) -> ffi::GstMemoryFlags {
1008 self.bits()
1009 }
1010}
1011
1012#[doc(hidden)]
1013impl FromGlib<ffi::GstMemoryFlags> for MemoryFlags {
1014 #[inline]
1015 unsafe fn from_glib(value: ffi::GstMemoryFlags) -> Self {
1016 skip_assert_initialized!();
1017 Self::from_bits_truncate(bits:value)
1018 }
1019}
1020
1021impl StaticType for MemoryFlags {
1022 #[inline]
1023 #[doc(alias = "gst_memory_flags_get_type")]
1024 fn static_type() -> glib::Type {
1025 unsafe { from_glib(val:ffi::gst_memory_flags_get_type()) }
1026 }
1027}
1028
1029impl glib::HasParamSpec for MemoryFlags {
1030 type ParamSpec = glib::ParamSpecFlags;
1031 type SetValue = Self;
1032 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1033
1034 fn param_spec_builder() -> Self::BuilderFn {
1035 Self::ParamSpec::builder
1036 }
1037}
1038
1039impl glib::value::ValueType for MemoryFlags {
1040 type Type = Self;
1041}
1042
1043unsafe impl<'a> glib::value::FromValue<'a> for MemoryFlags {
1044 type Checker = glib::value::GenericValueTypeChecker<Self>;
1045
1046 #[inline]
1047 unsafe fn from_value(value: &'a glib::Value) -> Self {
1048 skip_assert_initialized!();
1049 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1050 }
1051}
1052
1053impl ToValue for MemoryFlags {
1054 #[inline]
1055 fn to_value(&self) -> glib::Value {
1056 let mut value: Value = glib::Value::for_value_type::<Self>();
1057 unsafe {
1058 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1059 }
1060 value
1061 }
1062
1063 #[inline]
1064 fn value_type(&self) -> glib::Type {
1065 Self::static_type()
1066 }
1067}
1068
1069impl From<MemoryFlags> for glib::Value {
1070 #[inline]
1071 fn from(v: MemoryFlags) -> Self {
1072 skip_assert_initialized!();
1073 ToValue::to_value(&v)
1074 }
1075}
1076
1077bitflags! {
1078 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1079 #[doc(alias = "GstMetaFlags")]
1080 pub struct MetaFlags: u32 {
1081 #[doc(alias = "GST_META_FLAG_READONLY")]
1082 const READONLY = ffi::GST_META_FLAG_READONLY as _;
1083 #[doc(alias = "GST_META_FLAG_POOLED")]
1084 const POOLED = ffi::GST_META_FLAG_POOLED as _;
1085 #[doc(alias = "GST_META_FLAG_LOCKED")]
1086 const LOCKED = ffi::GST_META_FLAG_LOCKED as _;
1087 }
1088}
1089
1090#[doc(hidden)]
1091impl IntoGlib for MetaFlags {
1092 type GlibType = ffi::GstMetaFlags;
1093
1094 #[inline]
1095 fn into_glib(self) -> ffi::GstMetaFlags {
1096 self.bits()
1097 }
1098}
1099
1100#[doc(hidden)]
1101impl FromGlib<ffi::GstMetaFlags> for MetaFlags {
1102 #[inline]
1103 unsafe fn from_glib(value: ffi::GstMetaFlags) -> Self {
1104 skip_assert_initialized!();
1105 Self::from_bits_truncate(bits:value)
1106 }
1107}
1108
1109impl StaticType for MetaFlags {
1110 #[inline]
1111 #[doc(alias = "gst_meta_flags_get_type")]
1112 fn static_type() -> glib::Type {
1113 unsafe { from_glib(val:ffi::gst_meta_flags_get_type()) }
1114 }
1115}
1116
1117impl glib::HasParamSpec for MetaFlags {
1118 type ParamSpec = glib::ParamSpecFlags;
1119 type SetValue = Self;
1120 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1121
1122 fn param_spec_builder() -> Self::BuilderFn {
1123 Self::ParamSpec::builder
1124 }
1125}
1126
1127impl glib::value::ValueType for MetaFlags {
1128 type Type = Self;
1129}
1130
1131unsafe impl<'a> glib::value::FromValue<'a> for MetaFlags {
1132 type Checker = glib::value::GenericValueTypeChecker<Self>;
1133
1134 #[inline]
1135 unsafe fn from_value(value: &'a glib::Value) -> Self {
1136 skip_assert_initialized!();
1137 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1138 }
1139}
1140
1141impl ToValue for MetaFlags {
1142 #[inline]
1143 fn to_value(&self) -> glib::Value {
1144 let mut value: Value = glib::Value::for_value_type::<Self>();
1145 unsafe {
1146 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1147 }
1148 value
1149 }
1150
1151 #[inline]
1152 fn value_type(&self) -> glib::Type {
1153 Self::static_type()
1154 }
1155}
1156
1157impl From<MetaFlags> for glib::Value {
1158 #[inline]
1159 fn from(v: MetaFlags) -> Self {
1160 skip_assert_initialized!();
1161 ToValue::to_value(&v)
1162 }
1163}
1164
1165bitflags! {
1166 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1167 #[doc(alias = "GstObjectFlags")]
1168 pub struct ObjectFlags: u32 {
1169 #[doc(alias = "GST_OBJECT_FLAG_MAY_BE_LEAKED")]
1170 const MAY_BE_LEAKED = ffi::GST_OBJECT_FLAG_MAY_BE_LEAKED as _;
1171 }
1172}
1173
1174#[doc(hidden)]
1175impl IntoGlib for ObjectFlags {
1176 type GlibType = ffi::GstObjectFlags;
1177
1178 #[inline]
1179 fn into_glib(self) -> ffi::GstObjectFlags {
1180 self.bits()
1181 }
1182}
1183
1184#[doc(hidden)]
1185impl FromGlib<ffi::GstObjectFlags> for ObjectFlags {
1186 #[inline]
1187 unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self {
1188 skip_assert_initialized!();
1189 Self::from_bits_truncate(bits:value)
1190 }
1191}
1192
1193impl StaticType for ObjectFlags {
1194 #[inline]
1195 #[doc(alias = "gst_object_flags_get_type")]
1196 fn static_type() -> glib::Type {
1197 unsafe { from_glib(val:ffi::gst_object_flags_get_type()) }
1198 }
1199}
1200
1201impl glib::HasParamSpec for ObjectFlags {
1202 type ParamSpec = glib::ParamSpecFlags;
1203 type SetValue = Self;
1204 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1205
1206 fn param_spec_builder() -> Self::BuilderFn {
1207 Self::ParamSpec::builder
1208 }
1209}
1210
1211impl glib::value::ValueType for ObjectFlags {
1212 type Type = Self;
1213}
1214
1215unsafe impl<'a> glib::value::FromValue<'a> for ObjectFlags {
1216 type Checker = glib::value::GenericValueTypeChecker<Self>;
1217
1218 #[inline]
1219 unsafe fn from_value(value: &'a glib::Value) -> Self {
1220 skip_assert_initialized!();
1221 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1222 }
1223}
1224
1225impl ToValue for ObjectFlags {
1226 #[inline]
1227 fn to_value(&self) -> glib::Value {
1228 let mut value: Value = glib::Value::for_value_type::<Self>();
1229 unsafe {
1230 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1231 }
1232 value
1233 }
1234
1235 #[inline]
1236 fn value_type(&self) -> glib::Type {
1237 Self::static_type()
1238 }
1239}
1240
1241impl From<ObjectFlags> for glib::Value {
1242 #[inline]
1243 fn from(v: ObjectFlags) -> Self {
1244 skip_assert_initialized!();
1245 ToValue::to_value(&v)
1246 }
1247}
1248
1249bitflags! {
1250 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1251 #[doc(alias = "GstPadFlags")]
1252 pub struct PadFlags: u32 {
1253 #[doc(alias = "GST_PAD_FLAG_BLOCKED")]
1254 const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as _;
1255 #[doc(alias = "GST_PAD_FLAG_FLUSHING")]
1256 const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as _;
1257 #[doc(alias = "GST_PAD_FLAG_EOS")]
1258 const EOS = ffi::GST_PAD_FLAG_EOS as _;
1259 #[doc(alias = "GST_PAD_FLAG_BLOCKING")]
1260 const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as _;
1261 #[doc(alias = "GST_PAD_FLAG_NEED_PARENT")]
1262 const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as _;
1263 #[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")]
1264 const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as _;
1265 #[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")]
1266 const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as _;
1267 #[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")]
1268 const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as _;
1269 #[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")]
1270 const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as _;
1271 #[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")]
1272 const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as _;
1273 #[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")]
1274 const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as _;
1275 #[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")]
1276 const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as _;
1277 #[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")]
1278 const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as _;
1279 }
1280}
1281
1282#[doc(hidden)]
1283impl IntoGlib for PadFlags {
1284 type GlibType = ffi::GstPadFlags;
1285
1286 #[inline]
1287 fn into_glib(self) -> ffi::GstPadFlags {
1288 self.bits()
1289 }
1290}
1291
1292#[doc(hidden)]
1293impl FromGlib<ffi::GstPadFlags> for PadFlags {
1294 #[inline]
1295 unsafe fn from_glib(value: ffi::GstPadFlags) -> Self {
1296 skip_assert_initialized!();
1297 Self::from_bits_truncate(bits:value)
1298 }
1299}
1300
1301impl StaticType for PadFlags {
1302 #[inline]
1303 #[doc(alias = "gst_pad_flags_get_type")]
1304 fn static_type() -> glib::Type {
1305 unsafe { from_glib(val:ffi::gst_pad_flags_get_type()) }
1306 }
1307}
1308
1309impl glib::HasParamSpec for PadFlags {
1310 type ParamSpec = glib::ParamSpecFlags;
1311 type SetValue = Self;
1312 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1313
1314 fn param_spec_builder() -> Self::BuilderFn {
1315 Self::ParamSpec::builder
1316 }
1317}
1318
1319impl glib::value::ValueType for PadFlags {
1320 type Type = Self;
1321}
1322
1323unsafe impl<'a> glib::value::FromValue<'a> for PadFlags {
1324 type Checker = glib::value::GenericValueTypeChecker<Self>;
1325
1326 #[inline]
1327 unsafe fn from_value(value: &'a glib::Value) -> Self {
1328 skip_assert_initialized!();
1329 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1330 }
1331}
1332
1333impl ToValue for PadFlags {
1334 #[inline]
1335 fn to_value(&self) -> glib::Value {
1336 let mut value: Value = glib::Value::for_value_type::<Self>();
1337 unsafe {
1338 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1339 }
1340 value
1341 }
1342
1343 #[inline]
1344 fn value_type(&self) -> glib::Type {
1345 Self::static_type()
1346 }
1347}
1348
1349impl From<PadFlags> for glib::Value {
1350 #[inline]
1351 fn from(v: PadFlags) -> Self {
1352 skip_assert_initialized!();
1353 ToValue::to_value(&v)
1354 }
1355}
1356
1357bitflags! {
1358 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1359 #[doc(alias = "GstPadLinkCheck")]
1360 pub struct PadLinkCheck: u32 {
1361 #[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")]
1362 const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as _;
1363 #[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")]
1364 const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as _;
1365 #[doc(alias = "GST_PAD_LINK_CHECK_CAPS")]
1366 const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as _;
1367 #[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")]
1368 const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as _;
1369 #[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")]
1370 const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as _;
1371 }
1372}
1373
1374#[doc(hidden)]
1375impl IntoGlib for PadLinkCheck {
1376 type GlibType = ffi::GstPadLinkCheck;
1377
1378 #[inline]
1379 fn into_glib(self) -> ffi::GstPadLinkCheck {
1380 self.bits()
1381 }
1382}
1383
1384#[doc(hidden)]
1385impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck {
1386 #[inline]
1387 unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self {
1388 skip_assert_initialized!();
1389 Self::from_bits_truncate(bits:value)
1390 }
1391}
1392
1393impl StaticType for PadLinkCheck {
1394 #[inline]
1395 #[doc(alias = "gst_pad_link_check_get_type")]
1396 fn static_type() -> glib::Type {
1397 unsafe { from_glib(val:ffi::gst_pad_link_check_get_type()) }
1398 }
1399}
1400
1401impl glib::HasParamSpec for PadLinkCheck {
1402 type ParamSpec = glib::ParamSpecFlags;
1403 type SetValue = Self;
1404 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1405
1406 fn param_spec_builder() -> Self::BuilderFn {
1407 Self::ParamSpec::builder
1408 }
1409}
1410
1411impl glib::value::ValueType for PadLinkCheck {
1412 type Type = Self;
1413}
1414
1415unsafe impl<'a> glib::value::FromValue<'a> for PadLinkCheck {
1416 type Checker = glib::value::GenericValueTypeChecker<Self>;
1417
1418 #[inline]
1419 unsafe fn from_value(value: &'a glib::Value) -> Self {
1420 skip_assert_initialized!();
1421 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1422 }
1423}
1424
1425impl ToValue for PadLinkCheck {
1426 #[inline]
1427 fn to_value(&self) -> glib::Value {
1428 let mut value: Value = glib::Value::for_value_type::<Self>();
1429 unsafe {
1430 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1431 }
1432 value
1433 }
1434
1435 #[inline]
1436 fn value_type(&self) -> glib::Type {
1437 Self::static_type()
1438 }
1439}
1440
1441impl From<PadLinkCheck> for glib::Value {
1442 #[inline]
1443 fn from(v: PadLinkCheck) -> Self {
1444 skip_assert_initialized!();
1445 ToValue::to_value(&v)
1446 }
1447}
1448
1449bitflags! {
1450 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1451 #[doc(alias = "GstPadProbeType")]
1452 pub struct PadProbeType: u32 {
1453 #[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")]
1454 const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as _;
1455 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")]
1456 const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as _;
1457 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")]
1458 const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as _;
1459 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")]
1460 const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as _;
1461 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")]
1462 const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as _;
1463 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")]
1464 const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as _;
1465 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")]
1466 const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as _;
1467 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")]
1468 const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as _;
1469 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")]
1470 const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as _;
1471 #[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")]
1472 const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as _;
1473 #[doc(alias = "GST_PAD_PROBE_TYPE_PULL")]
1474 const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as _;
1475 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")]
1476 const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as _;
1477 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")]
1478 const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as _;
1479 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")]
1480 const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as _;
1481 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")]
1482 const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as _;
1483 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")]
1484 const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as _;
1485 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")]
1486 const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as _;
1487 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")]
1488 const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as _;
1489 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")]
1490 const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as _;
1491 #[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")]
1492 const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as _;
1493 #[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")]
1494 const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as _;
1495 }
1496}
1497
1498#[doc(hidden)]
1499impl IntoGlib for PadProbeType {
1500 type GlibType = ffi::GstPadProbeType;
1501
1502 #[inline]
1503 fn into_glib(self) -> ffi::GstPadProbeType {
1504 self.bits()
1505 }
1506}
1507
1508#[doc(hidden)]
1509impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
1510 #[inline]
1511 unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self {
1512 skip_assert_initialized!();
1513 Self::from_bits_truncate(bits:value)
1514 }
1515}
1516
1517impl StaticType for PadProbeType {
1518 #[inline]
1519 #[doc(alias = "gst_pad_probe_type_get_type")]
1520 fn static_type() -> glib::Type {
1521 unsafe { from_glib(val:ffi::gst_pad_probe_type_get_type()) }
1522 }
1523}
1524
1525impl glib::HasParamSpec for PadProbeType {
1526 type ParamSpec = glib::ParamSpecFlags;
1527 type SetValue = Self;
1528 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1529
1530 fn param_spec_builder() -> Self::BuilderFn {
1531 Self::ParamSpec::builder
1532 }
1533}
1534
1535impl glib::value::ValueType for PadProbeType {
1536 type Type = Self;
1537}
1538
1539unsafe impl<'a> glib::value::FromValue<'a> for PadProbeType {
1540 type Checker = glib::value::GenericValueTypeChecker<Self>;
1541
1542 #[inline]
1543 unsafe fn from_value(value: &'a glib::Value) -> Self {
1544 skip_assert_initialized!();
1545 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1546 }
1547}
1548
1549impl ToValue for PadProbeType {
1550 #[inline]
1551 fn to_value(&self) -> glib::Value {
1552 let mut value: Value = glib::Value::for_value_type::<Self>();
1553 unsafe {
1554 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1555 }
1556 value
1557 }
1558
1559 #[inline]
1560 fn value_type(&self) -> glib::Type {
1561 Self::static_type()
1562 }
1563}
1564
1565impl From<PadProbeType> for glib::Value {
1566 #[inline]
1567 fn from(v: PadProbeType) -> Self {
1568 skip_assert_initialized!();
1569 ToValue::to_value(&v)
1570 }
1571}
1572
1573bitflags! {
1574 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1575 #[doc(alias = "GstParseFlags")]
1576 pub struct ParseFlags: u32 {
1577 #[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")]
1578 const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as _;
1579 #[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")]
1580 const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as _;
1581 #[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")]
1582 const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as _;
1583 }
1584}
1585
1586#[doc(hidden)]
1587impl IntoGlib for ParseFlags {
1588 type GlibType = ffi::GstParseFlags;
1589
1590 #[inline]
1591 fn into_glib(self) -> ffi::GstParseFlags {
1592 self.bits()
1593 }
1594}
1595
1596#[doc(hidden)]
1597impl FromGlib<ffi::GstParseFlags> for ParseFlags {
1598 #[inline]
1599 unsafe fn from_glib(value: ffi::GstParseFlags) -> Self {
1600 skip_assert_initialized!();
1601 Self::from_bits_truncate(bits:value)
1602 }
1603}
1604
1605impl StaticType for ParseFlags {
1606 #[inline]
1607 #[doc(alias = "gst_parse_flags_get_type")]
1608 fn static_type() -> glib::Type {
1609 unsafe { from_glib(val:ffi::gst_parse_flags_get_type()) }
1610 }
1611}
1612
1613impl glib::HasParamSpec for ParseFlags {
1614 type ParamSpec = glib::ParamSpecFlags;
1615 type SetValue = Self;
1616 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1617
1618 fn param_spec_builder() -> Self::BuilderFn {
1619 Self::ParamSpec::builder
1620 }
1621}
1622
1623impl glib::value::ValueType for ParseFlags {
1624 type Type = Self;
1625}
1626
1627unsafe impl<'a> glib::value::FromValue<'a> for ParseFlags {
1628 type Checker = glib::value::GenericValueTypeChecker<Self>;
1629
1630 #[inline]
1631 unsafe fn from_value(value: &'a glib::Value) -> Self {
1632 skip_assert_initialized!();
1633 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1634 }
1635}
1636
1637impl ToValue for ParseFlags {
1638 #[inline]
1639 fn to_value(&self) -> glib::Value {
1640 let mut value: Value = glib::Value::for_value_type::<Self>();
1641 unsafe {
1642 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1643 }
1644 value
1645 }
1646
1647 #[inline]
1648 fn value_type(&self) -> glib::Type {
1649 Self::static_type()
1650 }
1651}
1652
1653impl From<ParseFlags> for glib::Value {
1654 #[inline]
1655 fn from(v: ParseFlags) -> Self {
1656 skip_assert_initialized!();
1657 ToValue::to_value(&v)
1658 }
1659}
1660
1661bitflags! {
1662 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1663 #[doc(alias = "GstPipelineFlags")]
1664 pub struct PipelineFlags: u32 {
1665 #[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")]
1666 const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as _;
1667 }
1668}
1669
1670#[doc(hidden)]
1671impl IntoGlib for PipelineFlags {
1672 type GlibType = ffi::GstPipelineFlags;
1673
1674 #[inline]
1675 fn into_glib(self) -> ffi::GstPipelineFlags {
1676 self.bits()
1677 }
1678}
1679
1680#[doc(hidden)]
1681impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags {
1682 #[inline]
1683 unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self {
1684 skip_assert_initialized!();
1685 Self::from_bits_truncate(bits:value)
1686 }
1687}
1688
1689impl StaticType for PipelineFlags {
1690 #[inline]
1691 #[doc(alias = "gst_pipeline_flags_get_type")]
1692 fn static_type() -> glib::Type {
1693 unsafe { from_glib(val:ffi::gst_pipeline_flags_get_type()) }
1694 }
1695}
1696
1697impl glib::HasParamSpec for PipelineFlags {
1698 type ParamSpec = glib::ParamSpecFlags;
1699 type SetValue = Self;
1700 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1701
1702 fn param_spec_builder() -> Self::BuilderFn {
1703 Self::ParamSpec::builder
1704 }
1705}
1706
1707impl glib::value::ValueType for PipelineFlags {
1708 type Type = Self;
1709}
1710
1711unsafe impl<'a> glib::value::FromValue<'a> for PipelineFlags {
1712 type Checker = glib::value::GenericValueTypeChecker<Self>;
1713
1714 #[inline]
1715 unsafe fn from_value(value: &'a glib::Value) -> Self {
1716 skip_assert_initialized!();
1717 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1718 }
1719}
1720
1721impl ToValue for PipelineFlags {
1722 #[inline]
1723 fn to_value(&self) -> glib::Value {
1724 let mut value: Value = glib::Value::for_value_type::<Self>();
1725 unsafe {
1726 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1727 }
1728 value
1729 }
1730
1731 #[inline]
1732 fn value_type(&self) -> glib::Type {
1733 Self::static_type()
1734 }
1735}
1736
1737impl From<PipelineFlags> for glib::Value {
1738 #[inline]
1739 fn from(v: PipelineFlags) -> Self {
1740 skip_assert_initialized!();
1741 ToValue::to_value(&v)
1742 }
1743}
1744
1745#[cfg(feature = "v1_18")]
1746bitflags! {
1747 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1748 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1749 #[doc(alias = "GstPluginAPIFlags")]
1750 pub struct PluginAPIFlags: u32 {
1751 #[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")]
1752 const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as _;
1753 }
1754}
1755
1756#[cfg(feature = "v1_18")]
1757#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1758#[doc(hidden)]
1759impl IntoGlib for PluginAPIFlags {
1760 type GlibType = ffi::GstPluginAPIFlags;
1761
1762 #[inline]
1763 fn into_glib(self) -> ffi::GstPluginAPIFlags {
1764 self.bits()
1765 }
1766}
1767
1768#[cfg(feature = "v1_18")]
1769#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1770#[doc(hidden)]
1771impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags {
1772 #[inline]
1773 unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self {
1774 skip_assert_initialized!();
1775 Self::from_bits_truncate(value)
1776 }
1777}
1778
1779#[cfg(feature = "v1_18")]
1780#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1781impl StaticType for PluginAPIFlags {
1782 #[inline]
1783 #[doc(alias = "gst_plugin_api_flags_get_type")]
1784 fn static_type() -> glib::Type {
1785 unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) }
1786 }
1787}
1788
1789#[cfg(feature = "v1_18")]
1790#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1791impl glib::HasParamSpec for PluginAPIFlags {
1792 type ParamSpec = glib::ParamSpecFlags;
1793 type SetValue = Self;
1794 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1795
1796 fn param_spec_builder() -> Self::BuilderFn {
1797 Self::ParamSpec::builder
1798 }
1799}
1800
1801#[cfg(feature = "v1_18")]
1802#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1803impl glib::value::ValueType for PluginAPIFlags {
1804 type Type = Self;
1805}
1806
1807#[cfg(feature = "v1_18")]
1808#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1809unsafe impl<'a> glib::value::FromValue<'a> for PluginAPIFlags {
1810 type Checker = glib::value::GenericValueTypeChecker<Self>;
1811
1812 #[inline]
1813 unsafe fn from_value(value: &'a glib::Value) -> Self {
1814 skip_assert_initialized!();
1815 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1816 }
1817}
1818
1819#[cfg(feature = "v1_18")]
1820#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1821impl ToValue for PluginAPIFlags {
1822 #[inline]
1823 fn to_value(&self) -> glib::Value {
1824 let mut value = glib::Value::for_value_type::<Self>();
1825 unsafe {
1826 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1827 }
1828 value
1829 }
1830
1831 #[inline]
1832 fn value_type(&self) -> glib::Type {
1833 Self::static_type()
1834 }
1835}
1836
1837#[cfg(feature = "v1_18")]
1838#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1839impl From<PluginAPIFlags> for glib::Value {
1840 #[inline]
1841 fn from(v: PluginAPIFlags) -> Self {
1842 skip_assert_initialized!();
1843 ToValue::to_value(&v)
1844 }
1845}
1846
1847bitflags! {
1848 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1849 #[doc(alias = "GstPluginDependencyFlags")]
1850 pub struct PluginDependencyFlags: u32 {
1851 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")]
1852 const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as _;
1853 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")]
1854 const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as _;
1855 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")]
1856 const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as _;
1857 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")]
1858 const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as _;
1859 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")]
1860 const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as _;
1861 }
1862}
1863
1864#[doc(hidden)]
1865impl IntoGlib for PluginDependencyFlags {
1866 type GlibType = ffi::GstPluginDependencyFlags;
1867
1868 #[inline]
1869 fn into_glib(self) -> ffi::GstPluginDependencyFlags {
1870 self.bits()
1871 }
1872}
1873
1874#[doc(hidden)]
1875impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags {
1876 #[inline]
1877 unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self {
1878 skip_assert_initialized!();
1879 Self::from_bits_truncate(bits:value)
1880 }
1881}
1882
1883impl StaticType for PluginDependencyFlags {
1884 #[inline]
1885 #[doc(alias = "gst_plugin_dependency_flags_get_type")]
1886 fn static_type() -> glib::Type {
1887 unsafe { from_glib(val:ffi::gst_plugin_dependency_flags_get_type()) }
1888 }
1889}
1890
1891impl glib::HasParamSpec for PluginDependencyFlags {
1892 type ParamSpec = glib::ParamSpecFlags;
1893 type SetValue = Self;
1894 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1895
1896 fn param_spec_builder() -> Self::BuilderFn {
1897 Self::ParamSpec::builder
1898 }
1899}
1900
1901impl glib::value::ValueType for PluginDependencyFlags {
1902 type Type = Self;
1903}
1904
1905unsafe impl<'a> glib::value::FromValue<'a> for PluginDependencyFlags {
1906 type Checker = glib::value::GenericValueTypeChecker<Self>;
1907
1908 #[inline]
1909 unsafe fn from_value(value: &'a glib::Value) -> Self {
1910 skip_assert_initialized!();
1911 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1912 }
1913}
1914
1915impl ToValue for PluginDependencyFlags {
1916 #[inline]
1917 fn to_value(&self) -> glib::Value {
1918 let mut value: Value = glib::Value::for_value_type::<Self>();
1919 unsafe {
1920 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
1921 }
1922 value
1923 }
1924
1925 #[inline]
1926 fn value_type(&self) -> glib::Type {
1927 Self::static_type()
1928 }
1929}
1930
1931impl From<PluginDependencyFlags> for glib::Value {
1932 #[inline]
1933 fn from(v: PluginDependencyFlags) -> Self {
1934 skip_assert_initialized!();
1935 ToValue::to_value(&v)
1936 }
1937}
1938
1939bitflags! {
1940 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1941 #[doc(alias = "GstPluginFlags")]
1942 pub struct PluginFlags: u32 {
1943 #[doc(alias = "GST_PLUGIN_FLAG_CACHED")]
1944 const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as _;
1945 #[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")]
1946 const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as _;
1947 }
1948}
1949
1950#[doc(hidden)]
1951impl IntoGlib for PluginFlags {
1952 type GlibType = ffi::GstPluginFlags;
1953
1954 #[inline]
1955 fn into_glib(self) -> ffi::GstPluginFlags {
1956 self.bits()
1957 }
1958}
1959
1960#[doc(hidden)]
1961impl FromGlib<ffi::GstPluginFlags> for PluginFlags {
1962 #[inline]
1963 unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self {
1964 skip_assert_initialized!();
1965 Self::from_bits_truncate(bits:value)
1966 }
1967}
1968
1969impl StaticType for PluginFlags {
1970 #[inline]
1971 #[doc(alias = "gst_plugin_flags_get_type")]
1972 fn static_type() -> glib::Type {
1973 unsafe { from_glib(val:ffi::gst_plugin_flags_get_type()) }
1974 }
1975}
1976
1977impl glib::HasParamSpec for PluginFlags {
1978 type ParamSpec = glib::ParamSpecFlags;
1979 type SetValue = Self;
1980 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1981
1982 fn param_spec_builder() -> Self::BuilderFn {
1983 Self::ParamSpec::builder
1984 }
1985}
1986
1987impl glib::value::ValueType for PluginFlags {
1988 type Type = Self;
1989}
1990
1991unsafe impl<'a> glib::value::FromValue<'a> for PluginFlags {
1992 type Checker = glib::value::GenericValueTypeChecker<Self>;
1993
1994 #[inline]
1995 unsafe fn from_value(value: &'a glib::Value) -> Self {
1996 skip_assert_initialized!();
1997 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1998 }
1999}
2000
2001impl ToValue for PluginFlags {
2002 #[inline]
2003 fn to_value(&self) -> glib::Value {
2004 let mut value: Value = glib::Value::for_value_type::<Self>();
2005 unsafe {
2006 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2007 }
2008 value
2009 }
2010
2011 #[inline]
2012 fn value_type(&self) -> glib::Type {
2013 Self::static_type()
2014 }
2015}
2016
2017impl From<PluginFlags> for glib::Value {
2018 #[inline]
2019 fn from(v: PluginFlags) -> Self {
2020 skip_assert_initialized!();
2021 ToValue::to_value(&v)
2022 }
2023}
2024
2025bitflags! {
2026 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2027 #[doc(alias = "GstSchedulingFlags")]
2028 pub struct SchedulingFlags: u32 {
2029 #[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")]
2030 const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as _;
2031 #[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")]
2032 const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as _;
2033 #[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")]
2034 const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as _;
2035 }
2036}
2037
2038#[doc(hidden)]
2039impl IntoGlib for SchedulingFlags {
2040 type GlibType = ffi::GstSchedulingFlags;
2041
2042 #[inline]
2043 fn into_glib(self) -> ffi::GstSchedulingFlags {
2044 self.bits()
2045 }
2046}
2047
2048#[doc(hidden)]
2049impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags {
2050 #[inline]
2051 unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self {
2052 skip_assert_initialized!();
2053 Self::from_bits_truncate(bits:value)
2054 }
2055}
2056
2057impl StaticType for SchedulingFlags {
2058 #[inline]
2059 #[doc(alias = "gst_scheduling_flags_get_type")]
2060 fn static_type() -> glib::Type {
2061 unsafe { from_glib(val:ffi::gst_scheduling_flags_get_type()) }
2062 }
2063}
2064
2065impl glib::HasParamSpec for SchedulingFlags {
2066 type ParamSpec = glib::ParamSpecFlags;
2067 type SetValue = Self;
2068 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2069
2070 fn param_spec_builder() -> Self::BuilderFn {
2071 Self::ParamSpec::builder
2072 }
2073}
2074
2075impl glib::value::ValueType for SchedulingFlags {
2076 type Type = Self;
2077}
2078
2079unsafe impl<'a> glib::value::FromValue<'a> for SchedulingFlags {
2080 type Checker = glib::value::GenericValueTypeChecker<Self>;
2081
2082 #[inline]
2083 unsafe fn from_value(value: &'a glib::Value) -> Self {
2084 skip_assert_initialized!();
2085 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2086 }
2087}
2088
2089impl ToValue for SchedulingFlags {
2090 #[inline]
2091 fn to_value(&self) -> glib::Value {
2092 let mut value: Value = glib::Value::for_value_type::<Self>();
2093 unsafe {
2094 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2095 }
2096 value
2097 }
2098
2099 #[inline]
2100 fn value_type(&self) -> glib::Type {
2101 Self::static_type()
2102 }
2103}
2104
2105impl From<SchedulingFlags> for glib::Value {
2106 #[inline]
2107 fn from(v: SchedulingFlags) -> Self {
2108 skip_assert_initialized!();
2109 ToValue::to_value(&v)
2110 }
2111}
2112
2113bitflags! {
2114 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2115 #[doc(alias = "GstSeekFlags")]
2116 pub struct SeekFlags: u32 {
2117 #[doc(alias = "GST_SEEK_FLAG_FLUSH")]
2118 const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as _;
2119 #[doc(alias = "GST_SEEK_FLAG_ACCURATE")]
2120 const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as _;
2121 #[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")]
2122 const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as _;
2123 #[doc(alias = "GST_SEEK_FLAG_SEGMENT")]
2124 const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as _;
2125 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE")]
2126 const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as _;
2127 #[doc(alias = "GST_SEEK_FLAG_SKIP")]
2128 const SKIP = ffi::GST_SEEK_FLAG_SKIP as _;
2129 #[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")]
2130 const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as _;
2131 #[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")]
2132 const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as _;
2133 #[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")]
2134 const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as _;
2135 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")]
2136 const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as _;
2137 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")]
2138 const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as _;
2139 #[cfg(feature = "v1_18")]
2140 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2141 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2142 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2143 #[cfg(feature = "v1_18")]
2144 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2145 #[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")]
2146 const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as _;
2147 }
2148}
2149
2150#[doc(hidden)]
2151impl IntoGlib for SeekFlags {
2152 type GlibType = ffi::GstSeekFlags;
2153
2154 #[inline]
2155 fn into_glib(self) -> ffi::GstSeekFlags {
2156 self.bits()
2157 }
2158}
2159
2160#[doc(hidden)]
2161impl FromGlib<ffi::GstSeekFlags> for SeekFlags {
2162 #[inline]
2163 unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self {
2164 skip_assert_initialized!();
2165 Self::from_bits_truncate(bits:value)
2166 }
2167}
2168
2169impl StaticType for SeekFlags {
2170 #[inline]
2171 #[doc(alias = "gst_seek_flags_get_type")]
2172 fn static_type() -> glib::Type {
2173 unsafe { from_glib(val:ffi::gst_seek_flags_get_type()) }
2174 }
2175}
2176
2177impl glib::HasParamSpec for SeekFlags {
2178 type ParamSpec = glib::ParamSpecFlags;
2179 type SetValue = Self;
2180 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2181
2182 fn param_spec_builder() -> Self::BuilderFn {
2183 Self::ParamSpec::builder
2184 }
2185}
2186
2187impl glib::value::ValueType for SeekFlags {
2188 type Type = Self;
2189}
2190
2191unsafe impl<'a> glib::value::FromValue<'a> for SeekFlags {
2192 type Checker = glib::value::GenericValueTypeChecker<Self>;
2193
2194 #[inline]
2195 unsafe fn from_value(value: &'a glib::Value) -> Self {
2196 skip_assert_initialized!();
2197 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2198 }
2199}
2200
2201impl ToValue for SeekFlags {
2202 #[inline]
2203 fn to_value(&self) -> glib::Value {
2204 let mut value: Value = glib::Value::for_value_type::<Self>();
2205 unsafe {
2206 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2207 }
2208 value
2209 }
2210
2211 #[inline]
2212 fn value_type(&self) -> glib::Type {
2213 Self::static_type()
2214 }
2215}
2216
2217impl From<SeekFlags> for glib::Value {
2218 #[inline]
2219 fn from(v: SeekFlags) -> Self {
2220 skip_assert_initialized!();
2221 ToValue::to_value(&v)
2222 }
2223}
2224
2225bitflags! {
2226 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2227 #[doc(alias = "GstSegmentFlags")]
2228 pub struct SegmentFlags: u32 {
2229 #[doc(alias = "GST_SEGMENT_FLAG_RESET")]
2230 const RESET = ffi::GST_SEGMENT_FLAG_RESET as _;
2231 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")]
2232 const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as _;
2233 #[doc(alias = "GST_SEGMENT_FLAG_SKIP")]
2234 const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as _;
2235 #[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")]
2236 const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as _;
2237 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")]
2238 const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as _;
2239 #[cfg(feature = "v1_18")]
2240 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2241 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2242 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2243 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")]
2244 const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as _;
2245 }
2246}
2247
2248#[doc(hidden)]
2249impl IntoGlib for SegmentFlags {
2250 type GlibType = ffi::GstSegmentFlags;
2251
2252 #[inline]
2253 fn into_glib(self) -> ffi::GstSegmentFlags {
2254 self.bits()
2255 }
2256}
2257
2258#[doc(hidden)]
2259impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags {
2260 #[inline]
2261 unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self {
2262 skip_assert_initialized!();
2263 Self::from_bits_truncate(bits:value)
2264 }
2265}
2266
2267impl StaticType for SegmentFlags {
2268 #[inline]
2269 #[doc(alias = "gst_segment_flags_get_type")]
2270 fn static_type() -> glib::Type {
2271 unsafe { from_glib(val:ffi::gst_segment_flags_get_type()) }
2272 }
2273}
2274
2275impl glib::HasParamSpec for SegmentFlags {
2276 type ParamSpec = glib::ParamSpecFlags;
2277 type SetValue = Self;
2278 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2279
2280 fn param_spec_builder() -> Self::BuilderFn {
2281 Self::ParamSpec::builder
2282 }
2283}
2284
2285impl glib::value::ValueType for SegmentFlags {
2286 type Type = Self;
2287}
2288
2289unsafe impl<'a> glib::value::FromValue<'a> for SegmentFlags {
2290 type Checker = glib::value::GenericValueTypeChecker<Self>;
2291
2292 #[inline]
2293 unsafe fn from_value(value: &'a glib::Value) -> Self {
2294 skip_assert_initialized!();
2295 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2296 }
2297}
2298
2299impl ToValue for SegmentFlags {
2300 #[inline]
2301 fn to_value(&self) -> glib::Value {
2302 let mut value: Value = glib::Value::for_value_type::<Self>();
2303 unsafe {
2304 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2305 }
2306 value
2307 }
2308
2309 #[inline]
2310 fn value_type(&self) -> glib::Type {
2311 Self::static_type()
2312 }
2313}
2314
2315impl From<SegmentFlags> for glib::Value {
2316 #[inline]
2317 fn from(v: SegmentFlags) -> Self {
2318 skip_assert_initialized!();
2319 ToValue::to_value(&v)
2320 }
2321}
2322
2323#[cfg(feature = "v1_20")]
2324bitflags! {
2325 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2326 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2327 #[doc(alias = "GstSerializeFlags")]
2328 pub struct SerializeFlags: u32 {
2329 #[doc(alias = "GST_SERIALIZE_FLAG_NONE")]
2330 const NONE = ffi::GST_SERIALIZE_FLAG_NONE as _;
2331 #[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")]
2332 const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as _;
2333 }
2334}
2335
2336#[cfg(feature = "v1_20")]
2337#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2338#[doc(hidden)]
2339impl IntoGlib for SerializeFlags {
2340 type GlibType = ffi::GstSerializeFlags;
2341
2342 #[inline]
2343 fn into_glib(self) -> ffi::GstSerializeFlags {
2344 self.bits()
2345 }
2346}
2347
2348#[cfg(feature = "v1_20")]
2349#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2350#[doc(hidden)]
2351impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags {
2352 #[inline]
2353 unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self {
2354 skip_assert_initialized!();
2355 Self::from_bits_truncate(value)
2356 }
2357}
2358
2359#[cfg(feature = "v1_20")]
2360#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2361impl StaticType for SerializeFlags {
2362 #[inline]
2363 #[doc(alias = "gst_serialize_flags_get_type")]
2364 fn static_type() -> glib::Type {
2365 unsafe { from_glib(ffi::gst_serialize_flags_get_type()) }
2366 }
2367}
2368
2369#[cfg(feature = "v1_20")]
2370#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2371impl glib::HasParamSpec for SerializeFlags {
2372 type ParamSpec = glib::ParamSpecFlags;
2373 type SetValue = Self;
2374 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2375
2376 fn param_spec_builder() -> Self::BuilderFn {
2377 Self::ParamSpec::builder
2378 }
2379}
2380
2381#[cfg(feature = "v1_20")]
2382#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2383impl glib::value::ValueType for SerializeFlags {
2384 type Type = Self;
2385}
2386
2387#[cfg(feature = "v1_20")]
2388#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2389unsafe impl<'a> glib::value::FromValue<'a> for SerializeFlags {
2390 type Checker = glib::value::GenericValueTypeChecker<Self>;
2391
2392 #[inline]
2393 unsafe fn from_value(value: &'a glib::Value) -> Self {
2394 skip_assert_initialized!();
2395 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2396 }
2397}
2398
2399#[cfg(feature = "v1_20")]
2400#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2401impl ToValue for SerializeFlags {
2402 #[inline]
2403 fn to_value(&self) -> glib::Value {
2404 let mut value = glib::Value::for_value_type::<Self>();
2405 unsafe {
2406 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2407 }
2408 value
2409 }
2410
2411 #[inline]
2412 fn value_type(&self) -> glib::Type {
2413 Self::static_type()
2414 }
2415}
2416
2417#[cfg(feature = "v1_20")]
2418#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2419impl From<SerializeFlags> for glib::Value {
2420 #[inline]
2421 fn from(v: SerializeFlags) -> Self {
2422 skip_assert_initialized!();
2423 ToValue::to_value(&v)
2424 }
2425}
2426
2427bitflags! {
2428 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2429 #[doc(alias = "GstStackTraceFlags")]
2430 pub struct StackTraceFlags: u32 {
2431 #[doc(alias = "GST_STACK_TRACE_SHOW_FULL")]
2432 const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as _;
2433 }
2434}
2435
2436#[doc(hidden)]
2437impl IntoGlib for StackTraceFlags {
2438 type GlibType = ffi::GstStackTraceFlags;
2439
2440 #[inline]
2441 fn into_glib(self) -> ffi::GstStackTraceFlags {
2442 self.bits()
2443 }
2444}
2445
2446#[doc(hidden)]
2447impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags {
2448 #[inline]
2449 unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self {
2450 skip_assert_initialized!();
2451 Self::from_bits_truncate(bits:value)
2452 }
2453}
2454
2455impl StaticType for StackTraceFlags {
2456 #[inline]
2457 #[doc(alias = "gst_stack_trace_flags_get_type")]
2458 fn static_type() -> glib::Type {
2459 unsafe { from_glib(val:ffi::gst_stack_trace_flags_get_type()) }
2460 }
2461}
2462
2463impl glib::HasParamSpec for StackTraceFlags {
2464 type ParamSpec = glib::ParamSpecFlags;
2465 type SetValue = Self;
2466 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2467
2468 fn param_spec_builder() -> Self::BuilderFn {
2469 Self::ParamSpec::builder
2470 }
2471}
2472
2473impl glib::value::ValueType for StackTraceFlags {
2474 type Type = Self;
2475}
2476
2477unsafe impl<'a> glib::value::FromValue<'a> for StackTraceFlags {
2478 type Checker = glib::value::GenericValueTypeChecker<Self>;
2479
2480 #[inline]
2481 unsafe fn from_value(value: &'a glib::Value) -> Self {
2482 skip_assert_initialized!();
2483 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2484 }
2485}
2486
2487impl ToValue for StackTraceFlags {
2488 #[inline]
2489 fn to_value(&self) -> glib::Value {
2490 let mut value: Value = glib::Value::for_value_type::<Self>();
2491 unsafe {
2492 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2493 }
2494 value
2495 }
2496
2497 #[inline]
2498 fn value_type(&self) -> glib::Type {
2499 Self::static_type()
2500 }
2501}
2502
2503impl From<StackTraceFlags> for glib::Value {
2504 #[inline]
2505 fn from(v: StackTraceFlags) -> Self {
2506 skip_assert_initialized!();
2507 ToValue::to_value(&v)
2508 }
2509}
2510
2511bitflags! {
2512 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2513 #[doc(alias = "GstStreamFlags")]
2514 pub struct StreamFlags: u32 {
2515 #[doc(alias = "GST_STREAM_FLAG_SPARSE")]
2516 const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as _;
2517 #[doc(alias = "GST_STREAM_FLAG_SELECT")]
2518 const SELECT = ffi::GST_STREAM_FLAG_SELECT as _;
2519 #[doc(alias = "GST_STREAM_FLAG_UNSELECT")]
2520 const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as _;
2521 }
2522}
2523
2524#[doc(hidden)]
2525impl IntoGlib for StreamFlags {
2526 type GlibType = ffi::GstStreamFlags;
2527
2528 #[inline]
2529 fn into_glib(self) -> ffi::GstStreamFlags {
2530 self.bits()
2531 }
2532}
2533
2534#[doc(hidden)]
2535impl FromGlib<ffi::GstStreamFlags> for StreamFlags {
2536 #[inline]
2537 unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self {
2538 skip_assert_initialized!();
2539 Self::from_bits_truncate(bits:value)
2540 }
2541}
2542
2543impl StaticType for StreamFlags {
2544 #[inline]
2545 #[doc(alias = "gst_stream_flags_get_type")]
2546 fn static_type() -> glib::Type {
2547 unsafe { from_glib(val:ffi::gst_stream_flags_get_type()) }
2548 }
2549}
2550
2551impl glib::HasParamSpec for StreamFlags {
2552 type ParamSpec = glib::ParamSpecFlags;
2553 type SetValue = Self;
2554 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2555
2556 fn param_spec_builder() -> Self::BuilderFn {
2557 Self::ParamSpec::builder
2558 }
2559}
2560
2561impl glib::value::ValueType for StreamFlags {
2562 type Type = Self;
2563}
2564
2565unsafe impl<'a> glib::value::FromValue<'a> for StreamFlags {
2566 type Checker = glib::value::GenericValueTypeChecker<Self>;
2567
2568 #[inline]
2569 unsafe fn from_value(value: &'a glib::Value) -> Self {
2570 skip_assert_initialized!();
2571 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2572 }
2573}
2574
2575impl ToValue for StreamFlags {
2576 #[inline]
2577 fn to_value(&self) -> glib::Value {
2578 let mut value: Value = glib::Value::for_value_type::<Self>();
2579 unsafe {
2580 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2581 }
2582 value
2583 }
2584
2585 #[inline]
2586 fn value_type(&self) -> glib::Type {
2587 Self::static_type()
2588 }
2589}
2590
2591impl From<StreamFlags> for glib::Value {
2592 #[inline]
2593 fn from(v: StreamFlags) -> Self {
2594 skip_assert_initialized!();
2595 ToValue::to_value(&v)
2596 }
2597}
2598
2599bitflags! {
2600 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2601 #[doc(alias = "GstStreamType")]
2602 pub struct StreamType: u32 {
2603 #[doc(alias = "GST_STREAM_TYPE_UNKNOWN")]
2604 const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as _;
2605 #[doc(alias = "GST_STREAM_TYPE_AUDIO")]
2606 const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as _;
2607 #[doc(alias = "GST_STREAM_TYPE_VIDEO")]
2608 const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as _;
2609 #[doc(alias = "GST_STREAM_TYPE_CONTAINER")]
2610 const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as _;
2611 #[doc(alias = "GST_STREAM_TYPE_TEXT")]
2612 const TEXT = ffi::GST_STREAM_TYPE_TEXT as _;
2613 }
2614}
2615
2616impl StreamType {
2617 pub fn name<'a>(self) -> &'a GStr {
2618 unsafe {
2619 GStr::from_ptr(
2620 ffi::gst_stream_type_get_name(self.into_glib())
2621 .as_ref()
2622 .expect(msg:"gst_stream_type_get_name returned NULL"),
2623 )
2624 }
2625 }
2626}
2627
2628impl fmt::Display for StreamType {
2629 #[inline]
2630 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2631 f.write_str(&self.name())
2632 }
2633}
2634
2635#[doc(hidden)]
2636impl IntoGlib for StreamType {
2637 type GlibType = ffi::GstStreamType;
2638
2639 #[inline]
2640 fn into_glib(self) -> ffi::GstStreamType {
2641 self.bits()
2642 }
2643}
2644
2645#[doc(hidden)]
2646impl FromGlib<ffi::GstStreamType> for StreamType {
2647 #[inline]
2648 unsafe fn from_glib(value: ffi::GstStreamType) -> Self {
2649 skip_assert_initialized!();
2650 Self::from_bits_truncate(bits:value)
2651 }
2652}
2653
2654impl StaticType for StreamType {
2655 #[inline]
2656 #[doc(alias = "gst_stream_type_get_type")]
2657 fn static_type() -> glib::Type {
2658 unsafe { from_glib(val:ffi::gst_stream_type_get_type()) }
2659 }
2660}
2661
2662impl glib::HasParamSpec for StreamType {
2663 type ParamSpec = glib::ParamSpecFlags;
2664 type SetValue = Self;
2665 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2666
2667 fn param_spec_builder() -> Self::BuilderFn {
2668 Self::ParamSpec::builder
2669 }
2670}
2671
2672impl glib::value::ValueType for StreamType {
2673 type Type = Self;
2674}
2675
2676unsafe impl<'a> glib::value::FromValue<'a> for StreamType {
2677 type Checker = glib::value::GenericValueTypeChecker<Self>;
2678
2679 #[inline]
2680 unsafe fn from_value(value: &'a glib::Value) -> Self {
2681 skip_assert_initialized!();
2682 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2683 }
2684}
2685
2686impl ToValue for StreamType {
2687 #[inline]
2688 fn to_value(&self) -> glib::Value {
2689 let mut value: Value = glib::Value::for_value_type::<Self>();
2690 unsafe {
2691 glib::gobject_ffi::g_value_set_flags(value:value.to_glib_none_mut().0, self.into_glib());
2692 }
2693 value
2694 }
2695
2696 #[inline]
2697 fn value_type(&self) -> glib::Type {
2698 Self::static_type()
2699 }
2700}
2701
2702impl From<StreamType> for glib::Value {
2703 #[inline]
2704 fn from(v: StreamType) -> Self {
2705 skip_assert_initialized!();
2706 ToValue::to_value(&v)
2707 }
2708}
2709