mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-05-16 07:12:45 +00:00
Code Issues Projects Releases Wiki Activity

Implement further parts of the Message machinery

Browse source
This commit is contained in:
Sebastian Dröge 2017-07-03 17:52:10 +03:00
parent 602c3f257f
commit eeea572c96
6 changed files with 886 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Gir_Gst.toml
View file

@ -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 = [

8
gstreamer/src/auto/element.rs
View file

@ -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() }
//}

602
gstreamer/src/auto/enums.rs
View file

@ -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,

61
gstreamer/src/auto/flags.rs
View file

@ -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;

49
gstreamer/src/auto/mod.rs
View file

@ -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;

280
gstreamer/src/message.rs
View file

@ -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 {