mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-05-07 02:48:46 +00:00
Code Issues Projects Releases Wiki Activity
gstreamer-rs/gstreamer/src/auto/flags.rs

2207 lines
64 KiB
Rust
Raw Blame History

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT
use bitflags::bitflags;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::StaticType;
use glib::Type;
use std::ffi::CStr;
use std::fmt;
bitflags! {
#[doc(alias = "GstBinFlags")]
pub struct BinFlags: u32 {
#[doc(alias = "GST_BIN_FLAG_NO_RESYNC")]
const NO_RESYNC = ffi::GST_BIN_FLAG_NO_RESYNC as _;
#[doc(alias = "GST_BIN_FLAG_STREAMS_AWARE")]
const STREAMS_AWARE = ffi::GST_BIN_FLAG_STREAMS_AWARE as _;
}
}
#[doc(hidden)]
impl IntoGlib for BinFlags {
type GlibType = ffi::GstBinFlags;
fn into_glib(self) -> ffi::GstBinFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstBinFlags> for BinFlags {
unsafe fn from_glib(value: ffi::GstBinFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for BinFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_bin_flags_get_type()) }
}
}
impl glib::value::ValueType for BinFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for BinFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for BinFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<BinFlags> for glib::Value {
#[inline]
fn from(v: BinFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstBufferCopyFlags")]
pub struct BufferCopyFlags: u32 {
#[doc(alias = "GST_BUFFER_COPY_FLAGS")]
const FLAGS = ffi::GST_BUFFER_COPY_FLAGS as _;
#[doc(alias = "GST_BUFFER_COPY_TIMESTAMPS")]
const TIMESTAMPS = ffi::GST_BUFFER_COPY_TIMESTAMPS as _;
#[doc(alias = "GST_BUFFER_COPY_META")]
const META = ffi::GST_BUFFER_COPY_META as _;
#[doc(alias = "GST_BUFFER_COPY_MEMORY")]
const MEMORY = ffi::GST_BUFFER_COPY_MEMORY as _;
#[doc(alias = "GST_BUFFER_COPY_MERGE")]
const MERGE = ffi::GST_BUFFER_COPY_MERGE as _;
#[doc(alias = "GST_BUFFER_COPY_DEEP")]
const DEEP = ffi::GST_BUFFER_COPY_DEEP as _;
}
}
#[doc(hidden)]
impl IntoGlib for BufferCopyFlags {
type GlibType = ffi::GstBufferCopyFlags;
fn into_glib(self) -> ffi::GstBufferCopyFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstBufferCopyFlags> for BufferCopyFlags {
unsafe fn from_glib(value: ffi::GstBufferCopyFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for BufferCopyFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_buffer_copy_flags_get_type()) }
}
}
impl glib::value::ValueType for BufferCopyFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for BufferCopyFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for BufferCopyFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<BufferCopyFlags> for glib::Value {
#[inline]
fn from(v: BufferCopyFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstBufferFlags")]
pub struct BufferFlags: u32 {
#[doc(alias = "GST_BUFFER_FLAG_LIVE")]
const LIVE = ffi::GST_BUFFER_FLAG_LIVE as _;
#[doc(alias = "GST_BUFFER_FLAG_DECODE_ONLY")]
const DECODE_ONLY = ffi::GST_BUFFER_FLAG_DECODE_ONLY as _;
#[doc(alias = "GST_BUFFER_FLAG_DISCONT")]
const DISCONT = ffi::GST_BUFFER_FLAG_DISCONT as _;
#[doc(alias = "GST_BUFFER_FLAG_RESYNC")]
const RESYNC = ffi::GST_BUFFER_FLAG_RESYNC as _;
#[doc(alias = "GST_BUFFER_FLAG_CORRUPTED")]
const CORRUPTED = ffi::GST_BUFFER_FLAG_CORRUPTED as _;
#[doc(alias = "GST_BUFFER_FLAG_MARKER")]
const MARKER = ffi::GST_BUFFER_FLAG_MARKER as _;
#[doc(alias = "GST_BUFFER_FLAG_HEADER")]
const HEADER = ffi::GST_BUFFER_FLAG_HEADER as _;
#[doc(alias = "GST_BUFFER_FLAG_GAP")]
const GAP = ffi::GST_BUFFER_FLAG_GAP as _;
#[doc(alias = "GST_BUFFER_FLAG_DROPPABLE")]
const DROPPABLE = ffi::GST_BUFFER_FLAG_DROPPABLE as _;
#[doc(alias = "GST_BUFFER_FLAG_DELTA_UNIT")]
const DELTA_UNIT = ffi::GST_BUFFER_FLAG_DELTA_UNIT as _;
#[doc(alias = "GST_BUFFER_FLAG_TAG_MEMORY")]
const TAG_MEMORY = ffi::GST_BUFFER_FLAG_TAG_MEMORY as _;
#[doc(alias = "GST_BUFFER_FLAG_SYNC_AFTER")]
const SYNC_AFTER = ffi::GST_BUFFER_FLAG_SYNC_AFTER as _;
#[doc(alias = "GST_BUFFER_FLAG_NON_DROPPABLE")]
const NON_DROPPABLE = ffi::GST_BUFFER_FLAG_NON_DROPPABLE as _;
}
}
#[doc(hidden)]
impl IntoGlib for BufferFlags {
type GlibType = ffi::GstBufferFlags;
fn into_glib(self) -> ffi::GstBufferFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstBufferFlags> for BufferFlags {
unsafe fn from_glib(value: ffi::GstBufferFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for BufferFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_buffer_flags_get_type()) }
}
}
impl glib::value::ValueType for BufferFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for BufferFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for BufferFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<BufferFlags> for glib::Value {
#[inline]
fn from(v: BufferFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstBufferPoolAcquireFlags")]
pub struct BufferPoolAcquireFlags: u32 {
#[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT")]
const KEY_UNIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT as _;
#[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT")]
const DONTWAIT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT as _;
#[doc(alias = "GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT")]
const DISCONT = ffi::GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT as _;
}
}
#[doc(hidden)]
impl IntoGlib for BufferPoolAcquireFlags {
type GlibType = ffi::GstBufferPoolAcquireFlags;
fn into_glib(self) -> ffi::GstBufferPoolAcquireFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstBufferPoolAcquireFlags> for BufferPoolAcquireFlags {
unsafe fn from_glib(value: ffi::GstBufferPoolAcquireFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for BufferPoolAcquireFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_buffer_pool_acquire_flags_get_type()) }
}
}
impl glib::value::ValueType for BufferPoolAcquireFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for BufferPoolAcquireFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for BufferPoolAcquireFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<BufferPoolAcquireFlags> for glib::Value {
#[inline]
fn from(v: BufferPoolAcquireFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstClockFlags")]
pub struct ClockFlags: u32 {
#[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC")]
const CAN_DO_SINGLE_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC as _;
#[doc(alias = "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC")]
const CAN_DO_SINGLE_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC as _;
#[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC")]
const CAN_DO_PERIODIC_SYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC as _;
#[doc(alias = "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC")]
const CAN_DO_PERIODIC_ASYNC = ffi::GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC as _;
#[doc(alias = "GST_CLOCK_FLAG_CAN_SET_RESOLUTION")]
const CAN_SET_RESOLUTION = ffi::GST_CLOCK_FLAG_CAN_SET_RESOLUTION as _;
#[doc(alias = "GST_CLOCK_FLAG_CAN_SET_MASTER")]
const CAN_SET_MASTER = ffi::GST_CLOCK_FLAG_CAN_SET_MASTER as _;
#[doc(alias = "GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC")]
const NEEDS_STARTUP_SYNC = ffi::GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC as _;
}
}
#[doc(hidden)]
impl IntoGlib for ClockFlags {
type GlibType = ffi::GstClockFlags;
fn into_glib(self) -> ffi::GstClockFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstClockFlags> for ClockFlags {
unsafe fn from_glib(value: ffi::GstClockFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for ClockFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_clock_flags_get_type()) }
}
}
impl glib::value::ValueType for ClockFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ClockFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for ClockFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<ClockFlags> for glib::Value {
#[inline]
fn from(v: ClockFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstDebugColorFlags")]
pub struct DebugColorFlags: u32 {
#[doc(alias = "GST_DEBUG_FG_BLACK")]
const FG_BLACK = ffi::GST_DEBUG_FG_BLACK as _;
#[doc(alias = "GST_DEBUG_FG_RED")]
const FG_RED = ffi::GST_DEBUG_FG_RED as _;
#[doc(alias = "GST_DEBUG_FG_GREEN")]
const FG_GREEN = ffi::GST_DEBUG_FG_GREEN as _;
#[doc(alias = "GST_DEBUG_FG_YELLOW")]
const FG_YELLOW = ffi::GST_DEBUG_FG_YELLOW as _;
#[doc(alias = "GST_DEBUG_FG_BLUE")]
const FG_BLUE = ffi::GST_DEBUG_FG_BLUE as _;
#[doc(alias = "GST_DEBUG_FG_MAGENTA")]
const FG_MAGENTA = ffi::GST_DEBUG_FG_MAGENTA as _;
#[doc(alias = "GST_DEBUG_FG_CYAN")]
const FG_CYAN = ffi::GST_DEBUG_FG_CYAN as _;
#[doc(alias = "GST_DEBUG_FG_WHITE")]
const FG_WHITE = ffi::GST_DEBUG_FG_WHITE as _;
#[doc(alias = "GST_DEBUG_BG_BLACK")]
const BG_BLACK = ffi::GST_DEBUG_BG_BLACK as _;
#[doc(alias = "GST_DEBUG_BG_RED")]
const BG_RED = ffi::GST_DEBUG_BG_RED as _;
#[doc(alias = "GST_DEBUG_BG_GREEN")]
const BG_GREEN = ffi::GST_DEBUG_BG_GREEN as _;
#[doc(alias = "GST_DEBUG_BG_YELLOW")]
const BG_YELLOW = ffi::GST_DEBUG_BG_YELLOW as _;
#[doc(alias = "GST_DEBUG_BG_BLUE")]
const BG_BLUE = ffi::GST_DEBUG_BG_BLUE as _;
#[doc(alias = "GST_DEBUG_BG_MAGENTA")]
const BG_MAGENTA = ffi::GST_DEBUG_BG_MAGENTA as _;
#[doc(alias = "GST_DEBUG_BG_CYAN")]
const BG_CYAN = ffi::GST_DEBUG_BG_CYAN as _;
#[doc(alias = "GST_DEBUG_BG_WHITE")]
const BG_WHITE = ffi::GST_DEBUG_BG_WHITE as _;
#[doc(alias = "GST_DEBUG_BOLD")]
const BOLD = ffi::GST_DEBUG_BOLD as _;
#[doc(alias = "GST_DEBUG_UNDERLINE")]
const UNDERLINE = ffi::GST_DEBUG_UNDERLINE as _;
}
}
#[doc(hidden)]
impl IntoGlib for DebugColorFlags {
type GlibType = ffi::GstDebugColorFlags;
fn into_glib(self) -> ffi::GstDebugColorFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstDebugColorFlags> for DebugColorFlags {
unsafe fn from_glib(value: ffi::GstDebugColorFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for DebugColorFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_debug_color_flags_get_type()) }
}
}
impl glib::value::ValueType for DebugColorFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for DebugColorFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for DebugColorFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<DebugColorFlags> for glib::Value {
#[inline]
fn from(v: DebugColorFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstDebugGraphDetails")]
pub struct DebugGraphDetails: u32 {
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE")]
const MEDIA_TYPE = ffi::GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS")]
const CAPS_DETAILS = ffi::GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS")]
const NON_DEFAULT_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_STATES")]
const STATES = ffi::GST_DEBUG_GRAPH_SHOW_STATES as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_FULL_PARAMS")]
const FULL_PARAMS = ffi::GST_DEBUG_GRAPH_SHOW_FULL_PARAMS as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_ALL")]
const ALL = ffi::GST_DEBUG_GRAPH_SHOW_ALL as _;
#[doc(alias = "GST_DEBUG_GRAPH_SHOW_VERBOSE")]
const VERBOSE = ffi::GST_DEBUG_GRAPH_SHOW_VERBOSE as _;
}
}
#[doc(hidden)]
impl IntoGlib for DebugGraphDetails {
type GlibType = ffi::GstDebugGraphDetails;
fn into_glib(self) -> ffi::GstDebugGraphDetails {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstDebugGraphDetails> for DebugGraphDetails {
unsafe fn from_glib(value: ffi::GstDebugGraphDetails) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for DebugGraphDetails {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_debug_graph_details_get_type()) }
}
}
impl glib::value::ValueType for DebugGraphDetails {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for DebugGraphDetails {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for DebugGraphDetails {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<DebugGraphDetails> for glib::Value {
#[inline]
fn from(v: DebugGraphDetails) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstElementFlags")]
pub struct ElementFlags: u32 {
#[doc(alias = "GST_ELEMENT_FLAG_LOCKED_STATE")]
const LOCKED_STATE = ffi::GST_ELEMENT_FLAG_LOCKED_STATE as _;
#[doc(alias = "GST_ELEMENT_FLAG_SINK")]
const SINK = ffi::GST_ELEMENT_FLAG_SINK as _;
#[doc(alias = "GST_ELEMENT_FLAG_SOURCE")]
const SOURCE = ffi::GST_ELEMENT_FLAG_SOURCE as _;
#[doc(alias = "GST_ELEMENT_FLAG_PROVIDE_CLOCK")]
const PROVIDE_CLOCK = ffi::GST_ELEMENT_FLAG_PROVIDE_CLOCK as _;
#[doc(alias = "GST_ELEMENT_FLAG_REQUIRE_CLOCK")]
const REQUIRE_CLOCK = ffi::GST_ELEMENT_FLAG_REQUIRE_CLOCK as _;
#[doc(alias = "GST_ELEMENT_FLAG_INDEXABLE")]
const INDEXABLE = ffi::GST_ELEMENT_FLAG_INDEXABLE as _;
}
}
#[doc(hidden)]
impl IntoGlib for ElementFlags {
type GlibType = ffi::GstElementFlags;
fn into_glib(self) -> ffi::GstElementFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstElementFlags> for ElementFlags {
unsafe fn from_glib(value: ffi::GstElementFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for ElementFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_element_flags_get_type()) }
}
}
impl glib::value::ValueType for ElementFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ElementFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for ElementFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<ElementFlags> for glib::Value {
#[inline]
fn from(v: ElementFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstEventTypeFlags")]
pub struct EventTypeFlags: u32 {
#[doc(alias = "GST_EVENT_TYPE_UPSTREAM")]
const UPSTREAM = ffi::GST_EVENT_TYPE_UPSTREAM as _;
#[doc(alias = "GST_EVENT_TYPE_DOWNSTREAM")]
const DOWNSTREAM = ffi::GST_EVENT_TYPE_DOWNSTREAM as _;
#[doc(alias = "GST_EVENT_TYPE_SERIALIZED")]
const SERIALIZED = ffi::GST_EVENT_TYPE_SERIALIZED as _;
#[doc(alias = "GST_EVENT_TYPE_STICKY")]
const STICKY = ffi::GST_EVENT_TYPE_STICKY as _;
#[doc(alias = "GST_EVENT_TYPE_STICKY_MULTI")]
const STICKY_MULTI = ffi::GST_EVENT_TYPE_STICKY_MULTI as _;
}
}
#[doc(hidden)]
impl IntoGlib for EventTypeFlags {
type GlibType = ffi::GstEventTypeFlags;
fn into_glib(self) -> ffi::GstEventTypeFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstEventTypeFlags> for EventTypeFlags {
unsafe fn from_glib(value: ffi::GstEventTypeFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for EventTypeFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_event_type_flags_get_type()) }
}
}
impl glib::value::ValueType for EventTypeFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for EventTypeFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for EventTypeFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<EventTypeFlags> for glib::Value {
#[inline]
fn from(v: EventTypeFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
bitflags! {
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(alias = "GstGapFlags")]
pub struct GapFlags: u32 {
#[doc(alias = "GST_GAP_FLAG_MISSING_DATA")]
const DATA = ffi::GST_GAP_FLAG_MISSING_DATA as _;
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl IntoGlib for GapFlags {
type GlibType = ffi::GstGapFlags;
fn into_glib(self) -> ffi::GstGapFlags {
self.bits()
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GstGapFlags> for GapFlags {
unsafe fn from_glib(value: ffi::GstGapFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl StaticType for GapFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_gap_flags_get_type()) }
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl glib::value::ValueType for GapFlags {
type Type = Self;
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
unsafe impl<'a> FromValue<'a> for GapFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl ToValue for GapFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl From<GapFlags> for glib::Value {
#[inline]
fn from(v: GapFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstMemoryFlags")]
pub struct MemoryFlags: u32 {
#[doc(alias = "GST_MEMORY_FLAG_READONLY")]
const READONLY = ffi::GST_MEMORY_FLAG_READONLY as _;
#[doc(alias = "GST_MEMORY_FLAG_NO_SHARE")]
const NO_SHARE = ffi::GST_MEMORY_FLAG_NO_SHARE as _;
#[doc(alias = "GST_MEMORY_FLAG_ZERO_PREFIXED")]
const ZERO_PREFIXED = ffi::GST_MEMORY_FLAG_ZERO_PREFIXED as _;
#[doc(alias = "GST_MEMORY_FLAG_ZERO_PADDED")]
const ZERO_PADDED = ffi::GST_MEMORY_FLAG_ZERO_PADDED as _;
#[doc(alias = "GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS")]
const PHYSICALLY_CONTIGUOUS = ffi::GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS as _;
#[doc(alias = "GST_MEMORY_FLAG_NOT_MAPPABLE")]
const NOT_MAPPABLE = ffi::GST_MEMORY_FLAG_NOT_MAPPABLE as _;
}
}
#[doc(hidden)]
impl IntoGlib for MemoryFlags {
type GlibType = ffi::GstMemoryFlags;
fn into_glib(self) -> ffi::GstMemoryFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstMemoryFlags> for MemoryFlags {
unsafe fn from_glib(value: ffi::GstMemoryFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for MemoryFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_memory_flags_get_type()) }
}
}
impl glib::value::ValueType for MemoryFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for MemoryFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for MemoryFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<MemoryFlags> for glib::Value {
#[inline]
fn from(v: MemoryFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstMetaFlags")]
pub struct MetaFlags: u32 {
#[doc(alias = "GST_META_FLAG_READONLY")]
const READONLY = ffi::GST_META_FLAG_READONLY as _;
#[doc(alias = "GST_META_FLAG_POOLED")]
const POOLED = ffi::GST_META_FLAG_POOLED as _;
#[doc(alias = "GST_META_FLAG_LOCKED")]
const LOCKED = ffi::GST_META_FLAG_LOCKED as _;
}
}
#[doc(hidden)]
impl IntoGlib for MetaFlags {
type GlibType = ffi::GstMetaFlags;
fn into_glib(self) -> ffi::GstMetaFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstMetaFlags> for MetaFlags {
unsafe fn from_glib(value: ffi::GstMetaFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for MetaFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_meta_flags_get_type()) }
}
}
impl glib::value::ValueType for MetaFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for MetaFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for MetaFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<MetaFlags> for glib::Value {
#[inline]
fn from(v: MetaFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstObjectFlags")]
pub struct ObjectFlags: u32 {
#[doc(alias = "GST_OBJECT_FLAG_MAY_BE_LEAKED")]
const MAY_BE_LEAKED = ffi::GST_OBJECT_FLAG_MAY_BE_LEAKED as _;
}
}
#[doc(hidden)]
impl IntoGlib for ObjectFlags {
type GlibType = ffi::GstObjectFlags;
fn into_glib(self) -> ffi::GstObjectFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstObjectFlags> for ObjectFlags {
unsafe fn from_glib(value: ffi::GstObjectFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for ObjectFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_object_flags_get_type()) }
}
}
impl glib::value::ValueType for ObjectFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ObjectFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for ObjectFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<ObjectFlags> for glib::Value {
#[inline]
fn from(v: ObjectFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPadFlags")]
pub struct PadFlags: u32 {
#[doc(alias = "GST_PAD_FLAG_BLOCKED")]
const BLOCKED = ffi::GST_PAD_FLAG_BLOCKED as _;
#[doc(alias = "GST_PAD_FLAG_FLUSHING")]
const FLUSHING = ffi::GST_PAD_FLAG_FLUSHING as _;
#[doc(alias = "GST_PAD_FLAG_EOS")]
const EOS = ffi::GST_PAD_FLAG_EOS as _;
#[doc(alias = "GST_PAD_FLAG_BLOCKING")]
const BLOCKING = ffi::GST_PAD_FLAG_BLOCKING as _;
#[doc(alias = "GST_PAD_FLAG_NEED_PARENT")]
const NEED_PARENT = ffi::GST_PAD_FLAG_NEED_PARENT as _;
#[doc(alias = "GST_PAD_FLAG_NEED_RECONFIGURE")]
const NEED_RECONFIGURE = ffi::GST_PAD_FLAG_NEED_RECONFIGURE as _;
#[doc(alias = "GST_PAD_FLAG_PENDING_EVENTS")]
const PENDING_EVENTS = ffi::GST_PAD_FLAG_PENDING_EVENTS as _;
#[doc(alias = "GST_PAD_FLAG_FIXED_CAPS")]
const FIXED_CAPS = ffi::GST_PAD_FLAG_FIXED_CAPS as _;
#[doc(alias = "GST_PAD_FLAG_PROXY_CAPS")]
const PROXY_CAPS = ffi::GST_PAD_FLAG_PROXY_CAPS as _;
#[doc(alias = "GST_PAD_FLAG_PROXY_ALLOCATION")]
const PROXY_ALLOCATION = ffi::GST_PAD_FLAG_PROXY_ALLOCATION as _;
#[doc(alias = "GST_PAD_FLAG_PROXY_SCHEDULING")]
const PROXY_SCHEDULING = ffi::GST_PAD_FLAG_PROXY_SCHEDULING as _;
#[doc(alias = "GST_PAD_FLAG_ACCEPT_INTERSECT")]
const ACCEPT_INTERSECT = ffi::GST_PAD_FLAG_ACCEPT_INTERSECT as _;
#[doc(alias = "GST_PAD_FLAG_ACCEPT_TEMPLATE")]
const ACCEPT_TEMPLATE = ffi::GST_PAD_FLAG_ACCEPT_TEMPLATE as _;
}
}
#[doc(hidden)]
impl IntoGlib for PadFlags {
type GlibType = ffi::GstPadFlags;
fn into_glib(self) -> ffi::GstPadFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPadFlags> for PadFlags {
unsafe fn from_glib(value: ffi::GstPadFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PadFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pad_flags_get_type()) }
}
}
impl glib::value::ValueType for PadFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PadFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PadFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PadFlags> for glib::Value {
#[inline]
fn from(v: PadFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPadLinkCheck")]
pub struct PadLinkCheck: u32 {
#[doc(alias = "GST_PAD_LINK_CHECK_HIERARCHY")]
const HIERARCHY = ffi::GST_PAD_LINK_CHECK_HIERARCHY as _;
#[doc(alias = "GST_PAD_LINK_CHECK_TEMPLATE_CAPS")]
const TEMPLATE_CAPS = ffi::GST_PAD_LINK_CHECK_TEMPLATE_CAPS as _;
#[doc(alias = "GST_PAD_LINK_CHECK_CAPS")]
const CAPS = ffi::GST_PAD_LINK_CHECK_CAPS as _;
#[doc(alias = "GST_PAD_LINK_CHECK_NO_RECONFIGURE")]
const NO_RECONFIGURE = ffi::GST_PAD_LINK_CHECK_NO_RECONFIGURE as _;
#[doc(alias = "GST_PAD_LINK_CHECK_DEFAULT")]
const DEFAULT = ffi::GST_PAD_LINK_CHECK_DEFAULT as _;
}
}
#[doc(hidden)]
impl IntoGlib for PadLinkCheck {
type GlibType = ffi::GstPadLinkCheck;
fn into_glib(self) -> ffi::GstPadLinkCheck {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPadLinkCheck> for PadLinkCheck {
unsafe fn from_glib(value: ffi::GstPadLinkCheck) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PadLinkCheck {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pad_link_check_get_type()) }
}
}
impl glib::value::ValueType for PadLinkCheck {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PadLinkCheck {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PadLinkCheck {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PadLinkCheck> for glib::Value {
#[inline]
fn from(v: PadLinkCheck) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPadProbeType")]
pub struct PadProbeType: u32 {
#[doc(alias = "GST_PAD_PROBE_TYPE_IDLE")]
const IDLE = ffi::GST_PAD_PROBE_TYPE_IDLE as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK")]
const BLOCK = ffi::GST_PAD_PROBE_TYPE_BLOCK as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER")]
const BUFFER = ffi::GST_PAD_PROBE_TYPE_BUFFER as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BUFFER_LIST")]
const BUFFER_LIST = ffi::GST_PAD_PROBE_TYPE_BUFFER_LIST as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM")]
const EVENT_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_UPSTREAM")]
const EVENT_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_EVENT_UPSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_FLUSH")]
const EVENT_FLUSH = ffi::GST_PAD_PROBE_TYPE_EVENT_FLUSH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM")]
const QUERY_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_UPSTREAM")]
const QUERY_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_QUERY_UPSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_PUSH")]
const PUSH = ffi::GST_PAD_PROBE_TYPE_PUSH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_PULL")]
const PULL = ffi::GST_PAD_PROBE_TYPE_PULL as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BLOCKING")]
const BLOCKING = ffi::GST_PAD_PROBE_TYPE_BLOCKING as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM")]
const DATA_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_DATA_UPSTREAM")]
const DATA_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_DATA_UPSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_DATA_BOTH")]
const DATA_BOTH = ffi::GST_PAD_PROBE_TYPE_DATA_BOTH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM")]
const BLOCK_DOWNSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM")]
const BLOCK_UPSTREAM = ffi::GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_EVENT_BOTH")]
const EVENT_BOTH = ffi::GST_PAD_PROBE_TYPE_EVENT_BOTH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_QUERY_BOTH")]
const QUERY_BOTH = ffi::GST_PAD_PROBE_TYPE_QUERY_BOTH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_ALL_BOTH")]
const ALL_BOTH = ffi::GST_PAD_PROBE_TYPE_ALL_BOTH as _;
#[doc(alias = "GST_PAD_PROBE_TYPE_SCHEDULING")]
const SCHEDULING = ffi::GST_PAD_PROBE_TYPE_SCHEDULING as _;
}
}
#[doc(hidden)]
impl IntoGlib for PadProbeType {
type GlibType = ffi::GstPadProbeType;
fn into_glib(self) -> ffi::GstPadProbeType {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPadProbeType> for PadProbeType {
unsafe fn from_glib(value: ffi::GstPadProbeType) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PadProbeType {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pad_probe_type_get_type()) }
}
}
impl glib::value::ValueType for PadProbeType {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PadProbeType {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PadProbeType {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PadProbeType> for glib::Value {
#[inline]
fn from(v: PadProbeType) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstParseFlags")]
pub struct ParseFlags: u32 {
#[doc(alias = "GST_PARSE_FLAG_FATAL_ERRORS")]
const FATAL_ERRORS = ffi::GST_PARSE_FLAG_FATAL_ERRORS as _;
#[doc(alias = "GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS")]
const NO_SINGLE_ELEMENT_BINS = ffi::GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS as _;
#[doc(alias = "GST_PARSE_FLAG_PLACE_IN_BIN")]
const PLACE_IN_BIN = ffi::GST_PARSE_FLAG_PLACE_IN_BIN as _;
}
}
#[doc(hidden)]
impl IntoGlib for ParseFlags {
type GlibType = ffi::GstParseFlags;
fn into_glib(self) -> ffi::GstParseFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstParseFlags> for ParseFlags {
unsafe fn from_glib(value: ffi::GstParseFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for ParseFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_parse_flags_get_type()) }
}
}
impl glib::value::ValueType for ParseFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ParseFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for ParseFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<ParseFlags> for glib::Value {
#[inline]
fn from(v: ParseFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPipelineFlags")]
pub struct PipelineFlags: u32 {
#[doc(alias = "GST_PIPELINE_FLAG_FIXED_CLOCK")]
const FIXED_CLOCK = ffi::GST_PIPELINE_FLAG_FIXED_CLOCK as _;
}
}
#[doc(hidden)]
impl IntoGlib for PipelineFlags {
type GlibType = ffi::GstPipelineFlags;
fn into_glib(self) -> ffi::GstPipelineFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPipelineFlags> for PipelineFlags {
unsafe fn from_glib(value: ffi::GstPipelineFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PipelineFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_pipeline_flags_get_type()) }
}
}
impl glib::value::ValueType for PipelineFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PipelineFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PipelineFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PipelineFlags> for glib::Value {
#[inline]
fn from(v: PipelineFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
bitflags! {
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(alias = "GstPluginAPIFlags")]
pub struct PluginAPIFlags: u32 {
#[doc(alias = "GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS")]
const MEMBERS = ffi::GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS as _;
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(hidden)]
impl IntoGlib for PluginAPIFlags {
type GlibType = ffi::GstPluginAPIFlags;
fn into_glib(self) -> ffi::GstPluginAPIFlags {
self.bits()
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(hidden)]
impl FromGlib<ffi::GstPluginAPIFlags> for PluginAPIFlags {
unsafe fn from_glib(value: ffi::GstPluginAPIFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl StaticType for PluginAPIFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_plugin_api_flags_get_type()) }
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl glib::value::ValueType for PluginAPIFlags {
type Type = Self;
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
unsafe impl<'a> FromValue<'a> for PluginAPIFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl ToValue for PluginAPIFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl From<PluginAPIFlags> for glib::Value {
#[inline]
fn from(v: PluginAPIFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPluginDependencyFlags")]
pub struct PluginDependencyFlags: u32 {
#[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_RECURSE")]
const RECURSE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_RECURSE as _;
#[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY")]
const PATHS_ARE_DEFAULT_ONLY = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY as _;
#[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX")]
const FILE_NAME_IS_SUFFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX as _;
#[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX")]
const FILE_NAME_IS_PREFIX = ffi::GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX as _;
#[doc(alias = "GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE")]
const PATHS_ARE_RELATIVE_TO_EXE = ffi::GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE as _;
}
}
#[doc(hidden)]
impl IntoGlib for PluginDependencyFlags {
type GlibType = ffi::GstPluginDependencyFlags;
fn into_glib(self) -> ffi::GstPluginDependencyFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPluginDependencyFlags> for PluginDependencyFlags {
unsafe fn from_glib(value: ffi::GstPluginDependencyFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PluginDependencyFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_plugin_dependency_flags_get_type()) }
}
}
impl glib::value::ValueType for PluginDependencyFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PluginDependencyFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PluginDependencyFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PluginDependencyFlags> for glib::Value {
#[inline]
fn from(v: PluginDependencyFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstPluginFlags")]
pub struct PluginFlags: u32 {
#[doc(alias = "GST_PLUGIN_FLAG_CACHED")]
const CACHED = ffi::GST_PLUGIN_FLAG_CACHED as _;
#[doc(alias = "GST_PLUGIN_FLAG_BLACKLISTED")]
const BLACKLISTED = ffi::GST_PLUGIN_FLAG_BLACKLISTED as _;
}
}
#[doc(hidden)]
impl IntoGlib for PluginFlags {
type GlibType = ffi::GstPluginFlags;
fn into_glib(self) -> ffi::GstPluginFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstPluginFlags> for PluginFlags {
unsafe fn from_glib(value: ffi::GstPluginFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for PluginFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_plugin_flags_get_type()) }
}
}
impl glib::value::ValueType for PluginFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for PluginFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for PluginFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<PluginFlags> for glib::Value {
#[inline]
fn from(v: PluginFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstSchedulingFlags")]
pub struct SchedulingFlags: u32 {
#[doc(alias = "GST_SCHEDULING_FLAG_SEEKABLE")]
const SEEKABLE = ffi::GST_SCHEDULING_FLAG_SEEKABLE as _;
#[doc(alias = "GST_SCHEDULING_FLAG_SEQUENTIAL")]
const SEQUENTIAL = ffi::GST_SCHEDULING_FLAG_SEQUENTIAL as _;
#[doc(alias = "GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED")]
const BANDWIDTH_LIMITED = ffi::GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED as _;
}
}
#[doc(hidden)]
impl IntoGlib for SchedulingFlags {
type GlibType = ffi::GstSchedulingFlags;
fn into_glib(self) -> ffi::GstSchedulingFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstSchedulingFlags> for SchedulingFlags {
unsafe fn from_glib(value: ffi::GstSchedulingFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for SchedulingFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_scheduling_flags_get_type()) }
}
}
impl glib::value::ValueType for SchedulingFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for SchedulingFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for SchedulingFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<SchedulingFlags> for glib::Value {
#[inline]
fn from(v: SchedulingFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstSeekFlags")]
pub struct SeekFlags: u32 {
#[doc(alias = "GST_SEEK_FLAG_FLUSH")]
const FLUSH = ffi::GST_SEEK_FLAG_FLUSH as _;
#[doc(alias = "GST_SEEK_FLAG_ACCURATE")]
const ACCURATE = ffi::GST_SEEK_FLAG_ACCURATE as _;
#[doc(alias = "GST_SEEK_FLAG_KEY_UNIT")]
const KEY_UNIT = ffi::GST_SEEK_FLAG_KEY_UNIT as _;
#[doc(alias = "GST_SEEK_FLAG_SEGMENT")]
const SEGMENT = ffi::GST_SEEK_FLAG_SEGMENT as _;
#[doc(alias = "GST_SEEK_FLAG_TRICKMODE")]
const TRICKMODE = ffi::GST_SEEK_FLAG_TRICKMODE as _;
#[doc(alias = "GST_SEEK_FLAG_SKIP")]
const SKIP = ffi::GST_SEEK_FLAG_SKIP as _;
#[doc(alias = "GST_SEEK_FLAG_SNAP_BEFORE")]
const SNAP_BEFORE = ffi::GST_SEEK_FLAG_SNAP_BEFORE as _;
#[doc(alias = "GST_SEEK_FLAG_SNAP_AFTER")]
const SNAP_AFTER = ffi::GST_SEEK_FLAG_SNAP_AFTER as _;
#[doc(alias = "GST_SEEK_FLAG_SNAP_NEAREST")]
const SNAP_NEAREST = ffi::GST_SEEK_FLAG_SNAP_NEAREST as _;
#[doc(alias = "GST_SEEK_FLAG_TRICKMODE_KEY_UNITS")]
const TRICKMODE_KEY_UNITS = ffi::GST_SEEK_FLAG_TRICKMODE_KEY_UNITS as _;
#[doc(alias = "GST_SEEK_FLAG_TRICKMODE_NO_AUDIO")]
const TRICKMODE_NO_AUDIO = ffi::GST_SEEK_FLAG_TRICKMODE_NO_AUDIO as _;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(alias = "GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED")]
const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(alias = "GST_SEEK_FLAG_INSTANT_RATE_CHANGE")]
const INSTANT_RATE_CHANGE = ffi::GST_SEEK_FLAG_INSTANT_RATE_CHANGE as _;
}
}
#[doc(hidden)]
impl IntoGlib for SeekFlags {
type GlibType = ffi::GstSeekFlags;
fn into_glib(self) -> ffi::GstSeekFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstSeekFlags> for SeekFlags {
unsafe fn from_glib(value: ffi::GstSeekFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for SeekFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_seek_flags_get_type()) }
}
}
impl glib::value::ValueType for SeekFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for SeekFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for SeekFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<SeekFlags> for glib::Value {
#[inline]
fn from(v: SeekFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstSegmentFlags")]
pub struct SegmentFlags: u32 {
#[doc(alias = "GST_SEGMENT_FLAG_RESET")]
const RESET = ffi::GST_SEGMENT_FLAG_RESET as _;
#[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE")]
const TRICKMODE = ffi::GST_SEGMENT_FLAG_TRICKMODE as _;
#[doc(alias = "GST_SEGMENT_FLAG_SKIP")]
const SKIP = ffi::GST_SEGMENT_FLAG_SKIP as _;
#[doc(alias = "GST_SEGMENT_FLAG_SEGMENT")]
const SEGMENT = ffi::GST_SEGMENT_FLAG_SEGMENT as _;
#[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS")]
const TRICKMODE_KEY_UNITS = ffi::GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS as _;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED")]
const TRICKMODE_FORWARD_PREDICTED = ffi::GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED as _;
#[doc(alias = "GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO")]
const TRICKMODE_NO_AUDIO = ffi::GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO as _;
}
}
#[doc(hidden)]
impl IntoGlib for SegmentFlags {
type GlibType = ffi::GstSegmentFlags;
fn into_glib(self) -> ffi::GstSegmentFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstSegmentFlags> for SegmentFlags {
unsafe fn from_glib(value: ffi::GstSegmentFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for SegmentFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_segment_flags_get_type()) }
}
}
impl glib::value::ValueType for SegmentFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for SegmentFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for SegmentFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<SegmentFlags> for glib::Value {
#[inline]
fn from(v: SegmentFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
bitflags! {
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(alias = "GstSerializeFlags")]
pub struct SerializeFlags: u32 {
#[doc(alias = "GST_SERIALIZE_FLAG_NONE")]
const NONE = ffi::GST_SERIALIZE_FLAG_NONE as _;
#[doc(alias = "GST_SERIALIZE_FLAG_BACKWARD_COMPAT")]
const BACKWARD_COMPAT = ffi::GST_SERIALIZE_FLAG_BACKWARD_COMPAT as _;
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl IntoGlib for SerializeFlags {
type GlibType = ffi::GstSerializeFlags;
fn into_glib(self) -> ffi::GstSerializeFlags {
self.bits()
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GstSerializeFlags> for SerializeFlags {
unsafe fn from_glib(value: ffi::GstSerializeFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl StaticType for SerializeFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_serialize_flags_get_type()) }
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl glib::value::ValueType for SerializeFlags {
type Type = Self;
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
unsafe impl<'a> FromValue<'a> for SerializeFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl ToValue for SerializeFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
impl From<SerializeFlags> for glib::Value {
#[inline]
fn from(v: SerializeFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstStackTraceFlags")]
pub struct StackTraceFlags: u32 {
#[doc(alias = "GST_STACK_TRACE_SHOW_FULL")]
const FULL = ffi::GST_STACK_TRACE_SHOW_FULL as _;
}
}
#[doc(hidden)]
impl IntoGlib for StackTraceFlags {
type GlibType = ffi::GstStackTraceFlags;
fn into_glib(self) -> ffi::GstStackTraceFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstStackTraceFlags> for StackTraceFlags {
unsafe fn from_glib(value: ffi::GstStackTraceFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for StackTraceFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_stack_trace_flags_get_type()) }
}
}
impl glib::value::ValueType for StackTraceFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for StackTraceFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for StackTraceFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<StackTraceFlags> for glib::Value {
#[inline]
fn from(v: StackTraceFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstStreamFlags")]
pub struct StreamFlags: u32 {
#[doc(alias = "GST_STREAM_FLAG_SPARSE")]
const SPARSE = ffi::GST_STREAM_FLAG_SPARSE as _;
#[doc(alias = "GST_STREAM_FLAG_SELECT")]
const SELECT = ffi::GST_STREAM_FLAG_SELECT as _;
#[doc(alias = "GST_STREAM_FLAG_UNSELECT")]
const UNSELECT = ffi::GST_STREAM_FLAG_UNSELECT as _;
}
}
#[doc(hidden)]
impl IntoGlib for StreamFlags {
type GlibType = ffi::GstStreamFlags;
fn into_glib(self) -> ffi::GstStreamFlags {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstStreamFlags> for StreamFlags {
unsafe fn from_glib(value: ffi::GstStreamFlags) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for StreamFlags {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_stream_flags_get_type()) }
}
}
impl glib::value::ValueType for StreamFlags {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for StreamFlags {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for StreamFlags {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<StreamFlags> for glib::Value {
#[inline]
fn from(v: StreamFlags) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
bitflags! {
#[doc(alias = "GstStreamType")]
pub struct StreamType: u32 {
#[doc(alias = "GST_STREAM_TYPE_UNKNOWN")]
const UNKNOWN = ffi::GST_STREAM_TYPE_UNKNOWN as _;
#[doc(alias = "GST_STREAM_TYPE_AUDIO")]
const AUDIO = ffi::GST_STREAM_TYPE_AUDIO as _;
#[doc(alias = "GST_STREAM_TYPE_VIDEO")]
const VIDEO = ffi::GST_STREAM_TYPE_VIDEO as _;
#[doc(alias = "GST_STREAM_TYPE_CONTAINER")]
const CONTAINER = ffi::GST_STREAM_TYPE_CONTAINER as _;
#[doc(alias = "GST_STREAM_TYPE_TEXT")]
const TEXT = ffi::GST_STREAM_TYPE_TEXT as _;
}
}
impl StreamType {
pub fn name<'a>(self) -> &'a str {
unsafe {
CStr::from_ptr(
ffi::gst_stream_type_get_name(self.into_glib())
.as_ref()
.expect("gst_stream_type_get_name returned NULL"),
)
.to_str()
.expect("gst_stream_type_get_name returned an invalid string")
}
}
}
impl fmt::Display for StreamType {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(&self.name())
}
}
#[doc(hidden)]
impl IntoGlib for StreamType {
type GlibType = ffi::GstStreamType;
fn into_glib(self) -> ffi::GstStreamType {
self.bits()
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstStreamType> for StreamType {
unsafe fn from_glib(value: ffi::GstStreamType) -> Self {
skip_assert_initialized!();
Self::from_bits_truncate(value)
}
}
impl StaticType for StreamType {
fn static_type() -> Type {
unsafe { from_glib(ffi::gst_stream_type_get_type()) }
}
}
impl glib::value::ValueType for StreamType {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for StreamType {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
}
}
impl ToValue for StreamType {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
impl From<StreamType> for glib::Value {
#[inline]
fn from(v: StreamType) -> Self {
skip_assert_initialized!();
ToValue::to_value(&v)
}
}
Reference in a new issue View git blame Copy permalink