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 6 use bitflags::bitflags; 7 use glib::translate::*; 8 use glib::value::FromValue; 9 use glib::value::ToValue; 10 use glib::StaticType; 11 use glib::Type; 12 #[cfg(any(feature = "v1_10", feature = "dox"))] 13 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 14 use std::ffi::CStr; 15 #[cfg(any(feature = "v1_10", feature = "dox"))] 16 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 17 use std::fmt; 18 19 bitflags! { 20 #[doc(alias = "GstBinFlags")] 21 pub struct BinFlags: u32 { 22 #[doc(alias = "GST_BIN_FLAG_NO_RESYNC")] 23 const NO_RESYNC = ffi::GST_BIN_FLAG_NO_RESYNC as u32; 24 #[cfg(any(feature = "v1_10", feature = "dox"))] 25 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 26 #[doc(alias = "GST_BIN_FLAG_STREAMS_AWARE")] 27 const STREAMS_AWARE = ffi::GST_BIN_FLAG_STREAMS_AWARE as u32; 28 } 29 } 30 31 #[doc(hidden)] 32 impl IntoGlib for BinFlags { 33 type GlibType = ffi::GstBinFlags; 34 into_glib(self) -> ffi::GstBinFlags35 fn into_glib(self) -> ffi::GstBinFlags { 36 self.bits() 37 } 38 } 39 40 #[doc(hidden)] 41 impl FromGlib<ffi::GstBinFlags> for BinFlags { from_glib(value: ffi::GstBinFlags) -> Self42 unsafe fn from_glib(value: ffi::GstBinFlags) -> Self { 43 skip_assert_initialized!(); 44 Self::from_bits_truncate(value) 45 } 46 } 47 48 impl StaticType for BinFlags { static_type() -> Type49 fn static_type() -> Type { 50 unsafe { from_glib(ffi::gst_bin_flags_get_type()) } 51 } 52 } 53 54 impl glib::value::ValueType for BinFlags { 55 type Type = Self; 56 } 57 58 unsafe impl<'a> FromValue<'a> for BinFlags { 59 type Checker = glib::value::GenericValueTypeChecker<Self>; 60 from_value(value: &'a glib::Value) -> Self61 unsafe fn from_value(value: &'a glib::Value) -> Self { 62 skip_assert_initialized!(); 63 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 64 } 65 } 66 67 impl ToValue for BinFlags { to_value(&self) -> glib::Value68 fn to_value(&self) -> glib::Value { 69 let mut value = glib::Value::for_value_type::<Self>(); 70 unsafe { 71 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 72 } 73 value 74 } 75 value_type(&self) -> glib::Type76 fn value_type(&self) -> glib::Type { 77 Self::static_type() 78 } 79 } 80 81 bitflags! { 82 #[doc(alias = "GstBufferCopyFlags")] 83 pub struct BufferCopyFlags: u32 { 84 #[doc(alias = "GST_BUFFER_COPY_FLAGS")] 85 const FLAGS = ffi::GST_BUFFER_COPY_FLAGS as u32; 86 #[doc(alias = "GST_BUFFER_COPY_TIMESTAMPS")] 87 const TIMESTAMPS = ffi::GST_BUFFER_COPY_TIMESTAMPS as u32; 88 #[doc(alias = "GST_BUFFER_COPY_META")] 89 const META = ffi::GST_BUFFER_COPY_META as u32; 90 #[doc(alias = "GST_BUFFER_COPY_MEMORY")] 91 const MEMORY = ffi::GST_BUFFER_COPY_MEMORY as u32; 92 #[doc(alias = "GST_BUFFER_COPY_MERGE")] 93 const MERGE = ffi::GST_BUFFER_COPY_MERGE as u32; 94 #[doc(alias = "GST_BUFFER_COPY_DEEP")] 95 const DEEP = ffi::GST_BUFFER_COPY_DEEP as u32; 96 } 97 } 98 99 #[doc(hidden)] 100 impl IntoGlib for BufferCopyFlags { 101 type GlibType = ffi::GstBufferCopyFlags; 102 into_glib(self) -> ffi::GstBufferCopyFlags103 fn into_glib(self) -> ffi::GstBufferCopyFlags { 104 self.bits() 105 } 106 } 107 108 #[doc(hidden)] 109 impl FromGlib<ffi::GstBufferCopyFlags> for BufferCopyFlags { from_glib(value: ffi::GstBufferCopyFlags) -> Self110 unsafe fn from_glib(value: ffi::GstBufferCopyFlags) -> Self { 111 skip_assert_initialized!(); 112 Self::from_bits_truncate(value) 113 } 114 } 115 116 impl StaticType for BufferCopyFlags { static_type() -> Type117 fn static_type() -> Type { 118 unsafe { from_glib(ffi::gst_buffer_copy_flags_get_type()) } 119 } 120 } 121 122 impl glib::value::ValueType for BufferCopyFlags { 123 type Type = Self; 124 } 125 126 unsafe impl<'a> FromValue<'a> for BufferCopyFlags { 127 type Checker = glib::value::GenericValueTypeChecker<Self>; 128 from_value(value: &'a glib::Value) -> Self129 unsafe fn from_value(value: &'a glib::Value) -> Self { 130 skip_assert_initialized!(); 131 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 132 } 133 } 134 135 impl ToValue for BufferCopyFlags { to_value(&self) -> glib::Value136 fn to_value(&self) -> glib::Value { 137 let mut value = glib::Value::for_value_type::<Self>(); 138 unsafe { 139 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 140 } 141 value 142 } 143 value_type(&self) -> glib::Type144 fn value_type(&self) -> glib::Type { 145 Self::static_type() 146 } 147 } 148 149 bitflags! { 150 #[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))] 151 #[doc(alias = "GstBufferFlags")] 152 pub struct BufferFlags: u32 { 153 #[doc(alias = "GST_BUFFER_FLAG_LIVE")] 154 const LIVE = ffi::GST_BUFFER_FLAG_LIVE as u32; 155 #[doc(alias = "GST_BUFFER_FLAG_DECODE_ONLY")] 156 const DECODE_ONLY = ffi::GST_BUFFER_FLAG_DECODE_ONLY as u32; 157 #[doc(alias = "GST_BUFFER_FLAG_DISCONT")] 158 const DISCONT = ffi::GST_BUFFER_FLAG_DISCONT as u32; 159 #[doc(alias = "GST_BUFFER_FLAG_RESYNC")] 160 const RESYNC = ffi::GST_BUFFER_FLAG_RESYNC as u32; 161 #[doc(alias = "GST_BUFFER_FLAG_CORRUPTED")] 162 const CORRUPTED = ffi::GST_BUFFER_FLAG_CORRUPTED as u32; 163 #[doc(alias = "GST_BUFFER_FLAG_MARKER")] 164 const MARKER = ffi::GST_BUFFER_FLAG_MARKER as u32; 165 #[doc(alias = "GST_BUFFER_FLAG_HEADER")] 166 const HEADER = ffi::GST_BUFFER_FLAG_HEADER as u32; 167 #[doc(alias = "GST_BUFFER_FLAG_GAP")] 168 const GAP = ffi::GST_BUFFER_FLAG_GAP as u32; 169 #[doc(alias = "GST_BUFFER_FLAG_DROPPABLE")] 170 const DROPPABLE = ffi::GST_BUFFER_FLAG_DROPPABLE as u32; 171 #[doc(alias = "GST_BUFFER_FLAG_DELTA_UNIT")] 172 const DELTA_UNIT = ffi::GST_BUFFER_FLAG_DELTA_UNIT as u32; 173 #[doc(alias = "GST_BUFFER_FLAG_TAG_MEMORY")] 174 const TAG_MEMORY = ffi::GST_BUFFER_FLAG_TAG_MEMORY as u32; 175 #[doc(alias = "GST_BUFFER_FLAG_SYNC_AFTER")] 176 const SYNC_AFTER = ffi::GST_BUFFER_FLAG_SYNC_AFTER as u32; 177 #[cfg(any(feature = "v1_14", feature = "dox"))] 178 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))] 179 #[doc(alias = "GST_BUFFER_FLAG_NON_DROPPABLE")] 180 const NON_DROPPABLE = ffi::GST_BUFFER_FLAG_NON_DROPPABLE as u32; 181 } 182 } 183 184 #[doc(hidden)] 185 impl IntoGlib for BufferFlags { 186 type GlibType = ffi::GstBufferFlags; 187 into_glib(self) -> ffi::GstBufferFlags188 fn into_glib(self) -> ffi::GstBufferFlags { 189 self.bits() 190 } 191 } 192 193 #[doc(hidden)] 194 impl FromGlib<ffi::GstBufferFlags> for BufferFlags { from_glib(value: ffi::GstBufferFlags) -> Self195 unsafe fn from_glib(value: ffi::GstBufferFlags) -> Self { 196 skip_assert_initialized!(); 197 Self::from_bits_truncate(value) 198 } 199 } 200 201 impl StaticType for BufferFlags { static_type() -> Type202 fn static_type() -> Type { 203 unsafe { from_glib(ffi::gst_buffer_flags_get_type()) } 204 } 205 } 206 207 impl glib::value::ValueType for BufferFlags { 208 type Type = Self; 209 } 210 211 unsafe impl<'a> FromValue<'a> for BufferFlags { 212 type Checker = glib::value::GenericValueTypeChecker<Self>; 213 from_value(value: &'a glib::Value) -> Self214 unsafe fn from_value(value: &'a glib::Value) -> Self { 215 skip_assert_initialized!(); 216 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 217 } 218 } 219 220 impl ToValue for BufferFlags { to_value(&self) -> glib::Value221 fn to_value(&self) -> glib::Value { 222 let mut value = glib::Value::for_value_type::<Self>(); 223 unsafe { 224 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 225 } 226 value 227 } 228 value_type(&self) -> glib::Type229 fn value_type(&self) -> glib::Type { 230 Self::static_type() 231 } 232 } 233 234 bitflags! { 235 #[doc(alias = "GstBufferPoolAcquireFlags")] 236 pub struct BufferPoolAcquireFlags: u32 { 237 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT")] 238 const KEY_UNIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT as u32; 239 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT")] 240 const DONTWAIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT as u32; 241 #[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT")] 242 const DISCONT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT as u32; 243 } 244 } 245 246 #[doc(hidden)] 247 impl IntoGlib for BufferPoolAcquireFlags { 248 type GlibType = ffi::GstBufferPoolAcquireFlags; 249 into_glib(self) -> ffi::GstBufferPoolAcquireFlags250 fn into_glib(self) -> ffi::GstBufferPoolAcquireFlags { 251 self.bits() 252 } 253 } 254 255 #[doc(hidden)] 256 impl FromGlib<ffi::GstBufferPoolAcquireFlags> for BufferPoolAcquireFlags { from_glib(value: ffi::GstBufferPoolAcquireFlags) -> Self257 unsafe fn from_glib(value: ffi::GstBufferPoolAcquireFlags) -> Self { 258 skip_assert_initialized!(); 259 Self::from_bits_truncate(value) 260 } 261 } 262 263 impl StaticType for BufferPoolAcquireFlags { static_type() -> Type264 fn static_type() -> Type { 265 unsafe { from_glib(ffi::gst_buffer_pool_acquire_flags_get_type()) } 266 } 267 } 268 269 impl glib::value::ValueType for BufferPoolAcquireFlags { 270 type Type = Self; 271 } 272 273 unsafe impl<'a> FromValue<'a> for BufferPoolAcquireFlags { 274 type Checker = glib::value::GenericValueTypeChecker<Self>; 275 from_value(value: &'a glib::Value) -> Self276 unsafe fn from_value(value: &'a glib::Value) -> Self { 277 skip_assert_initialized!(); 278 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 279 } 280 } 281 282 impl ToValue for BufferPoolAcquireFlags { to_value(&self) -> glib::Value283 fn to_value(&self) -> glib::Value { 284 let mut value = glib::Value::for_value_type::<Self>(); 285 unsafe { 286 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 287 } 288 value 289 } 290 value_type(&self) -> glib::Type291 fn value_type(&self) -> glib::Type { 292 Self::static_type() 293 } 294 } 295 296 bitflags! { 297 #[doc(alias = "GstClockFlags")] 298 pub struct ClockFlags: u32 { 299 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC")] 300 const CAN_DO_SINGLE_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC as u32; 301 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC")] 302 const CAN_DO_SINGLE_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC as u32; 303 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC")] 304 const CAN_DO_PERIODIC_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC as u32; 305 #[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC")] 306 const CAN_DO_PERIODIC_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC as u32; 307 #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_RESOLUTION")] 308 const CAN_SET_RESOLUTION = ffi::GST_CLOCK_FLAG_CAN_SET_RESOLUTION as u32; 309 #[doc(alias = "GST_CLOCK_FLAG_CAN_SET_MASTER")] 310 const CAN_SET_MASTER = ffi::GST_CLOCK_FLAG_CAN_SET_MASTER as u32; 311 #[doc(alias = "GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC")] 312 const NEEDS_STARTUP_SYNC = ffi::GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC as u32; 313 } 314 } 315 316 #[doc(hidden)] 317 impl IntoGlib for ClockFlags { 318 type GlibType = ffi::GstClockFlags; 319 into_glib(self) -> ffi::GstClockFlags320 fn into_glib(self) -> ffi::GstClockFlags { 321 self.bits() 322 } 323 } 324 325 #[doc(hidden)] 326 impl FromGlib<ffi::GstClockFlags> for ClockFlags { from_glib(value: ffi::GstClockFlags) -> Self327 unsafe fn from_glib(value: ffi::GstClockFlags) -> Self { 328 skip_assert_initialized!(); 329 Self::from_bits_truncate(value) 330 } 331 } 332 333 impl StaticType for ClockFlags { static_type() -> Type334 fn static_type() -> Type { 335 unsafe { from_glib(ffi::gst_clock_flags_get_type()) } 336 } 337 } 338 339 impl glib::value::ValueType for ClockFlags { 340 type Type = Self; 341 } 342 343 unsafe impl<'a> FromValue<'a> for ClockFlags { 344 type Checker = glib::value::GenericValueTypeChecker<Self>; 345 from_value(value: &'a glib::Value) -> Self346 unsafe fn from_value(value: &'a glib::Value) -> Self { 347 skip_assert_initialized!(); 348 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 349 } 350 } 351 352 impl ToValue for ClockFlags { to_value(&self) -> glib::Value353 fn to_value(&self) -> glib::Value { 354 let mut value = glib::Value::for_value_type::<Self>(); 355 unsafe { 356 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 357 } 358 value 359 } 360 value_type(&self) -> glib::Type361 fn value_type(&self) -> glib::Type { 362 Self::static_type() 363 } 364 } 365 366 bitflags! { 367 #[doc(alias = "GstDebugColorFlags")] 368 pub struct DebugColorFlags: u32 { 369 #[doc(alias = "GST_DEBUG_FG_BLACK")] 370 const FG_BLACK = ffi::GST_DEBUG_FG_BLACK as u32; 371 #[doc(alias = "GST_DEBUG_FG_RED")] 372 const FG_RED = ffi::GST_DEBUG_FG_RED as u32; 373 #[doc(alias = "GST_DEBUG_FG_GREEN")] 374 const FG_GREEN = ffi::GST_DEBUG_FG_GREEN as u32; 375 #[doc(alias = "GST_DEBUG_FG_YELLOW")] 376 const FG_YELLOW = ffi::GST_DEBUG_FG_YELLOW as u32; 377 #[doc(alias = "GST_DEBUG_FG_BLUE")] 378 const FG_BLUE = ffi::GST_DEBUG_FG_BLUE as u32; 379 #[doc(alias = "GST_DEBUG_FG_MAGENTA")] 380 const FG_MAGENTA = ffi::GST_DEBUG_FG_MAGENTA as u32; 381 #[doc(alias = "GST_DEBUG_FG_CYAN")] 382 const FG_CYAN = ffi::GST_DEBUG_FG_CYAN as u32; 383 #[doc(alias = "GST_DEBUG_FG_WHITE")] 384 const FG_WHITE = ffi::GST_DEBUG_FG_WHITE as u32; 385 #[doc(alias = "GST_DEBUG_BG_BLACK")] 386 const BG_BLACK = ffi::GST_DEBUG_BG_BLACK as u32; 387 #[doc(alias = "GST_DEBUG_BG_RED")] 388 const BG_RED = ffi::GST_DEBUG_BG_RED as u32; 389 #[doc(alias = "GST_DEBUG_BG_GREEN")] 390 const BG_GREEN = ffi::GST_DEBUG_BG_GREEN as u32; 391 #[doc(alias = "GST_DEBUG_BG_YELLOW")] 392 const BG_YELLOW = ffi::GST_DEBUG_BG_YELLOW as u32; 393 #[doc(alias = "GST_DEBUG_BG_BLUE")] 394 const BG_BLUE = ffi::GST_DEBUG_BG_BLUE as u32; 395 #[doc(alias = "GST_DEBUG_BG_MAGENTA")] 396 const BG_MAGENTA = ffi::GST_DEBUG_BG_MAGENTA as u32; 397 #[doc(alias = "GST_DEBUG_BG_CYAN")] 398 const BG_CYAN = ffi::GST_DEBUG_BG_CYAN as u32; 399 #[doc(alias = "GST_DEBUG_BG_WHITE")] 400 const BG_WHITE = ffi::GST_DEBUG_BG_WHITE as u32; 401 #[doc(alias = "GST_DEBUG_BOLD")] 402 const BOLD = ffi::GST_DEBUG_BOLD as u32; 403 #[doc(alias = "GST_DEBUG_UNDERLINE")] 404 const UNDERLINE = ffi::GST_DEBUG_UNDERLINE as u32; 405 } 406 } 407 408 #[doc(hidden)] 409 impl IntoGlib for DebugColorFlags { 410 type GlibType = ffi::GstDebugColorFlags; 411 into_glib(self) -> ffi::GstDebugColorFlags412 fn into_glib(self) -> ffi::GstDebugColorFlags { 413 self.bits() 414 } 415 } 416 417 #[doc(hidden)] 418 impl FromGlib<ffi::GstDebugColorFlags> for DebugColorFlags { from_glib(value: ffi::GstDebugColorFlags) -> Self419 unsafe fn from_glib(value: ffi::GstDebugColorFlags) -> Self { 420 skip_assert_initialized!(); 421 Self::from_bits_truncate(value) 422 } 423 } 424 425 impl StaticType for DebugColorFlags { static_type() -> Type426 fn static_type() -> Type { 427 unsafe { from_glib(ffi::gst_debug_color_flags_get_type()) } 428 } 429 } 430 431 impl glib::value::ValueType for DebugColorFlags { 432 type Type = Self; 433 } 434 435 unsafe impl<'a> FromValue<'a> for DebugColorFlags { 436 type Checker = glib::value::GenericValueTypeChecker<Self>; 437 from_value(value: &'a glib::Value) -> Self438 unsafe fn from_value(value: &'a glib::Value) -> Self { 439 skip_assert_initialized!(); 440 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 441 } 442 } 443 444 impl ToValue for DebugColorFlags { to_value(&self) -> glib::Value445 fn to_value(&self) -> glib::Value { 446 let mut value = glib::Value::for_value_type::<Self>(); 447 unsafe { 448 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 449 } 450 value 451 } 452 value_type(&self) -> glib::Type453 fn value_type(&self) -> glib::Type { 454 Self::static_type() 455 } 456 } 457 458 bitflags! { 459 #[doc(alias = "GstDebugGraphDetails")] 460 pub struct DebugGraphDetails: u32 { 461 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE")] 462 const MEDIA_TYPE = ffi::GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE as u32; 463 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS")] 464 const CAPS_DETAILS = ffi::GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS as u32; 465 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS")] 466 const NON_DEFAULT_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS as u32; 467 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_STATES")] 468 const STATES = ffi::GST_DEBUG_GRAPH_SHOW_STATES as u32; 469 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_FULL_PARAMS")] 470 const FULL_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_FULL_PARAMS as u32; 471 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_ALL")] 472 const ALL = ffi::GST_DEBUG_GRAPH_SHOW_ALL as u32; 473 #[doc(alias = "GST_DEBUG_GRAPH_SHOW_VERBOSE")] 474 const VERBOSE = ffi::GST_DEBUG_GRAPH_SHOW_VERBOSE as u32; 475 } 476 } 477 478 #[doc(hidden)] 479 impl IntoGlib for DebugGraphDetails { 480 type GlibType = ffi::GstDebugGraphDetails; 481 into_glib(self) -> ffi::GstDebugGraphDetails482 fn into_glib(self) -> ffi::GstDebugGraphDetails { 483 self.bits() 484 } 485 } 486 487 #[doc(hidden)] 488 impl FromGlib<ffi::GstDebugGraphDetails> for DebugGraphDetails { from_glib(value: ffi::GstDebugGraphDetails) -> Self489 unsafe fn from_glib(value: ffi::GstDebugGraphDetails) -> Self { 490 skip_assert_initialized!(); 491 Self::from_bits_truncate(value) 492 } 493 } 494 495 impl StaticType for DebugGraphDetails { static_type() -> Type496 fn static_type() -> Type { 497 unsafe { from_glib(ffi::gst_debug_graph_details_get_type()) } 498 } 499 } 500 501 impl glib::value::ValueType for DebugGraphDetails { 502 type Type = Self; 503 } 504 505 unsafe impl<'a> FromValue<'a> for DebugGraphDetails { 506 type Checker = glib::value::GenericValueTypeChecker<Self>; 507 from_value(value: &'a glib::Value) -> Self508 unsafe fn from_value(value: &'a glib::Value) -> Self { 509 skip_assert_initialized!(); 510 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 511 } 512 } 513 514 impl ToValue for DebugGraphDetails { to_value(&self) -> glib::Value515 fn to_value(&self) -> glib::Value { 516 let mut value = glib::Value::for_value_type::<Self>(); 517 unsafe { 518 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 519 } 520 value 521 } 522 value_type(&self) -> glib::Type523 fn value_type(&self) -> glib::Type { 524 Self::static_type() 525 } 526 } 527 528 bitflags! { 529 #[doc(alias = "GstElementFlags")] 530 pub struct ElementFlags: u32 { 531 #[doc(alias = "GST_ELEMENT_FLAG_LOCKED_STATE")] 532 const LOCKED_STATE = ffi::GST_ELEMENT_FLAG_LOCKED_STATE as u32; 533 #[doc(alias = "GST_ELEMENT_FLAG_SINK")] 534 const SINK = ffi::GST_ELEMENT_FLAG_SINK as u32; 535 #[doc(alias = "GST_ELEMENT_FLAG_SOURCE")] 536 const SOURCE = ffi::GST_ELEMENT_FLAG_SOURCE as u32; 537 #[doc(alias = "GST_ELEMENT_FLAG_PROVIDE_CLOCK")] 538 const PROVIDE_CLOCK = ffi::GST_ELEMENT_FLAG_PROVIDE_CLOCK as u32; 539 #[doc(alias = "GST_ELEMENT_FLAG_REQUIRE_CLOCK")] 540 const REQUIRE_CLOCK = ffi::GST_ELEMENT_FLAG_REQUIRE_CLOCK as u32; 541 #[doc(alias = "GST_ELEMENT_FLAG_INDEXABLE")] 542 const INDEXABLE = ffi::GST_ELEMENT_FLAG_INDEXABLE as u32; 543 } 544 } 545 546 #[doc(hidden)] 547 impl IntoGlib for ElementFlags { 548 type GlibType = ffi::GstElementFlags; 549 into_glib(self) -> ffi::GstElementFlags550 fn into_glib(self) -> ffi::GstElementFlags { 551 self.bits() 552 } 553 } 554 555 #[doc(hidden)] 556 impl FromGlib<ffi::GstElementFlags> for ElementFlags { from_glib(value: ffi::GstElementFlags) -> Self557 unsafe fn from_glib(value: ffi::GstElementFlags) -> Self { 558 skip_assert_initialized!(); 559 Self::from_bits_truncate(value) 560 } 561 } 562 563 impl StaticType for ElementFlags { static_type() -> Type564 fn static_type() -> Type { 565 unsafe { from_glib(ffi::gst_element_flags_get_type()) } 566 } 567 } 568 569 impl glib::value::ValueType for ElementFlags { 570 type Type = Self; 571 } 572 573 unsafe impl<'a> FromValue<'a> for ElementFlags { 574 type Checker = glib::value::GenericValueTypeChecker<Self>; 575 from_value(value: &'a glib::Value) -> Self576 unsafe fn from_value(value: &'a glib::Value) -> Self { 577 skip_assert_initialized!(); 578 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 579 } 580 } 581 582 impl ToValue for ElementFlags { to_value(&self) -> glib::Value583 fn to_value(&self) -> glib::Value { 584 let mut value = glib::Value::for_value_type::<Self>(); 585 unsafe { 586 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 587 } 588 value 589 } 590 value_type(&self) -> glib::Type591 fn value_type(&self) -> glib::Type { 592 Self::static_type() 593 } 594 } 595 596 bitflags! { 597 #[doc(alias = "GstEventTypeFlags")] 598 pub struct EventTypeFlags: u32 { 599 #[doc(alias = "GST_EVENT_TYPE_UPSTREAM")] 600 const UPSTREAM = ffi::GST_EVENT_TYPE_UPSTREAM as u32; 601 #[doc(alias = "GST_EVENT_TYPE_DOWNSTREAM")] 602 const DOWNSTREAM = ffi::GST_EVENT_TYPE_DOWNSTREAM as u32; 603 #[doc(alias = "GST_EVENT_TYPE_SERIALIZED")] 604 const SERIALIZED = ffi::GST_EVENT_TYPE_SERIALIZED as u32; 605 #[doc(alias = "GST_EVENT_TYPE_STICKY")] 606 const STICKY = ffi::GST_EVENT_TYPE_STICKY as u32; 607 #[doc(alias = "GST_EVENT_TYPE_STICKY_MULTI")] 608 const STICKY_MULTI = ffi::GST_EVENT_TYPE_STICKY_MULTI as u32; 609 } 610 } 611 612 #[doc(hidden)] 613 impl IntoGlib for EventTypeFlags { 614 type GlibType = ffi::GstEventTypeFlags; 615 into_glib(self) -> ffi::GstEventTypeFlags616 fn into_glib(self) -> ffi::GstEventTypeFlags { 617 self.bits() 618 } 619 } 620 621 #[doc(hidden)] 622 impl FromGlib<ffi::GstEventTypeFlags> for EventTypeFlags { from_glib(value: ffi::GstEventTypeFlags) -> Self623 unsafe fn from_glib(value: ffi::GstEventTypeFlags) -> Self { 624 skip_assert_initialized!(); 625 Self::from_bits_truncate(value) 626 } 627 } 628 629 impl StaticType for EventTypeFlags { static_type() -> Type630 fn static_type() -> Type { 631 unsafe { from_glib(ffi::gst_event_type_flags_get_type()) } 632 } 633 } 634 635 impl glib::value::ValueType for EventTypeFlags { 636 type Type = Self; 637 } 638 639 unsafe impl<'a> FromValue<'a> for EventTypeFlags { 640 type Checker = glib::value::GenericValueTypeChecker<Self>; 641 from_value(value: &'a glib::Value) -> Self642 unsafe fn from_value(value: &'a glib::Value) -> Self { 643 skip_assert_initialized!(); 644 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 645 } 646 } 647 648 impl ToValue for EventTypeFlags { to_value(&self) -> glib::Value649 fn to_value(&self) -> glib::Value { 650 let mut value = glib::Value::for_value_type::<Self>(); 651 unsafe { 652 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 653 } 654 value 655 } 656 value_type(&self) -> glib::Type657 fn value_type(&self) -> glib::Type { 658 Self::static_type() 659 } 660 } 661 662 #[cfg(any(feature = "v1_20", feature = "dox"))] 663 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 664 bitflags! { 665 #[doc(alias = "GstGapFlags")] 666 pub struct GapFlags: u32 { 667 #[doc(alias = "GST_GAP_FLAG_MISSING_DATA")] 668 const DATA = ffi::GST_GAP_FLAG_MISSING_DATA as u32; 669 } 670 } 671 672 #[cfg(any(feature = "v1_20", feature = "dox"))] 673 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 674 #[doc(hidden)] 675 impl IntoGlib for GapFlags { 676 type GlibType = ffi::GstGapFlags; 677 into_glib(self) -> ffi::GstGapFlags678 fn into_glib(self) -> ffi::GstGapFlags { 679 self.bits() 680 } 681 } 682 683 #[cfg(any(feature = "v1_20", feature = "dox"))] 684 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 685 #[doc(hidden)] 686 impl FromGlib<ffi::GstGapFlags> for GapFlags { from_glib(value: ffi::GstGapFlags) -> Self687 unsafe fn from_glib(value: ffi::GstGapFlags) -> Self { 688 skip_assert_initialized!(); 689 Self::from_bits_truncate(value) 690 } 691 } 692 693 #[cfg(any(feature = "v1_20", feature = "dox"))] 694 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 695 impl StaticType for GapFlags { static_type() -> Type696 fn static_type() -> Type { 697 unsafe { from_glib(ffi::gst_gap_flags_get_type()) } 698 } 699 } 700 701 #[cfg(any(feature = "v1_20", feature = "dox"))] 702 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 703 impl glib::value::ValueType for GapFlags { 704 type Type = Self; 705 } 706 707 #[cfg(any(feature = "v1_20", feature = "dox"))] 708 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 709 unsafe impl<'a> FromValue<'a> for GapFlags { 710 type Checker = glib::value::GenericValueTypeChecker<Self>; 711 from_value(value: &'a glib::Value) -> Self712 unsafe fn from_value(value: &'a glib::Value) -> Self { 713 skip_assert_initialized!(); 714 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 715 } 716 } 717 718 #[cfg(any(feature = "v1_20", feature = "dox"))] 719 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 720 impl ToValue for GapFlags { to_value(&self) -> glib::Value721 fn to_value(&self) -> glib::Value { 722 let mut value = glib::Value::for_value_type::<Self>(); 723 unsafe { 724 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 725 } 726 value 727 } 728 value_type(&self) -> glib::Type729 fn value_type(&self) -> glib::Type { 730 Self::static_type() 731 } 732 } 733 734 bitflags! { 735 #[doc(alias = "GstMemoryFlags")] 736 pub struct MemoryFlags: u32 { 737 #[doc(alias = "GST_MEMORY_FLAG_READONLY")] 738 const READONLY = ffi::GST_MEMORY_FLAG_READONLY as u32; 739 #[doc(alias = "GST_MEMORY_FLAG_NO_SHARE")] 740 const NO_SHARE = ffi::GST_MEMORY_FLAG_NO_SHARE as u32; 741 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PREFIXED")] 742 const ZERO_PREFIXED = ffi::GST_MEMORY_FLAG_ZERO_PREFIXED as u32; 743 #[doc(alias = "GST_MEMORY_FLAG_ZERO_PADDED")] 744 const ZERO_PADDED = ffi::GST_MEMORY_FLAG_ZERO_PADDED as u32; 745 #[doc(alias = "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS")] 746 const PHYSICALLY_CONTIGUOUS = ffi::GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS as u32; 747 #[doc(alias = "GST_MEMORY_FLAG_NOT_MAPPABLE")] 748 const NOT_MAPPABLE = ffi::GST_MEMORY_FLAG_NOT_MAPPABLE as u32; 749 } 750 } 751 752 #[doc(hidden)] 753 impl IntoGlib for MemoryFlags { 754 type GlibType = ffi::GstMemoryFlags; 755 into_glib(self) -> ffi::GstMemoryFlags756 fn into_glib(self) -> ffi::GstMemoryFlags { 757 self.bits() 758 } 759 } 760 761 #[doc(hidden)] 762 impl FromGlib<ffi::GstMemoryFlags> for MemoryFlags { from_glib(value: ffi::GstMemoryFlags) -> Self763 unsafe fn from_glib(value: ffi::GstMemoryFlags) -> Self { 764 skip_assert_initialized!(); 765 Self::from_bits_truncate(value) 766 } 767 } 768 769 impl StaticType for MemoryFlags { static_type() -> Type770 fn static_type() -> Type { 771 unsafe { from_glib(ffi::gst_memory_flags_get_type()) } 772 } 773 } 774 775 impl glib::value::ValueType for MemoryFlags { 776 type Type = Self; 777 } 778 779 unsafe impl<'a> FromValue<'a> for MemoryFlags { 780 type Checker = glib::value::GenericValueTypeChecker<Self>; 781 from_value(value: &'a glib::Value) -> Self782 unsafe fn from_value(value: &'a glib::Value) -> Self { 783 skip_assert_initialized!(); 784 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 785 } 786 } 787 788 impl ToValue for MemoryFlags { to_value(&self) -> glib::Value789 fn to_value(&self) -> glib::Value { 790 let mut value = glib::Value::for_value_type::<Self>(); 791 unsafe { 792 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 793 } 794 value 795 } 796 value_type(&self) -> glib::Type797 fn value_type(&self) -> glib::Type { 798 Self::static_type() 799 } 800 } 801 802 bitflags! { 803 #[doc(alias = "GstObjectFlags")] 804 pub struct ObjectFlags: u32 { 805 #[cfg(any(feature = "v1_10", feature = "dox"))] 806 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 807 #[doc(alias = "GST_OBJECT_FLAG_MAY_BE_LEAKED")] 808 const MAY_BE_LEAKED = ffi::GST_OBJECT_FLAG_MAY_BE_LEAKED as u32; 809 } 810 } 811 812 #[doc(hidden)] 813 impl IntoGlib for ObjectFlags { 814 type GlibType = ffi::GstObjectFlags; 815 into_glib(self) -> ffi::GstObjectFlags816 fn into_glib(self) -> ffi::GstObjectFlags { 817 self.bits() 818 } 819 } 820 821 #[doc(hidden)] 822 impl FromGlib<ffi::GstObjectFlags> for ObjectFlags { from_glib(value: ffi::GstObjectFlags) -> Self823 unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self { 824 skip_assert_initialized!(); 825 Self::from_bits_truncate(value) 826 } 827 } 828 829 impl StaticType for ObjectFlags { static_type() -> Type830 fn static_type() -> Type { 831 unsafe { from_glib(ffi::gst_object_flags_get_type()) } 832 } 833 } 834 835 impl glib::value::ValueType for ObjectFlags { 836 type Type = Self; 837 } 838 839 unsafe impl<'a> FromValue<'a> for ObjectFlags { 840 type Checker = glib::value::GenericValueTypeChecker<Self>; 841 from_value(value: &'a glib::Value) -> Self842 unsafe fn from_value(value: &'a glib::Value) -> Self { 843 skip_assert_initialized!(); 844 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 845 } 846 } 847 848 impl ToValue for ObjectFlags { to_value(&self) -> glib::Value849 fn to_value(&self) -> glib::Value { 850 let mut value = glib::Value::for_value_type::<Self>(); 851 unsafe { 852 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 853 } 854 value 855 } 856 value_type(&self) -> glib::Type857 fn value_type(&self) -> glib::Type { 858 Self::static_type() 859 } 860 } 861 862 bitflags! { 863 #[doc(alias = "GstPadFlags")] 864 pub struct PadFlags: u32 { 865 #[doc(alias = "GST_PAD_FLAG_BLOCKED")] 866 const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as u32; 867 #[doc(alias = "GST_PAD_FLAG_FLUSHING")] 868 const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as u32; 869 #[doc(alias = "GST_PAD_FLAG_EOS")] 870 const EOS = ffi::GST_PAD_FLAG_EOS as u32; 871 #[doc(alias = "GST_PAD_FLAG_BLOCKING")] 872 const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as u32; 873 #[doc(alias = "GST_PAD_FLAG_NEED_PARENT")] 874 const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as u32; 875 #[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")] 876 const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as u32; 877 #[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")] 878 const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as u32; 879 #[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")] 880 const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as u32; 881 #[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")] 882 const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as u32; 883 #[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")] 884 const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as u32; 885 #[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")] 886 const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as u32; 887 #[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")] 888 const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as u32; 889 #[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")] 890 const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as u32; 891 } 892 } 893 894 #[doc(hidden)] 895 impl IntoGlib for PadFlags { 896 type GlibType = ffi::GstPadFlags; 897 into_glib(self) -> ffi::GstPadFlags898 fn into_glib(self) -> ffi::GstPadFlags { 899 self.bits() 900 } 901 } 902 903 #[doc(hidden)] 904 impl FromGlib<ffi::GstPadFlags> for PadFlags { from_glib(value: ffi::GstPadFlags) -> Self905 unsafe fn from_glib(value: ffi::GstPadFlags) -> Self { 906 skip_assert_initialized!(); 907 Self::from_bits_truncate(value) 908 } 909 } 910 911 impl StaticType for PadFlags { static_type() -> Type912 fn static_type() -> Type { 913 unsafe { from_glib(ffi::gst_pad_flags_get_type()) } 914 } 915 } 916 917 impl glib::value::ValueType for PadFlags { 918 type Type = Self; 919 } 920 921 unsafe impl<'a> FromValue<'a> for PadFlags { 922 type Checker = glib::value::GenericValueTypeChecker<Self>; 923 from_value(value: &'a glib::Value) -> Self924 unsafe fn from_value(value: &'a glib::Value) -> Self { 925 skip_assert_initialized!(); 926 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 927 } 928 } 929 930 impl ToValue for PadFlags { to_value(&self) -> glib::Value931 fn to_value(&self) -> glib::Value { 932 let mut value = glib::Value::for_value_type::<Self>(); 933 unsafe { 934 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 935 } 936 value 937 } 938 value_type(&self) -> glib::Type939 fn value_type(&self) -> glib::Type { 940 Self::static_type() 941 } 942 } 943 944 bitflags! { 945 #[doc(alias = "GstPadLinkCheck")] 946 pub struct PadLinkCheck: u32 { 947 #[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")] 948 const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as u32; 949 #[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")] 950 const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as u32; 951 #[doc(alias = "GST_PAD_LINK_CHECK_CAPS")] 952 const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as u32; 953 #[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")] 954 const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as u32; 955 #[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")] 956 const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as u32; 957 } 958 } 959 960 #[doc(hidden)] 961 impl IntoGlib for PadLinkCheck { 962 type GlibType = ffi::GstPadLinkCheck; 963 into_glib(self) -> ffi::GstPadLinkCheck964 fn into_glib(self) -> ffi::GstPadLinkCheck { 965 self.bits() 966 } 967 } 968 969 #[doc(hidden)] 970 impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck { from_glib(value: ffi::GstPadLinkCheck) -> Self971 unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self { 972 skip_assert_initialized!(); 973 Self::from_bits_truncate(value) 974 } 975 } 976 977 impl StaticType for PadLinkCheck { static_type() -> Type978 fn static_type() -> Type { 979 unsafe { from_glib(ffi::gst_pad_link_check_get_type()) } 980 } 981 } 982 983 impl glib::value::ValueType for PadLinkCheck { 984 type Type = Self; 985 } 986 987 unsafe impl<'a> FromValue<'a> for PadLinkCheck { 988 type Checker = glib::value::GenericValueTypeChecker<Self>; 989 from_value(value: &'a glib::Value) -> Self990 unsafe fn from_value(value: &'a glib::Value) -> Self { 991 skip_assert_initialized!(); 992 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 993 } 994 } 995 996 impl ToValue for PadLinkCheck { to_value(&self) -> glib::Value997 fn to_value(&self) -> glib::Value { 998 let mut value = glib::Value::for_value_type::<Self>(); 999 unsafe { 1000 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1001 } 1002 value 1003 } 1004 value_type(&self) -> glib::Type1005 fn value_type(&self) -> glib::Type { 1006 Self::static_type() 1007 } 1008 } 1009 1010 bitflags! { 1011 #[doc(alias = "GstPadProbeType")] 1012 pub struct PadProbeType: u32 { 1013 #[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")] 1014 const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as u32; 1015 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")] 1016 const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as u32; 1017 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")] 1018 const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as u32; 1019 #[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")] 1020 const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as u32; 1021 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")] 1022 const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as u32; 1023 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")] 1024 const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as u32; 1025 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")] 1026 const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as u32; 1027 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")] 1028 const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as u32; 1029 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")] 1030 const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as u32; 1031 #[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")] 1032 const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as u32; 1033 #[doc(alias = "GST_PAD_PROBE_TYPE_PULL")] 1034 const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as u32; 1035 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")] 1036 const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as u32; 1037 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")] 1038 const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as u32; 1039 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")] 1040 const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as u32; 1041 #[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")] 1042 const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as u32; 1043 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")] 1044 const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as u32; 1045 #[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")] 1046 const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as u32; 1047 #[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")] 1048 const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as u32; 1049 #[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")] 1050 const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as u32; 1051 #[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")] 1052 const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as u32; 1053 #[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")] 1054 const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as u32; 1055 } 1056 } 1057 1058 #[doc(hidden)] 1059 impl IntoGlib for PadProbeType { 1060 type GlibType = ffi::GstPadProbeType; 1061 into_glib(self) -> ffi::GstPadProbeType1062 fn into_glib(self) -> ffi::GstPadProbeType { 1063 self.bits() 1064 } 1065 } 1066 1067 #[doc(hidden)] 1068 impl FromGlib<ffi::GstPadProbeType> for PadProbeType { from_glib(value: ffi::GstPadProbeType) -> Self1069 unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self { 1070 skip_assert_initialized!(); 1071 Self::from_bits_truncate(value) 1072 } 1073 } 1074 1075 impl StaticType for PadProbeType { static_type() -> Type1076 fn static_type() -> Type { 1077 unsafe { from_glib(ffi::gst_pad_probe_type_get_type()) } 1078 } 1079 } 1080 1081 impl glib::value::ValueType for PadProbeType { 1082 type Type = Self; 1083 } 1084 1085 unsafe impl<'a> FromValue<'a> for PadProbeType { 1086 type Checker = glib::value::GenericValueTypeChecker<Self>; 1087 from_value(value: &'a glib::Value) -> Self1088 unsafe fn from_value(value: &'a glib::Value) -> Self { 1089 skip_assert_initialized!(); 1090 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1091 } 1092 } 1093 1094 impl ToValue for PadProbeType { to_value(&self) -> glib::Value1095 fn to_value(&self) -> glib::Value { 1096 let mut value = glib::Value::for_value_type::<Self>(); 1097 unsafe { 1098 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1099 } 1100 value 1101 } 1102 value_type(&self) -> glib::Type1103 fn value_type(&self) -> glib::Type { 1104 Self::static_type() 1105 } 1106 } 1107 1108 bitflags! { 1109 #[doc(alias = "GstParseFlags")] 1110 pub struct ParseFlags: u32 { 1111 #[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")] 1112 const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as u32; 1113 #[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")] 1114 const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as u32; 1115 #[cfg(any(feature = "v1_10", feature = "dox"))] 1116 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1117 #[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")] 1118 const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as u32; 1119 } 1120 } 1121 1122 #[doc(hidden)] 1123 impl IntoGlib for ParseFlags { 1124 type GlibType = ffi::GstParseFlags; 1125 into_glib(self) -> ffi::GstParseFlags1126 fn into_glib(self) -> ffi::GstParseFlags { 1127 self.bits() 1128 } 1129 } 1130 1131 #[doc(hidden)] 1132 impl FromGlib<ffi::GstParseFlags> for ParseFlags { from_glib(value: ffi::GstParseFlags) -> Self1133 unsafe fn from_glib(value: ffi::GstParseFlags) -> Self { 1134 skip_assert_initialized!(); 1135 Self::from_bits_truncate(value) 1136 } 1137 } 1138 1139 impl StaticType for ParseFlags { static_type() -> Type1140 fn static_type() -> Type { 1141 unsafe { from_glib(ffi::gst_parse_flags_get_type()) } 1142 } 1143 } 1144 1145 impl glib::value::ValueType for ParseFlags { 1146 type Type = Self; 1147 } 1148 1149 unsafe impl<'a> FromValue<'a> for ParseFlags { 1150 type Checker = glib::value::GenericValueTypeChecker<Self>; 1151 from_value(value: &'a glib::Value) -> Self1152 unsafe fn from_value(value: &'a glib::Value) -> Self { 1153 skip_assert_initialized!(); 1154 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1155 } 1156 } 1157 1158 impl ToValue for ParseFlags { to_value(&self) -> glib::Value1159 fn to_value(&self) -> glib::Value { 1160 let mut value = glib::Value::for_value_type::<Self>(); 1161 unsafe { 1162 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1163 } 1164 value 1165 } 1166 value_type(&self) -> glib::Type1167 fn value_type(&self) -> glib::Type { 1168 Self::static_type() 1169 } 1170 } 1171 1172 bitflags! { 1173 #[doc(alias = "GstPipelineFlags")] 1174 pub struct PipelineFlags: u32 { 1175 #[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")] 1176 const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as u32; 1177 } 1178 } 1179 1180 #[doc(hidden)] 1181 impl IntoGlib for PipelineFlags { 1182 type GlibType = ffi::GstPipelineFlags; 1183 into_glib(self) -> ffi::GstPipelineFlags1184 fn into_glib(self) -> ffi::GstPipelineFlags { 1185 self.bits() 1186 } 1187 } 1188 1189 #[doc(hidden)] 1190 impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags { from_glib(value: ffi::GstPipelineFlags) -> Self1191 unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self { 1192 skip_assert_initialized!(); 1193 Self::from_bits_truncate(value) 1194 } 1195 } 1196 1197 impl StaticType for PipelineFlags { static_type() -> Type1198 fn static_type() -> Type { 1199 unsafe { from_glib(ffi::gst_pipeline_flags_get_type()) } 1200 } 1201 } 1202 1203 impl glib::value::ValueType for PipelineFlags { 1204 type Type = Self; 1205 } 1206 1207 unsafe impl<'a> FromValue<'a> for PipelineFlags { 1208 type Checker = glib::value::GenericValueTypeChecker<Self>; 1209 from_value(value: &'a glib::Value) -> Self1210 unsafe fn from_value(value: &'a glib::Value) -> Self { 1211 skip_assert_initialized!(); 1212 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1213 } 1214 } 1215 1216 impl ToValue for PipelineFlags { to_value(&self) -> glib::Value1217 fn to_value(&self) -> glib::Value { 1218 let mut value = glib::Value::for_value_type::<Self>(); 1219 unsafe { 1220 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1221 } 1222 value 1223 } 1224 value_type(&self) -> glib::Type1225 fn value_type(&self) -> glib::Type { 1226 Self::static_type() 1227 } 1228 } 1229 1230 #[cfg(any(feature = "v1_18", feature = "dox"))] 1231 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1232 bitflags! { 1233 #[doc(alias = "GstPluginAPIFlags")] 1234 pub struct PluginAPIFlags: u32 { 1235 #[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")] 1236 const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as u32; 1237 } 1238 } 1239 1240 #[cfg(any(feature = "v1_18", feature = "dox"))] 1241 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1242 #[doc(hidden)] 1243 impl IntoGlib for PluginAPIFlags { 1244 type GlibType = ffi::GstPluginAPIFlags; 1245 into_glib(self) -> ffi::GstPluginAPIFlags1246 fn into_glib(self) -> ffi::GstPluginAPIFlags { 1247 self.bits() 1248 } 1249 } 1250 1251 #[cfg(any(feature = "v1_18", feature = "dox"))] 1252 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1253 #[doc(hidden)] 1254 impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags { from_glib(value: ffi::GstPluginAPIFlags) -> Self1255 unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self { 1256 skip_assert_initialized!(); 1257 Self::from_bits_truncate(value) 1258 } 1259 } 1260 1261 #[cfg(any(feature = "v1_18", feature = "dox"))] 1262 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1263 impl StaticType for PluginAPIFlags { static_type() -> Type1264 fn static_type() -> Type { 1265 unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) } 1266 } 1267 } 1268 1269 #[cfg(any(feature = "v1_18", feature = "dox"))] 1270 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1271 impl glib::value::ValueType for PluginAPIFlags { 1272 type Type = Self; 1273 } 1274 1275 #[cfg(any(feature = "v1_18", feature = "dox"))] 1276 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1277 unsafe impl<'a> FromValue<'a> for PluginAPIFlags { 1278 type Checker = glib::value::GenericValueTypeChecker<Self>; 1279 from_value(value: &'a glib::Value) -> Self1280 unsafe fn from_value(value: &'a glib::Value) -> Self { 1281 skip_assert_initialized!(); 1282 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1283 } 1284 } 1285 1286 #[cfg(any(feature = "v1_18", feature = "dox"))] 1287 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1288 impl ToValue for PluginAPIFlags { to_value(&self) -> glib::Value1289 fn to_value(&self) -> glib::Value { 1290 let mut value = glib::Value::for_value_type::<Self>(); 1291 unsafe { 1292 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1293 } 1294 value 1295 } 1296 value_type(&self) -> glib::Type1297 fn value_type(&self) -> glib::Type { 1298 Self::static_type() 1299 } 1300 } 1301 1302 bitflags! { 1303 #[doc(alias = "GstPluginDependencyFlags")] 1304 pub struct PluginDependencyFlags: u32 { 1305 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")] 1306 const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as u32; 1307 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")] 1308 const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as u32; 1309 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")] 1310 const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as u32; 1311 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")] 1312 const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as u32; 1313 #[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")] 1314 const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as u32; 1315 } 1316 } 1317 1318 #[doc(hidden)] 1319 impl IntoGlib for PluginDependencyFlags { 1320 type GlibType = ffi::GstPluginDependencyFlags; 1321 into_glib(self) -> ffi::GstPluginDependencyFlags1322 fn into_glib(self) -> ffi::GstPluginDependencyFlags { 1323 self.bits() 1324 } 1325 } 1326 1327 #[doc(hidden)] 1328 impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags { from_glib(value: ffi::GstPluginDependencyFlags) -> Self1329 unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self { 1330 skip_assert_initialized!(); 1331 Self::from_bits_truncate(value) 1332 } 1333 } 1334 1335 impl StaticType for PluginDependencyFlags { static_type() -> Type1336 fn static_type() -> Type { 1337 unsafe { from_glib(ffi::gst_plugin_dependency_flags_get_type()) } 1338 } 1339 } 1340 1341 impl glib::value::ValueType for PluginDependencyFlags { 1342 type Type = Self; 1343 } 1344 1345 unsafe impl<'a> FromValue<'a> for PluginDependencyFlags { 1346 type Checker = glib::value::GenericValueTypeChecker<Self>; 1347 from_value(value: &'a glib::Value) -> Self1348 unsafe fn from_value(value: &'a glib::Value) -> Self { 1349 skip_assert_initialized!(); 1350 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1351 } 1352 } 1353 1354 impl ToValue for PluginDependencyFlags { to_value(&self) -> glib::Value1355 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 value_type(&self) -> glib::Type1363 fn value_type(&self) -> glib::Type { 1364 Self::static_type() 1365 } 1366 } 1367 1368 bitflags! { 1369 #[doc(alias = "GstPluginFlags")] 1370 pub struct PluginFlags: u32 { 1371 #[doc(alias = "GST_PLUGIN_FLAG_CACHED")] 1372 const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as u32; 1373 #[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")] 1374 const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as u32; 1375 } 1376 } 1377 1378 #[doc(hidden)] 1379 impl IntoGlib for PluginFlags { 1380 type GlibType = ffi::GstPluginFlags; 1381 into_glib(self) -> ffi::GstPluginFlags1382 fn into_glib(self) -> ffi::GstPluginFlags { 1383 self.bits() 1384 } 1385 } 1386 1387 #[doc(hidden)] 1388 impl FromGlib<ffi::GstPluginFlags> for PluginFlags { from_glib(value: ffi::GstPluginFlags) -> Self1389 unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self { 1390 skip_assert_initialized!(); 1391 Self::from_bits_truncate(value) 1392 } 1393 } 1394 1395 impl StaticType for PluginFlags { static_type() -> Type1396 fn static_type() -> Type { 1397 unsafe { from_glib(ffi::gst_plugin_flags_get_type()) } 1398 } 1399 } 1400 1401 impl glib::value::ValueType for PluginFlags { 1402 type Type = Self; 1403 } 1404 1405 unsafe impl<'a> FromValue<'a> for PluginFlags { 1406 type Checker = glib::value::GenericValueTypeChecker<Self>; 1407 from_value(value: &'a glib::Value) -> Self1408 unsafe fn from_value(value: &'a glib::Value) -> Self { 1409 skip_assert_initialized!(); 1410 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1411 } 1412 } 1413 1414 impl ToValue for PluginFlags { to_value(&self) -> glib::Value1415 fn to_value(&self) -> glib::Value { 1416 let mut value = glib::Value::for_value_type::<Self>(); 1417 unsafe { 1418 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1419 } 1420 value 1421 } 1422 value_type(&self) -> glib::Type1423 fn value_type(&self) -> glib::Type { 1424 Self::static_type() 1425 } 1426 } 1427 1428 bitflags! { 1429 #[doc(alias = "GstSchedulingFlags")] 1430 pub struct SchedulingFlags: u32 { 1431 #[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")] 1432 const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as u32; 1433 #[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")] 1434 const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as u32; 1435 #[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")] 1436 const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as u32; 1437 } 1438 } 1439 1440 #[doc(hidden)] 1441 impl IntoGlib for SchedulingFlags { 1442 type GlibType = ffi::GstSchedulingFlags; 1443 into_glib(self) -> ffi::GstSchedulingFlags1444 fn into_glib(self) -> ffi::GstSchedulingFlags { 1445 self.bits() 1446 } 1447 } 1448 1449 #[doc(hidden)] 1450 impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags { from_glib(value: ffi::GstSchedulingFlags) -> Self1451 unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self { 1452 skip_assert_initialized!(); 1453 Self::from_bits_truncate(value) 1454 } 1455 } 1456 1457 impl StaticType for SchedulingFlags { static_type() -> Type1458 fn static_type() -> Type { 1459 unsafe { from_glib(ffi::gst_scheduling_flags_get_type()) } 1460 } 1461 } 1462 1463 impl glib::value::ValueType for SchedulingFlags { 1464 type Type = Self; 1465 } 1466 1467 unsafe impl<'a> FromValue<'a> for SchedulingFlags { 1468 type Checker = glib::value::GenericValueTypeChecker<Self>; 1469 from_value(value: &'a glib::Value) -> Self1470 unsafe fn from_value(value: &'a glib::Value) -> Self { 1471 skip_assert_initialized!(); 1472 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1473 } 1474 } 1475 1476 impl ToValue for SchedulingFlags { to_value(&self) -> glib::Value1477 fn to_value(&self) -> glib::Value { 1478 let mut value = glib::Value::for_value_type::<Self>(); 1479 unsafe { 1480 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1481 } 1482 value 1483 } 1484 value_type(&self) -> glib::Type1485 fn value_type(&self) -> glib::Type { 1486 Self::static_type() 1487 } 1488 } 1489 1490 bitflags! { 1491 #[doc(alias = "GstSeekFlags")] 1492 pub struct SeekFlags: u32 { 1493 #[doc(alias = "GST_SEEK_FLAG_FLUSH")] 1494 const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as u32; 1495 #[doc(alias = "GST_SEEK_FLAG_ACCURATE")] 1496 const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as u32; 1497 #[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")] 1498 const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as u32; 1499 #[doc(alias = "GST_SEEK_FLAG_SEGMENT")] 1500 const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as u32; 1501 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE")] 1502 const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as u32; 1503 #[doc(alias = "GST_SEEK_FLAG_SKIP")] 1504 const SKIP = ffi::GST_SEEK_FLAG_SKIP as u32; 1505 #[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")] 1506 const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as u32; 1507 #[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")] 1508 const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as u32; 1509 #[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")] 1510 const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as u32; 1511 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")] 1512 const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as u32; 1513 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")] 1514 const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as u32; 1515 #[cfg(any(feature = "v1_18", feature = "dox"))] 1516 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1517 #[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")] 1518 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as u32; 1519 #[cfg(any(feature = "v1_18", feature = "dox"))] 1520 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1521 #[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")] 1522 const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as u32; 1523 } 1524 } 1525 1526 #[doc(hidden)] 1527 impl IntoGlib for SeekFlags { 1528 type GlibType = ffi::GstSeekFlags; 1529 into_glib(self) -> ffi::GstSeekFlags1530 fn into_glib(self) -> ffi::GstSeekFlags { 1531 self.bits() 1532 } 1533 } 1534 1535 #[doc(hidden)] 1536 impl FromGlib<ffi::GstSeekFlags> for SeekFlags { from_glib(value: ffi::GstSeekFlags) -> Self1537 unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self { 1538 skip_assert_initialized!(); 1539 Self::from_bits_truncate(value) 1540 } 1541 } 1542 1543 impl StaticType for SeekFlags { static_type() -> Type1544 fn static_type() -> Type { 1545 unsafe { from_glib(ffi::gst_seek_flags_get_type()) } 1546 } 1547 } 1548 1549 impl glib::value::ValueType for SeekFlags { 1550 type Type = Self; 1551 } 1552 1553 unsafe impl<'a> FromValue<'a> for SeekFlags { 1554 type Checker = glib::value::GenericValueTypeChecker<Self>; 1555 from_value(value: &'a glib::Value) -> Self1556 unsafe fn from_value(value: &'a glib::Value) -> Self { 1557 skip_assert_initialized!(); 1558 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1559 } 1560 } 1561 1562 impl ToValue for SeekFlags { to_value(&self) -> glib::Value1563 fn to_value(&self) -> glib::Value { 1564 let mut value = glib::Value::for_value_type::<Self>(); 1565 unsafe { 1566 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1567 } 1568 value 1569 } 1570 value_type(&self) -> glib::Type1571 fn value_type(&self) -> glib::Type { 1572 Self::static_type() 1573 } 1574 } 1575 1576 bitflags! { 1577 #[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))] 1578 #[doc(alias = "GstSegmentFlags")] 1579 pub struct SegmentFlags: u32 { 1580 #[doc(alias = "GST_SEGMENT_FLAG_RESET")] 1581 const RESET = ffi::GST_SEGMENT_FLAG_RESET as u32; 1582 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")] 1583 const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as u32; 1584 #[doc(alias = "GST_SEGMENT_FLAG_SKIP")] 1585 const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as u32; 1586 #[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")] 1587 const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as u32; 1588 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")] 1589 const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as u32; 1590 #[cfg(any(feature = "v1_18", feature = "dox"))] 1591 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] 1592 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")] 1593 const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as u32; 1594 #[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")] 1595 const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as u32; 1596 } 1597 } 1598 1599 #[doc(hidden)] 1600 impl IntoGlib for SegmentFlags { 1601 type GlibType = ffi::GstSegmentFlags; 1602 into_glib(self) -> ffi::GstSegmentFlags1603 fn into_glib(self) -> ffi::GstSegmentFlags { 1604 self.bits() 1605 } 1606 } 1607 1608 #[doc(hidden)] 1609 impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags { from_glib(value: ffi::GstSegmentFlags) -> Self1610 unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self { 1611 skip_assert_initialized!(); 1612 Self::from_bits_truncate(value) 1613 } 1614 } 1615 1616 impl StaticType for SegmentFlags { static_type() -> Type1617 fn static_type() -> Type { 1618 unsafe { from_glib(ffi::gst_segment_flags_get_type()) } 1619 } 1620 } 1621 1622 impl glib::value::ValueType for SegmentFlags { 1623 type Type = Self; 1624 } 1625 1626 unsafe impl<'a> FromValue<'a> for SegmentFlags { 1627 type Checker = glib::value::GenericValueTypeChecker<Self>; 1628 from_value(value: &'a glib::Value) -> Self1629 unsafe fn from_value(value: &'a glib::Value) -> Self { 1630 skip_assert_initialized!(); 1631 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1632 } 1633 } 1634 1635 impl ToValue for SegmentFlags { to_value(&self) -> glib::Value1636 fn to_value(&self) -> glib::Value { 1637 let mut value = glib::Value::for_value_type::<Self>(); 1638 unsafe { 1639 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1640 } 1641 value 1642 } 1643 value_type(&self) -> glib::Type1644 fn value_type(&self) -> glib::Type { 1645 Self::static_type() 1646 } 1647 } 1648 1649 #[cfg(any(feature = "v1_20", feature = "dox"))] 1650 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1651 bitflags! { 1652 #[doc(alias = "GstSerializeFlags")] 1653 pub struct SerializeFlags: u32 { 1654 #[doc(alias = "GST_SERIALIZE_FLAG_NONE")] 1655 const NONE = ffi::GST_SERIALIZE_FLAG_NONE as u32; 1656 #[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")] 1657 const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as u32; 1658 } 1659 } 1660 1661 #[cfg(any(feature = "v1_20", feature = "dox"))] 1662 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1663 #[doc(hidden)] 1664 impl IntoGlib for SerializeFlags { 1665 type GlibType = ffi::GstSerializeFlags; 1666 into_glib(self) -> ffi::GstSerializeFlags1667 fn into_glib(self) -> ffi::GstSerializeFlags { 1668 self.bits() 1669 } 1670 } 1671 1672 #[cfg(any(feature = "v1_20", feature = "dox"))] 1673 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1674 #[doc(hidden)] 1675 impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags { from_glib(value: ffi::GstSerializeFlags) -> Self1676 unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self { 1677 skip_assert_initialized!(); 1678 Self::from_bits_truncate(value) 1679 } 1680 } 1681 1682 #[cfg(any(feature = "v1_20", feature = "dox"))] 1683 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1684 impl StaticType for SerializeFlags { static_type() -> Type1685 fn static_type() -> Type { 1686 unsafe { from_glib(ffi::gst_serialize_flags_get_type()) } 1687 } 1688 } 1689 1690 #[cfg(any(feature = "v1_20", feature = "dox"))] 1691 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1692 impl glib::value::ValueType for SerializeFlags { 1693 type Type = Self; 1694 } 1695 1696 #[cfg(any(feature = "v1_20", feature = "dox"))] 1697 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1698 unsafe impl<'a> FromValue<'a> for SerializeFlags { 1699 type Checker = glib::value::GenericValueTypeChecker<Self>; 1700 from_value(value: &'a glib::Value) -> Self1701 unsafe fn from_value(value: &'a glib::Value) -> Self { 1702 skip_assert_initialized!(); 1703 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1704 } 1705 } 1706 1707 #[cfg(any(feature = "v1_20", feature = "dox"))] 1708 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))] 1709 impl ToValue for SerializeFlags { to_value(&self) -> glib::Value1710 fn to_value(&self) -> glib::Value { 1711 let mut value = glib::Value::for_value_type::<Self>(); 1712 unsafe { 1713 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1714 } 1715 value 1716 } 1717 value_type(&self) -> glib::Type1718 fn value_type(&self) -> glib::Type { 1719 Self::static_type() 1720 } 1721 } 1722 1723 #[cfg(any(feature = "v1_12", feature = "dox"))] 1724 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1725 bitflags! { 1726 #[doc(alias = "GstStackTraceFlags")] 1727 pub struct StackTraceFlags: u32 { 1728 #[doc(alias = "GST_STACK_TRACE_SHOW_FULL")] 1729 const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as u32; 1730 } 1731 } 1732 1733 #[cfg(any(feature = "v1_12", feature = "dox"))] 1734 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1735 #[doc(hidden)] 1736 impl IntoGlib for StackTraceFlags { 1737 type GlibType = ffi::GstStackTraceFlags; 1738 into_glib(self) -> ffi::GstStackTraceFlags1739 fn into_glib(self) -> ffi::GstStackTraceFlags { 1740 self.bits() 1741 } 1742 } 1743 1744 #[cfg(any(feature = "v1_12", feature = "dox"))] 1745 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1746 #[doc(hidden)] 1747 impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags { from_glib(value: ffi::GstStackTraceFlags) -> Self1748 unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self { 1749 skip_assert_initialized!(); 1750 Self::from_bits_truncate(value) 1751 } 1752 } 1753 1754 #[cfg(any(feature = "v1_12", feature = "dox"))] 1755 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1756 impl StaticType for StackTraceFlags { static_type() -> Type1757 fn static_type() -> Type { 1758 unsafe { from_glib(ffi::gst_stack_trace_flags_get_type()) } 1759 } 1760 } 1761 1762 #[cfg(any(feature = "v1_12", feature = "dox"))] 1763 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1764 impl glib::value::ValueType for StackTraceFlags { 1765 type Type = Self; 1766 } 1767 1768 #[cfg(any(feature = "v1_12", feature = "dox"))] 1769 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1770 unsafe impl<'a> FromValue<'a> for StackTraceFlags { 1771 type Checker = glib::value::GenericValueTypeChecker<Self>; 1772 from_value(value: &'a glib::Value) -> Self1773 unsafe fn from_value(value: &'a glib::Value) -> Self { 1774 skip_assert_initialized!(); 1775 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1776 } 1777 } 1778 1779 #[cfg(any(feature = "v1_12", feature = "dox"))] 1780 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))] 1781 impl ToValue for StackTraceFlags { to_value(&self) -> glib::Value1782 fn to_value(&self) -> glib::Value { 1783 let mut value = glib::Value::for_value_type::<Self>(); 1784 unsafe { 1785 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1786 } 1787 value 1788 } 1789 value_type(&self) -> glib::Type1790 fn value_type(&self) -> glib::Type { 1791 Self::static_type() 1792 } 1793 } 1794 1795 bitflags! { 1796 #[doc(alias = "GstStreamFlags")] 1797 pub struct StreamFlags: u32 { 1798 #[doc(alias = "GST_STREAM_FLAG_SPARSE")] 1799 const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as u32; 1800 #[doc(alias = "GST_STREAM_FLAG_SELECT")] 1801 const SELECT = ffi::GST_STREAM_FLAG_SELECT as u32; 1802 #[doc(alias = "GST_STREAM_FLAG_UNSELECT")] 1803 const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as u32; 1804 } 1805 } 1806 1807 #[doc(hidden)] 1808 impl IntoGlib for StreamFlags { 1809 type GlibType = ffi::GstStreamFlags; 1810 into_glib(self) -> ffi::GstStreamFlags1811 fn into_glib(self) -> ffi::GstStreamFlags { 1812 self.bits() 1813 } 1814 } 1815 1816 #[doc(hidden)] 1817 impl FromGlib<ffi::GstStreamFlags> for StreamFlags { from_glib(value: ffi::GstStreamFlags) -> Self1818 unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self { 1819 skip_assert_initialized!(); 1820 Self::from_bits_truncate(value) 1821 } 1822 } 1823 1824 impl StaticType for StreamFlags { static_type() -> Type1825 fn static_type() -> Type { 1826 unsafe { from_glib(ffi::gst_stream_flags_get_type()) } 1827 } 1828 } 1829 1830 impl glib::value::ValueType for StreamFlags { 1831 type Type = Self; 1832 } 1833 1834 unsafe impl<'a> FromValue<'a> for StreamFlags { 1835 type Checker = glib::value::GenericValueTypeChecker<Self>; 1836 from_value(value: &'a glib::Value) -> Self1837 unsafe fn from_value(value: &'a glib::Value) -> Self { 1838 skip_assert_initialized!(); 1839 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1840 } 1841 } 1842 1843 impl ToValue for StreamFlags { to_value(&self) -> glib::Value1844 fn to_value(&self) -> glib::Value { 1845 let mut value = glib::Value::for_value_type::<Self>(); 1846 unsafe { 1847 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1848 } 1849 value 1850 } 1851 value_type(&self) -> glib::Type1852 fn value_type(&self) -> glib::Type { 1853 Self::static_type() 1854 } 1855 } 1856 1857 #[cfg(any(feature = "v1_10", feature = "dox"))] 1858 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1859 bitflags! { 1860 #[doc(alias = "GstStreamType")] 1861 pub struct StreamType: u32 { 1862 #[doc(alias = "GST_STREAM_TYPE_UNKNOWN")] 1863 const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as u32; 1864 #[doc(alias = "GST_STREAM_TYPE_AUDIO")] 1865 const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as u32; 1866 #[doc(alias = "GST_STREAM_TYPE_VIDEO")] 1867 const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as u32; 1868 #[doc(alias = "GST_STREAM_TYPE_CONTAINER")] 1869 const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as u32; 1870 #[doc(alias = "GST_STREAM_TYPE_TEXT")] 1871 const TEXT = ffi::GST_STREAM_TYPE_TEXT as u32; 1872 } 1873 } 1874 1875 #[cfg(any(feature = "v1_10", feature = "dox"))] 1876 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1877 impl StreamType { name<'a>(self) -> &'a str1878 pub fn name<'a>(self) -> &'a str { 1879 unsafe { 1880 CStr::from_ptr( 1881 ffi::gst_stream_type_get_name(self.into_glib()) 1882 .as_ref() 1883 .expect("gst_stream_type_get_name returned NULL"), 1884 ) 1885 .to_str() 1886 .expect("gst_stream_type_get_name returned an invalid string") 1887 } 1888 } 1889 } 1890 1891 #[cfg(any(feature = "v1_10", feature = "dox"))] 1892 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1893 impl fmt::Display for StreamType { 1894 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1895 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1896 f.write_str(&self.name()) 1897 } 1898 } 1899 1900 #[cfg(any(feature = "v1_10", feature = "dox"))] 1901 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1902 #[doc(hidden)] 1903 impl IntoGlib for StreamType { 1904 type GlibType = ffi::GstStreamType; 1905 into_glib(self) -> ffi::GstStreamType1906 fn into_glib(self) -> ffi::GstStreamType { 1907 self.bits() 1908 } 1909 } 1910 1911 #[cfg(any(feature = "v1_10", feature = "dox"))] 1912 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1913 #[doc(hidden)] 1914 impl FromGlib<ffi::GstStreamType> for StreamType { from_glib(value: ffi::GstStreamType) -> Self1915 unsafe fn from_glib(value: ffi::GstStreamType) -> Self { 1916 skip_assert_initialized!(); 1917 Self::from_bits_truncate(value) 1918 } 1919 } 1920 1921 #[cfg(any(feature = "v1_10", feature = "dox"))] 1922 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1923 impl StaticType for StreamType { static_type() -> Type1924 fn static_type() -> Type { 1925 unsafe { from_glib(ffi::gst_stream_type_get_type()) } 1926 } 1927 } 1928 1929 #[cfg(any(feature = "v1_10", feature = "dox"))] 1930 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1931 impl glib::value::ValueType for StreamType { 1932 type Type = Self; 1933 } 1934 1935 #[cfg(any(feature = "v1_10", feature = "dox"))] 1936 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1937 unsafe impl<'a> FromValue<'a> for StreamType { 1938 type Checker = glib::value::GenericValueTypeChecker<Self>; 1939 from_value(value: &'a glib::Value) -> Self1940 unsafe fn from_value(value: &'a glib::Value) -> Self { 1941 skip_assert_initialized!(); 1942 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1943 } 1944 } 1945 1946 #[cfg(any(feature = "v1_10", feature = "dox"))] 1947 #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] 1948 impl ToValue for StreamType { to_value(&self) -> glib::Value1949 fn to_value(&self) -> glib::Value { 1950 let mut value = glib::Value::for_value_type::<Self>(); 1951 unsafe { 1952 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1953 } 1954 value 1955 } 1956 value_type(&self) -> glib::Type1957 fn value_type(&self) -> glib::Type { 1958 Self::static_type() 1959 } 1960 } 1961