2018-04-23 17:34:22 +00:00
|
|
|
// This file was generated by gir (https://github.com/gtk-rs/gir)
|
|
|
|
// from gir-files (https://github.com/gtk-rs/gir-files)
|
2021-04-01 13:58:41 +00:00
|
|
|
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
|
2017-08-10 21:41:55 +00:00
|
|
|
// DO NOT EDIT
|
|
|
|
|
2020-11-22 09:50:37 +00:00
|
|
|
use bitflags::bitflags;
|
2017-08-10 21:41:55 +00:00
|
|
|
use glib::translate::*;
|
2018-02-17 17:58:41 +00:00
|
|
|
use glib::value::FromValue;
|
2021-04-19 16:24:43 +00:00
|
|
|
use glib::value::ToValue;
|
2019-06-18 10:12:00 +00:00
|
|
|
use glib::StaticType;
|
|
|
|
use glib::Type;
|
2021-04-17 10:11:52 +00:00
|
|
|
use std::fmt;
|
2017-08-10 21:41:55 +00:00
|
|
|
|
2022-03-15 13:18:08 +00:00
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
bitflags! {
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
#[doc(alias = "GstNavigationModifierType")]
|
|
|
|
pub struct NavigationModifierType: u32 {
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_SHIFT_MASK")]
|
|
|
|
const SHIFT_MASK = ffi::GST_NAVIGATION_MODIFIER_SHIFT_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_LOCK_MASK")]
|
|
|
|
const LOCK_MASK = ffi::GST_NAVIGATION_MODIFIER_LOCK_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_CONTROL_MASK")]
|
|
|
|
const CONTROL_MASK = ffi::GST_NAVIGATION_MODIFIER_CONTROL_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_ALT_MASK")]
|
|
|
|
const ALT_MASK = ffi::GST_NAVIGATION_MODIFIER_ALT_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_BUTTON1_MASK")]
|
|
|
|
const BUTTON1_MASK = ffi::GST_NAVIGATION_MODIFIER_BUTTON1_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_BUTTON2_MASK")]
|
|
|
|
const BUTTON2_MASK = ffi::GST_NAVIGATION_MODIFIER_BUTTON2_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_BUTTON3_MASK")]
|
|
|
|
const BUTTON3_MASK = ffi::GST_NAVIGATION_MODIFIER_BUTTON3_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_BUTTON4_MASK")]
|
|
|
|
const BUTTON4_MASK = ffi::GST_NAVIGATION_MODIFIER_BUTTON4_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_BUTTON5_MASK")]
|
|
|
|
const BUTTON5_MASK = ffi::GST_NAVIGATION_MODIFIER_BUTTON5_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_SUPER_MASK")]
|
|
|
|
const SUPER_MASK = ffi::GST_NAVIGATION_MODIFIER_SUPER_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_HYPER_MASK")]
|
|
|
|
const HYPER_MASK = ffi::GST_NAVIGATION_MODIFIER_HYPER_MASK as u32;
|
|
|
|
#[doc(alias = "GST_NAVIGATION_MODIFIER_META_MASK")]
|
|
|
|
const META_MASK = ffi::GST_NAVIGATION_MODIFIER_META_MASK as u32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
#[doc(hidden)]
|
|
|
|
impl IntoGlib for NavigationModifierType {
|
|
|
|
type GlibType = ffi::GstNavigationModifierType;
|
|
|
|
|
|
|
|
fn into_glib(self) -> ffi::GstNavigationModifierType {
|
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
#[doc(hidden)]
|
|
|
|
impl FromGlib<ffi::GstNavigationModifierType> for NavigationModifierType {
|
|
|
|
unsafe fn from_glib(value: ffi::GstNavigationModifierType) -> Self {
|
|
|
|
skip_assert_initialized!();
|
|
|
|
Self::from_bits_truncate(value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
impl StaticType for NavigationModifierType {
|
|
|
|
fn static_type() -> Type {
|
|
|
|
unsafe { from_glib(ffi::gst_navigation_modifier_type_get_type()) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
impl glib::value::ValueType for NavigationModifierType {
|
|
|
|
type Type = Self;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
unsafe impl<'a> FromValue<'a> for NavigationModifierType {
|
|
|
|
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_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
impl ToValue for NavigationModifierType {
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-16 08:30:57 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoBufferFlags")]
|
2019-07-16 08:30:57 +00:00
|
|
|
pub struct VideoBufferFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_INTERLACED")]
|
|
|
|
const INTERLACED = ffi::GST_VIDEO_BUFFER_FLAG_INTERLACED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_TFF")]
|
|
|
|
const TFF = ffi::GST_VIDEO_BUFFER_FLAG_TFF as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_RFF")]
|
|
|
|
const RFF = ffi::GST_VIDEO_BUFFER_FLAG_RFF as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_ONEFIELD")]
|
|
|
|
const ONEFIELD = ffi::GST_VIDEO_BUFFER_FLAG_ONEFIELD as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_MULTIPLE_VIEW")]
|
|
|
|
const MULTIPLE_VIEW = ffi::GST_VIDEO_BUFFER_FLAG_MULTIPLE_VIEW as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_FIRST_IN_BUNDLE")]
|
|
|
|
const FIRST_IN_BUNDLE = ffi::GST_VIDEO_BUFFER_FLAG_FIRST_IN_BUNDLE as u32;
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_TOP_FIELD")]
|
|
|
|
const TOP_FIELD = ffi::GST_VIDEO_BUFFER_FLAG_TOP_FIELD as u32;
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_BOTTOM_FIELD")]
|
|
|
|
const BOTTOM_FIELD = ffi::GST_VIDEO_BUFFER_FLAG_BOTTOM_FIELD as u32;
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_BUFFER_FLAG_MARKER")]
|
|
|
|
const MARKER = ffi::GST_VIDEO_BUFFER_FLAG_MARKER as u32;
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoBufferFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoBufferFlags;
|
2019-07-16 08:30:57 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoBufferFlags {
|
2019-07-16 08:30:57 +00:00
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoBufferFlags> for VideoBufferFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoBufferFlags) -> Self {
|
2019-07-16 08:30:57 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoBufferFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_buffer_flags_get_type()) }
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoBufferFlags {
|
|
|
|
type Type = Self;
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoBufferFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoBufferFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2019-07-16 08:30:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-10 21:41:55 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoChromaSite")]
|
2017-08-10 21:41:55 +00:00
|
|
|
pub struct VideoChromaSite: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_NONE")]
|
|
|
|
const NONE = ffi::GST_VIDEO_CHROMA_SITE_NONE as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_H_COSITED")]
|
|
|
|
const H_COSITED = ffi::GST_VIDEO_CHROMA_SITE_H_COSITED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_V_COSITED")]
|
|
|
|
const V_COSITED = ffi::GST_VIDEO_CHROMA_SITE_V_COSITED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_ALT_LINE")]
|
|
|
|
const ALT_LINE = ffi::GST_VIDEO_CHROMA_SITE_ALT_LINE as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_COSITED")]
|
|
|
|
const COSITED = ffi::GST_VIDEO_CHROMA_SITE_COSITED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_JPEG")]
|
|
|
|
const JPEG = ffi::GST_VIDEO_CHROMA_SITE_JPEG as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_MPEG2")]
|
|
|
|
const MPEG2 = ffi::GST_VIDEO_CHROMA_SITE_MPEG2 as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CHROMA_SITE_DV")]
|
|
|
|
const DV = ffi::GST_VIDEO_CHROMA_SITE_DV as u32;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-17 10:11:52 +00:00
|
|
|
impl VideoChromaSite {
|
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
#[doc(alias = "gst_video_chroma_site_from_string")]
|
|
|
|
pub fn from_string(s: &str) -> VideoChromaSite {
|
|
|
|
assert_initialized_main_thread!();
|
|
|
|
unsafe { from_glib(ffi::gst_video_chroma_site_from_string(s.to_glib_none().0)) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for VideoChromaSite {
|
|
|
|
#[inline]
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
f.write_str(&self.to_str())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-10 21:41:55 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoChromaSite {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoChromaSite;
|
2017-08-10 21:41:55 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoChromaSite {
|
2018-04-04 07:46:18 +00:00
|
|
|
self.bits()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoChromaSite> for VideoChromaSite {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoChromaSite) -> Self {
|
2017-08-10 21:41:55 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoChromaSite {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_chroma_site_get_type()) }
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoChromaSite {
|
|
|
|
type Type = Self;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoChromaSite {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoChromaSite {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-11 12:58:39 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoCodecFrameFlags")]
|
2019-05-11 12:58:39 +00:00
|
|
|
pub struct VideoCodecFrameFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY")]
|
|
|
|
const DECODE_ONLY = ffi::GST_VIDEO_CODEC_FRAME_FLAG_DECODE_ONLY as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CODEC_FRAME_FLAG_SYNC_POINT")]
|
|
|
|
const SYNC_POINT = ffi::GST_VIDEO_CODEC_FRAME_FLAG_SYNC_POINT as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CODEC_FRAME_FLAG_FORCE_KEYFRAME")]
|
|
|
|
const FORCE_KEYFRAME = ffi::GST_VIDEO_CODEC_FRAME_FLAG_FORCE_KEYFRAME as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_CODEC_FRAME_FLAG_FORCE_KEYFRAME_HEADERS")]
|
|
|
|
const FORCE_KEYFRAME_HEADERS = ffi::GST_VIDEO_CODEC_FRAME_FLAG_FORCE_KEYFRAME_HEADERS as u32;
|
2021-04-17 10:11:52 +00:00
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
#[doc(alias = "GST_VIDEO_CODEC_FRAME_FLAG_CORRUPTED")]
|
|
|
|
const CORRUPTED = ffi::GST_VIDEO_CODEC_FRAME_FLAG_CORRUPTED as u32;
|
2019-05-11 12:58:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoCodecFrameFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoCodecFrameFlags;
|
2019-05-11 12:58:39 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoCodecFrameFlags {
|
2019-05-11 12:58:39 +00:00
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoCodecFrameFlags> for VideoCodecFrameFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoCodecFrameFlags) -> Self {
|
2019-05-11 12:58:39 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2019-05-11 12:58:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-08 16:44:38 +00:00
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
impl StaticType for VideoCodecFrameFlags {
|
|
|
|
fn static_type() -> Type {
|
|
|
|
unsafe { from_glib(ffi::gst_video_codec_frame_flags_get_type()) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
impl glib::value::ValueType for VideoCodecFrameFlags {
|
|
|
|
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 VideoCodecFrameFlags {
|
|
|
|
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 VideoCodecFrameFlags {
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-17 10:11:52 +00:00
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
bitflags! {
|
2021-08-30 07:52:36 +00:00
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
2021-04-17 10:11:52 +00:00
|
|
|
#[doc(alias = "GstVideoDecoderRequestSyncPointFlags")]
|
|
|
|
pub struct VideoDecoderRequestSyncPointFlags: u32 {
|
|
|
|
#[doc(alias = "GST_VIDEO_DECODER_REQUEST_SYNC_POINT_DISCARD_INPUT")]
|
|
|
|
const DISCARD_INPUT = ffi::GST_VIDEO_DECODER_REQUEST_SYNC_POINT_DISCARD_INPUT as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_DECODER_REQUEST_SYNC_POINT_CORRUPT_OUTPUT")]
|
|
|
|
const CORRUPT_OUTPUT = ffi::GST_VIDEO_DECODER_REQUEST_SYNC_POINT_CORRUPT_OUTPUT as u32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
#[doc(hidden)]
|
|
|
|
impl IntoGlib for VideoDecoderRequestSyncPointFlags {
|
|
|
|
type GlibType = ffi::GstVideoDecoderRequestSyncPointFlags;
|
|
|
|
|
|
|
|
fn into_glib(self) -> ffi::GstVideoDecoderRequestSyncPointFlags {
|
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
#[doc(hidden)]
|
|
|
|
impl FromGlib<ffi::GstVideoDecoderRequestSyncPointFlags> for VideoDecoderRequestSyncPointFlags {
|
|
|
|
unsafe fn from_glib(value: ffi::GstVideoDecoderRequestSyncPointFlags) -> Self {
|
|
|
|
skip_assert_initialized!();
|
|
|
|
Self::from_bits_truncate(value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-08 16:44:38 +00:00
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
impl StaticType for VideoDecoderRequestSyncPointFlags {
|
|
|
|
fn static_type() -> Type {
|
|
|
|
unsafe { from_glib(ffi::gst_video_decoder_request_sync_point_flags_get_type()) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(any(feature = "v1_20", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
|
|
|
|
impl glib::value::ValueType for VideoDecoderRequestSyncPointFlags {
|
|
|
|
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 VideoDecoderRequestSyncPointFlags {
|
|
|
|
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 VideoDecoderRequestSyncPointFlags {
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-10 21:41:55 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoFlags")]
|
2017-08-10 21:41:55 +00:00
|
|
|
pub struct VideoFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_FLAG_VARIABLE_FPS")]
|
|
|
|
const VARIABLE_FPS = ffi::GST_VIDEO_FLAG_VARIABLE_FPS as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FLAG_PREMULTIPLIED_ALPHA")]
|
|
|
|
const PREMULTIPLIED_ALPHA = ffi::GST_VIDEO_FLAG_PREMULTIPLIED_ALPHA as u32;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoFlags;
|
2017-08-10 21:41:55 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoFlags {
|
2018-04-04 07:46:18 +00:00
|
|
|
self.bits()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoFlags> for VideoFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoFlags) -> Self {
|
2017-08-10 21:41:55 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_flags_get_type()) }
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoFlags {
|
|
|
|
type Type = Self;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoFormatFlags")]
|
2017-08-10 21:41:55 +00:00
|
|
|
pub struct VideoFormatFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_YUV")]
|
|
|
|
const YUV = ffi::GST_VIDEO_FORMAT_FLAG_YUV as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_RGB")]
|
|
|
|
const RGB = ffi::GST_VIDEO_FORMAT_FLAG_RGB as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_GRAY")]
|
|
|
|
const GRAY = ffi::GST_VIDEO_FORMAT_FLAG_GRAY as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_ALPHA")]
|
|
|
|
const ALPHA = ffi::GST_VIDEO_FORMAT_FLAG_ALPHA as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_LE")]
|
|
|
|
const LE = ffi::GST_VIDEO_FORMAT_FLAG_LE as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_PALETTE")]
|
|
|
|
const PALETTE = ffi::GST_VIDEO_FORMAT_FLAG_PALETTE as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_COMPLEX")]
|
|
|
|
const COMPLEX = ffi::GST_VIDEO_FORMAT_FLAG_COMPLEX as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_UNPACK")]
|
|
|
|
const UNPACK = ffi::GST_VIDEO_FORMAT_FLAG_UNPACK as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_TILED")]
|
|
|
|
const TILED = ffi::GST_VIDEO_FORMAT_FLAG_TILED as u32;
|
2022-03-15 13:34:51 +00:00
|
|
|
#[cfg(any(feature = "v1_22", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_22")))]
|
|
|
|
#[doc(alias = "GST_VIDEO_FORMAT_FLAG_SUBTILES")]
|
|
|
|
const SUBTILES = ffi::GST_VIDEO_FORMAT_FLAG_SUBTILES as u32;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoFormatFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoFormatFlags;
|
2017-08-10 21:41:55 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoFormatFlags {
|
2018-04-04 07:46:18 +00:00
|
|
|
self.bits()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoFormatFlags> for VideoFormatFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoFormatFlags) -> Self {
|
2017-08-10 21:41:55 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoFormatFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_format_flags_get_type()) }
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoFormatFlags {
|
|
|
|
type Type = Self;
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoFormatFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoFormatFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2017-08-10 21:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-11 09:29:23 +00:00
|
|
|
|
2017-08-11 11:55:31 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoFrameFlags")]
|
2017-08-11 11:55:31 +00:00
|
|
|
pub struct VideoFrameFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_INTERLACED")]
|
|
|
|
const INTERLACED = ffi::GST_VIDEO_FRAME_FLAG_INTERLACED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_TFF")]
|
|
|
|
const TFF = ffi::GST_VIDEO_FRAME_FLAG_TFF as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_RFF")]
|
|
|
|
const RFF = ffi::GST_VIDEO_FRAME_FLAG_RFF as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_ONEFIELD")]
|
|
|
|
const ONEFIELD = ffi::GST_VIDEO_FRAME_FLAG_ONEFIELD as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_MULTIPLE_VIEW")]
|
|
|
|
const MULTIPLE_VIEW = ffi::GST_VIDEO_FRAME_FLAG_MULTIPLE_VIEW as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_FIRST_IN_BUNDLE")]
|
|
|
|
const FIRST_IN_BUNDLE = ffi::GST_VIDEO_FRAME_FLAG_FIRST_IN_BUNDLE as u32;
|
2021-12-03 16:14:55 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_TOP_FIELD")]
|
|
|
|
const TOP_FIELD = ffi::GST_VIDEO_FRAME_FLAG_TOP_FIELD as u32;
|
2021-12-03 16:14:55 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_FRAME_FLAG_BOTTOM_FIELD")]
|
|
|
|
const BOTTOM_FIELD = ffi::GST_VIDEO_FRAME_FLAG_BOTTOM_FIELD as u32;
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoFrameFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoFrameFlags;
|
2017-08-11 11:55:31 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoFrameFlags {
|
2018-04-04 07:46:18 +00:00
|
|
|
self.bits()
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoFrameFlags> for VideoFrameFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoFrameFlags) -> Self {
|
2017-08-11 11:55:31 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoFrameFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_frame_flags_get_type()) }
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoFrameFlags {
|
|
|
|
type Type = Self;
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoFrameFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoFrameFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2017-08-11 11:55:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-11 09:29:23 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoMultiviewFlags")]
|
2017-08-11 09:29:23 +00:00
|
|
|
pub struct VideoMultiviewFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST")]
|
|
|
|
const RIGHT_VIEW_FIRST = ffi::GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED")]
|
|
|
|
const LEFT_FLIPPED = ffi::GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED")]
|
|
|
|
const LEFT_FLOPPED = ffi::GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED")]
|
|
|
|
const RIGHT_FLIPPED = ffi::GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED")]
|
|
|
|
const RIGHT_FLOPPED = ffi::GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT")]
|
|
|
|
const HALF_ASPECT = ffi::GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO")]
|
|
|
|
const MIXED_MONO = ffi::GST_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO as u32;
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoMultiviewFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoMultiviewFlags;
|
2017-08-11 09:29:23 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoMultiviewFlags {
|
2018-04-04 07:46:18 +00:00
|
|
|
self.bits()
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoMultiviewFlags> for VideoMultiviewFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoMultiviewFlags) -> Self {
|
2017-08-11 09:29:23 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoMultiviewFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_multiview_flags_get_type()) }
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoMultiviewFlags {
|
|
|
|
type Type = Self;
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoMultiviewFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoMultiviewFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2017-08-11 09:29:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-04 08:39:15 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoOverlayFormatFlags")]
|
2018-10-04 08:39:15 +00:00
|
|
|
pub struct VideoOverlayFormatFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA")]
|
|
|
|
const PREMULTIPLIED_ALPHA = ffi::GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA")]
|
|
|
|
const GLOBAL_ALPHA = ffi::GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA as u32;
|
2018-10-04 08:39:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoOverlayFormatFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoOverlayFormatFlags;
|
2018-10-04 08:39:15 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoOverlayFormatFlags {
|
2018-10-04 08:39:15 +00:00
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoOverlayFormatFlags> for VideoOverlayFormatFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoOverlayFormatFlags) -> Self {
|
2018-10-04 08:39:15 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2018-10-04 08:39:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2019-04-23 14:32:09 +00:00
|
|
|
impl StaticType for VideoOverlayFormatFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_overlay_format_flags_get_type()) }
|
2019-04-23 14:32:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoOverlayFormatFlags {
|
|
|
|
type Type = Self;
|
2019-04-23 14:32:09 +00:00
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoOverlayFormatFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2019-04-23 14:32:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_16", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoOverlayFormatFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2019-04-23 14:32:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-28 07:26:44 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoPackFlags")]
|
2019-05-28 07:26:44 +00:00
|
|
|
pub struct VideoPackFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_PACK_FLAG_TRUNCATE_RANGE")]
|
|
|
|
const TRUNCATE_RANGE = ffi::GST_VIDEO_PACK_FLAG_TRUNCATE_RANGE as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_PACK_FLAG_INTERLACED")]
|
|
|
|
const INTERLACED = ffi::GST_VIDEO_PACK_FLAG_INTERLACED as u32;
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoPackFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoPackFlags;
|
2019-05-28 07:26:44 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoPackFlags {
|
2019-05-28 07:26:44 +00:00
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoPackFlags> for VideoPackFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoPackFlags) -> Self {
|
2019-05-28 07:26:44 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for VideoPackFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_pack_flags_get_type()) }
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoPackFlags {
|
|
|
|
type Type = Self;
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoPackFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoPackFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2019-05-28 07:26:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-15 12:50:11 +00:00
|
|
|
bitflags! {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GstVideoTimeCodeFlags")]
|
2018-12-15 12:50:11 +00:00
|
|
|
pub struct VideoTimeCodeFlags: u32 {
|
2021-06-02 07:47:51 +00:00
|
|
|
#[doc(alias = "GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME")]
|
|
|
|
const DROP_FRAME = ffi::GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME as u32;
|
|
|
|
#[doc(alias = "GST_VIDEO_TIME_CODE_FLAGS_INTERLACED")]
|
|
|
|
const INTERLACED = ffi::GST_VIDEO_TIME_CODE_FLAGS_INTERLACED as u32;
|
2018-12-15 12:50:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for VideoTimeCodeFlags {
|
2020-11-22 09:50:37 +00:00
|
|
|
type GlibType = ffi::GstVideoTimeCodeFlags;
|
2018-12-15 12:50:11 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstVideoTimeCodeFlags {
|
2018-12-15 12:50:11 +00:00
|
|
|
self.bits()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-22 09:50:37 +00:00
|
|
|
impl FromGlib<ffi::GstVideoTimeCodeFlags> for VideoTimeCodeFlags {
|
2021-04-25 16:45:59 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstVideoTimeCodeFlags) -> Self {
|
2018-12-15 12:50:11 +00:00
|
|
|
skip_assert_initialized!();
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::from_bits_truncate(value)
|
2018-12-15 12:50:11 +00:00
|
|
|
}
|
|
|
|
}
|
2020-04-30 16:51:41 +00:00
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
2020-04-30 16:51:41 +00:00
|
|
|
impl StaticType for VideoTimeCodeFlags {
|
|
|
|
fn static_type() -> Type {
|
2020-11-22 09:50:37 +00:00
|
|
|
unsafe { from_glib(ffi::gst_video_time_code_flags_get_type()) }
|
2020-04-30 16:51:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for VideoTimeCodeFlags {
|
|
|
|
type Type = Self;
|
2020-04-30 16:51:41 +00:00
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for VideoTimeCodeFlags {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-22 09:50:37 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
|
2020-04-30 16:51:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for VideoTimeCodeFlags {
|
|
|
|
fn to_value(&self) -> glib::Value {
|
2021-04-25 16:45:59 +00:00
|
|
|
let mut value = glib::Value::for_value_type::<Self>();
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe {
|
2021-04-27 15:10:39 +00:00
|
|
|
glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
|
2021-04-19 16:24:43 +00:00
|
|
|
}
|
|
|
|
value
|
|
|
|
}
|
|
|
|
|
|
|
|
fn value_type(&self) -> glib::Type {
|
|
|
|
Self::static_type()
|
2020-04-30 16:51:41 +00:00
|
|
|
}
|
|
|
|
}
|