1use crate::ffi;
7use glib::{GStr, bitflags::bitflags, prelude::*, translate::*};
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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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(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(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 unsafe { from_glib(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 = 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 unsafe { 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
983#[cfg(feature = "v1_28")]
984bitflags! {
985 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
986 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
987 #[doc(alias = "GstLogContextFlags")]
988 pub struct LogContextFlags: u32 {
989 #[doc(alias = "GST_LOG_CONTEXT_FLAG_THROTTLE")]
990 const THROTTLE = ffi::GST_LOG_CONTEXT_FLAG_THROTTLE as _;
991 }
992}
993
994#[cfg(feature = "v1_28")]
995#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
996#[doc(hidden)]
997impl IntoGlib for LogContextFlags {
998 type GlibType = ffi::GstLogContextFlags;
999
1000 #[inline]
1001 fn into_glib(self) -> ffi::GstLogContextFlags {
1002 self.bits()
1003 }
1004}
1005
1006#[cfg(feature = "v1_28")]
1007#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1008#[doc(hidden)]
1009impl FromGlib<ffi::GstLogContextFlags> for LogContextFlags {
1010 #[inline]
1011 unsafe fn from_glib(value: ffi::GstLogContextFlags) -> Self {
1012 skip_assert_initialized!();
1013 Self::from_bits_truncate(value)
1014 }
1015}
1016
1017#[cfg(feature = "v1_28")]
1018#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1019impl StaticType for LogContextFlags {
1020 #[inline]
1021 #[doc(alias = "gst_log_context_flags_get_type")]
1022 fn static_type() -> glib::Type {
1023 unsafe { from_glib(ffi::gst_log_context_flags_get_type()) }
1024 }
1025}
1026
1027#[cfg(feature = "v1_28")]
1028#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1029impl glib::HasParamSpec for LogContextFlags {
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
1039#[cfg(feature = "v1_28")]
1040#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1041impl glib::value::ValueType for LogContextFlags {
1042 type Type = Self;
1043}
1044
1045#[cfg(feature = "v1_28")]
1046#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1047unsafe impl<'a> glib::value::FromValue<'a> for LogContextFlags {
1048 type Checker = glib::value::GenericValueTypeChecker<Self>;
1049
1050 #[inline]
1051 unsafe fn from_value(value: &'a glib::Value) -> Self {
1052 skip_assert_initialized!();
1053 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1054 }
1055}
1056
1057#[cfg(feature = "v1_28")]
1058#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1059impl ToValue for LogContextFlags {
1060 #[inline]
1061 fn to_value(&self) -> glib::Value {
1062 let mut value = glib::Value::for_value_type::<Self>();
1063 unsafe {
1064 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1065 }
1066 value
1067 }
1068
1069 #[inline]
1070 fn value_type(&self) -> glib::Type {
1071 Self::static_type()
1072 }
1073}
1074
1075#[cfg(feature = "v1_28")]
1076#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1077impl From<LogContextFlags> for glib::Value {
1078 #[inline]
1079 fn from(v: LogContextFlags) -> Self {
1080 skip_assert_initialized!();
1081 ToValue::to_value(&v)
1082 }
1083}
1084
1085#[cfg(feature = "v1_28")]
1086bitflags! {
1087 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1088 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1089 #[doc(alias = "GstLogContextHashFlags")]
1090 pub struct LogContextHashFlags: u32 {
1091 #[doc(alias = "GST_LOG_CONTEXT_IGNORE_OBJECT")]
1092 const IGNORE_OBJECT = ffi::GST_LOG_CONTEXT_IGNORE_OBJECT as _;
1093 #[doc(alias = "GST_LOG_CONTEXT_IGNORE_FORMAT")]
1094 const IGNORE_FORMAT = ffi::GST_LOG_CONTEXT_IGNORE_FORMAT as _;
1095 #[doc(alias = "GST_LOG_CONTEXT_IGNORE_FILE")]
1096 const IGNORE_FILE = ffi::GST_LOG_CONTEXT_IGNORE_FILE as _;
1097 #[doc(alias = "GST_LOG_CONTEXT_USE_LINE_NUMBER")]
1098 const USE_LINE_NUMBER = ffi::GST_LOG_CONTEXT_USE_LINE_NUMBER as _;
1099 #[doc(alias = "GST_LOG_CONTEXT_USE_STRING_ARGS")]
1100 const USE_STRING_ARGS = ffi::GST_LOG_CONTEXT_USE_STRING_ARGS as _;
1101 }
1102}
1103
1104#[cfg(feature = "v1_28")]
1105#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1106#[doc(hidden)]
1107impl IntoGlib for LogContextHashFlags {
1108 type GlibType = ffi::GstLogContextHashFlags;
1109
1110 #[inline]
1111 fn into_glib(self) -> ffi::GstLogContextHashFlags {
1112 self.bits()
1113 }
1114}
1115
1116#[cfg(feature = "v1_28")]
1117#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1118#[doc(hidden)]
1119impl FromGlib<ffi::GstLogContextHashFlags> for LogContextHashFlags {
1120 #[inline]
1121 unsafe fn from_glib(value: ffi::GstLogContextHashFlags) -> Self {
1122 skip_assert_initialized!();
1123 Self::from_bits_truncate(value)
1124 }
1125}
1126
1127#[cfg(feature = "v1_28")]
1128#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1129impl StaticType for LogContextHashFlags {
1130 #[inline]
1131 #[doc(alias = "gst_log_context_hash_flags_get_type")]
1132 fn static_type() -> glib::Type {
1133 unsafe { from_glib(ffi::gst_log_context_hash_flags_get_type()) }
1134 }
1135}
1136
1137#[cfg(feature = "v1_28")]
1138#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1139impl glib::HasParamSpec for LogContextHashFlags {
1140 type ParamSpec = glib::ParamSpecFlags;
1141 type SetValue = Self;
1142 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1143
1144 fn param_spec_builder() -> Self::BuilderFn {
1145 Self::ParamSpec::builder
1146 }
1147}
1148
1149#[cfg(feature = "v1_28")]
1150#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1151impl glib::value::ValueType for LogContextHashFlags {
1152 type Type = Self;
1153}
1154
1155#[cfg(feature = "v1_28")]
1156#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1157unsafe impl<'a> glib::value::FromValue<'a> for LogContextHashFlags {
1158 type Checker = glib::value::GenericValueTypeChecker<Self>;
1159
1160 #[inline]
1161 unsafe fn from_value(value: &'a glib::Value) -> Self {
1162 skip_assert_initialized!();
1163 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1164 }
1165}
1166
1167#[cfg(feature = "v1_28")]
1168#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1169impl ToValue for LogContextHashFlags {
1170 #[inline]
1171 fn to_value(&self) -> glib::Value {
1172 let mut value = glib::Value::for_value_type::<Self>();
1173 unsafe {
1174 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1175 }
1176 value
1177 }
1178
1179 #[inline]
1180 fn value_type(&self) -> glib::Type {
1181 Self::static_type()
1182 }
1183}
1184
1185#[cfg(feature = "v1_28")]
1186#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
1187impl From<LogContextHashFlags> for glib::Value {
1188 #[inline]
1189 fn from(v: LogContextHashFlags) -> Self {
1190 skip_assert_initialized!();
1191 ToValue::to_value(&v)
1192 }
1193}
1194
1195bitflags! {
1196 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1197 #[doc(alias = "GstMemoryFlags")]
1198 pub struct MemoryFlags: u32 {
1199 #[doc(alias = "GST_MEMORY_FLAG_READONLY")]
1200 const READONLY = ffi::GST_MEMORY_FLAG_READONLY as _;
1201 #[doc(alias = "GST_MEMORY_FLAG_NO_SHARE")]
1202 const NO_SHARE = ffi::GST_MEMORY_FLAG_NO_SHARE as _;
1203 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PREFIXED")]
1204 const ZERO_PREFIXED = ffi::GST_MEMORY_FLAG_ZERO_PREFIXED as _;
1205 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PADDED")]
1206 const ZERO_PADDED = ffi::GST_MEMORY_FLAG_ZERO_PADDED as _;
1207 #[doc(alias = "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS")]
1208 const PHYSICALLY_CONTIGUOUS = ffi::GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS as _;
1209 #[doc(alias = "GST_MEMORY_FLAG_NOT_MAPPABLE")]
1210 const NOT_MAPPABLE = ffi::GST_MEMORY_FLAG_NOT_MAPPABLE as _;
1211 }
1212}
1213
1214#[doc(hidden)]
1215impl IntoGlib for MemoryFlags {
1216 type GlibType = ffi::GstMemoryFlags;
1217
1218 #[inline]
1219 fn into_glib(self) -> ffi::GstMemoryFlags {
1220 self.bits()
1221 }
1222}
1223
1224#[doc(hidden)]
1225impl FromGlib<ffi::GstMemoryFlags> for MemoryFlags {
1226 #[inline]
1227 unsafe fn from_glib(value: ffi::GstMemoryFlags) -> Self {
1228 skip_assert_initialized!();
1229 Self::from_bits_truncate(value)
1230 }
1231}
1232
1233impl StaticType for MemoryFlags {
1234 #[inline]
1235 #[doc(alias = "gst_memory_flags_get_type")]
1236 fn static_type() -> glib::Type {
1237 unsafe { from_glib(ffi::gst_memory_flags_get_type()) }
1238 }
1239}
1240
1241impl glib::HasParamSpec for MemoryFlags {
1242 type ParamSpec = glib::ParamSpecFlags;
1243 type SetValue = Self;
1244 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1245
1246 fn param_spec_builder() -> Self::BuilderFn {
1247 Self::ParamSpec::builder
1248 }
1249}
1250
1251impl glib::value::ValueType for MemoryFlags {
1252 type Type = Self;
1253}
1254
1255unsafe impl<'a> glib::value::FromValue<'a> for MemoryFlags {
1256 type Checker = glib::value::GenericValueTypeChecker<Self>;
1257
1258 #[inline]
1259 unsafe fn from_value(value: &'a glib::Value) -> Self {
1260 skip_assert_initialized!();
1261 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1262 }
1263}
1264
1265impl ToValue for MemoryFlags {
1266 #[inline]
1267 fn to_value(&self) -> glib::Value {
1268 let mut value = glib::Value::for_value_type::<Self>();
1269 unsafe {
1270 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1271 }
1272 value
1273 }
1274
1275 #[inline]
1276 fn value_type(&self) -> glib::Type {
1277 Self::static_type()
1278 }
1279}
1280
1281impl From<MemoryFlags> for glib::Value {
1282 #[inline]
1283 fn from(v: MemoryFlags) -> Self {
1284 skip_assert_initialized!();
1285 ToValue::to_value(&v)
1286 }
1287}
1288
1289bitflags! {
1290 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1291 #[doc(alias = "GstMetaFlags")]
1292 pub struct MetaFlags: u32 {
1293 #[doc(alias = "GST_META_FLAG_READONLY")]
1294 const READONLY = ffi::GST_META_FLAG_READONLY as _;
1295 #[doc(alias = "GST_META_FLAG_POOLED")]
1296 const POOLED = ffi::GST_META_FLAG_POOLED as _;
1297 #[doc(alias = "GST_META_FLAG_LOCKED")]
1298 const LOCKED = ffi::GST_META_FLAG_LOCKED as _;
1299 }
1300}
1301
1302#[doc(hidden)]
1303impl IntoGlib for MetaFlags {
1304 type GlibType = ffi::GstMetaFlags;
1305
1306 #[inline]
1307 fn into_glib(self) -> ffi::GstMetaFlags {
1308 self.bits()
1309 }
1310}
1311
1312#[doc(hidden)]
1313impl FromGlib<ffi::GstMetaFlags> for MetaFlags {
1314 #[inline]
1315 unsafe fn from_glib(value: ffi::GstMetaFlags) -> Self {
1316 skip_assert_initialized!();
1317 Self::from_bits_truncate(value)
1318 }
1319}
1320
1321impl StaticType for MetaFlags {
1322 #[inline]
1323 #[doc(alias = "gst_meta_flags_get_type")]
1324 fn static_type() -> glib::Type {
1325 unsafe { from_glib(ffi::gst_meta_flags_get_type()) }
1326 }
1327}
1328
1329impl glib::HasParamSpec for MetaFlags {
1330 type ParamSpec = glib::ParamSpecFlags;
1331 type SetValue = Self;
1332 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1333
1334 fn param_spec_builder() -> Self::BuilderFn {
1335 Self::ParamSpec::builder
1336 }
1337}
1338
1339impl glib::value::ValueType for MetaFlags {
1340 type Type = Self;
1341}
1342
1343unsafe impl<'a> glib::value::FromValue<'a> for MetaFlags {
1344 type Checker = glib::value::GenericValueTypeChecker<Self>;
1345
1346 #[inline]
1347 unsafe fn from_value(value: &'a glib::Value) -> Self {
1348 skip_assert_initialized!();
1349 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1350 }
1351}
1352
1353impl ToValue for MetaFlags {
1354 #[inline]
1355 fn to_value(&self) -> glib::Value {
1356 let mut value = glib::Value::for_value_type::<Self>();
1357 unsafe {
1358 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1359 }
1360 value
1361 }
1362
1363 #[inline]
1364 fn value_type(&self) -> glib::Type {
1365 Self::static_type()
1366 }
1367}
1368
1369impl From<MetaFlags> for glib::Value {
1370 #[inline]
1371 fn from(v: MetaFlags) -> Self {
1372 skip_assert_initialized!();
1373 ToValue::to_value(&v)
1374 }
1375}
1376
1377bitflags! {
1378 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1379 #[doc(alias = "GstObjectFlags")]
1380 pub struct ObjectFlags: u32 {
1381 #[doc(alias = "GST_OBJECT_FLAG_MAY_BE_LEAKED")]
1382 const MAY_BE_LEAKED = ffi::GST_OBJECT_FLAG_MAY_BE_LEAKED as _;
1383 #[cfg(feature = "v1_24")]
1384 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1385 #[doc(alias = "GST_OBJECT_FLAG_CONSTRUCTED")]
1386 const CONSTRUCTED = ffi::GST_OBJECT_FLAG_CONSTRUCTED as _;
1387 }
1388}
1389
1390#[doc(hidden)]
1391impl IntoGlib for ObjectFlags {
1392 type GlibType = ffi::GstObjectFlags;
1393
1394 #[inline]
1395 fn into_glib(self) -> ffi::GstObjectFlags {
1396 self.bits()
1397 }
1398}
1399
1400#[doc(hidden)]
1401impl FromGlib<ffi::GstObjectFlags> for ObjectFlags {
1402 #[inline]
1403 unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self {
1404 skip_assert_initialized!();
1405 Self::from_bits_truncate(value)
1406 }
1407}
1408
1409impl StaticType for ObjectFlags {
1410 #[inline]
1411 #[doc(alias = "gst_object_flags_get_type")]
1412 fn static_type() -> glib::Type {
1413 unsafe { from_glib(ffi::gst_object_flags_get_type()) }
1414 }
1415}
1416
1417impl glib::HasParamSpec for ObjectFlags {
1418 type ParamSpec = glib::ParamSpecFlags;
1419 type SetValue = Self;
1420 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1421
1422 fn param_spec_builder() -> Self::BuilderFn {
1423 Self::ParamSpec::builder
1424 }
1425}
1426
1427impl glib::value::ValueType for ObjectFlags {
1428 type Type = Self;
1429}
1430
1431unsafe impl<'a> glib::value::FromValue<'a> for ObjectFlags {
1432 type Checker = glib::value::GenericValueTypeChecker<Self>;
1433
1434 #[inline]
1435 unsafe fn from_value(value: &'a glib::Value) -> Self {
1436 skip_assert_initialized!();
1437 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1438 }
1439}
1440
1441impl ToValue for ObjectFlags {
1442 #[inline]
1443 fn to_value(&self) -> glib::Value {
1444 let mut value = glib::Value::for_value_type::<Self>();
1445 unsafe {
1446 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1447 }
1448 value
1449 }
1450
1451 #[inline]
1452 fn value_type(&self) -> glib::Type {
1453 Self::static_type()
1454 }
1455}
1456
1457impl From<ObjectFlags> for glib::Value {
1458 #[inline]
1459 fn from(v: ObjectFlags) -> Self {
1460 skip_assert_initialized!();
1461 ToValue::to_value(&v)
1462 }
1463}
1464
1465bitflags! {
1466 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1467 #[doc(alias = "GstPadFlags")]
1468 pub struct PadFlags: u32 {
1469 #[doc(alias = "GST_PAD_FLAG_BLOCKED")]
1470 const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as _;
1471 #[doc(alias = "GST_PAD_FLAG_FLUSHING")]
1472 const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as _;
1473 #[doc(alias = "GST_PAD_FLAG_EOS")]
1474 const EOS = ffi::GST_PAD_FLAG_EOS as _;
1475 #[doc(alias = "GST_PAD_FLAG_BLOCKING")]
1476 const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as _;
1477 #[doc(alias = "GST_PAD_FLAG_NEED_PARENT")]
1478 const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as _;
1479 #[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")]
1480 const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as _;
1481 #[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")]
1482 const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as _;
1483 #[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")]
1484 const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as _;
1485 #[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")]
1486 const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as _;
1487 #[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")]
1488 const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as _;
1489 #[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")]
1490 const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as _;
1491 #[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")]
1492 const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as _;
1493 #[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")]
1494 const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as _;
1495 }
1496}
1497
1498#[doc(hidden)]
1499impl IntoGlib for PadFlags {
1500 type GlibType = ffi::GstPadFlags;
1501
1502 #[inline]
1503 fn into_glib(self) -> ffi::GstPadFlags {
1504 self.bits()
1505 }
1506}
1507
1508#[doc(hidden)]
1509impl FromGlib<ffi::GstPadFlags> for PadFlags {
1510 #[inline]
1511 unsafe fn from_glib(value: ffi::GstPadFlags) -> Self {
1512 skip_assert_initialized!();
1513 Self::from_bits_truncate(value)
1514 }
1515}
1516
1517impl StaticType for PadFlags {
1518 #[inline]
1519 #[doc(alias = "gst_pad_flags_get_type")]
1520 fn static_type() -> glib::Type {
1521 unsafe { from_glib(ffi::gst_pad_flags_get_type()) }
1522 }
1523}
1524
1525impl glib::HasParamSpec for PadFlags {
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 PadFlags {
1536 type Type = Self;
1537}
1538
1539unsafe impl<'a> glib::value::FromValue<'a> for PadFlags {
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 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1546 }
1547}
1548
1549impl ToValue for PadFlags {
1550 #[inline]
1551 fn to_value(&self) -> glib::Value {
1552 let mut value = glib::Value::for_value_type::<Self>();
1553 unsafe {
1554 glib::gobject_ffi::g_value_set_flags(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<PadFlags> for glib::Value {
1566 #[inline]
1567 fn from(v: PadFlags) -> 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 = "GstPadLinkCheck")]
1576 pub struct PadLinkCheck: u32 {
1577 #[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")]
1578 const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as _;
1579 #[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")]
1580 const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as _;
1581 #[doc(alias = "GST_PAD_LINK_CHECK_CAPS")]
1582 const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as _;
1583 #[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")]
1584 const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as _;
1585 #[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")]
1586 const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as _;
1587 }
1588}
1589
1590#[doc(hidden)]
1591impl IntoGlib for PadLinkCheck {
1592 type GlibType = ffi::GstPadLinkCheck;
1593
1594 #[inline]
1595 fn into_glib(self) -> ffi::GstPadLinkCheck {
1596 self.bits()
1597 }
1598}
1599
1600#[doc(hidden)]
1601impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck {
1602 #[inline]
1603 unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self {
1604 skip_assert_initialized!();
1605 Self::from_bits_truncate(value)
1606 }
1607}
1608
1609impl StaticType for PadLinkCheck {
1610 #[inline]
1611 #[doc(alias = "gst_pad_link_check_get_type")]
1612 fn static_type() -> glib::Type {
1613 unsafe { from_glib(ffi::gst_pad_link_check_get_type()) }
1614 }
1615}
1616
1617impl glib::HasParamSpec for PadLinkCheck {
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 PadLinkCheck {
1628 type Type = Self;
1629}
1630
1631unsafe impl<'a> glib::value::FromValue<'a> for PadLinkCheck {
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 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1638 }
1639}
1640
1641impl ToValue for PadLinkCheck {
1642 #[inline]
1643 fn to_value(&self) -> glib::Value {
1644 let mut 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<PadLinkCheck> for glib::Value {
1658 #[inline]
1659 fn from(v: PadLinkCheck) -> 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 = "GstPadProbeType")]
1668 pub struct PadProbeType: u32 {
1669 #[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")]
1670 const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as _;
1671 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")]
1672 const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as _;
1673 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")]
1674 const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as _;
1675 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")]
1676 const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as _;
1677 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")]
1678 const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as _;
1679 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")]
1680 const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as _;
1681 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")]
1682 const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as _;
1683 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")]
1684 const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as _;
1685 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")]
1686 const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as _;
1687 #[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")]
1688 const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as _;
1689 #[doc(alias = "GST_PAD_PROBE_TYPE_PULL")]
1690 const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as _;
1691 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")]
1692 const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as _;
1693 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")]
1694 const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as _;
1695 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")]
1696 const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as _;
1697 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")]
1698 const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as _;
1699 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")]
1700 const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as _;
1701 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")]
1702 const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as _;
1703 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")]
1704 const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as _;
1705 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")]
1706 const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as _;
1707 #[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")]
1708 const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as _;
1709 #[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")]
1710 const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as _;
1711 }
1712}
1713
1714#[doc(hidden)]
1715impl IntoGlib for PadProbeType {
1716 type GlibType = ffi::GstPadProbeType;
1717
1718 #[inline]
1719 fn into_glib(self) -> ffi::GstPadProbeType {
1720 self.bits()
1721 }
1722}
1723
1724#[doc(hidden)]
1725impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
1726 #[inline]
1727 unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self {
1728 skip_assert_initialized!();
1729 Self::from_bits_truncate(value)
1730 }
1731}
1732
1733impl StaticType for PadProbeType {
1734 #[inline]
1735 #[doc(alias = "gst_pad_probe_type_get_type")]
1736 fn static_type() -> glib::Type {
1737 unsafe { from_glib(ffi::gst_pad_probe_type_get_type()) }
1738 }
1739}
1740
1741impl glib::HasParamSpec for PadProbeType {
1742 type ParamSpec = glib::ParamSpecFlags;
1743 type SetValue = Self;
1744 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1745
1746 fn param_spec_builder() -> Self::BuilderFn {
1747 Self::ParamSpec::builder
1748 }
1749}
1750
1751impl glib::value::ValueType for PadProbeType {
1752 type Type = Self;
1753}
1754
1755unsafe impl<'a> glib::value::FromValue<'a> for PadProbeType {
1756 type Checker = glib::value::GenericValueTypeChecker<Self>;
1757
1758 #[inline]
1759 unsafe fn from_value(value: &'a glib::Value) -> Self {
1760 skip_assert_initialized!();
1761 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1762 }
1763}
1764
1765impl ToValue for PadProbeType {
1766 #[inline]
1767 fn to_value(&self) -> glib::Value {
1768 let mut value = glib::Value::for_value_type::<Self>();
1769 unsafe {
1770 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1771 }
1772 value
1773 }
1774
1775 #[inline]
1776 fn value_type(&self) -> glib::Type {
1777 Self::static_type()
1778 }
1779}
1780
1781impl From<PadProbeType> for glib::Value {
1782 #[inline]
1783 fn from(v: PadProbeType) -> Self {
1784 skip_assert_initialized!();
1785 ToValue::to_value(&v)
1786 }
1787}
1788
1789bitflags! {
1790 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1791 #[doc(alias = "GstParseFlags")]
1792 pub struct ParseFlags: u32 {
1793 #[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")]
1794 const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as _;
1795 #[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")]
1796 const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as _;
1797 #[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")]
1798 const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as _;
1799 }
1800}
1801
1802#[doc(hidden)]
1803impl IntoGlib for ParseFlags {
1804 type GlibType = ffi::GstParseFlags;
1805
1806 #[inline]
1807 fn into_glib(self) -> ffi::GstParseFlags {
1808 self.bits()
1809 }
1810}
1811
1812#[doc(hidden)]
1813impl FromGlib<ffi::GstParseFlags> for ParseFlags {
1814 #[inline]
1815 unsafe fn from_glib(value: ffi::GstParseFlags) -> Self {
1816 skip_assert_initialized!();
1817 Self::from_bits_truncate(value)
1818 }
1819}
1820
1821impl StaticType for ParseFlags {
1822 #[inline]
1823 #[doc(alias = "gst_parse_flags_get_type")]
1824 fn static_type() -> glib::Type {
1825 unsafe { from_glib(ffi::gst_parse_flags_get_type()) }
1826 }
1827}
1828
1829impl glib::HasParamSpec for ParseFlags {
1830 type ParamSpec = glib::ParamSpecFlags;
1831 type SetValue = Self;
1832 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1833
1834 fn param_spec_builder() -> Self::BuilderFn {
1835 Self::ParamSpec::builder
1836 }
1837}
1838
1839impl glib::value::ValueType for ParseFlags {
1840 type Type = Self;
1841}
1842
1843unsafe impl<'a> glib::value::FromValue<'a> for ParseFlags {
1844 type Checker = glib::value::GenericValueTypeChecker<Self>;
1845
1846 #[inline]
1847 unsafe fn from_value(value: &'a glib::Value) -> Self {
1848 skip_assert_initialized!();
1849 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1850 }
1851}
1852
1853impl ToValue for ParseFlags {
1854 #[inline]
1855 fn to_value(&self) -> glib::Value {
1856 let mut value = glib::Value::for_value_type::<Self>();
1857 unsafe {
1858 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1859 }
1860 value
1861 }
1862
1863 #[inline]
1864 fn value_type(&self) -> glib::Type {
1865 Self::static_type()
1866 }
1867}
1868
1869impl From<ParseFlags> for glib::Value {
1870 #[inline]
1871 fn from(v: ParseFlags) -> Self {
1872 skip_assert_initialized!();
1873 ToValue::to_value(&v)
1874 }
1875}
1876
1877bitflags! {
1878 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1879 #[doc(alias = "GstPipelineFlags")]
1880 pub struct PipelineFlags: u32 {
1881 #[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")]
1882 const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as _;
1883 }
1884}
1885
1886#[doc(hidden)]
1887impl IntoGlib for PipelineFlags {
1888 type GlibType = ffi::GstPipelineFlags;
1889
1890 #[inline]
1891 fn into_glib(self) -> ffi::GstPipelineFlags {
1892 self.bits()
1893 }
1894}
1895
1896#[doc(hidden)]
1897impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags {
1898 #[inline]
1899 unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self {
1900 skip_assert_initialized!();
1901 Self::from_bits_truncate(value)
1902 }
1903}
1904
1905impl StaticType for PipelineFlags {
1906 #[inline]
1907 #[doc(alias = "gst_pipeline_flags_get_type")]
1908 fn static_type() -> glib::Type {
1909 unsafe { from_glib(ffi::gst_pipeline_flags_get_type()) }
1910 }
1911}
1912
1913impl glib::HasParamSpec for PipelineFlags {
1914 type ParamSpec = glib::ParamSpecFlags;
1915 type SetValue = Self;
1916 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1917
1918 fn param_spec_builder() -> Self::BuilderFn {
1919 Self::ParamSpec::builder
1920 }
1921}
1922
1923impl glib::value::ValueType for PipelineFlags {
1924 type Type = Self;
1925}
1926
1927unsafe impl<'a> glib::value::FromValue<'a> for PipelineFlags {
1928 type Checker = glib::value::GenericValueTypeChecker<Self>;
1929
1930 #[inline]
1931 unsafe fn from_value(value: &'a glib::Value) -> Self {
1932 skip_assert_initialized!();
1933 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1934 }
1935}
1936
1937impl ToValue for PipelineFlags {
1938 #[inline]
1939 fn to_value(&self) -> glib::Value {
1940 let mut value = glib::Value::for_value_type::<Self>();
1941 unsafe {
1942 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1943 }
1944 value
1945 }
1946
1947 #[inline]
1948 fn value_type(&self) -> glib::Type {
1949 Self::static_type()
1950 }
1951}
1952
1953impl From<PipelineFlags> for glib::Value {
1954 #[inline]
1955 fn from(v: PipelineFlags) -> Self {
1956 skip_assert_initialized!();
1957 ToValue::to_value(&v)
1958 }
1959}
1960
1961#[cfg(feature = "v1_18")]
1962bitflags! {
1963 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1964 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1965 #[doc(alias = "GstPluginAPIFlags")]
1966 pub struct PluginAPIFlags: u32 {
1967 #[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")]
1968 const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as _;
1969 }
1970}
1971
1972#[cfg(feature = "v1_18")]
1973#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1974#[doc(hidden)]
1975impl IntoGlib for PluginAPIFlags {
1976 type GlibType = ffi::GstPluginAPIFlags;
1977
1978 #[inline]
1979 fn into_glib(self) -> ffi::GstPluginAPIFlags {
1980 self.bits()
1981 }
1982}
1983
1984#[cfg(feature = "v1_18")]
1985#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1986#[doc(hidden)]
1987impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags {
1988 #[inline]
1989 unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self {
1990 skip_assert_initialized!();
1991 Self::from_bits_truncate(value)
1992 }
1993}
1994
1995#[cfg(feature = "v1_18")]
1996#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1997impl StaticType for PluginAPIFlags {
1998 #[inline]
1999 #[doc(alias = "gst_plugin_api_flags_get_type")]
2000 fn static_type() -> glib::Type {
2001 unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) }
2002 }
2003}
2004
2005#[cfg(feature = "v1_18")]
2006#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2007impl glib::HasParamSpec for PluginAPIFlags {
2008 type ParamSpec = glib::ParamSpecFlags;
2009 type SetValue = Self;
2010 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2011
2012 fn param_spec_builder() -> Self::BuilderFn {
2013 Self::ParamSpec::builder
2014 }
2015}
2016
2017#[cfg(feature = "v1_18")]
2018#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2019impl glib::value::ValueType for PluginAPIFlags {
2020 type Type = Self;
2021}
2022
2023#[cfg(feature = "v1_18")]
2024#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2025unsafe impl<'a> glib::value::FromValue<'a> for PluginAPIFlags {
2026 type Checker = glib::value::GenericValueTypeChecker<Self>;
2027
2028 #[inline]
2029 unsafe fn from_value(value: &'a glib::Value) -> Self {
2030 skip_assert_initialized!();
2031 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2032 }
2033}
2034
2035#[cfg(feature = "v1_18")]
2036#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2037impl ToValue for PluginAPIFlags {
2038 #[inline]
2039 fn to_value(&self) -> glib::Value {
2040 let mut value = glib::Value::for_value_type::<Self>();
2041 unsafe {
2042 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2043 }
2044 value
2045 }
2046
2047 #[inline]
2048 fn value_type(&self) -> glib::Type {
2049 Self::static_type()
2050 }
2051}
2052
2053#[cfg(feature = "v1_18")]
2054#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2055impl From<PluginAPIFlags> for glib::Value {
2056 #[inline]
2057 fn from(v: PluginAPIFlags) -> Self {
2058 skip_assert_initialized!();
2059 ToValue::to_value(&v)
2060 }
2061}
2062
2063bitflags! {
2064 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2065 #[doc(alias = "GstPluginDependencyFlags")]
2066 pub struct PluginDependencyFlags: u32 {
2067 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")]
2068 const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as _;
2069 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")]
2070 const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as _;
2071 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")]
2072 const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as _;
2073 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")]
2074 const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as _;
2075 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")]
2076 const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as _;
2077 }
2078}
2079
2080#[doc(hidden)]
2081impl IntoGlib for PluginDependencyFlags {
2082 type GlibType = ffi::GstPluginDependencyFlags;
2083
2084 #[inline]
2085 fn into_glib(self) -> ffi::GstPluginDependencyFlags {
2086 self.bits()
2087 }
2088}
2089
2090#[doc(hidden)]
2091impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags {
2092 #[inline]
2093 unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self {
2094 skip_assert_initialized!();
2095 Self::from_bits_truncate(value)
2096 }
2097}
2098
2099impl StaticType for PluginDependencyFlags {
2100 #[inline]
2101 #[doc(alias = "gst_plugin_dependency_flags_get_type")]
2102 fn static_type() -> glib::Type {
2103 unsafe { from_glib(ffi::gst_plugin_dependency_flags_get_type()) }
2104 }
2105}
2106
2107impl glib::HasParamSpec for PluginDependencyFlags {
2108 type ParamSpec = glib::ParamSpecFlags;
2109 type SetValue = Self;
2110 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2111
2112 fn param_spec_builder() -> Self::BuilderFn {
2113 Self::ParamSpec::builder
2114 }
2115}
2116
2117impl glib::value::ValueType for PluginDependencyFlags {
2118 type Type = Self;
2119}
2120
2121unsafe impl<'a> glib::value::FromValue<'a> for PluginDependencyFlags {
2122 type Checker = glib::value::GenericValueTypeChecker<Self>;
2123
2124 #[inline]
2125 unsafe fn from_value(value: &'a glib::Value) -> Self {
2126 skip_assert_initialized!();
2127 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2128 }
2129}
2130
2131impl ToValue for PluginDependencyFlags {
2132 #[inline]
2133 fn to_value(&self) -> glib::Value {
2134 let mut value = glib::Value::for_value_type::<Self>();
2135 unsafe {
2136 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2137 }
2138 value
2139 }
2140
2141 #[inline]
2142 fn value_type(&self) -> glib::Type {
2143 Self::static_type()
2144 }
2145}
2146
2147impl From<PluginDependencyFlags> for glib::Value {
2148 #[inline]
2149 fn from(v: PluginDependencyFlags) -> Self {
2150 skip_assert_initialized!();
2151 ToValue::to_value(&v)
2152 }
2153}
2154
2155bitflags! {
2156 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2157 #[doc(alias = "GstPluginFlags")]
2158 pub struct PluginFlags: u32 {
2159 #[doc(alias = "GST_PLUGIN_FLAG_CACHED")]
2160 const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as _;
2161 #[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")]
2162 const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as _;
2163 #[cfg(feature = "v1_30")]
2164 #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
2165 #[doc(alias = "GST_PLUGIN_FLAG_STATIC_FEATURES")]
2166 const STATIC_FEATURES = ffi::GST_PLUGIN_FLAG_STATIC_FEATURES as _;
2167 }
2168}
2169
2170#[doc(hidden)]
2171impl IntoGlib for PluginFlags {
2172 type GlibType = ffi::GstPluginFlags;
2173
2174 #[inline]
2175 fn into_glib(self) -> ffi::GstPluginFlags {
2176 self.bits()
2177 }
2178}
2179
2180#[doc(hidden)]
2181impl FromGlib<ffi::GstPluginFlags> for PluginFlags {
2182 #[inline]
2183 unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self {
2184 skip_assert_initialized!();
2185 Self::from_bits_truncate(value)
2186 }
2187}
2188
2189impl StaticType for PluginFlags {
2190 #[inline]
2191 #[doc(alias = "gst_plugin_flags_get_type")]
2192 fn static_type() -> glib::Type {
2193 unsafe { from_glib(ffi::gst_plugin_flags_get_type()) }
2194 }
2195}
2196
2197impl glib::HasParamSpec for PluginFlags {
2198 type ParamSpec = glib::ParamSpecFlags;
2199 type SetValue = Self;
2200 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2201
2202 fn param_spec_builder() -> Self::BuilderFn {
2203 Self::ParamSpec::builder
2204 }
2205}
2206
2207impl glib::value::ValueType for PluginFlags {
2208 type Type = Self;
2209}
2210
2211unsafe impl<'a> glib::value::FromValue<'a> for PluginFlags {
2212 type Checker = glib::value::GenericValueTypeChecker<Self>;
2213
2214 #[inline]
2215 unsafe fn from_value(value: &'a glib::Value) -> Self {
2216 skip_assert_initialized!();
2217 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2218 }
2219}
2220
2221impl ToValue for PluginFlags {
2222 #[inline]
2223 fn to_value(&self) -> glib::Value {
2224 let mut value = glib::Value::for_value_type::<Self>();
2225 unsafe {
2226 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2227 }
2228 value
2229 }
2230
2231 #[inline]
2232 fn value_type(&self) -> glib::Type {
2233 Self::static_type()
2234 }
2235}
2236
2237impl From<PluginFlags> for glib::Value {
2238 #[inline]
2239 fn from(v: PluginFlags) -> Self {
2240 skip_assert_initialized!();
2241 ToValue::to_value(&v)
2242 }
2243}
2244
2245bitflags! {
2246 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2247 #[doc(alias = "GstSchedulingFlags")]
2248 pub struct SchedulingFlags: u32 {
2249 #[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")]
2250 const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as _;
2251 #[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")]
2252 const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as _;
2253 #[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")]
2254 const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as _;
2255 }
2256}
2257
2258#[doc(hidden)]
2259impl IntoGlib for SchedulingFlags {
2260 type GlibType = ffi::GstSchedulingFlags;
2261
2262 #[inline]
2263 fn into_glib(self) -> ffi::GstSchedulingFlags {
2264 self.bits()
2265 }
2266}
2267
2268#[doc(hidden)]
2269impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags {
2270 #[inline]
2271 unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self {
2272 skip_assert_initialized!();
2273 Self::from_bits_truncate(value)
2274 }
2275}
2276
2277impl StaticType for SchedulingFlags {
2278 #[inline]
2279 #[doc(alias = "gst_scheduling_flags_get_type")]
2280 fn static_type() -> glib::Type {
2281 unsafe { from_glib(ffi::gst_scheduling_flags_get_type()) }
2282 }
2283}
2284
2285impl glib::HasParamSpec for SchedulingFlags {
2286 type ParamSpec = glib::ParamSpecFlags;
2287 type SetValue = Self;
2288 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2289
2290 fn param_spec_builder() -> Self::BuilderFn {
2291 Self::ParamSpec::builder
2292 }
2293}
2294
2295impl glib::value::ValueType for SchedulingFlags {
2296 type Type = Self;
2297}
2298
2299unsafe impl<'a> glib::value::FromValue<'a> for SchedulingFlags {
2300 type Checker = glib::value::GenericValueTypeChecker<Self>;
2301
2302 #[inline]
2303 unsafe fn from_value(value: &'a glib::Value) -> Self {
2304 skip_assert_initialized!();
2305 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2306 }
2307}
2308
2309impl ToValue for SchedulingFlags {
2310 #[inline]
2311 fn to_value(&self) -> glib::Value {
2312 let mut value = glib::Value::for_value_type::<Self>();
2313 unsafe {
2314 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2315 }
2316 value
2317 }
2318
2319 #[inline]
2320 fn value_type(&self) -> glib::Type {
2321 Self::static_type()
2322 }
2323}
2324
2325impl From<SchedulingFlags> for glib::Value {
2326 #[inline]
2327 fn from(v: SchedulingFlags) -> Self {
2328 skip_assert_initialized!();
2329 ToValue::to_value(&v)
2330 }
2331}
2332
2333bitflags! {
2334 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2335 #[doc(alias = "GstSeekFlags")]
2336 pub struct SeekFlags: u32 {
2337 #[doc(alias = "GST_SEEK_FLAG_FLUSH")]
2338 const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as _;
2339 #[doc(alias = "GST_SEEK_FLAG_ACCURATE")]
2340 const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as _;
2341 #[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")]
2342 const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as _;
2343 #[doc(alias = "GST_SEEK_FLAG_SEGMENT")]
2344 const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as _;
2345 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE")]
2346 const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as _;
2347 #[doc(alias = "GST_SEEK_FLAG_SKIP")]
2348 const SKIP = ffi::GST_SEEK_FLAG_SKIP as _;
2349 #[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")]
2350 const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as _;
2351 #[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")]
2352 const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as _;
2353 #[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")]
2354 const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as _;
2355 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")]
2356 const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as _;
2357 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")]
2358 const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as _;
2359 #[cfg(feature = "v1_18")]
2360 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2361 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2362 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2363 #[cfg(feature = "v1_18")]
2364 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2365 #[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")]
2366 const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as _;
2367 }
2368}
2369
2370#[doc(hidden)]
2371impl IntoGlib for SeekFlags {
2372 type GlibType = ffi::GstSeekFlags;
2373
2374 #[inline]
2375 fn into_glib(self) -> ffi::GstSeekFlags {
2376 self.bits()
2377 }
2378}
2379
2380#[doc(hidden)]
2381impl FromGlib<ffi::GstSeekFlags> for SeekFlags {
2382 #[inline]
2383 unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self {
2384 skip_assert_initialized!();
2385 Self::from_bits_truncate(value)
2386 }
2387}
2388
2389impl StaticType for SeekFlags {
2390 #[inline]
2391 #[doc(alias = "gst_seek_flags_get_type")]
2392 fn static_type() -> glib::Type {
2393 unsafe { from_glib(ffi::gst_seek_flags_get_type()) }
2394 }
2395}
2396
2397impl glib::HasParamSpec for SeekFlags {
2398 type ParamSpec = glib::ParamSpecFlags;
2399 type SetValue = Self;
2400 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2401
2402 fn param_spec_builder() -> Self::BuilderFn {
2403 Self::ParamSpec::builder
2404 }
2405}
2406
2407impl glib::value::ValueType for SeekFlags {
2408 type Type = Self;
2409}
2410
2411unsafe impl<'a> glib::value::FromValue<'a> for SeekFlags {
2412 type Checker = glib::value::GenericValueTypeChecker<Self>;
2413
2414 #[inline]
2415 unsafe fn from_value(value: &'a glib::Value) -> Self {
2416 skip_assert_initialized!();
2417 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2418 }
2419}
2420
2421impl ToValue for SeekFlags {
2422 #[inline]
2423 fn to_value(&self) -> glib::Value {
2424 let mut value = glib::Value::for_value_type::<Self>();
2425 unsafe {
2426 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2427 }
2428 value
2429 }
2430
2431 #[inline]
2432 fn value_type(&self) -> glib::Type {
2433 Self::static_type()
2434 }
2435}
2436
2437impl From<SeekFlags> for glib::Value {
2438 #[inline]
2439 fn from(v: SeekFlags) -> Self {
2440 skip_assert_initialized!();
2441 ToValue::to_value(&v)
2442 }
2443}
2444
2445bitflags! {
2446 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2447 #[doc(alias = "GstSegmentFlags")]
2448 pub struct SegmentFlags: u32 {
2449 #[doc(alias = "GST_SEGMENT_FLAG_RESET")]
2450 const RESET = ffi::GST_SEGMENT_FLAG_RESET as _;
2451 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")]
2452 const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as _;
2453 #[doc(alias = "GST_SEGMENT_FLAG_SKIP")]
2454 const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as _;
2455 #[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")]
2456 const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as _;
2457 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")]
2458 const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as _;
2459 #[cfg(feature = "v1_18")]
2460 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2461 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")]
2462 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
2463 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")]
2464 const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as _;
2465 }
2466}
2467
2468#[doc(hidden)]
2469impl IntoGlib for SegmentFlags {
2470 type GlibType = ffi::GstSegmentFlags;
2471
2472 #[inline]
2473 fn into_glib(self) -> ffi::GstSegmentFlags {
2474 self.bits()
2475 }
2476}
2477
2478#[doc(hidden)]
2479impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags {
2480 #[inline]
2481 unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self {
2482 skip_assert_initialized!();
2483 Self::from_bits_truncate(value)
2484 }
2485}
2486
2487impl StaticType for SegmentFlags {
2488 #[inline]
2489 #[doc(alias = "gst_segment_flags_get_type")]
2490 fn static_type() -> glib::Type {
2491 unsafe { from_glib(ffi::gst_segment_flags_get_type()) }
2492 }
2493}
2494
2495impl glib::HasParamSpec for SegmentFlags {
2496 type ParamSpec = glib::ParamSpecFlags;
2497 type SetValue = Self;
2498 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2499
2500 fn param_spec_builder() -> Self::BuilderFn {
2501 Self::ParamSpec::builder
2502 }
2503}
2504
2505impl glib::value::ValueType for SegmentFlags {
2506 type Type = Self;
2507}
2508
2509unsafe impl<'a> glib::value::FromValue<'a> for SegmentFlags {
2510 type Checker = glib::value::GenericValueTypeChecker<Self>;
2511
2512 #[inline]
2513 unsafe fn from_value(value: &'a glib::Value) -> Self {
2514 skip_assert_initialized!();
2515 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2516 }
2517}
2518
2519impl ToValue for SegmentFlags {
2520 #[inline]
2521 fn to_value(&self) -> glib::Value {
2522 let mut value = glib::Value::for_value_type::<Self>();
2523 unsafe {
2524 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2525 }
2526 value
2527 }
2528
2529 #[inline]
2530 fn value_type(&self) -> glib::Type {
2531 Self::static_type()
2532 }
2533}
2534
2535impl From<SegmentFlags> for glib::Value {
2536 #[inline]
2537 fn from(v: SegmentFlags) -> Self {
2538 skip_assert_initialized!();
2539 ToValue::to_value(&v)
2540 }
2541}
2542
2543#[cfg(feature = "v1_20")]
2544bitflags! {
2545 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2546 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2547 #[doc(alias = "GstSerializeFlags")]
2548 pub struct SerializeFlags: u32 {
2549 #[doc(alias = "GST_SERIALIZE_FLAG_NONE")]
2550 const NONE = ffi::GST_SERIALIZE_FLAG_NONE as _;
2551 #[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")]
2552 const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as _;
2553 }
2554}
2555
2556#[cfg(feature = "v1_20")]
2557#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2558#[doc(hidden)]
2559impl IntoGlib for SerializeFlags {
2560 type GlibType = ffi::GstSerializeFlags;
2561
2562 #[inline]
2563 fn into_glib(self) -> ffi::GstSerializeFlags {
2564 self.bits()
2565 }
2566}
2567
2568#[cfg(feature = "v1_20")]
2569#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2570#[doc(hidden)]
2571impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags {
2572 #[inline]
2573 unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self {
2574 skip_assert_initialized!();
2575 Self::from_bits_truncate(value)
2576 }
2577}
2578
2579#[cfg(feature = "v1_20")]
2580#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2581impl StaticType for SerializeFlags {
2582 #[inline]
2583 #[doc(alias = "gst_serialize_flags_get_type")]
2584 fn static_type() -> glib::Type {
2585 unsafe { from_glib(ffi::gst_serialize_flags_get_type()) }
2586 }
2587}
2588
2589#[cfg(feature = "v1_20")]
2590#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2591impl glib::HasParamSpec for SerializeFlags {
2592 type ParamSpec = glib::ParamSpecFlags;
2593 type SetValue = Self;
2594 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2595
2596 fn param_spec_builder() -> Self::BuilderFn {
2597 Self::ParamSpec::builder
2598 }
2599}
2600
2601#[cfg(feature = "v1_20")]
2602#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2603impl glib::value::ValueType for SerializeFlags {
2604 type Type = Self;
2605}
2606
2607#[cfg(feature = "v1_20")]
2608#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2609unsafe impl<'a> glib::value::FromValue<'a> for SerializeFlags {
2610 type Checker = glib::value::GenericValueTypeChecker<Self>;
2611
2612 #[inline]
2613 unsafe fn from_value(value: &'a glib::Value) -> Self {
2614 skip_assert_initialized!();
2615 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2616 }
2617}
2618
2619#[cfg(feature = "v1_20")]
2620#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2621impl ToValue for SerializeFlags {
2622 #[inline]
2623 fn to_value(&self) -> glib::Value {
2624 let mut value = glib::Value::for_value_type::<Self>();
2625 unsafe {
2626 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2627 }
2628 value
2629 }
2630
2631 #[inline]
2632 fn value_type(&self) -> glib::Type {
2633 Self::static_type()
2634 }
2635}
2636
2637#[cfg(feature = "v1_20")]
2638#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2639impl From<SerializeFlags> for glib::Value {
2640 #[inline]
2641 fn from(v: SerializeFlags) -> Self {
2642 skip_assert_initialized!();
2643 ToValue::to_value(&v)
2644 }
2645}
2646
2647bitflags! {
2648 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2649 #[doc(alias = "GstStackTraceFlags")]
2650 pub struct StackTraceFlags: u32 {
2651 #[doc(alias = "GST_STACK_TRACE_SHOW_FULL")]
2652 const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as _;
2653 }
2654}
2655
2656#[doc(hidden)]
2657impl IntoGlib for StackTraceFlags {
2658 type GlibType = ffi::GstStackTraceFlags;
2659
2660 #[inline]
2661 fn into_glib(self) -> ffi::GstStackTraceFlags {
2662 self.bits()
2663 }
2664}
2665
2666#[doc(hidden)]
2667impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags {
2668 #[inline]
2669 unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self {
2670 skip_assert_initialized!();
2671 Self::from_bits_truncate(value)
2672 }
2673}
2674
2675impl StaticType for StackTraceFlags {
2676 #[inline]
2677 #[doc(alias = "gst_stack_trace_flags_get_type")]
2678 fn static_type() -> glib::Type {
2679 unsafe { from_glib(ffi::gst_stack_trace_flags_get_type()) }
2680 }
2681}
2682
2683impl glib::HasParamSpec for StackTraceFlags {
2684 type ParamSpec = glib::ParamSpecFlags;
2685 type SetValue = Self;
2686 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2687
2688 fn param_spec_builder() -> Self::BuilderFn {
2689 Self::ParamSpec::builder
2690 }
2691}
2692
2693impl glib::value::ValueType for StackTraceFlags {
2694 type Type = Self;
2695}
2696
2697unsafe impl<'a> glib::value::FromValue<'a> for StackTraceFlags {
2698 type Checker = glib::value::GenericValueTypeChecker<Self>;
2699
2700 #[inline]
2701 unsafe fn from_value(value: &'a glib::Value) -> Self {
2702 skip_assert_initialized!();
2703 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2704 }
2705}
2706
2707impl ToValue for StackTraceFlags {
2708 #[inline]
2709 fn to_value(&self) -> glib::Value {
2710 let mut value = glib::Value::for_value_type::<Self>();
2711 unsafe {
2712 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2713 }
2714 value
2715 }
2716
2717 #[inline]
2718 fn value_type(&self) -> glib::Type {
2719 Self::static_type()
2720 }
2721}
2722
2723impl From<StackTraceFlags> for glib::Value {
2724 #[inline]
2725 fn from(v: StackTraceFlags) -> Self {
2726 skip_assert_initialized!();
2727 ToValue::to_value(&v)
2728 }
2729}
2730
2731bitflags! {
2732 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2733 #[doc(alias = "GstStreamFlags")]
2734 pub struct StreamFlags: u32 {
2735 #[doc(alias = "GST_STREAM_FLAG_SPARSE")]
2736 const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as _;
2737 #[doc(alias = "GST_STREAM_FLAG_SELECT")]
2738 const SELECT = ffi::GST_STREAM_FLAG_SELECT as _;
2739 #[doc(alias = "GST_STREAM_FLAG_UNSELECT")]
2740 const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as _;
2741 }
2742}
2743
2744#[doc(hidden)]
2745impl IntoGlib for StreamFlags {
2746 type GlibType = ffi::GstStreamFlags;
2747
2748 #[inline]
2749 fn into_glib(self) -> ffi::GstStreamFlags {
2750 self.bits()
2751 }
2752}
2753
2754#[doc(hidden)]
2755impl FromGlib<ffi::GstStreamFlags> for StreamFlags {
2756 #[inline]
2757 unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self {
2758 skip_assert_initialized!();
2759 Self::from_bits_truncate(value)
2760 }
2761}
2762
2763impl StaticType for StreamFlags {
2764 #[inline]
2765 #[doc(alias = "gst_stream_flags_get_type")]
2766 fn static_type() -> glib::Type {
2767 unsafe { from_glib(ffi::gst_stream_flags_get_type()) }
2768 }
2769}
2770
2771impl glib::HasParamSpec for StreamFlags {
2772 type ParamSpec = glib::ParamSpecFlags;
2773 type SetValue = Self;
2774 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2775
2776 fn param_spec_builder() -> Self::BuilderFn {
2777 Self::ParamSpec::builder
2778 }
2779}
2780
2781impl glib::value::ValueType for StreamFlags {
2782 type Type = Self;
2783}
2784
2785unsafe impl<'a> glib::value::FromValue<'a> for StreamFlags {
2786 type Checker = glib::value::GenericValueTypeChecker<Self>;
2787
2788 #[inline]
2789 unsafe fn from_value(value: &'a glib::Value) -> Self {
2790 skip_assert_initialized!();
2791 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2792 }
2793}
2794
2795impl ToValue for StreamFlags {
2796 #[inline]
2797 fn to_value(&self) -> glib::Value {
2798 let mut value = glib::Value::for_value_type::<Self>();
2799 unsafe {
2800 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2801 }
2802 value
2803 }
2804
2805 #[inline]
2806 fn value_type(&self) -> glib::Type {
2807 Self::static_type()
2808 }
2809}
2810
2811impl From<StreamFlags> for glib::Value {
2812 #[inline]
2813 fn from(v: StreamFlags) -> Self {
2814 skip_assert_initialized!();
2815 ToValue::to_value(&v)
2816 }
2817}
2818
2819bitflags! {
2820 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2821 #[doc(alias = "GstStreamType")]
2822 pub struct StreamType: u32 {
2823 #[doc(alias = "GST_STREAM_TYPE_UNKNOWN")]
2824 const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as _;
2825 #[doc(alias = "GST_STREAM_TYPE_AUDIO")]
2826 const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as _;
2827 #[doc(alias = "GST_STREAM_TYPE_VIDEO")]
2828 const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as _;
2829 #[doc(alias = "GST_STREAM_TYPE_CONTAINER")]
2830 const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as _;
2831 #[doc(alias = "GST_STREAM_TYPE_TEXT")]
2832 const TEXT = ffi::GST_STREAM_TYPE_TEXT as _;
2833 #[cfg(feature = "v1_28")]
2834 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
2835 #[doc(alias = "GST_STREAM_TYPE_METADATA")]
2836 const METADATA = ffi::GST_STREAM_TYPE_METADATA as _;
2837 }
2838}
2839
2840impl StreamType {
2841 pub fn name<'a>(self) -> &'a GStr {
2842 unsafe {
2843 GStr::from_ptr(
2844 ffi::gst_stream_type_get_name(self.into_glib())
2845 .as_ref()
2846 .expect("gst_stream_type_get_name returned NULL"),
2847 )
2848 }
2849 }
2850}
2851
2852impl std::fmt::Display for StreamType {
2853 #[inline]
2854 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2855 f.write_str(&self.name())
2856 }
2857}
2858
2859#[doc(hidden)]
2860impl IntoGlib for StreamType {
2861 type GlibType = ffi::GstStreamType;
2862
2863 #[inline]
2864 fn into_glib(self) -> ffi::GstStreamType {
2865 self.bits()
2866 }
2867}
2868
2869#[doc(hidden)]
2870impl FromGlib<ffi::GstStreamType> for StreamType {
2871 #[inline]
2872 unsafe fn from_glib(value: ffi::GstStreamType) -> Self {
2873 skip_assert_initialized!();
2874 Self::from_bits_truncate(value)
2875 }
2876}
2877
2878impl StaticType for StreamType {
2879 #[inline]
2880 #[doc(alias = "gst_stream_type_get_type")]
2881 fn static_type() -> glib::Type {
2882 unsafe { from_glib(ffi::gst_stream_type_get_type()) }
2883 }
2884}
2885
2886impl glib::HasParamSpec for StreamType {
2887 type ParamSpec = glib::ParamSpecFlags;
2888 type SetValue = Self;
2889 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2890
2891 fn param_spec_builder() -> Self::BuilderFn {
2892 Self::ParamSpec::builder
2893 }
2894}
2895
2896impl glib::value::ValueType for StreamType {
2897 type Type = Self;
2898}
2899
2900unsafe impl<'a> glib::value::FromValue<'a> for StreamType {
2901 type Checker = glib::value::GenericValueTypeChecker<Self>;
2902
2903 #[inline]
2904 unsafe fn from_value(value: &'a glib::Value) -> Self {
2905 skip_assert_initialized!();
2906 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
2907 }
2908}
2909
2910impl ToValue for StreamType {
2911 #[inline]
2912 fn to_value(&self) -> glib::Value {
2913 let mut value = glib::Value::for_value_type::<Self>();
2914 unsafe {
2915 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2916 }
2917 value
2918 }
2919
2920 #[inline]
2921 fn value_type(&self) -> glib::Type {
2922 Self::static_type()
2923 }
2924}
2925
2926impl From<StreamType> for glib::Value {
2927 #[inline]
2928 fn from(v: StreamType) -> Self {
2929 skip_assert_initialized!();
2930 ToValue::to_value(&v)
2931 }
2932}