mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git
synced 2024-10-31 22:59:14 +00:00
Implement further parts of the Message machinery
This commit is contained in:
parent
602c3f257f
commit
eeea572c96
6 changed files with 886 additions and 123 deletions
|
@ -27,7 +27,14 @@ generate = [
|
|||
"Gst.URIType",
|
||||
"Gst.ElementFactoryListType",
|
||||
"Gst.Format",
|
||||
"Gst.MessageType",
|
||||
"Gst.BufferingMode",
|
||||
"Gst.CoreError",
|
||||
"Gst.ResourceError",
|
||||
"Gst.LibraryError",
|
||||
"Gst.StreamError",
|
||||
"Gst.PluginError",
|
||||
"Gst.ParseError",
|
||||
"Gst.URIError",
|
||||
]
|
||||
|
||||
manual = [
|
||||
|
|
|
@ -146,10 +146,10 @@ pub trait ElementExt {
|
|||
|
||||
fn lost_state(&self);
|
||||
|
||||
//fn message_full<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32);
|
||||
//fn message_full<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: /*Ignored*/MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32);
|
||||
|
||||
//#[cfg(feature = "v1_10")]
|
||||
//fn message_full_with_details<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32, structure: /*Ignored*/&mut Structure);
|
||||
//fn message_full_with_details<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: /*Ignored*/MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32, structure: /*Ignored*/&mut Structure);
|
||||
|
||||
fn no_more_pads(&self);
|
||||
|
||||
|
@ -395,12 +395,12 @@ impl<O: IsA<Element> + IsA<glib::object::Object>> ElementExt for O {
|
|||
}
|
||||
}
|
||||
|
||||
//fn message_full<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32) {
|
||||
//fn message_full<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: /*Ignored*/MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32) {
|
||||
// unsafe { TODO: call ffi::gst_element_message_full() }
|
||||
//}
|
||||
|
||||
//#[cfg(feature = "v1_10")]
|
||||
//fn message_full_with_details<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32, structure: /*Ignored*/&mut Structure) {
|
||||
//fn message_full_with_details<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(&self, type_: /*Ignored*/MessageType, domain: /*Ignored*/glib::Quark, code: i32, text: P, debug: Q, file: &str, function: &str, line: i32, structure: /*Ignored*/&mut Structure) {
|
||||
// unsafe { TODO: call ffi::gst_element_message_full_with_details() }
|
||||
//}
|
||||
|
||||
|
|
|
@ -2,9 +2,151 @@
|
|||
// DO NOT EDIT
|
||||
|
||||
use ffi;
|
||||
use glib_ffi;
|
||||
use glib::error::ErrorDomain;
|
||||
use glib::translate::*;
|
||||
use std;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum BufferingMode {
|
||||
Stream,
|
||||
Download,
|
||||
Timeshift,
|
||||
Live,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for BufferingMode {
|
||||
type GlibType = ffi::GstBufferingMode;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstBufferingMode {
|
||||
match *self {
|
||||
BufferingMode::Stream => ffi::GST_BUFFERING_STREAM,
|
||||
BufferingMode::Download => ffi::GST_BUFFERING_DOWNLOAD,
|
||||
BufferingMode::Timeshift => ffi::GST_BUFFERING_TIMESHIFT,
|
||||
BufferingMode::Live => ffi::GST_BUFFERING_LIVE,
|
||||
BufferingMode::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstBufferingMode> for BufferingMode {
|
||||
fn from_glib(value: ffi::GstBufferingMode) -> Self {
|
||||
match value as i32 {
|
||||
0 => BufferingMode::Stream,
|
||||
1 => BufferingMode::Download,
|
||||
2 => BufferingMode::Timeshift,
|
||||
3 => BufferingMode::Live,
|
||||
value => BufferingMode::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum CoreError {
|
||||
Failed,
|
||||
TooLazy,
|
||||
NotImplemented,
|
||||
StateChange,
|
||||
Pad,
|
||||
Thread,
|
||||
Negotiation,
|
||||
Event,
|
||||
Seek,
|
||||
Caps,
|
||||
Tag,
|
||||
MissingPlugin,
|
||||
Clock,
|
||||
Disabled,
|
||||
NumErrors,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for CoreError {
|
||||
type GlibType = ffi::GstCoreError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstCoreError {
|
||||
match *self {
|
||||
CoreError::Failed => ffi::GST_CORE_ERROR_FAILED,
|
||||
CoreError::TooLazy => ffi::GST_CORE_ERROR_TOO_LAZY,
|
||||
CoreError::NotImplemented => ffi::GST_CORE_ERROR_NOT_IMPLEMENTED,
|
||||
CoreError::StateChange => ffi::GST_CORE_ERROR_STATE_CHANGE,
|
||||
CoreError::Pad => ffi::GST_CORE_ERROR_PAD,
|
||||
CoreError::Thread => ffi::GST_CORE_ERROR_THREAD,
|
||||
CoreError::Negotiation => ffi::GST_CORE_ERROR_NEGOTIATION,
|
||||
CoreError::Event => ffi::GST_CORE_ERROR_EVENT,
|
||||
CoreError::Seek => ffi::GST_CORE_ERROR_SEEK,
|
||||
CoreError::Caps => ffi::GST_CORE_ERROR_CAPS,
|
||||
CoreError::Tag => ffi::GST_CORE_ERROR_TAG,
|
||||
CoreError::MissingPlugin => ffi::GST_CORE_ERROR_MISSING_PLUGIN,
|
||||
CoreError::Clock => ffi::GST_CORE_ERROR_CLOCK,
|
||||
CoreError::Disabled => ffi::GST_CORE_ERROR_DISABLED,
|
||||
CoreError::NumErrors => ffi::GST_CORE_ERROR_NUM_ERRORS,
|
||||
CoreError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstCoreError> for CoreError {
|
||||
fn from_glib(value: ffi::GstCoreError) -> Self {
|
||||
match value as i32 {
|
||||
1 => CoreError::Failed,
|
||||
2 => CoreError::TooLazy,
|
||||
3 => CoreError::NotImplemented,
|
||||
4 => CoreError::StateChange,
|
||||
5 => CoreError::Pad,
|
||||
6 => CoreError::Thread,
|
||||
7 => CoreError::Negotiation,
|
||||
8 => CoreError::Event,
|
||||
9 => CoreError::Seek,
|
||||
10 => CoreError::Caps,
|
||||
11 => CoreError::Tag,
|
||||
12 => CoreError::MissingPlugin,
|
||||
13 => CoreError::Clock,
|
||||
14 => CoreError::Disabled,
|
||||
15 => CoreError::NumErrors,
|
||||
value => CoreError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for CoreError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_core_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
1 => Some(CoreError::Failed),
|
||||
2 => Some(CoreError::TooLazy),
|
||||
3 => Some(CoreError::NotImplemented),
|
||||
4 => Some(CoreError::StateChange),
|
||||
5 => Some(CoreError::Pad),
|
||||
6 => Some(CoreError::Thread),
|
||||
7 => Some(CoreError::Negotiation),
|
||||
8 => Some(CoreError::Event),
|
||||
9 => Some(CoreError::Seek),
|
||||
10 => Some(CoreError::Caps),
|
||||
11 => Some(CoreError::Tag),
|
||||
12 => Some(CoreError::MissingPlugin),
|
||||
13 => Some(CoreError::Clock),
|
||||
14 => Some(CoreError::Disabled),
|
||||
15 => Some(CoreError::NumErrors),
|
||||
_ => Some(CoreError::Failed),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum FlowReturn {
|
||||
CustomSuccess2,
|
||||
|
@ -114,6 +256,76 @@ impl FromGlib<ffi::GstFormat> for Format {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum LibraryError {
|
||||
Failed,
|
||||
TooLazy,
|
||||
Init,
|
||||
Shutdown,
|
||||
Settings,
|
||||
Encode,
|
||||
NumErrors,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for LibraryError {
|
||||
type GlibType = ffi::GstLibraryError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstLibraryError {
|
||||
match *self {
|
||||
LibraryError::Failed => ffi::GST_LIBRARY_ERROR_FAILED,
|
||||
LibraryError::TooLazy => ffi::GST_LIBRARY_ERROR_TOO_LAZY,
|
||||
LibraryError::Init => ffi::GST_LIBRARY_ERROR_INIT,
|
||||
LibraryError::Shutdown => ffi::GST_LIBRARY_ERROR_SHUTDOWN,
|
||||
LibraryError::Settings => ffi::GST_LIBRARY_ERROR_SETTINGS,
|
||||
LibraryError::Encode => ffi::GST_LIBRARY_ERROR_ENCODE,
|
||||
LibraryError::NumErrors => ffi::GST_LIBRARY_ERROR_NUM_ERRORS,
|
||||
LibraryError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstLibraryError> for LibraryError {
|
||||
fn from_glib(value: ffi::GstLibraryError) -> Self {
|
||||
match value as i32 {
|
||||
1 => LibraryError::Failed,
|
||||
2 => LibraryError::TooLazy,
|
||||
3 => LibraryError::Init,
|
||||
4 => LibraryError::Shutdown,
|
||||
5 => LibraryError::Settings,
|
||||
6 => LibraryError::Encode,
|
||||
7 => LibraryError::NumErrors,
|
||||
value => LibraryError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for LibraryError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_library_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
1 => Some(LibraryError::Failed),
|
||||
2 => Some(LibraryError::TooLazy),
|
||||
3 => Some(LibraryError::Init),
|
||||
4 => Some(LibraryError::Shutdown),
|
||||
5 => Some(LibraryError::Settings),
|
||||
6 => Some(LibraryError::Encode),
|
||||
7 => Some(LibraryError::NumErrors),
|
||||
_ => Some(LibraryError::Failed),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum PadDirection {
|
||||
Unknown,
|
||||
|
@ -149,6 +361,240 @@ impl FromGlib<ffi::GstPadDirection> for PadDirection {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum ParseError {
|
||||
Syntax,
|
||||
NoSuchElement,
|
||||
NoSuchProperty,
|
||||
Link,
|
||||
CouldNotSetProperty,
|
||||
EmptyBin,
|
||||
Empty,
|
||||
DelayedLink,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for ParseError {
|
||||
type GlibType = ffi::GstParseError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstParseError {
|
||||
match *self {
|
||||
ParseError::Syntax => ffi::GST_PARSE_ERROR_SYNTAX,
|
||||
ParseError::NoSuchElement => ffi::GST_PARSE_ERROR_NO_SUCH_ELEMENT,
|
||||
ParseError::NoSuchProperty => ffi::GST_PARSE_ERROR_NO_SUCH_PROPERTY,
|
||||
ParseError::Link => ffi::GST_PARSE_ERROR_LINK,
|
||||
ParseError::CouldNotSetProperty => ffi::GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,
|
||||
ParseError::EmptyBin => ffi::GST_PARSE_ERROR_EMPTY_BIN,
|
||||
ParseError::Empty => ffi::GST_PARSE_ERROR_EMPTY,
|
||||
ParseError::DelayedLink => ffi::GST_PARSE_ERROR_DELAYED_LINK,
|
||||
ParseError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstParseError> for ParseError {
|
||||
fn from_glib(value: ffi::GstParseError) -> Self {
|
||||
match value as i32 {
|
||||
0 => ParseError::Syntax,
|
||||
1 => ParseError::NoSuchElement,
|
||||
2 => ParseError::NoSuchProperty,
|
||||
3 => ParseError::Link,
|
||||
4 => ParseError::CouldNotSetProperty,
|
||||
5 => ParseError::EmptyBin,
|
||||
6 => ParseError::Empty,
|
||||
7 => ParseError::DelayedLink,
|
||||
value => ParseError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for ParseError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_parse_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
0 => Some(ParseError::Syntax),
|
||||
1 => Some(ParseError::NoSuchElement),
|
||||
2 => Some(ParseError::NoSuchProperty),
|
||||
3 => Some(ParseError::Link),
|
||||
4 => Some(ParseError::CouldNotSetProperty),
|
||||
5 => Some(ParseError::EmptyBin),
|
||||
6 => Some(ParseError::Empty),
|
||||
7 => Some(ParseError::DelayedLink),
|
||||
value => Some(ParseError::__Unknown(value)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum PluginError {
|
||||
Module,
|
||||
Dependencies,
|
||||
NameMismatch,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for PluginError {
|
||||
type GlibType = ffi::GstPluginError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstPluginError {
|
||||
match *self {
|
||||
PluginError::Module => ffi::GST_PLUGIN_ERROR_MODULE,
|
||||
PluginError::Dependencies => ffi::GST_PLUGIN_ERROR_DEPENDENCIES,
|
||||
PluginError::NameMismatch => ffi::GST_PLUGIN_ERROR_NAME_MISMATCH,
|
||||
PluginError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstPluginError> for PluginError {
|
||||
fn from_glib(value: ffi::GstPluginError) -> Self {
|
||||
match value as i32 {
|
||||
0 => PluginError::Module,
|
||||
1 => PluginError::Dependencies,
|
||||
2 => PluginError::NameMismatch,
|
||||
value => PluginError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for PluginError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_plugin_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
0 => Some(PluginError::Module),
|
||||
1 => Some(PluginError::Dependencies),
|
||||
2 => Some(PluginError::NameMismatch),
|
||||
value => Some(PluginError::__Unknown(value)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum ResourceError {
|
||||
Failed,
|
||||
TooLazy,
|
||||
NotFound,
|
||||
Busy,
|
||||
OpenRead,
|
||||
OpenWrite,
|
||||
OpenReadWrite,
|
||||
Close,
|
||||
Read,
|
||||
Write,
|
||||
Seek,
|
||||
Sync,
|
||||
Settings,
|
||||
NoSpaceLeft,
|
||||
NotAuthorized,
|
||||
NumErrors,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for ResourceError {
|
||||
type GlibType = ffi::GstResourceError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstResourceError {
|
||||
match *self {
|
||||
ResourceError::Failed => ffi::GST_RESOURCE_ERROR_FAILED,
|
||||
ResourceError::TooLazy => ffi::GST_RESOURCE_ERROR_TOO_LAZY,
|
||||
ResourceError::NotFound => ffi::GST_RESOURCE_ERROR_NOT_FOUND,
|
||||
ResourceError::Busy => ffi::GST_RESOURCE_ERROR_BUSY,
|
||||
ResourceError::OpenRead => ffi::GST_RESOURCE_ERROR_OPEN_READ,
|
||||
ResourceError::OpenWrite => ffi::GST_RESOURCE_ERROR_OPEN_WRITE,
|
||||
ResourceError::OpenReadWrite => ffi::GST_RESOURCE_ERROR_OPEN_READ_WRITE,
|
||||
ResourceError::Close => ffi::GST_RESOURCE_ERROR_CLOSE,
|
||||
ResourceError::Read => ffi::GST_RESOURCE_ERROR_READ,
|
||||
ResourceError::Write => ffi::GST_RESOURCE_ERROR_WRITE,
|
||||
ResourceError::Seek => ffi::GST_RESOURCE_ERROR_SEEK,
|
||||
ResourceError::Sync => ffi::GST_RESOURCE_ERROR_SYNC,
|
||||
ResourceError::Settings => ffi::GST_RESOURCE_ERROR_SETTINGS,
|
||||
ResourceError::NoSpaceLeft => ffi::GST_RESOURCE_ERROR_NO_SPACE_LEFT,
|
||||
ResourceError::NotAuthorized => ffi::GST_RESOURCE_ERROR_NOT_AUTHORIZED,
|
||||
ResourceError::NumErrors => ffi::GST_RESOURCE_ERROR_NUM_ERRORS,
|
||||
ResourceError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstResourceError> for ResourceError {
|
||||
fn from_glib(value: ffi::GstResourceError) -> Self {
|
||||
match value as i32 {
|
||||
1 => ResourceError::Failed,
|
||||
2 => ResourceError::TooLazy,
|
||||
3 => ResourceError::NotFound,
|
||||
4 => ResourceError::Busy,
|
||||
5 => ResourceError::OpenRead,
|
||||
6 => ResourceError::OpenWrite,
|
||||
7 => ResourceError::OpenReadWrite,
|
||||
8 => ResourceError::Close,
|
||||
9 => ResourceError::Read,
|
||||
10 => ResourceError::Write,
|
||||
11 => ResourceError::Seek,
|
||||
12 => ResourceError::Sync,
|
||||
13 => ResourceError::Settings,
|
||||
14 => ResourceError::NoSpaceLeft,
|
||||
15 => ResourceError::NotAuthorized,
|
||||
16 => ResourceError::NumErrors,
|
||||
value => ResourceError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for ResourceError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_resource_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
1 => Some(ResourceError::Failed),
|
||||
2 => Some(ResourceError::TooLazy),
|
||||
3 => Some(ResourceError::NotFound),
|
||||
4 => Some(ResourceError::Busy),
|
||||
5 => Some(ResourceError::OpenRead),
|
||||
6 => Some(ResourceError::OpenWrite),
|
||||
7 => Some(ResourceError::OpenReadWrite),
|
||||
8 => Some(ResourceError::Close),
|
||||
9 => Some(ResourceError::Read),
|
||||
10 => Some(ResourceError::Write),
|
||||
11 => Some(ResourceError::Seek),
|
||||
12 => Some(ResourceError::Sync),
|
||||
13 => Some(ResourceError::Settings),
|
||||
14 => Some(ResourceError::NoSpaceLeft),
|
||||
15 => Some(ResourceError::NotAuthorized),
|
||||
16 => Some(ResourceError::NumErrors),
|
||||
_ => Some(ResourceError::Failed),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum SeekType {
|
||||
None,
|
||||
|
@ -307,6 +753,162 @@ impl FromGlib<ffi::GstStateChangeReturn> for StateChangeReturn {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum StreamError {
|
||||
Failed,
|
||||
TooLazy,
|
||||
NotImplemented,
|
||||
TypeNotFound,
|
||||
WrongType,
|
||||
CodecNotFound,
|
||||
Decode,
|
||||
Encode,
|
||||
Demux,
|
||||
Mux,
|
||||
Format,
|
||||
Decrypt,
|
||||
DecryptNokey,
|
||||
NumErrors,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for StreamError {
|
||||
type GlibType = ffi::GstStreamError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstStreamError {
|
||||
match *self {
|
||||
StreamError::Failed => ffi::GST_STREAM_ERROR_FAILED,
|
||||
StreamError::TooLazy => ffi::GST_STREAM_ERROR_TOO_LAZY,
|
||||
StreamError::NotImplemented => ffi::GST_STREAM_ERROR_NOT_IMPLEMENTED,
|
||||
StreamError::TypeNotFound => ffi::GST_STREAM_ERROR_TYPE_NOT_FOUND,
|
||||
StreamError::WrongType => ffi::GST_STREAM_ERROR_WRONG_TYPE,
|
||||
StreamError::CodecNotFound => ffi::GST_STREAM_ERROR_CODEC_NOT_FOUND,
|
||||
StreamError::Decode => ffi::GST_STREAM_ERROR_DECODE,
|
||||
StreamError::Encode => ffi::GST_STREAM_ERROR_ENCODE,
|
||||
StreamError::Demux => ffi::GST_STREAM_ERROR_DEMUX,
|
||||
StreamError::Mux => ffi::GST_STREAM_ERROR_MUX,
|
||||
StreamError::Format => ffi::GST_STREAM_ERROR_FORMAT,
|
||||
StreamError::Decrypt => ffi::GST_STREAM_ERROR_DECRYPT,
|
||||
StreamError::DecryptNokey => ffi::GST_STREAM_ERROR_DECRYPT_NOKEY,
|
||||
StreamError::NumErrors => ffi::GST_STREAM_ERROR_NUM_ERRORS,
|
||||
StreamError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstStreamError> for StreamError {
|
||||
fn from_glib(value: ffi::GstStreamError) -> Self {
|
||||
match value as i32 {
|
||||
1 => StreamError::Failed,
|
||||
2 => StreamError::TooLazy,
|
||||
3 => StreamError::NotImplemented,
|
||||
4 => StreamError::TypeNotFound,
|
||||
5 => StreamError::WrongType,
|
||||
6 => StreamError::CodecNotFound,
|
||||
7 => StreamError::Decode,
|
||||
8 => StreamError::Encode,
|
||||
9 => StreamError::Demux,
|
||||
10 => StreamError::Mux,
|
||||
11 => StreamError::Format,
|
||||
12 => StreamError::Decrypt,
|
||||
13 => StreamError::DecryptNokey,
|
||||
14 => StreamError::NumErrors,
|
||||
value => StreamError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for StreamError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_stream_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
1 => Some(StreamError::Failed),
|
||||
2 => Some(StreamError::TooLazy),
|
||||
3 => Some(StreamError::NotImplemented),
|
||||
4 => Some(StreamError::TypeNotFound),
|
||||
5 => Some(StreamError::WrongType),
|
||||
6 => Some(StreamError::CodecNotFound),
|
||||
7 => Some(StreamError::Decode),
|
||||
8 => Some(StreamError::Encode),
|
||||
9 => Some(StreamError::Demux),
|
||||
10 => Some(StreamError::Mux),
|
||||
11 => Some(StreamError::Format),
|
||||
12 => Some(StreamError::Decrypt),
|
||||
13 => Some(StreamError::DecryptNokey),
|
||||
14 => Some(StreamError::NumErrors),
|
||||
_ => Some(StreamError::Failed),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum URIError {
|
||||
UnsupportedProtocol,
|
||||
BadUri,
|
||||
BadState,
|
||||
BadReference,
|
||||
#[doc(hidden)]
|
||||
__Unknown(i32),
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for URIError {
|
||||
type GlibType = ffi::GstURIError;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstURIError {
|
||||
match *self {
|
||||
URIError::UnsupportedProtocol => ffi::GST_URI_ERROR_UNSUPPORTED_PROTOCOL,
|
||||
URIError::BadUri => ffi::GST_URI_ERROR_BAD_URI,
|
||||
URIError::BadState => ffi::GST_URI_ERROR_BAD_STATE,
|
||||
URIError::BadReference => ffi::GST_URI_ERROR_BAD_REFERENCE,
|
||||
URIError::__Unknown(value) => unsafe{std::mem::transmute(value)}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstURIError> for URIError {
|
||||
fn from_glib(value: ffi::GstURIError) -> Self {
|
||||
match value as i32 {
|
||||
0 => URIError::UnsupportedProtocol,
|
||||
1 => URIError::BadUri,
|
||||
2 => URIError::BadState,
|
||||
3 => URIError::BadReference,
|
||||
value => URIError::__Unknown(value),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorDomain for URIError {
|
||||
fn domain() -> glib_ffi::GQuark {
|
||||
unsafe { ffi::gst_uri_error_quark() }
|
||||
}
|
||||
|
||||
fn code(self) -> i32 {
|
||||
self.to_glib() as i32
|
||||
}
|
||||
|
||||
fn from(code: i32) -> Option<Self> {
|
||||
match code {
|
||||
0 => Some(URIError::UnsupportedProtocol),
|
||||
1 => Some(URIError::BadUri),
|
||||
2 => Some(URIError::BadState),
|
||||
3 => Some(URIError::BadReference),
|
||||
value => Some(URIError::__Unknown(value)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
|
||||
pub enum URIType {
|
||||
Unknown,
|
||||
|
|
|
@ -4,67 +4,6 @@
|
|||
use ffi;
|
||||
use glib::translate::*;
|
||||
|
||||
bitflags! {
|
||||
pub struct MessageType: u32 {
|
||||
const MESSAGE_UNKNOWN = 0;
|
||||
const MESSAGE_EOS = 1;
|
||||
const MESSAGE_ERROR = 2;
|
||||
const MESSAGE_WARNING = 4;
|
||||
const MESSAGE_INFO = 8;
|
||||
const MESSAGE_TAG = 16;
|
||||
const MESSAGE_BUFFERING = 32;
|
||||
const MESSAGE_STATE_CHANGED = 64;
|
||||
const MESSAGE_STATE_DIRTY = 128;
|
||||
const MESSAGE_STEP_DONE = 256;
|
||||
const MESSAGE_CLOCK_PROVIDE = 512;
|
||||
const MESSAGE_CLOCK_LOST = 1024;
|
||||
const MESSAGE_NEW_CLOCK = 2048;
|
||||
const MESSAGE_STRUCTURE_CHANGE = 4096;
|
||||
const MESSAGE_STREAM_STATUS = 8192;
|
||||
const MESSAGE_APPLICATION = 16384;
|
||||
const MESSAGE_ELEMENT = 32768;
|
||||
const MESSAGE_SEGMENT_START = 65536;
|
||||
const MESSAGE_SEGMENT_DONE = 131072;
|
||||
const MESSAGE_DURATION_CHANGED = 262144;
|
||||
const MESSAGE_LATENCY = 524288;
|
||||
const MESSAGE_ASYNC_START = 1048576;
|
||||
const MESSAGE_ASYNC_DONE = 2097152;
|
||||
const MESSAGE_REQUEST_STATE = 4194304;
|
||||
const MESSAGE_STEP_START = 8388608;
|
||||
const MESSAGE_QOS = 16777216;
|
||||
const MESSAGE_PROGRESS = 33554432;
|
||||
const MESSAGE_TOC = 67108864;
|
||||
const MESSAGE_RESET_TIME = 134217728;
|
||||
const MESSAGE_STREAM_START = 268435456;
|
||||
const MESSAGE_NEED_CONTEXT = 536870912;
|
||||
const MESSAGE_HAVE_CONTEXT = 1073741824;
|
||||
const MESSAGE_EXTENDED = 2147483648;
|
||||
const MESSAGE_DEVICE_ADDED = 2147483649;
|
||||
const MESSAGE_DEVICE_REMOVED = 2147483650;
|
||||
const MESSAGE_PROPERTY_NOTIFY = 2147483651;
|
||||
const MESSAGE_STREAM_COLLECTION = 2147483652;
|
||||
const MESSAGE_STREAMS_SELECTED = 2147483653;
|
||||
const MESSAGE_REDIRECT = 2147483654;
|
||||
const MESSAGE_ANY = 4294967295;
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl ToGlib for MessageType {
|
||||
type GlibType = ffi::GstMessageType;
|
||||
|
||||
fn to_glib(&self) -> ffi::GstMessageType {
|
||||
ffi::GstMessageType::from_bits_truncate(self.bits())
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
impl FromGlib<ffi::GstMessageType> for MessageType {
|
||||
fn from_glib(value: ffi::GstMessageType) -> MessageType {
|
||||
MessageType::from_bits_truncate(value.bits())
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
pub struct SeekFlags: u32 {
|
||||
const SEEK_FLAG_NONE = 0;
|
||||
|
|
|
@ -43,57 +43,24 @@ pub use self::u_r_i_handler::URIHandler;
|
|||
pub use self::u_r_i_handler::URIHandlerExt;
|
||||
|
||||
mod enums;
|
||||
pub use self::enums::BufferingMode;
|
||||
pub use self::enums::CoreError;
|
||||
pub use self::enums::FlowReturn;
|
||||
pub use self::enums::Format;
|
||||
pub use self::enums::LibraryError;
|
||||
pub use self::enums::PadDirection;
|
||||
pub use self::enums::ParseError;
|
||||
pub use self::enums::PluginError;
|
||||
pub use self::enums::ResourceError;
|
||||
pub use self::enums::SeekType;
|
||||
pub use self::enums::State;
|
||||
pub use self::enums::StateChange;
|
||||
pub use self::enums::StateChangeReturn;
|
||||
pub use self::enums::StreamError;
|
||||
pub use self::enums::URIError;
|
||||
pub use self::enums::URIType;
|
||||
|
||||
mod flags;
|
||||
pub use self::flags::MessageType;
|
||||
pub use self::flags::MESSAGE_UNKNOWN;
|
||||
pub use self::flags::MESSAGE_EOS;
|
||||
pub use self::flags::MESSAGE_ERROR;
|
||||
pub use self::flags::MESSAGE_WARNING;
|
||||
pub use self::flags::MESSAGE_INFO;
|
||||
pub use self::flags::MESSAGE_TAG;
|
||||
pub use self::flags::MESSAGE_BUFFERING;
|
||||
pub use self::flags::MESSAGE_STATE_CHANGED;
|
||||
pub use self::flags::MESSAGE_STATE_DIRTY;
|
||||
pub use self::flags::MESSAGE_STEP_DONE;
|
||||
pub use self::flags::MESSAGE_CLOCK_PROVIDE;
|
||||
pub use self::flags::MESSAGE_CLOCK_LOST;
|
||||
pub use self::flags::MESSAGE_NEW_CLOCK;
|
||||
pub use self::flags::MESSAGE_STRUCTURE_CHANGE;
|
||||
pub use self::flags::MESSAGE_STREAM_STATUS;
|
||||
pub use self::flags::MESSAGE_APPLICATION;
|
||||
pub use self::flags::MESSAGE_ELEMENT;
|
||||
pub use self::flags::MESSAGE_SEGMENT_START;
|
||||
pub use self::flags::MESSAGE_SEGMENT_DONE;
|
||||
pub use self::flags::MESSAGE_DURATION_CHANGED;
|
||||
pub use self::flags::MESSAGE_LATENCY;
|
||||
pub use self::flags::MESSAGE_ASYNC_START;
|
||||
pub use self::flags::MESSAGE_ASYNC_DONE;
|
||||
pub use self::flags::MESSAGE_REQUEST_STATE;
|
||||
pub use self::flags::MESSAGE_STEP_START;
|
||||
pub use self::flags::MESSAGE_QOS;
|
||||
pub use self::flags::MESSAGE_PROGRESS;
|
||||
pub use self::flags::MESSAGE_TOC;
|
||||
pub use self::flags::MESSAGE_RESET_TIME;
|
||||
pub use self::flags::MESSAGE_STREAM_START;
|
||||
pub use self::flags::MESSAGE_NEED_CONTEXT;
|
||||
pub use self::flags::MESSAGE_HAVE_CONTEXT;
|
||||
pub use self::flags::MESSAGE_EXTENDED;
|
||||
pub use self::flags::MESSAGE_DEVICE_ADDED;
|
||||
pub use self::flags::MESSAGE_DEVICE_REMOVED;
|
||||
pub use self::flags::MESSAGE_PROPERTY_NOTIFY;
|
||||
pub use self::flags::MESSAGE_STREAM_COLLECTION;
|
||||
pub use self::flags::MESSAGE_STREAMS_SELECTED;
|
||||
pub use self::flags::MESSAGE_REDIRECT;
|
||||
pub use self::flags::MESSAGE_ANY;
|
||||
pub use self::flags::SeekFlags;
|
||||
pub use self::flags::SEEK_FLAG_NONE;
|
||||
pub use self::flags::SEEK_FLAG_FLUSH;
|
||||
|
|
|
@ -8,12 +8,12 @@
|
|||
|
||||
use ffi;
|
||||
use Object;
|
||||
use MessageType;
|
||||
use miniobject::*;
|
||||
use std::ffi::CStr;
|
||||
|
||||
use std::ptr;
|
||||
|
||||
use glib;
|
||||
use glib::translate::{from_glib, from_glib_none, from_glib_full, ToGlibPtr, ToGlib};
|
||||
use glib::translate::{from_glib, from_glib_none, from_glib_full, ToGlibPtr};
|
||||
|
||||
#[repr(C)]
|
||||
pub struct MessageImpl(ffi::GstMessage);
|
||||
|
@ -37,18 +37,6 @@ impl MessageImpl {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn get_message_type(&self) -> MessageType {
|
||||
unsafe {
|
||||
from_glib((*self.as_ptr()).type_)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_message_type_name(&self) -> &'static str {
|
||||
unsafe {
|
||||
CStr::from_ptr(ffi::gst_message_type_get_name(self.get_message_type().to_glib())).to_str().unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_seqnum(&self) -> u32 {
|
||||
unsafe {
|
||||
ffi::gst_message_get_seqnum(self.as_mut_ptr())
|
||||
|
@ -61,9 +49,269 @@ impl MessageImpl {
|
|||
}
|
||||
}
|
||||
|
||||
// TODO get_structure(), get_mut_structure()
|
||||
// TODO get_structure()
|
||||
|
||||
pub fn view(&self) -> MessageView {
|
||||
let type_ = unsafe { (*self.as_ptr()).type_ };
|
||||
|
||||
if type_ == ffi::GST_MESSAGE_EOS {
|
||||
MessageView::Eos(Eos(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_ERROR {
|
||||
MessageView::Error(Error(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_WARNING {
|
||||
MessageView::Warning(Warning(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_INFO {
|
||||
MessageView::Info(Info(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_TAG {
|
||||
MessageView::Tag(Tag(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_BUFFERING {
|
||||
MessageView::Buffering(Buffering(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STATE_CHANGED {
|
||||
MessageView::StateChanged(StateChanged(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STATE_DIRTY {
|
||||
MessageView::StateDirty(StateDirty(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STEP_DONE {
|
||||
MessageView::StepDone(StepDone(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_CLOCK_PROVIDE {
|
||||
MessageView::ClockProvide(ClockProvide(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_CLOCK_LOST {
|
||||
MessageView::ClockLost(ClockLost(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_NEW_CLOCK {
|
||||
MessageView::NewClock(NewClock(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STRUCTURE_CHANGE {
|
||||
MessageView::StructureChange(StructureChange(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STREAM_STATUS {
|
||||
MessageView::StreamStatus(StreamStatus(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_APPLICATION {
|
||||
MessageView::Application(Application(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_ELEMENT {
|
||||
MessageView::Element(Element(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_SEGMENT_START {
|
||||
MessageView::SegmentStart(SegmentStart(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_SEGMENT_DONE {
|
||||
MessageView::SegmentDone(SegmentDone(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_DURATION_CHANGED {
|
||||
MessageView::DurationChanged(DurationChanged(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_LATENCY {
|
||||
MessageView::Latency(Latency(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_ASYNC_START {
|
||||
MessageView::AsyncStart(AsyncStart(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_ASYNC_DONE {
|
||||
MessageView::AsyncDone(AsyncDone(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_REQUEST_STATE {
|
||||
MessageView::RequestState(RequestState(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STEP_START {
|
||||
MessageView::StepStart(StepStart(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_QOS {
|
||||
MessageView::Qos(Qos(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_PROGRESS {
|
||||
MessageView::Progress(Progress(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_TOC {
|
||||
MessageView::Toc(Toc(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_RESET_TIME {
|
||||
MessageView::ResetTime(ResetTime(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STREAM_START {
|
||||
MessageView::StreamStart(StreamStart(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_NEED_CONTEXT {
|
||||
MessageView::NeedContext(NeedContext(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_HAVE_CONTEXT {
|
||||
MessageView::HaveContext(HaveContext(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_DEVICE_ADDED {
|
||||
MessageView::DeviceAdded(DeviceAdded(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_DEVICE_REMOVED {
|
||||
MessageView::DeviceRemoved(DeviceRemoved(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_PROPERTY_NOTIFY {
|
||||
MessageView::PropertyNotify(PropertyNotify(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STREAM_COLLECTION {
|
||||
MessageView::StreamCollection(StreamCollection(self))
|
||||
} else if type_ == ffi::GST_MESSAGE_STREAMS_SELECTED {
|
||||
MessageView::StreamsSelected(StreamsSelected(self))
|
||||
} else {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub enum MessageView<'a> {
|
||||
Eos(Eos<'a>),
|
||||
Error(Error<'a>),
|
||||
Warning(Warning<'a>),
|
||||
Info(Info<'a>),
|
||||
Tag(Tag<'a>),
|
||||
Buffering(Buffering<'a>),
|
||||
StateChanged(StateChanged<'a>),
|
||||
StateDirty(StateDirty<'a>),
|
||||
StepDone(StepDone<'a>),
|
||||
ClockProvide(ClockProvide<'a>),
|
||||
ClockLost(ClockLost<'a>),
|
||||
NewClock(NewClock<'a>),
|
||||
StructureChange(StructureChange<'a>),
|
||||
StreamStatus(StreamStatus<'a>),
|
||||
Application(Application<'a>),
|
||||
Element(Element<'a>),
|
||||
SegmentStart(SegmentStart<'a>),
|
||||
SegmentDone(SegmentDone<'a>),
|
||||
DurationChanged(DurationChanged<'a>),
|
||||
Latency(Latency<'a>),
|
||||
AsyncStart(AsyncStart<'a>),
|
||||
AsyncDone(AsyncDone<'a>),
|
||||
RequestState(RequestState<'a>),
|
||||
StepStart(StepStart<'a>),
|
||||
Qos(Qos<'a>),
|
||||
Progress(Progress<'a>),
|
||||
Toc(Toc<'a>),
|
||||
ResetTime(ResetTime<'a>),
|
||||
StreamStart(StreamStart<'a>),
|
||||
NeedContext(NeedContext<'a>),
|
||||
HaveContext(HaveContext<'a>),
|
||||
DeviceAdded(DeviceAdded<'a>),
|
||||
DeviceRemoved(DeviceRemoved<'a>),
|
||||
PropertyNotify(PropertyNotify<'a>),
|
||||
StreamCollection(StreamCollection<'a>),
|
||||
StreamsSelected(StreamsSelected<'a>),
|
||||
Redirect(Redirect<'a>),
|
||||
__NonExhaustive,
|
||||
}
|
||||
|
||||
pub struct Eos<'a>(&'a MessageImpl);
|
||||
|
||||
pub struct Error<'a>(&'a MessageImpl);
|
||||
impl<'a> Error<'a> {
|
||||
pub fn get_error(&self) -> glib::Error {
|
||||
unsafe {
|
||||
let mut error = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_error(self.0.as_mut_ptr(), &mut error, ptr::null_mut());
|
||||
|
||||
from_glib_full(error)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_debug(&self) -> Option<String> {
|
||||
unsafe {
|
||||
let mut debug = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_error(self.0.as_mut_ptr(), ptr::null_mut(), &mut debug);
|
||||
|
||||
from_glib_full(debug)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO get_details()
|
||||
}
|
||||
|
||||
pub struct Warning<'a>(&'a MessageImpl);
|
||||
impl<'a> Warning<'a> {
|
||||
pub fn get_error(&self) -> glib::Error {
|
||||
unsafe {
|
||||
let mut error = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_warning(self.0.as_mut_ptr(), &mut error, ptr::null_mut());
|
||||
|
||||
from_glib_full(error)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_debug(&self) -> Option<String> {
|
||||
unsafe {
|
||||
let mut debug = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_warning(self.0.as_mut_ptr(), ptr::null_mut(), &mut debug);
|
||||
|
||||
from_glib_full(debug)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO get_details()
|
||||
}
|
||||
|
||||
pub struct Info<'a>(&'a MessageImpl);
|
||||
impl<'a> Info<'a> {
|
||||
pub fn get_error(&self) -> glib::Error {
|
||||
unsafe {
|
||||
let mut error = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_info(self.0.as_mut_ptr(), &mut error, ptr::null_mut());
|
||||
|
||||
from_glib_full(error)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_debug(&self) -> Option<String> {
|
||||
unsafe {
|
||||
let mut debug = ptr::null_mut();
|
||||
|
||||
ffi::gst_message_parse_info(self.0.as_mut_ptr(), ptr::null_mut(), &mut debug);
|
||||
|
||||
from_glib_full(debug)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO get_details()
|
||||
}
|
||||
|
||||
pub struct Tag<'a>(&'a MessageImpl);
|
||||
impl<'a> Tag<'a> {
|
||||
// TODO: get_tags()
|
||||
}
|
||||
|
||||
pub struct Buffering<'a>(&'a MessageImpl);
|
||||
impl<'a> Buffering<'a> {
|
||||
pub fn get_percent(&self) -> i32 {
|
||||
let mut p = 0;
|
||||
unsafe {
|
||||
ffi::gst_message_parse_buffering(self.0.as_mut_ptr(), &mut p);
|
||||
}
|
||||
|
||||
p
|
||||
}
|
||||
|
||||
pub fn get_buffering_stats(&self) -> (::BufferingMode, i32, i32, i64) {
|
||||
let mut mode = ffi::GstBufferingMode::Stream;
|
||||
let mut avg_in = 0;
|
||||
let mut avg_out = 0;
|
||||
let mut buffering_left = 0;
|
||||
|
||||
unsafe {
|
||||
ffi::gst_message_parse_buffering_stats(self.0.as_mut_ptr(), &mut mode, &mut avg_in, &mut avg_out, &mut buffering_left);
|
||||
}
|
||||
|
||||
(from_glib(mode), avg_in, avg_out, buffering_left)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct StateChanged<'a>(&'a MessageImpl);
|
||||
pub struct StateDirty<'a>(&'a MessageImpl);
|
||||
pub struct StepDone<'a>(&'a MessageImpl);
|
||||
pub struct ClockProvide<'a>(&'a MessageImpl);
|
||||
pub struct ClockLost<'a>(&'a MessageImpl);
|
||||
pub struct NewClock<'a>(&'a MessageImpl);
|
||||
pub struct StructureChange<'a>(&'a MessageImpl);
|
||||
pub struct StreamStatus<'a>(&'a MessageImpl);
|
||||
pub struct Application<'a>(&'a MessageImpl);
|
||||
pub struct Element<'a>(&'a MessageImpl);
|
||||
pub struct SegmentStart<'a>(&'a MessageImpl);
|
||||
pub struct SegmentDone<'a>(&'a MessageImpl);
|
||||
pub struct DurationChanged<'a>(&'a MessageImpl);
|
||||
pub struct Latency<'a>(&'a MessageImpl);
|
||||
pub struct AsyncStart<'a>(&'a MessageImpl);
|
||||
pub struct AsyncDone<'a>(&'a MessageImpl);
|
||||
pub struct RequestState<'a>(&'a MessageImpl);
|
||||
pub struct StepStart<'a>(&'a MessageImpl);
|
||||
pub struct Qos<'a>(&'a MessageImpl);
|
||||
pub struct Progress<'a>(&'a MessageImpl);
|
||||
pub struct Toc<'a>(&'a MessageImpl);
|
||||
pub struct ResetTime<'a>(&'a MessageImpl);
|
||||
pub struct StreamStart<'a>(&'a MessageImpl);
|
||||
pub struct NeedContext<'a>(&'a MessageImpl);
|
||||
pub struct HaveContext<'a>(&'a MessageImpl);
|
||||
pub struct DeviceAdded<'a>(&'a MessageImpl);
|
||||
pub struct DeviceRemoved<'a>(&'a MessageImpl);
|
||||
pub struct PropertyNotify<'a>(&'a MessageImpl);
|
||||
pub struct StreamCollection<'a>(&'a MessageImpl);
|
||||
pub struct StreamsSelected<'a>(&'a MessageImpl);
|
||||
pub struct Redirect<'a>(&'a MessageImpl);
|
||||
|
||||
impl glib::types::StaticType for GstRc<MessageImpl> {
|
||||
fn static_type() -> glib::types::Type {
|
||||
unsafe {
|
||||
|
|
Loading…
Reference in a new issue