1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6use crate::ffi;
7use glib::{bitflags::bitflags, prelude::*, translate::*, GStr};
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.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.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.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.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.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.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.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.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.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.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.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 #[cfg(feature = "v1_24")]
1172 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1173 #[doc(alias = "GST_OBJECT_FLAG_CONSTRUCTED")]
1174 const CONSTRUCTED = ffi::GST_OBJECT_FLAG_CONSTRUCTED as _;
1175 }
1176}
1177
1178#[doc(hidden)]
1179impl IntoGlib for ObjectFlags {
1180 type GlibType = ffi::GstObjectFlags;
1181
1182 #[inline]
1183 fn into_glib(self) -> ffi::GstObjectFlags {
1184 self.bits()
1185 }
1186}
1187
1188#[doc(hidden)]
1189impl FromGlib<ffi::GstObjectFlags> for ObjectFlags {
1190 #[inline]
1191 unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self {
1192 skip_assert_initialized!();
1193 Self::from_bits_truncate(bits:value)
1194 }
1195}
1196
1197impl StaticType for ObjectFlags {
1198 #[inline]
1199 #[doc(alias = "gst_object_flags_get_type")]
1200 fn static_type() -> glib::Type {
1201 unsafe { from_glib(val:ffi::gst_object_flags_get_type()) }
1202 }
1203}
1204
1205impl glib::HasParamSpec for ObjectFlags {
1206 type ParamSpec = glib::ParamSpecFlags;
1207 type SetValue = Self;
1208 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1209
1210 fn param_spec_builder() -> Self::BuilderFn {
1211 Self::ParamSpec::builder
1212 }
1213}
1214
1215impl glib::value::ValueType for ObjectFlags {
1216 type Type = Self;
1217}
1218
1219unsafe impl<'a> glib::value::FromValue<'a> for ObjectFlags {
1220 type Checker = glib::value::GenericValueTypeChecker<Self>;
1221
1222 #[inline]
1223 unsafe fn from_value(value: &'a glib::Value) -> Self {
1224 skip_assert_initialized!();
1225 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1226 }
1227}
1228
1229impl ToValue for ObjectFlags {
1230 #[inline]
1231 fn to_value(&self) -> glib::Value {
1232 let mut value: Value = glib::Value::for_value_type::<Self>();
1233 unsafe {
1234 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1235 }
1236 value
1237 }
1238
1239 #[inline]
1240 fn value_type(&self) -> glib::Type {
1241 Self::static_type()
1242 }
1243}
1244
1245impl From<ObjectFlags> for glib::Value {
1246 #[inline]
1247 fn from(v: ObjectFlags) -> Self {
1248 skip_assert_initialized!();
1249 ToValue::to_value(&v)
1250 }
1251}
1252
1253bitflags! {
1254 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1255 #[doc(alias = "GstPadFlags")]
1256 pub struct PadFlags: u32 {
1257 #[doc(alias = "GST_PAD_FLAG_BLOCKED")]
1258 const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as _;
1259 #[doc(alias = "GST_PAD_FLAG_FLUSHING")]
1260 const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as _;
1261 #[doc(alias = "GST_PAD_FLAG_EOS")]
1262 const EOS = ffi::GST_PAD_FLAG_EOS as _;
1263 #[doc(alias = "GST_PAD_FLAG_BLOCKING")]
1264 const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as _;
1265 #[doc(alias = "GST_PAD_FLAG_NEED_PARENT")]
1266 const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as _;
1267 #[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")]
1268 const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as _;
1269 #[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")]
1270 const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as _;
1271 #[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")]
1272 const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as _;
1273 #[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")]
1274 const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as _;
1275 #[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")]
1276 const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as _;
1277 #[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")]
1278 const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as _;
1279 #[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")]
1280 const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as _;
1281 #[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")]
1282 const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as _;
1283 }
1284}
1285
1286#[doc(hidden)]
1287impl IntoGlib for PadFlags {
1288 type GlibType = ffi::GstPadFlags;
1289
1290 #[inline]
1291 fn into_glib(self) -> ffi::GstPadFlags {
1292 self.bits()
1293 }
1294}
1295
1296#[doc(hidden)]
1297impl FromGlib<ffi::GstPadFlags> for PadFlags {
1298 #[inline]
1299 unsafe fn from_glib(value: ffi::GstPadFlags) -> Self {
1300 skip_assert_initialized!();
1301 Self::from_bits_truncate(bits:value)
1302 }
1303}
1304
1305impl StaticType for PadFlags {
1306 #[inline]
1307 #[doc(alias = "gst_pad_flags_get_type")]
1308 fn static_type() -> glib::Type {
1309 unsafe { from_glib(val:ffi::gst_pad_flags_get_type()) }
1310 }
1311}
1312
1313impl glib::HasParamSpec for PadFlags {
1314 type ParamSpec = glib::ParamSpecFlags;
1315 type SetValue = Self;
1316 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1317
1318 fn param_spec_builder() -> Self::BuilderFn {
1319 Self::ParamSpec::builder
1320 }
1321}
1322
1323impl glib::value::ValueType for PadFlags {
1324 type Type = Self;
1325}
1326
1327unsafe impl<'a> glib::value::FromValue<'a> for PadFlags {
1328 type Checker = glib::value::GenericValueTypeChecker<Self>;
1329
1330 #[inline]
1331 unsafe fn from_value(value: &'a glib::Value) -> Self {
1332 skip_assert_initialized!();
1333 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1334 }
1335}
1336
1337impl ToValue for PadFlags {
1338 #[inline]
1339 fn to_value(&self) -> glib::Value {
1340 let mut value: Value = glib::Value::for_value_type::<Self>();
1341 unsafe {
1342 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1343 }
1344 value
1345 }
1346
1347 #[inline]
1348 fn value_type(&self) -> glib::Type {
1349 Self::static_type()
1350 }
1351}
1352
1353impl From<PadFlags> for glib::Value {
1354 #[inline]
1355 fn from(v: PadFlags) -> Self {
1356 skip_assert_initialized!();
1357 ToValue::to_value(&v)
1358 }
1359}
1360
1361bitflags! {
1362 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1363 #[doc(alias = "GstPadLinkCheck")]
1364 pub struct PadLinkCheck: u32 {
1365 #[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")]
1366 const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as _;
1367 #[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")]
1368 const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as _;
1369 #[doc(alias = "GST_PAD_LINK_CHECK_CAPS")]
1370 const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as _;
1371 #[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")]
1372 const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as _;
1373 #[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")]
1374 const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as _;
1375 }
1376}
1377
1378#[doc(hidden)]
1379impl IntoGlib for PadLinkCheck {
1380 type GlibType = ffi::GstPadLinkCheck;
1381
1382 #[inline]
1383 fn into_glib(self) -> ffi::GstPadLinkCheck {
1384 self.bits()
1385 }
1386}
1387
1388#[doc(hidden)]
1389impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck {
1390 #[inline]
1391 unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self {
1392 skip_assert_initialized!();
1393 Self::from_bits_truncate(bits:value)
1394 }
1395}
1396
1397impl StaticType for PadLinkCheck {
1398 #[inline]
1399 #[doc(alias = "gst_pad_link_check_get_type")]
1400 fn static_type() -> glib::Type {
1401 unsafe { from_glib(val:ffi::gst_pad_link_check_get_type()) }
1402 }
1403}
1404
1405impl glib::HasParamSpec for PadLinkCheck {
1406 type ParamSpec = glib::ParamSpecFlags;
1407 type SetValue = Self;
1408 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1409
1410 fn param_spec_builder() -> Self::BuilderFn {
1411 Self::ParamSpec::builder
1412 }
1413}
1414
1415impl glib::value::ValueType for PadLinkCheck {
1416 type Type = Self;
1417}
1418
1419unsafe impl<'a> glib::value::FromValue<'a> for PadLinkCheck {
1420 type Checker = glib::value::GenericValueTypeChecker<Self>;
1421
1422 #[inline]
1423 unsafe fn from_value(value: &'a glib::Value) -> Self {
1424 skip_assert_initialized!();
1425 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1426 }
1427}
1428
1429impl ToValue for PadLinkCheck {
1430 #[inline]
1431 fn to_value(&self) -> glib::Value {
1432 let mut value: Value = glib::Value::for_value_type::<Self>();
1433 unsafe {
1434 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1435 }
1436 value
1437 }
1438
1439 #[inline]
1440 fn value_type(&self) -> glib::Type {
1441 Self::static_type()
1442 }
1443}
1444
1445impl From<PadLinkCheck> for glib::Value {
1446 #[inline]
1447 fn from(v: PadLinkCheck) -> Self {
1448 skip_assert_initialized!();
1449 ToValue::to_value(&v)
1450 }
1451}
1452
1453bitflags! {
1454 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1455 #[doc(alias = "GstPadProbeType")]
1456 pub struct PadProbeType: u32 {
1457 #[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")]
1458 const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as _;
1459 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")]
1460 const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as _;
1461 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")]
1462 const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as _;
1463 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")]
1464 const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as _;
1465 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")]
1466 const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as _;
1467 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")]
1468 const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as _;
1469 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")]
1470 const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as _;
1471 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")]
1472 const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as _;
1473 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")]
1474 const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as _;
1475 #[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")]
1476 const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as _;
1477 #[doc(alias = "GST_PAD_PROBE_TYPE_PULL")]
1478 const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as _;
1479 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")]
1480 const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as _;
1481 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")]
1482 const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as _;
1483 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")]
1484 const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as _;
1485 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")]
1486 const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as _;
1487 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")]
1488 const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as _;
1489 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")]
1490 const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as _;
1491 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")]
1492 const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as _;
1493 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")]
1494 const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as _;
1495 #[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")]
1496 const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as _;
1497 #[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")]
1498 const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as _;
1499 }
1500}
1501
1502#[doc(hidden)]
1503impl IntoGlib for PadProbeType {
1504 type GlibType = ffi::GstPadProbeType;
1505
1506 #[inline]
1507 fn into_glib(self) -> ffi::GstPadProbeType {
1508 self.bits()
1509 }
1510}
1511
1512#[doc(hidden)]
1513impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
1514 #[inline]
1515 unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self {
1516 skip_assert_initialized!();
1517 Self::from_bits_truncate(bits:value)
1518 }
1519}
1520
1521impl StaticType for PadProbeType {
1522 #[inline]
1523 #[doc(alias = "gst_pad_probe_type_get_type")]
1524 fn static_type() -> glib::Type {
1525 unsafe { from_glib(val:ffi::gst_pad_probe_type_get_type()) }
1526 }
1527}
1528
1529impl glib::HasParamSpec for PadProbeType {
1530 type ParamSpec = glib::ParamSpecFlags;
1531 type SetValue = Self;
1532 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1533
1534 fn param_spec_builder() -> Self::BuilderFn {
1535 Self::ParamSpec::builder
1536 }
1537}
1538
1539impl glib::value::ValueType for PadProbeType {
1540 type Type = Self;
1541}
1542
1543unsafe impl<'a> glib::value::FromValue<'a> for PadProbeType {
1544 type Checker = glib::value::GenericValueTypeChecker<Self>;
1545
1546 #[inline]
1547 unsafe fn from_value(value: &'a glib::Value) -> Self {
1548 skip_assert_initialized!();
1549 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1550 }
1551}
1552
1553impl ToValue for PadProbeType {
1554 #[inline]
1555 fn to_value(&self) -> glib::Value {
1556 let mut value: Value = glib::Value::for_value_type::<Self>();
1557 unsafe {
1558 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1559 }
1560 value
1561 }
1562
1563 #[inline]
1564 fn value_type(&self) -> glib::Type {
1565 Self::static_type()
1566 }
1567}
1568
1569impl From<PadProbeType> for glib::Value {
1570 #[inline]
1571 fn from(v: PadProbeType) -> Self {
1572 skip_assert_initialized!();
1573 ToValue::to_value(&v)
1574 }
1575}
1576
1577bitflags! {
1578 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1579 #[doc(alias = "GstParseFlags")]
1580 pub struct ParseFlags: u32 {
1581 #[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")]
1582 const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as _;
1583 #[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")]
1584 const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as _;
1585 #[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")]
1586 const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as _;
1587 }
1588}
1589
1590#[doc(hidden)]
1591impl IntoGlib for ParseFlags {
1592 type GlibType = ffi::GstParseFlags;
1593
1594 #[inline]
1595 fn into_glib(self) -> ffi::GstParseFlags {
1596 self.bits()
1597 }
1598}
1599
1600#[doc(hidden)]
1601impl FromGlib<ffi::GstParseFlags> for ParseFlags {
1602 #[inline]
1603 unsafe fn from_glib(value: ffi::GstParseFlags) -> Self {
1604 skip_assert_initialized!();
1605 Self::from_bits_truncate(bits:value)
1606 }
1607}
1608
1609impl StaticType for ParseFlags {
1610 #[inline]
1611 #[doc(alias = "gst_parse_flags_get_type")]
1612 fn static_type() -> glib::Type {
1613 unsafe { from_glib(val:ffi::gst_parse_flags_get_type()) }
1614 }
1615}
1616
1617impl glib::HasParamSpec for ParseFlags {
1618 type ParamSpec = glib::ParamSpecFlags;
1619 type SetValue = Self;
1620 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1621
1622 fn param_spec_builder() -> Self::BuilderFn {
1623 Self::ParamSpec::builder
1624 }
1625}
1626
1627impl glib::value::ValueType for ParseFlags {
1628 type Type = Self;
1629}
1630
1631unsafe impl<'a> glib::value::FromValue<'a> for ParseFlags {
1632 type Checker = glib::value::GenericValueTypeChecker<Self>;
1633
1634 #[inline]
1635 unsafe fn from_value(value: &'a glib::Value) -> Self {
1636 skip_assert_initialized!();
1637 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1638 }
1639}
1640
1641impl ToValue for ParseFlags {
1642 #[inline]
1643 fn to_value(&self) -> glib::Value {
1644 let mut value: Value = glib::Value::for_value_type::<Self>();
1645 unsafe {
1646 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1647 }
1648 value
1649 }
1650
1651 #[inline]
1652 fn value_type(&self) -> glib::Type {
1653 Self::static_type()
1654 }
1655}
1656
1657impl From<ParseFlags> for glib::Value {
1658 #[inline]
1659 fn from(v: ParseFlags) -> Self {
1660 skip_assert_initialized!();
1661 ToValue::to_value(&v)
1662 }
1663}
1664
1665bitflags! {
1666 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1667 #[doc(alias = "GstPipelineFlags")]
1668 pub struct PipelineFlags: u32 {
1669 #[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")]
1670 const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as _;
1671 }
1672}
1673
1674#[doc(hidden)]
1675impl IntoGlib for PipelineFlags {
1676 type GlibType = ffi::GstPipelineFlags;
1677
1678 #[inline]
1679 fn into_glib(self) -> ffi::GstPipelineFlags {
1680 self.bits()
1681 }
1682}
1683
1684#[doc(hidden)]
1685impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags {
1686 #[inline]
1687 unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self {
1688 skip_assert_initialized!();
1689 Self::from_bits_truncate(bits:value)
1690 }
1691}
1692
1693impl StaticType for PipelineFlags {
1694 #[inline]
1695 #[doc(alias = "gst_pipeline_flags_get_type")]
1696 fn static_type() -> glib::Type {
1697 unsafe { from_glib(val:ffi::gst_pipeline_flags_get_type()) }
1698 }
1699}
1700
1701impl glib::HasParamSpec for PipelineFlags {
1702 type ParamSpec = glib::ParamSpecFlags;
1703 type SetValue = Self;
1704 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1705
1706 fn param_spec_builder() -> Self::BuilderFn {
1707 Self::ParamSpec::builder
1708 }
1709}
1710
1711impl glib::value::ValueType for PipelineFlags {
1712 type Type = Self;
1713}
1714
1715unsafe impl<'a> glib::value::FromValue<'a> for PipelineFlags {
1716 type Checker = glib::value::GenericValueTypeChecker<Self>;
1717
1718 #[inline]
1719 unsafe fn from_value(value: &'a glib::Value) -> Self {
1720 skip_assert_initialized!();
1721 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1722 }
1723}
1724
1725impl ToValue for PipelineFlags {
1726 #[inline]
1727 fn to_value(&self) -> glib::Value {
1728 let mut value: Value = glib::Value::for_value_type::<Self>();
1729 unsafe {
1730 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1731 }
1732 value
1733 }
1734
1735 #[inline]
1736 fn value_type(&self) -> glib::Type {
1737 Self::static_type()
1738 }
1739}
1740
1741impl From<PipelineFlags> for glib::Value {
1742 #[inline]
1743 fn from(v: PipelineFlags) -> Self {
1744 skip_assert_initialized!();
1745 ToValue::to_value(&v)
1746 }
1747}
1748
1749#[cfg(feature = "v1_18")]
1750bitflags! {
1751 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1752 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1753 #[doc(alias = "GstPluginAPIFlags")]
1754 pub struct PluginAPIFlags: u32 {
1755 #[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")]
1756 const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as _;
1757 }
1758}
1759
1760#[cfg(feature = "v1_18")]
1761#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1762#[doc(hidden)]
1763impl IntoGlib for PluginAPIFlags {
1764 type GlibType = ffi::GstPluginAPIFlags;
1765
1766 #[inline]
1767 fn into_glib(self) -> ffi::GstPluginAPIFlags {
1768 self.bits()
1769 }
1770}
1771
1772#[cfg(feature = "v1_18")]
1773#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1774#[doc(hidden)]
1775impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags {
1776 #[inline]
1777 unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self {
1778 skip_assert_initialized!();
1779 Self::from_bits_truncate(value)
1780 }
1781}
1782
1783#[cfg(feature = "v1_18")]
1784#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1785impl StaticType for PluginAPIFlags {
1786 #[inline]
1787 #[doc(alias = "gst_plugin_api_flags_get_type")]
1788 fn static_type() -> glib::Type {
1789 unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) }
1790 }
1791}
1792
1793#[cfg(feature = "v1_18")]
1794#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1795impl glib::HasParamSpec for PluginAPIFlags {
1796 type ParamSpec = glib::ParamSpecFlags;
1797 type SetValue = Self;
1798 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1799
1800 fn param_spec_builder() -> Self::BuilderFn {
1801 Self::ParamSpec::builder
1802 }
1803}
1804
1805#[cfg(feature = "v1_18")]
1806#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1807impl glib::value::ValueType for PluginAPIFlags {
1808 type Type = Self;
1809}
1810
1811#[cfg(feature = "v1_18")]
1812#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1813unsafe impl<'a> glib::value::FromValue<'a> for PluginAPIFlags {
1814 type Checker = glib::value::GenericValueTypeChecker<Self>;
1815
1816 #[inline]
1817 unsafe fn from_value(value: &'a glib::Value) -> Self {
1818 skip_assert_initialized!();
1819 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1820 }
1821}
1822
1823#[cfg(feature = "v1_18")]
1824#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1825impl ToValue for PluginAPIFlags {
1826 #[inline]
1827 fn to_value(&self) -> glib::Value {
1828 let mut value = glib::Value::for_value_type::<Self>();
1829 unsafe {
1830 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1831 }
1832 value
1833 }
1834
1835 #[inline]
1836 fn value_type(&self) -> glib::Type {
1837 Self::static_type()
1838 }
1839}
1840
1841#[cfg(feature = "v1_18")]
1842#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1843impl From<PluginAPIFlags> for glib::Value {
1844 #[inline]
1845 fn from(v: PluginAPIFlags) -> Self {
1846 skip_assert_initialized!();
1847 ToValue::to_value(&v)
1848 }
1849}
1850
1851bitflags! {
1852 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1853 #[doc(alias = "GstPluginDependencyFlags")]
1854 pub struct PluginDependencyFlags: u32 {
1855 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")]
1856 const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as _;
1857 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")]
1858 const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as _;
1859 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")]
1860 const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as _;
1861 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")]
1862 const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as _;
1863 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")]
1864 const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as _;
1865 }
1866}
1867
1868#[doc(hidden)]
1869impl IntoGlib for PluginDependencyFlags {
1870 type GlibType = ffi::GstPluginDependencyFlags;
1871
1872 #[inline]
1873 fn into_glib(self) -> ffi::GstPluginDependencyFlags {
1874 self.bits()
1875 }
1876}
1877
1878#[doc(hidden)]
1879impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags {
1880 #[inline]
1881 unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self {
1882 skip_assert_initialized!();
1883 Self::from_bits_truncate(bits:value)
1884 }
1885}
1886
1887impl StaticType for PluginDependencyFlags {
1888 #[inline]
1889 #[doc(alias = "gst_plugin_dependency_flags_get_type")]
1890 fn static_type() -> glib::Type {
1891 unsafe { from_glib(val:ffi::gst_plugin_dependency_flags_get_type()) }
1892 }
1893}
1894
1895impl glib::HasParamSpec for PluginDependencyFlags {
1896 type ParamSpec = glib::ParamSpecFlags;
1897 type SetValue = Self;
1898 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1899
1900 fn param_spec_builder() -> Self::BuilderFn {
1901 Self::ParamSpec::builder
1902 }
1903}
1904
1905impl glib::value::ValueType for PluginDependencyFlags {
1906 type Type = Self;
1907}
1908
1909unsafe impl<'a> glib::value::FromValue<'a> for PluginDependencyFlags {
1910 type Checker = glib::value::GenericValueTypeChecker<Self>;
1911
1912 #[inline]
1913 unsafe fn from_value(value: &'a glib::Value) -> Self {
1914 skip_assert_initialized!();
1915 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1916 }
1917}
1918
1919impl ToValue for PluginDependencyFlags {
1920 #[inline]
1921 fn to_value(&self) -> glib::Value {
1922 let mut value: Value = glib::Value::for_value_type::<Self>();
1923 unsafe {
1924 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1925 }
1926 value
1927 }
1928
1929 #[inline]
1930 fn value_type(&self) -> glib::Type {
1931 Self::static_type()
1932 }
1933}
1934
1935impl From<PluginDependencyFlags> for glib::Value {
1936 #[inline]
1937 fn from(v: PluginDependencyFlags) -> Self {
1938 skip_assert_initialized!();
1939 ToValue::to_value(&v)
1940 }
1941}
1942
1943bitflags! {
1944 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1945 #[doc(alias = "GstPluginFlags")]
1946 pub struct PluginFlags: u32 {
1947 #[doc(alias = "GST_PLUGIN_FLAG_CACHED")]
1948 const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as _;
1949 #[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")]
1950 const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as _;
1951 }
1952}
1953
1954#[doc(hidden)]
1955impl IntoGlib for PluginFlags {
1956 type GlibType = ffi::GstPluginFlags;
1957
1958 #[inline]
1959 fn into_glib(self) -> ffi::GstPluginFlags {
1960 self.bits()
1961 }
1962}
1963
1964#[doc(hidden)]
1965impl FromGlib<ffi::GstPluginFlags> for PluginFlags {
1966 #[inline]
1967 unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self {
1968 skip_assert_initialized!();
1969 Self::from_bits_truncate(bits:value)
1970 }
1971}
1972
1973impl StaticType for PluginFlags {
1974 #[inline]
1975 #[doc(alias = "gst_plugin_flags_get_type")]
1976 fn static_type() -> glib::Type {
1977 unsafe { from_glib(val:ffi::gst_plugin_flags_get_type()) }
1978 }
1979}
1980
1981impl glib::HasParamSpec for PluginFlags {
1982 type ParamSpec = glib::ParamSpecFlags;
1983 type SetValue = Self;
1984 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1985
1986 fn param_spec_builder() -> Self::BuilderFn {
1987 Self::ParamSpec::builder
1988 }
1989}
1990
1991impl glib::value::ValueType for PluginFlags {
1992 type Type = Self;
1993}
1994
1995unsafe impl<'a> glib::value::FromValue<'a> for PluginFlags {
1996 type Checker = glib::value::GenericValueTypeChecker<Self>;
1997
1998 #[inline]
1999 unsafe fn from_value(value: &'a glib::Value) -> Self {
2000 skip_assert_initialized!();
2001 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2002 }
2003}
2004
2005impl ToValue for PluginFlags {
2006 #[inline]
2007 fn to_value(&self) -> glib::Value {
2008 let mut value: Value = glib::Value::for_value_type::<Self>();
2009 unsafe {
2010 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2011 }
2012 value
2013 }
2014
2015 #[inline]
2016 fn value_type(&self) -> glib::Type {
2017 Self::static_type()
2018 }
2019}
2020
2021impl From<PluginFlags> for glib::Value {
2022 #[inline]
2023 fn from(v: PluginFlags) -> Self {
2024 skip_assert_initialized!();
2025 ToValue::to_value(&v)
2026 }
2027}
2028
2029bitflags! {
2030 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2031 #[doc(alias = "GstSchedulingFlags")]
2032 pub struct SchedulingFlags: u32 {
2033 #[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")]
2034 const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as _;
2035 #[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")]
2036 const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as _;
2037 #[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")]
2038 const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as _;
2039 }
2040}
2041
2042#[doc(hidden)]
2043impl IntoGlib for SchedulingFlags {
2044 type GlibType = ffi::GstSchedulingFlags;
2045
2046 #[inline]
2047 fn into_glib(self) -> ffi::GstSchedulingFlags {
2048 self.bits()
2049 }
2050}
2051
2052#[doc(hidden)]
2053impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags {
2054 #[inline]
2055 unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self {
2056 skip_assert_initialized!();
2057 Self::from_bits_truncate(bits:value)
2058 }
2059}
2060
2061impl StaticType for SchedulingFlags {
2062 #[inline]
2063 #[doc(alias = "gst_scheduling_flags_get_type")]
2064 fn static_type() -> glib::Type {
2065 unsafe { from_glib(val:ffi::gst_scheduling_flags_get_type()) }
2066 }
2067}
2068
2069impl glib::HasParamSpec for SchedulingFlags {
2070 type ParamSpec = glib::ParamSpecFlags;
2071 type SetValue = Self;
2072 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2073
2074 fn param_spec_builder() -> Self::BuilderFn {
2075 Self::ParamSpec::builder
2076 }
2077}
2078
2079impl glib::value::ValueType for SchedulingFlags {
2080 type Type = Self;
2081}
2082
2083unsafe impl<'a> glib::value::FromValue<'a> for SchedulingFlags {
2084 type Checker = glib::value::GenericValueTypeChecker<Self>;
2085
2086 #[inline]
2087 unsafe fn from_value(value: &'a glib::Value) -> Self {
2088 skip_assert_initialized!();
2089 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2090 }
2091}
2092
2093impl ToValue for SchedulingFlags {
2094 #[inline]
2095 fn to_value(&self) -> glib::Value {
2096 let mut value: Value = glib::Value::for_value_type::<Self>();
2097 unsafe {
2098 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2099 }
2100 value
2101 }
2102
2103 #[inline]
2104 fn value_type(&self) -> glib::Type {
2105 Self::static_type()
2106 }
2107}
2108
2109impl From<SchedulingFlags> for glib::Value {
2110 #[inline]
2111 fn from(v: SchedulingFlags) -> Self {
2112 skip_assert_initialized!();
2113 ToValue::to_value(&v)
2114 }
2115}
2116
2117bitflags! {
2118 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2119 #[doc(alias = "GstSeekFlags")]
2120 pub struct SeekFlags: u32 {
2121 #[doc(alias = "GST_SEEK_FLAG_FLUSH")]
2122 const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as _;
2123 #[doc(alias = "GST_SEEK_FLAG_ACCURATE")]
2124 const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as _;
2125 #[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")]
2126 const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as _;
2127 #[doc(alias = "GST_SEEK_FLAG_SEGMENT")]
2128 const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as _;
2129 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE")]
2130 const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as _;
2131 #[doc(alias = "GST_SEEK_FLAG_SKIP")]
2132 const SKIP = ffi::GST_SEEK_FLAG_SKIP as _;
2133 #[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")]
2134 const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as _;
2135 #[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")]
2136 const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as _;
2137 #[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")]
2138 const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as _;
2139 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")]
2140 const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as _;
2141 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")]
2142 const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as _;
2143 #[cfg(feature = "v1_18")]
2144 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2145 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2146 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2147 #[cfg(feature = "v1_18")]
2148 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2149 #[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")]
2150 const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as _;
2151 }
2152}
2153
2154#[doc(hidden)]
2155impl IntoGlib for SeekFlags {
2156 type GlibType = ffi::GstSeekFlags;
2157
2158 #[inline]
2159 fn into_glib(self) -> ffi::GstSeekFlags {
2160 self.bits()
2161 }
2162}
2163
2164#[doc(hidden)]
2165impl FromGlib<ffi::GstSeekFlags> for SeekFlags {
2166 #[inline]
2167 unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self {
2168 skip_assert_initialized!();
2169 Self::from_bits_truncate(bits:value)
2170 }
2171}
2172
2173impl StaticType for SeekFlags {
2174 #[inline]
2175 #[doc(alias = "gst_seek_flags_get_type")]
2176 fn static_type() -> glib::Type {
2177 unsafe { from_glib(val:ffi::gst_seek_flags_get_type()) }
2178 }
2179}
2180
2181impl glib::HasParamSpec for SeekFlags {
2182 type ParamSpec = glib::ParamSpecFlags;
2183 type SetValue = Self;
2184 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2185
2186 fn param_spec_builder() -> Self::BuilderFn {
2187 Self::ParamSpec::builder
2188 }
2189}
2190
2191impl glib::value::ValueType for SeekFlags {
2192 type Type = Self;
2193}
2194
2195unsafe impl<'a> glib::value::FromValue<'a> for SeekFlags {
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_flags(value.to_glib_none().0))
2202 }
2203}
2204
2205impl ToValue for SeekFlags {
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_flags(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<SeekFlags> for glib::Value {
2222 #[inline]
2223 fn from(v: SeekFlags) -> Self {
2224 skip_assert_initialized!();
2225 ToValue::to_value(&v)
2226 }
2227}
2228
2229bitflags! {
2230 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2231 #[doc(alias = "GstSegmentFlags")]
2232 pub struct SegmentFlags: u32 {
2233 #[doc(alias = "GST_SEGMENT_FLAG_RESET")]
2234 const RESET = ffi::GST_SEGMENT_FLAG_RESET as _;
2235 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")]
2236 const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as _;
2237 #[doc(alias = "GST_SEGMENT_FLAG_SKIP")]
2238 const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as _;
2239 #[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")]
2240 const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as _;
2241 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")]
2242 const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as _;
2243 #[cfg(feature = "v1_18")]
2244 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2245 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2246 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2247 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")]
2248 const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as _;
2249 }
2250}
2251
2252#[doc(hidden)]
2253impl IntoGlib for SegmentFlags {
2254 type GlibType = ffi::GstSegmentFlags;
2255
2256 #[inline]
2257 fn into_glib(self) -> ffi::GstSegmentFlags {
2258 self.bits()
2259 }
2260}
2261
2262#[doc(hidden)]
2263impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags {
2264 #[inline]
2265 unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self {
2266 skip_assert_initialized!();
2267 Self::from_bits_truncate(bits:value)
2268 }
2269}
2270
2271impl StaticType for SegmentFlags {
2272 #[inline]
2273 #[doc(alias = "gst_segment_flags_get_type")]
2274 fn static_type() -> glib::Type {
2275 unsafe { from_glib(val:ffi::gst_segment_flags_get_type()) }
2276 }
2277}
2278
2279impl glib::HasParamSpec for SegmentFlags {
2280 type ParamSpec = glib::ParamSpecFlags;
2281 type SetValue = Self;
2282 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2283
2284 fn param_spec_builder() -> Self::BuilderFn {
2285 Self::ParamSpec::builder
2286 }
2287}
2288
2289impl glib::value::ValueType for SegmentFlags {
2290 type Type = Self;
2291}
2292
2293unsafe impl<'a> glib::value::FromValue<'a> for SegmentFlags {
2294 type Checker = glib::value::GenericValueTypeChecker<Self>;
2295
2296 #[inline]
2297 unsafe fn from_value(value: &'a glib::Value) -> Self {
2298 skip_assert_initialized!();
2299 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2300 }
2301}
2302
2303impl ToValue for SegmentFlags {
2304 #[inline]
2305 fn to_value(&self) -> glib::Value {
2306 let mut value: Value = glib::Value::for_value_type::<Self>();
2307 unsafe {
2308 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2309 }
2310 value
2311 }
2312
2313 #[inline]
2314 fn value_type(&self) -> glib::Type {
2315 Self::static_type()
2316 }
2317}
2318
2319impl From<SegmentFlags> for glib::Value {
2320 #[inline]
2321 fn from(v: SegmentFlags) -> Self {
2322 skip_assert_initialized!();
2323 ToValue::to_value(&v)
2324 }
2325}
2326
2327#[cfg(feature = "v1_20")]
2328bitflags! {
2329 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2330 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2331 #[doc(alias = "GstSerializeFlags")]
2332 pub struct SerializeFlags: u32 {
2333 #[doc(alias = "GST_SERIALIZE_FLAG_NONE")]
2334 const NONE = ffi::GST_SERIALIZE_FLAG_NONE as _;
2335 #[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")]
2336 const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as _;
2337 }
2338}
2339
2340#[cfg(feature = "v1_20")]
2341#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2342#[doc(hidden)]
2343impl IntoGlib for SerializeFlags {
2344 type GlibType = ffi::GstSerializeFlags;
2345
2346 #[inline]
2347 fn into_glib(self) -> ffi::GstSerializeFlags {
2348 self.bits()
2349 }
2350}
2351
2352#[cfg(feature = "v1_20")]
2353#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2354#[doc(hidden)]
2355impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags {
2356 #[inline]
2357 unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self {
2358 skip_assert_initialized!();
2359 Self::from_bits_truncate(value)
2360 }
2361}
2362
2363#[cfg(feature = "v1_20")]
2364#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2365impl StaticType for SerializeFlags {
2366 #[inline]
2367 #[doc(alias = "gst_serialize_flags_get_type")]
2368 fn static_type() -> glib::Type {
2369 unsafe { from_glib(ffi::gst_serialize_flags_get_type()) }
2370 }
2371}
2372
2373#[cfg(feature = "v1_20")]
2374#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2375impl glib::HasParamSpec for SerializeFlags {
2376 type ParamSpec = glib::ParamSpecFlags;
2377 type SetValue = Self;
2378 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2379
2380 fn param_spec_builder() -> Self::BuilderFn {
2381 Self::ParamSpec::builder
2382 }
2383}
2384
2385#[cfg(feature = "v1_20")]
2386#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2387impl glib::value::ValueType for SerializeFlags {
2388 type Type = Self;
2389}
2390
2391#[cfg(feature = "v1_20")]
2392#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2393unsafe impl<'a> glib::value::FromValue<'a> for SerializeFlags {
2394 type Checker = glib::value::GenericValueTypeChecker<Self>;
2395
2396 #[inline]
2397 unsafe fn from_value(value: &'a glib::Value) -> Self {
2398 skip_assert_initialized!();
2399 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2400 }
2401}
2402
2403#[cfg(feature = "v1_20")]
2404#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2405impl ToValue for SerializeFlags {
2406 #[inline]
2407 fn to_value(&self) -> glib::Value {
2408 let mut value = glib::Value::for_value_type::<Self>();
2409 unsafe {
2410 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2411 }
2412 value
2413 }
2414
2415 #[inline]
2416 fn value_type(&self) -> glib::Type {
2417 Self::static_type()
2418 }
2419}
2420
2421#[cfg(feature = "v1_20")]
2422#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2423impl From<SerializeFlags> for glib::Value {
2424 #[inline]
2425 fn from(v: SerializeFlags) -> Self {
2426 skip_assert_initialized!();
2427 ToValue::to_value(&v)
2428 }
2429}
2430
2431bitflags! {
2432 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2433 #[doc(alias = "GstStackTraceFlags")]
2434 pub struct StackTraceFlags: u32 {
2435 #[doc(alias = "GST_STACK_TRACE_SHOW_FULL")]
2436 const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as _;
2437 }
2438}
2439
2440#[doc(hidden)]
2441impl IntoGlib for StackTraceFlags {
2442 type GlibType = ffi::GstStackTraceFlags;
2443
2444 #[inline]
2445 fn into_glib(self) -> ffi::GstStackTraceFlags {
2446 self.bits()
2447 }
2448}
2449
2450#[doc(hidden)]
2451impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags {
2452 #[inline]
2453 unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self {
2454 skip_assert_initialized!();
2455 Self::from_bits_truncate(bits:value)
2456 }
2457}
2458
2459impl StaticType for StackTraceFlags {
2460 #[inline]
2461 #[doc(alias = "gst_stack_trace_flags_get_type")]
2462 fn static_type() -> glib::Type {
2463 unsafe { from_glib(val:ffi::gst_stack_trace_flags_get_type()) }
2464 }
2465}
2466
2467impl glib::HasParamSpec for StackTraceFlags {
2468 type ParamSpec = glib::ParamSpecFlags;
2469 type SetValue = Self;
2470 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2471
2472 fn param_spec_builder() -> Self::BuilderFn {
2473 Self::ParamSpec::builder
2474 }
2475}
2476
2477impl glib::value::ValueType for StackTraceFlags {
2478 type Type = Self;
2479}
2480
2481unsafe impl<'a> glib::value::FromValue<'a> for StackTraceFlags {
2482 type Checker = glib::value::GenericValueTypeChecker<Self>;
2483
2484 #[inline]
2485 unsafe fn from_value(value: &'a glib::Value) -> Self {
2486 skip_assert_initialized!();
2487 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2488 }
2489}
2490
2491impl ToValue for StackTraceFlags {
2492 #[inline]
2493 fn to_value(&self) -> glib::Value {
2494 let mut value: Value = glib::Value::for_value_type::<Self>();
2495 unsafe {
2496 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2497 }
2498 value
2499 }
2500
2501 #[inline]
2502 fn value_type(&self) -> glib::Type {
2503 Self::static_type()
2504 }
2505}
2506
2507impl From<StackTraceFlags> for glib::Value {
2508 #[inline]
2509 fn from(v: StackTraceFlags) -> Self {
2510 skip_assert_initialized!();
2511 ToValue::to_value(&v)
2512 }
2513}
2514
2515bitflags! {
2516 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2517 #[doc(alias = "GstStreamFlags")]
2518 pub struct StreamFlags: u32 {
2519 #[doc(alias = "GST_STREAM_FLAG_SPARSE")]
2520 const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as _;
2521 #[doc(alias = "GST_STREAM_FLAG_SELECT")]
2522 const SELECT = ffi::GST_STREAM_FLAG_SELECT as _;
2523 #[doc(alias = "GST_STREAM_FLAG_UNSELECT")]
2524 const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as _;
2525 }
2526}
2527
2528#[doc(hidden)]
2529impl IntoGlib for StreamFlags {
2530 type GlibType = ffi::GstStreamFlags;
2531
2532 #[inline]
2533 fn into_glib(self) -> ffi::GstStreamFlags {
2534 self.bits()
2535 }
2536}
2537
2538#[doc(hidden)]
2539impl FromGlib<ffi::GstStreamFlags> for StreamFlags {
2540 #[inline]
2541 unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self {
2542 skip_assert_initialized!();
2543 Self::from_bits_truncate(bits:value)
2544 }
2545}
2546
2547impl StaticType for StreamFlags {
2548 #[inline]
2549 #[doc(alias = "gst_stream_flags_get_type")]
2550 fn static_type() -> glib::Type {
2551 unsafe { from_glib(val:ffi::gst_stream_flags_get_type()) }
2552 }
2553}
2554
2555impl glib::HasParamSpec for StreamFlags {
2556 type ParamSpec = glib::ParamSpecFlags;
2557 type SetValue = Self;
2558 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2559
2560 fn param_spec_builder() -> Self::BuilderFn {
2561 Self::ParamSpec::builder
2562 }
2563}
2564
2565impl glib::value::ValueType for StreamFlags {
2566 type Type = Self;
2567}
2568
2569unsafe impl<'a> glib::value::FromValue<'a> for StreamFlags {
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_flags(value.to_glib_none().0))
2576 }
2577}
2578
2579impl ToValue for StreamFlags {
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_flags(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<StreamFlags> for glib::Value {
2596 #[inline]
2597 fn from(v: StreamFlags) -> Self {
2598 skip_assert_initialized!();
2599 ToValue::to_value(&v)
2600 }
2601}
2602
2603bitflags! {
2604 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2605 #[doc(alias = "GstStreamType")]
2606 pub struct StreamType: u32 {
2607 #[doc(alias = "GST_STREAM_TYPE_UNKNOWN")]
2608 const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as _;
2609 #[doc(alias = "GST_STREAM_TYPE_AUDIO")]
2610 const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as _;
2611 #[doc(alias = "GST_STREAM_TYPE_VIDEO")]
2612 const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as _;
2613 #[doc(alias = "GST_STREAM_TYPE_CONTAINER")]
2614 const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as _;
2615 #[doc(alias = "GST_STREAM_TYPE_TEXT")]
2616 const TEXT = ffi::GST_STREAM_TYPE_TEXT as _;
2617 }
2618}
2619
2620impl StreamType {
2621 pub fn name<'a>(self) -> &'a GStr {
2622 unsafe {
2623 GStr::from_ptr(
2624 ffi::gst_stream_type_get_name(self.into_glib())
2625 .as_ref()
2626 .expect(msg:"gst_stream_type_get_name returned NULL"),
2627 )
2628 }
2629 }
2630}
2631
2632impl std::fmt::Display for StreamType {
2633 #[inline]
2634 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2635 f.write_str(&self.name())
2636 }
2637}
2638
2639#[doc(hidden)]
2640impl IntoGlib for StreamType {
2641 type GlibType = ffi::GstStreamType;
2642
2643 #[inline]
2644 fn into_glib(self) -> ffi::GstStreamType {
2645 self.bits()
2646 }
2647}
2648
2649#[doc(hidden)]
2650impl FromGlib<ffi::GstStreamType> for StreamType {
2651 #[inline]
2652 unsafe fn from_glib(value: ffi::GstStreamType) -> Self {
2653 skip_assert_initialized!();
2654 Self::from_bits_truncate(bits:value)
2655 }
2656}
2657
2658impl StaticType for StreamType {
2659 #[inline]
2660 #[doc(alias = "gst_stream_type_get_type")]
2661 fn static_type() -> glib::Type {
2662 unsafe { from_glib(val:ffi::gst_stream_type_get_type()) }
2663 }
2664}
2665
2666impl glib::HasParamSpec for StreamType {
2667 type ParamSpec = glib::ParamSpecFlags;
2668 type SetValue = Self;
2669 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2670
2671 fn param_spec_builder() -> Self::BuilderFn {
2672 Self::ParamSpec::builder
2673 }
2674}
2675
2676impl glib::value::ValueType for StreamType {
2677 type Type = Self;
2678}
2679
2680unsafe impl<'a> glib::value::FromValue<'a> for StreamType {
2681 type Checker = glib::value::GenericValueTypeChecker<Self>;
2682
2683 #[inline]
2684 unsafe fn from_value(value: &'a glib::Value) -> Self {
2685 skip_assert_initialized!();
2686 from_glib(val:glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2687 }
2688}
2689
2690impl ToValue for StreamType {
2691 #[inline]
2692 fn to_value(&self) -> glib::Value {
2693 let mut value: Value = glib::Value::for_value_type::<Self>();
2694 unsafe {
2695 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2696 }
2697 value
2698 }
2699
2700 #[inline]
2701 fn value_type(&self) -> glib::Type {
2702 Self::static_type()
2703 }
2704}
2705
2706impl From<StreamType> for glib::Value {
2707 #[inline]
2708 fn from(v: StreamType) -> Self {
2709 skip_assert_initialized!();
2710 ToValue::to_value(&v)
2711 }
2712}
2713