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-05-12 12:24:03 +00:00
|
|
|
// DO NOT EDIT
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
use crate::EventTypeFlags;
|
2018-02-17 17:58:41 +00:00
|
|
|
use glib::error::ErrorDomain;
|
2017-05-12 12:24:03 +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::Quark;
|
|
|
|
use glib::StaticType;
|
|
|
|
use glib::Type;
|
2020-12-07 11:11:04 +00:00
|
|
|
use std::ffi::CStr;
|
|
|
|
use std::fmt;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstBufferingMode")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum BufferingMode {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUFFERING_STREAM")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Stream,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUFFERING_DOWNLOAD")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Download,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUFFERING_TIMESHIFT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Timeshift,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUFFERING_LIVE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Live,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for BufferingMode {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstBufferingMode;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstBufferingMode {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Stream => ffi::GST_BUFFERING_STREAM,
|
|
|
|
Self::Download => ffi::GST_BUFFERING_DOWNLOAD,
|
|
|
|
Self::Timeshift => ffi::GST_BUFFERING_TIMESHIFT,
|
|
|
|
Self::Live => ffi::GST_BUFFERING_LIVE,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstBufferingMode> for BufferingMode {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstBufferingMode) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_BUFFERING_STREAM => Self::Stream,
|
|
|
|
ffi::GST_BUFFERING_DOWNLOAD => Self::Download,
|
|
|
|
ffi::GST_BUFFERING_TIMESHIFT => Self::Timeshift,
|
|
|
|
ffi::GST_BUFFERING_LIVE => Self::Live,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for BufferingMode {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_buffering_mode_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for BufferingMode {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for BufferingMode {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for BufferingMode {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstBusSyncReply")]
|
2017-07-11 16:29:16 +00:00
|
|
|
pub enum BusSyncReply {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUS_DROP")]
|
2017-07-11 16:29:16 +00:00
|
|
|
Drop,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUS_PASS")]
|
2017-07-11 16:29:16 +00:00
|
|
|
Pass,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_BUS_ASYNC")]
|
2017-07-11 16:29:16 +00:00
|
|
|
Async,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for BusSyncReply {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstBusSyncReply;
|
2017-07-11 16:29:16 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstBusSyncReply {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Drop => ffi::GST_BUS_DROP,
|
|
|
|
Self::Pass => ffi::GST_BUS_PASS,
|
|
|
|
Self::Async => ffi::GST_BUS_ASYNC,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-11 16:29:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstBusSyncReply> for BusSyncReply {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstBusSyncReply) -> Self {
|
2017-07-11 16:29:16 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_BUS_DROP => Self::Drop,
|
|
|
|
ffi::GST_BUS_PASS => Self::Pass,
|
|
|
|
ffi::GST_BUS_ASYNC => Self::Async,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-11 16:29:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for BusSyncReply {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_bus_sync_reply_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for BusSyncReply {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for BusSyncReply {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for BusSyncReply {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstCapsIntersectMode")]
|
2017-07-24 23:03:18 +00:00
|
|
|
pub enum CapsIntersectMode {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CAPS_INTERSECT_ZIG_ZAG")]
|
2017-07-24 23:03:18 +00:00
|
|
|
ZigZag,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CAPS_INTERSECT_FIRST")]
|
2017-07-24 23:03:18 +00:00
|
|
|
First,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for CapsIntersectMode {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstCapsIntersectMode;
|
2017-07-24 23:03:18 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstCapsIntersectMode {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::ZigZag => ffi::GST_CAPS_INTERSECT_ZIG_ZAG,
|
|
|
|
Self::First => ffi::GST_CAPS_INTERSECT_FIRST,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstCapsIntersectMode> for CapsIntersectMode {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstCapsIntersectMode) -> Self {
|
2017-07-24 23:03:18 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CAPS_INTERSECT_ZIG_ZAG => Self::ZigZag,
|
|
|
|
ffi::GST_CAPS_INTERSECT_FIRST => Self::First,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for CapsIntersectMode {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_caps_intersect_mode_get_type()) }
|
2017-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for CapsIntersectMode {
|
|
|
|
type Type = Self;
|
2017-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for CapsIntersectMode {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for CapsIntersectMode {
|
|
|
|
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_enum(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-07-24 23:03:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-25 13:44:20 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstClockEntryType")]
|
2019-09-25 13:44:20 +00:00
|
|
|
pub enum ClockEntryType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_ENTRY_SINGLE")]
|
2019-09-25 13:44:20 +00:00
|
|
|
Single,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_ENTRY_PERIODIC")]
|
2019-09-25 13:44:20 +00:00
|
|
|
Periodic,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ClockEntryType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstClockEntryType;
|
2019-09-25 13:44:20 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstClockEntryType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Single => ffi::GST_CLOCK_ENTRY_SINGLE,
|
|
|
|
Self::Periodic => ffi::GST_CLOCK_ENTRY_PERIODIC,
|
|
|
|
Self::__Unknown(value) => value,
|
2019-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstClockEntryType> for ClockEntryType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstClockEntryType) -> Self {
|
2019-09-25 13:44:20 +00:00
|
|
|
skip_assert_initialized!();
|
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CLOCK_ENTRY_SINGLE => Self::Single,
|
|
|
|
ffi::GST_CLOCK_ENTRY_PERIODIC => Self::Periodic,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2019-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for ClockEntryType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_clock_entry_type_get_type()) }
|
2019-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ClockEntryType {
|
|
|
|
type Type = Self;
|
2019-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ClockEntryType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2019-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ClockEntryType {
|
|
|
|
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_enum(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-09-25 13:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-05 17:16:50 +00:00
|
|
|
#[must_use]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstClockReturn")]
|
2017-08-13 22:40:43 +00:00
|
|
|
pub enum ClockReturn {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_OK")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Ok,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_EARLY")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Early,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_UNSCHEDULED")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Unscheduled,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_BUSY")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Busy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_BADTIME")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Badtime,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_ERROR")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Error,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_UNSUPPORTED")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Unsupported,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_DONE")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Done,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ClockReturn {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstClockReturn;
|
2017-08-13 22:40:43 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstClockReturn {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Ok => ffi::GST_CLOCK_OK,
|
|
|
|
Self::Early => ffi::GST_CLOCK_EARLY,
|
|
|
|
Self::Unscheduled => ffi::GST_CLOCK_UNSCHEDULED,
|
|
|
|
Self::Busy => ffi::GST_CLOCK_BUSY,
|
|
|
|
Self::Badtime => ffi::GST_CLOCK_BADTIME,
|
|
|
|
Self::Error => ffi::GST_CLOCK_ERROR,
|
|
|
|
Self::Unsupported => ffi::GST_CLOCK_UNSUPPORTED,
|
|
|
|
Self::Done => ffi::GST_CLOCK_DONE,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstClockReturn> for ClockReturn {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstClockReturn) -> Self {
|
2017-08-13 22:40:43 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CLOCK_OK => Self::Ok,
|
|
|
|
ffi::GST_CLOCK_EARLY => Self::Early,
|
|
|
|
ffi::GST_CLOCK_UNSCHEDULED => Self::Unscheduled,
|
|
|
|
ffi::GST_CLOCK_BUSY => Self::Busy,
|
|
|
|
ffi::GST_CLOCK_BADTIME => Self::Badtime,
|
|
|
|
ffi::GST_CLOCK_ERROR => Self::Error,
|
|
|
|
ffi::GST_CLOCK_UNSUPPORTED => Self::Unsupported,
|
|
|
|
ffi::GST_CLOCK_DONE => Self::Done,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for ClockReturn {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_clock_return_get_type()) }
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ClockReturn {
|
|
|
|
type Type = Self;
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ClockReturn {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ClockReturn {
|
|
|
|
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_enum(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-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstClockType")]
|
2017-08-13 22:40:43 +00:00
|
|
|
pub enum ClockType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_TYPE_REALTIME")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Realtime,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_TYPE_MONOTONIC")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Monotonic,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_TYPE_OTHER")]
|
2017-08-13 22:40:43 +00:00
|
|
|
Other,
|
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-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CLOCK_TYPE_TAI")]
|
2020-04-30 16:51:41 +00:00
|
|
|
Tai,
|
2017-08-13 22:40:43 +00:00
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ClockType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstClockType;
|
2017-08-13 22:40:43 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstClockType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Realtime => ffi::GST_CLOCK_TYPE_REALTIME,
|
|
|
|
Self::Monotonic => ffi::GST_CLOCK_TYPE_MONOTONIC,
|
|
|
|
Self::Other => ffi::GST_CLOCK_TYPE_OTHER,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Tai => ffi::GST_CLOCK_TYPE_TAI,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstClockType> for ClockType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstClockType) -> Self {
|
2017-08-13 22:40:43 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CLOCK_TYPE_REALTIME => Self::Realtime,
|
|
|
|
ffi::GST_CLOCK_TYPE_MONOTONIC => Self::Monotonic,
|
|
|
|
ffi::GST_CLOCK_TYPE_OTHER => Self::Other,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CLOCK_TYPE_TAI => Self::Tai,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for ClockType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_clock_type_get_type()) }
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ClockType {
|
|
|
|
type Type = Self;
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ClockType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ClockType {
|
|
|
|
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_enum(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-13 22:40:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstCoreError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum CoreError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_FAILED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Failed,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_TOO_LAZY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
TooLazy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_NOT_IMPLEMENTED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NotImplemented,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_STATE_CHANGE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
StateChange,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_PAD")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Pad,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_THREAD")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Thread,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_NEGOTIATION")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Negotiation,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_EVENT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Event,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_SEEK")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Seek,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_CAPS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Caps,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_TAG")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Tag,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_MISSING_PLUGIN")]
|
2017-07-03 14:52:10 +00:00
|
|
|
MissingPlugin,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_CLOCK")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Clock,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_DISABLED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Disabled,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_CORE_ERROR_NUM_ERRORS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NumErrors,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for CoreError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstCoreError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstCoreError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Failed => ffi::GST_CORE_ERROR_FAILED,
|
|
|
|
Self::TooLazy => ffi::GST_CORE_ERROR_TOO_LAZY,
|
|
|
|
Self::NotImplemented => ffi::GST_CORE_ERROR_NOT_IMPLEMENTED,
|
|
|
|
Self::StateChange => ffi::GST_CORE_ERROR_STATE_CHANGE,
|
|
|
|
Self::Pad => ffi::GST_CORE_ERROR_PAD,
|
|
|
|
Self::Thread => ffi::GST_CORE_ERROR_THREAD,
|
|
|
|
Self::Negotiation => ffi::GST_CORE_ERROR_NEGOTIATION,
|
|
|
|
Self::Event => ffi::GST_CORE_ERROR_EVENT,
|
|
|
|
Self::Seek => ffi::GST_CORE_ERROR_SEEK,
|
|
|
|
Self::Caps => ffi::GST_CORE_ERROR_CAPS,
|
|
|
|
Self::Tag => ffi::GST_CORE_ERROR_TAG,
|
|
|
|
Self::MissingPlugin => ffi::GST_CORE_ERROR_MISSING_PLUGIN,
|
|
|
|
Self::Clock => ffi::GST_CORE_ERROR_CLOCK,
|
|
|
|
Self::Disabled => ffi::GST_CORE_ERROR_DISABLED,
|
|
|
|
Self::NumErrors => ffi::GST_CORE_ERROR_NUM_ERRORS,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstCoreError> for CoreError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstCoreError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CORE_ERROR_FAILED => Self::Failed,
|
|
|
|
ffi::GST_CORE_ERROR_TOO_LAZY => Self::TooLazy,
|
|
|
|
ffi::GST_CORE_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
|
|
|
|
ffi::GST_CORE_ERROR_STATE_CHANGE => Self::StateChange,
|
|
|
|
ffi::GST_CORE_ERROR_PAD => Self::Pad,
|
|
|
|
ffi::GST_CORE_ERROR_THREAD => Self::Thread,
|
|
|
|
ffi::GST_CORE_ERROR_NEGOTIATION => Self::Negotiation,
|
|
|
|
ffi::GST_CORE_ERROR_EVENT => Self::Event,
|
|
|
|
ffi::GST_CORE_ERROR_SEEK => Self::Seek,
|
|
|
|
ffi::GST_CORE_ERROR_CAPS => Self::Caps,
|
|
|
|
ffi::GST_CORE_ERROR_TAG => Self::Tag,
|
|
|
|
ffi::GST_CORE_ERROR_MISSING_PLUGIN => Self::MissingPlugin,
|
|
|
|
ffi::GST_CORE_ERROR_CLOCK => Self::Clock,
|
|
|
|
ffi::GST_CORE_ERROR_DISABLED => Self::Disabled,
|
|
|
|
ffi::GST_CORE_ERROR_NUM_ERRORS => Self::NumErrors,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for CoreError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_core_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_CORE_ERROR_FAILED => Some(Self::Failed),
|
|
|
|
ffi::GST_CORE_ERROR_TOO_LAZY => Some(Self::TooLazy),
|
|
|
|
ffi::GST_CORE_ERROR_NOT_IMPLEMENTED => Some(Self::NotImplemented),
|
|
|
|
ffi::GST_CORE_ERROR_STATE_CHANGE => Some(Self::StateChange),
|
|
|
|
ffi::GST_CORE_ERROR_PAD => Some(Self::Pad),
|
|
|
|
ffi::GST_CORE_ERROR_THREAD => Some(Self::Thread),
|
|
|
|
ffi::GST_CORE_ERROR_NEGOTIATION => Some(Self::Negotiation),
|
|
|
|
ffi::GST_CORE_ERROR_EVENT => Some(Self::Event),
|
|
|
|
ffi::GST_CORE_ERROR_SEEK => Some(Self::Seek),
|
|
|
|
ffi::GST_CORE_ERROR_CAPS => Some(Self::Caps),
|
|
|
|
ffi::GST_CORE_ERROR_TAG => Some(Self::Tag),
|
|
|
|
ffi::GST_CORE_ERROR_MISSING_PLUGIN => Some(Self::MissingPlugin),
|
|
|
|
ffi::GST_CORE_ERROR_CLOCK => Some(Self::Clock),
|
|
|
|
ffi::GST_CORE_ERROR_DISABLED => Some(Self::Disabled),
|
|
|
|
ffi::GST_CORE_ERROR_NUM_ERRORS => Some(Self::NumErrors),
|
2021-04-25 16:45:59 +00:00
|
|
|
_ => Some(Self::Failed),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for CoreError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_core_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for CoreError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for CoreError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for CoreError {
|
|
|
|
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_enum(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-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstDebugLevel")]
|
2017-08-17 12:31:00 +00:00
|
|
|
pub enum DebugLevel {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_NONE")]
|
2017-08-17 12:31:00 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_ERROR")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Error,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_WARNING")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Warning,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_FIXME")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Fixme,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_INFO")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Info,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_DEBUG")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Debug,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_LOG")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Log,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_TRACE")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Trace,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_MEMDUMP")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Memdump,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LEVEL_COUNT")]
|
2017-08-17 12:31:00 +00:00
|
|
|
Count,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl DebugLevel {
|
2021-04-11 19:38:18 +00:00
|
|
|
pub fn name<'a>(self) -> &'a str {
|
2020-12-07 11:11:04 +00:00
|
|
|
unsafe {
|
|
|
|
CStr::from_ptr(
|
2021-04-27 15:10:39 +00:00
|
|
|
ffi::gst_debug_level_get_name(self.into_glib())
|
2020-12-07 11:11:04 +00:00
|
|
|
.as_ref()
|
|
|
|
.expect("gst_debug_level_get_name returned NULL"),
|
|
|
|
)
|
|
|
|
.to_str()
|
|
|
|
.expect("gst_debug_level_get_name returned an invalid string")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for DebugLevel {
|
|
|
|
#[inline]
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2021-04-11 19:38:18 +00:00
|
|
|
f.write_str(&self.name())
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-17 12:31:00 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for DebugLevel {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstDebugLevel;
|
2017-08-17 12:31:00 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstDebugLevel {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_LEVEL_NONE,
|
|
|
|
Self::Error => ffi::GST_LEVEL_ERROR,
|
|
|
|
Self::Warning => ffi::GST_LEVEL_WARNING,
|
|
|
|
Self::Fixme => ffi::GST_LEVEL_FIXME,
|
|
|
|
Self::Info => ffi::GST_LEVEL_INFO,
|
|
|
|
Self::Debug => ffi::GST_LEVEL_DEBUG,
|
|
|
|
Self::Log => ffi::GST_LEVEL_LOG,
|
|
|
|
Self::Trace => ffi::GST_LEVEL_TRACE,
|
|
|
|
Self::Memdump => ffi::GST_LEVEL_MEMDUMP,
|
|
|
|
Self::Count => ffi::GST_LEVEL_COUNT,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstDebugLevel> for DebugLevel {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstDebugLevel) -> Self {
|
2017-08-17 12:31:00 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_LEVEL_NONE => Self::None,
|
|
|
|
ffi::GST_LEVEL_ERROR => Self::Error,
|
|
|
|
ffi::GST_LEVEL_WARNING => Self::Warning,
|
|
|
|
ffi::GST_LEVEL_FIXME => Self::Fixme,
|
|
|
|
ffi::GST_LEVEL_INFO => Self::Info,
|
|
|
|
ffi::GST_LEVEL_DEBUG => Self::Debug,
|
|
|
|
ffi::GST_LEVEL_LOG => Self::Log,
|
|
|
|
ffi::GST_LEVEL_TRACE => Self::Trace,
|
|
|
|
ffi::GST_LEVEL_MEMDUMP => Self::Memdump,
|
|
|
|
ffi::GST_LEVEL_COUNT => Self::Count,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for DebugLevel {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_debug_level_get_type()) }
|
2017-08-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for DebugLevel {
|
|
|
|
type Type = Self;
|
2017-08-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for DebugLevel {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-17 12:31:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for DebugLevel {
|
|
|
|
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_enum(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-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstEventType")]
|
2017-07-30 14:09:51 +00:00
|
|
|
pub enum EventType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_UNKNOWN")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Unknown,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_FLUSH_START")]
|
2017-07-30 14:09:51 +00:00
|
|
|
FlushStart,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_FLUSH_STOP")]
|
2017-07-30 14:09:51 +00:00
|
|
|
FlushStop,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_STREAM_START")]
|
2017-07-30 14:09:51 +00:00
|
|
|
StreamStart,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CAPS")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Caps,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_SEGMENT")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Segment,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_STREAM_COLLECTION")]
|
2017-07-30 14:09:51 +00:00
|
|
|
StreamCollection,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_TAG")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Tag,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_BUFFERSIZE")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Buffersize,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_SINK_MESSAGE")]
|
2017-07-30 14:09:51 +00:00
|
|
|
SinkMessage,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_STREAM_GROUP_DONE")]
|
2017-07-30 14:09:51 +00:00
|
|
|
StreamGroupDone,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_EOS")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Eos,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_TOC")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Toc,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_PROTECTION")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Protection,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_SEGMENT_DONE")]
|
2017-07-30 14:09:51 +00:00
|
|
|
SegmentDone,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_GAP")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Gap,
|
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-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_INSTANT_RATE_CHANGE")]
|
2020-04-30 16:51:41 +00:00
|
|
|
InstantRateChange,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_QOS")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Qos,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_SEEK")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Seek,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_NAVIGATION")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Navigation,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_LATENCY")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Latency,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_STEP")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Step,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_RECONFIGURE")]
|
2017-07-30 14:09:51 +00:00
|
|
|
Reconfigure,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_TOC_SELECT")]
|
2017-07-30 14:09:51 +00:00
|
|
|
TocSelect,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_SELECT_STREAMS")]
|
2017-07-30 14:09:51 +00:00
|
|
|
SelectStreams,
|
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-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_INSTANT_RATE_SYNC_TIME")]
|
2020-04-30 16:51:41 +00:00
|
|
|
InstantRateSyncTime,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_UPSTREAM")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomUpstream,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomDownstream,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_OOB")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomDownstreamOob,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_DOWNSTREAM_STICKY")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomDownstreamSticky,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_BOTH")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomBoth,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_EVENT_CUSTOM_BOTH_OOB")]
|
2017-07-30 14:09:51 +00:00
|
|
|
CustomBothOob,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl EventType {
|
2020-12-08 13:00:17 +00:00
|
|
|
#[doc(alias = "gst_event_type_get_flags")]
|
2021-05-03 18:35:37 +00:00
|
|
|
#[doc(alias = "get_flags")]
|
2021-04-11 19:38:18 +00:00
|
|
|
pub fn flags(self) -> EventTypeFlags {
|
2020-12-07 11:11:04 +00:00
|
|
|
assert_initialized_main_thread!();
|
2021-04-27 15:10:39 +00:00
|
|
|
unsafe { from_glib(ffi::gst_event_type_get_flags(self.into_glib())) }
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
|
2021-04-11 19:38:18 +00:00
|
|
|
pub fn name<'a>(self) -> &'a str {
|
2020-12-07 11:11:04 +00:00
|
|
|
unsafe {
|
|
|
|
CStr::from_ptr(
|
2021-04-27 15:10:39 +00:00
|
|
|
ffi::gst_event_type_get_name(self.into_glib())
|
2020-12-07 11:11:04 +00:00
|
|
|
.as_ref()
|
|
|
|
.expect("gst_event_type_get_name returned NULL"),
|
|
|
|
)
|
|
|
|
.to_str()
|
|
|
|
.expect("gst_event_type_get_name returned an invalid string")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-08 13:00:17 +00:00
|
|
|
#[doc(alias = "gst_event_type_to_quark")]
|
2020-12-07 11:11:04 +00:00
|
|
|
pub fn to_quark(self) -> glib::Quark {
|
|
|
|
assert_initialized_main_thread!();
|
2021-04-27 15:10:39 +00:00
|
|
|
unsafe { from_glib(ffi::gst_event_type_to_quark(self.into_glib())) }
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for EventType {
|
|
|
|
#[inline]
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2021-04-11 19:38:18 +00:00
|
|
|
f.write_str(&self.name())
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-30 14:09:51 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for EventType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstEventType;
|
2017-07-30 14:09:51 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstEventType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Unknown => ffi::GST_EVENT_UNKNOWN,
|
|
|
|
Self::FlushStart => ffi::GST_EVENT_FLUSH_START,
|
|
|
|
Self::FlushStop => ffi::GST_EVENT_FLUSH_STOP,
|
|
|
|
Self::StreamStart => ffi::GST_EVENT_STREAM_START,
|
|
|
|
Self::Caps => ffi::GST_EVENT_CAPS,
|
|
|
|
Self::Segment => ffi::GST_EVENT_SEGMENT,
|
|
|
|
Self::StreamCollection => ffi::GST_EVENT_STREAM_COLLECTION,
|
|
|
|
Self::Tag => ffi::GST_EVENT_TAG,
|
|
|
|
Self::Buffersize => ffi::GST_EVENT_BUFFERSIZE,
|
|
|
|
Self::SinkMessage => ffi::GST_EVENT_SINK_MESSAGE,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::StreamGroupDone => ffi::GST_EVENT_STREAM_GROUP_DONE,
|
|
|
|
Self::Eos => ffi::GST_EVENT_EOS,
|
|
|
|
Self::Toc => ffi::GST_EVENT_TOC,
|
|
|
|
Self::Protection => ffi::GST_EVENT_PROTECTION,
|
|
|
|
Self::SegmentDone => ffi::GST_EVENT_SEGMENT_DONE,
|
|
|
|
Self::Gap => ffi::GST_EVENT_GAP,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::InstantRateChange => ffi::GST_EVENT_INSTANT_RATE_CHANGE,
|
|
|
|
Self::Qos => ffi::GST_EVENT_QOS,
|
|
|
|
Self::Seek => ffi::GST_EVENT_SEEK,
|
|
|
|
Self::Navigation => ffi::GST_EVENT_NAVIGATION,
|
|
|
|
Self::Latency => ffi::GST_EVENT_LATENCY,
|
|
|
|
Self::Step => ffi::GST_EVENT_STEP,
|
|
|
|
Self::Reconfigure => ffi::GST_EVENT_RECONFIGURE,
|
|
|
|
Self::TocSelect => ffi::GST_EVENT_TOC_SELECT,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::SelectStreams => ffi::GST_EVENT_SELECT_STREAMS,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::InstantRateSyncTime => ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME,
|
|
|
|
Self::CustomUpstream => ffi::GST_EVENT_CUSTOM_UPSTREAM,
|
|
|
|
Self::CustomDownstream => ffi::GST_EVENT_CUSTOM_DOWNSTREAM,
|
|
|
|
Self::CustomDownstreamOob => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB,
|
|
|
|
Self::CustomDownstreamSticky => ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY,
|
|
|
|
Self::CustomBoth => ffi::GST_EVENT_CUSTOM_BOTH,
|
|
|
|
Self::CustomBothOob => ffi::GST_EVENT_CUSTOM_BOTH_OOB,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstEventType> for EventType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstEventType) -> Self {
|
2017-07-30 14:09:51 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_EVENT_UNKNOWN => Self::Unknown,
|
|
|
|
ffi::GST_EVENT_FLUSH_START => Self::FlushStart,
|
|
|
|
ffi::GST_EVENT_FLUSH_STOP => Self::FlushStop,
|
|
|
|
ffi::GST_EVENT_STREAM_START => Self::StreamStart,
|
|
|
|
ffi::GST_EVENT_CAPS => Self::Caps,
|
|
|
|
ffi::GST_EVENT_SEGMENT => Self::Segment,
|
|
|
|
ffi::GST_EVENT_STREAM_COLLECTION => Self::StreamCollection,
|
|
|
|
ffi::GST_EVENT_TAG => Self::Tag,
|
|
|
|
ffi::GST_EVENT_BUFFERSIZE => Self::Buffersize,
|
|
|
|
ffi::GST_EVENT_SINK_MESSAGE => Self::SinkMessage,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_EVENT_STREAM_GROUP_DONE => Self::StreamGroupDone,
|
|
|
|
ffi::GST_EVENT_EOS => Self::Eos,
|
|
|
|
ffi::GST_EVENT_TOC => Self::Toc,
|
|
|
|
ffi::GST_EVENT_PROTECTION => Self::Protection,
|
|
|
|
ffi::GST_EVENT_SEGMENT_DONE => Self::SegmentDone,
|
|
|
|
ffi::GST_EVENT_GAP => Self::Gap,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_EVENT_INSTANT_RATE_CHANGE => Self::InstantRateChange,
|
|
|
|
ffi::GST_EVENT_QOS => Self::Qos,
|
|
|
|
ffi::GST_EVENT_SEEK => Self::Seek,
|
|
|
|
ffi::GST_EVENT_NAVIGATION => Self::Navigation,
|
|
|
|
ffi::GST_EVENT_LATENCY => Self::Latency,
|
|
|
|
ffi::GST_EVENT_STEP => Self::Step,
|
|
|
|
ffi::GST_EVENT_RECONFIGURE => Self::Reconfigure,
|
|
|
|
ffi::GST_EVENT_TOC_SELECT => Self::TocSelect,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_10", feature = "dox"))]
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_EVENT_SELECT_STREAMS => Self::SelectStreams,
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_18", feature = "dox"))]
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_EVENT_INSTANT_RATE_SYNC_TIME => Self::InstantRateSyncTime,
|
|
|
|
ffi::GST_EVENT_CUSTOM_UPSTREAM => Self::CustomUpstream,
|
|
|
|
ffi::GST_EVENT_CUSTOM_DOWNSTREAM => Self::CustomDownstream,
|
|
|
|
ffi::GST_EVENT_CUSTOM_DOWNSTREAM_OOB => Self::CustomDownstreamOob,
|
|
|
|
ffi::GST_EVENT_CUSTOM_DOWNSTREAM_STICKY => Self::CustomDownstreamSticky,
|
|
|
|
ffi::GST_EVENT_CUSTOM_BOTH => Self::CustomBoth,
|
|
|
|
ffi::GST_EVENT_CUSTOM_BOTH_OOB => Self::CustomBothOob,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for EventType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_event_type_get_type()) }
|
2017-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for EventType {
|
|
|
|
type Type = Self;
|
2017-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for EventType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-30 14:09:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for EventType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-05 17:16:50 +00:00
|
|
|
#[must_use]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstFlowReturn")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum FlowReturn {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_2")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomSuccess2,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_SUCCESS_1")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomSuccess1,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_SUCCESS")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomSuccess,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_OK")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Ok,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_NOT_LINKED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
NotLinked,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_FLUSHING")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Flushing,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_EOS")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Eos,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_NOT_NEGOTIATED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
NotNegotiated,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_ERROR")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Error,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_NOT_SUPPORTED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
NotSupported,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_ERROR")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomError,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_ERROR_1")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomError1,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FLOW_CUSTOM_ERROR_2")]
|
2017-05-12 12:24:03 +00:00
|
|
|
CustomError2,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for FlowReturn {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstFlowReturn;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstFlowReturn {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::CustomSuccess2 => ffi::GST_FLOW_CUSTOM_SUCCESS_2,
|
|
|
|
Self::CustomSuccess1 => ffi::GST_FLOW_CUSTOM_SUCCESS_1,
|
|
|
|
Self::CustomSuccess => ffi::GST_FLOW_CUSTOM_SUCCESS,
|
|
|
|
Self::Ok => ffi::GST_FLOW_OK,
|
|
|
|
Self::NotLinked => ffi::GST_FLOW_NOT_LINKED,
|
|
|
|
Self::Flushing => ffi::GST_FLOW_FLUSHING,
|
|
|
|
Self::Eos => ffi::GST_FLOW_EOS,
|
|
|
|
Self::NotNegotiated => ffi::GST_FLOW_NOT_NEGOTIATED,
|
|
|
|
Self::Error => ffi::GST_FLOW_ERROR,
|
|
|
|
Self::NotSupported => ffi::GST_FLOW_NOT_SUPPORTED,
|
|
|
|
Self::CustomError => ffi::GST_FLOW_CUSTOM_ERROR,
|
|
|
|
Self::CustomError1 => ffi::GST_FLOW_CUSTOM_ERROR_1,
|
|
|
|
Self::CustomError2 => ffi::GST_FLOW_CUSTOM_ERROR_2,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstFlowReturn> for FlowReturn {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstFlowReturn) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_FLOW_CUSTOM_SUCCESS_2 => Self::CustomSuccess2,
|
|
|
|
ffi::GST_FLOW_CUSTOM_SUCCESS_1 => Self::CustomSuccess1,
|
|
|
|
ffi::GST_FLOW_CUSTOM_SUCCESS => Self::CustomSuccess,
|
|
|
|
ffi::GST_FLOW_OK => Self::Ok,
|
|
|
|
ffi::GST_FLOW_NOT_LINKED => Self::NotLinked,
|
|
|
|
ffi::GST_FLOW_FLUSHING => Self::Flushing,
|
|
|
|
ffi::GST_FLOW_EOS => Self::Eos,
|
|
|
|
ffi::GST_FLOW_NOT_NEGOTIATED => Self::NotNegotiated,
|
|
|
|
ffi::GST_FLOW_ERROR => Self::Error,
|
|
|
|
ffi::GST_FLOW_NOT_SUPPORTED => Self::NotSupported,
|
|
|
|
ffi::GST_FLOW_CUSTOM_ERROR => Self::CustomError,
|
|
|
|
ffi::GST_FLOW_CUSTOM_ERROR_1 => Self::CustomError1,
|
|
|
|
ffi::GST_FLOW_CUSTOM_ERROR_2 => Self::CustomError2,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for FlowReturn {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_flow_return_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for FlowReturn {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for FlowReturn {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for FlowReturn {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstFormat")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum Format {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_UNDEFINED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Undefined,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_DEFAULT")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Default,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_BYTES")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Bytes,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_TIME")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Time,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_BUFFERS")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Buffers,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_FORMAT_PERCENT")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Percent,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl Format {
|
2020-12-08 13:00:17 +00:00
|
|
|
#[doc(alias = "gst_format_get_by_nick")]
|
2021-05-03 18:35:37 +00:00
|
|
|
#[doc(alias = "get_by_nick")]
|
2021-04-19 20:13:58 +00:00
|
|
|
pub fn by_nick(nick: &str) -> Format {
|
2020-12-07 11:11:04 +00:00
|
|
|
assert_initialized_main_thread!();
|
|
|
|
unsafe { from_glib(ffi::gst_format_get_by_nick(nick.to_glib_none().0)) }
|
|
|
|
}
|
|
|
|
|
2020-12-08 13:00:17 +00:00
|
|
|
//#[doc(alias = "gst_format_get_details")]
|
2021-05-03 18:35:37 +00:00
|
|
|
//#[doc(alias = "get_details")]
|
2021-04-19 20:13:58 +00:00
|
|
|
//pub fn details(self) -> /*Ignored*/Option<FormatDefinition> {
|
2020-12-07 11:11:04 +00:00
|
|
|
// unsafe { TODO: call ffi:gst_format_get_details() }
|
|
|
|
//}
|
|
|
|
|
2020-12-08 13:00:17 +00:00
|
|
|
#[doc(alias = "gst_format_get_name")]
|
2021-05-03 18:35:37 +00:00
|
|
|
#[doc(alias = "get_name")]
|
2021-04-11 19:38:18 +00:00
|
|
|
pub fn name(self) -> Option<glib::GString> {
|
2020-12-07 11:11:04 +00:00
|
|
|
assert_initialized_main_thread!();
|
2021-04-27 15:10:39 +00:00
|
|
|
unsafe { from_glib_none(ffi::gst_format_get_name(self.into_glib())) }
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
|
2020-12-08 13:00:17 +00:00
|
|
|
//#[doc(alias = "gst_format_iterate_definitions")]
|
2020-12-07 11:11:04 +00:00
|
|
|
//pub fn iterate_definitions() -> /*Ignored*/Iterator {
|
|
|
|
// unsafe { TODO: call ffi:gst_format_iterate_definitions() }
|
|
|
|
//}
|
|
|
|
|
2020-12-08 13:00:17 +00:00
|
|
|
#[doc(alias = "gst_format_to_quark")]
|
2020-12-07 11:11:04 +00:00
|
|
|
pub fn to_quark(self) -> glib::Quark {
|
|
|
|
assert_initialized_main_thread!();
|
2021-04-27 15:10:39 +00:00
|
|
|
unsafe { from_glib(ffi::gst_format_to_quark(self.into_glib())) }
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-12 12:24:03 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for Format {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstFormat;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstFormat {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Undefined => ffi::GST_FORMAT_UNDEFINED,
|
|
|
|
Self::Default => ffi::GST_FORMAT_DEFAULT,
|
|
|
|
Self::Bytes => ffi::GST_FORMAT_BYTES,
|
|
|
|
Self::Time => ffi::GST_FORMAT_TIME,
|
|
|
|
Self::Buffers => ffi::GST_FORMAT_BUFFERS,
|
|
|
|
Self::Percent => ffi::GST_FORMAT_PERCENT,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstFormat> for Format {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstFormat) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_FORMAT_UNDEFINED => Self::Undefined,
|
|
|
|
ffi::GST_FORMAT_DEFAULT => Self::Default,
|
|
|
|
ffi::GST_FORMAT_BYTES => Self::Bytes,
|
|
|
|
ffi::GST_FORMAT_TIME => Self::Time,
|
|
|
|
ffi::GST_FORMAT_BUFFERS => Self::Buffers,
|
|
|
|
ffi::GST_FORMAT_PERCENT => Self::Percent,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for Format {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_format_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for Format {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for Format {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for Format {
|
|
|
|
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_enum(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-07-29 13:37:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstLibraryError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum LibraryError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_FAILED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Failed,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_TOO_LAZY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
TooLazy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_INIT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Init,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_SHUTDOWN")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Shutdown,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_SETTINGS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Settings,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_ENCODE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Encode,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_LIBRARY_ERROR_NUM_ERRORS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NumErrors,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for LibraryError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstLibraryError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstLibraryError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Failed => ffi::GST_LIBRARY_ERROR_FAILED,
|
|
|
|
Self::TooLazy => ffi::GST_LIBRARY_ERROR_TOO_LAZY,
|
|
|
|
Self::Init => ffi::GST_LIBRARY_ERROR_INIT,
|
|
|
|
Self::Shutdown => ffi::GST_LIBRARY_ERROR_SHUTDOWN,
|
|
|
|
Self::Settings => ffi::GST_LIBRARY_ERROR_SETTINGS,
|
|
|
|
Self::Encode => ffi::GST_LIBRARY_ERROR_ENCODE,
|
|
|
|
Self::NumErrors => ffi::GST_LIBRARY_ERROR_NUM_ERRORS,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstLibraryError> for LibraryError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstLibraryError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_LIBRARY_ERROR_FAILED => Self::Failed,
|
|
|
|
ffi::GST_LIBRARY_ERROR_TOO_LAZY => Self::TooLazy,
|
|
|
|
ffi::GST_LIBRARY_ERROR_INIT => Self::Init,
|
|
|
|
ffi::GST_LIBRARY_ERROR_SHUTDOWN => Self::Shutdown,
|
|
|
|
ffi::GST_LIBRARY_ERROR_SETTINGS => Self::Settings,
|
|
|
|
ffi::GST_LIBRARY_ERROR_ENCODE => Self::Encode,
|
|
|
|
ffi::GST_LIBRARY_ERROR_NUM_ERRORS => Self::NumErrors,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for LibraryError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_library_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_LIBRARY_ERROR_FAILED => Some(Self::Failed),
|
|
|
|
ffi::GST_LIBRARY_ERROR_TOO_LAZY => Some(Self::TooLazy),
|
|
|
|
ffi::GST_LIBRARY_ERROR_INIT => Some(Self::Init),
|
|
|
|
ffi::GST_LIBRARY_ERROR_SHUTDOWN => Some(Self::Shutdown),
|
|
|
|
ffi::GST_LIBRARY_ERROR_SETTINGS => Some(Self::Settings),
|
|
|
|
ffi::GST_LIBRARY_ERROR_ENCODE => Some(Self::Encode),
|
|
|
|
ffi::GST_LIBRARY_ERROR_NUM_ERRORS => Some(Self::NumErrors),
|
2021-04-25 16:45:59 +00:00
|
|
|
_ => Some(Self::Failed),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for LibraryError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_library_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for LibraryError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for LibraryError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for LibraryError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPadDirection")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum PadDirection {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_UNKNOWN")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Unknown,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_SRC")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Src,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_SINK")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Sink,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PadDirection {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPadDirection;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPadDirection {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Unknown => ffi::GST_PAD_UNKNOWN,
|
|
|
|
Self::Src => ffi::GST_PAD_SRC,
|
|
|
|
Self::Sink => ffi::GST_PAD_SINK,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPadDirection> for PadDirection {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPadDirection) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PAD_UNKNOWN => Self::Unknown,
|
|
|
|
ffi::GST_PAD_SRC => Self::Src,
|
|
|
|
ffi::GST_PAD_SINK => Self::Sink,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for PadDirection {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_pad_direction_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PadDirection {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PadDirection {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PadDirection {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-05 17:16:50 +00:00
|
|
|
#[must_use]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPadLinkReturn")]
|
2017-07-05 07:40:02 +00:00
|
|
|
pub enum PadLinkReturn {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_OK")]
|
2017-07-05 07:40:02 +00:00
|
|
|
Ok,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_WRONG_HIERARCHY")]
|
2017-07-05 07:40:02 +00:00
|
|
|
WrongHierarchy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_WAS_LINKED")]
|
2017-07-05 07:40:02 +00:00
|
|
|
WasLinked,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_WRONG_DIRECTION")]
|
2017-07-05 07:40:02 +00:00
|
|
|
WrongDirection,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_NOFORMAT")]
|
2017-07-05 07:40:02 +00:00
|
|
|
Noformat,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_NOSCHED")]
|
2017-07-05 07:40:02 +00:00
|
|
|
Nosched,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_LINK_REFUSED")]
|
2017-07-05 07:40:02 +00:00
|
|
|
Refused,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PadLinkReturn {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPadLinkReturn;
|
2017-07-05 07:40:02 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPadLinkReturn {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Ok => ffi::GST_PAD_LINK_OK,
|
|
|
|
Self::WrongHierarchy => ffi::GST_PAD_LINK_WRONG_HIERARCHY,
|
|
|
|
Self::WasLinked => ffi::GST_PAD_LINK_WAS_LINKED,
|
|
|
|
Self::WrongDirection => ffi::GST_PAD_LINK_WRONG_DIRECTION,
|
|
|
|
Self::Noformat => ffi::GST_PAD_LINK_NOFORMAT,
|
|
|
|
Self::Nosched => ffi::GST_PAD_LINK_NOSCHED,
|
|
|
|
Self::Refused => ffi::GST_PAD_LINK_REFUSED,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-05 07:40:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPadLinkReturn> for PadLinkReturn {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPadLinkReturn) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PAD_LINK_OK => Self::Ok,
|
|
|
|
ffi::GST_PAD_LINK_WRONG_HIERARCHY => Self::WrongHierarchy,
|
|
|
|
ffi::GST_PAD_LINK_WAS_LINKED => Self::WasLinked,
|
|
|
|
ffi::GST_PAD_LINK_WRONG_DIRECTION => Self::WrongDirection,
|
|
|
|
ffi::GST_PAD_LINK_NOFORMAT => Self::Noformat,
|
|
|
|
ffi::GST_PAD_LINK_NOSCHED => Self::Nosched,
|
|
|
|
ffi::GST_PAD_LINK_REFUSED => Self::Refused,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-05 07:40:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for PadLinkReturn {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_pad_link_return_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PadLinkReturn {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PadLinkReturn {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PadLinkReturn {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPadMode")]
|
2017-07-29 11:58:54 +00:00
|
|
|
pub enum PadMode {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_MODE_NONE")]
|
2017-07-29 11:58:54 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_MODE_PUSH")]
|
2017-07-29 11:58:54 +00:00
|
|
|
Push,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_MODE_PULL")]
|
2017-07-29 11:58:54 +00:00
|
|
|
Pull,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl PadMode {
|
2021-04-11 19:38:18 +00:00
|
|
|
pub fn name<'a>(self) -> &'a str {
|
2020-12-07 11:11:04 +00:00
|
|
|
unsafe {
|
|
|
|
CStr::from_ptr(
|
2021-04-27 15:10:39 +00:00
|
|
|
ffi::gst_pad_mode_get_name(self.into_glib())
|
2020-12-07 11:11:04 +00:00
|
|
|
.as_ref()
|
|
|
|
.expect("gst_pad_mode_get_name returned NULL"),
|
|
|
|
)
|
|
|
|
.to_str()
|
|
|
|
.expect("gst_pad_mode_get_name returned an invalid string")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for PadMode {
|
|
|
|
#[inline]
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2021-04-11 19:38:18 +00:00
|
|
|
f.write_str(&self.name())
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-29 11:58:54 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PadMode {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPadMode;
|
2017-07-29 11:58:54 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPadMode {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_PAD_MODE_NONE,
|
|
|
|
Self::Push => ffi::GST_PAD_MODE_PUSH,
|
|
|
|
Self::Pull => ffi::GST_PAD_MODE_PULL,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPadMode> for PadMode {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPadMode) -> Self {
|
2017-07-29 11:58:54 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PAD_MODE_NONE => Self::None,
|
|
|
|
ffi::GST_PAD_MODE_PUSH => Self::Push,
|
|
|
|
ffi::GST_PAD_MODE_PULL => Self::Pull,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for PadMode {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_pad_mode_get_type()) }
|
2017-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PadMode {
|
|
|
|
type Type = Self;
|
2017-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PadMode {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PadMode {
|
|
|
|
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_enum(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-07-29 11:58:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPadPresence")]
|
2017-07-10 21:02:08 +00:00
|
|
|
pub enum PadPresence {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_ALWAYS")]
|
2017-07-10 21:02:08 +00:00
|
|
|
Always,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_SOMETIMES")]
|
2017-07-10 21:02:08 +00:00
|
|
|
Sometimes,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_REQUEST")]
|
2017-07-10 21:02:08 +00:00
|
|
|
Request,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PadPresence {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPadPresence;
|
2017-07-10 21:02:08 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPadPresence {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Always => ffi::GST_PAD_ALWAYS,
|
|
|
|
Self::Sometimes => ffi::GST_PAD_SOMETIMES,
|
|
|
|
Self::Request => ffi::GST_PAD_REQUEST,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-10 21:02:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPadPresence> for PadPresence {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPadPresence) -> Self {
|
2017-07-10 21:02:08 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PAD_ALWAYS => Self::Always,
|
|
|
|
ffi::GST_PAD_SOMETIMES => Self::Sometimes,
|
|
|
|
ffi::GST_PAD_REQUEST => Self::Request,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-10 21:02:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for PadPresence {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_pad_presence_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PadPresence {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PadPresence {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PadPresence {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPadProbeReturn")]
|
2017-07-24 08:51:14 +00:00
|
|
|
pub enum PadProbeReturn {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_PROBE_DROP")]
|
2017-07-24 08:51:14 +00:00
|
|
|
Drop,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_PROBE_OK")]
|
2017-07-24 08:51:14 +00:00
|
|
|
Ok,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_PROBE_REMOVE")]
|
2017-07-24 08:51:14 +00:00
|
|
|
Remove,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_PROBE_PASS")]
|
2017-07-24 08:51:14 +00:00
|
|
|
Pass,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PAD_PROBE_HANDLED")]
|
2017-07-24 08:51:14 +00:00
|
|
|
Handled,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PadProbeReturn {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPadProbeReturn;
|
2017-07-24 08:51:14 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPadProbeReturn {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Drop => ffi::GST_PAD_PROBE_DROP,
|
|
|
|
Self::Ok => ffi::GST_PAD_PROBE_OK,
|
|
|
|
Self::Remove => ffi::GST_PAD_PROBE_REMOVE,
|
|
|
|
Self::Pass => ffi::GST_PAD_PROBE_PASS,
|
|
|
|
Self::Handled => ffi::GST_PAD_PROBE_HANDLED,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPadProbeReturn> for PadProbeReturn {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPadProbeReturn) -> Self {
|
2017-07-24 08:51:14 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PAD_PROBE_DROP => Self::Drop,
|
|
|
|
ffi::GST_PAD_PROBE_OK => Self::Ok,
|
|
|
|
ffi::GST_PAD_PROBE_REMOVE => Self::Remove,
|
|
|
|
ffi::GST_PAD_PROBE_PASS => Self::Pass,
|
|
|
|
ffi::GST_PAD_PROBE_HANDLED => Self::Handled,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for PadProbeReturn {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_pad_probe_return_get_type()) }
|
2017-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PadProbeReturn {
|
|
|
|
type Type = Self;
|
2017-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PadProbeReturn {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PadProbeReturn {
|
|
|
|
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_enum(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-07-24 08:51:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstParseError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum ParseError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_SYNTAX")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Syntax,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_NO_SUCH_ELEMENT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NoSuchElement,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_NO_SUCH_PROPERTY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NoSuchProperty,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_LINK")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Link,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
CouldNotSetProperty,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_EMPTY_BIN")]
|
2017-07-03 14:52:10 +00:00
|
|
|
EmptyBin,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_EMPTY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Empty,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PARSE_ERROR_DELAYED_LINK")]
|
2017-07-03 14:52:10 +00:00
|
|
|
DelayedLink,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ParseError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstParseError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstParseError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Syntax => ffi::GST_PARSE_ERROR_SYNTAX,
|
|
|
|
Self::NoSuchElement => ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT,
|
|
|
|
Self::NoSuchProperty => ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY,
|
|
|
|
Self::Link => ffi::GST_PARSE_ERROR_LINK,
|
|
|
|
Self::CouldNotSetProperty => ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
|
|
|
|
Self::EmptyBin => ffi::GST_PARSE_ERROR_EMPTY_BIN,
|
|
|
|
Self::Empty => ffi::GST_PARSE_ERROR_EMPTY,
|
|
|
|
Self::DelayedLink => ffi::GST_PARSE_ERROR_DELAYED_LINK,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstParseError> for ParseError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstParseError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PARSE_ERROR_SYNTAX => Self::Syntax,
|
|
|
|
ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT => Self::NoSuchElement,
|
|
|
|
ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY => Self::NoSuchProperty,
|
|
|
|
ffi::GST_PARSE_ERROR_LINK => Self::Link,
|
|
|
|
ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY => Self::CouldNotSetProperty,
|
|
|
|
ffi::GST_PARSE_ERROR_EMPTY_BIN => Self::EmptyBin,
|
|
|
|
ffi::GST_PARSE_ERROR_EMPTY => Self::Empty,
|
|
|
|
ffi::GST_PARSE_ERROR_DELAYED_LINK => Self::DelayedLink,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for ParseError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_parse_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PARSE_ERROR_SYNTAX => Some(Self::Syntax),
|
|
|
|
ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT => Some(Self::NoSuchElement),
|
|
|
|
ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY => Some(Self::NoSuchProperty),
|
|
|
|
ffi::GST_PARSE_ERROR_LINK => Some(Self::Link),
|
|
|
|
ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY => Some(Self::CouldNotSetProperty),
|
|
|
|
ffi::GST_PARSE_ERROR_EMPTY_BIN => Some(Self::EmptyBin),
|
|
|
|
ffi::GST_PARSE_ERROR_EMPTY => Some(Self::Empty),
|
|
|
|
ffi::GST_PARSE_ERROR_DELAYED_LINK => Some(Self::DelayedLink),
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Some(Self::__Unknown(value)),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for ParseError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_parse_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ParseError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ParseError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ParseError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPluginError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum PluginError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PLUGIN_ERROR_MODULE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Module,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PLUGIN_ERROR_DEPENDENCIES")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Dependencies,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PLUGIN_ERROR_NAME_MISMATCH")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NameMismatch,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PluginError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPluginError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPluginError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Module => ffi::GST_PLUGIN_ERROR_MODULE,
|
|
|
|
Self::Dependencies => ffi::GST_PLUGIN_ERROR_DEPENDENCIES,
|
|
|
|
Self::NameMismatch => ffi::GST_PLUGIN_ERROR_NAME_MISMATCH,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPluginError> for PluginError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPluginError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PLUGIN_ERROR_MODULE => Self::Module,
|
|
|
|
ffi::GST_PLUGIN_ERROR_DEPENDENCIES => Self::Dependencies,
|
|
|
|
ffi::GST_PLUGIN_ERROR_NAME_MISMATCH => Self::NameMismatch,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for PluginError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_plugin_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PLUGIN_ERROR_MODULE => Some(Self::Module),
|
|
|
|
ffi::GST_PLUGIN_ERROR_DEPENDENCIES => Some(Self::Dependencies),
|
|
|
|
ffi::GST_PLUGIN_ERROR_NAME_MISMATCH => Some(Self::NameMismatch),
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Some(Self::__Unknown(value)),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for PluginError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_plugin_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PluginError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PluginError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PluginError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstProgressType")]
|
2017-07-07 11:38:00 +00:00
|
|
|
pub enum ProgressType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROGRESS_TYPE_START")]
|
2017-07-07 11:38:00 +00:00
|
|
|
Start,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROGRESS_TYPE_CONTINUE")]
|
2017-07-07 11:38:00 +00:00
|
|
|
Continue,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROGRESS_TYPE_COMPLETE")]
|
2017-07-07 11:38:00 +00:00
|
|
|
Complete,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROGRESS_TYPE_CANCELED")]
|
2017-07-07 11:38:00 +00:00
|
|
|
Canceled,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROGRESS_TYPE_ERROR")]
|
2017-07-07 11:38:00 +00:00
|
|
|
Error,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ProgressType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstProgressType;
|
2017-07-07 11:38:00 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstProgressType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Start => ffi::GST_PROGRESS_TYPE_START,
|
|
|
|
Self::Continue => ffi::GST_PROGRESS_TYPE_CONTINUE,
|
|
|
|
Self::Complete => ffi::GST_PROGRESS_TYPE_COMPLETE,
|
|
|
|
Self::Canceled => ffi::GST_PROGRESS_TYPE_CANCELED,
|
|
|
|
Self::Error => ffi::GST_PROGRESS_TYPE_ERROR,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-07 11:38:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstProgressType> for ProgressType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstProgressType) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PROGRESS_TYPE_START => Self::Start,
|
|
|
|
ffi::GST_PROGRESS_TYPE_CONTINUE => Self::Continue,
|
|
|
|
ffi::GST_PROGRESS_TYPE_COMPLETE => Self::Complete,
|
|
|
|
ffi::GST_PROGRESS_TYPE_CANCELED => Self::Canceled,
|
|
|
|
ffi::GST_PROGRESS_TYPE_ERROR => Self::Error,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-07 11:38:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for ProgressType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_progress_type_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ProgressType {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ProgressType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ProgressType {
|
|
|
|
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_enum(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-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstPromiseResult")]
|
2018-03-15 09:43:35 +00:00
|
|
|
pub enum PromiseResult {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROMISE_RESULT_PENDING")]
|
2018-03-15 09:43:35 +00:00
|
|
|
Pending,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROMISE_RESULT_INTERRUPTED")]
|
2018-03-15 09:43:35 +00:00
|
|
|
Interrupted,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROMISE_RESULT_REPLIED")]
|
2018-03-15 09:43:35 +00:00
|
|
|
Replied,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_PROMISE_RESULT_EXPIRED")]
|
2018-03-15 09:43:35 +00:00
|
|
|
Expired,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2018-03-15 09:43:35 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for PromiseResult {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstPromiseResult;
|
2018-03-15 09:43:35 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstPromiseResult {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Pending => ffi::GST_PROMISE_RESULT_PENDING,
|
|
|
|
Self::Interrupted => ffi::GST_PROMISE_RESULT_INTERRUPTED,
|
|
|
|
Self::Replied => ffi::GST_PROMISE_RESULT_REPLIED,
|
|
|
|
Self::Expired => ffi::GST_PROMISE_RESULT_EXPIRED,
|
|
|
|
Self::__Unknown(value) => value,
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2018-03-15 09:43:35 +00:00
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstPromiseResult> for PromiseResult {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstPromiseResult) -> Self {
|
2018-03-15 09:43:35 +00:00
|
|
|
skip_assert_initialized!();
|
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_PROMISE_RESULT_PENDING => Self::Pending,
|
|
|
|
ffi::GST_PROMISE_RESULT_INTERRUPTED => Self::Interrupted,
|
|
|
|
ffi::GST_PROMISE_RESULT_REPLIED => Self::Replied,
|
|
|
|
ffi::GST_PROMISE_RESULT_EXPIRED => Self::Expired,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2018-03-15 09:43:35 +00:00
|
|
|
impl StaticType for PromiseResult {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_promise_result_get_type()) }
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for PromiseResult {
|
|
|
|
type Type = Self;
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for PromiseResult {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-27 13:37:24 +00:00
|
|
|
#[cfg(any(feature = "v1_14", feature = "dox"))]
|
|
|
|
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_14")))]
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for PromiseResult {
|
|
|
|
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_enum(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()
|
2018-03-15 09:43:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstQOSType")]
|
2017-07-30 14:06:44 +00:00
|
|
|
pub enum QOSType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_QOS_TYPE_OVERFLOW")]
|
2017-07-30 14:06:44 +00:00
|
|
|
Overflow,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_QOS_TYPE_UNDERFLOW")]
|
2017-07-30 14:06:44 +00:00
|
|
|
Underflow,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_QOS_TYPE_THROTTLE")]
|
2017-07-30 14:06:44 +00:00
|
|
|
Throttle,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for QOSType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstQOSType;
|
2017-07-30 14:06:44 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstQOSType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Overflow => ffi::GST_QOS_TYPE_OVERFLOW,
|
|
|
|
Self::Underflow => ffi::GST_QOS_TYPE_UNDERFLOW,
|
|
|
|
Self::Throttle => ffi::GST_QOS_TYPE_THROTTLE,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstQOSType> for QOSType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstQOSType) -> Self {
|
2017-07-30 14:06:44 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_QOS_TYPE_OVERFLOW => Self::Overflow,
|
|
|
|
ffi::GST_QOS_TYPE_UNDERFLOW => Self::Underflow,
|
|
|
|
ffi::GST_QOS_TYPE_THROTTLE => Self::Throttle,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for QOSType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_qos_type_get_type()) }
|
2017-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for QOSType {
|
|
|
|
type Type = Self;
|
2017-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for QOSType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-30 14:06:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for QOSType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstRank")]
|
2017-08-14 19:18:34 +00:00
|
|
|
pub enum Rank {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RANK_NONE")]
|
2017-08-14 19:18:34 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RANK_MARGINAL")]
|
2017-08-14 19:18:34 +00:00
|
|
|
Marginal,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RANK_SECONDARY")]
|
2017-08-14 19:18:34 +00:00
|
|
|
Secondary,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RANK_PRIMARY")]
|
2017-08-14 19:18:34 +00:00
|
|
|
Primary,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for Rank {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstRank;
|
2017-08-14 19:18:34 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstRank {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_RANK_NONE,
|
|
|
|
Self::Marginal => ffi::GST_RANK_MARGINAL,
|
|
|
|
Self::Secondary => ffi::GST_RANK_SECONDARY,
|
|
|
|
Self::Primary => ffi::GST_RANK_PRIMARY,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstRank> for Rank {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstRank) -> Self {
|
2017-08-14 19:18:34 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_RANK_NONE => Self::None,
|
|
|
|
ffi::GST_RANK_MARGINAL => Self::Marginal,
|
|
|
|
ffi::GST_RANK_SECONDARY => Self::Secondary,
|
|
|
|
ffi::GST_RANK_PRIMARY => Self::Primary,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for Rank {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_rank_get_type()) }
|
2017-08-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for Rank {
|
|
|
|
type Type = Self;
|
2017-08-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for Rank {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for Rank {
|
|
|
|
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_enum(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-14 19:18:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstResourceError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum ResourceError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_FAILED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Failed,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_TOO_LAZY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
TooLazy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_NOT_FOUND")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NotFound,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_BUSY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Busy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ")]
|
2017-07-03 14:52:10 +00:00
|
|
|
OpenRead,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_OPEN_WRITE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
OpenWrite,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_OPEN_READ_WRITE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
OpenReadWrite,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_CLOSE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Close,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_READ")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Read,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_WRITE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Write,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_SEEK")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Seek,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_SYNC")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Sync,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_SETTINGS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Settings,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_NO_SPACE_LEFT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NoSpaceLeft,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_NOT_AUTHORIZED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NotAuthorized,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_RESOURCE_ERROR_NUM_ERRORS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NumErrors,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for ResourceError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstResourceError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstResourceError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Failed => ffi::GST_RESOURCE_ERROR_FAILED,
|
|
|
|
Self::TooLazy => ffi::GST_RESOURCE_ERROR_TOO_LAZY,
|
|
|
|
Self::NotFound => ffi::GST_RESOURCE_ERROR_NOT_FOUND,
|
|
|
|
Self::Busy => ffi::GST_RESOURCE_ERROR_BUSY,
|
|
|
|
Self::OpenRead => ffi::GST_RESOURCE_ERROR_OPEN_READ,
|
|
|
|
Self::OpenWrite => ffi::GST_RESOURCE_ERROR_OPEN_WRITE,
|
|
|
|
Self::OpenReadWrite => ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE,
|
|
|
|
Self::Close => ffi::GST_RESOURCE_ERROR_CLOSE,
|
|
|
|
Self::Read => ffi::GST_RESOURCE_ERROR_READ,
|
|
|
|
Self::Write => ffi::GST_RESOURCE_ERROR_WRITE,
|
|
|
|
Self::Seek => ffi::GST_RESOURCE_ERROR_SEEK,
|
|
|
|
Self::Sync => ffi::GST_RESOURCE_ERROR_SYNC,
|
|
|
|
Self::Settings => ffi::GST_RESOURCE_ERROR_SETTINGS,
|
|
|
|
Self::NoSpaceLeft => ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT,
|
|
|
|
Self::NotAuthorized => ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED,
|
|
|
|
Self::NumErrors => ffi::GST_RESOURCE_ERROR_NUM_ERRORS,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstResourceError> for ResourceError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstResourceError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_RESOURCE_ERROR_FAILED => Self::Failed,
|
|
|
|
ffi::GST_RESOURCE_ERROR_TOO_LAZY => Self::TooLazy,
|
|
|
|
ffi::GST_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
|
|
|
|
ffi::GST_RESOURCE_ERROR_BUSY => Self::Busy,
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_READ => Self::OpenRead,
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_WRITE => Self::OpenWrite,
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE => Self::OpenReadWrite,
|
|
|
|
ffi::GST_RESOURCE_ERROR_CLOSE => Self::Close,
|
|
|
|
ffi::GST_RESOURCE_ERROR_READ => Self::Read,
|
|
|
|
ffi::GST_RESOURCE_ERROR_WRITE => Self::Write,
|
|
|
|
ffi::GST_RESOURCE_ERROR_SEEK => Self::Seek,
|
|
|
|
ffi::GST_RESOURCE_ERROR_SYNC => Self::Sync,
|
|
|
|
ffi::GST_RESOURCE_ERROR_SETTINGS => Self::Settings,
|
|
|
|
ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT => Self::NoSpaceLeft,
|
|
|
|
ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
|
|
|
|
ffi::GST_RESOURCE_ERROR_NUM_ERRORS => Self::NumErrors,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for ResourceError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_resource_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_RESOURCE_ERROR_FAILED => Some(Self::Failed),
|
|
|
|
ffi::GST_RESOURCE_ERROR_TOO_LAZY => Some(Self::TooLazy),
|
|
|
|
ffi::GST_RESOURCE_ERROR_NOT_FOUND => Some(Self::NotFound),
|
|
|
|
ffi::GST_RESOURCE_ERROR_BUSY => Some(Self::Busy),
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_READ => Some(Self::OpenRead),
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_WRITE => Some(Self::OpenWrite),
|
|
|
|
ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE => Some(Self::OpenReadWrite),
|
|
|
|
ffi::GST_RESOURCE_ERROR_CLOSE => Some(Self::Close),
|
|
|
|
ffi::GST_RESOURCE_ERROR_READ => Some(Self::Read),
|
|
|
|
ffi::GST_RESOURCE_ERROR_WRITE => Some(Self::Write),
|
|
|
|
ffi::GST_RESOURCE_ERROR_SEEK => Some(Self::Seek),
|
|
|
|
ffi::GST_RESOURCE_ERROR_SYNC => Some(Self::Sync),
|
|
|
|
ffi::GST_RESOURCE_ERROR_SETTINGS => Some(Self::Settings),
|
|
|
|
ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT => Some(Self::NoSpaceLeft),
|
|
|
|
ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED => Some(Self::NotAuthorized),
|
|
|
|
ffi::GST_RESOURCE_ERROR_NUM_ERRORS => Some(Self::NumErrors),
|
2021-04-25 16:45:59 +00:00
|
|
|
_ => Some(Self::Failed),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for ResourceError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_resource_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for ResourceError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for ResourceError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for ResourceError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstSeekType")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum SeekType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_SEEK_TYPE_NONE")]
|
2017-05-12 12:24:03 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_SEEK_TYPE_SET")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Set,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_SEEK_TYPE_END")]
|
2017-05-12 12:24:03 +00:00
|
|
|
End,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for SeekType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstSeekType;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstSeekType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_SEEK_TYPE_NONE,
|
|
|
|
Self::Set => ffi::GST_SEEK_TYPE_SET,
|
|
|
|
Self::End => ffi::GST_SEEK_TYPE_END,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstSeekType> for SeekType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstSeekType) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_SEEK_TYPE_NONE => Self::None,
|
|
|
|
ffi::GST_SEEK_TYPE_SET => Self::Set,
|
|
|
|
ffi::GST_SEEK_TYPE_END => Self::End,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for SeekType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_seek_type_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for SeekType {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for SeekType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for SeekType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstState")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum State {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_VOID_PENDING")]
|
2017-05-12 12:24:03 +00:00
|
|
|
VoidPending,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_NULL")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Null,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_READY")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Ready,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_PAUSED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Paused,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_PLAYING")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Playing,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for State {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstState;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstState {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::VoidPending => ffi::GST_STATE_VOID_PENDING,
|
|
|
|
Self::Null => ffi::GST_STATE_NULL,
|
|
|
|
Self::Ready => ffi::GST_STATE_READY,
|
|
|
|
Self::Paused => ffi::GST_STATE_PAUSED,
|
|
|
|
Self::Playing => ffi::GST_STATE_PLAYING,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstState> for State {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstState) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STATE_VOID_PENDING => Self::VoidPending,
|
|
|
|
ffi::GST_STATE_NULL => Self::Null,
|
|
|
|
ffi::GST_STATE_READY => Self::Ready,
|
|
|
|
ffi::GST_STATE_PAUSED => Self::Paused,
|
|
|
|
ffi::GST_STATE_PLAYING => Self::Playing,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for State {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_state_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for State {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for State {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for State {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstStateChange")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum StateChange {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_NULL_TO_READY")]
|
2017-05-12 12:24:03 +00:00
|
|
|
NullToReady,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_READY_TO_PAUSED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
ReadyToPaused,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PLAYING")]
|
2017-05-12 12:24:03 +00:00
|
|
|
PausedToPlaying,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PAUSED")]
|
2017-05-12 12:24:03 +00:00
|
|
|
PlayingToPaused,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_READY")]
|
2017-05-12 12:24:03 +00:00
|
|
|
PausedToReady,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_READY_TO_NULL")]
|
2017-05-12 12:24:03 +00:00
|
|
|
ReadyToNull,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_NULL_TO_NULL")]
|
2018-03-15 08:39:12 +00:00
|
|
|
NullToNull,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_READY_TO_READY")]
|
2018-03-15 08:39:12 +00:00
|
|
|
ReadyToReady,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_PAUSED_TO_PAUSED")]
|
2018-03-15 08:39:12 +00:00
|
|
|
PausedToPaused,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_PLAYING_TO_PLAYING")]
|
2018-03-15 08:39:12 +00:00
|
|
|
PlayingToPlaying,
|
2017-05-12 12:24:03 +00:00
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl fmt::Display for StateChange {
|
|
|
|
#[inline]
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2021-04-11 19:38:18 +00:00
|
|
|
f.write_str(&self.name())
|
2020-12-07 11:11:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-12 12:24:03 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for StateChange {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstStateChange;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstStateChange {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::NullToReady => ffi::GST_STATE_CHANGE_NULL_TO_READY,
|
|
|
|
Self::ReadyToPaused => ffi::GST_STATE_CHANGE_READY_TO_PAUSED,
|
|
|
|
Self::PausedToPlaying => ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING,
|
|
|
|
Self::PlayingToPaused => ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED,
|
|
|
|
Self::PausedToReady => ffi::GST_STATE_CHANGE_PAUSED_TO_READY,
|
|
|
|
Self::ReadyToNull => ffi::GST_STATE_CHANGE_READY_TO_NULL,
|
|
|
|
Self::NullToNull => ffi::GST_STATE_CHANGE_NULL_TO_NULL,
|
|
|
|
Self::ReadyToReady => ffi::GST_STATE_CHANGE_READY_TO_READY,
|
|
|
|
Self::PausedToPaused => ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED,
|
|
|
|
Self::PlayingToPlaying => ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstStateChange> for StateChange {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstStateChange) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STATE_CHANGE_NULL_TO_READY => Self::NullToReady,
|
|
|
|
ffi::GST_STATE_CHANGE_READY_TO_PAUSED => Self::ReadyToPaused,
|
|
|
|
ffi::GST_STATE_CHANGE_PAUSED_TO_PLAYING => Self::PausedToPlaying,
|
|
|
|
ffi::GST_STATE_CHANGE_PLAYING_TO_PAUSED => Self::PlayingToPaused,
|
|
|
|
ffi::GST_STATE_CHANGE_PAUSED_TO_READY => Self::PausedToReady,
|
|
|
|
ffi::GST_STATE_CHANGE_READY_TO_NULL => Self::ReadyToNull,
|
|
|
|
ffi::GST_STATE_CHANGE_NULL_TO_NULL => Self::NullToNull,
|
|
|
|
ffi::GST_STATE_CHANGE_READY_TO_READY => Self::ReadyToReady,
|
|
|
|
ffi::GST_STATE_CHANGE_PAUSED_TO_PAUSED => Self::PausedToPaused,
|
|
|
|
ffi::GST_STATE_CHANGE_PLAYING_TO_PLAYING => Self::PlayingToPlaying,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for StateChange {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_state_change_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for StateChange {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for StateChange {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for StateChange {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-05 17:16:50 +00:00
|
|
|
#[must_use]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstStateChangeReturn")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum StateChangeReturn {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_FAILURE")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Failure,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_SUCCESS")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Success,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_ASYNC")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Async,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STATE_CHANGE_NO_PREROLL")]
|
2017-05-12 12:24:03 +00:00
|
|
|
NoPreroll,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for StateChangeReturn {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstStateChangeReturn;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstStateChangeReturn {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Failure => ffi::GST_STATE_CHANGE_FAILURE,
|
|
|
|
Self::Success => ffi::GST_STATE_CHANGE_SUCCESS,
|
|
|
|
Self::Async => ffi::GST_STATE_CHANGE_ASYNC,
|
|
|
|
Self::NoPreroll => ffi::GST_STATE_CHANGE_NO_PREROLL,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstStateChangeReturn> for StateChangeReturn {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstStateChangeReturn) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STATE_CHANGE_FAILURE => Self::Failure,
|
|
|
|
ffi::GST_STATE_CHANGE_SUCCESS => Self::Success,
|
|
|
|
ffi::GST_STATE_CHANGE_ASYNC => Self::Async,
|
|
|
|
ffi::GST_STATE_CHANGE_NO_PREROLL => Self::NoPreroll,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for StateChangeReturn {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_state_change_return_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for StateChangeReturn {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for StateChangeReturn {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for StateChangeReturn {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstStreamError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum StreamError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_FAILED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Failed,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_TOO_LAZY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
TooLazy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_NOT_IMPLEMENTED")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NotImplemented,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_TYPE_NOT_FOUND")]
|
2017-07-03 14:52:10 +00:00
|
|
|
TypeNotFound,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_WRONG_TYPE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
WrongType,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_CODEC_NOT_FOUND")]
|
2017-07-03 14:52:10 +00:00
|
|
|
CodecNotFound,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_DECODE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Decode,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_ENCODE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Encode,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_DEMUX")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Demux,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_MUX")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Mux,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_FORMAT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Format,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_DECRYPT")]
|
2017-07-03 14:52:10 +00:00
|
|
|
Decrypt,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_DECRYPT_NOKEY")]
|
2017-07-03 14:52:10 +00:00
|
|
|
DecryptNokey,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_ERROR_NUM_ERRORS")]
|
2017-07-03 14:52:10 +00:00
|
|
|
NumErrors,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for StreamError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstStreamError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstStreamError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Failed => ffi::GST_STREAM_ERROR_FAILED,
|
|
|
|
Self::TooLazy => ffi::GST_STREAM_ERROR_TOO_LAZY,
|
|
|
|
Self::NotImplemented => ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED,
|
|
|
|
Self::TypeNotFound => ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND,
|
|
|
|
Self::WrongType => ffi::GST_STREAM_ERROR_WRONG_TYPE,
|
|
|
|
Self::CodecNotFound => ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND,
|
|
|
|
Self::Decode => ffi::GST_STREAM_ERROR_DECODE,
|
|
|
|
Self::Encode => ffi::GST_STREAM_ERROR_ENCODE,
|
|
|
|
Self::Demux => ffi::GST_STREAM_ERROR_DEMUX,
|
|
|
|
Self::Mux => ffi::GST_STREAM_ERROR_MUX,
|
|
|
|
Self::Format => ffi::GST_STREAM_ERROR_FORMAT,
|
|
|
|
Self::Decrypt => ffi::GST_STREAM_ERROR_DECRYPT,
|
|
|
|
Self::DecryptNokey => ffi::GST_STREAM_ERROR_DECRYPT_NOKEY,
|
|
|
|
Self::NumErrors => ffi::GST_STREAM_ERROR_NUM_ERRORS,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstStreamError> for StreamError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstStreamError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STREAM_ERROR_FAILED => Self::Failed,
|
|
|
|
ffi::GST_STREAM_ERROR_TOO_LAZY => Self::TooLazy,
|
|
|
|
ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
|
|
|
|
ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND => Self::TypeNotFound,
|
|
|
|
ffi::GST_STREAM_ERROR_WRONG_TYPE => Self::WrongType,
|
|
|
|
ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND => Self::CodecNotFound,
|
|
|
|
ffi::GST_STREAM_ERROR_DECODE => Self::Decode,
|
|
|
|
ffi::GST_STREAM_ERROR_ENCODE => Self::Encode,
|
|
|
|
ffi::GST_STREAM_ERROR_DEMUX => Self::Demux,
|
|
|
|
ffi::GST_STREAM_ERROR_MUX => Self::Mux,
|
|
|
|
ffi::GST_STREAM_ERROR_FORMAT => Self::Format,
|
|
|
|
ffi::GST_STREAM_ERROR_DECRYPT => Self::Decrypt,
|
|
|
|
ffi::GST_STREAM_ERROR_DECRYPT_NOKEY => Self::DecryptNokey,
|
|
|
|
ffi::GST_STREAM_ERROR_NUM_ERRORS => Self::NumErrors,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for StreamError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_stream_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STREAM_ERROR_FAILED => Some(Self::Failed),
|
|
|
|
ffi::GST_STREAM_ERROR_TOO_LAZY => Some(Self::TooLazy),
|
|
|
|
ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED => Some(Self::NotImplemented),
|
|
|
|
ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND => Some(Self::TypeNotFound),
|
|
|
|
ffi::GST_STREAM_ERROR_WRONG_TYPE => Some(Self::WrongType),
|
|
|
|
ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND => Some(Self::CodecNotFound),
|
|
|
|
ffi::GST_STREAM_ERROR_DECODE => Some(Self::Decode),
|
|
|
|
ffi::GST_STREAM_ERROR_ENCODE => Some(Self::Encode),
|
|
|
|
ffi::GST_STREAM_ERROR_DEMUX => Some(Self::Demux),
|
|
|
|
ffi::GST_STREAM_ERROR_MUX => Some(Self::Mux),
|
|
|
|
ffi::GST_STREAM_ERROR_FORMAT => Some(Self::Format),
|
|
|
|
ffi::GST_STREAM_ERROR_DECRYPT => Some(Self::Decrypt),
|
|
|
|
ffi::GST_STREAM_ERROR_DECRYPT_NOKEY => Some(Self::DecryptNokey),
|
|
|
|
ffi::GST_STREAM_ERROR_NUM_ERRORS => Some(Self::NumErrors),
|
2021-04-25 16:45:59 +00:00
|
|
|
_ => Some(Self::Failed),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for StreamError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_stream_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for StreamError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for StreamError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for StreamError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstStreamStatusType")]
|
2017-07-04 22:47:33 +00:00
|
|
|
pub enum StreamStatusType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_CREATE")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Create,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_ENTER")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Enter,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_LEAVE")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Leave,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_DESTROY")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Destroy,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_START")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Start,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_PAUSE")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Pause,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STREAM_STATUS_TYPE_STOP")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Stop,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for StreamStatusType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstStreamStatusType;
|
2017-07-04 22:47:33 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstStreamStatusType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Create => ffi::GST_STREAM_STATUS_TYPE_CREATE,
|
|
|
|
Self::Enter => ffi::GST_STREAM_STATUS_TYPE_ENTER,
|
|
|
|
Self::Leave => ffi::GST_STREAM_STATUS_TYPE_LEAVE,
|
|
|
|
Self::Destroy => ffi::GST_STREAM_STATUS_TYPE_DESTROY,
|
|
|
|
Self::Start => ffi::GST_STREAM_STATUS_TYPE_START,
|
|
|
|
Self::Pause => ffi::GST_STREAM_STATUS_TYPE_PAUSE,
|
|
|
|
Self::Stop => ffi::GST_STREAM_STATUS_TYPE_STOP,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-04 22:47:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstStreamStatusType> for StreamStatusType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstStreamStatusType) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STREAM_STATUS_TYPE_CREATE => Self::Create,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_ENTER => Self::Enter,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_LEAVE => Self::Leave,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_DESTROY => Self::Destroy,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_START => Self::Start,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_PAUSE => Self::Pause,
|
|
|
|
ffi::GST_STREAM_STATUS_TYPE_STOP => Self::Stop,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-04 22:47:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for StreamStatusType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_stream_status_type_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for StreamStatusType {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for StreamStatusType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for StreamStatusType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstStructureChangeType")]
|
2017-07-04 22:47:33 +00:00
|
|
|
pub enum StructureChangeType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_LINK")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Link,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK")]
|
2017-07-04 22:47:33 +00:00
|
|
|
Unlink,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for StructureChangeType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstStructureChangeType;
|
2017-07-04 22:47:33 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstStructureChangeType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Link => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK,
|
|
|
|
Self::Unlink => ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-04 22:47:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstStructureChangeType> for StructureChangeType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstStructureChangeType) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_LINK => Self::Link,
|
|
|
|
ffi::GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK => Self::Unlink,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-04 22:47:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for StructureChangeType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_structure_change_type_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for StructureChangeType {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for StructureChangeType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for StructureChangeType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTagFlag")]
|
2019-01-23 13:42:46 +00:00
|
|
|
pub enum TagFlag {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_FLAG_UNDEFINED")]
|
2019-01-23 13:42:46 +00:00
|
|
|
Undefined,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_FLAG_META")]
|
2019-01-23 13:42:46 +00:00
|
|
|
Meta,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_FLAG_ENCODED")]
|
2019-01-23 13:42:46 +00:00
|
|
|
Encoded,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_FLAG_DECODED")]
|
2019-01-23 13:42:46 +00:00
|
|
|
Decoded,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_FLAG_COUNT")]
|
2019-01-23 13:42:46 +00:00
|
|
|
Count,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TagFlag {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTagFlag;
|
2019-01-23 13:42:46 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTagFlag {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Undefined => ffi::GST_TAG_FLAG_UNDEFINED,
|
|
|
|
Self::Meta => ffi::GST_TAG_FLAG_META,
|
|
|
|
Self::Encoded => ffi::GST_TAG_FLAG_ENCODED,
|
|
|
|
Self::Decoded => ffi::GST_TAG_FLAG_DECODED,
|
|
|
|
Self::Count => ffi::GST_TAG_FLAG_COUNT,
|
|
|
|
Self::__Unknown(value) => value,
|
2019-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTagFlag> for TagFlag {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTagFlag) -> Self {
|
2019-01-23 13:42:46 +00:00
|
|
|
skip_assert_initialized!();
|
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TAG_FLAG_UNDEFINED => Self::Undefined,
|
|
|
|
ffi::GST_TAG_FLAG_META => Self::Meta,
|
|
|
|
ffi::GST_TAG_FLAG_ENCODED => Self::Encoded,
|
|
|
|
ffi::GST_TAG_FLAG_DECODED => Self::Decoded,
|
|
|
|
ffi::GST_TAG_FLAG_COUNT => Self::Count,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2019-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TagFlag {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_tag_flag_get_type()) }
|
2019-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TagFlag {
|
|
|
|
type Type = Self;
|
2019-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TagFlag {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2019-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TagFlag {
|
|
|
|
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_enum(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-01-23 13:42:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTagMergeMode")]
|
2017-07-12 07:27:43 +00:00
|
|
|
pub enum TagMergeMode {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_UNDEFINED")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Undefined,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_REPLACE_ALL")]
|
2017-07-12 07:27:43 +00:00
|
|
|
ReplaceAll,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_REPLACE")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Replace,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_APPEND")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Append,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_PREPEND")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Prepend,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_KEEP")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Keep,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_KEEP_ALL")]
|
2017-07-12 07:27:43 +00:00
|
|
|
KeepAll,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_MERGE_COUNT")]
|
2017-07-12 07:27:43 +00:00
|
|
|
Count,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TagMergeMode {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTagMergeMode;
|
2017-07-12 07:27:43 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTagMergeMode {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Undefined => ffi::GST_TAG_MERGE_UNDEFINED,
|
|
|
|
Self::ReplaceAll => ffi::GST_TAG_MERGE_REPLACE_ALL,
|
|
|
|
Self::Replace => ffi::GST_TAG_MERGE_REPLACE,
|
|
|
|
Self::Append => ffi::GST_TAG_MERGE_APPEND,
|
|
|
|
Self::Prepend => ffi::GST_TAG_MERGE_PREPEND,
|
|
|
|
Self::Keep => ffi::GST_TAG_MERGE_KEEP,
|
|
|
|
Self::KeepAll => ffi::GST_TAG_MERGE_KEEP_ALL,
|
|
|
|
Self::Count => ffi::GST_TAG_MERGE_COUNT,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-12 07:27:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTagMergeMode> for TagMergeMode {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTagMergeMode) -> Self {
|
2017-07-12 07:27:43 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TAG_MERGE_UNDEFINED => Self::Undefined,
|
|
|
|
ffi::GST_TAG_MERGE_REPLACE_ALL => Self::ReplaceAll,
|
|
|
|
ffi::GST_TAG_MERGE_REPLACE => Self::Replace,
|
|
|
|
ffi::GST_TAG_MERGE_APPEND => Self::Append,
|
|
|
|
ffi::GST_TAG_MERGE_PREPEND => Self::Prepend,
|
|
|
|
ffi::GST_TAG_MERGE_KEEP => Self::Keep,
|
|
|
|
ffi::GST_TAG_MERGE_KEEP_ALL => Self::KeepAll,
|
|
|
|
ffi::GST_TAG_MERGE_COUNT => Self::Count,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-12 07:27:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for TagMergeMode {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_tag_merge_mode_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TagMergeMode {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TagMergeMode {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TagMergeMode {
|
|
|
|
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_enum(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-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTagScope")]
|
2019-03-19 16:14:42 +00:00
|
|
|
pub enum TagScope {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_SCOPE_STREAM")]
|
2019-03-19 16:14:42 +00:00
|
|
|
Stream,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TAG_SCOPE_GLOBAL")]
|
2019-03-19 16:14:42 +00:00
|
|
|
Global,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TagScope {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTagScope;
|
2019-03-19 16:14:42 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTagScope {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Stream => ffi::GST_TAG_SCOPE_STREAM,
|
|
|
|
Self::Global => ffi::GST_TAG_SCOPE_GLOBAL,
|
|
|
|
Self::__Unknown(value) => value,
|
2019-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTagScope> for TagScope {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTagScope) -> Self {
|
2019-03-19 16:14:42 +00:00
|
|
|
skip_assert_initialized!();
|
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TAG_SCOPE_STREAM => Self::Stream,
|
|
|
|
ffi::GST_TAG_SCOPE_GLOBAL => Self::Global,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2019-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TagScope {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_tag_scope_get_type()) }
|
2019-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TagScope {
|
|
|
|
type Type = Self;
|
2019-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TagScope {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2019-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TagScope {
|
|
|
|
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_enum(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-03-19 16:14:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTaskState")]
|
2017-09-17 21:32:29 +00:00
|
|
|
pub enum TaskState {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TASK_STARTED")]
|
2017-09-17 21:32:29 +00:00
|
|
|
Started,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TASK_STOPPED")]
|
2017-09-17 21:32:29 +00:00
|
|
|
Stopped,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TASK_PAUSED")]
|
2017-09-17 21:32:29 +00:00
|
|
|
Paused,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TaskState {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTaskState;
|
2017-09-17 21:32:29 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTaskState {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Started => ffi::GST_TASK_STARTED,
|
|
|
|
Self::Stopped => ffi::GST_TASK_STOPPED,
|
|
|
|
Self::Paused => ffi::GST_TASK_PAUSED,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTaskState> for TaskState {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTaskState) -> Self {
|
2017-09-17 21:32:29 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TASK_STARTED => Self::Started,
|
|
|
|
ffi::GST_TASK_STOPPED => Self::Stopped,
|
|
|
|
ffi::GST_TASK_PAUSED => Self::Paused,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TaskState {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_task_state_get_type()) }
|
2017-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TaskState {
|
|
|
|
type Type = Self;
|
2017-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TaskState {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TaskState {
|
|
|
|
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_enum(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-09-17 21:32:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTocEntryType")]
|
2017-08-08 20:37:48 +00:00
|
|
|
pub enum TocEntryType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_ANGLE")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Angle,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_VERSION")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Version,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_EDITION")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Edition,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_INVALID")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Invalid,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_TITLE")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Title,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_TRACK")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Track,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_ENTRY_TYPE_CHAPTER")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Chapter,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
2020-12-07 11:11:04 +00:00
|
|
|
impl TocEntryType {
|
2021-04-19 20:13:58 +00:00
|
|
|
pub fn nick<'a>(self) -> &'a str {
|
2020-12-07 11:11:04 +00:00
|
|
|
unsafe {
|
|
|
|
CStr::from_ptr(
|
2021-04-27 15:10:39 +00:00
|
|
|
ffi::gst_toc_entry_type_get_nick(self.into_glib())
|
2020-12-07 11:11:04 +00:00
|
|
|
.as_ref()
|
|
|
|
.expect("gst_toc_entry_type_get_nick returned NULL"),
|
|
|
|
)
|
|
|
|
.to_str()
|
|
|
|
.expect("gst_toc_entry_type_get_nick returned an invalid string")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-08 20:37:48 +00:00
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TocEntryType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTocEntryType;
|
2017-08-08 20:37:48 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTocEntryType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Angle => ffi::GST_TOC_ENTRY_TYPE_ANGLE,
|
|
|
|
Self::Version => ffi::GST_TOC_ENTRY_TYPE_VERSION,
|
|
|
|
Self::Edition => ffi::GST_TOC_ENTRY_TYPE_EDITION,
|
|
|
|
Self::Invalid => ffi::GST_TOC_ENTRY_TYPE_INVALID,
|
|
|
|
Self::Title => ffi::GST_TOC_ENTRY_TYPE_TITLE,
|
|
|
|
Self::Track => ffi::GST_TOC_ENTRY_TYPE_TRACK,
|
|
|
|
Self::Chapter => ffi::GST_TOC_ENTRY_TYPE_CHAPTER,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTocEntryType> for TocEntryType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTocEntryType) -> Self {
|
2017-08-08 20:37:48 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TOC_ENTRY_TYPE_ANGLE => Self::Angle,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_VERSION => Self::Version,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_EDITION => Self::Edition,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_INVALID => Self::Invalid,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_TITLE => Self::Title,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_TRACK => Self::Track,
|
|
|
|
ffi::GST_TOC_ENTRY_TYPE_CHAPTER => Self::Chapter,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TocEntryType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_toc_entry_type_get_type()) }
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TocEntryType {
|
|
|
|
type Type = Self;
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TocEntryType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TocEntryType {
|
|
|
|
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_enum(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-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTocLoopType")]
|
2017-08-08 20:37:48 +00:00
|
|
|
pub enum TocLoopType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_LOOP_NONE")]
|
2017-08-08 20:37:48 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_LOOP_FORWARD")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Forward,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_LOOP_REVERSE")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Reverse,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_LOOP_PING_PONG")]
|
2017-08-08 20:37:48 +00:00
|
|
|
PingPong,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TocLoopType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTocLoopType;
|
2017-08-08 20:37:48 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTocLoopType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_TOC_LOOP_NONE,
|
|
|
|
Self::Forward => ffi::GST_TOC_LOOP_FORWARD,
|
|
|
|
Self::Reverse => ffi::GST_TOC_LOOP_REVERSE,
|
|
|
|
Self::PingPong => ffi::GST_TOC_LOOP_PING_PONG,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTocLoopType> for TocLoopType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTocLoopType) -> Self {
|
2017-08-08 20:37:48 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TOC_LOOP_NONE => Self::None,
|
|
|
|
ffi::GST_TOC_LOOP_FORWARD => Self::Forward,
|
|
|
|
ffi::GST_TOC_LOOP_REVERSE => Self::Reverse,
|
|
|
|
ffi::GST_TOC_LOOP_PING_PONG => Self::PingPong,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TocLoopType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_toc_loop_type_get_type()) }
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TocLoopType {
|
|
|
|
type Type = Self;
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TocLoopType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TocLoopType {
|
|
|
|
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_enum(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-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
#[cfg_attr(feature = "ser_de", derive(serde::Serialize, serde::Deserialize))]
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTocScope")]
|
2017-08-08 20:37:48 +00:00
|
|
|
pub enum TocScope {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_SCOPE_GLOBAL")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Global,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TOC_SCOPE_CURRENT")]
|
2017-08-08 20:37:48 +00:00
|
|
|
Current,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TocScope {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTocScope;
|
2017-08-08 20:37:48 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTocScope {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Global => ffi::GST_TOC_SCOPE_GLOBAL,
|
|
|
|
Self::Current => ffi::GST_TOC_SCOPE_CURRENT,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTocScope> for TocScope {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTocScope) -> Self {
|
2017-08-08 20:37:48 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TOC_SCOPE_GLOBAL => Self::Global,
|
|
|
|
ffi::GST_TOC_SCOPE_CURRENT => Self::Current,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TocScope {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_toc_scope_get_type()) }
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TocScope {
|
|
|
|
type Type = Self;
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TocScope {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-08-08 20:37:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TocScope {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstTypeFindProbability")]
|
2017-12-18 07:52:22 +00:00
|
|
|
pub enum TypeFindProbability {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_NONE")]
|
2017-12-18 07:52:22 +00:00
|
|
|
None,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_MINIMUM")]
|
2017-12-18 07:52:22 +00:00
|
|
|
Minimum,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_POSSIBLE")]
|
2017-12-18 07:52:22 +00:00
|
|
|
Possible,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_LIKELY")]
|
2017-12-18 07:52:22 +00:00
|
|
|
Likely,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_NEARLY_CERTAIN")]
|
2017-12-18 07:52:22 +00:00
|
|
|
NearlyCertain,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_TYPE_FIND_MAXIMUM")]
|
2017-12-18 07:52:22 +00:00
|
|
|
Maximum,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for TypeFindProbability {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstTypeFindProbability;
|
2017-12-18 07:52:22 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstTypeFindProbability {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::None => ffi::GST_TYPE_FIND_NONE,
|
|
|
|
Self::Minimum => ffi::GST_TYPE_FIND_MINIMUM,
|
|
|
|
Self::Possible => ffi::GST_TYPE_FIND_POSSIBLE,
|
|
|
|
Self::Likely => ffi::GST_TYPE_FIND_LIKELY,
|
|
|
|
Self::NearlyCertain => ffi::GST_TYPE_FIND_NEARLY_CERTAIN,
|
|
|
|
Self::Maximum => ffi::GST_TYPE_FIND_MAXIMUM,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstTypeFindProbability> for TypeFindProbability {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstTypeFindProbability) -> Self {
|
2017-12-18 07:52:22 +00:00
|
|
|
skip_assert_initialized!();
|
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_TYPE_FIND_NONE => Self::None,
|
|
|
|
ffi::GST_TYPE_FIND_MINIMUM => Self::Minimum,
|
|
|
|
ffi::GST_TYPE_FIND_POSSIBLE => Self::Possible,
|
|
|
|
ffi::GST_TYPE_FIND_LIKELY => Self::Likely,
|
|
|
|
ffi::GST_TYPE_FIND_NEARLY_CERTAIN => Self::NearlyCertain,
|
|
|
|
ffi::GST_TYPE_FIND_MAXIMUM => Self::Maximum,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticType for TypeFindProbability {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_type_find_probability_get_type()) }
|
2017-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for TypeFindProbability {
|
|
|
|
type Type = Self;
|
2017-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for TypeFindProbability {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for TypeFindProbability {
|
|
|
|
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_enum(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-12-18 07:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstURIError")]
|
2017-07-03 14:52:10 +00:00
|
|
|
pub enum URIError {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_ERROR_UNSUPPORTED_PROTOCOL")]
|
2017-07-03 14:52:10 +00:00
|
|
|
UnsupportedProtocol,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_ERROR_BAD_URI")]
|
2017-07-03 14:52:10 +00:00
|
|
|
BadUri,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_ERROR_BAD_STATE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
BadState,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_ERROR_BAD_REFERENCE")]
|
2017-07-03 14:52:10 +00:00
|
|
|
BadReference,
|
|
|
|
#[doc(hidden)]
|
|
|
|
__Unknown(i32),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for URIError {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstURIError;
|
2017-07-03 14:52:10 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstURIError {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::UnsupportedProtocol => ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
|
|
|
|
Self::BadUri => ffi::GST_URI_ERROR_BAD_URI,
|
|
|
|
Self::BadState => ffi::GST_URI_ERROR_BAD_STATE,
|
|
|
|
Self::BadReference => ffi::GST_URI_ERROR_BAD_REFERENCE,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstURIError> for URIError {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstURIError) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL => Self::UnsupportedProtocol,
|
|
|
|
ffi::GST_URI_ERROR_BAD_URI => Self::BadUri,
|
|
|
|
ffi::GST_URI_ERROR_BAD_STATE => Self::BadState,
|
|
|
|
ffi::GST_URI_ERROR_BAD_REFERENCE => Self::BadReference,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ErrorDomain for URIError {
|
2018-07-30 08:46:40 +00:00
|
|
|
fn domain() -> Quark {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2020-10-31 07:36:53 +00:00
|
|
|
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_uri_error_quark()) }
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn code(self) -> i32 {
|
2021-04-27 15:10:39 +00:00
|
|
|
self.into_glib()
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn from(code: i32) -> Option<Self> {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-07-03 14:52:10 +00:00
|
|
|
match code {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL => Some(Self::UnsupportedProtocol),
|
|
|
|
ffi::GST_URI_ERROR_BAD_URI => Some(Self::BadUri),
|
|
|
|
ffi::GST_URI_ERROR_BAD_STATE => Some(Self::BadState),
|
|
|
|
ffi::GST_URI_ERROR_BAD_REFERENCE => Some(Self::BadReference),
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Some(Self::__Unknown(value)),
|
2017-07-03 14:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for URIError {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_uri_error_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for URIError {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for URIError {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for URIError {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-18 10:12:00 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
|
2020-04-12 15:55:06 +00:00
|
|
|
#[non_exhaustive]
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GstURIType")]
|
2017-05-12 12:24:03 +00:00
|
|
|
pub enum URIType {
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_UNKNOWN")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Unknown,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_SINK")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Sink,
|
2020-12-18 14:23:05 +00:00
|
|
|
#[doc(alias = "GST_URI_SRC")]
|
2017-05-12 12:24:03 +00:00
|
|
|
Src,
|
|
|
|
#[doc(hidden)]
|
2017-06-25 08:04:37 +00:00
|
|
|
__Unknown(i32),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2021-04-27 15:10:39 +00:00
|
|
|
impl IntoGlib for URIType {
|
2020-11-21 13:46:33 +00:00
|
|
|
type GlibType = ffi::GstURIType;
|
2017-05-12 12:24:03 +00:00
|
|
|
|
2021-04-27 15:10:39 +00:00
|
|
|
fn into_glib(self) -> ffi::GstURIType {
|
|
|
|
match self {
|
2021-04-25 16:45:59 +00:00
|
|
|
Self::Unknown => ffi::GST_URI_UNKNOWN,
|
|
|
|
Self::Sink => ffi::GST_URI_SINK,
|
|
|
|
Self::Src => ffi::GST_URI_SRC,
|
|
|
|
Self::__Unknown(value) => value,
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2020-11-21 13:46:33 +00:00
|
|
|
impl FromGlib<ffi::GstURIType> for URIType {
|
2020-12-08 13:00:17 +00:00
|
|
|
unsafe fn from_glib(value: ffi::GstURIType) -> Self {
|
2017-07-10 09:36:15 +00:00
|
|
|
skip_assert_initialized!();
|
2017-11-05 17:01:15 +00:00
|
|
|
match value {
|
2021-05-23 16:27:13 +00:00
|
|
|
ffi::GST_URI_UNKNOWN => Self::Unknown,
|
|
|
|
ffi::GST_URI_SINK => Self::Sink,
|
|
|
|
ffi::GST_URI_SRC => Self::Src,
|
2021-04-25 16:45:59 +00:00
|
|
|
value => Self::__Unknown(value),
|
2017-05-12 12:24:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-19 18:41:25 +00:00
|
|
|
impl StaticType for URIType {
|
|
|
|
fn static_type() -> Type {
|
2020-11-21 13:46:33 +00:00
|
|
|
unsafe { from_glib(ffi::gst_uri_type_get_type()) }
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl glib::value::ValueType for URIType {
|
|
|
|
type Type = Self;
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
unsafe impl<'a> FromValue<'a> for URIType {
|
|
|
|
type Checker = glib::value::GenericValueTypeChecker<Self>;
|
|
|
|
|
|
|
|
unsafe fn from_value(value: &'a glib::Value) -> Self {
|
|
|
|
skip_assert_initialized!();
|
2020-11-21 13:46:33 +00:00
|
|
|
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
|
2017-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-19 16:24:43 +00:00
|
|
|
impl ToValue for URIType {
|
|
|
|
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_enum(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-07-19 18:41:25 +00:00
|
|
|
}
|
|
|
|
}
|